old-cross-binutils/gdb/energize.c

1533 lines
34 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Energize (formerly known as Cadillac) interface routines.
Copyright 1991, 1992 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
#include "symtab.h"
#include "inferior.h"
#include "command.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
#include <sys/types.h>
#include <sys/time.h>
#include <sys/param.h>
#include "energize/connection.h"
#include "energize/genericreq.h"
#include "energize/debuggerreq.h"
#include "energize/debuggerconn.h"
#include "energize/ttyconn.h"
#include <varargs.h>
#include <sys/stat.h>
#ifdef USG
#include <sys/file.h>
#endif
#include <fcntl.h>
#include <sys/filio.h>
#include <setjmp.h>
#include <signal.h>
#include <sys/errno.h>
#include <termios.h>
#include <string.h>
/* Non-zero means that we're doing the energize interface. */
int energize = 0;
/* Connection block for debugger<=>kernel communications. */
static Connection *conn = 0;
/* fd for our socket to the kernel. */
static int kerfd;
/* The kernel's ID for this instance of the program. */
static int program_id;
static int instance_id;
/* The fd for the pty associated with the inferior. */
static int inferior_pty = -1;
static int inferior_tty = -1;
static int has_run = 0;
extern int pgrp_inferior;
extern char *source_path;
/* The name of the executable file */
static char *exec_file;
/* Tell energize_command_line_input() where to get its text from */
static int doing_breakcommands_message = 0;
/* Stash command text here */
static char *command_line_text = 0;
static int command_line_length = 0;
/* Flags returned by wait_for_events() */
#define KERNEL_EVENT 1
#define PTY_EVENT 2
/* This routine redirects the output of fputs_filtered to the kernel so that
the user can see what's going on in his debugger window. */
void
energize_fputs(ptr)
const char *ptr;
{
if (conn)
CVWriteTranscriptInfo (conn, instance_id, (char *)ptr);
else
fputs (ptr, stdout);
}
void
energize_query(query, args)
char *query;
va_list args;
{
char buf[100];
if (!energize)
return;
vsprintf(buf, query, args);
CVWriteQueryInfo(conn,
instance_id,
CQueryConfirm,
qno_unknown,
buf,
""); /* transcript */
}
void
energize_acknowledge_query(ack)
char *ack;
{
CVWriteQueryInfo(conn,
instance_id,
CQueryAcknowleged,
0,
ack,
""); /* transcript */
}
/* Copy all data from the pty to the kernel. */
static void
pty_to_kernel()
{
CTtyRequest *req;
char buf[1024];
int cc;
while (1)
{
cc = read(inferior_pty, buf, sizeof(buf));
if (cc == 0
|| (cc < 0
&& errno == EWOULDBLOCK))
break;
if (cc < 0)
{
close(inferior_pty);
inferior_pty = -1;
perror("pty read error");
break;
}
req = CWriteTtyRequest(conn, TextIORType);
CWriteVstringLen(conn, buf, cc);
CWriteLength(conn);
}
CWriteRequestBuffer(conn);
}
/* Copy data from the kernel to the pty. */
static void
kernel_to_pty(data, len)
char *data;
int len;
{
int cc;
cc = write(inferior_pty, data, len);
if (cc != len)
{
if (cc < 0)
{
close(inferior_pty);
inferior_pty = -1;
perror("pty write error");
return;
}
printf("Couldn't write all the data to the pty, wanted %d, got %d\n",
len, cc);
}
}
static char *
full_filename(symtab)
struct symtab *symtab;
{
int pathlen;
char *filename;
if (!symtab)
return NULL;
if (symtab->fullname)
return savestring(symtab->fullname, strlen(symtab->fullname));
if (symtab->dirname)
pathlen = strlen(symtab->dirname);
else
pathlen = 0;
if (symtab->filename)
pathlen += strlen(symtab->filename);
filename = xmalloc(pathlen+1);
if (symtab->dirname)
strcpy(filename, symtab->dirname);
else
*filename = '\000';
if (symtab->filename)
strcat(filename, symtab->filename);
return filename;
}
/* Tell the energize kernel how high the stack is so that frame numbers (which
are relative to the current stack height make sense.
Calculate the number of frames on the stack, and the number of subroutine
invocations that haven't changed since the last call to this routine. The
second number is calculated by comparing the PCs of the current stack frames
to the PCs of the previous set of stack frames. The screw here is that a
subroutine may call several different procedures, which means that the PC
in its frame changes, even though you are still in the same subroutine. We
resolve this by converting the frames PC into the PC at the start of the
function (for efficiency, this is done only if the simple comparison test
fails). */
struct pclist
{
CORE_ADDR pc;
struct pclist *next;
};
/* Non-zero means that Energize kernel already knows how high the stack is. */
static int stack_info_valid = 0;
static void
send_stack_info()
{
struct pclist *pclist = 0, *pli, *opli;
static struct pclist *old_pclist;
FRAME frame;
int height, similar;
if (stack_info_valid)
return;
height = 0;
similar = 0;
/* First, calculate the stack height, and build the new pclist */
for (frame = get_current_frame();
frame != 0;
frame = get_prev_frame(frame))
{
(height)++;
pli = (struct pclist *)xmalloc(sizeof(struct pclist));
pli->pc = frame->pc;
pli->next = pclist;
pclist = pli;
}
/* Now, figure out how much of the stack hasn't changed */
for (pli = pclist, opli = old_pclist;
pli != 0 && opli != 0;
pli = pli->next, opli = opli->next, (similar)++)
{
if ((pli->pc != opli->pc)
&& (get_pc_function_start(pli->pc)
!= get_pc_function_start(opli->pc)))
break;
}
/* Free up all elements of the old pclist */
opli = old_pclist;
while (opli)
{
pli = opli->next;
free (opli);
opli = pli;
}
old_pclist = pclist; /* Install the new pclist */
CVWriteStackSizeInfo(conn,
instance_id,
height, /* Frame depth */
CInnerFrameIs0,
similar, /* Frame diff */
"" /* Transcript */
);
stack_info_valid = 1;
}
/* Tell the kernel where we are in the program, and what the stack looks like.
*/
static void
send_status()
{
static int linecount = 48;
struct symtab_and_line sal;
struct symbol *symbol;
char *funcname, *filename;
static int sent_prog_inst = 0;
if (!has_run)
return;
if (inferior_pid == 0) /* target has died */
{
CVWriteProgramTerminatedInfo(conn,
instance_id,
""
);
return;
}
sal = find_pc_line(stop_pc, 0);
symbol = find_pc_function(stop_pc);
funcname = symbol ? symbol->name : "";
filename = full_filename(sal.symtab);
if (!sent_prog_inst)
{
sent_prog_inst = 1;
CVWriteProgramInstanceInfo(conn,
program_id,
instance_id,
"", /* hostname */
"", /* arglist */
""
);
}
send_stack_info();
CVWriteStackFrameInfo(conn,
instance_id,
sal.line,
CFileLinePos,
0, /* XXX - frame # */
funcname,
filename,
"" /* XXX ? transcript */
);
CVWriteProgramStoppedInfo(conn,
instance_id,
0, /* XXX - breakpoint # or signal # */
CDebuggerCommand,
funcname,
"" /* XXX ? transcript */
);
if (filename)
free(filename);
}
/* Call this to output annotated function names. Names will be demangled if
necessary. arg_mode contains flags that are passed on to cplus_demangle. */
void
energize_annotate_function(funcname, arg_mode, level)
char *funcname;
int arg_mode;
int level;
{
extern int demangle;
char *demangled_name = NULL;
if (funcname == NULL)
return;
if (demangle)
{
demangled_name = cplus_demangle(funcname, arg_mode);
if (demangled_name)
funcname = demangled_name;
}
send_stack_info();
if (level < 0) level = 0;
CVWriteBackTraceEntryInfo(conn,
instance_id,
level, /* frameNo */
funcname);
if (demangled_name)
free(demangled_name);
}
/* Call this just prior to printing out the name & value of a variable. This
tells the kernel where to annotate the output. */
/* The args are:
expression - A text handle on what GDB can use to reference this value.
This can be a symbol name, or a convenience var, etc...
symbol - Used to determine the scope of the data. May be NULL.
type - Determines if we have a pointer ref, and the print name of the type.
Used in ShowValue message.
valaddr - The address in target memory of the data.
field - The field name of the struct or union element being referenced.
*/
static char cum_expr[200]; /* Cumulative expression */
static char *expr_stack[100] = {cum_expr}; /* Pointers to end of expressions */
static char **last_expr = expr_stack; /* Current expr stack pointer */
void
energize_start_variable_annotation(expression, symbol, type, valaddr, field)
char *expression;
struct symbol *symbol;
struct type *type;
CORE_ADDR valaddr;
char *field;
{
int ref_type;
int stor_cl;
enum type_code type_code;
enum address_class sym_class;
char *type_cast;
if (!energize)
return;
send_stack_info();
strcpy(*last_expr++, expression);
*last_expr = *(last_expr-1) + strlen(expression);
switch (TYPE_CODE(type))
{
case TYPE_CODE_ARRAY:
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
case TYPE_CODE_ENUM:
case TYPE_CODE_INT:
case TYPE_CODE_FLT:
ref_type = CValueValueRef;
break;
case TYPE_CODE_PTR:
ref_type = CValuePointerRef;
break;
default:
ref_type = CValueUndefRef;
break;
}
/* Make sure that pointer points at something we understand */
if (ref_type == CValuePointerRef)
switch (TYPE_CODE(TYPE_TARGET_TYPE(type)))
{
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
case TYPE_CODE_ENUM:
case TYPE_CODE_INT:
case TYPE_CODE_FLT:
break;
default:
ref_type = CValueUndefRef;
break;
}
if (symbol)
{
sym_class = SYMBOL_CLASS(symbol);
switch (sym_class)
{
case LOC_CONST:
case LOC_CONST_BYTES:
stor_cl = CValueStorStaticConst;
break;
case LOC_STATIC:
stor_cl = CValueStorStaticVar;
break;
case LOC_REGISTER:
case LOC_REGPARM:
stor_cl = CValueStorRegister;
break;
case LOC_ARG:
case LOC_REF_ARG:
case LOC_LOCAL:
case LOC_LOCAL_ARG:
stor_cl = CValueStorLocalVar;
break;
default:
stor_cl = CValueStorUndef;
break;
}
}
else
stor_cl = CValueStorUndef;
type_cast = TYPE_NAME(type);
CVWriteValueBeginInfo(conn,
instance_id,
valaddr,
ref_type,
stor_cl,
0, /* XXX - frameno */
cum_expr,
field,
type_cast,
""); /* transcript */
}
void
energize_end_variable_annotation()
{
if (!energize)
return;
last_expr--; /* Pop the expr stack */
**last_expr = '\000'; /* Cut off the last part of the expr */
CVWriteValueEndInfo(conn,
instance_id,
""); /* transcript */
}
/* Tell the kernel that the target is now running. */
static void
go_busy()
{
CVWriteProgramBusyInfo(conn,
instance_id,
""); /* XXX ? transcript */
CWriteRequestBuffer(conn); /* Must take place synchronusly! */
stack_info_valid = 0;
}
void
energize_symbol_file(objfile)
struct objfile *objfile;
{
if (!energize)
return;
CVWriteSymbolTableInfo(conn,
objfile->name,
""); /* Transcript */
}
/* execute_command_1(echo, queue, cmd, args) - echo - non-zero means echo the
command. queue - non-zero means don't execute it now, just save it away for
later. cmd - string containing printf control sequences. args - list of
arguments needed by those control sequences.
*/
/* Linked list of queued up commands */
static struct command_line *queued_commands = 0;
static struct command_line *last_queued_command = 0;
/* Call this routine to save a command for later. The command string is
copied into freshly malloc'ed memory. */
static void
queue_command(cmd)
char *cmd;
{
char *buf;
struct command_line *cl;
unsigned long s;
s = (strlen(cmd) + 1) + 7 & ~(unsigned long)7;
buf = (char *)xmalloc(s + sizeof(struct command_line));
cl = (struct command_line *)(buf + s);
cl->next = 0;
cl->line = buf;
strncpy(cl->line, cmd, s);
if (queued_commands)
last_queued_command->next = cl;
else
queued_commands = cl;
last_queued_command = cl;
}
/* Call this procedure to take a command off of the command queue. It returns
a pointer to a buf which the caller is responsible for freeing. NULL is
returned if there are no commands queued. */
static char *
dequeue_command()
{
struct command_line *cl;
char *cmd;
cl = queued_commands;
if (!cl)
return NULL;
queued_commands = cl->next;
return cl->line;
}
static void
execute_command_1(va_alist)
va_dcl
{
char buf[100]; /* XXX - make buf dynamic! */
int echo;
int queue;
char *cmd;
va_list args;
va_start(args);
echo = va_arg(args, int);
queue = va_arg(args, int);
cmd = va_arg(args, char *);
vsprintf(buf, cmd, args);
if (queue)
queue_command(buf);
else
{
if (echo)
printf_filtered("%s\n", buf);
execute_command(buf, 1);
}
va_end(args);
}
#ifdef KERNEL_RECORD
FILE *kerout;
static int
kernel_record(fd, ptr, num)
int fd, num;
char *ptr;
{
fwrite(ptr, num, 1, kerout);
fflush(kerout);
return write(fd, ptr, num);
}
#endif
void
energize_condition_breakpoint(b)
struct breakpoint *b;
{
if (energize)
CVWriteBreakConditionInfo(conn,
instance_id,
b->number,
b->cond_string ? b->cond_string : "",
"" /* transcript */
);
}
void
energize_commands_breakpoint(b)
struct breakpoint *b;
{
struct command_line *l;
if (!energize)
return;
CVWriteBreakCommandBegInfo(conn,
instance_id,
b->number,
""); /* transcript */
for (l = b->commands; l; l = l->next)
CVWriteBreakCommandEntryInfo(conn,
instance_id,
l->line,
""); /* transcript */
CVWriteBreakCommandEndInfo(conn,
instance_id,
""); /* transcript */
}
static void
breakpoint_notify(b, action)
struct breakpoint *b;
int action;
{
struct symbol *sym;
char *funcname = "";
char *filename;
char *included_in_filename = "";
if (!energize)
return;
if (b->type != bp_breakpoint)
return;
filename = full_filename(b->symtab);
sym = find_pc_function(b->address);
if (sym)
funcname = SYMBOL_NAME(sym);
CVWriteBreakpointInfo (conn,
instance_id,
b->number,
b->line_number,
CFileLinePos,
CBreakOnInstrAccess,
action,
b->ignore_count,
funcname,
filename ? filename : "",
"", /* included_in_filename */
"" /* transcript */
);
if (b->commands)
energize_commands_breakpoint(b);
energize_condition_breakpoint(b);
if (filename)
free(filename);
}
void
energize_create_breakpoint(b)
struct breakpoint *b;
{
breakpoint_notify(b, CEnableBreakpoint);
}
void
energize_delete_breakpoint(b)
struct breakpoint *b;
{
breakpoint_notify(b, CDeleteBreakpoint);
}
void
energize_enable_breakpoint(b)
struct breakpoint *b;
{
breakpoint_notify(b, CEnableBreakpoint);
}
void
energize_disable_breakpoint(b)
struct breakpoint *b;
{
breakpoint_notify(b, CDisableBreakpoint);
}
void
energize_ignore_breakpoint(b)
struct breakpoint *b;
{
breakpoint_notify(b, CBreakAttrUnchanged);
}
/* Open up a pty and its associated tty. Return the fd of the tty. */
static void
getpty()
{
int n, ptyfd, ttyfd;
static char dev[30];
struct stat statbuf;
struct termios termios;
#define HIGHPTY (('z' - 'p') * 16 - 1)
for (n = 0; n <= HIGHPTY; n++)
{
sprintf(dev, "/dev/pty%c%x", n/16 + 'p', n%16);
if (stat(dev, &statbuf))
break;
ptyfd = open(dev, O_RDWR);
if (ptyfd < 0)
continue;
sprintf(dev, "/dev/tty%c%x", n/16 + 'p', n%16);
ttyfd = open(dev, O_RDWR);
if (ttyfd < 0) {close(ptyfd); continue;}
/* Setup pty for non-blocking I/O. Also make it give us a SIGIO when
there's data available. */
n = fcntl(ptyfd, F_GETFL, 0);
fcntl(ptyfd, F_SETFL, n|FNDELAY|FASYNC);
fcntl(ptyfd, F_SETOWN, getpid());
tcgetattr(ttyfd, &termios);
termios.c_oflag &= ~OPOST; /* No post-processing */
tcsetattr(ttyfd, TCSANOW, &termios);
inferior_pty = ptyfd;
inferior_tty = ttyfd;
return;
}
error ("getpty: can't get a pty\n");
}
/* Examine a protocol packet from the driver. */
static void
kernel_dispatch(queue)
int queue; /* Non-zero means we should just queue up
commands. */
{
register CHeader *head;
head = (CHeader *)CPeekNextRequest (conn);
if (head == NULL)
{
fprintf (stderr, "EOF on kernel read!\n");
exit (1);
}
if (head->reqType < LastTtyRequestRType)
{
CTtyRequest* req = CReadTtyRequest (conn);
switch (req->head.reqType)
{
case AcceptConnectionRType:
/* Tell the rest of the world that energize is now set up */
CSkipRequest (conn);
break;
case RefuseConnectionRType:
fprintf (stderr, "Debugger connection refused\n");
exit (1);
case KillProgramRType:
exit (0);
case TextIORType:
{
char *p;
ReqLen len;
p = CGetVstring(conn, &len);
kernel_to_pty(p, len);
}
break;
default:
fprintf(stderr, "Unknown Tty request type = %d\n",
req->head.reqType);
break;
}
}
else
{
CVDebuggerRequest *req = CVReadDebuggerRequest (conn);
if (!req)
{
fprintf (stderr, "CVReadDebuggerRequest returned NULL, type = %d\n",
head->reqType);
exit(1);
}
switch (req->head.request->reqType)
{
case OpenProgramInstanceRType:
{
char *arglist, buf[100]; /* XXX - Make buf dynamic! */
int arglen;
/* XXX - should notice when program_id changes */
arglist = req->openProgramInstance.progArglist.text;
arglen = req->openProgramInstance.progArglist.byteLen;
execute_command_1(1, queue, "break main");
execute_command_1(1, queue, "enable delete $bpnum");
if (arglist)
{
execute_command_1(1, queue, "set args %.*s", arglen, arglist);
}
execute_command_1(1, queue, "run");
}
break;
case SearchPathRType:
directory_command(req->searchPath.searchPath.text, 0);
break;
case QuitDebuggerRType:
execute_command_1(1, queue, "quit");
break;
case RunRType:
if (req->run.request->useArglist == CNewArglist)
{
execute_command_1(1, queue, "set args %.*s",
req->run.progArglist.byteLen,
req->run.progArglist.text);
}
execute_command_1(1, queue, "run");
break;
case ContinueRType:
execute_command_1(1, queue, "continue");
break;
case StepRType:
execute_command_1(1, queue, "step %d", req->step.request->stepCount);
break;
case NextRType:
execute_command_1(1, queue, "next %d", req->next.request->nextCount);
break;
case ChangeStackFrameRType:
switch (req->changeStackFrame.request->frameMovement)
{
case CToCurrentStackFrame:
execute_command_1(1, queue, "frame %d",
req->changeStackFrame.request->frameNo);
break;
case CToInnerStackFrame:
execute_command_1(1, queue, "down %d",
req->changeStackFrame.request->frameNo);
break;
case CToOuterStackFrame:
execute_command_1(1, queue, "up %d",
req->changeStackFrame.request->frameNo);
break;
case CToAbsoluteStackFrame:
execute_command_1(1, queue, "frame %d",
req->changeStackFrame.request->frameNo);
break;
}
break;
case BackTraceRType:
/* XXX - deal with limit??? */
execute_command_1(1, queue, "backtrace");
break;
case FinishRType:
execute_command_1(1, queue, "finish");
break;
case TerminateProgramRType:
execute_command_1(1, queue, "kill");
break;
case NewBreakpointRType:
{
char *tail;
int skipped;
tail = strrchr(req->newBreakpoint.fileName.text, '/');
if (!tail)
tail = req->newBreakpoint.fileName.text;
else
tail++;
skipped = tail - req->newBreakpoint.fileName.text;
execute_command_1(1, queue, "break %.*s:%d",
req->newBreakpoint.fileName.byteLen - skipped,
tail,
req->newBreakpoint.request->fileLinePos);
}
break;
case StopRType:
killpg(pgrp_inferior, SIGINT);
break;
case UserInputRType:
{
char *text;
long len;
/* XXX - should really break command up into seperate lines
and spoon-feed it to execute_command */
text = req->userInput.userInput.text;
len = req->userInput.userInput.byteLen;
if (text[len-1] == '\n') text[len-1] = '\000';
while (*text == ' ' || *text == '\t') text++;
if (strcmp(text, "]*[") == 0) /* XXX - What does this mean??? */
break;
if (*text != '\000')
execute_command_1(0, queue, "%s", text);
else
print_prompt(); /* User just typed a blank line */
}
break;
case QueryResponseRType:
{
char *resp;
if (req->queryResponse.request->response)
resp = "y";
else
resp = "n";
execute_command_1(1, 1, resp);
printf_filtered("%s\n", resp);
}
break;
case ChangeBreakpointRType:
switch (req->changeBreakpoint.request->breakpointAttr)
{
case CBreakAttrUnchanged:
execute_command_1(1, queue, "ignore %d %d",
req->changeBreakpoint.request->breakpointId,
req->changeBreakpoint.request->ignoreCount);
break;
case CEnableBreakpoint:
execute_command_1(1, queue, "enable %d",
req->changeBreakpoint.request->breakpointId);
break;
case CDisableBreakpoint:
execute_command_1(1, queue, "disable %d",
req->changeBreakpoint.request->breakpointId);
break;
case CDeleteBreakpoint:
execute_command_1(1, queue, "delete %d",
req->changeBreakpoint.request->breakpointId);
break;
case CEnableDisableBreakpoint:
execute_command_1(1, queue, "enable once %d",
req->changeBreakpoint.request->breakpointId);
break;
case CEnableDeleteBreakpoint:
execute_command_1(1, queue, "enable delete %d",
req->changeBreakpoint.request->breakpointId);
break;
default:
printf_filtered("ChangeBreakpointRType: unknown breakpointAttr\n");
printf_filtered(" breakpointAttr = %d\n",
req->changeBreakpoint.request->breakpointAttr);
printf_filtered(" breakpointId = %d\n",
req->changeBreakpoint.request->breakpointId);
printf_filtered(" breakpointType = %d\n",
req->changeBreakpoint.request->breakpointType);
printf_filtered(" ignoreCount = %d\n",
req->changeBreakpoint.request->ignoreCount);
break;
}
break;
case BreakConditionRType:
execute_command_1(1, queue, "condition %d %.*s",
req->breakCondition.request->breakpointId,
req->breakCondition.condition.byteLen,
req->breakCondition.condition.text);
break;
case BreakCommandsRType:
/* Put pointers to where energize_command_line_input() can find
them. */
doing_breakcommands_message = 1;
command_line_length = req->breakCommands.commands.byteLen;
command_line_text = req->breakCommands.commands.text;
execute_command_1(1, queue, "commands %d",
req->breakCommands.request->breakpointId);
command_line_text = (char *)NULL;
command_line_length = 0;
doing_breakcommands_message = 0;
break;
case ShowValueRType:
{
char expr[100], *p = expr;
expr[0] = 0;
if (req->showValue.request->ref_type == CValuePointerRef)
strcat(expr, "* ");
if (req->showValue.type_cast.byteLen)
{
strcat(expr, "(");
strncat(expr, req->showValue.type_cast.text,
req->showValue.type_cast.byteLen);
strcat(expr, ") ");
}
if (req->showValue.field.byteLen)
strcat(expr, "(");
strncat(expr, req->showValue.expression.text,
req->showValue.expression.byteLen);
if (req->showValue.field.byteLen)
{
strcat(expr, ")");
strncat(expr, req->showValue.field.text,
req->showValue.field.byteLen);
}
execute_command_1(1, queue, "print %s", expr);
}
break;
case SetValueRType:
{
char expr[100], *p = expr;
expr[0] = 0;
if (req->setValue.request->ref_type == CValuePointerRef)
strcat(expr, "* ");
#if 0
if (req->setValue.type_cast.byteLen)
{
strcat(expr, "(");
strncat(expr, req->setValue.type_cast.text,
req->setValue.type_cast.byteLen);
strcat(expr, ") ");
}
#endif
if (req->setValue.field.byteLen)
strcat(expr, "(");
strncat(expr, req->setValue.expression.text,
req->setValue.expression.byteLen);
if (req->setValue.field.byteLen)
{
strcat(expr, ")");
strncat(expr, req->setValue.field.text,
req->setValue.field.byteLen);
}
execute_command_1(1, queue, "print %s = (%s) %s", expr,
req->setValue.type_cast.text,
req->setValue.value.text);
}
break;
case DynamicLoadRType:
{
char *filename;
filename = req->dynamicLoad.filenames.byteLen ?
req->dynamicLoad.filenames.text : exec_file;
switch (req->dynamicLoad.request->action)
{
case CDynamicLoadUpdateSymtab:
execute_command_1(1, queue, "exec-file %s", filename);
execute_command_1(1, queue, "symbol-file %s", filename);
break;
default:
printf_filtered("DynamicLoadRType: unknown action=%d, filename=%s\n",
req->dynamicLoad.request->action,
req->dynamicLoad.filenames.text);
break;
}
}
break;
default:
fprintf(stderr, "Unknown Debugger request type = %d\n",
req->head.request->reqType);
break;
}
free (req); /* Should probably call CVFreeDebuggerRequest() here, but
can't do so if interrupt level has mucked with req->
request. CVFreeDebuggerRequest() only ends up calling
free() anyway! */
}
}
/* Return a bitmask indicating if the kernel or the pty did something
interesting. Set poll to non-zero if you don't want to wait. */
static int
wait_for_events(poll)
int poll;
{
fd_set readfds;
int numfds;
int eventmask = 0;
static struct timeval tv = {0};
/* Output all pending requests. */
CWriteRequestBuffer(conn);
FD_ZERO(&readfds);
/* Wait till there's some activity from the kernel or the pty. */
do
{
FD_SET(kerfd, &readfds);
if (inferior_pty > 0)
FD_SET(inferior_pty, &readfds);
if (poll)
numfds = select(sizeof(readfds)*8, &readfds, 0, 0, &tv);
else
numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0);
}
while (numfds <= 0 && !poll);
if (FD_ISSET(inferior_pty, &readfds))
eventmask |= PTY_EVENT;
if (FD_ISSET(kerfd, &readfds))
eventmask |= KERNEL_EVENT;
return eventmask;
}
/* This is called from read_command_lines() to provide the text for breakpoint
commands, which is supplied in a BreakCommands message. Each call to this
routine supplies a single line of text, with the newline removed. */
/* This routine may be invoked in two different contexts. In the first, it
is being called as a result of the BreakCommands message. In this case,
all of the command text is immediately available. In the second case, it is
called as a result of the user typing the 'command' command. The command
text then needs to be glommed out of UserInput messages (and possibly other
messages as well). The most 'straighforward' way of doing this is to
basically simulate the main loop, but just accumulate the command text
instead of sending it to execute_command(). */
char *
energize_command_line_input(prompt, repeat)
char *prompt;
int repeat;
{
char *p;
if (!energize)
return command_line_input(prompt, repeat);
if (doing_breakcommands_message)
{
if (command_line_length <= 0)
return (char *)NULL;
p = command_line_text;
while (command_line_length-- > 0)
{
if (*command_line_text == '\n')
{
*command_line_text = '\000';
command_line_text++;
break;
}
command_line_text++;
}
printf_filtered("%s\n", p);
return p;
}
else
{
/* We come here when the user has typed the 'command' or 'define' command
to the GDB window. We are basically deep inside of the 'command'
command processing routine right now, and will be called to get a new
line of input. We expect that kernel_dispatch will queue up only one
command at a time. */
int eventmask;
static char buf[100];
eventmask = wait_for_events(0);
if (eventmask & PTY_EVENT)
pty_to_kernel();
if (eventmask & KERNEL_EVENT)
kernel_dispatch(1); /* Queue up commands */
/* Note that command has been echoed by the time we get here */
p = dequeue_command();
if (p)
{
strncpy(buf, p, sizeof(buf));
free(p);
return buf;
}
else
return NULL;
}
}
/* Establish contact with the kernel. */
void
energize_initialize(energize_id, execarg)
char *energize_id;
char *execarg;
{
CTtyRequest *req;
char *ctmp;
extern long strtol(char *str, char **ptr, int base);
char pathname[MAXPATHLEN];
int n;
if (!energize_id)
return;
if (!execarg) execarg = "";
exec_file = strdup(execarg); /* Save for later */
printf("\ngdb-debugger pid=%d\n", getpid()); /* XXX - debugging only */
/* First establish the connection with the kernel. */
kerfd = COpenClientSocket(NULL);
if (kerfd < 0) {
printf("COpenClientSocket() failed\n");
exit(1);
}
/* Setup for I/O interrupts when appropriate. */
n = fcntl(kerfd, F_GETFL, 0);
fcntl(kerfd, F_SETFL, n|FASYNC);
fcntl(kerfd, F_SETOWN, getpid());
/* Setup connection buffering. */
CSetSocketBufferSize (kerfd, 12000);
/* Generate a new connection control block. */
conn = NewConnection (0, kerfd, kerfd);
if (!conn) {
printf("NewConnection() failed\n");
exit(1);
}
#ifdef KERNEL_RECORD
kerout = fopen("kernel.output", "+w");
CReadWriteHooks(conn, conn->previewMethod, conn->readMethod, kernel_record);
#endif
/* Tell the kernel that we are the "debugger". */
req = CWriteTtyRequest (conn, QueryConnectionRType);
req->generic.queryconnection.major = 0;
req->generic.queryconnection.minor = 0;
req->generic.queryconnection.cadillacId1=strtol(energize_id, &ctmp, 16);
req->generic.queryconnection.cadillacId2 = strtol(++ctmp, NULL, 16);
req->generic.queryconnection.nProtocols = 1;
CWriteProtocol (conn, 0, 0, "debugger");
CWriteLength (conn);
/* Tell the kernel that we are actually running. */
/* KROCK ALERT!!! The kernel doesn't really care about the arguments to
the program at all! It only cares that argument 7 be the name of the
target program. So, we just fill in the rest of the slots with
padding. I hope the kernel never cares about this! */
req = CWriteTtyRequest (conn, RunningProgramRType);
req->runningprogram.argc = 8;
getwd (pathname);
CWriteVstring0 (conn, pathname);
CWriteVstring0 (conn, "0");
CWriteVstring0 (conn, "1");
CWriteVstring0 (conn, "2");
CWriteVstring0 (conn, "3");
CWriteVstring0 (conn, "4");
CWriteVstring0 (conn, "5");
CWriteVstring0 (conn, "6");
CWriteVstring0 (conn, execarg);
CWriteLength (conn);
/* Tell the kernel our PID and all that */
program_id = 1;
CVWriteDebugProgramInfo(conn,
getpid(),
program_id,
execarg,
"");
/* Tell the rest of the world that Energize is now set up. */
energize = 1;
setsid(); /* Drop controlling tty, become pgrp master */
getpty(); /* Setup the pty */
dup2(inferior_tty, 0); /* Attach all GDB I/O to the pty */
dup2(inferior_tty, 1);
dup2(inferior_tty, 2);
}
/* This is called from execute_command, and provides a wrapper around
various command routines in a place where both protocol messages and
user input both flow through.
*/
void
energize_call_command(cmdblk, arg, from_tty)
struct cmd_list_element *cmdblk;
char *arg;
int from_tty;
{
if (!energize)
{
(*cmdblk->function.cfunc) (arg, from_tty);
return;
}
if (cmdblk->class == class_run)
{
go_busy();
has_run = 1;
(*cmdblk->function.cfunc)(arg, from_tty);
send_status();
}
else
(*cmdblk->function.cfunc)(arg, from_tty);
print_prompt();
}
void
energize_new_process()
{
instance_id = inferior_pid;
}
static void
iosig(signo)
int signo;
{
while (1)
{
int eventmask;
eventmask = wait_for_events(1);
if (eventmask == 0)
return;
if (eventmask & PTY_EVENT)
pty_to_kernel();
if (eventmask & KERNEL_EVENT)
kernel_dispatch(1);
}
}
int
energize_wait(status)
int *status;
{
int pid;
if (!energize)
return wait(status);
signal(SIGIO, iosig);
pid = wait(status);
signal(SIGIO, SIG_DFL);
return pid;
}
static void
null_routine(arg)
int arg;
{
}
/* All requests from the Energize kernel eventually end up here. */
void
energize_main_loop()
{
CTtyRequest *req;
struct cleanup *old_chain;
doing_breakcommands_message = 0;
/* We will come thru here any time there is an error, so send status if
necessary. */
send_status();
print_prompt();
/* The actual event loop! */
while (1)
{
int eventmask;
char *cmd;
old_chain = make_cleanup(null_routine, 0);
/* First, empty out the command queue, then check for new requests. */
while (cmd = dequeue_command())
{
execute_command_1(1, 0, cmd);
free(cmd);
}
eventmask = wait_for_events(0);
if (eventmask & PTY_EVENT)
pty_to_kernel();
if (eventmask & KERNEL_EVENT)
kernel_dispatch(0);
bpstat_do_actions(&stop_bpstat);
do_cleanups(old_chain);
}
}