#include "defs.h"
#include "symtab.h"
#include "inferior.h"
#include "command.h"
#include "source.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
#include "target.h"
#include "gdbcore.h"
#include "tracepoint.h"
#include "demangle.h"
#include "frame.h"
#include "tui/tui-file.h"
#include <sys/stat.h>
#include <tcl.h>
#include <tk.h>
#include <itcl.h>
#include <tix.h>
#include "guitcl.h"
#include "gdbtk.h"
#include "gdbtk-wrapper.h"
#include <signal.h>
#include <fcntl.h>
#include "top.h"
#include <sys/ioctl.h>
#include "gdb_string.h"
#include "dis-asm.h"
#include <stdio.h>
#include "gdbcmd.h"
#include "annotate.h"
#include <sys/time.h>
static void setup_architecture_data (void);
static int tracepoint_exists (char *args);
struct wrapped_call_args
{
Tcl_Interp *interp;
Tcl_ObjCmdProc *func;
int objc;
Tcl_Obj *CONST * objv;
int val;
};
static Tcl_Obj *mangled, *not_mangled;
int No_Update = 0;
int load_in_progress = 0;
#ifndef INVALID_FLOAT
#define INVALID_FLOAT(x, y) (0 != 0)
#endif
struct my_line_entry
{
int line;
CORE_ADDR start_pc;
CORE_ADDR end_pc;
};
struct disassembly_client_data {
FILE *fp;
int file_opened_p;
int widget_line_no;
Tcl_Interp *interp;
char *widget;
Tcl_Obj *result_obj[3];
char *asm_argv[14];
char *source_argv[7];
char *map_arr;
Tcl_DString src_to_line_prefix;
Tcl_DString pc_to_line_prefix;
Tcl_DString line_to_pc_prefix;
Tcl_CmdInfo cmd;
};
static char *old_regs;
char *bptypes[] =
{"none", "breakpoint", "hw breakpoint", "until",
"finish", "watchpoint", "hw watchpoint",
"read watchpoint", "acc watchpoint",
"longjmp", "longjmp resume", "step resume",
"sigtramp", "watchpoint scope",
"call dummy", "shlib events", "catch load",
"catch unload", "catch fork", "catch vfork",
"catch exec", "catch catch", "catch throw"
};
char *bpdisp[] =
{"delete", "delstop", "disable", "donttouch"};
extern struct breakpoint *set_raw_breakpoint (struct symtab_and_line sal);
extern void set_breakpoint_count (int);
extern int breakpoint_count;
int disassemble_from_exec = -1;
extern int gdb_variable_init (Tcl_Interp * interp);
int Gdbtk_Init (Tcl_Interp * interp);
int call_wrapper (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int compare_lines (const PTR, const PTR);
static int comp_files (const void *, const void *);
static int gdb_actions_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_changed_register_list (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_clear_file (ClientData, Tcl_Interp * interp, int,
Tcl_Obj * CONST[]);
static int gdb_cmd (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_confirm_quit (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_disassemble (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_eval (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_fetch_registers (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_find_file_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_force_quit (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static struct symtab *full_lookup_symtab (char *file);
static int gdb_get_args_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_breakpoint_info (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_get_breakpoint_list (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_get_file_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_function_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_line_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_locals_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_mem (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_get_trace_frame_num (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_tracepoint_list (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_get_vars_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_immediate_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_listfiles (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_listfuncs (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_loadfile (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_load_disassembly (ClientData clientData, Tcl_Interp
* interp, int objc, Tcl_Obj * CONST objv[]);
static int gdb_load_info (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_loc (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_path_conv (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_prompt_command (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_regnames (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_restore_fputs (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_search (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST objv[]);
static int gdb_set_bp (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST objv[]);
static int gdb_set_bp_addr (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_find_bp_at_line (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_find_bp_at_addr (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdb_stop (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_target_has_execution_command (ClientData,
Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_trace_status (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST[]);
static int gdb_tracepoint_exists_command (ClientData, Tcl_Interp *,
int, Tcl_Obj * CONST objv[]);
static int gdb_get_tracepoint_info (ClientData, Tcl_Interp *, int,
Tcl_Obj * CONST objv[]);
static int gdbtk_dis_asm_read_memory (bfd_vma, bfd_byte *, unsigned int,
disassemble_info *);
static void gdbtk_load_source (ClientData clientData,
struct symtab *symtab,
int start_line, int end_line);
static CORE_ADDR gdbtk_load_asm (ClientData clientData, CORE_ADDR pc,
struct disassemble_info *di);
static void gdbtk_print_source (ClientData clientData,
struct symtab *symtab,
int start_line, int end_line);
static CORE_ADDR gdbtk_print_asm (ClientData clientData, CORE_ADDR pc,
struct disassemble_info *di);
static int gdb_disassemble_driver (CORE_ADDR low, CORE_ADDR high,
int mixed_source_and_assembly,
ClientData clientData,
void (*print_source_fn) (ClientData, struct
symtab *, int,
int),
CORE_ADDR (*print_asm_fn) (ClientData,
CORE_ADDR,
struct
disassemble_info
*));
static int get_pc_register (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_stack (ClientData, Tcl_Interp *, int, Tcl_Obj * CONST[]);
static int gdb_selected_frame (ClientData clientData,
Tcl_Interp * interp, int argc,
Tcl_Obj * CONST objv[]);
static int gdb_selected_block (ClientData clientData,
Tcl_Interp * interp, int argc,
Tcl_Obj * CONST objv[]);
static int gdb_get_blocks (ClientData clientData,
Tcl_Interp * interp, int objc,
Tcl_Obj * CONST objv[]);
static int gdb_block_vars (ClientData clientData,
Tcl_Interp * interp, int objc,
Tcl_Obj * CONST objv[]);
char *get_prompt (void);
static void get_register (int, void *);
static void get_register_name (int, void *);
static int map_arg_registers (int, Tcl_Obj * CONST[],
void (*)(int, void *), void *);
static int perror_with_name_wrapper (PTR args);
static void register_changed_p (int, void *);
static int wrapped_call (PTR opaque_args);
static void get_frame_name (Tcl_Interp * interp, Tcl_Obj * list,
struct frame_info *fi);
char *pc_function_name (CORE_ADDR pc);
int
Gdbtk_Init (interp)
Tcl_Interp *interp;
{
Tcl_CreateObjCommand (interp, "gdb_cmd", call_wrapper, gdb_cmd, NULL);
Tcl_CreateObjCommand (interp, "gdb_immediate", call_wrapper,
gdb_immediate_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_loc", call_wrapper, gdb_loc, NULL);
Tcl_CreateObjCommand (interp, "gdb_path_conv", call_wrapper, gdb_path_conv,
NULL);
Tcl_CreateObjCommand (interp, "gdb_listfiles", call_wrapper, gdb_listfiles,
NULL);
Tcl_CreateObjCommand (interp, "gdb_listfuncs", call_wrapper, gdb_listfuncs,
NULL);
Tcl_CreateObjCommand (interp, "gdb_get_mem", call_wrapper, gdb_get_mem,
NULL);
Tcl_CreateObjCommand (interp, "gdb_stop", call_wrapper, gdb_stop, NULL);
Tcl_CreateObjCommand (interp, "gdb_regnames", call_wrapper, gdb_regnames,
NULL);
Tcl_CreateObjCommand (interp, "gdb_restore_fputs", call_wrapper, gdb_restore_fputs,
NULL);
Tcl_CreateObjCommand (interp, "gdb_fetch_registers", call_wrapper,
gdb_fetch_registers, NULL);
Tcl_CreateObjCommand (interp, "gdb_changed_register_list", call_wrapper,
gdb_changed_register_list, NULL);
Tcl_CreateObjCommand (interp, "gdb_disassemble", call_wrapper,
gdb_disassemble, NULL);
Tcl_CreateObjCommand (interp, "gdb_eval", call_wrapper, gdb_eval, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_breakpoint_list", call_wrapper,
gdb_get_breakpoint_list, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_breakpoint_info", call_wrapper,
gdb_get_breakpoint_info, NULL);
Tcl_CreateObjCommand (interp, "gdb_clear_file", call_wrapper,
gdb_clear_file, NULL);
Tcl_CreateObjCommand (interp, "gdb_confirm_quit", call_wrapper,
gdb_confirm_quit, NULL);
Tcl_CreateObjCommand (interp, "gdb_force_quit", call_wrapper,
gdb_force_quit, NULL);
Tcl_CreateObjCommand (interp, "gdb_target_has_execution",
call_wrapper,
gdb_target_has_execution_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_is_tracing",
call_wrapper, gdb_trace_status,
NULL);
Tcl_CreateObjCommand (interp, "gdb_load_info", call_wrapper, gdb_load_info,
NULL);
Tcl_CreateObjCommand (interp, "gdb_get_locals", call_wrapper,
gdb_get_locals_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_args", call_wrapper,
gdb_get_args_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_function", call_wrapper,
gdb_get_function_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_line", call_wrapper,
gdb_get_line_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_file", call_wrapper,
gdb_get_file_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_tracepoint_exists",
call_wrapper, gdb_tracepoint_exists_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_tracepoint_info",
call_wrapper, gdb_get_tracepoint_info, NULL);
Tcl_CreateObjCommand (interp, "gdb_actions",
call_wrapper, gdb_actions_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_prompt",
call_wrapper, gdb_prompt_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_find_file",
call_wrapper, gdb_find_file_command, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_tracepoint_list",
call_wrapper, gdb_get_tracepoint_list, NULL);
Tcl_CreateObjCommand (interp, "gdb_pc_reg", call_wrapper, get_pc_register,
NULL);
Tcl_CreateObjCommand (interp, "gdb_loadfile", call_wrapper, gdb_loadfile,
NULL);
Tcl_CreateObjCommand (interp, "gdb_load_disassembly", call_wrapper,
gdb_load_disassembly, NULL);
Tcl_CreateObjCommand (gdbtk_interp, "gdb_search", call_wrapper,
gdb_search, NULL);
Tcl_CreateObjCommand (interp, "gdb_set_bp", call_wrapper, gdb_set_bp, NULL);
Tcl_CreateObjCommand (interp, "gdb_set_bp_addr", call_wrapper,
gdb_set_bp_addr, NULL);
Tcl_CreateObjCommand (interp, "gdb_find_bp_at_line", call_wrapper,
gdb_find_bp_at_line, NULL);
Tcl_CreateObjCommand (interp, "gdb_find_bp_at_addr", call_wrapper,
gdb_find_bp_at_addr, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_trace_frame_num",
call_wrapper, gdb_get_trace_frame_num, NULL);
Tcl_CreateObjCommand (interp, "gdb_stack", call_wrapper, gdb_stack, NULL);
Tcl_CreateObjCommand (interp, "gdb_selected_frame", call_wrapper,
gdb_selected_frame, NULL);
Tcl_CreateObjCommand (interp, "gdb_selected_block", call_wrapper,
gdb_selected_block, NULL);
Tcl_CreateObjCommand (interp, "gdb_get_blocks", call_wrapper,
gdb_get_blocks, NULL);
Tcl_CreateObjCommand (interp, "gdb_block_variables", call_wrapper,
gdb_block_vars, NULL);
Tcl_LinkVar (interp, "gdb_selected_frame_level",
(char *) &selected_frame_level,
TCL_LINK_INT | TCL_LINK_READ_ONLY);
Tcl_LinkVar (interp, "gdb_context_id",
(char *) &gdb_context,
TCL_LINK_INT | TCL_LINK_READ_ONLY);
if (gdb_variable_init (interp) != TCL_OK)
return TCL_ERROR;
gdb_stdtarg = gdb_stderr;
gdb_stdlog = gdb_stderr;
setup_architecture_data ();
register_gdbarch_swap (&old_regs, sizeof (old_regs), NULL);
register_gdbarch_swap (NULL, 0, setup_architecture_data);
Tcl_LinkVar (gdbtk_interp, "disassemble-from-exec",
(char *) &disassemble_from_exec,
TCL_LINK_INT);
Tcl_PkgProvide (interp, "Gdbtk", GDBTK_VERSION);
return TCL_OK;
}
int
call_wrapper (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct wrapped_call_args wrapped_args;
gdbtk_result new_result, *old_result_ptr;
old_result_ptr = result_ptr;
result_ptr = &new_result;
result_ptr->obj_ptr = Tcl_NewObj ();
result_ptr->flags = GDBTK_TO_RESULT;
wrapped_args.func = (Tcl_ObjCmdProc *) clientData;
wrapped_args.interp = interp;
wrapped_args.objc = objc;
wrapped_args.objv = objv;
wrapped_args.val = TCL_OK;
if (!catch_errors (wrapped_call, &wrapped_args, "", RETURN_MASK_ALL))
{
wrapped_args.val = TCL_ERROR;
gdbtk_stop_timer ();
gdb_flush (gdb_stderr);
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
gdb_flush (gdb_stdout);
running_now = 0;
Tcl_Eval (interp, "gdbtk_tcl_idle");
}
load_in_progress = 0;
if (result_ptr->flags & GDBTK_IN_TCL_RESULT)
{
Tcl_DecrRefCount (result_ptr->obj_ptr);
}
else
{
Tcl_SetObjResult (interp, result_ptr->obj_ptr);
}
result_ptr = old_result_ptr;
#ifdef _WIN32
close_bfds ();
#endif
return wrapped_args.val;
}
static int
wrapped_call (opaque_args)
PTR opaque_args;
{
struct wrapped_call_args *args = (struct wrapped_call_args *) opaque_args;
args->val = (*args->func) (args->func, args->interp, args->objc, args->objv);
return 1;
}
static void
sprintf_append_element_to_obj (Tcl_Obj * objp, char *format,...)
{
va_list args;
char buf[1024];
va_start (args, format);
vsprintf (buf, format, args);
Tcl_ListObjAppendElement (NULL, objp, Tcl_NewStringObj (buf, -1));
}
static int
gdb_clear_file (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
if (objc != 1)
Tcl_SetStringObj (result_ptr->obj_ptr,
"Wrong number of args, none are allowed.", -1);
if (inferior_pid != 0 && target_has_execution)
{
if (attach_flag)
target_detach (NULL, 0);
else
target_kill ();
}
if (target_has_execution)
pop_target ();
delete_command (NULL, 0);
exec_file_command (NULL, 0);
symbol_file_command (NULL, 0);
return TCL_OK;
}
static int
gdb_confirm_quit (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int ret;
if (objc != 1)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"Wrong number of args, should be none.", -1);
return TCL_ERROR;
}
ret = quit_confirm ();
Tcl_SetBooleanObj (result_ptr->obj_ptr, ret);
return TCL_OK;
}
static int
gdb_force_quit (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
if (objc != 1)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"Wrong number of args, should be none.", -1);
return TCL_ERROR;
}
quit_force ((char *) NULL, 1);
return TCL_OK;
}
static int
gdb_stop (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int force = 0;
char *s;
if (objc > 1)
{
s = Tcl_GetStringFromObj (objv[1], NULL);
if (STREQ (s, "detach"))
force = 1;
}
if (force)
{
gdbtk_force_detach = 1;
}
else
{
if (target_stop != target_ignore)
target_stop ();
else
quit_flag = 1;
}
return TCL_OK;
}
static int
gdb_eval (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct expression *expr;
struct cleanup *old_chain = NULL;
value_ptr val;
if (objc != 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"wrong # args, should be \"gdb_eval expression\"", -1);
return TCL_ERROR;
}
expr = parse_expression (Tcl_GetStringFromObj (objv[1], NULL));
old_chain = make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
gdb_stdout, 0, 0, 0, 0);
do_cleanups (old_chain);
return TCL_OK;
}
static int
gdb_cmd (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int from_tty = 0;
if (objc < 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "wrong # args", -1);
return TCL_ERROR;
}
if (objc == 3)
{
if (Tcl_GetBooleanFromObj (NULL, objv[2], &from_tty) != TCL_OK)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "from_tty must be a boolean.",
-1);
return TCL_ERROR;
}
}
if (running_now || load_in_progress)
return TCL_OK;
No_Update = 1;
if ((strncmp ("load ", Tcl_GetStringFromObj (objv[1], NULL), 5) == 0))
{
result_ptr->flags &= ~GDBTK_TO_RESULT;
load_in_progress = 1;
}
execute_command (Tcl_GetStringFromObj (objv[1], NULL), from_tty);
if (load_in_progress)
{
load_in_progress = 0;
result_ptr->flags |= GDBTK_TO_RESULT;
}
bpstat_do_actions (&stop_bpstat);
return TCL_OK;
}
static int
gdb_immediate_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int from_tty = 0;
if (objc < 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "wrong # args", -1);
return TCL_ERROR;
}
if (objc == 3)
{
if (Tcl_GetBooleanFromObj (NULL, objv[2], &from_tty) != TCL_OK)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "from_tty must be a boolean.",
-1);
return TCL_ERROR;
}
}
if (running_now || load_in_progress)
return TCL_OK;
No_Update = 0;
result_ptr->flags &= ~GDBTK_TO_RESULT;
execute_command (Tcl_GetStringFromObj (objv[1], NULL), from_tty);
bpstat_do_actions (&stop_bpstat);
result_ptr->flags |= GDBTK_TO_RESULT;
return TCL_OK;
}
static int
gdb_prompt_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
Tcl_SetStringObj (result_ptr->obj_ptr, get_prompt (), -1);
return TCL_OK;
}
static int
gdb_target_has_execution_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int result = 0;
if (target_has_execution && inferior_pid != 0)
result = 1;
Tcl_SetBooleanObj (result_ptr->obj_ptr, result);
return TCL_OK;
}
static int
gdb_load_info (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
bfd *loadfile_bfd;
struct cleanup *old_cleanups;
asection *s;
Tcl_Obj *ob[2];
char *filename = Tcl_GetStringFromObj (objv[1], NULL);
loadfile_bfd = bfd_openr (filename, gnutarget);
if (loadfile_bfd == NULL)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Open failed", -1);
return TCL_ERROR;
}
old_cleanups = make_cleanup_bfd_close (loadfile_bfd);
if (!bfd_check_format (loadfile_bfd, bfd_object))
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Bad Object File", -1);
return TCL_ERROR;
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
for (s = loadfile_bfd->sections; s; s = s->next)
{
if (s->flags & SEC_LOAD)
{
bfd_size_type size = bfd_get_section_size_before_reloc (s);
if (size > 0)
{
ob[0] = Tcl_NewStringObj ((char *)
bfd_get_section_name (loadfile_bfd, s),
-1);
ob[1] = Tcl_NewLongObj ((long) size);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewListObj (2, ob));
}
}
}
do_cleanups (old_cleanups);
return TCL_OK;
}
static int
gdb_get_locals_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
return gdb_get_vars_command ((ClientData) 0, interp, objc, objv);
}
static int
gdb_get_args_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
return gdb_get_vars_command ((ClientData) 1, interp, objc, objv);
}
static int
gdb_get_vars_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtabs_and_lines sals;
struct symbol *sym;
struct block *block;
char **canonical, *args;
int i, nsyms, arguments;
if (objc > 2)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # of args: should be \"",
Tcl_GetStringFromObj (objv[0], NULL),
" [function:line|function|line|*addr]\"", NULL);
return TCL_ERROR;
}
arguments = (int) clientData;
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
if (objc == 2)
{
args = Tcl_GetStringFromObj (objv[1], NULL);
sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
if (sals.nelts == 0)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"error decoding line", -1);
return TCL_ERROR;
}
for (i = 0; i < sals.nelts; i++)
resolve_sal_pc (&sals.sals[i]);
block = block_for_pc (sals.sals[0].pc);
}
else
{
if (selected_frame == NULL)
return TCL_OK;
block = get_frame_block (selected_frame);
}
while (block != 0)
{
nsyms = BLOCK_NSYMS (block);
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (block, i);
switch (SYMBOL_CLASS (sym))
{
default:
case LOC_UNDEF:
case LOC_CONST:
case LOC_TYPEDEF:
case LOC_LABEL:
case LOC_BLOCK:
case LOC_CONST_BYTES:
case LOC_UNRESOLVED:
case LOC_OPTIMIZED_OUT:
break;
case LOC_ARG:
case LOC_REF_ARG:
case LOC_REGPARM:
case LOC_REGPARM_ADDR:
case LOC_LOCAL_ARG:
case LOC_BASEREG_ARG:
if (arguments)
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (SYMBOL_NAME (sym), -1));
break;
case LOC_LOCAL:
case LOC_BASEREG:
case LOC_STATIC:
case LOC_REGISTER:
if (!arguments)
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (SYMBOL_NAME (sym), -1));
break;
}
}
if (BLOCK_FUNCTION (block))
break;
else
block = BLOCK_SUPERBLOCK (block);
}
return TCL_OK;
}
static int
gdb_get_line_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtabs_and_lines sals;
char *args, **canonical;
if (objc != 2)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # of args: should be \"",
Tcl_GetStringFromObj (objv[0], NULL),
" linespec\"", NULL);
return TCL_ERROR;
}
args = Tcl_GetStringFromObj (objv[1], NULL);
sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
if (sals.nelts == 1)
{
Tcl_SetIntObj (result_ptr->obj_ptr, sals.sals[0].line);
return TCL_OK;
}
Tcl_SetStringObj (result_ptr->obj_ptr, "N/A", -1);
return TCL_OK;
}
static int
gdb_get_file_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtabs_and_lines sals;
char *args, **canonical;
if (objc != 2)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # of args: should be \"",
Tcl_GetStringFromObj (objv[0], NULL),
" linespec\"", NULL);
return TCL_ERROR;
}
args = Tcl_GetStringFromObj (objv[1], NULL);
sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
if (sals.nelts == 1)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
sals.sals[0].symtab->filename, -1);
return TCL_OK;
}
Tcl_SetStringObj (result_ptr->obj_ptr, "N/A", -1);
return TCL_OK;
}
static int
gdb_get_function_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char *function;
struct symtabs_and_lines sals;
char *args, **canonical;
if (objc != 2)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # of args: should be \"",
Tcl_GetStringFromObj (objv[0], NULL),
" linespec\"", NULL);
return TCL_ERROR;
}
args = Tcl_GetStringFromObj (objv[1], NULL);
sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
if (sals.nelts == 1)
{
resolve_sal_pc (&sals.sals[0]);
function = pc_function_name (sals.sals[0].pc);
Tcl_SetStringObj (result_ptr->obj_ptr, function, -1);
return TCL_OK;
}
Tcl_SetStringObj (result_ptr->obj_ptr, "N/A", -1);
return TCL_OK;
}
static int
gdb_find_file_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char *filename = NULL;
struct symtab *st;
if (objc != 2)
{
Tcl_WrongNumArgs (interp, 1, objv, "filename");
return TCL_ERROR;
}
st = full_lookup_symtab (Tcl_GetStringFromObj (objv[1], NULL));
if (st)
filename = st->fullname;
if (filename == NULL)
Tcl_SetStringObj (result_ptr->obj_ptr, "", 0);
else
Tcl_SetStringObj (result_ptr->obj_ptr, filename, -1);
return TCL_OK;
}
static int
gdb_listfiles (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct objfile *objfile;
struct partial_symtab *psymtab;
struct symtab *symtab;
char *lastfile, *pathname = NULL, **files;
int files_size;
int i, numfiles = 0, len = 0;
files_size = 1000;
files = (char **) xmalloc (sizeof (char *) * files_size);
if (objc > 2)
{
Tcl_WrongNumArgs (interp, 1, objv, "Usage: gdb_listfiles ?pathname?");
return TCL_ERROR;
}
else if (objc == 2)
pathname = Tcl_GetStringFromObj (objv[1], &len);
ALL_PSYMTABS (objfile, psymtab)
{
if (numfiles == files_size)
{
files_size = files_size * 2;
files = (char **) xrealloc (files, sizeof (char *) * files_size);
}
if (psymtab->filename)
{
if (!len || !strncmp (pathname, psymtab->filename, len)
|| !strcmp (psymtab->filename, basename (psymtab->filename)))
{
files[numfiles++] = basename (psymtab->filename);
}
}
}
ALL_SYMTABS (objfile, symtab)
{
if (numfiles == files_size)
{
files_size = files_size * 2;
files = (char **) xrealloc (files, sizeof (char *) * files_size);
}
if (symtab->filename && symtab->linetable && symtab->linetable->nitems)
{
if (!len || !strncmp (pathname, symtab->filename, len)
|| !strcmp (symtab->filename, basename (symtab->filename)))
{
files[numfiles++] = basename (symtab->filename);
}
}
}
qsort (files, numfiles, sizeof (char *), comp_files);
lastfile = "";
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
for (i = 0; i < numfiles; i++)
{
if (strcmp (files[i], lastfile))
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (files[i], -1));
lastfile = files[i];
}
free (files);
return TCL_OK;
}
static int
comp_files (file1, file2)
const void *file1, *file2;
{
return strcmp (*(char **) file1, *(char **) file2);
}
static int
gdb_search (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symbol_search *ss = NULL;
struct symbol_search *p;
struct cleanup *old_chain = NULL;
Tcl_Obj *CONST * switch_objv;
int index, switch_objc, i, show_files = 0;
namespace_enum space = 0;
char *regexp;
int static_only, nfiles;
Tcl_Obj **file_list;
char **files;
static char *search_options[] =
{"functions", "variables", "types", (char *) NULL};
static char *switches[] =
{"-files", "-filename", "-static", (char *) NULL};
enum search_opts
{
SEARCH_FUNCTIONS, SEARCH_VARIABLES, SEARCH_TYPES
};
enum switches_opts
{
SWITCH_FILES, SWITCH_FILENAME, SWITCH_STATIC_ONLY
};
if (objc < 3)
{
Tcl_WrongNumArgs (interp, 1, objv, "option regexp ?arg ...?");
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (Tcl_GetIndexFromObj (interp, objv[1], search_options, "option", 0,
&index) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
switch ((enum search_opts) index)
{
case SEARCH_FUNCTIONS:
space = FUNCTIONS_NAMESPACE;
break;
case SEARCH_VARIABLES:
space = VARIABLES_NAMESPACE;
break;
case SEARCH_TYPES:
space = TYPES_NAMESPACE;
break;
}
regexp = Tcl_GetStringFromObj (objv[2], NULL);
switch_objc = objc - 3;
switch_objv = objv + 3;
static_only = 0;
nfiles = 0;
files = (char **) NULL;
while (switch_objc > 0)
{
if (Tcl_GetIndexFromObj (interp, switch_objv[0], switches,
"option", 0, &index) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
switch ((enum switches_opts) index)
{
case SWITCH_FILENAME:
{
if (switch_objc < 2)
{
Tcl_WrongNumArgs (interp, 3, objv,
"?-files fileList -filename 1|0 -static 1|0?");
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (Tcl_GetBooleanFromObj (interp, switch_objv[1], &show_files)
!= TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
switch_objc--;
switch_objv++;
}
break;
case SWITCH_FILES:
{
int result;
if (switch_objc < 2)
{
Tcl_WrongNumArgs (interp, 3, objv,
"?-files fileList -filename 1|0 -static 1|0?");
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
result = Tcl_ListObjGetElements (interp, switch_objv[1],
&nfiles, &file_list);
if (result != TCL_OK)
return result;
files = (char **) xmalloc (nfiles * sizeof (char *));
for (i = 0; i < nfiles; i++)
files[i] = Tcl_GetStringFromObj (file_list[i], NULL);
switch_objc--;
switch_objv++;
}
break;
case SWITCH_STATIC_ONLY:
if (switch_objc < 2)
{
Tcl_WrongNumArgs (interp, 3, objv,
"?-files fileList -filename 1|0 -static 1|0?");
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (Tcl_GetBooleanFromObj (interp, switch_objv[1], &static_only)
!= TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
switch_objc--;
switch_objv++;
}
switch_objc--;
switch_objv++;
}
search_symbols (regexp, space, nfiles, files, &ss);
if (ss != NULL)
old_chain = make_cleanup_free_search_symbols (ss);
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
for (p = ss; p != NULL; p = p->next)
{
Tcl_Obj *elem;
if (static_only && p->block != STATIC_BLOCK)
continue;
if ((p->symbol != NULL && !STREQN (SYMBOL_NAME (p->symbol), "__tf", 4)
&& !STREQN (SYMBOL_NAME (p->symbol), "_GLOBAL_", 8))
|| p->msymbol != NULL)
{
elem = Tcl_NewListObj (0, NULL);
if (p->msymbol == NULL)
Tcl_ListObjAppendElement (interp, elem,
Tcl_NewStringObj (SYMBOL_SOURCE_NAME (p->symbol), -1));
else
Tcl_ListObjAppendElement (interp, elem,
Tcl_NewStringObj (SYMBOL_SOURCE_NAME (p->msymbol), -1));
if (show_files)
{
if ((p->symtab != NULL) && (p->symtab->filename != NULL))
{
Tcl_ListObjAppendElement (interp, elem, Tcl_NewStringObj
(p->symtab->filename, -1));
}
else
{
Tcl_ListObjAppendElement (interp, elem,
Tcl_NewStringObj ("", 0));
}
}
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr, elem);
}
}
if (ss != NULL)
do_cleanups (old_chain);
return TCL_OK;
}
static int
gdb_listfuncs (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtab *symtab;
struct blockvector *bv;
struct block *b;
struct symbol *sym;
int i, j;
Tcl_Obj *funcVals[2];
if (objc != 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "wrong # args", -1);
}
symtab = full_lookup_symtab (Tcl_GetStringFromObj (objv[1], NULL));
if (!symtab)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "No such file", -1);
return TCL_ERROR;
}
if (mangled == NULL)
{
mangled = Tcl_NewBooleanObj (1);
not_mangled = Tcl_NewBooleanObj (0);
Tcl_IncrRefCount (mangled);
Tcl_IncrRefCount (not_mangled);
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
bv = BLOCKVECTOR (symtab);
for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
{
b = BLOCKVECTOR_BLOCK (bv, i);
if (!BLOCK_SHOULD_SORT (b))
sort_block_syms (b);
for (j = 0; j < BLOCK_NSYMS (b); j++)
{
sym = BLOCK_SYM (b, j);
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
char *name = SYMBOL_DEMANGLED_NAME (sym);
if (name)
{
if (strncmp (name, "global ", 7))
{
funcVals[0] = Tcl_NewStringObj (name, -1);
funcVals[1] = mangled;
}
else
continue;
}
else
{
funcVals[0] = Tcl_NewStringObj (SYMBOL_NAME (sym), -1);
funcVals[1] = not_mangled;
}
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewListObj (2, funcVals));
}
}
}
return TCL_OK;
}
static int
map_arg_registers (objc, objv, func, argp)
int objc;
Tcl_Obj *CONST objv[];
void (*func) (int regnum, void *argp);
void *argp;
{
int regnum, numregs;
numregs = ARCH_NUM_REGS + NUM_PSEUDO_REGS;
if (objc == 0)
{
for (regnum = 0;
regnum < numregs;
regnum++)
{
if (REGISTER_NAME (regnum) == NULL
|| *(REGISTER_NAME (regnum)) == '\0')
continue;
func (regnum, argp);
}
return TCL_OK;
}
for (; objc > 0; objc--, objv++)
{
if (Tcl_GetIntFromObj (NULL, *objv, ®num) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (regnum >= 0
&& regnum < numregs
&& REGISTER_NAME (regnum) != NULL
&& *REGISTER_NAME (regnum) != '\000')
func (regnum, argp);
else
{
Tcl_SetStringObj (result_ptr->obj_ptr, "bad register number", -1);
return TCL_ERROR;
}
}
return TCL_OK;
}
static int
gdb_restore_fputs (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
fputs_unfiltered_hook = gdbtk_fputs;
return TCL_OK;
}
static int
gdb_regnames (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int numbers = 0;
objc--;
objv++;
if (objc >= 1)
{
char *s = Tcl_GetStringFromObj (objv[0], NULL);
if (STREQ (s, "-numbers"))
numbers = 1;
objc--;
objv++;
}
return map_arg_registers (objc, objv, get_register_name, &numbers);
}
static void
get_register_name (regnum, argp)
int regnum;
void *argp;
{
int numbers = * (int *) argp;
Tcl_Obj *name = Tcl_NewStringObj (REGISTER_NAME (regnum), -1);
Tcl_Obj *elt;
if (numbers)
{
Tcl_Obj *array[2];
array[0] = name;
array[1] = Tcl_NewIntObj (regnum);
elt = Tcl_NewListObj (2, array);
}
else
elt = name;
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, elt);
}
static int
gdb_fetch_registers (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int format, result;
if (objc < 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"wrong # args, should be gdb_fetch_registers format ?register1 register2 ...?", -1);
}
objc -= 2;
objv++;
format = *(Tcl_GetStringFromObj (objv[0], NULL));
objv++;
result_ptr->flags |= GDBTK_MAKES_LIST;
result = map_arg_registers (objc, objv, get_register, (void *) format);
result_ptr->flags &= ~GDBTK_MAKES_LIST;
return result;
}
static void
get_register (regnum, fp)
int regnum;
void *fp;
{
struct type *reg_vtype;
char raw_buffer[MAX_REGISTER_RAW_SIZE];
char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
int format = (int) fp;
int optim;
if (format == 'N')
format = 0;
get_saved_register (raw_buffer, &optim, (CORE_ADDR *) NULL, selected_frame,
regnum, (enum lval_type *) NULL);
if (optim)
{
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj ("Optimized out", -1));
return;
}
reg_vtype = REGISTER_VIRTUAL_TYPE (regnum);
if (REGISTER_CONVERTIBLE (regnum))
{
REGISTER_CONVERT_TO_VIRTUAL (regnum, reg_vtype,
raw_buffer, virtual_buffer);
}
else
memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (regnum));
if (format == 'r')
{
int j;
char *ptr, buf[1024];
strcpy (buf, "0x");
ptr = buf + 2;
for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
{
register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
: REGISTER_RAW_SIZE (regnum) - 1 - j;
sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
ptr += 2;
}
fputs_filtered (buf, gdb_stdout);
}
else
if ((TYPE_CODE (reg_vtype) == TYPE_CODE_UNION)
&& (strcmp (FIELD_NAME (TYPE_FIELD (reg_vtype, 0)), REGISTER_NAME (regnum)) == 0))
{
val_print (FIELD_TYPE (TYPE_FIELD (reg_vtype, 0)), virtual_buffer, 0, 0,
gdb_stdout, format, 1, 0, Val_pretty_default);
}
else
val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0, 0,
gdb_stdout, format, 1, 0, Val_pretty_default);
}
static int
get_pc_register (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char buff[64];
sprintf (buff, "0x%llx", (long long) read_register (PC_REGNUM));
Tcl_SetStringObj (result_ptr->obj_ptr, buff, -1);
return TCL_OK;
}
static int
gdb_changed_register_list (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
objc--;
objv++;
return map_arg_registers (objc, objv, register_changed_p, NULL);
}
static void
register_changed_p (regnum, argp)
int regnum;
void *argp;
{
char raw_buffer[MAX_REGISTER_RAW_SIZE];
if (read_relative_register_raw_bytes (regnum, raw_buffer))
return;
if (memcmp (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
REGISTER_RAW_SIZE (regnum)) == 0)
return;
memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
REGISTER_RAW_SIZE (regnum));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, Tcl_NewIntObj (regnum));
}
static int
gdb_get_tracepoint_list (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct tracepoint *tp;
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
ALL_TRACEPOINTS (tp)
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (tp->number));
return TCL_OK;
}
static int
tracepoint_exists (char *args)
{
struct tracepoint *tp;
char **canonical;
struct symtabs_and_lines sals;
char *file = NULL;
int result = -1;
sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
if (sals.nelts == 1)
{
resolve_sal_pc (&sals.sals[0]);
file = xmalloc (strlen (sals.sals[0].symtab->dirname)
+ strlen (sals.sals[0].symtab->filename) + 1);
if (file != NULL)
{
strcpy (file, sals.sals[0].symtab->dirname);
strcat (file, sals.sals[0].symtab->filename);
ALL_TRACEPOINTS (tp)
{
if (tp->address == sals.sals[0].pc)
result = tp->number;
#if 0
else if (tp->source_file != NULL
&& strcmp (tp->source_file, file) == 0
&& sals.sals[0].line == tp->line_number)
result = tp->number;
#endif
}
}
}
if (file != NULL)
free (file);
return result;
}
static int
gdb_tracepoint_exists_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char *args;
if (objc != 2)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # of args: should be \"",
Tcl_GetStringFromObj (objv[0], NULL),
" function:line|function|line|*addr\"", NULL);
return TCL_ERROR;
}
args = Tcl_GetStringFromObj (objv[1], NULL);
Tcl_SetIntObj (result_ptr->obj_ptr, tracepoint_exists (args));
return TCL_OK;
}
static int
gdb_get_tracepoint_info (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtab_and_line sal;
int tpnum;
struct tracepoint *tp;
struct action_line *al;
Tcl_Obj *action_list;
char *filename, *funcname, *fname;
if (objc != 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "wrong # args", -1);
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (NULL, objv[1], &tpnum) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
ALL_TRACEPOINTS (tp)
if (tp->number == tpnum)
break;
if (tp == NULL)
{
char buff[64];
sprintf (buff, "Tracepoint #%d does not exist", tpnum);
Tcl_SetStringObj (result_ptr->obj_ptr, buff, -1);
return TCL_ERROR;
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
sal = find_pc_line (tp->address, 0);
filename = symtab_to_filename (sal.symtab);
if (filename == NULL)
filename = "N/A";
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (filename, -1));
funcname = pc_function_name (tp->address);
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr, Tcl_NewStringObj
(funcname, -1));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (sal.line));
{
char *tmp;
asprintf (&tmp, "0x%s", paddr_nz (tp->address));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (tmp, -1));
free (tmp);
}
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (tp->enabled));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (tp->pass_count));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (tp->step_count));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (tp->thread));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewIntObj (tp->hit_count));
action_list = Tcl_NewObj ();
for (al = tp->actions; al != NULL; al = al->next)
{
Tcl_ListObjAppendElement (interp, action_list,
Tcl_NewStringObj (al->action, -1));
}
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr, action_list);
return TCL_OK;
}
static int
gdb_trace_status (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int result = 0;
if (trace_running_p)
result = 1;
Tcl_SetIntObj (result_ptr->obj_ptr, result);
return TCL_OK;
}
static int
gdb_get_trace_frame_num (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
if (objc != 1)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # of args: should be \"",
Tcl_GetStringFromObj (objv[0], NULL),
" linespec\"", NULL);
return TCL_ERROR;
}
Tcl_SetIntObj (result_ptr->obj_ptr, get_traceframe_number ());
return TCL_OK;
}
static int
gdb_actions_command (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct tracepoint *tp;
Tcl_Obj **actions;
int nactions, i, len;
char *number, *args, *action;
long step_count;
struct action_line *next = NULL, *temp;
enum actionline_type linetype;
if (objc != 3)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr,
"wrong # args: should be: \"",
Tcl_GetStringFromObj (objv[0], NULL),
" number actions\"", NULL);
return TCL_ERROR;
}
args = number = Tcl_GetStringFromObj (objv[1], NULL);
tp = get_tracepoint_by_number (&args, 0, 0);
if (tp == NULL)
{
Tcl_AppendStringsToObj (result_ptr->obj_ptr, "Tracepoint \"",
number, "\" does not exist", NULL);
return TCL_ERROR;
}
if (tp->actions != NULL)
free_actions (tp);
step_count = 0;
Tcl_ListObjGetElements (interp, objv[2], &nactions, &actions);
for (i = 0; i < nactions; i++)
{
temp = xmalloc (sizeof (struct action_line));
temp->next = NULL;
action = Tcl_GetStringFromObj (actions[i], &len);
temp->action = savestring (action, len);
linetype = validate_actionline (&(temp->action), tp);
if (linetype == BADLINE)
{
free (temp);
continue;
}
if (next == NULL)
{
tp->actions = temp;
next = temp;
}
else
{
next->next = temp;
next = temp;
}
}
return TCL_OK;
}
static int
gdb_disassemble (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
CORE_ADDR low, high;
char *arg_ptr;
int mixed_source_and_assembly;
if (objc != 3 && objc != 4)
error ("wrong # args");
arg_ptr = Tcl_GetStringFromObj (objv[1], NULL);
if (*arg_ptr == 's' && strcmp (arg_ptr, "source") == 0)
mixed_source_and_assembly = 1;
else if (*arg_ptr == 'n' && strcmp (arg_ptr, "nosource") == 0)
mixed_source_and_assembly = 0;
else
error ("First arg must be 'source' or 'nosource'");
low = parse_and_eval_address (Tcl_GetStringFromObj (objv[2], NULL));
if (objc == 3)
{
if (find_pc_partial_function (low, NULL, &low, &high) == 0)
error ("No function contains specified address");
}
else
high = parse_and_eval_address (Tcl_GetStringFromObj (objv[3], NULL));
return gdb_disassemble_driver (low, high, mixed_source_and_assembly, NULL,
gdbtk_print_source, gdbtk_print_asm);
}
static int
gdb_load_disassembly (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
CORE_ADDR low, high;
struct disassembly_client_data client_data;
int mixed_source_and_assembly, ret_val, i;
char *widget;
char *arg_ptr;
char *map_name;
if (objc != 6 && objc != 7) {
Tcl_SetStringObj (result_ptr->obj_ptr, "wrong # args, should be: widget [source|nosource] map_arr index_prefix low_address ?hi_address", -1);
return TCL_ERROR;
}
client_data.widget = Tcl_GetStringFromObj (objv[1], NULL);
if ( Tk_NameToWindow (interp, client_data.widget,
Tk_MainWindow (interp)) == NULL)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Invalid widget name.", -1);
return TCL_ERROR;
}
if (!Tcl_GetCommandInfo (interp, client_data.widget, &client_data.cmd))
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Can't get widget command info",
-1);
return TCL_ERROR;
}
arg_ptr = Tcl_GetStringFromObj (objv[2], NULL);
if (*arg_ptr == 's' && strcmp (arg_ptr, "source") == 0)
mixed_source_and_assembly = 1;
else if (*arg_ptr == 'n' && strcmp (arg_ptr, "nosource") == 0)
mixed_source_and_assembly = 0;
else
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"Second arg must be 'source' or 'nosource'", -1);
return TCL_ERROR;
}
map_name = Tcl_GetStringFromObj (objv[3], NULL);
if (*map_name != '\0')
{
char *prefix;
int prefix_len;
client_data.map_arr = "map_array";
if (Tcl_UpVar (interp, "1", map_name, client_data.map_arr, 0) != TCL_OK) {
Tcl_SetStringObj (result_ptr->obj_ptr, "Can't link map array.", -1);
return TCL_ERROR;
}
prefix = Tcl_GetStringFromObj (objv[4], &prefix_len);
Tcl_DStringInit(&client_data.src_to_line_prefix);
Tcl_DStringAppend (&client_data.src_to_line_prefix,
prefix, prefix_len);
Tcl_DStringAppend (&client_data.src_to_line_prefix, ",srcline=",
sizeof (",srcline=") - 1);
Tcl_DStringInit(&client_data.pc_to_line_prefix);
Tcl_DStringAppend (&client_data.pc_to_line_prefix,
prefix, prefix_len);
Tcl_DStringAppend (&client_data.pc_to_line_prefix, ",pc=",
sizeof (",pc=") - 1);
Tcl_DStringInit(&client_data.line_to_pc_prefix);
Tcl_DStringAppend (&client_data.line_to_pc_prefix,
prefix, prefix_len);
Tcl_DStringAppend (&client_data.line_to_pc_prefix, ",line=",
sizeof (",line=") - 1);
}
else
{
client_data.map_arr = "";
}
low = parse_and_eval_address (Tcl_GetStringFromObj (objv[5], NULL));
if (objc == 6)
{
if (find_pc_partial_function (low, NULL, &low, &high) == 0)
error ("No function contains specified address");
}
else
high = parse_and_eval_address (Tcl_GetStringFromObj (objv[6], NULL));
client_data.file_opened_p = 0;
client_data.widget_line_no = 0;
client_data.interp = interp;
for (i = 0; i < 3; i++)
{
client_data.result_obj[i] = Tcl_NewObj();
Tcl_IncrRefCount (client_data.result_obj[i]);
}
client_data.asm_argv[0] = client_data.widget;
client_data.asm_argv[1] = "insert";
client_data.asm_argv[2] = "end";
client_data.asm_argv[3] = "-\t";
client_data.asm_argv[4] = "break_rgn_tag";
client_data.asm_argv[6] = "break_rgn_tag";
client_data.asm_argv[8] = "break_rgn_tag";
client_data.asm_argv[9] = ":\t\t";
client_data.asm_argv[10] = "source_tag";
client_data.asm_argv[12] = "source_tag";
client_data.asm_argv[13] = "\n";
if (mixed_source_and_assembly)
{
client_data.source_argv[0] = client_data.widget;
client_data.source_argv[1] = "insert";
client_data.source_argv[2] = "end";
client_data.source_argv[4] = "";
client_data.source_argv[6] = "source_tag";
}
ret_val = gdb_disassemble_driver (low, high, mixed_source_and_assembly,
(ClientData) &client_data,
gdbtk_load_source, gdbtk_load_asm);
if (client_data.file_opened_p == 1) {
fclose(client_data.fp);
}
if (*client_data.map_arr != '\0')
{
Tcl_DStringFree(&client_data.src_to_line_prefix);
Tcl_DStringFree(&client_data.pc_to_line_prefix);
Tcl_DStringFree(&client_data.line_to_pc_prefix);
}
for (i = 0; i < 3; i++)
{
Tcl_DecrRefCount (client_data.result_obj[i]);
}
if (ret_val == TCL_OK) {
char buffer[256];
Tcl_Obj *limits_obj[2];
sprintf (buffer, "0x%s", paddr_nz (low));
limits_obj[0] = Tcl_NewStringObj (buffer, -1);
sprintf (buffer, "0x%s", paddr_nz (high));
limits_obj[1] = Tcl_NewStringObj (buffer, -1);
Tcl_DecrRefCount (result_ptr->obj_ptr);
result_ptr->obj_ptr = Tcl_NewListObj (2, limits_obj);
}
return ret_val;
}
static void
gdbtk_load_source (ClientData clientData, struct symtab *symtab, int
start_line, int end_line)
{
struct disassembly_client_data *client_data =
(struct disassembly_client_data *) clientData;
char buffer[18];
int index_len;
index_len = Tcl_DStringLength (&client_data->src_to_line_prefix);
if (client_data->file_opened_p == 1)
{
char **text_argv;
char line[10000], line_number[18];
int found_carriage_return = 1;
if (start_line < 1
|| end_line < start_line || end_line > symtab->nlines)
{
return;
}
line_number[0] = '\t';
line[0] = '\t';
text_argv = client_data->source_argv;
text_argv[3] = line_number;
text_argv[5] = line;
if (fseek (client_data->fp, symtab->line_charpos[start_line - 1],
SEEK_SET) < 0)
{
fclose(client_data->fp);
client_data->file_opened_p = -1;
return;
}
for (; start_line < end_line; start_line++)
{
if (!fgets (line + 1, 9980, client_data->fp))
{
fclose(client_data->fp);
client_data->file_opened_p = -1;
return;
}
client_data->widget_line_no++;
sprintf (line_number + 1, "%d", start_line);
if (found_carriage_return) {
char *p;
p = strrchr(line, '\0') - 2;
if (*p == '\r') {
*p = '\n';
*(p + 1) = '\0';
} else {
found_carriage_return = 0;
}
}
client_data->cmd.proc (client_data->cmd.clientData,
client_data->interp, 7, text_argv);
if (*client_data->map_arr != '\0')
{
Tcl_DStringAppend (&client_data->src_to_line_prefix,
line_number + 1, -1);
sprintf (buffer, "%d", client_data->widget_line_no);
Tcl_SetVar2 (client_data->interp, client_data->map_arr,
Tcl_DStringValue (&client_data->src_to_line_prefix),
buffer, 0);
Tcl_DStringSetLength (&client_data->src_to_line_prefix, index_len);
}
}
}
else if (!client_data->file_opened_p)
{
int fdes;
fdes = open_source_file (symtab);
if (fdes < 0)
{
client_data->file_opened_p = -1;
}
else
{
client_data->file_opened_p = 1;
client_data->fp = fdopen (fdes, FOPEN_RB);
clearerr (client_data->fp);
if (symtab->line_charpos == 0)
find_source_lines (symtab, fdes);
gdbtk_load_source (clientData, symtab, start_line, end_line);
}
}
else {
return;
}
}
static CORE_ADDR
gdbtk_load_asm (clientData, pc, di)
ClientData clientData;
CORE_ADDR pc;
struct disassemble_info *di;
{
struct disassembly_client_data * client_data
= (struct disassembly_client_data *) clientData;
char **text_argv;
int i, pc_to_line_len, line_to_pc_len;
gdbtk_result new_result;
struct cleanup *old_chain = NULL;
pc_to_line_len = Tcl_DStringLength (&client_data->pc_to_line_prefix);
line_to_pc_len = Tcl_DStringLength (&client_data->line_to_pc_prefix);
text_argv = client_data->asm_argv;
old_chain = make_cleanup (gdbtk_restore_result_ptr, (void *) result_ptr);
result_ptr = &new_result;
result_ptr->obj_ptr = client_data->result_obj[0];
result_ptr->flags = GDBTK_TO_RESULT;
for (i = 0; i < 3; i++)
Tcl_SetObjLength (client_data->result_obj[i], 0);
print_address_numeric (pc, 1, gdb_stdout);
gdb_flush (gdb_stdout);
result_ptr->obj_ptr = client_data->result_obj[1];
print_address_symbolic (pc, gdb_stdout, 1, "\t");
gdb_flush (gdb_stdout);
result_ptr->obj_ptr = client_data->result_obj[2];
pc += (*tm_print_insn) (pc, di);
gdb_flush (gdb_stdout);
client_data->widget_line_no++;
text_argv[5] = Tcl_GetStringFromObj (client_data->result_obj[0], NULL);
text_argv[7] = Tcl_GetStringFromObj (client_data->result_obj[1], NULL);
text_argv[11] = Tcl_GetStringFromObj (client_data->result_obj[2], NULL);
client_data->cmd.proc (client_data->cmd.clientData,
client_data->interp, 14, text_argv);
if (*client_data->map_arr != '\0')
{
char buffer[16];
Tcl_DStringAppend (&client_data->pc_to_line_prefix, text_argv[5], -1);
sprintf (buffer, "%d", client_data->widget_line_no);
Tcl_SetVar2 (client_data->interp, client_data->map_arr,
Tcl_DStringValue (&client_data->pc_to_line_prefix),
buffer, 0);
Tcl_DStringAppend (&client_data->line_to_pc_prefix, buffer, -1);
Tcl_SetVar2 (client_data->interp, client_data->map_arr,
Tcl_DStringValue (&client_data->line_to_pc_prefix),
text_argv[5], 0);
Tcl_DStringSetLength (&client_data->pc_to_line_prefix, pc_to_line_len);
Tcl_DStringSetLength (&client_data->line_to_pc_prefix, line_to_pc_len);
}
do_cleanups (old_chain);
return pc;
}
static void
gdbtk_print_source (clientData, symtab, start_line, end_line)
ClientData clientData;
struct symtab *symtab;
int start_line;
int end_line;
{
print_source_lines (symtab, start_line, end_line, 0);
gdb_flush (gdb_stdout);
}
static CORE_ADDR
gdbtk_print_asm (clientData, pc, di)
ClientData clientData;
CORE_ADDR pc;
struct disassemble_info *di;
{
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 pc;
}
static int
gdb_disassemble_driver (low, high, mixed_source_and_assembly,
clientData, print_source_fn, print_asm_fn)
CORE_ADDR low;
CORE_ADDR high;
int mixed_source_and_assembly;
ClientData clientData;
void (*print_source_fn) (ClientData, struct symtab *, int, int);
CORE_ADDR (*print_asm_fn) (ClientData, CORE_ADDR,
struct disassemble_info *);
{
CORE_ADDR pc;
static disassemble_info di;
static int di_initialized;
if (! di_initialized)
{
INIT_DISASSEMBLE_INFO_NO_ARCH (di, gdb_stdout,
(fprintf_ftype) fprintf_unfiltered);
di.flavour = bfd_target_unknown_flavour;
di.memory_error_func = dis_asm_memory_error;
di.print_address_func = dis_asm_print_address;
di_initialized = 1;
}
di.mach = TARGET_PRINT_INSN_INFO->mach;
if (TARGET_BYTE_ORDER == BIG_ENDIAN)
di.endian = BFD_ENDIAN_BIG;
else
di.endian = BFD_ENDIAN_LITTLE;
if (TARGET_ARCHITECTURE != NULL)
di.mach = TARGET_ARCHITECTURE->mach;
if (disassemble_from_exec == -1)
{
if (strcmp (target_shortname, "child") == 0
|| strcmp (target_shortname, "procfs") == 0
|| strcmp (target_shortname, "vxprocess") == 0
|| strstr (target_shortname, "threads") != NULL)
disassemble_from_exec = 0;
else
disassemble_from_exec = 1;
}
if (disassemble_from_exec)
di.read_memory_func = gdbtk_dis_asm_read_memory;
else
di.read_memory_func = dis_asm_read_memory;
if (mixed_source_and_assembly)
{
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);
if (!symtab || !symtab->linetable)
goto assembly_only;
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;
for (i = 0; i < nlines - 1 && le[i].pc < low; i++) ;
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;
if (le[i].line != 0)
{
mle[newlines].line = le[i].line;
}
else
{
if (newlines > 0)
mle[newlines].line = mle[newlines - 1].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 (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++;
}
if (out_of_order)
qsort (mle, newlines, sizeof (struct my_line_entry), compare_lines);
next_line = 0;
for (i = 0; i < newlines; i++)
{
if (mle[i].line >= next_line)
{
if (next_line != 0)
print_source_fn (clientData, symtab, next_line,
mle[i].line + 1);
else
print_source_fn (clientData, symtab, mle[i].line,
mle[i].line + 1);
next_line = mle[i].line + 1;
}
for (pc = mle[i].start_pc; pc < mle[i].end_pc; )
{
QUIT;
pc = print_asm_fn (clientData, pc, &di);
}
}
}
else
{
assembly_only:
for (pc = low; pc < high; )
{
QUIT;
pc = print_asm_fn (clientData, pc, &di);
}
}
return TCL_OK;
}
static int
gdbtk_dis_asm_read_memory (memaddr, myaddr, len, info)
bfd_vma memaddr;
bfd_byte *myaddr;
unsigned 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;
}
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_loc (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char *filename;
struct symtab_and_line sal;
struct symbol *sym;
char *fname;
CORE_ADDR pc;
if (objc == 1)
{
if (selected_frame && (selected_frame->pc != read_pc ()))
{
pc = selected_frame->pc;
sal = find_pc_line (selected_frame->pc,
selected_frame->next != NULL
&& !selected_frame->next->signal_handler_caller
&& !frame_in_dummy (selected_frame->next));
}
else
{
pc = read_pc ();
sal = find_pc_line (pc, 0);
}
}
else if (objc == 2)
{
struct symtabs_and_lines sals;
int nelts;
sals = decode_line_spec (Tcl_GetStringFromObj (objv[1], NULL), 1);
nelts = sals.nelts;
sal = sals.sals[0];
free (sals.sals);
if (sals.nelts != 1)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Ambiguous line spec", -1);
return TCL_ERROR;
}
resolve_sal_pc (&sal);
pc = sal.pc;
}
else
{
Tcl_SetStringObj (result_ptr->obj_ptr, "wrong # args", -1);
return TCL_ERROR;
}
if (sal.symtab)
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (sal.symtab->filename, -1));
else
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj ("", 0));
fname = pc_function_name (pc);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (fname, -1));
filename = symtab_to_filename (sal.symtab);
if (filename == NULL)
filename = "";
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (filename, -1));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (sal.line));
sprintf_append_element_to_obj (result_ptr->obj_ptr, "0x%s", paddr_nz (pc));
sprintf_append_element_to_obj (result_ptr->obj_ptr, "0x%s",
paddr_nz (stop_pc));
#ifdef PC_SOLIB
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (PC_SOLIB (pc), -1));
#else
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj ("", -1));
#endif
return TCL_OK;
}
static int
gdb_get_mem (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int size, asize, i, j, bc;
CORE_ADDR addr;
int nbytes, rnum, bpr;
long tmp;
char format, buff[128], aschar, *mbuf, *mptr, *cptr, *bptr;
struct type *val_type;
if (objc < 6 || objc > 7)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"addr format size bytes bytes_per_row ?ascii_char?",
-1);
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (interp, objv[3], &size) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
else if (size <= 0)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Invalid size, must be > 0", -1);
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (interp, objv[4], &nbytes) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
else if (nbytes <= 0)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"Invalid number of bytes, must be > 0",
-1);
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (interp, objv[5], &bpr) != TCL_OK)
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
else if (bpr <= 0)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"Invalid bytes per row, must be > 0", -1);
return TCL_ERROR;
}
if (Tcl_GetLongFromObj (interp, objv[1], &tmp) != TCL_OK)
return TCL_OK;
addr = (CORE_ADDR) tmp;
format = *(Tcl_GetStringFromObj (objv[2], NULL));
mbuf = (char *) xmalloc (nbytes + 32);
if (!mbuf)
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Out of memory.", -1);
return TCL_ERROR;
}
memset (mbuf, 0, nbytes + 32);
mptr = cptr = mbuf;
rnum = 0;
while (rnum < nbytes)
{
int error;
int num = target_read_memory_partial (addr + rnum, mbuf + rnum,
nbytes - rnum, &error);
if (num <= 0)
break;
rnum += num;
}
if (objc == 7)
aschar = *(Tcl_GetStringFromObj (objv[6], NULL));
else
aschar = 0;
switch (size)
{
case 1:
val_type = builtin_type_int8;
asize = 'b';
break;
case 2:
val_type = builtin_type_int16;
asize = 'h';
break;
case 4:
val_type = builtin_type_int32;
asize = 'w';
break;
case 8:
val_type = builtin_type_int64;
asize = 'g';
break;
default:
val_type = builtin_type_int8;
asize = 'b';
}
bc = 0;
bptr = &buff[0];
result_ptr->flags |= GDBTK_MAKES_LIST;
for (i = 0; i < nbytes; i += size)
{
if (i >= rnum)
{
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj ("N/A", 3));
if (aschar)
for (j = 0; j < size; j++)
*bptr++ = 'X';
}
else
{
print_scalar_formatted (mptr, val_type, format, asize, gdb_stdout);
if (aschar)
{
for (j = 0; j < size; j++)
{
*bptr = *cptr++;
if (*bptr < 32 || *bptr > 126)
*bptr = aschar;
bptr++;
}
}
}
mptr += size;
bc += size;
if (aschar && (bc >= bpr))
{
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (buff, bc));
bc = 0;
bptr = &buff[0];
}
}
result_ptr->flags &= ~GDBTK_MAKES_LIST;
free (mbuf);
return TCL_OK;
}
#define LTABLE_SIZE 20000
static int
gdb_loadfile (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char *file, *widget;
int linenumbers, ln, lnum, ltable_size;
FILE *fp;
char *ltable;
struct symtab *symtab;
struct linetable_entry *le;
long mtime = 0;
struct stat st;
char line[10000], line_num_buf[18];
int prefix_len_1, prefix_len_2, cur_prefix_len, widget_len;
char *text_argv[8];
Tcl_CmdInfo text_cmd;
if (objc != 4)
{
Tcl_WrongNumArgs(interp, 1, objv, "widget filename linenumbers");
return TCL_ERROR;
}
widget = Tcl_GetStringFromObj (objv[1], NULL);
if ( Tk_NameToWindow (interp, widget, Tk_MainWindow (interp)) == NULL)
{
return TCL_ERROR;
}
if (!Tcl_GetCommandInfo (interp, widget, &text_cmd))
{
Tcl_SetStringObj (result_ptr->obj_ptr, "Can't get widget command info",
-1);
return TCL_ERROR;
}
file = Tcl_GetStringFromObj (objv[2], NULL);
Tcl_GetBooleanFromObj (interp, objv[3], &linenumbers);
symtab = full_lookup_symtab (file);
if (!symtab)
{
Tcl_SetStringObj ( result_ptr->obj_ptr, "File not found in symtab", -1);
return TCL_ERROR;
}
file = symtab_to_filename ( symtab );
if ((fp = fopen ( file, "r" )) == NULL)
{
Tcl_SetStringObj ( result_ptr->obj_ptr, "Can't open file for reading",
-1);
return TCL_ERROR;
}
if (stat (file, &st) < 0)
{
catch_errors (perror_with_name_wrapper, "gdbtk: get time stamp", "",
RETURN_MASK_ALL);
return TCL_ERROR;
}
if (symtab && symtab->objfile && symtab->objfile->obfd)
mtime = bfd_get_mtime(symtab->objfile->obfd);
else if (exec_bfd)
mtime = bfd_get_mtime(exec_bfd);
if (mtime && mtime < st.st_mtime)
{
gdbtk_ignorable_warning("file_times",\
"Source file is more recent than executable.\n");
}
ltable_size = LTABLE_SIZE;
ltable = (char *)xmalloc (LTABLE_SIZE);
if (ltable == NULL)
{
Tcl_SetStringObj ( result_ptr->obj_ptr, "Out of memory.", -1);
fclose (fp);
return TCL_ERROR;
}
memset (ltable, 0, LTABLE_SIZE);
if (symtab->linetable && symtab->linetable->nitems)
{
le = symtab->linetable->item;
for (ln = symtab->linetable->nitems ;ln > 0; ln--, le++)
{
lnum = le->line >> 3;
if (lnum >= ltable_size)
{
char *new_ltable;
new_ltable = (char *)realloc (ltable, ltable_size*2);
memset (new_ltable + ltable_size, 0, ltable_size);
ltable_size *= 2;
if (new_ltable == NULL)
{
Tcl_SetStringObj ( result_ptr->obj_ptr, "Out of memory.",
-1);
free (ltable);
fclose (fp);
return TCL_ERROR;
}
ltable = new_ltable;
}
ltable[lnum] |= 1 << (le->line % 8);
}
}
ln = 1;
line[0] = '\t';
text_argv[0] = widget;
text_argv[1] = "insert";
text_argv[2] = "end";
text_argv[5] = line;
text_argv[6] = "source_tag";
text_argv[8] = NULL;
if (linenumbers)
{
int found_carriage_return = 1;
line_num_buf[1] = '\t';
text_argv[3] = line_num_buf;
while (fgets (line + 1, 9980, fp))
{
char *p;
if (found_carriage_return) {
char *p;
p = strrchr(line, '\0') - 2;
if (*p == '\r') {
*p = '\n';
*(p + 1) = '\0';
} else {
found_carriage_return = 0;
}
}
sprintf (line_num_buf+2, "%d", ln);
if (ltable[ln >> 3] & (1 << (ln % 8)))
{
line_num_buf[0] = '-';
text_argv[4] = "break_rgn_tag";
}
else
{
line_num_buf[0] = ' ';
text_argv[4] = "";
}
text_cmd.proc(text_cmd.clientData, interp, 7, text_argv);
ln++;
}
}
else
{
int found_carriage_return = 1;
while (fgets (line + 1, 9980, fp))
{
if (found_carriage_return) {
char *p;
p = strrchr(line, '\0') - 2;
if (*p == '\r') {
*p = '\n';
*(p + 1) = '\0';
} else {
found_carriage_return = 0;
}
}
if (ltable[ln >> 3] & (1 << (ln % 8)))
{
text_argv[3] = "- ";
text_argv[4] = "break_rgn_tag";
}
else
{
text_argv[3] = " ";
text_argv[4] = "";
}
text_cmd.proc(text_cmd.clientData, interp, 7, text_argv);
ln++;
}
}
free (ltable);
fclose (fp);
return TCL_OK;
}
static int
gdb_set_bp (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtab_and_line sal;
int line, ret, thread = -1;
struct breakpoint *b;
char buf[64], *typestr;
Tcl_DString cmd;
enum bpdisp disp;
if (objc != 4 && objc != 5)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"wrong number of args, should be \"filename line type [thread]\"", -1);
return TCL_ERROR;
}
sal.symtab = full_lookup_symtab (Tcl_GetStringFromObj (objv[1], NULL));
if (sal.symtab == NULL)
return TCL_ERROR;
if (Tcl_GetIntFromObj (interp, objv[2], &line) == TCL_ERROR)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
typestr = Tcl_GetStringFromObj (objv[3], NULL);
if (typestr == NULL)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (strncmp (typestr, "temp", 4) == 0)
disp = del;
else if (strncmp (typestr, "normal", 6) == 0)
disp = donttouch;
else
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"type must be \"temp\" or \"normal\"", -1);
return TCL_ERROR;
}
if (objc == 5)
{
if (Tcl_GetIntFromObj (interp, objv[4], &thread) == TCL_ERROR)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
}
sal.line = line;
if (!find_line_pc (sal.symtab, sal.line, &sal.pc))
return TCL_ERROR;
sal.section = find_pc_overlay (sal.pc);
b = set_raw_breakpoint (sal);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->type = bp_breakpoint;
b->disposition = disp;
b->thread = thread;
sprintf (buf, "%s:%d", basename (Tcl_GetStringFromObj (objv[1], NULL)),
line);
b->addr_string = strsave (buf);
Tcl_DStringInit (&cmd);
Tcl_DStringAppend (&cmd, "gdbtk_tcl_breakpoint create ", -1);
sprintf (buf, "%d", b->number);
Tcl_DStringAppendElement (&cmd, buf);
sprintf (buf, "0x%lx", (long) sal.pc);
Tcl_DStringAppendElement (&cmd, buf);
Tcl_DStringAppendElement (&cmd, Tcl_GetStringFromObj (objv[2], NULL));
Tcl_DStringAppendElement (&cmd, Tcl_GetStringFromObj (objv[1], NULL));
Tcl_DStringAppendElement (&cmd, bpdisp[b->disposition]);
sprintf (buf, "%d", b->enable);
Tcl_DStringAppendElement (&cmd, buf);
sprintf (buf, "%d", b->thread);
Tcl_DStringAppendElement (&cmd, buf);
ret = Tcl_Eval (interp, Tcl_DStringValue (&cmd));
Tcl_DStringFree (&cmd);
return ret;
}
static int
gdb_set_bp_addr (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtab_and_line sal;
int line, ret, thread = -1;
long addr;
struct breakpoint *b;
char *filename, *typestr, buf[64];
Tcl_DString cmd;
enum bpdisp disp;
if (objc != 4 && objc != 3)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"wrong number of args, should be \"address type [thread]\"", -1);
return TCL_ERROR;
}
if (Tcl_GetLongFromObj (interp, objv[1], &addr) == TCL_ERROR)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
typestr = Tcl_GetStringFromObj (objv[2], NULL);
if (typestr == NULL)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (strncmp (typestr, "temp", 4) == 0)
disp = del;
else if (strncmp (typestr, "normal", 6) == 0)
disp = donttouch;
else
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"type must be \"temp\" or \"normal\"", -1);
return TCL_ERROR;
}
if (objc == 4)
{
if (Tcl_GetIntFromObj (interp, objv[3], &thread) == TCL_ERROR)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
}
sal = find_pc_line (addr, 0);
sal.pc = addr;
b = set_raw_breakpoint (sal);
set_breakpoint_count (breakpoint_count + 1);
b->number = breakpoint_count;
b->type = bp_breakpoint;
b->disposition = disp;
b->thread = thread;
sprintf (buf, "*(0x%lx)", addr);
b->addr_string = strsave (buf);
Tcl_DStringInit (&cmd);
Tcl_DStringAppend (&cmd, "gdbtk_tcl_breakpoint create ", -1);
sprintf (buf, "%d", b->number);
Tcl_DStringAppendElement (&cmd, buf);
sprintf (buf, "0x%lx", addr);
Tcl_DStringAppendElement (&cmd, buf);
sprintf (buf, "%d", b->line_number);
Tcl_DStringAppendElement (&cmd, buf);
filename = symtab_to_filename (sal.symtab);
if (filename == NULL)
filename = "";
Tcl_DStringAppendElement (&cmd, filename);
Tcl_DStringAppendElement (&cmd, bpdisp[b->disposition]);
sprintf (buf, "%d", b->enable);
Tcl_DStringAppendElement (&cmd, buf);
sprintf (buf, "%d", b->thread);
Tcl_DStringAppendElement (&cmd, buf);
ret = Tcl_Eval (interp, Tcl_DStringValue (&cmd));
Tcl_DStringFree (&cmd);
return ret;
}
static int
gdb_find_bp_at_line (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtab *s;
int line;
struct breakpoint *b;
extern struct breakpoint *breakpoint_chain;
if (objc != 3)
{
Tcl_WrongNumArgs (interp, 1, objv, "filename line");
return TCL_ERROR;
}
s = full_lookup_symtab (Tcl_GetStringFromObj (objv[1], NULL));
if (s == NULL)
return TCL_ERROR;
if (Tcl_GetIntFromObj (interp, objv[2], &line) == TCL_ERROR)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
for (b = breakpoint_chain; b; b = b->next)
if (b->line_number == line && !strcmp (b->source_file, s->filename))
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (b->number));
return TCL_OK;
}
static int
gdb_find_bp_at_addr (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
long addr;
struct breakpoint *b;
extern struct breakpoint *breakpoint_chain;
if (objc != 2)
{
Tcl_WrongNumArgs (interp, 1, objv, "address");
return TCL_ERROR;
}
if (Tcl_GetLongFromObj (interp, objv[1], &addr) == TCL_ERROR)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
for (b = breakpoint_chain; b; b = b->next)
if (b->address == (CORE_ADDR) addr)
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (b->number));
return TCL_OK;
}
static int
gdb_get_breakpoint_info (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct symtab_and_line sal;
struct command_line *cmd;
int bpnum;
struct breakpoint *b;
extern struct breakpoint *breakpoint_chain;
char *funcname, *filename;
struct symbol *sym;
Tcl_Obj *new_obj;
if (objc != 2)
{
Tcl_SetStringObj (result_ptr->obj_ptr,
"wrong number of args, should be \"breakpoint\"", -1);
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (NULL, objv[1], &bpnum) != TCL_OK)
{
result_ptr->flags = GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
for (b = breakpoint_chain; b; b = b->next)
if (b->number == bpnum)
break;
if (!b || b->type != bp_breakpoint)
{
char err_buf[64];
sprintf (err_buf, "Breakpoint #%d does not exist.", bpnum);
Tcl_SetStringObj (result_ptr->obj_ptr, err_buf, -1);
return TCL_ERROR;
}
sal = find_pc_line (b->address, 0);
filename = symtab_to_filename (sal.symtab);
if (filename == NULL)
filename = "";
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (filename, -1));
funcname = pc_function_name (b->address);
new_obj = Tcl_NewStringObj (funcname, -1);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, new_obj);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (b->line_number));
sprintf_append_element_to_obj (result_ptr->obj_ptr, "0x%s",
paddr_nz (b->address));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (bptypes[b->type], -1));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewBooleanObj (b->enable == enabled));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (bpdisp[b->disposition], -1));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (b->ignore_count));
new_obj = Tcl_NewObj ();
for (cmd = b->commands; cmd; cmd = cmd->next)
Tcl_ListObjAppendElement (NULL, new_obj,
Tcl_NewStringObj (cmd->line, -1));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, new_obj);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewStringObj (b->cond_string, -1));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (b->thread));
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr,
Tcl_NewIntObj (b->hit_count));
return TCL_OK;
}
static int
gdb_get_breakpoint_list (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct breakpoint *b;
extern struct breakpoint *breakpoint_chain;
Tcl_Obj *new_obj;
if (objc != 1)
error ("wrong number of args, none are allowed");
for (b = breakpoint_chain; b; b = b->next)
if (b->type == bp_breakpoint)
{
new_obj = Tcl_NewIntObj (b->number);
Tcl_ListObjAppendElement (NULL, result_ptr->obj_ptr, new_obj);
}
return TCL_OK;
}
static int
gdb_stack (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
int start, count;
if (objc < 3)
{
Tcl_WrongNumArgs (interp, 1, objv, "start count");
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (NULL, objv[1], &start))
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (Tcl_GetIntFromObj (NULL, objv[2], &count))
{
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
if (target_has_stack)
{
gdb_result r;
struct frame_info *top;
struct frame_info *fi;
r = GDB_get_current_frame (&fi);
if (r != GDB_OK)
return TCL_OK;
while (fi != NULL)
{
top = fi;
r = GDB_get_prev_frame (fi, &fi);
if (r != GDB_OK)
fi = NULL;
}
start = -start;
r = GDB_find_relative_frame (top, &start, &top);
result_ptr->obj_ptr = Tcl_NewListObj (0, NULL);
if (r != GDB_OK)
return TCL_OK;
if (start == 0)
{
fi = top;
while (fi && count--)
{
get_frame_name (interp, result_ptr->obj_ptr, fi);
r = GDB_get_next_frame (fi, &fi);
if (r != GDB_OK)
break;
}
}
}
return TCL_OK;
}
static void
get_frame_name (interp, list, fi)
Tcl_Interp *interp;
Tcl_Obj *list;
struct frame_info *fi;
{
struct symtab_and_line sal;
struct symbol *func = NULL;
register char *funname = 0;
enum language funlang = language_unknown;
Tcl_Obj *objv[1];
if (frame_in_dummy (fi))
{
objv[0] = Tcl_NewStringObj ("<function called from gdb>\n", -1);
Tcl_ListObjAppendElement (interp, list, objv[0]);
return;
}
if (fi->signal_handler_caller)
{
objv[0] = Tcl_NewStringObj ("<signal handler called>\n", -1);
Tcl_ListObjAppendElement (interp, list, objv[0]);
return;
}
sal =
find_pc_line (fi->pc,
fi->next != NULL
&& !fi->next->signal_handler_caller
&& !frame_in_dummy (fi->next));
func = find_pc_function (fi->pc);
if (func)
{
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL
&& (SYMBOL_VALUE_ADDRESS (msymbol)
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
{
func = 0;
funname = GDBTK_SYMBOL_SOURCE_NAME (msymbol);
funlang = SYMBOL_LANGUAGE (msymbol);
}
else
{
funname = GDBTK_SYMBOL_SOURCE_NAME (func);
funlang = SYMBOL_LANGUAGE (func);
}
}
else
{
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL)
{
funname = GDBTK_SYMBOL_SOURCE_NAME (msymbol);
funlang = SYMBOL_LANGUAGE (msymbol);
}
}
if (sal.symtab)
{
char *name = NULL;
objv[0] = Tcl_NewStringObj (funname, -1);
Tcl_ListObjAppendElement (interp, list, objv[0]);
}
else
{
#if 0
if (fi->pc != sal.pc || !sal.symtab)
{
print_address_numeric (fi->pc, 1, gdb_stdout);
printf_filtered (" in ");
}
printf_symbol_filtered (gdb_stdout, funname ? funname : "??", funlang,
DMGL_ANSI);
#endif
objv[0] = Tcl_NewStringObj (funname != NULL ? funname : "??", -1);
#ifdef PC_LOAD_SEGMENT
if (!funname)
{
Tcl_AppendStringsToObj (objv[0], " from ", PC_LOAD_SEGMENT (fi->pc),
(char *) NULL);
}
#endif
#ifdef PC_SOLIB
if (!funname)
{
char *lib = PC_SOLIB (fi->pc);
if (lib)
{
Tcl_AppendStringsToObj (objv[0], " from ", lib, (char *) NULL);
}
}
#endif
Tcl_ListObjAppendElement (interp, list, objv[0]);
}
}
static int
gdb_selected_frame (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char frame[32];
if (selected_frame == NULL)
strcpy (frame, "");
else
sprintf (frame, "0x%s", paddr_nz (FRAME_FP (selected_frame)));
Tcl_SetStringObj (result_ptr->obj_ptr, frame, -1);
return TCL_OK;
}
static int
gdb_selected_block (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
char start[32];
char end[32];
if (selected_frame == NULL)
{
strcpy (start, "");
strcpy (end, "");
}
else
{
struct block *block;
block = get_frame_block (selected_frame);
sprintf (start, "0x%s", paddr_nz (BLOCK_START (block)));
sprintf (end, "0x%s", paddr_nz (BLOCK_END (block)));
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (start, -1));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (end, -1));
return TCL_OK;
}
static int
gdb_get_blocks (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct block *block;
int nsyms, i, junk;
struct symbol *sym;
CORE_ADDR pc;
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
if (selected_frame != NULL)
{
block = get_frame_block (selected_frame);
pc = get_frame_pc (selected_frame);
while (block != 0)
{
nsyms = BLOCK_NSYMS (block);
junk = 0;
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (block, i);
switch (SYMBOL_CLASS (sym))
{
default:
case LOC_UNDEF:
case LOC_CONST:
case LOC_TYPEDEF:
case LOC_LABEL:
case LOC_BLOCK:
case LOC_CONST_BYTES:
case LOC_UNRESOLVED:
case LOC_OPTIMIZED_OUT:
junk = 1;
break;
case LOC_ARG:
case LOC_REF_ARG:
case LOC_REGPARM:
case LOC_REGPARM_ADDR:
case LOC_LOCAL_ARG:
case LOC_BASEREG_ARG:
case LOC_LOCAL:
case LOC_BASEREG:
case LOC_STATIC:
case LOC_REGISTER:
junk = 0;
break;
}
}
if (!junk && pc < BLOCK_END (block))
{
char addr[32];
Tcl_Obj *elt = Tcl_NewListObj (0, NULL);
sprintf (addr, "0x%s", paddr_nz (BLOCK_START (block)));
Tcl_ListObjAppendElement (interp, elt,
Tcl_NewStringObj (addr, -1));
sprintf (addr, "0x%s", paddr_nz (BLOCK_END (block)));
Tcl_ListObjAppendElement (interp, elt,
Tcl_NewStringObj (addr, -1));
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr, elt);
}
if (BLOCK_FUNCTION (block))
break;
else
block = BLOCK_SUPERBLOCK (block);
}
}
return TCL_OK;
}
static int
gdb_block_vars (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
struct block *block;
int nsyms, i;
struct symbol *sym;
CORE_ADDR start, end;
if (objc < 3)
{
Tcl_WrongNumArgs (interp, 1, objv, "startAddr endAddr");
result_ptr->flags |= GDBTK_IN_TCL_RESULT;
return TCL_ERROR;
}
Tcl_SetListObj (result_ptr->obj_ptr, 0, NULL);
if (selected_frame == NULL)
return TCL_OK;
start = parse_and_eval_address (Tcl_GetStringFromObj (objv[1], NULL));
end = parse_and_eval_address (Tcl_GetStringFromObj (objv[2], NULL));
block = get_frame_block (selected_frame);
while (block != 0)
{
if (BLOCK_START (block) == start && BLOCK_END (block) == end)
{
nsyms = BLOCK_NSYMS (block);
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (block, i);
switch (SYMBOL_CLASS (sym))
{
case LOC_ARG:
case LOC_REF_ARG:
case LOC_REGPARM:
case LOC_REGPARM_ADDR:
case LOC_LOCAL_ARG:
case LOC_BASEREG_ARG:
case LOC_LOCAL:
case LOC_BASEREG:
case LOC_STATIC:
case LOC_REGISTER:
Tcl_ListObjAppendElement (interp, result_ptr->obj_ptr,
Tcl_NewStringObj (SYMBOL_NAME (sym),
-1));
break;
default:
break;
}
}
return TCL_OK;
}
else if (BLOCK_FUNCTION (block))
break;
else
block = BLOCK_SUPERBLOCK (block);
}
return TCL_OK;
}
static int
gdb_path_conv (clientData, interp, objc, objv)
ClientData clientData;
Tcl_Interp *interp;
int objc;
Tcl_Obj *CONST objv[];
{
if (objc != 2)
error ("wrong # args");
#ifdef __CYGWIN__
{
char pathname[256], *ptr;
cygwin32_conv_to_full_win32_path (Tcl_GetStringFromObj (objv[1], NULL),
pathname);
for (ptr = pathname; *ptr; ptr++)
{
if (*ptr == '\\')
*ptr = '/';
}
Tcl_SetStringObj (result_ptr->obj_ptr, pathname, -1);
}
#else
Tcl_SetStringObj (result_ptr->obj_ptr, Tcl_GetStringFromObj (objv[1], NULL),
-1);
#endif
return TCL_OK;
}
static int
perror_with_name_wrapper (args)
PTR args;
{
perror_with_name (args);
return 1;
}
static struct symtab *
full_lookup_symtab (file)
char *file;
{
struct symtab *st;
struct objfile *objfile;
char *bfile, *fullname;
struct partial_symtab *pt;
if (!file)
return NULL;
st = lookup_symtab (file);
if (st)
{
if (!st->fullname)
symtab_to_filename (st);
return st;
}
bfile = basename (file);
ALL_SYMTABS (objfile, st)
{
if (!strcmp (bfile, basename (st->filename)))
{
if (!st->fullname)
fullname = symtab_to_filename (st);
else
fullname = st->fullname;
if (!strcmp (file, fullname))
return st;
}
}
ALL_PSYMTABS (objfile, pt)
{
if (!strcmp (bfile, basename (pt->filename)))
{
st = PSYMTAB_TO_SYMTAB (pt);
if (st)
{
fullname = symtab_to_filename (st);
if (!strcmp (file, fullname))
return st;
}
}
}
return NULL;
}
char *
pc_function_name (pc)
CORE_ADDR pc;
{
struct symbol *sym;
char *funcname = NULL;
sym = find_pc_function (pc);
if (sym != NULL)
funcname = GDBTK_SYMBOL_SOURCE_NAME (sym);
else
{
struct minimal_symbol *msym = NULL;
msym = lookup_minimal_symbol_by_pc (pc);
if (msym != NULL)
funcname = GDBTK_SYMBOL_SOURCE_NAME (msym);
}
if (funcname == NULL)
funcname = "";
return funcname;
}
static void
setup_architecture_data ()
{
old_regs = xmalloc (REGISTER_BYTES + 1);
memset (old_regs, 0, REGISTER_BYTES + 1);
}