1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
38 #include "gdb_assert.h"
40 #include "exceptions.h"
41 #include "target-descriptions.h"
42 #include "gdbthread.h"
45 static void target_info (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_watchpoint_addr_within_range (struct target_ops
*,
52 CORE_ADDR
, CORE_ADDR
, int);
54 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
56 static int nosymbol (char *, CORE_ADDR
*);
58 static void tcomplain (void) ATTR_NORETURN
;
60 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
62 static int return_zero (void);
64 static int return_one (void);
66 static int return_minus_one (void);
68 void target_ignore (void);
70 static void target_command (char *, int);
72 static struct target_ops
*find_default_run_target (char *);
74 static void nosupport_runtime (void);
76 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
77 enum target_object object
,
78 const char *annex
, gdb_byte
*readbuf
,
79 const gdb_byte
*writebuf
,
80 ULONGEST offset
, LONGEST len
);
82 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
83 enum target_object object
,
84 const char *annex
, gdb_byte
*readbuf
,
85 const gdb_byte
*writebuf
,
86 ULONGEST offset
, LONGEST len
);
88 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
89 enum target_object object
,
91 void *readbuf
, const void *writebuf
,
92 ULONGEST offset
, LONGEST len
);
94 static void init_dummy_target (void);
96 static struct target_ops debug_target
;
98 static void debug_to_open (char *, int);
100 static void debug_to_close (int);
102 static void debug_to_attach (struct target_ops
*ops
, char *, int);
104 static void debug_to_detach (struct target_ops
*ops
, char *, int);
106 static void debug_to_resume (ptid_t
, int, enum target_signal
);
108 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
110 static void debug_to_fetch_registers (struct regcache
*, int);
112 static void debug_to_store_registers (struct regcache
*, int);
114 static void debug_to_prepare_to_store (struct regcache
*);
116 static void debug_to_files_info (struct target_ops
*);
118 static int debug_to_insert_breakpoint (struct bp_target_info
*);
120 static int debug_to_remove_breakpoint (struct bp_target_info
*);
122 static int debug_to_can_use_hw_breakpoint (int, int, int);
124 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
126 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
128 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
130 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
132 static int debug_to_stopped_by_watchpoint (void);
134 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
136 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
137 CORE_ADDR
, CORE_ADDR
, int);
139 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
141 static void debug_to_terminal_init (void);
143 static void debug_to_terminal_inferior (void);
145 static void debug_to_terminal_ours_for_output (void);
147 static void debug_to_terminal_save_ours (void);
149 static void debug_to_terminal_ours (void);
151 static void debug_to_terminal_info (char *, int);
153 static void debug_to_kill (void);
155 static void debug_to_load (char *, int);
157 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
159 static void debug_to_mourn_inferior (struct target_ops
*);
161 static int debug_to_can_run (void);
163 static void debug_to_notice_signals (ptid_t
);
165 static int debug_to_thread_alive (ptid_t
);
167 static void debug_to_stop (ptid_t
);
169 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
170 wierd and mysterious ways. Putting the variable here lets those
171 wierd and mysterious ways keep building while they are being
172 converted to the inferior inheritance structure. */
173 struct target_ops deprecated_child_ops
;
175 /* Pointer to array of target architecture structures; the size of the
176 array; the current index into the array; the allocated size of the
178 struct target_ops
**target_structs
;
179 unsigned target_struct_size
;
180 unsigned target_struct_index
;
181 unsigned target_struct_allocsize
;
182 #define DEFAULT_ALLOCSIZE 10
184 /* The initial current target, so that there is always a semi-valid
187 static struct target_ops dummy_target
;
189 /* Top of target stack. */
191 static struct target_ops
*target_stack
;
193 /* The target structure we are currently using to talk to a process
194 or file or whatever "inferior" we have. */
196 struct target_ops current_target
;
198 /* Command list for target. */
200 static struct cmd_list_element
*targetlist
= NULL
;
202 /* Nonzero if we should trust readonly sections from the
203 executable when reading memory. */
205 static int trust_readonly
= 0;
207 /* Nonzero if we should show true memory content including
208 memory breakpoint inserted by gdb. */
210 static int show_memory_breakpoints
= 0;
212 /* Non-zero if we want to see trace of target level stuff. */
214 static int targetdebug
= 0;
216 show_targetdebug (struct ui_file
*file
, int from_tty
,
217 struct cmd_list_element
*c
, const char *value
)
219 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
222 static void setup_target_debug (void);
224 DCACHE
*target_dcache
;
226 /* The user just typed 'target' without the name of a target. */
229 target_command (char *arg
, int from_tty
)
231 fputs_filtered ("Argument required (target name). Try `help target'\n",
235 /* Add a possible target architecture to the list. */
238 add_target (struct target_ops
*t
)
240 /* Provide default values for all "must have" methods. */
241 if (t
->to_xfer_partial
== NULL
)
242 t
->to_xfer_partial
= default_xfer_partial
;
246 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
247 target_structs
= (struct target_ops
**) xmalloc
248 (target_struct_allocsize
* sizeof (*target_structs
));
250 if (target_struct_size
>= target_struct_allocsize
)
252 target_struct_allocsize
*= 2;
253 target_structs
= (struct target_ops
**)
254 xrealloc ((char *) target_structs
,
255 target_struct_allocsize
* sizeof (*target_structs
));
257 target_structs
[target_struct_size
++] = t
;
259 if (targetlist
== NULL
)
260 add_prefix_cmd ("target", class_run
, target_command
, _("\
261 Connect to a target machine or process.\n\
262 The first argument is the type or protocol of the target machine.\n\
263 Remaining arguments are interpreted by the target protocol. For more\n\
264 information on the arguments for a particular protocol, type\n\
265 `help target ' followed by the protocol name."),
266 &targetlist
, "target ", 0, &cmdlist
);
267 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
278 target_load (char *arg
, int from_tty
)
280 dcache_invalidate (target_dcache
);
281 (*current_target
.to_load
) (arg
, from_tty
);
284 void target_create_inferior (char *exec_file
, char *args
,
285 char **env
, int from_tty
)
287 struct target_ops
*t
;
288 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
290 if (t
->to_create_inferior
!= NULL
)
292 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
297 internal_error (__FILE__
, __LINE__
,
298 "could not find a target to create inferior");
303 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
304 struct target_ops
*t
)
306 errno
= EIO
; /* Can't read/write this location */
307 return 0; /* No bytes handled */
313 error (_("You can't do that when your target is `%s'"),
314 current_target
.to_shortname
);
320 error (_("You can't do that without a process to debug."));
324 nosymbol (char *name
, CORE_ADDR
*addrp
)
326 return 1; /* Symbol does not exist in target env */
330 nosupport_runtime (void)
332 if (ptid_equal (inferior_ptid
, null_ptid
))
335 error (_("No run-time support for this"));
340 default_terminal_info (char *args
, int from_tty
)
342 printf_unfiltered (_("No saved terminal information.\n"));
345 /* This is the default target_create_inferior and target_attach function.
346 If the current target is executing, it asks whether to kill it off.
347 If this function returns without calling error(), it has killed off
348 the target, and the operation should be attempted. */
351 kill_or_be_killed (int from_tty
)
353 if (target_has_execution
)
355 printf_unfiltered (_("You are already running a program:\n"));
356 target_files_info ();
357 if (query ("Kill it? "))
360 if (target_has_execution
)
361 error (_("Killing the program did not help."));
366 error (_("Program not killed."));
372 /* A default implementation for the to_get_ada_task_ptid target method.
374 This function builds the PTID by using both LWP and TID as part of
375 the PTID lwp and tid elements. The pid used is the pid of the
379 default_get_ada_task_ptid (long lwp
, long tid
)
381 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
384 /* Go through the target stack from top to bottom, copying over zero
385 entries in current_target, then filling in still empty entries. In
386 effect, we are doing class inheritance through the pushed target
389 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
390 is currently implemented, is that it discards any knowledge of
391 which target an inherited method originally belonged to.
392 Consequently, new new target methods should instead explicitly and
393 locally search the target stack for the target that can handle the
397 update_current_target (void)
399 struct target_ops
*t
;
401 /* First, reset current's contents. */
402 memset (¤t_target
, 0, sizeof (current_target
));
404 #define INHERIT(FIELD, TARGET) \
405 if (!current_target.FIELD) \
406 current_target.FIELD = (TARGET)->FIELD
408 for (t
= target_stack
; t
; t
= t
->beneath
)
410 INHERIT (to_shortname
, t
);
411 INHERIT (to_longname
, t
);
413 /* Do not inherit to_open. */
414 /* Do not inherit to_close. */
415 /* Do not inherit to_attach. */
416 INHERIT (to_post_attach
, t
);
417 INHERIT (to_attach_no_wait
, t
);
418 /* Do not inherit to_detach. */
419 /* Do not inherit to_disconnect. */
420 INHERIT (to_resume
, t
);
421 INHERIT (to_wait
, t
);
422 INHERIT (to_fetch_registers
, t
);
423 INHERIT (to_store_registers
, t
);
424 INHERIT (to_prepare_to_store
, t
);
425 INHERIT (deprecated_xfer_memory
, t
);
426 INHERIT (to_files_info
, t
);
427 INHERIT (to_insert_breakpoint
, t
);
428 INHERIT (to_remove_breakpoint
, t
);
429 INHERIT (to_can_use_hw_breakpoint
, t
);
430 INHERIT (to_insert_hw_breakpoint
, t
);
431 INHERIT (to_remove_hw_breakpoint
, t
);
432 INHERIT (to_insert_watchpoint
, t
);
433 INHERIT (to_remove_watchpoint
, t
);
434 INHERIT (to_stopped_data_address
, t
);
435 INHERIT (to_have_steppable_watchpoint
, t
);
436 INHERIT (to_have_continuable_watchpoint
, t
);
437 INHERIT (to_stopped_by_watchpoint
, t
);
438 INHERIT (to_watchpoint_addr_within_range
, t
);
439 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
440 INHERIT (to_terminal_init
, t
);
441 INHERIT (to_terminal_inferior
, t
);
442 INHERIT (to_terminal_ours_for_output
, t
);
443 INHERIT (to_terminal_ours
, t
);
444 INHERIT (to_terminal_save_ours
, t
);
445 INHERIT (to_terminal_info
, t
);
446 INHERIT (to_kill
, t
);
447 INHERIT (to_load
, t
);
448 INHERIT (to_lookup_symbol
, t
);
449 /* Do no inherit to_create_inferior. */
450 INHERIT (to_post_startup_inferior
, t
);
451 INHERIT (to_acknowledge_created_inferior
, t
);
452 INHERIT (to_insert_fork_catchpoint
, t
);
453 INHERIT (to_remove_fork_catchpoint
, t
);
454 INHERIT (to_insert_vfork_catchpoint
, t
);
455 INHERIT (to_remove_vfork_catchpoint
, t
);
456 /* Do not inherit to_follow_fork. */
457 INHERIT (to_insert_exec_catchpoint
, t
);
458 INHERIT (to_remove_exec_catchpoint
, t
);
459 INHERIT (to_has_exited
, t
);
460 /* Do no inherit to_mourn_inferiour. */
461 INHERIT (to_can_run
, t
);
462 INHERIT (to_notice_signals
, t
);
463 INHERIT (to_thread_alive
, t
);
464 INHERIT (to_find_new_threads
, t
);
465 INHERIT (to_pid_to_str
, t
);
466 INHERIT (to_extra_thread_info
, t
);
467 INHERIT (to_stop
, t
);
468 /* Do not inherit to_xfer_partial. */
469 INHERIT (to_rcmd
, t
);
470 INHERIT (to_pid_to_exec_file
, t
);
471 INHERIT (to_log_command
, t
);
472 INHERIT (to_stratum
, t
);
473 INHERIT (to_has_all_memory
, t
);
474 INHERIT (to_has_memory
, t
);
475 INHERIT (to_has_stack
, t
);
476 INHERIT (to_has_registers
, t
);
477 INHERIT (to_has_execution
, t
);
478 INHERIT (to_has_thread_control
, t
);
479 INHERIT (to_sections
, t
);
480 INHERIT (to_sections_end
, t
);
481 INHERIT (to_can_async_p
, t
);
482 INHERIT (to_is_async_p
, t
);
483 INHERIT (to_async
, t
);
484 INHERIT (to_async_mask
, t
);
485 INHERIT (to_find_memory_regions
, t
);
486 INHERIT (to_make_corefile_notes
, t
);
487 INHERIT (to_get_thread_local_address
, t
);
488 INHERIT (to_can_execute_reverse
, t
);
489 /* Do not inherit to_read_description. */
490 INHERIT (to_get_ada_task_ptid
, t
);
491 /* Do not inherit to_search_memory. */
492 INHERIT (to_supports_multi_process
, t
);
493 INHERIT (to_magic
, t
);
494 /* Do not inherit to_memory_map. */
495 /* Do not inherit to_flash_erase. */
496 /* Do not inherit to_flash_done. */
500 /* Clean up a target struct so it no longer has any zero pointers in
501 it. Some entries are defaulted to a method that print an error,
502 others are hard-wired to a standard recursive default. */
504 #define de_fault(field, value) \
505 if (!current_target.field) \
506 current_target.field = value
509 (void (*) (char *, int))
514 de_fault (to_post_attach
,
518 (void (*) (ptid_t
, int, enum target_signal
))
521 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
523 de_fault (to_fetch_registers
,
524 (void (*) (struct regcache
*, int))
526 de_fault (to_store_registers
,
527 (void (*) (struct regcache
*, int))
529 de_fault (to_prepare_to_store
,
530 (void (*) (struct regcache
*))
532 de_fault (deprecated_xfer_memory
,
533 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
535 de_fault (to_files_info
,
536 (void (*) (struct target_ops
*))
538 de_fault (to_insert_breakpoint
,
539 memory_insert_breakpoint
);
540 de_fault (to_remove_breakpoint
,
541 memory_remove_breakpoint
);
542 de_fault (to_can_use_hw_breakpoint
,
543 (int (*) (int, int, int))
545 de_fault (to_insert_hw_breakpoint
,
546 (int (*) (struct bp_target_info
*))
548 de_fault (to_remove_hw_breakpoint
,
549 (int (*) (struct bp_target_info
*))
551 de_fault (to_insert_watchpoint
,
552 (int (*) (CORE_ADDR
, int, int))
554 de_fault (to_remove_watchpoint
,
555 (int (*) (CORE_ADDR
, int, int))
557 de_fault (to_stopped_by_watchpoint
,
560 de_fault (to_stopped_data_address
,
561 (int (*) (struct target_ops
*, CORE_ADDR
*))
563 de_fault (to_watchpoint_addr_within_range
,
564 default_watchpoint_addr_within_range
);
565 de_fault (to_region_ok_for_hw_watchpoint
,
566 default_region_ok_for_hw_watchpoint
);
567 de_fault (to_terminal_init
,
570 de_fault (to_terminal_inferior
,
573 de_fault (to_terminal_ours_for_output
,
576 de_fault (to_terminal_ours
,
579 de_fault (to_terminal_save_ours
,
582 de_fault (to_terminal_info
,
583 default_terminal_info
);
588 (void (*) (char *, int))
590 de_fault (to_lookup_symbol
,
591 (int (*) (char *, CORE_ADDR
*))
593 de_fault (to_post_startup_inferior
,
596 de_fault (to_acknowledge_created_inferior
,
599 de_fault (to_insert_fork_catchpoint
,
602 de_fault (to_remove_fork_catchpoint
,
605 de_fault (to_insert_vfork_catchpoint
,
608 de_fault (to_remove_vfork_catchpoint
,
611 de_fault (to_insert_exec_catchpoint
,
614 de_fault (to_remove_exec_catchpoint
,
617 de_fault (to_has_exited
,
618 (int (*) (int, int, int *))
620 de_fault (to_can_run
,
622 de_fault (to_notice_signals
,
625 de_fault (to_thread_alive
,
628 de_fault (to_find_new_threads
,
631 de_fault (to_extra_thread_info
,
632 (char *(*) (struct thread_info
*))
637 current_target
.to_xfer_partial
= current_xfer_partial
;
639 (void (*) (char *, struct ui_file
*))
641 de_fault (to_pid_to_exec_file
,
645 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
647 de_fault (to_async_mask
,
650 current_target
.to_read_description
= NULL
;
651 de_fault (to_get_ada_task_ptid
,
652 (ptid_t (*) (long, long))
653 default_get_ada_task_ptid
);
654 de_fault (to_supports_multi_process
,
659 /* Finally, position the target-stack beneath the squashed
660 "current_target". That way code looking for a non-inherited
661 target method can quickly and simply find it. */
662 current_target
.beneath
= target_stack
;
665 setup_target_debug ();
668 /* Mark OPS as a running target. This reverses the effect
669 of target_mark_exited. */
672 target_mark_running (struct target_ops
*ops
)
674 struct target_ops
*t
;
676 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
680 internal_error (__FILE__
, __LINE__
,
681 "Attempted to mark unpushed target \"%s\" as running",
684 ops
->to_has_execution
= 1;
685 ops
->to_has_all_memory
= 1;
686 ops
->to_has_memory
= 1;
687 ops
->to_has_stack
= 1;
688 ops
->to_has_registers
= 1;
690 update_current_target ();
693 /* Mark OPS as a non-running target. This reverses the effect
694 of target_mark_running. */
697 target_mark_exited (struct target_ops
*ops
)
699 struct target_ops
*t
;
701 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
705 internal_error (__FILE__
, __LINE__
,
706 "Attempted to mark unpushed target \"%s\" as running",
709 ops
->to_has_execution
= 0;
710 ops
->to_has_all_memory
= 0;
711 ops
->to_has_memory
= 0;
712 ops
->to_has_stack
= 0;
713 ops
->to_has_registers
= 0;
715 update_current_target ();
718 /* Push a new target type into the stack of the existing target accessors,
719 possibly superseding some of the existing accessors.
721 Result is zero if the pushed target ended up on top of the stack,
722 nonzero if at least one target is on top of it.
724 Rather than allow an empty stack, we always have the dummy target at
725 the bottom stratum, so we can call the function vectors without
729 push_target (struct target_ops
*t
)
731 struct target_ops
**cur
;
733 /* Check magic number. If wrong, it probably means someone changed
734 the struct definition, but not all the places that initialize one. */
735 if (t
->to_magic
!= OPS_MAGIC
)
737 fprintf_unfiltered (gdb_stderr
,
738 "Magic number of %s target struct wrong\n",
740 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
743 /* Find the proper stratum to install this target in. */
744 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
746 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
750 /* If there's already targets at this stratum, remove them. */
751 /* FIXME: cagney/2003-10-15: I think this should be popping all
752 targets to CUR, and not just those at this stratum level. */
753 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
755 /* There's already something at this stratum level. Close it,
756 and un-hook it from the stack. */
757 struct target_ops
*tmp
= (*cur
);
758 (*cur
) = (*cur
)->beneath
;
760 target_close (tmp
, 0);
763 /* We have removed all targets in our stratum, now add the new one. */
767 update_current_target ();
770 return (t
!= target_stack
);
773 /* Remove a target_ops vector from the stack, wherever it may be.
774 Return how many times it was removed (0 or 1). */
777 unpush_target (struct target_ops
*t
)
779 struct target_ops
**cur
;
780 struct target_ops
*tmp
;
782 if (t
->to_stratum
== dummy_stratum
)
783 internal_error (__FILE__
, __LINE__
,
784 "Attempt to unpush the dummy target");
786 /* Look for the specified target. Note that we assume that a target
787 can only occur once in the target stack. */
789 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
796 return 0; /* Didn't find target_ops, quit now */
798 /* NOTE: cagney/2003-12-06: In '94 the close call was made
799 unconditional by moving it to before the above check that the
800 target was in the target stack (something about "Change the way
801 pushing and popping of targets work to support target overlays
802 and inheritance"). This doesn't make much sense - only open
803 targets should be closed. */
806 /* Unchain the target */
808 (*cur
) = (*cur
)->beneath
;
811 update_current_target ();
819 target_close (target_stack
, 0); /* Let it clean up */
820 if (unpush_target (target_stack
) == 1)
823 fprintf_unfiltered (gdb_stderr
,
824 "pop_target couldn't find target %s\n",
825 current_target
.to_shortname
);
826 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
830 pop_all_targets_above (enum strata above_stratum
, int quitting
)
832 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
834 target_close (target_stack
, quitting
);
835 if (!unpush_target (target_stack
))
837 fprintf_unfiltered (gdb_stderr
,
838 "pop_all_targets couldn't find target %s\n",
839 target_stack
->to_shortname
);
840 internal_error (__FILE__
, __LINE__
,
841 _("failed internal consistency check"));
848 pop_all_targets (int quitting
)
850 pop_all_targets_above (dummy_stratum
, quitting
);
853 /* Using the objfile specified in OBJFILE, find the address for the
854 current thread's thread-local storage with offset OFFSET. */
856 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
858 volatile CORE_ADDR addr
= 0;
860 if (target_get_thread_local_address_p ()
861 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
863 ptid_t ptid
= inferior_ptid
;
864 volatile struct gdb_exception ex
;
866 TRY_CATCH (ex
, RETURN_MASK_ALL
)
870 /* Fetch the load module address for this objfile. */
871 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
873 /* If it's 0, throw the appropriate exception. */
875 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
876 _("TLS load module not found"));
878 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
880 /* If an error occurred, print TLS related messages here. Otherwise,
881 throw the error to some higher catcher. */
884 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
888 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
889 error (_("Cannot find thread-local variables in this thread library."));
891 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
892 if (objfile_is_library
)
893 error (_("Cannot find shared library `%s' in dynamic"
894 " linker's load module list"), objfile
->name
);
896 error (_("Cannot find executable file `%s' in dynamic"
897 " linker's load module list"), objfile
->name
);
899 case TLS_NOT_ALLOCATED_YET_ERROR
:
900 if (objfile_is_library
)
901 error (_("The inferior has not yet allocated storage for"
902 " thread-local variables in\n"
903 "the shared library `%s'\n"
905 objfile
->name
, target_pid_to_str (ptid
));
907 error (_("The inferior has not yet allocated storage for"
908 " thread-local variables in\n"
909 "the executable `%s'\n"
911 objfile
->name
, target_pid_to_str (ptid
));
913 case TLS_GENERIC_ERROR
:
914 if (objfile_is_library
)
915 error (_("Cannot find thread-local storage for %s, "
916 "shared library %s:\n%s"),
917 target_pid_to_str (ptid
),
918 objfile
->name
, ex
.message
);
920 error (_("Cannot find thread-local storage for %s, "
921 "executable file %s:\n%s"),
922 target_pid_to_str (ptid
),
923 objfile
->name
, ex
.message
);
926 throw_exception (ex
);
931 /* It wouldn't be wrong here to try a gdbarch method, too; finding
932 TLS is an ABI-specific thing. But we don't do that yet. */
934 error (_("Cannot find thread-local variables on this target"));
940 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
942 /* target_read_string -- read a null terminated string, up to LEN bytes,
943 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
944 Set *STRING to a pointer to malloc'd memory containing the data; the caller
945 is responsible for freeing it. Return the number of bytes successfully
949 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
951 int tlen
, origlen
, offset
, i
;
955 int buffer_allocated
;
957 unsigned int nbytes_read
= 0;
961 /* Small for testing. */
962 buffer_allocated
= 4;
963 buffer
= xmalloc (buffer_allocated
);
970 tlen
= MIN (len
, 4 - (memaddr
& 3));
971 offset
= memaddr
& 3;
973 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
976 /* The transfer request might have crossed the boundary to an
977 unallocated region of memory. Retry the transfer, requesting
981 errcode
= target_read_memory (memaddr
, buf
, 1);
986 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
989 bytes
= bufptr
- buffer
;
990 buffer_allocated
*= 2;
991 buffer
= xrealloc (buffer
, buffer_allocated
);
992 bufptr
= buffer
+ bytes
;
995 for (i
= 0; i
< tlen
; i
++)
997 *bufptr
++ = buf
[i
+ offset
];
998 if (buf
[i
+ offset
] == '\000')
1000 nbytes_read
+= i
+ 1;
1007 nbytes_read
+= tlen
;
1016 /* Find a section containing ADDR. */
1017 struct section_table
*
1018 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1020 struct section_table
*secp
;
1021 for (secp
= target
->to_sections
;
1022 secp
< target
->to_sections_end
;
1025 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1031 /* Perform a partial memory transfer. The arguments and return
1032 value are just as for target_xfer_partial. */
1035 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1036 ULONGEST memaddr
, LONGEST len
)
1040 struct mem_region
*region
;
1042 /* Zero length requests are ok and require no work. */
1046 /* Try the executable file, if "trust-readonly-sections" is set. */
1047 if (readbuf
!= NULL
&& trust_readonly
)
1049 struct section_table
*secp
;
1051 secp
= target_section_by_addr (ops
, memaddr
);
1053 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1055 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1058 /* Likewise for accesses to unmapped overlay sections. */
1059 if (readbuf
!= NULL
&& overlay_debugging
)
1061 struct obj_section
*section
= find_pc_overlay (memaddr
);
1062 if (pc_in_unmapped_range (memaddr
, section
))
1063 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1066 /* Try GDB's internal data cache. */
1067 region
= lookup_mem_region (memaddr
);
1068 /* region->hi == 0 means there's no upper bound. */
1069 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1072 reg_len
= region
->hi
- memaddr
;
1074 switch (region
->attrib
.mode
)
1077 if (writebuf
!= NULL
)
1082 if (readbuf
!= NULL
)
1087 /* We only support writing to flash during "load" for now. */
1088 if (writebuf
!= NULL
)
1089 error (_("Writing to flash memory forbidden in this context"));
1096 if (region
->attrib
.cache
)
1098 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1099 memory request will start back at current_target. */
1100 if (readbuf
!= NULL
)
1101 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1104 /* FIXME drow/2006-08-09: If we're going to preserve const
1105 correctness dcache_xfer_memory should take readbuf and
1107 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1114 if (readbuf
&& !show_memory_breakpoints
)
1115 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1120 /* If none of those methods found the memory we wanted, fall back
1121 to a target partial transfer. Normally a single call to
1122 to_xfer_partial is enough; if it doesn't recognize an object
1123 it will call the to_xfer_partial of the next target down.
1124 But for memory this won't do. Memory is the only target
1125 object which can be read from more than one valid target.
1126 A core file, for instance, could have some of memory but
1127 delegate other bits to the target below it. So, we must
1128 manually try all targets. */
1132 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1133 readbuf
, writebuf
, memaddr
, reg_len
);
1137 /* We want to continue past core files to executables, but not
1138 past a running target's memory. */
1139 if (ops
->to_has_all_memory
)
1144 while (ops
!= NULL
);
1146 if (readbuf
&& !show_memory_breakpoints
)
1147 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1149 /* If we still haven't got anything, return the last error. We
1155 restore_show_memory_breakpoints (void *arg
)
1157 show_memory_breakpoints
= (uintptr_t) arg
;
1161 make_show_memory_breakpoints_cleanup (int show
)
1163 int current
= show_memory_breakpoints
;
1164 show_memory_breakpoints
= show
;
1166 return make_cleanup (restore_show_memory_breakpoints
,
1167 (void *) (uintptr_t) current
);
1171 target_xfer_partial (struct target_ops
*ops
,
1172 enum target_object object
, const char *annex
,
1173 void *readbuf
, const void *writebuf
,
1174 ULONGEST offset
, LONGEST len
)
1178 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1180 /* If this is a memory transfer, let the memory-specific code
1181 have a look at it instead. Memory transfers are more
1183 if (object
== TARGET_OBJECT_MEMORY
)
1184 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1187 enum target_object raw_object
= object
;
1189 /* If this is a raw memory transfer, request the normal
1190 memory object from other layers. */
1191 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1192 raw_object
= TARGET_OBJECT_MEMORY
;
1194 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1195 writebuf
, offset
, len
);
1200 const unsigned char *myaddr
= NULL
;
1202 fprintf_unfiltered (gdb_stdlog
,
1203 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
1206 (annex
? annex
: "(null)"),
1207 (long) readbuf
, (long) writebuf
,
1208 core_addr_to_string_nz (offset
),
1209 plongest (len
), plongest (retval
));
1215 if (retval
> 0 && myaddr
!= NULL
)
1219 fputs_unfiltered (", bytes =", gdb_stdlog
);
1220 for (i
= 0; i
< retval
; i
++)
1222 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1224 if (targetdebug
< 2 && i
> 0)
1226 fprintf_unfiltered (gdb_stdlog
, " ...");
1229 fprintf_unfiltered (gdb_stdlog
, "\n");
1232 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1236 fputc_unfiltered ('\n', gdb_stdlog
);
1241 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1242 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1243 if any error occurs.
1245 If an error occurs, no guarantee is made about the contents of the data at
1246 MYADDR. In particular, the caller should not depend upon partial reads
1247 filling the buffer with good data. There is no way for the caller to know
1248 how much good data might have been transfered anyway. Callers that can
1249 deal with partial reads should call target_read (which will retry until
1250 it makes no progress, and then return how much was transferred). */
1253 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1255 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1256 myaddr
, memaddr
, len
) == len
)
1263 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1265 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1266 myaddr
, memaddr
, len
) == len
)
1272 /* Fetch the target's memory map. */
1275 target_memory_map (void)
1277 VEC(mem_region_s
) *result
;
1278 struct mem_region
*last_one
, *this_one
;
1280 struct target_ops
*t
;
1283 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1285 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1286 if (t
->to_memory_map
!= NULL
)
1292 result
= t
->to_memory_map (t
);
1296 qsort (VEC_address (mem_region_s
, result
),
1297 VEC_length (mem_region_s
, result
),
1298 sizeof (struct mem_region
), mem_region_cmp
);
1300 /* Check that regions do not overlap. Simultaneously assign
1301 a numbering for the "mem" commands to use to refer to
1304 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1306 this_one
->number
= ix
;
1308 if (last_one
&& last_one
->hi
> this_one
->lo
)
1310 warning (_("Overlapping regions in memory map: ignoring"));
1311 VEC_free (mem_region_s
, result
);
1314 last_one
= this_one
;
1321 target_flash_erase (ULONGEST address
, LONGEST length
)
1323 struct target_ops
*t
;
1325 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1326 if (t
->to_flash_erase
!= NULL
)
1329 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1330 paddr (address
), phex (length
, 0));
1331 t
->to_flash_erase (t
, address
, length
);
1339 target_flash_done (void)
1341 struct target_ops
*t
;
1343 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1344 if (t
->to_flash_done
!= NULL
)
1347 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1348 t
->to_flash_done (t
);
1355 #ifndef target_stopped_data_address_p
1357 target_stopped_data_address_p (struct target_ops
*target
)
1359 if (target
->to_stopped_data_address
1360 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1362 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1363 && (debug_target
.to_stopped_data_address
1364 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1371 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1372 struct cmd_list_element
*c
, const char *value
)
1374 fprintf_filtered (file
, _("\
1375 Mode for reading from readonly sections is %s.\n"),
1379 /* More generic transfers. */
1382 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1383 const char *annex
, gdb_byte
*readbuf
,
1384 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1386 if (object
== TARGET_OBJECT_MEMORY
1387 && ops
->deprecated_xfer_memory
!= NULL
)
1388 /* If available, fall back to the target's
1389 "deprecated_xfer_memory" method. */
1393 if (writebuf
!= NULL
)
1395 void *buffer
= xmalloc (len
);
1396 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1397 memcpy (buffer
, writebuf
, len
);
1398 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1399 1/*write*/, NULL
, ops
);
1400 do_cleanups (cleanup
);
1402 if (readbuf
!= NULL
)
1403 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1404 0/*read*/, NULL
, ops
);
1407 else if (xfered
== 0 && errno
== 0)
1408 /* "deprecated_xfer_memory" uses 0, cross checked against
1409 ERRNO as one indication of an error. */
1414 else if (ops
->beneath
!= NULL
)
1415 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1416 readbuf
, writebuf
, offset
, len
);
1421 /* The xfer_partial handler for the topmost target. Unlike the default,
1422 it does not need to handle memory specially; it just passes all
1423 requests down the stack. */
1426 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1427 const char *annex
, gdb_byte
*readbuf
,
1428 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1430 if (ops
->beneath
!= NULL
)
1431 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1432 readbuf
, writebuf
, offset
, len
);
1437 /* Target vector read/write partial wrapper functions.
1439 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1440 (inbuf, outbuf)", instead of separate read/write methods, make life
1444 target_read_partial (struct target_ops
*ops
,
1445 enum target_object object
,
1446 const char *annex
, gdb_byte
*buf
,
1447 ULONGEST offset
, LONGEST len
)
1449 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1453 target_write_partial (struct target_ops
*ops
,
1454 enum target_object object
,
1455 const char *annex
, const gdb_byte
*buf
,
1456 ULONGEST offset
, LONGEST len
)
1458 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1461 /* Wrappers to perform the full transfer. */
1463 target_read (struct target_ops
*ops
,
1464 enum target_object object
,
1465 const char *annex
, gdb_byte
*buf
,
1466 ULONGEST offset
, LONGEST len
)
1469 while (xfered
< len
)
1471 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1472 (gdb_byte
*) buf
+ xfered
,
1473 offset
+ xfered
, len
- xfered
);
1474 /* Call an observer, notifying them of the xfer progress? */
1486 target_read_until_error (struct target_ops
*ops
,
1487 enum target_object object
,
1488 const char *annex
, gdb_byte
*buf
,
1489 ULONGEST offset
, LONGEST len
)
1492 while (xfered
< len
)
1494 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1495 (gdb_byte
*) buf
+ xfered
,
1496 offset
+ xfered
, len
- xfered
);
1497 /* Call an observer, notifying them of the xfer progress? */
1502 /* We've got an error. Try to read in smaller blocks. */
1503 ULONGEST start
= offset
+ xfered
;
1504 ULONGEST remaining
= len
- xfered
;
1507 /* If an attempt was made to read a random memory address,
1508 it's likely that the very first byte is not accessible.
1509 Try reading the first byte, to avoid doing log N tries
1511 xfer
= target_read_partial (ops
, object
, annex
,
1512 (gdb_byte
*) buf
+ xfered
, start
, 1);
1521 xfer
= target_read_partial (ops
, object
, annex
,
1522 (gdb_byte
*) buf
+ xfered
,
1532 /* We have successfully read the first half. So, the
1533 error must be in the second half. Adjust start and
1534 remaining to point at the second half. */
1551 /* An alternative to target_write with progress callbacks. */
1554 target_write_with_progress (struct target_ops
*ops
,
1555 enum target_object object
,
1556 const char *annex
, const gdb_byte
*buf
,
1557 ULONGEST offset
, LONGEST len
,
1558 void (*progress
) (ULONGEST
, void *), void *baton
)
1562 /* Give the progress callback a chance to set up. */
1564 (*progress
) (0, baton
);
1566 while (xfered
< len
)
1568 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1569 (gdb_byte
*) buf
+ xfered
,
1570 offset
+ xfered
, len
- xfered
);
1578 (*progress
) (xfer
, baton
);
1587 target_write (struct target_ops
*ops
,
1588 enum target_object object
,
1589 const char *annex
, const gdb_byte
*buf
,
1590 ULONGEST offset
, LONGEST len
)
1592 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1596 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1597 the size of the transferred data. PADDING additional bytes are
1598 available in *BUF_P. This is a helper function for
1599 target_read_alloc; see the declaration of that function for more
1603 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1604 const char *annex
, gdb_byte
**buf_p
, int padding
)
1606 size_t buf_alloc
, buf_pos
;
1610 /* This function does not have a length parameter; it reads the
1611 entire OBJECT). Also, it doesn't support objects fetched partly
1612 from one target and partly from another (in a different stratum,
1613 e.g. a core file and an executable). Both reasons make it
1614 unsuitable for reading memory. */
1615 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1617 /* Start by reading up to 4K at a time. The target will throttle
1618 this number down if necessary. */
1620 buf
= xmalloc (buf_alloc
);
1624 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1625 buf_pos
, buf_alloc
- buf_pos
- padding
);
1628 /* An error occurred. */
1634 /* Read all there was. */
1644 /* If the buffer is filling up, expand it. */
1645 if (buf_alloc
< buf_pos
* 2)
1648 buf
= xrealloc (buf
, buf_alloc
);
1655 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1656 the size of the transferred data. See the declaration in "target.h"
1657 function for more information about the return value. */
1660 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1661 const char *annex
, gdb_byte
**buf_p
)
1663 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1666 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1667 returned as a string, allocated using xmalloc. If an error occurs
1668 or the transfer is unsupported, NULL is returned. Empty objects
1669 are returned as allocated but empty strings. A warning is issued
1670 if the result contains any embedded NUL bytes. */
1673 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1677 LONGEST transferred
;
1679 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1681 if (transferred
< 0)
1684 if (transferred
== 0)
1685 return xstrdup ("");
1687 buffer
[transferred
] = 0;
1688 if (strlen (buffer
) < transferred
)
1689 warning (_("target object %d, annex %s, "
1690 "contained unexpected null characters"),
1691 (int) object
, annex
? annex
: "(none)");
1693 return (char *) buffer
;
1696 /* Memory transfer methods. */
1699 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1702 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1704 memory_error (EIO
, addr
);
1708 get_target_memory_unsigned (struct target_ops
*ops
,
1709 CORE_ADDR addr
, int len
)
1711 gdb_byte buf
[sizeof (ULONGEST
)];
1713 gdb_assert (len
<= sizeof (buf
));
1714 get_target_memory (ops
, addr
, buf
, len
);
1715 return extract_unsigned_integer (buf
, len
);
1719 target_info (char *args
, int from_tty
)
1721 struct target_ops
*t
;
1722 int has_all_mem
= 0;
1724 if (symfile_objfile
!= NULL
)
1725 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1727 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1729 if (!t
->to_has_memory
)
1732 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1735 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1736 printf_unfiltered ("%s:\n", t
->to_longname
);
1737 (t
->to_files_info
) (t
);
1738 has_all_mem
= t
->to_has_all_memory
;
1742 /* This function is called before any new inferior is created, e.g.
1743 by running a program, attaching, or connecting to a target.
1744 It cleans up any state from previous invocations which might
1745 change between runs. This is a subset of what target_preopen
1746 resets (things which might change between targets). */
1749 target_pre_inferior (int from_tty
)
1751 /* Clear out solib state. Otherwise the solib state of the previous
1752 inferior might have survived and is entirely wrong for the new
1753 target. This has been observed on GNU/Linux using glibc 2.3. How
1765 Cannot access memory at address 0xdeadbeef
1768 /* In some OSs, the shared library list is the same/global/shared
1769 across inferiors. If code is shared between processes, so are
1770 memory regions and features. */
1771 if (!gdbarch_has_global_solist (target_gdbarch
))
1773 no_shared_libraries (NULL
, from_tty
);
1775 invalidate_target_mem_regions ();
1777 target_clear_description ();
1781 /* This is to be called by the open routine before it does
1785 target_preopen (int from_tty
)
1789 if (target_has_execution
)
1792 || query (_("A program is being debugged already. Kill it? ")))
1795 error (_("Program not killed."));
1798 /* Calling target_kill may remove the target from the stack. But if
1799 it doesn't (which seems like a win for UDI), remove it now. */
1800 /* Leave the exec target, though. The user may be switching from a
1801 live process to a core of the same program. */
1802 pop_all_targets_above (file_stratum
, 0);
1804 target_pre_inferior (from_tty
);
1807 /* Detach a target after doing deferred register stores. */
1810 target_detach (char *args
, int from_tty
)
1812 struct target_ops
* t
;
1814 if (gdbarch_has_global_solist (target_gdbarch
))
1815 /* Don't remove global breakpoints here. They're removed on
1816 disconnection from the target. */
1819 /* If we're in breakpoints-always-inserted mode, have to remove
1820 them before detaching. */
1821 remove_breakpoints ();
1823 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1825 if (t
->to_detach
!= NULL
)
1827 t
->to_detach (t
, args
, from_tty
);
1832 internal_error (__FILE__
, __LINE__
, "could not find a target to detach");
1836 target_disconnect (char *args
, int from_tty
)
1838 struct target_ops
*t
;
1840 /* If we're in breakpoints-always-inserted mode or if breakpoints
1841 are global across processes, we have to remove them before
1843 remove_breakpoints ();
1845 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1846 if (t
->to_disconnect
!= NULL
)
1849 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1851 t
->to_disconnect (t
, args
, from_tty
);
1859 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1861 dcache_invalidate (target_dcache
);
1862 (*current_target
.to_resume
) (ptid
, step
, signal
);
1863 set_executing (ptid
, 1);
1864 set_running (ptid
, 1);
1866 /* Look through the list of possible targets for a target that can
1870 target_follow_fork (int follow_child
)
1872 struct target_ops
*t
;
1874 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1876 if (t
->to_follow_fork
!= NULL
)
1878 int retval
= t
->to_follow_fork (t
, follow_child
);
1880 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1881 follow_child
, retval
);
1886 /* Some target returned a fork event, but did not know how to follow it. */
1887 internal_error (__FILE__
, __LINE__
,
1888 "could not find a target to follow fork");
1892 target_mourn_inferior (void)
1894 struct target_ops
*t
;
1895 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1897 if (t
->to_mourn_inferior
!= NULL
)
1899 t
->to_mourn_inferior (t
);
1904 internal_error (__FILE__
, __LINE__
,
1905 "could not find a target to follow mourn inferiour");
1908 /* Look for a target which can describe architectural features, starting
1909 from TARGET. If we find one, return its description. */
1911 const struct target_desc
*
1912 target_read_description (struct target_ops
*target
)
1914 struct target_ops
*t
;
1916 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1917 if (t
->to_read_description
!= NULL
)
1919 const struct target_desc
*tdesc
;
1921 tdesc
= t
->to_read_description (t
);
1929 /* The default implementation of to_search_memory.
1930 This implements a basic search of memory, reading target memory and
1931 performing the search here (as opposed to performing the search in on the
1932 target side with, for example, gdbserver). */
1935 simple_search_memory (struct target_ops
*ops
,
1936 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1937 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1938 CORE_ADDR
*found_addrp
)
1940 /* NOTE: also defined in find.c testcase. */
1941 #define SEARCH_CHUNK_SIZE 16000
1942 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1943 /* Buffer to hold memory contents for searching. */
1944 gdb_byte
*search_buf
;
1945 unsigned search_buf_size
;
1946 struct cleanup
*old_cleanups
;
1948 search_buf_size
= chunk_size
+ pattern_len
- 1;
1950 /* No point in trying to allocate a buffer larger than the search space. */
1951 if (search_space_len
< search_buf_size
)
1952 search_buf_size
= search_space_len
;
1954 search_buf
= malloc (search_buf_size
);
1955 if (search_buf
== NULL
)
1956 error (_("Unable to allocate memory to perform the search."));
1957 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1959 /* Prime the search buffer. */
1961 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1962 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1964 warning (_("Unable to access target memory at %s, halting search."),
1965 hex_string (start_addr
));
1966 do_cleanups (old_cleanups
);
1970 /* Perform the search.
1972 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1973 When we've scanned N bytes we copy the trailing bytes to the start and
1974 read in another N bytes. */
1976 while (search_space_len
>= pattern_len
)
1978 gdb_byte
*found_ptr
;
1979 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1981 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1982 pattern
, pattern_len
);
1984 if (found_ptr
!= NULL
)
1986 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1987 *found_addrp
= found_addr
;
1988 do_cleanups (old_cleanups
);
1992 /* Not found in this chunk, skip to next chunk. */
1994 /* Don't let search_space_len wrap here, it's unsigned. */
1995 if (search_space_len
>= chunk_size
)
1996 search_space_len
-= chunk_size
;
1998 search_space_len
= 0;
2000 if (search_space_len
>= pattern_len
)
2002 unsigned keep_len
= search_buf_size
- chunk_size
;
2003 CORE_ADDR read_addr
= start_addr
+ keep_len
;
2006 /* Copy the trailing part of the previous iteration to the front
2007 of the buffer for the next iteration. */
2008 gdb_assert (keep_len
== pattern_len
- 1);
2009 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2011 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2013 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2014 search_buf
+ keep_len
, read_addr
,
2015 nr_to_read
) != nr_to_read
)
2017 warning (_("Unable to access target memory at %s, halting search."),
2018 hex_string (read_addr
));
2019 do_cleanups (old_cleanups
);
2023 start_addr
+= chunk_size
;
2029 do_cleanups (old_cleanups
);
2033 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2034 sequence of bytes in PATTERN with length PATTERN_LEN.
2036 The result is 1 if found, 0 if not found, and -1 if there was an error
2037 requiring halting of the search (e.g. memory read error).
2038 If the pattern is found the address is recorded in FOUND_ADDRP. */
2041 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2042 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2043 CORE_ADDR
*found_addrp
)
2045 struct target_ops
*t
;
2048 /* We don't use INHERIT to set current_target.to_search_memory,
2049 so we have to scan the target stack and handle targetdebug
2053 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2054 hex_string (start_addr
));
2056 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2057 if (t
->to_search_memory
!= NULL
)
2062 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2063 pattern
, pattern_len
, found_addrp
);
2067 /* If a special version of to_search_memory isn't available, use the
2069 found
= simple_search_memory (¤t_target
,
2070 start_addr
, search_space_len
,
2071 pattern
, pattern_len
, found_addrp
);
2075 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2080 /* Look through the currently pushed targets. If none of them will
2081 be able to restart the currently running process, issue an error
2085 target_require_runnable (void)
2087 struct target_ops
*t
;
2089 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2091 /* If this target knows how to create a new program, then
2092 assume we will still be able to after killing the current
2093 one. Either killing and mourning will not pop T, or else
2094 find_default_run_target will find it again. */
2095 if (t
->to_create_inferior
!= NULL
)
2098 /* Do not worry about thread_stratum targets that can not
2099 create inferiors. Assume they will be pushed again if
2100 necessary, and continue to the process_stratum. */
2101 if (t
->to_stratum
== thread_stratum
)
2105 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2109 /* This function is only called if the target is running. In that
2110 case there should have been a process_stratum target and it
2111 should either know how to create inferiors, or not... */
2112 internal_error (__FILE__
, __LINE__
, "No targets found");
2115 /* Look through the list of possible targets for a target that can
2116 execute a run or attach command without any other data. This is
2117 used to locate the default process stratum.
2119 If DO_MESG is not NULL, the result is always valid (error() is
2120 called for errors); else, return NULL on error. */
2122 static struct target_ops
*
2123 find_default_run_target (char *do_mesg
)
2125 struct target_ops
**t
;
2126 struct target_ops
*runable
= NULL
;
2131 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2134 if ((*t
)->to_can_run
&& target_can_run (*t
))
2144 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2153 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2155 struct target_ops
*t
;
2157 t
= find_default_run_target ("attach");
2158 (t
->to_attach
) (t
, args
, from_tty
);
2163 find_default_create_inferior (struct target_ops
*ops
,
2164 char *exec_file
, char *allargs
, char **env
,
2167 struct target_ops
*t
;
2169 t
= find_default_run_target ("run");
2170 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2175 find_default_can_async_p (void)
2177 struct target_ops
*t
;
2179 /* This may be called before the target is pushed on the stack;
2180 look for the default process stratum. If there's none, gdb isn't
2181 configured with a native debugger, and target remote isn't
2183 t
= find_default_run_target (NULL
);
2184 if (t
&& t
->to_can_async_p
)
2185 return (t
->to_can_async_p
) ();
2190 find_default_is_async_p (void)
2192 struct target_ops
*t
;
2194 /* This may be called before the target is pushed on the stack;
2195 look for the default process stratum. If there's none, gdb isn't
2196 configured with a native debugger, and target remote isn't
2198 t
= find_default_run_target (NULL
);
2199 if (t
&& t
->to_is_async_p
)
2200 return (t
->to_is_async_p
) ();
2205 find_default_supports_non_stop (void)
2207 struct target_ops
*t
;
2209 t
= find_default_run_target (NULL
);
2210 if (t
&& t
->to_supports_non_stop
)
2211 return (t
->to_supports_non_stop
) ();
2216 target_supports_non_stop ()
2218 struct target_ops
*t
;
2219 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2220 if (t
->to_supports_non_stop
)
2221 return t
->to_supports_non_stop ();
2228 target_get_osdata (const char *type
)
2231 struct target_ops
*t
;
2233 if (target_can_run (¤t_target
))
2234 t
= ¤t_target
;
2236 t
= find_default_run_target ("get OS data");
2241 document
= target_read_stralloc (t
,
2242 TARGET_OBJECT_OSDATA
,
2248 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2250 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2254 default_watchpoint_addr_within_range (struct target_ops
*target
,
2256 CORE_ADDR start
, int length
)
2258 return addr
>= start
&& addr
< start
+ length
;
2274 return_minus_one (void)
2280 * Resize the to_sections pointer. Also make sure that anyone that
2281 * was holding on to an old value of it gets updated.
2282 * Returns the old size.
2286 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2288 struct target_ops
**t
;
2289 struct section_table
*old_value
;
2292 old_value
= target
->to_sections
;
2294 if (target
->to_sections
)
2296 old_count
= target
->to_sections_end
- target
->to_sections
;
2297 target
->to_sections
= (struct section_table
*)
2298 xrealloc ((char *) target
->to_sections
,
2299 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2304 target
->to_sections
= (struct section_table
*)
2305 xmalloc ((sizeof (struct section_table
)) * num_added
);
2307 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2309 /* Check to see if anyone else was pointing to this structure.
2310 If old_value was null, then no one was. */
2314 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2317 if ((*t
)->to_sections
== old_value
)
2319 (*t
)->to_sections
= target
->to_sections
;
2320 (*t
)->to_sections_end
= target
->to_sections_end
;
2323 /* There is a flattened view of the target stack in current_target,
2324 so its to_sections pointer might also need updating. */
2325 if (current_target
.to_sections
== old_value
)
2327 current_target
.to_sections
= target
->to_sections
;
2328 current_target
.to_sections_end
= target
->to_sections_end
;
2336 /* Remove all target sections taken from ABFD.
2338 Scan the current target stack for targets whose section tables
2339 refer to sections from BFD, and remove those sections. We use this
2340 when we notice that the inferior has unloaded a shared object, for
2343 remove_target_sections (bfd
*abfd
)
2345 struct target_ops
**t
;
2347 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2349 struct section_table
*src
, *dest
;
2351 dest
= (*t
)->to_sections
;
2352 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2353 if (src
->bfd
!= abfd
)
2355 /* Keep this section. */
2356 if (dest
< src
) *dest
= *src
;
2360 /* If we've dropped any sections, resize the section table. */
2362 target_resize_to_sections (*t
, dest
- src
);
2369 /* Find a single runnable target in the stack and return it. If for
2370 some reason there is more than one, return NULL. */
2373 find_run_target (void)
2375 struct target_ops
**t
;
2376 struct target_ops
*runable
= NULL
;
2381 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2383 if ((*t
)->to_can_run
&& target_can_run (*t
))
2390 return (count
== 1 ? runable
: NULL
);
2393 /* Find a single core_stratum target in the list of targets and return it.
2394 If for some reason there is more than one, return NULL. */
2397 find_core_target (void)
2399 struct target_ops
**t
;
2400 struct target_ops
*runable
= NULL
;
2405 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2408 if ((*t
)->to_stratum
== core_stratum
)
2415 return (count
== 1 ? runable
: NULL
);
2419 * Find the next target down the stack from the specified target.
2423 find_target_beneath (struct target_ops
*t
)
2429 /* The inferior process has died. Long live the inferior! */
2432 generic_mourn_inferior (void)
2436 ptid
= inferior_ptid
;
2437 inferior_ptid
= null_ptid
;
2439 if (!ptid_equal (ptid
, null_ptid
))
2441 int pid
= ptid_get_pid (ptid
);
2442 delete_inferior (pid
);
2445 breakpoint_init_inferior (inf_exited
);
2446 registers_changed ();
2448 reopen_exec_file ();
2449 reinit_frame_cache ();
2451 if (deprecated_detach_hook
)
2452 deprecated_detach_hook ();
2455 /* Helper function for child_wait and the derivatives of child_wait.
2456 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2457 translation of that in OURSTATUS. */
2459 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2461 if (WIFEXITED (hoststatus
))
2463 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2464 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2466 else if (!WIFSTOPPED (hoststatus
))
2468 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2469 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2473 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2474 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2478 /* Returns zero to leave the inferior alone, one to interrupt it. */
2479 int (*target_activity_function
) (void);
2480 int target_activity_fd
;
2482 /* Convert a normal process ID to a string. Returns the string in a
2486 normal_pid_to_str (ptid_t ptid
)
2488 static char buf
[32];
2490 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2494 /* Error-catcher for target_find_memory_regions */
2495 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2497 error (_("No target."));
2501 /* Error-catcher for target_make_corefile_notes */
2502 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2504 error (_("No target."));
2508 /* Set up the handful of non-empty slots needed by the dummy target
2512 init_dummy_target (void)
2514 dummy_target
.to_shortname
= "None";
2515 dummy_target
.to_longname
= "None";
2516 dummy_target
.to_doc
= "";
2517 dummy_target
.to_attach
= find_default_attach
;
2518 dummy_target
.to_detach
=
2519 (void (*)(struct target_ops
*, char *, int))target_ignore
;
2520 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2521 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2522 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2523 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2524 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2525 dummy_target
.to_stratum
= dummy_stratum
;
2526 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2527 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2528 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2529 dummy_target
.to_magic
= OPS_MAGIC
;
2533 debug_to_open (char *args
, int from_tty
)
2535 debug_target
.to_open (args
, from_tty
);
2537 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2541 debug_to_close (int quitting
)
2543 target_close (&debug_target
, quitting
);
2544 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2548 target_close (struct target_ops
*targ
, int quitting
)
2550 if (targ
->to_xclose
!= NULL
)
2551 targ
->to_xclose (targ
, quitting
);
2552 else if (targ
->to_close
!= NULL
)
2553 targ
->to_close (quitting
);
2557 target_attach (char *args
, int from_tty
)
2559 struct target_ops
*t
;
2560 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2562 if (t
->to_attach
!= NULL
)
2564 t
->to_attach (t
, args
, from_tty
);
2569 internal_error (__FILE__
, __LINE__
,
2570 "could not find a target to attach");
2575 debug_to_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2577 debug_target
.to_attach (&debug_target
, args
, from_tty
);
2579 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2584 debug_to_post_attach (int pid
)
2586 debug_target
.to_post_attach (pid
);
2588 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2592 debug_to_detach (struct target_ops
*ops
, char *args
, int from_tty
)
2594 debug_target
.to_detach (&debug_target
, args
, from_tty
);
2596 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2600 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2602 debug_target
.to_resume (ptid
, step
, siggnal
);
2604 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2605 step
? "step" : "continue",
2606 target_signal_to_name (siggnal
));
2610 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2614 retval
= debug_target
.to_wait (ptid
, status
);
2616 fprintf_unfiltered (gdb_stdlog
,
2617 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2619 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2620 switch (status
->kind
)
2622 case TARGET_WAITKIND_EXITED
:
2623 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2624 status
->value
.integer
);
2626 case TARGET_WAITKIND_STOPPED
:
2627 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2628 target_signal_to_name (status
->value
.sig
));
2630 case TARGET_WAITKIND_SIGNALLED
:
2631 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2632 target_signal_to_name (status
->value
.sig
));
2634 case TARGET_WAITKIND_LOADED
:
2635 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2637 case TARGET_WAITKIND_FORKED
:
2638 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2640 case TARGET_WAITKIND_VFORKED
:
2641 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2643 case TARGET_WAITKIND_EXECD
:
2644 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2646 case TARGET_WAITKIND_SPURIOUS
:
2647 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2650 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2658 debug_print_register (const char * func
,
2659 struct regcache
*regcache
, int regno
)
2661 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2662 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2663 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2664 && gdbarch_register_name (gdbarch
, regno
) != NULL
2665 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2666 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2667 gdbarch_register_name (gdbarch
, regno
));
2669 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2670 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2672 int i
, size
= register_size (gdbarch
, regno
);
2673 unsigned char buf
[MAX_REGISTER_SIZE
];
2674 regcache_raw_collect (regcache
, regno
, buf
);
2675 fprintf_unfiltered (gdb_stdlog
, " = ");
2676 for (i
= 0; i
< size
; i
++)
2678 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2680 if (size
<= sizeof (LONGEST
))
2682 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2683 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2684 core_addr_to_string_nz (val
), plongest (val
));
2687 fprintf_unfiltered (gdb_stdlog
, "\n");
2691 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2693 debug_target
.to_fetch_registers (regcache
, regno
);
2694 debug_print_register ("target_fetch_registers", regcache
, regno
);
2698 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2700 debug_target
.to_store_registers (regcache
, regno
);
2701 debug_print_register ("target_store_registers", regcache
, regno
);
2702 fprintf_unfiltered (gdb_stdlog
, "\n");
2706 debug_to_prepare_to_store (struct regcache
*regcache
)
2708 debug_target
.to_prepare_to_store (regcache
);
2710 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2714 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2715 int write
, struct mem_attrib
*attrib
,
2716 struct target_ops
*target
)
2720 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2723 fprintf_unfiltered (gdb_stdlog
,
2724 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2725 (unsigned int) memaddr
, /* possable truncate long long */
2726 len
, write
? "write" : "read", retval
);
2732 fputs_unfiltered (", bytes =", gdb_stdlog
);
2733 for (i
= 0; i
< retval
; i
++)
2735 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2737 if (targetdebug
< 2 && i
> 0)
2739 fprintf_unfiltered (gdb_stdlog
, " ...");
2742 fprintf_unfiltered (gdb_stdlog
, "\n");
2745 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2749 fputc_unfiltered ('\n', gdb_stdlog
);
2755 debug_to_files_info (struct target_ops
*target
)
2757 debug_target
.to_files_info (target
);
2759 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2763 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2767 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2769 fprintf_unfiltered (gdb_stdlog
,
2770 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2771 (unsigned long) bp_tgt
->placed_address
,
2772 (unsigned long) retval
);
2777 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2781 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2783 fprintf_unfiltered (gdb_stdlog
,
2784 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2785 (unsigned long) bp_tgt
->placed_address
,
2786 (unsigned long) retval
);
2791 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2795 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2797 fprintf_unfiltered (gdb_stdlog
,
2798 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2799 (unsigned long) type
,
2800 (unsigned long) cnt
,
2801 (unsigned long) from_tty
,
2802 (unsigned long) retval
);
2807 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2811 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2813 fprintf_unfiltered (gdb_stdlog
,
2814 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2815 (unsigned long) addr
,
2816 (unsigned long) len
,
2817 (unsigned long) retval
);
2822 debug_to_stopped_by_watchpoint (void)
2826 retval
= debug_target
.to_stopped_by_watchpoint ();
2828 fprintf_unfiltered (gdb_stdlog
,
2829 "STOPPED_BY_WATCHPOINT () = %ld\n",
2830 (unsigned long) retval
);
2835 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2839 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2841 fprintf_unfiltered (gdb_stdlog
,
2842 "target_stopped_data_address ([0x%lx]) = %ld\n",
2843 (unsigned long)*addr
,
2844 (unsigned long)retval
);
2849 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2851 CORE_ADDR start
, int length
)
2855 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2858 fprintf_filtered (gdb_stdlog
,
2859 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2860 (unsigned long) addr
, (unsigned long) start
, length
,
2866 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2870 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2872 fprintf_unfiltered (gdb_stdlog
,
2873 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2874 (unsigned long) bp_tgt
->placed_address
,
2875 (unsigned long) retval
);
2880 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2884 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2886 fprintf_unfiltered (gdb_stdlog
,
2887 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2888 (unsigned long) bp_tgt
->placed_address
,
2889 (unsigned long) retval
);
2894 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2898 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2900 fprintf_unfiltered (gdb_stdlog
,
2901 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2902 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2907 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2911 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2913 fprintf_unfiltered (gdb_stdlog
,
2914 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2915 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2920 debug_to_terminal_init (void)
2922 debug_target
.to_terminal_init ();
2924 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2928 debug_to_terminal_inferior (void)
2930 debug_target
.to_terminal_inferior ();
2932 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2936 debug_to_terminal_ours_for_output (void)
2938 debug_target
.to_terminal_ours_for_output ();
2940 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2944 debug_to_terminal_ours (void)
2946 debug_target
.to_terminal_ours ();
2948 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2952 debug_to_terminal_save_ours (void)
2954 debug_target
.to_terminal_save_ours ();
2956 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2960 debug_to_terminal_info (char *arg
, int from_tty
)
2962 debug_target
.to_terminal_info (arg
, from_tty
);
2964 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2969 debug_to_kill (void)
2971 debug_target
.to_kill ();
2973 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2977 debug_to_load (char *args
, int from_tty
)
2979 debug_target
.to_load (args
, from_tty
);
2981 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2985 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2989 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2991 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2997 debug_to_create_inferior (struct target_ops
*ops
,
2998 char *exec_file
, char *args
, char **env
,
3001 debug_target
.to_create_inferior (ops
, exec_file
, args
, env
, from_tty
);
3003 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
3004 exec_file
, args
, from_tty
);
3008 debug_to_post_startup_inferior (ptid_t ptid
)
3010 debug_target
.to_post_startup_inferior (ptid
);
3012 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
3017 debug_to_acknowledge_created_inferior (int pid
)
3019 debug_target
.to_acknowledge_created_inferior (pid
);
3021 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
3026 debug_to_insert_fork_catchpoint (int pid
)
3028 debug_target
.to_insert_fork_catchpoint (pid
);
3030 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
3035 debug_to_remove_fork_catchpoint (int pid
)
3039 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
3041 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
3048 debug_to_insert_vfork_catchpoint (int pid
)
3050 debug_target
.to_insert_vfork_catchpoint (pid
);
3052 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
3057 debug_to_remove_vfork_catchpoint (int pid
)
3061 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
3063 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
3070 debug_to_insert_exec_catchpoint (int pid
)
3072 debug_target
.to_insert_exec_catchpoint (pid
);
3074 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
3079 debug_to_remove_exec_catchpoint (int pid
)
3083 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
3085 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
3092 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
3096 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
3098 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
3099 pid
, wait_status
, *exit_status
, has_exited
);
3105 debug_to_mourn_inferior (struct target_ops
*ops
)
3107 debug_target
.to_mourn_inferior (&debug_target
);
3109 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3113 debug_to_can_run (void)
3117 retval
= debug_target
.to_can_run ();
3119 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3125 debug_to_notice_signals (ptid_t ptid
)
3127 debug_target
.to_notice_signals (ptid
);
3129 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3134 debug_to_thread_alive (ptid_t ptid
)
3138 retval
= debug_target
.to_thread_alive (ptid
);
3140 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3141 PIDGET (ptid
), retval
);
3147 debug_to_find_new_threads (void)
3149 debug_target
.to_find_new_threads ();
3151 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3155 debug_to_stop (ptid_t ptid
)
3157 debug_target
.to_stop (ptid
);
3159 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3160 target_pid_to_str (ptid
));
3164 debug_to_rcmd (char *command
,
3165 struct ui_file
*outbuf
)
3167 debug_target
.to_rcmd (command
, outbuf
);
3168 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3172 debug_to_pid_to_exec_file (int pid
)
3176 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3178 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3185 setup_target_debug (void)
3187 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3189 current_target
.to_open
= debug_to_open
;
3190 current_target
.to_close
= debug_to_close
;
3191 current_target
.to_attach
= debug_to_attach
;
3192 current_target
.to_post_attach
= debug_to_post_attach
;
3193 current_target
.to_detach
= debug_to_detach
;
3194 current_target
.to_resume
= debug_to_resume
;
3195 current_target
.to_wait
= debug_to_wait
;
3196 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3197 current_target
.to_store_registers
= debug_to_store_registers
;
3198 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3199 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3200 current_target
.to_files_info
= debug_to_files_info
;
3201 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3202 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3203 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3204 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3205 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3206 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3207 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3208 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3209 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3210 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3211 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3212 current_target
.to_terminal_init
= debug_to_terminal_init
;
3213 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3214 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3215 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3216 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3217 current_target
.to_terminal_info
= debug_to_terminal_info
;
3218 current_target
.to_kill
= debug_to_kill
;
3219 current_target
.to_load
= debug_to_load
;
3220 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3221 current_target
.to_create_inferior
= debug_to_create_inferior
;
3222 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3223 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3224 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3225 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3226 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3227 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3228 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3229 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3230 current_target
.to_has_exited
= debug_to_has_exited
;
3231 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3232 current_target
.to_can_run
= debug_to_can_run
;
3233 current_target
.to_notice_signals
= debug_to_notice_signals
;
3234 current_target
.to_thread_alive
= debug_to_thread_alive
;
3235 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3236 current_target
.to_stop
= debug_to_stop
;
3237 current_target
.to_rcmd
= debug_to_rcmd
;
3238 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3242 static char targ_desc
[] =
3243 "Names of targets and files being debugged.\n\
3244 Shows the entire stack of targets currently in use (including the exec-file,\n\
3245 core-file, and process, if any), as well as the symbol file name.";
3248 do_monitor_command (char *cmd
,
3251 if ((current_target
.to_rcmd
3252 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3253 || (current_target
.to_rcmd
== debug_to_rcmd
3254 && (debug_target
.to_rcmd
3255 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3256 error (_("\"monitor\" command not supported by this target."));
3257 target_rcmd (cmd
, gdb_stdtarg
);
3260 /* Print the name of each layers of our target stack. */
3263 maintenance_print_target_stack (char *cmd
, int from_tty
)
3265 struct target_ops
*t
;
3267 printf_filtered (_("The current target stack is:\n"));
3269 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3271 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3275 /* Controls if async mode is permitted. */
3276 int target_async_permitted
= 0;
3278 /* The set command writes to this variable. If the inferior is
3279 executing, linux_nat_async_permitted is *not* updated. */
3280 static int target_async_permitted_1
= 0;
3283 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3284 struct cmd_list_element
*c
)
3286 if (target_has_execution
)
3288 target_async_permitted_1
= target_async_permitted
;
3289 error (_("Cannot change this setting while the inferior is running."));
3292 target_async_permitted
= target_async_permitted_1
;
3296 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3297 struct cmd_list_element
*c
,
3300 fprintf_filtered (file
, _("\
3301 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3305 initialize_targets (void)
3307 init_dummy_target ();
3308 push_target (&dummy_target
);
3310 add_info ("target", target_info
, targ_desc
);
3311 add_info ("files", target_info
, targ_desc
);
3313 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3314 Set target debugging."), _("\
3315 Show target debugging."), _("\
3316 When non-zero, target debugging is enabled. Higher numbers are more\n\
3317 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3321 &setdebuglist
, &showdebuglist
);
3323 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3324 &trust_readonly
, _("\
3325 Set mode for reading from readonly sections."), _("\
3326 Show mode for reading from readonly sections."), _("\
3327 When this mode is on, memory reads from readonly sections (such as .text)\n\
3328 will be read from the object file instead of from the target. This will\n\
3329 result in significant performance improvement for remote targets."),
3331 show_trust_readonly
,
3332 &setlist
, &showlist
);
3334 add_com ("monitor", class_obscure
, do_monitor_command
,
3335 _("Send a command to the remote monitor (remote targets only)."));
3337 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3338 _("Print the name of each layer of the internal target stack."),
3339 &maintenanceprintlist
);
3341 add_setshow_boolean_cmd ("target-async", no_class
,
3342 &target_async_permitted_1
, _("\
3343 Set whether gdb controls the inferior in asynchronous mode."), _("\
3344 Show whether gdb controls the inferior in asynchronous mode."), _("\
3345 Tells gdb whether to control the inferior in asynchronous mode."),
3346 set_maintenance_target_async_permitted
,
3347 show_maintenance_target_async_permitted
,
3351 target_dcache
= dcache_init ();