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 ptid_t default_get_ada_task_ptid (struct target_ops *self,
63 static int default_follow_fork (struct target_ops *self, int follow_child,
66 static void default_mourn_inferior (struct target_ops *self);
68 static void tcomplain (void) ATTRIBUTE_NORETURN;
70 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
72 static int return_zero (void);
74 void target_ignore (void);
76 static void target_command (char *, int);
78 static struct target_ops *find_default_run_target (char *);
80 static target_xfer_partial_ftype default_xfer_partial;
82 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
85 static int dummy_find_memory_regions (struct target_ops *self,
86 find_memory_region_ftype ignore1,
89 static char *dummy_make_corefile_notes (struct target_ops *self,
90 bfd *ignore1, int *ignore2);
92 static char *default_pid_to_str (struct target_ops *ops, ptid_t ptid);
94 static int find_default_can_async_p (struct target_ops *ignore);
96 static int find_default_is_async_p (struct target_ops *ignore);
98 static enum exec_direction_kind default_execution_direction
99 (struct target_ops *self);
101 #include "target-delegates.c"
103 static void init_dummy_target (void);
105 static struct target_ops debug_target;
107 static void debug_to_open (char *, int);
109 static void debug_to_prepare_to_store (struct target_ops *self,
112 static void debug_to_files_info (struct target_ops *);
114 static int debug_to_insert_breakpoint (struct target_ops *, struct gdbarch *,
115 struct bp_target_info *);
117 static int debug_to_remove_breakpoint (struct target_ops *, struct gdbarch *,
118 struct bp_target_info *);
120 static int debug_to_can_use_hw_breakpoint (struct target_ops *self,
123 static int debug_to_insert_hw_breakpoint (struct target_ops *self,
125 struct bp_target_info *);
127 static int debug_to_remove_hw_breakpoint (struct target_ops *self,
129 struct bp_target_info *);
131 static int debug_to_insert_watchpoint (struct target_ops *self,
133 struct expression *);
135 static int debug_to_remove_watchpoint (struct target_ops *self,
137 struct expression *);
139 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
141 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
142 CORE_ADDR, CORE_ADDR, int);
144 static int debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
147 static int debug_to_can_accel_watchpoint_condition (struct target_ops *self,
149 struct expression *);
151 static void debug_to_terminal_init (struct target_ops *self);
153 static void debug_to_terminal_inferior (struct target_ops *self);
155 static void debug_to_terminal_ours_for_output (struct target_ops *self);
157 static void debug_to_terminal_save_ours (struct target_ops *self);
159 static void debug_to_terminal_ours (struct target_ops *self);
161 static void debug_to_load (struct target_ops *self, char *, int);
163 static int debug_to_can_run (struct target_ops *self);
165 static void debug_to_stop (struct target_ops *self, ptid_t);
167 /* Pointer to array of target architecture structures; the size of the
168 array; the current index into the array; the allocated size of the
170 struct target_ops **target_structs;
171 unsigned target_struct_size;
172 unsigned target_struct_allocsize;
173 #define DEFAULT_ALLOCSIZE 10
175 /* The initial current target, so that there is always a semi-valid
178 static struct target_ops dummy_target;
180 /* Top of target stack. */
182 static struct target_ops *target_stack;
184 /* The target structure we are currently using to talk to a process
185 or file or whatever "inferior" we have. */
187 struct target_ops current_target;
189 /* Command list for target. */
191 static struct cmd_list_element *targetlist = NULL;
193 /* Nonzero if we should trust readonly sections from the
194 executable when reading memory. */
196 static int trust_readonly = 0;
198 /* Nonzero if we should show true memory content including
199 memory breakpoint inserted by gdb. */
201 static int show_memory_breakpoints = 0;
203 /* These globals control whether GDB attempts to perform these
204 operations; they are useful for targets that need to prevent
205 inadvertant disruption, such as in non-stop mode. */
207 int may_write_registers = 1;
209 int may_write_memory = 1;
211 int may_insert_breakpoints = 1;
213 int may_insert_tracepoints = 1;
215 int may_insert_fast_tracepoints = 1;
219 /* Non-zero if we want to see trace of target level stuff. */
221 static unsigned int targetdebug = 0;
223 show_targetdebug (struct ui_file *file, int from_tty,
224 struct cmd_list_element *c, const char *value)
226 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
229 static void setup_target_debug (void);
231 /* The user just typed 'target' without the name of a target. */
234 target_command (char *arg, int from_tty)
236 fputs_filtered ("Argument required (target name). Try `help target'\n",
240 /* Default target_has_* methods for process_stratum targets. */
243 default_child_has_all_memory (struct target_ops *ops)
245 /* If no inferior selected, then we can't read memory here. */
246 if (ptid_equal (inferior_ptid, null_ptid))
253 default_child_has_memory (struct target_ops *ops)
255 /* If no inferior selected, then we can't read memory here. */
256 if (ptid_equal (inferior_ptid, null_ptid))
263 default_child_has_stack (struct target_ops *ops)
265 /* If no inferior selected, there's no stack. */
266 if (ptid_equal (inferior_ptid, null_ptid))
273 default_child_has_registers (struct target_ops *ops)
275 /* Can't read registers from no inferior. */
276 if (ptid_equal (inferior_ptid, null_ptid))
283 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
285 /* If there's no thread selected, then we can't make it run through
287 if (ptid_equal (the_ptid, null_ptid))
295 target_has_all_memory_1 (void)
297 struct target_ops *t;
299 for (t = current_target.beneath; t != NULL; t = t->beneath)
300 if (t->to_has_all_memory (t))
307 target_has_memory_1 (void)
309 struct target_ops *t;
311 for (t = current_target.beneath; t != NULL; t = t->beneath)
312 if (t->to_has_memory (t))
319 target_has_stack_1 (void)
321 struct target_ops *t;
323 for (t = current_target.beneath; t != NULL; t = t->beneath)
324 if (t->to_has_stack (t))
331 target_has_registers_1 (void)
333 struct target_ops *t;
335 for (t = current_target.beneath; t != NULL; t = t->beneath)
336 if (t->to_has_registers (t))
343 target_has_execution_1 (ptid_t the_ptid)
345 struct target_ops *t;
347 for (t = current_target.beneath; t != NULL; t = t->beneath)
348 if (t->to_has_execution (t, the_ptid))
355 target_has_execution_current (void)
357 return target_has_execution_1 (inferior_ptid);
360 /* Complete initialization of T. This ensures that various fields in
361 T are set, if needed by the target implementation. */
364 complete_target_initialization (struct target_ops *t)
366 /* Provide default values for all "must have" methods. */
367 if (t->to_xfer_partial == NULL)
368 t->to_xfer_partial = default_xfer_partial;
370 if (t->to_has_all_memory == NULL)
371 t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
373 if (t->to_has_memory == NULL)
374 t->to_has_memory = (int (*) (struct target_ops *)) return_zero;
376 if (t->to_has_stack == NULL)
377 t->to_has_stack = (int (*) (struct target_ops *)) return_zero;
379 if (t->to_has_registers == NULL)
380 t->to_has_registers = (int (*) (struct target_ops *)) return_zero;
382 if (t->to_has_execution == NULL)
383 t->to_has_execution = (int (*) (struct target_ops *, ptid_t)) return_zero;
385 install_delegators (t);
388 /* Add possible target architecture T to the list and add a new
389 command 'target T->to_shortname'. Set COMPLETER as the command's
390 completer if not NULL. */
393 add_target_with_completer (struct target_ops *t,
394 completer_ftype *completer)
396 struct cmd_list_element *c;
398 complete_target_initialization (t);
402 target_struct_allocsize = DEFAULT_ALLOCSIZE;
403 target_structs = (struct target_ops **) xmalloc
404 (target_struct_allocsize * sizeof (*target_structs));
406 if (target_struct_size >= target_struct_allocsize)
408 target_struct_allocsize *= 2;
409 target_structs = (struct target_ops **)
410 xrealloc ((char *) target_structs,
411 target_struct_allocsize * sizeof (*target_structs));
413 target_structs[target_struct_size++] = t;
415 if (targetlist == NULL)
416 add_prefix_cmd ("target", class_run, target_command, _("\
417 Connect to a target machine or process.\n\
418 The first argument is the type or protocol of the target machine.\n\
419 Remaining arguments are interpreted by the target protocol. For more\n\
420 information on the arguments for a particular protocol, type\n\
421 `help target ' followed by the protocol name."),
422 &targetlist, "target ", 0, &cmdlist);
423 c = add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc,
425 if (completer != NULL)
426 set_cmd_completer (c, completer);
429 /* Add a possible target architecture to the list. */
432 add_target (struct target_ops *t)
434 add_target_with_completer (t, NULL);
440 add_deprecated_target_alias (struct target_ops *t, char *alias)
442 struct cmd_list_element *c;
445 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
447 c = add_cmd (alias, no_class, t->to_open, t->to_doc, &targetlist);
448 alt = xstrprintf ("target %s", t->to_shortname);
449 deprecate_cmd (c, alt);
463 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
465 current_target.to_kill (¤t_target);
469 target_load (char *arg, int from_tty)
471 target_dcache_invalidate ();
472 (*current_target.to_load) (¤t_target, arg, from_tty);
476 target_create_inferior (char *exec_file, char *args,
477 char **env, int from_tty)
479 struct target_ops *t;
481 for (t = current_target.beneath; t != NULL; t = t->beneath)
483 if (t->to_create_inferior != NULL)
485 t->to_create_inferior (t, exec_file, args, env, from_tty);
487 fprintf_unfiltered (gdb_stdlog,
488 "target_create_inferior (%s, %s, xxx, %d)\n",
489 exec_file, args, from_tty);
494 internal_error (__FILE__, __LINE__,
495 _("could not find a target to create inferior"));
499 target_terminal_inferior (void)
501 /* A background resume (``run&'') should leave GDB in control of the
502 terminal. Use target_can_async_p, not target_is_async_p, since at
503 this point the target is not async yet. However, if sync_execution
504 is not set, we know it will become async prior to resume. */
505 if (target_can_async_p () && !sync_execution)
508 /* If GDB is resuming the inferior in the foreground, install
509 inferior's terminal modes. */
510 (*current_target.to_terminal_inferior) (¤t_target);
514 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
515 struct target_ops *t)
517 errno = EIO; /* Can't read/write this location. */
518 return 0; /* No bytes handled. */
524 error (_("You can't do that when your target is `%s'"),
525 current_target.to_shortname);
531 error (_("You can't do that without a process to debug."));
535 default_terminal_info (struct target_ops *self, const char *args, int from_tty)
537 printf_unfiltered (_("No saved terminal information.\n"));
540 /* A default implementation for the to_get_ada_task_ptid target method.
542 This function builds the PTID by using both LWP and TID as part of
543 the PTID lwp and tid elements. The pid used is the pid of the
547 default_get_ada_task_ptid (struct target_ops *self, long lwp, long tid)
549 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
552 static enum exec_direction_kind
553 default_execution_direction (struct target_ops *self)
555 if (!target_can_execute_reverse)
557 else if (!target_can_async_p ())
560 gdb_assert_not_reached ("\
561 to_execution_direction must be implemented for reverse async");
564 /* Go through the target stack from top to bottom, copying over zero
565 entries in current_target, then filling in still empty entries. In
566 effect, we are doing class inheritance through the pushed target
569 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
570 is currently implemented, is that it discards any knowledge of
571 which target an inherited method originally belonged to.
572 Consequently, new new target methods should instead explicitly and
573 locally search the target stack for the target that can handle the
577 update_current_target (void)
579 struct target_ops *t;
581 /* First, reset current's contents. */
582 memset (¤t_target, 0, sizeof (current_target));
584 /* Install the delegators. */
585 install_delegators (¤t_target);
587 #define INHERIT(FIELD, TARGET) \
588 if (!current_target.FIELD) \
589 current_target.FIELD = (TARGET)->FIELD
591 for (t = target_stack; t; t = t->beneath)
593 INHERIT (to_shortname, t);
594 INHERIT (to_longname, t);
596 /* Do not inherit to_open. */
597 /* Do not inherit to_close. */
598 /* Do not inherit to_attach. */
599 /* Do not inherit to_post_attach. */
600 INHERIT (to_attach_no_wait, t);
601 /* Do not inherit to_detach. */
602 /* Do not inherit to_disconnect. */
603 /* Do not inherit to_resume. */
604 /* Do not inherit to_wait. */
605 /* Do not inherit to_fetch_registers. */
606 /* Do not inherit to_store_registers. */
607 /* Do not inherit to_prepare_to_store. */
608 INHERIT (deprecated_xfer_memory, t);
609 /* Do not inherit to_files_info. */
610 /* Do not inherit to_insert_breakpoint. */
611 /* Do not inherit to_remove_breakpoint. */
612 /* Do not inherit to_can_use_hw_breakpoint. */
613 /* Do not inherit to_insert_hw_breakpoint. */
614 /* Do not inherit to_remove_hw_breakpoint. */
615 /* Do not inherit to_ranged_break_num_registers. */
616 /* Do not inherit to_insert_watchpoint. */
617 /* Do not inherit to_remove_watchpoint. */
618 /* Do not inherit to_insert_mask_watchpoint. */
619 /* Do not inherit to_remove_mask_watchpoint. */
620 /* Do not inherit to_stopped_data_address. */
621 INHERIT (to_have_steppable_watchpoint, t);
622 INHERIT (to_have_continuable_watchpoint, t);
623 /* Do not inherit to_stopped_by_watchpoint. */
624 /* Do not inherit to_watchpoint_addr_within_range. */
625 /* Do not inherit to_region_ok_for_hw_watchpoint. */
626 /* Do not inherit to_can_accel_watchpoint_condition. */
627 /* Do not inherit to_masked_watch_num_registers. */
628 /* Do not inherit to_terminal_init. */
629 /* Do not inherit to_terminal_inferior. */
630 /* Do not inherit to_terminal_ours_for_output. */
631 /* Do not inherit to_terminal_ours. */
632 /* Do not inherit to_terminal_save_ours. */
633 /* Do not inherit to_terminal_info. */
634 /* Do not inherit to_kill. */
635 /* Do not inherit to_load. */
636 /* Do no inherit to_create_inferior. */
637 /* Do not inherit to_post_startup_inferior. */
638 /* Do not inherit to_insert_fork_catchpoint. */
639 /* Do not inherit to_remove_fork_catchpoint. */
640 /* Do not inherit to_insert_vfork_catchpoint. */
641 /* Do not inherit to_remove_vfork_catchpoint. */
642 /* Do not inherit to_follow_fork. */
643 /* Do not inherit to_insert_exec_catchpoint. */
644 /* Do not inherit to_remove_exec_catchpoint. */
645 /* Do not inherit to_set_syscall_catchpoint. */
646 /* Do not inherit to_has_exited. */
647 /* Do not inherit to_mourn_inferior. */
648 INHERIT (to_can_run, t);
649 /* Do not inherit to_pass_signals. */
650 /* Do not inherit to_program_signals. */
651 /* Do not inherit to_thread_alive. */
652 /* Do not inherit to_find_new_threads. */
653 /* Do not inherit to_pid_to_str. */
654 /* Do not inherit to_extra_thread_info. */
655 /* Do not inherit to_thread_name. */
656 /* Do not inherit to_stop. */
657 /* Do not inherit to_xfer_partial. */
658 /* Do not inherit to_rcmd. */
659 /* Do not inherit to_pid_to_exec_file. */
660 /* Do not inherit to_log_command. */
661 INHERIT (to_stratum, t);
662 /* Do not inherit to_has_all_memory. */
663 /* Do not inherit to_has_memory. */
664 /* Do not inherit to_has_stack. */
665 /* Do not inherit to_has_registers. */
666 /* Do not inherit to_has_execution. */
667 INHERIT (to_has_thread_control, t);
668 /* Do not inherit to_can_async_p. */
669 /* Do not inherit to_is_async_p. */
670 /* Do not inherit to_async. */
671 /* Do not inherit to_find_memory_regions. */
672 /* Do not inherit to_make_corefile_notes. */
673 /* Do not inherit to_get_bookmark. */
674 /* Do not inherit to_goto_bookmark. */
675 /* Do not inherit to_get_thread_local_address. */
676 /* Do not inherit to_can_execute_reverse. */
677 /* Do not inherit to_execution_direction. */
678 /* Do not inherit to_thread_architecture. */
679 /* Do not inherit to_read_description. */
680 /* Do not inherit to_get_ada_task_ptid. */
681 /* Do not inherit to_search_memory. */
682 /* Do not inherit to_supports_multi_process. */
683 /* Do not inherit to_supports_enable_disable_tracepoint. */
684 /* Do not inherit to_supports_string_tracing. */
685 /* Do not inherit to_trace_init. */
686 /* Do not inherit to_download_tracepoint. */
687 /* Do not inherit to_can_download_tracepoint. */
688 /* Do not inherit to_download_trace_state_variable. */
689 /* Do not inherit to_enable_tracepoint. */
690 /* Do not inherit to_disable_tracepoint. */
691 /* Do not inherit to_trace_set_readonly_regions. */
692 /* Do not inherit to_trace_start. */
693 /* Do not inherit to_get_trace_status. */
694 /* Do not inherit to_get_tracepoint_status. */
695 /* Do not inherit to_trace_stop. */
696 /* Do not inherit to_trace_find. */
697 /* Do not inherit to_get_trace_state_variable_value. */
698 /* Do not inherit to_save_trace_data. */
699 /* Do not inherit to_upload_tracepoints. */
700 /* Do not inherit to_upload_trace_state_variables. */
701 /* Do not inherit to_get_raw_trace_data. */
702 /* Do not inherit to_get_min_fast_tracepoint_insn_len. */
703 /* Do not inherit to_set_disconnected_tracing. */
704 /* Do not inherit to_set_circular_trace_buffer. */
705 /* Do not inherit to_set_trace_buffer_size. */
706 /* Do not inherit to_set_trace_notes. */
707 /* Do not inherit to_get_tib_address. */
708 /* Do not inherit to_set_permissions. */
709 /* Do not inherit to_static_tracepoint_marker_at. */
710 /* Do not inherit to_static_tracepoint_markers_by_strid. */
711 /* Do not inherit to_traceframe_info. */
712 /* Do not inherit to_use_agent. */
713 /* Do not inherit to_can_use_agent. */
714 /* Do not inherit to_augmented_libraries_svr4_read. */
715 INHERIT (to_magic, t);
717 to_supports_evaluation_of_breakpoint_conditions. */
718 /* Do not inherit to_can_run_breakpoint_commands. */
719 /* Do not inherit to_memory_map. */
720 /* Do not inherit to_flash_erase. */
721 /* Do not inherit to_flash_done. */
725 /* Clean up a target struct so it no longer has any zero pointers in
726 it. Some entries are defaulted to a method that print an error,
727 others are hard-wired to a standard recursive default. */
729 #define de_fault(field, value) \
730 if (!current_target.field) \
731 current_target.field = value
734 (void (*) (char *, int))
737 (void (*) (struct target_ops *))
739 de_fault (deprecated_xfer_memory,
740 (int (*) (CORE_ADDR, gdb_byte *, int, int,
741 struct mem_attrib *, struct target_ops *))
743 de_fault (to_can_run,
744 (int (*) (struct target_ops *))
746 current_target.to_read_description = NULL;
750 /* Finally, position the target-stack beneath the squashed
751 "current_target". That way code looking for a non-inherited
752 target method can quickly and simply find it. */
753 current_target.beneath = target_stack;
756 setup_target_debug ();
759 /* Push a new target type into the stack of the existing target accessors,
760 possibly superseding some of the existing accessors.
762 Rather than allow an empty stack, we always have the dummy target at
763 the bottom stratum, so we can call the function vectors without
767 push_target (struct target_ops *t)
769 struct target_ops **cur;
771 /* Check magic number. If wrong, it probably means someone changed
772 the struct definition, but not all the places that initialize one. */
773 if (t->to_magic != OPS_MAGIC)
775 fprintf_unfiltered (gdb_stderr,
776 "Magic number of %s target struct wrong\n",
778 internal_error (__FILE__, __LINE__,
779 _("failed internal consistency check"));
782 /* Find the proper stratum to install this target in. */
783 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
785 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
789 /* If there's already targets at this stratum, remove them. */
790 /* FIXME: cagney/2003-10-15: I think this should be popping all
791 targets to CUR, and not just those at this stratum level. */
792 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
794 /* There's already something at this stratum level. Close it,
795 and un-hook it from the stack. */
796 struct target_ops *tmp = (*cur);
798 (*cur) = (*cur)->beneath;
803 /* We have removed all targets in our stratum, now add the new one. */
807 update_current_target ();
810 /* Remove a target_ops vector from the stack, wherever it may be.
811 Return how many times it was removed (0 or 1). */
814 unpush_target (struct target_ops *t)
816 struct target_ops **cur;
817 struct target_ops *tmp;
819 if (t->to_stratum == dummy_stratum)
820 internal_error (__FILE__, __LINE__,
821 _("Attempt to unpush the dummy target"));
823 /* Look for the specified target. Note that we assume that a target
824 can only occur once in the target stack. */
826 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
832 /* If we don't find target_ops, quit. Only open targets should be
837 /* Unchain the target. */
839 (*cur) = (*cur)->beneath;
842 update_current_target ();
844 /* Finally close the target. Note we do this after unchaining, so
845 any target method calls from within the target_close
846 implementation don't end up in T anymore. */
853 pop_all_targets_above (enum strata above_stratum)
855 while ((int) (current_target.to_stratum) > (int) above_stratum)
857 if (!unpush_target (target_stack))
859 fprintf_unfiltered (gdb_stderr,
860 "pop_all_targets couldn't find target %s\n",
861 target_stack->to_shortname);
862 internal_error (__FILE__, __LINE__,
863 _("failed internal consistency check"));
870 pop_all_targets (void)
872 pop_all_targets_above (dummy_stratum);
875 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
878 target_is_pushed (struct target_ops *t)
880 struct target_ops **cur;
882 /* Check magic number. If wrong, it probably means someone changed
883 the struct definition, but not all the places that initialize one. */
884 if (t->to_magic != OPS_MAGIC)
886 fprintf_unfiltered (gdb_stderr,
887 "Magic number of %s target struct wrong\n",
889 internal_error (__FILE__, __LINE__,
890 _("failed internal consistency check"));
893 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
900 /* Using the objfile specified in OBJFILE, find the address for the
901 current thread's thread-local storage with offset OFFSET. */
903 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
905 volatile CORE_ADDR addr = 0;
906 struct target_ops *target;
908 for (target = current_target.beneath;
910 target = target->beneath)
912 if (target->to_get_thread_local_address != NULL)
917 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
919 ptid_t ptid = inferior_ptid;
920 volatile struct gdb_exception ex;
922 TRY_CATCH (ex, RETURN_MASK_ALL)
926 /* Fetch the load module address for this objfile. */
927 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
929 /* If it's 0, throw the appropriate exception. */
931 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
932 _("TLS load module not found"));
934 addr = target->to_get_thread_local_address (target, ptid,
937 /* If an error occurred, print TLS related messages here. Otherwise,
938 throw the error to some higher catcher. */
941 int objfile_is_library = (objfile->flags & OBJF_SHARED);
945 case TLS_NO_LIBRARY_SUPPORT_ERROR:
946 error (_("Cannot find thread-local variables "
947 "in this thread library."));
949 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
950 if (objfile_is_library)
951 error (_("Cannot find shared library `%s' in dynamic"
952 " linker's load module list"), objfile_name (objfile));
954 error (_("Cannot find executable file `%s' in dynamic"
955 " linker's load module list"), objfile_name (objfile));
957 case TLS_NOT_ALLOCATED_YET_ERROR:
958 if (objfile_is_library)
959 error (_("The inferior has not yet allocated storage for"
960 " thread-local variables in\n"
961 "the shared library `%s'\n"
963 objfile_name (objfile), target_pid_to_str (ptid));
965 error (_("The inferior has not yet allocated storage for"
966 " thread-local variables in\n"
967 "the executable `%s'\n"
969 objfile_name (objfile), target_pid_to_str (ptid));
971 case TLS_GENERIC_ERROR:
972 if (objfile_is_library)
973 error (_("Cannot find thread-local storage for %s, "
974 "shared library %s:\n%s"),
975 target_pid_to_str (ptid),
976 objfile_name (objfile), ex.message);
978 error (_("Cannot find thread-local storage for %s, "
979 "executable file %s:\n%s"),
980 target_pid_to_str (ptid),
981 objfile_name (objfile), ex.message);
984 throw_exception (ex);
989 /* It wouldn't be wrong here to try a gdbarch method, too; finding
990 TLS is an ABI-specific thing. But we don't do that yet. */
992 error (_("Cannot find thread-local variables on this target"));
998 target_xfer_status_to_string (enum target_xfer_status err)
1000 #define CASE(X) case X: return #X
1003 CASE(TARGET_XFER_E_IO);
1004 CASE(TARGET_XFER_E_UNAVAILABLE);
1013 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1015 /* target_read_string -- read a null terminated string, up to LEN bytes,
1016 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1017 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1018 is responsible for freeing it. Return the number of bytes successfully
1022 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
1024 int tlen, offset, i;
1028 int buffer_allocated;
1030 unsigned int nbytes_read = 0;
1032 gdb_assert (string);
1034 /* Small for testing. */
1035 buffer_allocated = 4;
1036 buffer = xmalloc (buffer_allocated);
1041 tlen = MIN (len, 4 - (memaddr & 3));
1042 offset = memaddr & 3;
1044 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
1047 /* The transfer request might have crossed the boundary to an
1048 unallocated region of memory. Retry the transfer, requesting
1052 errcode = target_read_memory (memaddr, buf, 1);
1057 if (bufptr - buffer + tlen > buffer_allocated)
1061 bytes = bufptr - buffer;
1062 buffer_allocated *= 2;
1063 buffer = xrealloc (buffer, buffer_allocated);
1064 bufptr = buffer + bytes;
1067 for (i = 0; i < tlen; i++)
1069 *bufptr++ = buf[i + offset];
1070 if (buf[i + offset] == '\000')
1072 nbytes_read += i + 1;
1079 nbytes_read += tlen;
1088 struct target_section_table *
1089 target_get_section_table (struct target_ops *target)
1092 fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
1094 return (*target->to_get_section_table) (target);
1097 /* Find a section containing ADDR. */
1099 struct target_section *
1100 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1102 struct target_section_table *table = target_get_section_table (target);
1103 struct target_section *secp;
1108 for (secp = table->sections; secp < table->sections_end; secp++)
1110 if (addr >= secp->addr && addr < secp->endaddr)
1116 /* Read memory from the live target, even if currently inspecting a
1117 traceframe. The return is the same as that of target_read. */
1119 static enum target_xfer_status
1120 target_read_live_memory (enum target_object object,
1121 ULONGEST memaddr, gdb_byte *myaddr, ULONGEST len,
1122 ULONGEST *xfered_len)
1124 enum target_xfer_status ret;
1125 struct cleanup *cleanup;
1127 /* Switch momentarily out of tfind mode so to access live memory.
1128 Note that this must not clear global state, such as the frame
1129 cache, which must still remain valid for the previous traceframe.
1130 We may be _building_ the frame cache at this point. */
1131 cleanup = make_cleanup_restore_traceframe_number ();
1132 set_traceframe_number (-1);
1134 ret = target_xfer_partial (current_target.beneath, object, NULL,
1135 myaddr, NULL, memaddr, len, xfered_len);
1137 do_cleanups (cleanup);
1141 /* Using the set of read-only target sections of OPS, read live
1142 read-only memory. Note that the actual reads start from the
1143 top-most target again.
1145 For interface/parameters/return description see target.h,
1148 static enum target_xfer_status
1149 memory_xfer_live_readonly_partial (struct target_ops *ops,
1150 enum target_object object,
1151 gdb_byte *readbuf, ULONGEST memaddr,
1152 ULONGEST len, ULONGEST *xfered_len)
1154 struct target_section *secp;
1155 struct target_section_table *table;
1157 secp = target_section_by_addr (ops, memaddr);
1159 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1160 secp->the_bfd_section)
1163 struct target_section *p;
1164 ULONGEST memend = memaddr + len;
1166 table = target_get_section_table (ops);
1168 for (p = table->sections; p < table->sections_end; p++)
1170 if (memaddr >= p->addr)
1172 if (memend <= p->endaddr)
1174 /* Entire transfer is within this section. */
1175 return target_read_live_memory (object, memaddr,
1176 readbuf, len, xfered_len);
1178 else if (memaddr >= p->endaddr)
1180 /* This section ends before the transfer starts. */
1185 /* This section overlaps the transfer. Just do half. */
1186 len = p->endaddr - memaddr;
1187 return target_read_live_memory (object, memaddr,
1188 readbuf, len, xfered_len);
1194 return TARGET_XFER_EOF;
1197 /* Read memory from more than one valid target. A core file, for
1198 instance, could have some of memory but delegate other bits to
1199 the target below it. So, we must manually try all targets. */
1201 static enum target_xfer_status
1202 raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
1203 const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
1204 ULONGEST *xfered_len)
1206 enum target_xfer_status res;
1210 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1211 readbuf, writebuf, memaddr, len,
1213 if (res == TARGET_XFER_OK)
1216 /* Stop if the target reports that the memory is not available. */
1217 if (res == TARGET_XFER_E_UNAVAILABLE)
1220 /* We want to continue past core files to executables, but not
1221 past a running target's memory. */
1222 if (ops->to_has_all_memory (ops))
1227 while (ops != NULL);
1232 /* Perform a partial memory transfer.
1233 For docs see target.h, to_xfer_partial. */
1235 static enum target_xfer_status
1236 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
1237 gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr,
1238 ULONGEST len, ULONGEST *xfered_len)
1240 enum target_xfer_status res;
1242 struct mem_region *region;
1243 struct inferior *inf;
1245 /* For accesses to unmapped overlay sections, read directly from
1246 files. Must do this first, as MEMADDR may need adjustment. */
1247 if (readbuf != NULL && overlay_debugging)
1249 struct obj_section *section = find_pc_overlay (memaddr);
1251 if (pc_in_unmapped_range (memaddr, section))
1253 struct target_section_table *table
1254 = target_get_section_table (ops);
1255 const char *section_name = section->the_bfd_section->name;
1257 memaddr = overlay_mapped_address (memaddr, section);
1258 return section_table_xfer_memory_partial (readbuf, writebuf,
1259 memaddr, len, xfered_len,
1261 table->sections_end,
1266 /* Try the executable files, if "trust-readonly-sections" is set. */
1267 if (readbuf != NULL && trust_readonly)
1269 struct target_section *secp;
1270 struct target_section_table *table;
1272 secp = target_section_by_addr (ops, memaddr);
1274 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1275 secp->the_bfd_section)
1278 table = target_get_section_table (ops);
1279 return section_table_xfer_memory_partial (readbuf, writebuf,
1280 memaddr, len, xfered_len,
1282 table->sections_end,
1287 /* If reading unavailable memory in the context of traceframes, and
1288 this address falls within a read-only section, fallback to
1289 reading from live memory. */
1290 if (readbuf != NULL && get_traceframe_number () != -1)
1292 VEC(mem_range_s) *available;
1294 /* If we fail to get the set of available memory, then the
1295 target does not support querying traceframe info, and so we
1296 attempt reading from the traceframe anyway (assuming the
1297 target implements the old QTro packet then). */
1298 if (traceframe_available_memory (&available, memaddr, len))
1300 struct cleanup *old_chain;
1302 old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
1304 if (VEC_empty (mem_range_s, available)
1305 || VEC_index (mem_range_s, available, 0)->start != memaddr)
1307 /* Don't read into the traceframe's available
1309 if (!VEC_empty (mem_range_s, available))
1311 LONGEST oldlen = len;
1313 len = VEC_index (mem_range_s, available, 0)->start - memaddr;
1314 gdb_assert (len <= oldlen);
1317 do_cleanups (old_chain);
1319 /* This goes through the topmost target again. */
1320 res = memory_xfer_live_readonly_partial (ops, object,
1323 if (res == TARGET_XFER_OK)
1324 return TARGET_XFER_OK;
1327 /* No use trying further, we know some memory starting
1328 at MEMADDR isn't available. */
1330 return TARGET_XFER_E_UNAVAILABLE;
1334 /* Don't try to read more than how much is available, in
1335 case the target implements the deprecated QTro packet to
1336 cater for older GDBs (the target's knowledge of read-only
1337 sections may be outdated by now). */
1338 len = VEC_index (mem_range_s, available, 0)->length;
1340 do_cleanups (old_chain);
1344 /* Try GDB's internal data cache. */
1345 region = lookup_mem_region (memaddr);
1346 /* region->hi == 0 means there's no upper bound. */
1347 if (memaddr + len < region->hi || region->hi == 0)
1350 reg_len = region->hi - memaddr;
1352 switch (region->attrib.mode)
1355 if (writebuf != NULL)
1356 return TARGET_XFER_E_IO;
1360 if (readbuf != NULL)
1361 return TARGET_XFER_E_IO;
1365 /* We only support writing to flash during "load" for now. */
1366 if (writebuf != NULL)
1367 error (_("Writing to flash memory forbidden in this context"));
1371 return TARGET_XFER_E_IO;
1374 if (!ptid_equal (inferior_ptid, null_ptid))
1375 inf = find_inferior_pid (ptid_get_pid (inferior_ptid));
1380 /* The dcache reads whole cache lines; that doesn't play well
1381 with reading from a trace buffer, because reading outside of
1382 the collected memory range fails. */
1383 && get_traceframe_number () == -1
1384 && (region->attrib.cache
1385 || (stack_cache_enabled_p () && object == TARGET_OBJECT_STACK_MEMORY)
1386 || (code_cache_enabled_p () && object == TARGET_OBJECT_CODE_MEMORY)))
1388 DCACHE *dcache = target_dcache_get_or_init ();
1391 if (readbuf != NULL)
1392 l = dcache_xfer_memory (ops, dcache, memaddr, readbuf, reg_len, 0);
1394 /* FIXME drow/2006-08-09: If we're going to preserve const
1395 correctness dcache_xfer_memory should take readbuf and
1397 l = dcache_xfer_memory (ops, dcache, memaddr, (void *) writebuf,
1400 return TARGET_XFER_E_IO;
1403 *xfered_len = (ULONGEST) l;
1404 return TARGET_XFER_OK;
1408 /* If none of those methods found the memory we wanted, fall back
1409 to a target partial transfer. Normally a single call to
1410 to_xfer_partial is enough; if it doesn't recognize an object
1411 it will call the to_xfer_partial of the next target down.
1412 But for memory this won't do. Memory is the only target
1413 object which can be read from more than one valid target.
1414 A core file, for instance, could have some of memory but
1415 delegate other bits to the target below it. So, we must
1416 manually try all targets. */
1418 res = raw_memory_xfer_partial (ops, readbuf, writebuf, memaddr, reg_len,
1421 /* Make sure the cache gets updated no matter what - if we are writing
1422 to the stack. Even if this write is not tagged as such, we still need
1423 to update the cache. */
1425 if (res == TARGET_XFER_OK
1428 && target_dcache_init_p ()
1429 && !region->attrib.cache
1430 && ((stack_cache_enabled_p () && object != TARGET_OBJECT_STACK_MEMORY)
1431 || (code_cache_enabled_p () && object != TARGET_OBJECT_CODE_MEMORY)))
1433 DCACHE *dcache = target_dcache_get ();
1435 dcache_update (dcache, memaddr, (void *) writebuf, reg_len);
1438 /* If we still haven't got anything, return the last error. We
1443 /* Perform a partial memory transfer. For docs see target.h,
1446 static enum target_xfer_status
1447 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1448 gdb_byte *readbuf, const gdb_byte *writebuf,
1449 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1451 enum target_xfer_status res;
1453 /* Zero length requests are ok and require no work. */
1455 return TARGET_XFER_EOF;
1457 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1458 breakpoint insns, thus hiding out from higher layers whether
1459 there are software breakpoints inserted in the code stream. */
1460 if (readbuf != NULL)
1462 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len,
1465 if (res == TARGET_XFER_OK && !show_memory_breakpoints)
1466 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, res);
1471 struct cleanup *old_chain;
1473 /* A large write request is likely to be partially satisfied
1474 by memory_xfer_partial_1. We will continually malloc
1475 and free a copy of the entire write request for breakpoint
1476 shadow handling even though we only end up writing a small
1477 subset of it. Cap writes to 4KB to mitigate this. */
1478 len = min (4096, len);
1480 buf = xmalloc (len);
1481 old_chain = make_cleanup (xfree, buf);
1482 memcpy (buf, writebuf, len);
1484 breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
1485 res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len,
1488 do_cleanups (old_chain);
1495 restore_show_memory_breakpoints (void *arg)
1497 show_memory_breakpoints = (uintptr_t) arg;
1501 make_show_memory_breakpoints_cleanup (int show)
1503 int current = show_memory_breakpoints;
1505 show_memory_breakpoints = show;
1506 return make_cleanup (restore_show_memory_breakpoints,
1507 (void *) (uintptr_t) current);
1510 /* For docs see target.h, to_xfer_partial. */
1512 enum target_xfer_status
1513 target_xfer_partial (struct target_ops *ops,
1514 enum target_object object, const char *annex,
1515 gdb_byte *readbuf, const gdb_byte *writebuf,
1516 ULONGEST offset, ULONGEST len,
1517 ULONGEST *xfered_len)
1519 enum target_xfer_status retval;
1521 gdb_assert (ops->to_xfer_partial != NULL);
1523 /* Transfer is done when LEN is zero. */
1525 return TARGET_XFER_EOF;
1527 if (writebuf && !may_write_memory)
1528 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1529 core_addr_to_string_nz (offset), plongest (len));
1533 /* If this is a memory transfer, let the memory-specific code
1534 have a look at it instead. Memory transfers are more
1536 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
1537 || object == TARGET_OBJECT_CODE_MEMORY)
1538 retval = memory_xfer_partial (ops, object, readbuf,
1539 writebuf, offset, len, xfered_len);
1540 else if (object == TARGET_OBJECT_RAW_MEMORY)
1542 /* Request the normal memory object from other layers. */
1543 retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len,
1547 retval = ops->to_xfer_partial (ops, object, annex, readbuf,
1548 writebuf, offset, len, xfered_len);
1552 const unsigned char *myaddr = NULL;
1554 fprintf_unfiltered (gdb_stdlog,
1555 "%s:target_xfer_partial "
1556 "(%d, %s, %s, %s, %s, %s) = %d, %s",
1559 (annex ? annex : "(null)"),
1560 host_address_to_string (readbuf),
1561 host_address_to_string (writebuf),
1562 core_addr_to_string_nz (offset),
1563 pulongest (len), retval,
1564 pulongest (*xfered_len));
1570 if (retval == TARGET_XFER_OK && myaddr != NULL)
1574 fputs_unfiltered (", bytes =", gdb_stdlog);
1575 for (i = 0; i < *xfered_len; i++)
1577 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1579 if (targetdebug < 2 && i > 0)
1581 fprintf_unfiltered (gdb_stdlog, " ...");
1584 fprintf_unfiltered (gdb_stdlog, "\n");
1587 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1591 fputc_unfiltered ('\n', gdb_stdlog);
1594 /* Check implementations of to_xfer_partial update *XFERED_LEN
1595 properly. Do assertion after printing debug messages, so that we
1596 can find more clues on assertion failure from debugging messages. */
1597 if (retval == TARGET_XFER_OK || retval == TARGET_XFER_E_UNAVAILABLE)
1598 gdb_assert (*xfered_len > 0);
1603 /* Read LEN bytes of target memory at address MEMADDR, placing the
1604 results in GDB's memory at MYADDR. Returns either 0 for success or
1605 TARGET_XFER_E_IO if any error occurs.
1607 If an error occurs, no guarantee is made about the contents of the data at
1608 MYADDR. In particular, the caller should not depend upon partial reads
1609 filling the buffer with good data. There is no way for the caller to know
1610 how much good data might have been transfered anyway. Callers that can
1611 deal with partial reads should call target_read (which will retry until
1612 it makes no progress, and then return how much was transferred). */
1615 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1617 /* Dispatch to the topmost target, not the flattened current_target.
1618 Memory accesses check target->to_has_(all_)memory, and the
1619 flattened target doesn't inherit those. */
1620 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1621 myaddr, memaddr, len) == len)
1624 return TARGET_XFER_E_IO;
1627 /* Like target_read_memory, but specify explicitly that this is a read
1628 from the target's raw memory. That is, this read bypasses the
1629 dcache, breakpoint shadowing, etc. */
1632 target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1634 /* See comment in target_read_memory about why the request starts at
1635 current_target.beneath. */
1636 if (target_read (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1637 myaddr, memaddr, len) == len)
1640 return TARGET_XFER_E_IO;
1643 /* Like target_read_memory, but specify explicitly that this is a read from
1644 the target's stack. This may trigger different cache behavior. */
1647 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1649 /* See comment in target_read_memory about why the request starts at
1650 current_target.beneath. */
1651 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1652 myaddr, memaddr, len) == len)
1655 return TARGET_XFER_E_IO;
1658 /* Like target_read_memory, but specify explicitly that this is a read from
1659 the target's code. This may trigger different cache behavior. */
1662 target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1664 /* See comment in target_read_memory about why the request starts at
1665 current_target.beneath. */
1666 if (target_read (current_target.beneath, TARGET_OBJECT_CODE_MEMORY, NULL,
1667 myaddr, memaddr, len) == len)
1670 return TARGET_XFER_E_IO;
1673 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1674 Returns either 0 for success or TARGET_XFER_E_IO if any
1675 error occurs. If an error occurs, no guarantee is made about how
1676 much data got written. Callers that can deal with partial writes
1677 should call target_write. */
1680 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1682 /* See comment in target_read_memory about why the request starts at
1683 current_target.beneath. */
1684 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1685 myaddr, memaddr, len) == len)
1688 return TARGET_XFER_E_IO;
1691 /* Write LEN bytes from MYADDR to target raw memory at address
1692 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
1693 if any error occurs. If an error occurs, no guarantee is made
1694 about how much data got written. Callers that can deal with
1695 partial writes should call target_write. */
1698 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
1700 /* See comment in target_read_memory about why the request starts at
1701 current_target.beneath. */
1702 if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1703 myaddr, memaddr, len) == len)
1706 return TARGET_XFER_E_IO;
1709 /* Fetch the target's memory map. */
1712 target_memory_map (void)
1714 VEC(mem_region_s) *result;
1715 struct mem_region *last_one, *this_one;
1717 struct target_ops *t;
1720 fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1722 for (t = current_target.beneath; t != NULL; t = t->beneath)
1723 if (t->to_memory_map != NULL)
1729 result = t->to_memory_map (t);
1733 qsort (VEC_address (mem_region_s, result),
1734 VEC_length (mem_region_s, result),
1735 sizeof (struct mem_region), mem_region_cmp);
1737 /* Check that regions do not overlap. Simultaneously assign
1738 a numbering for the "mem" commands to use to refer to
1741 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1743 this_one->number = ix;
1745 if (last_one && last_one->hi > this_one->lo)
1747 warning (_("Overlapping regions in memory map: ignoring"));
1748 VEC_free (mem_region_s, result);
1751 last_one = this_one;
1758 target_flash_erase (ULONGEST address, LONGEST length)
1761 fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1762 hex_string (address), phex (length, 0));
1763 current_target.to_flash_erase (¤t_target, address, length);
1767 target_flash_done (void)
1770 fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1771 current_target.to_flash_done (¤t_target);
1775 show_trust_readonly (struct ui_file *file, int from_tty,
1776 struct cmd_list_element *c, const char *value)
1778 fprintf_filtered (file,
1779 _("Mode for reading from readonly sections is %s.\n"),
1783 /* More generic transfers. */
1785 static enum target_xfer_status
1786 default_xfer_partial (struct target_ops *ops, enum target_object object,
1787 const char *annex, gdb_byte *readbuf,
1788 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1789 ULONGEST *xfered_len)
1791 if (object == TARGET_OBJECT_MEMORY
1792 && ops->deprecated_xfer_memory != NULL)
1793 /* If available, fall back to the target's
1794 "deprecated_xfer_memory" method. */
1799 if (writebuf != NULL)
1801 void *buffer = xmalloc (len);
1802 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1804 memcpy (buffer, writebuf, len);
1805 xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1806 1/*write*/, NULL, ops);
1807 do_cleanups (cleanup);
1809 if (readbuf != NULL)
1810 xfered = ops->deprecated_xfer_memory (offset, readbuf, len,
1811 0/*read*/, NULL, ops);
1814 *xfered_len = (ULONGEST) xfered;
1815 return TARGET_XFER_E_IO;
1817 else if (xfered == 0 && errno == 0)
1818 /* "deprecated_xfer_memory" uses 0, cross checked against
1819 ERRNO as one indication of an error. */
1820 return TARGET_XFER_EOF;
1822 return TARGET_XFER_E_IO;
1826 gdb_assert (ops->beneath != NULL);
1827 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1828 readbuf, writebuf, offset, len,
1833 /* Target vector read/write partial wrapper functions. */
1835 static enum target_xfer_status
1836 target_read_partial (struct target_ops *ops,
1837 enum target_object object,
1838 const char *annex, gdb_byte *buf,
1839 ULONGEST offset, ULONGEST len,
1840 ULONGEST *xfered_len)
1842 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len,
1846 static enum target_xfer_status
1847 target_write_partial (struct target_ops *ops,
1848 enum target_object object,
1849 const char *annex, const gdb_byte *buf,
1850 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
1852 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len,
1856 /* Wrappers to perform the full transfer. */
1858 /* For docs on target_read see target.h. */
1861 target_read (struct target_ops *ops,
1862 enum target_object object,
1863 const char *annex, gdb_byte *buf,
1864 ULONGEST offset, LONGEST len)
1868 while (xfered < len)
1870 ULONGEST xfered_len;
1871 enum target_xfer_status status;
1873 status = target_read_partial (ops, object, annex,
1874 (gdb_byte *) buf + xfered,
1875 offset + xfered, len - xfered,
1878 /* Call an observer, notifying them of the xfer progress? */
1879 if (status == TARGET_XFER_EOF)
1881 else if (status == TARGET_XFER_OK)
1883 xfered += xfered_len;
1893 /* Assuming that the entire [begin, end) range of memory cannot be
1894 read, try to read whatever subrange is possible to read.
1896 The function returns, in RESULT, either zero or one memory block.
1897 If there's a readable subrange at the beginning, it is completely
1898 read and returned. Any further readable subrange will not be read.
1899 Otherwise, if there's a readable subrange at the end, it will be
1900 completely read and returned. Any readable subranges before it
1901 (obviously, not starting at the beginning), will be ignored. In
1902 other cases -- either no readable subrange, or readable subrange(s)
1903 that is neither at the beginning, or end, nothing is returned.
1905 The purpose of this function is to handle a read across a boundary
1906 of accessible memory in a case when memory map is not available.
1907 The above restrictions are fine for this case, but will give
1908 incorrect results if the memory is 'patchy'. However, supporting
1909 'patchy' memory would require trying to read every single byte,
1910 and it seems unacceptable solution. Explicit memory map is
1911 recommended for this case -- and target_read_memory_robust will
1912 take care of reading multiple ranges then. */
1915 read_whatever_is_readable (struct target_ops *ops,
1916 ULONGEST begin, ULONGEST end,
1917 VEC(memory_read_result_s) **result)
1919 gdb_byte *buf = xmalloc (end - begin);
1920 ULONGEST current_begin = begin;
1921 ULONGEST current_end = end;
1923 memory_read_result_s r;
1924 ULONGEST xfered_len;
1926 /* If we previously failed to read 1 byte, nothing can be done here. */
1927 if (end - begin <= 1)
1933 /* Check that either first or the last byte is readable, and give up
1934 if not. This heuristic is meant to permit reading accessible memory
1935 at the boundary of accessible region. */
1936 if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1937 buf, begin, 1, &xfered_len) == TARGET_XFER_OK)
1942 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1943 buf + (end-begin) - 1, end - 1, 1,
1944 &xfered_len) == TARGET_XFER_OK)
1955 /* Loop invariant is that the [current_begin, current_end) was previously
1956 found to be not readable as a whole.
1958 Note loop condition -- if the range has 1 byte, we can't divide the range
1959 so there's no point trying further. */
1960 while (current_end - current_begin > 1)
1962 ULONGEST first_half_begin, first_half_end;
1963 ULONGEST second_half_begin, second_half_end;
1965 ULONGEST middle = current_begin + (current_end - current_begin)/2;
1969 first_half_begin = current_begin;
1970 first_half_end = middle;
1971 second_half_begin = middle;
1972 second_half_end = current_end;
1976 first_half_begin = middle;
1977 first_half_end = current_end;
1978 second_half_begin = current_begin;
1979 second_half_end = middle;
1982 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1983 buf + (first_half_begin - begin),
1985 first_half_end - first_half_begin);
1987 if (xfer == first_half_end - first_half_begin)
1989 /* This half reads up fine. So, the error must be in the
1991 current_begin = second_half_begin;
1992 current_end = second_half_end;
1996 /* This half is not readable. Because we've tried one byte, we
1997 know some part of this half if actually redable. Go to the next
1998 iteration to divide again and try to read.
2000 We don't handle the other half, because this function only tries
2001 to read a single readable subrange. */
2002 current_begin = first_half_begin;
2003 current_end = first_half_end;
2009 /* The [begin, current_begin) range has been read. */
2011 r.end = current_begin;
2016 /* The [current_end, end) range has been read. */
2017 LONGEST rlen = end - current_end;
2019 r.data = xmalloc (rlen);
2020 memcpy (r.data, buf + current_end - begin, rlen);
2021 r.begin = current_end;
2025 VEC_safe_push(memory_read_result_s, (*result), &r);
2029 free_memory_read_result_vector (void *x)
2031 VEC(memory_read_result_s) *v = x;
2032 memory_read_result_s *current;
2035 for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
2037 xfree (current->data);
2039 VEC_free (memory_read_result_s, v);
2042 VEC(memory_read_result_s) *
2043 read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
2045 VEC(memory_read_result_s) *result = 0;
2048 while (xfered < len)
2050 struct mem_region *region = lookup_mem_region (offset + xfered);
2053 /* If there is no explicit region, a fake one should be created. */
2054 gdb_assert (region);
2056 if (region->hi == 0)
2057 rlen = len - xfered;
2059 rlen = region->hi - offset;
2061 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
2063 /* Cannot read this region. Note that we can end up here only
2064 if the region is explicitly marked inaccessible, or
2065 'inaccessible-by-default' is in effect. */
2070 LONGEST to_read = min (len - xfered, rlen);
2071 gdb_byte *buffer = (gdb_byte *)xmalloc (to_read);
2073 LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2074 (gdb_byte *) buffer,
2075 offset + xfered, to_read);
2076 /* Call an observer, notifying them of the xfer progress? */
2079 /* Got an error reading full chunk. See if maybe we can read
2082 read_whatever_is_readable (ops, offset + xfered,
2083 offset + xfered + to_read, &result);
2088 struct memory_read_result r;
2090 r.begin = offset + xfered;
2091 r.end = r.begin + xfer;
2092 VEC_safe_push (memory_read_result_s, result, &r);
2102 /* An alternative to target_write with progress callbacks. */
2105 target_write_with_progress (struct target_ops *ops,
2106 enum target_object object,
2107 const char *annex, const gdb_byte *buf,
2108 ULONGEST offset, LONGEST len,
2109 void (*progress) (ULONGEST, void *), void *baton)
2113 /* Give the progress callback a chance to set up. */
2115 (*progress) (0, baton);
2117 while (xfered < len)
2119 ULONGEST xfered_len;
2120 enum target_xfer_status status;
2122 status = target_write_partial (ops, object, annex,
2123 (gdb_byte *) buf + xfered,
2124 offset + xfered, len - xfered,
2127 if (status == TARGET_XFER_EOF)
2129 if (TARGET_XFER_STATUS_ERROR_P (status))
2132 gdb_assert (status == TARGET_XFER_OK);
2134 (*progress) (xfered_len, baton);
2136 xfered += xfered_len;
2142 /* For docs on target_write see target.h. */
2145 target_write (struct target_ops *ops,
2146 enum target_object object,
2147 const char *annex, const gdb_byte *buf,
2148 ULONGEST offset, LONGEST len)
2150 return target_write_with_progress (ops, object, annex, buf, offset, len,
2154 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2155 the size of the transferred data. PADDING additional bytes are
2156 available in *BUF_P. This is a helper function for
2157 target_read_alloc; see the declaration of that function for more
2161 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
2162 const char *annex, gdb_byte **buf_p, int padding)
2164 size_t buf_alloc, buf_pos;
2167 /* This function does not have a length parameter; it reads the
2168 entire OBJECT). Also, it doesn't support objects fetched partly
2169 from one target and partly from another (in a different stratum,
2170 e.g. a core file and an executable). Both reasons make it
2171 unsuitable for reading memory. */
2172 gdb_assert (object != TARGET_OBJECT_MEMORY);
2174 /* Start by reading up to 4K at a time. The target will throttle
2175 this number down if necessary. */
2177 buf = xmalloc (buf_alloc);
2181 ULONGEST xfered_len;
2182 enum target_xfer_status status;
2184 status = target_read_partial (ops, object, annex, &buf[buf_pos],
2185 buf_pos, buf_alloc - buf_pos - padding,
2188 if (status == TARGET_XFER_EOF)
2190 /* Read all there was. */
2197 else if (status != TARGET_XFER_OK)
2199 /* An error occurred. */
2201 return TARGET_XFER_E_IO;
2204 buf_pos += xfered_len;
2206 /* If the buffer is filling up, expand it. */
2207 if (buf_alloc < buf_pos * 2)
2210 buf = xrealloc (buf, buf_alloc);
2217 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2218 the size of the transferred data. See the declaration in "target.h"
2219 function for more information about the return value. */
2222 target_read_alloc (struct target_ops *ops, enum target_object object,
2223 const char *annex, gdb_byte **buf_p)
2225 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
2228 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2229 returned as a string, allocated using xmalloc. If an error occurs
2230 or the transfer is unsupported, NULL is returned. Empty objects
2231 are returned as allocated but empty strings. A warning is issued
2232 if the result contains any embedded NUL bytes. */
2235 target_read_stralloc (struct target_ops *ops, enum target_object object,
2240 LONGEST i, transferred;
2242 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
2243 bufstr = (char *) buffer;
2245 if (transferred < 0)
2248 if (transferred == 0)
2249 return xstrdup ("");
2251 bufstr[transferred] = 0;
2253 /* Check for embedded NUL bytes; but allow trailing NULs. */
2254 for (i = strlen (bufstr); i < transferred; i++)
2257 warning (_("target object %d, annex %s, "
2258 "contained unexpected null characters"),
2259 (int) object, annex ? annex : "(none)");
2266 /* Memory transfer methods. */
2269 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2272 /* This method is used to read from an alternate, non-current
2273 target. This read must bypass the overlay support (as symbols
2274 don't match this target), and GDB's internal cache (wrong cache
2275 for this target). */
2276 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2278 memory_error (TARGET_XFER_E_IO, addr);
2282 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2283 int len, enum bfd_endian byte_order)
2285 gdb_byte buf[sizeof (ULONGEST)];
2287 gdb_assert (len <= sizeof (buf));
2288 get_target_memory (ops, addr, buf, len);
2289 return extract_unsigned_integer (buf, len, byte_order);
2295 target_insert_breakpoint (struct gdbarch *gdbarch,
2296 struct bp_target_info *bp_tgt)
2298 if (!may_insert_breakpoints)
2300 warning (_("May not insert breakpoints"));
2304 return current_target.to_insert_breakpoint (¤t_target,
2311 target_remove_breakpoint (struct gdbarch *gdbarch,
2312 struct bp_target_info *bp_tgt)
2314 /* This is kind of a weird case to handle, but the permission might
2315 have been changed after breakpoints were inserted - in which case
2316 we should just take the user literally and assume that any
2317 breakpoints should be left in place. */
2318 if (!may_insert_breakpoints)
2320 warning (_("May not remove breakpoints"));
2324 return current_target.to_remove_breakpoint (¤t_target,
2329 target_info (char *args, int from_tty)
2331 struct target_ops *t;
2332 int has_all_mem = 0;
2334 if (symfile_objfile != NULL)
2335 printf_unfiltered (_("Symbols from \"%s\".\n"),
2336 objfile_name (symfile_objfile));
2338 for (t = target_stack; t != NULL; t = t->beneath)
2340 if (!(*t->to_has_memory) (t))
2343 if ((int) (t->to_stratum) <= (int) dummy_stratum)
2346 printf_unfiltered (_("\tWhile running this, "
2347 "GDB does not access memory from...\n"));
2348 printf_unfiltered ("%s:\n", t->to_longname);
2349 (t->to_files_info) (t);
2350 has_all_mem = (*t->to_has_all_memory) (t);
2354 /* This function is called before any new inferior is created, e.g.
2355 by running a program, attaching, or connecting to a target.
2356 It cleans up any state from previous invocations which might
2357 change between runs. This is a subset of what target_preopen
2358 resets (things which might change between targets). */
2361 target_pre_inferior (int from_tty)
2363 /* Clear out solib state. Otherwise the solib state of the previous
2364 inferior might have survived and is entirely wrong for the new
2365 target. This has been observed on GNU/Linux using glibc 2.3. How
2377 Cannot access memory at address 0xdeadbeef
2380 /* In some OSs, the shared library list is the same/global/shared
2381 across inferiors. If code is shared between processes, so are
2382 memory regions and features. */
2383 if (!gdbarch_has_global_solist (target_gdbarch ()))
2385 no_shared_libraries (NULL, from_tty);
2387 invalidate_target_mem_regions ();
2389 target_clear_description ();
2392 agent_capability_invalidate ();
2395 /* Callback for iterate_over_inferiors. Gets rid of the given
2399 dispose_inferior (struct inferior *inf, void *args)
2401 struct thread_info *thread;
2403 thread = any_thread_of_process (inf->pid);
2406 switch_to_thread (thread->ptid);
2408 /* Core inferiors actually should be detached, not killed. */
2409 if (target_has_execution)
2412 target_detach (NULL, 0);
2418 /* This is to be called by the open routine before it does
2422 target_preopen (int from_tty)
2426 if (have_inferiors ())
2429 || !have_live_inferiors ()
2430 || query (_("A program is being debugged already. Kill it? ")))
2431 iterate_over_inferiors (dispose_inferior, NULL);
2433 error (_("Program not killed."));
2436 /* Calling target_kill may remove the target from the stack. But if
2437 it doesn't (which seems like a win for UDI), remove it now. */
2438 /* Leave the exec target, though. The user may be switching from a
2439 live process to a core of the same program. */
2440 pop_all_targets_above (file_stratum);
2442 target_pre_inferior (from_tty);
2445 /* Detach a target after doing deferred register stores. */
2448 target_detach (const char *args, int from_tty)
2450 struct target_ops* t;
2452 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2453 /* Don't remove global breakpoints here. They're removed on
2454 disconnection from the target. */
2457 /* If we're in breakpoints-always-inserted mode, have to remove
2458 them before detaching. */
2459 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
2461 prepare_for_detach ();
2463 current_target.to_detach (¤t_target, args, from_tty);
2465 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
2470 target_disconnect (char *args, int from_tty)
2472 struct target_ops *t;
2474 /* If we're in breakpoints-always-inserted mode or if breakpoints
2475 are global across processes, we have to remove them before
2477 remove_breakpoints ();
2479 for (t = current_target.beneath; t != NULL; t = t->beneath)
2480 if (t->to_disconnect != NULL)
2483 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
2485 t->to_disconnect (t, args, from_tty);
2493 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2495 struct target_ops *t;
2496 ptid_t retval = (current_target.to_wait) (¤t_target, ptid,
2501 char *status_string;
2502 char *options_string;
2504 status_string = target_waitstatus_to_string (status);
2505 options_string = target_options_to_string (options);
2506 fprintf_unfiltered (gdb_stdlog,
2507 "target_wait (%d, status, options={%s})"
2509 ptid_get_pid (ptid), options_string,
2510 ptid_get_pid (retval), status_string);
2511 xfree (status_string);
2512 xfree (options_string);
2519 target_pid_to_str (ptid_t ptid)
2521 return (*current_target.to_pid_to_str) (¤t_target, ptid);
2525 target_thread_name (struct thread_info *info)
2527 return current_target.to_thread_name (¤t_target, info);
2531 target_resume (ptid_t ptid, int step, enum gdb_signal signal)
2533 struct target_ops *t;
2535 target_dcache_invalidate ();
2537 current_target.to_resume (¤t_target, ptid, step, signal);
2539 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
2540 ptid_get_pid (ptid),
2541 step ? "step" : "continue",
2542 gdb_signal_to_name (signal));
2544 registers_changed_ptid (ptid);
2545 set_executing (ptid, 1);
2546 set_running (ptid, 1);
2547 clear_inline_frame_state (ptid);
2551 target_pass_signals (int numsigs, unsigned char *pass_signals)
2557 fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
2560 for (i = 0; i < numsigs; i++)
2561 if (pass_signals[i])
2562 fprintf_unfiltered (gdb_stdlog, " %s",
2563 gdb_signal_to_name (i));
2565 fprintf_unfiltered (gdb_stdlog, " })\n");
2568 (*current_target.to_pass_signals) (¤t_target, numsigs, pass_signals);
2572 target_program_signals (int numsigs, unsigned char *program_signals)
2578 fprintf_unfiltered (gdb_stdlog, "target_program_signals (%d, {",
2581 for (i = 0; i < numsigs; i++)
2582 if (program_signals[i])
2583 fprintf_unfiltered (gdb_stdlog, " %s",
2584 gdb_signal_to_name (i));
2586 fprintf_unfiltered (gdb_stdlog, " })\n");
2589 (*current_target.to_program_signals) (¤t_target,
2590 numsigs, program_signals);
2594 default_follow_fork (struct target_ops *self, int follow_child,
2597 /* Some target returned a fork event, but did not know how to follow it. */
2598 internal_error (__FILE__, __LINE__,
2599 _("could not find a target to follow fork"));
2602 /* Look through the list of possible targets for a target that can
2606 target_follow_fork (int follow_child, int detach_fork)
2608 int retval = current_target.to_follow_fork (¤t_target,
2609 follow_child, detach_fork);
2612 fprintf_unfiltered (gdb_stdlog,
2613 "target_follow_fork (%d, %d) = %d\n",
2614 follow_child, detach_fork, retval);
2619 default_mourn_inferior (struct target_ops *self)
2621 internal_error (__FILE__, __LINE__,
2622 _("could not find a target to follow mourn inferior"));
2626 target_mourn_inferior (void)
2628 current_target.to_mourn_inferior (¤t_target);
2630 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2632 /* We no longer need to keep handles on any of the object files.
2633 Make sure to release them to avoid unnecessarily locking any
2634 of them while we're not actually debugging. */
2635 bfd_cache_close_all ();
2638 /* Look for a target which can describe architectural features, starting
2639 from TARGET. If we find one, return its description. */
2641 const struct target_desc *
2642 target_read_description (struct target_ops *target)
2644 struct target_ops *t;
2646 for (t = target; t != NULL; t = t->beneath)
2647 if (t->to_read_description != NULL)
2649 const struct target_desc *tdesc;
2651 tdesc = t->to_read_description (t);
2659 /* The default implementation of to_search_memory.
2660 This implements a basic search of memory, reading target memory and
2661 performing the search here (as opposed to performing the search in on the
2662 target side with, for example, gdbserver). */
2665 simple_search_memory (struct target_ops *ops,
2666 CORE_ADDR start_addr, ULONGEST search_space_len,
2667 const gdb_byte *pattern, ULONGEST pattern_len,
2668 CORE_ADDR *found_addrp)
2670 /* NOTE: also defined in find.c testcase. */
2671 #define SEARCH_CHUNK_SIZE 16000
2672 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2673 /* Buffer to hold memory contents for searching. */
2674 gdb_byte *search_buf;
2675 unsigned search_buf_size;
2676 struct cleanup *old_cleanups;
2678 search_buf_size = chunk_size + pattern_len - 1;
2680 /* No point in trying to allocate a buffer larger than the search space. */
2681 if (search_space_len < search_buf_size)
2682 search_buf_size = search_space_len;
2684 search_buf = malloc (search_buf_size);
2685 if (search_buf == NULL)
2686 error (_("Unable to allocate memory to perform the search."));
2687 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2689 /* Prime the search buffer. */
2691 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2692 search_buf, start_addr, search_buf_size) != search_buf_size)
2694 warning (_("Unable to access %s bytes of target "
2695 "memory at %s, halting search."),
2696 pulongest (search_buf_size), hex_string (start_addr));
2697 do_cleanups (old_cleanups);
2701 /* Perform the search.
2703 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2704 When we've scanned N bytes we copy the trailing bytes to the start and
2705 read in another N bytes. */
2707 while (search_space_len >= pattern_len)
2709 gdb_byte *found_ptr;
2710 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2712 found_ptr = memmem (search_buf, nr_search_bytes,
2713 pattern, pattern_len);
2715 if (found_ptr != NULL)
2717 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2719 *found_addrp = found_addr;
2720 do_cleanups (old_cleanups);
2724 /* Not found in this chunk, skip to next chunk. */
2726 /* Don't let search_space_len wrap here, it's unsigned. */
2727 if (search_space_len >= chunk_size)
2728 search_space_len -= chunk_size;
2730 search_space_len = 0;
2732 if (search_space_len >= pattern_len)
2734 unsigned keep_len = search_buf_size - chunk_size;
2735 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
2738 /* Copy the trailing part of the previous iteration to the front
2739 of the buffer for the next iteration. */
2740 gdb_assert (keep_len == pattern_len - 1);
2741 memcpy (search_buf, search_buf + chunk_size, keep_len);
2743 nr_to_read = min (search_space_len - keep_len, chunk_size);
2745 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2746 search_buf + keep_len, read_addr,
2747 nr_to_read) != nr_to_read)
2749 warning (_("Unable to access %s bytes of target "
2750 "memory at %s, halting search."),
2751 plongest (nr_to_read),
2752 hex_string (read_addr));
2753 do_cleanups (old_cleanups);
2757 start_addr += chunk_size;
2763 do_cleanups (old_cleanups);
2767 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2768 sequence of bytes in PATTERN with length PATTERN_LEN.
2770 The result is 1 if found, 0 if not found, and -1 if there was an error
2771 requiring halting of the search (e.g. memory read error).
2772 If the pattern is found the address is recorded in FOUND_ADDRP. */
2775 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2776 const gdb_byte *pattern, ULONGEST pattern_len,
2777 CORE_ADDR *found_addrp)
2779 struct target_ops *t;
2782 /* We don't use INHERIT to set current_target.to_search_memory,
2783 so we have to scan the target stack and handle targetdebug
2787 fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2788 hex_string (start_addr));
2790 for (t = current_target.beneath; t != NULL; t = t->beneath)
2791 if (t->to_search_memory != NULL)
2796 found = t->to_search_memory (t, start_addr, search_space_len,
2797 pattern, pattern_len, found_addrp);
2801 /* If a special version of to_search_memory isn't available, use the
2803 found = simple_search_memory (current_target.beneath,
2804 start_addr, search_space_len,
2805 pattern, pattern_len, found_addrp);
2809 fprintf_unfiltered (gdb_stdlog, " = %d\n", found);
2814 /* Look through the currently pushed targets. If none of them will
2815 be able to restart the currently running process, issue an error
2819 target_require_runnable (void)
2821 struct target_ops *t;
2823 for (t = target_stack; t != NULL; t = t->beneath)
2825 /* If this target knows how to create a new program, then
2826 assume we will still be able to after killing the current
2827 one. Either killing and mourning will not pop T, or else
2828 find_default_run_target will find it again. */
2829 if (t->to_create_inferior != NULL)
2832 /* Do not worry about thread_stratum targets that can not
2833 create inferiors. Assume they will be pushed again if
2834 necessary, and continue to the process_stratum. */
2835 if (t->to_stratum == thread_stratum
2836 || t->to_stratum == arch_stratum)
2839 error (_("The \"%s\" target does not support \"run\". "
2840 "Try \"help target\" or \"continue\"."),
2844 /* This function is only called if the target is running. In that
2845 case there should have been a process_stratum target and it
2846 should either know how to create inferiors, or not... */
2847 internal_error (__FILE__, __LINE__, _("No targets found"));
2850 /* Look through the list of possible targets for a target that can
2851 execute a run or attach command without any other data. This is
2852 used to locate the default process stratum.
2854 If DO_MESG is not NULL, the result is always valid (error() is
2855 called for errors); else, return NULL on error. */
2857 static struct target_ops *
2858 find_default_run_target (char *do_mesg)
2860 struct target_ops **t;
2861 struct target_ops *runable = NULL;
2866 for (t = target_structs; t < target_structs + target_struct_size;
2869 if ((*t)->to_can_run && target_can_run (*t))
2879 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2888 find_default_attach (struct target_ops *ops, char *args, int from_tty)
2890 struct target_ops *t;
2892 t = find_default_run_target ("attach");
2893 (t->to_attach) (t, args, from_tty);
2898 find_default_create_inferior (struct target_ops *ops,
2899 char *exec_file, char *allargs, char **env,
2902 struct target_ops *t;
2904 t = find_default_run_target ("run");
2905 (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
2910 find_default_can_async_p (struct target_ops *ignore)
2912 struct target_ops *t;
2914 /* This may be called before the target is pushed on the stack;
2915 look for the default process stratum. If there's none, gdb isn't
2916 configured with a native debugger, and target remote isn't
2918 t = find_default_run_target (NULL);
2919 if (t && t->to_can_async_p != delegate_can_async_p)
2920 return (t->to_can_async_p) (t);
2925 find_default_is_async_p (struct target_ops *ignore)
2927 struct target_ops *t;
2929 /* This may be called before the target is pushed on the stack;
2930 look for the default process stratum. If there's none, gdb isn't
2931 configured with a native debugger, and target remote isn't
2933 t = find_default_run_target (NULL);
2934 if (t && t->to_is_async_p != delegate_is_async_p)
2935 return (t->to_is_async_p) (t);
2940 find_default_supports_non_stop (struct target_ops *self)
2942 struct target_ops *t;
2944 t = find_default_run_target (NULL);
2945 if (t && t->to_supports_non_stop)
2946 return (t->to_supports_non_stop) (t);
2951 target_supports_non_stop (void)
2953 struct target_ops *t;
2955 for (t = ¤t_target; t != NULL; t = t->beneath)
2956 if (t->to_supports_non_stop)
2957 return t->to_supports_non_stop (t);
2962 /* Implement the "info proc" command. */
2965 target_info_proc (char *args, enum info_proc_what what)
2967 struct target_ops *t;
2969 /* If we're already connected to something that can get us OS
2970 related data, use it. Otherwise, try using the native
2972 if (current_target.to_stratum >= process_stratum)
2973 t = current_target.beneath;
2975 t = find_default_run_target (NULL);
2977 for (; t != NULL; t = t->beneath)
2979 if (t->to_info_proc != NULL)
2981 t->to_info_proc (t, args, what);
2984 fprintf_unfiltered (gdb_stdlog,
2985 "target_info_proc (\"%s\", %d)\n", args, what);
2995 find_default_supports_disable_randomization (struct target_ops *self)
2997 struct target_ops *t;
2999 t = find_default_run_target (NULL);
3000 if (t && t->to_supports_disable_randomization)
3001 return (t->to_supports_disable_randomization) (t);
3006 target_supports_disable_randomization (void)
3008 struct target_ops *t;
3010 for (t = ¤t_target; t != NULL; t = t->beneath)
3011 if (t->to_supports_disable_randomization)
3012 return t->to_supports_disable_randomization (t);
3018 target_get_osdata (const char *type)
3020 struct target_ops *t;
3022 /* If we're already connected to something that can get us OS
3023 related data, use it. Otherwise, try using the native
3025 if (current_target.to_stratum >= process_stratum)
3026 t = current_target.beneath;
3028 t = find_default_run_target ("get OS data");
3033 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
3036 /* Determine the current address space of thread PTID. */
3038 struct address_space *
3039 target_thread_address_space (ptid_t ptid)
3041 struct address_space *aspace;
3042 struct inferior *inf;
3043 struct target_ops *t;
3045 for (t = current_target.beneath; t != NULL; t = t->beneath)
3047 if (t->to_thread_address_space != NULL)
3049 aspace = t->to_thread_address_space (t, ptid);
3050 gdb_assert (aspace);
3053 fprintf_unfiltered (gdb_stdlog,
3054 "target_thread_address_space (%s) = %d\n",
3055 target_pid_to_str (ptid),
3056 address_space_num (aspace));
3061 /* Fall-back to the "main" address space of the inferior. */
3062 inf = find_inferior_pid (ptid_get_pid (ptid));
3064 if (inf == NULL || inf->aspace == NULL)
3065 internal_error (__FILE__, __LINE__,
3066 _("Can't determine the current "
3067 "address space of thread %s\n"),
3068 target_pid_to_str (ptid));
3074 /* Target file operations. */
3076 static struct target_ops *
3077 default_fileio_target (void)
3079 /* If we're already connected to something that can perform
3080 file I/O, use it. Otherwise, try using the native target. */
3081 if (current_target.to_stratum >= process_stratum)
3082 return current_target.beneath;
3084 return find_default_run_target ("file I/O");
3087 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3088 target file descriptor, or -1 if an error occurs (and set
3091 target_fileio_open (const char *filename, int flags, int mode,
3094 struct target_ops *t;
3096 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3098 if (t->to_fileio_open != NULL)
3100 int fd = t->to_fileio_open (t, filename, flags, mode, target_errno);
3103 fprintf_unfiltered (gdb_stdlog,
3104 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3105 filename, flags, mode,
3106 fd, fd != -1 ? 0 : *target_errno);
3111 *target_errno = FILEIO_ENOSYS;
3115 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3116 Return the number of bytes written, or -1 if an error occurs
3117 (and set *TARGET_ERRNO). */
3119 target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
3120 ULONGEST offset, int *target_errno)
3122 struct target_ops *t;
3124 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3126 if (t->to_fileio_pwrite != NULL)
3128 int ret = t->to_fileio_pwrite (t, fd, write_buf, len, offset,
3132 fprintf_unfiltered (gdb_stdlog,
3133 "target_fileio_pwrite (%d,...,%d,%s) "
3135 fd, len, pulongest (offset),
3136 ret, ret != -1 ? 0 : *target_errno);
3141 *target_errno = FILEIO_ENOSYS;
3145 /* Read up to LEN bytes FD on the target into READ_BUF.
3146 Return the number of bytes read, or -1 if an error occurs
3147 (and set *TARGET_ERRNO). */
3149 target_fileio_pread (int fd, gdb_byte *read_buf, int len,
3150 ULONGEST offset, int *target_errno)
3152 struct target_ops *t;
3154 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3156 if (t->to_fileio_pread != NULL)
3158 int ret = t->to_fileio_pread (t, fd, read_buf, len, offset,
3162 fprintf_unfiltered (gdb_stdlog,
3163 "target_fileio_pread (%d,...,%d,%s) "
3165 fd, len, pulongest (offset),
3166 ret, ret != -1 ? 0 : *target_errno);
3171 *target_errno = FILEIO_ENOSYS;
3175 /* Close FD on the target. Return 0, or -1 if an error occurs
3176 (and set *TARGET_ERRNO). */
3178 target_fileio_close (int fd, int *target_errno)
3180 struct target_ops *t;
3182 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3184 if (t->to_fileio_close != NULL)
3186 int ret = t->to_fileio_close (t, fd, target_errno);
3189 fprintf_unfiltered (gdb_stdlog,
3190 "target_fileio_close (%d) = %d (%d)\n",
3191 fd, ret, ret != -1 ? 0 : *target_errno);
3196 *target_errno = FILEIO_ENOSYS;
3200 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3201 occurs (and set *TARGET_ERRNO). */
3203 target_fileio_unlink (const char *filename, int *target_errno)
3205 struct target_ops *t;
3207 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3209 if (t->to_fileio_unlink != NULL)
3211 int ret = t->to_fileio_unlink (t, filename, target_errno);
3214 fprintf_unfiltered (gdb_stdlog,
3215 "target_fileio_unlink (%s) = %d (%d)\n",
3216 filename, ret, ret != -1 ? 0 : *target_errno);
3221 *target_errno = FILEIO_ENOSYS;
3225 /* Read value of symbolic link FILENAME on the target. Return a
3226 null-terminated string allocated via xmalloc, or NULL if an error
3227 occurs (and set *TARGET_ERRNO). */
3229 target_fileio_readlink (const char *filename, int *target_errno)
3231 struct target_ops *t;
3233 for (t = default_fileio_target (); t != NULL; t = t->beneath)
3235 if (t->to_fileio_readlink != NULL)
3237 char *ret = t->to_fileio_readlink (t, filename, target_errno);
3240 fprintf_unfiltered (gdb_stdlog,
3241 "target_fileio_readlink (%s) = %s (%d)\n",
3242 filename, ret? ret : "(nil)",
3243 ret? 0 : *target_errno);
3248 *target_errno = FILEIO_ENOSYS;
3253 target_fileio_close_cleanup (void *opaque)
3255 int fd = *(int *) opaque;
3258 target_fileio_close (fd, &target_errno);
3261 /* Read target file FILENAME. Store the result in *BUF_P and
3262 return the size of the transferred data. PADDING additional bytes are
3263 available in *BUF_P. This is a helper function for
3264 target_fileio_read_alloc; see the declaration of that function for more
3268 target_fileio_read_alloc_1 (const char *filename,
3269 gdb_byte **buf_p, int padding)
3271 struct cleanup *close_cleanup;
3272 size_t buf_alloc, buf_pos;
3278 fd = target_fileio_open (filename, FILEIO_O_RDONLY, 0700, &target_errno);
3282 close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
3284 /* Start by reading up to 4K at a time. The target will throttle
3285 this number down if necessary. */
3287 buf = xmalloc (buf_alloc);
3291 n = target_fileio_pread (fd, &buf[buf_pos],
3292 buf_alloc - buf_pos - padding, buf_pos,
3296 /* An error occurred. */
3297 do_cleanups (close_cleanup);
3303 /* Read all there was. */
3304 do_cleanups (close_cleanup);
3314 /* If the buffer is filling up, expand it. */
3315 if (buf_alloc < buf_pos * 2)
3318 buf = xrealloc (buf, buf_alloc);
3325 /* Read target file FILENAME. Store the result in *BUF_P and return
3326 the size of the transferred data. See the declaration in "target.h"
3327 function for more information about the return value. */
3330 target_fileio_read_alloc (const char *filename, gdb_byte **buf_p)
3332 return target_fileio_read_alloc_1 (filename, buf_p, 0);
3335 /* Read target file FILENAME. The result is NUL-terminated and
3336 returned as a string, allocated using xmalloc. If an error occurs
3337 or the transfer is unsupported, NULL is returned. Empty objects
3338 are returned as allocated but empty strings. A warning is issued
3339 if the result contains any embedded NUL bytes. */
3342 target_fileio_read_stralloc (const char *filename)
3346 LONGEST i, transferred;
3348 transferred = target_fileio_read_alloc_1 (filename, &buffer, 1);
3349 bufstr = (char *) buffer;
3351 if (transferred < 0)
3354 if (transferred == 0)
3355 return xstrdup ("");
3357 bufstr[transferred] = 0;
3359 /* Check for embedded NUL bytes; but allow trailing NULs. */
3360 for (i = strlen (bufstr); i < transferred; i++)
3363 warning (_("target file %s "
3364 "contained unexpected null characters"),
3374 default_region_ok_for_hw_watchpoint (struct target_ops *self,
3375 CORE_ADDR addr, int len)
3377 return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
3381 default_watchpoint_addr_within_range (struct target_ops *target,
3383 CORE_ADDR start, int length)
3385 return addr >= start && addr < start + length;
3388 static struct gdbarch *
3389 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3391 return target_gdbarch ();
3401 * Find the next target down the stack from the specified target.
3405 find_target_beneath (struct target_ops *t)
3413 find_target_at (enum strata stratum)
3415 struct target_ops *t;
3417 for (t = current_target.beneath; t != NULL; t = t->beneath)
3418 if (t->to_stratum == stratum)
3425 /* The inferior process has died. Long live the inferior! */
3428 generic_mourn_inferior (void)
3432 ptid = inferior_ptid;
3433 inferior_ptid = null_ptid;
3435 /* Mark breakpoints uninserted in case something tries to delete a
3436 breakpoint while we delete the inferior's threads (which would
3437 fail, since the inferior is long gone). */
3438 mark_breakpoints_out ();
3440 if (!ptid_equal (ptid, null_ptid))
3442 int pid = ptid_get_pid (ptid);
3443 exit_inferior (pid);
3446 /* Note this wipes step-resume breakpoints, so needs to be done
3447 after exit_inferior, which ends up referencing the step-resume
3448 breakpoints through clear_thread_inferior_resources. */
3449 breakpoint_init_inferior (inf_exited);
3451 registers_changed ();
3453 reopen_exec_file ();
3454 reinit_frame_cache ();
3456 if (deprecated_detach_hook)
3457 deprecated_detach_hook ();
3460 /* Convert a normal process ID to a string. Returns the string in a
3464 normal_pid_to_str (ptid_t ptid)
3466 static char buf[32];
3468 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
3473 default_pid_to_str (struct target_ops *ops, ptid_t ptid)
3475 return normal_pid_to_str (ptid);
3478 /* Error-catcher for target_find_memory_regions. */
3480 dummy_find_memory_regions (struct target_ops *self,
3481 find_memory_region_ftype ignore1, void *ignore2)
3483 error (_("Command not implemented for this target."));
3487 /* Error-catcher for target_make_corefile_notes. */
3489 dummy_make_corefile_notes (struct target_ops *self,
3490 bfd *ignore1, int *ignore2)
3492 error (_("Command not implemented for this target."));
3496 /* Set up the handful of non-empty slots needed by the dummy target
3500 init_dummy_target (void)
3502 dummy_target.to_shortname = "None";
3503 dummy_target.to_longname = "None";
3504 dummy_target.to_doc = "";
3505 dummy_target.to_create_inferior = find_default_create_inferior;
3506 dummy_target.to_supports_non_stop = find_default_supports_non_stop;
3507 dummy_target.to_supports_disable_randomization
3508 = find_default_supports_disable_randomization;
3509 dummy_target.to_stratum = dummy_stratum;
3510 dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
3511 dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero;
3512 dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero;
3513 dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero;
3514 dummy_target.to_has_execution
3515 = (int (*) (struct target_ops *, ptid_t)) return_zero;
3516 dummy_target.to_magic = OPS_MAGIC;
3518 install_dummy_methods (&dummy_target);
3522 debug_to_open (char *args, int from_tty)
3524 debug_target.to_open (args, from_tty);
3526 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
3530 target_close (struct target_ops *targ)
3532 gdb_assert (!target_is_pushed (targ));
3534 if (targ->to_xclose != NULL)
3535 targ->to_xclose (targ);
3536 else if (targ->to_close != NULL)
3537 targ->to_close (targ);
3540 fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
3544 target_attach (char *args, int from_tty)
3546 current_target.to_attach (¤t_target, args, from_tty);
3548 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
3553 target_thread_alive (ptid_t ptid)
3555 struct target_ops *t;
3557 for (t = current_target.beneath; t != NULL; t = t->beneath)
3559 if (t->to_thread_alive != NULL)
3563 retval = t->to_thread_alive (t, ptid);
3565 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3566 ptid_get_pid (ptid), retval);
3576 target_find_new_threads (void)
3578 current_target.to_find_new_threads (¤t_target);
3580 fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
3584 target_stop (ptid_t ptid)
3588 warning (_("May not interrupt or stop the target, ignoring attempt"));
3592 (*current_target.to_stop) (¤t_target, ptid);
3596 debug_to_post_attach (struct target_ops *self, int pid)
3598 debug_target.to_post_attach (&debug_target, pid);
3600 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
3603 /* Concatenate ELEM to LIST, a comma separate list, and return the
3604 result. The LIST incoming argument is released. */
3607 str_comma_list_concat_elem (char *list, const char *elem)
3610 return xstrdup (elem);
3612 return reconcat (list, list, ", ", elem, (char *) NULL);
3615 /* Helper for target_options_to_string. If OPT is present in
3616 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3617 Returns the new resulting string. OPT is removed from
3621 do_option (int *target_options, char *ret,
3622 int opt, char *opt_str)
3624 if ((*target_options & opt) != 0)
3626 ret = str_comma_list_concat_elem (ret, opt_str);
3627 *target_options &= ~opt;
3634 target_options_to_string (int target_options)
3638 #define DO_TARG_OPTION(OPT) \
3639 ret = do_option (&target_options, ret, OPT, #OPT)
3641 DO_TARG_OPTION (TARGET_WNOHANG);
3643 if (target_options != 0)
3644 ret = str_comma_list_concat_elem (ret, "unknown???");
3652 debug_print_register (const char * func,
3653 struct regcache *regcache, int regno)
3655 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3657 fprintf_unfiltered (gdb_stdlog, "%s ", func);
3658 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
3659 && gdbarch_register_name (gdbarch, regno) != NULL
3660 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3661 fprintf_unfiltered (gdb_stdlog, "(%s)",
3662 gdbarch_register_name (gdbarch, regno));
3664 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
3665 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
3667 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3668 int i, size = register_size (gdbarch, regno);
3669 gdb_byte buf[MAX_REGISTER_SIZE];
3671 regcache_raw_collect (regcache, regno, buf);
3672 fprintf_unfiltered (gdb_stdlog, " = ");
3673 for (i = 0; i < size; i++)
3675 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3677 if (size <= sizeof (LONGEST))
3679 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
3681 fprintf_unfiltered (gdb_stdlog, " %s %s",
3682 core_addr_to_string_nz (val), plongest (val));
3685 fprintf_unfiltered (gdb_stdlog, "\n");
3689 target_fetch_registers (struct regcache *regcache, int regno)
3691 current_target.to_fetch_registers (¤t_target, regcache, regno);
3693 debug_print_register ("target_fetch_registers", regcache, regno);
3697 target_store_registers (struct regcache *regcache, int regno)
3699 struct target_ops *t;
3701 if (!may_write_registers)
3702 error (_("Writing to registers is not allowed (regno %d)"), regno);
3704 current_target.to_store_registers (¤t_target, regcache, regno);
3707 debug_print_register ("target_store_registers", regcache, regno);
3712 target_core_of_thread (ptid_t ptid)
3714 int retval = current_target.to_core_of_thread (¤t_target, ptid);
3717 fprintf_unfiltered (gdb_stdlog,
3718 "target_core_of_thread (%d) = %d\n",
3719 ptid_get_pid (ptid), retval);
3724 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3726 int retval = current_target.to_verify_memory (¤t_target,
3727 data, memaddr, size);
3730 fprintf_unfiltered (gdb_stdlog,
3731 "target_verify_memory (%s, %s) = %d\n",
3732 paddress (target_gdbarch (), memaddr),
3738 /* The documentation for this function is in its prototype declaration in
3742 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3746 ret = current_target.to_insert_mask_watchpoint (¤t_target,
3750 fprintf_unfiltered (gdb_stdlog, "\
3751 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3752 core_addr_to_string (addr),
3753 core_addr_to_string (mask), rw, ret);
3758 /* The documentation for this function is in its prototype declaration in
3762 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3766 ret = current_target.to_remove_mask_watchpoint (¤t_target,
3770 fprintf_unfiltered (gdb_stdlog, "\
3771 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
3772 core_addr_to_string (addr),
3773 core_addr_to_string (mask), rw, ret);
3778 /* The documentation for this function is in its prototype declaration
3782 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
3784 return current_target.to_masked_watch_num_registers (¤t_target,
3788 /* The documentation for this function is in its prototype declaration
3792 target_ranged_break_num_registers (void)
3794 return current_target.to_ranged_break_num_registers (¤t_target);
3799 struct btrace_target_info *
3800 target_enable_btrace (ptid_t ptid)
3802 struct target_ops *t;
3804 for (t = current_target.beneath; t != NULL; t = t->beneath)
3805 if (t->to_enable_btrace != NULL)
3806 return t->to_enable_btrace (t, ptid);
3815 target_disable_btrace (struct btrace_target_info *btinfo)
3817 struct target_ops *t;
3819 for (t = current_target.beneath; t != NULL; t = t->beneath)
3820 if (t->to_disable_btrace != NULL)
3822 t->to_disable_btrace (t, btinfo);
3832 target_teardown_btrace (struct btrace_target_info *btinfo)
3834 struct target_ops *t;
3836 for (t = current_target.beneath; t != NULL; t = t->beneath)
3837 if (t->to_teardown_btrace != NULL)
3839 t->to_teardown_btrace (t, btinfo);
3849 target_read_btrace (VEC (btrace_block_s) **btrace,
3850 struct btrace_target_info *btinfo,
3851 enum btrace_read_type type)
3853 struct target_ops *t;
3855 for (t = current_target.beneath; t != NULL; t = t->beneath)
3856 if (t->to_read_btrace != NULL)
3857 return t->to_read_btrace (t, btrace, btinfo, type);
3860 return BTRACE_ERR_NOT_SUPPORTED;
3866 target_stop_recording (void)
3868 struct target_ops *t;
3870 for (t = current_target.beneath; t != NULL; t = t->beneath)
3871 if (t->to_stop_recording != NULL)
3873 t->to_stop_recording (t);
3877 /* This is optional. */
3883 target_info_record (void)
3885 struct target_ops *t;
3887 for (t = current_target.beneath; t != NULL; t = t->beneath)
3888 if (t->to_info_record != NULL)
3890 t->to_info_record (t);
3900 target_save_record (const char *filename)
3902 struct target_ops *t;
3904 for (t = current_target.beneath; t != NULL; t = t->beneath)
3905 if (t->to_save_record != NULL)
3907 t->to_save_record (t, filename);
3917 target_supports_delete_record (void)
3919 struct target_ops *t;
3921 for (t = current_target.beneath; t != NULL; t = t->beneath)
3922 if (t->to_delete_record != NULL)
3931 target_delete_record (void)
3933 struct target_ops *t;
3935 for (t = current_target.beneath; t != NULL; t = t->beneath)
3936 if (t->to_delete_record != NULL)
3938 t->to_delete_record (t);
3948 target_record_is_replaying (void)
3950 struct target_ops *t;
3952 for (t = current_target.beneath; t != NULL; t = t->beneath)
3953 if (t->to_record_is_replaying != NULL)
3954 return t->to_record_is_replaying (t);
3962 target_goto_record_begin (void)
3964 struct target_ops *t;
3966 for (t = current_target.beneath; t != NULL; t = t->beneath)
3967 if (t->to_goto_record_begin != NULL)
3969 t->to_goto_record_begin (t);
3979 target_goto_record_end (void)
3981 struct target_ops *t;
3983 for (t = current_target.beneath; t != NULL; t = t->beneath)
3984 if (t->to_goto_record_end != NULL)
3986 t->to_goto_record_end (t);
3996 target_goto_record (ULONGEST insn)
3998 struct target_ops *t;
4000 for (t = current_target.beneath; t != NULL; t = t->beneath)
4001 if (t->to_goto_record != NULL)
4003 t->to_goto_record (t, insn);
4013 target_insn_history (int size, int flags)
4015 struct target_ops *t;
4017 for (t = current_target.beneath; t != NULL; t = t->beneath)
4018 if (t->to_insn_history != NULL)
4020 t->to_insn_history (t, size, flags);
4030 target_insn_history_from (ULONGEST from, int size, int flags)
4032 struct target_ops *t;
4034 for (t = current_target.beneath; t != NULL; t = t->beneath)
4035 if (t->to_insn_history_from != NULL)
4037 t->to_insn_history_from (t, from, size, flags);
4047 target_insn_history_range (ULONGEST begin, ULONGEST end, int flags)
4049 struct target_ops *t;
4051 for (t = current_target.beneath; t != NULL; t = t->beneath)
4052 if (t->to_insn_history_range != NULL)
4054 t->to_insn_history_range (t, begin, end, flags);
4064 target_call_history (int size, int flags)
4066 struct target_ops *t;
4068 for (t = current_target.beneath; t != NULL; t = t->beneath)
4069 if (t->to_call_history != NULL)
4071 t->to_call_history (t, size, flags);
4081 target_call_history_from (ULONGEST begin, int size, int flags)
4083 struct target_ops *t;
4085 for (t = current_target.beneath; t != NULL; t = t->beneath)
4086 if (t->to_call_history_from != NULL)
4088 t->to_call_history_from (t, begin, size, flags);
4098 target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
4100 struct target_ops *t;
4102 for (t = current_target.beneath; t != NULL; t = t->beneath)
4103 if (t->to_call_history_range != NULL)
4105 t->to_call_history_range (t, begin, end, flags);
4113 debug_to_prepare_to_store (struct target_ops *self, struct regcache *regcache)
4115 debug_target.to_prepare_to_store (&debug_target, regcache);
4117 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
4122 const struct frame_unwind *
4123 target_get_unwinder (void)
4125 struct target_ops *t;
4127 for (t = current_target.beneath; t != NULL; t = t->beneath)
4128 if (t->to_get_unwinder != NULL)
4129 return t->to_get_unwinder;
4136 const struct frame_unwind *
4137 target_get_tailcall_unwinder (void)
4139 struct target_ops *t;
4141 for (t = current_target.beneath; t != NULL; t = t->beneath)
4142 if (t->to_get_tailcall_unwinder != NULL)
4143 return t->to_get_tailcall_unwinder;
4151 forward_target_decr_pc_after_break (struct target_ops *ops,
4152 struct gdbarch *gdbarch)
4154 for (; ops != NULL; ops = ops->beneath)
4155 if (ops->to_decr_pc_after_break != NULL)
4156 return ops->to_decr_pc_after_break (ops, gdbarch);
4158 return gdbarch_decr_pc_after_break (gdbarch);
4164 target_decr_pc_after_break (struct gdbarch *gdbarch)
4166 return forward_target_decr_pc_after_break (current_target.beneath, gdbarch);
4170 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
4171 int write, struct mem_attrib *attrib,
4172 struct target_ops *target)
4176 retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
4179 fprintf_unfiltered (gdb_stdlog,
4180 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4181 paddress (target_gdbarch (), memaddr), len,
4182 write ? "write" : "read", retval);
4188 fputs_unfiltered (", bytes =", gdb_stdlog);
4189 for (i = 0; i < retval; i++)
4191 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
4193 if (targetdebug < 2 && i > 0)
4195 fprintf_unfiltered (gdb_stdlog, " ...");
4198 fprintf_unfiltered (gdb_stdlog, "\n");
4201 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
4205 fputc_unfiltered ('\n', gdb_stdlog);
4211 debug_to_files_info (struct target_ops *target)
4213 debug_target.to_files_info (target);
4215 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
4219 debug_to_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
4220 struct bp_target_info *bp_tgt)
4224 retval = debug_target.to_insert_breakpoint (&debug_target, gdbarch, bp_tgt);
4226 fprintf_unfiltered (gdb_stdlog,
4227 "target_insert_breakpoint (%s, xxx) = %ld\n",
4228 core_addr_to_string (bp_tgt->placed_address),
4229 (unsigned long) retval);
4234 debug_to_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
4235 struct bp_target_info *bp_tgt)
4239 retval = debug_target.to_remove_breakpoint (&debug_target, gdbarch, bp_tgt);
4241 fprintf_unfiltered (gdb_stdlog,
4242 "target_remove_breakpoint (%s, xxx) = %ld\n",
4243 core_addr_to_string (bp_tgt->placed_address),
4244 (unsigned long) retval);
4249 debug_to_can_use_hw_breakpoint (struct target_ops *self,
4250 int type, int cnt, int from_tty)
4254 retval = debug_target.to_can_use_hw_breakpoint (&debug_target,
4255 type, cnt, from_tty);
4257 fprintf_unfiltered (gdb_stdlog,
4258 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4259 (unsigned long) type,
4260 (unsigned long) cnt,
4261 (unsigned long) from_tty,
4262 (unsigned long) retval);
4267 debug_to_region_ok_for_hw_watchpoint (struct target_ops *self,
4268 CORE_ADDR addr, int len)
4272 retval = debug_target.to_region_ok_for_hw_watchpoint (&debug_target,
4275 fprintf_unfiltered (gdb_stdlog,
4276 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4277 core_addr_to_string (addr), (unsigned long) len,
4278 core_addr_to_string (retval));
4283 debug_to_can_accel_watchpoint_condition (struct target_ops *self,
4284 CORE_ADDR addr, int len, int rw,
4285 struct expression *cond)
4289 retval = debug_target.to_can_accel_watchpoint_condition (&debug_target,
4293 fprintf_unfiltered (gdb_stdlog,
4294 "target_can_accel_watchpoint_condition "
4295 "(%s, %d, %d, %s) = %ld\n",
4296 core_addr_to_string (addr), len, rw,
4297 host_address_to_string (cond), (unsigned long) retval);
4302 debug_to_stopped_by_watchpoint (struct target_ops *ops)
4306 retval = debug_target.to_stopped_by_watchpoint (&debug_target);
4308 fprintf_unfiltered (gdb_stdlog,
4309 "target_stopped_by_watchpoint () = %ld\n",
4310 (unsigned long) retval);
4315 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
4319 retval = debug_target.to_stopped_data_address (target, addr);
4321 fprintf_unfiltered (gdb_stdlog,
4322 "target_stopped_data_address ([%s]) = %ld\n",
4323 core_addr_to_string (*addr),
4324 (unsigned long)retval);
4329 debug_to_watchpoint_addr_within_range (struct target_ops *target,
4331 CORE_ADDR start, int length)
4335 retval = debug_target.to_watchpoint_addr_within_range (target, addr,
4338 fprintf_filtered (gdb_stdlog,
4339 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4340 core_addr_to_string (addr), core_addr_to_string (start),
4346 debug_to_insert_hw_breakpoint (struct target_ops *self,
4347 struct gdbarch *gdbarch,
4348 struct bp_target_info *bp_tgt)
4352 retval = debug_target.to_insert_hw_breakpoint (&debug_target,
4355 fprintf_unfiltered (gdb_stdlog,
4356 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4357 core_addr_to_string (bp_tgt->placed_address),
4358 (unsigned long) retval);
4363 debug_to_remove_hw_breakpoint (struct target_ops *self,
4364 struct gdbarch *gdbarch,
4365 struct bp_target_info *bp_tgt)
4369 retval = debug_target.to_remove_hw_breakpoint (&debug_target,
4372 fprintf_unfiltered (gdb_stdlog,
4373 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4374 core_addr_to_string (bp_tgt->placed_address),
4375 (unsigned long) retval);
4380 debug_to_insert_watchpoint (struct target_ops *self,
4381 CORE_ADDR addr, int len, int type,
4382 struct expression *cond)
4386 retval = debug_target.to_insert_watchpoint (&debug_target,
4387 addr, len, type, cond);
4389 fprintf_unfiltered (gdb_stdlog,
4390 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4391 core_addr_to_string (addr), len, type,
4392 host_address_to_string (cond), (unsigned long) retval);
4397 debug_to_remove_watchpoint (struct target_ops *self,
4398 CORE_ADDR addr, int len, int type,
4399 struct expression *cond)
4403 retval = debug_target.to_remove_watchpoint (&debug_target,
4404 addr, len, type, cond);
4406 fprintf_unfiltered (gdb_stdlog,
4407 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4408 core_addr_to_string (addr), len, type,
4409 host_address_to_string (cond), (unsigned long) retval);
4414 debug_to_terminal_init (struct target_ops *self)
4416 debug_target.to_terminal_init (&debug_target);
4418 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
4422 debug_to_terminal_inferior (struct target_ops *self)
4424 debug_target.to_terminal_inferior (&debug_target);
4426 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
4430 debug_to_terminal_ours_for_output (struct target_ops *self)
4432 debug_target.to_terminal_ours_for_output (&debug_target);
4434 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
4438 debug_to_terminal_ours (struct target_ops *self)
4440 debug_target.to_terminal_ours (&debug_target);
4442 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
4446 debug_to_terminal_save_ours (struct target_ops *self)
4448 debug_target.to_terminal_save_ours (&debug_target);
4450 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
4454 debug_to_terminal_info (struct target_ops *self,
4455 const char *arg, int from_tty)
4457 debug_target.to_terminal_info (&debug_target, arg, from_tty);
4459 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
4464 debug_to_load (struct target_ops *self, char *args, int from_tty)
4466 debug_target.to_load (&debug_target, args, from_tty);
4468 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
4472 debug_to_post_startup_inferior (struct target_ops *self, ptid_t ptid)
4474 debug_target.to_post_startup_inferior (&debug_target, ptid);
4476 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
4477 ptid_get_pid (ptid));
4481 debug_to_insert_fork_catchpoint (struct target_ops *self, int pid)
4485 retval = debug_target.to_insert_fork_catchpoint (&debug_target, pid);
4487 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
4494 debug_to_remove_fork_catchpoint (struct target_ops *self, int pid)
4498 retval = debug_target.to_remove_fork_catchpoint (&debug_target, pid);
4500 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
4507 debug_to_insert_vfork_catchpoint (struct target_ops *self, int pid)
4511 retval = debug_target.to_insert_vfork_catchpoint (&debug_target, pid);
4513 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
4520 debug_to_remove_vfork_catchpoint (struct target_ops *self, int pid)
4524 retval = debug_target.to_remove_vfork_catchpoint (&debug_target, pid);
4526 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
4533 debug_to_insert_exec_catchpoint (struct target_ops *self, int pid)
4537 retval = debug_target.to_insert_exec_catchpoint (&debug_target, pid);
4539 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
4546 debug_to_remove_exec_catchpoint (struct target_ops *self, int pid)
4550 retval = debug_target.to_remove_exec_catchpoint (&debug_target, pid);
4552 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
4559 debug_to_has_exited (struct target_ops *self,
4560 int pid, int wait_status, int *exit_status)
4564 has_exited = debug_target.to_has_exited (&debug_target,
4565 pid, wait_status, exit_status);
4567 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
4568 pid, wait_status, *exit_status, has_exited);
4574 debug_to_can_run (struct target_ops *self)
4578 retval = debug_target.to_can_run (&debug_target);
4580 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
4585 static struct gdbarch *
4586 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
4588 struct gdbarch *retval;
4590 retval = debug_target.to_thread_architecture (ops, ptid);
4592 fprintf_unfiltered (gdb_stdlog,
4593 "target_thread_architecture (%s) = %s [%s]\n",
4594 target_pid_to_str (ptid),
4595 host_address_to_string (retval),
4596 gdbarch_bfd_arch_info (retval)->printable_name);
4601 debug_to_stop (struct target_ops *self, ptid_t ptid)
4603 debug_target.to_stop (&debug_target, ptid);
4605 fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
4606 target_pid_to_str (ptid));
4610 debug_to_rcmd (struct target_ops *self, char *command,
4611 struct ui_file *outbuf)
4613 debug_target.to_rcmd (&debug_target, command, outbuf);
4614 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
4618 debug_to_pid_to_exec_file (struct target_ops *self, int pid)
4622 exec_file = debug_target.to_pid_to_exec_file (&debug_target, pid);
4624 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
4631 setup_target_debug (void)
4633 memcpy (&debug_target, ¤t_target, sizeof debug_target);
4635 current_target.to_open = debug_to_open;
4636 current_target.to_post_attach = debug_to_post_attach;
4637 current_target.to_prepare_to_store = debug_to_prepare_to_store;
4638 current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
4639 current_target.to_files_info = debug_to_files_info;
4640 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
4641 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
4642 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
4643 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
4644 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
4645 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
4646 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
4647 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
4648 current_target.to_stopped_data_address = debug_to_stopped_data_address;
4649 current_target.to_watchpoint_addr_within_range
4650 = debug_to_watchpoint_addr_within_range;
4651 current_target.to_region_ok_for_hw_watchpoint
4652 = debug_to_region_ok_for_hw_watchpoint;
4653 current_target.to_can_accel_watchpoint_condition
4654 = debug_to_can_accel_watchpoint_condition;
4655 current_target.to_terminal_init = debug_to_terminal_init;
4656 current_target.to_terminal_inferior = debug_to_terminal_inferior;
4657 current_target.to_terminal_ours_for_output
4658 = debug_to_terminal_ours_for_output;
4659 current_target.to_terminal_ours = debug_to_terminal_ours;
4660 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
4661 current_target.to_terminal_info = debug_to_terminal_info;
4662 current_target.to_load = debug_to_load;
4663 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
4664 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
4665 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
4666 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
4667 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
4668 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
4669 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
4670 current_target.to_has_exited = debug_to_has_exited;
4671 current_target.to_can_run = debug_to_can_run;
4672 current_target.to_stop = debug_to_stop;
4673 current_target.to_rcmd = debug_to_rcmd;
4674 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
4675 current_target.to_thread_architecture = debug_to_thread_architecture;
4679 static char targ_desc[] =
4680 "Names of targets and files being debugged.\nShows the entire \
4681 stack of targets currently in use (including the exec-file,\n\
4682 core-file, and process, if any), as well as the symbol file name.";
4685 default_rcmd (struct target_ops *self, char *command, struct ui_file *output)
4687 error (_("\"monitor\" command not supported by this target."));
4691 do_monitor_command (char *cmd,
4694 target_rcmd (cmd, gdb_stdtarg);
4697 /* Print the name of each layers of our target stack. */
4700 maintenance_print_target_stack (char *cmd, int from_tty)
4702 struct target_ops *t;
4704 printf_filtered (_("The current target stack is:\n"));
4706 for (t = target_stack; t != NULL; t = t->beneath)
4708 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
4712 /* Controls if async mode is permitted. */
4713 int target_async_permitted = 0;
4715 /* The set command writes to this variable. If the inferior is
4716 executing, target_async_permitted is *not* updated. */
4717 static int target_async_permitted_1 = 0;
4720 set_target_async_command (char *args, int from_tty,
4721 struct cmd_list_element *c)
4723 if (have_live_inferiors ())
4725 target_async_permitted_1 = target_async_permitted;
4726 error (_("Cannot change this setting while the inferior is running."));
4729 target_async_permitted = target_async_permitted_1;
4733 show_target_async_command (struct ui_file *file, int from_tty,
4734 struct cmd_list_element *c,
4737 fprintf_filtered (file,
4738 _("Controlling the inferior in "
4739 "asynchronous mode is %s.\n"), value);
4742 /* Temporary copies of permission settings. */
4744 static int may_write_registers_1 = 1;
4745 static int may_write_memory_1 = 1;
4746 static int may_insert_breakpoints_1 = 1;
4747 static int may_insert_tracepoints_1 = 1;
4748 static int may_insert_fast_tracepoints_1 = 1;
4749 static int may_stop_1 = 1;
4751 /* Make the user-set values match the real values again. */
4754 update_target_permissions (void)
4756 may_write_registers_1 = may_write_registers;
4757 may_write_memory_1 = may_write_memory;
4758 may_insert_breakpoints_1 = may_insert_breakpoints;
4759 may_insert_tracepoints_1 = may_insert_tracepoints;
4760 may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
4761 may_stop_1 = may_stop;
4764 /* The one function handles (most of) the permission flags in the same
4768 set_target_permissions (char *args, int from_tty,
4769 struct cmd_list_element *c)
4771 if (target_has_execution)
4773 update_target_permissions ();
4774 error (_("Cannot change this setting while the inferior is running."));
4777 /* Make the real values match the user-changed values. */
4778 may_write_registers = may_write_registers_1;
4779 may_insert_breakpoints = may_insert_breakpoints_1;
4780 may_insert_tracepoints = may_insert_tracepoints_1;
4781 may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
4782 may_stop = may_stop_1;
4783 update_observer_mode ();
4786 /* Set memory write permission independently of observer mode. */
4789 set_write_memory_permission (char *args, int from_tty,
4790 struct cmd_list_element *c)
4792 /* Make the real values match the user-changed values. */
4793 may_write_memory = may_write_memory_1;
4794 update_observer_mode ();
4799 initialize_targets (void)
4801 init_dummy_target ();
4802 push_target (&dummy_target);
4804 add_info ("target", target_info, targ_desc);
4805 add_info ("files", target_info, targ_desc);
4807 add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
4808 Set target debugging."), _("\
4809 Show target debugging."), _("\
4810 When non-zero, target debugging is enabled. Higher numbers are more\n\
4811 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
4815 &setdebuglist, &showdebuglist);
4817 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
4818 &trust_readonly, _("\
4819 Set mode for reading from readonly sections."), _("\
4820 Show mode for reading from readonly sections."), _("\
4821 When this mode is on, memory reads from readonly sections (such as .text)\n\
4822 will be read from the object file instead of from the target. This will\n\
4823 result in significant performance improvement for remote targets."),
4825 show_trust_readonly,
4826 &setlist, &showlist);
4828 add_com ("monitor", class_obscure, do_monitor_command,
4829 _("Send a command to the remote monitor (remote targets only)."));
4831 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
4832 _("Print the name of each layer of the internal target stack."),
4833 &maintenanceprintlist);
4835 add_setshow_boolean_cmd ("target-async", no_class,
4836 &target_async_permitted_1, _("\
4837 Set whether gdb controls the inferior in asynchronous mode."), _("\
4838 Show whether gdb controls the inferior in asynchronous mode."), _("\
4839 Tells gdb whether to control the inferior in asynchronous mode."),
4840 set_target_async_command,
4841 show_target_async_command,
4845 add_setshow_boolean_cmd ("may-write-registers", class_support,
4846 &may_write_registers_1, _("\
4847 Set permission to write into registers."), _("\
4848 Show permission to write into registers."), _("\
4849 When this permission is on, GDB may write into the target's registers.\n\
4850 Otherwise, any sort of write attempt will result in an error."),
4851 set_target_permissions, NULL,
4852 &setlist, &showlist);
4854 add_setshow_boolean_cmd ("may-write-memory", class_support,
4855 &may_write_memory_1, _("\
4856 Set permission to write into target memory."), _("\
4857 Show permission to write into target memory."), _("\
4858 When this permission is on, GDB may write into the target's memory.\n\
4859 Otherwise, any sort of write attempt will result in an error."),
4860 set_write_memory_permission, NULL,
4861 &setlist, &showlist);
4863 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
4864 &may_insert_breakpoints_1, _("\
4865 Set permission to insert breakpoints in the target."), _("\
4866 Show permission to insert breakpoints in the target."), _("\
4867 When this permission is on, GDB may insert breakpoints in the program.\n\
4868 Otherwise, any sort of insertion attempt will result in an error."),
4869 set_target_permissions, NULL,
4870 &setlist, &showlist);
4872 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
4873 &may_insert_tracepoints_1, _("\
4874 Set permission to insert tracepoints in the target."), _("\
4875 Show permission to insert tracepoints in the target."), _("\
4876 When this permission is on, GDB may insert tracepoints in the program.\n\
4877 Otherwise, any sort of insertion attempt will result in an error."),
4878 set_target_permissions, NULL,
4879 &setlist, &showlist);
4881 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
4882 &may_insert_fast_tracepoints_1, _("\
4883 Set permission to insert fast tracepoints in the target."), _("\
4884 Show permission to insert fast tracepoints in the target."), _("\
4885 When this permission is on, GDB may insert fast tracepoints.\n\
4886 Otherwise, any sort of insertion attempt will result in an error."),
4887 set_target_permissions, NULL,
4888 &setlist, &showlist);
4890 add_setshow_boolean_cmd ("may-interrupt", class_support,
4892 Set permission to interrupt or signal the target."), _("\
4893 Show permission to interrupt or signal the target."), _("\
4894 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4895 Otherwise, any attempt to interrupt or stop will be ignored."),
4896 set_target_permissions, NULL,
4897 &setlist, &showlist);