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 (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 (CORE_ADDR
, int);
57 static void tcomplain (void) ATTRIBUTE_NORETURN
;
59 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
61 static int return_zero (void);
63 static int return_one (void);
65 static int return_minus_one (void);
67 static void *return_null (void);
69 void target_ignore (void);
71 static void target_command (char *, int);
73 static struct target_ops
*find_default_run_target (char *);
75 static target_xfer_partial_ftype default_xfer_partial
;
77 static target_xfer_partial_ftype current_xfer_partial
;
79 static struct gdbarch
*default_thread_architecture (struct target_ops
*ops
,
82 static void init_dummy_target (void);
84 static struct target_ops debug_target
;
86 static void debug_to_open (char *, int);
88 static void debug_to_prepare_to_store (struct target_ops
*self
,
91 static void debug_to_files_info (struct target_ops
*);
93 static int debug_to_insert_breakpoint (struct target_ops
*, struct gdbarch
*,
94 struct bp_target_info
*);
96 static int debug_to_remove_breakpoint (struct target_ops
*, struct gdbarch
*,
97 struct bp_target_info
*);
99 static int debug_to_can_use_hw_breakpoint (int, int, int);
101 static int debug_to_insert_hw_breakpoint (struct gdbarch
*,
102 struct bp_target_info
*);
104 static int debug_to_remove_hw_breakpoint (struct gdbarch
*,
105 struct bp_target_info
*);
107 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int,
108 struct expression
*);
110 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int,
111 struct expression
*);
113 static int debug_to_stopped_by_watchpoint (void);
115 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
117 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
118 CORE_ADDR
, CORE_ADDR
, int);
120 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
122 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR
, int, int,
123 struct expression
*);
125 static void debug_to_terminal_init (void);
127 static void debug_to_terminal_inferior (void);
129 static void debug_to_terminal_ours_for_output (void);
131 static void debug_to_terminal_save_ours (void);
133 static void debug_to_terminal_ours (void);
135 static void debug_to_load (char *, int);
137 static int debug_to_can_run (void);
139 static void debug_to_stop (ptid_t
);
141 /* Pointer to array of target architecture structures; the size of the
142 array; the current index into the array; the allocated size of the
144 struct target_ops
**target_structs
;
145 unsigned target_struct_size
;
146 unsigned target_struct_allocsize
;
147 #define DEFAULT_ALLOCSIZE 10
149 /* The initial current target, so that there is always a semi-valid
152 static struct target_ops dummy_target
;
154 /* Top of target stack. */
156 static struct target_ops
*target_stack
;
158 /* The target structure we are currently using to talk to a process
159 or file or whatever "inferior" we have. */
161 struct target_ops current_target
;
163 /* Command list for target. */
165 static struct cmd_list_element
*targetlist
= NULL
;
167 /* Nonzero if we should trust readonly sections from the
168 executable when reading memory. */
170 static int trust_readonly
= 0;
172 /* Nonzero if we should show true memory content including
173 memory breakpoint inserted by gdb. */
175 static int show_memory_breakpoints
= 0;
177 /* These globals control whether GDB attempts to perform these
178 operations; they are useful for targets that need to prevent
179 inadvertant disruption, such as in non-stop mode. */
181 int may_write_registers
= 1;
183 int may_write_memory
= 1;
185 int may_insert_breakpoints
= 1;
187 int may_insert_tracepoints
= 1;
189 int may_insert_fast_tracepoints
= 1;
193 /* Non-zero if we want to see trace of target level stuff. */
195 static unsigned int targetdebug
= 0;
197 show_targetdebug (struct ui_file
*file
, int from_tty
,
198 struct cmd_list_element
*c
, const char *value
)
200 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
203 static void setup_target_debug (void);
205 /* The user just typed 'target' without the name of a target. */
208 target_command (char *arg
, int from_tty
)
210 fputs_filtered ("Argument required (target name). Try `help target'\n",
214 /* Default target_has_* methods for process_stratum targets. */
217 default_child_has_all_memory (struct target_ops
*ops
)
219 /* If no inferior selected, then we can't read memory here. */
220 if (ptid_equal (inferior_ptid
, null_ptid
))
227 default_child_has_memory (struct target_ops
*ops
)
229 /* If no inferior selected, then we can't read memory here. */
230 if (ptid_equal (inferior_ptid
, null_ptid
))
237 default_child_has_stack (struct target_ops
*ops
)
239 /* If no inferior selected, there's no stack. */
240 if (ptid_equal (inferior_ptid
, null_ptid
))
247 default_child_has_registers (struct target_ops
*ops
)
249 /* Can't read registers from no inferior. */
250 if (ptid_equal (inferior_ptid
, null_ptid
))
257 default_child_has_execution (struct target_ops
*ops
, ptid_t the_ptid
)
259 /* If there's no thread selected, then we can't make it run through
261 if (ptid_equal (the_ptid
, null_ptid
))
269 target_has_all_memory_1 (void)
271 struct target_ops
*t
;
273 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
274 if (t
->to_has_all_memory (t
))
281 target_has_memory_1 (void)
283 struct target_ops
*t
;
285 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
286 if (t
->to_has_memory (t
))
293 target_has_stack_1 (void)
295 struct target_ops
*t
;
297 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
298 if (t
->to_has_stack (t
))
305 target_has_registers_1 (void)
307 struct target_ops
*t
;
309 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
310 if (t
->to_has_registers (t
))
317 target_has_execution_1 (ptid_t the_ptid
)
319 struct target_ops
*t
;
321 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
322 if (t
->to_has_execution (t
, the_ptid
))
329 target_has_execution_current (void)
331 return target_has_execution_1 (inferior_ptid
);
334 /* Complete initialization of T. This ensures that various fields in
335 T are set, if needed by the target implementation. */
338 complete_target_initialization (struct target_ops
*t
)
340 /* Provide default values for all "must have" methods. */
341 if (t
->to_xfer_partial
== NULL
)
342 t
->to_xfer_partial
= default_xfer_partial
;
344 if (t
->to_has_all_memory
== NULL
)
345 t
->to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
347 if (t
->to_has_memory
== NULL
)
348 t
->to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
350 if (t
->to_has_stack
== NULL
)
351 t
->to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
353 if (t
->to_has_registers
== NULL
)
354 t
->to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
356 if (t
->to_has_execution
== NULL
)
357 t
->to_has_execution
= (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
360 /* Add possible target architecture T to the list and add a new
361 command 'target T->to_shortname'. Set COMPLETER as the command's
362 completer if not NULL. */
365 add_target_with_completer (struct target_ops
*t
,
366 completer_ftype
*completer
)
368 struct cmd_list_element
*c
;
370 complete_target_initialization (t
);
374 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
375 target_structs
= (struct target_ops
**) xmalloc
376 (target_struct_allocsize
* sizeof (*target_structs
));
378 if (target_struct_size
>= target_struct_allocsize
)
380 target_struct_allocsize
*= 2;
381 target_structs
= (struct target_ops
**)
382 xrealloc ((char *) target_structs
,
383 target_struct_allocsize
* sizeof (*target_structs
));
385 target_structs
[target_struct_size
++] = t
;
387 if (targetlist
== NULL
)
388 add_prefix_cmd ("target", class_run
, target_command
, _("\
389 Connect to a target machine or process.\n\
390 The first argument is the type or protocol of the target machine.\n\
391 Remaining arguments are interpreted by the target protocol. For more\n\
392 information on the arguments for a particular protocol, type\n\
393 `help target ' followed by the protocol name."),
394 &targetlist
, "target ", 0, &cmdlist
);
395 c
= add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
,
397 if (completer
!= NULL
)
398 set_cmd_completer (c
, completer
);
401 /* Add a possible target architecture to the list. */
404 add_target (struct target_ops
*t
)
406 add_target_with_completer (t
, NULL
);
412 add_deprecated_target_alias (struct target_ops
*t
, char *alias
)
414 struct cmd_list_element
*c
;
417 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
419 c
= add_cmd (alias
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
420 alt
= xstrprintf ("target %s", t
->to_shortname
);
421 deprecate_cmd (c
, alt
);
434 struct target_ops
*t
;
436 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
437 if (t
->to_kill
!= NULL
)
440 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
450 target_load (char *arg
, int from_tty
)
452 target_dcache_invalidate ();
453 (*current_target
.to_load
) (arg
, from_tty
);
457 target_create_inferior (char *exec_file
, char *args
,
458 char **env
, int from_tty
)
460 struct target_ops
*t
;
462 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
464 if (t
->to_create_inferior
!= NULL
)
466 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
468 fprintf_unfiltered (gdb_stdlog
,
469 "target_create_inferior (%s, %s, xxx, %d)\n",
470 exec_file
, args
, from_tty
);
475 internal_error (__FILE__
, __LINE__
,
476 _("could not find a target to create inferior"));
480 target_terminal_inferior (void)
482 /* A background resume (``run&'') should leave GDB in control of the
483 terminal. Use target_can_async_p, not target_is_async_p, since at
484 this point the target is not async yet. However, if sync_execution
485 is not set, we know it will become async prior to resume. */
486 if (target_can_async_p () && !sync_execution
)
489 /* If GDB is resuming the inferior in the foreground, install
490 inferior's terminal modes. */
491 (*current_target
.to_terminal_inferior
) ();
495 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
496 struct target_ops
*t
)
498 errno
= EIO
; /* Can't read/write this location. */
499 return 0; /* No bytes handled. */
505 error (_("You can't do that when your target is `%s'"),
506 current_target
.to_shortname
);
512 error (_("You can't do that without a process to debug."));
516 default_terminal_info (const char *args
, int from_tty
)
518 printf_unfiltered (_("No saved terminal information.\n"));
521 /* A default implementation for the to_get_ada_task_ptid target method.
523 This function builds the PTID by using both LWP and TID as part of
524 the PTID lwp and tid elements. The pid used is the pid of the
528 default_get_ada_task_ptid (long lwp
, long tid
)
530 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
533 static enum exec_direction_kind
534 default_execution_direction (void)
536 if (!target_can_execute_reverse
)
538 else if (!target_can_async_p ())
541 gdb_assert_not_reached ("\
542 to_execution_direction must be implemented for reverse async");
545 /* Go through the target stack from top to bottom, copying over zero
546 entries in current_target, then filling in still empty entries. In
547 effect, we are doing class inheritance through the pushed target
550 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
551 is currently implemented, is that it discards any knowledge of
552 which target an inherited method originally belonged to.
553 Consequently, new new target methods should instead explicitly and
554 locally search the target stack for the target that can handle the
558 update_current_target (void)
560 struct target_ops
*t
;
562 /* First, reset current's contents. */
563 memset (¤t_target
, 0, sizeof (current_target
));
565 #define INHERIT(FIELD, TARGET) \
566 if (!current_target.FIELD) \
567 current_target.FIELD = (TARGET)->FIELD
569 for (t
= target_stack
; t
; t
= t
->beneath
)
571 INHERIT (to_shortname
, t
);
572 INHERIT (to_longname
, t
);
574 /* Do not inherit to_open. */
575 /* Do not inherit to_close. */
576 /* Do not inherit to_attach. */
577 INHERIT (to_post_attach
, t
);
578 INHERIT (to_attach_no_wait
, t
);
579 /* Do not inherit to_detach. */
580 /* Do not inherit to_disconnect. */
581 /* Do not inherit to_resume. */
582 /* Do not inherit to_wait. */
583 /* Do not inherit to_fetch_registers. */
584 /* Do not inherit to_store_registers. */
585 INHERIT (to_prepare_to_store
, t
);
586 INHERIT (deprecated_xfer_memory
, t
);
587 INHERIT (to_files_info
, t
);
588 /* Do not inherit to_insert_breakpoint. */
589 /* Do not inherit to_remove_breakpoint. */
590 INHERIT (to_can_use_hw_breakpoint
, t
);
591 INHERIT (to_insert_hw_breakpoint
, t
);
592 INHERIT (to_remove_hw_breakpoint
, t
);
593 /* Do not inherit to_ranged_break_num_registers. */
594 INHERIT (to_insert_watchpoint
, t
);
595 INHERIT (to_remove_watchpoint
, t
);
596 /* Do not inherit to_insert_mask_watchpoint. */
597 /* Do not inherit to_remove_mask_watchpoint. */
598 INHERIT (to_stopped_data_address
, t
);
599 INHERIT (to_have_steppable_watchpoint
, t
);
600 INHERIT (to_have_continuable_watchpoint
, t
);
601 INHERIT (to_stopped_by_watchpoint
, t
);
602 INHERIT (to_watchpoint_addr_within_range
, t
);
603 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
604 INHERIT (to_can_accel_watchpoint_condition
, t
);
605 /* Do not inherit to_masked_watch_num_registers. */
606 INHERIT (to_terminal_init
, t
);
607 INHERIT (to_terminal_inferior
, t
);
608 INHERIT (to_terminal_ours_for_output
, t
);
609 INHERIT (to_terminal_ours
, t
);
610 INHERIT (to_terminal_save_ours
, t
);
611 INHERIT (to_terminal_info
, t
);
612 /* Do not inherit to_kill. */
613 INHERIT (to_load
, t
);
614 /* Do no inherit to_create_inferior. */
615 INHERIT (to_post_startup_inferior
, t
);
616 INHERIT (to_insert_fork_catchpoint
, t
);
617 INHERIT (to_remove_fork_catchpoint
, t
);
618 INHERIT (to_insert_vfork_catchpoint
, t
);
619 INHERIT (to_remove_vfork_catchpoint
, t
);
620 /* Do not inherit to_follow_fork. */
621 INHERIT (to_insert_exec_catchpoint
, t
);
622 INHERIT (to_remove_exec_catchpoint
, t
);
623 INHERIT (to_set_syscall_catchpoint
, t
);
624 INHERIT (to_has_exited
, t
);
625 /* Do not inherit to_mourn_inferior. */
626 INHERIT (to_can_run
, t
);
627 /* Do not inherit to_pass_signals. */
628 /* Do not inherit to_program_signals. */
629 /* Do not inherit to_thread_alive. */
630 /* Do not inherit to_find_new_threads. */
631 /* Do not inherit to_pid_to_str. */
632 INHERIT (to_extra_thread_info
, t
);
633 INHERIT (to_thread_name
, t
);
634 INHERIT (to_stop
, t
);
635 /* Do not inherit to_xfer_partial. */
636 INHERIT (to_rcmd
, t
);
637 INHERIT (to_pid_to_exec_file
, t
);
638 INHERIT (to_log_command
, t
);
639 INHERIT (to_stratum
, t
);
640 /* Do not inherit to_has_all_memory. */
641 /* Do not inherit to_has_memory. */
642 /* Do not inherit to_has_stack. */
643 /* Do not inherit to_has_registers. */
644 /* Do not inherit to_has_execution. */
645 INHERIT (to_has_thread_control
, t
);
646 INHERIT (to_can_async_p
, t
);
647 INHERIT (to_is_async_p
, t
);
648 INHERIT (to_async
, t
);
649 INHERIT (to_find_memory_regions
, t
);
650 INHERIT (to_make_corefile_notes
, t
);
651 INHERIT (to_get_bookmark
, t
);
652 INHERIT (to_goto_bookmark
, t
);
653 /* Do not inherit to_get_thread_local_address. */
654 INHERIT (to_can_execute_reverse
, t
);
655 INHERIT (to_execution_direction
, t
);
656 INHERIT (to_thread_architecture
, t
);
657 /* Do not inherit to_read_description. */
658 INHERIT (to_get_ada_task_ptid
, t
);
659 /* Do not inherit to_search_memory. */
660 INHERIT (to_supports_multi_process
, t
);
661 INHERIT (to_supports_enable_disable_tracepoint
, t
);
662 INHERIT (to_supports_string_tracing
, t
);
663 INHERIT (to_trace_init
, t
);
664 INHERIT (to_download_tracepoint
, t
);
665 INHERIT (to_can_download_tracepoint
, t
);
666 INHERIT (to_download_trace_state_variable
, t
);
667 INHERIT (to_enable_tracepoint
, t
);
668 INHERIT (to_disable_tracepoint
, t
);
669 INHERIT (to_trace_set_readonly_regions
, t
);
670 INHERIT (to_trace_start
, t
);
671 INHERIT (to_get_trace_status
, t
);
672 INHERIT (to_get_tracepoint_status
, t
);
673 INHERIT (to_trace_stop
, t
);
674 INHERIT (to_trace_find
, t
);
675 INHERIT (to_get_trace_state_variable_value
, t
);
676 INHERIT (to_save_trace_data
, t
);
677 INHERIT (to_upload_tracepoints
, t
);
678 INHERIT (to_upload_trace_state_variables
, t
);
679 INHERIT (to_get_raw_trace_data
, t
);
680 INHERIT (to_get_min_fast_tracepoint_insn_len
, t
);
681 INHERIT (to_set_disconnected_tracing
, t
);
682 INHERIT (to_set_circular_trace_buffer
, t
);
683 INHERIT (to_set_trace_buffer_size
, t
);
684 INHERIT (to_set_trace_notes
, t
);
685 INHERIT (to_get_tib_address
, t
);
686 INHERIT (to_set_permissions
, t
);
687 INHERIT (to_static_tracepoint_marker_at
, t
);
688 INHERIT (to_static_tracepoint_markers_by_strid
, t
);
689 INHERIT (to_traceframe_info
, t
);
690 INHERIT (to_use_agent
, t
);
691 INHERIT (to_can_use_agent
, t
);
692 INHERIT (to_augmented_libraries_svr4_read
, t
);
693 INHERIT (to_magic
, t
);
694 INHERIT (to_supports_evaluation_of_breakpoint_conditions
, t
);
695 INHERIT (to_can_run_breakpoint_commands
, t
);
696 /* Do not inherit to_memory_map. */
697 /* Do not inherit to_flash_erase. */
698 /* Do not inherit to_flash_done. */
702 /* Clean up a target struct so it no longer has any zero pointers in
703 it. Some entries are defaulted to a method that print an error,
704 others are hard-wired to a standard recursive default. */
706 #define de_fault(field, value) \
707 if (!current_target.field) \
708 current_target.field = value
711 (void (*) (char *, int))
716 de_fault (to_post_attach
,
719 de_fault (to_prepare_to_store
,
720 (void (*) (struct target_ops
*, struct regcache
*))
722 de_fault (deprecated_xfer_memory
,
723 (int (*) (CORE_ADDR
, gdb_byte
*, int, int,
724 struct mem_attrib
*, struct target_ops
*))
726 de_fault (to_files_info
,
727 (void (*) (struct target_ops
*))
729 de_fault (to_can_use_hw_breakpoint
,
730 (int (*) (int, int, int))
732 de_fault (to_insert_hw_breakpoint
,
733 (int (*) (struct gdbarch
*, struct bp_target_info
*))
735 de_fault (to_remove_hw_breakpoint
,
736 (int (*) (struct gdbarch
*, struct bp_target_info
*))
738 de_fault (to_insert_watchpoint
,
739 (int (*) (CORE_ADDR
, int, int, struct expression
*))
741 de_fault (to_remove_watchpoint
,
742 (int (*) (CORE_ADDR
, int, int, struct expression
*))
744 de_fault (to_stopped_by_watchpoint
,
747 de_fault (to_stopped_data_address
,
748 (int (*) (struct target_ops
*, CORE_ADDR
*))
750 de_fault (to_watchpoint_addr_within_range
,
751 default_watchpoint_addr_within_range
);
752 de_fault (to_region_ok_for_hw_watchpoint
,
753 default_region_ok_for_hw_watchpoint
);
754 de_fault (to_can_accel_watchpoint_condition
,
755 (int (*) (CORE_ADDR
, int, int, struct expression
*))
757 de_fault (to_terminal_init
,
760 de_fault (to_terminal_inferior
,
763 de_fault (to_terminal_ours_for_output
,
766 de_fault (to_terminal_ours
,
769 de_fault (to_terminal_save_ours
,
772 de_fault (to_terminal_info
,
773 default_terminal_info
);
775 (void (*) (char *, int))
777 de_fault (to_post_startup_inferior
,
780 de_fault (to_insert_fork_catchpoint
,
783 de_fault (to_remove_fork_catchpoint
,
786 de_fault (to_insert_vfork_catchpoint
,
789 de_fault (to_remove_vfork_catchpoint
,
792 de_fault (to_insert_exec_catchpoint
,
795 de_fault (to_remove_exec_catchpoint
,
798 de_fault (to_set_syscall_catchpoint
,
799 (int (*) (int, int, int, int, int *))
801 de_fault (to_has_exited
,
802 (int (*) (int, int, int *))
804 de_fault (to_can_run
,
806 de_fault (to_extra_thread_info
,
807 (char *(*) (struct thread_info
*))
809 de_fault (to_thread_name
,
810 (char *(*) (struct thread_info
*))
815 current_target
.to_xfer_partial
= current_xfer_partial
;
817 (void (*) (char *, struct ui_file
*))
819 de_fault (to_pid_to_exec_file
,
823 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
825 de_fault (to_thread_architecture
,
826 default_thread_architecture
);
827 current_target
.to_read_description
= NULL
;
828 de_fault (to_get_ada_task_ptid
,
829 (ptid_t (*) (long, long))
830 default_get_ada_task_ptid
);
831 de_fault (to_supports_multi_process
,
834 de_fault (to_supports_enable_disable_tracepoint
,
837 de_fault (to_supports_string_tracing
,
840 de_fault (to_trace_init
,
843 de_fault (to_download_tracepoint
,
844 (void (*) (struct bp_location
*))
846 de_fault (to_can_download_tracepoint
,
849 de_fault (to_download_trace_state_variable
,
850 (void (*) (struct trace_state_variable
*))
852 de_fault (to_enable_tracepoint
,
853 (void (*) (struct bp_location
*))
855 de_fault (to_disable_tracepoint
,
856 (void (*) (struct bp_location
*))
858 de_fault (to_trace_set_readonly_regions
,
861 de_fault (to_trace_start
,
864 de_fault (to_get_trace_status
,
865 (int (*) (struct trace_status
*))
867 de_fault (to_get_tracepoint_status
,
868 (void (*) (struct breakpoint
*, struct uploaded_tp
*))
870 de_fault (to_trace_stop
,
873 de_fault (to_trace_find
,
874 (int (*) (enum trace_find_type
, int, CORE_ADDR
, CORE_ADDR
, int *))
876 de_fault (to_get_trace_state_variable_value
,
877 (int (*) (int, LONGEST
*))
879 de_fault (to_save_trace_data
,
880 (int (*) (const char *))
882 de_fault (to_upload_tracepoints
,
883 (int (*) (struct uploaded_tp
**))
885 de_fault (to_upload_trace_state_variables
,
886 (int (*) (struct uploaded_tsv
**))
888 de_fault (to_get_raw_trace_data
,
889 (LONGEST (*) (gdb_byte
*, ULONGEST
, LONGEST
))
891 de_fault (to_get_min_fast_tracepoint_insn_len
,
894 de_fault (to_set_disconnected_tracing
,
897 de_fault (to_set_circular_trace_buffer
,
900 de_fault (to_set_trace_buffer_size
,
903 de_fault (to_set_trace_notes
,
904 (int (*) (const char *, const char *, const char *))
906 de_fault (to_get_tib_address
,
907 (int (*) (ptid_t
, CORE_ADDR
*))
909 de_fault (to_set_permissions
,
912 de_fault (to_static_tracepoint_marker_at
,
913 (int (*) (CORE_ADDR
, struct static_tracepoint_marker
*))
915 de_fault (to_static_tracepoint_markers_by_strid
,
916 (VEC(static_tracepoint_marker_p
) * (*) (const char *))
918 de_fault (to_traceframe_info
,
919 (struct traceframe_info
* (*) (void))
921 de_fault (to_supports_evaluation_of_breakpoint_conditions
,
924 de_fault (to_can_run_breakpoint_commands
,
927 de_fault (to_use_agent
,
930 de_fault (to_can_use_agent
,
933 de_fault (to_augmented_libraries_svr4_read
,
936 de_fault (to_execution_direction
, default_execution_direction
);
940 /* Finally, position the target-stack beneath the squashed
941 "current_target". That way code looking for a non-inherited
942 target method can quickly and simply find it. */
943 current_target
.beneath
= target_stack
;
946 setup_target_debug ();
949 /* Push a new target type into the stack of the existing target accessors,
950 possibly superseding some of the existing accessors.
952 Rather than allow an empty stack, we always have the dummy target at
953 the bottom stratum, so we can call the function vectors without
957 push_target (struct target_ops
*t
)
959 struct target_ops
**cur
;
961 /* Check magic number. If wrong, it probably means someone changed
962 the struct definition, but not all the places that initialize one. */
963 if (t
->to_magic
!= OPS_MAGIC
)
965 fprintf_unfiltered (gdb_stderr
,
966 "Magic number of %s target struct wrong\n",
968 internal_error (__FILE__
, __LINE__
,
969 _("failed internal consistency check"));
972 /* Find the proper stratum to install this target in. */
973 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
975 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
979 /* If there's already targets at this stratum, remove them. */
980 /* FIXME: cagney/2003-10-15: I think this should be popping all
981 targets to CUR, and not just those at this stratum level. */
982 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
984 /* There's already something at this stratum level. Close it,
985 and un-hook it from the stack. */
986 struct target_ops
*tmp
= (*cur
);
988 (*cur
) = (*cur
)->beneath
;
993 /* We have removed all targets in our stratum, now add the new one. */
997 update_current_target ();
1000 /* Remove a target_ops vector from the stack, wherever it may be.
1001 Return how many times it was removed (0 or 1). */
1004 unpush_target (struct target_ops
*t
)
1006 struct target_ops
**cur
;
1007 struct target_ops
*tmp
;
1009 if (t
->to_stratum
== dummy_stratum
)
1010 internal_error (__FILE__
, __LINE__
,
1011 _("Attempt to unpush the dummy target"));
1013 /* Look for the specified target. Note that we assume that a target
1014 can only occur once in the target stack. */
1016 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1022 /* If we don't find target_ops, quit. Only open targets should be
1027 /* Unchain the target. */
1029 (*cur
) = (*cur
)->beneath
;
1030 tmp
->beneath
= NULL
;
1032 update_current_target ();
1034 /* Finally close the target. Note we do this after unchaining, so
1035 any target method calls from within the target_close
1036 implementation don't end up in T anymore. */
1043 pop_all_targets_above (enum strata above_stratum
)
1045 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
1047 if (!unpush_target (target_stack
))
1049 fprintf_unfiltered (gdb_stderr
,
1050 "pop_all_targets couldn't find target %s\n",
1051 target_stack
->to_shortname
);
1052 internal_error (__FILE__
, __LINE__
,
1053 _("failed internal consistency check"));
1060 pop_all_targets (void)
1062 pop_all_targets_above (dummy_stratum
);
1065 /* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
1068 target_is_pushed (struct target_ops
*t
)
1070 struct target_ops
**cur
;
1072 /* Check magic number. If wrong, it probably means someone changed
1073 the struct definition, but not all the places that initialize one. */
1074 if (t
->to_magic
!= OPS_MAGIC
)
1076 fprintf_unfiltered (gdb_stderr
,
1077 "Magic number of %s target struct wrong\n",
1079 internal_error (__FILE__
, __LINE__
,
1080 _("failed internal consistency check"));
1083 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
1090 /* Using the objfile specified in OBJFILE, find the address for the
1091 current thread's thread-local storage with offset OFFSET. */
1093 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
1095 volatile CORE_ADDR addr
= 0;
1096 struct target_ops
*target
;
1098 for (target
= current_target
.beneath
;
1100 target
= target
->beneath
)
1102 if (target
->to_get_thread_local_address
!= NULL
)
1107 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
1109 ptid_t ptid
= inferior_ptid
;
1110 volatile struct gdb_exception ex
;
1112 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1116 /* Fetch the load module address for this objfile. */
1117 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch (),
1119 /* If it's 0, throw the appropriate exception. */
1121 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1122 _("TLS load module not found"));
1124 addr
= target
->to_get_thread_local_address (target
, ptid
,
1127 /* If an error occurred, print TLS related messages here. Otherwise,
1128 throw the error to some higher catcher. */
1131 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1135 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
1136 error (_("Cannot find thread-local variables "
1137 "in this thread library."));
1139 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
1140 if (objfile_is_library
)
1141 error (_("Cannot find shared library `%s' in dynamic"
1142 " linker's load module list"), objfile_name (objfile
));
1144 error (_("Cannot find executable file `%s' in dynamic"
1145 " linker's load module list"), objfile_name (objfile
));
1147 case TLS_NOT_ALLOCATED_YET_ERROR
:
1148 if (objfile_is_library
)
1149 error (_("The inferior has not yet allocated storage for"
1150 " thread-local variables in\n"
1151 "the shared library `%s'\n"
1153 objfile_name (objfile
), target_pid_to_str (ptid
));
1155 error (_("The inferior has not yet allocated storage for"
1156 " thread-local variables in\n"
1157 "the executable `%s'\n"
1159 objfile_name (objfile
), target_pid_to_str (ptid
));
1161 case TLS_GENERIC_ERROR
:
1162 if (objfile_is_library
)
1163 error (_("Cannot find thread-local storage for %s, "
1164 "shared library %s:\n%s"),
1165 target_pid_to_str (ptid
),
1166 objfile_name (objfile
), ex
.message
);
1168 error (_("Cannot find thread-local storage for %s, "
1169 "executable file %s:\n%s"),
1170 target_pid_to_str (ptid
),
1171 objfile_name (objfile
), ex
.message
);
1174 throw_exception (ex
);
1179 /* It wouldn't be wrong here to try a gdbarch method, too; finding
1180 TLS is an ABI-specific thing. But we don't do that yet. */
1182 error (_("Cannot find thread-local variables on this target"));
1188 target_xfer_error_to_string (enum target_xfer_error err
)
1190 #define CASE(X) case X: return #X
1193 CASE(TARGET_XFER_E_IO
);
1194 CASE(TARGET_XFER_E_UNAVAILABLE
);
1203 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1205 /* target_read_string -- read a null terminated string, up to LEN bytes,
1206 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
1207 Set *STRING to a pointer to malloc'd memory containing the data; the caller
1208 is responsible for freeing it. Return the number of bytes successfully
1212 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
1214 int tlen
, offset
, i
;
1218 int buffer_allocated
;
1220 unsigned int nbytes_read
= 0;
1222 gdb_assert (string
);
1224 /* Small for testing. */
1225 buffer_allocated
= 4;
1226 buffer
= xmalloc (buffer_allocated
);
1231 tlen
= MIN (len
, 4 - (memaddr
& 3));
1232 offset
= memaddr
& 3;
1234 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
1237 /* The transfer request might have crossed the boundary to an
1238 unallocated region of memory. Retry the transfer, requesting
1242 errcode
= target_read_memory (memaddr
, buf
, 1);
1247 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
1251 bytes
= bufptr
- buffer
;
1252 buffer_allocated
*= 2;
1253 buffer
= xrealloc (buffer
, buffer_allocated
);
1254 bufptr
= buffer
+ bytes
;
1257 for (i
= 0; i
< tlen
; i
++)
1259 *bufptr
++ = buf
[i
+ offset
];
1260 if (buf
[i
+ offset
] == '\000')
1262 nbytes_read
+= i
+ 1;
1269 nbytes_read
+= tlen
;
1278 struct target_section_table
*
1279 target_get_section_table (struct target_ops
*target
)
1281 struct target_ops
*t
;
1284 fprintf_unfiltered (gdb_stdlog
, "target_get_section_table ()\n");
1286 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1287 if (t
->to_get_section_table
!= NULL
)
1288 return (*t
->to_get_section_table
) (t
);
1293 /* Find a section containing ADDR. */
1295 struct target_section
*
1296 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1298 struct target_section_table
*table
= target_get_section_table (target
);
1299 struct target_section
*secp
;
1304 for (secp
= table
->sections
; secp
< table
->sections_end
; secp
++)
1306 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1312 /* Read memory from the live target, even if currently inspecting a
1313 traceframe. The return is the same as that of target_read. */
1316 target_read_live_memory (enum target_object object
,
1317 ULONGEST memaddr
, gdb_byte
*myaddr
, ULONGEST len
)
1320 struct cleanup
*cleanup
;
1322 /* Switch momentarily out of tfind mode so to access live memory.
1323 Note that this must not clear global state, such as the frame
1324 cache, which must still remain valid for the previous traceframe.
1325 We may be _building_ the frame cache at this point. */
1326 cleanup
= make_cleanup_restore_traceframe_number ();
1327 set_traceframe_number (-1);
1329 ret
= target_read (current_target
.beneath
, object
, NULL
,
1330 myaddr
, memaddr
, len
);
1332 do_cleanups (cleanup
);
1336 /* Using the set of read-only target sections of OPS, read live
1337 read-only memory. Note that the actual reads start from the
1338 top-most target again.
1340 For interface/parameters/return description see target.h,
1344 memory_xfer_live_readonly_partial (struct target_ops
*ops
,
1345 enum target_object object
,
1346 gdb_byte
*readbuf
, ULONGEST memaddr
,
1349 struct target_section
*secp
;
1350 struct target_section_table
*table
;
1352 secp
= target_section_by_addr (ops
, memaddr
);
1354 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1355 secp
->the_bfd_section
)
1358 struct target_section
*p
;
1359 ULONGEST memend
= memaddr
+ len
;
1361 table
= target_get_section_table (ops
);
1363 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
1365 if (memaddr
>= p
->addr
)
1367 if (memend
<= p
->endaddr
)
1369 /* Entire transfer is within this section. */
1370 return target_read_live_memory (object
, memaddr
,
1373 else if (memaddr
>= p
->endaddr
)
1375 /* This section ends before the transfer starts. */
1380 /* This section overlaps the transfer. Just do half. */
1381 len
= p
->endaddr
- memaddr
;
1382 return target_read_live_memory (object
, memaddr
,
1392 /* Read memory from more than one valid target. A core file, for
1393 instance, could have some of memory but delegate other bits to
1394 the target below it. So, we must manually try all targets. */
1397 raw_memory_xfer_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
1398 const gdb_byte
*writebuf
, ULONGEST memaddr
, LONGEST len
)
1404 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1405 readbuf
, writebuf
, memaddr
, len
);
1409 /* Stop if the target reports that the memory is not available. */
1410 if (res
== TARGET_XFER_E_UNAVAILABLE
)
1413 /* We want to continue past core files to executables, but not
1414 past a running target's memory. */
1415 if (ops
->to_has_all_memory (ops
))
1420 while (ops
!= NULL
);
1425 /* Perform a partial memory transfer.
1426 For docs see target.h, to_xfer_partial. */
1429 memory_xfer_partial_1 (struct target_ops
*ops
, enum target_object object
,
1430 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1435 struct mem_region
*region
;
1436 struct inferior
*inf
;
1438 /* For accesses to unmapped overlay sections, read directly from
1439 files. Must do this first, as MEMADDR may need adjustment. */
1440 if (readbuf
!= NULL
&& overlay_debugging
)
1442 struct obj_section
*section
= find_pc_overlay (memaddr
);
1444 if (pc_in_unmapped_range (memaddr
, section
))
1446 struct target_section_table
*table
1447 = target_get_section_table (ops
);
1448 const char *section_name
= section
->the_bfd_section
->name
;
1450 memaddr
= overlay_mapped_address (memaddr
, section
);
1451 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1454 table
->sections_end
,
1459 /* Try the executable files, if "trust-readonly-sections" is set. */
1460 if (readbuf
!= NULL
&& trust_readonly
)
1462 struct target_section
*secp
;
1463 struct target_section_table
*table
;
1465 secp
= target_section_by_addr (ops
, memaddr
);
1467 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
1468 secp
->the_bfd_section
)
1471 table
= target_get_section_table (ops
);
1472 return section_table_xfer_memory_partial (readbuf
, writebuf
,
1475 table
->sections_end
,
1480 /* If reading unavailable memory in the context of traceframes, and
1481 this address falls within a read-only section, fallback to
1482 reading from live memory. */
1483 if (readbuf
!= NULL
&& get_traceframe_number () != -1)
1485 VEC(mem_range_s
) *available
;
1487 /* If we fail to get the set of available memory, then the
1488 target does not support querying traceframe info, and so we
1489 attempt reading from the traceframe anyway (assuming the
1490 target implements the old QTro packet then). */
1491 if (traceframe_available_memory (&available
, memaddr
, len
))
1493 struct cleanup
*old_chain
;
1495 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
1497 if (VEC_empty (mem_range_s
, available
)
1498 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
1500 /* Don't read into the traceframe's available
1502 if (!VEC_empty (mem_range_s
, available
))
1504 LONGEST oldlen
= len
;
1506 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
1507 gdb_assert (len
<= oldlen
);
1510 do_cleanups (old_chain
);
1512 /* This goes through the topmost target again. */
1513 res
= memory_xfer_live_readonly_partial (ops
, object
,
1514 readbuf
, memaddr
, len
);
1518 /* No use trying further, we know some memory starting
1519 at MEMADDR isn't available. */
1520 return TARGET_XFER_E_UNAVAILABLE
;
1523 /* Don't try to read more than how much is available, in
1524 case the target implements the deprecated QTro packet to
1525 cater for older GDBs (the target's knowledge of read-only
1526 sections may be outdated by now). */
1527 len
= VEC_index (mem_range_s
, available
, 0)->length
;
1529 do_cleanups (old_chain
);
1533 /* Try GDB's internal data cache. */
1534 region
= lookup_mem_region (memaddr
);
1535 /* region->hi == 0 means there's no upper bound. */
1536 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1539 reg_len
= region
->hi
- memaddr
;
1541 switch (region
->attrib
.mode
)
1544 if (writebuf
!= NULL
)
1549 if (readbuf
!= NULL
)
1554 /* We only support writing to flash during "load" for now. */
1555 if (writebuf
!= NULL
)
1556 error (_("Writing to flash memory forbidden in this context"));
1563 if (!ptid_equal (inferior_ptid
, null_ptid
))
1564 inf
= find_inferior_pid (ptid_get_pid (inferior_ptid
));
1569 /* The dcache reads whole cache lines; that doesn't play well
1570 with reading from a trace buffer, because reading outside of
1571 the collected memory range fails. */
1572 && get_traceframe_number () == -1
1573 && (region
->attrib
.cache
1574 || (stack_cache_enabled_p () && object
== TARGET_OBJECT_STACK_MEMORY
)
1575 || (code_cache_enabled_p () && object
== TARGET_OBJECT_CODE_MEMORY
)))
1577 DCACHE
*dcache
= target_dcache_get_or_init ();
1579 if (readbuf
!= NULL
)
1580 res
= dcache_xfer_memory (ops
, dcache
, memaddr
, readbuf
, reg_len
, 0);
1582 /* FIXME drow/2006-08-09: If we're going to preserve const
1583 correctness dcache_xfer_memory should take readbuf and
1585 res
= dcache_xfer_memory (ops
, dcache
, memaddr
, (void *) writebuf
,
1593 /* If none of those methods found the memory we wanted, fall back
1594 to a target partial transfer. Normally a single call to
1595 to_xfer_partial is enough; if it doesn't recognize an object
1596 it will call the to_xfer_partial of the next target down.
1597 But for memory this won't do. Memory is the only target
1598 object which can be read from more than one valid target. */
1599 res
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, memaddr
, reg_len
);
1601 /* Make sure the cache gets updated no matter what - if we are writing
1602 to the stack. Even if this write is not tagged as such, we still need
1603 to update the cache. */
1608 && target_dcache_init_p ()
1609 && !region
->attrib
.cache
1610 && ((stack_cache_enabled_p () && object
!= TARGET_OBJECT_STACK_MEMORY
)
1611 || (code_cache_enabled_p () && object
!= TARGET_OBJECT_CODE_MEMORY
)))
1613 DCACHE
*dcache
= target_dcache_get ();
1615 dcache_update (dcache
, memaddr
, (void *) writebuf
, res
);
1618 /* If we still haven't got anything, return the last error. We
1623 /* Perform a partial memory transfer. For docs see target.h,
1627 memory_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1628 gdb_byte
*readbuf
, const gdb_byte
*writebuf
, ULONGEST memaddr
,
1633 /* Zero length requests are ok and require no work. */
1637 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1638 breakpoint insns, thus hiding out from higher layers whether
1639 there are software breakpoints inserted in the code stream. */
1640 if (readbuf
!= NULL
)
1642 res
= memory_xfer_partial_1 (ops
, object
, readbuf
, NULL
, memaddr
, len
);
1644 if (res
> 0 && !show_memory_breakpoints
)
1645 breakpoint_xfer_memory (readbuf
, NULL
, NULL
, memaddr
, res
);
1650 struct cleanup
*old_chain
;
1652 /* A large write request is likely to be partially satisfied
1653 by memory_xfer_partial_1. We will continually malloc
1654 and free a copy of the entire write request for breakpoint
1655 shadow handling even though we only end up writing a small
1656 subset of it. Cap writes to 4KB to mitigate this. */
1657 len
= min (4096, len
);
1659 buf
= xmalloc (len
);
1660 old_chain
= make_cleanup (xfree
, buf
);
1661 memcpy (buf
, writebuf
, len
);
1663 breakpoint_xfer_memory (NULL
, buf
, writebuf
, memaddr
, len
);
1664 res
= memory_xfer_partial_1 (ops
, object
, NULL
, buf
, memaddr
, len
);
1666 do_cleanups (old_chain
);
1673 restore_show_memory_breakpoints (void *arg
)
1675 show_memory_breakpoints
= (uintptr_t) arg
;
1679 make_show_memory_breakpoints_cleanup (int show
)
1681 int current
= show_memory_breakpoints
;
1683 show_memory_breakpoints
= show
;
1684 return make_cleanup (restore_show_memory_breakpoints
,
1685 (void *) (uintptr_t) current
);
1688 /* For docs see target.h, to_xfer_partial. */
1691 target_xfer_partial (struct target_ops
*ops
,
1692 enum target_object object
, const char *annex
,
1693 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1694 ULONGEST offset
, ULONGEST len
)
1698 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1700 if (writebuf
&& !may_write_memory
)
1701 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1702 core_addr_to_string_nz (offset
), plongest (len
));
1704 /* If this is a memory transfer, let the memory-specific code
1705 have a look at it instead. Memory transfers are more
1707 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1708 || object
== TARGET_OBJECT_CODE_MEMORY
)
1709 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1710 writebuf
, offset
, len
);
1711 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1713 /* Request the normal memory object from other layers. */
1714 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1717 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1718 writebuf
, offset
, len
);
1722 const unsigned char *myaddr
= NULL
;
1724 fprintf_unfiltered (gdb_stdlog
,
1725 "%s:target_xfer_partial "
1726 "(%d, %s, %s, %s, %s, %s) = %s",
1729 (annex
? annex
: "(null)"),
1730 host_address_to_string (readbuf
),
1731 host_address_to_string (writebuf
),
1732 core_addr_to_string_nz (offset
),
1733 pulongest (len
), plongest (retval
));
1739 if (retval
> 0 && myaddr
!= NULL
)
1743 fputs_unfiltered (", bytes =", gdb_stdlog
);
1744 for (i
= 0; i
< retval
; i
++)
1746 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1748 if (targetdebug
< 2 && i
> 0)
1750 fprintf_unfiltered (gdb_stdlog
, " ...");
1753 fprintf_unfiltered (gdb_stdlog
, "\n");
1756 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1760 fputc_unfiltered ('\n', gdb_stdlog
);
1765 /* Read LEN bytes of target memory at address MEMADDR, placing the
1766 results in GDB's memory at MYADDR. Returns either 0 for success or
1767 a target_xfer_error value if any error occurs.
1769 If an error occurs, no guarantee is made about the contents of the data at
1770 MYADDR. In particular, the caller should not depend upon partial reads
1771 filling the buffer with good data. There is no way for the caller to know
1772 how much good data might have been transfered anyway. Callers that can
1773 deal with partial reads should call target_read (which will retry until
1774 it makes no progress, and then return how much was transferred). */
1777 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1779 /* Dispatch to the topmost target, not the flattened current_target.
1780 Memory accesses check target->to_has_(all_)memory, and the
1781 flattened target doesn't inherit those. */
1782 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1783 myaddr
, memaddr
, len
) == len
)
1786 return TARGET_XFER_E_IO
;
1789 /* Like target_read_memory, but specify explicitly that this is a read
1790 from the target's raw memory. That is, this read bypasses the
1791 dcache, breakpoint shadowing, etc. */
1794 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1796 /* See comment in target_read_memory about why the request starts at
1797 current_target.beneath. */
1798 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1799 myaddr
, memaddr
, len
) == len
)
1802 return TARGET_XFER_E_IO
;
1805 /* Like target_read_memory, but specify explicitly that this is a read from
1806 the target's stack. This may trigger different cache behavior. */
1809 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1811 /* See comment in target_read_memory about why the request starts at
1812 current_target.beneath. */
1813 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1814 myaddr
, memaddr
, len
) == len
)
1817 return TARGET_XFER_E_IO
;
1820 /* Like target_read_memory, but specify explicitly that this is a read from
1821 the target's code. This may trigger different cache behavior. */
1824 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1826 /* See comment in target_read_memory about why the request starts at
1827 current_target.beneath. */
1828 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1829 myaddr
, memaddr
, len
) == len
)
1832 return TARGET_XFER_E_IO
;
1835 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1836 Returns either 0 for success or a target_xfer_error value if any
1837 error occurs. If an error occurs, no guarantee is made about how
1838 much data got written. Callers that can deal with partial writes
1839 should call target_write. */
1842 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1844 /* See comment in target_read_memory about why the request starts at
1845 current_target.beneath. */
1846 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1847 myaddr
, memaddr
, len
) == len
)
1850 return TARGET_XFER_E_IO
;
1853 /* Write LEN bytes from MYADDR to target raw memory at address
1854 MEMADDR. Returns either 0 for success or a target_xfer_error value
1855 if any error occurs. If an error occurs, no guarantee is made
1856 about how much data got written. Callers that can deal with
1857 partial writes should call target_write. */
1860 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1862 /* See comment in target_read_memory about why the request starts at
1863 current_target.beneath. */
1864 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1865 myaddr
, memaddr
, len
) == len
)
1868 return TARGET_XFER_E_IO
;
1871 /* Fetch the target's memory map. */
1874 target_memory_map (void)
1876 VEC(mem_region_s
) *result
;
1877 struct mem_region
*last_one
, *this_one
;
1879 struct target_ops
*t
;
1882 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1884 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1885 if (t
->to_memory_map
!= NULL
)
1891 result
= t
->to_memory_map (t
);
1895 qsort (VEC_address (mem_region_s
, result
),
1896 VEC_length (mem_region_s
, result
),
1897 sizeof (struct mem_region
), mem_region_cmp
);
1899 /* Check that regions do not overlap. Simultaneously assign
1900 a numbering for the "mem" commands to use to refer to
1903 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1905 this_one
->number
= ix
;
1907 if (last_one
&& last_one
->hi
> this_one
->lo
)
1909 warning (_("Overlapping regions in memory map: ignoring"));
1910 VEC_free (mem_region_s
, result
);
1913 last_one
= this_one
;
1920 target_flash_erase (ULONGEST address
, LONGEST length
)
1922 struct target_ops
*t
;
1924 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1925 if (t
->to_flash_erase
!= NULL
)
1928 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1929 hex_string (address
), phex (length
, 0));
1930 t
->to_flash_erase (t
, address
, length
);
1938 target_flash_done (void)
1940 struct target_ops
*t
;
1942 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1943 if (t
->to_flash_done
!= NULL
)
1946 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1947 t
->to_flash_done (t
);
1955 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1956 struct cmd_list_element
*c
, const char *value
)
1958 fprintf_filtered (file
,
1959 _("Mode for reading from readonly sections is %s.\n"),
1963 /* More generic transfers. */
1966 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1967 const char *annex
, gdb_byte
*readbuf
,
1968 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
1970 if (object
== TARGET_OBJECT_MEMORY
1971 && ops
->deprecated_xfer_memory
!= NULL
)
1972 /* If available, fall back to the target's
1973 "deprecated_xfer_memory" method. */
1978 if (writebuf
!= NULL
)
1980 void *buffer
= xmalloc (len
);
1981 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1983 memcpy (buffer
, writebuf
, len
);
1984 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1985 1/*write*/, NULL
, ops
);
1986 do_cleanups (cleanup
);
1988 if (readbuf
!= NULL
)
1989 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1990 0/*read*/, NULL
, ops
);
1993 else if (xfered
== 0 && errno
== 0)
1994 /* "deprecated_xfer_memory" uses 0, cross checked against
1995 ERRNO as one indication of an error. */
2000 else if (ops
->beneath
!= NULL
)
2001 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2002 readbuf
, writebuf
, offset
, len
);
2007 /* The xfer_partial handler for the topmost target. Unlike the default,
2008 it does not need to handle memory specially; it just passes all
2009 requests down the stack. */
2012 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2013 const char *annex
, gdb_byte
*readbuf
,
2014 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
2016 if (ops
->beneath
!= NULL
)
2017 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2018 readbuf
, writebuf
, offset
, len
);
2023 /* Target vector read/write partial wrapper functions. */
2026 target_read_partial (struct target_ops
*ops
,
2027 enum target_object object
,
2028 const char *annex
, gdb_byte
*buf
,
2029 ULONGEST offset
, LONGEST len
)
2031 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
2035 target_write_partial (struct target_ops
*ops
,
2036 enum target_object object
,
2037 const char *annex
, const gdb_byte
*buf
,
2038 ULONGEST offset
, LONGEST len
)
2040 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
2043 /* Wrappers to perform the full transfer. */
2045 /* For docs on target_read see target.h. */
2048 target_read (struct target_ops
*ops
,
2049 enum target_object object
,
2050 const char *annex
, gdb_byte
*buf
,
2051 ULONGEST offset
, LONGEST len
)
2055 while (xfered
< len
)
2057 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
2058 (gdb_byte
*) buf
+ xfered
,
2059 offset
+ xfered
, len
- xfered
);
2061 /* Call an observer, notifying them of the xfer progress? */
2072 /* Assuming that the entire [begin, end) range of memory cannot be
2073 read, try to read whatever subrange is possible to read.
2075 The function returns, in RESULT, either zero or one memory block.
2076 If there's a readable subrange at the beginning, it is completely
2077 read and returned. Any further readable subrange will not be read.
2078 Otherwise, if there's a readable subrange at the end, it will be
2079 completely read and returned. Any readable subranges before it
2080 (obviously, not starting at the beginning), will be ignored. In
2081 other cases -- either no readable subrange, or readable subrange(s)
2082 that is neither at the beginning, or end, nothing is returned.
2084 The purpose of this function is to handle a read across a boundary
2085 of accessible memory in a case when memory map is not available.
2086 The above restrictions are fine for this case, but will give
2087 incorrect results if the memory is 'patchy'. However, supporting
2088 'patchy' memory would require trying to read every single byte,
2089 and it seems unacceptable solution. Explicit memory map is
2090 recommended for this case -- and target_read_memory_robust will
2091 take care of reading multiple ranges then. */
2094 read_whatever_is_readable (struct target_ops
*ops
,
2095 ULONGEST begin
, ULONGEST end
,
2096 VEC(memory_read_result_s
) **result
)
2098 gdb_byte
*buf
= xmalloc (end
- begin
);
2099 ULONGEST current_begin
= begin
;
2100 ULONGEST current_end
= end
;
2102 memory_read_result_s r
;
2104 /* If we previously failed to read 1 byte, nothing can be done here. */
2105 if (end
- begin
<= 1)
2111 /* Check that either first or the last byte is readable, and give up
2112 if not. This heuristic is meant to permit reading accessible memory
2113 at the boundary of accessible region. */
2114 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2115 buf
, begin
, 1) == 1)
2120 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2121 buf
+ (end
-begin
) - 1, end
- 1, 1) == 1)
2132 /* Loop invariant is that the [current_begin, current_end) was previously
2133 found to be not readable as a whole.
2135 Note loop condition -- if the range has 1 byte, we can't divide the range
2136 so there's no point trying further. */
2137 while (current_end
- current_begin
> 1)
2139 ULONGEST first_half_begin
, first_half_end
;
2140 ULONGEST second_half_begin
, second_half_end
;
2142 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
2146 first_half_begin
= current_begin
;
2147 first_half_end
= middle
;
2148 second_half_begin
= middle
;
2149 second_half_end
= current_end
;
2153 first_half_begin
= middle
;
2154 first_half_end
= current_end
;
2155 second_half_begin
= current_begin
;
2156 second_half_end
= middle
;
2159 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2160 buf
+ (first_half_begin
- begin
),
2162 first_half_end
- first_half_begin
);
2164 if (xfer
== first_half_end
- first_half_begin
)
2166 /* This half reads up fine. So, the error must be in the
2168 current_begin
= second_half_begin
;
2169 current_end
= second_half_end
;
2173 /* This half is not readable. Because we've tried one byte, we
2174 know some part of this half if actually redable. Go to the next
2175 iteration to divide again and try to read.
2177 We don't handle the other half, because this function only tries
2178 to read a single readable subrange. */
2179 current_begin
= first_half_begin
;
2180 current_end
= first_half_end
;
2186 /* The [begin, current_begin) range has been read. */
2188 r
.end
= current_begin
;
2193 /* The [current_end, end) range has been read. */
2194 LONGEST rlen
= end
- current_end
;
2196 r
.data
= xmalloc (rlen
);
2197 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2198 r
.begin
= current_end
;
2202 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2206 free_memory_read_result_vector (void *x
)
2208 VEC(memory_read_result_s
) *v
= x
;
2209 memory_read_result_s
*current
;
2212 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2214 xfree (current
->data
);
2216 VEC_free (memory_read_result_s
, v
);
2219 VEC(memory_read_result_s
) *
2220 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2222 VEC(memory_read_result_s
) *result
= 0;
2225 while (xfered
< len
)
2227 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2230 /* If there is no explicit region, a fake one should be created. */
2231 gdb_assert (region
);
2233 if (region
->hi
== 0)
2234 rlen
= len
- xfered
;
2236 rlen
= region
->hi
- offset
;
2238 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2240 /* Cannot read this region. Note that we can end up here only
2241 if the region is explicitly marked inaccessible, or
2242 'inaccessible-by-default' is in effect. */
2247 LONGEST to_read
= min (len
- xfered
, rlen
);
2248 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2250 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2251 (gdb_byte
*) buffer
,
2252 offset
+ xfered
, to_read
);
2253 /* Call an observer, notifying them of the xfer progress? */
2256 /* Got an error reading full chunk. See if maybe we can read
2259 read_whatever_is_readable (ops
, offset
+ xfered
,
2260 offset
+ xfered
+ to_read
, &result
);
2265 struct memory_read_result r
;
2267 r
.begin
= offset
+ xfered
;
2268 r
.end
= r
.begin
+ xfer
;
2269 VEC_safe_push (memory_read_result_s
, result
, &r
);
2279 /* An alternative to target_write with progress callbacks. */
2282 target_write_with_progress (struct target_ops
*ops
,
2283 enum target_object object
,
2284 const char *annex
, const gdb_byte
*buf
,
2285 ULONGEST offset
, LONGEST len
,
2286 void (*progress
) (ULONGEST
, void *), void *baton
)
2290 /* Give the progress callback a chance to set up. */
2292 (*progress
) (0, baton
);
2294 while (xfered
< len
)
2296 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
2297 (gdb_byte
*) buf
+ xfered
,
2298 offset
+ xfered
, len
- xfered
);
2306 (*progress
) (xfer
, baton
);
2314 /* For docs on target_write see target.h. */
2317 target_write (struct target_ops
*ops
,
2318 enum target_object object
,
2319 const char *annex
, const gdb_byte
*buf
,
2320 ULONGEST offset
, LONGEST len
)
2322 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2326 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2327 the size of the transferred data. PADDING additional bytes are
2328 available in *BUF_P. This is a helper function for
2329 target_read_alloc; see the declaration of that function for more
2333 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2334 const char *annex
, gdb_byte
**buf_p
, int padding
)
2336 size_t buf_alloc
, buf_pos
;
2340 /* This function does not have a length parameter; it reads the
2341 entire OBJECT). Also, it doesn't support objects fetched partly
2342 from one target and partly from another (in a different stratum,
2343 e.g. a core file and an executable). Both reasons make it
2344 unsuitable for reading memory. */
2345 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2347 /* Start by reading up to 4K at a time. The target will throttle
2348 this number down if necessary. */
2350 buf
= xmalloc (buf_alloc
);
2354 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2355 buf_pos
, buf_alloc
- buf_pos
- padding
);
2358 /* An error occurred. */
2364 /* Read all there was. */
2374 /* If the buffer is filling up, expand it. */
2375 if (buf_alloc
< buf_pos
* 2)
2378 buf
= xrealloc (buf
, buf_alloc
);
2385 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2386 the size of the transferred data. See the declaration in "target.h"
2387 function for more information about the return value. */
2390 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2391 const char *annex
, gdb_byte
**buf_p
)
2393 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2396 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2397 returned as a string, allocated using xmalloc. If an error occurs
2398 or the transfer is unsupported, NULL is returned. Empty objects
2399 are returned as allocated but empty strings. A warning is issued
2400 if the result contains any embedded NUL bytes. */
2403 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2408 LONGEST i
, transferred
;
2410 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2411 bufstr
= (char *) buffer
;
2413 if (transferred
< 0)
2416 if (transferred
== 0)
2417 return xstrdup ("");
2419 bufstr
[transferred
] = 0;
2421 /* Check for embedded NUL bytes; but allow trailing NULs. */
2422 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2425 warning (_("target object %d, annex %s, "
2426 "contained unexpected null characters"),
2427 (int) object
, annex
? annex
: "(none)");
2434 /* Memory transfer methods. */
2437 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2440 /* This method is used to read from an alternate, non-current
2441 target. This read must bypass the overlay support (as symbols
2442 don't match this target), and GDB's internal cache (wrong cache
2443 for this target). */
2444 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2446 memory_error (TARGET_XFER_E_IO
, addr
);
2450 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2451 int len
, enum bfd_endian byte_order
)
2453 gdb_byte buf
[sizeof (ULONGEST
)];
2455 gdb_assert (len
<= sizeof (buf
));
2456 get_target_memory (ops
, addr
, buf
, len
);
2457 return extract_unsigned_integer (buf
, len
, byte_order
);
2463 forward_target_insert_breakpoint (struct target_ops
*ops
,
2464 struct gdbarch
*gdbarch
,
2465 struct bp_target_info
*bp_tgt
)
2467 for (; ops
!= NULL
; ops
= ops
->beneath
)
2468 if (ops
->to_insert_breakpoint
!= NULL
)
2469 return ops
->to_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
2471 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
2477 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2478 struct bp_target_info
*bp_tgt
)
2480 if (!may_insert_breakpoints
)
2482 warning (_("May not insert breakpoints"));
2486 return forward_target_insert_breakpoint (¤t_target
, gdbarch
, bp_tgt
);
2492 forward_target_remove_breakpoint (struct target_ops
*ops
,
2493 struct gdbarch
*gdbarch
,
2494 struct bp_target_info
*bp_tgt
)
2496 /* This is kind of a weird case to handle, but the permission might
2497 have been changed after breakpoints were inserted - in which case
2498 we should just take the user literally and assume that any
2499 breakpoints should be left in place. */
2500 if (!may_insert_breakpoints
)
2502 warning (_("May not remove breakpoints"));
2506 for (; ops
!= NULL
; ops
= ops
->beneath
)
2507 if (ops
->to_remove_breakpoint
!= NULL
)
2508 return ops
->to_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
2510 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
2516 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2517 struct bp_target_info
*bp_tgt
)
2519 return forward_target_remove_breakpoint (¤t_target
, gdbarch
, bp_tgt
);
2523 target_info (char *args
, int from_tty
)
2525 struct target_ops
*t
;
2526 int has_all_mem
= 0;
2528 if (symfile_objfile
!= NULL
)
2529 printf_unfiltered (_("Symbols from \"%s\".\n"),
2530 objfile_name (symfile_objfile
));
2532 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2534 if (!(*t
->to_has_memory
) (t
))
2537 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2540 printf_unfiltered (_("\tWhile running this, "
2541 "GDB does not access memory from...\n"));
2542 printf_unfiltered ("%s:\n", t
->to_longname
);
2543 (t
->to_files_info
) (t
);
2544 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2548 /* This function is called before any new inferior is created, e.g.
2549 by running a program, attaching, or connecting to a target.
2550 It cleans up any state from previous invocations which might
2551 change between runs. This is a subset of what target_preopen
2552 resets (things which might change between targets). */
2555 target_pre_inferior (int from_tty
)
2557 /* Clear out solib state. Otherwise the solib state of the previous
2558 inferior might have survived and is entirely wrong for the new
2559 target. This has been observed on GNU/Linux using glibc 2.3. How
2571 Cannot access memory at address 0xdeadbeef
2574 /* In some OSs, the shared library list is the same/global/shared
2575 across inferiors. If code is shared between processes, so are
2576 memory regions and features. */
2577 if (!gdbarch_has_global_solist (target_gdbarch ()))
2579 no_shared_libraries (NULL
, from_tty
);
2581 invalidate_target_mem_regions ();
2583 target_clear_description ();
2586 agent_capability_invalidate ();
2589 /* Callback for iterate_over_inferiors. Gets rid of the given
2593 dispose_inferior (struct inferior
*inf
, void *args
)
2595 struct thread_info
*thread
;
2597 thread
= any_thread_of_process (inf
->pid
);
2600 switch_to_thread (thread
->ptid
);
2602 /* Core inferiors actually should be detached, not killed. */
2603 if (target_has_execution
)
2606 target_detach (NULL
, 0);
2612 /* This is to be called by the open routine before it does
2616 target_preopen (int from_tty
)
2620 if (have_inferiors ())
2623 || !have_live_inferiors ()
2624 || query (_("A program is being debugged already. Kill it? ")))
2625 iterate_over_inferiors (dispose_inferior
, NULL
);
2627 error (_("Program not killed."));
2630 /* Calling target_kill may remove the target from the stack. But if
2631 it doesn't (which seems like a win for UDI), remove it now. */
2632 /* Leave the exec target, though. The user may be switching from a
2633 live process to a core of the same program. */
2634 pop_all_targets_above (file_stratum
);
2636 target_pre_inferior (from_tty
);
2639 /* Detach a target after doing deferred register stores. */
2642 target_detach (const char *args
, int from_tty
)
2644 struct target_ops
* t
;
2646 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2647 /* Don't remove global breakpoints here. They're removed on
2648 disconnection from the target. */
2651 /* If we're in breakpoints-always-inserted mode, have to remove
2652 them before detaching. */
2653 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2655 prepare_for_detach ();
2657 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2659 if (t
->to_detach
!= NULL
)
2661 t
->to_detach (t
, args
, from_tty
);
2663 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2669 internal_error (__FILE__
, __LINE__
, _("could not find a target to detach"));
2673 target_disconnect (char *args
, int from_tty
)
2675 struct target_ops
*t
;
2677 /* If we're in breakpoints-always-inserted mode or if breakpoints
2678 are global across processes, we have to remove them before
2680 remove_breakpoints ();
2682 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2683 if (t
->to_disconnect
!= NULL
)
2686 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2688 t
->to_disconnect (t
, args
, from_tty
);
2696 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2698 struct target_ops
*t
;
2700 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2702 if (t
->to_wait
!= NULL
)
2704 ptid_t retval
= (*t
->to_wait
) (t
, ptid
, status
, options
);
2708 char *status_string
;
2709 char *options_string
;
2711 status_string
= target_waitstatus_to_string (status
);
2712 options_string
= target_options_to_string (options
);
2713 fprintf_unfiltered (gdb_stdlog
,
2714 "target_wait (%d, status, options={%s})"
2716 ptid_get_pid (ptid
), options_string
,
2717 ptid_get_pid (retval
), status_string
);
2718 xfree (status_string
);
2719 xfree (options_string
);
2730 target_pid_to_str (ptid_t ptid
)
2732 struct target_ops
*t
;
2734 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2736 if (t
->to_pid_to_str
!= NULL
)
2737 return (*t
->to_pid_to_str
) (t
, ptid
);
2740 return normal_pid_to_str (ptid
);
2744 target_thread_name (struct thread_info
*info
)
2746 struct target_ops
*t
;
2748 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2750 if (t
->to_thread_name
!= NULL
)
2751 return (*t
->to_thread_name
) (info
);
2758 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2760 struct target_ops
*t
;
2762 target_dcache_invalidate ();
2764 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2766 if (t
->to_resume
!= NULL
)
2768 t
->to_resume (t
, ptid
, step
, signal
);
2770 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2771 ptid_get_pid (ptid
),
2772 step
? "step" : "continue",
2773 gdb_signal_to_name (signal
));
2775 registers_changed_ptid (ptid
);
2776 set_executing (ptid
, 1);
2777 set_running (ptid
, 1);
2778 clear_inline_frame_state (ptid
);
2787 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2789 struct target_ops
*t
;
2791 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2793 if (t
->to_pass_signals
!= NULL
)
2799 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2802 for (i
= 0; i
< numsigs
; i
++)
2803 if (pass_signals
[i
])
2804 fprintf_unfiltered (gdb_stdlog
, " %s",
2805 gdb_signal_to_name (i
));
2807 fprintf_unfiltered (gdb_stdlog
, " })\n");
2810 (*t
->to_pass_signals
) (numsigs
, pass_signals
);
2817 target_program_signals (int numsigs
, unsigned char *program_signals
)
2819 struct target_ops
*t
;
2821 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2823 if (t
->to_program_signals
!= NULL
)
2829 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2832 for (i
= 0; i
< numsigs
; i
++)
2833 if (program_signals
[i
])
2834 fprintf_unfiltered (gdb_stdlog
, " %s",
2835 gdb_signal_to_name (i
));
2837 fprintf_unfiltered (gdb_stdlog
, " })\n");
2840 (*t
->to_program_signals
) (numsigs
, program_signals
);
2846 /* Look through the list of possible targets for a target that can
2850 target_follow_fork (int follow_child
, int detach_fork
)
2852 struct target_ops
*t
;
2854 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2856 if (t
->to_follow_fork
!= NULL
)
2858 int retval
= t
->to_follow_fork (t
, follow_child
, detach_fork
);
2861 fprintf_unfiltered (gdb_stdlog
,
2862 "target_follow_fork (%d, %d) = %d\n",
2863 follow_child
, detach_fork
, retval
);
2868 /* Some target returned a fork event, but did not know how to follow it. */
2869 internal_error (__FILE__
, __LINE__
,
2870 _("could not find a target to follow fork"));
2874 target_mourn_inferior (void)
2876 struct target_ops
*t
;
2878 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2880 if (t
->to_mourn_inferior
!= NULL
)
2882 t
->to_mourn_inferior (t
);
2884 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2886 /* We no longer need to keep handles on any of the object files.
2887 Make sure to release them to avoid unnecessarily locking any
2888 of them while we're not actually debugging. */
2889 bfd_cache_close_all ();
2895 internal_error (__FILE__
, __LINE__
,
2896 _("could not find a target to follow mourn inferior"));
2899 /* Look for a target which can describe architectural features, starting
2900 from TARGET. If we find one, return its description. */
2902 const struct target_desc
*
2903 target_read_description (struct target_ops
*target
)
2905 struct target_ops
*t
;
2907 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2908 if (t
->to_read_description
!= NULL
)
2910 const struct target_desc
*tdesc
;
2912 tdesc
= t
->to_read_description (t
);
2920 /* The default implementation of to_search_memory.
2921 This implements a basic search of memory, reading target memory and
2922 performing the search here (as opposed to performing the search in on the
2923 target side with, for example, gdbserver). */
2926 simple_search_memory (struct target_ops
*ops
,
2927 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2928 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2929 CORE_ADDR
*found_addrp
)
2931 /* NOTE: also defined in find.c testcase. */
2932 #define SEARCH_CHUNK_SIZE 16000
2933 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2934 /* Buffer to hold memory contents for searching. */
2935 gdb_byte
*search_buf
;
2936 unsigned search_buf_size
;
2937 struct cleanup
*old_cleanups
;
2939 search_buf_size
= chunk_size
+ pattern_len
- 1;
2941 /* No point in trying to allocate a buffer larger than the search space. */
2942 if (search_space_len
< search_buf_size
)
2943 search_buf_size
= search_space_len
;
2945 search_buf
= malloc (search_buf_size
);
2946 if (search_buf
== NULL
)
2947 error (_("Unable to allocate memory to perform the search."));
2948 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2950 /* Prime the search buffer. */
2952 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2953 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2955 warning (_("Unable to access %s bytes of target "
2956 "memory at %s, halting search."),
2957 pulongest (search_buf_size
), hex_string (start_addr
));
2958 do_cleanups (old_cleanups
);
2962 /* Perform the search.
2964 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2965 When we've scanned N bytes we copy the trailing bytes to the start and
2966 read in another N bytes. */
2968 while (search_space_len
>= pattern_len
)
2970 gdb_byte
*found_ptr
;
2971 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2973 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2974 pattern
, pattern_len
);
2976 if (found_ptr
!= NULL
)
2978 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2980 *found_addrp
= found_addr
;
2981 do_cleanups (old_cleanups
);
2985 /* Not found in this chunk, skip to next chunk. */
2987 /* Don't let search_space_len wrap here, it's unsigned. */
2988 if (search_space_len
>= chunk_size
)
2989 search_space_len
-= chunk_size
;
2991 search_space_len
= 0;
2993 if (search_space_len
>= pattern_len
)
2995 unsigned keep_len
= search_buf_size
- chunk_size
;
2996 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
2999 /* Copy the trailing part of the previous iteration to the front
3000 of the buffer for the next iteration. */
3001 gdb_assert (keep_len
== pattern_len
- 1);
3002 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
3004 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
3006 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3007 search_buf
+ keep_len
, read_addr
,
3008 nr_to_read
) != nr_to_read
)
3010 warning (_("Unable to access %s bytes of target "
3011 "memory at %s, halting search."),
3012 plongest (nr_to_read
),
3013 hex_string (read_addr
));
3014 do_cleanups (old_cleanups
);
3018 start_addr
+= chunk_size
;
3024 do_cleanups (old_cleanups
);
3028 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
3029 sequence of bytes in PATTERN with length PATTERN_LEN.
3031 The result is 1 if found, 0 if not found, and -1 if there was an error
3032 requiring halting of the search (e.g. memory read error).
3033 If the pattern is found the address is recorded in FOUND_ADDRP. */
3036 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
3037 const gdb_byte
*pattern
, ULONGEST pattern_len
,
3038 CORE_ADDR
*found_addrp
)
3040 struct target_ops
*t
;
3043 /* We don't use INHERIT to set current_target.to_search_memory,
3044 so we have to scan the target stack and handle targetdebug
3048 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
3049 hex_string (start_addr
));
3051 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3052 if (t
->to_search_memory
!= NULL
)
3057 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
3058 pattern
, pattern_len
, found_addrp
);
3062 /* If a special version of to_search_memory isn't available, use the
3064 found
= simple_search_memory (current_target
.beneath
,
3065 start_addr
, search_space_len
,
3066 pattern
, pattern_len
, found_addrp
);
3070 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
3075 /* Look through the currently pushed targets. If none of them will
3076 be able to restart the currently running process, issue an error
3080 target_require_runnable (void)
3082 struct target_ops
*t
;
3084 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3086 /* If this target knows how to create a new program, then
3087 assume we will still be able to after killing the current
3088 one. Either killing and mourning will not pop T, or else
3089 find_default_run_target will find it again. */
3090 if (t
->to_create_inferior
!= NULL
)
3093 /* Do not worry about thread_stratum targets that can not
3094 create inferiors. Assume they will be pushed again if
3095 necessary, and continue to the process_stratum. */
3096 if (t
->to_stratum
== thread_stratum
3097 || t
->to_stratum
== arch_stratum
)
3100 error (_("The \"%s\" target does not support \"run\". "
3101 "Try \"help target\" or \"continue\"."),
3105 /* This function is only called if the target is running. In that
3106 case there should have been a process_stratum target and it
3107 should either know how to create inferiors, or not... */
3108 internal_error (__FILE__
, __LINE__
, _("No targets found"));
3111 /* Look through the list of possible targets for a target that can
3112 execute a run or attach command without any other data. This is
3113 used to locate the default process stratum.
3115 If DO_MESG is not NULL, the result is always valid (error() is
3116 called for errors); else, return NULL on error. */
3118 static struct target_ops
*
3119 find_default_run_target (char *do_mesg
)
3121 struct target_ops
**t
;
3122 struct target_ops
*runable
= NULL
;
3127 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
3130 if ((*t
)->to_can_run
&& target_can_run (*t
))
3140 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
3149 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3151 struct target_ops
*t
;
3153 t
= find_default_run_target ("attach");
3154 (t
->to_attach
) (t
, args
, from_tty
);
3159 find_default_create_inferior (struct target_ops
*ops
,
3160 char *exec_file
, char *allargs
, char **env
,
3163 struct target_ops
*t
;
3165 t
= find_default_run_target ("run");
3166 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
3171 find_default_can_async_p (void)
3173 struct target_ops
*t
;
3175 /* This may be called before the target is pushed on the stack;
3176 look for the default process stratum. If there's none, gdb isn't
3177 configured with a native debugger, and target remote isn't
3179 t
= find_default_run_target (NULL
);
3180 if (t
&& t
->to_can_async_p
)
3181 return (t
->to_can_async_p
) ();
3186 find_default_is_async_p (void)
3188 struct target_ops
*t
;
3190 /* This may be called before the target is pushed on the stack;
3191 look for the default process stratum. If there's none, gdb isn't
3192 configured with a native debugger, and target remote isn't
3194 t
= find_default_run_target (NULL
);
3195 if (t
&& t
->to_is_async_p
)
3196 return (t
->to_is_async_p
) ();
3201 find_default_supports_non_stop (void)
3203 struct target_ops
*t
;
3205 t
= find_default_run_target (NULL
);
3206 if (t
&& t
->to_supports_non_stop
)
3207 return (t
->to_supports_non_stop
) ();
3212 target_supports_non_stop (void)
3214 struct target_ops
*t
;
3216 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3217 if (t
->to_supports_non_stop
)
3218 return t
->to_supports_non_stop ();
3223 /* Implement the "info proc" command. */
3226 target_info_proc (char *args
, enum info_proc_what what
)
3228 struct target_ops
*t
;
3230 /* If we're already connected to something that can get us OS
3231 related data, use it. Otherwise, try using the native
3233 if (current_target
.to_stratum
>= process_stratum
)
3234 t
= current_target
.beneath
;
3236 t
= find_default_run_target (NULL
);
3238 for (; t
!= NULL
; t
= t
->beneath
)
3240 if (t
->to_info_proc
!= NULL
)
3242 t
->to_info_proc (t
, args
, what
);
3245 fprintf_unfiltered (gdb_stdlog
,
3246 "target_info_proc (\"%s\", %d)\n", args
, what
);
3256 find_default_supports_disable_randomization (void)
3258 struct target_ops
*t
;
3260 t
= find_default_run_target (NULL
);
3261 if (t
&& t
->to_supports_disable_randomization
)
3262 return (t
->to_supports_disable_randomization
) ();
3267 target_supports_disable_randomization (void)
3269 struct target_ops
*t
;
3271 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3272 if (t
->to_supports_disable_randomization
)
3273 return t
->to_supports_disable_randomization ();
3279 target_get_osdata (const char *type
)
3281 struct target_ops
*t
;
3283 /* If we're already connected to something that can get us OS
3284 related data, use it. Otherwise, try using the native
3286 if (current_target
.to_stratum
>= process_stratum
)
3287 t
= current_target
.beneath
;
3289 t
= find_default_run_target ("get OS data");
3294 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3297 /* Determine the current address space of thread PTID. */
3299 struct address_space
*
3300 target_thread_address_space (ptid_t ptid
)
3302 struct address_space
*aspace
;
3303 struct inferior
*inf
;
3304 struct target_ops
*t
;
3306 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3308 if (t
->to_thread_address_space
!= NULL
)
3310 aspace
= t
->to_thread_address_space (t
, ptid
);
3311 gdb_assert (aspace
);
3314 fprintf_unfiltered (gdb_stdlog
,
3315 "target_thread_address_space (%s) = %d\n",
3316 target_pid_to_str (ptid
),
3317 address_space_num (aspace
));
3322 /* Fall-back to the "main" address space of the inferior. */
3323 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3325 if (inf
== NULL
|| inf
->aspace
== NULL
)
3326 internal_error (__FILE__
, __LINE__
,
3327 _("Can't determine the current "
3328 "address space of thread %s\n"),
3329 target_pid_to_str (ptid
));
3335 /* Target file operations. */
3337 static struct target_ops
*
3338 default_fileio_target (void)
3340 /* If we're already connected to something that can perform
3341 file I/O, use it. Otherwise, try using the native target. */
3342 if (current_target
.to_stratum
>= process_stratum
)
3343 return current_target
.beneath
;
3345 return find_default_run_target ("file I/O");
3348 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3349 target file descriptor, or -1 if an error occurs (and set
3352 target_fileio_open (const char *filename
, int flags
, int mode
,
3355 struct target_ops
*t
;
3357 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3359 if (t
->to_fileio_open
!= NULL
)
3361 int fd
= t
->to_fileio_open (filename
, flags
, mode
, target_errno
);
3364 fprintf_unfiltered (gdb_stdlog
,
3365 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3366 filename
, flags
, mode
,
3367 fd
, fd
!= -1 ? 0 : *target_errno
);
3372 *target_errno
= FILEIO_ENOSYS
;
3376 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3377 Return the number of bytes written, or -1 if an error occurs
3378 (and set *TARGET_ERRNO). */
3380 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3381 ULONGEST offset
, int *target_errno
)
3383 struct target_ops
*t
;
3385 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3387 if (t
->to_fileio_pwrite
!= NULL
)
3389 int ret
= t
->to_fileio_pwrite (fd
, write_buf
, len
, offset
,
3393 fprintf_unfiltered (gdb_stdlog
,
3394 "target_fileio_pwrite (%d,...,%d,%s) "
3396 fd
, len
, pulongest (offset
),
3397 ret
, ret
!= -1 ? 0 : *target_errno
);
3402 *target_errno
= FILEIO_ENOSYS
;
3406 /* Read up to LEN bytes FD on the target into READ_BUF.
3407 Return the number of bytes read, or -1 if an error occurs
3408 (and set *TARGET_ERRNO). */
3410 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3411 ULONGEST offset
, int *target_errno
)
3413 struct target_ops
*t
;
3415 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3417 if (t
->to_fileio_pread
!= NULL
)
3419 int ret
= t
->to_fileio_pread (fd
, read_buf
, len
, offset
,
3423 fprintf_unfiltered (gdb_stdlog
,
3424 "target_fileio_pread (%d,...,%d,%s) "
3426 fd
, len
, pulongest (offset
),
3427 ret
, ret
!= -1 ? 0 : *target_errno
);
3432 *target_errno
= FILEIO_ENOSYS
;
3436 /* Close FD on the target. Return 0, or -1 if an error occurs
3437 (and set *TARGET_ERRNO). */
3439 target_fileio_close (int fd
, int *target_errno
)
3441 struct target_ops
*t
;
3443 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3445 if (t
->to_fileio_close
!= NULL
)
3447 int ret
= t
->to_fileio_close (fd
, target_errno
);
3450 fprintf_unfiltered (gdb_stdlog
,
3451 "target_fileio_close (%d) = %d (%d)\n",
3452 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3457 *target_errno
= FILEIO_ENOSYS
;
3461 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3462 occurs (and set *TARGET_ERRNO). */
3464 target_fileio_unlink (const char *filename
, int *target_errno
)
3466 struct target_ops
*t
;
3468 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3470 if (t
->to_fileio_unlink
!= NULL
)
3472 int ret
= t
->to_fileio_unlink (filename
, target_errno
);
3475 fprintf_unfiltered (gdb_stdlog
,
3476 "target_fileio_unlink (%s) = %d (%d)\n",
3477 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3482 *target_errno
= FILEIO_ENOSYS
;
3486 /* Read value of symbolic link FILENAME on the target. Return a
3487 null-terminated string allocated via xmalloc, or NULL if an error
3488 occurs (and set *TARGET_ERRNO). */
3490 target_fileio_readlink (const char *filename
, int *target_errno
)
3492 struct target_ops
*t
;
3494 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3496 if (t
->to_fileio_readlink
!= NULL
)
3498 char *ret
= t
->to_fileio_readlink (filename
, target_errno
);
3501 fprintf_unfiltered (gdb_stdlog
,
3502 "target_fileio_readlink (%s) = %s (%d)\n",
3503 filename
, ret
? ret
: "(nil)",
3504 ret
? 0 : *target_errno
);
3509 *target_errno
= FILEIO_ENOSYS
;
3514 target_fileio_close_cleanup (void *opaque
)
3516 int fd
= *(int *) opaque
;
3519 target_fileio_close (fd
, &target_errno
);
3522 /* Read target file FILENAME. Store the result in *BUF_P and
3523 return the size of the transferred data. PADDING additional bytes are
3524 available in *BUF_P. This is a helper function for
3525 target_fileio_read_alloc; see the declaration of that function for more
3529 target_fileio_read_alloc_1 (const char *filename
,
3530 gdb_byte
**buf_p
, int padding
)
3532 struct cleanup
*close_cleanup
;
3533 size_t buf_alloc
, buf_pos
;
3539 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3543 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3545 /* Start by reading up to 4K at a time. The target will throttle
3546 this number down if necessary. */
3548 buf
= xmalloc (buf_alloc
);
3552 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3553 buf_alloc
- buf_pos
- padding
, buf_pos
,
3557 /* An error occurred. */
3558 do_cleanups (close_cleanup
);
3564 /* Read all there was. */
3565 do_cleanups (close_cleanup
);
3575 /* If the buffer is filling up, expand it. */
3576 if (buf_alloc
< buf_pos
* 2)
3579 buf
= xrealloc (buf
, buf_alloc
);
3586 /* Read target file FILENAME. Store the result in *BUF_P and return
3587 the size of the transferred data. See the declaration in "target.h"
3588 function for more information about the return value. */
3591 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3593 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3596 /* Read target file FILENAME. The result is NUL-terminated and
3597 returned as a string, allocated using xmalloc. If an error occurs
3598 or the transfer is unsupported, NULL is returned. Empty objects
3599 are returned as allocated but empty strings. A warning is issued
3600 if the result contains any embedded NUL bytes. */
3603 target_fileio_read_stralloc (const char *filename
)
3607 LONGEST i
, transferred
;
3609 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3610 bufstr
= (char *) buffer
;
3612 if (transferred
< 0)
3615 if (transferred
== 0)
3616 return xstrdup ("");
3618 bufstr
[transferred
] = 0;
3620 /* Check for embedded NUL bytes; but allow trailing NULs. */
3621 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3624 warning (_("target file %s "
3625 "contained unexpected null characters"),
3635 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3637 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3641 default_watchpoint_addr_within_range (struct target_ops
*target
,
3643 CORE_ADDR start
, int length
)
3645 return addr
>= start
&& addr
< start
+ length
;
3648 static struct gdbarch
*
3649 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3651 return target_gdbarch ();
3667 return_minus_one (void)
3679 * Find the next target down the stack from the specified target.
3683 find_target_beneath (struct target_ops
*t
)
3689 /* The inferior process has died. Long live the inferior! */
3692 generic_mourn_inferior (void)
3696 ptid
= inferior_ptid
;
3697 inferior_ptid
= null_ptid
;
3699 /* Mark breakpoints uninserted in case something tries to delete a
3700 breakpoint while we delete the inferior's threads (which would
3701 fail, since the inferior is long gone). */
3702 mark_breakpoints_out ();
3704 if (!ptid_equal (ptid
, null_ptid
))
3706 int pid
= ptid_get_pid (ptid
);
3707 exit_inferior (pid
);
3710 /* Note this wipes step-resume breakpoints, so needs to be done
3711 after exit_inferior, which ends up referencing the step-resume
3712 breakpoints through clear_thread_inferior_resources. */
3713 breakpoint_init_inferior (inf_exited
);
3715 registers_changed ();
3717 reopen_exec_file ();
3718 reinit_frame_cache ();
3720 if (deprecated_detach_hook
)
3721 deprecated_detach_hook ();
3724 /* Convert a normal process ID to a string. Returns the string in a
3728 normal_pid_to_str (ptid_t ptid
)
3730 static char buf
[32];
3732 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3737 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3739 return normal_pid_to_str (ptid
);
3742 /* Error-catcher for target_find_memory_regions. */
3744 dummy_find_memory_regions (find_memory_region_ftype ignore1
, void *ignore2
)
3746 error (_("Command not implemented for this target."));
3750 /* Error-catcher for target_make_corefile_notes. */
3752 dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
3754 error (_("Command not implemented for this target."));
3758 /* Error-catcher for target_get_bookmark. */
3760 dummy_get_bookmark (char *ignore1
, int ignore2
)
3766 /* Error-catcher for target_goto_bookmark. */
3768 dummy_goto_bookmark (gdb_byte
*ignore
, int from_tty
)
3773 /* Set up the handful of non-empty slots needed by the dummy target
3777 init_dummy_target (void)
3779 dummy_target
.to_shortname
= "None";
3780 dummy_target
.to_longname
= "None";
3781 dummy_target
.to_doc
= "";
3782 dummy_target
.to_attach
= find_default_attach
;
3783 dummy_target
.to_detach
=
3784 (void (*)(struct target_ops
*, const char *, int))target_ignore
;
3785 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3786 dummy_target
.to_can_async_p
= find_default_can_async_p
;
3787 dummy_target
.to_is_async_p
= find_default_is_async_p
;
3788 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3789 dummy_target
.to_supports_disable_randomization
3790 = find_default_supports_disable_randomization
;
3791 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3792 dummy_target
.to_stratum
= dummy_stratum
;
3793 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3794 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3795 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3796 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3797 dummy_target
.to_xfer_partial
= default_xfer_partial
;
3798 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3799 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3800 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3801 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3802 dummy_target
.to_has_execution
3803 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3804 dummy_target
.to_stopped_by_watchpoint
= return_zero
;
3805 dummy_target
.to_stopped_data_address
=
3806 (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
;
3807 dummy_target
.to_magic
= OPS_MAGIC
;
3811 debug_to_open (char *args
, int from_tty
)
3813 debug_target
.to_open (args
, from_tty
);
3815 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3819 target_close (struct target_ops
*targ
)
3821 gdb_assert (!target_is_pushed (targ
));
3823 if (targ
->to_xclose
!= NULL
)
3824 targ
->to_xclose (targ
);
3825 else if (targ
->to_close
!= NULL
)
3829 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3833 target_attach (char *args
, int from_tty
)
3835 struct target_ops
*t
;
3837 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3839 if (t
->to_attach
!= NULL
)
3841 t
->to_attach (t
, args
, from_tty
);
3843 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3849 internal_error (__FILE__
, __LINE__
,
3850 _("could not find a target to attach"));
3854 target_thread_alive (ptid_t ptid
)
3856 struct target_ops
*t
;
3858 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3860 if (t
->to_thread_alive
!= NULL
)
3864 retval
= t
->to_thread_alive (t
, ptid
);
3866 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3867 ptid_get_pid (ptid
), retval
);
3877 target_find_new_threads (void)
3879 struct target_ops
*t
;
3881 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3883 if (t
->to_find_new_threads
!= NULL
)
3885 t
->to_find_new_threads (t
);
3887 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3895 target_stop (ptid_t ptid
)
3899 warning (_("May not interrupt or stop the target, ignoring attempt"));
3903 (*current_target
.to_stop
) (ptid
);
3907 debug_to_post_attach (int pid
)
3909 debug_target
.to_post_attach (pid
);
3911 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3914 /* Concatenate ELEM to LIST, a comma separate list, and return the
3915 result. The LIST incoming argument is released. */
3918 str_comma_list_concat_elem (char *list
, const char *elem
)
3921 return xstrdup (elem
);
3923 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3926 /* Helper for target_options_to_string. If OPT is present in
3927 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3928 Returns the new resulting string. OPT is removed from
3932 do_option (int *target_options
, char *ret
,
3933 int opt
, char *opt_str
)
3935 if ((*target_options
& opt
) != 0)
3937 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3938 *target_options
&= ~opt
;
3945 target_options_to_string (int target_options
)
3949 #define DO_TARG_OPTION(OPT) \
3950 ret = do_option (&target_options, ret, OPT, #OPT)
3952 DO_TARG_OPTION (TARGET_WNOHANG
);
3954 if (target_options
!= 0)
3955 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3963 debug_print_register (const char * func
,
3964 struct regcache
*regcache
, int regno
)
3966 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3968 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3969 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3970 && gdbarch_register_name (gdbarch
, regno
) != NULL
3971 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3972 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3973 gdbarch_register_name (gdbarch
, regno
));
3975 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3976 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3978 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3979 int i
, size
= register_size (gdbarch
, regno
);
3980 gdb_byte buf
[MAX_REGISTER_SIZE
];
3982 regcache_raw_collect (regcache
, regno
, buf
);
3983 fprintf_unfiltered (gdb_stdlog
, " = ");
3984 for (i
= 0; i
< size
; i
++)
3986 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3988 if (size
<= sizeof (LONGEST
))
3990 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3992 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3993 core_addr_to_string_nz (val
), plongest (val
));
3996 fprintf_unfiltered (gdb_stdlog
, "\n");
4000 target_fetch_registers (struct regcache
*regcache
, int regno
)
4002 struct target_ops
*t
;
4004 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4006 if (t
->to_fetch_registers
!= NULL
)
4008 t
->to_fetch_registers (t
, regcache
, regno
);
4010 debug_print_register ("target_fetch_registers", regcache
, regno
);
4017 target_store_registers (struct regcache
*regcache
, int regno
)
4019 struct target_ops
*t
;
4021 if (!may_write_registers
)
4022 error (_("Writing to registers is not allowed (regno %d)"), regno
);
4024 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4026 if (t
->to_store_registers
!= NULL
)
4028 t
->to_store_registers (t
, regcache
, regno
);
4031 debug_print_register ("target_store_registers", regcache
, regno
);
4041 target_core_of_thread (ptid_t ptid
)
4043 struct target_ops
*t
;
4045 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4047 if (t
->to_core_of_thread
!= NULL
)
4049 int retval
= t
->to_core_of_thread (t
, ptid
);
4052 fprintf_unfiltered (gdb_stdlog
,
4053 "target_core_of_thread (%d) = %d\n",
4054 ptid_get_pid (ptid
), retval
);
4063 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
4065 struct target_ops
*t
;
4067 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4069 if (t
->to_verify_memory
!= NULL
)
4071 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
4074 fprintf_unfiltered (gdb_stdlog
,
4075 "target_verify_memory (%s, %s) = %d\n",
4076 paddress (target_gdbarch (), memaddr
),
4086 /* The documentation for this function is in its prototype declaration in
4090 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4092 struct target_ops
*t
;
4094 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4095 if (t
->to_insert_mask_watchpoint
!= NULL
)
4099 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
4102 fprintf_unfiltered (gdb_stdlog
, "\
4103 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4104 core_addr_to_string (addr
),
4105 core_addr_to_string (mask
), rw
, ret
);
4113 /* The documentation for this function is in its prototype declaration in
4117 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4119 struct target_ops
*t
;
4121 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4122 if (t
->to_remove_mask_watchpoint
!= NULL
)
4126 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
4129 fprintf_unfiltered (gdb_stdlog
, "\
4130 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4131 core_addr_to_string (addr
),
4132 core_addr_to_string (mask
), rw
, ret
);
4140 /* The documentation for this function is in its prototype declaration
4144 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
4146 struct target_ops
*t
;
4148 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4149 if (t
->to_masked_watch_num_registers
!= NULL
)
4150 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
4155 /* The documentation for this function is in its prototype declaration
4159 target_ranged_break_num_registers (void)
4161 struct target_ops
*t
;
4163 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4164 if (t
->to_ranged_break_num_registers
!= NULL
)
4165 return t
->to_ranged_break_num_registers (t
);
4173 target_supports_btrace (void)
4175 struct target_ops
*t
;
4177 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4178 if (t
->to_supports_btrace
!= NULL
)
4179 return t
->to_supports_btrace ();
4186 struct btrace_target_info
*
4187 target_enable_btrace (ptid_t ptid
)
4189 struct target_ops
*t
;
4191 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4192 if (t
->to_enable_btrace
!= NULL
)
4193 return t
->to_enable_btrace (ptid
);
4202 target_disable_btrace (struct btrace_target_info
*btinfo
)
4204 struct target_ops
*t
;
4206 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4207 if (t
->to_disable_btrace
!= NULL
)
4209 t
->to_disable_btrace (btinfo
);
4219 target_teardown_btrace (struct btrace_target_info
*btinfo
)
4221 struct target_ops
*t
;
4223 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4224 if (t
->to_teardown_btrace
!= NULL
)
4226 t
->to_teardown_btrace (btinfo
);
4236 target_read_btrace (VEC (btrace_block_s
) **btrace
,
4237 struct btrace_target_info
*btinfo
,
4238 enum btrace_read_type type
)
4240 struct target_ops
*t
;
4242 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4243 if (t
->to_read_btrace
!= NULL
)
4244 return t
->to_read_btrace (btrace
, btinfo
, type
);
4247 return BTRACE_ERR_NOT_SUPPORTED
;
4253 target_stop_recording (void)
4255 struct target_ops
*t
;
4257 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4258 if (t
->to_stop_recording
!= NULL
)
4260 t
->to_stop_recording ();
4264 /* This is optional. */
4270 target_info_record (void)
4272 struct target_ops
*t
;
4274 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4275 if (t
->to_info_record
!= NULL
)
4277 t
->to_info_record ();
4287 target_save_record (const char *filename
)
4289 struct target_ops
*t
;
4291 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4292 if (t
->to_save_record
!= NULL
)
4294 t
->to_save_record (filename
);
4304 target_supports_delete_record (void)
4306 struct target_ops
*t
;
4308 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4309 if (t
->to_delete_record
!= NULL
)
4318 target_delete_record (void)
4320 struct target_ops
*t
;
4322 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4323 if (t
->to_delete_record
!= NULL
)
4325 t
->to_delete_record ();
4335 target_record_is_replaying (void)
4337 struct target_ops
*t
;
4339 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4340 if (t
->to_record_is_replaying
!= NULL
)
4341 return t
->to_record_is_replaying ();
4349 target_goto_record_begin (void)
4351 struct target_ops
*t
;
4353 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4354 if (t
->to_goto_record_begin
!= NULL
)
4356 t
->to_goto_record_begin ();
4366 target_goto_record_end (void)
4368 struct target_ops
*t
;
4370 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4371 if (t
->to_goto_record_end
!= NULL
)
4373 t
->to_goto_record_end ();
4383 target_goto_record (ULONGEST insn
)
4385 struct target_ops
*t
;
4387 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4388 if (t
->to_goto_record
!= NULL
)
4390 t
->to_goto_record (insn
);
4400 target_insn_history (int size
, int flags
)
4402 struct target_ops
*t
;
4404 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4405 if (t
->to_insn_history
!= NULL
)
4407 t
->to_insn_history (size
, flags
);
4417 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4419 struct target_ops
*t
;
4421 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4422 if (t
->to_insn_history_from
!= NULL
)
4424 t
->to_insn_history_from (from
, size
, flags
);
4434 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4436 struct target_ops
*t
;
4438 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4439 if (t
->to_insn_history_range
!= NULL
)
4441 t
->to_insn_history_range (begin
, end
, flags
);
4451 target_call_history (int size
, int flags
)
4453 struct target_ops
*t
;
4455 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4456 if (t
->to_call_history
!= NULL
)
4458 t
->to_call_history (size
, flags
);
4468 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4470 struct target_ops
*t
;
4472 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4473 if (t
->to_call_history_from
!= NULL
)
4475 t
->to_call_history_from (begin
, size
, flags
);
4485 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4487 struct target_ops
*t
;
4489 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4490 if (t
->to_call_history_range
!= NULL
)
4492 t
->to_call_history_range (begin
, end
, flags
);
4500 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4502 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4504 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4509 const struct frame_unwind
*
4510 target_get_unwinder (void)
4512 struct target_ops
*t
;
4514 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4515 if (t
->to_get_unwinder
!= NULL
)
4516 return t
->to_get_unwinder
;
4523 const struct frame_unwind
*
4524 target_get_tailcall_unwinder (void)
4526 struct target_ops
*t
;
4528 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4529 if (t
->to_get_tailcall_unwinder
!= NULL
)
4530 return t
->to_get_tailcall_unwinder
;
4538 forward_target_decr_pc_after_break (struct target_ops
*ops
,
4539 struct gdbarch
*gdbarch
)
4541 for (; ops
!= NULL
; ops
= ops
->beneath
)
4542 if (ops
->to_decr_pc_after_break
!= NULL
)
4543 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
4545 return gdbarch_decr_pc_after_break (gdbarch
);
4551 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
4553 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
4557 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4558 int write
, struct mem_attrib
*attrib
,
4559 struct target_ops
*target
)
4563 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4566 fprintf_unfiltered (gdb_stdlog
,
4567 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4568 paddress (target_gdbarch (), memaddr
), len
,
4569 write
? "write" : "read", retval
);
4575 fputs_unfiltered (", bytes =", gdb_stdlog
);
4576 for (i
= 0; i
< retval
; i
++)
4578 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4580 if (targetdebug
< 2 && i
> 0)
4582 fprintf_unfiltered (gdb_stdlog
, " ...");
4585 fprintf_unfiltered (gdb_stdlog
, "\n");
4588 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4592 fputc_unfiltered ('\n', gdb_stdlog
);
4598 debug_to_files_info (struct target_ops
*target
)
4600 debug_target
.to_files_info (target
);
4602 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4606 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4607 struct bp_target_info
*bp_tgt
)
4611 retval
= forward_target_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4613 fprintf_unfiltered (gdb_stdlog
,
4614 "target_insert_breakpoint (%s, xxx) = %ld\n",
4615 core_addr_to_string (bp_tgt
->placed_address
),
4616 (unsigned long) retval
);
4621 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4622 struct bp_target_info
*bp_tgt
)
4626 retval
= forward_target_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4628 fprintf_unfiltered (gdb_stdlog
,
4629 "target_remove_breakpoint (%s, xxx) = %ld\n",
4630 core_addr_to_string (bp_tgt
->placed_address
),
4631 (unsigned long) retval
);
4636 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
4640 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
4642 fprintf_unfiltered (gdb_stdlog
,
4643 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4644 (unsigned long) type
,
4645 (unsigned long) cnt
,
4646 (unsigned long) from_tty
,
4647 (unsigned long) retval
);
4652 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
4656 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
4658 fprintf_unfiltered (gdb_stdlog
,
4659 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4660 core_addr_to_string (addr
), (unsigned long) len
,
4661 core_addr_to_string (retval
));
4666 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr
, int len
, int rw
,
4667 struct expression
*cond
)
4671 retval
= debug_target
.to_can_accel_watchpoint_condition (addr
, len
,
4674 fprintf_unfiltered (gdb_stdlog
,
4675 "target_can_accel_watchpoint_condition "
4676 "(%s, %d, %d, %s) = %ld\n",
4677 core_addr_to_string (addr
), len
, rw
,
4678 host_address_to_string (cond
), (unsigned long) retval
);
4683 debug_to_stopped_by_watchpoint (void)
4687 retval
= debug_target
.to_stopped_by_watchpoint ();
4689 fprintf_unfiltered (gdb_stdlog
,
4690 "target_stopped_by_watchpoint () = %ld\n",
4691 (unsigned long) retval
);
4696 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4700 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4702 fprintf_unfiltered (gdb_stdlog
,
4703 "target_stopped_data_address ([%s]) = %ld\n",
4704 core_addr_to_string (*addr
),
4705 (unsigned long)retval
);
4710 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4712 CORE_ADDR start
, int length
)
4716 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4719 fprintf_filtered (gdb_stdlog
,
4720 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4721 core_addr_to_string (addr
), core_addr_to_string (start
),
4727 debug_to_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
4728 struct bp_target_info
*bp_tgt
)
4732 retval
= debug_target
.to_insert_hw_breakpoint (gdbarch
, bp_tgt
);
4734 fprintf_unfiltered (gdb_stdlog
,
4735 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4736 core_addr_to_string (bp_tgt
->placed_address
),
4737 (unsigned long) retval
);
4742 debug_to_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
4743 struct bp_target_info
*bp_tgt
)
4747 retval
= debug_target
.to_remove_hw_breakpoint (gdbarch
, bp_tgt
);
4749 fprintf_unfiltered (gdb_stdlog
,
4750 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4751 core_addr_to_string (bp_tgt
->placed_address
),
4752 (unsigned long) retval
);
4757 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
4758 struct expression
*cond
)
4762 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
, cond
);
4764 fprintf_unfiltered (gdb_stdlog
,
4765 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4766 core_addr_to_string (addr
), len
, type
,
4767 host_address_to_string (cond
), (unsigned long) retval
);
4772 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
4773 struct expression
*cond
)
4777 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
, cond
);
4779 fprintf_unfiltered (gdb_stdlog
,
4780 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4781 core_addr_to_string (addr
), len
, type
,
4782 host_address_to_string (cond
), (unsigned long) retval
);
4787 debug_to_terminal_init (void)
4789 debug_target
.to_terminal_init ();
4791 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4795 debug_to_terminal_inferior (void)
4797 debug_target
.to_terminal_inferior ();
4799 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4803 debug_to_terminal_ours_for_output (void)
4805 debug_target
.to_terminal_ours_for_output ();
4807 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4811 debug_to_terminal_ours (void)
4813 debug_target
.to_terminal_ours ();
4815 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4819 debug_to_terminal_save_ours (void)
4821 debug_target
.to_terminal_save_ours ();
4823 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4827 debug_to_terminal_info (const char *arg
, int from_tty
)
4829 debug_target
.to_terminal_info (arg
, from_tty
);
4831 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4836 debug_to_load (char *args
, int from_tty
)
4838 debug_target
.to_load (args
, from_tty
);
4840 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4844 debug_to_post_startup_inferior (ptid_t ptid
)
4846 debug_target
.to_post_startup_inferior (ptid
);
4848 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4849 ptid_get_pid (ptid
));
4853 debug_to_insert_fork_catchpoint (int pid
)
4857 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
4859 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4866 debug_to_remove_fork_catchpoint (int pid
)
4870 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
4872 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4879 debug_to_insert_vfork_catchpoint (int pid
)
4883 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
4885 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4892 debug_to_remove_vfork_catchpoint (int pid
)
4896 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
4898 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4905 debug_to_insert_exec_catchpoint (int pid
)
4909 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
4911 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4918 debug_to_remove_exec_catchpoint (int pid
)
4922 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
4924 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4931 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
4935 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
4937 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4938 pid
, wait_status
, *exit_status
, has_exited
);
4944 debug_to_can_run (void)
4948 retval
= debug_target
.to_can_run ();
4950 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4955 static struct gdbarch
*
4956 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4958 struct gdbarch
*retval
;
4960 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4962 fprintf_unfiltered (gdb_stdlog
,
4963 "target_thread_architecture (%s) = %s [%s]\n",
4964 target_pid_to_str (ptid
),
4965 host_address_to_string (retval
),
4966 gdbarch_bfd_arch_info (retval
)->printable_name
);
4971 debug_to_stop (ptid_t ptid
)
4973 debug_target
.to_stop (ptid
);
4975 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4976 target_pid_to_str (ptid
));
4980 debug_to_rcmd (char *command
,
4981 struct ui_file
*outbuf
)
4983 debug_target
.to_rcmd (command
, outbuf
);
4984 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4988 debug_to_pid_to_exec_file (int pid
)
4992 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
4994 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
5001 setup_target_debug (void)
5003 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
5005 current_target
.to_open
= debug_to_open
;
5006 current_target
.to_post_attach
= debug_to_post_attach
;
5007 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
5008 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
5009 current_target
.to_files_info
= debug_to_files_info
;
5010 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
5011 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
5012 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
5013 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
5014 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
5015 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
5016 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
5017 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
5018 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
5019 current_target
.to_watchpoint_addr_within_range
5020 = debug_to_watchpoint_addr_within_range
;
5021 current_target
.to_region_ok_for_hw_watchpoint
5022 = debug_to_region_ok_for_hw_watchpoint
;
5023 current_target
.to_can_accel_watchpoint_condition
5024 = debug_to_can_accel_watchpoint_condition
;
5025 current_target
.to_terminal_init
= debug_to_terminal_init
;
5026 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
5027 current_target
.to_terminal_ours_for_output
5028 = debug_to_terminal_ours_for_output
;
5029 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
5030 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
5031 current_target
.to_terminal_info
= debug_to_terminal_info
;
5032 current_target
.to_load
= debug_to_load
;
5033 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
5034 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
5035 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
5036 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
5037 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
5038 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
5039 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
5040 current_target
.to_has_exited
= debug_to_has_exited
;
5041 current_target
.to_can_run
= debug_to_can_run
;
5042 current_target
.to_stop
= debug_to_stop
;
5043 current_target
.to_rcmd
= debug_to_rcmd
;
5044 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
5045 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
5049 static char targ_desc
[] =
5050 "Names of targets and files being debugged.\nShows the entire \
5051 stack of targets currently in use (including the exec-file,\n\
5052 core-file, and process, if any), as well as the symbol file name.";
5055 do_monitor_command (char *cmd
,
5058 if ((current_target
.to_rcmd
5059 == (void (*) (char *, struct ui_file
*)) tcomplain
)
5060 || (current_target
.to_rcmd
== debug_to_rcmd
5061 && (debug_target
.to_rcmd
5062 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
5063 error (_("\"monitor\" command not supported by this target."));
5064 target_rcmd (cmd
, gdb_stdtarg
);
5067 /* Print the name of each layers of our target stack. */
5070 maintenance_print_target_stack (char *cmd
, int from_tty
)
5072 struct target_ops
*t
;
5074 printf_filtered (_("The current target stack is:\n"));
5076 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
5078 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
5082 /* Controls if async mode is permitted. */
5083 int target_async_permitted
= 0;
5085 /* The set command writes to this variable. If the inferior is
5086 executing, target_async_permitted is *not* updated. */
5087 static int target_async_permitted_1
= 0;
5090 set_target_async_command (char *args
, int from_tty
,
5091 struct cmd_list_element
*c
)
5093 if (have_live_inferiors ())
5095 target_async_permitted_1
= target_async_permitted
;
5096 error (_("Cannot change this setting while the inferior is running."));
5099 target_async_permitted
= target_async_permitted_1
;
5103 show_target_async_command (struct ui_file
*file
, int from_tty
,
5104 struct cmd_list_element
*c
,
5107 fprintf_filtered (file
,
5108 _("Controlling the inferior in "
5109 "asynchronous mode is %s.\n"), value
);
5112 /* Temporary copies of permission settings. */
5114 static int may_write_registers_1
= 1;
5115 static int may_write_memory_1
= 1;
5116 static int may_insert_breakpoints_1
= 1;
5117 static int may_insert_tracepoints_1
= 1;
5118 static int may_insert_fast_tracepoints_1
= 1;
5119 static int may_stop_1
= 1;
5121 /* Make the user-set values match the real values again. */
5124 update_target_permissions (void)
5126 may_write_registers_1
= may_write_registers
;
5127 may_write_memory_1
= may_write_memory
;
5128 may_insert_breakpoints_1
= may_insert_breakpoints
;
5129 may_insert_tracepoints_1
= may_insert_tracepoints
;
5130 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
5131 may_stop_1
= may_stop
;
5134 /* The one function handles (most of) the permission flags in the same
5138 set_target_permissions (char *args
, int from_tty
,
5139 struct cmd_list_element
*c
)
5141 if (target_has_execution
)
5143 update_target_permissions ();
5144 error (_("Cannot change this setting while the inferior is running."));
5147 /* Make the real values match the user-changed values. */
5148 may_write_registers
= may_write_registers_1
;
5149 may_insert_breakpoints
= may_insert_breakpoints_1
;
5150 may_insert_tracepoints
= may_insert_tracepoints_1
;
5151 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
5152 may_stop
= may_stop_1
;
5153 update_observer_mode ();
5156 /* Set memory write permission independently of observer mode. */
5159 set_write_memory_permission (char *args
, int from_tty
,
5160 struct cmd_list_element
*c
)
5162 /* Make the real values match the user-changed values. */
5163 may_write_memory
= may_write_memory_1
;
5164 update_observer_mode ();
5169 initialize_targets (void)
5171 init_dummy_target ();
5172 push_target (&dummy_target
);
5174 add_info ("target", target_info
, targ_desc
);
5175 add_info ("files", target_info
, targ_desc
);
5177 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
5178 Set target debugging."), _("\
5179 Show target debugging."), _("\
5180 When non-zero, target debugging is enabled. Higher numbers are more\n\
5181 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5185 &setdebuglist
, &showdebuglist
);
5187 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
5188 &trust_readonly
, _("\
5189 Set mode for reading from readonly sections."), _("\
5190 Show mode for reading from readonly sections."), _("\
5191 When this mode is on, memory reads from readonly sections (such as .text)\n\
5192 will be read from the object file instead of from the target. This will\n\
5193 result in significant performance improvement for remote targets."),
5195 show_trust_readonly
,
5196 &setlist
, &showlist
);
5198 add_com ("monitor", class_obscure
, do_monitor_command
,
5199 _("Send a command to the remote monitor (remote targets only)."));
5201 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
5202 _("Print the name of each layer of the internal target stack."),
5203 &maintenanceprintlist
);
5205 add_setshow_boolean_cmd ("target-async", no_class
,
5206 &target_async_permitted_1
, _("\
5207 Set whether gdb controls the inferior in asynchronous mode."), _("\
5208 Show whether gdb controls the inferior in asynchronous mode."), _("\
5209 Tells gdb whether to control the inferior in asynchronous mode."),
5210 set_target_async_command
,
5211 show_target_async_command
,
5215 add_setshow_boolean_cmd ("may-write-registers", class_support
,
5216 &may_write_registers_1
, _("\
5217 Set permission to write into registers."), _("\
5218 Show permission to write into registers."), _("\
5219 When this permission is on, GDB may write into the target's registers.\n\
5220 Otherwise, any sort of write attempt will result in an error."),
5221 set_target_permissions
, NULL
,
5222 &setlist
, &showlist
);
5224 add_setshow_boolean_cmd ("may-write-memory", class_support
,
5225 &may_write_memory_1
, _("\
5226 Set permission to write into target memory."), _("\
5227 Show permission to write into target memory."), _("\
5228 When this permission is on, GDB may write into the target's memory.\n\
5229 Otherwise, any sort of write attempt will result in an error."),
5230 set_write_memory_permission
, NULL
,
5231 &setlist
, &showlist
);
5233 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
5234 &may_insert_breakpoints_1
, _("\
5235 Set permission to insert breakpoints in the target."), _("\
5236 Show permission to insert breakpoints in the target."), _("\
5237 When this permission is on, GDB may insert breakpoints in the program.\n\
5238 Otherwise, any sort of insertion attempt will result in an error."),
5239 set_target_permissions
, NULL
,
5240 &setlist
, &showlist
);
5242 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
5243 &may_insert_tracepoints_1
, _("\
5244 Set permission to insert tracepoints in the target."), _("\
5245 Show permission to insert tracepoints in the target."), _("\
5246 When this permission is on, GDB may insert tracepoints in the program.\n\
5247 Otherwise, any sort of insertion attempt will result in an error."),
5248 set_target_permissions
, NULL
,
5249 &setlist
, &showlist
);
5251 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
5252 &may_insert_fast_tracepoints_1
, _("\
5253 Set permission to insert fast tracepoints in the target."), _("\
5254 Show permission to insert fast tracepoints in the target."), _("\
5255 When this permission is on, GDB may insert fast tracepoints.\n\
5256 Otherwise, any sort of insertion attempt will result in an error."),
5257 set_target_permissions
, NULL
,
5258 &setlist
, &showlist
);
5260 add_setshow_boolean_cmd ("may-interrupt", class_support
,
5262 Set permission to interrupt or signal the target."), _("\
5263 Show permission to interrupt or signal the target."), _("\
5264 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5265 Otherwise, any attempt to interrupt or stop will be ignored."),
5266 set_target_permissions
, NULL
,
5267 &setlist
, &showlist
);