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, 2009
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, %s, %s, %s, %s) = %s",
1206 (annex
? annex
: "(null)"),
1207 host_address_to_string (readbuf
),
1208 host_address_to_string (writebuf
),
1209 core_addr_to_string_nz (offset
),
1210 plongest (len
), plongest (retval
));
1216 if (retval
> 0 && myaddr
!= NULL
)
1220 fputs_unfiltered (", bytes =", gdb_stdlog
);
1221 for (i
= 0; i
< retval
; i
++)
1223 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1225 if (targetdebug
< 2 && i
> 0)
1227 fprintf_unfiltered (gdb_stdlog
, " ...");
1230 fprintf_unfiltered (gdb_stdlog
, "\n");
1233 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1237 fputc_unfiltered ('\n', gdb_stdlog
);
1242 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1243 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1244 if any error occurs.
1246 If an error occurs, no guarantee is made about the contents of the data at
1247 MYADDR. In particular, the caller should not depend upon partial reads
1248 filling the buffer with good data. There is no way for the caller to know
1249 how much good data might have been transfered anyway. Callers that can
1250 deal with partial reads should call target_read (which will retry until
1251 it makes no progress, and then return how much was transferred). */
1254 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1256 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1257 myaddr
, memaddr
, len
) == len
)
1264 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1266 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1267 myaddr
, memaddr
, len
) == len
)
1273 /* Fetch the target's memory map. */
1276 target_memory_map (void)
1278 VEC(mem_region_s
) *result
;
1279 struct mem_region
*last_one
, *this_one
;
1281 struct target_ops
*t
;
1284 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1286 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1287 if (t
->to_memory_map
!= NULL
)
1293 result
= t
->to_memory_map (t
);
1297 qsort (VEC_address (mem_region_s
, result
),
1298 VEC_length (mem_region_s
, result
),
1299 sizeof (struct mem_region
), mem_region_cmp
);
1301 /* Check that regions do not overlap. Simultaneously assign
1302 a numbering for the "mem" commands to use to refer to
1305 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1307 this_one
->number
= ix
;
1309 if (last_one
&& last_one
->hi
> this_one
->lo
)
1311 warning (_("Overlapping regions in memory map: ignoring"));
1312 VEC_free (mem_region_s
, result
);
1315 last_one
= this_one
;
1322 target_flash_erase (ULONGEST address
, LONGEST length
)
1324 struct target_ops
*t
;
1326 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1327 if (t
->to_flash_erase
!= NULL
)
1330 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1331 paddr (address
), phex (length
, 0));
1332 t
->to_flash_erase (t
, address
, length
);
1340 target_flash_done (void)
1342 struct target_ops
*t
;
1344 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1345 if (t
->to_flash_done
!= NULL
)
1348 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1349 t
->to_flash_done (t
);
1357 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1358 struct cmd_list_element
*c
, const char *value
)
1360 fprintf_filtered (file
, _("\
1361 Mode for reading from readonly sections is %s.\n"),
1365 /* More generic transfers. */
1368 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1369 const char *annex
, gdb_byte
*readbuf
,
1370 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1372 if (object
== TARGET_OBJECT_MEMORY
1373 && ops
->deprecated_xfer_memory
!= NULL
)
1374 /* If available, fall back to the target's
1375 "deprecated_xfer_memory" method. */
1379 if (writebuf
!= NULL
)
1381 void *buffer
= xmalloc (len
);
1382 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1383 memcpy (buffer
, writebuf
, len
);
1384 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1385 1/*write*/, NULL
, ops
);
1386 do_cleanups (cleanup
);
1388 if (readbuf
!= NULL
)
1389 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1390 0/*read*/, NULL
, ops
);
1393 else if (xfered
== 0 && errno
== 0)
1394 /* "deprecated_xfer_memory" uses 0, cross checked against
1395 ERRNO as one indication of an error. */
1400 else if (ops
->beneath
!= NULL
)
1401 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1402 readbuf
, writebuf
, offset
, len
);
1407 /* The xfer_partial handler for the topmost target. Unlike the default,
1408 it does not need to handle memory specially; it just passes all
1409 requests down the stack. */
1412 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1413 const char *annex
, gdb_byte
*readbuf
,
1414 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1416 if (ops
->beneath
!= NULL
)
1417 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1418 readbuf
, writebuf
, offset
, len
);
1423 /* Target vector read/write partial wrapper functions.
1425 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1426 (inbuf, outbuf)", instead of separate read/write methods, make life
1430 target_read_partial (struct target_ops
*ops
,
1431 enum target_object object
,
1432 const char *annex
, gdb_byte
*buf
,
1433 ULONGEST offset
, LONGEST len
)
1435 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1439 target_write_partial (struct target_ops
*ops
,
1440 enum target_object object
,
1441 const char *annex
, const gdb_byte
*buf
,
1442 ULONGEST offset
, LONGEST len
)
1444 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1447 /* Wrappers to perform the full transfer. */
1449 target_read (struct target_ops
*ops
,
1450 enum target_object object
,
1451 const char *annex
, gdb_byte
*buf
,
1452 ULONGEST offset
, LONGEST len
)
1455 while (xfered
< len
)
1457 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1458 (gdb_byte
*) buf
+ xfered
,
1459 offset
+ xfered
, len
- xfered
);
1460 /* Call an observer, notifying them of the xfer progress? */
1472 target_read_until_error (struct target_ops
*ops
,
1473 enum target_object object
,
1474 const char *annex
, gdb_byte
*buf
,
1475 ULONGEST offset
, LONGEST len
)
1478 while (xfered
< len
)
1480 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1481 (gdb_byte
*) buf
+ xfered
,
1482 offset
+ xfered
, len
- xfered
);
1483 /* Call an observer, notifying them of the xfer progress? */
1488 /* We've got an error. Try to read in smaller blocks. */
1489 ULONGEST start
= offset
+ xfered
;
1490 ULONGEST remaining
= len
- xfered
;
1493 /* If an attempt was made to read a random memory address,
1494 it's likely that the very first byte is not accessible.
1495 Try reading the first byte, to avoid doing log N tries
1497 xfer
= target_read_partial (ops
, object
, annex
,
1498 (gdb_byte
*) buf
+ xfered
, start
, 1);
1507 xfer
= target_read_partial (ops
, object
, annex
,
1508 (gdb_byte
*) buf
+ xfered
,
1518 /* We have successfully read the first half. So, the
1519 error must be in the second half. Adjust start and
1520 remaining to point at the second half. */
1537 /* An alternative to target_write with progress callbacks. */
1540 target_write_with_progress (struct target_ops
*ops
,
1541 enum target_object object
,
1542 const char *annex
, const gdb_byte
*buf
,
1543 ULONGEST offset
, LONGEST len
,
1544 void (*progress
) (ULONGEST
, void *), void *baton
)
1548 /* Give the progress callback a chance to set up. */
1550 (*progress
) (0, baton
);
1552 while (xfered
< len
)
1554 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1555 (gdb_byte
*) buf
+ xfered
,
1556 offset
+ xfered
, len
- xfered
);
1564 (*progress
) (xfer
, baton
);
1573 target_write (struct target_ops
*ops
,
1574 enum target_object object
,
1575 const char *annex
, const gdb_byte
*buf
,
1576 ULONGEST offset
, LONGEST len
)
1578 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1582 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1583 the size of the transferred data. PADDING additional bytes are
1584 available in *BUF_P. This is a helper function for
1585 target_read_alloc; see the declaration of that function for more
1589 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1590 const char *annex
, gdb_byte
**buf_p
, int padding
)
1592 size_t buf_alloc
, buf_pos
;
1596 /* This function does not have a length parameter; it reads the
1597 entire OBJECT). Also, it doesn't support objects fetched partly
1598 from one target and partly from another (in a different stratum,
1599 e.g. a core file and an executable). Both reasons make it
1600 unsuitable for reading memory. */
1601 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1603 /* Start by reading up to 4K at a time. The target will throttle
1604 this number down if necessary. */
1606 buf
= xmalloc (buf_alloc
);
1610 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1611 buf_pos
, buf_alloc
- buf_pos
- padding
);
1614 /* An error occurred. */
1620 /* Read all there was. */
1630 /* If the buffer is filling up, expand it. */
1631 if (buf_alloc
< buf_pos
* 2)
1634 buf
= xrealloc (buf
, buf_alloc
);
1641 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1642 the size of the transferred data. See the declaration in "target.h"
1643 function for more information about the return value. */
1646 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1647 const char *annex
, gdb_byte
**buf_p
)
1649 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1652 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1653 returned as a string, allocated using xmalloc. If an error occurs
1654 or the transfer is unsupported, NULL is returned. Empty objects
1655 are returned as allocated but empty strings. A warning is issued
1656 if the result contains any embedded NUL bytes. */
1659 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1663 LONGEST transferred
;
1665 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1667 if (transferred
< 0)
1670 if (transferred
== 0)
1671 return xstrdup ("");
1673 buffer
[transferred
] = 0;
1674 if (strlen (buffer
) < transferred
)
1675 warning (_("target object %d, annex %s, "
1676 "contained unexpected null characters"),
1677 (int) object
, annex
? annex
: "(none)");
1679 return (char *) buffer
;
1682 /* Memory transfer methods. */
1685 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1688 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1690 memory_error (EIO
, addr
);
1694 get_target_memory_unsigned (struct target_ops
*ops
,
1695 CORE_ADDR addr
, int len
)
1697 gdb_byte buf
[sizeof (ULONGEST
)];
1699 gdb_assert (len
<= sizeof (buf
));
1700 get_target_memory (ops
, addr
, buf
, len
);
1701 return extract_unsigned_integer (buf
, len
);
1705 target_info (char *args
, int from_tty
)
1707 struct target_ops
*t
;
1708 int has_all_mem
= 0;
1710 if (symfile_objfile
!= NULL
)
1711 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1713 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1715 if (!t
->to_has_memory
)
1718 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1721 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1722 printf_unfiltered ("%s:\n", t
->to_longname
);
1723 (t
->to_files_info
) (t
);
1724 has_all_mem
= t
->to_has_all_memory
;
1728 /* This function is called before any new inferior is created, e.g.
1729 by running a program, attaching, or connecting to a target.
1730 It cleans up any state from previous invocations which might
1731 change between runs. This is a subset of what target_preopen
1732 resets (things which might change between targets). */
1735 target_pre_inferior (int from_tty
)
1737 /* Clear out solib state. Otherwise the solib state of the previous
1738 inferior might have survived and is entirely wrong for the new
1739 target. This has been observed on GNU/Linux using glibc 2.3. How
1751 Cannot access memory at address 0xdeadbeef
1754 /* In some OSs, the shared library list is the same/global/shared
1755 across inferiors. If code is shared between processes, so are
1756 memory regions and features. */
1757 if (!gdbarch_has_global_solist (target_gdbarch
))
1759 no_shared_libraries (NULL
, from_tty
);
1761 invalidate_target_mem_regions ();
1763 target_clear_description ();
1767 /* This is to be called by the open routine before it does
1771 target_preopen (int from_tty
)
1775 if (target_has_execution
)
1778 || query (_("A program is being debugged already. Kill it? ")))
1781 error (_("Program not killed."));
1784 /* Calling target_kill may remove the target from the stack. But if
1785 it doesn't (which seems like a win for UDI), remove it now. */
1786 /* Leave the exec target, though. The user may be switching from a
1787 live process to a core of the same program. */
1788 pop_all_targets_above (file_stratum
, 0);
1790 target_pre_inferior (from_tty
);
1793 /* Detach a target after doing deferred register stores. */
1796 target_detach (char *args
, int from_tty
)
1798 struct target_ops
* t
;
1800 if (gdbarch_has_global_solist (target_gdbarch
))
1801 /* Don't remove global breakpoints here. They're removed on
1802 disconnection from the target. */
1805 /* If we're in breakpoints-always-inserted mode, have to remove
1806 them before detaching. */
1807 remove_breakpoints ();
1809 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1811 if (t
->to_detach
!= NULL
)
1813 t
->to_detach (t
, args
, from_tty
);
1818 internal_error (__FILE__
, __LINE__
, "could not find a target to detach");
1822 target_disconnect (char *args
, int from_tty
)
1824 struct target_ops
*t
;
1826 /* If we're in breakpoints-always-inserted mode or if breakpoints
1827 are global across processes, we have to remove them before
1829 remove_breakpoints ();
1831 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1832 if (t
->to_disconnect
!= NULL
)
1835 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1837 t
->to_disconnect (t
, args
, from_tty
);
1845 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1847 dcache_invalidate (target_dcache
);
1848 (*current_target
.to_resume
) (ptid
, step
, signal
);
1849 set_executing (ptid
, 1);
1850 set_running (ptid
, 1);
1852 /* Look through the list of possible targets for a target that can
1856 target_follow_fork (int follow_child
)
1858 struct target_ops
*t
;
1860 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1862 if (t
->to_follow_fork
!= NULL
)
1864 int retval
= t
->to_follow_fork (t
, follow_child
);
1866 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1867 follow_child
, retval
);
1872 /* Some target returned a fork event, but did not know how to follow it. */
1873 internal_error (__FILE__
, __LINE__
,
1874 "could not find a target to follow fork");
1878 target_mourn_inferior (void)
1880 struct target_ops
*t
;
1881 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1883 if (t
->to_mourn_inferior
!= NULL
)
1885 t
->to_mourn_inferior (t
);
1890 internal_error (__FILE__
, __LINE__
,
1891 "could not find a target to follow mourn inferiour");
1894 /* Look for a target which can describe architectural features, starting
1895 from TARGET. If we find one, return its description. */
1897 const struct target_desc
*
1898 target_read_description (struct target_ops
*target
)
1900 struct target_ops
*t
;
1902 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1903 if (t
->to_read_description
!= NULL
)
1905 const struct target_desc
*tdesc
;
1907 tdesc
= t
->to_read_description (t
);
1915 /* The default implementation of to_search_memory.
1916 This implements a basic search of memory, reading target memory and
1917 performing the search here (as opposed to performing the search in on the
1918 target side with, for example, gdbserver). */
1921 simple_search_memory (struct target_ops
*ops
,
1922 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1923 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1924 CORE_ADDR
*found_addrp
)
1926 /* NOTE: also defined in find.c testcase. */
1927 #define SEARCH_CHUNK_SIZE 16000
1928 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1929 /* Buffer to hold memory contents for searching. */
1930 gdb_byte
*search_buf
;
1931 unsigned search_buf_size
;
1932 struct cleanup
*old_cleanups
;
1934 search_buf_size
= chunk_size
+ pattern_len
- 1;
1936 /* No point in trying to allocate a buffer larger than the search space. */
1937 if (search_space_len
< search_buf_size
)
1938 search_buf_size
= search_space_len
;
1940 search_buf
= malloc (search_buf_size
);
1941 if (search_buf
== NULL
)
1942 error (_("Unable to allocate memory to perform the search."));
1943 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1945 /* Prime the search buffer. */
1947 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1948 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1950 warning (_("Unable to access target memory at %s, halting search."),
1951 hex_string (start_addr
));
1952 do_cleanups (old_cleanups
);
1956 /* Perform the search.
1958 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1959 When we've scanned N bytes we copy the trailing bytes to the start and
1960 read in another N bytes. */
1962 while (search_space_len
>= pattern_len
)
1964 gdb_byte
*found_ptr
;
1965 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1967 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1968 pattern
, pattern_len
);
1970 if (found_ptr
!= NULL
)
1972 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1973 *found_addrp
= found_addr
;
1974 do_cleanups (old_cleanups
);
1978 /* Not found in this chunk, skip to next chunk. */
1980 /* Don't let search_space_len wrap here, it's unsigned. */
1981 if (search_space_len
>= chunk_size
)
1982 search_space_len
-= chunk_size
;
1984 search_space_len
= 0;
1986 if (search_space_len
>= pattern_len
)
1988 unsigned keep_len
= search_buf_size
- chunk_size
;
1989 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1992 /* Copy the trailing part of the previous iteration to the front
1993 of the buffer for the next iteration. */
1994 gdb_assert (keep_len
== pattern_len
- 1);
1995 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1997 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1999 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2000 search_buf
+ keep_len
, read_addr
,
2001 nr_to_read
) != nr_to_read
)
2003 warning (_("Unable to access target memory at %s, halting search."),
2004 hex_string (read_addr
));
2005 do_cleanups (old_cleanups
);
2009 start_addr
+= chunk_size
;
2015 do_cleanups (old_cleanups
);
2019 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2020 sequence of bytes in PATTERN with length PATTERN_LEN.
2022 The result is 1 if found, 0 if not found, and -1 if there was an error
2023 requiring halting of the search (e.g. memory read error).
2024 If the pattern is found the address is recorded in FOUND_ADDRP. */
2027 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2028 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2029 CORE_ADDR
*found_addrp
)
2031 struct target_ops
*t
;
2034 /* We don't use INHERIT to set current_target.to_search_memory,
2035 so we have to scan the target stack and handle targetdebug
2039 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2040 hex_string (start_addr
));
2042 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2043 if (t
->to_search_memory
!= NULL
)
2048 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2049 pattern
, pattern_len
, found_addrp
);
2053 /* If a special version of to_search_memory isn't available, use the
2055 found
= simple_search_memory (¤t_target
,
2056 start_addr
, search_space_len
,
2057 pattern
, pattern_len
, found_addrp
);
2061 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2066 /* Look through the currently pushed targets. If none of them will
2067 be able to restart the currently running process, issue an error
2071 target_require_runnable (void)
2073 struct target_ops
*t
;
2075 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2077 /* If this target knows how to create a new program, then
2078 assume we will still be able to after killing the current
2079 one. Either killing and mourning will not pop T, or else
2080 find_default_run_target will find it again. */
2081 if (t
->to_create_inferior
!= NULL
)
2084 /* Do not worry about thread_stratum targets that can not
2085 create inferiors. Assume they will be pushed again if
2086 necessary, and continue to the process_stratum. */
2087 if (t
->to_stratum
== thread_stratum
)
2091 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2095 /* This function is only called if the target is running. In that
2096 case there should have been a process_stratum target and it
2097 should either know how to create inferiors, or not... */
2098 internal_error (__FILE__
, __LINE__
, "No targets found");
2101 /* Look through the list of possible targets for a target that can
2102 execute a run or attach command without any other data. This is
2103 used to locate the default process stratum.
2105 If DO_MESG is not NULL, the result is always valid (error() is
2106 called for errors); else, return NULL on error. */
2108 static struct target_ops
*
2109 find_default_run_target (char *do_mesg
)
2111 struct target_ops
**t
;
2112 struct target_ops
*runable
= NULL
;
2117 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2120 if ((*t
)->to_can_run
&& target_can_run (*t
))
2130 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2139 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2141 struct target_ops
*t
;
2143 t
= find_default_run_target ("attach");
2144 (t
->to_attach
) (t
, args
, from_tty
);
2149 find_default_create_inferior (struct target_ops
*ops
,
2150 char *exec_file
, char *allargs
, char **env
,
2153 struct target_ops
*t
;
2155 t
= find_default_run_target ("run");
2156 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2161 find_default_can_async_p (void)
2163 struct target_ops
*t
;
2165 /* This may be called before the target is pushed on the stack;
2166 look for the default process stratum. If there's none, gdb isn't
2167 configured with a native debugger, and target remote isn't
2169 t
= find_default_run_target (NULL
);
2170 if (t
&& t
->to_can_async_p
)
2171 return (t
->to_can_async_p
) ();
2176 find_default_is_async_p (void)
2178 struct target_ops
*t
;
2180 /* This may be called before the target is pushed on the stack;
2181 look for the default process stratum. If there's none, gdb isn't
2182 configured with a native debugger, and target remote isn't
2184 t
= find_default_run_target (NULL
);
2185 if (t
&& t
->to_is_async_p
)
2186 return (t
->to_is_async_p
) ();
2191 find_default_supports_non_stop (void)
2193 struct target_ops
*t
;
2195 t
= find_default_run_target (NULL
);
2196 if (t
&& t
->to_supports_non_stop
)
2197 return (t
->to_supports_non_stop
) ();
2202 target_supports_non_stop ()
2204 struct target_ops
*t
;
2205 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2206 if (t
->to_supports_non_stop
)
2207 return t
->to_supports_non_stop ();
2214 target_get_osdata (const char *type
)
2217 struct target_ops
*t
;
2219 if (target_can_run (¤t_target
))
2220 t
= ¤t_target
;
2222 t
= find_default_run_target ("get OS data");
2227 document
= target_read_stralloc (t
,
2228 TARGET_OBJECT_OSDATA
,
2234 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2236 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2240 default_watchpoint_addr_within_range (struct target_ops
*target
,
2242 CORE_ADDR start
, int length
)
2244 return addr
>= start
&& addr
< start
+ length
;
2260 return_minus_one (void)
2266 * Resize the to_sections pointer. Also make sure that anyone that
2267 * was holding on to an old value of it gets updated.
2268 * Returns the old size.
2272 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2274 struct target_ops
**t
;
2275 struct section_table
*old_value
;
2278 old_value
= target
->to_sections
;
2280 if (target
->to_sections
)
2282 old_count
= target
->to_sections_end
- target
->to_sections
;
2283 target
->to_sections
= (struct section_table
*)
2284 xrealloc ((char *) target
->to_sections
,
2285 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2290 target
->to_sections
= (struct section_table
*)
2291 xmalloc ((sizeof (struct section_table
)) * num_added
);
2293 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2295 /* Check to see if anyone else was pointing to this structure.
2296 If old_value was null, then no one was. */
2300 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2303 if ((*t
)->to_sections
== old_value
)
2305 (*t
)->to_sections
= target
->to_sections
;
2306 (*t
)->to_sections_end
= target
->to_sections_end
;
2309 /* There is a flattened view of the target stack in current_target,
2310 so its to_sections pointer might also need updating. */
2311 if (current_target
.to_sections
== old_value
)
2313 current_target
.to_sections
= target
->to_sections
;
2314 current_target
.to_sections_end
= target
->to_sections_end
;
2322 /* Remove all target sections taken from ABFD.
2324 Scan the current target stack for targets whose section tables
2325 refer to sections from BFD, and remove those sections. We use this
2326 when we notice that the inferior has unloaded a shared object, for
2329 remove_target_sections (bfd
*abfd
)
2331 struct target_ops
**t
;
2333 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2335 struct section_table
*src
, *dest
;
2337 dest
= (*t
)->to_sections
;
2338 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2339 if (src
->bfd
!= abfd
)
2341 /* Keep this section. */
2342 if (dest
< src
) *dest
= *src
;
2346 /* If we've dropped any sections, resize the section table. */
2348 target_resize_to_sections (*t
, dest
- src
);
2355 /* Find a single runnable target in the stack and return it. If for
2356 some reason there is more than one, return NULL. */
2359 find_run_target (void)
2361 struct target_ops
**t
;
2362 struct target_ops
*runable
= NULL
;
2367 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2369 if ((*t
)->to_can_run
&& target_can_run (*t
))
2376 return (count
== 1 ? runable
: NULL
);
2379 /* Find a single core_stratum target in the list of targets and return it.
2380 If for some reason there is more than one, return NULL. */
2383 find_core_target (void)
2385 struct target_ops
**t
;
2386 struct target_ops
*runable
= NULL
;
2391 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2394 if ((*t
)->to_stratum
== core_stratum
)
2401 return (count
== 1 ? runable
: NULL
);
2405 * Find the next target down the stack from the specified target.
2409 find_target_beneath (struct target_ops
*t
)
2415 /* The inferior process has died. Long live the inferior! */
2418 generic_mourn_inferior (void)
2422 ptid
= inferior_ptid
;
2423 inferior_ptid
= null_ptid
;
2425 if (!ptid_equal (ptid
, null_ptid
))
2427 int pid
= ptid_get_pid (ptid
);
2428 delete_inferior (pid
);
2431 breakpoint_init_inferior (inf_exited
);
2432 registers_changed ();
2434 reopen_exec_file ();
2435 reinit_frame_cache ();
2437 if (deprecated_detach_hook
)
2438 deprecated_detach_hook ();
2441 /* Helper function for child_wait and the derivatives of child_wait.
2442 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2443 translation of that in OURSTATUS. */
2445 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2447 if (WIFEXITED (hoststatus
))
2449 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2450 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2452 else if (!WIFSTOPPED (hoststatus
))
2454 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2455 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2459 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2460 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2464 /* Convert a normal process ID to a string. Returns the string in a
2468 normal_pid_to_str (ptid_t ptid
)
2470 static char buf
[32];
2472 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2476 /* Error-catcher for target_find_memory_regions */
2477 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2479 error (_("No target."));
2483 /* Error-catcher for target_make_corefile_notes */
2484 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2486 error (_("No target."));
2490 /* Set up the handful of non-empty slots needed by the dummy target
2494 init_dummy_target (void)
2496 dummy_target
.to_shortname
= "None";
2497 dummy_target
.to_longname
= "None";
2498 dummy_target
.to_doc
= "";
2499 dummy_target
.to_attach
= find_default_attach
;
2500 dummy_target
.to_detach
=
2501 (void (*)(struct target_ops
*, char *, int))target_ignore
;
2502 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2503 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2504 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2505 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2506 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2507 dummy_target
.to_stratum
= dummy_stratum
;
2508 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2509 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2510 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2511 dummy_target
.to_magic
= OPS_MAGIC
;
2515 debug_to_open (char *args
, int from_tty
)
2517 debug_target
.to_open (args
, from_tty
);
2519 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2523 debug_to_close (int quitting
)
2525 target_close (&debug_target
, quitting
);
2526 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2530 target_close (struct target_ops
*targ
, int quitting
)
2532 if (targ
->to_xclose
!= NULL
)
2533 targ
->to_xclose (targ
, quitting
);
2534 else if (targ
->to_close
!= NULL
)
2535 targ
->to_close (quitting
);
2539 target_attach (char *args
, int from_tty
)
2541 struct target_ops
*t
;
2542 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2544 if (t
->to_attach
!= NULL
)
2546 t
->to_attach (t
, args
, from_tty
);
2551 internal_error (__FILE__
, __LINE__
,
2552 "could not find a target to attach");
2557 debug_to_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2559 debug_target
.to_attach (&debug_target
, args
, from_tty
);
2561 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2566 debug_to_post_attach (int pid
)
2568 debug_target
.to_post_attach (pid
);
2570 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2574 debug_to_detach (struct target_ops
*ops
, char *args
, int from_tty
)
2576 debug_target
.to_detach (&debug_target
, args
, from_tty
);
2578 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2582 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2584 debug_target
.to_resume (ptid
, step
, siggnal
);
2586 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2587 step
? "step" : "continue",
2588 target_signal_to_name (siggnal
));
2591 /* Return a pretty printed form of target_waitstatus.
2592 Space for the result is malloc'd, caller must free. */
2595 target_waitstatus_to_string (const struct target_waitstatus
*ws
)
2597 const char *kind_str
= "status->kind = ";
2601 case TARGET_WAITKIND_EXITED
:
2602 return xstrprintf ("%sexited, status = %d",
2603 kind_str
, ws
->value
.integer
);
2604 case TARGET_WAITKIND_STOPPED
:
2605 return xstrprintf ("%sstopped, signal = %s",
2606 kind_str
, target_signal_to_name (ws
->value
.sig
));
2607 case TARGET_WAITKIND_SIGNALLED
:
2608 return xstrprintf ("%ssignalled, signal = %s",
2609 kind_str
, target_signal_to_name (ws
->value
.sig
));
2610 case TARGET_WAITKIND_LOADED
:
2611 return xstrprintf ("%sloaded", kind_str
);
2612 case TARGET_WAITKIND_FORKED
:
2613 return xstrprintf ("%sforked", kind_str
);
2614 case TARGET_WAITKIND_VFORKED
:
2615 return xstrprintf ("%svforked", kind_str
);
2616 case TARGET_WAITKIND_EXECD
:
2617 return xstrprintf ("%sexecd", kind_str
);
2618 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2619 return xstrprintf ("%ssyscall-entry", kind_str
);
2620 case TARGET_WAITKIND_SYSCALL_RETURN
:
2621 return xstrprintf ("%ssyscall-return", kind_str
);
2622 case TARGET_WAITKIND_SPURIOUS
:
2623 return xstrprintf ("%sspurious", kind_str
);
2624 case TARGET_WAITKIND_IGNORE
:
2625 return xstrprintf ("%signore", kind_str
);
2626 case TARGET_WAITKIND_NO_HISTORY
:
2627 return xstrprintf ("%sno-history", kind_str
);
2629 return xstrprintf ("%sunknown???", kind_str
);
2634 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2637 char *status_string
;
2639 retval
= debug_target
.to_wait (ptid
, status
);
2641 fprintf_unfiltered (gdb_stdlog
,
2642 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2645 status_string
= target_waitstatus_to_string (status
);
2646 fprintf_unfiltered (gdb_stdlog
, "%s\n", status_string
);
2647 xfree (status_string
);
2653 debug_print_register (const char * func
,
2654 struct regcache
*regcache
, int regno
)
2656 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2657 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2658 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2659 && gdbarch_register_name (gdbarch
, regno
) != NULL
2660 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2661 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2662 gdbarch_register_name (gdbarch
, regno
));
2664 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2665 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2667 int i
, size
= register_size (gdbarch
, regno
);
2668 unsigned char buf
[MAX_REGISTER_SIZE
];
2669 regcache_raw_collect (regcache
, regno
, buf
);
2670 fprintf_unfiltered (gdb_stdlog
, " = ");
2671 for (i
= 0; i
< size
; i
++)
2673 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2675 if (size
<= sizeof (LONGEST
))
2677 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2678 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2679 core_addr_to_string_nz (val
), plongest (val
));
2682 fprintf_unfiltered (gdb_stdlog
, "\n");
2686 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2688 debug_target
.to_fetch_registers (regcache
, regno
);
2689 debug_print_register ("target_fetch_registers", regcache
, regno
);
2693 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2695 debug_target
.to_store_registers (regcache
, regno
);
2696 debug_print_register ("target_store_registers", regcache
, regno
);
2697 fprintf_unfiltered (gdb_stdlog
, "\n");
2701 debug_to_prepare_to_store (struct regcache
*regcache
)
2703 debug_target
.to_prepare_to_store (regcache
);
2705 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2709 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2710 int write
, struct mem_attrib
*attrib
,
2711 struct target_ops
*target
)
2715 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2718 fprintf_unfiltered (gdb_stdlog
,
2719 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
2720 paddress (memaddr
), len
, write
? "write" : "read",
2727 fputs_unfiltered (", bytes =", gdb_stdlog
);
2728 for (i
= 0; i
< retval
; i
++)
2730 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
2732 if (targetdebug
< 2 && i
> 0)
2734 fprintf_unfiltered (gdb_stdlog
, " ...");
2737 fprintf_unfiltered (gdb_stdlog
, "\n");
2740 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2744 fputc_unfiltered ('\n', gdb_stdlog
);
2750 debug_to_files_info (struct target_ops
*target
)
2752 debug_target
.to_files_info (target
);
2754 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2758 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2762 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2764 fprintf_unfiltered (gdb_stdlog
,
2765 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2766 (unsigned long) bp_tgt
->placed_address
,
2767 (unsigned long) retval
);
2772 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2776 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2778 fprintf_unfiltered (gdb_stdlog
,
2779 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2780 (unsigned long) bp_tgt
->placed_address
,
2781 (unsigned long) retval
);
2786 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2790 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2792 fprintf_unfiltered (gdb_stdlog
,
2793 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2794 (unsigned long) type
,
2795 (unsigned long) cnt
,
2796 (unsigned long) from_tty
,
2797 (unsigned long) retval
);
2802 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2806 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2808 fprintf_unfiltered (gdb_stdlog
,
2809 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2810 (unsigned long) addr
,
2811 (unsigned long) len
,
2812 (unsigned long) retval
);
2817 debug_to_stopped_by_watchpoint (void)
2821 retval
= debug_target
.to_stopped_by_watchpoint ();
2823 fprintf_unfiltered (gdb_stdlog
,
2824 "STOPPED_BY_WATCHPOINT () = %ld\n",
2825 (unsigned long) retval
);
2830 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2834 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2836 fprintf_unfiltered (gdb_stdlog
,
2837 "target_stopped_data_address ([0x%lx]) = %ld\n",
2838 (unsigned long)*addr
,
2839 (unsigned long)retval
);
2844 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2846 CORE_ADDR start
, int length
)
2850 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2853 fprintf_filtered (gdb_stdlog
,
2854 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2855 (unsigned long) addr
, (unsigned long) start
, length
,
2861 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2865 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2867 fprintf_unfiltered (gdb_stdlog
,
2868 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2869 (unsigned long) bp_tgt
->placed_address
,
2870 (unsigned long) retval
);
2875 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2879 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2881 fprintf_unfiltered (gdb_stdlog
,
2882 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2883 (unsigned long) bp_tgt
->placed_address
,
2884 (unsigned long) retval
);
2889 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2893 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2895 fprintf_unfiltered (gdb_stdlog
,
2896 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2897 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2902 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2906 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2908 fprintf_unfiltered (gdb_stdlog
,
2909 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2910 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2915 debug_to_terminal_init (void)
2917 debug_target
.to_terminal_init ();
2919 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2923 debug_to_terminal_inferior (void)
2925 debug_target
.to_terminal_inferior ();
2927 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2931 debug_to_terminal_ours_for_output (void)
2933 debug_target
.to_terminal_ours_for_output ();
2935 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2939 debug_to_terminal_ours (void)
2941 debug_target
.to_terminal_ours ();
2943 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2947 debug_to_terminal_save_ours (void)
2949 debug_target
.to_terminal_save_ours ();
2951 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2955 debug_to_terminal_info (char *arg
, int from_tty
)
2957 debug_target
.to_terminal_info (arg
, from_tty
);
2959 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2964 debug_to_kill (void)
2966 debug_target
.to_kill ();
2968 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2972 debug_to_load (char *args
, int from_tty
)
2974 debug_target
.to_load (args
, from_tty
);
2976 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2980 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2984 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2986 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2992 debug_to_create_inferior (struct target_ops
*ops
,
2993 char *exec_file
, char *args
, char **env
,
2996 debug_target
.to_create_inferior (ops
, exec_file
, args
, env
, from_tty
);
2998 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2999 exec_file
, args
, from_tty
);
3003 debug_to_post_startup_inferior (ptid_t ptid
)
3005 debug_target
.to_post_startup_inferior (ptid
);
3007 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
3012 debug_to_acknowledge_created_inferior (int pid
)
3014 debug_target
.to_acknowledge_created_inferior (pid
);
3016 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
3021 debug_to_insert_fork_catchpoint (int pid
)
3023 debug_target
.to_insert_fork_catchpoint (pid
);
3025 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
3030 debug_to_remove_fork_catchpoint (int pid
)
3034 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
3036 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
3043 debug_to_insert_vfork_catchpoint (int pid
)
3045 debug_target
.to_insert_vfork_catchpoint (pid
);
3047 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
3052 debug_to_remove_vfork_catchpoint (int pid
)
3056 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
3058 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
3065 debug_to_insert_exec_catchpoint (int pid
)
3067 debug_target
.to_insert_exec_catchpoint (pid
);
3069 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
3074 debug_to_remove_exec_catchpoint (int pid
)
3078 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
3080 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
3087 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
3091 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
3093 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
3094 pid
, wait_status
, *exit_status
, has_exited
);
3100 debug_to_mourn_inferior (struct target_ops
*ops
)
3102 debug_target
.to_mourn_inferior (&debug_target
);
3104 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3108 debug_to_can_run (void)
3112 retval
= debug_target
.to_can_run ();
3114 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3120 debug_to_notice_signals (ptid_t ptid
)
3122 debug_target
.to_notice_signals (ptid
);
3124 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3129 debug_to_thread_alive (ptid_t ptid
)
3133 retval
= debug_target
.to_thread_alive (ptid
);
3135 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3136 PIDGET (ptid
), retval
);
3142 debug_to_find_new_threads (void)
3144 debug_target
.to_find_new_threads ();
3146 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3150 debug_to_stop (ptid_t ptid
)
3152 debug_target
.to_stop (ptid
);
3154 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3155 target_pid_to_str (ptid
));
3159 debug_to_rcmd (char *command
,
3160 struct ui_file
*outbuf
)
3162 debug_target
.to_rcmd (command
, outbuf
);
3163 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3167 debug_to_pid_to_exec_file (int pid
)
3171 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3173 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3180 setup_target_debug (void)
3182 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3184 current_target
.to_open
= debug_to_open
;
3185 current_target
.to_close
= debug_to_close
;
3186 current_target
.to_attach
= debug_to_attach
;
3187 current_target
.to_post_attach
= debug_to_post_attach
;
3188 current_target
.to_detach
= debug_to_detach
;
3189 current_target
.to_resume
= debug_to_resume
;
3190 current_target
.to_wait
= debug_to_wait
;
3191 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3192 current_target
.to_store_registers
= debug_to_store_registers
;
3193 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3194 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3195 current_target
.to_files_info
= debug_to_files_info
;
3196 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3197 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3198 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3199 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3200 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3201 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3202 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3203 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3204 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3205 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3206 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3207 current_target
.to_terminal_init
= debug_to_terminal_init
;
3208 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3209 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3210 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3211 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3212 current_target
.to_terminal_info
= debug_to_terminal_info
;
3213 current_target
.to_kill
= debug_to_kill
;
3214 current_target
.to_load
= debug_to_load
;
3215 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3216 current_target
.to_create_inferior
= debug_to_create_inferior
;
3217 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3218 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3219 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3220 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3221 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3222 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3223 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3224 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3225 current_target
.to_has_exited
= debug_to_has_exited
;
3226 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3227 current_target
.to_can_run
= debug_to_can_run
;
3228 current_target
.to_notice_signals
= debug_to_notice_signals
;
3229 current_target
.to_thread_alive
= debug_to_thread_alive
;
3230 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3231 current_target
.to_stop
= debug_to_stop
;
3232 current_target
.to_rcmd
= debug_to_rcmd
;
3233 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3237 static char targ_desc
[] =
3238 "Names of targets and files being debugged.\n\
3239 Shows the entire stack of targets currently in use (including the exec-file,\n\
3240 core-file, and process, if any), as well as the symbol file name.";
3243 do_monitor_command (char *cmd
,
3246 if ((current_target
.to_rcmd
3247 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3248 || (current_target
.to_rcmd
== debug_to_rcmd
3249 && (debug_target
.to_rcmd
3250 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3251 error (_("\"monitor\" command not supported by this target."));
3252 target_rcmd (cmd
, gdb_stdtarg
);
3255 /* Print the name of each layers of our target stack. */
3258 maintenance_print_target_stack (char *cmd
, int from_tty
)
3260 struct target_ops
*t
;
3262 printf_filtered (_("The current target stack is:\n"));
3264 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3266 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3270 /* Controls if async mode is permitted. */
3271 int target_async_permitted
= 0;
3273 /* The set command writes to this variable. If the inferior is
3274 executing, linux_nat_async_permitted is *not* updated. */
3275 static int target_async_permitted_1
= 0;
3278 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3279 struct cmd_list_element
*c
)
3281 if (target_has_execution
)
3283 target_async_permitted_1
= target_async_permitted
;
3284 error (_("Cannot change this setting while the inferior is running."));
3287 target_async_permitted
= target_async_permitted_1
;
3291 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3292 struct cmd_list_element
*c
,
3295 fprintf_filtered (file
, _("\
3296 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3300 initialize_targets (void)
3302 init_dummy_target ();
3303 push_target (&dummy_target
);
3305 add_info ("target", target_info
, targ_desc
);
3306 add_info ("files", target_info
, targ_desc
);
3308 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3309 Set target debugging."), _("\
3310 Show target debugging."), _("\
3311 When non-zero, target debugging is enabled. Higher numbers are more\n\
3312 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3316 &setdebuglist
, &showdebuglist
);
3318 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3319 &trust_readonly
, _("\
3320 Set mode for reading from readonly sections."), _("\
3321 Show mode for reading from readonly sections."), _("\
3322 When this mode is on, memory reads from readonly sections (such as .text)\n\
3323 will be read from the object file instead of from the target. This will\n\
3324 result in significant performance improvement for remote targets."),
3326 show_trust_readonly
,
3327 &setlist
, &showlist
);
3329 add_com ("monitor", class_obscure
, do_monitor_command
,
3330 _("Send a command to the remote monitor (remote targets only)."));
3332 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3333 _("Print the name of each layer of the internal target stack."),
3334 &maintenanceprintlist
);
3336 add_setshow_boolean_cmd ("target-async", no_class
,
3337 &target_async_permitted_1
, _("\
3338 Set whether gdb controls the inferior in asynchronous mode."), _("\
3339 Show whether gdb controls the inferior in asynchronous mode."), _("\
3340 Tells gdb whether to control the inferior in asynchronous mode."),
3341 set_maintenance_target_async_permitted
,
3342 show_maintenance_target_async_permitted
,
3346 target_dcache
= dcache_init ();