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)
1769 struct target_ops
*t
;
1771 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1772 if (t
->to_flash_done
!= NULL
)
1775 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1776 t
->to_flash_done (t
);
1784 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1785 struct cmd_list_element
*c
, const char *value
)
1787 fprintf_filtered (file
,
1788 _("Mode for reading from readonly sections is %s.\n"),
1792 /* More generic transfers. */
1794 static enum target_xfer_status
1795 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1796 const char *annex
, gdb_byte
*readbuf
,
1797 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
1798 ULONGEST
*xfered_len
)
1800 if (object
== TARGET_OBJECT_MEMORY
1801 && ops
->deprecated_xfer_memory
!= NULL
)
1802 /* If available, fall back to the target's
1803 "deprecated_xfer_memory" method. */
1808 if (writebuf
!= NULL
)
1810 void *buffer
= xmalloc (len
);
1811 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1813 memcpy (buffer
, writebuf
, len
);
1814 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1815 1/*write*/, NULL
, ops
);
1816 do_cleanups (cleanup
);
1818 if (readbuf
!= NULL
)
1819 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1820 0/*read*/, NULL
, ops
);
1823 *xfered_len
= (ULONGEST
) xfered
;
1824 return TARGET_XFER_E_IO
;
1826 else if (xfered
== 0 && errno
== 0)
1827 /* "deprecated_xfer_memory" uses 0, cross checked against
1828 ERRNO as one indication of an error. */
1829 return TARGET_XFER_EOF
;
1831 return TARGET_XFER_E_IO
;
1835 gdb_assert (ops
->beneath
!= NULL
);
1836 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1837 readbuf
, writebuf
, offset
, len
,
1842 /* Target vector read/write partial wrapper functions. */
1844 static enum target_xfer_status
1845 target_read_partial (struct target_ops
*ops
,
1846 enum target_object object
,
1847 const char *annex
, gdb_byte
*buf
,
1848 ULONGEST offset
, ULONGEST len
,
1849 ULONGEST
*xfered_len
)
1851 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
,
1855 static enum target_xfer_status
1856 target_write_partial (struct target_ops
*ops
,
1857 enum target_object object
,
1858 const char *annex
, const gdb_byte
*buf
,
1859 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
)
1861 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
,
1865 /* Wrappers to perform the full transfer. */
1867 /* For docs on target_read see target.h. */
1870 target_read (struct target_ops
*ops
,
1871 enum target_object object
,
1872 const char *annex
, gdb_byte
*buf
,
1873 ULONGEST offset
, LONGEST len
)
1877 while (xfered
< len
)
1879 ULONGEST xfered_len
;
1880 enum target_xfer_status status
;
1882 status
= target_read_partial (ops
, object
, annex
,
1883 (gdb_byte
*) buf
+ xfered
,
1884 offset
+ xfered
, len
- xfered
,
1887 /* Call an observer, notifying them of the xfer progress? */
1888 if (status
== TARGET_XFER_EOF
)
1890 else if (status
== TARGET_XFER_OK
)
1892 xfered
+= xfered_len
;
1902 /* Assuming that the entire [begin, end) range of memory cannot be
1903 read, try to read whatever subrange is possible to read.
1905 The function returns, in RESULT, either zero or one memory block.
1906 If there's a readable subrange at the beginning, it is completely
1907 read and returned. Any further readable subrange will not be read.
1908 Otherwise, if there's a readable subrange at the end, it will be
1909 completely read and returned. Any readable subranges before it
1910 (obviously, not starting at the beginning), will be ignored. In
1911 other cases -- either no readable subrange, or readable subrange(s)
1912 that is neither at the beginning, or end, nothing is returned.
1914 The purpose of this function is to handle a read across a boundary
1915 of accessible memory in a case when memory map is not available.
1916 The above restrictions are fine for this case, but will give
1917 incorrect results if the memory is 'patchy'. However, supporting
1918 'patchy' memory would require trying to read every single byte,
1919 and it seems unacceptable solution. Explicit memory map is
1920 recommended for this case -- and target_read_memory_robust will
1921 take care of reading multiple ranges then. */
1924 read_whatever_is_readable (struct target_ops
*ops
,
1925 ULONGEST begin
, ULONGEST end
,
1926 VEC(memory_read_result_s
) **result
)
1928 gdb_byte
*buf
= xmalloc (end
- begin
);
1929 ULONGEST current_begin
= begin
;
1930 ULONGEST current_end
= end
;
1932 memory_read_result_s r
;
1933 ULONGEST xfered_len
;
1935 /* If we previously failed to read 1 byte, nothing can be done here. */
1936 if (end
- begin
<= 1)
1942 /* Check that either first or the last byte is readable, and give up
1943 if not. This heuristic is meant to permit reading accessible memory
1944 at the boundary of accessible region. */
1945 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1946 buf
, begin
, 1, &xfered_len
) == TARGET_XFER_OK
)
1951 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1952 buf
+ (end
-begin
) - 1, end
- 1, 1,
1953 &xfered_len
) == TARGET_XFER_OK
)
1964 /* Loop invariant is that the [current_begin, current_end) was previously
1965 found to be not readable as a whole.
1967 Note loop condition -- if the range has 1 byte, we can't divide the range
1968 so there's no point trying further. */
1969 while (current_end
- current_begin
> 1)
1971 ULONGEST first_half_begin
, first_half_end
;
1972 ULONGEST second_half_begin
, second_half_end
;
1974 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
1978 first_half_begin
= current_begin
;
1979 first_half_end
= middle
;
1980 second_half_begin
= middle
;
1981 second_half_end
= current_end
;
1985 first_half_begin
= middle
;
1986 first_half_end
= current_end
;
1987 second_half_begin
= current_begin
;
1988 second_half_end
= middle
;
1991 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1992 buf
+ (first_half_begin
- begin
),
1994 first_half_end
- first_half_begin
);
1996 if (xfer
== first_half_end
- first_half_begin
)
1998 /* This half reads up fine. So, the error must be in the
2000 current_begin
= second_half_begin
;
2001 current_end
= second_half_end
;
2005 /* This half is not readable. Because we've tried one byte, we
2006 know some part of this half if actually redable. Go to the next
2007 iteration to divide again and try to read.
2009 We don't handle the other half, because this function only tries
2010 to read a single readable subrange. */
2011 current_begin
= first_half_begin
;
2012 current_end
= first_half_end
;
2018 /* The [begin, current_begin) range has been read. */
2020 r
.end
= current_begin
;
2025 /* The [current_end, end) range has been read. */
2026 LONGEST rlen
= end
- current_end
;
2028 r
.data
= xmalloc (rlen
);
2029 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2030 r
.begin
= current_end
;
2034 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2038 free_memory_read_result_vector (void *x
)
2040 VEC(memory_read_result_s
) *v
= x
;
2041 memory_read_result_s
*current
;
2044 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2046 xfree (current
->data
);
2048 VEC_free (memory_read_result_s
, v
);
2051 VEC(memory_read_result_s
) *
2052 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2054 VEC(memory_read_result_s
) *result
= 0;
2057 while (xfered
< len
)
2059 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2062 /* If there is no explicit region, a fake one should be created. */
2063 gdb_assert (region
);
2065 if (region
->hi
== 0)
2066 rlen
= len
- xfered
;
2068 rlen
= region
->hi
- offset
;
2070 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2072 /* Cannot read this region. Note that we can end up here only
2073 if the region is explicitly marked inaccessible, or
2074 'inaccessible-by-default' is in effect. */
2079 LONGEST to_read
= min (len
- xfered
, rlen
);
2080 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2082 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2083 (gdb_byte
*) buffer
,
2084 offset
+ xfered
, to_read
);
2085 /* Call an observer, notifying them of the xfer progress? */
2088 /* Got an error reading full chunk. See if maybe we can read
2091 read_whatever_is_readable (ops
, offset
+ xfered
,
2092 offset
+ xfered
+ to_read
, &result
);
2097 struct memory_read_result r
;
2099 r
.begin
= offset
+ xfered
;
2100 r
.end
= r
.begin
+ xfer
;
2101 VEC_safe_push (memory_read_result_s
, result
, &r
);
2111 /* An alternative to target_write with progress callbacks. */
2114 target_write_with_progress (struct target_ops
*ops
,
2115 enum target_object object
,
2116 const char *annex
, const gdb_byte
*buf
,
2117 ULONGEST offset
, LONGEST len
,
2118 void (*progress
) (ULONGEST
, void *), void *baton
)
2122 /* Give the progress callback a chance to set up. */
2124 (*progress
) (0, baton
);
2126 while (xfered
< len
)
2128 ULONGEST xfered_len
;
2129 enum target_xfer_status status
;
2131 status
= target_write_partial (ops
, object
, annex
,
2132 (gdb_byte
*) buf
+ xfered
,
2133 offset
+ xfered
, len
- xfered
,
2136 if (status
== TARGET_XFER_EOF
)
2138 if (TARGET_XFER_STATUS_ERROR_P (status
))
2141 gdb_assert (status
== TARGET_XFER_OK
);
2143 (*progress
) (xfered_len
, baton
);
2145 xfered
+= xfered_len
;
2151 /* For docs on target_write see target.h. */
2154 target_write (struct target_ops
*ops
,
2155 enum target_object object
,
2156 const char *annex
, const gdb_byte
*buf
,
2157 ULONGEST offset
, LONGEST len
)
2159 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2163 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2164 the size of the transferred data. PADDING additional bytes are
2165 available in *BUF_P. This is a helper function for
2166 target_read_alloc; see the declaration of that function for more
2170 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2171 const char *annex
, gdb_byte
**buf_p
, int padding
)
2173 size_t buf_alloc
, buf_pos
;
2176 /* This function does not have a length parameter; it reads the
2177 entire OBJECT). Also, it doesn't support objects fetched partly
2178 from one target and partly from another (in a different stratum,
2179 e.g. a core file and an executable). Both reasons make it
2180 unsuitable for reading memory. */
2181 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2183 /* Start by reading up to 4K at a time. The target will throttle
2184 this number down if necessary. */
2186 buf
= xmalloc (buf_alloc
);
2190 ULONGEST xfered_len
;
2191 enum target_xfer_status status
;
2193 status
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2194 buf_pos
, buf_alloc
- buf_pos
- padding
,
2197 if (status
== TARGET_XFER_EOF
)
2199 /* Read all there was. */
2206 else if (status
!= TARGET_XFER_OK
)
2208 /* An error occurred. */
2210 return TARGET_XFER_E_IO
;
2213 buf_pos
+= xfered_len
;
2215 /* If the buffer is filling up, expand it. */
2216 if (buf_alloc
< buf_pos
* 2)
2219 buf
= xrealloc (buf
, buf_alloc
);
2226 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2227 the size of the transferred data. See the declaration in "target.h"
2228 function for more information about the return value. */
2231 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2232 const char *annex
, gdb_byte
**buf_p
)
2234 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2237 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2238 returned as a string, allocated using xmalloc. If an error occurs
2239 or the transfer is unsupported, NULL is returned. Empty objects
2240 are returned as allocated but empty strings. A warning is issued
2241 if the result contains any embedded NUL bytes. */
2244 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2249 LONGEST i
, transferred
;
2251 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2252 bufstr
= (char *) buffer
;
2254 if (transferred
< 0)
2257 if (transferred
== 0)
2258 return xstrdup ("");
2260 bufstr
[transferred
] = 0;
2262 /* Check for embedded NUL bytes; but allow trailing NULs. */
2263 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2266 warning (_("target object %d, annex %s, "
2267 "contained unexpected null characters"),
2268 (int) object
, annex
? annex
: "(none)");
2275 /* Memory transfer methods. */
2278 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2281 /* This method is used to read from an alternate, non-current
2282 target. This read must bypass the overlay support (as symbols
2283 don't match this target), and GDB's internal cache (wrong cache
2284 for this target). */
2285 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2287 memory_error (TARGET_XFER_E_IO
, addr
);
2291 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2292 int len
, enum bfd_endian byte_order
)
2294 gdb_byte buf
[sizeof (ULONGEST
)];
2296 gdb_assert (len
<= sizeof (buf
));
2297 get_target_memory (ops
, addr
, buf
, len
);
2298 return extract_unsigned_integer (buf
, len
, byte_order
);
2304 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2305 struct bp_target_info
*bp_tgt
)
2307 if (!may_insert_breakpoints
)
2309 warning (_("May not insert breakpoints"));
2313 return current_target
.to_insert_breakpoint (¤t_target
,
2320 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2321 struct bp_target_info
*bp_tgt
)
2323 /* This is kind of a weird case to handle, but the permission might
2324 have been changed after breakpoints were inserted - in which case
2325 we should just take the user literally and assume that any
2326 breakpoints should be left in place. */
2327 if (!may_insert_breakpoints
)
2329 warning (_("May not remove breakpoints"));
2333 return current_target
.to_remove_breakpoint (¤t_target
,
2338 target_info (char *args
, int from_tty
)
2340 struct target_ops
*t
;
2341 int has_all_mem
= 0;
2343 if (symfile_objfile
!= NULL
)
2344 printf_unfiltered (_("Symbols from \"%s\".\n"),
2345 objfile_name (symfile_objfile
));
2347 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2349 if (!(*t
->to_has_memory
) (t
))
2352 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2355 printf_unfiltered (_("\tWhile running this, "
2356 "GDB does not access memory from...\n"));
2357 printf_unfiltered ("%s:\n", t
->to_longname
);
2358 (t
->to_files_info
) (t
);
2359 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2363 /* This function is called before any new inferior is created, e.g.
2364 by running a program, attaching, or connecting to a target.
2365 It cleans up any state from previous invocations which might
2366 change between runs. This is a subset of what target_preopen
2367 resets (things which might change between targets). */
2370 target_pre_inferior (int from_tty
)
2372 /* Clear out solib state. Otherwise the solib state of the previous
2373 inferior might have survived and is entirely wrong for the new
2374 target. This has been observed on GNU/Linux using glibc 2.3. How
2386 Cannot access memory at address 0xdeadbeef
2389 /* In some OSs, the shared library list is the same/global/shared
2390 across inferiors. If code is shared between processes, so are
2391 memory regions and features. */
2392 if (!gdbarch_has_global_solist (target_gdbarch ()))
2394 no_shared_libraries (NULL
, from_tty
);
2396 invalidate_target_mem_regions ();
2398 target_clear_description ();
2401 agent_capability_invalidate ();
2404 /* Callback for iterate_over_inferiors. Gets rid of the given
2408 dispose_inferior (struct inferior
*inf
, void *args
)
2410 struct thread_info
*thread
;
2412 thread
= any_thread_of_process (inf
->pid
);
2415 switch_to_thread (thread
->ptid
);
2417 /* Core inferiors actually should be detached, not killed. */
2418 if (target_has_execution
)
2421 target_detach (NULL
, 0);
2427 /* This is to be called by the open routine before it does
2431 target_preopen (int from_tty
)
2435 if (have_inferiors ())
2438 || !have_live_inferiors ()
2439 || query (_("A program is being debugged already. Kill it? ")))
2440 iterate_over_inferiors (dispose_inferior
, NULL
);
2442 error (_("Program not killed."));
2445 /* Calling target_kill may remove the target from the stack. But if
2446 it doesn't (which seems like a win for UDI), remove it now. */
2447 /* Leave the exec target, though. The user may be switching from a
2448 live process to a core of the same program. */
2449 pop_all_targets_above (file_stratum
);
2451 target_pre_inferior (from_tty
);
2454 /* Detach a target after doing deferred register stores. */
2457 target_detach (const char *args
, int from_tty
)
2459 struct target_ops
* t
;
2461 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2462 /* Don't remove global breakpoints here. They're removed on
2463 disconnection from the target. */
2466 /* If we're in breakpoints-always-inserted mode, have to remove
2467 them before detaching. */
2468 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2470 prepare_for_detach ();
2472 current_target
.to_detach (¤t_target
, args
, from_tty
);
2474 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2479 target_disconnect (char *args
, int from_tty
)
2481 struct target_ops
*t
;
2483 /* If we're in breakpoints-always-inserted mode or if breakpoints
2484 are global across processes, we have to remove them before
2486 remove_breakpoints ();
2488 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2489 if (t
->to_disconnect
!= NULL
)
2492 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2494 t
->to_disconnect (t
, args
, from_tty
);
2502 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2504 struct target_ops
*t
;
2505 ptid_t retval
= (current_target
.to_wait
) (¤t_target
, ptid
,
2510 char *status_string
;
2511 char *options_string
;
2513 status_string
= target_waitstatus_to_string (status
);
2514 options_string
= target_options_to_string (options
);
2515 fprintf_unfiltered (gdb_stdlog
,
2516 "target_wait (%d, status, options={%s})"
2518 ptid_get_pid (ptid
), options_string
,
2519 ptid_get_pid (retval
), status_string
);
2520 xfree (status_string
);
2521 xfree (options_string
);
2528 target_pid_to_str (ptid_t ptid
)
2530 return (*current_target
.to_pid_to_str
) (¤t_target
, ptid
);
2534 target_thread_name (struct thread_info
*info
)
2536 return current_target
.to_thread_name (¤t_target
, info
);
2540 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2542 struct target_ops
*t
;
2544 target_dcache_invalidate ();
2546 current_target
.to_resume (¤t_target
, ptid
, step
, signal
);
2548 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2549 ptid_get_pid (ptid
),
2550 step
? "step" : "continue",
2551 gdb_signal_to_name (signal
));
2553 registers_changed_ptid (ptid
);
2554 set_executing (ptid
, 1);
2555 set_running (ptid
, 1);
2556 clear_inline_frame_state (ptid
);
2560 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2566 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2569 for (i
= 0; i
< numsigs
; i
++)
2570 if (pass_signals
[i
])
2571 fprintf_unfiltered (gdb_stdlog
, " %s",
2572 gdb_signal_to_name (i
));
2574 fprintf_unfiltered (gdb_stdlog
, " })\n");
2577 (*current_target
.to_pass_signals
) (¤t_target
, numsigs
, pass_signals
);
2581 target_program_signals (int numsigs
, unsigned char *program_signals
)
2587 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2590 for (i
= 0; i
< numsigs
; i
++)
2591 if (program_signals
[i
])
2592 fprintf_unfiltered (gdb_stdlog
, " %s",
2593 gdb_signal_to_name (i
));
2595 fprintf_unfiltered (gdb_stdlog
, " })\n");
2598 (*current_target
.to_program_signals
) (¤t_target
,
2599 numsigs
, program_signals
);
2603 default_follow_fork (struct target_ops
*self
, int follow_child
,
2606 /* Some target returned a fork event, but did not know how to follow it. */
2607 internal_error (__FILE__
, __LINE__
,
2608 _("could not find a target to follow fork"));
2611 /* Look through the list of possible targets for a target that can
2615 target_follow_fork (int follow_child
, int detach_fork
)
2617 int retval
= current_target
.to_follow_fork (¤t_target
,
2618 follow_child
, detach_fork
);
2621 fprintf_unfiltered (gdb_stdlog
,
2622 "target_follow_fork (%d, %d) = %d\n",
2623 follow_child
, detach_fork
, retval
);
2628 default_mourn_inferior (struct target_ops
*self
)
2630 internal_error (__FILE__
, __LINE__
,
2631 _("could not find a target to follow mourn inferior"));
2635 target_mourn_inferior (void)
2637 current_target
.to_mourn_inferior (¤t_target
);
2639 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2641 /* We no longer need to keep handles on any of the object files.
2642 Make sure to release them to avoid unnecessarily locking any
2643 of them while we're not actually debugging. */
2644 bfd_cache_close_all ();
2647 /* Look for a target which can describe architectural features, starting
2648 from TARGET. If we find one, return its description. */
2650 const struct target_desc
*
2651 target_read_description (struct target_ops
*target
)
2653 struct target_ops
*t
;
2655 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2656 if (t
->to_read_description
!= NULL
)
2658 const struct target_desc
*tdesc
;
2660 tdesc
= t
->to_read_description (t
);
2668 /* The default implementation of to_search_memory.
2669 This implements a basic search of memory, reading target memory and
2670 performing the search here (as opposed to performing the search in on the
2671 target side with, for example, gdbserver). */
2674 simple_search_memory (struct target_ops
*ops
,
2675 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2676 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2677 CORE_ADDR
*found_addrp
)
2679 /* NOTE: also defined in find.c testcase. */
2680 #define SEARCH_CHUNK_SIZE 16000
2681 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2682 /* Buffer to hold memory contents for searching. */
2683 gdb_byte
*search_buf
;
2684 unsigned search_buf_size
;
2685 struct cleanup
*old_cleanups
;
2687 search_buf_size
= chunk_size
+ pattern_len
- 1;
2689 /* No point in trying to allocate a buffer larger than the search space. */
2690 if (search_space_len
< search_buf_size
)
2691 search_buf_size
= search_space_len
;
2693 search_buf
= malloc (search_buf_size
);
2694 if (search_buf
== NULL
)
2695 error (_("Unable to allocate memory to perform the search."));
2696 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2698 /* Prime the search buffer. */
2700 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2701 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2703 warning (_("Unable to access %s bytes of target "
2704 "memory at %s, halting search."),
2705 pulongest (search_buf_size
), hex_string (start_addr
));
2706 do_cleanups (old_cleanups
);
2710 /* Perform the search.
2712 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2713 When we've scanned N bytes we copy the trailing bytes to the start and
2714 read in another N bytes. */
2716 while (search_space_len
>= pattern_len
)
2718 gdb_byte
*found_ptr
;
2719 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2721 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2722 pattern
, pattern_len
);
2724 if (found_ptr
!= NULL
)
2726 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2728 *found_addrp
= found_addr
;
2729 do_cleanups (old_cleanups
);
2733 /* Not found in this chunk, skip to next chunk. */
2735 /* Don't let search_space_len wrap here, it's unsigned. */
2736 if (search_space_len
>= chunk_size
)
2737 search_space_len
-= chunk_size
;
2739 search_space_len
= 0;
2741 if (search_space_len
>= pattern_len
)
2743 unsigned keep_len
= search_buf_size
- chunk_size
;
2744 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2747 /* Copy the trailing part of the previous iteration to the front
2748 of the buffer for the next iteration. */
2749 gdb_assert (keep_len
== pattern_len
- 1);
2750 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2752 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2754 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2755 search_buf
+ keep_len
, read_addr
,
2756 nr_to_read
) != nr_to_read
)
2758 warning (_("Unable to access %s bytes of target "
2759 "memory at %s, halting search."),
2760 plongest (nr_to_read
),
2761 hex_string (read_addr
));
2762 do_cleanups (old_cleanups
);
2766 start_addr
+= chunk_size
;
2772 do_cleanups (old_cleanups
);
2776 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2777 sequence of bytes in PATTERN with length PATTERN_LEN.
2779 The result is 1 if found, 0 if not found, and -1 if there was an error
2780 requiring halting of the search (e.g. memory read error).
2781 If the pattern is found the address is recorded in FOUND_ADDRP. */
2784 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2785 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2786 CORE_ADDR
*found_addrp
)
2788 struct target_ops
*t
;
2791 /* We don't use INHERIT to set current_target.to_search_memory,
2792 so we have to scan the target stack and handle targetdebug
2796 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2797 hex_string (start_addr
));
2799 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2800 if (t
->to_search_memory
!= NULL
)
2805 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2806 pattern
, pattern_len
, found_addrp
);
2810 /* If a special version of to_search_memory isn't available, use the
2812 found
= simple_search_memory (current_target
.beneath
,
2813 start_addr
, search_space_len
,
2814 pattern
, pattern_len
, found_addrp
);
2818 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2823 /* Look through the currently pushed targets. If none of them will
2824 be able to restart the currently running process, issue an error
2828 target_require_runnable (void)
2830 struct target_ops
*t
;
2832 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2834 /* If this target knows how to create a new program, then
2835 assume we will still be able to after killing the current
2836 one. Either killing and mourning will not pop T, or else
2837 find_default_run_target will find it again. */
2838 if (t
->to_create_inferior
!= NULL
)
2841 /* Do not worry about thread_stratum targets that can not
2842 create inferiors. Assume they will be pushed again if
2843 necessary, and continue to the process_stratum. */
2844 if (t
->to_stratum
== thread_stratum
2845 || t
->to_stratum
== arch_stratum
)
2848 error (_("The \"%s\" target does not support \"run\". "
2849 "Try \"help target\" or \"continue\"."),
2853 /* This function is only called if the target is running. In that
2854 case there should have been a process_stratum target and it
2855 should either know how to create inferiors, or not... */
2856 internal_error (__FILE__
, __LINE__
, _("No targets found"));
2859 /* Look through the list of possible targets for a target that can
2860 execute a run or attach command without any other data. This is
2861 used to locate the default process stratum.
2863 If DO_MESG is not NULL, the result is always valid (error() is
2864 called for errors); else, return NULL on error. */
2866 static struct target_ops
*
2867 find_default_run_target (char *do_mesg
)
2869 struct target_ops
**t
;
2870 struct target_ops
*runable
= NULL
;
2875 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2878 if ((*t
)->to_can_run
&& target_can_run (*t
))
2888 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2897 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2899 struct target_ops
*t
;
2901 t
= find_default_run_target ("attach");
2902 (t
->to_attach
) (t
, args
, from_tty
);
2907 find_default_create_inferior (struct target_ops
*ops
,
2908 char *exec_file
, char *allargs
, char **env
,
2911 struct target_ops
*t
;
2913 t
= find_default_run_target ("run");
2914 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2919 find_default_can_async_p (struct target_ops
*ignore
)
2921 struct target_ops
*t
;
2923 /* This may be called before the target is pushed on the stack;
2924 look for the default process stratum. If there's none, gdb isn't
2925 configured with a native debugger, and target remote isn't
2927 t
= find_default_run_target (NULL
);
2928 if (t
&& t
->to_can_async_p
!= delegate_can_async_p
)
2929 return (t
->to_can_async_p
) (t
);
2934 find_default_is_async_p (struct target_ops
*ignore
)
2936 struct target_ops
*t
;
2938 /* This may be called before the target is pushed on the stack;
2939 look for the default process stratum. If there's none, gdb isn't
2940 configured with a native debugger, and target remote isn't
2942 t
= find_default_run_target (NULL
);
2943 if (t
&& t
->to_is_async_p
!= delegate_is_async_p
)
2944 return (t
->to_is_async_p
) (t
);
2949 find_default_supports_non_stop (struct target_ops
*self
)
2951 struct target_ops
*t
;
2953 t
= find_default_run_target (NULL
);
2954 if (t
&& t
->to_supports_non_stop
)
2955 return (t
->to_supports_non_stop
) (t
);
2960 target_supports_non_stop (void)
2962 struct target_ops
*t
;
2964 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2965 if (t
->to_supports_non_stop
)
2966 return t
->to_supports_non_stop (t
);
2971 /* Implement the "info proc" command. */
2974 target_info_proc (char *args
, enum info_proc_what what
)
2976 struct target_ops
*t
;
2978 /* If we're already connected to something that can get us OS
2979 related data, use it. Otherwise, try using the native
2981 if (current_target
.to_stratum
>= process_stratum
)
2982 t
= current_target
.beneath
;
2984 t
= find_default_run_target (NULL
);
2986 for (; t
!= NULL
; t
= t
->beneath
)
2988 if (t
->to_info_proc
!= NULL
)
2990 t
->to_info_proc (t
, args
, what
);
2993 fprintf_unfiltered (gdb_stdlog
,
2994 "target_info_proc (\"%s\", %d)\n", args
, what
);
3004 find_default_supports_disable_randomization (struct target_ops
*self
)
3006 struct target_ops
*t
;
3008 t
= find_default_run_target (NULL
);
3009 if (t
&& t
->to_supports_disable_randomization
)
3010 return (t
->to_supports_disable_randomization
) (t
);
3015 target_supports_disable_randomization (void)
3017 struct target_ops
*t
;
3019 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3020 if (t
->to_supports_disable_randomization
)
3021 return t
->to_supports_disable_randomization (t
);
3027 target_get_osdata (const char *type
)
3029 struct target_ops
*t
;
3031 /* If we're already connected to something that can get us OS
3032 related data, use it. Otherwise, try using the native
3034 if (current_target
.to_stratum
>= process_stratum
)
3035 t
= current_target
.beneath
;
3037 t
= find_default_run_target ("get OS data");
3042 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3045 /* Determine the current address space of thread PTID. */
3047 struct address_space
*
3048 target_thread_address_space (ptid_t ptid
)
3050 struct address_space
*aspace
;
3051 struct inferior
*inf
;
3052 struct target_ops
*t
;
3054 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3056 if (t
->to_thread_address_space
!= NULL
)
3058 aspace
= t
->to_thread_address_space (t
, ptid
);
3059 gdb_assert (aspace
);
3062 fprintf_unfiltered (gdb_stdlog
,
3063 "target_thread_address_space (%s) = %d\n",
3064 target_pid_to_str (ptid
),
3065 address_space_num (aspace
));
3070 /* Fall-back to the "main" address space of the inferior. */
3071 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3073 if (inf
== NULL
|| inf
->aspace
== NULL
)
3074 internal_error (__FILE__
, __LINE__
,
3075 _("Can't determine the current "
3076 "address space of thread %s\n"),
3077 target_pid_to_str (ptid
));
3083 /* Target file operations. */
3085 static struct target_ops
*
3086 default_fileio_target (void)
3088 /* If we're already connected to something that can perform
3089 file I/O, use it. Otherwise, try using the native target. */
3090 if (current_target
.to_stratum
>= process_stratum
)
3091 return current_target
.beneath
;
3093 return find_default_run_target ("file I/O");
3096 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3097 target file descriptor, or -1 if an error occurs (and set
3100 target_fileio_open (const char *filename
, int flags
, int mode
,
3103 struct target_ops
*t
;
3105 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3107 if (t
->to_fileio_open
!= NULL
)
3109 int fd
= t
->to_fileio_open (t
, filename
, flags
, mode
, target_errno
);
3112 fprintf_unfiltered (gdb_stdlog
,
3113 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3114 filename
, flags
, mode
,
3115 fd
, fd
!= -1 ? 0 : *target_errno
);
3120 *target_errno
= FILEIO_ENOSYS
;
3124 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3125 Return the number of bytes written, or -1 if an error occurs
3126 (and set *TARGET_ERRNO). */
3128 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3129 ULONGEST offset
, int *target_errno
)
3131 struct target_ops
*t
;
3133 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3135 if (t
->to_fileio_pwrite
!= NULL
)
3137 int ret
= t
->to_fileio_pwrite (t
, fd
, write_buf
, len
, offset
,
3141 fprintf_unfiltered (gdb_stdlog
,
3142 "target_fileio_pwrite (%d,...,%d,%s) "
3144 fd
, len
, pulongest (offset
),
3145 ret
, ret
!= -1 ? 0 : *target_errno
);
3150 *target_errno
= FILEIO_ENOSYS
;
3154 /* Read up to LEN bytes FD on the target into READ_BUF.
3155 Return the number of bytes read, or -1 if an error occurs
3156 (and set *TARGET_ERRNO). */
3158 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3159 ULONGEST offset
, int *target_errno
)
3161 struct target_ops
*t
;
3163 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3165 if (t
->to_fileio_pread
!= NULL
)
3167 int ret
= t
->to_fileio_pread (t
, fd
, read_buf
, len
, offset
,
3171 fprintf_unfiltered (gdb_stdlog
,
3172 "target_fileio_pread (%d,...,%d,%s) "
3174 fd
, len
, pulongest (offset
),
3175 ret
, ret
!= -1 ? 0 : *target_errno
);
3180 *target_errno
= FILEIO_ENOSYS
;
3184 /* Close FD on the target. Return 0, or -1 if an error occurs
3185 (and set *TARGET_ERRNO). */
3187 target_fileio_close (int fd
, int *target_errno
)
3189 struct target_ops
*t
;
3191 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3193 if (t
->to_fileio_close
!= NULL
)
3195 int ret
= t
->to_fileio_close (t
, fd
, target_errno
);
3198 fprintf_unfiltered (gdb_stdlog
,
3199 "target_fileio_close (%d) = %d (%d)\n",
3200 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3205 *target_errno
= FILEIO_ENOSYS
;
3209 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3210 occurs (and set *TARGET_ERRNO). */
3212 target_fileio_unlink (const char *filename
, int *target_errno
)
3214 struct target_ops
*t
;
3216 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3218 if (t
->to_fileio_unlink
!= NULL
)
3220 int ret
= t
->to_fileio_unlink (t
, filename
, target_errno
);
3223 fprintf_unfiltered (gdb_stdlog
,
3224 "target_fileio_unlink (%s) = %d (%d)\n",
3225 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3230 *target_errno
= FILEIO_ENOSYS
;
3234 /* Read value of symbolic link FILENAME on the target. Return a
3235 null-terminated string allocated via xmalloc, or NULL if an error
3236 occurs (and set *TARGET_ERRNO). */
3238 target_fileio_readlink (const char *filename
, int *target_errno
)
3240 struct target_ops
*t
;
3242 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3244 if (t
->to_fileio_readlink
!= NULL
)
3246 char *ret
= t
->to_fileio_readlink (t
, filename
, target_errno
);
3249 fprintf_unfiltered (gdb_stdlog
,
3250 "target_fileio_readlink (%s) = %s (%d)\n",
3251 filename
, ret
? ret
: "(nil)",
3252 ret
? 0 : *target_errno
);
3257 *target_errno
= FILEIO_ENOSYS
;
3262 target_fileio_close_cleanup (void *opaque
)
3264 int fd
= *(int *) opaque
;
3267 target_fileio_close (fd
, &target_errno
);
3270 /* Read target file FILENAME. Store the result in *BUF_P and
3271 return the size of the transferred data. PADDING additional bytes are
3272 available in *BUF_P. This is a helper function for
3273 target_fileio_read_alloc; see the declaration of that function for more
3277 target_fileio_read_alloc_1 (const char *filename
,
3278 gdb_byte
**buf_p
, int padding
)
3280 struct cleanup
*close_cleanup
;
3281 size_t buf_alloc
, buf_pos
;
3287 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3291 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3293 /* Start by reading up to 4K at a time. The target will throttle
3294 this number down if necessary. */
3296 buf
= xmalloc (buf_alloc
);
3300 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3301 buf_alloc
- buf_pos
- padding
, buf_pos
,
3305 /* An error occurred. */
3306 do_cleanups (close_cleanup
);
3312 /* Read all there was. */
3313 do_cleanups (close_cleanup
);
3323 /* If the buffer is filling up, expand it. */
3324 if (buf_alloc
< buf_pos
* 2)
3327 buf
= xrealloc (buf
, buf_alloc
);
3334 /* Read target file FILENAME. Store the result in *BUF_P and return
3335 the size of the transferred data. See the declaration in "target.h"
3336 function for more information about the return value. */
3339 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3341 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3344 /* Read target file FILENAME. The result is NUL-terminated and
3345 returned as a string, allocated using xmalloc. If an error occurs
3346 or the transfer is unsupported, NULL is returned. Empty objects
3347 are returned as allocated but empty strings. A warning is issued
3348 if the result contains any embedded NUL bytes. */
3351 target_fileio_read_stralloc (const char *filename
)
3355 LONGEST i
, transferred
;
3357 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3358 bufstr
= (char *) buffer
;
3360 if (transferred
< 0)
3363 if (transferred
== 0)
3364 return xstrdup ("");
3366 bufstr
[transferred
] = 0;
3368 /* Check for embedded NUL bytes; but allow trailing NULs. */
3369 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3372 warning (_("target file %s "
3373 "contained unexpected null characters"),
3383 default_region_ok_for_hw_watchpoint (struct target_ops
*self
,
3384 CORE_ADDR addr
, int len
)
3386 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3390 default_watchpoint_addr_within_range (struct target_ops
*target
,
3392 CORE_ADDR start
, int length
)
3394 return addr
>= start
&& addr
< start
+ length
;
3397 static struct gdbarch
*
3398 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3400 return target_gdbarch ();
3410 * Find the next target down the stack from the specified target.
3414 find_target_beneath (struct target_ops
*t
)
3422 find_target_at (enum strata stratum
)
3424 struct target_ops
*t
;
3426 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3427 if (t
->to_stratum
== stratum
)
3434 /* The inferior process has died. Long live the inferior! */
3437 generic_mourn_inferior (void)
3441 ptid
= inferior_ptid
;
3442 inferior_ptid
= null_ptid
;
3444 /* Mark breakpoints uninserted in case something tries to delete a
3445 breakpoint while we delete the inferior's threads (which would
3446 fail, since the inferior is long gone). */
3447 mark_breakpoints_out ();
3449 if (!ptid_equal (ptid
, null_ptid
))
3451 int pid
= ptid_get_pid (ptid
);
3452 exit_inferior (pid
);
3455 /* Note this wipes step-resume breakpoints, so needs to be done
3456 after exit_inferior, which ends up referencing the step-resume
3457 breakpoints through clear_thread_inferior_resources. */
3458 breakpoint_init_inferior (inf_exited
);
3460 registers_changed ();
3462 reopen_exec_file ();
3463 reinit_frame_cache ();
3465 if (deprecated_detach_hook
)
3466 deprecated_detach_hook ();
3469 /* Convert a normal process ID to a string. Returns the string in a
3473 normal_pid_to_str (ptid_t ptid
)
3475 static char buf
[32];
3477 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3482 default_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3484 return normal_pid_to_str (ptid
);
3487 /* Error-catcher for target_find_memory_regions. */
3489 dummy_find_memory_regions (struct target_ops
*self
,
3490 find_memory_region_ftype ignore1
, void *ignore2
)
3492 error (_("Command not implemented for this target."));
3496 /* Error-catcher for target_make_corefile_notes. */
3498 dummy_make_corefile_notes (struct target_ops
*self
,
3499 bfd
*ignore1
, int *ignore2
)
3501 error (_("Command not implemented for this target."));
3505 /* Set up the handful of non-empty slots needed by the dummy target
3509 init_dummy_target (void)
3511 dummy_target
.to_shortname
= "None";
3512 dummy_target
.to_longname
= "None";
3513 dummy_target
.to_doc
= "";
3514 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3515 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3516 dummy_target
.to_supports_disable_randomization
3517 = find_default_supports_disable_randomization
;
3518 dummy_target
.to_stratum
= dummy_stratum
;
3519 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3520 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3521 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3522 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3523 dummy_target
.to_has_execution
3524 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3525 dummy_target
.to_magic
= OPS_MAGIC
;
3527 install_dummy_methods (&dummy_target
);
3531 debug_to_open (char *args
, int from_tty
)
3533 debug_target
.to_open (args
, from_tty
);
3535 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3539 target_close (struct target_ops
*targ
)
3541 gdb_assert (!target_is_pushed (targ
));
3543 if (targ
->to_xclose
!= NULL
)
3544 targ
->to_xclose (targ
);
3545 else if (targ
->to_close
!= NULL
)
3546 targ
->to_close (targ
);
3549 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3553 target_attach (char *args
, int from_tty
)
3555 current_target
.to_attach (¤t_target
, args
, from_tty
);
3557 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3562 target_thread_alive (ptid_t ptid
)
3564 struct target_ops
*t
;
3566 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3568 if (t
->to_thread_alive
!= NULL
)
3572 retval
= t
->to_thread_alive (t
, ptid
);
3574 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3575 ptid_get_pid (ptid
), retval
);
3585 target_find_new_threads (void)
3587 current_target
.to_find_new_threads (¤t_target
);
3589 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3593 target_stop (ptid_t ptid
)
3597 warning (_("May not interrupt or stop the target, ignoring attempt"));
3601 (*current_target
.to_stop
) (¤t_target
, ptid
);
3605 debug_to_post_attach (struct target_ops
*self
, int pid
)
3607 debug_target
.to_post_attach (&debug_target
, pid
);
3609 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3612 /* Concatenate ELEM to LIST, a comma separate list, and return the
3613 result. The LIST incoming argument is released. */
3616 str_comma_list_concat_elem (char *list
, const char *elem
)
3619 return xstrdup (elem
);
3621 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3624 /* Helper for target_options_to_string. If OPT is present in
3625 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3626 Returns the new resulting string. OPT is removed from
3630 do_option (int *target_options
, char *ret
,
3631 int opt
, char *opt_str
)
3633 if ((*target_options
& opt
) != 0)
3635 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3636 *target_options
&= ~opt
;
3643 target_options_to_string (int target_options
)
3647 #define DO_TARG_OPTION(OPT) \
3648 ret = do_option (&target_options, ret, OPT, #OPT)
3650 DO_TARG_OPTION (TARGET_WNOHANG
);
3652 if (target_options
!= 0)
3653 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3661 debug_print_register (const char * func
,
3662 struct regcache
*regcache
, int regno
)
3664 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3666 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3667 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3668 && gdbarch_register_name (gdbarch
, regno
) != NULL
3669 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3670 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3671 gdbarch_register_name (gdbarch
, regno
));
3673 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3674 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3676 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3677 int i
, size
= register_size (gdbarch
, regno
);
3678 gdb_byte buf
[MAX_REGISTER_SIZE
];
3680 regcache_raw_collect (regcache
, regno
, buf
);
3681 fprintf_unfiltered (gdb_stdlog
, " = ");
3682 for (i
= 0; i
< size
; i
++)
3684 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3686 if (size
<= sizeof (LONGEST
))
3688 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3690 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3691 core_addr_to_string_nz (val
), plongest (val
));
3694 fprintf_unfiltered (gdb_stdlog
, "\n");
3698 target_fetch_registers (struct regcache
*regcache
, int regno
)
3700 current_target
.to_fetch_registers (¤t_target
, regcache
, regno
);
3702 debug_print_register ("target_fetch_registers", regcache
, regno
);
3706 target_store_registers (struct regcache
*regcache
, int regno
)
3708 struct target_ops
*t
;
3710 if (!may_write_registers
)
3711 error (_("Writing to registers is not allowed (regno %d)"), regno
);
3713 current_target
.to_store_registers (¤t_target
, regcache
, regno
);
3716 debug_print_register ("target_store_registers", regcache
, regno
);
3721 target_core_of_thread (ptid_t ptid
)
3723 struct target_ops
*t
;
3725 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3727 if (t
->to_core_of_thread
!= NULL
)
3729 int retval
= t
->to_core_of_thread (t
, ptid
);
3732 fprintf_unfiltered (gdb_stdlog
,
3733 "target_core_of_thread (%d) = %d\n",
3734 ptid_get_pid (ptid
), retval
);
3743 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
3745 struct target_ops
*t
;
3747 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3749 if (t
->to_verify_memory
!= NULL
)
3751 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
3754 fprintf_unfiltered (gdb_stdlog
,
3755 "target_verify_memory (%s, %s) = %d\n",
3756 paddress (target_gdbarch (), memaddr
),
3766 /* The documentation for this function is in its prototype declaration in
3770 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3774 ret
= current_target
.to_insert_mask_watchpoint (¤t_target
,
3778 fprintf_unfiltered (gdb_stdlog
, "\
3779 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3780 core_addr_to_string (addr
),
3781 core_addr_to_string (mask
), rw
, ret
);
3786 /* The documentation for this function is in its prototype declaration in
3790 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
3794 ret
= current_target
.to_remove_mask_watchpoint (¤t_target
,
3798 fprintf_unfiltered (gdb_stdlog
, "\
3799 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
3800 core_addr_to_string (addr
),
3801 core_addr_to_string (mask
), rw
, ret
);
3806 /* The documentation for this function is in its prototype declaration
3810 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
3812 return current_target
.to_masked_watch_num_registers (¤t_target
,
3816 /* The documentation for this function is in its prototype declaration
3820 target_ranged_break_num_registers (void)
3822 return current_target
.to_ranged_break_num_registers (¤t_target
);
3827 struct btrace_target_info
*
3828 target_enable_btrace (ptid_t ptid
)
3830 struct target_ops
*t
;
3832 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3833 if (t
->to_enable_btrace
!= NULL
)
3834 return t
->to_enable_btrace (t
, ptid
);
3843 target_disable_btrace (struct btrace_target_info
*btinfo
)
3845 struct target_ops
*t
;
3847 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3848 if (t
->to_disable_btrace
!= NULL
)
3850 t
->to_disable_btrace (t
, btinfo
);
3860 target_teardown_btrace (struct btrace_target_info
*btinfo
)
3862 struct target_ops
*t
;
3864 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3865 if (t
->to_teardown_btrace
!= NULL
)
3867 t
->to_teardown_btrace (t
, btinfo
);
3877 target_read_btrace (VEC (btrace_block_s
) **btrace
,
3878 struct btrace_target_info
*btinfo
,
3879 enum btrace_read_type type
)
3881 struct target_ops
*t
;
3883 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3884 if (t
->to_read_btrace
!= NULL
)
3885 return t
->to_read_btrace (t
, btrace
, btinfo
, type
);
3888 return BTRACE_ERR_NOT_SUPPORTED
;
3894 target_stop_recording (void)
3896 struct target_ops
*t
;
3898 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3899 if (t
->to_stop_recording
!= NULL
)
3901 t
->to_stop_recording (t
);
3905 /* This is optional. */
3911 target_info_record (void)
3913 struct target_ops
*t
;
3915 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3916 if (t
->to_info_record
!= NULL
)
3918 t
->to_info_record (t
);
3928 target_save_record (const char *filename
)
3930 struct target_ops
*t
;
3932 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3933 if (t
->to_save_record
!= NULL
)
3935 t
->to_save_record (t
, filename
);
3945 target_supports_delete_record (void)
3947 struct target_ops
*t
;
3949 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3950 if (t
->to_delete_record
!= NULL
)
3959 target_delete_record (void)
3961 struct target_ops
*t
;
3963 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3964 if (t
->to_delete_record
!= NULL
)
3966 t
->to_delete_record (t
);
3976 target_record_is_replaying (void)
3978 struct target_ops
*t
;
3980 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3981 if (t
->to_record_is_replaying
!= NULL
)
3982 return t
->to_record_is_replaying (t
);
3990 target_goto_record_begin (void)
3992 struct target_ops
*t
;
3994 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3995 if (t
->to_goto_record_begin
!= NULL
)
3997 t
->to_goto_record_begin (t
);
4007 target_goto_record_end (void)
4009 struct target_ops
*t
;
4011 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4012 if (t
->to_goto_record_end
!= NULL
)
4014 t
->to_goto_record_end (t
);
4024 target_goto_record (ULONGEST insn
)
4026 struct target_ops
*t
;
4028 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4029 if (t
->to_goto_record
!= NULL
)
4031 t
->to_goto_record (t
, insn
);
4041 target_insn_history (int size
, int flags
)
4043 struct target_ops
*t
;
4045 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4046 if (t
->to_insn_history
!= NULL
)
4048 t
->to_insn_history (t
, size
, flags
);
4058 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4060 struct target_ops
*t
;
4062 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4063 if (t
->to_insn_history_from
!= NULL
)
4065 t
->to_insn_history_from (t
, from
, size
, flags
);
4075 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4077 struct target_ops
*t
;
4079 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4080 if (t
->to_insn_history_range
!= NULL
)
4082 t
->to_insn_history_range (t
, begin
, end
, flags
);
4092 target_call_history (int size
, int flags
)
4094 struct target_ops
*t
;
4096 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4097 if (t
->to_call_history
!= NULL
)
4099 t
->to_call_history (t
, size
, flags
);
4109 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4111 struct target_ops
*t
;
4113 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4114 if (t
->to_call_history_from
!= NULL
)
4116 t
->to_call_history_from (t
, begin
, size
, flags
);
4126 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4128 struct target_ops
*t
;
4130 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4131 if (t
->to_call_history_range
!= NULL
)
4133 t
->to_call_history_range (t
, begin
, end
, flags
);
4141 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4143 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4145 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4150 const struct frame_unwind
*
4151 target_get_unwinder (void)
4153 struct target_ops
*t
;
4155 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4156 if (t
->to_get_unwinder
!= NULL
)
4157 return t
->to_get_unwinder
;
4164 const struct frame_unwind
*
4165 target_get_tailcall_unwinder (void)
4167 struct target_ops
*t
;
4169 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4170 if (t
->to_get_tailcall_unwinder
!= NULL
)
4171 return t
->to_get_tailcall_unwinder
;
4179 forward_target_decr_pc_after_break (struct target_ops
*ops
,
4180 struct gdbarch
*gdbarch
)
4182 for (; ops
!= NULL
; ops
= ops
->beneath
)
4183 if (ops
->to_decr_pc_after_break
!= NULL
)
4184 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
4186 return gdbarch_decr_pc_after_break (gdbarch
);
4192 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
4194 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
4198 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4199 int write
, struct mem_attrib
*attrib
,
4200 struct target_ops
*target
)
4204 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4207 fprintf_unfiltered (gdb_stdlog
,
4208 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4209 paddress (target_gdbarch (), memaddr
), len
,
4210 write
? "write" : "read", retval
);
4216 fputs_unfiltered (", bytes =", gdb_stdlog
);
4217 for (i
= 0; i
< retval
; i
++)
4219 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4221 if (targetdebug
< 2 && i
> 0)
4223 fprintf_unfiltered (gdb_stdlog
, " ...");
4226 fprintf_unfiltered (gdb_stdlog
, "\n");
4229 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4233 fputc_unfiltered ('\n', gdb_stdlog
);
4239 debug_to_files_info (struct target_ops
*target
)
4241 debug_target
.to_files_info (target
);
4243 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4247 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4248 struct bp_target_info
*bp_tgt
)
4252 retval
= debug_target
.to_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4254 fprintf_unfiltered (gdb_stdlog
,
4255 "target_insert_breakpoint (%s, xxx) = %ld\n",
4256 core_addr_to_string (bp_tgt
->placed_address
),
4257 (unsigned long) retval
);
4262 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4263 struct bp_target_info
*bp_tgt
)
4267 retval
= debug_target
.to_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4269 fprintf_unfiltered (gdb_stdlog
,
4270 "target_remove_breakpoint (%s, xxx) = %ld\n",
4271 core_addr_to_string (bp_tgt
->placed_address
),
4272 (unsigned long) retval
);
4277 debug_to_can_use_hw_breakpoint (struct target_ops
*self
,
4278 int type
, int cnt
, int from_tty
)
4282 retval
= debug_target
.to_can_use_hw_breakpoint (&debug_target
,
4283 type
, cnt
, from_tty
);
4285 fprintf_unfiltered (gdb_stdlog
,
4286 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4287 (unsigned long) type
,
4288 (unsigned long) cnt
,
4289 (unsigned long) from_tty
,
4290 (unsigned long) retval
);
4295 debug_to_region_ok_for_hw_watchpoint (struct target_ops
*self
,
4296 CORE_ADDR addr
, int len
)
4300 retval
= debug_target
.to_region_ok_for_hw_watchpoint (&debug_target
,
4303 fprintf_unfiltered (gdb_stdlog
,
4304 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4305 core_addr_to_string (addr
), (unsigned long) len
,
4306 core_addr_to_string (retval
));
4311 debug_to_can_accel_watchpoint_condition (struct target_ops
*self
,
4312 CORE_ADDR addr
, int len
, int rw
,
4313 struct expression
*cond
)
4317 retval
= debug_target
.to_can_accel_watchpoint_condition (&debug_target
,
4321 fprintf_unfiltered (gdb_stdlog
,
4322 "target_can_accel_watchpoint_condition "
4323 "(%s, %d, %d, %s) = %ld\n",
4324 core_addr_to_string (addr
), len
, rw
,
4325 host_address_to_string (cond
), (unsigned long) retval
);
4330 debug_to_stopped_by_watchpoint (struct target_ops
*ops
)
4334 retval
= debug_target
.to_stopped_by_watchpoint (&debug_target
);
4336 fprintf_unfiltered (gdb_stdlog
,
4337 "target_stopped_by_watchpoint () = %ld\n",
4338 (unsigned long) retval
);
4343 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4347 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4349 fprintf_unfiltered (gdb_stdlog
,
4350 "target_stopped_data_address ([%s]) = %ld\n",
4351 core_addr_to_string (*addr
),
4352 (unsigned long)retval
);
4357 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4359 CORE_ADDR start
, int length
)
4363 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4366 fprintf_filtered (gdb_stdlog
,
4367 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4368 core_addr_to_string (addr
), core_addr_to_string (start
),
4374 debug_to_insert_hw_breakpoint (struct target_ops
*self
,
4375 struct gdbarch
*gdbarch
,
4376 struct bp_target_info
*bp_tgt
)
4380 retval
= debug_target
.to_insert_hw_breakpoint (&debug_target
,
4383 fprintf_unfiltered (gdb_stdlog
,
4384 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4385 core_addr_to_string (bp_tgt
->placed_address
),
4386 (unsigned long) retval
);
4391 debug_to_remove_hw_breakpoint (struct target_ops
*self
,
4392 struct gdbarch
*gdbarch
,
4393 struct bp_target_info
*bp_tgt
)
4397 retval
= debug_target
.to_remove_hw_breakpoint (&debug_target
,
4400 fprintf_unfiltered (gdb_stdlog
,
4401 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4402 core_addr_to_string (bp_tgt
->placed_address
),
4403 (unsigned long) retval
);
4408 debug_to_insert_watchpoint (struct target_ops
*self
,
4409 CORE_ADDR addr
, int len
, int type
,
4410 struct expression
*cond
)
4414 retval
= debug_target
.to_insert_watchpoint (&debug_target
,
4415 addr
, len
, type
, cond
);
4417 fprintf_unfiltered (gdb_stdlog
,
4418 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4419 core_addr_to_string (addr
), len
, type
,
4420 host_address_to_string (cond
), (unsigned long) retval
);
4425 debug_to_remove_watchpoint (struct target_ops
*self
,
4426 CORE_ADDR addr
, int len
, int type
,
4427 struct expression
*cond
)
4431 retval
= debug_target
.to_remove_watchpoint (&debug_target
,
4432 addr
, len
, type
, cond
);
4434 fprintf_unfiltered (gdb_stdlog
,
4435 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4436 core_addr_to_string (addr
), len
, type
,
4437 host_address_to_string (cond
), (unsigned long) retval
);
4442 debug_to_terminal_init (struct target_ops
*self
)
4444 debug_target
.to_terminal_init (&debug_target
);
4446 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4450 debug_to_terminal_inferior (struct target_ops
*self
)
4452 debug_target
.to_terminal_inferior (&debug_target
);
4454 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4458 debug_to_terminal_ours_for_output (struct target_ops
*self
)
4460 debug_target
.to_terminal_ours_for_output (&debug_target
);
4462 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4466 debug_to_terminal_ours (struct target_ops
*self
)
4468 debug_target
.to_terminal_ours (&debug_target
);
4470 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4474 debug_to_terminal_save_ours (struct target_ops
*self
)
4476 debug_target
.to_terminal_save_ours (&debug_target
);
4478 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4482 debug_to_terminal_info (struct target_ops
*self
,
4483 const char *arg
, int from_tty
)
4485 debug_target
.to_terminal_info (&debug_target
, arg
, from_tty
);
4487 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4492 debug_to_load (struct target_ops
*self
, char *args
, int from_tty
)
4494 debug_target
.to_load (&debug_target
, args
, from_tty
);
4496 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4500 debug_to_post_startup_inferior (struct target_ops
*self
, ptid_t ptid
)
4502 debug_target
.to_post_startup_inferior (&debug_target
, ptid
);
4504 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4505 ptid_get_pid (ptid
));
4509 debug_to_insert_fork_catchpoint (struct target_ops
*self
, int pid
)
4513 retval
= debug_target
.to_insert_fork_catchpoint (&debug_target
, pid
);
4515 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4522 debug_to_remove_fork_catchpoint (struct target_ops
*self
, int pid
)
4526 retval
= debug_target
.to_remove_fork_catchpoint (&debug_target
, pid
);
4528 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4535 debug_to_insert_vfork_catchpoint (struct target_ops
*self
, int pid
)
4539 retval
= debug_target
.to_insert_vfork_catchpoint (&debug_target
, pid
);
4541 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4548 debug_to_remove_vfork_catchpoint (struct target_ops
*self
, int pid
)
4552 retval
= debug_target
.to_remove_vfork_catchpoint (&debug_target
, pid
);
4554 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4561 debug_to_insert_exec_catchpoint (struct target_ops
*self
, int pid
)
4565 retval
= debug_target
.to_insert_exec_catchpoint (&debug_target
, pid
);
4567 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4574 debug_to_remove_exec_catchpoint (struct target_ops
*self
, int pid
)
4578 retval
= debug_target
.to_remove_exec_catchpoint (&debug_target
, pid
);
4580 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4587 debug_to_has_exited (struct target_ops
*self
,
4588 int pid
, int wait_status
, int *exit_status
)
4592 has_exited
= debug_target
.to_has_exited (&debug_target
,
4593 pid
, wait_status
, exit_status
);
4595 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4596 pid
, wait_status
, *exit_status
, has_exited
);
4602 debug_to_can_run (struct target_ops
*self
)
4606 retval
= debug_target
.to_can_run (&debug_target
);
4608 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4613 static struct gdbarch
*
4614 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4616 struct gdbarch
*retval
;
4618 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4620 fprintf_unfiltered (gdb_stdlog
,
4621 "target_thread_architecture (%s) = %s [%s]\n",
4622 target_pid_to_str (ptid
),
4623 host_address_to_string (retval
),
4624 gdbarch_bfd_arch_info (retval
)->printable_name
);
4629 debug_to_stop (struct target_ops
*self
, ptid_t ptid
)
4631 debug_target
.to_stop (&debug_target
, ptid
);
4633 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4634 target_pid_to_str (ptid
));
4638 debug_to_rcmd (struct target_ops
*self
, char *command
,
4639 struct ui_file
*outbuf
)
4641 debug_target
.to_rcmd (&debug_target
, command
, outbuf
);
4642 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4646 debug_to_pid_to_exec_file (struct target_ops
*self
, int pid
)
4650 exec_file
= debug_target
.to_pid_to_exec_file (&debug_target
, pid
);
4652 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
4659 setup_target_debug (void)
4661 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
4663 current_target
.to_open
= debug_to_open
;
4664 current_target
.to_post_attach
= debug_to_post_attach
;
4665 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
4666 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
4667 current_target
.to_files_info
= debug_to_files_info
;
4668 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
4669 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
4670 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
4671 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
4672 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
4673 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
4674 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
4675 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
4676 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
4677 current_target
.to_watchpoint_addr_within_range
4678 = debug_to_watchpoint_addr_within_range
;
4679 current_target
.to_region_ok_for_hw_watchpoint
4680 = debug_to_region_ok_for_hw_watchpoint
;
4681 current_target
.to_can_accel_watchpoint_condition
4682 = debug_to_can_accel_watchpoint_condition
;
4683 current_target
.to_terminal_init
= debug_to_terminal_init
;
4684 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
4685 current_target
.to_terminal_ours_for_output
4686 = debug_to_terminal_ours_for_output
;
4687 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
4688 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
4689 current_target
.to_terminal_info
= debug_to_terminal_info
;
4690 current_target
.to_load
= debug_to_load
;
4691 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
4692 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
4693 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
4694 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
4695 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
4696 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
4697 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
4698 current_target
.to_has_exited
= debug_to_has_exited
;
4699 current_target
.to_can_run
= debug_to_can_run
;
4700 current_target
.to_stop
= debug_to_stop
;
4701 current_target
.to_rcmd
= debug_to_rcmd
;
4702 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
4703 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
4707 static char targ_desc
[] =
4708 "Names of targets and files being debugged.\nShows the entire \
4709 stack of targets currently in use (including the exec-file,\n\
4710 core-file, and process, if any), as well as the symbol file name.";
4713 default_rcmd (struct target_ops
*self
, char *command
, struct ui_file
*output
)
4715 error (_("\"monitor\" command not supported by this target."));
4719 do_monitor_command (char *cmd
,
4722 target_rcmd (cmd
, gdb_stdtarg
);
4725 /* Print the name of each layers of our target stack. */
4728 maintenance_print_target_stack (char *cmd
, int from_tty
)
4730 struct target_ops
*t
;
4732 printf_filtered (_("The current target stack is:\n"));
4734 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
4736 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
4740 /* Controls if async mode is permitted. */
4741 int target_async_permitted
= 0;
4743 /* The set command writes to this variable. If the inferior is
4744 executing, target_async_permitted is *not* updated. */
4745 static int target_async_permitted_1
= 0;
4748 set_target_async_command (char *args
, int from_tty
,
4749 struct cmd_list_element
*c
)
4751 if (have_live_inferiors ())
4753 target_async_permitted_1
= target_async_permitted
;
4754 error (_("Cannot change this setting while the inferior is running."));
4757 target_async_permitted
= target_async_permitted_1
;
4761 show_target_async_command (struct ui_file
*file
, int from_tty
,
4762 struct cmd_list_element
*c
,
4765 fprintf_filtered (file
,
4766 _("Controlling the inferior in "
4767 "asynchronous mode is %s.\n"), value
);
4770 /* Temporary copies of permission settings. */
4772 static int may_write_registers_1
= 1;
4773 static int may_write_memory_1
= 1;
4774 static int may_insert_breakpoints_1
= 1;
4775 static int may_insert_tracepoints_1
= 1;
4776 static int may_insert_fast_tracepoints_1
= 1;
4777 static int may_stop_1
= 1;
4779 /* Make the user-set values match the real values again. */
4782 update_target_permissions (void)
4784 may_write_registers_1
= may_write_registers
;
4785 may_write_memory_1
= may_write_memory
;
4786 may_insert_breakpoints_1
= may_insert_breakpoints
;
4787 may_insert_tracepoints_1
= may_insert_tracepoints
;
4788 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
4789 may_stop_1
= may_stop
;
4792 /* The one function handles (most of) the permission flags in the same
4796 set_target_permissions (char *args
, int from_tty
,
4797 struct cmd_list_element
*c
)
4799 if (target_has_execution
)
4801 update_target_permissions ();
4802 error (_("Cannot change this setting while the inferior is running."));
4805 /* Make the real values match the user-changed values. */
4806 may_write_registers
= may_write_registers_1
;
4807 may_insert_breakpoints
= may_insert_breakpoints_1
;
4808 may_insert_tracepoints
= may_insert_tracepoints_1
;
4809 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
4810 may_stop
= may_stop_1
;
4811 update_observer_mode ();
4814 /* Set memory write permission independently of observer mode. */
4817 set_write_memory_permission (char *args
, int from_tty
,
4818 struct cmd_list_element
*c
)
4820 /* Make the real values match the user-changed values. */
4821 may_write_memory
= may_write_memory_1
;
4822 update_observer_mode ();
4827 initialize_targets (void)
4829 init_dummy_target ();
4830 push_target (&dummy_target
);
4832 add_info ("target", target_info
, targ_desc
);
4833 add_info ("files", target_info
, targ_desc
);
4835 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
4836 Set target debugging."), _("\
4837 Show target debugging."), _("\
4838 When non-zero, target debugging is enabled. Higher numbers are more\n\
4839 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
4843 &setdebuglist
, &showdebuglist
);
4845 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
4846 &trust_readonly
, _("\
4847 Set mode for reading from readonly sections."), _("\
4848 Show mode for reading from readonly sections."), _("\
4849 When this mode is on, memory reads from readonly sections (such as .text)\n\
4850 will be read from the object file instead of from the target. This will\n\
4851 result in significant performance improvement for remote targets."),
4853 show_trust_readonly
,
4854 &setlist
, &showlist
);
4856 add_com ("monitor", class_obscure
, do_monitor_command
,
4857 _("Send a command to the remote monitor (remote targets only)."));
4859 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
4860 _("Print the name of each layer of the internal target stack."),
4861 &maintenanceprintlist
);
4863 add_setshow_boolean_cmd ("target-async", no_class
,
4864 &target_async_permitted_1
, _("\
4865 Set whether gdb controls the inferior in asynchronous mode."), _("\
4866 Show whether gdb controls the inferior in asynchronous mode."), _("\
4867 Tells gdb whether to control the inferior in asynchronous mode."),
4868 set_target_async_command
,
4869 show_target_async_command
,
4873 add_setshow_boolean_cmd ("may-write-registers", class_support
,
4874 &may_write_registers_1
, _("\
4875 Set permission to write into registers."), _("\
4876 Show permission to write into registers."), _("\
4877 When this permission is on, GDB may write into the target's registers.\n\
4878 Otherwise, any sort of write attempt will result in an error."),
4879 set_target_permissions
, NULL
,
4880 &setlist
, &showlist
);
4882 add_setshow_boolean_cmd ("may-write-memory", class_support
,
4883 &may_write_memory_1
, _("\
4884 Set permission to write into target memory."), _("\
4885 Show permission to write into target memory."), _("\
4886 When this permission is on, GDB may write into the target's memory.\n\
4887 Otherwise, any sort of write attempt will result in an error."),
4888 set_write_memory_permission
, NULL
,
4889 &setlist
, &showlist
);
4891 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
4892 &may_insert_breakpoints_1
, _("\
4893 Set permission to insert breakpoints in the target."), _("\
4894 Show permission to insert breakpoints in the target."), _("\
4895 When this permission is on, GDB may insert breakpoints in the program.\n\
4896 Otherwise, any sort of insertion attempt will result in an error."),
4897 set_target_permissions
, NULL
,
4898 &setlist
, &showlist
);
4900 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
4901 &may_insert_tracepoints_1
, _("\
4902 Set permission to insert tracepoints in the target."), _("\
4903 Show permission to insert tracepoints in the target."), _("\
4904 When this permission is on, GDB may insert tracepoints in the program.\n\
4905 Otherwise, any sort of insertion attempt will result in an error."),
4906 set_target_permissions
, NULL
,
4907 &setlist
, &showlist
);
4909 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
4910 &may_insert_fast_tracepoints_1
, _("\
4911 Set permission to insert fast tracepoints in the target."), _("\
4912 Show permission to insert fast tracepoints in the target."), _("\
4913 When this permission is on, GDB may insert fast tracepoints.\n\
4914 Otherwise, any sort of insertion attempt will result in an error."),
4915 set_target_permissions
, NULL
,
4916 &setlist
, &showlist
);
4918 add_setshow_boolean_cmd ("may-interrupt", class_support
,
4920 Set permission to interrupt or signal the target."), _("\
4921 Show permission to interrupt or signal the target."), _("\
4922 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4923 Otherwise, any attempt to interrupt or stop will be ignored."),
4924 set_target_permissions
, NULL
,
4925 &setlist
, &showlist
);