1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
35 #include "gdb_assert.h"
37 #include "exceptions.h"
38 #include "target-descriptions.h"
39 #include "gdbthread.h"
42 #include "inline-frame.h"
43 #include "tracepoint.h"
44 #include "gdb/fileio.h"
47 static void target_info (char *, int);
49 static void default_terminal_info (const char *, int);
51 static int default_watchpoint_addr_within_range (struct target_ops *,
52 CORE_ADDR, CORE_ADDR, int);
54 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
56 static void tcomplain (void) ATTRIBUTE_NORETURN;
58 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
60 static int return_zero (void);
62 static int return_one (void);
64 static int return_minus_one (void);
66 void target_ignore (void);
68 static void target_command (char *, int);
70 static struct target_ops *find_default_run_target (char *);
72 static LONGEST default_xfer_partial (struct target_ops *ops,
73 enum target_object object,
74 const char *annex, gdb_byte *readbuf,
75 const gdb_byte *writebuf,
76 ULONGEST offset, LONGEST len);
78 static LONGEST current_xfer_partial (struct target_ops *ops,
79 enum target_object object,
80 const char *annex, gdb_byte *readbuf,
81 const gdb_byte *writebuf,
82 ULONGEST offset, LONGEST len);
84 static LONGEST target_xfer_partial (struct target_ops *ops,
85 enum target_object object,
87 void *readbuf, const void *writebuf,
88 ULONGEST offset, LONGEST len);
90 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
93 static void init_dummy_target (void);
95 static struct target_ops debug_target;
97 static void debug_to_open (char *, int);
99 static void debug_to_prepare_to_store (struct regcache *);
101 static void debug_to_files_info (struct target_ops *);
103 static int debug_to_insert_breakpoint (struct gdbarch *,
104 struct bp_target_info *);
106 static int debug_to_remove_breakpoint (struct gdbarch *,
107 struct bp_target_info *);
109 static int debug_to_can_use_hw_breakpoint (int, int, int);
111 static int debug_to_insert_hw_breakpoint (struct gdbarch *,
112 struct bp_target_info *);
114 static int debug_to_remove_hw_breakpoint (struct gdbarch *,
115 struct bp_target_info *);
117 static int debug_to_insert_watchpoint (CORE_ADDR, int, int,
118 struct expression *);
120 static int debug_to_remove_watchpoint (CORE_ADDR, int, int,
121 struct expression *);
123 static int debug_to_stopped_by_watchpoint (void);
125 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
127 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
128 CORE_ADDR, CORE_ADDR, int);
130 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
132 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR, int, int,
133 struct expression *);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_load (char *, int);
147 static int debug_to_can_run (void);
149 static void debug_to_stop (ptid_t);
151 /* Pointer to array of target architecture structures; the size of the
152 array; the current index into the array; the allocated size of the
154 struct target_ops **target_structs;
155 unsigned target_struct_size;
156 unsigned target_struct_allocsize;
157 #define DEFAULT_ALLOCSIZE 10
159 /* The initial current target, so that there is always a semi-valid
162 static struct target_ops dummy_target;
164 /* Top of target stack. */
166 static struct target_ops *target_stack;
168 /* The target structure we are currently using to talk to a process
169 or file or whatever "inferior" we have. */
171 struct target_ops current_target;
173 /* Command list for target. */
175 static struct cmd_list_element *targetlist = NULL;
177 /* Nonzero if we should trust readonly sections from the
178 executable when reading memory. */
180 static int trust_readonly = 0;
182 /* Nonzero if we should show true memory content including
183 memory breakpoint inserted by gdb. */
185 static int show_memory_breakpoints = 0;
187 /* These globals control whether GDB attempts to perform these
188 operations; they are useful for targets that need to prevent
189 inadvertant disruption, such as in non-stop mode. */
191 int may_write_registers = 1;
193 int may_write_memory = 1;
195 int may_insert_breakpoints = 1;
197 int may_insert_tracepoints = 1;
199 int may_insert_fast_tracepoints = 1;
203 /* Non-zero if we want to see trace of target level stuff. */
205 static unsigned int targetdebug = 0;
207 show_targetdebug (struct ui_file *file, int from_tty,
208 struct cmd_list_element *c, const char *value)
210 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
213 static void setup_target_debug (void);
215 /* The option sets this. */
216 static int stack_cache_enabled_p_1 = 1;
217 /* And set_stack_cache_enabled_p updates this.
218 The reason for the separation is so that we don't flush the cache for
219 on->on transitions. */
220 static int stack_cache_enabled_p = 1;
222 /* This is called *after* the stack-cache has been set.
223 Flush the cache for off->on and on->off transitions.
224 There's no real need to flush the cache for on->off transitions,
225 except cleanliness. */
228 set_stack_cache_enabled_p (char *args, int from_tty,
229 struct cmd_list_element *c)
231 if (stack_cache_enabled_p != stack_cache_enabled_p_1)
232 target_dcache_invalidate ();
234 stack_cache_enabled_p = stack_cache_enabled_p_1;
238 show_stack_cache_enabled_p (struct ui_file *file, int from_tty,
239 struct cmd_list_element *c, const char *value)
241 fprintf_filtered (file, _("Cache use for stack accesses is %s.\n"), value);
244 /* Cache of memory operations, to speed up remote access. */
245 static DCACHE *target_dcache;
247 /* Invalidate the target dcache. */
250 target_dcache_invalidate (void)
252 dcache_invalidate (target_dcache);
255 /* The user just typed 'target' without the name of a target. */
258 target_command (char *arg, int from_tty)
260 fputs_filtered ("Argument required (target name). Try `help target'\n",
264 /* Default target_has_* methods for process_stratum targets. */
267 default_child_has_all_memory (struct target_ops *ops)
269 /* If no inferior selected, then we can't read memory here. */
270 if (ptid_equal (inferior_ptid, null_ptid))
277 default_child_has_memory (struct target_ops *ops)
279 /* If no inferior selected, then we can't read memory here. */
280 if (ptid_equal (inferior_ptid, null_ptid))
287 default_child_has_stack (struct target_ops *ops)
289 /* If no inferior selected, there's no stack. */
290 if (ptid_equal (inferior_ptid, null_ptid))
297 default_child_has_registers (struct target_ops *ops)
299 /* Can't read registers from no inferior. */
300 if (ptid_equal (inferior_ptid, null_ptid))
307 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
309 /* If there's no thread selected, then we can't make it run through
311 if (ptid_equal (the_ptid, null_ptid))
319 target_has_all_memory_1 (void)
321 struct target_ops *t;
323 for (t = current_target.beneath; t != NULL; t = t->beneath)
324 if (t->to_has_all_memory (t))
331 target_has_memory_1 (void)
333 struct target_ops *t;
335 for (t = current_target.beneath; t != NULL; t = t->beneath)
336 if (t->to_has_memory (t))
343 target_has_stack_1 (void)
345 struct target_ops *t;
347 for (t = current_target.beneath; t != NULL; t = t->beneath)
348 if (t->to_has_stack (t))
355 target_has_registers_1 (void)
357 struct target_ops *t;
359 for (t = current_target.beneath; t != NULL; t = t->beneath)
360 if (t->to_has_registers (t))
367 target_has_execution_1 (ptid_t the_ptid)
369 struct target_ops *t;
371 for (t = current_target.beneath; t != NULL; t = t->beneath)
372 if (t->to_has_execution (t, the_ptid))
379 target_has_execution_current (void)
381 return target_has_execution_1 (inferior_ptid);
384 /* Complete initialization of T. This ensures that various fields in
385 T are set, if needed by the target implementation. */
388 complete_target_initialization (struct target_ops *t)
390 /* Provide default values for all "must have" methods. */
391 if (t->to_xfer_partial == NULL)
392 t->to_xfer_partial = default_xfer_partial;
394 if (t->to_has_all_memory == NULL)
395 t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
397 if (t->to_has_memory == NULL)
398 t->to_has_memory = (int (*) (struct target_ops *)) return_zero;
400 if (t->to_has_stack == NULL)
401 t->to_has_stack = (int (*) (struct target_ops *)) return_zero;
403 if (t->to_has_registers == NULL)
404 t->to_has_registers = (int (*) (struct target_ops *)) return_zero;
406 if (t->to_has_execution == NULL)
407 t->to_has_execution = (int (*) (struct target_ops *, ptid_t)) return_zero;
410 /* Add possible target architecture T to the list and add a new
411 command 'target T->to_shortname'. Set COMPLETER as the command's
412 completer if not NULL. */
415 add_target_with_completer (struct target_ops *t,
416 completer_ftype *completer)
418 struct cmd_list_element *c;
420 complete_target_initialization (t);
424 target_struct_allocsize = DEFAULT_ALLOCSIZE;
425 target_structs = (struct target_ops **) xmalloc
426 (target_struct_allocsize * sizeof (*target_structs));
428 if (target_struct_size >= target_struct_allocsize)
430 target_struct_allocsize *= 2;
431 target_structs = (struct target_ops **)
432 xrealloc ((char *) target_structs,
433 target_struct_allocsize * sizeof (*target_structs));
435 target_structs[target_struct_size++] = t;
437 if (targetlist == NULL)
438 add_prefix_cmd ("target", class_run, target_command, _("\
439 Connect to a target machine or process.\n\
440 The first argument is the type or protocol of the target machine.\n\
441 Remaining arguments are interpreted by the target protocol. For more\n\
442 information on the arguments for a particular protocol, type\n\
443 `help target ' followed by the protocol name."),
444 &targetlist, "target ", 0, &cmdlist);
445 c = add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc,
447 if (completer != NULL)
448 set_cmd_completer (c, completer);
451 /* Add a possible target architecture to the list. */
454 add_target (struct target_ops *t)
456 add_target_with_completer (t, NULL);
462 add_deprecated_target_alias (struct target_ops *t, char *alias)
464 struct cmd_list_element *c;
467 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
469 c = add_cmd (alias, no_class, t->to_open, t->to_doc, &targetlist);
470 alt = xstrprintf ("target %s", t->to_shortname);
471 deprecate_cmd (c, alt);
484 struct target_ops *t;
486 for (t = current_target.beneath; t != NULL; t = t->beneath)
487 if (t->to_kill != NULL)
490 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
500 target_load (char *arg, int from_tty)
502 target_dcache_invalidate ();
503 (*current_target.to_load) (arg, from_tty);
507 target_create_inferior (char *exec_file, char *args,
508 char **env, int from_tty)
510 struct target_ops *t;
512 for (t = current_target.beneath; t != NULL; t = t->beneath)
514 if (t->to_create_inferior != NULL)
516 t->to_create_inferior (t, exec_file, args, env, from_tty);
518 fprintf_unfiltered (gdb_stdlog,
519 "target_create_inferior (%s, %s, xxx, %d)\n",
520 exec_file, args, from_tty);
525 internal_error (__FILE__, __LINE__,
526 _("could not find a target to create inferior"));
530 target_terminal_inferior (void)
532 /* A background resume (``run&'') should leave GDB in control of the
533 terminal. Use target_can_async_p, not target_is_async_p, since at
534 this point the target is not async yet. However, if sync_execution
535 is not set, we know it will become async prior to resume. */
536 if (target_can_async_p () && !sync_execution)
539 /* If GDB is resuming the inferior in the foreground, install
540 inferior's terminal modes. */
541 (*current_target.to_terminal_inferior) ();
545 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
546 struct target_ops *t)
548 errno = EIO; /* Can't read/write this location. */
549 return 0; /* No bytes handled. */
555 error (_("You can't do that when your target is `%s'"),
556 current_target.to_shortname);
562 error (_("You can't do that without a process to debug."));
566 default_terminal_info (const char *args, int from_tty)
568 printf_unfiltered (_("No saved terminal information.\n"));
571 /* A default implementation for the to_get_ada_task_ptid target method.
573 This function builds the PTID by using both LWP and TID as part of
574 the PTID lwp and tid elements. The pid used is the pid of the
578 default_get_ada_task_ptid (long lwp, long tid)
580 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
583 static enum exec_direction_kind
584 default_execution_direction (void)
586 if (!target_can_execute_reverse)
588 else if (!target_can_async_p ())
591 gdb_assert_not_reached ("\
592 to_execution_direction must be implemented for reverse async");
595 /* Go through the target stack from top to bottom, copying over zero
596 entries in current_target, then filling in still empty entries. In
597 effect, we are doing class inheritance through the pushed target
600 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
601 is currently implemented, is that it discards any knowledge of
602 which target an inherited method originally belonged to.
603 Consequently, new new target methods should instead explicitly and
604 locally search the target stack for the target that can handle the
608 update_current_target (void)
610 struct target_ops *t;
612 /* First, reset current's contents. */
613 memset (¤t_target, 0, sizeof (current_target));
615 #define INHERIT(FIELD, TARGET) \
616 if (!current_target.FIELD) \
617 current_target.FIELD = (TARGET)->FIELD
619 for (t = target_stack; t; t = t->beneath)
621 INHERIT (to_shortname, t);
622 INHERIT (to_longname, t);
624 /* Do not inherit to_open. */
625 /* Do not inherit to_close. */
626 /* Do not inherit to_attach. */
627 INHERIT (to_post_attach, t);
628 INHERIT (to_attach_no_wait, t);
629 /* Do not inherit to_detach. */
630 /* Do not inherit to_disconnect. */
631 /* Do not inherit to_resume. */
632 /* Do not inherit to_wait. */
633 /* Do not inherit to_fetch_registers. */
634 /* Do not inherit to_store_registers. */
635 INHERIT (to_prepare_to_store, t);
636 INHERIT (deprecated_xfer_memory, t);
637 INHERIT (to_files_info, t);
638 INHERIT (to_insert_breakpoint, t);
639 INHERIT (to_remove_breakpoint, t);
640 INHERIT (to_can_use_hw_breakpoint, t);
641 INHERIT (to_insert_hw_breakpoint, t);
642 INHERIT (to_remove_hw_breakpoint, t);
643 /* Do not inherit to_ranged_break_num_registers. */
644 INHERIT (to_insert_watchpoint, t);
645 INHERIT (to_remove_watchpoint, t);
646 /* Do not inherit to_insert_mask_watchpoint. */
647 /* Do not inherit to_remove_mask_watchpoint. */
648 INHERIT (to_stopped_data_address, t);
649 INHERIT (to_have_steppable_watchpoint, t);
650 INHERIT (to_have_continuable_watchpoint, t);
651 INHERIT (to_stopped_by_watchpoint, t);
652 INHERIT (to_watchpoint_addr_within_range, t);
653 INHERIT (to_region_ok_for_hw_watchpoint, t);
654 INHERIT (to_can_accel_watchpoint_condition, t);
655 /* Do not inherit to_masked_watch_num_registers. */
656 INHERIT (to_terminal_init, t);
657 INHERIT (to_terminal_inferior, t);
658 INHERIT (to_terminal_ours_for_output, t);
659 INHERIT (to_terminal_ours, t);
660 INHERIT (to_terminal_save_ours, t);
661 INHERIT (to_terminal_info, t);
662 /* Do not inherit to_kill. */
663 INHERIT (to_load, t);
664 /* Do no inherit to_create_inferior. */
665 INHERIT (to_post_startup_inferior, t);
666 INHERIT (to_insert_fork_catchpoint, t);
667 INHERIT (to_remove_fork_catchpoint, t);
668 INHERIT (to_insert_vfork_catchpoint, t);
669 INHERIT (to_remove_vfork_catchpoint, t);
670 /* Do not inherit to_follow_fork. */
671 INHERIT (to_insert_exec_catchpoint, t);
672 INHERIT (to_remove_exec_catchpoint, t);
673 INHERIT (to_set_syscall_catchpoint, t);
674 INHERIT (to_has_exited, t);
675 /* Do not inherit to_mourn_inferior. */
676 INHERIT (to_can_run, t);
677 /* Do not inherit to_pass_signals. */
678 /* Do not inherit to_program_signals. */
679 /* Do not inherit to_thread_alive. */
680 /* Do not inherit to_find_new_threads. */
681 /* Do not inherit to_pid_to_str. */
682 INHERIT (to_extra_thread_info, t);
683 INHERIT (to_thread_name, t);
684 INHERIT (to_stop, t);
685 /* Do not inherit to_xfer_partial. */
686 INHERIT (to_rcmd, t);
687 INHERIT (to_pid_to_exec_file, t);
688 INHERIT (to_log_command, t);
689 INHERIT (to_stratum, t);
690 /* Do not inherit to_has_all_memory. */
691 /* Do not inherit to_has_memory. */
692 /* Do not inherit to_has_stack. */
693 /* Do not inherit to_has_registers. */
694 /* Do not inherit to_has_execution. */
695 INHERIT (to_has_thread_control, t);
696 INHERIT (to_can_async_p, t);
697 INHERIT (to_is_async_p, t);
698 INHERIT (to_async, t);
699 INHERIT (to_find_memory_regions, t);
700 INHERIT (to_make_corefile_notes, t);
701 INHERIT (to_get_bookmark, t);
702 INHERIT (to_goto_bookmark, t);
703 /* Do not inherit to_get_thread_local_address. */
704 INHERIT (to_can_execute_reverse, t);
705 INHERIT (to_execution_direction, t);
706 INHERIT (to_thread_architecture, t);
707 /* Do not inherit to_read_description. */
708 INHERIT (to_get_ada_task_ptid, t);
709 /* Do not inherit to_search_memory. */
710 INHERIT (to_supports_multi_process, t);
711 INHERIT (to_supports_enable_disable_tracepoint, t);
712 INHERIT (to_supports_string_tracing, t);
713 INHERIT (to_trace_init, t);
714 INHERIT (to_download_tracepoint, t);
715 INHERIT (to_can_download_tracepoint, t);
716 INHERIT (to_download_trace_state_variable, t);
717 INHERIT (to_enable_tracepoint, t);
718 INHERIT (to_disable_tracepoint, t);
719 INHERIT (to_trace_set_readonly_regions, t);
720 INHERIT (to_trace_start, t);
721 INHERIT (to_get_trace_status, t);
722 INHERIT (to_get_tracepoint_status, t);
723 INHERIT (to_trace_stop, t);
724 INHERIT (to_trace_find, t);
725 INHERIT (to_get_trace_state_variable_value, t);
726 INHERIT (to_save_trace_data, t);
727 INHERIT (to_upload_tracepoints, t);
728 INHERIT (to_upload_trace_state_variables, t);
729 INHERIT (to_get_raw_trace_data, t);
730 INHERIT (to_get_min_fast_tracepoint_insn_len, t);
731 INHERIT (to_set_disconnected_tracing, t);
732 INHERIT (to_set_circular_trace_buffer, t);
733 INHERIT (to_set_trace_buffer_size, t);
734 INHERIT (to_set_trace_notes, t);
735 INHERIT (to_get_tib_address, t);
736 INHERIT (to_set_permissions, t);
737 INHERIT (to_static_tracepoint_marker_at, t);
738 INHERIT (to_static_tracepoint_markers_by_strid, t);
739 INHERIT (to_traceframe_info, t);
740 INHERIT (to_use_agent, t);
741 INHERIT (to_can_use_agent, t);
742 INHERIT (to_augmented_libraries_svr4_read, t);
743 INHERIT (to_magic, t);
744 INHERIT (to_supports_evaluation_of_breakpoint_conditions, t);
745 INHERIT (to_can_run_breakpoint_commands, t);
746 /* Do not inherit to_memory_map. */
747 /* Do not inherit to_flash_erase. */
748 /* Do not inherit to_flash_done. */
752 /* Clean up a target struct so it no longer has any zero pointers in
753 it. Some entries are defaulted to a method that print an error,
754 others are hard-wired to a standard recursive default. */
756 #define de_fault(field, value) \
757 if (!current_target.field) \
758 current_target.field = value
761 (void (*) (char *, int))
766 de_fault (to_post_attach,
769 de_fault (to_prepare_to_store,
770 (void (*) (struct regcache *))
772 de_fault (deprecated_xfer_memory,
773 (int (*) (CORE_ADDR, gdb_byte *, int, int,
774 struct mem_attrib *, struct target_ops *))
776 de_fault (to_files_info,
777 (void (*) (struct target_ops *))
779 de_fault (to_insert_breakpoint,
780 memory_insert_breakpoint);
781 de_fault (to_remove_breakpoint,
782 memory_remove_breakpoint);
783 de_fault (to_can_use_hw_breakpoint,
784 (int (*) (int, int, int))
786 de_fault (to_insert_hw_breakpoint,
787 (int (*) (struct gdbarch *, struct bp_target_info *))
789 de_fault (to_remove_hw_breakpoint,
790 (int (*) (struct gdbarch *, struct bp_target_info *))
792 de_fault (to_insert_watchpoint,
793 (int (*) (CORE_ADDR, int, int, struct expression *))
795 de_fault (to_remove_watchpoint,
796 (int (*) (CORE_ADDR, int, int, struct expression *))
798 de_fault (to_stopped_by_watchpoint,
801 de_fault (to_stopped_data_address,
802 (int (*) (struct target_ops *, CORE_ADDR *))
804 de_fault (to_watchpoint_addr_within_range,
805 default_watchpoint_addr_within_range);
806 de_fault (to_region_ok_for_hw_watchpoint,
807 default_region_ok_for_hw_watchpoint);
808 de_fault (to_can_accel_watchpoint_condition,
809 (int (*) (CORE_ADDR, int, int, struct expression *))
811 de_fault (to_terminal_init,
814 de_fault (to_terminal_inferior,
817 de_fault (to_terminal_ours_for_output,
820 de_fault (to_terminal_ours,
823 de_fault (to_terminal_save_ours,
826 de_fault (to_terminal_info,
827 default_terminal_info);
829 (void (*) (char *, int))
831 de_fault (to_post_startup_inferior,
834 de_fault (to_insert_fork_catchpoint,
837 de_fault (to_remove_fork_catchpoint,
840 de_fault (to_insert_vfork_catchpoint,
843 de_fault (to_remove_vfork_catchpoint,
846 de_fault (to_insert_exec_catchpoint,
849 de_fault (to_remove_exec_catchpoint,
852 de_fault (to_set_syscall_catchpoint,
853 (int (*) (int, int, int, int, int *))
855 de_fault (to_has_exited,
856 (int (*) (int, int, int *))
858 de_fault (to_can_run,
860 de_fault (to_extra_thread_info,
861 (char *(*) (struct thread_info *))
863 de_fault (to_thread_name,
864 (char *(*) (struct thread_info *))
869 current_target.to_xfer_partial = current_xfer_partial;
871 (void (*) (char *, struct ui_file *))
873 de_fault (to_pid_to_exec_file,
877 (void (*) (void (*) (enum inferior_event_type, void*), void*))
879 de_fault (to_thread_architecture,
880 default_thread_architecture);
881 current_target.to_read_description = NULL;
882 de_fault (to_get_ada_task_ptid,
883 (ptid_t (*) (long, long))
884 default_get_ada_task_ptid);
885 de_fault (to_supports_multi_process,
888 de_fault (to_supports_enable_disable_tracepoint,
891 de_fault (to_supports_string_tracing,
894 de_fault (to_trace_init,
897 de_fault (to_download_tracepoint,
898 (void (*) (struct bp_location *))
900 de_fault (to_can_download_tracepoint,
903 de_fault (to_download_trace_state_variable,
904 (void (*) (struct trace_state_variable *))
906 de_fault (to_enable_tracepoint,
907 (void (*) (struct bp_location *))
909 de_fault (to_disable_tracepoint,
910 (void (*) (struct bp_location *))
912 de_fault (to_trace_set_readonly_regions,
915 de_fault (to_trace_start,
918 de_fault (to_get_trace_status,
919 (int (*) (struct trace_status *))
921 de_fault (to_get_tracepoint_status,
922 (void (*) (struct breakpoint *, struct uploaded_tp *))
924 de_fault (to_trace_stop,
927 de_fault (to_trace_find,
928 (int (*) (enum trace_find_type, int, CORE_ADDR, CORE_ADDR, int *))
930 de_fault (to_get_trace_state_variable_value,
931 (int (*) (int, LONGEST *))
933 de_fault (to_save_trace_data,
934 (int (*) (const char *))
936 de_fault (to_upload_tracepoints,
937 (int (*) (struct uploaded_tp **))
939 de_fault (to_upload_trace_state_variables,
940 (int (*) (struct uploaded_tsv **))
942 de_fault (to_get_raw_trace_data,
943 (LONGEST (*) (gdb_byte *, ULONGEST, LONGEST))
945 de_fault (to_get_min_fast_tracepoint_insn_len,
948 de_fault (to_set_disconnected_tracing,
951 de_fault (to_set_circular_trace_buffer,
954 de_fault (to_set_trace_buffer_size,
957 de_fault (to_set_trace_notes,
958 (int (*) (const char *, const char *, const char *))
960 de_fault (to_get_tib_address,
961 (int (*) (ptid_t, CORE_ADDR *))
963 de_fault (to_set_permissions,
966 de_fault (to_static_tracepoint_marker_at,
967 (int (*) (CORE_ADDR, struct static_tracepoint_marker *))
969 de_fault (to_static_tracepoint_markers_by_strid,
970 (VEC(static_tracepoint_marker_p) * (*) (const char *))
972 de_fault (to_traceframe_info,
973 (struct traceframe_info * (*) (void))
975 de_fault (to_supports_evaluation_of_breakpoint_conditions,
978 de_fault (to_can_run_breakpoint_commands,
981 de_fault (to_use_agent,
984 de_fault (to_can_use_agent,
987 de_fault (to_augmented_libraries_svr4_read,
990 de_fault (to_execution_direction, default_execution_direction);
994 /* Finally, position the target-stack beneath the squashed
995 "current_target". That way code looking for a non-inherited
996 target method can quickly and simply find it. */
997 current_target.beneath = target_stack;
1000 setup_target_debug ();
1003 /* Push a new target type into the stack of the existing target accessors,
1004 possibly superseding some of the existing accessors.
1006 Rather than allow an empty stack, we always have the dummy target at
1007 the bottom stratum, so we can call the function vectors without
1011 push_target (struct target_ops *t)
1013 struct target_ops **cur;
1015 /* Check magic number. If wrong, it probably means someone changed
1016 the struct definition, but not all the places that initialize one. */
1017 if (t->to_magic != OPS_MAGIC)
1019 fprintf_unfiltered (gdb_stderr,
1020 "Magic number of %s target struct wrong\n",
1022 internal_error (__FILE__, __LINE__,
1023 _("failed internal consistency check"));
1026 /* Find the proper stratum to install this target in. */
1027 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
1029 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
1033 /* If there's already targets at this stratum, remove them. */
1034 /* FIXME: cagney/2003-10-15: I think this should be popping all
1035 targets to CUR, and not just those at this stratum level. */
1036 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
1038 /* There's already something at this stratum level. Close it,
1039 and un-hook it from the stack. */
1040 struct target_ops *tmp = (*cur);
1042 (*cur) = (*cur)->beneath;
1043 tmp->beneath = NULL;
1047 /* We have removed all targets in our stratum, now add the new one. */
1048 t->beneath = (*cur);
1051 update_current_target ();
1054 /* Remove a target_ops vector from the stack, wherever it may be.
1055 Return how many times it was removed (0 or 1). */
1058 unpush_target (struct target_ops *t)
1060 struct target_ops **cur;
1061 struct target_ops *tmp;
1063 if (t->to_stratum == dummy_stratum)
1064 internal_error (__FILE__, __LINE__,
1065 _("Attempt to unpush the dummy target"));
1067 /* Look for the specified target. Note that we assume that a target
1068 can only occur once in the target stack. */
1070 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
1076 /* If we don't find target_ops, quit. Only open targets should be
1081 /* Unchain the target. */
1083 (*cur) = (*cur)->beneath;
1084 tmp->beneath = NULL;
1086 update_current_target ();
1088 /* Finally close the target. Note we do this after unchaining, so
1089 any target method calls from within the target_close
1090 implementation don't end up in T anymore. */
1099 target_close (target_stack); /* Let it clean up. */
1100 if (unpush_target (target_stack) == 1)
1103 fprintf_unfiltered (gdb_stderr,
1104 "pop_target couldn't find target %s\n",
1105 current_target.to_shortname);
1106 internal_error (__FILE__, __LINE__,
1107 _("failed internal consistency check"));
1111 pop_all_targets_above (enum strata above_stratum)
1113 while ((int) (current_target.to_stratum) > (int) above_stratum)
1115 target_close (target_stack);
1116 if (!unpush_target (target_stack))
1118 fprintf_unfiltered (gdb_stderr,
1119 "pop_all_targets couldn't find target %s\n",
1120 target_stack->to_shortname);
1121 internal_error (__FILE__, __LINE__,
1122 _("failed internal consistency check"));
1129 pop_all_targets (void)
1131 pop_all_targets_above (dummy_stratum);
1134 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1137 target_is_pushed (struct target_ops *t)
1139 struct target_ops **cur;
1141 /* Check magic number. If wrong, it probably means someone changed
1142 the struct definition, but not all the places that initialize one. */
1143 if (t->to_magic != OPS_MAGIC)
1145 fprintf_unfiltered (gdb_stderr,
1146 "Magic number of %s target struct wrong\n",
1148 internal_error (__FILE__, __LINE__,
1149 _("failed internal consistency check"));
1152 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
1159 /* Using the objfile specified in OBJFILE, find the address for the
1160 current thread's thread-local storage with offset OFFSET. */
1162 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
1164 volatile CORE_ADDR addr = 0;
1165 struct target_ops *target;
1167 for (target = current_target.beneath;
1169 target = target->beneath)
1171 if (target->to_get_thread_local_address != NULL)
1176 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1178 ptid_t ptid = inferior_ptid;
1179 volatile struct gdb_exception ex;
1181 TRY_CATCH (ex, RETURN_MASK_ALL)
1185 /* Fetch the load module address for this objfile. */
1186 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1188 /* If it's 0, throw the appropriate exception. */
1190 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
1191 _("TLS load module not found"));
1193 addr = target->to_get_thread_local_address (target, ptid,
1196 /* If an error occurred, print TLS related messages here. Otherwise,
1197 throw the error to some higher catcher. */
1200 int objfile_is_library = (objfile->flags & OBJF_SHARED);
1204 case TLS_NO_LIBRARY_SUPPORT_ERROR:
1205 error (_("Cannot find thread-local variables "
1206 "in this thread library."));
1208 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
1209 if (objfile_is_library)
1210 error (_("Cannot find shared library `%s' in dynamic"
1211 " linker's load module list"), objfile->name);
1213 error (_("Cannot find executable file `%s' in dynamic"
1214 " linker's load module list"), objfile->name);
1216 case TLS_NOT_ALLOCATED_YET_ERROR:
1217 if (objfile_is_library)
1218 error (_("The inferior has not yet allocated storage for"
1219 " thread-local variables in\n"
1220 "the shared library `%s'\n"
1222 objfile->name, target_pid_to_str (ptid));
1224 error (_("The inferior has not yet allocated storage for"
1225 " thread-local variables in\n"
1226 "the executable `%s'\n"
1228 objfile->name, target_pid_to_str (ptid));
1230 case TLS_GENERIC_ERROR:
1231 if (objfile_is_library)
1232 error (_("Cannot find thread-local storage for %s, "
1233 "shared library %s:\n%s"),
1234 target_pid_to_str (ptid),
1235 objfile->name, ex.message);
1237 error (_("Cannot find thread-local storage for %s, "
1238 "executable file %s:\n%s"),
1239 target_pid_to_str (ptid),
1240 objfile->name, ex.message);
1243 throw_exception (ex);
1248 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1249 TLS is an ABI-specific thing. But we don't do that yet. */
1251 error (_("Cannot find thread-local variables on this target"));
1257 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1259 /* target_read_string -- read a null terminated string, up to LEN bytes,
1260 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1261 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1262 is responsible for freeing it. Return the number of bytes successfully
1266 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
1268 int tlen, offset, i;
1272 int buffer_allocated;
1274 unsigned int nbytes_read = 0;
1276 gdb_assert (string);
1278 /* Small for testing. */
1279 buffer_allocated = 4;
1280 buffer = xmalloc (buffer_allocated);
1285 tlen = MIN (len, 4 - (memaddr & 3));
1286 offset = memaddr & 3;
1288 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
1291 /* The transfer request might have crossed the boundary to an
1292 unallocated region of memory. Retry the transfer, requesting
1296 errcode = target_read_memory (memaddr, buf, 1);
1301 if (bufptr - buffer + tlen > buffer_allocated)
1305 bytes = bufptr - buffer;
1306 buffer_allocated *= 2;
1307 buffer = xrealloc (buffer, buffer_allocated);
1308 bufptr = buffer + bytes;
1311 for (i = 0; i < tlen; i++)
1313 *bufptr++ = buf[i + offset];
1314 if (buf[i + offset] == '\000')
1316 nbytes_read += i + 1;
1323 nbytes_read += tlen;
1332 struct target_section_table *
1333 target_get_section_table (struct target_ops *target)
1335 struct target_ops *t;
1338 fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
1340 for (t = target; t != NULL; t = t->beneath)
1341 if (t->to_get_section_table != NULL)
1342 return (*t->to_get_section_table) (t);
1347 /* Find a section containing ADDR. */
1349 struct target_section *
1350 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1352 struct target_section_table *table = target_get_section_table (target);
1353 struct target_section *secp;
1358 for (secp = table->sections; secp < table->sections_end; secp++)
1360 if (addr >= secp->addr && addr < secp->endaddr)
1366 /* Read memory from the live target, even if currently inspecting a
1367 traceframe. The return is the same as that of target_read. */
1370 target_read_live_memory (enum target_object object,
1371 ULONGEST memaddr, gdb_byte *myaddr, LONGEST len)
1374 struct cleanup *cleanup;
1376 /* Switch momentarily out of tfind mode so to access live memory.
1377 Note that this must not clear global state, such as the frame
1378 cache, which must still remain valid for the previous traceframe.
1379 We may be _building_ the frame cache at this point. */
1380 cleanup = make_cleanup_restore_traceframe_number ();
1381 set_traceframe_number (-1);
1383 ret = target_read (current_target.beneath, object, NULL,
1384 myaddr, memaddr, len);
1386 do_cleanups (cleanup);
1390 /* Using the set of read-only target sections of OPS, read live
1391 read-only memory. Note that the actual reads start from the
1392 top-most target again.
1394 For interface/parameters/return description see target.h,
1398 memory_xfer_live_readonly_partial (struct target_ops *ops,
1399 enum target_object object,
1400 gdb_byte *readbuf, ULONGEST memaddr,
1403 struct target_section *secp;
1404 struct target_section_table *table;
1406 secp = target_section_by_addr (ops, memaddr);
1408 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1409 secp->the_bfd_section)
1412 struct target_section *p;
1413 ULONGEST memend = memaddr + len;
1415 table = target_get_section_table (ops);
1417 for (p = table->sections; p < table->sections_end; p++)
1419 if (memaddr >= p->addr)
1421 if (memend <= p->endaddr)
1423 /* Entire transfer is within this section. */
1424 return target_read_live_memory (object, memaddr,
1427 else if (memaddr >= p->endaddr)
1429 /* This section ends before the transfer starts. */
1434 /* This section overlaps the transfer. Just do half. */
1435 len = p->endaddr - memaddr;
1436 return target_read_live_memory (object, memaddr,
1446 /* Perform a partial memory transfer.
1447 For docs see target.h, to_xfer_partial. */
1450 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
1451 void *readbuf, const void *writebuf, ULONGEST memaddr,
1456 struct mem_region *region;
1457 struct inferior *inf;
1459 /* For accesses to unmapped overlay sections, read directly from
1460 files. Must do this first, as MEMADDR may need adjustment. */
1461 if (readbuf != NULL && overlay_debugging)
1463 struct obj_section *section = find_pc_overlay (memaddr);
1465 if (pc_in_unmapped_range (memaddr, section))
1467 struct target_section_table *table
1468 = target_get_section_table (ops);
1469 const char *section_name = section->the_bfd_section->name;
1471 memaddr = overlay_mapped_address (memaddr, section);
1472 return section_table_xfer_memory_partial (readbuf, writebuf,
1475 table->sections_end,
1480 /* Try the executable files, if "trust-readonly-sections" is set. */
1481 if (readbuf != NULL && trust_readonly)
1483 struct target_section *secp;
1484 struct target_section_table *table;
1486 secp = target_section_by_addr (ops, memaddr);
1488 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1489 secp->the_bfd_section)
1492 table = target_get_section_table (ops);
1493 return section_table_xfer_memory_partial (readbuf, writebuf,
1496 table->sections_end,
1501 /* If reading unavailable memory in the context of traceframes, and
1502 this address falls within a read-only section, fallback to
1503 reading from live memory. */
1504 if (readbuf != NULL && get_traceframe_number () != -1)
1506 VEC(mem_range_s) *available;
1508 /* If we fail to get the set of available memory, then the
1509 target does not support querying traceframe info, and so we
1510 attempt reading from the traceframe anyway (assuming the
1511 target implements the old QTro packet then). */
1512 if (traceframe_available_memory (&available, memaddr, len))
1514 struct cleanup *old_chain;
1516 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
1518 if (VEC_empty (mem_range_s, available)
1519 || VEC_index (mem_range_s, available, 0)->start != memaddr)
1521 /* Don't read into the traceframe's available
1523 if (!VEC_empty (mem_range_s, available))
1525 LONGEST oldlen = len;
1527 len = VEC_index (mem_range_s, available, 0)->start - memaddr;
1528 gdb_assert (len <= oldlen);
1531 do_cleanups (old_chain);
1533 /* This goes through the topmost target again. */
1534 res = memory_xfer_live_readonly_partial (ops, object,
1535 readbuf, memaddr, len);
1539 /* No use trying further, we know some memory starting
1540 at MEMADDR isn't available. */
1544 /* Don't try to read more than how much is available, in
1545 case the target implements the deprecated QTro packet to
1546 cater for older GDBs (the target's knowledge of read-only
1547 sections may be outdated by now). */
1548 len = VEC_index (mem_range_s, available, 0)->length;
1550 do_cleanups (old_chain);
1554 /* Try GDB's internal data cache. */
1555 region = lookup_mem_region (memaddr);
1556 /* region->hi == 0 means there's no upper bound. */
1557 if (memaddr + len < region->hi || region->hi == 0)
1560 reg_len = region->hi - memaddr;
1562 switch (region->attrib.mode)
1565 if (writebuf != NULL)
1570 if (readbuf != NULL)
1575 /* We only support writing to flash during "load" for now. */
1576 if (writebuf != NULL)
1577 error (_("Writing to flash memory forbidden in this context"));
1584 if (!ptid_equal (inferior_ptid, null_ptid))
1585 inf = find_inferior_pid (ptid_get_pid (inferior_ptid));
1590 /* The dcache reads whole cache lines; that doesn't play well
1591 with reading from a trace buffer, because reading outside of
1592 the collected memory range fails. */
1593 && get_traceframe_number () == -1
1594 && (region->attrib.cache
1595 || (stack_cache_enabled_p && object == TARGET_OBJECT_STACK_MEMORY)))
1597 if (readbuf != NULL)
1598 res = dcache_xfer_memory (ops, target_dcache, memaddr, readbuf,
1601 /* FIXME drow/2006-08-09: If we're going to preserve const
1602 correctness dcache_xfer_memory should take readbuf and
1604 res = dcache_xfer_memory (ops, target_dcache, memaddr,
1613 /* If none of those methods found the memory we wanted, fall back
1614 to a target partial transfer. Normally a single call to
1615 to_xfer_partial is enough; if it doesn't recognize an object
1616 it will call the to_xfer_partial of the next target down.
1617 But for memory this won't do. Memory is the only target
1618 object which can be read from more than one valid target.
1619 A core file, for instance, could have some of memory but
1620 delegate other bits to the target below it. So, we must
1621 manually try all targets. */
1625 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1626 readbuf, writebuf, memaddr, reg_len);
1630 /* We want to continue past core files to executables, but not
1631 past a running target's memory. */
1632 if (ops->to_has_all_memory (ops))
1637 while (ops != NULL);
1639 /* Make sure the cache gets updated no matter what - if we are writing
1640 to the stack. Even if this write is not tagged as such, we still need
1641 to update the cache. */
1646 && !region->attrib.cache
1647 && stack_cache_enabled_p
1648 && object != TARGET_OBJECT_STACK_MEMORY)
1650 dcache_update (target_dcache, memaddr, (void *) writebuf, res);
1653 /* If we still haven't got anything, return the last error. We
1658 /* Perform a partial memory transfer. For docs see target.h,
1662 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1663 void *readbuf, const void *writebuf, ULONGEST memaddr,
1668 /* Zero length requests are ok and require no work. */
1672 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1673 breakpoint insns, thus hiding out from higher layers whether
1674 there are software breakpoints inserted in the code stream. */
1675 if (readbuf != NULL)
1677 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len);
1679 if (res > 0 && !show_memory_breakpoints)
1680 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, res);
1685 struct cleanup *old_chain;
1687 buf = xmalloc (len);
1688 old_chain = make_cleanup (xfree, buf);
1689 memcpy (buf, writebuf, len);
1691 breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
1692 res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len);
1694 do_cleanups (old_chain);
1701 restore_show_memory_breakpoints (void *arg)
1703 show_memory_breakpoints = (uintptr_t) arg;
1707 make_show_memory_breakpoints_cleanup (int show)
1709 int current = show_memory_breakpoints;
1711 show_memory_breakpoints = show;
1712 return make_cleanup (restore_show_memory_breakpoints,
1713 (void *) (uintptr_t) current);
1716 /* For docs see target.h, to_xfer_partial. */
1719 target_xfer_partial (struct target_ops *ops,
1720 enum target_object object, const char *annex,
1721 void *readbuf, const void *writebuf,
1722 ULONGEST offset, LONGEST len)
1726 gdb_assert (ops->to_xfer_partial != NULL);
1728 if (writebuf && !may_write_memory)
1729 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1730 core_addr_to_string_nz (offset), plongest (len));
1732 /* If this is a memory transfer, let the memory-specific code
1733 have a look at it instead. Memory transfers are more
1735 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY)
1736 retval = memory_xfer_partial (ops, object, readbuf,
1737 writebuf, offset, len);
1740 enum target_object raw_object = object;
1742 /* If this is a raw memory transfer, request the normal
1743 memory object from other layers. */
1744 if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1745 raw_object = TARGET_OBJECT_MEMORY;
1747 retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1748 writebuf, offset, len);
1753 const unsigned char *myaddr = NULL;
1755 fprintf_unfiltered (gdb_stdlog,
1756 "%s:target_xfer_partial "
1757 "(%d, %s, %s, %s, %s, %s) = %s",
1760 (annex ? annex : "(null)"),
1761 host_address_to_string (readbuf),
1762 host_address_to_string (writebuf),
1763 core_addr_to_string_nz (offset),
1764 plongest (len), plongest (retval));
1770 if (retval > 0 && myaddr != NULL)
1774 fputs_unfiltered (", bytes =", gdb_stdlog);
1775 for (i = 0; i < retval; i++)
1777 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1779 if (targetdebug < 2 && i > 0)
1781 fprintf_unfiltered (gdb_stdlog, " ...");
1784 fprintf_unfiltered (gdb_stdlog, "\n");
1787 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1791 fputc_unfiltered ('\n', gdb_stdlog);
1796 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1797 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1798 if any error occurs.
1800 If an error occurs, no guarantee is made about the contents of the data at
1801 MYADDR. In particular, the caller should not depend upon partial reads
1802 filling the buffer with good data. There is no way for the caller to know
1803 how much good data might have been transfered anyway. Callers that can
1804 deal with partial reads should call target_read (which will retry until
1805 it makes no progress, and then return how much was transferred). */
1808 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1810 /* Dispatch to the topmost target, not the flattened current_target.
1811 Memory accesses check target->to_has_(all_)memory, and the
1812 flattened target doesn't inherit those. */
1813 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1814 myaddr, memaddr, len) == len)
1820 /* Like target_read_memory, but specify explicitly that this is a read from
1821 the target's stack. This may trigger different cache behavior. */
1824 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1826 /* Dispatch to the topmost target, not the flattened current_target.
1827 Memory accesses check target->to_has_(all_)memory, and the
1828 flattened target doesn't inherit those. */
1830 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1831 myaddr, memaddr, len) == len)
1837 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1838 Returns either 0 for success or an errno value if any error occurs.
1839 If an error occurs, no guarantee is made about how much data got written.
1840 Callers that can deal with partial writes should call target_write. */
1843 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1845 /* Dispatch to the topmost target, not the flattened current_target.
1846 Memory accesses check target->to_has_(all_)memory, and the
1847 flattened target doesn't inherit those. */
1848 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1849 myaddr, memaddr, len) == len)
1855 /* Write LEN bytes from MYADDR to target raw memory at address
1856 MEMADDR. Returns either 0 for success or an errno value if any
1857 error occurs. If an error occurs, no guarantee is made about how
1858 much data got written. Callers that can deal with partial writes
1859 should call target_write. */
1862 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1864 /* Dispatch to the topmost target, not the flattened current_target.
1865 Memory accesses check target->to_has_(all_)memory, and the
1866 flattened target doesn't inherit those. */
1867 if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1868 myaddr, memaddr, len) == len)
1874 /* Fetch the target's memory map. */
1877 target_memory_map (void)
1879 VEC(mem_region_s) *result;
1880 struct mem_region *last_one, *this_one;
1882 struct target_ops *t;
1885 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1887 for (t = current_target.beneath; t != NULL; t = t->beneath)
1888 if (t->to_memory_map != NULL)
1894 result = t->to_memory_map (t);
1898 qsort (VEC_address (mem_region_s, result),
1899 VEC_length (mem_region_s, result),
1900 sizeof (struct mem_region), mem_region_cmp);
1902 /* Check that regions do not overlap. Simultaneously assign
1903 a numbering for the "mem" commands to use to refer to
1906 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1908 this_one->number = ix;
1910 if (last_one && last_one->hi > this_one->lo)
1912 warning (_("Overlapping regions in memory map: ignoring"));
1913 VEC_free (mem_region_s, result);
1916 last_one = this_one;
1923 target_flash_erase (ULONGEST address, LONGEST length)
1925 struct target_ops *t;
1927 for (t = current_target.beneath; t != NULL; t = t->beneath)
1928 if (t->to_flash_erase != NULL)
1931 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1932 hex_string (address), phex (length, 0));
1933 t->to_flash_erase (t, address, length);
1941 target_flash_done (void)
1943 struct target_ops *t;
1945 for (t = current_target.beneath; t != NULL; t = t->beneath)
1946 if (t->to_flash_done != NULL)
1949 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1950 t->to_flash_done (t);
1958 show_trust_readonly (struct ui_file *file, int from_tty,
1959 struct cmd_list_element *c, const char *value)
1961 fprintf_filtered (file,
1962 _("Mode for reading from readonly sections is %s.\n"),
1966 /* More generic transfers. */
1969 default_xfer_partial (struct target_ops *ops, enum target_object object,
1970 const char *annex, gdb_byte *readbuf,
1971 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1973 if (object == TARGET_OBJECT_MEMORY
1974 && ops->deprecated_xfer_memory != NULL)
1975 /* If available, fall back to the target's
1976 "deprecated_xfer_memory" method. */
1981 if (writebuf != NULL)
1983 void *buffer = xmalloc (len);
1984 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1986 memcpy (buffer, writebuf, len);
1987 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1988 1/*write*/, NULL, ops);
1989 do_cleanups (cleanup);
1991 if (readbuf != NULL)
1992 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1993 0/*read*/, NULL, ops);
1996 else if (xfered == 0 && errno == 0)
1997 /* "deprecated_xfer_memory" uses 0, cross checked against
1998 ERRNO as one indication of an error. */
2003 else if (ops->beneath != NULL)
2004 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2005 readbuf, writebuf, offset, len);
2010 /* The xfer_partial handler for the topmost target. Unlike the default,
2011 it does not need to handle memory specially; it just passes all
2012 requests down the stack. */
2015 current_xfer_partial (struct target_ops *ops, enum target_object object,
2016 const char *annex, gdb_byte *readbuf,
2017 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2019 if (ops->beneath != NULL)
2020 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2021 readbuf, writebuf, offset, len);
2026 /* Target vector read/write partial wrapper functions. */
2029 target_read_partial (struct target_ops *ops,
2030 enum target_object object,
2031 const char *annex, gdb_byte *buf,
2032 ULONGEST offset, LONGEST len)
2034 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
2038 target_write_partial (struct target_ops *ops,
2039 enum target_object object,
2040 const char *annex, const gdb_byte *buf,
2041 ULONGEST offset, LONGEST len)
2043 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
2046 /* Wrappers to perform the full transfer. */
2048 /* For docs on target_read see target.h. */
2051 target_read (struct target_ops *ops,
2052 enum target_object object,
2053 const char *annex, gdb_byte *buf,
2054 ULONGEST offset, LONGEST len)
2058 while (xfered < len)
2060 LONGEST xfer = target_read_partial (ops, object, annex,
2061 (gdb_byte *) buf + xfered,
2062 offset + xfered, len - xfered);
2064 /* Call an observer, notifying them of the xfer progress? */
2075 /* Assuming that the entire [begin, end) range of memory cannot be
2076 read, try to read whatever subrange is possible to read.
2078 The function returns, in RESULT, either zero or one memory block.
2079 If there's a readable subrange at the beginning, it is completely
2080 read and returned. Any further readable subrange will not be read.
2081 Otherwise, if there's a readable subrange at the end, it will be
2082 completely read and returned. Any readable subranges before it
2083 (obviously, not starting at the beginning), will be ignored. In
2084 other cases -- either no readable subrange, or readable subrange(s)
2085 that is neither at the beginning, or end, nothing is returned.
2087 The purpose of this function is to handle a read across a boundary
2088 of accessible memory in a case when memory map is not available.
2089 The above restrictions are fine for this case, but will give
2090 incorrect results if the memory is 'patchy'. However, supporting
2091 'patchy' memory would require trying to read every single byte,
2092 and it seems unacceptable solution. Explicit memory map is
2093 recommended for this case -- and target_read_memory_robust will
2094 take care of reading multiple ranges then. */
2097 read_whatever_is_readable (struct target_ops *ops,
2098 ULONGEST begin, ULONGEST end,
2099 VEC(memory_read_result_s) **result)
2101 gdb_byte *buf = xmalloc (end - begin);
2102 ULONGEST current_begin = begin;
2103 ULONGEST current_end = end;
2105 memory_read_result_s r;
2107 /* If we previously failed to read 1 byte, nothing can be done here. */
2108 if (end - begin <= 1)
2114 /* Check that either first or the last byte is readable, and give up
2115 if not. This heuristic is meant to permit reading accessible memory
2116 at the boundary of accessible region. */
2117 if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2118 buf, begin, 1) == 1)
2123 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2124 buf + (end-begin) - 1, end - 1, 1) == 1)
2135 /* Loop invariant is that the [current_begin, current_end) was previously
2136 found to be not readable as a whole.
2138 Note loop condition -- if the range has 1 byte, we can't divide the range
2139 so there's no point trying further. */
2140 while (current_end - current_begin > 1)
2142 ULONGEST first_half_begin, first_half_end;
2143 ULONGEST second_half_begin, second_half_end;
2145 ULONGEST middle = current_begin + (current_end - current_begin)/2;
2149 first_half_begin = current_begin;
2150 first_half_end = middle;
2151 second_half_begin = middle;
2152 second_half_end = current_end;
2156 first_half_begin = middle;
2157 first_half_end = current_end;
2158 second_half_begin = current_begin;
2159 second_half_end = middle;
2162 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2163 buf + (first_half_begin - begin),
2165 first_half_end - first_half_begin);
2167 if (xfer == first_half_end - first_half_begin)
2169 /* This half reads up fine. So, the error must be in the
2171 current_begin = second_half_begin;
2172 current_end = second_half_end;
2176 /* This half is not readable. Because we've tried one byte, we
2177 know some part of this half if actually redable. Go to the next
2178 iteration to divide again and try to read.
2180 We don't handle the other half, because this function only tries
2181 to read a single readable subrange. */
2182 current_begin = first_half_begin;
2183 current_end = first_half_end;
2189 /* The [begin, current_begin) range has been read. */
2191 r.end = current_begin;
2196 /* The [current_end, end) range has been read. */
2197 LONGEST rlen = end - current_end;
2199 r.data = xmalloc (rlen);
2200 memcpy (r.data, buf + current_end - begin, rlen);
2201 r.begin = current_end;
2205 VEC_safe_push(memory_read_result_s, (*result), &r);
2209 free_memory_read_result_vector (void *x)
2211 VEC(memory_read_result_s) *v = x;
2212 memory_read_result_s *current;
2215 for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
2217 xfree (current->data);
2219 VEC_free (memory_read_result_s, v);
2222 VEC(memory_read_result_s) *
2223 read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
2225 VEC(memory_read_result_s) *result = 0;
2228 while (xfered < len)
2230 struct mem_region *region = lookup_mem_region (offset + xfered);
2233 /* If there is no explicit region, a fake one should be created. */
2234 gdb_assert (region);
2236 if (region->hi == 0)
2237 rlen = len - xfered;
2239 rlen = region->hi - offset;
2241 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
2243 /* Cannot read this region. Note that we can end up here only
2244 if the region is explicitly marked inaccessible, or
2245 'inaccessible-by-default' is in effect. */
2250 LONGEST to_read = min (len - xfered, rlen);
2251 gdb_byte *buffer = (gdb_byte *)xmalloc (to_read);
2253 LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2254 (gdb_byte *) buffer,
2255 offset + xfered, to_read);
2256 /* Call an observer, notifying them of the xfer progress? */
2259 /* Got an error reading full chunk. See if maybe we can read
2262 read_whatever_is_readable (ops, offset + xfered,
2263 offset + xfered + to_read, &result);
2268 struct memory_read_result r;
2270 r.begin = offset + xfered;
2271 r.end = r.begin + xfer;
2272 VEC_safe_push (memory_read_result_s, result, &r);
2282 /* An alternative to target_write with progress callbacks. */
2285 target_write_with_progress (struct target_ops *ops,
2286 enum target_object object,
2287 const char *annex, const gdb_byte *buf,
2288 ULONGEST offset, LONGEST len,
2289 void (*progress) (ULONGEST, void *), void *baton)
2293 /* Give the progress callback a chance to set up. */
2295 (*progress) (0, baton);
2297 while (xfered < len)
2299 LONGEST xfer = target_write_partial (ops, object, annex,
2300 (gdb_byte *) buf + xfered,
2301 offset + xfered, len - xfered);
2309 (*progress) (xfer, baton);
2317 /* For docs on target_write see target.h. */
2320 target_write (struct target_ops *ops,
2321 enum target_object object,
2322 const char *annex, const gdb_byte *buf,
2323 ULONGEST offset, LONGEST len)
2325 return target_write_with_progress (ops, object, annex, buf, offset, len,
2329 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2330 the size of the transferred data. PADDING additional bytes are
2331 available in *BUF_P. This is a helper function for
2332 target_read_alloc; see the declaration of that function for more
2336 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
2337 const char *annex, gdb_byte **buf_p, int padding)
2339 size_t buf_alloc, buf_pos;
2343 /* This function does not have a length parameter; it reads the
2344 entire OBJECT). Also, it doesn't support objects fetched partly
2345 from one target and partly from another (in a different stratum,
2346 e.g. a core file and an executable). Both reasons make it
2347 unsuitable for reading memory. */
2348 gdb_assert (object != TARGET_OBJECT_MEMORY);
2350 /* Start by reading up to 4K at a time. The target will throttle
2351 this number down if necessary. */
2353 buf = xmalloc (buf_alloc);
2357 n = target_read_partial (ops, object, annex, &buf[buf_pos],
2358 buf_pos, buf_alloc - buf_pos - padding);
2361 /* An error occurred. */
2367 /* Read all there was. */
2377 /* If the buffer is filling up, expand it. */
2378 if (buf_alloc < buf_pos * 2)
2381 buf = xrealloc (buf, buf_alloc);
2388 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2389 the size of the transferred data. See the declaration in "target.h"
2390 function for more information about the return value. */
2393 target_read_alloc (struct target_ops *ops, enum target_object object,
2394 const char *annex, gdb_byte **buf_p)
2396 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
2399 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2400 returned as a string, allocated using xmalloc. If an error occurs
2401 or the transfer is unsupported, NULL is returned. Empty objects
2402 are returned as allocated but empty strings. A warning is issued
2403 if the result contains any embedded NUL bytes. */
2406 target_read_stralloc (struct target_ops *ops, enum target_object object,
2411 LONGEST i, transferred;
2413 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
2414 bufstr = (char *) buffer;
2416 if (transferred < 0)
2419 if (transferred == 0)
2420 return xstrdup ("");
2422 bufstr[transferred] = 0;
2424 /* Check for embedded NUL bytes; but allow trailing NULs. */
2425 for (i = strlen (bufstr); i < transferred; i++)
2428 warning (_("target object %d, annex %s, "
2429 "contained unexpected null characters"),
2430 (int) object, annex ? annex : "(none)");
2437 /* Memory transfer methods. */
2440 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2443 /* This method is used to read from an alternate, non-current
2444 target. This read must bypass the overlay support (as symbols
2445 don't match this target), and GDB's internal cache (wrong cache
2446 for this target). */
2447 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2449 memory_error (EIO, addr);
2453 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2454 int len, enum bfd_endian byte_order)
2456 gdb_byte buf[sizeof (ULONGEST)];
2458 gdb_assert (len <= sizeof (buf));
2459 get_target_memory (ops, addr, buf, len);
2460 return extract_unsigned_integer (buf, len, byte_order);
2464 target_insert_breakpoint (struct gdbarch *gdbarch,
2465 struct bp_target_info *bp_tgt)
2467 if (!may_insert_breakpoints)
2469 warning (_("May not insert breakpoints"));
2473 return (*current_target.to_insert_breakpoint) (gdbarch, bp_tgt);
2477 target_remove_breakpoint (struct gdbarch *gdbarch,
2478 struct bp_target_info *bp_tgt)
2480 /* This is kind of a weird case to handle, but the permission might
2481 have been changed after breakpoints were inserted - in which case
2482 we should just take the user literally and assume that any
2483 breakpoints should be left in place. */
2484 if (!may_insert_breakpoints)
2486 warning (_("May not remove breakpoints"));
2490 return (*current_target.to_remove_breakpoint) (gdbarch, bp_tgt);
2494 target_info (char *args, int from_tty)
2496 struct target_ops *t;
2497 int has_all_mem = 0;
2499 if (symfile_objfile != NULL)
2500 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
2502 for (t = target_stack; t != NULL; t = t->beneath)
2504 if (!(*t->to_has_memory) (t))
2507 if ((int) (t->to_stratum) <= (int) dummy_stratum)
2510 printf_unfiltered (_("\tWhile running this, "
2511 "GDB does not access memory from...\n"));
2512 printf_unfiltered ("%s:\n", t->to_longname);
2513 (t->to_files_info) (t);
2514 has_all_mem = (*t->to_has_all_memory) (t);
2518 /* This function is called before any new inferior is created, e.g.
2519 by running a program, attaching, or connecting to a target.
2520 It cleans up any state from previous invocations which might
2521 change between runs. This is a subset of what target_preopen
2522 resets (things which might change between targets). */
2525 target_pre_inferior (int from_tty)
2527 /* Clear out solib state. Otherwise the solib state of the previous
2528 inferior might have survived and is entirely wrong for the new
2529 target. This has been observed on GNU/Linux using glibc 2.3. How
2541 Cannot access memory at address 0xdeadbeef
2544 /* In some OSs, the shared library list is the same/global/shared
2545 across inferiors. If code is shared between processes, so are
2546 memory regions and features. */
2547 if (!gdbarch_has_global_solist (target_gdbarch ()))
2549 no_shared_libraries (NULL, from_tty);
2551 invalidate_target_mem_regions ();
2553 target_clear_description ();
2556 agent_capability_invalidate ();
2559 /* Callback for iterate_over_inferiors. Gets rid of the given
2563 dispose_inferior (struct inferior *inf, void *args)
2565 struct thread_info *thread;
2567 thread = any_thread_of_process (inf->pid);
2570 switch_to_thread (thread->ptid);
2572 /* Core inferiors actually should be detached, not killed. */
2573 if (target_has_execution)
2576 target_detach (NULL, 0);
2582 /* This is to be called by the open routine before it does
2586 target_preopen (int from_tty)
2590 if (have_inferiors ())
2593 || !have_live_inferiors ()
2594 || query (_("A program is being debugged already. Kill it? ")))
2595 iterate_over_inferiors (dispose_inferior, NULL);
2597 error (_("Program not killed."));
2600 /* Calling target_kill may remove the target from the stack. But if
2601 it doesn't (which seems like a win for UDI), remove it now. */
2602 /* Leave the exec target, though. The user may be switching from a
2603 live process to a core of the same program. */
2604 pop_all_targets_above (file_stratum);
2606 target_pre_inferior (from_tty);
2609 /* Detach a target after doing deferred register stores. */
2612 target_detach (char *args, int from_tty)
2614 struct target_ops* t;
2616 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2617 /* Don't remove global breakpoints here. They're removed on
2618 disconnection from the target. */
2621 /* If we're in breakpoints-always-inserted mode, have to remove
2622 them before detaching. */
2623 remove_breakpoints_pid (PIDGET (inferior_ptid));
2625 prepare_for_detach ();
2627 for (t = current_target.beneath; t != NULL; t = t->beneath)
2629 if (t->to_detach != NULL)
2631 t->to_detach (t, args, from_tty);
2633 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
2639 internal_error (__FILE__, __LINE__, _("could not find a target to detach"));
2643 target_disconnect (char *args, int from_tty)
2645 struct target_ops *t;
2647 /* If we're in breakpoints-always-inserted mode or if breakpoints
2648 are global across processes, we have to remove them before
2650 remove_breakpoints ();
2652 for (t = current_target.beneath; t != NULL; t = t->beneath)
2653 if (t->to_disconnect != NULL)
2656 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
2658 t->to_disconnect (t, args, from_tty);
2666 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2668 struct target_ops *t;
2670 for (t = current_target.beneath; t != NULL; t = t->beneath)
2672 if (t->to_wait != NULL)
2674 ptid_t retval = (*t->to_wait) (t, ptid, status, options);
2678 char *status_string;
2679 char *options_string;
2681 status_string = target_waitstatus_to_string (status);
2682 options_string = target_options_to_string (options);
2683 fprintf_unfiltered (gdb_stdlog,
2684 "target_wait (%d, status, options={%s})"
2686 PIDGET (ptid), options_string,
2687 PIDGET (retval), status_string);
2688 xfree (status_string);
2689 xfree (options_string);
2700 target_pid_to_str (ptid_t ptid)
2702 struct target_ops *t;
2704 for (t = current_target.beneath; t != NULL; t = t->beneath)
2706 if (t->to_pid_to_str != NULL)
2707 return (*t->to_pid_to_str) (t, ptid);
2710 return normal_pid_to_str (ptid);
2714 target_thread_name (struct thread_info *info)
2716 struct target_ops *t;
2718 for (t = current_target.beneath; t != NULL; t = t->beneath)
2720 if (t->to_thread_name != NULL)
2721 return (*t->to_thread_name) (info);
2728 target_resume (ptid_t ptid, int step, enum gdb_signal signal)
2730 struct target_ops *t;
2732 target_dcache_invalidate ();
2734 for (t = current_target.beneath; t != NULL; t = t->beneath)
2736 if (t->to_resume != NULL)
2738 t->to_resume (t, ptid, step, signal);
2740 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
2742 step ? "step" : "continue",
2743 gdb_signal_to_name (signal));
2745 registers_changed_ptid (ptid);
2746 set_executing (ptid, 1);
2747 set_running (ptid, 1);
2748 clear_inline_frame_state (ptid);
2757 target_pass_signals (int numsigs, unsigned char *pass_signals)
2759 struct target_ops *t;
2761 for (t = current_target.beneath; t != NULL; t = t->beneath)
2763 if (t->to_pass_signals != NULL)
2769 fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
2772 for (i = 0; i < numsigs; i++)
2773 if (pass_signals[i])
2774 fprintf_unfiltered (gdb_stdlog, " %s",
2775 gdb_signal_to_name (i));
2777 fprintf_unfiltered (gdb_stdlog, " })\n");
2780 (*t->to_pass_signals) (numsigs, pass_signals);
2787 target_program_signals (int numsigs, unsigned char *program_signals)
2789 struct target_ops *t;
2791 for (t = current_target.beneath; t != NULL; t = t->beneath)
2793 if (t->to_program_signals != NULL)
2799 fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
2802 for (i = 0; i < numsigs; i++)
2803 if (program_signals[i])
2804 fprintf_unfiltered (gdb_stdlog, " %s",
2805 gdb_signal_to_name (i));
2807 fprintf_unfiltered (gdb_stdlog, " })\n");
2810 (*t->to_program_signals) (numsigs, program_signals);
2816 /* Look through the list of possible targets for a target that can
2820 target_follow_fork (int follow_child)
2822 struct target_ops *t;
2824 for (t = current_target.beneath; t != NULL; t = t->beneath)
2826 if (t->to_follow_fork != NULL)
2828 int retval = t->to_follow_fork (t, follow_child);
2831 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2832 follow_child, retval);
2837 /* Some target returned a fork event, but did not know how to follow it. */
2838 internal_error (__FILE__, __LINE__,
2839 _("could not find a target to follow fork"));
2843 target_mourn_inferior (void)
2845 struct target_ops *t;
2847 for (t = current_target.beneath; t != NULL; t = t->beneath)
2849 if (t->to_mourn_inferior != NULL)
2851 t->to_mourn_inferior (t);
2853 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2855 /* We no longer need to keep handles on any of the object files.
2856 Make sure to release them to avoid unnecessarily locking any
2857 of them while we're not actually debugging. */
2858 bfd_cache_close_all ();
2864 internal_error (__FILE__, __LINE__,
2865 _("could not find a target to follow mourn inferior"));
2868 /* Look for a target which can describe architectural features, starting
2869 from TARGET. If we find one, return its description. */
2871 const struct target_desc *
2872 target_read_description (struct target_ops *target)
2874 struct target_ops *t;
2876 for (t = target; t != NULL; t = t->beneath)
2877 if (t->to_read_description != NULL)
2879 const struct target_desc *tdesc;
2881 tdesc = t->to_read_description (t);
2889 /* The default implementation of to_search_memory.
2890 This implements a basic search of memory, reading target memory and
2891 performing the search here (as opposed to performing the search in on the
2892 target side with, for example, gdbserver). */
2895 simple_search_memory (struct target_ops *ops,
2896 CORE_ADDR start_addr, ULONGEST search_space_len,
2897 const gdb_byte *pattern, ULONGEST pattern_len,
2898 CORE_ADDR *found_addrp)
2900 /* NOTE: also defined in find.c testcase. */
2901 #define SEARCH_CHUNK_SIZE 16000
2902 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2903 /* Buffer to hold memory contents for searching. */
2904 gdb_byte *search_buf;
2905 unsigned search_buf_size;
2906 struct cleanup *old_cleanups;
2908 search_buf_size = chunk_size + pattern_len - 1;
2910 /* No point in trying to allocate a buffer larger than the search space. */
2911 if (search_space_len < search_buf_size)
2912 search_buf_size = search_space_len;
2914 search_buf = malloc (search_buf_size);
2915 if (search_buf == NULL)
2916 error (_("Unable to allocate memory to perform the search."));
2917 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2919 /* Prime the search buffer. */
2921 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2922 search_buf, start_addr, search_buf_size) != search_buf_size)
2924 warning (_("Unable to access %s bytes of target "
2925 "memory at %s, halting search."),
2926 pulongest (search_buf_size), hex_string (start_addr));
2927 do_cleanups (old_cleanups);
2931 /* Perform the search.
2933 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2934 When we've scanned N bytes we copy the trailing bytes to the start and
2935 read in another N bytes. */
2937 while (search_space_len >= pattern_len)
2939 gdb_byte *found_ptr;
2940 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2942 found_ptr = memmem (search_buf, nr_search_bytes,
2943 pattern, pattern_len);
2945 if (found_ptr != NULL)
2947 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2949 *found_addrp = found_addr;
2950 do_cleanups (old_cleanups);
2954 /* Not found in this chunk, skip to next chunk. */
2956 /* Don't let search_space_len wrap here, it's unsigned. */
2957 if (search_space_len >= chunk_size)
2958 search_space_len -= chunk_size;
2960 search_space_len = 0;
2962 if (search_space_len >= pattern_len)
2964 unsigned keep_len = search_buf_size - chunk_size;
2965 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
2968 /* Copy the trailing part of the previous iteration to the front
2969 of the buffer for the next iteration. */
2970 gdb_assert (keep_len == pattern_len - 1);
2971 memcpy (search_buf, search_buf + chunk_size, keep_len);
2973 nr_to_read = min (search_space_len - keep_len, chunk_size);
2975 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2976 search_buf + keep_len, read_addr,
2977 nr_to_read) != nr_to_read)
2979 warning (_("Unable to access %s bytes of target "
2980 "memory at %s, halting search."),
2981 plongest (nr_to_read),
2982 hex_string (read_addr));
2983 do_cleanups (old_cleanups);
2987 start_addr += chunk_size;
2993 do_cleanups (old_cleanups);
2997 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2998 sequence of bytes in PATTERN with length PATTERN_LEN.
3000 The result is 1 if found, 0 if not found, and -1 if there was an error
3001 requiring halting of the search (e.g. memory read error).
3002 If the pattern is found the address is recorded in FOUND_ADDRP. */
3005 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
3006 const gdb_byte *pattern, ULONGEST pattern_len,
3007 CORE_ADDR *found_addrp)
3009 struct target_ops *t;
3012 /* We don't use INHERIT to set current_target.to_search_memory,
3013 so we have to scan the target stack and handle targetdebug
3017 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
3018 hex_string (start_addr));
3020 for (t = current_target.beneath; t != NULL; t = t->beneath)
3021 if (t->to_search_memory != NULL)
3026 found = t->to_search_memory (t, start_addr, search_space_len,
3027 pattern, pattern_len, found_addrp);
3031 /* If a special version of to_search_memory isn't available, use the
3033 found = simple_search_memory (current_target.beneath,
3034 start_addr, search_space_len,
3035 pattern, pattern_len, found_addrp);
3039 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
3044 /* Look through the currently pushed targets. If none of them will
3045 be able to restart the currently running process, issue an error
3049 target_require_runnable (void)
3051 struct target_ops *t;
3053 for (t = target_stack; t != NULL; t = t->beneath)
3055 /* If this target knows how to create a new program, then
3056 assume we will still be able to after killing the current
3057 one. Either killing and mourning will not pop T, or else
3058 find_default_run_target will find it again. */
3059 if (t->to_create_inferior != NULL)
3062 /* Do not worry about thread_stratum targets that can not
3063 create inferiors. Assume they will be pushed again if
3064 necessary, and continue to the process_stratum. */
3065 if (t->to_stratum == thread_stratum
3066 || t->to_stratum == arch_stratum)
3069 error (_("The \"%s\" target does not support \"run\". "
3070 "Try \"help target\" or \"continue\"."),
3074 /* This function is only called if the target is running. In that
3075 case there should have been a process_stratum target and it
3076 should either know how to create inferiors, or not... */
3077 internal_error (__FILE__, __LINE__, _("No targets found"));
3080 /* Look through the list of possible targets for a target that can
3081 execute a run or attach command without any other data. This is
3082 used to locate the default process stratum.
3084 If DO_MESG is not NULL, the result is always valid (error() is
3085 called for errors); else, return NULL on error. */
3087 static struct target_ops *
3088 find_default_run_target (char *do_mesg)
3090 struct target_ops **t;
3091 struct target_ops *runable = NULL;
3096 for (t = target_structs; t < target_structs + target_struct_size;
3099 if ((*t)->to_can_run && target_can_run (*t))
3109 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
3118 find_default_attach (struct target_ops *ops, char *args, int from_tty)
3120 struct target_ops *t;
3122 t = find_default_run_target ("attach");
3123 (t->to_attach) (t, args, from_tty);
3128 find_default_create_inferior (struct target_ops *ops,
3129 char *exec_file, char *allargs, char **env,
3132 struct target_ops *t;
3134 t = find_default_run_target ("run");
3135 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
3140 find_default_can_async_p (void)
3142 struct target_ops *t;
3144 /* This may be called before the target is pushed on the stack;
3145 look for the default process stratum. If there's none, gdb isn't
3146 configured with a native debugger, and target remote isn't
3148 t = find_default_run_target (NULL);
3149 if (t && t->to_can_async_p)
3150 return (t->to_can_async_p) ();
3155 find_default_is_async_p (void)
3157 struct target_ops *t;
3159 /* This may be called before the target is pushed on the stack;
3160 look for the default process stratum. If there's none, gdb isn't
3161 configured with a native debugger, and target remote isn't
3163 t = find_default_run_target (NULL);
3164 if (t && t->to_is_async_p)
3165 return (t->to_is_async_p) ();
3170 find_default_supports_non_stop (void)
3172 struct target_ops *t;
3174 t = find_default_run_target (NULL);
3175 if (t && t->to_supports_non_stop)
3176 return (t->to_supports_non_stop) ();
3181 target_supports_non_stop (void)
3183 struct target_ops *t;
3185 for (t = ¤t_target; t != NULL; t = t->beneath)
3186 if (t->to_supports_non_stop)
3187 return t->to_supports_non_stop ();
3192 /* Implement the "info proc" command. */
3195 target_info_proc (char *args, enum info_proc_what what)
3197 struct target_ops *t;
3199 /* If we're already connected to something that can get us OS
3200 related data, use it. Otherwise, try using the native
3202 if (current_target.to_stratum >= process_stratum)
3203 t = current_target.beneath;
3205 t = find_default_run_target (NULL);
3207 for (; t != NULL; t = t->beneath)
3209 if (t->to_info_proc != NULL)
3211 t->to_info_proc (t, args, what);
3214 fprintf_unfiltered (gdb_stdlog,
3215 "target_info_proc (\"%s\", %d)\n", args, what);
3225 find_default_supports_disable_randomization (void)
3227 struct target_ops *t;
3229 t = find_default_run_target (NULL);
3230 if (t && t->to_supports_disable_randomization)
3231 return (t->to_supports_disable_randomization) ();
3236 target_supports_disable_randomization (void)
3238 struct target_ops *t;
3240 for (t = ¤t_target; t != NULL; t = t->beneath)
3241 if (t->to_supports_disable_randomization)
3242 return t->to_supports_disable_randomization ();
3248 target_get_osdata (const char *type)
3250 struct target_ops *t;
3252 /* If we're already connected to something that can get us OS
3253 related data, use it. Otherwise, try using the native
3255 if (current_target.to_stratum >= process_stratum)
3256 t = current_target.beneath;
3258 t = find_default_run_target ("get OS data");
3263 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
3266 /* Determine the current address space of thread PTID. */
3268 struct address_space *
3269 target_thread_address_space (ptid_t ptid)
3271 struct address_space *aspace;
3272 struct inferior *inf;
3273 struct target_ops *t;
3275 for (t = current_target.beneath; t != NULL; t = t->beneath)
3277 if (t->to_thread_address_space != NULL)
3279 aspace = t->to_thread_address_space (t, ptid);
3280 gdb_assert (aspace);
3283 fprintf_unfiltered (gdb_stdlog,
3284 "target_thread_address_space (%s) = %d\n",
3285 target_pid_to_str (ptid),
3286 address_space_num (aspace));
3291 /* Fall-back to the "main" address space of the inferior. */
3292 inf = find_inferior_pid (ptid_get_pid (ptid));
3294 if (inf == NULL || inf->aspace == NULL)
3295 internal_error (__FILE__, __LINE__,
3296 _("Can't determine the current "
3297 "address space of thread %s\n"),
3298 target_pid_to_str (ptid));
3304 /* Target file operations. */
3306 static struct target_ops *
3307 default_fileio_target (void)
3309 /* If we're already connected to something that can perform
3310 file I/O, use it. Otherwise, try using the native target. */
3311 if (current_target.to_stratum >= process_stratum)
3312 return current_target.beneath;
3314 return find_default_run_target ("file I/O");
3317 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3318 target file descriptor, or -1 if an error occurs (and set
3321 target_fileio_open (const char *filename, int flags, int mode,
3324 struct target_ops *t;
3326 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3328 if (t->to_fileio_open != NULL)
3330 int fd = t->to_fileio_open (filename, flags, mode, target_errno);
3333 fprintf_unfiltered (gdb_stdlog,
3334 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3335 filename, flags, mode,
3336 fd, fd != -1 ? 0 : *target_errno);
3341 *target_errno = FILEIO_ENOSYS;
3345 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3346 Return the number of bytes written, or -1 if an error occurs
3347 (and set *TARGET_ERRNO). */
3349 target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
3350 ULONGEST offset, int *target_errno)
3352 struct target_ops *t;
3354 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3356 if (t->to_fileio_pwrite != NULL)
3358 int ret = t->to_fileio_pwrite (fd, write_buf, len, offset,
3362 fprintf_unfiltered (gdb_stdlog,
3363 "target_fileio_pwrite (%d,...,%d,%s) "
3365 fd, len, pulongest (offset),
3366 ret, ret != -1 ? 0 : *target_errno);
3371 *target_errno = FILEIO_ENOSYS;
3375 /* Read up to LEN bytes FD on the target into READ_BUF.
3376 Return the number of bytes read, or -1 if an error occurs
3377 (and set *TARGET_ERRNO). */
3379 target_fileio_pread (int fd, gdb_byte *read_buf, int len,
3380 ULONGEST offset, int *target_errno)
3382 struct target_ops *t;
3384 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3386 if (t->to_fileio_pread != NULL)
3388 int ret = t->to_fileio_pread (fd, read_buf, len, offset,
3392 fprintf_unfiltered (gdb_stdlog,
3393 "target_fileio_pread (%d,...,%d,%s) "
3395 fd, len, pulongest (offset),
3396 ret, ret != -1 ? 0 : *target_errno);
3401 *target_errno = FILEIO_ENOSYS;
3405 /* Close FD on the target. Return 0, or -1 if an error occurs
3406 (and set *TARGET_ERRNO). */
3408 target_fileio_close (int fd, int *target_errno)
3410 struct target_ops *t;
3412 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3414 if (t->to_fileio_close != NULL)
3416 int ret = t->to_fileio_close (fd, target_errno);
3419 fprintf_unfiltered (gdb_stdlog,
3420 "target_fileio_close (%d) = %d (%d)\n",
3421 fd, ret, ret != -1 ? 0 : *target_errno);
3426 *target_errno = FILEIO_ENOSYS;
3430 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3431 occurs (and set *TARGET_ERRNO). */
3433 target_fileio_unlink (const char *filename, int *target_errno)
3435 struct target_ops *t;
3437 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3439 if (t->to_fileio_unlink != NULL)
3441 int ret = t->to_fileio_unlink (filename, target_errno);
3444 fprintf_unfiltered (gdb_stdlog,
3445 "target_fileio_unlink (%s) = %d (%d)\n",
3446 filename, ret, ret != -1 ? 0 : *target_errno);
3451 *target_errno = FILEIO_ENOSYS;
3455 /* Read value of symbolic link FILENAME on the target. Return a
3456 null-terminated string allocated via xmalloc, or NULL if an error
3457 occurs (and set *TARGET_ERRNO). */
3459 target_fileio_readlink (const char *filename, int *target_errno)
3461 struct target_ops *t;
3463 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3465 if (t->to_fileio_readlink != NULL)
3467 char *ret = t->to_fileio_readlink (filename, target_errno);
3470 fprintf_unfiltered (gdb_stdlog,
3471 "target_fileio_readlink (%s) = %s (%d)\n",
3472 filename, ret? ret : "(nil)",
3473 ret? 0 : *target_errno);
3478 *target_errno = FILEIO_ENOSYS;
3483 target_fileio_close_cleanup (void *opaque)
3485 int fd = *(int *) opaque;
3488 target_fileio_close (fd, &target_errno);
3491 /* Read target file FILENAME. Store the result in *BUF_P and
3492 return the size of the transferred data. PADDING additional bytes are
3493 available in *BUF_P. This is a helper function for
3494 target_fileio_read_alloc; see the declaration of that function for more
3498 target_fileio_read_alloc_1 (const char *filename,
3499 gdb_byte **buf_p, int padding)
3501 struct cleanup *close_cleanup;
3502 size_t buf_alloc, buf_pos;
3508 fd = target_fileio_open (filename, FILEIO_O_RDONLY, 0700, &target_errno);
3512 close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
3514 /* Start by reading up to 4K at a time. The target will throttle
3515 this number down if necessary. */
3517 buf = xmalloc (buf_alloc);
3521 n = target_fileio_pread (fd, &buf[buf_pos],
3522 buf_alloc - buf_pos - padding, buf_pos,
3526 /* An error occurred. */
3527 do_cleanups (close_cleanup);
3533 /* Read all there was. */
3534 do_cleanups (close_cleanup);
3544 /* If the buffer is filling up, expand it. */
3545 if (buf_alloc < buf_pos * 2)
3548 buf = xrealloc (buf, buf_alloc);
3555 /* Read target file FILENAME. Store the result in *BUF_P and return
3556 the size of the transferred data. See the declaration in "target.h"
3557 function for more information about the return value. */
3560 target_fileio_read_alloc (const char *filename, gdb_byte **buf_p)
3562 return target_fileio_read_alloc_1 (filename, buf_p, 0);
3565 /* Read target file FILENAME. The result is NUL-terminated and
3566 returned as a string, allocated using xmalloc. If an error occurs
3567 or the transfer is unsupported, NULL is returned. Empty objects
3568 are returned as allocated but empty strings. A warning is issued
3569 if the result contains any embedded NUL bytes. */
3572 target_fileio_read_stralloc (const char *filename)
3576 LONGEST i, transferred;
3578 transferred = target_fileio_read_alloc_1 (filename, &buffer, 1);
3579 bufstr = (char *) buffer;
3581 if (transferred < 0)
3584 if (transferred == 0)
3585 return xstrdup ("");
3587 bufstr[transferred] = 0;
3589 /* Check for embedded NUL bytes; but allow trailing NULs. */
3590 for (i = strlen (bufstr); i < transferred; i++)
3593 warning (_("target file %s "
3594 "contained unexpected null characters"),
3604 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
3606 return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
3610 default_watchpoint_addr_within_range (struct target_ops *target,
3612 CORE_ADDR start, int length)
3614 return addr >= start && addr < start + length;
3617 static struct gdbarch *
3618 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3620 return target_gdbarch ();
3636 return_minus_one (void)
3642 * Find the next target down the stack from the specified target.
3646 find_target_beneath (struct target_ops *t)
3652 /* The inferior process has died. Long live the inferior! */
3655 generic_mourn_inferior (void)
3659 ptid = inferior_ptid;
3660 inferior_ptid = null_ptid;
3662 /* Mark breakpoints uninserted in case something tries to delete a
3663 breakpoint while we delete the inferior's threads (which would
3664 fail, since the inferior is long gone). */
3665 mark_breakpoints_out ();
3667 if (!ptid_equal (ptid, null_ptid))
3669 int pid = ptid_get_pid (ptid);
3670 exit_inferior (pid);
3673 /* Note this wipes step-resume breakpoints, so needs to be done
3674 after exit_inferior, which ends up referencing the step-resume
3675 breakpoints through clear_thread_inferior_resources. */
3676 breakpoint_init_inferior (inf_exited);
3678 registers_changed ();
3680 reopen_exec_file ();
3681 reinit_frame_cache ();
3683 if (deprecated_detach_hook)
3684 deprecated_detach_hook ();
3687 /* Convert a normal process ID to a string. Returns the string in a
3691 normal_pid_to_str (ptid_t ptid)
3693 static char buf[32];
3695 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
3700 dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
3702 return normal_pid_to_str (ptid);
3705 /* Error-catcher for target_find_memory_regions. */
3707 dummy_find_memory_regions (find_memory_region_ftype ignore1, void *ignore2)
3709 error (_("Command not implemented for this target."));
3713 /* Error-catcher for target_make_corefile_notes. */
3715 dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
3717 error (_("Command not implemented for this target."));
3721 /* Error-catcher for target_get_bookmark. */
3723 dummy_get_bookmark (char *ignore1, int ignore2)
3729 /* Error-catcher for target_goto_bookmark. */
3731 dummy_goto_bookmark (gdb_byte *ignore, int from_tty)
3736 /* Set up the handful of non-empty slots needed by the dummy target
3740 init_dummy_target (void)
3742 dummy_target.to_shortname = "None";
3743 dummy_target.to_longname = "None";
3744 dummy_target.to_doc = "";
3745 dummy_target.to_attach = find_default_attach;
3746 dummy_target.to_detach =
3747 (void (*)(struct target_ops *, char *, int))target_ignore;
3748 dummy_target.to_create_inferior = find_default_create_inferior;
3749 dummy_target.to_can_async_p = find_default_can_async_p;
3750 dummy_target.to_is_async_p = find_default_is_async_p;
3751 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
3752 dummy_target.to_supports_disable_randomization
3753 = find_default_supports_disable_randomization;
3754 dummy_target.to_pid_to_str = dummy_pid_to_str;
3755 dummy_target.to_stratum = dummy_stratum;
3756 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
3757 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
3758 dummy_target.to_get_bookmark = dummy_get_bookmark;
3759 dummy_target.to_goto_bookmark = dummy_goto_bookmark;
3760 dummy_target.to_xfer_partial = default_xfer_partial;
3761 dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
3762 dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero;
3763 dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero;
3764 dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero;
3765 dummy_target.to_has_execution
3766 = (int (*) (struct target_ops *, ptid_t)) return_zero;
3767 dummy_target.to_stopped_by_watchpoint = return_zero;
3768 dummy_target.to_stopped_data_address =
3769 (int (*) (struct target_ops *, CORE_ADDR *)) return_zero;
3770 dummy_target.to_magic = OPS_MAGIC;
3774 debug_to_open (char *args, int from_tty)
3776 debug_target.to_open (args, from_tty);
3778 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
3782 target_close (struct target_ops *targ)
3784 if (targ->to_xclose != NULL)
3785 targ->to_xclose (targ);
3786 else if (targ->to_close != NULL)
3790 fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
3794 target_attach (char *args, int from_tty)
3796 struct target_ops *t;
3798 for (t = current_target.beneath; t != NULL; t = t->beneath)
3800 if (t->to_attach != NULL)
3802 t->to_attach (t, args, from_tty);
3804 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
3810 internal_error (__FILE__, __LINE__,
3811 _("could not find a target to attach"));
3815 target_thread_alive (ptid_t ptid)
3817 struct target_ops *t;
3819 for (t = current_target.beneath; t != NULL; t = t->beneath)
3821 if (t->to_thread_alive != NULL)
3825 retval = t->to_thread_alive (t, ptid);
3827 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3828 PIDGET (ptid), retval);
3838 target_find_new_threads (void)
3840 struct target_ops *t;
3842 for (t = current_target.beneath; t != NULL; t = t->beneath)
3844 if (t->to_find_new_threads != NULL)
3846 t->to_find_new_threads (t);
3848 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
3856 target_stop (ptid_t ptid)
3860 warning (_("May not interrupt or stop the target, ignoring attempt"));
3864 (*current_target.to_stop) (ptid);
3868 debug_to_post_attach (int pid)
3870 debug_target.to_post_attach (pid);
3872 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
3875 /* Concatenate ELEM to LIST, a comma separate list, and return the
3876 result. The LIST incoming argument is released. */
3879 str_comma_list_concat_elem (char *list, const char *elem)
3882 return xstrdup (elem);
3884 return reconcat (list, list, ", ", elem, (char *) NULL);
3887 /* Helper for target_options_to_string. If OPT is present in
3888 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3889 Returns the new resulting string. OPT is removed from
3893 do_option (int *target_options, char *ret,
3894 int opt, char *opt_str)
3896 if ((*target_options & opt) != 0)
3898 ret = str_comma_list_concat_elem (ret, opt_str);
3899 *target_options &= ~opt;
3906 target_options_to_string (int target_options)
3910 #define DO_TARG_OPTION(OPT) \
3911 ret = do_option (&target_options, ret, OPT, #OPT)
3913 DO_TARG_OPTION (TARGET_WNOHANG);
3915 if (target_options != 0)
3916 ret = str_comma_list_concat_elem (ret, "unknown???");
3924 debug_print_register (const char * func,
3925 struct regcache *regcache, int regno)
3927 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3929 fprintf_unfiltered (gdb_stdlog, "%s ", func);
3930 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
3931 && gdbarch_register_name (gdbarch, regno) != NULL
3932 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3933 fprintf_unfiltered (gdb_stdlog, "(%s)",
3934 gdbarch_register_name (gdbarch, regno));
3936 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
3937 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
3939 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3940 int i, size = register_size (gdbarch, regno);
3941 gdb_byte buf[MAX_REGISTER_SIZE];
3943 regcache_raw_collect (regcache, regno, buf);
3944 fprintf_unfiltered (gdb_stdlog, " = ");
3945 for (i = 0; i < size; i++)
3947 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3949 if (size <= sizeof (LONGEST))
3951 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
3953 fprintf_unfiltered (gdb_stdlog, " %s %s",
3954 core_addr_to_string_nz (val), plongest (val));
3957 fprintf_unfiltered (gdb_stdlog, "\n");
3961 target_fetch_registers (struct regcache *regcache, int regno)
3963 struct target_ops *t;
3965 for (t = current_target.beneath; t != NULL; t = t->beneath)
3967 if (t->to_fetch_registers != NULL)
3969 t->to_fetch_registers (t, regcache, regno);
3971 debug_print_register ("target_fetch_registers", regcache, regno);
3978 target_store_registers (struct regcache *regcache, int regno)
3980 struct target_ops *t;
3982 if (!may_write_registers)
3983 error (_("Writing to registers is not allowed (regno %d)"), regno);
3985 for (t = current_target.beneath; t != NULL; t = t->beneath)
3987 if (t->to_store_registers != NULL)
3989 t->to_store_registers (t, regcache, regno);
3992 debug_print_register ("target_store_registers", regcache, regno);
4002 target_core_of_thread (ptid_t ptid)
4004 struct target_ops *t;
4006 for (t = current_target.beneath; t != NULL; t = t->beneath)
4008 if (t->to_core_of_thread != NULL)
4010 int retval = t->to_core_of_thread (t, ptid);
4013 fprintf_unfiltered (gdb_stdlog,
4014 "target_core_of_thread (%d) = %d\n",
4015 PIDGET (ptid), retval);
4024 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
4026 struct target_ops *t;
4028 for (t = current_target.beneath; t != NULL; t = t->beneath)
4030 if (t->to_verify_memory != NULL)
4032 int retval = t->to_verify_memory (t, data, memaddr, size);
4035 fprintf_unfiltered (gdb_stdlog,
4036 "target_verify_memory (%s, %s) = %d\n",
4037 paddress (target_gdbarch (), memaddr),
4047 /* The documentation for this function is in its prototype declaration in
4051 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
4053 struct target_ops *t;
4055 for (t = current_target.beneath; t != NULL; t = t->beneath)
4056 if (t->to_insert_mask_watchpoint != NULL)
4060 ret = t->to_insert_mask_watchpoint (t, addr, mask, rw);
4063 fprintf_unfiltered (gdb_stdlog, "\
4064 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4065 core_addr_to_string (addr),
4066 core_addr_to_string (mask), rw, ret);
4074 /* The documentation for this function is in its prototype declaration in
4078 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
4080 struct target_ops *t;
4082 for (t = current_target.beneath; t != NULL; t = t->beneath)
4083 if (t->to_remove_mask_watchpoint != NULL)
4087 ret = t->to_remove_mask_watchpoint (t, addr, mask, rw);
4090 fprintf_unfiltered (gdb_stdlog, "\
4091 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4092 core_addr_to_string (addr),
4093 core_addr_to_string (mask), rw, ret);
4101 /* The documentation for this function is in its prototype declaration
4105 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
4107 struct target_ops *t;
4109 for (t = current_target.beneath; t != NULL; t = t->beneath)
4110 if (t->to_masked_watch_num_registers != NULL)
4111 return t->to_masked_watch_num_registers (t, addr, mask);
4116 /* The documentation for this function is in its prototype declaration
4120 target_ranged_break_num_registers (void)
4122 struct target_ops *t;
4124 for (t = current_target.beneath; t != NULL; t = t->beneath)
4125 if (t->to_ranged_break_num_registers != NULL)
4126 return t->to_ranged_break_num_registers (t);
4134 target_supports_btrace (void)
4136 struct target_ops *t;
4138 for (t = current_target.beneath; t != NULL; t = t->beneath)
4139 if (t->to_supports_btrace != NULL)
4140 return t->to_supports_btrace ();
4147 struct btrace_target_info *
4148 target_enable_btrace (ptid_t ptid)
4150 struct target_ops *t;
4152 for (t = current_target.beneath; t != NULL; t = t->beneath)
4153 if (t->to_enable_btrace != NULL)
4154 return t->to_enable_btrace (ptid);
4163 target_disable_btrace (struct btrace_target_info *btinfo)
4165 struct target_ops *t;
4167 for (t = current_target.beneath; t != NULL; t = t->beneath)
4168 if (t->to_disable_btrace != NULL)
4169 return t->to_disable_btrace (btinfo);
4177 target_teardown_btrace (struct btrace_target_info *btinfo)
4179 struct target_ops *t;
4181 for (t = current_target.beneath; t != NULL; t = t->beneath)
4182 if (t->to_teardown_btrace != NULL)
4183 return t->to_teardown_btrace (btinfo);
4190 VEC (btrace_block_s) *
4191 target_read_btrace (struct btrace_target_info *btinfo,
4192 enum btrace_read_type type)
4194 struct target_ops *t;
4196 for (t = current_target.beneath; t != NULL; t = t->beneath)
4197 if (t->to_read_btrace != NULL)
4198 return t->to_read_btrace (btinfo, type);
4207 target_stop_recording (void)
4209 struct target_ops *t;
4211 for (t = current_target.beneath; t != NULL; t = t->beneath)
4212 if (t->to_stop_recording != NULL)
4214 t->to_stop_recording ();
4218 /* This is optional. */
4224 target_info_record (void)
4226 struct target_ops *t;
4228 for (t = current_target.beneath; t != NULL; t = t->beneath)
4229 if (t->to_info_record != NULL)
4231 t->to_info_record ();
4241 target_save_record (const char *filename)
4243 struct target_ops *t;
4245 for (t = current_target.beneath; t != NULL; t = t->beneath)
4246 if (t->to_save_record != NULL)
4248 t->to_save_record (filename);
4258 target_supports_delete_record (void)
4260 struct target_ops *t;
4262 for (t = current_target.beneath; t != NULL; t = t->beneath)
4263 if (t->to_delete_record != NULL)
4272 target_delete_record (void)
4274 struct target_ops *t;
4276 for (t = current_target.beneath; t != NULL; t = t->beneath)
4277 if (t->to_delete_record != NULL)
4279 t->to_delete_record ();
4289 target_record_is_replaying (void)
4291 struct target_ops *t;
4293 for (t = current_target.beneath; t != NULL; t = t->beneath)
4294 if (t->to_record_is_replaying != NULL)
4295 return t->to_record_is_replaying ();
4303 target_goto_record_begin (void)
4305 struct target_ops *t;
4307 for (t = current_target.beneath; t != NULL; t = t->beneath)
4308 if (t->to_goto_record_begin != NULL)
4310 t->to_goto_record_begin ();
4320 target_goto_record_end (void)
4322 struct target_ops *t;
4324 for (t = current_target.beneath; t != NULL; t = t->beneath)
4325 if (t->to_goto_record_end != NULL)
4327 t->to_goto_record_end ();
4337 target_goto_record (ULONGEST insn)
4339 struct target_ops *t;
4341 for (t = current_target.beneath; t != NULL; t = t->beneath)
4342 if (t->to_goto_record != NULL)
4344 t->to_goto_record (insn);
4354 target_insn_history (int size, int flags)
4356 struct target_ops *t;
4358 for (t = current_target.beneath; t != NULL; t = t->beneath)
4359 if (t->to_insn_history != NULL)
4361 t->to_insn_history (size, flags);
4371 target_insn_history_from (ULONGEST from, int size, int flags)
4373 struct target_ops *t;
4375 for (t = current_target.beneath; t != NULL; t = t->beneath)
4376 if (t->to_insn_history_from != NULL)
4378 t->to_insn_history_from (from, size, flags);
4388 target_insn_history_range (ULONGEST begin, ULONGEST end, int flags)
4390 struct target_ops *t;
4392 for (t = current_target.beneath; t != NULL; t = t->beneath)
4393 if (t->to_insn_history_range != NULL)
4395 t->to_insn_history_range (begin, end, flags);
4405 target_call_history (int size, int flags)
4407 struct target_ops *t;
4409 for (t = current_target.beneath; t != NULL; t = t->beneath)
4410 if (t->to_call_history != NULL)
4412 t->to_call_history (size, flags);
4422 target_call_history_from (ULONGEST begin, int size, int flags)
4424 struct target_ops *t;
4426 for (t = current_target.beneath; t != NULL; t = t->beneath)
4427 if (t->to_call_history_from != NULL)
4429 t->to_call_history_from (begin, size, flags);
4439 target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
4441 struct target_ops *t;
4443 for (t = current_target.beneath; t != NULL; t = t->beneath)
4444 if (t->to_call_history_range != NULL)
4446 t->to_call_history_range (begin, end, flags);
4454 debug_to_prepare_to_store (struct regcache *regcache)
4456 debug_target.to_prepare_to_store (regcache);
4458 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
4462 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
4463 int write, struct mem_attrib *attrib,
4464 struct target_ops *target)
4468 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
4471 fprintf_unfiltered (gdb_stdlog,
4472 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4473 paddress (target_gdbarch (), memaddr), len,
4474 write ? "write" : "read", retval);
4480 fputs_unfiltered (", bytes =", gdb_stdlog);
4481 for (i = 0; i < retval; i++)
4483 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
4485 if (targetdebug < 2 && i > 0)
4487 fprintf_unfiltered (gdb_stdlog, " ...");
4490 fprintf_unfiltered (gdb_stdlog, "\n");
4493 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
4497 fputc_unfiltered ('\n', gdb_stdlog);
4503 debug_to_files_info (struct target_ops *target)
4505 debug_target.to_files_info (target);
4507 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
4511 debug_to_insert_breakpoint (struct gdbarch *gdbarch,
4512 struct bp_target_info *bp_tgt)
4516 retval = debug_target.to_insert_breakpoint (gdbarch, bp_tgt);
4518 fprintf_unfiltered (gdb_stdlog,
4519 "target_insert_breakpoint (%s, xxx) = %ld\n",
4520 core_addr_to_string (bp_tgt->placed_address),
4521 (unsigned long) retval);
4526 debug_to_remove_breakpoint (struct gdbarch *gdbarch,
4527 struct bp_target_info *bp_tgt)
4531 retval = debug_target.to_remove_breakpoint (gdbarch, bp_tgt);
4533 fprintf_unfiltered (gdb_stdlog,
4534 "target_remove_breakpoint (%s, xxx) = %ld\n",
4535 core_addr_to_string (bp_tgt->placed_address),
4536 (unsigned long) retval);
4541 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
4545 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
4547 fprintf_unfiltered (gdb_stdlog,
4548 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4549 (unsigned long) type,
4550 (unsigned long) cnt,
4551 (unsigned long) from_tty,
4552 (unsigned long) retval);
4557 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
4561 retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
4563 fprintf_unfiltered (gdb_stdlog,
4564 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4565 core_addr_to_string (addr), (unsigned long) len,
4566 core_addr_to_string (retval));
4571 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw,
4572 struct expression *cond)
4576 retval = debug_target.to_can_accel_watchpoint_condition (addr, len,
4579 fprintf_unfiltered (gdb_stdlog,
4580 "target_can_accel_watchpoint_condition "
4581 "(%s, %d, %d, %s) = %ld\n",
4582 core_addr_to_string (addr), len, rw,
4583 host_address_to_string (cond), (unsigned long) retval);
4588 debug_to_stopped_by_watchpoint (void)
4592 retval = debug_target.to_stopped_by_watchpoint ();
4594 fprintf_unfiltered (gdb_stdlog,
4595 "target_stopped_by_watchpoint () = %ld\n",
4596 (unsigned long) retval);
4601 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
4605 retval = debug_target.to_stopped_data_address (target, addr);
4607 fprintf_unfiltered (gdb_stdlog,
4608 "target_stopped_data_address ([%s]) = %ld\n",
4609 core_addr_to_string (*addr),
4610 (unsigned long)retval);
4615 debug_to_watchpoint_addr_within_range (struct target_ops *target,
4617 CORE_ADDR start, int length)
4621 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
4624 fprintf_filtered (gdb_stdlog,
4625 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4626 core_addr_to_string (addr), core_addr_to_string (start),
4632 debug_to_insert_hw_breakpoint (struct gdbarch *gdbarch,
4633 struct bp_target_info *bp_tgt)
4637 retval = debug_target.to_insert_hw_breakpoint (gdbarch, bp_tgt);
4639 fprintf_unfiltered (gdb_stdlog,
4640 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4641 core_addr_to_string (bp_tgt->placed_address),
4642 (unsigned long) retval);
4647 debug_to_remove_hw_breakpoint (struct gdbarch *gdbarch,
4648 struct bp_target_info *bp_tgt)
4652 retval = debug_target.to_remove_hw_breakpoint (gdbarch, bp_tgt);
4654 fprintf_unfiltered (gdb_stdlog,
4655 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4656 core_addr_to_string (bp_tgt->placed_address),
4657 (unsigned long) retval);
4662 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type,
4663 struct expression *cond)
4667 retval = debug_target.to_insert_watchpoint (addr, len, type, cond);
4669 fprintf_unfiltered (gdb_stdlog,
4670 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4671 core_addr_to_string (addr), len, type,
4672 host_address_to_string (cond), (unsigned long) retval);
4677 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type,
4678 struct expression *cond)
4682 retval = debug_target.to_remove_watchpoint (addr, len, type, cond);
4684 fprintf_unfiltered (gdb_stdlog,
4685 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4686 core_addr_to_string (addr), len, type,
4687 host_address_to_string (cond), (unsigned long) retval);
4692 debug_to_terminal_init (void)
4694 debug_target.to_terminal_init ();
4696 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
4700 debug_to_terminal_inferior (void)
4702 debug_target.to_terminal_inferior ();
4704 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
4708 debug_to_terminal_ours_for_output (void)
4710 debug_target.to_terminal_ours_for_output ();
4712 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
4716 debug_to_terminal_ours (void)
4718 debug_target.to_terminal_ours ();
4720 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
4724 debug_to_terminal_save_ours (void)
4726 debug_target.to_terminal_save_ours ();
4728 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
4732 debug_to_terminal_info (const char *arg, int from_tty)
4734 debug_target.to_terminal_info (arg, from_tty);
4736 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
4741 debug_to_load (char *args, int from_tty)
4743 debug_target.to_load (args, from_tty);
4745 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
4749 debug_to_post_startup_inferior (ptid_t ptid)
4751 debug_target.to_post_startup_inferior (ptid);
4753 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
4758 debug_to_insert_fork_catchpoint (int pid)
4762 retval = debug_target.to_insert_fork_catchpoint (pid);
4764 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
4771 debug_to_remove_fork_catchpoint (int pid)
4775 retval = debug_target.to_remove_fork_catchpoint (pid);
4777 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
4784 debug_to_insert_vfork_catchpoint (int pid)
4788 retval = debug_target.to_insert_vfork_catchpoint (pid);
4790 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
4797 debug_to_remove_vfork_catchpoint (int pid)
4801 retval = debug_target.to_remove_vfork_catchpoint (pid);
4803 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
4810 debug_to_insert_exec_catchpoint (int pid)
4814 retval = debug_target.to_insert_exec_catchpoint (pid);
4816 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
4823 debug_to_remove_exec_catchpoint (int pid)
4827 retval = debug_target.to_remove_exec_catchpoint (pid);
4829 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
4836 debug_to_has_exited (int pid, int wait_status, int *exit_status)
4840 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
4842 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
4843 pid, wait_status, *exit_status, has_exited);
4849 debug_to_can_run (void)
4853 retval = debug_target.to_can_run ();
4855 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
4860 static struct gdbarch *
4861 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
4863 struct gdbarch *retval;
4865 retval = debug_target.to_thread_architecture (ops, ptid);
4867 fprintf_unfiltered (gdb_stdlog,
4868 "target_thread_architecture (%s) = %s [%s]\n",
4869 target_pid_to_str (ptid),
4870 host_address_to_string (retval),
4871 gdbarch_bfd_arch_info (retval)->printable_name);
4876 debug_to_stop (ptid_t ptid)
4878 debug_target.to_stop (ptid);
4880 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
4881 target_pid_to_str (ptid));
4885 debug_to_rcmd (char *command,
4886 struct ui_file *outbuf)
4888 debug_target.to_rcmd (command, outbuf);
4889 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
4893 debug_to_pid_to_exec_file (int pid)
4897 exec_file = debug_target.to_pid_to_exec_file (pid);
4899 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
4906 setup_target_debug (void)
4908 memcpy (&debug_target, ¤t_target, sizeof debug_target);
4910 current_target.to_open = debug_to_open;
4911 current_target.to_post_attach = debug_to_post_attach;
4912 current_target.to_prepare_to_store = debug_to_prepare_to_store;
4913 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
4914 current_target.to_files_info = debug_to_files_info;
4915 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
4916 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
4917 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
4918 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
4919 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
4920 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
4921 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
4922 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
4923 current_target.to_stopped_data_address = debug_to_stopped_data_address;
4924 current_target.to_watchpoint_addr_within_range
4925 = debug_to_watchpoint_addr_within_range;
4926 current_target.to_region_ok_for_hw_watchpoint
4927 = debug_to_region_ok_for_hw_watchpoint;
4928 current_target.to_can_accel_watchpoint_condition
4929 = debug_to_can_accel_watchpoint_condition;
4930 current_target.to_terminal_init = debug_to_terminal_init;
4931 current_target.to_terminal_inferior = debug_to_terminal_inferior;
4932 current_target.to_terminal_ours_for_output
4933 = debug_to_terminal_ours_for_output;
4934 current_target.to_terminal_ours = debug_to_terminal_ours;
4935 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
4936 current_target.to_terminal_info = debug_to_terminal_info;
4937 current_target.to_load = debug_to_load;
4938 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
4939 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
4940 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
4941 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
4942 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
4943 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
4944 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
4945 current_target.to_has_exited = debug_to_has_exited;
4946 current_target.to_can_run = debug_to_can_run;
4947 current_target.to_stop = debug_to_stop;
4948 current_target.to_rcmd = debug_to_rcmd;
4949 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
4950 current_target.to_thread_architecture = debug_to_thread_architecture;
4954 static char targ_desc[] =
4955 "Names of targets and files being debugged.\nShows the entire \
4956 stack of targets currently in use (including the exec-file,\n\
4957 core-file, and process, if any), as well as the symbol file name.";
4960 do_monitor_command (char *cmd,
4963 if ((current_target.to_rcmd
4964 == (void (*) (char *, struct ui_file *)) tcomplain)
4965 || (current_target.to_rcmd == debug_to_rcmd
4966 && (debug_target.to_rcmd
4967 == (void (*) (char *, struct ui_file *)) tcomplain)))
4968 error (_("\"monitor\" command not supported by this target."));
4969 target_rcmd (cmd, gdb_stdtarg);
4972 /* Print the name of each layers of our target stack. */
4975 maintenance_print_target_stack (char *cmd, int from_tty)
4977 struct target_ops *t;
4979 printf_filtered (_("The current target stack is:\n"));
4981 for (t = target_stack; t != NULL; t = t->beneath)
4983 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
4987 /* Controls if async mode is permitted. */
4988 int target_async_permitted = 0;
4990 /* The set command writes to this variable. If the inferior is
4991 executing, linux_nat_async_permitted is *not* updated. */
4992 static int target_async_permitted_1 = 0;
4995 set_target_async_command (char *args, int from_tty,
4996 struct cmd_list_element *c)
4998 if (have_live_inferiors ())
5000 target_async_permitted_1 = target_async_permitted;
5001 error (_("Cannot change this setting while the inferior is running."));
5004 target_async_permitted = target_async_permitted_1;
5008 show_target_async_command (struct ui_file *file, int from_tty,
5009 struct cmd_list_element *c,
5012 fprintf_filtered (file,
5013 _("Controlling the inferior in "
5014 "asynchronous mode is %s.\n"), value);
5017 /* Temporary copies of permission settings. */
5019 static int may_write_registers_1 = 1;
5020 static int may_write_memory_1 = 1;
5021 static int may_insert_breakpoints_1 = 1;
5022 static int may_insert_tracepoints_1 = 1;
5023 static int may_insert_fast_tracepoints_1 = 1;
5024 static int may_stop_1 = 1;
5026 /* Make the user-set values match the real values again. */
5029 update_target_permissions (void)
5031 may_write_registers_1 = may_write_registers;
5032 may_write_memory_1 = may_write_memory;
5033 may_insert_breakpoints_1 = may_insert_breakpoints;
5034 may_insert_tracepoints_1 = may_insert_tracepoints;
5035 may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
5036 may_stop_1 = may_stop;
5039 /* The one function handles (most of) the permission flags in the same
5043 set_target_permissions (char *args, int from_tty,
5044 struct cmd_list_element *c)
5046 if (target_has_execution)
5048 update_target_permissions ();
5049 error (_("Cannot change this setting while the inferior is running."));
5052 /* Make the real values match the user-changed values. */
5053 may_write_registers = may_write_registers_1;
5054 may_insert_breakpoints = may_insert_breakpoints_1;
5055 may_insert_tracepoints = may_insert_tracepoints_1;
5056 may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
5057 may_stop = may_stop_1;
5058 update_observer_mode ();
5061 /* Set memory write permission independently of observer mode. */
5064 set_write_memory_permission (char *args, int from_tty,
5065 struct cmd_list_element *c)
5067 /* Make the real values match the user-changed values. */
5068 may_write_memory = may_write_memory_1;
5069 update_observer_mode ();
5074 initialize_targets (void)
5076 init_dummy_target ();
5077 push_target (&dummy_target);
5079 add_info ("target", target_info, targ_desc);
5080 add_info ("files", target_info, targ_desc);
5082 add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
5083 Set target debugging."), _("\
5084 Show target debugging."), _("\
5085 When non-zero, target debugging is enabled. Higher numbers are more\n\
5086 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5090 &setdebuglist, &showdebuglist);
5092 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
5093 &trust_readonly, _("\
5094 Set mode for reading from readonly sections."), _("\
5095 Show mode for reading from readonly sections."), _("\
5096 When this mode is on, memory reads from readonly sections (such as .text)\n\
5097 will be read from the object file instead of from the target. This will\n\
5098 result in significant performance improvement for remote targets."),
5100 show_trust_readonly,
5101 &setlist, &showlist);
5103 add_com ("monitor", class_obscure, do_monitor_command,
5104 _("Send a command to the remote monitor (remote targets only)."));
5106 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
5107 _("Print the name of each layer of the internal target stack."),
5108 &maintenanceprintlist);
5110 add_setshow_boolean_cmd ("target-async", no_class,
5111 &target_async_permitted_1, _("\
5112 Set whether gdb controls the inferior in asynchronous mode."), _("\
5113 Show whether gdb controls the inferior in asynchronous mode."), _("\
5114 Tells gdb whether to control the inferior in asynchronous mode."),
5115 set_target_async_command,
5116 show_target_async_command,
5120 add_setshow_boolean_cmd ("stack-cache", class_support,
5121 &stack_cache_enabled_p_1, _("\
5122 Set cache use for stack access."), _("\
5123 Show cache use for stack access."), _("\
5124 When on, use the data cache for all stack access, regardless of any\n\
5125 configured memory regions. This improves remote performance significantly.\n\
5126 By default, caching for stack access is on."),
5127 set_stack_cache_enabled_p,
5128 show_stack_cache_enabled_p,
5129 &setlist, &showlist);
5131 add_setshow_boolean_cmd ("may-write-registers", class_support,
5132 &may_write_registers_1, _("\
5133 Set permission to write into registers."), _("\
5134 Show permission to write into registers."), _("\
5135 When this permission is on, GDB may write into the target's registers.\n\
5136 Otherwise, any sort of write attempt will result in an error."),
5137 set_target_permissions, NULL,
5138 &setlist, &showlist);
5140 add_setshow_boolean_cmd ("may-write-memory", class_support,
5141 &may_write_memory_1, _("\
5142 Set permission to write into target memory."), _("\
5143 Show permission to write into target memory."), _("\
5144 When this permission is on, GDB may write into the target's memory.\n\
5145 Otherwise, any sort of write attempt will result in an error."),
5146 set_write_memory_permission, NULL,
5147 &setlist, &showlist);
5149 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
5150 &may_insert_breakpoints_1, _("\
5151 Set permission to insert breakpoints in the target."), _("\
5152 Show permission to insert breakpoints in the target."), _("\
5153 When this permission is on, GDB may insert breakpoints in the program.\n\
5154 Otherwise, any sort of insertion attempt will result in an error."),
5155 set_target_permissions, NULL,
5156 &setlist, &showlist);
5158 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
5159 &may_insert_tracepoints_1, _("\
5160 Set permission to insert tracepoints in the target."), _("\
5161 Show permission to insert tracepoints in the target."), _("\
5162 When this permission is on, GDB may insert tracepoints in the program.\n\
5163 Otherwise, any sort of insertion attempt will result in an error."),
5164 set_target_permissions, NULL,
5165 &setlist, &showlist);
5167 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
5168 &may_insert_fast_tracepoints_1, _("\
5169 Set permission to insert fast tracepoints in the target."), _("\
5170 Show permission to insert fast tracepoints in the target."), _("\
5171 When this permission is on, GDB may insert fast tracepoints.\n\
5172 Otherwise, any sort of insertion attempt will result in an error."),
5173 set_target_permissions, NULL,
5174 &setlist, &showlist);
5176 add_setshow_boolean_cmd ("may-interrupt", class_support,
5178 Set permission to interrupt or signal the target."), _("\
5179 Show permission to interrupt or signal the target."), _("\
5180 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5181 Otherwise, any attempt to interrupt or stop will be ignored."),
5182 set_target_permissions, NULL,
5183 &setlist, &showlist);
5186 target_dcache = dcache_init ();