1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990-2014 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/>. */
26 #include "target-dcache.h"
36 #include "gdb_assert.h"
38 #include "exceptions.h"
39 #include "target-descriptions.h"
40 #include "gdbthread.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
45 #include "gdb/fileio.h"
48 static void target_info (char *, int);
50 static void default_terminal_info (struct target_ops *, const char *, int);
52 static int default_watchpoint_addr_within_range (struct target_ops *,
53 CORE_ADDR, CORE_ADDR, int);
55 static int default_region_ok_for_hw_watchpoint (struct target_ops *,
58 static void default_rcmd (struct target_ops *, char *, struct ui_file *);
60 static void tcomplain (void) ATTRIBUTE_NORETURN;
62 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
64 static int return_zero (void);
66 static int return_one (void);
68 static int return_minus_one (void);
70 static void *return_null (void);
72 void target_ignore (void);
74 static void target_command (char *, int);
76 static struct target_ops *find_default_run_target (char *);
78 static target_xfer_partial_ftype default_xfer_partial;
80 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
83 static int find_default_can_async_p (struct target_ops *ignore);
85 static int find_default_is_async_p (struct target_ops *ignore);
87 #include "target-delegates.c"
89 static void init_dummy_target (void);
91 static struct target_ops debug_target;
93 static void debug_to_open (char *, int);
95 static void debug_to_prepare_to_store (struct target_ops *self,
98 static void debug_to_files_info (struct target_ops *);
100 static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
101 struct bp_target_info *);
103 static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
104 struct bp_target_info *);
106 static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
109 static int debug_to_insert_hw_breakpoint (struct target_ops *self,
111 struct bp_target_info *);
113 static int debug_to_remove_hw_breakpoint (struct target_ops *self,
115 struct bp_target_info *);
117 static int debug_to_insert_watchpoint (struct target_ops *self,
119 struct expression *);
121 static int debug_to_remove_watchpoint (struct target_ops *self,
123 struct expression *);
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 (struct target_ops *self,
133 static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
135 struct expression *);
137 static void debug_to_terminal_init (struct target_ops *self);
139 static void debug_to_terminal_inferior (struct target_ops *self);
141 static void debug_to_terminal_ours_for_output (struct target_ops *self);
143 static void debug_to_terminal_save_ours (struct target_ops *self);
145 static void debug_to_terminal_ours (struct target_ops *self);
147 static void debug_to_load (struct target_ops *self, char *, int);
149 static int debug_to_can_run (struct target_ops *self);
151 static void debug_to_stop (struct target_ops *self, ptid_t);
153 /* Pointer to array of target architecture structures; the size of the
154 array; the current index into the array; the allocated size of the
156 struct target_ops **target_structs;
157 unsigned target_struct_size;
158 unsigned target_struct_allocsize;
159 #define DEFAULT_ALLOCSIZE 10
161 /* The initial current target, so that there is always a semi-valid
164 static struct target_ops dummy_target;
166 /* Top of target stack. */
168 static struct target_ops *target_stack;
170 /* The target structure we are currently using to talk to a process
171 or file or whatever "inferior" we have. */
173 struct target_ops current_target;
175 /* Command list for target. */
177 static struct cmd_list_element *targetlist = NULL;
179 /* Nonzero if we should trust readonly sections from the
180 executable when reading memory. */
182 static int trust_readonly = 0;
184 /* Nonzero if we should show true memory content including
185 memory breakpoint inserted by gdb. */
187 static int show_memory_breakpoints = 0;
189 /* These globals control whether GDB attempts to perform these
190 operations; they are useful for targets that need to prevent
191 inadvertant disruption, such as in non-stop mode. */
193 int may_write_registers = 1;
195 int may_write_memory = 1;
197 int may_insert_breakpoints = 1;
199 int may_insert_tracepoints = 1;
201 int may_insert_fast_tracepoints = 1;
205 /* Non-zero if we want to see trace of target level stuff. */
207 static unsigned int targetdebug = 0;
209 show_targetdebug (struct ui_file *file, int from_tty,
210 struct cmd_list_element *c, const char *value)
212 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
215 static void setup_target_debug (void);
217 /* The user just typed 'target' without the name of a target. */
220 target_command (char *arg, int from_tty)
222 fputs_filtered ("Argument required (target name). Try `help target'\n",
226 /* Default target_has_* methods for process_stratum targets. */
229 default_child_has_all_memory (struct target_ops *ops)
231 /* If no inferior selected, then we can't read memory here. */
232 if (ptid_equal (inferior_ptid, null_ptid))
239 default_child_has_memory (struct target_ops *ops)
241 /* If no inferior selected, then we can't read memory here. */
242 if (ptid_equal (inferior_ptid, null_ptid))
249 default_child_has_stack (struct target_ops *ops)
251 /* If no inferior selected, there's no stack. */
252 if (ptid_equal (inferior_ptid, null_ptid))
259 default_child_has_registers (struct target_ops *ops)
261 /* Can't read registers from no inferior. */
262 if (ptid_equal (inferior_ptid, null_ptid))
269 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
271 /* If there's no thread selected, then we can't make it run through
273 if (ptid_equal (the_ptid, null_ptid))
281 target_has_all_memory_1 (void)
283 struct target_ops *t;
285 for (t = current_target.beneath; t != NULL; t = t->beneath)
286 if (t->to_has_all_memory (t))
293 target_has_memory_1 (void)
295 struct target_ops *t;
297 for (t = current_target.beneath; t != NULL; t = t->beneath)
298 if (t->to_has_memory (t))
305 target_has_stack_1 (void)
307 struct target_ops *t;
309 for (t = current_target.beneath; t != NULL; t = t->beneath)
310 if (t->to_has_stack (t))
317 target_has_registers_1 (void)
319 struct target_ops *t;
321 for (t = current_target.beneath; t != NULL; t = t->beneath)
322 if (t->to_has_registers (t))
329 target_has_execution_1 (ptid_t the_ptid)
331 struct target_ops *t;
333 for (t = current_target.beneath; t != NULL; t = t->beneath)
334 if (t->to_has_execution (t, the_ptid))
341 target_has_execution_current (void)
343 return target_has_execution_1 (inferior_ptid);
346 /* Complete initialization of T. This ensures that various fields in
347 T are set, if needed by the target implementation. */
350 complete_target_initialization (struct target_ops *t)
352 /* Provide default values for all "must have" methods. */
353 if (t->to_xfer_partial == NULL)
354 t->to_xfer_partial = default_xfer_partial;
356 if (t->to_has_all_memory == NULL)
357 t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
359 if (t->to_has_memory == NULL)
360 t->to_has_memory = (int (*) (struct target_ops *)) return_zero;
362 if (t->to_has_stack == NULL)
363 t->to_has_stack = (int (*) (struct target_ops *)) return_zero;
365 if (t->to_has_registers == NULL)
366 t->to_has_registers = (int (*) (struct target_ops *)) return_zero;
368 if (t->to_has_execution == NULL)
369 t->to_has_execution = (int (*) (struct target_ops *, ptid_t)) return_zero;
371 install_delegators (t);
374 /* Add possible target architecture T to the list and add a new
375 command 'target T->to_shortname'. Set COMPLETER as the command's
376 completer if not NULL. */
379 add_target_with_completer (struct target_ops *t,
380 completer_ftype *completer)
382 struct cmd_list_element *c;
384 complete_target_initialization (t);
388 target_struct_allocsize = DEFAULT_ALLOCSIZE;
389 target_structs = (struct target_ops **) xmalloc
390 (target_struct_allocsize * sizeof (*target_structs));
392 if (target_struct_size >= target_struct_allocsize)
394 target_struct_allocsize *= 2;
395 target_structs = (struct target_ops **)
396 xrealloc ((char *) target_structs,
397 target_struct_allocsize * sizeof (*target_structs));
399 target_structs[target_struct_size++] = t;
401 if (targetlist == NULL)
402 add_prefix_cmd ("target", class_run, target_command, _("\
403 Connect to a target machine or process.\n\
404 The first argument is the type or protocol of the target machine.\n\
405 Remaining arguments are interpreted by the target protocol. For more\n\
406 information on the arguments for a particular protocol, type\n\
407 `help target ' followed by the protocol name."),
408 &targetlist, "target ", 0, &cmdlist);
409 c = add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc,
411 if (completer != NULL)
412 set_cmd_completer (c, completer);
415 /* Add a possible target architecture to the list. */
418 add_target (struct target_ops *t)
420 add_target_with_completer (t, NULL);
426 add_deprecated_target_alias (struct target_ops *t, char *alias)
428 struct cmd_list_element *c;
431 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
433 c = add_cmd (alias, no_class, t->to_open, t->to_doc, &targetlist);
434 alt = xstrprintf ("target %s", t->to_shortname);
435 deprecate_cmd (c, alt);
448 struct target_ops *t;
450 for (t = current_target.beneath; t != NULL; t = t->beneath)
451 if (t->to_kill != NULL)
454 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
464 target_load (char *arg, int from_tty)
466 target_dcache_invalidate ();
467 (*current_target.to_load) (¤t_target, arg, from_tty);
471 target_create_inferior (char *exec_file, char *args,
472 char **env, int from_tty)
474 struct target_ops *t;
476 for (t = current_target.beneath; t != NULL; t = t->beneath)
478 if (t->to_create_inferior != NULL)
480 t->to_create_inferior (t, exec_file, args, env, from_tty);
482 fprintf_unfiltered (gdb_stdlog,
483 "target_create_inferior (%s, %s, xxx, %d)\n",
484 exec_file, args, from_tty);
489 internal_error (__FILE__, __LINE__,
490 _("could not find a target to create inferior"));
494 target_terminal_inferior (void)
496 /* A background resume (``run&'') should leave GDB in control of the
497 terminal. Use target_can_async_p, not target_is_async_p, since at
498 this point the target is not async yet. However, if sync_execution
499 is not set, we know it will become async prior to resume. */
500 if (target_can_async_p () && !sync_execution)
503 /* If GDB is resuming the inferior in the foreground, install
504 inferior's terminal modes. */
505 (*current_target.to_terminal_inferior) (¤t_target);
509 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
510 struct target_ops *t)
512 errno = EIO; /* Can't read/write this location. */
513 return 0; /* No bytes handled. */
519 error (_("You can't do that when your target is `%s'"),
520 current_target.to_shortname);
526 error (_("You can't do that without a process to debug."));
530 default_terminal_info (struct target_ops *self, const char *args, int from_tty)
532 printf_unfiltered (_("No saved terminal information.\n"));
535 /* A default implementation for the to_get_ada_task_ptid target method.
537 This function builds the PTID by using both LWP and TID as part of
538 the PTID lwp and tid elements. The pid used is the pid of the
542 default_get_ada_task_ptid (struct target_ops *self, long lwp, long tid)
544 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
547 static enum exec_direction_kind
548 default_execution_direction (struct target_ops *self)
550 if (!target_can_execute_reverse)
552 else if (!target_can_async_p ())
555 gdb_assert_not_reached ("\
556 to_execution_direction must be implemented for reverse async");
559 /* Go through the target stack from top to bottom, copying over zero
560 entries in current_target, then filling in still empty entries. In
561 effect, we are doing class inheritance through the pushed target
564 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
565 is currently implemented, is that it discards any knowledge of
566 which target an inherited method originally belonged to.
567 Consequently, new new target methods should instead explicitly and
568 locally search the target stack for the target that can handle the
572 update_current_target (void)
574 struct target_ops *t;
576 /* First, reset current's contents. */
577 memset (¤t_target, 0, sizeof (current_target));
579 /* Install the delegators. */
580 install_delegators (¤t_target);
582 #define INHERIT(FIELD, TARGET) \
583 if (!current_target.FIELD) \
584 current_target.FIELD = (TARGET)->FIELD
586 for (t = target_stack; t; t = t->beneath)
588 INHERIT (to_shortname, t);
589 INHERIT (to_longname, t);
591 /* Do not inherit to_open. */
592 /* Do not inherit to_close. */
593 /* Do not inherit to_attach. */
594 /* Do not inherit to_post_attach. */
595 INHERIT (to_attach_no_wait, t);
596 /* Do not inherit to_detach. */
597 /* Do not inherit to_disconnect. */
598 /* Do not inherit to_resume. */
599 /* Do not inherit to_wait. */
600 /* Do not inherit to_fetch_registers. */
601 /* Do not inherit to_store_registers. */
602 /* Do not inherit to_prepare_to_store. */
603 INHERIT (deprecated_xfer_memory, t);
604 /* Do not inherit to_files_info. */
605 /* Do not inherit to_insert_breakpoint. */
606 /* Do not inherit to_remove_breakpoint. */
607 /* Do not inherit to_can_use_hw_breakpoint. */
608 /* Do not inherit to_insert_hw_breakpoint. */
609 /* Do not inherit to_remove_hw_breakpoint. */
610 /* Do not inherit to_ranged_break_num_registers. */
611 /* Do not inherit to_insert_watchpoint. */
612 /* Do not inherit to_remove_watchpoint. */
613 /* Do not inherit to_insert_mask_watchpoint. */
614 /* Do not inherit to_remove_mask_watchpoint. */
615 /* Do not inherit to_stopped_data_address. */
616 INHERIT (to_have_steppable_watchpoint, t);
617 INHERIT (to_have_continuable_watchpoint, t);
618 /* Do not inherit to_stopped_by_watchpoint. */
619 /* Do not inherit to_watchpoint_addr_within_range. */
620 /* Do not inherit to_region_ok_for_hw_watchpoint. */
621 /* Do not inherit to_can_accel_watchpoint_condition. */
622 /* Do not inherit to_masked_watch_num_registers. */
623 /* Do not inherit to_terminal_init. */
624 /* Do not inherit to_terminal_inferior. */
625 /* Do not inherit to_terminal_ours_for_output. */
626 /* Do not inherit to_terminal_ours. */
627 /* Do not inherit to_terminal_save_ours. */
628 /* Do not inherit to_terminal_info. */
629 /* Do not inherit to_kill. */
630 /* Do not inherit to_load. */
631 /* Do no inherit to_create_inferior. */
632 /* Do not inherit to_post_startup_inferior. */
633 /* Do not inherit to_insert_fork_catchpoint. */
634 /* Do not inherit to_remove_fork_catchpoint. */
635 /* Do not inherit to_insert_vfork_catchpoint. */
636 /* Do not inherit to_remove_vfork_catchpoint. */
637 /* Do not inherit to_follow_fork. */
638 INHERIT (to_insert_exec_catchpoint, t);
639 INHERIT (to_remove_exec_catchpoint, t);
640 INHERIT (to_set_syscall_catchpoint, t);
641 INHERIT (to_has_exited, t);
642 /* Do not inherit to_mourn_inferior. */
643 INHERIT (to_can_run, t);
644 /* Do not inherit to_pass_signals. */
645 /* Do not inherit to_program_signals. */
646 /* Do not inherit to_thread_alive. */
647 /* Do not inherit to_find_new_threads. */
648 /* Do not inherit to_pid_to_str. */
649 INHERIT (to_extra_thread_info, t);
650 INHERIT (to_thread_name, t);
651 INHERIT (to_stop, t);
652 /* Do not inherit to_xfer_partial. */
653 /* Do not inherit to_rcmd. */
654 INHERIT (to_pid_to_exec_file, t);
655 INHERIT (to_log_command, t);
656 INHERIT (to_stratum, t);
657 /* Do not inherit to_has_all_memory. */
658 /* Do not inherit to_has_memory. */
659 /* Do not inherit to_has_stack. */
660 /* Do not inherit to_has_registers. */
661 /* Do not inherit to_has_execution. */
662 INHERIT (to_has_thread_control, t);
663 /* Do not inherit to_can_async_p. */
664 /* Do not inherit to_is_async_p. */
665 /* Do not inherit to_async. */
666 INHERIT (to_find_memory_regions, t);
667 INHERIT (to_make_corefile_notes, t);
668 INHERIT (to_get_bookmark, t);
669 INHERIT (to_goto_bookmark, t);
670 /* Do not inherit to_get_thread_local_address. */
671 INHERIT (to_can_execute_reverse, t);
672 INHERIT (to_execution_direction, t);
673 INHERIT (to_thread_architecture, t);
674 /* Do not inherit to_read_description. */
675 INHERIT (to_get_ada_task_ptid, t);
676 /* Do not inherit to_search_memory. */
677 INHERIT (to_supports_multi_process, t);
678 INHERIT (to_supports_enable_disable_tracepoint, t);
679 INHERIT (to_supports_string_tracing, t);
680 INHERIT (to_trace_init, t);
681 INHERIT (to_download_tracepoint, t);
682 INHERIT (to_can_download_tracepoint, t);
683 INHERIT (to_download_trace_state_variable, t);
684 INHERIT (to_enable_tracepoint, t);
685 INHERIT (to_disable_tracepoint, t);
686 INHERIT (to_trace_set_readonly_regions, t);
687 INHERIT (to_trace_start, t);
688 INHERIT (to_get_trace_status, t);
689 INHERIT (to_get_tracepoint_status, t);
690 INHERIT (to_trace_stop, t);
691 INHERIT (to_trace_find, t);
692 INHERIT (to_get_trace_state_variable_value, t);
693 INHERIT (to_save_trace_data, t);
694 INHERIT (to_upload_tracepoints, t);
695 INHERIT (to_upload_trace_state_variables, t);
696 INHERIT (to_get_raw_trace_data, t);
697 INHERIT (to_get_min_fast_tracepoint_insn_len, t);
698 INHERIT (to_set_disconnected_tracing, t);
699 INHERIT (to_set_circular_trace_buffer, t);
700 INHERIT (to_set_trace_buffer_size, t);
701 INHERIT (to_set_trace_notes, t);
702 INHERIT (to_get_tib_address, t);
703 INHERIT (to_set_permissions, t);
704 INHERIT (to_static_tracepoint_marker_at, t);
705 INHERIT (to_static_tracepoint_markers_by_strid, t);
706 INHERIT (to_traceframe_info, t);
707 INHERIT (to_use_agent, t);
708 INHERIT (to_can_use_agent, t);
709 INHERIT (to_augmented_libraries_svr4_read, t);
710 INHERIT (to_magic, t);
711 INHERIT (to_supports_evaluation_of_breakpoint_conditions, t);
712 INHERIT (to_can_run_breakpoint_commands, t);
713 /* Do not inherit to_memory_map. */
714 /* Do not inherit to_flash_erase. */
715 /* Do not inherit to_flash_done. */
719 /* Clean up a target struct so it no longer has any zero pointers in
720 it. Some entries are defaulted to a method that print an error,
721 others are hard-wired to a standard recursive default. */
723 #define de_fault(field, value) \
724 if (!current_target.field) \
725 current_target.field = value
728 (void (*) (char *, int))
731 (void (*) (struct target_ops *))
733 de_fault (deprecated_xfer_memory,
734 (int (*) (CORE_ADDR, gdb_byte *, int, int,
735 struct mem_attrib *, struct target_ops *))
737 de_fault (to_insert_exec_catchpoint,
738 (int (*) (struct target_ops *, int))
740 de_fault (to_remove_exec_catchpoint,
741 (int (*) (struct target_ops *, int))
743 de_fault (to_set_syscall_catchpoint,
744 (int (*) (struct target_ops *, int, int, int, int, int *))
746 de_fault (to_has_exited,
747 (int (*) (struct target_ops *, int, int, int *))
749 de_fault (to_can_run,
750 (int (*) (struct target_ops *))
752 de_fault (to_extra_thread_info,
753 (char *(*) (struct target_ops *, struct thread_info *))
755 de_fault (to_thread_name,
756 (char *(*) (struct target_ops *, struct thread_info *))
759 (void (*) (struct target_ops *, ptid_t))
761 de_fault (to_pid_to_exec_file,
762 (char *(*) (struct target_ops *, int))
764 de_fault (to_thread_architecture,
765 default_thread_architecture);
766 current_target.to_read_description = NULL;
767 de_fault (to_get_ada_task_ptid,
768 (ptid_t (*) (struct target_ops *, long, long))
769 default_get_ada_task_ptid);
770 de_fault (to_supports_multi_process,
771 (int (*) (struct target_ops *))
773 de_fault (to_supports_enable_disable_tracepoint,
774 (int (*) (struct target_ops *))
776 de_fault (to_supports_string_tracing,
777 (int (*) (struct target_ops *))
779 de_fault (to_trace_init,
780 (void (*) (struct target_ops *))
782 de_fault (to_download_tracepoint,
783 (void (*) (struct target_ops *, struct bp_location *))
785 de_fault (to_can_download_tracepoint,
786 (int (*) (struct target_ops *))
788 de_fault (to_download_trace_state_variable,
789 (void (*) (struct target_ops *, struct trace_state_variable *))
791 de_fault (to_enable_tracepoint,
792 (void (*) (struct target_ops *, struct bp_location *))
794 de_fault (to_disable_tracepoint,
795 (void (*) (struct target_ops *, struct bp_location *))
797 de_fault (to_trace_set_readonly_regions,
798 (void (*) (struct target_ops *))
800 de_fault (to_trace_start,
801 (void (*) (struct target_ops *))
803 de_fault (to_get_trace_status,
804 (int (*) (struct target_ops *, struct trace_status *))
806 de_fault (to_get_tracepoint_status,
807 (void (*) (struct target_ops *, struct breakpoint *,
808 struct uploaded_tp *))
810 de_fault (to_trace_stop,
811 (void (*) (struct target_ops *))
813 de_fault (to_trace_find,
814 (int (*) (struct target_ops *,
815 enum trace_find_type, int, CORE_ADDR, CORE_ADDR, int *))
817 de_fault (to_get_trace_state_variable_value,
818 (int (*) (struct target_ops *, int, LONGEST *))
820 de_fault (to_save_trace_data,
821 (int (*) (struct target_ops *, const char *))
823 de_fault (to_upload_tracepoints,
824 (int (*) (struct target_ops *, struct uploaded_tp **))
826 de_fault (to_upload_trace_state_variables,
827 (int (*) (struct target_ops *, struct uploaded_tsv **))
829 de_fault (to_get_raw_trace_data,
830 (LONGEST (*) (struct target_ops *, gdb_byte *, ULONGEST, LONGEST))
832 de_fault (to_get_min_fast_tracepoint_insn_len,
833 (int (*) (struct target_ops *))
835 de_fault (to_set_disconnected_tracing,
836 (void (*) (struct target_ops *, int))
838 de_fault (to_set_circular_trace_buffer,
839 (void (*) (struct target_ops *, int))
841 de_fault (to_set_trace_buffer_size,
842 (void (*) (struct target_ops *, LONGEST))
844 de_fault (to_set_trace_notes,
845 (int (*) (struct target_ops *,
846 const char *, const char *, const char *))
848 de_fault (to_get_tib_address,
849 (int (*) (struct target_ops *, ptid_t, CORE_ADDR *))
851 de_fault (to_set_permissions,
852 (void (*) (struct target_ops *))
854 de_fault (to_static_tracepoint_marker_at,
855 (int (*) (struct target_ops *,
856 CORE_ADDR, struct static_tracepoint_marker *))
858 de_fault (to_static_tracepoint_markers_by_strid,
859 (VEC(static_tracepoint_marker_p) * (*) (struct target_ops *,
862 de_fault (to_traceframe_info,
863 (struct traceframe_info * (*) (struct target_ops *))
865 de_fault (to_supports_evaluation_of_breakpoint_conditions,
866 (int (*) (struct target_ops *))
868 de_fault (to_can_run_breakpoint_commands,
869 (int (*) (struct target_ops *))
871 de_fault (to_use_agent,
872 (int (*) (struct target_ops *, int))
874 de_fault (to_can_use_agent,
875 (int (*) (struct target_ops *))
877 de_fault (to_augmented_libraries_svr4_read,
878 (int (*) (struct target_ops *))
880 de_fault (to_execution_direction, default_execution_direction);
884 /* Finally, position the target-stack beneath the squashed
885 "current_target". That way code looking for a non-inherited
886 target method can quickly and simply find it. */
887 current_target.beneath = target_stack;
890 setup_target_debug ();
893 /* Push a new target type into the stack of the existing target accessors,
894 possibly superseding some of the existing accessors.
896 Rather than allow an empty stack, we always have the dummy target at
897 the bottom stratum, so we can call the function vectors without
901 push_target (struct target_ops *t)
903 struct target_ops **cur;
905 /* Check magic number. If wrong, it probably means someone changed
906 the struct definition, but not all the places that initialize one. */
907 if (t->to_magic != OPS_MAGIC)
909 fprintf_unfiltered (gdb_stderr,
910 "Magic number of %s target struct wrong\n",
912 internal_error (__FILE__, __LINE__,
913 _("failed internal consistency check"));
916 /* Find the proper stratum to install this target in. */
917 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
919 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
923 /* If there's already targets at this stratum, remove them. */
924 /* FIXME: cagney/2003-10-15: I think this should be popping all
925 targets to CUR, and not just those at this stratum level. */
926 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
928 /* There's already something at this stratum level. Close it,
929 and un-hook it from the stack. */
930 struct target_ops *tmp = (*cur);
932 (*cur) = (*cur)->beneath;
937 /* We have removed all targets in our stratum, now add the new one. */
941 update_current_target ();
944 /* Remove a target_ops vector from the stack, wherever it may be.
945 Return how many times it was removed (0 or 1). */
948 unpush_target (struct target_ops *t)
950 struct target_ops **cur;
951 struct target_ops *tmp;
953 if (t->to_stratum == dummy_stratum)
954 internal_error (__FILE__, __LINE__,
955 _("Attempt to unpush the dummy target"));
957 /* Look for the specified target. Note that we assume that a target
958 can only occur once in the target stack. */
960 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
966 /* If we don't find target_ops, quit. Only open targets should be
971 /* Unchain the target. */
973 (*cur) = (*cur)->beneath;
976 update_current_target ();
978 /* Finally close the target. Note we do this after unchaining, so
979 any target method calls from within the target_close
980 implementation don't end up in T anymore. */
987 pop_all_targets_above (enum strata above_stratum)
989 while ((int) (current_target.to_stratum) > (int) above_stratum)
991 if (!unpush_target (target_stack))
993 fprintf_unfiltered (gdb_stderr,
994 "pop_all_targets couldn't find target %s\n",
995 target_stack->to_shortname);
996 internal_error (__FILE__, __LINE__,
997 _("failed internal consistency check"));
1004 pop_all_targets (void)
1006 pop_all_targets_above (dummy_stratum);
1009 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1012 target_is_pushed (struct target_ops *t)
1014 struct target_ops **cur;
1016 /* Check magic number. If wrong, it probably means someone changed
1017 the struct definition, but not all the places that initialize one. */
1018 if (t->to_magic != OPS_MAGIC)
1020 fprintf_unfiltered (gdb_stderr,
1021 "Magic number of %s target struct wrong\n",
1023 internal_error (__FILE__, __LINE__,
1024 _("failed internal consistency check"));
1027 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
1034 /* Using the objfile specified in OBJFILE, find the address for the
1035 current thread's thread-local storage with offset OFFSET. */
1037 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
1039 volatile CORE_ADDR addr = 0;
1040 struct target_ops *target;
1042 for (target = current_target.beneath;
1044 target = target->beneath)
1046 if (target->to_get_thread_local_address != NULL)
1051 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1053 ptid_t ptid = inferior_ptid;
1054 volatile struct gdb_exception ex;
1056 TRY_CATCH (ex, RETURN_MASK_ALL)
1060 /* Fetch the load module address for this objfile. */
1061 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1063 /* If it's 0, throw the appropriate exception. */
1065 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
1066 _("TLS load module not found"));
1068 addr = target->to_get_thread_local_address (target, ptid,
1071 /* If an error occurred, print TLS related messages here. Otherwise,
1072 throw the error to some higher catcher. */
1075 int objfile_is_library = (objfile->flags & OBJF_SHARED);
1079 case TLS_NO_LIBRARY_SUPPORT_ERROR:
1080 error (_("Cannot find thread-local variables "
1081 "in this thread library."));
1083 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
1084 if (objfile_is_library)
1085 error (_("Cannot find shared library `%s' in dynamic"
1086 " linker's load module list"), objfile_name (objfile));
1088 error (_("Cannot find executable file `%s' in dynamic"
1089 " linker's load module list"), objfile_name (objfile));
1091 case TLS_NOT_ALLOCATED_YET_ERROR:
1092 if (objfile_is_library)
1093 error (_("The inferior has not yet allocated storage for"
1094 " thread-local variables in\n"
1095 "the shared library `%s'\n"
1097 objfile_name (objfile), target_pid_to_str (ptid));
1099 error (_("The inferior has not yet allocated storage for"
1100 " thread-local variables in\n"
1101 "the executable `%s'\n"
1103 objfile_name (objfile), target_pid_to_str (ptid));
1105 case TLS_GENERIC_ERROR:
1106 if (objfile_is_library)
1107 error (_("Cannot find thread-local storage for %s, "
1108 "shared library %s:\n%s"),
1109 target_pid_to_str (ptid),
1110 objfile_name (objfile), ex.message);
1112 error (_("Cannot find thread-local storage for %s, "
1113 "executable file %s:\n%s"),
1114 target_pid_to_str (ptid),
1115 objfile_name (objfile), ex.message);
1118 throw_exception (ex);
1123 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1124 TLS is an ABI-specific thing. But we don't do that yet. */
1126 error (_("Cannot find thread-local variables on this target"));
1132 target_xfer_status_to_string (enum target_xfer_status err)
1134 #define CASE(X) case X: return #X
1137 CASE(TARGET_XFER_E_IO);
1138 CASE(TARGET_XFER_E_UNAVAILABLE);
1147 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1149 /* target_read_string -- read a null terminated string, up to LEN bytes,
1150 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1151 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1152 is responsible for freeing it. Return the number of bytes successfully
1156 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
1158 int tlen, offset, i;
1162 int buffer_allocated;
1164 unsigned int nbytes_read = 0;
1166 gdb_assert (string);
1168 /* Small for testing. */
1169 buffer_allocated = 4;
1170 buffer = xmalloc (buffer_allocated);
1175 tlen = MIN (len, 4 - (memaddr & 3));
1176 offset = memaddr & 3;
1178 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
1181 /* The transfer request might have crossed the boundary to an
1182 unallocated region of memory. Retry the transfer, requesting
1186 errcode = target_read_memory (memaddr, buf, 1);
1191 if (bufptr - buffer + tlen > buffer_allocated)
1195 bytes = bufptr - buffer;
1196 buffer_allocated *= 2;
1197 buffer = xrealloc (buffer, buffer_allocated);
1198 bufptr = buffer + bytes;
1201 for (i = 0; i < tlen; i++)
1203 *bufptr++ = buf[i + offset];
1204 if (buf[i + offset] == '\000')
1206 nbytes_read += i + 1;
1213 nbytes_read += tlen;
1222 struct target_section_table *
1223 target_get_section_table (struct target_ops *target)
1225 struct target_ops *t;
1228 fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
1230 for (t = target; t != NULL; t = t->beneath)
1231 if (t->to_get_section_table != NULL)
1232 return (*t->to_get_section_table) (t);
1237 /* Find a section containing ADDR. */
1239 struct target_section *
1240 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1242 struct target_section_table *table = target_get_section_table (target);
1243 struct target_section *secp;
1248 for (secp = table->sections; secp < table->sections_end; secp++)
1250 if (addr >= secp->addr && addr < secp->endaddr)
1256 /* Read memory from the live target, even if currently inspecting a
1257 traceframe. The return is the same as that of target_read. */
1259 static enum target_xfer_status
1260 target_read_live_memory (enum target_object object,
1261 ULONGEST memaddr, gdb_byte *myaddr, ULONGEST len,
1262 ULONGEST *xfered_len)
1264 enum target_xfer_status ret;
1265 struct cleanup *cleanup;
1267 /* Switch momentarily out of tfind mode so to access live memory.
1268 Note that this must not clear global state, such as the frame
1269 cache, which must still remain valid for the previous traceframe.
1270 We may be _building_ the frame cache at this point. */
1271 cleanup = make_cleanup_restore_traceframe_number ();
1272 set_traceframe_number (-1);
1274 ret = target_xfer_partial (current_target.beneath, object, NULL,
1275 myaddr, NULL, memaddr, len, xfered_len);
1277 do_cleanups (cleanup);
1281 /* Using the set of read-only target sections of OPS, read live
1282 read-only memory. Note that the actual reads start from the
1283 top-most target again.
1285 For interface/parameters/return description see target.h,
1288 static enum target_xfer_status
1289 memory_xfer_live_readonly_partial (struct target_ops *ops,
1290 enum target_object object,
1291 gdb_byte *readbuf, ULONGEST memaddr,
1292 ULONGEST len, ULONGEST *xfered_len)
1294 struct target_section *secp;
1295 struct target_section_table *table;
1297 secp = target_section_by_addr (ops, memaddr);
1299 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1300 secp->the_bfd_section)
1303 struct target_section *p;
1304 ULONGEST memend = memaddr + len;
1306 table = target_get_section_table (ops);
1308 for (p = table->sections; p < table->sections_end; p++)
1310 if (memaddr >= p->addr)
1312 if (memend <= p->endaddr)
1314 /* Entire transfer is within this section. */
1315 return target_read_live_memory (object, memaddr,
1316 readbuf, len, xfered_len);
1318 else if (memaddr >= p->endaddr)
1320 /* This section ends before the transfer starts. */
1325 /* This section overlaps the transfer. Just do half. */
1326 len = p->endaddr - memaddr;
1327 return target_read_live_memory (object, memaddr,
1328 readbuf, len, xfered_len);
1334 return TARGET_XFER_EOF;
1337 /* Read memory from more than one valid target. A core file, for
1338 instance, could have some of memory but delegate other bits to
1339 the target below it. So, we must manually try all targets. */
1341 static enum target_xfer_status
1342 raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
1343 const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
1344 ULONGEST *xfered_len)
1346 enum target_xfer_status res;
1350 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1351 readbuf, writebuf, memaddr, len,
1353 if (res == TARGET_XFER_OK)
1356 /* Stop if the target reports that the memory is not available. */
1357 if (res == TARGET_XFER_E_UNAVAILABLE)
1360 /* We want to continue past core files to executables, but not
1361 past a running target's memory. */
1362 if (ops->to_has_all_memory (ops))
1367 while (ops != NULL);
1372 /* Perform a partial memory transfer.
1373 For docs see target.h, to_xfer_partial. */
1375 static enum target_xfer_status
1376 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
1377 gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr,
1378 ULONGEST len, ULONGEST *xfered_len)
1380 enum target_xfer_status res;
1382 struct mem_region *region;
1383 struct inferior *inf;
1385 /* For accesses to unmapped overlay sections, read directly from
1386 files. Must do this first, as MEMADDR may need adjustment. */
1387 if (readbuf != NULL && overlay_debugging)
1389 struct obj_section *section = find_pc_overlay (memaddr);
1391 if (pc_in_unmapped_range (memaddr, section))
1393 struct target_section_table *table
1394 = target_get_section_table (ops);
1395 const char *section_name = section->the_bfd_section->name;
1397 memaddr = overlay_mapped_address (memaddr, section);
1398 return section_table_xfer_memory_partial (readbuf, writebuf,
1399 memaddr, len, xfered_len,
1401 table->sections_end,
1406 /* Try the executable files, if "trust-readonly-sections" is set. */
1407 if (readbuf != NULL && trust_readonly)
1409 struct target_section *secp;
1410 struct target_section_table *table;
1412 secp = target_section_by_addr (ops, memaddr);
1414 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1415 secp->the_bfd_section)
1418 table = target_get_section_table (ops);
1419 return section_table_xfer_memory_partial (readbuf, writebuf,
1420 memaddr, len, xfered_len,
1422 table->sections_end,
1427 /* If reading unavailable memory in the context of traceframes, and
1428 this address falls within a read-only section, fallback to
1429 reading from live memory. */
1430 if (readbuf != NULL && get_traceframe_number () != -1)
1432 VEC(mem_range_s) *available;
1434 /* If we fail to get the set of available memory, then the
1435 target does not support querying traceframe info, and so we
1436 attempt reading from the traceframe anyway (assuming the
1437 target implements the old QTro packet then). */
1438 if (traceframe_available_memory (&available, memaddr, len))
1440 struct cleanup *old_chain;
1442 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
1444 if (VEC_empty (mem_range_s, available)
1445 || VEC_index (mem_range_s, available, 0)->start != memaddr)
1447 /* Don't read into the traceframe's available
1449 if (!VEC_empty (mem_range_s, available))
1451 LONGEST oldlen = len;
1453 len = VEC_index (mem_range_s, available, 0)->start - memaddr;
1454 gdb_assert (len <= oldlen);
1457 do_cleanups (old_chain);
1459 /* This goes through the topmost target again. */
1460 res = memory_xfer_live_readonly_partial (ops, object,
1463 if (res == TARGET_XFER_OK)
1464 return TARGET_XFER_OK;
1467 /* No use trying further, we know some memory starting
1468 at MEMADDR isn't available. */
1470 return TARGET_XFER_E_UNAVAILABLE;
1474 /* Don't try to read more than how much is available, in
1475 case the target implements the deprecated QTro packet to
1476 cater for older GDBs (the target's knowledge of read-only
1477 sections may be outdated by now). */
1478 len = VEC_index (mem_range_s, available, 0)->length;
1480 do_cleanups (old_chain);
1484 /* Try GDB's internal data cache. */
1485 region = lookup_mem_region (memaddr);
1486 /* region->hi == 0 means there's no upper bound. */
1487 if (memaddr + len < region->hi || region->hi == 0)
1490 reg_len = region->hi - memaddr;
1492 switch (region->attrib.mode)
1495 if (writebuf != NULL)
1496 return TARGET_XFER_E_IO;
1500 if (readbuf != NULL)
1501 return TARGET_XFER_E_IO;
1505 /* We only support writing to flash during "load" for now. */
1506 if (writebuf != NULL)
1507 error (_("Writing to flash memory forbidden in this context"));
1511 return TARGET_XFER_E_IO;
1514 if (!ptid_equal (inferior_ptid, null_ptid))
1515 inf = find_inferior_pid (ptid_get_pid (inferior_ptid));
1520 /* The dcache reads whole cache lines; that doesn't play well
1521 with reading from a trace buffer, because reading outside of
1522 the collected memory range fails. */
1523 && get_traceframe_number () == -1
1524 && (region->attrib.cache
1525 || (stack_cache_enabled_p () && object == TARGET_OBJECT_STACK_MEMORY)
1526 || (code_cache_enabled_p () && object == TARGET_OBJECT_CODE_MEMORY)))
1528 DCACHE *dcache = target_dcache_get_or_init ();
1531 if (readbuf != NULL)
1532 l = dcache_xfer_memory (ops, dcache, memaddr, readbuf, reg_len, 0);
1534 /* FIXME drow/2006-08-09: If we're going to preserve const
1535 correctness dcache_xfer_memory should take readbuf and
1537 l = dcache_xfer_memory (ops, dcache, memaddr, (void *) writebuf,
1540 return TARGET_XFER_E_IO;
1543 *xfered_len = (ULONGEST) l;
1544 return TARGET_XFER_OK;
1548 /* If none of those methods found the memory we wanted, fall back
1549 to a target partial transfer. Normally a single call to
1550 to_xfer_partial is enough; if it doesn't recognize an object
1551 it will call the to_xfer_partial of the next target down.
1552 But for memory this won't do. Memory is the only target
1553 object which can be read from more than one valid target.
1554 A core file, for instance, could have some of memory but
1555 delegate other bits to the target below it. So, we must
1556 manually try all targets. */
1558 res = raw_memory_xfer_partial (ops, readbuf, writebuf, memaddr, reg_len,
1561 /* Make sure the cache gets updated no matter what - if we are writing
1562 to the stack. Even if this write is not tagged as such, we still need
1563 to update the cache. */
1565 if (res == TARGET_XFER_OK
1568 && target_dcache_init_p ()
1569 && !region->attrib.cache
1570 && ((stack_cache_enabled_p () && object != TARGET_OBJECT_STACK_MEMORY)
1571 || (code_cache_enabled_p () && object != TARGET_OBJECT_CODE_MEMORY)))
1573 DCACHE *dcache = target_dcache_get ();
1575 dcache_update (dcache, memaddr, (void *) writebuf, reg_len);
1578 /* If we still haven't got anything, return the last error. We
1583 /* Perform a partial memory transfer. For docs see target.h,
1586 static enum target_xfer_status
1587 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1588 gdb_byte *readbuf, const gdb_byte *writebuf,
1589 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1591 enum target_xfer_status res;
1593 /* Zero length requests are ok and require no work. */
1595 return TARGET_XFER_EOF;
1597 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1598 breakpoint insns, thus hiding out from higher layers whether
1599 there are software breakpoints inserted in the code stream. */
1600 if (readbuf != NULL)
1602 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len,
1605 if (res == TARGET_XFER_OK && !show_memory_breakpoints)
1606 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, res);
1611 struct cleanup *old_chain;
1613 /* A large write request is likely to be partially satisfied
1614 by memory_xfer_partial_1. We will continually malloc
1615 and free a copy of the entire write request for breakpoint
1616 shadow handling even though we only end up writing a small
1617 subset of it. Cap writes to 4KB to mitigate this. */
1618 len = min (4096, len);
1620 buf = xmalloc (len);
1621 old_chain = make_cleanup (xfree, buf);
1622 memcpy (buf, writebuf, len);
1624 breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
1625 res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len,
1628 do_cleanups (old_chain);
1635 restore_show_memory_breakpoints (void *arg)
1637 show_memory_breakpoints = (uintptr_t) arg;
1641 make_show_memory_breakpoints_cleanup (int show)
1643 int current = show_memory_breakpoints;
1645 show_memory_breakpoints = show;
1646 return make_cleanup (restore_show_memory_breakpoints,
1647 (void *) (uintptr_t) current);
1650 /* For docs see target.h, to_xfer_partial. */
1652 enum target_xfer_status
1653 target_xfer_partial (struct target_ops *ops,
1654 enum target_object object, const char *annex,
1655 gdb_byte *readbuf, const gdb_byte *writebuf,
1656 ULONGEST offset, ULONGEST len,
1657 ULONGEST *xfered_len)
1659 enum target_xfer_status retval;
1661 gdb_assert (ops->to_xfer_partial != NULL);
1663 /* Transfer is done when LEN is zero. */
1665 return TARGET_XFER_EOF;
1667 if (writebuf && !may_write_memory)
1668 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1669 core_addr_to_string_nz (offset), plongest (len));
1673 /* If this is a memory transfer, let the memory-specific code
1674 have a look at it instead. Memory transfers are more
1676 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
1677 || object == TARGET_OBJECT_CODE_MEMORY)
1678 retval = memory_xfer_partial (ops, object, readbuf,
1679 writebuf, offset, len, xfered_len);
1680 else if (object == TARGET_OBJECT_RAW_MEMORY)
1682 /* Request the normal memory object from other layers. */
1683 retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len,
1687 retval = ops->to_xfer_partial (ops, object, annex, readbuf,
1688 writebuf, offset, len, xfered_len);
1692 const unsigned char *myaddr = NULL;
1694 fprintf_unfiltered (gdb_stdlog,
1695 "%s:target_xfer_partial "
1696 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1699 (annex ? annex : "(null)"),
1700 host_address_to_string (readbuf),
1701 host_address_to_string (writebuf),
1702 core_addr_to_string_nz (offset),
1703 pulongest (len), retval,
1704 pulongest (*xfered_len));
1710 if (retval == TARGET_XFER_OK && myaddr != NULL)
1714 fputs_unfiltered (", bytes =", gdb_stdlog);
1715 for (i = 0; i < *xfered_len; i++)
1717 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1719 if (targetdebug < 2 && i > 0)
1721 fprintf_unfiltered (gdb_stdlog, " ...");
1724 fprintf_unfiltered (gdb_stdlog, "\n");
1727 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1731 fputc_unfiltered ('\n', gdb_stdlog);
1734 /* Check implementations of to_xfer_partial update *XFERED_LEN
1735 properly. Do assertion after printing debug messages, so that we
1736 can find more clues on assertion failure from debugging messages. */
1737 if (retval == TARGET_XFER_OK || retval == TARGET_XFER_E_UNAVAILABLE)
1738 gdb_assert (*xfered_len > 0);
1743 /* Read LEN bytes of target memory at address MEMADDR, placing the
1744 results in GDB's memory at MYADDR. Returns either 0 for success or
1745 TARGET_XFER_E_IO if any error occurs.
1747 If an error occurs, no guarantee is made about the contents of the data at
1748 MYADDR. In particular, the caller should not depend upon partial reads
1749 filling the buffer with good data. There is no way for the caller to know
1750 how much good data might have been transfered anyway. Callers that can
1751 deal with partial reads should call target_read (which will retry until
1752 it makes no progress, and then return how much was transferred). */
1755 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1757 /* Dispatch to the topmost target, not the flattened current_target.
1758 Memory accesses check target->to_has_(all_)memory, and the
1759 flattened target doesn't inherit those. */
1760 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1761 myaddr, memaddr, len) == len)
1764 return TARGET_XFER_E_IO;
1767 /* Like target_read_memory, but specify explicitly that this is a read
1768 from the target's raw memory. That is, this read bypasses the
1769 dcache, breakpoint shadowing, etc. */
1772 target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1774 /* See comment in target_read_memory about why the request starts at
1775 current_target.beneath. */
1776 if (target_read (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1777 myaddr, memaddr, len) == len)
1780 return TARGET_XFER_E_IO;
1783 /* Like target_read_memory, but specify explicitly that this is a read from
1784 the target's stack. This may trigger different cache behavior. */
1787 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1789 /* See comment in target_read_memory about why the request starts at
1790 current_target.beneath. */
1791 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1792 myaddr, memaddr, len) == len)
1795 return TARGET_XFER_E_IO;
1798 /* Like target_read_memory, but specify explicitly that this is a read from
1799 the target's code. This may trigger different cache behavior. */
1802 target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1804 /* See comment in target_read_memory about why the request starts at
1805 current_target.beneath. */
1806 if (target_read (current_target.beneath, TARGET_OBJECT_CODE_MEMORY, NULL,
1807 myaddr, memaddr, len) == len)
1810 return TARGET_XFER_E_IO;
1813 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1814 Returns either 0 for success or TARGET_XFER_E_IO if any
1815 error occurs. If an error occurs, no guarantee is made about how
1816 much data got written. Callers that can deal with partial writes
1817 should call target_write. */
1820 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1822 /* See comment in target_read_memory about why the request starts at
1823 current_target.beneath. */
1824 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1825 myaddr, memaddr, len) == len)
1828 return TARGET_XFER_E_IO;
1831 /* Write LEN bytes from MYADDR to target raw memory at address
1832 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1833 if any error occurs. If an error occurs, no guarantee is made
1834 about how much data got written. Callers that can deal with
1835 partial writes should call target_write. */
1838 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1840 /* See comment in target_read_memory about why the request starts at
1841 current_target.beneath. */
1842 if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1843 myaddr, memaddr, len) == len)
1846 return TARGET_XFER_E_IO;
1849 /* Fetch the target's memory map. */
1852 target_memory_map (void)
1854 VEC(mem_region_s) *result;
1855 struct mem_region *last_one, *this_one;
1857 struct target_ops *t;
1860 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1862 for (t = current_target.beneath; t != NULL; t = t->beneath)
1863 if (t->to_memory_map != NULL)
1869 result = t->to_memory_map (t);
1873 qsort (VEC_address (mem_region_s, result),
1874 VEC_length (mem_region_s, result),
1875 sizeof (struct mem_region), mem_region_cmp);
1877 /* Check that regions do not overlap. Simultaneously assign
1878 a numbering for the "mem" commands to use to refer to
1881 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1883 this_one->number = ix;
1885 if (last_one && last_one->hi > this_one->lo)
1887 warning (_("Overlapping regions in memory map: ignoring"));
1888 VEC_free (mem_region_s, result);
1891 last_one = this_one;
1898 target_flash_erase (ULONGEST address, LONGEST length)
1900 struct target_ops *t;
1902 for (t = current_target.beneath; t != NULL; t = t->beneath)
1903 if (t->to_flash_erase != NULL)
1906 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1907 hex_string (address), phex (length, 0));
1908 t->to_flash_erase (t, address, length);
1916 target_flash_done (void)
1918 struct target_ops *t;
1920 for (t = current_target.beneath; t != NULL; t = t->beneath)
1921 if (t->to_flash_done != NULL)
1924 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1925 t->to_flash_done (t);
1933 show_trust_readonly (struct ui_file *file, int from_tty,
1934 struct cmd_list_element *c, const char *value)
1936 fprintf_filtered (file,
1937 _("Mode for reading from readonly sections is %s.\n"),
1941 /* More generic transfers. */
1943 static enum target_xfer_status
1944 default_xfer_partial (struct target_ops *ops, enum target_object object,
1945 const char *annex, gdb_byte *readbuf,
1946 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1947 ULONGEST *xfered_len)
1949 if (object == TARGET_OBJECT_MEMORY
1950 && ops->deprecated_xfer_memory != NULL)
1951 /* If available, fall back to the target's
1952 "deprecated_xfer_memory" method. */
1957 if (writebuf != NULL)
1959 void *buffer = xmalloc (len);
1960 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1962 memcpy (buffer, writebuf, len);
1963 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1964 1/*write*/, NULL, ops);
1965 do_cleanups (cleanup);
1967 if (readbuf != NULL)
1968 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1969 0/*read*/, NULL, ops);
1972 *xfered_len = (ULONGEST) xfered;
1973 return TARGET_XFER_E_IO;
1975 else if (xfered == 0 && errno == 0)
1976 /* "deprecated_xfer_memory" uses 0, cross checked against
1977 ERRNO as one indication of an error. */
1978 return TARGET_XFER_EOF;
1980 return TARGET_XFER_E_IO;
1984 gdb_assert (ops->beneath != NULL);
1985 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1986 readbuf, writebuf, offset, len,
1991 /* Target vector read/write partial wrapper functions. */
1993 static enum target_xfer_status
1994 target_read_partial (struct target_ops *ops,
1995 enum target_object object,
1996 const char *annex, gdb_byte *buf,
1997 ULONGEST offset, ULONGEST len,
1998 ULONGEST *xfered_len)
2000 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len,
2004 static enum target_xfer_status
2005 target_write_partial (struct target_ops *ops,
2006 enum target_object object,
2007 const char *annex, const gdb_byte *buf,
2008 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
2010 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len,
2014 /* Wrappers to perform the full transfer. */
2016 /* For docs on target_read see target.h. */
2019 target_read (struct target_ops *ops,
2020 enum target_object object,
2021 const char *annex, gdb_byte *buf,
2022 ULONGEST offset, LONGEST len)
2026 while (xfered < len)
2028 ULONGEST xfered_len;
2029 enum target_xfer_status status;
2031 status = target_read_partial (ops, object, annex,
2032 (gdb_byte *) buf + xfered,
2033 offset + xfered, len - xfered,
2036 /* Call an observer, notifying them of the xfer progress? */
2037 if (status == TARGET_XFER_EOF)
2039 else if (status == TARGET_XFER_OK)
2041 xfered += xfered_len;
2051 /* Assuming that the entire [begin, end) range of memory cannot be
2052 read, try to read whatever subrange is possible to read.
2054 The function returns, in RESULT, either zero or one memory block.
2055 If there's a readable subrange at the beginning, it is completely
2056 read and returned. Any further readable subrange will not be read.
2057 Otherwise, if there's a readable subrange at the end, it will be
2058 completely read and returned. Any readable subranges before it
2059 (obviously, not starting at the beginning), will be ignored. In
2060 other cases -- either no readable subrange, or readable subrange(s)
2061 that is neither at the beginning, or end, nothing is returned.
2063 The purpose of this function is to handle a read across a boundary
2064 of accessible memory in a case when memory map is not available.
2065 The above restrictions are fine for this case, but will give
2066 incorrect results if the memory is 'patchy'. However, supporting
2067 'patchy' memory would require trying to read every single byte,
2068 and it seems unacceptable solution. Explicit memory map is
2069 recommended for this case -- and target_read_memory_robust will
2070 take care of reading multiple ranges then. */
2073 read_whatever_is_readable (struct target_ops *ops,
2074 ULONGEST begin, ULONGEST end,
2075 VEC(memory_read_result_s) **result)
2077 gdb_byte *buf = xmalloc (end - begin);
2078 ULONGEST current_begin = begin;
2079 ULONGEST current_end = end;
2081 memory_read_result_s r;
2082 ULONGEST xfered_len;
2084 /* If we previously failed to read 1 byte, nothing can be done here. */
2085 if (end - begin <= 1)
2091 /* Check that either first or the last byte is readable, and give up
2092 if not. This heuristic is meant to permit reading accessible memory
2093 at the boundary of accessible region. */
2094 if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2095 buf, begin, 1, &xfered_len) == TARGET_XFER_OK)
2100 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2101 buf + (end-begin) - 1, end - 1, 1,
2102 &xfered_len) == TARGET_XFER_OK)
2113 /* Loop invariant is that the [current_begin, current_end) was previously
2114 found to be not readable as a whole.
2116 Note loop condition -- if the range has 1 byte, we can't divide the range
2117 so there's no point trying further. */
2118 while (current_end - current_begin > 1)
2120 ULONGEST first_half_begin, first_half_end;
2121 ULONGEST second_half_begin, second_half_end;
2123 ULONGEST middle = current_begin + (current_end - current_begin)/2;
2127 first_half_begin = current_begin;
2128 first_half_end = middle;
2129 second_half_begin = middle;
2130 second_half_end = current_end;
2134 first_half_begin = middle;
2135 first_half_end = current_end;
2136 second_half_begin = current_begin;
2137 second_half_end = middle;
2140 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2141 buf + (first_half_begin - begin),
2143 first_half_end - first_half_begin);
2145 if (xfer == first_half_end - first_half_begin)
2147 /* This half reads up fine. So, the error must be in the
2149 current_begin = second_half_begin;
2150 current_end = second_half_end;
2154 /* This half is not readable. Because we've tried one byte, we
2155 know some part of this half if actually redable. Go to the next
2156 iteration to divide again and try to read.
2158 We don't handle the other half, because this function only tries
2159 to read a single readable subrange. */
2160 current_begin = first_half_begin;
2161 current_end = first_half_end;
2167 /* The [begin, current_begin) range has been read. */
2169 r.end = current_begin;
2174 /* The [current_end, end) range has been read. */
2175 LONGEST rlen = end - current_end;
2177 r.data = xmalloc (rlen);
2178 memcpy (r.data, buf + current_end - begin, rlen);
2179 r.begin = current_end;
2183 VEC_safe_push(memory_read_result_s, (*result), &r);
2187 free_memory_read_result_vector (void *x)
2189 VEC(memory_read_result_s) *v = x;
2190 memory_read_result_s *current;
2193 for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
2195 xfree (current->data);
2197 VEC_free (memory_read_result_s, v);
2200 VEC(memory_read_result_s) *
2201 read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
2203 VEC(memory_read_result_s) *result = 0;
2206 while (xfered < len)
2208 struct mem_region *region = lookup_mem_region (offset + xfered);
2211 /* If there is no explicit region, a fake one should be created. */
2212 gdb_assert (region);
2214 if (region->hi == 0)
2215 rlen = len - xfered;
2217 rlen = region->hi - offset;
2219 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
2221 /* Cannot read this region. Note that we can end up here only
2222 if the region is explicitly marked inaccessible, or
2223 'inaccessible-by-default' is in effect. */
2228 LONGEST to_read = min (len - xfered, rlen);
2229 gdb_byte *buffer = (gdb_byte *)xmalloc (to_read);
2231 LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2232 (gdb_byte *) buffer,
2233 offset + xfered, to_read);
2234 /* Call an observer, notifying them of the xfer progress? */
2237 /* Got an error reading full chunk. See if maybe we can read
2240 read_whatever_is_readable (ops, offset + xfered,
2241 offset + xfered + to_read, &result);
2246 struct memory_read_result r;
2248 r.begin = offset + xfered;
2249 r.end = r.begin + xfer;
2250 VEC_safe_push (memory_read_result_s, result, &r);
2260 /* An alternative to target_write with progress callbacks. */
2263 target_write_with_progress (struct target_ops *ops,
2264 enum target_object object,
2265 const char *annex, const gdb_byte *buf,
2266 ULONGEST offset, LONGEST len,
2267 void (*progress) (ULONGEST, void *), void *baton)
2271 /* Give the progress callback a chance to set up. */
2273 (*progress) (0, baton);
2275 while (xfered < len)
2277 ULONGEST xfered_len;
2278 enum target_xfer_status status;
2280 status = target_write_partial (ops, object, annex,
2281 (gdb_byte *) buf + xfered,
2282 offset + xfered, len - xfered,
2285 if (status == TARGET_XFER_EOF)
2287 if (TARGET_XFER_STATUS_ERROR_P (status))
2290 gdb_assert (status == TARGET_XFER_OK);
2292 (*progress) (xfered_len, baton);
2294 xfered += xfered_len;
2300 /* For docs on target_write see target.h. */
2303 target_write (struct target_ops *ops,
2304 enum target_object object,
2305 const char *annex, const gdb_byte *buf,
2306 ULONGEST offset, LONGEST len)
2308 return target_write_with_progress (ops, object, annex, buf, offset, len,
2312 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2313 the size of the transferred data. PADDING additional bytes are
2314 available in *BUF_P. This is a helper function for
2315 target_read_alloc; see the declaration of that function for more
2319 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
2320 const char *annex, gdb_byte **buf_p, int padding)
2322 size_t buf_alloc, buf_pos;
2325 /* This function does not have a length parameter; it reads the
2326 entire OBJECT). Also, it doesn't support objects fetched partly
2327 from one target and partly from another (in a different stratum,
2328 e.g. a core file and an executable). Both reasons make it
2329 unsuitable for reading memory. */
2330 gdb_assert (object != TARGET_OBJECT_MEMORY);
2332 /* Start by reading up to 4K at a time. The target will throttle
2333 this number down if necessary. */
2335 buf = xmalloc (buf_alloc);
2339 ULONGEST xfered_len;
2340 enum target_xfer_status status;
2342 status = target_read_partial (ops, object, annex, &buf[buf_pos],
2343 buf_pos, buf_alloc - buf_pos - padding,
2346 if (status == TARGET_XFER_EOF)
2348 /* Read all there was. */
2355 else if (status != TARGET_XFER_OK)
2357 /* An error occurred. */
2359 return TARGET_XFER_E_IO;
2362 buf_pos += xfered_len;
2364 /* If the buffer is filling up, expand it. */
2365 if (buf_alloc < buf_pos * 2)
2368 buf = xrealloc (buf, buf_alloc);
2375 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2376 the size of the transferred data. See the declaration in "target.h"
2377 function for more information about the return value. */
2380 target_read_alloc (struct target_ops *ops, enum target_object object,
2381 const char *annex, gdb_byte **buf_p)
2383 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
2386 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2387 returned as a string, allocated using xmalloc. If an error occurs
2388 or the transfer is unsupported, NULL is returned. Empty objects
2389 are returned as allocated but empty strings. A warning is issued
2390 if the result contains any embedded NUL bytes. */
2393 target_read_stralloc (struct target_ops *ops, enum target_object object,
2398 LONGEST i, transferred;
2400 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
2401 bufstr = (char *) buffer;
2403 if (transferred < 0)
2406 if (transferred == 0)
2407 return xstrdup ("");
2409 bufstr[transferred] = 0;
2411 /* Check for embedded NUL bytes; but allow trailing NULs. */
2412 for (i = strlen (bufstr); i < transferred; i++)
2415 warning (_("target object %d, annex %s, "
2416 "contained unexpected null characters"),
2417 (int) object, annex ? annex : "(none)");
2424 /* Memory transfer methods. */
2427 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2430 /* This method is used to read from an alternate, non-current
2431 target. This read must bypass the overlay support (as symbols
2432 don't match this target), and GDB's internal cache (wrong cache
2433 for this target). */
2434 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2436 memory_error (TARGET_XFER_E_IO, addr);
2440 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2441 int len, enum bfd_endian byte_order)
2443 gdb_byte buf[sizeof (ULONGEST)];
2445 gdb_assert (len <= sizeof (buf));
2446 get_target_memory (ops, addr, buf, len);
2447 return extract_unsigned_integer (buf, len, byte_order);
2453 target_insert_breakpoint (struct gdbarch *gdbarch,
2454 struct bp_target_info *bp_tgt)
2456 if (!may_insert_breakpoints)
2458 warning (_("May not insert breakpoints"));
2462 return current_target.to_insert_breakpoint (¤t_target,
2469 target_remove_breakpoint (struct gdbarch *gdbarch,
2470 struct bp_target_info *bp_tgt)
2472 /* This is kind of a weird case to handle, but the permission might
2473 have been changed after breakpoints were inserted - in which case
2474 we should just take the user literally and assume that any
2475 breakpoints should be left in place. */
2476 if (!may_insert_breakpoints)
2478 warning (_("May not remove breakpoints"));
2482 return current_target.to_remove_breakpoint (¤t_target,
2487 target_info (char *args, int from_tty)
2489 struct target_ops *t;
2490 int has_all_mem = 0;
2492 if (symfile_objfile != NULL)
2493 printf_unfiltered (_("Symbols from \"%s\".\n"),
2494 objfile_name (symfile_objfile));
2496 for (t = target_stack; t != NULL; t = t->beneath)
2498 if (!(*t->to_has_memory) (t))
2501 if ((int) (t->to_stratum) <= (int) dummy_stratum)
2504 printf_unfiltered (_("\tWhile running this, "
2505 "GDB does not access memory from...\n"));
2506 printf_unfiltered ("%s:\n", t->to_longname);
2507 (t->to_files_info) (t);
2508 has_all_mem = (*t->to_has_all_memory) (t);
2512 /* This function is called before any new inferior is created, e.g.
2513 by running a program, attaching, or connecting to a target.
2514 It cleans up any state from previous invocations which might
2515 change between runs. This is a subset of what target_preopen
2516 resets (things which might change between targets). */
2519 target_pre_inferior (int from_tty)
2521 /* Clear out solib state. Otherwise the solib state of the previous
2522 inferior might have survived and is entirely wrong for the new
2523 target. This has been observed on GNU/Linux using glibc 2.3. How
2535 Cannot access memory at address 0xdeadbeef
2538 /* In some OSs, the shared library list is the same/global/shared
2539 across inferiors. If code is shared between processes, so are
2540 memory regions and features. */
2541 if (!gdbarch_has_global_solist (target_gdbarch ()))
2543 no_shared_libraries (NULL, from_tty);
2545 invalidate_target_mem_regions ();
2547 target_clear_description ();
2550 agent_capability_invalidate ();
2553 /* Callback for iterate_over_inferiors. Gets rid of the given
2557 dispose_inferior (struct inferior *inf, void *args)
2559 struct thread_info *thread;
2561 thread = any_thread_of_process (inf->pid);
2564 switch_to_thread (thread->ptid);
2566 /* Core inferiors actually should be detached, not killed. */
2567 if (target_has_execution)
2570 target_detach (NULL, 0);
2576 /* This is to be called by the open routine before it does
2580 target_preopen (int from_tty)
2584 if (have_inferiors ())
2587 || !have_live_inferiors ()
2588 || query (_("A program is being debugged already. Kill it? ")))
2589 iterate_over_inferiors (dispose_inferior, NULL);
2591 error (_("Program not killed."));
2594 /* Calling target_kill may remove the target from the stack. But if
2595 it doesn't (which seems like a win for UDI), remove it now. */
2596 /* Leave the exec target, though. The user may be switching from a
2597 live process to a core of the same program. */
2598 pop_all_targets_above (file_stratum);
2600 target_pre_inferior (from_tty);
2603 /* Detach a target after doing deferred register stores. */
2606 target_detach (const char *args, int from_tty)
2608 struct target_ops* t;
2610 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2611 /* Don't remove global breakpoints here. They're removed on
2612 disconnection from the target. */
2615 /* If we're in breakpoints-always-inserted mode, have to remove
2616 them before detaching. */
2617 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
2619 prepare_for_detach ();
2621 current_target.to_detach (¤t_target, args, from_tty);
2623 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
2628 target_disconnect (char *args, int from_tty)
2630 struct target_ops *t;
2632 /* If we're in breakpoints-always-inserted mode or if breakpoints
2633 are global across processes, we have to remove them before
2635 remove_breakpoints ();
2637 for (t = current_target.beneath; t != NULL; t = t->beneath)
2638 if (t->to_disconnect != NULL)
2641 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
2643 t->to_disconnect (t, args, from_tty);
2651 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2653 struct target_ops *t;
2654 ptid_t retval = (current_target.to_wait) (¤t_target, ptid,
2659 char *status_string;
2660 char *options_string;
2662 status_string = target_waitstatus_to_string (status);
2663 options_string = target_options_to_string (options);
2664 fprintf_unfiltered (gdb_stdlog,
2665 "target_wait (%d, status, options={%s})"
2667 ptid_get_pid (ptid), options_string,
2668 ptid_get_pid (retval), status_string);
2669 xfree (status_string);
2670 xfree (options_string);
2677 target_pid_to_str (ptid_t ptid)
2679 struct target_ops *t;
2681 for (t = current_target.beneath; t != NULL; t = t->beneath)
2683 if (t->to_pid_to_str != NULL)
2684 return (*t->to_pid_to_str) (t, ptid);
2687 return normal_pid_to_str (ptid);
2691 target_thread_name (struct thread_info *info)
2693 struct target_ops *t;
2695 for (t = current_target.beneath; t != NULL; t = t->beneath)
2697 if (t->to_thread_name != NULL)
2698 return (*t->to_thread_name) (t, info);
2705 target_resume (ptid_t ptid, int step, enum gdb_signal signal)
2707 struct target_ops *t;
2709 target_dcache_invalidate ();
2711 current_target.to_resume (¤t_target, ptid, step, signal);
2713 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
2714 ptid_get_pid (ptid),
2715 step ? "step" : "continue",
2716 gdb_signal_to_name (signal));
2718 registers_changed_ptid (ptid);
2719 set_executing (ptid, 1);
2720 set_running (ptid, 1);
2721 clear_inline_frame_state (ptid);
2725 target_pass_signals (int numsigs, unsigned char *pass_signals)
2727 struct target_ops *t;
2729 for (t = current_target.beneath; t != NULL; t = t->beneath)
2731 if (t->to_pass_signals != NULL)
2737 fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
2740 for (i = 0; i < numsigs; i++)
2741 if (pass_signals[i])
2742 fprintf_unfiltered (gdb_stdlog, " %s",
2743 gdb_signal_to_name (i));
2745 fprintf_unfiltered (gdb_stdlog, " })\n");
2748 (*t->to_pass_signals) (t, numsigs, pass_signals);
2755 target_program_signals (int numsigs, unsigned char *program_signals)
2757 struct target_ops *t;
2759 for (t = current_target.beneath; t != NULL; t = t->beneath)
2761 if (t->to_program_signals != NULL)
2767 fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
2770 for (i = 0; i < numsigs; i++)
2771 if (program_signals[i])
2772 fprintf_unfiltered (gdb_stdlog, " %s",
2773 gdb_signal_to_name (i));
2775 fprintf_unfiltered (gdb_stdlog, " })\n");
2778 (*t->to_program_signals) (t, numsigs, program_signals);
2784 /* Look through the list of possible targets for a target that can
2788 target_follow_fork (int follow_child, int detach_fork)
2790 struct target_ops *t;
2792 for (t = current_target.beneath; t != NULL; t = t->beneath)
2794 if (t->to_follow_fork != NULL)
2796 int retval = t->to_follow_fork (t, follow_child, detach_fork);
2799 fprintf_unfiltered (gdb_stdlog,
2800 "target_follow_fork (%d, %d) = %d\n",
2801 follow_child, detach_fork, retval);
2806 /* Some target returned a fork event, but did not know how to follow it. */
2807 internal_error (__FILE__, __LINE__,
2808 _("could not find a target to follow fork"));
2812 target_mourn_inferior (void)
2814 struct target_ops *t;
2816 for (t = current_target.beneath; t != NULL; t = t->beneath)
2818 if (t->to_mourn_inferior != NULL)
2820 t->to_mourn_inferior (t);
2822 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2824 /* We no longer need to keep handles on any of the object files.
2825 Make sure to release them to avoid unnecessarily locking any
2826 of them while we're not actually debugging. */
2827 bfd_cache_close_all ();
2833 internal_error (__FILE__, __LINE__,
2834 _("could not find a target to follow mourn inferior"));
2837 /* Look for a target which can describe architectural features, starting
2838 from TARGET. If we find one, return its description. */
2840 const struct target_desc *
2841 target_read_description (struct target_ops *target)
2843 struct target_ops *t;
2845 for (t = target; t != NULL; t = t->beneath)
2846 if (t->to_read_description != NULL)
2848 const struct target_desc *tdesc;
2850 tdesc = t->to_read_description (t);
2858 /* The default implementation of to_search_memory.
2859 This implements a basic search of memory, reading target memory and
2860 performing the search here (as opposed to performing the search in on the
2861 target side with, for example, gdbserver). */
2864 simple_search_memory (struct target_ops *ops,
2865 CORE_ADDR start_addr, ULONGEST search_space_len,
2866 const gdb_byte *pattern, ULONGEST pattern_len,
2867 CORE_ADDR *found_addrp)
2869 /* NOTE: also defined in find.c testcase. */
2870 #define SEARCH_CHUNK_SIZE 16000
2871 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2872 /* Buffer to hold memory contents for searching. */
2873 gdb_byte *search_buf;
2874 unsigned search_buf_size;
2875 struct cleanup *old_cleanups;
2877 search_buf_size = chunk_size + pattern_len - 1;
2879 /* No point in trying to allocate a buffer larger than the search space. */
2880 if (search_space_len < search_buf_size)
2881 search_buf_size = search_space_len;
2883 search_buf = malloc (search_buf_size);
2884 if (search_buf == NULL)
2885 error (_("Unable to allocate memory to perform the search."));
2886 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2888 /* Prime the search buffer. */
2890 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2891 search_buf, start_addr, search_buf_size) != search_buf_size)
2893 warning (_("Unable to access %s bytes of target "
2894 "memory at %s, halting search."),
2895 pulongest (search_buf_size), hex_string (start_addr));
2896 do_cleanups (old_cleanups);
2900 /* Perform the search.
2902 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2903 When we've scanned N bytes we copy the trailing bytes to the start and
2904 read in another N bytes. */
2906 while (search_space_len >= pattern_len)
2908 gdb_byte *found_ptr;
2909 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2911 found_ptr = memmem (search_buf, nr_search_bytes,
2912 pattern, pattern_len);
2914 if (found_ptr != NULL)
2916 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2918 *found_addrp = found_addr;
2919 do_cleanups (old_cleanups);
2923 /* Not found in this chunk, skip to next chunk. */
2925 /* Don't let search_space_len wrap here, it's unsigned. */
2926 if (search_space_len >= chunk_size)
2927 search_space_len -= chunk_size;
2929 search_space_len = 0;
2931 if (search_space_len >= pattern_len)
2933 unsigned keep_len = search_buf_size - chunk_size;
2934 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
2937 /* Copy the trailing part of the previous iteration to the front
2938 of the buffer for the next iteration. */
2939 gdb_assert (keep_len == pattern_len - 1);
2940 memcpy (search_buf, search_buf + chunk_size, keep_len);
2942 nr_to_read = min (search_space_len - keep_len, chunk_size);
2944 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2945 search_buf + keep_len, read_addr,
2946 nr_to_read) != nr_to_read)
2948 warning (_("Unable to access %s bytes of target "
2949 "memory at %s, halting search."),
2950 plongest (nr_to_read),
2951 hex_string (read_addr));
2952 do_cleanups (old_cleanups);
2956 start_addr += chunk_size;
2962 do_cleanups (old_cleanups);
2966 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2967 sequence of bytes in PATTERN with length PATTERN_LEN.
2969 The result is 1 if found, 0 if not found, and -1 if there was an error
2970 requiring halting of the search (e.g. memory read error).
2971 If the pattern is found the address is recorded in FOUND_ADDRP. */
2974 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2975 const gdb_byte *pattern, ULONGEST pattern_len,
2976 CORE_ADDR *found_addrp)
2978 struct target_ops *t;
2981 /* We don't use INHERIT to set current_target.to_search_memory,
2982 so we have to scan the target stack and handle targetdebug
2986 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2987 hex_string (start_addr));
2989 for (t = current_target.beneath; t != NULL; t = t->beneath)
2990 if (t->to_search_memory != NULL)
2995 found = t->to_search_memory (t, start_addr, search_space_len,
2996 pattern, pattern_len, found_addrp);
3000 /* If a special version of to_search_memory isn't available, use the
3002 found = simple_search_memory (current_target.beneath,
3003 start_addr, search_space_len,
3004 pattern, pattern_len, found_addrp);
3008 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
3013 /* Look through the currently pushed targets. If none of them will
3014 be able to restart the currently running process, issue an error
3018 target_require_runnable (void)
3020 struct target_ops *t;
3022 for (t = target_stack; t != NULL; t = t->beneath)
3024 /* If this target knows how to create a new program, then
3025 assume we will still be able to after killing the current
3026 one. Either killing and mourning will not pop T, or else
3027 find_default_run_target will find it again. */
3028 if (t->to_create_inferior != NULL)
3031 /* Do not worry about thread_stratum targets that can not
3032 create inferiors. Assume they will be pushed again if
3033 necessary, and continue to the process_stratum. */
3034 if (t->to_stratum == thread_stratum
3035 || t->to_stratum == arch_stratum)
3038 error (_("The \"%s\" target does not support \"run\". "
3039 "Try \"help target\" or \"continue\"."),
3043 /* This function is only called if the target is running. In that
3044 case there should have been a process_stratum target and it
3045 should either know how to create inferiors, or not... */
3046 internal_error (__FILE__, __LINE__, _("No targets found"));
3049 /* Look through the list of possible targets for a target that can
3050 execute a run or attach command without any other data. This is
3051 used to locate the default process stratum.
3053 If DO_MESG is not NULL, the result is always valid (error() is
3054 called for errors); else, return NULL on error. */
3056 static struct target_ops *
3057 find_default_run_target (char *do_mesg)
3059 struct target_ops **t;
3060 struct target_ops *runable = NULL;
3065 for (t = target_structs; t < target_structs + target_struct_size;
3068 if ((*t)->to_can_run && target_can_run (*t))
3078 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
3087 find_default_attach (struct target_ops *ops, char *args, int from_tty)
3089 struct target_ops *t;
3091 t = find_default_run_target ("attach");
3092 (t->to_attach) (t, args, from_tty);
3097 find_default_create_inferior (struct target_ops *ops,
3098 char *exec_file, char *allargs, char **env,
3101 struct target_ops *t;
3103 t = find_default_run_target ("run");
3104 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
3109 find_default_can_async_p (struct target_ops *ignore)
3111 struct target_ops *t;
3113 /* This may be called before the target is pushed on the stack;
3114 look for the default process stratum. If there's none, gdb isn't
3115 configured with a native debugger, and target remote isn't
3117 t = find_default_run_target (NULL);
3118 if (t && t->to_can_async_p != delegate_can_async_p)
3119 return (t->to_can_async_p) (t);
3124 find_default_is_async_p (struct target_ops *ignore)
3126 struct target_ops *t;
3128 /* This may be called before the target is pushed on the stack;
3129 look for the default process stratum. If there's none, gdb isn't
3130 configured with a native debugger, and target remote isn't
3132 t = find_default_run_target (NULL);
3133 if (t && t->to_is_async_p != delegate_is_async_p)
3134 return (t->to_is_async_p) (t);
3139 find_default_supports_non_stop (struct target_ops *self)
3141 struct target_ops *t;
3143 t = find_default_run_target (NULL);
3144 if (t && t->to_supports_non_stop)
3145 return (t->to_supports_non_stop) (t);
3150 target_supports_non_stop (void)
3152 struct target_ops *t;
3154 for (t = ¤t_target; t != NULL; t = t->beneath)
3155 if (t->to_supports_non_stop)
3156 return t->to_supports_non_stop (t);
3161 /* Implement the "info proc" command. */
3164 target_info_proc (char *args, enum info_proc_what what)
3166 struct target_ops *t;
3168 /* If we're already connected to something that can get us OS
3169 related data, use it. Otherwise, try using the native
3171 if (current_target.to_stratum >= process_stratum)
3172 t = current_target.beneath;
3174 t = find_default_run_target (NULL);
3176 for (; t != NULL; t = t->beneath)
3178 if (t->to_info_proc != NULL)
3180 t->to_info_proc (t, args, what);
3183 fprintf_unfiltered (gdb_stdlog,
3184 "target_info_proc (\"%s\", %d)\n", args, what);
3194 find_default_supports_disable_randomization (struct target_ops *self)
3196 struct target_ops *t;
3198 t = find_default_run_target (NULL);
3199 if (t && t->to_supports_disable_randomization)
3200 return (t->to_supports_disable_randomization) (t);
3205 target_supports_disable_randomization (void)
3207 struct target_ops *t;
3209 for (t = ¤t_target; t != NULL; t = t->beneath)
3210 if (t->to_supports_disable_randomization)
3211 return t->to_supports_disable_randomization (t);
3217 target_get_osdata (const char *type)
3219 struct target_ops *t;
3221 /* If we're already connected to something that can get us OS
3222 related data, use it. Otherwise, try using the native
3224 if (current_target.to_stratum >= process_stratum)
3225 t = current_target.beneath;
3227 t = find_default_run_target ("get OS data");
3232 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
3235 /* Determine the current address space of thread PTID. */
3237 struct address_space *
3238 target_thread_address_space (ptid_t ptid)
3240 struct address_space *aspace;
3241 struct inferior *inf;
3242 struct target_ops *t;
3244 for (t = current_target.beneath; t != NULL; t = t->beneath)
3246 if (t->to_thread_address_space != NULL)
3248 aspace = t->to_thread_address_space (t, ptid);
3249 gdb_assert (aspace);
3252 fprintf_unfiltered (gdb_stdlog,
3253 "target_thread_address_space (%s) = %d\n",
3254 target_pid_to_str (ptid),
3255 address_space_num (aspace));
3260 /* Fall-back to the "main" address space of the inferior. */
3261 inf = find_inferior_pid (ptid_get_pid (ptid));
3263 if (inf == NULL || inf->aspace == NULL)
3264 internal_error (__FILE__, __LINE__,
3265 _("Can't determine the current "
3266 "address space of thread %s\n"),
3267 target_pid_to_str (ptid));
3273 /* Target file operations. */
3275 static struct target_ops *
3276 default_fileio_target (void)
3278 /* If we're already connected to something that can perform
3279 file I/O, use it. Otherwise, try using the native target. */
3280 if (current_target.to_stratum >= process_stratum)
3281 return current_target.beneath;
3283 return find_default_run_target ("file I/O");
3286 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3287 target file descriptor, or -1 if an error occurs (and set
3290 target_fileio_open (const char *filename, int flags, int mode,
3293 struct target_ops *t;
3295 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3297 if (t->to_fileio_open != NULL)
3299 int fd = t->to_fileio_open (t, filename, flags, mode, target_errno);
3302 fprintf_unfiltered (gdb_stdlog,
3303 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3304 filename, flags, mode,
3305 fd, fd != -1 ? 0 : *target_errno);
3310 *target_errno = FILEIO_ENOSYS;
3314 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3315 Return the number of bytes written, or -1 if an error occurs
3316 (and set *TARGET_ERRNO). */
3318 target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
3319 ULONGEST offset, int *target_errno)
3321 struct target_ops *t;
3323 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3325 if (t->to_fileio_pwrite != NULL)
3327 int ret = t->to_fileio_pwrite (t, fd, write_buf, len, offset,
3331 fprintf_unfiltered (gdb_stdlog,
3332 "target_fileio_pwrite (%d,...,%d,%s) "
3334 fd, len, pulongest (offset),
3335 ret, ret != -1 ? 0 : *target_errno);
3340 *target_errno = FILEIO_ENOSYS;
3344 /* Read up to LEN bytes FD on the target into READ_BUF.
3345 Return the number of bytes read, or -1 if an error occurs
3346 (and set *TARGET_ERRNO). */
3348 target_fileio_pread (int fd, gdb_byte *read_buf, int len,
3349 ULONGEST offset, int *target_errno)
3351 struct target_ops *t;
3353 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3355 if (t->to_fileio_pread != NULL)
3357 int ret = t->to_fileio_pread (t, fd, read_buf, len, offset,
3361 fprintf_unfiltered (gdb_stdlog,
3362 "target_fileio_pread (%d,...,%d,%s) "
3364 fd, len, pulongest (offset),
3365 ret, ret != -1 ? 0 : *target_errno);
3370 *target_errno = FILEIO_ENOSYS;
3374 /* Close FD on the target. Return 0, or -1 if an error occurs
3375 (and set *TARGET_ERRNO). */
3377 target_fileio_close (int fd, int *target_errno)
3379 struct target_ops *t;
3381 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3383 if (t->to_fileio_close != NULL)
3385 int ret = t->to_fileio_close (t, fd, target_errno);
3388 fprintf_unfiltered (gdb_stdlog,
3389 "target_fileio_close (%d) = %d (%d)\n",
3390 fd, ret, ret != -1 ? 0 : *target_errno);
3395 *target_errno = FILEIO_ENOSYS;
3399 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3400 occurs (and set *TARGET_ERRNO). */
3402 target_fileio_unlink (const char *filename, int *target_errno)
3404 struct target_ops *t;
3406 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3408 if (t->to_fileio_unlink != NULL)
3410 int ret = t->to_fileio_unlink (t, filename, target_errno);
3413 fprintf_unfiltered (gdb_stdlog,
3414 "target_fileio_unlink (%s) = %d (%d)\n",
3415 filename, ret, ret != -1 ? 0 : *target_errno);
3420 *target_errno = FILEIO_ENOSYS;
3424 /* Read value of symbolic link FILENAME on the target. Return a
3425 null-terminated string allocated via xmalloc, or NULL if an error
3426 occurs (and set *TARGET_ERRNO). */
3428 target_fileio_readlink (const char *filename, int *target_errno)
3430 struct target_ops *t;
3432 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3434 if (t->to_fileio_readlink != NULL)
3436 char *ret = t->to_fileio_readlink (t, filename, target_errno);
3439 fprintf_unfiltered (gdb_stdlog,
3440 "target_fileio_readlink (%s) = %s (%d)\n",
3441 filename, ret? ret : "(nil)",
3442 ret? 0 : *target_errno);
3447 *target_errno = FILEIO_ENOSYS;
3452 target_fileio_close_cleanup (void *opaque)
3454 int fd = *(int *) opaque;
3457 target_fileio_close (fd, &target_errno);
3460 /* Read target file FILENAME. Store the result in *BUF_P and
3461 return the size of the transferred data. PADDING additional bytes are
3462 available in *BUF_P. This is a helper function for
3463 target_fileio_read_alloc; see the declaration of that function for more
3467 target_fileio_read_alloc_1 (const char *filename,
3468 gdb_byte **buf_p, int padding)
3470 struct cleanup *close_cleanup;
3471 size_t buf_alloc, buf_pos;
3477 fd = target_fileio_open (filename, FILEIO_O_RDONLY, 0700, &target_errno);
3481 close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
3483 /* Start by reading up to 4K at a time. The target will throttle
3484 this number down if necessary. */
3486 buf = xmalloc (buf_alloc);
3490 n = target_fileio_pread (fd, &buf[buf_pos],
3491 buf_alloc - buf_pos - padding, buf_pos,
3495 /* An error occurred. */
3496 do_cleanups (close_cleanup);
3502 /* Read all there was. */
3503 do_cleanups (close_cleanup);
3513 /* If the buffer is filling up, expand it. */
3514 if (buf_alloc < buf_pos * 2)
3517 buf = xrealloc (buf, buf_alloc);
3524 /* Read target file FILENAME. Store the result in *BUF_P and return
3525 the size of the transferred data. See the declaration in "target.h"
3526 function for more information about the return value. */
3529 target_fileio_read_alloc (const char *filename, gdb_byte **buf_p)
3531 return target_fileio_read_alloc_1 (filename, buf_p, 0);
3534 /* Read target file FILENAME. The result is NUL-terminated and
3535 returned as a string, allocated using xmalloc. If an error occurs
3536 or the transfer is unsupported, NULL is returned. Empty objects
3537 are returned as allocated but empty strings. A warning is issued
3538 if the result contains any embedded NUL bytes. */
3541 target_fileio_read_stralloc (const char *filename)
3545 LONGEST i, transferred;
3547 transferred = target_fileio_read_alloc_1 (filename, &buffer, 1);
3548 bufstr = (char *) buffer;
3550 if (transferred < 0)
3553 if (transferred == 0)
3554 return xstrdup ("");
3556 bufstr[transferred] = 0;
3558 /* Check for embedded NUL bytes; but allow trailing NULs. */
3559 for (i = strlen (bufstr); i < transferred; i++)
3562 warning (_("target file %s "
3563 "contained unexpected null characters"),
3573 default_region_ok_for_hw_watchpoint (struct target_ops *self,
3574 CORE_ADDR addr, int len)
3576 return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
3580 default_watchpoint_addr_within_range (struct target_ops *target,
3582 CORE_ADDR start, int length)
3584 return addr >= start && addr < start + length;
3587 static struct gdbarch *
3588 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3590 return target_gdbarch ();
3606 return_minus_one (void)
3618 * Find the next target down the stack from the specified target.
3622 find_target_beneath (struct target_ops *t)
3630 find_target_at (enum strata stratum)
3632 struct target_ops *t;
3634 for (t = current_target.beneath; t != NULL; t = t->beneath)
3635 if (t->to_stratum == stratum)
3642 /* The inferior process has died. Long live the inferior! */
3645 generic_mourn_inferior (void)
3649 ptid = inferior_ptid;
3650 inferior_ptid = null_ptid;
3652 /* Mark breakpoints uninserted in case something tries to delete a
3653 breakpoint while we delete the inferior's threads (which would
3654 fail, since the inferior is long gone). */
3655 mark_breakpoints_out ();
3657 if (!ptid_equal (ptid, null_ptid))
3659 int pid = ptid_get_pid (ptid);
3660 exit_inferior (pid);
3663 /* Note this wipes step-resume breakpoints, so needs to be done
3664 after exit_inferior, which ends up referencing the step-resume
3665 breakpoints through clear_thread_inferior_resources. */
3666 breakpoint_init_inferior (inf_exited);
3668 registers_changed ();
3670 reopen_exec_file ();
3671 reinit_frame_cache ();
3673 if (deprecated_detach_hook)
3674 deprecated_detach_hook ();
3677 /* Convert a normal process ID to a string. Returns the string in a
3681 normal_pid_to_str (ptid_t ptid)
3683 static char buf[32];
3685 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
3690 dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
3692 return normal_pid_to_str (ptid);
3695 /* Error-catcher for target_find_memory_regions. */
3697 dummy_find_memory_regions (struct target_ops *self,
3698 find_memory_region_ftype ignore1, void *ignore2)
3700 error (_("Command not implemented for this target."));
3704 /* Error-catcher for target_make_corefile_notes. */
3706 dummy_make_corefile_notes (struct target_ops *self,
3707 bfd *ignore1, int *ignore2)
3709 error (_("Command not implemented for this target."));
3713 /* Error-catcher for target_get_bookmark. */
3715 dummy_get_bookmark (struct target_ops *self, char *ignore1, int ignore2)
3721 /* Error-catcher for target_goto_bookmark. */
3723 dummy_goto_bookmark (struct target_ops *self, gdb_byte *ignore, int from_tty)
3728 /* Set up the handful of non-empty slots needed by the dummy target
3732 init_dummy_target (void)
3734 dummy_target.to_shortname = "None";
3735 dummy_target.to_longname = "None";
3736 dummy_target.to_doc = "";
3737 dummy_target.to_create_inferior = find_default_create_inferior;
3738 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
3739 dummy_target.to_supports_disable_randomization
3740 = find_default_supports_disable_randomization;
3741 dummy_target.to_pid_to_str = dummy_pid_to_str;
3742 dummy_target.to_stratum = dummy_stratum;
3743 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
3744 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
3745 dummy_target.to_get_bookmark = dummy_get_bookmark;
3746 dummy_target.to_goto_bookmark = dummy_goto_bookmark;
3747 dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
3748 dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero;
3749 dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero;
3750 dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero;
3751 dummy_target.to_has_execution
3752 = (int (*) (struct target_ops *, ptid_t)) return_zero;
3753 dummy_target.to_magic = OPS_MAGIC;
3755 install_dummy_methods (&dummy_target);
3759 debug_to_open (char *args, int from_tty)
3761 debug_target.to_open (args, from_tty);
3763 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
3767 target_close (struct target_ops *targ)
3769 gdb_assert (!target_is_pushed (targ));
3771 if (targ->to_xclose != NULL)
3772 targ->to_xclose (targ);
3773 else if (targ->to_close != NULL)
3774 targ->to_close (targ);
3777 fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
3781 target_attach (char *args, int from_tty)
3783 current_target.to_attach (¤t_target, args, from_tty);
3785 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
3790 target_thread_alive (ptid_t ptid)
3792 struct target_ops *t;
3794 for (t = current_target.beneath; t != NULL; t = t->beneath)
3796 if (t->to_thread_alive != NULL)
3800 retval = t->to_thread_alive (t, ptid);
3802 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3803 ptid_get_pid (ptid), retval);
3813 target_find_new_threads (void)
3815 struct target_ops *t;
3817 for (t = current_target.beneath; t != NULL; t = t->beneath)
3819 if (t->to_find_new_threads != NULL)
3821 t->to_find_new_threads (t);
3823 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
3831 target_stop (ptid_t ptid)
3835 warning (_("May not interrupt or stop the target, ignoring attempt"));
3839 (*current_target.to_stop) (¤t_target, ptid);
3843 debug_to_post_attach (struct target_ops *self, int pid)
3845 debug_target.to_post_attach (&debug_target, pid);
3847 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
3850 /* Concatenate ELEM to LIST, a comma separate list, and return the
3851 result. The LIST incoming argument is released. */
3854 str_comma_list_concat_elem (char *list, const char *elem)
3857 return xstrdup (elem);
3859 return reconcat (list, list, ", ", elem, (char *) NULL);
3862 /* Helper for target_options_to_string. If OPT is present in
3863 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3864 Returns the new resulting string. OPT is removed from
3868 do_option (int *target_options, char *ret,
3869 int opt, char *opt_str)
3871 if ((*target_options & opt) != 0)
3873 ret = str_comma_list_concat_elem (ret, opt_str);
3874 *target_options &= ~opt;
3881 target_options_to_string (int target_options)
3885 #define DO_TARG_OPTION(OPT) \
3886 ret = do_option (&target_options, ret, OPT, #OPT)
3888 DO_TARG_OPTION (TARGET_WNOHANG);
3890 if (target_options != 0)
3891 ret = str_comma_list_concat_elem (ret, "unknown???");
3899 debug_print_register (const char * func,
3900 struct regcache *regcache, int regno)
3902 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3904 fprintf_unfiltered (gdb_stdlog, "%s ", func);
3905 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
3906 && gdbarch_register_name (gdbarch, regno) != NULL
3907 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3908 fprintf_unfiltered (gdb_stdlog, "(%s)",
3909 gdbarch_register_name (gdbarch, regno));
3911 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
3912 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
3914 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3915 int i, size = register_size (gdbarch, regno);
3916 gdb_byte buf[MAX_REGISTER_SIZE];
3918 regcache_raw_collect (regcache, regno, buf);
3919 fprintf_unfiltered (gdb_stdlog, " = ");
3920 for (i = 0; i < size; i++)
3922 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3924 if (size <= sizeof (LONGEST))
3926 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
3928 fprintf_unfiltered (gdb_stdlog, " %s %s",
3929 core_addr_to_string_nz (val), plongest (val));
3932 fprintf_unfiltered (gdb_stdlog, "\n");
3936 target_fetch_registers (struct regcache *regcache, int regno)
3938 struct target_ops *t;
3940 for (t = current_target.beneath; t != NULL; t = t->beneath)
3942 if (t->to_fetch_registers != NULL)
3944 t->to_fetch_registers (t, regcache, regno);
3946 debug_print_register ("target_fetch_registers", regcache, regno);
3953 target_store_registers (struct regcache *regcache, int regno)
3955 struct target_ops *t;
3957 if (!may_write_registers)
3958 error (_("Writing to registers is not allowed (regno %d)"), regno);
3960 current_target.to_store_registers (¤t_target, regcache, regno);
3963 debug_print_register ("target_store_registers", regcache, regno);
3968 target_core_of_thread (ptid_t ptid)
3970 struct target_ops *t;
3972 for (t = current_target.beneath; t != NULL; t = t->beneath)
3974 if (t->to_core_of_thread != NULL)
3976 int retval = t->to_core_of_thread (t, ptid);
3979 fprintf_unfiltered (gdb_stdlog,
3980 "target_core_of_thread (%d) = %d\n",
3981 ptid_get_pid (ptid), retval);
3990 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3992 struct target_ops *t;
3994 for (t = current_target.beneath; t != NULL; t = t->beneath)
3996 if (t->to_verify_memory != NULL)
3998 int retval = t->to_verify_memory (t, data, memaddr, size);
4001 fprintf_unfiltered (gdb_stdlog,
4002 "target_verify_memory (%s, %s) = %d\n",
4003 paddress (target_gdbarch (), memaddr),
4013 /* The documentation for this function is in its prototype declaration in
4017 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
4019 struct target_ops *t;
4021 for (t = current_target.beneath; t != NULL; t = t->beneath)
4022 if (t->to_insert_mask_watchpoint != NULL)
4026 ret = t->to_insert_mask_watchpoint (t, addr, mask, rw);
4029 fprintf_unfiltered (gdb_stdlog, "\
4030 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4031 core_addr_to_string (addr),
4032 core_addr_to_string (mask), rw, ret);
4040 /* The documentation for this function is in its prototype declaration in
4044 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
4046 struct target_ops *t;
4048 for (t = current_target.beneath; t != NULL; t = t->beneath)
4049 if (t->to_remove_mask_watchpoint != NULL)
4053 ret = t->to_remove_mask_watchpoint (t, addr, mask, rw);
4056 fprintf_unfiltered (gdb_stdlog, "\
4057 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4058 core_addr_to_string (addr),
4059 core_addr_to_string (mask), rw, ret);
4067 /* The documentation for this function is in its prototype declaration
4071 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
4073 struct target_ops *t;
4075 for (t = current_target.beneath; t != NULL; t = t->beneath)
4076 if (t->to_masked_watch_num_registers != NULL)
4077 return t->to_masked_watch_num_registers (t, addr, mask);
4082 /* The documentation for this function is in its prototype declaration
4086 target_ranged_break_num_registers (void)
4088 struct target_ops *t;
4090 for (t = current_target.beneath; t != NULL; t = t->beneath)
4091 if (t->to_ranged_break_num_registers != NULL)
4092 return t->to_ranged_break_num_registers (t);
4099 struct btrace_target_info *
4100 target_enable_btrace (ptid_t ptid)
4102 struct target_ops *t;
4104 for (t = current_target.beneath; t != NULL; t = t->beneath)
4105 if (t->to_enable_btrace != NULL)
4106 return t->to_enable_btrace (t, ptid);
4115 target_disable_btrace (struct btrace_target_info *btinfo)
4117 struct target_ops *t;
4119 for (t = current_target.beneath; t != NULL; t = t->beneath)
4120 if (t->to_disable_btrace != NULL)
4122 t->to_disable_btrace (t, btinfo);
4132 target_teardown_btrace (struct btrace_target_info *btinfo)
4134 struct target_ops *t;
4136 for (t = current_target.beneath; t != NULL; t = t->beneath)
4137 if (t->to_teardown_btrace != NULL)
4139 t->to_teardown_btrace (t, btinfo);
4149 target_read_btrace (VEC (btrace_block_s) **btrace,
4150 struct btrace_target_info *btinfo,
4151 enum btrace_read_type type)
4153 struct target_ops *t;
4155 for (t = current_target.beneath; t != NULL; t = t->beneath)
4156 if (t->to_read_btrace != NULL)
4157 return t->to_read_btrace (t, btrace, btinfo, type);
4160 return BTRACE_ERR_NOT_SUPPORTED;
4166 target_stop_recording (void)
4168 struct target_ops *t;
4170 for (t = current_target.beneath; t != NULL; t = t->beneath)
4171 if (t->to_stop_recording != NULL)
4173 t->to_stop_recording (t);
4177 /* This is optional. */
4183 target_info_record (void)
4185 struct target_ops *t;
4187 for (t = current_target.beneath; t != NULL; t = t->beneath)
4188 if (t->to_info_record != NULL)
4190 t->to_info_record (t);
4200 target_save_record (const char *filename)
4202 struct target_ops *t;
4204 for (t = current_target.beneath; t != NULL; t = t->beneath)
4205 if (t->to_save_record != NULL)
4207 t->to_save_record (t, filename);
4217 target_supports_delete_record (void)
4219 struct target_ops *t;
4221 for (t = current_target.beneath; t != NULL; t = t->beneath)
4222 if (t->to_delete_record != NULL)
4231 target_delete_record (void)
4233 struct target_ops *t;
4235 for (t = current_target.beneath; t != NULL; t = t->beneath)
4236 if (t->to_delete_record != NULL)
4238 t->to_delete_record (t);
4248 target_record_is_replaying (void)
4250 struct target_ops *t;
4252 for (t = current_target.beneath; t != NULL; t = t->beneath)
4253 if (t->to_record_is_replaying != NULL)
4254 return t->to_record_is_replaying (t);
4262 target_goto_record_begin (void)
4264 struct target_ops *t;
4266 for (t = current_target.beneath; t != NULL; t = t->beneath)
4267 if (t->to_goto_record_begin != NULL)
4269 t->to_goto_record_begin (t);
4279 target_goto_record_end (void)
4281 struct target_ops *t;
4283 for (t = current_target.beneath; t != NULL; t = t->beneath)
4284 if (t->to_goto_record_end != NULL)
4286 t->to_goto_record_end (t);
4296 target_goto_record (ULONGEST insn)
4298 struct target_ops *t;
4300 for (t = current_target.beneath; t != NULL; t = t->beneath)
4301 if (t->to_goto_record != NULL)
4303 t->to_goto_record (t, insn);
4313 target_insn_history (int size, int flags)
4315 struct target_ops *t;
4317 for (t = current_target.beneath; t != NULL; t = t->beneath)
4318 if (t->to_insn_history != NULL)
4320 t->to_insn_history (t, size, flags);
4330 target_insn_history_from (ULONGEST from, int size, int flags)
4332 struct target_ops *t;
4334 for (t = current_target.beneath; t != NULL; t = t->beneath)
4335 if (t->to_insn_history_from != NULL)
4337 t->to_insn_history_from (t, from, size, flags);
4347 target_insn_history_range (ULONGEST begin, ULONGEST end, int flags)
4349 struct target_ops *t;
4351 for (t = current_target.beneath; t != NULL; t = t->beneath)
4352 if (t->to_insn_history_range != NULL)
4354 t->to_insn_history_range (t, begin, end, flags);
4364 target_call_history (int size, int flags)
4366 struct target_ops *t;
4368 for (t = current_target.beneath; t != NULL; t = t->beneath)
4369 if (t->to_call_history != NULL)
4371 t->to_call_history (t, size, flags);
4381 target_call_history_from (ULONGEST begin, int size, int flags)
4383 struct target_ops *t;
4385 for (t = current_target.beneath; t != NULL; t = t->beneath)
4386 if (t->to_call_history_from != NULL)
4388 t->to_call_history_from (t, begin, size, flags);
4398 target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
4400 struct target_ops *t;
4402 for (t = current_target.beneath; t != NULL; t = t->beneath)
4403 if (t->to_call_history_range != NULL)
4405 t->to_call_history_range (t, begin, end, flags);
4413 debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
4415 debug_target.to_prepare_to_store (&debug_target, regcache);
4417 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
4422 const struct frame_unwind *
4423 target_get_unwinder (void)
4425 struct target_ops *t;
4427 for (t = current_target.beneath; t != NULL; t = t->beneath)
4428 if (t->to_get_unwinder != NULL)
4429 return t->to_get_unwinder;
4436 const struct frame_unwind *
4437 target_get_tailcall_unwinder (void)
4439 struct target_ops *t;
4441 for (t = current_target.beneath; t != NULL; t = t->beneath)
4442 if (t->to_get_tailcall_unwinder != NULL)
4443 return t->to_get_tailcall_unwinder;
4451 forward_target_decr_pc_after_break (struct target_ops *ops,
4452 struct gdbarch *gdbarch)
4454 for (; ops != NULL; ops = ops->beneath)
4455 if (ops->to_decr_pc_after_break != NULL)
4456 return ops->to_decr_pc_after_break (ops, gdbarch);
4458 return gdbarch_decr_pc_after_break (gdbarch);
4464 target_decr_pc_after_break (struct gdbarch *gdbarch)
4466 return forward_target_decr_pc_after_break (current_target.beneath, gdbarch);
4470 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
4471 int write, struct mem_attrib *attrib,
4472 struct target_ops *target)
4476 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
4479 fprintf_unfiltered (gdb_stdlog,
4480 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4481 paddress (target_gdbarch (), memaddr), len,
4482 write ? "write" : "read", retval);
4488 fputs_unfiltered (", bytes =", gdb_stdlog);
4489 for (i = 0; i < retval; i++)
4491 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
4493 if (targetdebug < 2 && i > 0)
4495 fprintf_unfiltered (gdb_stdlog, " ...");
4498 fprintf_unfiltered (gdb_stdlog, "\n");
4501 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
4505 fputc_unfiltered ('\n', gdb_stdlog);
4511 debug_to_files_info (struct target_ops *target)
4513 debug_target.to_files_info (target);
4515 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
4519 debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
4520 struct bp_target_info *bp_tgt)
4524 retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
4526 fprintf_unfiltered (gdb_stdlog,
4527 "target_insert_breakpoint (%s, xxx) = %ld\n",
4528 core_addr_to_string (bp_tgt->placed_address),
4529 (unsigned long) retval);
4534 debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
4535 struct bp_target_info *bp_tgt)
4539 retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
4541 fprintf_unfiltered (gdb_stdlog,
4542 "target_remove_breakpoint (%s, xxx) = %ld\n",
4543 core_addr_to_string (bp_tgt->placed_address),
4544 (unsigned long) retval);
4549 debug_to_can_use_hw_breakpoint (struct target_ops *self,
4550 int type, int cnt, int from_tty)
4554 retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
4555 type, cnt, from_tty);
4557 fprintf_unfiltered (gdb_stdlog,
4558 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4559 (unsigned long) type,
4560 (unsigned long) cnt,
4561 (unsigned long) from_tty,
4562 (unsigned long) retval);
4567 debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
4568 CORE_ADDR addr, int len)
4572 retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
4575 fprintf_unfiltered (gdb_stdlog,
4576 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4577 core_addr_to_string (addr), (unsigned long) len,
4578 core_addr_to_string (retval));
4583 debug_to_can_accel_watchpoint_condition (struct target_ops *self,
4584 CORE_ADDR addr, int len, int rw,
4585 struct expression *cond)
4589 retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
4593 fprintf_unfiltered (gdb_stdlog,
4594 "target_can_accel_watchpoint_condition "
4595 "(%s, %d, %d, %s) = %ld\n",
4596 core_addr_to_string (addr), len, rw,
4597 host_address_to_string (cond), (unsigned long) retval);
4602 debug_to_stopped_by_watchpoint (struct target_ops *ops)
4606 retval = debug_target.to_stopped_by_watchpoint (&debug_target);
4608 fprintf_unfiltered (gdb_stdlog,
4609 "target_stopped_by_watchpoint () = %ld\n",
4610 (unsigned long) retval);
4615 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
4619 retval = debug_target.to_stopped_data_address (target, addr);
4621 fprintf_unfiltered (gdb_stdlog,
4622 "target_stopped_data_address ([%s]) = %ld\n",
4623 core_addr_to_string (*addr),
4624 (unsigned long)retval);
4629 debug_to_watchpoint_addr_within_range (struct target_ops *target,
4631 CORE_ADDR start, int length)
4635 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
4638 fprintf_filtered (gdb_stdlog,
4639 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4640 core_addr_to_string (addr), core_addr_to_string (start),
4646 debug_to_insert_hw_breakpoint (struct target_ops *self,
4647 struct gdbarch *gdbarch,
4648 struct bp_target_info *bp_tgt)
4652 retval = debug_target.to_insert_hw_breakpoint (&debug_target,
4655 fprintf_unfiltered (gdb_stdlog,
4656 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4657 core_addr_to_string (bp_tgt->placed_address),
4658 (unsigned long) retval);
4663 debug_to_remove_hw_breakpoint (struct target_ops *self,
4664 struct gdbarch *gdbarch,
4665 struct bp_target_info *bp_tgt)
4669 retval = debug_target.to_remove_hw_breakpoint (&debug_target,
4672 fprintf_unfiltered (gdb_stdlog,
4673 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4674 core_addr_to_string (bp_tgt->placed_address),
4675 (unsigned long) retval);
4680 debug_to_insert_watchpoint (struct target_ops *self,
4681 CORE_ADDR addr, int len, int type,
4682 struct expression *cond)
4686 retval = debug_target.to_insert_watchpoint (&debug_target,
4687 addr, len, type, cond);
4689 fprintf_unfiltered (gdb_stdlog,
4690 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4691 core_addr_to_string (addr), len, type,
4692 host_address_to_string (cond), (unsigned long) retval);
4697 debug_to_remove_watchpoint (struct target_ops *self,
4698 CORE_ADDR addr, int len, int type,
4699 struct expression *cond)
4703 retval = debug_target.to_remove_watchpoint (&debug_target,
4704 addr, len, type, cond);
4706 fprintf_unfiltered (gdb_stdlog,
4707 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4708 core_addr_to_string (addr), len, type,
4709 host_address_to_string (cond), (unsigned long) retval);
4714 debug_to_terminal_init (struct target_ops *self)
4716 debug_target.to_terminal_init (&debug_target);
4718 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
4722 debug_to_terminal_inferior (struct target_ops *self)
4724 debug_target.to_terminal_inferior (&debug_target);
4726 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
4730 debug_to_terminal_ours_for_output (struct target_ops *self)
4732 debug_target.to_terminal_ours_for_output (&debug_target);
4734 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
4738 debug_to_terminal_ours (struct target_ops *self)
4740 debug_target.to_terminal_ours (&debug_target);
4742 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
4746 debug_to_terminal_save_ours (struct target_ops *self)
4748 debug_target.to_terminal_save_ours (&debug_target);
4750 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
4754 debug_to_terminal_info (struct target_ops *self,
4755 const char *arg, int from_tty)
4757 debug_target.to_terminal_info (&debug_target, arg, from_tty);
4759 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
4764 debug_to_load (struct target_ops *self, char *args, int from_tty)
4766 debug_target.to_load (&debug_target, args, from_tty);
4768 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
4772 debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
4774 debug_target.to_post_startup_inferior (&debug_target, ptid);
4776 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
4777 ptid_get_pid (ptid));
4781 debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
4785 retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
4787 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
4794 debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
4798 retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
4800 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
4807 debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
4811 retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
4813 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
4820 debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
4824 retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
4826 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
4833 debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
4837 retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
4839 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
4846 debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
4850 retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
4852 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
4859 debug_to_has_exited (struct target_ops *self,
4860 int pid, int wait_status, int *exit_status)
4864 has_exited = debug_target.to_has_exited (&debug_target,
4865 pid, wait_status, exit_status);
4867 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
4868 pid, wait_status, *exit_status, has_exited);
4874 debug_to_can_run (struct target_ops *self)
4878 retval = debug_target.to_can_run (&debug_target);
4880 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
4885 static struct gdbarch *
4886 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
4888 struct gdbarch *retval;
4890 retval = debug_target.to_thread_architecture (ops, ptid);
4892 fprintf_unfiltered (gdb_stdlog,
4893 "target_thread_architecture (%s) = %s [%s]\n",
4894 target_pid_to_str (ptid),
4895 host_address_to_string (retval),
4896 gdbarch_bfd_arch_info (retval)->printable_name);
4901 debug_to_stop (struct target_ops *self, ptid_t ptid)
4903 debug_target.to_stop (&debug_target, ptid);
4905 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
4906 target_pid_to_str (ptid));
4910 debug_to_rcmd (struct target_ops *self, char *command,
4911 struct ui_file *outbuf)
4913 debug_target.to_rcmd (&debug_target, command, outbuf);
4914 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
4918 debug_to_pid_to_exec_file (struct target_ops *self, int pid)
4922 exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
4924 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
4931 setup_target_debug (void)
4933 memcpy (&debug_target, ¤t_target, sizeof debug_target);
4935 current_target.to_open = debug_to_open;
4936 current_target.to_post_attach = debug_to_post_attach;
4937 current_target.to_prepare_to_store = debug_to_prepare_to_store;
4938 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
4939 current_target.to_files_info = debug_to_files_info;
4940 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
4941 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
4942 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
4943 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
4944 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
4945 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
4946 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
4947 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
4948 current_target.to_stopped_data_address = debug_to_stopped_data_address;
4949 current_target.to_watchpoint_addr_within_range
4950 = debug_to_watchpoint_addr_within_range;
4951 current_target.to_region_ok_for_hw_watchpoint
4952 = debug_to_region_ok_for_hw_watchpoint;
4953 current_target.to_can_accel_watchpoint_condition
4954 = debug_to_can_accel_watchpoint_condition;
4955 current_target.to_terminal_init = debug_to_terminal_init;
4956 current_target.to_terminal_inferior = debug_to_terminal_inferior;
4957 current_target.to_terminal_ours_for_output
4958 = debug_to_terminal_ours_for_output;
4959 current_target.to_terminal_ours = debug_to_terminal_ours;
4960 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
4961 current_target.to_terminal_info = debug_to_terminal_info;
4962 current_target.to_load = debug_to_load;
4963 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
4964 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
4965 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
4966 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
4967 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
4968 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
4969 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
4970 current_target.to_has_exited = debug_to_has_exited;
4971 current_target.to_can_run = debug_to_can_run;
4972 current_target.to_stop = debug_to_stop;
4973 current_target.to_rcmd = debug_to_rcmd;
4974 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
4975 current_target.to_thread_architecture = debug_to_thread_architecture;
4979 static char targ_desc[] =
4980 "Names of targets and files being debugged.\nShows the entire \
4981 stack of targets currently in use (including the exec-file,\n\
4982 core-file, and process, if any), as well as the symbol file name.";
4985 default_rcmd (struct target_ops *self, char *command, struct ui_file *output)
4987 error (_("\"monitor\" command not supported by this target."));
4991 do_monitor_command (char *cmd,
4994 target_rcmd (cmd, gdb_stdtarg);
4997 /* Print the name of each layers of our target stack. */
5000 maintenance_print_target_stack (char *cmd, int from_tty)
5002 struct target_ops *t;
5004 printf_filtered (_("The current target stack is:\n"));
5006 for (t = target_stack; t != NULL; t = t->beneath)
5008 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
5012 /* Controls if async mode is permitted. */
5013 int target_async_permitted = 0;
5015 /* The set command writes to this variable. If the inferior is
5016 executing, target_async_permitted is *not* updated. */
5017 static int target_async_permitted_1 = 0;
5020 set_target_async_command (char *args, int from_tty,
5021 struct cmd_list_element *c)
5023 if (have_live_inferiors ())
5025 target_async_permitted_1 = target_async_permitted;
5026 error (_("Cannot change this setting while the inferior is running."));
5029 target_async_permitted = target_async_permitted_1;
5033 show_target_async_command (struct ui_file *file, int from_tty,
5034 struct cmd_list_element *c,
5037 fprintf_filtered (file,
5038 _("Controlling the inferior in "
5039 "asynchronous mode is %s.\n"), value);
5042 /* Temporary copies of permission settings. */
5044 static int may_write_registers_1 = 1;
5045 static int may_write_memory_1 = 1;
5046 static int may_insert_breakpoints_1 = 1;
5047 static int may_insert_tracepoints_1 = 1;
5048 static int may_insert_fast_tracepoints_1 = 1;
5049 static int may_stop_1 = 1;
5051 /* Make the user-set values match the real values again. */
5054 update_target_permissions (void)
5056 may_write_registers_1 = may_write_registers;
5057 may_write_memory_1 = may_write_memory;
5058 may_insert_breakpoints_1 = may_insert_breakpoints;
5059 may_insert_tracepoints_1 = may_insert_tracepoints;
5060 may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
5061 may_stop_1 = may_stop;
5064 /* The one function handles (most of) the permission flags in the same
5068 set_target_permissions (char *args, int from_tty,
5069 struct cmd_list_element *c)
5071 if (target_has_execution)
5073 update_target_permissions ();
5074 error (_("Cannot change this setting while the inferior is running."));
5077 /* Make the real values match the user-changed values. */
5078 may_write_registers = may_write_registers_1;
5079 may_insert_breakpoints = may_insert_breakpoints_1;
5080 may_insert_tracepoints = may_insert_tracepoints_1;
5081 may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
5082 may_stop = may_stop_1;
5083 update_observer_mode ();
5086 /* Set memory write permission independently of observer mode. */
5089 set_write_memory_permission (char *args, int from_tty,
5090 struct cmd_list_element *c)
5092 /* Make the real values match the user-changed values. */
5093 may_write_memory = may_write_memory_1;
5094 update_observer_mode ();
5099 initialize_targets (void)
5101 init_dummy_target ();
5102 push_target (&dummy_target);
5104 add_info ("target", target_info, targ_desc);
5105 add_info ("files", target_info, targ_desc);
5107 add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
5108 Set target debugging."), _("\
5109 Show target debugging."), _("\
5110 When non-zero, target debugging is enabled. Higher numbers are more\n\
5111 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5115 &setdebuglist, &showdebuglist);
5117 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
5118 &trust_readonly, _("\
5119 Set mode for reading from readonly sections."), _("\
5120 Show mode for reading from readonly sections."), _("\
5121 When this mode is on, memory reads from readonly sections (such as .text)\n\
5122 will be read from the object file instead of from the target. This will\n\
5123 result in significant performance improvement for remote targets."),
5125 show_trust_readonly,
5126 &setlist, &showlist);
5128 add_com ("monitor", class_obscure, do_monitor_command,
5129 _("Send a command to the remote monitor (remote targets only)."));
5131 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
5132 _("Print the name of each layer of the internal target stack."),
5133 &maintenanceprintlist);
5135 add_setshow_boolean_cmd ("target-async", no_class,
5136 &target_async_permitted_1, _("\
5137 Set whether gdb controls the inferior in asynchronous mode."), _("\
5138 Show whether gdb controls the inferior in asynchronous mode."), _("\
5139 Tells gdb whether to control the inferior in asynchronous mode."),
5140 set_target_async_command,
5141 show_target_async_command,
5145 add_setshow_boolean_cmd ("may-write-registers", class_support,
5146 &may_write_registers_1, _("\
5147 Set permission to write into registers."), _("\
5148 Show permission to write into registers."), _("\
5149 When this permission is on, GDB may write into the target's registers.\n\
5150 Otherwise, any sort of write attempt will result in an error."),
5151 set_target_permissions, NULL,
5152 &setlist, &showlist);
5154 add_setshow_boolean_cmd ("may-write-memory", class_support,
5155 &may_write_memory_1, _("\
5156 Set permission to write into target memory."), _("\
5157 Show permission to write into target memory."), _("\
5158 When this permission is on, GDB may write into the target's memory.\n\
5159 Otherwise, any sort of write attempt will result in an error."),
5160 set_write_memory_permission, NULL,
5161 &setlist, &showlist);
5163 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
5164 &may_insert_breakpoints_1, _("\
5165 Set permission to insert breakpoints in the target."), _("\
5166 Show permission to insert breakpoints in the target."), _("\
5167 When this permission is on, GDB may insert breakpoints in the program.\n\
5168 Otherwise, any sort of insertion attempt will result in an error."),
5169 set_target_permissions, NULL,
5170 &setlist, &showlist);
5172 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
5173 &may_insert_tracepoints_1, _("\
5174 Set permission to insert tracepoints in the target."), _("\
5175 Show permission to insert tracepoints in the target."), _("\
5176 When this permission is on, GDB may insert tracepoints in the program.\n\
5177 Otherwise, any sort of insertion attempt will result in an error."),
5178 set_target_permissions, NULL,
5179 &setlist, &showlist);
5181 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
5182 &may_insert_fast_tracepoints_1, _("\
5183 Set permission to insert fast tracepoints in the target."), _("\
5184 Show permission to insert fast tracepoints in the target."), _("\
5185 When this permission is on, GDB may insert fast tracepoints.\n\
5186 Otherwise, any sort of insertion attempt will result in an error."),
5187 set_target_permissions, NULL,
5188 &setlist, &showlist);
5190 add_setshow_boolean_cmd ("may-interrupt", class_support,
5192 Set permission to interrupt or signal the target."), _("\
5193 Show permission to interrupt or signal the target."), _("\
5194 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5195 Otherwise, any attempt to interrupt or stop will be ignored."),
5196 set_target_permissions, NULL,
5197 &setlist, &showlist);