-/* TK interface routines.
- Copyright 1994 Free Software Foundation, Inc.
+/* Tcl/Tk interface routines.
+ Copyright 1994, 1995 Free Software Foundation, Inc.
+
+ Written by Stu Grossman <grossman@cygnus.com> of Cygnus Support.
This file is part of GDB.
#include "target.h"
#include <tcl.h>
#include <tk.h>
+#ifdef ANSI_PROTOTYPES
+#include <stdarg.h>
+#else
#include <varargs.h>
+#endif
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
-
-/* Non-zero means that we're doing the gdbtk interface. */
-int gdbtk = 0;
-
-/* Non-zero means we are reloading breakpoints, etc from the
- Gdbtk kernel, and we should suppress various messages */
-static int gdbtk_reloading = 0;
+#include <setjmp.h>
+#include "top.h"
+#include <sys/ioctl.h>
+#include <string.h>
+#include "dis-asm.h"
+#include <stdio.h>
+#include "gdbcmd.h"
+
+#ifndef FIOASYNC
+#include <sys/stropts.h>
+#endif
/* Handle for TCL interpreter */
static Tcl_Interp *interp = NULL;
static int x_fd; /* X network socket */
-static void
-null_routine(arg)
- int arg;
+/* This variable determines where memory used for disassembly is read from.
+
+ If > 0, then disassembly comes from the exec file rather than the target
+ (which might be at the other end of a slow serial link). If == 0 then
+ disassembly comes from target. If < 0 disassembly is automatically switched
+ to the target if it's an inferior process, otherwise the exec file is
+ used.
+ */
+
+static int disassemble_from_exec = -1;
+
+/* Supply malloc calls for tcl/tk. */
+
+char *
+Tcl_Malloc (size)
+ unsigned int size;
{
+ return xmalloc (size);
}
-\f
-/* This routine redirects the output of fputs_unfiltered so that
- the user can see what's going on in his debugger window. */
+char *
+Tcl_Realloc (ptr, size)
+ char *ptr;
+ unsigned int size;
+{
+ return xrealloc (ptr, size);
+}
-static char holdbuf[200];
-static char *holdbufp = holdbuf;
-static int holdfree = sizeof (holdbuf);
+void
+Tcl_Free(ptr)
+ char *ptr;
+{
+ free (ptr);
+}
static void
-flush_holdbuf ()
+null_routine(arg)
+ int arg;
{
- if (holdbufp == holdbuf)
- return;
-
- Tcl_VarEval (interp, "gdbtk_tcl_fputs ", "{", holdbuf, "}", NULL);
- holdbufp = holdbuf;
- holdfree = sizeof (holdbuf);
}
+/* The following routines deal with stdout/stderr data, which is created by
+ {f}printf_{un}filtered and friends. gdbtk_fputs and gdbtk_flush are the
+ lowest level of these routines and capture all output from the rest of GDB.
+ Normally they present their data to tcl via callbacks to the following tcl
+ routines: gdbtk_tcl_fputs, gdbtk_tcl_fputs_error, and gdbtk_flush. These
+ in turn call tk routines to update the display.
+
+ Under some circumstances, you may want to collect the output so that it can
+ be returned as the value of a tcl procedure. This can be done by
+ surrounding the output routines with calls to start_saving_output and
+ finish_saving_output. The saved data can then be retrieved with
+ get_saved_output (but this must be done before the call to
+ finish_saving_output). */
+
+/* Dynamic string header for stdout. */
+
+static Tcl_DString *result_ptr;
+\f
static void
gdbtk_flush (stream)
FILE *stream;
{
- flush_holdbuf ();
+#if 0
+ /* Force immediate screen update */
Tcl_VarEval (interp, "gdbtk_tcl_flush", NULL);
+#endif
}
static void
-gdbtk_fputs (ptr)
+gdbtk_fputs (ptr, stream)
const char *ptr;
+ FILE *stream;
{
- int len;
+ if (result_ptr)
+ Tcl_DStringAppend (result_ptr, (char *)ptr, -1);
+ else
+ {
+ Tcl_DString str;
- len = strlen (ptr) + 1;
+ Tcl_DStringInit (&str);
- if (len > holdfree)
- {
- flush_holdbuf ();
+ Tcl_DStringAppend (&str, "gdbtk_tcl_fputs", -1);
+ Tcl_DStringAppendElement (&str, (char *)ptr);
- if (len > sizeof (holdbuf))
- {
- Tcl_VarEval (interp, "gdbtk_tcl_fputs ", "{", ptr, "}", NULL);
- return;
- }
+ Tcl_Eval (interp, Tcl_DStringValue (&str));
+ Tcl_DStringFree (&str);
}
-
- strncpy (holdbufp, ptr, len);
- holdbufp += len - 1;
- holdfree -= len - 1;
}
static int
-gdbtk_query (args)
+gdbtk_query (query, args)
+ char *query;
va_list args;
{
- char *query;
char buf[200];
long val;
- query = va_arg (args, char *);
-
- vsprintf(buf, query, args);
+ vsprintf (buf, query, args);
Tcl_VarEval (interp, "gdbtk_tcl_query ", "{", buf, "}", NULL);
val = atol (interp->result);
return val;
}
\f
-#if 0
-static char *
-full_filename(symtab)
- struct symtab *symtab;
+static void
+#ifdef ANSI_PROTOTYPES
+dsprintf_append_element (Tcl_DString *dsp, char *format, ...)
+#else
+dsprintf_append_element (va_alist)
+ va_dcl
+#endif
{
- int pathlen;
- char *filename;
+ va_list args;
+ char buf[1024];
+
+#ifdef ANSI_PROTOTYPES
+ va_start (args, format);
+#else
+ Tcl_DString *dsp;
+ char *format;
+
+ va_start (args);
+ dsp = va_arg (args, Tcl_DString *);
+ format = va_arg (args, char *);
+#endif
- if (!symtab)
- return NULL;
+ vsprintf (buf, format, args);
- if (symtab->fullname)
- return savestring(symtab->fullname, strlen(symtab->fullname));
+ Tcl_DStringAppendElement (dsp, buf);
+}
- if (symtab->filename[0] == '/')
- return savestring(symtab->filename, strlen(symtab->filename));
+static int
+gdb_get_breakpoint_list (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ struct breakpoint *b;
+ extern struct breakpoint *breakpoint_chain;
- if (symtab->dirname)
- pathlen = strlen(symtab->dirname);
- else
- pathlen = 0;
- if (symtab->filename)
- pathlen += strlen(symtab->filename);
+ if (argc != 1)
+ error ("wrong # args");
- filename = xmalloc(pathlen+1);
+ for (b = breakpoint_chain; b; b = b->next)
+ if (b->type == bp_breakpoint)
+ dsprintf_append_element (result_ptr, "%d", b->number);
- if (symtab->dirname)
- strcpy(filename, symtab->dirname);
- else
- *filename = '\000';
- if (symtab->filename)
- strcat(filename, symtab->filename);
+ return TCL_OK;
+}
- return filename;
+static int
+gdb_get_breakpoint_info (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ struct symtab_and_line sal;
+ static char *bptypes[] = {"breakpoint", "hardware breakpoint", "until",
+ "finish", "watchpoint", "hardware watchpoint",
+ "read watchpoint", "access watchpoint",
+ "longjmp", "longjmp resume", "step resume",
+ "through sigtramp", "watchpoint scope",
+ "call dummy" };
+ static char *bpdisp[] = {"delete", "disable", "donttouch"};
+ struct command_line *cmd;
+ int bpnum;
+ struct breakpoint *b;
+ extern struct breakpoint *breakpoint_chain;
+
+ if (argc != 2)
+ error ("wrong # args");
+
+ bpnum = atoi (argv[1]);
+
+ for (b = breakpoint_chain; b; b = b->next)
+ if (b->number == bpnum)
+ break;
+
+ if (!b || b->type != bp_breakpoint)
+ error ("Breakpoint #%d does not exist", bpnum);
+
+ sal = find_pc_line (b->address, 0);
+
+ Tcl_DStringAppendElement (result_ptr, symtab_to_filename (sal.symtab));
+ dsprintf_append_element (result_ptr, "%d", sal.line);
+ dsprintf_append_element (result_ptr, "0x%lx", b->address);
+ Tcl_DStringAppendElement (result_ptr, bptypes[b->type]);
+ Tcl_DStringAppendElement (result_ptr, b->enable == enabled ? "1" : "0");
+ Tcl_DStringAppendElement (result_ptr, bpdisp[b->disposition]);
+ dsprintf_append_element (result_ptr, "%d", b->silent);
+ dsprintf_append_element (result_ptr, "%d", b->ignore_count);
+
+ Tcl_DStringStartSublist (result_ptr);
+ for (cmd = b->commands; cmd; cmd = cmd->next)
+ Tcl_DStringAppendElement (result_ptr, cmd->line);
+ Tcl_DStringEndSublist (result_ptr);
+
+ Tcl_DStringAppendElement (result_ptr, b->cond_string);
+
+ dsprintf_append_element (result_ptr, "%d", b->thread);
+ dsprintf_append_element (result_ptr, "%d", b->hit_count);
+
+ return TCL_OK;
}
-#endif
-\f
+
static void
breakpoint_notify(b, action)
struct breakpoint *b;
const char *action;
{
- struct symbol *sym;
- char bpnum[50], line[50], pc[50];
- struct symtab_and_line sal;
- char *filename;
+ char buf[100];
int v;
if (b->type != bp_breakpoint)
return;
- sal = find_pc_line (b->address, 0);
+ sprintf (buf, "gdbtk_tcl_breakpoint %s %d", action, b->number);
- filename = symtab_to_filename (sal.symtab);
-
- sprintf (bpnum, "%d", b->number);
- sprintf (line, "%d", sal.line);
- sprintf (pc, "0x%x", b->address);
-
- v = Tcl_VarEval (interp,
- "gdbtk_tcl_breakpoint ",
- action,
- " ", bpnum,
- " ", filename,
- " ", line,
- " ", pc,
- NULL);
+ v = Tcl_Eval (interp, buf);
if (v != TCL_OK)
{
- gdbtk_fputs (interp->result);
- gdbtk_fputs ("\n");
+ gdbtk_fputs (interp->result, gdb_stdout);
+ gdbtk_fputs ("\n", gdb_stdout);
}
}
gdbtk_create_breakpoint(b)
struct breakpoint *b;
{
- breakpoint_notify(b, "create");
+ breakpoint_notify (b, "create");
}
static void
gdbtk_delete_breakpoint(b)
struct breakpoint *b;
{
- breakpoint_notify(b, "delete");
-}
-
-static void
-gdbtk_enable_breakpoint(b)
- struct breakpoint *b;
-{
- breakpoint_notify(b, "enable");
+ breakpoint_notify (b, "delete");
}
static void
-gdbtk_disable_breakpoint(b)
+gdbtk_modify_breakpoint(b)
struct breakpoint *b;
{
- breakpoint_notify(b, "disable");
+ breakpoint_notify (b, "modify");
}
\f
/* This implements the TCL command `gdb_loc', which returns a list consisting
char *argv[];
{
char *filename;
- char buf[100];
struct symtab_and_line sal;
char *funcname;
CORE_ADDR pc;
free (sals.sals);
if (sals.nelts != 1)
- {
- Tcl_SetResult (interp, "Ambiguous line spec", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("Ambiguous line spec");
pc = sal.pc;
}
else
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
if (sal.symtab)
- Tcl_AppendElement (interp, sal.symtab->filename);
+ Tcl_DStringAppendElement (result_ptr, sal.symtab->filename);
else
- Tcl_AppendElement (interp, "");
+ Tcl_DStringAppendElement (result_ptr, "");
find_pc_partial_function (pc, &funcname, NULL, NULL);
- Tcl_AppendElement (interp, funcname);
+ Tcl_DStringAppendElement (result_ptr, funcname);
filename = symtab_to_filename (sal.symtab);
- Tcl_AppendElement (interp, filename);
+ Tcl_DStringAppendElement (result_ptr, filename);
- sprintf (buf, "%d", sal.line);
- Tcl_AppendElement (interp, buf); /* line number */
+ dsprintf_append_element (result_ptr, "%d", sal.line); /* line number */
- sprintf (buf, "0x%x", pc);
- Tcl_AppendElement (interp, buf); /* PC */
+ dsprintf_append_element (result_ptr, "0x%lx", pc); /* PC */
+
+ return TCL_OK;
+}
+\f
+/* This implements the TCL command `gdb_eval'. */
+
+static int
+gdb_eval (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ struct expression *expr;
+ struct cleanup *old_chain;
+ value_ptr val;
+
+ if (argc != 2)
+ error ("wrong # args");
+
+ expr = parse_expression (argv[1]);
+
+ old_chain = make_cleanup (free_current_contents, &expr);
+
+ val = evaluate_expression (expr);
+
+ val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
+ gdb_stdout, 0, 0, 0, 0);
+
+ do_cleanups (old_chain);
return TCL_OK;
}
struct symtab *symtab;
struct linetable_entry *le;
int nlines;
- char buf[100];
if (argc != 2)
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
symtab = lookup_symtab (argv[1]);
if (!symtab)
- {
- Tcl_SetResult (interp, "No such file", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("No such file");
/* If there's no linetable, or no entries, then we are done. */
if (!symtab->linetable
|| symtab->linetable->nitems == 0)
{
- Tcl_AppendElement (interp, "");
+ Tcl_DStringAppendElement (result_ptr, "");
return TCL_OK;
}
&& le->pc == (le + 1)->pc)
continue;
- sprintf (buf, "%d", le->line);
- Tcl_AppendElement (interp, buf);
+ dsprintf_append_element (result_ptr, "%d", le->line);
}
return TCL_OK;
map_arg_registers (argc, argv, func, argp)
int argc;
char *argv[];
- int (*func) PARAMS ((int regnum, void *argp));
+ void (*func) PARAMS ((int regnum, void *argp));
void *argp;
{
int regnum;
&& *reg_names[regnum] != '\000')
func (regnum, argp);
else
- {
- Tcl_SetResult (interp, "bad register number", TCL_STATIC);
-
- return TCL_ERROR;
- }
+ error ("bad register number");
}
return TCL_OK;
}
-static int
+static void
get_register_name (regnum, argp)
int regnum;
void *argp; /* Ignored */
{
- Tcl_AppendElement (interp, reg_names[regnum]);
+ Tcl_DStringAppendElement (result_ptr, reg_names[regnum]);
}
/* This implements the TCL command `gdb_regnames', which returns a list of
return map_arg_registers (argc, argv, get_register_name, 0);
}
-static char reg_value[200];
-static char *reg_valp = reg_value;
-
-static void
-save_reg_value (ptr)
- const char *ptr;
-{
- int len;
-
- len = strlen (ptr);
-
- strncpy (reg_valp, ptr, len + 1);
-
- reg_valp += len;
-}
-
#ifndef REGISTER_CONVERTIBLE
#define REGISTER_CONVERTIBLE(x) (0 != 0)
#endif
#define INVALID_FLOAT(x, y) (0 != 0)
#endif
-static int
+static void
get_register (regnum, fp)
+ int regnum;
void *fp;
{
char raw_buffer[MAX_REGISTER_RAW_SIZE];
if (read_relative_register_raw_bytes (regnum, raw_buffer))
{
- Tcl_AppendElement (interp, "Optimized out");
+ Tcl_DStringAppendElement (result_ptr, "Optimized out");
return;
}
- fputs_unfiltered_hook = save_reg_value;
- flush_hook = 0;
- reg_valp = reg_value;
-
/* Convert raw data to virtual format if necessary. */
if (REGISTER_CONVERTIBLE (regnum))
val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0,
gdb_stdout, format, 1, 0, Val_pretty_default);
- fputs_unfiltered_hook = gdbtk_fputs;
- flush_hook = gdbtk_flush;
-
- Tcl_AppendElement (interp, reg_value);
+ Tcl_DStringAppend (result_ptr, " ", -1);
}
static int
int format;
if (argc < 2)
- {
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ error ("wrong # args");
argc--;
argv++;
static char old_regs[REGISTER_BYTES];
-static int
+static void
register_changed_p (regnum, argp)
+ int regnum;
void *argp; /* Ignored */
{
char raw_buffer[MAX_REGISTER_RAW_SIZE];
memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
REGISTER_RAW_SIZE (regnum));
- sprintf (buf, "%d", regnum);
- Tcl_AppendElement (interp, buf);
+ dsprintf_append_element (result_ptr, "%d", regnum);
}
static int
int argc;
char *argv[];
{
- int format;
-
argc--;
argv++;
return map_arg_registers (argc, argv, register_changed_p, NULL);
}
\f
+/* This implements the TCL command `gdb_cmd', which sends it's argument into
+ the GDB command scanner. */
+
static int
-gdb_cmd_stub (cmd)
- char *cmd;
+gdb_cmd (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
{
- execute_command (cmd, 1);
+ if (argc != 2)
+ error ("wrong # args");
- return 1; /* Indicate success */
+ execute_command (argv[1], 1);
+
+ bpstat_do_actions (&stop_bpstat);
+
+ return TCL_OK;
}
-/* This implements the TCL command `gdb_cmd', which sends it's argument into
- the GDB command scanner. */
+/* This routine acts as a top-level for all GDB code called by tcl/Tk. It
+ handles cleanups, and calls to return_to_top_level (usually via error).
+ This is necessary in order to prevent a longjmp out of the bowels of Tk,
+ possibly leaving things in a bad state. Since this routine can be called
+ recursively, it needs to save and restore the contents of the jmp_buf as
+ necessary. */
static int
-gdb_cmd (clientData, interp, argc, argv)
+call_wrapper (clientData, interp, argc, argv)
ClientData clientData;
Tcl_Interp *interp;
int argc;
char *argv[];
{
int val;
- struct cleanup *old_chain;
+ struct cleanup *saved_cleanup_chain;
+ Tcl_CmdProc *func;
+ jmp_buf saved_error_return;
+ Tcl_DString result, *old_result_ptr;
- if (argc != 2)
+ Tcl_DStringInit (&result);
+ old_result_ptr = result_ptr;
+ result_ptr = &result;
+
+ func = (Tcl_CmdProc *)clientData;
+ memcpy (saved_error_return, error_return, sizeof (jmp_buf));
+
+ saved_cleanup_chain = save_cleanups ();
+
+ if (!setjmp (error_return))
+ val = func (clientData, interp, argc, argv);
+ else
{
- Tcl_SetResult (interp, "wrong # args", TCL_STATIC);
- return TCL_ERROR;
- }
+ val = TCL_ERROR; /* Flag an error for TCL */
- old_chain = make_cleanup (null_routine, 0);
+ gdb_flush (gdb_stderr); /* Flush error output */
- val = catch_errors (gdb_cmd_stub, argv[1], "", RETURN_MASK_ERROR);
+ gdb_flush (gdb_stdout); /* Sometimes error output comes here as well */
- /* In case of an error, we may need to force the GUI into idle mode because
- gdbtk_call_command may have bombed out while in the command routine. */
+/* In case of an error, we may need to force the GUI into idle mode because
+ gdbtk_call_command may have bombed out while in the command routine. */
- if (val == 0)
- Tcl_VarEval (interp, "gdbtk_tcl_idle", NULL);
+ Tcl_VarEval (interp, "gdbtk_tcl_idle", NULL);
+ }
- bpstat_do_actions (&stop_bpstat);
- do_cleanups (old_chain);
+ do_cleanups (ALL_CLEANUPS);
- /* Drain all buffered command output */
+ restore_cleanups (saved_cleanup_chain);
- gdb_flush (gdb_stderr);
- gdb_flush (gdb_stdout);
+ memcpy (error_return, saved_error_return, sizeof (jmp_buf));
- /* We could base the return value on val, but that would require most users
- to use catch. Since GDB errors are already being handled elsewhere, I
- see no reason to pass them up to the caller. */
+ Tcl_DStringResult (interp, &result);
+ result_ptr = old_result_ptr;
- return TCL_OK;
+ return val;
}
static int
int argc;
char *argv[];
{
- int val;
struct objfile *objfile;
struct partial_symtab *psymtab;
+ struct symtab *symtab;
ALL_PSYMTABS (objfile, psymtab)
- Tcl_AppendElement (interp, psymtab->filename);
+ Tcl_DStringAppendElement (result_ptr, psymtab->filename);
+
+ ALL_SYMTABS (objfile, symtab)
+ Tcl_DStringAppendElement (result_ptr, symtab->filename);
return TCL_OK;
}
char *argv[];
{
target_stop ();
+
+ return TCL_OK;
}
+\f
+/* This implements the TCL command `gdb_disassemble'. */
+
+static int
+gdbtk_dis_asm_read_memory (memaddr, myaddr, len, info)
+ bfd_vma memaddr;
+ bfd_byte *myaddr;
+ int len;
+ disassemble_info *info;
+{
+ extern struct target_ops exec_ops;
+ int res;
+
+ errno = 0;
+ res = xfer_memory (memaddr, myaddr, len, 0, &exec_ops);
+
+ if (res == len)
+ return 0;
+ else
+ if (errno == 0)
+ return EIO;
+ else
+ return errno;
+}
+
+/* We need a different sort of line table from the normal one cuz we can't
+ depend upon implicit line-end pc's for lines. This is because of the
+ reordering we are about to do. */
+
+struct my_line_entry {
+ int line;
+ CORE_ADDR start_pc;
+ CORE_ADDR end_pc;
+};
+
+static int
+compare_lines (mle1p, mle2p)
+ const PTR mle1p;
+ const PTR mle2p;
+{
+ struct my_line_entry *mle1, *mle2;
+ int val;
+
+ mle1 = (struct my_line_entry *) mle1p;
+ mle2 = (struct my_line_entry *) mle2p;
+
+ val = mle1->line - mle2->line;
+
+ if (val != 0)
+ return val;
+
+ return mle1->start_pc - mle2->start_pc;
+}
+
+static int
+gdb_disassemble (clientData, interp, argc, argv)
+ ClientData clientData;
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ CORE_ADDR pc, low, high;
+ int mixed_source_and_assembly;
+ static disassemble_info di = {
+ (fprintf_ftype) fprintf_filtered, /* fprintf_func */
+ gdb_stdout, /* stream */
+ NULL, /* application_data */
+ 0, /* flags */
+ NULL, /* private_data */
+ NULL, /* read_memory_func */
+ dis_asm_memory_error, /* memory_error_func */
+ dis_asm_print_address /* print_address_func */
+ };
+
+ if (argc != 3 && argc != 4)
+ error ("wrong # args");
+
+ if (strcmp (argv[1], "source") == 0)
+ mixed_source_and_assembly = 1;
+ else if (strcmp (argv[1], "nosource") == 0)
+ mixed_source_and_assembly = 0;
+ else
+ error ("First arg must be 'source' or 'nosource'");
+
+ low = parse_and_eval_address (argv[2]);
+
+ if (argc == 3)
+ {
+ if (find_pc_partial_function (low, NULL, &low, &high) == 0)
+ error ("No function contains specified address");
+ }
+ else
+ high = parse_and_eval_address (argv[3]);
+
+ /* If disassemble_from_exec == -1, then we use the following heuristic to
+ determine whether or not to do disassembly from target memory or from the
+ exec file:
+
+ If we're debugging a local process, read target memory, instead of the
+ exec file. This makes disassembly of functions in shared libs work
+ correctly.
+
+ Else, we're debugging a remote process, and should disassemble from the
+ exec file for speed. However, this is no good if the target modifies it's
+ code (for relocation, or whatever).
+ */
+
+ if (disassemble_from_exec == -1)
+ if (strcmp (target_shortname, "child") == 0
+ || strcmp (target_shortname, "procfs") == 0
+ || strcmp (target_shortname, "vxprocess") == 0)
+ disassemble_from_exec = 0; /* It's a child process, read inferior mem */
+ else
+ disassemble_from_exec = 1; /* It's remote, read the exec file */
+
+ if (disassemble_from_exec)
+ di.read_memory_func = gdbtk_dis_asm_read_memory;
+ else
+ di.read_memory_func = dis_asm_read_memory;
+
+ /* If just doing straight assembly, all we need to do is disassemble
+ everything between low and high. If doing mixed source/assembly, we've
+ got a totally different path to follow. */
+
+ if (mixed_source_and_assembly)
+ { /* Come here for mixed source/assembly */
+ /* The idea here is to present a source-O-centric view of a function to
+ the user. This means that things are presented in source order, with
+ (possibly) out of order assembly immediately following. */
+ struct symtab *symtab;
+ struct linetable_entry *le;
+ int nlines;
+ int newlines;
+ struct my_line_entry *mle;
+ struct symtab_and_line sal;
+ int i;
+ int out_of_order;
+ int next_line;
+
+ symtab = find_pc_symtab (low); /* Assume symtab is valid for whole PC range */
+
+ if (!symtab)
+ goto assembly_only;
+
+/* First, convert the linetable to a bunch of my_line_entry's. */
+
+ le = symtab->linetable->item;
+ nlines = symtab->linetable->nitems;
+
+ if (nlines <= 0)
+ goto assembly_only;
+
+ mle = (struct my_line_entry *) alloca (nlines * sizeof (struct my_line_entry));
+
+ out_of_order = 0;
+
+/* Copy linetable entries for this function into our data structure, creating
+ end_pc's and setting out_of_order as appropriate. */
+
+/* First, skip all the preceding functions. */
+
+ for (i = 0; i < nlines - 1 && le[i].pc < low; i++) ;
+
+/* Now, copy all entries before the end of this function. */
+
+ newlines = 0;
+ for (; i < nlines - 1 && le[i].pc < high; i++)
+ {
+ if (le[i].line == le[i + 1].line
+ && le[i].pc == le[i + 1].pc)
+ continue; /* Ignore duplicates */
+
+ mle[newlines].line = le[i].line;
+ if (le[i].line > le[i + 1].line)
+ out_of_order = 1;
+ mle[newlines].start_pc = le[i].pc;
+ mle[newlines].end_pc = le[i + 1].pc;
+ newlines++;
+ }
+
+/* If we're on the last line, and it's part of the function, then we need to
+ get the end pc in a special way. */
+
+ if (i == nlines - 1
+ && le[i].pc < high)
+ {
+ mle[newlines].line = le[i].line;
+ mle[newlines].start_pc = le[i].pc;
+ sal = find_pc_line (le[i].pc, 0);
+ mle[newlines].end_pc = sal.end;
+ newlines++;
+ }
+
+/* Now, sort mle by line #s (and, then by addresses within lines). */
+
+ if (out_of_order)
+ qsort (mle, newlines, sizeof (struct my_line_entry), compare_lines);
+
+/* Now, for each line entry, emit the specified lines (unless they have been
+ emitted before), followed by the assembly code for that line. */
+
+ next_line = 0; /* Force out first line */
+ for (i = 0; i < newlines; i++)
+ {
+/* Print out everything from next_line to the current line. */
+
+ if (mle[i].line >= next_line)
+ {
+ if (next_line != 0)
+ print_source_lines (symtab, next_line, mle[i].line + 1, 0);
+ else
+ print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
+
+ next_line = mle[i].line + 1;
+ }
+
+ for (pc = mle[i].start_pc; pc < mle[i].end_pc; )
+ {
+ QUIT;
+ fputs_unfiltered (" ", gdb_stdout);
+ print_address (pc, gdb_stdout);
+ fputs_unfiltered (":\t ", gdb_stdout);
+ pc += (*tm_print_insn) (pc, &di);
+ fputs_unfiltered ("\n", gdb_stdout);
+ }
+ }
+ }
+ else
+ {
+assembly_only:
+ for (pc = low; pc < high; )
+ {
+ QUIT;
+ fputs_unfiltered (" ", gdb_stdout);
+ print_address (pc, gdb_stdout);
+ fputs_unfiltered (":\t ", gdb_stdout);
+ pc += (*tm_print_insn) (pc, &di);
+ fputs_unfiltered ("\n", gdb_stdout);
+ }
+ }
+ gdb_flush (gdb_stdout);
+
+ return TCL_OK;
+}
\f
static void
tk_command (cmd, from_tty)
char *cmd;
int from_tty;
{
- Tcl_VarEval (interp, cmd, NULL);
+ int retval;
+ char *result;
+ struct cleanup *old_chain;
+
+ retval = Tcl_Eval (interp, cmd);
+
+ result = strdup (interp->result);
+
+ old_chain = make_cleanup (free, result);
- gdbtk_fputs (interp->result);
- gdbtk_fputs ("\n");
+ if (retval != TCL_OK)
+ error (result);
+
+ printf_unfiltered ("%s\n", result);
+
+ do_cleanups (old_chain);
}
static void
int pid;
struct target_waitstatus *ourstatus;
{
- signal (SIGIO, x_event);
+ struct sigaction action;
+ static sigset_t nullsigmask = {0};
+
+#ifndef SA_RESTART
+ /* Needed for SunOS 4.1.x */
+#define SA_RESTART 0
+#endif
+
+ action.sa_handler = x_event;
+ action.sa_mask = nullsigmask;
+ action.sa_flags = SA_RESTART;
+ sigaction(SIGIO, &action, NULL);
pid = target_wait (pid, ourstatus);
- signal (SIGIO, SIG_IGN);
+ action.sa_handler = SIG_IGN;
+ sigaction(SIGIO, &action, NULL);
return pid;
}
struct cleanup *old_chain;
char *gdbtk_filename;
int i;
+ struct sigaction action;
+ static sigset_t nullsigmask = {0};
old_chain = make_cleanup (cleanup_init, 0);
if (Tk_Init(interp) != TCL_OK)
error ("Tk_Init failed: %s", interp->result);
- Tcl_CreateCommand (interp, "gdb_cmd", gdb_cmd, NULL, NULL);
- Tcl_CreateCommand (interp, "gdb_loc", gdb_loc, NULL, NULL);
- Tcl_CreateCommand (interp, "gdb_sourcelines", gdb_sourcelines, NULL, NULL);
- Tcl_CreateCommand (interp, "gdb_listfiles", gdb_listfiles, NULL, NULL);
- Tcl_CreateCommand (interp, "gdb_stop", gdb_stop, NULL, NULL);
- Tcl_CreateCommand (interp, "gdb_regnames", gdb_regnames, NULL, NULL);
- Tcl_CreateCommand (interp, "gdb_fetch_registers", gdb_fetch_registers, NULL,
+ Tcl_CreateCommand (interp, "gdb_cmd", call_wrapper, gdb_cmd, NULL);
+ Tcl_CreateCommand (interp, "gdb_loc", call_wrapper, gdb_loc, NULL);
+ Tcl_CreateCommand (interp, "gdb_sourcelines", call_wrapper, gdb_sourcelines,
NULL);
- Tcl_CreateCommand (interp, "gdb_changed_register_list",
- gdb_changed_register_list, NULL, NULL);
-
- gdbtk_filename = getenv ("GDBTK_FILENAME");
- if (!gdbtk_filename)
- if (access ("gdbtk.tcl", R_OK) == 0)
- gdbtk_filename = "gdbtk.tcl";
- else
- gdbtk_filename = GDBTK_FILENAME;
-
- if (Tcl_EvalFile (interp, gdbtk_filename) != TCL_OK)
- error ("Failure reading %s: %s", gdbtk_filename, interp->result);
-
- /* Get the file descriptor for the X server */
-
- x_fd = ConnectionNumber (Tk_Display (mainWindow));
-
- /* Setup for I/O interrupts */
-
- signal (SIGIO, SIG_IGN);
-
- i = fcntl (x_fd, F_GETFL, 0);
- fcntl (x_fd, F_SETFL, i|FASYNC);
- fcntl (x_fd, F_SETOWN, getpid());
+ Tcl_CreateCommand (interp, "gdb_listfiles", call_wrapper, gdb_listfiles,
+ NULL);
+ Tcl_CreateCommand (interp, "gdb_stop", call_wrapper, gdb_stop, NULL);
+ Tcl_CreateCommand (interp, "gdb_regnames", call_wrapper, gdb_regnames, NULL);
+ Tcl_CreateCommand (interp, "gdb_fetch_registers", call_wrapper,
+ gdb_fetch_registers, NULL);
+ Tcl_CreateCommand (interp, "gdb_changed_register_list", call_wrapper,
+ gdb_changed_register_list, NULL);
+ Tcl_CreateCommand (interp, "gdb_disassemble", call_wrapper,
+ gdb_disassemble, NULL);
+ Tcl_CreateCommand (interp, "gdb_eval", call_wrapper, gdb_eval, NULL);
+ Tcl_CreateCommand (interp, "gdb_get_breakpoint_list", call_wrapper,
+ gdb_get_breakpoint_list, NULL);
+ Tcl_CreateCommand (interp, "gdb_get_breakpoint_info", call_wrapper,
+ gdb_get_breakpoint_info, NULL);
command_loop_hook = Tk_MainLoop;
- fputs_unfiltered_hook = gdbtk_fputs;
print_frame_info_listing_hook = null_routine;
query_hook = gdbtk_query;
flush_hook = gdbtk_flush;
create_breakpoint_hook = gdbtk_create_breakpoint;
delete_breakpoint_hook = gdbtk_delete_breakpoint;
- enable_breakpoint_hook = gdbtk_enable_breakpoint;
- disable_breakpoint_hook = gdbtk_disable_breakpoint;
+ modify_breakpoint_hook = gdbtk_modify_breakpoint;
interactive_hook = gdbtk_interactive;
target_wait_hook = gdbtk_wait;
call_command_hook = gdbtk_call_command;
- discard_cleanups (old_chain);
+ /* Get the file descriptor for the X server */
+
+ x_fd = ConnectionNumber (Tk_Display (mainWindow));
+
+ /* Setup for I/O interrupts */
+
+ action.sa_mask = nullsigmask;
+ action.sa_flags = 0;
+ action.sa_handler = SIG_IGN;
+ sigaction(SIGIO, &action, NULL);
+
+#ifdef FIOASYNC
+ i = 1;
+ if (ioctl (x_fd, FIOASYNC, &i))
+ perror_with_name ("gdbtk_init: ioctl FIOASYNC failed");
+
+#ifdef SIOCSPGRP
+ i = getpid();
+ if (ioctl (x_fd, SIOCSPGRP, &i))
+ perror_with_name ("gdbtk_init: ioctl SIOCSPGRP failed");
+
+#else
+#ifdef F_SETOWN
+ i = getpid();
+ if (fcntl (x_fd, F_SETOWN, i))
+ perror_with_name ("gdbtk_init: fcntl F_SETOWN failed");
+#endif /* F_SETOWN */
+#endif /* !SIOCSPGRP */
+#else
+ if (ioctl (x_fd, I_SETSIG, S_INPUT|S_RDNORM) < 0)
+ perror_with_name ("gdbtk_init: ioctl I_SETSIG failed");
+#endif /* ifndef FIOASYNC */
add_com ("tk", class_obscure, tk_command,
"Send a command directly into tk.");
+
+ Tcl_LinkVar (interp, "disassemble-from-exec", (char *)&disassemble_from_exec,
+ TCL_LINK_INT);
+
+ /* Load up gdbtk.tcl after all the environment stuff has been setup. */
+
+ gdbtk_filename = getenv ("GDBTK_FILENAME");
+ if (!gdbtk_filename)
+ if (access ("gdbtk.tcl", R_OK) == 0)
+ gdbtk_filename = "gdbtk.tcl";
+ else
+ gdbtk_filename = GDBTK_FILENAME;
+
+/* Defer setup of fputs_unfiltered_hook to near the end so that error messages
+ prior to this point go to stdout/stderr. */
+
+ fputs_unfiltered_hook = gdbtk_fputs;
+
+ if (Tcl_EvalFile (interp, gdbtk_filename) != TCL_OK)
+ {
+ fputs_unfiltered_hook = NULL; /* Force errors to stdout/stderr */
+
+ fprintf_unfiltered (stderr, "%s:%d: %s\n", gdbtk_filename,
+ interp->errorLine, interp->result);
+
+ fputs_unfiltered ("Stack trace:\n", gdb_stderr);
+ fputs_unfiltered (Tcl_GetVar (interp, "errorInfo", 0), gdb_stderr);
+ error ("");
+ }
+
+ discard_cleanups (old_chain);
}
/* Come here during initialze_all_files () */