X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftarget.c;h=e7382081b9b09016e618392961f48dc2d0bdfcf3;hb=3f66068d9a87154c55f079d96e05a7f1028f045d;hp=0142aaa93b6196be6d52e26cc442b0068b5e6609;hpb=03f2053f967aada4d75ee44d41ef3f803fb2f2a9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.c b/gdb/target.c index 0142aaa93b..e7382081b9 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -1,5 +1,7 @@ /* Select target systems and architectures at runtime for GDB. - Copyright 1990, 1992-1995, 1998-2000 Free Software Foundation, Inc. + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002 + Free Software Foundation, Inc. Contributed by Cygnus Support. This file is part of GDB. @@ -21,7 +23,6 @@ #include "defs.h" #include -#include #include "gdb_string.h" #include "target.h" #include "gdbcmd.h" @@ -31,61 +32,49 @@ #include "symfile.h" #include "objfiles.h" #include "gdb_wait.h" +#include "dcache.h" #include +#include "regcache.h" extern int errno; -static void -target_info PARAMS ((char *, int)); +static void target_info (char *, int); -static void -cleanup_target PARAMS ((struct target_ops *)); +static void cleanup_target (struct target_ops *); -static void -maybe_kill_then_create_inferior PARAMS ((char *, char *, char **)); +static void maybe_kill_then_create_inferior (char *, char *, char **); -static void -default_clone_and_follow_inferior PARAMS ((int, int *)); +static void maybe_kill_then_attach (char *, int); -static void -maybe_kill_then_attach PARAMS ((char *, int)); +static void kill_or_be_killed (int); -static void -kill_or_be_killed PARAMS ((int)); +static void default_terminal_info (char *, int); -static void -default_terminal_info PARAMS ((char *, int)); +static int default_region_size_ok_for_hw_watchpoint (int); -static int -nosymbol PARAMS ((char *, CORE_ADDR *)); +static int nosymbol (char *, CORE_ADDR *); -static void -tcomplain PARAMS ((void)); +static void tcomplain (void); -static int -nomemory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *)); +static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *); -static int -return_zero PARAMS ((void)); +static int return_zero (void); -static int -return_one PARAMS ((void)); +static int return_one (void); -void -target_ignore PARAMS ((void)); +static int return_minus_one (void); -static void -target_command PARAMS ((char *, int)); +void target_ignore (void); -static struct target_ops * -find_default_run_target PARAMS ((char *)); +static void target_command (char *, int); -static void -update_current_target PARAMS ((void)); +static struct target_ops *find_default_run_target (char *); -static void nosupport_runtime PARAMS ((void)); +static void update_current_target (void); -static void normal_target_post_startup_inferior PARAMS ((int pid)); +static void nosupport_runtime (void); + +static void normal_target_post_startup_inferior (ptid_t ptid); /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR. Returns 0 for success, errno code for failure (which @@ -93,94 +82,87 @@ static void normal_target_post_startup_inferior PARAMS ((int pid)); partial transfers, try either target_read_memory_partial or target_write_memory_partial). */ -static int -target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, - int write, asection * bfd_section)); +static int target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, + int write); -static void init_dummy_target PARAMS ((void)); +static void init_dummy_target (void); -static void -debug_to_open PARAMS ((char *, int)); +static void debug_to_open (char *, int); -static void -debug_to_close PARAMS ((int)); +static void debug_to_close (int); -static void -debug_to_attach PARAMS ((char *, int)); +static void debug_to_attach (char *, int); -static void -debug_to_detach PARAMS ((char *, int)); +static void debug_to_detach (char *, int); -static void -debug_to_resume PARAMS ((int, int, enum target_signal)); +static void debug_to_disconnect (char *, int); -static int -debug_to_wait PARAMS ((int, struct target_waitstatus *)); +static void debug_to_resume (ptid_t, int, enum target_signal); -static void -debug_to_fetch_registers PARAMS ((int)); +static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *); -static void -debug_to_store_registers PARAMS ((int)); +static void debug_to_fetch_registers (int); -static void -debug_to_prepare_to_store PARAMS ((void)); +static void debug_to_store_registers (int); -static int -debug_to_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *)); +static void debug_to_prepare_to_store (void); -static void -debug_to_files_info PARAMS ((struct target_ops *)); +static int debug_to_xfer_memory (CORE_ADDR, char *, int, int, + struct mem_attrib *, struct target_ops *); -static int -debug_to_insert_breakpoint PARAMS ((CORE_ADDR, char *)); +static void debug_to_files_info (struct target_ops *); -static int -debug_to_remove_breakpoint PARAMS ((CORE_ADDR, char *)); +static int debug_to_insert_breakpoint (CORE_ADDR, char *); -static void -debug_to_terminal_init PARAMS ((void)); +static int debug_to_remove_breakpoint (CORE_ADDR, char *); -static void -debug_to_terminal_inferior PARAMS ((void)); +static int debug_to_can_use_hw_breakpoint (int, int, int); -static void -debug_to_terminal_ours_for_output PARAMS ((void)); +static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *); -static void -debug_to_terminal_ours PARAMS ((void)); +static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *); -static void -debug_to_terminal_info PARAMS ((char *, int)); +static int debug_to_insert_watchpoint (CORE_ADDR, int, int); -static void -debug_to_kill PARAMS ((void)); +static int debug_to_remove_watchpoint (CORE_ADDR, int, int); -static void -debug_to_load PARAMS ((char *, int)); +static int debug_to_stopped_by_watchpoint (void); -static int -debug_to_lookup_symbol PARAMS ((char *, CORE_ADDR *)); +static CORE_ADDR debug_to_stopped_data_address (void); -static void -debug_to_create_inferior PARAMS ((char *, char *, char **)); +static int debug_to_region_size_ok_for_hw_watchpoint (int); -static void -debug_to_mourn_inferior PARAMS ((void)); +static void debug_to_terminal_init (void); -static int -debug_to_can_run PARAMS ((void)); +static void debug_to_terminal_inferior (void); -static void -debug_to_notice_signals PARAMS ((int)); +static void debug_to_terminal_ours_for_output (void); -static int -debug_to_thread_alive PARAMS ((int)); +static void debug_to_terminal_save_ours (void); -static void -debug_to_stop PARAMS ((void)); +static void debug_to_terminal_ours (void); + +static void debug_to_terminal_info (char *, int); + +static void debug_to_kill (void); + +static void debug_to_load (char *, int); -static int debug_to_query PARAMS ((int /*char */ , char *, char *, int *)); +static int debug_to_lookup_symbol (char *, CORE_ADDR *); + +static void debug_to_create_inferior (char *, char *, char **); + +static void debug_to_mourn_inferior (void); + +static int debug_to_can_run (void); + +static void debug_to_notice_signals (ptid_t); + +static int debug_to_thread_alive (ptid_t); + +static void debug_to_stop (void); + +static int debug_to_query (int /*char */ , char *, char *, int *); /* Pointer to array of target architecture structures; the size of the array; the current index into the array; the allocated size of the @@ -218,15 +200,15 @@ int attach_flag; static int targetdebug = 0; -static void setup_target_debug PARAMS ((void)); +static void setup_target_debug (void); + +DCACHE *target_dcache; /* The user just typed 'target' without the name of a target. */ /* ARGSUSED */ static void -target_command (arg, from_tty) - char *arg; - int from_tty; +target_command (char *arg, int from_tty) { fputs_filtered ("Argument required (target name). Try `help target'\n", gdb_stdout); @@ -235,8 +217,7 @@ target_command (arg, from_tty) /* Add a possible target architecture to the list. */ void -add_target (t) - struct target_ops *t; +add_target (struct target_ops *t) { if (!target_structs) { @@ -268,56 +249,51 @@ information on the arguments for a particular protocol, type\n\ /* Stub functions */ void -target_ignore () +target_ignore (void) { } void target_load (char *arg, int from_tty) { + dcache_invalidate (target_dcache); (*current_target.to_load) (arg, from_tty); } /* ARGSUSED */ static int -nomemory (memaddr, myaddr, len, write, t) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *t; +nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct target_ops *t) { errno = EIO; /* Can't read/write this location */ return 0; /* No bytes handled */ } static void -tcomplain () +tcomplain (void) { error ("You can't do that when your target is `%s'", current_target.to_shortname); } void -noprocess () +noprocess (void) { error ("You can't do that without a process to debug."); } /* ARGSUSED */ static int -nosymbol (name, addrp) - char *name; - CORE_ADDR *addrp; +nosymbol (char *name, CORE_ADDR *addrp) { return 1; /* Symbol does not exist in target env */ } /* ARGSUSED */ static void -nosupport_runtime () +nosupport_runtime (void) { - if (!inferior_pid) + if (ptid_equal (inferior_ptid, null_ptid)) noprocess (); else error ("No run-time support for this"); @@ -326,9 +302,7 @@ nosupport_runtime () /* ARGSUSED */ static void -default_terminal_info (args, from_tty) - char *args; - int from_tty; +default_terminal_info (char *args, int from_tty) { printf_unfiltered ("No saved terminal information.\n"); } @@ -339,8 +313,7 @@ default_terminal_info (args, from_tty) the target, and the operation should be attempted. */ static void -kill_or_be_killed (from_tty) - int from_tty; +kill_or_be_killed (int from_tty) { if (target_has_execution) { @@ -362,38 +335,24 @@ kill_or_be_killed (from_tty) } static void -maybe_kill_then_attach (args, from_tty) - char *args; - int from_tty; +maybe_kill_then_attach (char *args, int from_tty) { kill_or_be_killed (from_tty); target_attach (args, from_tty); } static void -maybe_kill_then_create_inferior (exec, args, env) - char *exec; - char *args; - char **env; +maybe_kill_then_create_inferior (char *exec, char *args, char **env) { kill_or_be_killed (0); target_create_inferior (exec, args, env); } -static void -default_clone_and_follow_inferior (child_pid, followed_child) - int child_pid; - int *followed_child; -{ - target_clone_and_follow_inferior (child_pid, followed_child); -} - /* Clean up a target struct so it no longer has any zero pointers in it. We default entries, at least to stubs that print error messages. */ static void -cleanup_target (t) - struct target_ops *t; +cleanup_target (struct target_ops *t) { #define de_fault(field, value) \ @@ -411,22 +370,20 @@ cleanup_target (t) de_fault (to_post_attach, (void (*) (int)) target_ignore); - de_fault (to_require_attach, - maybe_kill_then_attach); de_fault (to_detach, (void (*) (char *, int)) target_ignore); - de_fault (to_require_detach, - (void (*) (int, char *, int)) - target_ignore); + de_fault (to_disconnect, + (void (*) (char *, int)) + tcomplain); de_fault (to_resume, - (void (*) (int, int, enum target_signal)) + (void (*) (ptid_t, int, enum target_signal)) noprocess); de_fault (to_wait, - (int (*) (int, struct target_waitstatus *)) + (ptid_t (*) (ptid_t, struct target_waitstatus *)) noprocess); de_fault (to_post_wait, - (void (*) (int, int)) + (void (*) (ptid_t, int)) target_ignore); de_fault (to_fetch_registers, (void (*) (int)) @@ -438,7 +395,7 @@ cleanup_target (t) (void (*) (void)) noprocess); de_fault (to_xfer_memory, - (int (*) (CORE_ADDR, char *, int, int, struct target_ops *)) + (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *)) nomemory); de_fault (to_files_info, (void (*) (struct target_ops *)) @@ -447,6 +404,29 @@ cleanup_target (t) memory_insert_breakpoint); de_fault (to_remove_breakpoint, memory_remove_breakpoint); + de_fault (to_can_use_hw_breakpoint, + (int (*) (int, int, int)) + return_zero); + de_fault (to_insert_hw_breakpoint, + (int (*) (CORE_ADDR, char *)) + return_minus_one); + de_fault (to_remove_hw_breakpoint, + (int (*) (CORE_ADDR, char *)) + return_minus_one); + de_fault (to_insert_watchpoint, + (int (*) (CORE_ADDR, int, int)) + return_minus_one); + de_fault (to_remove_watchpoint, + (int (*) (CORE_ADDR, int, int)) + return_minus_one); + de_fault (to_stopped_by_watchpoint, + (int (*) (void)) + return_zero); + de_fault (to_stopped_data_address, + (CORE_ADDR (*) (void)) + return_zero); + de_fault (to_region_size_ok_for_hw_watchpoint, + default_region_size_ok_for_hw_watchpoint); de_fault (to_terminal_init, (void (*) (void)) target_ignore); @@ -459,6 +439,9 @@ cleanup_target (t) de_fault (to_terminal_ours, (void (*) (void)) target_ignore); + de_fault (to_terminal_save_ours, + (void (*) (void)) + target_ignore); de_fault (to_terminal_info, default_terminal_info); de_fault (to_kill, @@ -473,16 +456,11 @@ cleanup_target (t) de_fault (to_create_inferior, maybe_kill_then_create_inferior); de_fault (to_post_startup_inferior, - (void (*) (int)) + (void (*) (ptid_t)) target_ignore); de_fault (to_acknowledge_created_inferior, (void (*) (int)) target_ignore); - de_fault (to_clone_and_follow_inferior, - default_clone_and_follow_inferior); - de_fault (to_post_follow_inferior_by_clone, - (void (*) (void)) - target_ignore); de_fault (to_insert_fork_catchpoint, (int (*) (int)) tcomplain); @@ -495,17 +473,8 @@ cleanup_target (t) de_fault (to_remove_vfork_catchpoint, (int (*) (int)) tcomplain); - de_fault (to_has_forked, - (int (*) (int, int *)) - return_zero); - de_fault (to_has_vforked, - (int (*) (int, int *)) - return_zero); - de_fault (to_can_follow_vfork_prior_to_exec, - (int (*) (void)) - return_zero); - de_fault (to_post_follow_vfork, - (void (*) (int, int, int, int)) + de_fault (to_follow_fork, + (int (*) (int)) target_ignore); de_fault (to_insert_exec_catchpoint, (int (*) (int)) @@ -513,15 +482,9 @@ cleanup_target (t) de_fault (to_remove_exec_catchpoint, (int (*) (int)) tcomplain); - de_fault (to_has_execd, - (int (*) (int, char **)) - return_zero); de_fault (to_reported_exec_events_per_exec_call, (int (*) (void)) return_one); - de_fault (to_has_syscall_event, - (int (*) (int, enum target_waitkind *, int *)) - return_zero); de_fault (to_has_exited, (int (*) (int, int, int *)) return_zero); @@ -531,10 +494,10 @@ cleanup_target (t) de_fault (to_can_run, return_zero); de_fault (to_notice_signals, - (void (*) (int)) + (void (*) (ptid_t)) target_ignore); de_fault (to_thread_alive, - (int (*) (int)) + (int (*) (ptid_t)) return_zero); de_fault (to_find_new_threads, (void (*) (void)) @@ -545,9 +508,6 @@ cleanup_target (t) de_fault (to_stop, (void (*) (void)) target_ignore); - de_fault (to_query, - (int (*) (int, char *, char *, int *)) - return_zero); de_fault (to_rcmd, (void (*) (char *, struct ui_file *)) tcomplain); @@ -560,9 +520,6 @@ cleanup_target (t) de_fault (to_pid_to_exec_file, (char *(*) (int)) return_zero); - de_fault (to_core_file_to_sym_file, - (char *(*) (char *)) - return_zero); de_fault (to_can_async_p, (int (*) (void)) return_zero); @@ -580,7 +537,7 @@ cleanup_target (t) pushed target vectors. */ static void -update_current_target () +update_current_target (void) { struct target_stack_item *item; struct target_ops *t; @@ -603,9 +560,8 @@ update_current_target () INHERIT (to_close, t); INHERIT (to_attach, t); INHERIT (to_post_attach, t); - INHERIT (to_require_attach, t); INHERIT (to_detach, t); - INHERIT (to_require_detach, t); + INHERIT (to_disconnect, t); INHERIT (to_resume, t); INHERIT (to_wait, t); INHERIT (to_post_wait, t); @@ -616,10 +572,20 @@ update_current_target () INHERIT (to_files_info, t); INHERIT (to_insert_breakpoint, t); INHERIT (to_remove_breakpoint, t); + INHERIT (to_can_use_hw_breakpoint, t); + INHERIT (to_insert_hw_breakpoint, t); + INHERIT (to_remove_hw_breakpoint, t); + INHERIT (to_insert_watchpoint, t); + INHERIT (to_remove_watchpoint, t); + INHERIT (to_stopped_data_address, t); + INHERIT (to_stopped_by_watchpoint, t); + INHERIT (to_have_continuable_watchpoint, t); + INHERIT (to_region_size_ok_for_hw_watchpoint, t); INHERIT (to_terminal_init, t); INHERIT (to_terminal_inferior, t); INHERIT (to_terminal_ours_for_output, t); INHERIT (to_terminal_ours, t); + INHERIT (to_terminal_save_ours, t); INHERIT (to_terminal_info, t); INHERIT (to_kill, t); INHERIT (to_load, t); @@ -627,21 +593,14 @@ update_current_target () INHERIT (to_create_inferior, t); INHERIT (to_post_startup_inferior, t); INHERIT (to_acknowledge_created_inferior, t); - INHERIT (to_clone_and_follow_inferior, t); - INHERIT (to_post_follow_inferior_by_clone, t); INHERIT (to_insert_fork_catchpoint, t); INHERIT (to_remove_fork_catchpoint, t); INHERIT (to_insert_vfork_catchpoint, t); INHERIT (to_remove_vfork_catchpoint, t); - INHERIT (to_has_forked, t); - INHERIT (to_has_vforked, t); - INHERIT (to_can_follow_vfork_prior_to_exec, t); - INHERIT (to_post_follow_vfork, t); + INHERIT (to_follow_fork, t); INHERIT (to_insert_exec_catchpoint, t); INHERIT (to_remove_exec_catchpoint, t); - INHERIT (to_has_execd, t); INHERIT (to_reported_exec_events_per_exec_call, t); - INHERIT (to_has_syscall_event, t); INHERIT (to_has_exited, t); INHERIT (to_mourn_inferior, t); INHERIT (to_can_run, t); @@ -656,9 +615,7 @@ update_current_target () INHERIT (to_enable_exception_callback, t); INHERIT (to_get_current_exception_event, t); INHERIT (to_pid_to_exec_file, t); - INHERIT (to_core_file_to_sym_file, t); INHERIT (to_stratum, t); - INHERIT (DONT_USE, t); INHERIT (to_has_all_memory, t); INHERIT (to_has_memory, t); INHERIT (to_has_stack, t); @@ -671,6 +628,9 @@ update_current_target () INHERIT (to_is_async_p, t); INHERIT (to_async, t); INHERIT (to_async_mask_value, t); + INHERIT (to_find_memory_regions, t); + INHERIT (to_make_corefile_notes, t); + INHERIT (to_get_thread_local_address, t); INHERIT (to_magic, t); #undef INHERIT @@ -688,8 +648,7 @@ update_current_target () checking them. */ int -push_target (t) - struct target_ops *t; +push_target (struct target_ops *t) { struct target_stack_item *cur, *prev, *tmp; @@ -700,7 +659,7 @@ push_target (t) fprintf_unfiltered (gdb_stderr, "Magic number of %s target struct wrong\n", t->to_shortname); - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); } /* Find the proper stratum to install this target in. */ @@ -724,7 +683,7 @@ push_target (t) else target_stack = cur->next; /* Unchain first on list */ tmp = cur->next; - free (cur); + xfree (cur); cur = tmp; } @@ -754,8 +713,7 @@ push_target (t) Return how many times it was removed (0 or 1). */ int -unpush_target (t) - struct target_ops *t; +unpush_target (struct target_ops *t) { struct target_stack_item *cur, *prev; @@ -779,7 +737,7 @@ unpush_target (t) else prev->next = cur->next; - free (cur); /* Release the target_stack_item */ + xfree (cur); /* Release the target_stack_item */ update_current_target (); cleanup_target (¤t_target); @@ -788,7 +746,7 @@ unpush_target (t) } void -pop_target () +pop_target (void) { (current_target.to_close) (0); /* Let it clean up */ if (unpush_target (target_stack->target_ops) == 1) @@ -797,7 +755,7 @@ pop_target () fprintf_unfiltered (gdb_stderr, "pop_target couldn't find target %s\n", current_target.to_shortname); - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); } #undef MIN @@ -810,11 +768,7 @@ pop_target () read. */ int -target_read_string (memaddr, string, len, errnop) - CORE_ADDR memaddr; - char **string; - int len; - int *errnop; +target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop) { int tlen, origlen, offset, i; char buf[4]; @@ -836,7 +790,7 @@ target_read_string (memaddr, string, len, errnop) tlen = MIN (len, 4 - (memaddr & 3)); offset = memaddr & 3; - errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0, NULL); + errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0); if (errcode != 0) { /* The transfer request might have crossed the boundary to an @@ -844,7 +798,7 @@ target_read_string (memaddr, string, len, errnop) a single byte. */ tlen = 1; offset = 0; - errcode = target_xfer_memory (memaddr, buf, 1, 0, NULL); + errcode = target_xfer_memory (memaddr, buf, 1, 0); if (errcode != 0) goto done; } @@ -891,59 +845,30 @@ done: deal with partial reads should call target_read_memory_partial. */ int -target_read_memory (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; -{ - return target_xfer_memory (memaddr, myaddr, len, 0, NULL); -} - -int -target_read_memory_section (memaddr, myaddr, len, bfd_section) - CORE_ADDR memaddr; - char *myaddr; - int len; - asection *bfd_section; +target_read_memory (CORE_ADDR memaddr, char *myaddr, int len) { - return target_xfer_memory (memaddr, myaddr, len, 0, bfd_section); + return target_xfer_memory (memaddr, myaddr, len, 0); } int -target_write_memory (memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +target_write_memory (CORE_ADDR memaddr, char *myaddr, int len) { - return target_xfer_memory (memaddr, myaddr, len, 1, NULL); + return target_xfer_memory (memaddr, myaddr, len, 1); } -/* This variable is used to pass section information down to targets. This - *should* be done by adding an argument to the target_xfer_memory function - of all the targets, but I didn't feel like changing 50+ files. */ - -asection *target_memory_bfd_section = NULL; +static int trust_readonly = 0; -/* Move memory to or from the targets. Iterate until all of it has - been moved, if necessary. The top target gets priority; anything - it doesn't want, is offered to the next one down, etc. Note the - business with curlen: if an early target says "no, but I have a - boundary overlapping this xfer" then we shorten what we offer to - the subsequent targets so the early guy will get a chance at the - tail before the subsequent ones do. +/* Move memory to or from the targets. The top target gets priority; + if it cannot handle it, it is offered to the next one down, etc. - Result is 0 or errno value. */ + Result is -1 on error, or the number of bytes transfered. */ -static int -target_xfer_memory (memaddr, myaddr, len, write, bfd_section) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - asection *bfd_section; -{ - int curlen; +int +do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct mem_attrib *attrib) +{ int res; + int done = 0; struct target_ops *t; struct target_stack_item *item; @@ -951,32 +876,44 @@ target_xfer_memory (memaddr, myaddr, len, write, bfd_section) if (len == 0) return 0; - target_memory_bfd_section = bfd_section; - /* to_xfer_memory is not guaranteed to set errno, even when it returns 0. */ errno = 0; - /* The quick case is that the top target does it all. */ - res = current_target.to_xfer_memory - (memaddr, myaddr, len, write, ¤t_target); - if (res == len) - return 0; + if (!write && trust_readonly) + { + /* User-settable option, "trust-readonly-sections". If true, + then memory from any SEC_READONLY bfd section may be read + directly from the bfd file. */ - if (res > 0) - goto bump; - /* If res <= 0 then we call it again in the loop. Ah well. */ + struct section_table *secp; - for (; len > 0;) + for (secp = current_target.to_sections; + secp < current_target.to_sections_end; + secp++) + { + if (bfd_get_section_flags (secp->bfd, secp->the_bfd_section) + & SEC_READONLY) + if (memaddr >= secp->addr && memaddr < secp->endaddr) + return xfer_memory (memaddr, myaddr, len, 0, + attrib, ¤t_target); + } + } + + /* The quick case is that the top target can handle the transfer. */ + res = current_target.to_xfer_memory + (memaddr, myaddr, len, write, attrib, ¤t_target); + + /* If res <= 0 then we call it again in the loop. Ah well. */ + if (res <= 0) { - curlen = len; /* Want to do it all */ for (item = target_stack; item; item = item->next) { t = item->target_ops; if (!t->to_has_memory) continue; - res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t); + res = t->to_xfer_memory (memaddr, myaddr, len, write, attrib, t); if (res > 0) break; /* Handled all or part of xfer */ if (t->to_has_all_memory) @@ -984,36 +921,96 @@ target_xfer_memory (memaddr, myaddr, len, write, bfd_section) } if (res <= 0) + return -1; + } + + return res; +} + + +/* Perform a memory transfer. Iterate until the entire region has + been transfered. + + Result is 0 or errno value. */ + +static int +target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write) +{ + int res; + int reg_len; + struct mem_region *region; + + /* Zero length requests are ok and require no work. */ + if (len == 0) + { + return 0; + } + + while (len > 0) + { + region = lookup_mem_region(memaddr); + if (memaddr + len < region->hi) + reg_len = len; + else + reg_len = region->hi - memaddr; + + switch (region->attrib.mode) { - /* If this address is for nonexistent memory, - read zeros if reading, or do nothing if writing. Return error. */ + case MEM_RO: + if (write) + return EIO; + break; + + case MEM_WO: if (!write) - memset (myaddr, 0, len); - if (errno == 0) return EIO; + break; + } + + while (reg_len > 0) + { + if (region->attrib.cache) + res = dcache_xfer_memory (target_dcache, memaddr, myaddr, + reg_len, write); else - return errno; + res = do_xfer_memory (memaddr, myaddr, reg_len, write, + ®ion->attrib); + + if (res <= 0) + { + /* If this address is for nonexistent memory, read zeros + if reading, or do nothing if writing. Return + error. */ + if (!write) + memset (myaddr, 0, len); + if (errno == 0) + return EIO; + else + return errno; + } + + memaddr += res; + myaddr += res; + len -= res; + reg_len -= res; } - bump: - memaddr += res; - myaddr += res; - len -= res; } + return 0; /* We managed to cover it all somehow. */ } -/* Perform a partial memory transfer. */ +/* Perform a partial memory transfer. + + Result is -1 on error, or the number of bytes transfered. */ static int -target_xfer_memory_partial (CORE_ADDR memaddr, char *buf, int len, +target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len, int write_p, int *err) { int res; - int err_res; - int len_res; - struct target_ops *t; - struct target_stack_item *item; + int reg_len; + struct mem_region *region; /* Zero length requests are ok and require no work. */ if (len == 0) @@ -1022,42 +1019,50 @@ target_xfer_memory_partial (CORE_ADDR memaddr, char *buf, int len, return 0; } - /* The quick case is that the top target does it all. */ - res = current_target.to_xfer_memory (memaddr, buf, len, write_p, ¤t_target); - if (res > 0) - { - *err = 0; - return res; - } - - /* xfer memory doesn't always reliably set errno. */ - errno = 0; + region = lookup_mem_region(memaddr); + if (memaddr + len < region->hi) + reg_len = len; + else + reg_len = region->hi - memaddr; - /* Try all levels of the target stack to see one can handle it. */ - for (item = target_stack; item; item = item->next) + switch (region->attrib.mode) { - t = item->target_ops; - if (!t->to_has_memory) - continue; - res = t->to_xfer_memory (memaddr, buf, len, write_p, t); - if (res > 0) + case MEM_RO: + if (write_p) { - /* Handled all or part of xfer */ - *err = 0; - return res; + *err = EIO; + return -1; } - if (t->to_has_all_memory) - break; + break; + + case MEM_WO: + if (write_p) + { + *err = EIO; + return -1; + } + break; } - /* Total failure. Return error. */ - if (errno != 0) + if (region->attrib.cache) + res = dcache_xfer_memory (target_dcache, memaddr, myaddr, + reg_len, write_p); + else + res = do_xfer_memory (memaddr, myaddr, reg_len, write_p, + ®ion->attrib); + + if (res <= 0) { - *err = errno; - return -1; + if (errno != 0) + *err = errno; + else + *err = EIO; + + return -1; } - *err = EIO; - return -1; + + *err = 0; + return res; } int @@ -1074,9 +1079,7 @@ target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err) /* ARGSUSED */ static void -target_info (args, from_tty) - char *args; - int from_tty; +target_info (char *args, int from_tty) { struct target_ops *t; struct target_stack_item *item; @@ -1111,8 +1114,7 @@ target_info (args, from_tty) anything. */ void -target_preopen (from_tty) - int from_tty; +target_preopen (int from_tty) { dont_repeat (); @@ -1135,9 +1137,7 @@ target_preopen (from_tty) /* Detach a target after doing deferred register stores. */ void -target_detach (args, from_tty) - char *args; - int from_tty; +target_detach (char *args, int from_tty) { /* Handle any optimized stores to the inferior. */ #ifdef DO_DEFERRED_STORES @@ -1147,9 +1147,17 @@ target_detach (args, from_tty) } void -target_link (modname, t_reloc) - char *modname; - CORE_ADDR *t_reloc; +target_disconnect (char *args, int from_tty) +{ + /* Handle any optimized stores to the inferior. */ +#ifdef DO_DEFERRED_STORES + DO_DEFERRED_STORES; +#endif + (current_target.to_disconnect) (args, from_tty); +} + +void +target_link (char *modname, CORE_ADDR *t_reloc) { if (STREQ (current_target.to_shortname, "rombug")) { @@ -1176,8 +1184,7 @@ target_async_mask (int mask) Result is always valid (error() is called for errors). */ static struct target_ops * -find_default_run_target (do_mesg) - char *do_mesg; +find_default_run_target (char *do_mesg) { struct target_ops **t; struct target_ops *runable = NULL; @@ -1202,9 +1209,7 @@ find_default_run_target (do_mesg) } void -find_default_attach (args, from_tty) - char *args; - int from_tty; +find_default_attach (char *args, int from_tty) { struct target_ops *t; @@ -1214,35 +1219,7 @@ find_default_attach (args, from_tty) } void -find_default_require_attach (args, from_tty) - char *args; - int from_tty; -{ - struct target_ops *t; - - t = find_default_run_target ("require_attach"); - (t->to_require_attach) (args, from_tty); - return; -} - -void -find_default_require_detach (pid, args, from_tty) - int pid; - char *args; - int from_tty; -{ - struct target_ops *t; - - t = find_default_run_target ("require_detach"); - (t->to_require_detach) (pid, args, from_tty); - return; -} - -void -find_default_create_inferior (exec_file, allargs, env) - char *exec_file; - char *allargs; - char **env; +find_default_create_inferior (char *exec_file, char *allargs, char **env) { struct target_ops *t; @@ -1251,30 +1228,30 @@ find_default_create_inferior (exec_file, allargs, env) return; } -void -find_default_clone_and_follow_inferior (child_pid, followed_child) - int child_pid; - int *followed_child; +static int +default_region_size_ok_for_hw_watchpoint (int byte_count) { - struct target_ops *t; - - t = find_default_run_target ("run"); - (t->to_clone_and_follow_inferior) (child_pid, followed_child); - return; + return (byte_count <= DEPRECATED_REGISTER_SIZE); } static int -return_zero () +return_zero (void) { return 0; } static int -return_one () +return_one (void) { return 1; } +static int +return_minus_one (void) +{ + return -1; +} + /* * Resize the to_sections pointer. Also make sure that anyone that * was holding on to an old value of it gets updated. @@ -1325,11 +1302,44 @@ target_resize_to_sections (struct target_ops *target, int num_added) } +/* Remove all target sections taken from ABFD. + + Scan the current target stack for targets whose section tables + refer to sections from BFD, and remove those sections. We use this + when we notice that the inferior has unloaded a shared object, for + example. */ +void +remove_target_sections (bfd *abfd) +{ + struct target_ops **t; + + for (t = target_structs; t < target_structs + target_struct_size; t++) + { + struct section_table *src, *dest; + + dest = (*t)->to_sections; + for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++) + if (src->bfd != abfd) + { + /* Keep this section. */ + if (dest < src) *dest = *src; + dest++; + } + + /* If we've dropped any sections, resize the section table. */ + if (dest < src) + target_resize_to_sections (*t, dest - src); + } +} + + + + /* Find a single runnable target in the stack and return it. If for some reason there is more than one, return NULL. */ struct target_ops * -find_run_target () +find_run_target (void) { struct target_ops **t; struct target_ops *runable = NULL; @@ -1353,7 +1363,7 @@ find_run_target () If for some reason there is more than one, return NULL. */ struct target_ops * -find_core_target () +find_core_target (void) { struct target_ops **t; struct target_ops *runable = NULL; @@ -1379,8 +1389,7 @@ find_core_target () */ struct target_ops * -find_target_beneath (t) - struct target_ops *t; +find_target_beneath (struct target_ops *t) { struct target_stack_item *cur; @@ -1398,11 +1407,11 @@ find_target_beneath (t) /* The inferior process has died. Long live the inferior! */ void -generic_mourn_inferior () +generic_mourn_inferior (void) { extern int show_breakpoint_hit_counts; - inferior_pid = 0; + inferior_ptid = null_ptid; attach_flag = 0; breakpoint_init_inferior (inf_exited); registers_changed (); @@ -1421,787 +1430,106 @@ generic_mourn_inferior () using hit counts. So don't clear them if we're counting hits. */ if (!show_breakpoint_hit_counts) breakpoint_clear_ignore_counts (); + + if (detach_hook) + detach_hook (); } -/* This table must match in order and size the signals in enum target_signal - in target.h. */ -/* *INDENT-OFF* */ -static struct { - char *name; - char *string; - } signals [] = -{ - {"0", "Signal 0"}, - {"SIGHUP", "Hangup"}, - {"SIGINT", "Interrupt"}, - {"SIGQUIT", "Quit"}, - {"SIGILL", "Illegal instruction"}, - {"SIGTRAP", "Trace/breakpoint trap"}, - {"SIGABRT", "Aborted"}, - {"SIGEMT", "Emulation trap"}, - {"SIGFPE", "Arithmetic exception"}, - {"SIGKILL", "Killed"}, - {"SIGBUS", "Bus error"}, - {"SIGSEGV", "Segmentation fault"}, - {"SIGSYS", "Bad system call"}, - {"SIGPIPE", "Broken pipe"}, - {"SIGALRM", "Alarm clock"}, - {"SIGTERM", "Terminated"}, - {"SIGURG", "Urgent I/O condition"}, - {"SIGSTOP", "Stopped (signal)"}, - {"SIGTSTP", "Stopped (user)"}, - {"SIGCONT", "Continued"}, - {"SIGCHLD", "Child status changed"}, - {"SIGTTIN", "Stopped (tty input)"}, - {"SIGTTOU", "Stopped (tty output)"}, - {"SIGIO", "I/O possible"}, - {"SIGXCPU", "CPU time limit exceeded"}, - {"SIGXFSZ", "File size limit exceeded"}, - {"SIGVTALRM", "Virtual timer expired"}, - {"SIGPROF", "Profiling timer expired"}, - {"SIGWINCH", "Window size changed"}, - {"SIGLOST", "Resource lost"}, - {"SIGUSR1", "User defined signal 1"}, - {"SIGUSR2", "User defined signal 2"}, - {"SIGPWR", "Power fail/restart"}, - {"SIGPOLL", "Pollable event occurred"}, - {"SIGWIND", "SIGWIND"}, - {"SIGPHONE", "SIGPHONE"}, - {"SIGWAITING", "Process's LWPs are blocked"}, - {"SIGLWP", "Signal LWP"}, - {"SIGDANGER", "Swap space dangerously low"}, - {"SIGGRANT", "Monitor mode granted"}, - {"SIGRETRACT", "Need to relinquish monitor mode"}, - {"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"}, - {"SIGCANCEL", "LWP internal signal"}, - {"SIG32", "Real-time event 32"}, - -#if defined(MACH) || defined(__MACH__) - /* Mach exceptions */ - {"EXC_BAD_ACCESS", "Could not access memory"}, - {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"}, - {"EXC_ARITHMETIC", "Arithmetic exception"}, - {"EXC_EMULATION", "Emulation instruction"}, - {"EXC_SOFTWARE", "Software generated exception"}, - {"EXC_BREAKPOINT", "Breakpoint"}, +/* Helper function for child_wait and the Lynx derivatives of child_wait. + HOSTSTATUS is the waitstatus from wait() or the equivalent; store our + translation of that in OURSTATUS. */ +void +store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus) +{ +#ifdef CHILD_SPECIAL_WAITSTATUS + /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS + if it wants to deal with hoststatus. */ + if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus)) + return; #endif - {"SIGINFO", "Information request"}, - - {NULL, "Unknown signal"}, - {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"}, - - /* Last entry, used to check whether the table is the right size. */ - {NULL, "TARGET_SIGNAL_MAGIC"} -}; -/* *INDENT-ON* */ - - -/* Return the string for a signal. */ -char * -target_signal_to_string (sig) - enum target_signal sig; -{ - if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST)) - return signals[sig].string; + if (WIFEXITED (hoststatus)) + { + ourstatus->kind = TARGET_WAITKIND_EXITED; + ourstatus->value.integer = WEXITSTATUS (hoststatus); + } + else if (!WIFSTOPPED (hoststatus)) + { + ourstatus->kind = TARGET_WAITKIND_SIGNALLED; + ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus)); + } else - return signals[TARGET_SIGNAL_UNKNOWN].string; + { + ourstatus->kind = TARGET_WAITKIND_STOPPED; + ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus)); + } } + +/* Returns zero to leave the inferior alone, one to interrupt it. */ +int (*target_activity_function) (void); +int target_activity_fd; + +/* Convert a normal process ID to a string. Returns the string in a static + buffer. */ -/* Return the name for a signal. */ char * -target_signal_to_name (sig) - enum target_signal sig; +normal_pid_to_str (ptid_t ptid) { - if (sig == TARGET_SIGNAL_UNKNOWN) - /* I think the code which prints this will always print it along with - the string, so no need to be verbose. */ - return "?"; - return signals[sig].name; -} - -/* Given a name, return its signal. */ -enum target_signal -target_signal_from_name (name) - char *name; -{ - enum target_signal sig; - - /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD" - for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more - questionable; seems like by now people should call it SIGABRT - instead. */ + static char buf[30]; - /* This ugly cast brought to you by the native VAX compiler. */ - for (sig = TARGET_SIGNAL_HUP; - signals[sig].name != NULL; - sig = (enum target_signal) ((int) sig + 1)) - if (STREQ (name, signals[sig].name)) - return sig; - return TARGET_SIGNAL_UNKNOWN; + sprintf (buf, "process %d", PIDGET (ptid)); + return buf; } - -/* The following functions are to help certain targets deal - with the signal/waitstatus stuff. They could just as well be in - a file called native-utils.c or unixwaitstatus-utils.c or whatever. */ - -/* Convert host signal to our signals. */ -enum target_signal -target_signal_from_host (hostsig) - int hostsig; -{ - /* A switch statement would make sense but would require special kludges - to deal with the cases where more than one signal has the same number. */ - if (hostsig == 0) - return TARGET_SIGNAL_0; - -#if defined (SIGHUP) - if (hostsig == SIGHUP) - return TARGET_SIGNAL_HUP; -#endif -#if defined (SIGINT) - if (hostsig == SIGINT) - return TARGET_SIGNAL_INT; -#endif -#if defined (SIGQUIT) - if (hostsig == SIGQUIT) - return TARGET_SIGNAL_QUIT; -#endif -#if defined (SIGILL) - if (hostsig == SIGILL) - return TARGET_SIGNAL_ILL; -#endif -#if defined (SIGTRAP) - if (hostsig == SIGTRAP) - return TARGET_SIGNAL_TRAP; -#endif -#if defined (SIGABRT) - if (hostsig == SIGABRT) - return TARGET_SIGNAL_ABRT; -#endif -#if defined (SIGEMT) - if (hostsig == SIGEMT) - return TARGET_SIGNAL_EMT; -#endif -#if defined (SIGFPE) - if (hostsig == SIGFPE) - return TARGET_SIGNAL_FPE; -#endif -#if defined (SIGKILL) - if (hostsig == SIGKILL) - return TARGET_SIGNAL_KILL; -#endif -#if defined (SIGBUS) - if (hostsig == SIGBUS) - return TARGET_SIGNAL_BUS; -#endif -#if defined (SIGSEGV) - if (hostsig == SIGSEGV) - return TARGET_SIGNAL_SEGV; -#endif -#if defined (SIGSYS) - if (hostsig == SIGSYS) - return TARGET_SIGNAL_SYS; -#endif -#if defined (SIGPIPE) - if (hostsig == SIGPIPE) - return TARGET_SIGNAL_PIPE; -#endif -#if defined (SIGALRM) - if (hostsig == SIGALRM) - return TARGET_SIGNAL_ALRM; -#endif -#if defined (SIGTERM) - if (hostsig == SIGTERM) - return TARGET_SIGNAL_TERM; -#endif -#if defined (SIGUSR1) - if (hostsig == SIGUSR1) - return TARGET_SIGNAL_USR1; -#endif -#if defined (SIGUSR2) - if (hostsig == SIGUSR2) - return TARGET_SIGNAL_USR2; -#endif -#if defined (SIGCLD) - if (hostsig == SIGCLD) - return TARGET_SIGNAL_CHLD; -#endif -#if defined (SIGCHLD) - if (hostsig == SIGCHLD) - return TARGET_SIGNAL_CHLD; -#endif -#if defined (SIGPWR) - if (hostsig == SIGPWR) - return TARGET_SIGNAL_PWR; -#endif -#if defined (SIGWINCH) - if (hostsig == SIGWINCH) - return TARGET_SIGNAL_WINCH; -#endif -#if defined (SIGURG) - if (hostsig == SIGURG) - return TARGET_SIGNAL_URG; -#endif -#if defined (SIGIO) - if (hostsig == SIGIO) - return TARGET_SIGNAL_IO; -#endif -#if defined (SIGPOLL) - if (hostsig == SIGPOLL) - return TARGET_SIGNAL_POLL; -#endif -#if defined (SIGSTOP) - if (hostsig == SIGSTOP) - return TARGET_SIGNAL_STOP; -#endif -#if defined (SIGTSTP) - if (hostsig == SIGTSTP) - return TARGET_SIGNAL_TSTP; -#endif -#if defined (SIGCONT) - if (hostsig == SIGCONT) - return TARGET_SIGNAL_CONT; -#endif -#if defined (SIGTTIN) - if (hostsig == SIGTTIN) - return TARGET_SIGNAL_TTIN; -#endif -#if defined (SIGTTOU) - if (hostsig == SIGTTOU) - return TARGET_SIGNAL_TTOU; -#endif -#if defined (SIGVTALRM) - if (hostsig == SIGVTALRM) - return TARGET_SIGNAL_VTALRM; -#endif -#if defined (SIGPROF) - if (hostsig == SIGPROF) - return TARGET_SIGNAL_PROF; -#endif -#if defined (SIGXCPU) - if (hostsig == SIGXCPU) - return TARGET_SIGNAL_XCPU; -#endif -#if defined (SIGXFSZ) - if (hostsig == SIGXFSZ) - return TARGET_SIGNAL_XFSZ; -#endif -#if defined (SIGWIND) - if (hostsig == SIGWIND) - return TARGET_SIGNAL_WIND; -#endif -#if defined (SIGPHONE) - if (hostsig == SIGPHONE) - return TARGET_SIGNAL_PHONE; -#endif -#if defined (SIGLOST) - if (hostsig == SIGLOST) - return TARGET_SIGNAL_LOST; -#endif -#if defined (SIGWAITING) - if (hostsig == SIGWAITING) - return TARGET_SIGNAL_WAITING; -#endif -#if defined (SIGCANCEL) - if (hostsig == SIGCANCEL) - return TARGET_SIGNAL_CANCEL; -#endif -#if defined (SIGLWP) - if (hostsig == SIGLWP) - return TARGET_SIGNAL_LWP; -#endif -#if defined (SIGDANGER) - if (hostsig == SIGDANGER) - return TARGET_SIGNAL_DANGER; -#endif -#if defined (SIGGRANT) - if (hostsig == SIGGRANT) - return TARGET_SIGNAL_GRANT; -#endif -#if defined (SIGRETRACT) - if (hostsig == SIGRETRACT) - return TARGET_SIGNAL_RETRACT; -#endif -#if defined (SIGMSG) - if (hostsig == SIGMSG) - return TARGET_SIGNAL_MSG; -#endif -#if defined (SIGSOUND) - if (hostsig == SIGSOUND) - return TARGET_SIGNAL_SOUND; -#endif -#if defined (SIGSAK) - if (hostsig == SIGSAK) - return TARGET_SIGNAL_SAK; -#endif -#if defined (SIGPRIO) - if (hostsig == SIGPRIO) - return TARGET_SIGNAL_PRIO; -#endif - - /* Mach exceptions. Assumes that the values for EXC_ are positive! */ -#if defined (EXC_BAD_ACCESS) && defined (_NSIG) - if (hostsig == _NSIG + EXC_BAD_ACCESS) - return TARGET_EXC_BAD_ACCESS; -#endif -#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) - if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) - return TARGET_EXC_BAD_INSTRUCTION; -#endif -#if defined (EXC_ARITHMETIC) && defined (_NSIG) - if (hostsig == _NSIG + EXC_ARITHMETIC) - return TARGET_EXC_ARITHMETIC; -#endif -#if defined (EXC_EMULATION) && defined (_NSIG) - if (hostsig == _NSIG + EXC_EMULATION) - return TARGET_EXC_EMULATION; -#endif -#if defined (EXC_SOFTWARE) && defined (_NSIG) - if (hostsig == _NSIG + EXC_SOFTWARE) - return TARGET_EXC_SOFTWARE; -#endif -#if defined (EXC_BREAKPOINT) && defined (_NSIG) - if (hostsig == _NSIG + EXC_BREAKPOINT) - return TARGET_EXC_BREAKPOINT; -#endif - -#if defined (SIGINFO) - if (hostsig == SIGINFO) - return TARGET_SIGNAL_INFO; -#endif - -#if defined (REALTIME_LO) - if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI) - { - /* This block of TARGET_SIGNAL_REALTIME value is in order. */ - if (33 <= hostsig && hostsig <= 63) - return (enum target_signal) - (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33); - else if (hostsig == 32) - return TARGET_SIGNAL_REALTIME_32; - else - error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal"); - } -#endif - return TARGET_SIGNAL_UNKNOWN; -} - -/* Convert a OURSIG (an enum target_signal) to the form used by the - target operating system (refered to as the ``host'') or zero if the - equivalent host signal is not available. Set/clear OURSIG_OK - accordingly. */ - -static int -do_target_signal_to_host (enum target_signal oursig, - int *oursig_ok) -{ - *oursig_ok = 1; - switch (oursig) - { - case TARGET_SIGNAL_0: - return 0; - -#if defined (SIGHUP) - case TARGET_SIGNAL_HUP: - return SIGHUP; -#endif -#if defined (SIGINT) - case TARGET_SIGNAL_INT: - return SIGINT; -#endif -#if defined (SIGQUIT) - case TARGET_SIGNAL_QUIT: - return SIGQUIT; -#endif -#if defined (SIGILL) - case TARGET_SIGNAL_ILL: - return SIGILL; -#endif -#if defined (SIGTRAP) - case TARGET_SIGNAL_TRAP: - return SIGTRAP; -#endif -#if defined (SIGABRT) - case TARGET_SIGNAL_ABRT: - return SIGABRT; -#endif -#if defined (SIGEMT) - case TARGET_SIGNAL_EMT: - return SIGEMT; -#endif -#if defined (SIGFPE) - case TARGET_SIGNAL_FPE: - return SIGFPE; -#endif -#if defined (SIGKILL) - case TARGET_SIGNAL_KILL: - return SIGKILL; -#endif -#if defined (SIGBUS) - case TARGET_SIGNAL_BUS: - return SIGBUS; -#endif -#if defined (SIGSEGV) - case TARGET_SIGNAL_SEGV: - return SIGSEGV; -#endif -#if defined (SIGSYS) - case TARGET_SIGNAL_SYS: - return SIGSYS; -#endif -#if defined (SIGPIPE) - case TARGET_SIGNAL_PIPE: - return SIGPIPE; -#endif -#if defined (SIGALRM) - case TARGET_SIGNAL_ALRM: - return SIGALRM; -#endif -#if defined (SIGTERM) - case TARGET_SIGNAL_TERM: - return SIGTERM; -#endif -#if defined (SIGUSR1) - case TARGET_SIGNAL_USR1: - return SIGUSR1; -#endif -#if defined (SIGUSR2) - case TARGET_SIGNAL_USR2: - return SIGUSR2; -#endif -#if defined (SIGCHLD) || defined (SIGCLD) - case TARGET_SIGNAL_CHLD: -#if defined (SIGCHLD) - return SIGCHLD; -#else - return SIGCLD; -#endif -#endif /* SIGCLD or SIGCHLD */ -#if defined (SIGPWR) - case TARGET_SIGNAL_PWR: - return SIGPWR; -#endif -#if defined (SIGWINCH) - case TARGET_SIGNAL_WINCH: - return SIGWINCH; -#endif -#if defined (SIGURG) - case TARGET_SIGNAL_URG: - return SIGURG; -#endif -#if defined (SIGIO) - case TARGET_SIGNAL_IO: - return SIGIO; -#endif -#if defined (SIGPOLL) - case TARGET_SIGNAL_POLL: - return SIGPOLL; -#endif -#if defined (SIGSTOP) - case TARGET_SIGNAL_STOP: - return SIGSTOP; -#endif -#if defined (SIGTSTP) - case TARGET_SIGNAL_TSTP: - return SIGTSTP; -#endif -#if defined (SIGCONT) - case TARGET_SIGNAL_CONT: - return SIGCONT; -#endif -#if defined (SIGTTIN) - case TARGET_SIGNAL_TTIN: - return SIGTTIN; -#endif -#if defined (SIGTTOU) - case TARGET_SIGNAL_TTOU: - return SIGTTOU; -#endif -#if defined (SIGVTALRM) - case TARGET_SIGNAL_VTALRM: - return SIGVTALRM; -#endif -#if defined (SIGPROF) - case TARGET_SIGNAL_PROF: - return SIGPROF; -#endif -#if defined (SIGXCPU) - case TARGET_SIGNAL_XCPU: - return SIGXCPU; -#endif -#if defined (SIGXFSZ) - case TARGET_SIGNAL_XFSZ: - return SIGXFSZ; -#endif -#if defined (SIGWIND) - case TARGET_SIGNAL_WIND: - return SIGWIND; -#endif -#if defined (SIGPHONE) - case TARGET_SIGNAL_PHONE: - return SIGPHONE; -#endif -#if defined (SIGLOST) - case TARGET_SIGNAL_LOST: - return SIGLOST; -#endif -#if defined (SIGWAITING) - case TARGET_SIGNAL_WAITING: - return SIGWAITING; -#endif -#if defined (SIGCANCEL) - case TARGET_SIGNAL_CANCEL: - return SIGCANCEL; -#endif -#if defined (SIGLWP) - case TARGET_SIGNAL_LWP: - return SIGLWP; -#endif -#if defined (SIGDANGER) - case TARGET_SIGNAL_DANGER: - return SIGDANGER; -#endif -#if defined (SIGGRANT) - case TARGET_SIGNAL_GRANT: - return SIGGRANT; -#endif -#if defined (SIGRETRACT) - case TARGET_SIGNAL_RETRACT: - return SIGRETRACT; -#endif -#if defined (SIGMSG) - case TARGET_SIGNAL_MSG: - return SIGMSG; -#endif -#if defined (SIGSOUND) - case TARGET_SIGNAL_SOUND: - return SIGSOUND; -#endif -#if defined (SIGSAK) - case TARGET_SIGNAL_SAK: - return SIGSAK; -#endif -#if defined (SIGPRIO) - case TARGET_SIGNAL_PRIO: - return SIGPRIO; -#endif - - case TARGET_SIGNAL_REALTIME_32: return 32; /* by definition */ - - /* Mach exceptions. Assumes that the values for EXC_ are positive! */ -#if defined (EXC_BAD_ACCESS) && defined (_NSIG) - case TARGET_EXC_BAD_ACCESS: - return _NSIG + EXC_BAD_ACCESS; -#endif -#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) - case TARGET_EXC_BAD_INSTRUCTION: - return _NSIG + EXC_BAD_INSTRUCTION; -#endif -#if defined (EXC_ARITHMETIC) && defined (_NSIG) - case TARGET_EXC_ARITHMETIC: - return _NSIG + EXC_ARITHMETIC; -#endif -#if defined (EXC_EMULATION) && defined (_NSIG) - case TARGET_EXC_EMULATION: - return _NSIG + EXC_EMULATION; -#endif -#if defined (EXC_SOFTWARE) && defined (_NSIG) - case TARGET_EXC_SOFTWARE: - return _NSIG + EXC_SOFTWARE; -#endif -#if defined (EXC_BREAKPOINT) && defined (_NSIG) - case TARGET_EXC_BREAKPOINT: - return _NSIG + EXC_BREAKPOINT; -#endif - -#if defined (SIGINFO) - case TARGET_SIGNAL_INFO: - return SIGINFO; -#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 - *oursig_ok = 0; - return 0; - } -} - -int -target_signal_to_host_p (enum target_signal oursig) -{ - int oursig_ok; - do_target_signal_to_host (oursig, &oursig_ok); - return oursig_ok; -} - -int -target_signal_to_host (enum target_signal oursig) -{ - int oursig_ok; - int targ_signo = do_target_signal_to_host (oursig, &oursig_ok); - if (!oursig_ok) - { - /* 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", - target_signal_to_name (oursig)); - return 0; - } - else - return targ_signo; -} - -/* Helper function for child_wait and the Lynx derivatives of child_wait. - HOSTSTATUS is the waitstatus from wait() or the equivalent; store our - translation of that in OURSTATUS. */ -void -store_waitstatus (ourstatus, hoststatus) - struct target_waitstatus *ourstatus; - int hoststatus; -{ -#ifdef CHILD_SPECIAL_WAITSTATUS - /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS - if it wants to deal with hoststatus. */ - if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus)) - return; -#endif - - if (WIFEXITED (hoststatus)) - { - ourstatus->kind = TARGET_WAITKIND_EXITED; - ourstatus->value.integer = WEXITSTATUS (hoststatus); - } - else if (!WIFSTOPPED (hoststatus)) - { - ourstatus->kind = TARGET_WAITKIND_SIGNALLED; - ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus)); - } - else - { - ourstatus->kind = TARGET_WAITKIND_STOPPED; - 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)); -int target_activity_fd; - -/* Convert a normal process ID to a string. Returns the string in a static - buffer. */ - -char * -normal_pid_to_str (pid) - int pid; -{ - static char buf[30]; - - if (STREQ (current_target.to_shortname, "remote")) - sprintf (buf, "thread %d", pid); - else - sprintf (buf, "process %d", pid); - - return buf; -} - -/* Some targets (such as ttrace-based HPUX) don't allow us to request - notification of inferior events such as fork and vork immediately - after the inferior is created. (This because of how gdb gets an - inferior created via invoking a shell to do it. In such a scenario, - if the shell init file has commands in it, the shell will fork and - exec for each of those commands, and we will see each such fork - event. Very bad.) +/* Some targets (such as ttrace-based HPUX) don't allow us to request + notification of inferior events such as fork and vork immediately + after the inferior is created. (This because of how gdb gets an + inferior created via invoking a shell to do it. In such a scenario, + if the shell init file has commands in it, the shell will fork and + exec for each of those commands, and we will see each such fork + event. Very bad.) This function is used by all targets that allow us to request notification of forks, etc at inferior creation time; e.g., in target_acknowledge_forked_child. */ static void -normal_target_post_startup_inferior (pid) - int pid; +normal_target_post_startup_inferior (ptid_t ptid) { /* This space intentionally left blank. */ } +/* Error-catcher for target_find_memory_regions */ +/* ARGSUSED */ +static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2) +{ + error ("No target."); + return 0; +} + +/* Error-catcher for target_make_corefile_notes */ +/* ARGSUSED */ +static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2) +{ + error ("No target."); + return NULL; +} + /* Set up the handful of non-empty slots needed by the dummy target vector. */ static void -init_dummy_target () +init_dummy_target (void) { dummy_target.to_shortname = "None"; dummy_target.to_longname = "None"; dummy_target.to_doc = ""; dummy_target.to_attach = find_default_attach; - dummy_target.to_require_attach = find_default_require_attach; - dummy_target.to_require_detach = find_default_require_detach; dummy_target.to_create_inferior = find_default_create_inferior; - dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior; dummy_target.to_pid_to_str = normal_pid_to_str; dummy_target.to_stratum = dummy_stratum; + dummy_target.to_find_memory_regions = dummy_find_memory_regions; + dummy_target.to_make_corefile_notes = dummy_make_corefile_notes; dummy_target.to_magic = OPS_MAGIC; } @@ -2209,9 +1537,7 @@ init_dummy_target () static struct target_ops debug_target; static void -debug_to_open (args, from_tty) - char *args; - int from_tty; +debug_to_open (char *args, int from_tty) { debug_target.to_open (args, from_tty); @@ -2219,8 +1545,7 @@ debug_to_open (args, from_tty) } static void -debug_to_close (quitting) - int quitting; +debug_to_close (int quitting) { debug_target.to_close (quitting); @@ -2228,9 +1553,7 @@ debug_to_close (quitting) } static void -debug_to_attach (args, from_tty) - char *args; - int from_tty; +debug_to_attach (char *args, int from_tty) { debug_target.to_attach (args, from_tty); @@ -2239,8 +1562,7 @@ debug_to_attach (args, from_tty) static void -debug_to_post_attach (pid) - int pid; +debug_to_post_attach (int pid) { debug_target.to_post_attach (pid); @@ -2248,20 +1570,7 @@ debug_to_post_attach (pid) } static void -debug_to_require_attach (args, from_tty) - char *args; - int from_tty; -{ - debug_target.to_require_attach (args, from_tty); - - fprintf_unfiltered (gdb_stdlog, - "target_require_attach (%s, %d)\n", args, from_tty); -} - -static void -debug_to_detach (args, from_tty) - char *args; - int from_tty; +debug_to_detach (char *args, int from_tty) { debug_target.to_detach (args, from_tty); @@ -2269,41 +1578,34 @@ debug_to_detach (args, from_tty) } static void -debug_to_require_detach (pid, args, from_tty) - int pid; - char *args; - int from_tty; +debug_to_disconnect (char *args, int from_tty) { - debug_target.to_require_detach (pid, args, from_tty); + debug_target.to_disconnect (args, from_tty); - fprintf_unfiltered (gdb_stdlog, - "target_require_detach (%d, %s, %d)\n", pid, args, from_tty); + fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n", + args, from_tty); } static void -debug_to_resume (pid, step, siggnal) - int pid; - int step; - enum target_signal siggnal; +debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal) { - debug_target.to_resume (pid, step, siggnal); + debug_target.to_resume (ptid, step, siggnal); - fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", pid, + fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid), step ? "step" : "continue", target_signal_to_name (siggnal)); } -static int -debug_to_wait (pid, status) - int pid; - struct target_waitstatus *status; +static ptid_t +debug_to_wait (ptid_t ptid, struct target_waitstatus *status) { - int retval; + ptid_t retval; - retval = debug_target.to_wait (pid, status); + retval = debug_target.to_wait (ptid, status); fprintf_unfiltered (gdb_stdlog, - "target_wait (%d, status) = %d, ", pid, retval); + "target_wait (%d, status) = %d, ", PIDGET (ptid), + PIDGET (retval)); fprintf_unfiltered (gdb_stdlog, "status->kind = "); switch (status->kind) { @@ -2343,48 +1645,60 @@ debug_to_wait (pid, status) } static void -debug_to_post_wait (pid, status) - int pid; - int status; +debug_to_post_wait (ptid_t ptid, int status) { - debug_target.to_post_wait (pid, status); + debug_target.to_post_wait (ptid, status); fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n", - pid, status); + PIDGET (ptid), status); } static void -debug_to_fetch_registers (regno) - int regno; +debug_print_register (const char * func, int regno) { - debug_target.to_fetch_registers (regno); - - fprintf_unfiltered (gdb_stdlog, "target_fetch_registers (%s)", - regno != -1 ? REGISTER_NAME (regno) : "-1"); - if (regno != -1) - fprintf_unfiltered (gdb_stdlog, " = 0x%lx %ld", - (unsigned long) read_register (regno), - (unsigned long) read_register (regno)); + fprintf_unfiltered (gdb_stdlog, "%s ", func); + if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS + && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0') + fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno)); + else + fprintf_unfiltered (gdb_stdlog, "(%d)", regno); + if (regno >= 0) + { + int i; + unsigned char buf[MAX_REGISTER_SIZE]; + deprecated_read_register_gen (regno, buf); + fprintf_unfiltered (gdb_stdlog, " = "); + for (i = 0; i < REGISTER_RAW_SIZE (regno); i++) + { + fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]); + } + if (REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST)) + { + fprintf_unfiltered (gdb_stdlog, " 0x%s %s", + paddr_nz (read_register (regno)), + paddr_d (read_register (regno))); + } + } fprintf_unfiltered (gdb_stdlog, "\n"); } static void -debug_to_store_registers (regno) - int regno; +debug_to_fetch_registers (int regno) { - debug_target.to_store_registers (regno); + debug_target.to_fetch_registers (regno); + debug_print_register ("target_fetch_registers", regno); +} - if (regno >= 0 && regno < NUM_REGS) - fprintf_unfiltered (gdb_stdlog, "target_store_registers (%s) = 0x%lx %ld\n", - REGISTER_NAME (regno), - (unsigned long) read_register (regno), - (unsigned long) read_register (regno)); - else - fprintf_unfiltered (gdb_stdlog, "target_store_registers (%d)\n", regno); +static void +debug_to_store_registers (int regno) +{ + debug_target.to_store_registers (regno); + debug_print_register ("target_store_registers", regno); + fprintf_unfiltered (gdb_stdlog, "\n"); } static void -debug_to_prepare_to_store () +debug_to_prepare_to_store (void) { debug_target.to_prepare_to_store (); @@ -2392,16 +1706,14 @@ debug_to_prepare_to_store () } static int -debug_to_xfer_memory (memaddr, myaddr, len, write, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *target; +debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct mem_attrib *attrib, + struct target_ops *target) { int retval; - retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target); + retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, + attrib, target); fprintf_unfiltered (gdb_stdlog, "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d", @@ -2429,8 +1741,7 @@ debug_to_xfer_memory (memaddr, myaddr, len, write, target) } static void -debug_to_files_info (target) - struct target_ops *target; +debug_to_files_info (struct target_ops *target) { debug_target.to_files_info (target); @@ -2438,9 +1749,7 @@ debug_to_files_info (target) } static int -debug_to_insert_breakpoint (addr, save) - CORE_ADDR addr; - char *save; +debug_to_insert_breakpoint (CORE_ADDR addr, char *save) { int retval; @@ -2454,9 +1763,7 @@ debug_to_insert_breakpoint (addr, save) } static int -debug_to_remove_breakpoint (addr, save) - CORE_ADDR addr; - char *save; +debug_to_remove_breakpoint (CORE_ADDR addr, char *save) { int retval; @@ -2469,8 +1776,118 @@ debug_to_remove_breakpoint (addr, save) return retval; } +static int +debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty) +{ + int retval; + + retval = debug_target.to_can_use_hw_breakpoint (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_size_ok_for_hw_watchpoint (int byte_count) +{ + CORE_ADDR retval; + + retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count); + + fprintf_unfiltered (gdb_stdlog, + "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n", + (unsigned long) byte_count, + (unsigned long) retval); + return retval; +} + +static int +debug_to_stopped_by_watchpoint (void) +{ + int retval; + + retval = debug_target.to_stopped_by_watchpoint (); + + fprintf_unfiltered (gdb_stdlog, + "STOPPED_BY_WATCHPOINT () = %ld\n", + (unsigned long) retval); + return retval; +} + +static CORE_ADDR +debug_to_stopped_data_address (void) +{ + CORE_ADDR retval; + + retval = debug_target.to_stopped_data_address (); + + fprintf_unfiltered (gdb_stdlog, + "target_stopped_data_address () = 0x%lx\n", + (unsigned long) retval); + return retval; +} + +static int +debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save) +{ + int retval; + + retval = debug_target.to_insert_hw_breakpoint (addr, save); + + fprintf_unfiltered (gdb_stdlog, + "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n", + (unsigned long) addr, + (unsigned long) retval); + return retval; +} + +static int +debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save) +{ + int retval; + + retval = debug_target.to_remove_hw_breakpoint (addr, save); + + fprintf_unfiltered (gdb_stdlog, + "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n", + (unsigned long) addr, + (unsigned long) retval); + return retval; +} + +static int +debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type) +{ + int retval; + + retval = debug_target.to_insert_watchpoint (addr, len, type); + + fprintf_unfiltered (gdb_stdlog, + "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n", + (unsigned long) addr, len, type, (unsigned long) retval); + return retval; +} + +static int +debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type) +{ + int retval; + + retval = debug_target.to_insert_watchpoint (addr, len, type); + + fprintf_unfiltered (gdb_stdlog, + "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n", + (unsigned long) addr, len, type, (unsigned long) retval); + return retval; +} + static void -debug_to_terminal_init () +debug_to_terminal_init (void) { debug_target.to_terminal_init (); @@ -2478,7 +1895,7 @@ debug_to_terminal_init () } static void -debug_to_terminal_inferior () +debug_to_terminal_inferior (void) { debug_target.to_terminal_inferior (); @@ -2486,7 +1903,7 @@ debug_to_terminal_inferior () } static void -debug_to_terminal_ours_for_output () +debug_to_terminal_ours_for_output (void) { debug_target.to_terminal_ours_for_output (); @@ -2494,7 +1911,7 @@ debug_to_terminal_ours_for_output () } static void -debug_to_terminal_ours () +debug_to_terminal_ours (void) { debug_target.to_terminal_ours (); @@ -2502,9 +1919,15 @@ debug_to_terminal_ours () } static void -debug_to_terminal_info (arg, from_tty) - char *arg; - int from_tty; +debug_to_terminal_save_ours (void) +{ + debug_target.to_terminal_save_ours (); + + fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n"); +} + +static void +debug_to_terminal_info (char *arg, int from_tty) { debug_target.to_terminal_info (arg, from_tty); @@ -2513,7 +1936,7 @@ debug_to_terminal_info (arg, from_tty) } static void -debug_to_kill () +debug_to_kill (void) { debug_target.to_kill (); @@ -2521,9 +1944,7 @@ debug_to_kill () } static void -debug_to_load (args, from_tty) - char *args; - int from_tty; +debug_to_load (char *args, int from_tty) { debug_target.to_load (args, from_tty); @@ -2531,9 +1952,7 @@ debug_to_load (args, from_tty) } static int -debug_to_lookup_symbol (name, addrp) - char *name; - CORE_ADDR *addrp; +debug_to_lookup_symbol (char *name, CORE_ADDR *addrp) { int retval; @@ -2545,10 +1964,7 @@ debug_to_lookup_symbol (name, addrp) } static void -debug_to_create_inferior (exec_file, args, env) - char *exec_file; - char *args; - char **env; +debug_to_create_inferior (char *exec_file, char *args, char **env) { debug_target.to_create_inferior (exec_file, args, env); @@ -2557,18 +1973,16 @@ debug_to_create_inferior (exec_file, args, env) } static void -debug_to_post_startup_inferior (pid) - int pid; +debug_to_post_startup_inferior (ptid_t ptid) { - debug_target.to_post_startup_inferior (pid); + debug_target.to_post_startup_inferior (ptid); fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n", - pid); + PIDGET (ptid)); } static void -debug_to_acknowledge_created_inferior (pid) - int pid; +debug_to_acknowledge_created_inferior (int pid) { debug_target.to_acknowledge_created_inferior (pid); @@ -2576,29 +1990,8 @@ debug_to_acknowledge_created_inferior (pid) pid); } -static void -debug_to_clone_and_follow_inferior (child_pid, followed_child) - int child_pid; - int *followed_child; -{ - debug_target.to_clone_and_follow_inferior (child_pid, followed_child); - - fprintf_unfiltered (gdb_stdlog, - "target_clone_and_follow_inferior (%d, %d)\n", - child_pid, *followed_child); -} - -static void -debug_to_post_follow_inferior_by_clone () -{ - debug_target.to_post_follow_inferior_by_clone (); - - fprintf_unfiltered (gdb_stdlog, "target_post_follow_inferior_by_clone ()\n"); -} - static int -debug_to_insert_fork_catchpoint (pid) - int pid; +debug_to_insert_fork_catchpoint (int pid) { int retval; @@ -2611,8 +2004,7 @@ debug_to_insert_fork_catchpoint (pid) } static int -debug_to_remove_fork_catchpoint (pid) - int pid; +debug_to_remove_fork_catchpoint (int pid) { int retval; @@ -2625,8 +2017,7 @@ debug_to_remove_fork_catchpoint (pid) } static int -debug_to_insert_vfork_catchpoint (pid) - int pid; +debug_to_insert_vfork_catchpoint (int pid) { int retval; @@ -2639,8 +2030,7 @@ debug_to_insert_vfork_catchpoint (pid) } static int -debug_to_remove_vfork_catchpoint (pid) - int pid; +debug_to_remove_vfork_catchpoint (int pid) { int retval; @@ -2653,65 +2043,18 @@ debug_to_remove_vfork_catchpoint (pid) } static int -debug_to_has_forked (pid, child_pid) - int pid; - int *child_pid; +debug_to_follow_fork (int follow_child) { - int has_forked; + int retval = debug_target.to_follow_fork (follow_child); - has_forked = debug_target.to_has_forked (pid, child_pid); - - fprintf_unfiltered (gdb_stdlog, "target_has_forked (%d, %d) = %d\n", - pid, *child_pid, has_forked); - - return has_forked; -} - -static int -debug_to_has_vforked (pid, child_pid) - int pid; - int *child_pid; -{ - int has_vforked; + fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n", + follow_child, retval); - has_vforked = debug_target.to_has_vforked (pid, child_pid); - - fprintf_unfiltered (gdb_stdlog, "target_has_vforked (%d, %d) = %d\n", - pid, *child_pid, has_vforked); - - return has_vforked; -} - -static int -debug_to_can_follow_vfork_prior_to_exec () -{ - int can_immediately_follow_vfork; - - can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec (); - - fprintf_unfiltered (gdb_stdlog, "target_can_follow_vfork_prior_to_exec () = %d\n", - can_immediately_follow_vfork); - - return can_immediately_follow_vfork; -} - -static void -debug_to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child) - int parent_pid; - int followed_parent; - int child_pid; - int followed_child; -{ - debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child); - - fprintf_unfiltered (gdb_stdlog, - "target_post_follow_vfork (%d, %d, %d, %d)\n", - parent_pid, followed_parent, child_pid, followed_child); + return retval; } static int -debug_to_insert_exec_catchpoint (pid) - int pid; +debug_to_insert_exec_catchpoint (int pid) { int retval; @@ -2724,8 +2067,7 @@ debug_to_insert_exec_catchpoint (pid) } static int -debug_to_remove_exec_catchpoint (pid) - int pid; +debug_to_remove_exec_catchpoint (int pid) { int retval; @@ -2738,23 +2080,7 @@ debug_to_remove_exec_catchpoint (pid) } static int -debug_to_has_execd (pid, execd_pathname) - int pid; - char **execd_pathname; -{ - int has_execd; - - has_execd = debug_target.to_has_execd (pid, execd_pathname); - - fprintf_unfiltered (gdb_stdlog, "target_has_execd (%d, %s) = %d\n", - pid, (*execd_pathname ? *execd_pathname : ""), - has_execd); - - return has_execd; -} - -static int -debug_to_reported_exec_events_per_exec_call () +debug_to_reported_exec_events_per_exec_call (void) { int reported_exec_events; @@ -2768,42 +2094,7 @@ debug_to_reported_exec_events_per_exec_call () } static int -debug_to_has_syscall_event (pid, kind, syscall_id) - int pid; - enum target_waitkind *kind; - int *syscall_id; -{ - int has_syscall_event; - char *kind_spelling = "??"; - - has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id); - if (has_syscall_event) - { - switch (*kind) - { - case TARGET_WAITKIND_SYSCALL_ENTRY: - kind_spelling = "SYSCALL_ENTRY"; - break; - case TARGET_WAITKIND_SYSCALL_RETURN: - kind_spelling = "SYSCALL_RETURN"; - break; - default: - break; - } - } - - fprintf_unfiltered (gdb_stdlog, - "target_has_syscall_event (%d, %s, %d) = %d\n", - pid, kind_spelling, *syscall_id, has_syscall_event); - - return has_syscall_event; -} - -static int -debug_to_has_exited (pid, wait_status, exit_status) - int pid; - int wait_status; - int *exit_status; +debug_to_has_exited (int pid, int wait_status, int *exit_status) { int has_exited; @@ -2816,7 +2107,7 @@ debug_to_has_exited (pid, wait_status, exit_status) } static void -debug_to_mourn_inferior () +debug_to_mourn_inferior (void) { debug_target.to_mourn_inferior (); @@ -2824,7 +2115,7 @@ debug_to_mourn_inferior () } static int -debug_to_can_run () +debug_to_can_run (void) { int retval; @@ -2836,30 +2127,29 @@ debug_to_can_run () } static void -debug_to_notice_signals (pid) - int pid; +debug_to_notice_signals (ptid_t ptid) { - debug_target.to_notice_signals (pid); + debug_target.to_notice_signals (ptid); - fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n", pid); + fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n", + PIDGET (ptid)); } static int -debug_to_thread_alive (pid) - int pid; +debug_to_thread_alive (ptid_t ptid) { int retval; - retval = debug_target.to_thread_alive (pid); + retval = debug_target.to_thread_alive (ptid); fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n", - pid, retval); + PIDGET (ptid), retval); return retval; } static void -debug_to_find_new_threads () +debug_to_find_new_threads (void) { debug_target.to_find_new_threads (); @@ -2867,7 +2157,7 @@ debug_to_find_new_threads () } static void -debug_to_stop () +debug_to_stop (void) { debug_target.to_stop (); @@ -2875,11 +2165,7 @@ debug_to_stop () } static int -debug_to_query (type, req, resp, siz) - int type; - char *req; - char *resp; - int *siz; +debug_to_query (int type, char *req, char *resp, int *siz) { int retval; @@ -2899,9 +2185,7 @@ debug_to_rcmd (char *command, } static struct symtab_and_line * -debug_to_enable_exception_callback (kind, enable) - enum exception_event_kind kind; - int enable; +debug_to_enable_exception_callback (enum exception_event_kind kind, int enable) { struct symtab_and_line *result; result = debug_target.to_enable_exception_callback (kind, enable); @@ -2912,7 +2196,7 @@ debug_to_enable_exception_callback (kind, enable) } static struct exception_event_record * -debug_to_get_current_exception_event () +debug_to_get_current_exception_event (void) { struct exception_event_record *result; result = debug_target.to_get_current_exception_event (); @@ -2921,8 +2205,7 @@ debug_to_get_current_exception_event () } static char * -debug_to_pid_to_exec_file (pid) - int pid; +debug_to_pid_to_exec_file (int pid) { char *exec_file; @@ -2934,22 +2217,8 @@ debug_to_pid_to_exec_file (pid) return exec_file; } -static char * -debug_to_core_file_to_sym_file (core) - char *core; -{ - char *sym_file; - - sym_file = debug_target.to_core_file_to_sym_file (core); - - fprintf_unfiltered (gdb_stdlog, "target_core_file_to_sym_file (%s) = %s\n", - core, sym_file); - - return sym_file; -} - static void -setup_target_debug () +setup_target_debug (void) { memcpy (&debug_target, ¤t_target, sizeof debug_target); @@ -2957,9 +2226,8 @@ setup_target_debug () current_target.to_close = debug_to_close; current_target.to_attach = debug_to_attach; current_target.to_post_attach = debug_to_post_attach; - current_target.to_require_attach = debug_to_require_attach; current_target.to_detach = debug_to_detach; - current_target.to_require_detach = debug_to_require_detach; + current_target.to_disconnect = debug_to_disconnect; current_target.to_resume = debug_to_resume; current_target.to_wait = debug_to_wait; current_target.to_post_wait = debug_to_post_wait; @@ -2970,10 +2238,19 @@ setup_target_debug () 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_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint; 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_kill = debug_to_kill; current_target.to_load = debug_to_load; @@ -2981,21 +2258,14 @@ setup_target_debug () current_target.to_create_inferior = debug_to_create_inferior; current_target.to_post_startup_inferior = debug_to_post_startup_inferior; current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior; - current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior; - current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone; 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_has_forked = debug_to_has_forked; - current_target.to_has_vforked = debug_to_has_vforked; - current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec; - current_target.to_post_follow_vfork = debug_to_post_follow_vfork; + current_target.to_follow_fork = debug_to_follow_fork; 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_execd = debug_to_has_execd; current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call; - current_target.to_has_syscall_event = debug_to_has_syscall_event; current_target.to_has_exited = debug_to_has_exited; current_target.to_mourn_inferior = debug_to_mourn_inferior; current_target.to_can_run = debug_to_can_run; @@ -3008,7 +2278,6 @@ setup_target_debug () current_target.to_enable_exception_callback = debug_to_enable_exception_callback; current_target.to_get_current_exception_event = debug_to_get_current_exception_event; current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file; - current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file; } @@ -3022,9 +2291,11 @@ static void do_monitor_command (char *cmd, int from_tty) { - if ((current_target.to_rcmd == (void*) tcomplain) + if ((current_target.to_rcmd + == (void (*) (char *, struct ui_file *)) tcomplain) || (current_target.to_rcmd == debug_to_rcmd - && (debug_target.to_rcmd == (void*) tcomplain))) + && (debug_target.to_rcmd + == (void (*) (char *, struct ui_file *)) tcomplain))) { error ("\"monitor\" command not supported by this target.\n"); } @@ -3032,7 +2303,7 @@ do_monitor_command (char *cmd, } void -initialize_targets () +initialize_targets (void) { init_dummy_target (); push_target (&dummy_target); @@ -3040,17 +2311,25 @@ initialize_targets () add_info ("target", target_info, targ_desc); add_info ("files", target_info, targ_desc); - 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); - + add_show_from_set + (add_set_cmd ("target", class_maintenance, var_zinteger, + (char *) &targetdebug, + "Set target debugging.\n\ +When non-zero, target debugging is enabled.", &setdebuglist), + &showdebuglist); + + add_setshow_boolean_cmd ("trust-readonly-sections", class_support, + &trust_readonly, "\ +Set mode for reading from readonly sections.\n\ +When this mode is on, memory reads from readonly sections (such as .text)\n\ +will be read from the object file instead of from the target. This will\n\ +result in significant performance improvement for remote targets.", "\ +Show mode for reading from readonly sections.\n", + NULL, NULL, + &setlist, &showlist); add_com ("monitor", class_obscure, do_monitor_command, "Send a command to the remote monitor (remote targets only)."); - if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC")) - abort (); + target_dcache = dcache_init (); }