X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftarget.c;h=af94f48279abaa5291435537a918fd5fd7f4b035;hb=32b40af94e919e235c21486110311647cbeecf2e;hp=91756c874507434808bf912ef416e75900b93f29;hpb=f0f9ff9530992cb86c7022310af223b2721117d1;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.c b/gdb/target.c index 91756c8745..af94f48279 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -1,6 +1,6 @@ /* Select target systems and architectures at runtime for GDB. - Copyright (C) 1990-2014 Free Software Foundation, Inc. + Copyright (C) 1990-2015 Free Software Foundation, Inc. Contributed by Cygnus Support. @@ -20,8 +20,6 @@ along with this program. If not, see . */ #include "defs.h" -#include -#include #include "target.h" #include "target-dcache.h" #include "gdbcmd.h" @@ -34,9 +32,7 @@ #include "dcache.h" #include #include "regcache.h" -#include "gdb_assert.h" #include "gdbcore.h" -#include "exceptions.h" #include "target-descriptions.h" #include "gdbthread.h" #include "solib.h" @@ -46,6 +42,7 @@ #include "gdb/fileio.h" #include "agent.h" #include "auxv.h" +#include "target-debug.h" static void target_info (char *, int); @@ -108,82 +105,18 @@ static char *default_pid_to_str (struct target_ops *ops, ptid_t ptid); static enum exec_direction_kind default_execution_direction (struct target_ops *self); -static CORE_ADDR default_target_decr_pc_after_break (struct target_ops *ops, - struct gdbarch *gdbarch); +static struct target_ops debug_target; #include "target-delegates.c" static void init_dummy_target (void); -static struct target_ops debug_target; - -static void debug_to_open (char *, int); - -static void debug_to_prepare_to_store (struct target_ops *self, - struct regcache *); - -static void debug_to_files_info (struct target_ops *); - -static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *, - struct bp_target_info *); - -static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *, - struct bp_target_info *); - -static int debug_to_can_use_hw_breakpoint (struct target_ops *self, - int, int, int); - -static int debug_to_insert_hw_breakpoint (struct target_ops *self, - struct gdbarch *, - struct bp_target_info *); - -static int debug_to_remove_hw_breakpoint (struct target_ops *self, - struct gdbarch *, - struct bp_target_info *); - -static int debug_to_insert_watchpoint (struct target_ops *self, - CORE_ADDR, int, int, - struct expression *); - -static int debug_to_remove_watchpoint (struct target_ops *self, - CORE_ADDR, int, int, - struct expression *); - -static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *); - -static int debug_to_watchpoint_addr_within_range (struct target_ops *, - CORE_ADDR, CORE_ADDR, int); - -static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self, - CORE_ADDR, int); - -static int debug_to_can_accel_watchpoint_condition (struct target_ops *self, - CORE_ADDR, int, int, - struct expression *); +static void update_current_target (void); -static void debug_to_terminal_init (struct target_ops *self); - -static void debug_to_terminal_inferior (struct target_ops *self); - -static void debug_to_terminal_ours_for_output (struct target_ops *self); - -static void debug_to_terminal_save_ours (struct target_ops *self); - -static void debug_to_terminal_ours (struct target_ops *self); - -static void debug_to_load (struct target_ops *self, const char *, int); - -static int debug_to_can_run (struct target_ops *self); - -static void debug_to_stop (struct target_ops *self, ptid_t); - -/* Pointer to array of target architecture structures; the size of the - array; the current index into the array; the allocated size of the - array. */ -struct target_ops **target_structs; -unsigned target_struct_size; -unsigned target_struct_allocsize; -#define DEFAULT_ALLOCSIZE 10 +/* Vector of existing target structures. */ +typedef struct target_ops *target_ops_p; +DEF_VEC_P (target_ops_p); +static VEC (target_ops_p) *target_structs; /* The initial current target, so that there is always a semi-valid current target. */ @@ -232,6 +165,13 @@ int may_stop = 1; /* Non-zero if we want to see trace of target level stuff. */ static unsigned int targetdebug = 0; + +static void +set_targetdebug (char *args, int from_tty, struct cmd_list_element *c) +{ + update_current_target (); +} + static void show_targetdebug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) @@ -402,6 +342,24 @@ complete_target_initialization (struct target_ops *t) install_delegators (t); } +/* This is used to implement the various target commands. */ + +static void +open_target (char *args, int from_tty, struct cmd_list_element *command) +{ + struct target_ops *ops = get_cmd_context (command); + + if (targetdebug) + fprintf_unfiltered (gdb_stdlog, "-> %s->to_open (...)\n", + ops->to_shortname); + + ops->to_open (args, from_tty); + + if (targetdebug) + fprintf_unfiltered (gdb_stdlog, "<- %s->to_open (%s, %d)\n", + ops->to_shortname, args, from_tty); +} + /* Add possible target architecture T to the list and add a new command 'target T->to_shortname'. Set COMPLETER as the command's completer if not NULL. */ @@ -414,20 +372,7 @@ add_target_with_completer (struct target_ops *t, complete_target_initialization (t); - if (!target_structs) - { - target_struct_allocsize = DEFAULT_ALLOCSIZE; - target_structs = (struct target_ops **) xmalloc - (target_struct_allocsize * sizeof (*target_structs)); - } - if (target_struct_size >= target_struct_allocsize) - { - target_struct_allocsize *= 2; - target_structs = (struct target_ops **) - xrealloc ((char *) target_structs, - target_struct_allocsize * sizeof (*target_structs)); - } - target_structs[target_struct_size++] = t; + VEC_safe_push (target_ops_p, target_structs, t); if (targetlist == NULL) add_prefix_cmd ("target", class_run, target_command, _("\ @@ -437,8 +382,9 @@ Remaining arguments are interpreted by the target protocol. For more\n\ information on the arguments for a particular protocol, type\n\ `help target ' followed by the protocol name."), &targetlist, "target ", 0, &cmdlist); - c = add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, - &targetlist); + c = add_cmd (t->to_shortname, no_class, NULL, t->to_doc, &targetlist); + set_cmd_sfunc (c, open_target); + set_cmd_context (c, t); if (completer != NULL) set_cmd_completer (c, completer); } @@ -461,7 +407,9 @@ add_deprecated_target_alias (struct target_ops *t, char *alias) /* If we use add_alias_cmd, here, we do not get the deprecated warning, see PR cli/15104. */ - c = add_cmd (alias, no_class, t->to_open, t->to_doc, &targetlist); + c = add_cmd (alias, no_class, NULL, t->to_doc, &targetlist); + set_cmd_sfunc (c, open_target); + set_cmd_context (c, t); alt = xstrprintf ("target %s", t->to_shortname); deprecate_cmd (c, alt); } @@ -471,9 +419,6 @@ add_deprecated_target_alias (struct target_ops *t, char *alias) void target_kill (void) { - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_kill ()\n"); - current_target.to_kill (¤t_target); } @@ -484,6 +429,43 @@ target_load (const char *arg, int from_tty) (*current_target.to_load) (¤t_target, arg, from_tty); } +/* Possible terminal states. */ + +enum terminal_state + { + /* The inferior's terminal settings are in effect. */ + terminal_is_inferior = 0, + + /* Some of our terminal settings are in effect, enough to get + proper output. */ + terminal_is_ours_for_output = 1, + + /* Our terminal settings are in effect, for output and input. */ + terminal_is_ours = 2 + }; + +static enum terminal_state terminal_state; + +/* See target.h. */ + +void +target_terminal_init (void) +{ + (*current_target.to_terminal_init) (¤t_target); + + terminal_state = terminal_is_ours; +} + +/* See target.h. */ + +int +target_terminal_is_inferior (void) +{ + return (terminal_state == terminal_is_inferior); +} + +/* See target.h. */ + void target_terminal_inferior (void) { @@ -494,9 +476,87 @@ target_terminal_inferior (void) if (target_can_async_p () && !sync_execution) return; + if (terminal_state == terminal_is_inferior) + return; + /* If GDB is resuming the inferior in the foreground, install inferior's terminal modes. */ (*current_target.to_terminal_inferior) (¤t_target); + terminal_state = terminal_is_inferior; +} + +/* See target.h. */ + +void +target_terminal_ours (void) +{ + if (terminal_state == terminal_is_ours) + return; + + (*current_target.to_terminal_ours) (¤t_target); + terminal_state = terminal_is_ours; +} + +/* See target.h. */ + +void +target_terminal_ours_for_output (void) +{ + if (terminal_state != terminal_is_inferior) + return; + (*current_target.to_terminal_ours_for_output) (¤t_target); + terminal_state = terminal_is_ours_for_output; +} + +/* See target.h. */ + +int +target_supports_terminal_ours (void) +{ + struct target_ops *t; + + for (t = current_target.beneath; t != NULL; t = t->beneath) + { + if (t->to_terminal_ours != delegate_terminal_ours + && t->to_terminal_ours != tdefault_terminal_ours) + return 1; + } + + return 0; +} + +/* Restore the terminal to its previous state (helper for + make_cleanup_restore_target_terminal). */ + +static void +cleanup_restore_target_terminal (void *arg) +{ + enum terminal_state *previous_state = arg; + + switch (*previous_state) + { + case terminal_is_ours: + target_terminal_ours (); + break; + case terminal_is_ours_for_output: + target_terminal_ours_for_output (); + break; + case terminal_is_inferior: + target_terminal_inferior (); + break; + } +} + +/* See target.h. */ + +struct cleanup * +make_cleanup_restore_target_terminal (void) +{ + enum terminal_state *ts = xmalloc (sizeof (*ts)); + + *ts = terminal_state; + + return make_cleanup_dtor (cleanup_restore_target_terminal, ts, xfree); } static void @@ -714,7 +774,7 @@ pop_all_targets (void) int target_is_pushed (struct target_ops *t) { - struct target_ops **cur; + struct target_ops *cur; /* Check magic number. If wrong, it probably means someone changed the struct definition, but not all the places that initialize one. */ @@ -727,8 +787,8 @@ target_is_pushed (struct target_ops *t) _("failed internal consistency check")); } - for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath) - if (*cur == t) + for (cur = target_stack; cur != NULL; cur = cur->beneath) + if (cur == t) return 1; return 0; @@ -754,9 +814,8 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset) if (gdbarch_fetch_tls_load_module_address_p (target_gdbarch ())) { ptid_t ptid = inferior_ptid; - volatile struct gdb_exception ex; - TRY_CATCH (ex, RETURN_MASK_ALL) + TRY { CORE_ADDR lm_addr; @@ -769,7 +828,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset) } /* If an error occurred, print TLS related messages here. Otherwise, throw the error to some higher catcher. */ - if (ex.reason < 0) + CATCH (ex, RETURN_MASK_ALL) { int objfile_is_library = (objfile->flags & OBJF_SHARED); @@ -818,6 +877,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset) break; } } + END_CATCH } /* It wouldn't be wrong here to try a gdbarch method, too; finding TLS is an ABI-specific thing. But we don't do that yet. */ @@ -921,9 +981,6 @@ done: struct target_section_table * target_get_section_table (struct target_ops *target) { - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n"); - return (*target->to_get_section_table) (target); } @@ -946,6 +1003,59 @@ target_section_by_addr (struct target_ops *target, CORE_ADDR addr) return NULL; } + +/* Helper for the memory xfer routines. Checks the attributes of the + memory region of MEMADDR against the read or write being attempted. + If the access is permitted returns true, otherwise returns false. + REGION_P is an optional output parameter. If not-NULL, it is + filled with a pointer to the memory region of MEMADDR. REG_LEN + returns LEN trimmed to the end of the region. This is how much the + caller can continue requesting, if the access is permitted. A + single xfer request must not straddle memory region boundaries. */ + +static int +memory_xfer_check_region (gdb_byte *readbuf, const gdb_byte *writebuf, + ULONGEST memaddr, ULONGEST len, ULONGEST *reg_len, + struct mem_region **region_p) +{ + struct mem_region *region; + + region = lookup_mem_region (memaddr); + + if (region_p != NULL) + *region_p = region; + + switch (region->attrib.mode) + { + case MEM_RO: + if (writebuf != NULL) + return 0; + break; + + case MEM_WO: + if (readbuf != NULL) + return 0; + break; + + case MEM_FLASH: + /* We only support writing to flash during "load" for now. */ + if (writebuf != NULL) + error (_("Writing to flash memory forbidden in this context")); + break; + + case MEM_NONE: + return 0; + } + + /* region->hi == 0 means there's no upper bound. */ + if (memaddr + len < region->hi || region->hi == 0) + *reg_len = len; + else + *reg_len = region->hi - memaddr; + + return 1; +} + /* Read memory from more than one valid target. A core file, for instance, could have some of memory but delegate other bits to the target below it. So, we must manually try all targets. */ @@ -1007,7 +1117,7 @@ memory_xfer_partial_1 (struct target_ops *ops, enum target_object object, ULONGEST len, ULONGEST *xfered_len) { enum target_xfer_status res; - int reg_len; + ULONGEST reg_len; struct mem_region *region; struct inferior *inf; @@ -1054,37 +1164,13 @@ memory_xfer_partial_1 (struct target_ops *ops, enum target_object object, } /* Try GDB's internal data cache. */ - region = lookup_mem_region (memaddr); - /* region->hi == 0 means there's no upper bound. */ - if (memaddr + len < region->hi || region->hi == 0) - reg_len = len; - else - reg_len = region->hi - memaddr; - - switch (region->attrib.mode) - { - case MEM_RO: - if (writebuf != NULL) - return TARGET_XFER_E_IO; - break; - - case MEM_WO: - if (readbuf != NULL) - return TARGET_XFER_E_IO; - break; - - case MEM_FLASH: - /* We only support writing to flash during "load" for now. */ - if (writebuf != NULL) - error (_("Writing to flash memory forbidden in this context")); - break; - case MEM_NONE: - return TARGET_XFER_E_IO; - } + if (!memory_xfer_check_region (readbuf, writebuf, memaddr, len, ®_len, + ®ion)) + return TARGET_XFER_E_IO; if (!ptid_equal (inferior_ptid, null_ptid)) - inf = find_inferior_pid (ptid_get_pid (inferior_ptid)); + inf = find_inferior_ptid (inferior_ptid); else inf = NULL; @@ -1221,6 +1307,16 @@ target_xfer_partial (struct target_ops *ops, writebuf, offset, len, xfered_len); else if (object == TARGET_OBJECT_RAW_MEMORY) { + /* Skip/avoid accessing the target if the memory region + attributes block the access. Check this here instead of in + raw_memory_xfer_partial as otherwise we'd end up checking + this twice in the case of the memory_xfer_partial path is + taken; once before checking the dcache, and another in the + tail call to raw_memory_xfer_partial. */ + if (!memory_xfer_check_region (readbuf, writebuf, offset, len, &len, + NULL)) + return TARGET_XFER_E_IO; + /* Request the normal memory object from other layers. */ retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len, xfered_len); @@ -1306,6 +1402,22 @@ target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len) return TARGET_XFER_E_IO; } +/* See target/target.h. */ + +int +target_read_uint32 (CORE_ADDR memaddr, uint32_t *result) +{ + gdb_byte buf[4]; + int r; + + r = target_read_memory (memaddr, buf, sizeof buf); + if (r != 0) + return r; + *result = extract_unsigned_integer (buf, sizeof buf, + gdbarch_byte_order (target_gdbarch ())); + return 0; +} + /* Like target_read_memory, but specify explicitly that this is a read from the target's raw memory. That is, this read bypasses the dcache, breakpoint shadowing, etc. */ @@ -1398,9 +1510,6 @@ target_memory_map (void) int ix; struct target_ops *t; - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n"); - result = current_target.to_memory_map (¤t_target); if (result == NULL) return NULL; @@ -1432,17 +1541,12 @@ target_memory_map (void) void target_flash_erase (ULONGEST address, LONGEST length) { - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n", - hex_string (address), phex (length, 0)); current_target.to_flash_erase (¤t_target, address, length); } void target_flash_done (void) { - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_flash_done\n"); current_target.to_flash_done (¤t_target); } @@ -2083,9 +2187,6 @@ target_detach (const char *args, int from_tty) prepare_for_detach (); current_target.to_detach (¤t_target, args, from_tty); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", - args, from_tty); } void @@ -2096,36 +2197,13 @@ target_disconnect (const char *args, int from_tty) disconnecting. */ remove_breakpoints (); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n", - args, from_tty); current_target.to_disconnect (¤t_target, args, from_tty); } ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status, int options) { - struct target_ops *t; - ptid_t retval = (current_target.to_wait) (¤t_target, ptid, - status, options); - - if (targetdebug) - { - char *status_string; - char *options_string; - - status_string = target_waitstatus_to_string (status); - options_string = target_options_to_string (options); - fprintf_unfiltered (gdb_stdlog, - "target_wait (%d, status, options={%s})" - " = %d, %s\n", - ptid_get_pid (ptid), options_string, - ptid_get_pid (retval), status_string); - xfree (status_string); - xfree (options_string); - } - - return retval; + return (current_target.to_wait) (¤t_target, ptid, status, options); } char * @@ -2148,11 +2226,6 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal) target_dcache_invalidate (); current_target.to_resume (¤t_target, ptid, step, signal); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", - ptid_get_pid (ptid), - step ? "step" : "continue", - gdb_signal_to_name (signal)); registers_changed_ptid (ptid); /* We only set the internal executing state here. The user/frontend @@ -2164,42 +2237,12 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal) void target_pass_signals (int numsigs, unsigned char *pass_signals) { - if (targetdebug) - { - int i; - - fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {", - numsigs); - - for (i = 0; i < numsigs; i++) - if (pass_signals[i]) - fprintf_unfiltered (gdb_stdlog, " %s", - gdb_signal_to_name (i)); - - fprintf_unfiltered (gdb_stdlog, " })\n"); - } - (*current_target.to_pass_signals) (¤t_target, numsigs, pass_signals); } void target_program_signals (int numsigs, unsigned char *program_signals) { - if (targetdebug) - { - int i; - - fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {", - numsigs); - - for (i = 0; i < numsigs; i++) - if (program_signals[i]) - fprintf_unfiltered (gdb_stdlog, " %s", - gdb_signal_to_name (i)); - - fprintf_unfiltered (gdb_stdlog, " })\n"); - } - (*current_target.to_program_signals) (¤t_target, numsigs, program_signals); } @@ -2219,14 +2262,8 @@ default_follow_fork (struct target_ops *self, int follow_child, int target_follow_fork (int follow_child, int detach_fork) { - int retval = current_target.to_follow_fork (¤t_target, - follow_child, detach_fork); - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, - "target_follow_fork (%d, %d) = %d\n", - follow_child, detach_fork, retval); - return retval; + return current_target.to_follow_fork (¤t_target, + follow_child, detach_fork); } static void @@ -2240,8 +2277,6 @@ void target_mourn_inferior (void) { current_target.to_mourn_inferior (¤t_target); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n"); /* We no longer need to keep handles on any of the object files. Make sure to release them to avoid unnecessarily locking any @@ -2391,20 +2426,9 @@ target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len, const gdb_byte *pattern, ULONGEST pattern_len, CORE_ADDR *found_addrp) { - int found; - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n", - hex_string (start_addr)); - - found = current_target.to_search_memory (¤t_target, start_addr, - search_space_len, - pattern, pattern_len, found_addrp); - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, " = %d\n", found); - - return found; + return current_target.to_search_memory (¤t_target, start_addr, + search_space_len, + pattern, pattern_len, found_addrp); } /* Look through the currently pushed targets. If none of them will @@ -2425,10 +2449,11 @@ target_require_runnable (void) if (t->to_create_inferior != NULL) return; - /* Do not worry about thread_stratum targets that can not + /* Do not worry about targets at certain strata that can not create inferiors. Assume they will be pushed again if necessary, and continue to the process_stratum. */ if (t->to_stratum == thread_stratum + || t->to_stratum == record_stratum || t->to_stratum == arch_stratum) continue; @@ -2471,15 +2496,15 @@ find_default_run_target (char *do_mesg) if (auto_connect_native_target) { - struct target_ops **t; + struct target_ops *t; int count = 0; + int i; - for (t = target_structs; t < target_structs + target_struct_size; - ++t) + for (i = 0; VEC_iterate (target_ops_p, target_structs, i, t); ++i) { - if ((*t)->to_can_run != delegate_can_run && target_can_run (*t)) + if (t->to_can_run != delegate_can_run && target_can_run (t)) { - runable = *t; + runable = t; ++count; } } @@ -2621,7 +2646,7 @@ default_thread_address_space (struct target_ops *self, ptid_t ptid) struct inferior *inf; /* Fall-back to the "main" address space of the inferior. */ - inf = find_inferior_pid (ptid_get_pid (ptid)); + inf = find_inferior_ptid (ptid); if (inf == NULL || inf->aspace == NULL) internal_error (__FILE__, __LINE__, @@ -2642,12 +2667,6 @@ target_thread_address_space (ptid_t ptid) aspace = current_target.to_thread_address_space (¤t_target, ptid); gdb_assert (aspace != NULL); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, - "target_thread_address_space (%s) = %d\n", - target_pid_to_str (ptid), - address_space_num (aspace)); - return aspace; } @@ -3102,13 +3121,6 @@ init_dummy_target (void) install_dummy_methods (&dummy_target); } -static void -debug_to_open (char *args, int from_tty) -{ - debug_target.to_open (args, from_tty); - - fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty); -} void target_close (struct target_ops *targ) @@ -3127,22 +3139,13 @@ target_close (struct target_ops *targ) int target_thread_alive (ptid_t ptid) { - int retval; - - retval = current_target.to_thread_alive (¤t_target, ptid); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n", - ptid_get_pid (ptid), retval); - - return retval; + return current_target.to_thread_alive (¤t_target, ptid); } void -target_find_new_threads (void) +target_update_thread_list (void) { - current_target.to_find_new_threads (¤t_target); - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n"); + current_target.to_update_thread_list (¤t_target); } void @@ -3157,12 +3160,29 @@ target_stop (ptid_t ptid) (*current_target.to_stop) (¤t_target, ptid); } -static void -debug_to_post_attach (struct target_ops *self, int pid) +/* See target/target.h. */ + +void +target_stop_and_wait (ptid_t ptid) { - debug_target.to_post_attach (&debug_target, pid); + struct target_waitstatus status; + int was_non_stop = non_stop; + + non_stop = 1; + target_stop (ptid); - fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid); + memset (&status, 0, sizeof (status)); + target_wait (ptid, &status, 0); + + non_stop = was_non_stop; +} + +/* See target/target.h. */ + +void +target_continue_no_signal (ptid_t ptid) +{ + target_resume (ptid, 0, GDB_SIGNAL_0); } /* Concatenate ELEM to LIST, a comma separate list, and return the @@ -3276,14 +3296,8 @@ target_store_registers (struct regcache *regcache, int regno) int target_core_of_thread (ptid_t ptid) { - int retval = current_target.to_core_of_thread (¤t_target, ptid); - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, - "target_core_of_thread (%d) = %d\n", - ptid_get_pid (ptid), retval); - return retval; -} + return current_target.to_core_of_thread (¤t_target, ptid); +} int simple_verify_memory (struct target_ops *ops, @@ -3327,16 +3341,8 @@ default_verify_memory (struct target_ops *self, int target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size) { - int retval = current_target.to_verify_memory (¤t_target, - data, memaddr, size); - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, - "target_verify_memory (%s, %s) = %d\n", - paddress (target_gdbarch (), memaddr), - pulongest (size), - retval); - return retval; + return current_target.to_verify_memory (¤t_target, + data, memaddr, size); } /* The documentation for this function is in its prototype declaration in @@ -3345,18 +3351,8 @@ target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size) int target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw) { - int ret; - - ret = current_target.to_insert_mask_watchpoint (¤t_target, - addr, mask, rw); - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "\ -target_insert_mask_watchpoint (%s, %s, %d) = %d\n", - core_addr_to_string (addr), - core_addr_to_string (mask), rw, ret); - - return ret; + return current_target.to_insert_mask_watchpoint (¤t_target, + addr, mask, rw); } /* The documentation for this function is in its prototype declaration in @@ -3365,18 +3361,8 @@ target_insert_mask_watchpoint (%s, %s, %d) = %d\n", int target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw) { - int ret; - - ret = current_target.to_remove_mask_watchpoint (¤t_target, - addr, mask, rw); - - if (targetdebug) - fprintf_unfiltered (gdb_stdlog, "\ -target_remove_mask_watchpoint (%s, %s, %d) = %d\n", - core_addr_to_string (addr), - core_addr_to_string (mask), rw, ret); - - return ret; + return current_target.to_remove_mask_watchpoint (¤t_target, + addr, mask, rw); } /* The documentation for this function is in its prototype declaration @@ -3400,10 +3386,18 @@ target_ranged_break_num_registers (void) /* See target.h. */ +int +target_supports_btrace (enum btrace_format format) +{ + return current_target.to_supports_btrace (¤t_target, format); +} + +/* See target.h. */ + struct btrace_target_info * -target_enable_btrace (ptid_t ptid) +target_enable_btrace (ptid_t ptid, const struct btrace_config *conf) { - return current_target.to_enable_btrace (¤t_target, ptid); + return current_target.to_enable_btrace (¤t_target, ptid, conf); } /* See target.h. */ @@ -3425,7 +3419,7 @@ target_teardown_btrace (struct btrace_target_info *btinfo) /* See target.h. */ enum btrace_error -target_read_btrace (VEC (btrace_block_s) **btrace, +target_read_btrace (struct btrace_data *btrace, struct btrace_target_info *btinfo, enum btrace_read_type type) { @@ -3434,27 +3428,18 @@ target_read_btrace (VEC (btrace_block_s) **btrace, /* See target.h. */ -void -target_stop_recording (void) +const struct btrace_config * +target_btrace_conf (const struct btrace_target_info *btinfo) { - current_target.to_stop_recording (¤t_target); + return current_target.to_btrace_conf (¤t_target, btinfo); } /* See target.h. */ void -target_info_record (void) +target_stop_recording (void) { - struct target_ops *t; - - for (t = current_target.beneath; t != NULL; t = t->beneath) - if (t->to_info_record != NULL) - { - t->to_info_record (t); - return; - } - - tcomplain (); + current_target.to_stop_recording (¤t_target); } /* See target.h. */ @@ -3473,7 +3458,8 @@ target_supports_delete_record (void) struct target_ops *t; for (t = current_target.beneath; t != NULL; t = t->beneath) - if (t->to_delete_record != NULL) + if (t->to_delete_record != delegate_delete_record + && t->to_delete_record != tdefault_delete_record) return 1; return 0; @@ -3567,14 +3553,6 @@ target_call_history_range (ULONGEST begin, ULONGEST end, int flags) current_target.to_call_history_range (¤t_target, begin, end, flags); } -static void -debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache) -{ - debug_target.to_prepare_to_store (&debug_target, regcache); - - fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n"); -} - /* See target.h. */ const struct frame_unwind * @@ -3591,23 +3569,6 @@ target_get_tailcall_unwinder (void) return current_target.to_get_tailcall_unwinder (¤t_target); } -/* Default implementation of to_decr_pc_after_break. */ - -static CORE_ADDR -default_target_decr_pc_after_break (struct target_ops *ops, - struct gdbarch *gdbarch) -{ - return gdbarch_decr_pc_after_break (gdbarch); -} - -/* See target.h. */ - -CORE_ADDR -target_decr_pc_after_break (struct gdbarch *gdbarch) -{ - return current_target.to_decr_pc_after_break (¤t_target, gdbarch); -} - /* See target.h. */ void @@ -3624,471 +3585,12 @@ target_done_generating_core (void) current_target.to_done_generating_core (¤t_target); } -static void -debug_to_files_info (struct target_ops *target) -{ - debug_target.to_files_info (target); - - fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n"); -} - -static int -debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - int retval; - - retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt); - - fprintf_unfiltered (gdb_stdlog, - "target_insert_breakpoint (%s, xxx) = %ld\n", - core_addr_to_string (bp_tgt->placed_address), - (unsigned long) retval); - return retval; -} - -static int -debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - int retval; - - retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt); - - fprintf_unfiltered (gdb_stdlog, - "target_remove_breakpoint (%s, xxx) = %ld\n", - core_addr_to_string (bp_tgt->placed_address), - (unsigned long) retval); - return retval; -} - -static int -debug_to_can_use_hw_breakpoint (struct target_ops *self, - int type, int cnt, int from_tty) -{ - int retval; - - retval = debug_target.to_can_use_hw_breakpoint (&debug_target, - type, cnt, from_tty); - - fprintf_unfiltered (gdb_stdlog, - "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n", - (unsigned long) type, - (unsigned long) cnt, - (unsigned long) from_tty, - (unsigned long) retval); - return retval; -} - -static int -debug_to_region_ok_for_hw_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len) -{ - CORE_ADDR retval; - - retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target, - addr, len); - - fprintf_unfiltered (gdb_stdlog, - "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n", - core_addr_to_string (addr), (unsigned long) len, - core_addr_to_string (retval)); - return retval; -} - -static int -debug_to_can_accel_watchpoint_condition (struct target_ops *self, - CORE_ADDR addr, int len, int rw, - struct expression *cond) -{ - int retval; - - retval = debug_target.to_can_accel_watchpoint_condition (&debug_target, - addr, len, - rw, cond); - - fprintf_unfiltered (gdb_stdlog, - "target_can_accel_watchpoint_condition " - "(%s, %d, %d, %s) = %ld\n", - core_addr_to_string (addr), len, rw, - host_address_to_string (cond), (unsigned long) retval); - return retval; -} - -static int -debug_to_stopped_by_watchpoint (struct target_ops *ops) -{ - int retval; - - retval = debug_target.to_stopped_by_watchpoint (&debug_target); - - fprintf_unfiltered (gdb_stdlog, - "target_stopped_by_watchpoint () = %ld\n", - (unsigned long) retval); - return retval; -} - -static int -debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr) -{ - int retval; - - retval = debug_target.to_stopped_data_address (target, addr); - - fprintf_unfiltered (gdb_stdlog, - "target_stopped_data_address ([%s]) = %ld\n", - core_addr_to_string (*addr), - (unsigned long)retval); - return retval; -} - -static int -debug_to_watchpoint_addr_within_range (struct target_ops *target, - CORE_ADDR addr, - CORE_ADDR start, int length) -{ - int retval; - - retval = debug_target.to_watchpoint_addr_within_range (target, addr, - start, length); - - fprintf_filtered (gdb_stdlog, - "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n", - core_addr_to_string (addr), core_addr_to_string (start), - length, retval); - return retval; -} - -static int -debug_to_insert_hw_breakpoint (struct target_ops *self, - struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - int retval; - - retval = debug_target.to_insert_hw_breakpoint (&debug_target, - gdbarch, bp_tgt); - - fprintf_unfiltered (gdb_stdlog, - "target_insert_hw_breakpoint (%s, xxx) = %ld\n", - core_addr_to_string (bp_tgt->placed_address), - (unsigned long) retval); - return retval; -} - -static int -debug_to_remove_hw_breakpoint (struct target_ops *self, - struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - int retval; - - retval = debug_target.to_remove_hw_breakpoint (&debug_target, - gdbarch, bp_tgt); - - fprintf_unfiltered (gdb_stdlog, - "target_remove_hw_breakpoint (%s, xxx) = %ld\n", - core_addr_to_string (bp_tgt->placed_address), - (unsigned long) retval); - return retval; -} - -static int -debug_to_insert_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, - struct expression *cond) -{ - int retval; - - retval = debug_target.to_insert_watchpoint (&debug_target, - addr, len, type, cond); - - fprintf_unfiltered (gdb_stdlog, - "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n", - core_addr_to_string (addr), len, type, - host_address_to_string (cond), (unsigned long) retval); - return retval; -} - -static int -debug_to_remove_watchpoint (struct target_ops *self, - CORE_ADDR addr, int len, int type, - struct expression *cond) -{ - int retval; - - retval = debug_target.to_remove_watchpoint (&debug_target, - addr, len, type, cond); - - fprintf_unfiltered (gdb_stdlog, - "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n", - core_addr_to_string (addr), len, type, - host_address_to_string (cond), (unsigned long) retval); - return retval; -} - -static void -debug_to_terminal_init (struct target_ops *self) -{ - debug_target.to_terminal_init (&debug_target); - - fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n"); -} - -static void -debug_to_terminal_inferior (struct target_ops *self) -{ - debug_target.to_terminal_inferior (&debug_target); - - fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n"); -} - -static void -debug_to_terminal_ours_for_output (struct target_ops *self) -{ - debug_target.to_terminal_ours_for_output (&debug_target); - - fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n"); -} - -static void -debug_to_terminal_ours (struct target_ops *self) -{ - debug_target.to_terminal_ours (&debug_target); - - fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n"); -} - -static void -debug_to_terminal_save_ours (struct target_ops *self) -{ - debug_target.to_terminal_save_ours (&debug_target); - - fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n"); -} - -static void -debug_to_terminal_info (struct target_ops *self, - const char *arg, int from_tty) -{ - debug_target.to_terminal_info (&debug_target, arg, from_tty); - - fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg, - from_tty); -} - -static void -debug_to_load (struct target_ops *self, const char *args, int from_tty) -{ - debug_target.to_load (&debug_target, args, from_tty); - - fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty); -} - -static void -debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid) -{ - debug_target.to_post_startup_inferior (&debug_target, ptid); - - fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n", - ptid_get_pid (ptid)); -} - -static int -debug_to_insert_fork_catchpoint (struct target_ops *self, int pid) -{ - int retval; - - retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n", - pid, retval); - - return retval; -} - -static int -debug_to_remove_fork_catchpoint (struct target_ops *self, int pid) -{ - int retval; - - retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n", - pid, retval); - - return retval; -} - -static int -debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid) -{ - int retval; - - retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n", - pid, retval); - - return retval; -} - -static int -debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid) -{ - int retval; - - retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n", - pid, retval); - - return retval; -} - -static int -debug_to_insert_exec_catchpoint (struct target_ops *self, int pid) -{ - int retval; - - retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n", - pid, retval); - - return retval; -} - -static int -debug_to_remove_exec_catchpoint (struct target_ops *self, int pid) -{ - int retval; - - retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n", - pid, retval); - - return retval; -} - -static int -debug_to_has_exited (struct target_ops *self, - int pid, int wait_status, int *exit_status) -{ - int has_exited; - - has_exited = debug_target.to_has_exited (&debug_target, - pid, wait_status, exit_status); - - fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n", - pid, wait_status, *exit_status, has_exited); - - return has_exited; -} - -static int -debug_to_can_run (struct target_ops *self) -{ - int retval; - - retval = debug_target.to_can_run (&debug_target); - - fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval); - - return retval; -} - -static struct gdbarch * -debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid) -{ - struct gdbarch *retval; - - retval = debug_target.to_thread_architecture (ops, ptid); - - fprintf_unfiltered (gdb_stdlog, - "target_thread_architecture (%s) = %s [%s]\n", - target_pid_to_str (ptid), - host_address_to_string (retval), - gdbarch_bfd_arch_info (retval)->printable_name); - return retval; -} - -static void -debug_to_stop (struct target_ops *self, ptid_t ptid) -{ - debug_target.to_stop (&debug_target, ptid); - - fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n", - target_pid_to_str (ptid)); -} - -static void -debug_to_rcmd (struct target_ops *self, const char *command, - struct ui_file *outbuf) -{ - debug_target.to_rcmd (&debug_target, command, outbuf); - fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command); -} - -static char * -debug_to_pid_to_exec_file (struct target_ops *self, int pid) -{ - char *exec_file; - - exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid); - - fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n", - pid, exec_file); - - return exec_file; -} - static void setup_target_debug (void) { memcpy (&debug_target, ¤t_target, sizeof debug_target); - current_target.to_open = debug_to_open; - current_target.to_post_attach = debug_to_post_attach; - current_target.to_prepare_to_store = debug_to_prepare_to_store; - 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_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint; - current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint; - current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint; - current_target.to_insert_watchpoint = debug_to_insert_watchpoint; - current_target.to_remove_watchpoint = debug_to_remove_watchpoint; - current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint; - current_target.to_stopped_data_address = debug_to_stopped_data_address; - current_target.to_watchpoint_addr_within_range - = debug_to_watchpoint_addr_within_range; - current_target.to_region_ok_for_hw_watchpoint - = debug_to_region_ok_for_hw_watchpoint; - current_target.to_can_accel_watchpoint_condition - = debug_to_can_accel_watchpoint_condition; - 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_save_ours = debug_to_terminal_save_ours; - current_target.to_terminal_info = debug_to_terminal_info; - current_target.to_load = debug_to_load; - current_target.to_post_startup_inferior = debug_to_post_startup_inferior; - current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint; - current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint; - current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint; - current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint; - current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint; - current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint; - current_target.to_has_exited = debug_to_has_exited; - current_target.to_can_run = debug_to_can_run; - current_target.to_stop = debug_to_stop; - current_target.to_rcmd = debug_to_rcmd; - current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file; - current_target.to_thread_architecture = debug_to_thread_architecture; + init_debug_target (¤t_target); } @@ -4226,9 +3728,8 @@ initialize_targets (void) Set target debugging."), _("\ Show target debugging."), _("\ When non-zero, target debugging is enabled. Higher numbers are more\n\ -verbose. Changes do not take effect until the next \"run\" or \"target\"\n\ -command."), - NULL, +verbose."), + set_targetdebug, show_targetdebug, &setdebuglist, &showdebuglist);