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
)
1545 return TARGET_XFER_E_IO
;
1549 if (readbuf
!= NULL
)
1550 return TARGET_XFER_E_IO
;
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"));
1560 return TARGET_XFER_E_IO
;
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 /* Transfer is done when LEN is zero. */
1704 if (writebuf
&& !may_write_memory
)
1705 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1706 core_addr_to_string_nz (offset
), plongest (len
));
1708 /* If this is a memory transfer, let the memory-specific code
1709 have a look at it instead. Memory transfers are more
1711 if (object
== TARGET_OBJECT_MEMORY
|| object
== TARGET_OBJECT_STACK_MEMORY
1712 || object
== TARGET_OBJECT_CODE_MEMORY
)
1713 retval
= memory_xfer_partial (ops
, object
, readbuf
,
1714 writebuf
, offset
, len
);
1715 else if (object
== TARGET_OBJECT_RAW_MEMORY
)
1717 /* Request the normal memory object from other layers. */
1718 retval
= raw_memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1721 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
,
1722 writebuf
, offset
, len
);
1726 const unsigned char *myaddr
= NULL
;
1728 fprintf_unfiltered (gdb_stdlog
,
1729 "%s:target_xfer_partial "
1730 "(%d, %s, %s, %s, %s, %s) = %s",
1733 (annex
? annex
: "(null)"),
1734 host_address_to_string (readbuf
),
1735 host_address_to_string (writebuf
),
1736 core_addr_to_string_nz (offset
),
1737 pulongest (len
), plongest (retval
));
1743 if (retval
> 0 && myaddr
!= NULL
)
1747 fputs_unfiltered (", bytes =", gdb_stdlog
);
1748 for (i
= 0; i
< retval
; i
++)
1750 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1752 if (targetdebug
< 2 && i
> 0)
1754 fprintf_unfiltered (gdb_stdlog
, " ...");
1757 fprintf_unfiltered (gdb_stdlog
, "\n");
1760 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1764 fputc_unfiltered ('\n', gdb_stdlog
);
1769 /* Read LEN bytes of target memory at address MEMADDR, placing the
1770 results in GDB's memory at MYADDR. Returns either 0 for success or
1771 a target_xfer_error value if any error occurs.
1773 If an error occurs, no guarantee is made about the contents of the data at
1774 MYADDR. In particular, the caller should not depend upon partial reads
1775 filling the buffer with good data. There is no way for the caller to know
1776 how much good data might have been transfered anyway. Callers that can
1777 deal with partial reads should call target_read (which will retry until
1778 it makes no progress, and then return how much was transferred). */
1781 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1783 /* Dispatch to the topmost target, not the flattened current_target.
1784 Memory accesses check target->to_has_(all_)memory, and the
1785 flattened target doesn't inherit those. */
1786 if (target_read (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1787 myaddr
, memaddr
, len
) == len
)
1790 return TARGET_XFER_E_IO
;
1793 /* Like target_read_memory, but specify explicitly that this is a read
1794 from the target's raw memory. That is, this read bypasses the
1795 dcache, breakpoint shadowing, etc. */
1798 target_read_raw_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1800 /* See comment in target_read_memory about why the request starts at
1801 current_target.beneath. */
1802 if (target_read (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1803 myaddr
, memaddr
, len
) == len
)
1806 return TARGET_XFER_E_IO
;
1809 /* Like target_read_memory, but specify explicitly that this is a read from
1810 the target's stack. This may trigger different cache behavior. */
1813 target_read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1815 /* See comment in target_read_memory about why the request starts at
1816 current_target.beneath. */
1817 if (target_read (current_target
.beneath
, TARGET_OBJECT_STACK_MEMORY
, NULL
,
1818 myaddr
, memaddr
, len
) == len
)
1821 return TARGET_XFER_E_IO
;
1824 /* Like target_read_memory, but specify explicitly that this is a read from
1825 the target's code. This may trigger different cache behavior. */
1828 target_read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
1830 /* See comment in target_read_memory about why the request starts at
1831 current_target.beneath. */
1832 if (target_read (current_target
.beneath
, TARGET_OBJECT_CODE_MEMORY
, NULL
,
1833 myaddr
, memaddr
, len
) == len
)
1836 return TARGET_XFER_E_IO
;
1839 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1840 Returns either 0 for success or a target_xfer_error value if any
1841 error occurs. If an error occurs, no guarantee is made about how
1842 much data got written. Callers that can deal with partial writes
1843 should call target_write. */
1846 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1848 /* See comment in target_read_memory about why the request starts at
1849 current_target.beneath. */
1850 if (target_write (current_target
.beneath
, TARGET_OBJECT_MEMORY
, NULL
,
1851 myaddr
, memaddr
, len
) == len
)
1854 return TARGET_XFER_E_IO
;
1857 /* Write LEN bytes from MYADDR to target raw memory at address
1858 MEMADDR. Returns either 0 for success or a target_xfer_error value
1859 if any error occurs. If an error occurs, no guarantee is made
1860 about how much data got written. Callers that can deal with
1861 partial writes should call target_write. */
1864 target_write_raw_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ssize_t len
)
1866 /* See comment in target_read_memory about why the request starts at
1867 current_target.beneath. */
1868 if (target_write (current_target
.beneath
, TARGET_OBJECT_RAW_MEMORY
, NULL
,
1869 myaddr
, memaddr
, len
) == len
)
1872 return TARGET_XFER_E_IO
;
1875 /* Fetch the target's memory map. */
1878 target_memory_map (void)
1880 VEC(mem_region_s
) *result
;
1881 struct mem_region
*last_one
, *this_one
;
1883 struct target_ops
*t
;
1886 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1888 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1889 if (t
->to_memory_map
!= NULL
)
1895 result
= t
->to_memory_map (t
);
1899 qsort (VEC_address (mem_region_s
, result
),
1900 VEC_length (mem_region_s
, result
),
1901 sizeof (struct mem_region
), mem_region_cmp
);
1903 /* Check that regions do not overlap. Simultaneously assign
1904 a numbering for the "mem" commands to use to refer to
1907 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1909 this_one
->number
= ix
;
1911 if (last_one
&& last_one
->hi
> this_one
->lo
)
1913 warning (_("Overlapping regions in memory map: ignoring"));
1914 VEC_free (mem_region_s
, result
);
1917 last_one
= this_one
;
1924 target_flash_erase (ULONGEST address
, LONGEST length
)
1926 struct target_ops
*t
;
1928 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1929 if (t
->to_flash_erase
!= NULL
)
1932 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1933 hex_string (address
), phex (length
, 0));
1934 t
->to_flash_erase (t
, address
, length
);
1942 target_flash_done (void)
1944 struct target_ops
*t
;
1946 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1947 if (t
->to_flash_done
!= NULL
)
1950 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1951 t
->to_flash_done (t
);
1959 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1960 struct cmd_list_element
*c
, const char *value
)
1962 fprintf_filtered (file
,
1963 _("Mode for reading from readonly sections is %s.\n"),
1967 /* More generic transfers. */
1970 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1971 const char *annex
, gdb_byte
*readbuf
,
1972 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
1974 if (object
== TARGET_OBJECT_MEMORY
1975 && ops
->deprecated_xfer_memory
!= NULL
)
1976 /* If available, fall back to the target's
1977 "deprecated_xfer_memory" method. */
1982 if (writebuf
!= NULL
)
1984 void *buffer
= xmalloc (len
);
1985 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1987 memcpy (buffer
, writebuf
, len
);
1988 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1989 1/*write*/, NULL
, ops
);
1990 do_cleanups (cleanup
);
1992 if (readbuf
!= NULL
)
1993 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1994 0/*read*/, NULL
, ops
);
1997 else if (xfered
== 0 && errno
== 0)
1998 /* "deprecated_xfer_memory" uses 0, cross checked against
1999 ERRNO as one indication of an error. */
2004 else if (ops
->beneath
!= NULL
)
2005 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2006 readbuf
, writebuf
, offset
, len
);
2011 /* The xfer_partial handler for the topmost target. Unlike the default,
2012 it does not need to handle memory specially; it just passes all
2013 requests down the stack. */
2016 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2017 const char *annex
, gdb_byte
*readbuf
,
2018 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
)
2020 if (ops
->beneath
!= NULL
)
2021 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
2022 readbuf
, writebuf
, offset
, len
);
2027 /* Target vector read/write partial wrapper functions. */
2030 target_read_partial (struct target_ops
*ops
,
2031 enum target_object object
,
2032 const char *annex
, gdb_byte
*buf
,
2033 ULONGEST offset
, LONGEST len
)
2035 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
2039 target_write_partial (struct target_ops
*ops
,
2040 enum target_object object
,
2041 const char *annex
, const gdb_byte
*buf
,
2042 ULONGEST offset
, LONGEST len
)
2044 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
2047 /* Wrappers to perform the full transfer. */
2049 /* For docs on target_read see target.h. */
2052 target_read (struct target_ops
*ops
,
2053 enum target_object object
,
2054 const char *annex
, gdb_byte
*buf
,
2055 ULONGEST offset
, LONGEST len
)
2059 while (xfered
< len
)
2061 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
2062 (gdb_byte
*) buf
+ xfered
,
2063 offset
+ xfered
, len
- xfered
);
2065 /* Call an observer, notifying them of the xfer progress? */
2076 /* Assuming that the entire [begin, end) range of memory cannot be
2077 read, try to read whatever subrange is possible to read.
2079 The function returns, in RESULT, either zero or one memory block.
2080 If there's a readable subrange at the beginning, it is completely
2081 read and returned. Any further readable subrange will not be read.
2082 Otherwise, if there's a readable subrange at the end, it will be
2083 completely read and returned. Any readable subranges before it
2084 (obviously, not starting at the beginning), will be ignored. In
2085 other cases -- either no readable subrange, or readable subrange(s)
2086 that is neither at the beginning, or end, nothing is returned.
2088 The purpose of this function is to handle a read across a boundary
2089 of accessible memory in a case when memory map is not available.
2090 The above restrictions are fine for this case, but will give
2091 incorrect results if the memory is 'patchy'. However, supporting
2092 'patchy' memory would require trying to read every single byte,
2093 and it seems unacceptable solution. Explicit memory map is
2094 recommended for this case -- and target_read_memory_robust will
2095 take care of reading multiple ranges then. */
2098 read_whatever_is_readable (struct target_ops
*ops
,
2099 ULONGEST begin
, ULONGEST end
,
2100 VEC(memory_read_result_s
) **result
)
2102 gdb_byte
*buf
= xmalloc (end
- begin
);
2103 ULONGEST current_begin
= begin
;
2104 ULONGEST current_end
= end
;
2106 memory_read_result_s r
;
2108 /* If we previously failed to read 1 byte, nothing can be done here. */
2109 if (end
- begin
<= 1)
2115 /* Check that either first or the last byte is readable, and give up
2116 if not. This heuristic is meant to permit reading accessible memory
2117 at the boundary of accessible region. */
2118 if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2119 buf
, begin
, 1) == 1)
2124 else if (target_read_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2125 buf
+ (end
-begin
) - 1, end
- 1, 1) == 1)
2136 /* Loop invariant is that the [current_begin, current_end) was previously
2137 found to be not readable as a whole.
2139 Note loop condition -- if the range has 1 byte, we can't divide the range
2140 so there's no point trying further. */
2141 while (current_end
- current_begin
> 1)
2143 ULONGEST first_half_begin
, first_half_end
;
2144 ULONGEST second_half_begin
, second_half_end
;
2146 ULONGEST middle
= current_begin
+ (current_end
- current_begin
)/2;
2150 first_half_begin
= current_begin
;
2151 first_half_end
= middle
;
2152 second_half_begin
= middle
;
2153 second_half_end
= current_end
;
2157 first_half_begin
= middle
;
2158 first_half_end
= current_end
;
2159 second_half_begin
= current_begin
;
2160 second_half_end
= middle
;
2163 xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2164 buf
+ (first_half_begin
- begin
),
2166 first_half_end
- first_half_begin
);
2168 if (xfer
== first_half_end
- first_half_begin
)
2170 /* This half reads up fine. So, the error must be in the
2172 current_begin
= second_half_begin
;
2173 current_end
= second_half_end
;
2177 /* This half is not readable. Because we've tried one byte, we
2178 know some part of this half if actually redable. Go to the next
2179 iteration to divide again and try to read.
2181 We don't handle the other half, because this function only tries
2182 to read a single readable subrange. */
2183 current_begin
= first_half_begin
;
2184 current_end
= first_half_end
;
2190 /* The [begin, current_begin) range has been read. */
2192 r
.end
= current_begin
;
2197 /* The [current_end, end) range has been read. */
2198 LONGEST rlen
= end
- current_end
;
2200 r
.data
= xmalloc (rlen
);
2201 memcpy (r
.data
, buf
+ current_end
- begin
, rlen
);
2202 r
.begin
= current_end
;
2206 VEC_safe_push(memory_read_result_s
, (*result
), &r
);
2210 free_memory_read_result_vector (void *x
)
2212 VEC(memory_read_result_s
) *v
= x
;
2213 memory_read_result_s
*current
;
2216 for (ix
= 0; VEC_iterate (memory_read_result_s
, v
, ix
, current
); ++ix
)
2218 xfree (current
->data
);
2220 VEC_free (memory_read_result_s
, v
);
2223 VEC(memory_read_result_s
) *
2224 read_memory_robust (struct target_ops
*ops
, ULONGEST offset
, LONGEST len
)
2226 VEC(memory_read_result_s
) *result
= 0;
2229 while (xfered
< len
)
2231 struct mem_region
*region
= lookup_mem_region (offset
+ xfered
);
2234 /* If there is no explicit region, a fake one should be created. */
2235 gdb_assert (region
);
2237 if (region
->hi
== 0)
2238 rlen
= len
- xfered
;
2240 rlen
= region
->hi
- offset
;
2242 if (region
->attrib
.mode
== MEM_NONE
|| region
->attrib
.mode
== MEM_WO
)
2244 /* Cannot read this region. Note that we can end up here only
2245 if the region is explicitly marked inaccessible, or
2246 'inaccessible-by-default' is in effect. */
2251 LONGEST to_read
= min (len
- xfered
, rlen
);
2252 gdb_byte
*buffer
= (gdb_byte
*)xmalloc (to_read
);
2254 LONGEST xfer
= target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2255 (gdb_byte
*) buffer
,
2256 offset
+ xfered
, to_read
);
2257 /* Call an observer, notifying them of the xfer progress? */
2260 /* Got an error reading full chunk. See if maybe we can read
2263 read_whatever_is_readable (ops
, offset
+ xfered
,
2264 offset
+ xfered
+ to_read
, &result
);
2269 struct memory_read_result r
;
2271 r
.begin
= offset
+ xfered
;
2272 r
.end
= r
.begin
+ xfer
;
2273 VEC_safe_push (memory_read_result_s
, result
, &r
);
2283 /* An alternative to target_write with progress callbacks. */
2286 target_write_with_progress (struct target_ops
*ops
,
2287 enum target_object object
,
2288 const char *annex
, const gdb_byte
*buf
,
2289 ULONGEST offset
, LONGEST len
,
2290 void (*progress
) (ULONGEST
, void *), void *baton
)
2294 /* Give the progress callback a chance to set up. */
2296 (*progress
) (0, baton
);
2298 while (xfered
< len
)
2300 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
2301 (gdb_byte
*) buf
+ xfered
,
2302 offset
+ xfered
, len
- xfered
);
2310 (*progress
) (xfer
, baton
);
2318 /* For docs on target_write see target.h. */
2321 target_write (struct target_ops
*ops
,
2322 enum target_object object
,
2323 const char *annex
, const gdb_byte
*buf
,
2324 ULONGEST offset
, LONGEST len
)
2326 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
2330 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2331 the size of the transferred data. PADDING additional bytes are
2332 available in *BUF_P. This is a helper function for
2333 target_read_alloc; see the declaration of that function for more
2337 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
2338 const char *annex
, gdb_byte
**buf_p
, int padding
)
2340 size_t buf_alloc
, buf_pos
;
2344 /* This function does not have a length parameter; it reads the
2345 entire OBJECT). Also, it doesn't support objects fetched partly
2346 from one target and partly from another (in a different stratum,
2347 e.g. a core file and an executable). Both reasons make it
2348 unsuitable for reading memory. */
2349 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
2351 /* Start by reading up to 4K at a time. The target will throttle
2352 this number down if necessary. */
2354 buf
= xmalloc (buf_alloc
);
2358 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
2359 buf_pos
, buf_alloc
- buf_pos
- padding
);
2362 /* An error occurred. */
2368 /* Read all there was. */
2378 /* If the buffer is filling up, expand it. */
2379 if (buf_alloc
< buf_pos
* 2)
2382 buf
= xrealloc (buf
, buf_alloc
);
2389 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
2390 the size of the transferred data. See the declaration in "target.h"
2391 function for more information about the return value. */
2394 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
2395 const char *annex
, gdb_byte
**buf_p
)
2397 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
2400 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
2401 returned as a string, allocated using xmalloc. If an error occurs
2402 or the transfer is unsupported, NULL is returned. Empty objects
2403 are returned as allocated but empty strings. A warning is issued
2404 if the result contains any embedded NUL bytes. */
2407 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
2412 LONGEST i
, transferred
;
2414 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
2415 bufstr
= (char *) buffer
;
2417 if (transferred
< 0)
2420 if (transferred
== 0)
2421 return xstrdup ("");
2423 bufstr
[transferred
] = 0;
2425 /* Check for embedded NUL bytes; but allow trailing NULs. */
2426 for (i
= strlen (bufstr
); i
< transferred
; i
++)
2429 warning (_("target object %d, annex %s, "
2430 "contained unexpected null characters"),
2431 (int) object
, annex
? annex
: "(none)");
2438 /* Memory transfer methods. */
2441 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
2444 /* This method is used to read from an alternate, non-current
2445 target. This read must bypass the overlay support (as symbols
2446 don't match this target), and GDB's internal cache (wrong cache
2447 for this target). */
2448 if (target_read (ops
, TARGET_OBJECT_RAW_MEMORY
, NULL
, buf
, addr
, len
)
2450 memory_error (TARGET_XFER_E_IO
, addr
);
2454 get_target_memory_unsigned (struct target_ops
*ops
, CORE_ADDR addr
,
2455 int len
, enum bfd_endian byte_order
)
2457 gdb_byte buf
[sizeof (ULONGEST
)];
2459 gdb_assert (len
<= sizeof (buf
));
2460 get_target_memory (ops
, addr
, buf
, len
);
2461 return extract_unsigned_integer (buf
, len
, byte_order
);
2467 forward_target_insert_breakpoint (struct target_ops
*ops
,
2468 struct gdbarch
*gdbarch
,
2469 struct bp_target_info
*bp_tgt
)
2471 for (; ops
!= NULL
; ops
= ops
->beneath
)
2472 if (ops
->to_insert_breakpoint
!= NULL
)
2473 return ops
->to_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
2475 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
2481 target_insert_breakpoint (struct gdbarch
*gdbarch
,
2482 struct bp_target_info
*bp_tgt
)
2484 if (!may_insert_breakpoints
)
2486 warning (_("May not insert breakpoints"));
2490 return forward_target_insert_breakpoint (¤t_target
, gdbarch
, bp_tgt
);
2496 forward_target_remove_breakpoint (struct target_ops
*ops
,
2497 struct gdbarch
*gdbarch
,
2498 struct bp_target_info
*bp_tgt
)
2500 /* This is kind of a weird case to handle, but the permission might
2501 have been changed after breakpoints were inserted - in which case
2502 we should just take the user literally and assume that any
2503 breakpoints should be left in place. */
2504 if (!may_insert_breakpoints
)
2506 warning (_("May not remove breakpoints"));
2510 for (; ops
!= NULL
; ops
= ops
->beneath
)
2511 if (ops
->to_remove_breakpoint
!= NULL
)
2512 return ops
->to_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
2514 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
);
2520 target_remove_breakpoint (struct gdbarch
*gdbarch
,
2521 struct bp_target_info
*bp_tgt
)
2523 return forward_target_remove_breakpoint (¤t_target
, gdbarch
, bp_tgt
);
2527 target_info (char *args
, int from_tty
)
2529 struct target_ops
*t
;
2530 int has_all_mem
= 0;
2532 if (symfile_objfile
!= NULL
)
2533 printf_unfiltered (_("Symbols from \"%s\".\n"),
2534 objfile_name (symfile_objfile
));
2536 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2538 if (!(*t
->to_has_memory
) (t
))
2541 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
2544 printf_unfiltered (_("\tWhile running this, "
2545 "GDB does not access memory from...\n"));
2546 printf_unfiltered ("%s:\n", t
->to_longname
);
2547 (t
->to_files_info
) (t
);
2548 has_all_mem
= (*t
->to_has_all_memory
) (t
);
2552 /* This function is called before any new inferior is created, e.g.
2553 by running a program, attaching, or connecting to a target.
2554 It cleans up any state from previous invocations which might
2555 change between runs. This is a subset of what target_preopen
2556 resets (things which might change between targets). */
2559 target_pre_inferior (int from_tty
)
2561 /* Clear out solib state. Otherwise the solib state of the previous
2562 inferior might have survived and is entirely wrong for the new
2563 target. This has been observed on GNU/Linux using glibc 2.3. How
2575 Cannot access memory at address 0xdeadbeef
2578 /* In some OSs, the shared library list is the same/global/shared
2579 across inferiors. If code is shared between processes, so are
2580 memory regions and features. */
2581 if (!gdbarch_has_global_solist (target_gdbarch ()))
2583 no_shared_libraries (NULL
, from_tty
);
2585 invalidate_target_mem_regions ();
2587 target_clear_description ();
2590 agent_capability_invalidate ();
2593 /* Callback for iterate_over_inferiors. Gets rid of the given
2597 dispose_inferior (struct inferior
*inf
, void *args
)
2599 struct thread_info
*thread
;
2601 thread
= any_thread_of_process (inf
->pid
);
2604 switch_to_thread (thread
->ptid
);
2606 /* Core inferiors actually should be detached, not killed. */
2607 if (target_has_execution
)
2610 target_detach (NULL
, 0);
2616 /* This is to be called by the open routine before it does
2620 target_preopen (int from_tty
)
2624 if (have_inferiors ())
2627 || !have_live_inferiors ()
2628 || query (_("A program is being debugged already. Kill it? ")))
2629 iterate_over_inferiors (dispose_inferior
, NULL
);
2631 error (_("Program not killed."));
2634 /* Calling target_kill may remove the target from the stack. But if
2635 it doesn't (which seems like a win for UDI), remove it now. */
2636 /* Leave the exec target, though. The user may be switching from a
2637 live process to a core of the same program. */
2638 pop_all_targets_above (file_stratum
);
2640 target_pre_inferior (from_tty
);
2643 /* Detach a target after doing deferred register stores. */
2646 target_detach (const char *args
, int from_tty
)
2648 struct target_ops
* t
;
2650 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
2651 /* Don't remove global breakpoints here. They're removed on
2652 disconnection from the target. */
2655 /* If we're in breakpoints-always-inserted mode, have to remove
2656 them before detaching. */
2657 remove_breakpoints_pid (ptid_get_pid (inferior_ptid
));
2659 prepare_for_detach ();
2661 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2663 if (t
->to_detach
!= NULL
)
2665 t
->to_detach (t
, args
, from_tty
);
2667 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
2673 internal_error (__FILE__
, __LINE__
, _("could not find a target to detach"));
2677 target_disconnect (char *args
, int from_tty
)
2679 struct target_ops
*t
;
2681 /* If we're in breakpoints-always-inserted mode or if breakpoints
2682 are global across processes, we have to remove them before
2684 remove_breakpoints ();
2686 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2687 if (t
->to_disconnect
!= NULL
)
2690 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
2692 t
->to_disconnect (t
, args
, from_tty
);
2700 target_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
2702 struct target_ops
*t
;
2704 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2706 if (t
->to_wait
!= NULL
)
2708 ptid_t retval
= (*t
->to_wait
) (t
, ptid
, status
, options
);
2712 char *status_string
;
2713 char *options_string
;
2715 status_string
= target_waitstatus_to_string (status
);
2716 options_string
= target_options_to_string (options
);
2717 fprintf_unfiltered (gdb_stdlog
,
2718 "target_wait (%d, status, options={%s})"
2720 ptid_get_pid (ptid
), options_string
,
2721 ptid_get_pid (retval
), status_string
);
2722 xfree (status_string
);
2723 xfree (options_string
);
2734 target_pid_to_str (ptid_t ptid
)
2736 struct target_ops
*t
;
2738 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2740 if (t
->to_pid_to_str
!= NULL
)
2741 return (*t
->to_pid_to_str
) (t
, ptid
);
2744 return normal_pid_to_str (ptid
);
2748 target_thread_name (struct thread_info
*info
)
2750 struct target_ops
*t
;
2752 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2754 if (t
->to_thread_name
!= NULL
)
2755 return (*t
->to_thread_name
) (info
);
2762 target_resume (ptid_t ptid
, int step
, enum gdb_signal signal
)
2764 struct target_ops
*t
;
2766 target_dcache_invalidate ();
2768 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2770 if (t
->to_resume
!= NULL
)
2772 t
->to_resume (t
, ptid
, step
, signal
);
2774 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n",
2775 ptid_get_pid (ptid
),
2776 step
? "step" : "continue",
2777 gdb_signal_to_name (signal
));
2779 registers_changed_ptid (ptid
);
2780 set_executing (ptid
, 1);
2781 set_running (ptid
, 1);
2782 clear_inline_frame_state (ptid
);
2791 target_pass_signals (int numsigs
, unsigned char *pass_signals
)
2793 struct target_ops
*t
;
2795 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2797 if (t
->to_pass_signals
!= NULL
)
2803 fprintf_unfiltered (gdb_stdlog
, "target_pass_signals (%d, {",
2806 for (i
= 0; i
< numsigs
; i
++)
2807 if (pass_signals
[i
])
2808 fprintf_unfiltered (gdb_stdlog
, " %s",
2809 gdb_signal_to_name (i
));
2811 fprintf_unfiltered (gdb_stdlog
, " })\n");
2814 (*t
->to_pass_signals
) (numsigs
, pass_signals
);
2821 target_program_signals (int numsigs
, unsigned char *program_signals
)
2823 struct target_ops
*t
;
2825 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2827 if (t
->to_program_signals
!= NULL
)
2833 fprintf_unfiltered (gdb_stdlog
, "target_program_signals (%d, {",
2836 for (i
= 0; i
< numsigs
; i
++)
2837 if (program_signals
[i
])
2838 fprintf_unfiltered (gdb_stdlog
, " %s",
2839 gdb_signal_to_name (i
));
2841 fprintf_unfiltered (gdb_stdlog
, " })\n");
2844 (*t
->to_program_signals
) (numsigs
, program_signals
);
2850 /* Look through the list of possible targets for a target that can
2854 target_follow_fork (int follow_child
, int detach_fork
)
2856 struct target_ops
*t
;
2858 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2860 if (t
->to_follow_fork
!= NULL
)
2862 int retval
= t
->to_follow_fork (t
, follow_child
, detach_fork
);
2865 fprintf_unfiltered (gdb_stdlog
,
2866 "target_follow_fork (%d, %d) = %d\n",
2867 follow_child
, detach_fork
, retval
);
2872 /* Some target returned a fork event, but did not know how to follow it. */
2873 internal_error (__FILE__
, __LINE__
,
2874 _("could not find a target to follow fork"));
2878 target_mourn_inferior (void)
2880 struct target_ops
*t
;
2882 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2884 if (t
->to_mourn_inferior
!= NULL
)
2886 t
->to_mourn_inferior (t
);
2888 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2890 /* We no longer need to keep handles on any of the object files.
2891 Make sure to release them to avoid unnecessarily locking any
2892 of them while we're not actually debugging. */
2893 bfd_cache_close_all ();
2899 internal_error (__FILE__
, __LINE__
,
2900 _("could not find a target to follow mourn inferior"));
2903 /* Look for a target which can describe architectural features, starting
2904 from TARGET. If we find one, return its description. */
2906 const struct target_desc
*
2907 target_read_description (struct target_ops
*target
)
2909 struct target_ops
*t
;
2911 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
2912 if (t
->to_read_description
!= NULL
)
2914 const struct target_desc
*tdesc
;
2916 tdesc
= t
->to_read_description (t
);
2924 /* The default implementation of to_search_memory.
2925 This implements a basic search of memory, reading target memory and
2926 performing the search here (as opposed to performing the search in on the
2927 target side with, for example, gdbserver). */
2930 simple_search_memory (struct target_ops
*ops
,
2931 CORE_ADDR start_addr
, ULONGEST search_space_len
,
2932 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2933 CORE_ADDR
*found_addrp
)
2935 /* NOTE: also defined in find.c testcase. */
2936 #define SEARCH_CHUNK_SIZE 16000
2937 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
2938 /* Buffer to hold memory contents for searching. */
2939 gdb_byte
*search_buf
;
2940 unsigned search_buf_size
;
2941 struct cleanup
*old_cleanups
;
2943 search_buf_size
= chunk_size
+ pattern_len
- 1;
2945 /* No point in trying to allocate a buffer larger than the search space. */
2946 if (search_space_len
< search_buf_size
)
2947 search_buf_size
= search_space_len
;
2949 search_buf
= malloc (search_buf_size
);
2950 if (search_buf
== NULL
)
2951 error (_("Unable to allocate memory to perform the search."));
2952 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
2954 /* Prime the search buffer. */
2956 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2957 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2959 warning (_("Unable to access %s bytes of target "
2960 "memory at %s, halting search."),
2961 pulongest (search_buf_size
), hex_string (start_addr
));
2962 do_cleanups (old_cleanups
);
2966 /* Perform the search.
2968 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2969 When we've scanned N bytes we copy the trailing bytes to the start and
2970 read in another N bytes. */
2972 while (search_space_len
>= pattern_len
)
2974 gdb_byte
*found_ptr
;
2975 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2977 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2978 pattern
, pattern_len
);
2980 if (found_ptr
!= NULL
)
2982 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2984 *found_addrp
= found_addr
;
2985 do_cleanups (old_cleanups
);
2989 /* Not found in this chunk, skip to next chunk. */
2991 /* Don't let search_space_len wrap here, it's unsigned. */
2992 if (search_space_len
>= chunk_size
)
2993 search_space_len
-= chunk_size
;
2995 search_space_len
= 0;
2997 if (search_space_len
>= pattern_len
)
2999 unsigned keep_len
= search_buf_size
- chunk_size
;
3000 CORE_ADDR read_addr
= start_addr
+ chunk_size
+ keep_len
;
3003 /* Copy the trailing part of the previous iteration to the front
3004 of the buffer for the next iteration. */
3005 gdb_assert (keep_len
== pattern_len
- 1);
3006 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
3008 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
3010 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
3011 search_buf
+ keep_len
, read_addr
,
3012 nr_to_read
) != nr_to_read
)
3014 warning (_("Unable to access %s bytes of target "
3015 "memory at %s, halting search."),
3016 plongest (nr_to_read
),
3017 hex_string (read_addr
));
3018 do_cleanups (old_cleanups
);
3022 start_addr
+= chunk_size
;
3028 do_cleanups (old_cleanups
);
3032 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
3033 sequence of bytes in PATTERN with length PATTERN_LEN.
3035 The result is 1 if found, 0 if not found, and -1 if there was an error
3036 requiring halting of the search (e.g. memory read error).
3037 If the pattern is found the address is recorded in FOUND_ADDRP. */
3040 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
3041 const gdb_byte
*pattern
, ULONGEST pattern_len
,
3042 CORE_ADDR
*found_addrp
)
3044 struct target_ops
*t
;
3047 /* We don't use INHERIT to set current_target.to_search_memory,
3048 so we have to scan the target stack and handle targetdebug
3052 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
3053 hex_string (start_addr
));
3055 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3056 if (t
->to_search_memory
!= NULL
)
3061 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
3062 pattern
, pattern_len
, found_addrp
);
3066 /* If a special version of to_search_memory isn't available, use the
3068 found
= simple_search_memory (current_target
.beneath
,
3069 start_addr
, search_space_len
,
3070 pattern
, pattern_len
, found_addrp
);
3074 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
3079 /* Look through the currently pushed targets. If none of them will
3080 be able to restart the currently running process, issue an error
3084 target_require_runnable (void)
3086 struct target_ops
*t
;
3088 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3090 /* If this target knows how to create a new program, then
3091 assume we will still be able to after killing the current
3092 one. Either killing and mourning will not pop T, or else
3093 find_default_run_target will find it again. */
3094 if (t
->to_create_inferior
!= NULL
)
3097 /* Do not worry about thread_stratum targets that can not
3098 create inferiors. Assume they will be pushed again if
3099 necessary, and continue to the process_stratum. */
3100 if (t
->to_stratum
== thread_stratum
3101 || t
->to_stratum
== arch_stratum
)
3104 error (_("The \"%s\" target does not support \"run\". "
3105 "Try \"help target\" or \"continue\"."),
3109 /* This function is only called if the target is running. In that
3110 case there should have been a process_stratum target and it
3111 should either know how to create inferiors, or not... */
3112 internal_error (__FILE__
, __LINE__
, _("No targets found"));
3115 /* Look through the list of possible targets for a target that can
3116 execute a run or attach command without any other data. This is
3117 used to locate the default process stratum.
3119 If DO_MESG is not NULL, the result is always valid (error() is
3120 called for errors); else, return NULL on error. */
3122 static struct target_ops
*
3123 find_default_run_target (char *do_mesg
)
3125 struct target_ops
**t
;
3126 struct target_ops
*runable
= NULL
;
3131 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
3134 if ((*t
)->to_can_run
&& target_can_run (*t
))
3144 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
3153 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
3155 struct target_ops
*t
;
3157 t
= find_default_run_target ("attach");
3158 (t
->to_attach
) (t
, args
, from_tty
);
3163 find_default_create_inferior (struct target_ops
*ops
,
3164 char *exec_file
, char *allargs
, char **env
,
3167 struct target_ops
*t
;
3169 t
= find_default_run_target ("run");
3170 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
3175 find_default_can_async_p (void)
3177 struct target_ops
*t
;
3179 /* This may be called before the target is pushed on the stack;
3180 look for the default process stratum. If there's none, gdb isn't
3181 configured with a native debugger, and target remote isn't
3183 t
= find_default_run_target (NULL
);
3184 if (t
&& t
->to_can_async_p
)
3185 return (t
->to_can_async_p
) ();
3190 find_default_is_async_p (void)
3192 struct target_ops
*t
;
3194 /* This may be called before the target is pushed on the stack;
3195 look for the default process stratum. If there's none, gdb isn't
3196 configured with a native debugger, and target remote isn't
3198 t
= find_default_run_target (NULL
);
3199 if (t
&& t
->to_is_async_p
)
3200 return (t
->to_is_async_p
) ();
3205 find_default_supports_non_stop (void)
3207 struct target_ops
*t
;
3209 t
= find_default_run_target (NULL
);
3210 if (t
&& t
->to_supports_non_stop
)
3211 return (t
->to_supports_non_stop
) ();
3216 target_supports_non_stop (void)
3218 struct target_ops
*t
;
3220 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3221 if (t
->to_supports_non_stop
)
3222 return t
->to_supports_non_stop ();
3227 /* Implement the "info proc" command. */
3230 target_info_proc (char *args
, enum info_proc_what what
)
3232 struct target_ops
*t
;
3234 /* If we're already connected to something that can get us OS
3235 related data, use it. Otherwise, try using the native
3237 if (current_target
.to_stratum
>= process_stratum
)
3238 t
= current_target
.beneath
;
3240 t
= find_default_run_target (NULL
);
3242 for (; t
!= NULL
; t
= t
->beneath
)
3244 if (t
->to_info_proc
!= NULL
)
3246 t
->to_info_proc (t
, args
, what
);
3249 fprintf_unfiltered (gdb_stdlog
,
3250 "target_info_proc (\"%s\", %d)\n", args
, what
);
3260 find_default_supports_disable_randomization (void)
3262 struct target_ops
*t
;
3264 t
= find_default_run_target (NULL
);
3265 if (t
&& t
->to_supports_disable_randomization
)
3266 return (t
->to_supports_disable_randomization
) ();
3271 target_supports_disable_randomization (void)
3273 struct target_ops
*t
;
3275 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
3276 if (t
->to_supports_disable_randomization
)
3277 return t
->to_supports_disable_randomization ();
3283 target_get_osdata (const char *type
)
3285 struct target_ops
*t
;
3287 /* If we're already connected to something that can get us OS
3288 related data, use it. Otherwise, try using the native
3290 if (current_target
.to_stratum
>= process_stratum
)
3291 t
= current_target
.beneath
;
3293 t
= find_default_run_target ("get OS data");
3298 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
3301 /* Determine the current address space of thread PTID. */
3303 struct address_space
*
3304 target_thread_address_space (ptid_t ptid
)
3306 struct address_space
*aspace
;
3307 struct inferior
*inf
;
3308 struct target_ops
*t
;
3310 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3312 if (t
->to_thread_address_space
!= NULL
)
3314 aspace
= t
->to_thread_address_space (t
, ptid
);
3315 gdb_assert (aspace
);
3318 fprintf_unfiltered (gdb_stdlog
,
3319 "target_thread_address_space (%s) = %d\n",
3320 target_pid_to_str (ptid
),
3321 address_space_num (aspace
));
3326 /* Fall-back to the "main" address space of the inferior. */
3327 inf
= find_inferior_pid (ptid_get_pid (ptid
));
3329 if (inf
== NULL
|| inf
->aspace
== NULL
)
3330 internal_error (__FILE__
, __LINE__
,
3331 _("Can't determine the current "
3332 "address space of thread %s\n"),
3333 target_pid_to_str (ptid
));
3339 /* Target file operations. */
3341 static struct target_ops
*
3342 default_fileio_target (void)
3344 /* If we're already connected to something that can perform
3345 file I/O, use it. Otherwise, try using the native target. */
3346 if (current_target
.to_stratum
>= process_stratum
)
3347 return current_target
.beneath
;
3349 return find_default_run_target ("file I/O");
3352 /* Open FILENAME on the target, using FLAGS and MODE. Return a
3353 target file descriptor, or -1 if an error occurs (and set
3356 target_fileio_open (const char *filename
, int flags
, int mode
,
3359 struct target_ops
*t
;
3361 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3363 if (t
->to_fileio_open
!= NULL
)
3365 int fd
= t
->to_fileio_open (filename
, flags
, mode
, target_errno
);
3368 fprintf_unfiltered (gdb_stdlog
,
3369 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3370 filename
, flags
, mode
,
3371 fd
, fd
!= -1 ? 0 : *target_errno
);
3376 *target_errno
= FILEIO_ENOSYS
;
3380 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3381 Return the number of bytes written, or -1 if an error occurs
3382 (and set *TARGET_ERRNO). */
3384 target_fileio_pwrite (int fd
, const gdb_byte
*write_buf
, int len
,
3385 ULONGEST offset
, int *target_errno
)
3387 struct target_ops
*t
;
3389 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3391 if (t
->to_fileio_pwrite
!= NULL
)
3393 int ret
= t
->to_fileio_pwrite (fd
, write_buf
, len
, offset
,
3397 fprintf_unfiltered (gdb_stdlog
,
3398 "target_fileio_pwrite (%d,...,%d,%s) "
3400 fd
, len
, pulongest (offset
),
3401 ret
, ret
!= -1 ? 0 : *target_errno
);
3406 *target_errno
= FILEIO_ENOSYS
;
3410 /* Read up to LEN bytes FD on the target into READ_BUF.
3411 Return the number of bytes read, or -1 if an error occurs
3412 (and set *TARGET_ERRNO). */
3414 target_fileio_pread (int fd
, gdb_byte
*read_buf
, int len
,
3415 ULONGEST offset
, int *target_errno
)
3417 struct target_ops
*t
;
3419 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3421 if (t
->to_fileio_pread
!= NULL
)
3423 int ret
= t
->to_fileio_pread (fd
, read_buf
, len
, offset
,
3427 fprintf_unfiltered (gdb_stdlog
,
3428 "target_fileio_pread (%d,...,%d,%s) "
3430 fd
, len
, pulongest (offset
),
3431 ret
, ret
!= -1 ? 0 : *target_errno
);
3436 *target_errno
= FILEIO_ENOSYS
;
3440 /* Close FD on the target. Return 0, or -1 if an error occurs
3441 (and set *TARGET_ERRNO). */
3443 target_fileio_close (int fd
, int *target_errno
)
3445 struct target_ops
*t
;
3447 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3449 if (t
->to_fileio_close
!= NULL
)
3451 int ret
= t
->to_fileio_close (fd
, target_errno
);
3454 fprintf_unfiltered (gdb_stdlog
,
3455 "target_fileio_close (%d) = %d (%d)\n",
3456 fd
, ret
, ret
!= -1 ? 0 : *target_errno
);
3461 *target_errno
= FILEIO_ENOSYS
;
3465 /* Unlink FILENAME on the target. Return 0, or -1 if an error
3466 occurs (and set *TARGET_ERRNO). */
3468 target_fileio_unlink (const char *filename
, int *target_errno
)
3470 struct target_ops
*t
;
3472 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3474 if (t
->to_fileio_unlink
!= NULL
)
3476 int ret
= t
->to_fileio_unlink (filename
, target_errno
);
3479 fprintf_unfiltered (gdb_stdlog
,
3480 "target_fileio_unlink (%s) = %d (%d)\n",
3481 filename
, ret
, ret
!= -1 ? 0 : *target_errno
);
3486 *target_errno
= FILEIO_ENOSYS
;
3490 /* Read value of symbolic link FILENAME on the target. Return a
3491 null-terminated string allocated via xmalloc, or NULL if an error
3492 occurs (and set *TARGET_ERRNO). */
3494 target_fileio_readlink (const char *filename
, int *target_errno
)
3496 struct target_ops
*t
;
3498 for (t
= default_fileio_target (); t
!= NULL
; t
= t
->beneath
)
3500 if (t
->to_fileio_readlink
!= NULL
)
3502 char *ret
= t
->to_fileio_readlink (filename
, target_errno
);
3505 fprintf_unfiltered (gdb_stdlog
,
3506 "target_fileio_readlink (%s) = %s (%d)\n",
3507 filename
, ret
? ret
: "(nil)",
3508 ret
? 0 : *target_errno
);
3513 *target_errno
= FILEIO_ENOSYS
;
3518 target_fileio_close_cleanup (void *opaque
)
3520 int fd
= *(int *) opaque
;
3523 target_fileio_close (fd
, &target_errno
);
3526 /* Read target file FILENAME. Store the result in *BUF_P and
3527 return the size of the transferred data. PADDING additional bytes are
3528 available in *BUF_P. This is a helper function for
3529 target_fileio_read_alloc; see the declaration of that function for more
3533 target_fileio_read_alloc_1 (const char *filename
,
3534 gdb_byte
**buf_p
, int padding
)
3536 struct cleanup
*close_cleanup
;
3537 size_t buf_alloc
, buf_pos
;
3543 fd
= target_fileio_open (filename
, FILEIO_O_RDONLY
, 0700, &target_errno
);
3547 close_cleanup
= make_cleanup (target_fileio_close_cleanup
, &fd
);
3549 /* Start by reading up to 4K at a time. The target will throttle
3550 this number down if necessary. */
3552 buf
= xmalloc (buf_alloc
);
3556 n
= target_fileio_pread (fd
, &buf
[buf_pos
],
3557 buf_alloc
- buf_pos
- padding
, buf_pos
,
3561 /* An error occurred. */
3562 do_cleanups (close_cleanup
);
3568 /* Read all there was. */
3569 do_cleanups (close_cleanup
);
3579 /* If the buffer is filling up, expand it. */
3580 if (buf_alloc
< buf_pos
* 2)
3583 buf
= xrealloc (buf
, buf_alloc
);
3590 /* Read target file FILENAME. Store the result in *BUF_P and return
3591 the size of the transferred data. See the declaration in "target.h"
3592 function for more information about the return value. */
3595 target_fileio_read_alloc (const char *filename
, gdb_byte
**buf_p
)
3597 return target_fileio_read_alloc_1 (filename
, buf_p
, 0);
3600 /* Read target file FILENAME. The result is NUL-terminated and
3601 returned as a string, allocated using xmalloc. If an error occurs
3602 or the transfer is unsupported, NULL is returned. Empty objects
3603 are returned as allocated but empty strings. A warning is issued
3604 if the result contains any embedded NUL bytes. */
3607 target_fileio_read_stralloc (const char *filename
)
3611 LONGEST i
, transferred
;
3613 transferred
= target_fileio_read_alloc_1 (filename
, &buffer
, 1);
3614 bufstr
= (char *) buffer
;
3616 if (transferred
< 0)
3619 if (transferred
== 0)
3620 return xstrdup ("");
3622 bufstr
[transferred
] = 0;
3624 /* Check for embedded NUL bytes; but allow trailing NULs. */
3625 for (i
= strlen (bufstr
); i
< transferred
; i
++)
3628 warning (_("target file %s "
3629 "contained unexpected null characters"),
3639 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
3641 return (len
<= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT
);
3645 default_watchpoint_addr_within_range (struct target_ops
*target
,
3647 CORE_ADDR start
, int length
)
3649 return addr
>= start
&& addr
< start
+ length
;
3652 static struct gdbarch
*
3653 default_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
3655 return target_gdbarch ();
3671 return_minus_one (void)
3683 * Find the next target down the stack from the specified target.
3687 find_target_beneath (struct target_ops
*t
)
3693 /* The inferior process has died. Long live the inferior! */
3696 generic_mourn_inferior (void)
3700 ptid
= inferior_ptid
;
3701 inferior_ptid
= null_ptid
;
3703 /* Mark breakpoints uninserted in case something tries to delete a
3704 breakpoint while we delete the inferior's threads (which would
3705 fail, since the inferior is long gone). */
3706 mark_breakpoints_out ();
3708 if (!ptid_equal (ptid
, null_ptid
))
3710 int pid
= ptid_get_pid (ptid
);
3711 exit_inferior (pid
);
3714 /* Note this wipes step-resume breakpoints, so needs to be done
3715 after exit_inferior, which ends up referencing the step-resume
3716 breakpoints through clear_thread_inferior_resources. */
3717 breakpoint_init_inferior (inf_exited
);
3719 registers_changed ();
3721 reopen_exec_file ();
3722 reinit_frame_cache ();
3724 if (deprecated_detach_hook
)
3725 deprecated_detach_hook ();
3728 /* Convert a normal process ID to a string. Returns the string in a
3732 normal_pid_to_str (ptid_t ptid
)
3734 static char buf
[32];
3736 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
3741 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
3743 return normal_pid_to_str (ptid
);
3746 /* Error-catcher for target_find_memory_regions. */
3748 dummy_find_memory_regions (find_memory_region_ftype ignore1
, void *ignore2
)
3750 error (_("Command not implemented for this target."));
3754 /* Error-catcher for target_make_corefile_notes. */
3756 dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
3758 error (_("Command not implemented for this target."));
3762 /* Error-catcher for target_get_bookmark. */
3764 dummy_get_bookmark (char *ignore1
, int ignore2
)
3770 /* Error-catcher for target_goto_bookmark. */
3772 dummy_goto_bookmark (gdb_byte
*ignore
, int from_tty
)
3777 /* Set up the handful of non-empty slots needed by the dummy target
3781 init_dummy_target (void)
3783 dummy_target
.to_shortname
= "None";
3784 dummy_target
.to_longname
= "None";
3785 dummy_target
.to_doc
= "";
3786 dummy_target
.to_attach
= find_default_attach
;
3787 dummy_target
.to_detach
=
3788 (void (*)(struct target_ops
*, const char *, int))target_ignore
;
3789 dummy_target
.to_create_inferior
= find_default_create_inferior
;
3790 dummy_target
.to_can_async_p
= find_default_can_async_p
;
3791 dummy_target
.to_is_async_p
= find_default_is_async_p
;
3792 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
3793 dummy_target
.to_supports_disable_randomization
3794 = find_default_supports_disable_randomization
;
3795 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
3796 dummy_target
.to_stratum
= dummy_stratum
;
3797 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
3798 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
3799 dummy_target
.to_get_bookmark
= dummy_get_bookmark
;
3800 dummy_target
.to_goto_bookmark
= dummy_goto_bookmark
;
3801 dummy_target
.to_xfer_partial
= default_xfer_partial
;
3802 dummy_target
.to_has_all_memory
= (int (*) (struct target_ops
*)) return_zero
;
3803 dummy_target
.to_has_memory
= (int (*) (struct target_ops
*)) return_zero
;
3804 dummy_target
.to_has_stack
= (int (*) (struct target_ops
*)) return_zero
;
3805 dummy_target
.to_has_registers
= (int (*) (struct target_ops
*)) return_zero
;
3806 dummy_target
.to_has_execution
3807 = (int (*) (struct target_ops
*, ptid_t
)) return_zero
;
3808 dummy_target
.to_stopped_by_watchpoint
= return_zero
;
3809 dummy_target
.to_stopped_data_address
=
3810 (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
;
3811 dummy_target
.to_magic
= OPS_MAGIC
;
3815 debug_to_open (char *args
, int from_tty
)
3817 debug_target
.to_open (args
, from_tty
);
3819 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
3823 target_close (struct target_ops
*targ
)
3825 gdb_assert (!target_is_pushed (targ
));
3827 if (targ
->to_xclose
!= NULL
)
3828 targ
->to_xclose (targ
);
3829 else if (targ
->to_close
!= NULL
)
3833 fprintf_unfiltered (gdb_stdlog
, "target_close ()\n");
3837 target_attach (char *args
, int from_tty
)
3839 struct target_ops
*t
;
3841 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3843 if (t
->to_attach
!= NULL
)
3845 t
->to_attach (t
, args
, from_tty
);
3847 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
3853 internal_error (__FILE__
, __LINE__
,
3854 _("could not find a target to attach"));
3858 target_thread_alive (ptid_t ptid
)
3860 struct target_ops
*t
;
3862 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3864 if (t
->to_thread_alive
!= NULL
)
3868 retval
= t
->to_thread_alive (t
, ptid
);
3870 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3871 ptid_get_pid (ptid
), retval
);
3881 target_find_new_threads (void)
3883 struct target_ops
*t
;
3885 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
3887 if (t
->to_find_new_threads
!= NULL
)
3889 t
->to_find_new_threads (t
);
3891 fprintf_unfiltered (gdb_stdlog
, "target_find_new_threads ()\n");
3899 target_stop (ptid_t ptid
)
3903 warning (_("May not interrupt or stop the target, ignoring attempt"));
3907 (*current_target
.to_stop
) (ptid
);
3911 debug_to_post_attach (int pid
)
3913 debug_target
.to_post_attach (pid
);
3915 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
3918 /* Concatenate ELEM to LIST, a comma separate list, and return the
3919 result. The LIST incoming argument is released. */
3922 str_comma_list_concat_elem (char *list
, const char *elem
)
3925 return xstrdup (elem
);
3927 return reconcat (list
, list
, ", ", elem
, (char *) NULL
);
3930 /* Helper for target_options_to_string. If OPT is present in
3931 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3932 Returns the new resulting string. OPT is removed from
3936 do_option (int *target_options
, char *ret
,
3937 int opt
, char *opt_str
)
3939 if ((*target_options
& opt
) != 0)
3941 ret
= str_comma_list_concat_elem (ret
, opt_str
);
3942 *target_options
&= ~opt
;
3949 target_options_to_string (int target_options
)
3953 #define DO_TARG_OPTION(OPT) \
3954 ret = do_option (&target_options, ret, OPT, #OPT)
3956 DO_TARG_OPTION (TARGET_WNOHANG
);
3958 if (target_options
!= 0)
3959 ret
= str_comma_list_concat_elem (ret
, "unknown???");
3967 debug_print_register (const char * func
,
3968 struct regcache
*regcache
, int regno
)
3970 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3972 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
3973 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
3974 && gdbarch_register_name (gdbarch
, regno
) != NULL
3975 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
3976 fprintf_unfiltered (gdb_stdlog
, "(%s)",
3977 gdbarch_register_name (gdbarch
, regno
));
3979 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
3980 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
3982 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3983 int i
, size
= register_size (gdbarch
, regno
);
3984 gdb_byte buf
[MAX_REGISTER_SIZE
];
3986 regcache_raw_collect (regcache
, regno
, buf
);
3987 fprintf_unfiltered (gdb_stdlog
, " = ");
3988 for (i
= 0; i
< size
; i
++)
3990 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3992 if (size
<= sizeof (LONGEST
))
3994 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
3996 fprintf_unfiltered (gdb_stdlog
, " %s %s",
3997 core_addr_to_string_nz (val
), plongest (val
));
4000 fprintf_unfiltered (gdb_stdlog
, "\n");
4004 target_fetch_registers (struct regcache
*regcache
, int regno
)
4006 struct target_ops
*t
;
4008 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4010 if (t
->to_fetch_registers
!= NULL
)
4012 t
->to_fetch_registers (t
, regcache
, regno
);
4014 debug_print_register ("target_fetch_registers", regcache
, regno
);
4021 target_store_registers (struct regcache
*regcache
, int regno
)
4023 struct target_ops
*t
;
4025 if (!may_write_registers
)
4026 error (_("Writing to registers is not allowed (regno %d)"), regno
);
4028 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4030 if (t
->to_store_registers
!= NULL
)
4032 t
->to_store_registers (t
, regcache
, regno
);
4035 debug_print_register ("target_store_registers", regcache
, regno
);
4045 target_core_of_thread (ptid_t ptid
)
4047 struct target_ops
*t
;
4049 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4051 if (t
->to_core_of_thread
!= NULL
)
4053 int retval
= t
->to_core_of_thread (t
, ptid
);
4056 fprintf_unfiltered (gdb_stdlog
,
4057 "target_core_of_thread (%d) = %d\n",
4058 ptid_get_pid (ptid
), retval
);
4067 target_verify_memory (const gdb_byte
*data
, CORE_ADDR memaddr
, ULONGEST size
)
4069 struct target_ops
*t
;
4071 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4073 if (t
->to_verify_memory
!= NULL
)
4075 int retval
= t
->to_verify_memory (t
, data
, memaddr
, size
);
4078 fprintf_unfiltered (gdb_stdlog
,
4079 "target_verify_memory (%s, %s) = %d\n",
4080 paddress (target_gdbarch (), memaddr
),
4090 /* The documentation for this function is in its prototype declaration in
4094 target_insert_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4096 struct target_ops
*t
;
4098 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4099 if (t
->to_insert_mask_watchpoint
!= NULL
)
4103 ret
= t
->to_insert_mask_watchpoint (t
, addr
, mask
, rw
);
4106 fprintf_unfiltered (gdb_stdlog
, "\
4107 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
4108 core_addr_to_string (addr
),
4109 core_addr_to_string (mask
), rw
, ret
);
4117 /* The documentation for this function is in its prototype declaration in
4121 target_remove_mask_watchpoint (CORE_ADDR addr
, CORE_ADDR mask
, int rw
)
4123 struct target_ops
*t
;
4125 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4126 if (t
->to_remove_mask_watchpoint
!= NULL
)
4130 ret
= t
->to_remove_mask_watchpoint (t
, addr
, mask
, rw
);
4133 fprintf_unfiltered (gdb_stdlog
, "\
4134 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4135 core_addr_to_string (addr
),
4136 core_addr_to_string (mask
), rw
, ret
);
4144 /* The documentation for this function is in its prototype declaration
4148 target_masked_watch_num_registers (CORE_ADDR addr
, CORE_ADDR mask
)
4150 struct target_ops
*t
;
4152 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4153 if (t
->to_masked_watch_num_registers
!= NULL
)
4154 return t
->to_masked_watch_num_registers (t
, addr
, mask
);
4159 /* The documentation for this function is in its prototype declaration
4163 target_ranged_break_num_registers (void)
4165 struct target_ops
*t
;
4167 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4168 if (t
->to_ranged_break_num_registers
!= NULL
)
4169 return t
->to_ranged_break_num_registers (t
);
4177 target_supports_btrace (void)
4179 struct target_ops
*t
;
4181 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4182 if (t
->to_supports_btrace
!= NULL
)
4183 return t
->to_supports_btrace ();
4190 struct btrace_target_info
*
4191 target_enable_btrace (ptid_t ptid
)
4193 struct target_ops
*t
;
4195 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4196 if (t
->to_enable_btrace
!= NULL
)
4197 return t
->to_enable_btrace (ptid
);
4206 target_disable_btrace (struct btrace_target_info
*btinfo
)
4208 struct target_ops
*t
;
4210 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4211 if (t
->to_disable_btrace
!= NULL
)
4213 t
->to_disable_btrace (btinfo
);
4223 target_teardown_btrace (struct btrace_target_info
*btinfo
)
4225 struct target_ops
*t
;
4227 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4228 if (t
->to_teardown_btrace
!= NULL
)
4230 t
->to_teardown_btrace (btinfo
);
4240 target_read_btrace (VEC (btrace_block_s
) **btrace
,
4241 struct btrace_target_info
*btinfo
,
4242 enum btrace_read_type type
)
4244 struct target_ops
*t
;
4246 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4247 if (t
->to_read_btrace
!= NULL
)
4248 return t
->to_read_btrace (btrace
, btinfo
, type
);
4251 return BTRACE_ERR_NOT_SUPPORTED
;
4257 target_stop_recording (void)
4259 struct target_ops
*t
;
4261 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4262 if (t
->to_stop_recording
!= NULL
)
4264 t
->to_stop_recording ();
4268 /* This is optional. */
4274 target_info_record (void)
4276 struct target_ops
*t
;
4278 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4279 if (t
->to_info_record
!= NULL
)
4281 t
->to_info_record ();
4291 target_save_record (const char *filename
)
4293 struct target_ops
*t
;
4295 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4296 if (t
->to_save_record
!= NULL
)
4298 t
->to_save_record (filename
);
4308 target_supports_delete_record (void)
4310 struct target_ops
*t
;
4312 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4313 if (t
->to_delete_record
!= NULL
)
4322 target_delete_record (void)
4324 struct target_ops
*t
;
4326 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4327 if (t
->to_delete_record
!= NULL
)
4329 t
->to_delete_record ();
4339 target_record_is_replaying (void)
4341 struct target_ops
*t
;
4343 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4344 if (t
->to_record_is_replaying
!= NULL
)
4345 return t
->to_record_is_replaying ();
4353 target_goto_record_begin (void)
4355 struct target_ops
*t
;
4357 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4358 if (t
->to_goto_record_begin
!= NULL
)
4360 t
->to_goto_record_begin ();
4370 target_goto_record_end (void)
4372 struct target_ops
*t
;
4374 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4375 if (t
->to_goto_record_end
!= NULL
)
4377 t
->to_goto_record_end ();
4387 target_goto_record (ULONGEST insn
)
4389 struct target_ops
*t
;
4391 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4392 if (t
->to_goto_record
!= NULL
)
4394 t
->to_goto_record (insn
);
4404 target_insn_history (int size
, int flags
)
4406 struct target_ops
*t
;
4408 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4409 if (t
->to_insn_history
!= NULL
)
4411 t
->to_insn_history (size
, flags
);
4421 target_insn_history_from (ULONGEST from
, int size
, int flags
)
4423 struct target_ops
*t
;
4425 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4426 if (t
->to_insn_history_from
!= NULL
)
4428 t
->to_insn_history_from (from
, size
, flags
);
4438 target_insn_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4440 struct target_ops
*t
;
4442 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4443 if (t
->to_insn_history_range
!= NULL
)
4445 t
->to_insn_history_range (begin
, end
, flags
);
4455 target_call_history (int size
, int flags
)
4457 struct target_ops
*t
;
4459 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4460 if (t
->to_call_history
!= NULL
)
4462 t
->to_call_history (size
, flags
);
4472 target_call_history_from (ULONGEST begin
, int size
, int flags
)
4474 struct target_ops
*t
;
4476 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4477 if (t
->to_call_history_from
!= NULL
)
4479 t
->to_call_history_from (begin
, size
, flags
);
4489 target_call_history_range (ULONGEST begin
, ULONGEST end
, int flags
)
4491 struct target_ops
*t
;
4493 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4494 if (t
->to_call_history_range
!= NULL
)
4496 t
->to_call_history_range (begin
, end
, flags
);
4504 debug_to_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
4506 debug_target
.to_prepare_to_store (&debug_target
, regcache
);
4508 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
4513 const struct frame_unwind
*
4514 target_get_unwinder (void)
4516 struct target_ops
*t
;
4518 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4519 if (t
->to_get_unwinder
!= NULL
)
4520 return t
->to_get_unwinder
;
4527 const struct frame_unwind
*
4528 target_get_tailcall_unwinder (void)
4530 struct target_ops
*t
;
4532 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
4533 if (t
->to_get_tailcall_unwinder
!= NULL
)
4534 return t
->to_get_tailcall_unwinder
;
4542 forward_target_decr_pc_after_break (struct target_ops
*ops
,
4543 struct gdbarch
*gdbarch
)
4545 for (; ops
!= NULL
; ops
= ops
->beneath
)
4546 if (ops
->to_decr_pc_after_break
!= NULL
)
4547 return ops
->to_decr_pc_after_break (ops
, gdbarch
);
4549 return gdbarch_decr_pc_after_break (gdbarch
);
4555 target_decr_pc_after_break (struct gdbarch
*gdbarch
)
4557 return forward_target_decr_pc_after_break (current_target
.beneath
, gdbarch
);
4561 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
4562 int write
, struct mem_attrib
*attrib
,
4563 struct target_ops
*target
)
4567 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
4570 fprintf_unfiltered (gdb_stdlog
,
4571 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4572 paddress (target_gdbarch (), memaddr
), len
,
4573 write
? "write" : "read", retval
);
4579 fputs_unfiltered (", bytes =", gdb_stdlog
);
4580 for (i
= 0; i
< retval
; i
++)
4582 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
4584 if (targetdebug
< 2 && i
> 0)
4586 fprintf_unfiltered (gdb_stdlog
, " ...");
4589 fprintf_unfiltered (gdb_stdlog
, "\n");
4592 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
4596 fputc_unfiltered ('\n', gdb_stdlog
);
4602 debug_to_files_info (struct target_ops
*target
)
4604 debug_target
.to_files_info (target
);
4606 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
4610 debug_to_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4611 struct bp_target_info
*bp_tgt
)
4615 retval
= forward_target_insert_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4617 fprintf_unfiltered (gdb_stdlog
,
4618 "target_insert_breakpoint (%s, xxx) = %ld\n",
4619 core_addr_to_string (bp_tgt
->placed_address
),
4620 (unsigned long) retval
);
4625 debug_to_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
4626 struct bp_target_info
*bp_tgt
)
4630 retval
= forward_target_remove_breakpoint (&debug_target
, gdbarch
, bp_tgt
);
4632 fprintf_unfiltered (gdb_stdlog
,
4633 "target_remove_breakpoint (%s, xxx) = %ld\n",
4634 core_addr_to_string (bp_tgt
->placed_address
),
4635 (unsigned long) retval
);
4640 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
4644 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
4646 fprintf_unfiltered (gdb_stdlog
,
4647 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4648 (unsigned long) type
,
4649 (unsigned long) cnt
,
4650 (unsigned long) from_tty
,
4651 (unsigned long) retval
);
4656 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
4660 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
4662 fprintf_unfiltered (gdb_stdlog
,
4663 "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4664 core_addr_to_string (addr
), (unsigned long) len
,
4665 core_addr_to_string (retval
));
4670 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr
, int len
, int rw
,
4671 struct expression
*cond
)
4675 retval
= debug_target
.to_can_accel_watchpoint_condition (addr
, len
,
4678 fprintf_unfiltered (gdb_stdlog
,
4679 "target_can_accel_watchpoint_condition "
4680 "(%s, %d, %d, %s) = %ld\n",
4681 core_addr_to_string (addr
), len
, rw
,
4682 host_address_to_string (cond
), (unsigned long) retval
);
4687 debug_to_stopped_by_watchpoint (void)
4691 retval
= debug_target
.to_stopped_by_watchpoint ();
4693 fprintf_unfiltered (gdb_stdlog
,
4694 "target_stopped_by_watchpoint () = %ld\n",
4695 (unsigned long) retval
);
4700 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
4704 retval
= debug_target
.to_stopped_data_address (target
, addr
);
4706 fprintf_unfiltered (gdb_stdlog
,
4707 "target_stopped_data_address ([%s]) = %ld\n",
4708 core_addr_to_string (*addr
),
4709 (unsigned long)retval
);
4714 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
4716 CORE_ADDR start
, int length
)
4720 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
4723 fprintf_filtered (gdb_stdlog
,
4724 "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4725 core_addr_to_string (addr
), core_addr_to_string (start
),
4731 debug_to_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
4732 struct bp_target_info
*bp_tgt
)
4736 retval
= debug_target
.to_insert_hw_breakpoint (gdbarch
, bp_tgt
);
4738 fprintf_unfiltered (gdb_stdlog
,
4739 "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4740 core_addr_to_string (bp_tgt
->placed_address
),
4741 (unsigned long) retval
);
4746 debug_to_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
4747 struct bp_target_info
*bp_tgt
)
4751 retval
= debug_target
.to_remove_hw_breakpoint (gdbarch
, bp_tgt
);
4753 fprintf_unfiltered (gdb_stdlog
,
4754 "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4755 core_addr_to_string (bp_tgt
->placed_address
),
4756 (unsigned long) retval
);
4761 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
,
4762 struct expression
*cond
)
4766 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
, cond
);
4768 fprintf_unfiltered (gdb_stdlog
,
4769 "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4770 core_addr_to_string (addr
), len
, type
,
4771 host_address_to_string (cond
), (unsigned long) retval
);
4776 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
,
4777 struct expression
*cond
)
4781 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
, cond
);
4783 fprintf_unfiltered (gdb_stdlog
,
4784 "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4785 core_addr_to_string (addr
), len
, type
,
4786 host_address_to_string (cond
), (unsigned long) retval
);
4791 debug_to_terminal_init (void)
4793 debug_target
.to_terminal_init ();
4795 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
4799 debug_to_terminal_inferior (void)
4801 debug_target
.to_terminal_inferior ();
4803 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
4807 debug_to_terminal_ours_for_output (void)
4809 debug_target
.to_terminal_ours_for_output ();
4811 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
4815 debug_to_terminal_ours (void)
4817 debug_target
.to_terminal_ours ();
4819 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
4823 debug_to_terminal_save_ours (void)
4825 debug_target
.to_terminal_save_ours ();
4827 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
4831 debug_to_terminal_info (const char *arg
, int from_tty
)
4833 debug_target
.to_terminal_info (arg
, from_tty
);
4835 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
4840 debug_to_load (char *args
, int from_tty
)
4842 debug_target
.to_load (args
, from_tty
);
4844 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
4848 debug_to_post_startup_inferior (ptid_t ptid
)
4850 debug_target
.to_post_startup_inferior (ptid
);
4852 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
4853 ptid_get_pid (ptid
));
4857 debug_to_insert_fork_catchpoint (int pid
)
4861 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
4863 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
4870 debug_to_remove_fork_catchpoint (int pid
)
4874 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
4876 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
4883 debug_to_insert_vfork_catchpoint (int pid
)
4887 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
4889 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d) = %d\n",
4896 debug_to_remove_vfork_catchpoint (int pid
)
4900 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
4902 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
4909 debug_to_insert_exec_catchpoint (int pid
)
4913 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
4915 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
4922 debug_to_remove_exec_catchpoint (int pid
)
4926 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
4928 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
4935 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
4939 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
4941 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
4942 pid
, wait_status
, *exit_status
, has_exited
);
4948 debug_to_can_run (void)
4952 retval
= debug_target
.to_can_run ();
4954 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
4959 static struct gdbarch
*
4960 debug_to_thread_architecture (struct target_ops
*ops
, ptid_t ptid
)
4962 struct gdbarch
*retval
;
4964 retval
= debug_target
.to_thread_architecture (ops
, ptid
);
4966 fprintf_unfiltered (gdb_stdlog
,
4967 "target_thread_architecture (%s) = %s [%s]\n",
4968 target_pid_to_str (ptid
),
4969 host_address_to_string (retval
),
4970 gdbarch_bfd_arch_info (retval
)->printable_name
);
4975 debug_to_stop (ptid_t ptid
)
4977 debug_target
.to_stop (ptid
);
4979 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
4980 target_pid_to_str (ptid
));
4984 debug_to_rcmd (char *command
,
4985 struct ui_file
*outbuf
)
4987 debug_target
.to_rcmd (command
, outbuf
);
4988 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
4992 debug_to_pid_to_exec_file (int pid
)
4996 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
4998 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
5005 setup_target_debug (void)
5007 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
5009 current_target
.to_open
= debug_to_open
;
5010 current_target
.to_post_attach
= debug_to_post_attach
;
5011 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
5012 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
5013 current_target
.to_files_info
= debug_to_files_info
;
5014 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
5015 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
5016 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
5017 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
5018 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
5019 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
5020 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
5021 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
5022 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
5023 current_target
.to_watchpoint_addr_within_range
5024 = debug_to_watchpoint_addr_within_range
;
5025 current_target
.to_region_ok_for_hw_watchpoint
5026 = debug_to_region_ok_for_hw_watchpoint
;
5027 current_target
.to_can_accel_watchpoint_condition
5028 = debug_to_can_accel_watchpoint_condition
;
5029 current_target
.to_terminal_init
= debug_to_terminal_init
;
5030 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
5031 current_target
.to_terminal_ours_for_output
5032 = debug_to_terminal_ours_for_output
;
5033 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
5034 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
5035 current_target
.to_terminal_info
= debug_to_terminal_info
;
5036 current_target
.to_load
= debug_to_load
;
5037 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
5038 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
5039 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
5040 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
5041 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
5042 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
5043 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
5044 current_target
.to_has_exited
= debug_to_has_exited
;
5045 current_target
.to_can_run
= debug_to_can_run
;
5046 current_target
.to_stop
= debug_to_stop
;
5047 current_target
.to_rcmd
= debug_to_rcmd
;
5048 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
5049 current_target
.to_thread_architecture
= debug_to_thread_architecture
;
5053 static char targ_desc
[] =
5054 "Names of targets and files being debugged.\nShows the entire \
5055 stack of targets currently in use (including the exec-file,\n\
5056 core-file, and process, if any), as well as the symbol file name.";
5059 do_monitor_command (char *cmd
,
5062 if ((current_target
.to_rcmd
5063 == (void (*) (char *, struct ui_file
*)) tcomplain
)
5064 || (current_target
.to_rcmd
== debug_to_rcmd
5065 && (debug_target
.to_rcmd
5066 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
5067 error (_("\"monitor\" command not supported by this target."));
5068 target_rcmd (cmd
, gdb_stdtarg
);
5071 /* Print the name of each layers of our target stack. */
5074 maintenance_print_target_stack (char *cmd
, int from_tty
)
5076 struct target_ops
*t
;
5078 printf_filtered (_("The current target stack is:\n"));
5080 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
5082 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
5086 /* Controls if async mode is permitted. */
5087 int target_async_permitted
= 0;
5089 /* The set command writes to this variable. If the inferior is
5090 executing, target_async_permitted is *not* updated. */
5091 static int target_async_permitted_1
= 0;
5094 set_target_async_command (char *args
, int from_tty
,
5095 struct cmd_list_element
*c
)
5097 if (have_live_inferiors ())
5099 target_async_permitted_1
= target_async_permitted
;
5100 error (_("Cannot change this setting while the inferior is running."));
5103 target_async_permitted
= target_async_permitted_1
;
5107 show_target_async_command (struct ui_file
*file
, int from_tty
,
5108 struct cmd_list_element
*c
,
5111 fprintf_filtered (file
,
5112 _("Controlling the inferior in "
5113 "asynchronous mode is %s.\n"), value
);
5116 /* Temporary copies of permission settings. */
5118 static int may_write_registers_1
= 1;
5119 static int may_write_memory_1
= 1;
5120 static int may_insert_breakpoints_1
= 1;
5121 static int may_insert_tracepoints_1
= 1;
5122 static int may_insert_fast_tracepoints_1
= 1;
5123 static int may_stop_1
= 1;
5125 /* Make the user-set values match the real values again. */
5128 update_target_permissions (void)
5130 may_write_registers_1
= may_write_registers
;
5131 may_write_memory_1
= may_write_memory
;
5132 may_insert_breakpoints_1
= may_insert_breakpoints
;
5133 may_insert_tracepoints_1
= may_insert_tracepoints
;
5134 may_insert_fast_tracepoints_1
= may_insert_fast_tracepoints
;
5135 may_stop_1
= may_stop
;
5138 /* The one function handles (most of) the permission flags in the same
5142 set_target_permissions (char *args
, int from_tty
,
5143 struct cmd_list_element
*c
)
5145 if (target_has_execution
)
5147 update_target_permissions ();
5148 error (_("Cannot change this setting while the inferior is running."));
5151 /* Make the real values match the user-changed values. */
5152 may_write_registers
= may_write_registers_1
;
5153 may_insert_breakpoints
= may_insert_breakpoints_1
;
5154 may_insert_tracepoints
= may_insert_tracepoints_1
;
5155 may_insert_fast_tracepoints
= may_insert_fast_tracepoints_1
;
5156 may_stop
= may_stop_1
;
5157 update_observer_mode ();
5160 /* Set memory write permission independently of observer mode. */
5163 set_write_memory_permission (char *args
, int from_tty
,
5164 struct cmd_list_element
*c
)
5166 /* Make the real values match the user-changed values. */
5167 may_write_memory
= may_write_memory_1
;
5168 update_observer_mode ();
5173 initialize_targets (void)
5175 init_dummy_target ();
5176 push_target (&dummy_target
);
5178 add_info ("target", target_info
, targ_desc
);
5179 add_info ("files", target_info
, targ_desc
);
5181 add_setshow_zuinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
5182 Set target debugging."), _("\
5183 Show target debugging."), _("\
5184 When non-zero, target debugging is enabled. Higher numbers are more\n\
5185 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
5189 &setdebuglist
, &showdebuglist
);
5191 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
5192 &trust_readonly
, _("\
5193 Set mode for reading from readonly sections."), _("\
5194 Show mode for reading from readonly sections."), _("\
5195 When this mode is on, memory reads from readonly sections (such as .text)\n\
5196 will be read from the object file instead of from the target. This will\n\
5197 result in significant performance improvement for remote targets."),
5199 show_trust_readonly
,
5200 &setlist
, &showlist
);
5202 add_com ("monitor", class_obscure
, do_monitor_command
,
5203 _("Send a command to the remote monitor (remote targets only)."));
5205 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
5206 _("Print the name of each layer of the internal target stack."),
5207 &maintenanceprintlist
);
5209 add_setshow_boolean_cmd ("target-async", no_class
,
5210 &target_async_permitted_1
, _("\
5211 Set whether gdb controls the inferior in asynchronous mode."), _("\
5212 Show whether gdb controls the inferior in asynchronous mode."), _("\
5213 Tells gdb whether to control the inferior in asynchronous mode."),
5214 set_target_async_command
,
5215 show_target_async_command
,
5219 add_setshow_boolean_cmd ("may-write-registers", class_support
,
5220 &may_write_registers_1
, _("\
5221 Set permission to write into registers."), _("\
5222 Show permission to write into registers."), _("\
5223 When this permission is on, GDB may write into the target's registers.\n\
5224 Otherwise, any sort of write attempt will result in an error."),
5225 set_target_permissions
, NULL
,
5226 &setlist
, &showlist
);
5228 add_setshow_boolean_cmd ("may-write-memory", class_support
,
5229 &may_write_memory_1
, _("\
5230 Set permission to write into target memory."), _("\
5231 Show permission to write into target memory."), _("\
5232 When this permission is on, GDB may write into the target's memory.\n\
5233 Otherwise, any sort of write attempt will result in an error."),
5234 set_write_memory_permission
, NULL
,
5235 &setlist
, &showlist
);
5237 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support
,
5238 &may_insert_breakpoints_1
, _("\
5239 Set permission to insert breakpoints in the target."), _("\
5240 Show permission to insert breakpoints in the target."), _("\
5241 When this permission is on, GDB may insert breakpoints in the program.\n\
5242 Otherwise, any sort of insertion attempt will result in an error."),
5243 set_target_permissions
, NULL
,
5244 &setlist
, &showlist
);
5246 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support
,
5247 &may_insert_tracepoints_1
, _("\
5248 Set permission to insert tracepoints in the target."), _("\
5249 Show permission to insert tracepoints in the target."), _("\
5250 When this permission is on, GDB may insert tracepoints in the program.\n\
5251 Otherwise, any sort of insertion attempt will result in an error."),
5252 set_target_permissions
, NULL
,
5253 &setlist
, &showlist
);
5255 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support
,
5256 &may_insert_fast_tracepoints_1
, _("\
5257 Set permission to insert fast tracepoints in the target."), _("\
5258 Show permission to insert fast tracepoints in the target."), _("\
5259 When this permission is on, GDB may insert fast tracepoints.\n\
5260 Otherwise, any sort of insertion attempt will result in an error."),
5261 set_target_permissions
, NULL
,
5262 &setlist
, &showlist
);
5264 add_setshow_boolean_cmd ("may-interrupt", class_support
,
5266 Set permission to interrupt or signal the target."), _("\
5267 Show permission to interrupt or signal the target."), _("\
5268 When this permission is on, GDB may interrupt/stop the target's execution.\n\
5269 Otherwise, any attempt to interrupt or stop will be ignored."),
5270 set_target_permissions
, NULL
,
5271 &setlist
, &showlist
);