diff options
Diffstat (limited to 'gdb/target.c')
| -rw-r--r-- | gdb/target.c | 528 |
1 files changed, 508 insertions, 20 deletions
diff --git a/gdb/target.c b/gdb/target.c index 6abbd00..9368d58 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -84,24 +84,47 @@ unsigned target_struct_allocsize; /* The initial current target, so that there is always a semi-valid current target. */ -struct target_ops dummy_target = {"None", "None", "", - 0, 0, /* open, close */ - find_default_attach, 0, /* attach, detach */ - 0, 0, /* resume, wait */ - 0, 0, 0, /* registers */ - 0, 0, /* memory */ - 0, 0, /* bkpts */ - 0, 0, 0, 0, 0, /* terminal */ - 0, 0, /* kill, load */ - 0, /* lookup_symbol */ - find_default_create_inferior, /* create_inferior */ - 0, /* mourn_inferior */ - 0, /* can_run */ - 0, /* notice_signals */ - dummy_stratum, 0, /* stratum, next */ - 0, 0, 0, 0, 0, /* all mem, mem, stack, regs, exec */ - 0, 0, /* section pointers */ - OPS_MAGIC, +struct target_ops dummy_target = { + "None", /* to_shortname */ + "None", /* to_longname */ + "", /* to_doc */ + 0, /* to_open */ + 0, /* to_close */ + find_default_attach, /* to_attach */ + 0, /* to_detach */ + 0, /* to_resume */ + 0, /* to_wait */ + 0, /* to_fetch_registers */ + 0, /* to_store_registers */ + 0, /* to_prepare_to_store */ + 0, /* to_xfer_memory */ + 0, /* to_files_info */ + 0, /* to_insert_breakpoint */ + 0, /* to_remove_breakpoint */ + 0, /* to_terminal_init */ + 0, /* to_terminal_inferior */ + 0, /* to_terminal_ours_for_output */ + 0, /* to_terminal_ours */ + 0, /* to_terminal_info */ + 0, /* to_kill */ + 0, /* to_load */ + 0, /* to_lookup_symbol */ + find_default_create_inferior, /* to_create_inferior */ + 0, /* to_mourn_inferior */ + 0, /* to_can_run */ + 0, /* to_notice_signals */ + 0, /* to_thread_alive */ + 0, /* to_stop */ + dummy_stratum, /* to_stratum */ + 0, /* to_next */ + 0, /* to_next */ + 0, /* to_has_all_memory */ + 0, /* to_has_memory */ + 0, /* to_has_registers */ + 0, /* to_has_execution */ + 0, /* to_sections */ + 0, /* to_sections_end */ + OPS_MAGIC, /* to_magic */ }; /* Top of target stack. */ @@ -122,6 +145,15 @@ static struct cmd_list_element *targetlist = NULL; int attach_flag; +#ifdef MAINTENANCE_CMDS +/* Non-zero if we want to see trace of target level stuff. */ + +static int targetdebug = 0; + +static void setup_target_debug PARAMS ((void)); + +#endif + /* The user just typed 'target' without the name of a target. */ /* ARGSUSED */ @@ -300,6 +332,8 @@ cleanup_target (t) de_fault (to_mourn_inferior, (void (*)())noprocess); de_fault (to_can_run, return_zero); de_fault (to_notice_signals, (void (*)())ignore); + de_fault (to_thread_alive, (void (*)())ignore); + de_fault (to_stop, (void (*)())ignore); #undef de_fault } @@ -353,6 +387,8 @@ update_current_target () INHERIT (to_mourn_inferior, t); INHERIT (to_can_run, t); INHERIT (to_notice_signals, t); + INHERIT (to_thread_alive, t); + INHERIT (to_stop, t); INHERIT (to_stratum, t); INHERIT (DONT_USE, t); INHERIT (to_has_all_memory, t); @@ -433,6 +469,12 @@ push_target (t) update_current_target (); cleanup_target (¤t_target); /* Fill in the gaps */ + +#ifdef MAINTENANCE_CMDS + if (targetdebug) + setup_target_debug (); +#endif + return prev != 0; } @@ -806,7 +848,7 @@ find_default_run_target (do_mesg) for (t = target_structs; t < target_structs + target_struct_size; ++t) { - if (target_can_run(*t)) + if ((*t)->to_can_run && target_can_run(*t)) { runable = *t; ++count; @@ -951,6 +993,39 @@ static struct { {"SIGMSG", "Monitor mode data available"}, {"SIGSOUND", "Sound completed"}, {"SIGSAK", "Secure attention"}, + {"SIGPRIO", "SIGPRIO"}, + {"SIG33", "Real-time event 33"}, + {"SIG34", "Real-time event 34"}, + {"SIG35", "Real-time event 35"}, + {"SIG36", "Real-time event 36"}, + {"SIG37", "Real-time event 37"}, + {"SIG38", "Real-time event 38"}, + {"SIG39", "Real-time event 39"}, + {"SIG40", "Real-time event 40"}, + {"SIG41", "Real-time event 41"}, + {"SIG42", "Real-time event 42"}, + {"SIG43", "Real-time event 43"}, + {"SIG44", "Real-time event 44"}, + {"SIG45", "Real-time event 45"}, + {"SIG46", "Real-time event 46"}, + {"SIG47", "Real-time event 47"}, + {"SIG48", "Real-time event 48"}, + {"SIG49", "Real-time event 49"}, + {"SIG50", "Real-time event 50"}, + {"SIG51", "Real-time event 51"}, + {"SIG52", "Real-time event 52"}, + {"SIG53", "Real-time event 53"}, + {"SIG54", "Real-time event 54"}, + {"SIG55", "Real-time event 55"}, + {"SIG56", "Real-time event 56"}, + {"SIG57", "Real-time event 57"}, + {"SIG58", "Real-time event 58"}, + {"SIG59", "Real-time event 59"}, + {"SIG60", "Real-time event 60"}, + {"SIG61", "Real-time event 61"}, + {"SIG62", "Real-time event 62"}, + {"SIG63", "Real-time event 63"}, + {NULL, "Unknown signal"}, {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"}, @@ -1145,6 +1220,14 @@ target_signal_from_host (hostsig) #if defined (SIGSAK) if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK; #endif +#if defined (SIGPRIO) + if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO; +#endif +#if defined (REALTIME_LO) + if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI) + return (enum target_signal) + (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33); +#endif return TARGET_SIGNAL_UNKNOWN; } @@ -1290,7 +1373,20 @@ target_signal_to_host (oursig) #if defined (SIGSAK) case TARGET_SIGNAL_SAK: return SIGSAK; #endif +#if defined (SIGPRIO) + case TARGET_SIGNAL_PRIO: return SIGPRIO; +#endif default: +#if defined (REALTIME_LO) + if (oursig >= TARGET_SIGNAL_REALTIME_33 + && oursig <= TARGET_SIGNAL_REALTIME_63) + { + int retsig = + (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + REALTIME_LO; + if (retsig < REALTIME_HI) + return retsig; + } +#endif /* The user might be trying to do "signal SIGSAK" where this system doesn't have SIGSAK. */ warning ("Signal %s does not exist on this system.\n", @@ -1330,7 +1426,24 @@ store_waitstatus (ourstatus, hoststatus) ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus)); } } + +/* In some circumstances we allow a command to specify a numeric + signal. The idea is to keep these circumstances limited so that + users (and scripts) develop portable habits. For comparison, + POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a + numeric signal at all is obscelescent. We are slightly more + lenient and allow 1-15 which should match host signal numbers on + most systems. Use of symbolic signal names is strongly encouraged. */ +enum target_signal +target_signal_from_command (num) + int num; +{ + if (num >= 1 && num <= 15) + return (enum target_signal)num; + error ("Only signals 1-15 are valid as numeric signals.\n\ +Use \"info signals\" for a list of symbolic signals."); +} /* Returns zero to leave the inferior alone, one to interrupt it. */ int (*target_activity_function) PARAMS ((void)); @@ -1345,11 +1458,377 @@ normal_pid_to_str (pid) { static char buf[30]; - sprintf (buf, "process %d", pid); + if (STREQ (current_target.to_shortname, "remote")) + sprintf (buf, "thread %d", pid); + else + sprintf (buf, "process %d", pid); return buf; } +#ifdef MAINTENANCE_CMDS +static struct target_ops debug_target; + +static void +debug_to_open (args, from_tty) + char *args; + int from_tty; +{ + debug_target.to_open (args, from_tty); + + fprintf_unfiltered (stderr, "target_open (%s, %d)\n", args, from_tty); +} + +static void +debug_to_close (quitting) + int quitting; +{ + debug_target.to_close (quitting); + + fprintf_unfiltered (stderr, "target_close (%d)\n", quitting); +} + +static void +debug_to_attach (args, from_tty) + char *args; + int from_tty; +{ + debug_target.to_attach (args, from_tty); + + fprintf_unfiltered (stderr, "target_attach (%s, %d)\n", args, from_tty); +} + +static void +debug_to_detach (args, from_tty) + char *args; + int from_tty; +{ + debug_target.to_detach (args, from_tty); + + fprintf_unfiltered (stderr, "target_detach (%s, %d)\n", args, from_tty); +} + +static void +debug_to_resume (pid, step, siggnal) + int pid; + int step; + enum target_signal siggnal; +{ + debug_target.to_resume (pid, step, siggnal); + + fprintf_unfiltered (stderr, "target_resume (%d, %s, %s)\n", pid, + step ? "step" : "continue", + target_signal_to_name (siggnal)); +} + +static int +debug_to_wait (pid, status) + int pid; + struct target_waitstatus *status; +{ + int retval; + + retval = debug_target.to_wait (pid, status); + + fprintf_unfiltered (stderr, "target_wait (%d, status) = %d, ", pid, retval); + fprintf_unfiltered (stderr, "status->kind = "); + switch (status->kind) + { + case TARGET_WAITKIND_EXITED: + fprintf_unfiltered (stderr, "exited, status = %d\n", status->value.integer); + break; + case TARGET_WAITKIND_STOPPED: + fprintf_unfiltered (stderr, "stopped, signal = %s\n", + target_signal_to_name (status->value.sig)); + break; + case TARGET_WAITKIND_SIGNALLED: + fprintf_unfiltered (stderr, "signalled, signal = %s\n", + target_signal_to_name (status->value.sig)); + break; + case TARGET_WAITKIND_LOADED: + fprintf_unfiltered (stderr, "loaded\n"); + break; + case TARGET_WAITKIND_SPURIOUS: + fprintf_unfiltered (stderr, "spurious\n"); + break; + default: + fprintf_unfiltered (stderr, "unknown???\n"); + break; + } + + return retval; +} + +static void +debug_to_fetch_registers (regno) + int regno; +{ + debug_target.to_fetch_registers (regno); + + fprintf_unfiltered (stderr, "target_fetch_registers (%s)", + regno != -1 ? reg_names[regno] : "-1"); + if (regno != -1) + fprintf_unfiltered (stderr, " = 0x%x %d", read_register (regno), + read_register (regno)); + fprintf_unfiltered (stderr, "\n"); +} + +static void +debug_to_store_registers (regno) + int regno; +{ + debug_target.to_store_registers (regno); + + if (regno >= 0 && regno < NUM_REGS) + fprintf_unfiltered (stderr, "target_store_registers (%s) = 0x%x %d\n", + reg_names[regno], read_register (regno), + read_register (regno)); + else + fprintf_unfiltered (stderr, "target_store_registers (%d)\n", regno); +} + +static void +debug_to_prepare_to_store () +{ + debug_target.to_prepare_to_store (); + + fprintf_unfiltered (stderr, "target_prepare_to_store ()\n"); +} + +static int +debug_to_xfer_memory (memaddr, myaddr, len, write, target) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; + struct target_ops *target; +{ + int retval; + + retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target); + + fprintf_unfiltered (stderr, "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d", + memaddr, len, write ? "write" : "read", retval); + + if (retval > 0) + { + int i; + + fputs_unfiltered (", bytes =", gdb_stderr); + for (i = 0; i < retval; i++) + fprintf_unfiltered (stderr, " %02x", myaddr[i] & 0xff); + } + + fputc_unfiltered ('\n', gdb_stderr); + + return retval; +} + +static void +debug_to_files_info (target) + struct target_ops *target; +{ + debug_target.to_files_info (target); + + fprintf_unfiltered (stderr, "target_files_info (xxx)\n"); +} + +static int +debug_to_insert_breakpoint (addr, save) + CORE_ADDR addr; + char *save; +{ + int retval; + + retval = debug_target.to_insert_breakpoint (addr, save); + + fprintf_unfiltered (stderr, "target_insert_breakpoint (0x%x, xxx) = %d\n", + addr, retval); + return retval; +} + +static int +debug_to_remove_breakpoint (addr, save) + CORE_ADDR addr; + char *save; +{ + int retval; + + retval = debug_target.to_remove_breakpoint (addr, save); + + fprintf_unfiltered (stderr, "target_remove_breakpoint (0x%x, xxx) = %d\n", + addr, retval); + return retval; +} + +static void +debug_to_terminal_init () +{ + debug_target.to_terminal_init (); + + fprintf_unfiltered (stderr, "target_terminal_init ()\n"); +} + +static void +debug_to_terminal_inferior () +{ + debug_target.to_terminal_inferior (); + + fprintf_unfiltered (stderr, "target_terminal_inferior ()\n"); +} + +static void +debug_to_terminal_ours_for_output () +{ + debug_target.to_terminal_ours_for_output (); + + fprintf_unfiltered (stderr, "target_terminal_ours_for_output ()\n"); +} + +static void +debug_to_terminal_ours () +{ + debug_target.to_terminal_ours (); + + fprintf_unfiltered (stderr, "target_terminal_ours ()\n"); +} + +static void +debug_to_terminal_info (arg, from_tty) + char *arg; + int from_tty; +{ + debug_target.to_terminal_info (arg, from_tty); + + fprintf_unfiltered (stderr, "target_terminal_info (%s, %d)\n", arg, + from_tty); +} + +static void +debug_to_kill () +{ + debug_target.to_kill (); + + fprintf_unfiltered (stderr, "target_kill ()\n"); +} + +static void +debug_to_load (args, from_tty) + char *args; + int from_tty; +{ + debug_target.to_load (args, from_tty); + + fprintf_unfiltered (stderr, "target_load (%s, %d)\n", args, from_tty); +} + +static int +debug_to_lookup_symbol (name, addrp) + char *name; + CORE_ADDR *addrp; +{ + int retval; + + retval = debug_target.to_lookup_symbol (name, addrp); + + fprintf_unfiltered (stderr, "target_lookup_symbol (%s, xxx)\n", name); + + return retval; +} + +static void +debug_to_create_inferior (exec_file, args, env) + char *exec_file; + char *args; + char **env; +{ + debug_target.to_create_inferior (exec_file, args, env); + + fprintf_unfiltered (stderr, "target_create_inferior (%s, %s, xxx)\n", + exec_file, args); +} + +static void +debug_to_mourn_inferior () +{ + debug_target.to_mourn_inferior (); + + fprintf_unfiltered (stderr, "target_mourn_inferior ()\n"); +} + +static int +debug_to_can_run () +{ + int retval; + + retval = debug_target.to_can_run (); + + fprintf_unfiltered (stderr, "target_can_run () = %d\n", retval); + + return retval; +} + +static void +debug_to_notice_signals (pid) + int pid; +{ + debug_target.to_notice_signals (pid); + + fprintf_unfiltered (stderr, "target_notice_signals (%d)\n", pid); +} + +static void +debug_to_thread_alive (pid) + int pid; +{ + debug_target.to_thread_alive (pid); + + fprintf_unfiltered (stderr, "target_thread_alive (%d)\n", pid); +} + +static void +debug_to_stop () +{ + debug_target.to_stop (); + + fprintf_unfiltered (stderr, "target_stop ()\n"); +} + +static void +setup_target_debug () +{ + memcpy (&debug_target, ¤t_target, sizeof debug_target); + + current_target.to_open = debug_to_open; + current_target.to_close = debug_to_close; + current_target.to_attach = debug_to_attach; + current_target.to_detach = debug_to_detach; + current_target.to_resume = debug_to_resume; + current_target.to_wait = debug_to_wait; + current_target.to_fetch_registers = debug_to_fetch_registers; + current_target.to_store_registers = debug_to_store_registers; + current_target.to_prepare_to_store = debug_to_prepare_to_store; + current_target.to_xfer_memory = debug_to_xfer_memory; + current_target.to_files_info = debug_to_files_info; + current_target.to_insert_breakpoint = debug_to_insert_breakpoint; + current_target.to_remove_breakpoint = debug_to_remove_breakpoint; + current_target.to_terminal_init = debug_to_terminal_init; + current_target.to_terminal_inferior = debug_to_terminal_inferior; + current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output; + current_target.to_terminal_ours = debug_to_terminal_ours; + current_target.to_terminal_info = debug_to_terminal_info; + current_target.to_kill = debug_to_kill; + current_target.to_load = debug_to_load; + current_target.to_lookup_symbol = debug_to_lookup_symbol; + current_target.to_create_inferior = debug_to_create_inferior; + current_target.to_mourn_inferior = debug_to_mourn_inferior; + current_target.to_can_run = debug_to_can_run; + current_target.to_notice_signals = debug_to_notice_signals; + current_target.to_thread_alive = debug_to_thread_alive; + current_target.to_stop = debug_to_stop; +} +#endif /* MAINTENANCE_CMDS */ + static char targ_desc[] = "Names of targets and files being debugged.\n\ Shows the entire stack of targets currently in use (including the exec-file,\n\ @@ -1363,6 +1842,15 @@ initialize_targets () add_info ("target", target_info, targ_desc); add_info ("files", target_info, targ_desc); +#ifdef MAINTENANCE_CMDS + add_show_from_set ( + add_set_cmd ("targetdebug", class_maintenance, var_zinteger, + (char *)&targetdebug, + "Set target debugging.\n\ +When non-zero, target debugging is enabled.", &setlist), + &showlist); +#endif + if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC")) abort (); } |