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 (char *, int);
104 static void debug_to_detach (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 (void);
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 are debugging an attached outside process
203 rather than an inferior. */
207 /* Nonzero if we should trust readonly sections from the
208 executable when reading memory. */
210 static int trust_readonly
= 0;
212 /* Nonzero if we should show true memory content including
213 memory breakpoint inserted by gdb. */
215 static int show_memory_breakpoints
= 0;
217 /* Non-zero if we want to see trace of target level stuff. */
219 static int targetdebug
= 0;
221 show_targetdebug (struct ui_file
*file
, int from_tty
,
222 struct cmd_list_element
*c
, const char *value
)
224 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
227 static void setup_target_debug (void);
229 DCACHE
*target_dcache
;
231 /* The user just typed 'target' without the name of a target. */
234 target_command (char *arg
, int from_tty
)
236 fputs_filtered ("Argument required (target name). Try `help target'\n",
240 /* Add a possible target architecture to the list. */
243 add_target (struct target_ops
*t
)
245 /* Provide default values for all "must have" methods. */
246 if (t
->to_xfer_partial
== NULL
)
247 t
->to_xfer_partial
= default_xfer_partial
;
251 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
252 target_structs
= (struct target_ops
**) xmalloc
253 (target_struct_allocsize
* sizeof (*target_structs
));
255 if (target_struct_size
>= target_struct_allocsize
)
257 target_struct_allocsize
*= 2;
258 target_structs
= (struct target_ops
**)
259 xrealloc ((char *) target_structs
,
260 target_struct_allocsize
* sizeof (*target_structs
));
262 target_structs
[target_struct_size
++] = t
;
264 if (targetlist
== NULL
)
265 add_prefix_cmd ("target", class_run
, target_command
, _("\
266 Connect to a target machine or process.\n\
267 The first argument is the type or protocol of the target machine.\n\
268 Remaining arguments are interpreted by the target protocol. For more\n\
269 information on the arguments for a particular protocol, type\n\
270 `help target ' followed by the protocol name."),
271 &targetlist
, "target ", 0, &cmdlist
);
272 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
283 target_load (char *arg
, int from_tty
)
285 dcache_invalidate (target_dcache
);
286 (*current_target
.to_load
) (arg
, from_tty
);
290 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
291 struct target_ops
*t
)
293 errno
= EIO
; /* Can't read/write this location */
294 return 0; /* No bytes handled */
300 error (_("You can't do that when your target is `%s'"),
301 current_target
.to_shortname
);
307 error (_("You can't do that without a process to debug."));
311 nosymbol (char *name
, CORE_ADDR
*addrp
)
313 return 1; /* Symbol does not exist in target env */
317 nosupport_runtime (void)
319 if (ptid_equal (inferior_ptid
, null_ptid
))
322 error (_("No run-time support for this"));
327 default_terminal_info (char *args
, int from_tty
)
329 printf_unfiltered (_("No saved terminal information.\n"));
332 /* This is the default target_create_inferior and target_attach function.
333 If the current target is executing, it asks whether to kill it off.
334 If this function returns without calling error(), it has killed off
335 the target, and the operation should be attempted. */
338 kill_or_be_killed (int from_tty
)
340 if (target_has_execution
)
342 printf_unfiltered (_("You are already running a program:\n"));
343 target_files_info ();
344 if (query ("Kill it? "))
347 if (target_has_execution
)
348 error (_("Killing the program did not help."));
353 error (_("Program not killed."));
359 /* Go through the target stack from top to bottom, copying over zero
360 entries in current_target, then filling in still empty entries. In
361 effect, we are doing class inheritance through the pushed target
364 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
365 is currently implemented, is that it discards any knowledge of
366 which target an inherited method originally belonged to.
367 Consequently, new new target methods should instead explicitly and
368 locally search the target stack for the target that can handle the
372 update_current_target (void)
374 struct target_ops
*t
;
376 /* First, reset current's contents. */
377 memset (¤t_target
, 0, sizeof (current_target
));
379 #define INHERIT(FIELD, TARGET) \
380 if (!current_target.FIELD) \
381 current_target.FIELD = (TARGET)->FIELD
383 for (t
= target_stack
; t
; t
= t
->beneath
)
385 INHERIT (to_shortname
, t
);
386 INHERIT (to_longname
, t
);
388 INHERIT (to_open
, t
);
389 INHERIT (to_close
, t
);
390 INHERIT (to_attach
, t
);
391 INHERIT (to_post_attach
, t
);
392 INHERIT (to_attach_no_wait
, t
);
393 INHERIT (to_detach
, t
);
394 /* Do not inherit to_disconnect. */
395 INHERIT (to_resume
, t
);
396 INHERIT (to_wait
, t
);
397 INHERIT (to_fetch_registers
, t
);
398 INHERIT (to_store_registers
, t
);
399 INHERIT (to_prepare_to_store
, t
);
400 INHERIT (deprecated_xfer_memory
, t
);
401 INHERIT (to_files_info
, t
);
402 INHERIT (to_insert_breakpoint
, t
);
403 INHERIT (to_remove_breakpoint
, t
);
404 INHERIT (to_can_use_hw_breakpoint
, t
);
405 INHERIT (to_insert_hw_breakpoint
, t
);
406 INHERIT (to_remove_hw_breakpoint
, t
);
407 INHERIT (to_insert_watchpoint
, t
);
408 INHERIT (to_remove_watchpoint
, t
);
409 INHERIT (to_stopped_data_address
, t
);
410 INHERIT (to_have_steppable_watchpoint
, t
);
411 INHERIT (to_have_continuable_watchpoint
, t
);
412 INHERIT (to_stopped_by_watchpoint
, t
);
413 INHERIT (to_watchpoint_addr_within_range
, t
);
414 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
415 INHERIT (to_terminal_init
, t
);
416 INHERIT (to_terminal_inferior
, t
);
417 INHERIT (to_terminal_ours_for_output
, t
);
418 INHERIT (to_terminal_ours
, t
);
419 INHERIT (to_terminal_save_ours
, t
);
420 INHERIT (to_terminal_info
, t
);
421 INHERIT (to_kill
, t
);
422 INHERIT (to_load
, t
);
423 INHERIT (to_lookup_symbol
, t
);
424 INHERIT (to_create_inferior
, t
);
425 INHERIT (to_post_startup_inferior
, t
);
426 INHERIT (to_acknowledge_created_inferior
, t
);
427 INHERIT (to_insert_fork_catchpoint
, t
);
428 INHERIT (to_remove_fork_catchpoint
, t
);
429 INHERIT (to_insert_vfork_catchpoint
, t
);
430 INHERIT (to_remove_vfork_catchpoint
, t
);
431 /* Do not inherit to_follow_fork. */
432 INHERIT (to_insert_exec_catchpoint
, t
);
433 INHERIT (to_remove_exec_catchpoint
, t
);
434 INHERIT (to_has_exited
, t
);
435 INHERIT (to_mourn_inferior
, t
);
436 INHERIT (to_can_run
, t
);
437 INHERIT (to_notice_signals
, t
);
438 INHERIT (to_thread_alive
, t
);
439 INHERIT (to_find_new_threads
, t
);
440 INHERIT (to_pid_to_str
, t
);
441 INHERIT (to_extra_thread_info
, t
);
442 INHERIT (to_stop
, t
);
443 /* Do not inherit to_xfer_partial. */
444 INHERIT (to_rcmd
, t
);
445 INHERIT (to_pid_to_exec_file
, t
);
446 INHERIT (to_log_command
, t
);
447 INHERIT (to_stratum
, t
);
448 INHERIT (to_has_all_memory
, t
);
449 INHERIT (to_has_memory
, t
);
450 INHERIT (to_has_stack
, t
);
451 INHERIT (to_has_registers
, t
);
452 INHERIT (to_has_execution
, t
);
453 INHERIT (to_has_thread_control
, t
);
454 INHERIT (to_sections
, t
);
455 INHERIT (to_sections_end
, t
);
456 INHERIT (to_can_async_p
, t
);
457 INHERIT (to_is_async_p
, t
);
458 INHERIT (to_async
, t
);
459 INHERIT (to_async_mask
, t
);
460 INHERIT (to_find_memory_regions
, t
);
461 INHERIT (to_make_corefile_notes
, t
);
462 INHERIT (to_get_thread_local_address
, t
);
463 /* Do not inherit to_read_description. */
464 /* Do not inherit to_search_memory. */
465 INHERIT (to_magic
, t
);
466 /* Do not inherit to_memory_map. */
467 /* Do not inherit to_flash_erase. */
468 /* Do not inherit to_flash_done. */
472 /* Clean up a target struct so it no longer has any zero pointers in
473 it. Some entries are defaulted to a method that print an error,
474 others are hard-wired to a standard recursive default. */
476 #define de_fault(field, value) \
477 if (!current_target.field) \
478 current_target.field = value
481 (void (*) (char *, int))
486 de_fault (to_post_attach
,
490 (void (*) (char *, int))
493 (void (*) (ptid_t
, int, enum target_signal
))
496 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
498 de_fault (to_fetch_registers
,
499 (void (*) (struct regcache
*, int))
501 de_fault (to_store_registers
,
502 (void (*) (struct regcache
*, int))
504 de_fault (to_prepare_to_store
,
505 (void (*) (struct regcache
*))
507 de_fault (deprecated_xfer_memory
,
508 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
510 de_fault (to_files_info
,
511 (void (*) (struct target_ops
*))
513 de_fault (to_insert_breakpoint
,
514 memory_insert_breakpoint
);
515 de_fault (to_remove_breakpoint
,
516 memory_remove_breakpoint
);
517 de_fault (to_can_use_hw_breakpoint
,
518 (int (*) (int, int, int))
520 de_fault (to_insert_hw_breakpoint
,
521 (int (*) (struct bp_target_info
*))
523 de_fault (to_remove_hw_breakpoint
,
524 (int (*) (struct bp_target_info
*))
526 de_fault (to_insert_watchpoint
,
527 (int (*) (CORE_ADDR
, int, int))
529 de_fault (to_remove_watchpoint
,
530 (int (*) (CORE_ADDR
, int, int))
532 de_fault (to_stopped_by_watchpoint
,
535 de_fault (to_stopped_data_address
,
536 (int (*) (struct target_ops
*, CORE_ADDR
*))
538 de_fault (to_watchpoint_addr_within_range
,
539 default_watchpoint_addr_within_range
);
540 de_fault (to_region_ok_for_hw_watchpoint
,
541 default_region_ok_for_hw_watchpoint
);
542 de_fault (to_terminal_init
,
545 de_fault (to_terminal_inferior
,
548 de_fault (to_terminal_ours_for_output
,
551 de_fault (to_terminal_ours
,
554 de_fault (to_terminal_save_ours
,
557 de_fault (to_terminal_info
,
558 default_terminal_info
);
563 (void (*) (char *, int))
565 de_fault (to_lookup_symbol
,
566 (int (*) (char *, CORE_ADDR
*))
568 de_fault (to_post_startup_inferior
,
571 de_fault (to_acknowledge_created_inferior
,
574 de_fault (to_insert_fork_catchpoint
,
577 de_fault (to_remove_fork_catchpoint
,
580 de_fault (to_insert_vfork_catchpoint
,
583 de_fault (to_remove_vfork_catchpoint
,
586 de_fault (to_insert_exec_catchpoint
,
589 de_fault (to_remove_exec_catchpoint
,
592 de_fault (to_has_exited
,
593 (int (*) (int, int, int *))
595 de_fault (to_mourn_inferior
,
598 de_fault (to_can_run
,
600 de_fault (to_notice_signals
,
603 de_fault (to_thread_alive
,
606 de_fault (to_find_new_threads
,
609 de_fault (to_extra_thread_info
,
610 (char *(*) (struct thread_info
*))
615 current_target
.to_xfer_partial
= current_xfer_partial
;
617 (void (*) (char *, struct ui_file
*))
619 de_fault (to_pid_to_exec_file
,
623 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
625 de_fault (to_async_mask
,
628 current_target
.to_read_description
= NULL
;
631 /* Finally, position the target-stack beneath the squashed
632 "current_target". That way code looking for a non-inherited
633 target method can quickly and simply find it. */
634 current_target
.beneath
= target_stack
;
637 setup_target_debug ();
640 /* Mark OPS as a running target. This reverses the effect
641 of target_mark_exited. */
644 target_mark_running (struct target_ops
*ops
)
646 struct target_ops
*t
;
648 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
652 internal_error (__FILE__
, __LINE__
,
653 "Attempted to mark unpushed target \"%s\" as running",
656 ops
->to_has_execution
= 1;
657 ops
->to_has_all_memory
= 1;
658 ops
->to_has_memory
= 1;
659 ops
->to_has_stack
= 1;
660 ops
->to_has_registers
= 1;
662 update_current_target ();
665 /* Mark OPS as a non-running target. This reverses the effect
666 of target_mark_running. */
669 target_mark_exited (struct target_ops
*ops
)
671 struct target_ops
*t
;
673 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
677 internal_error (__FILE__
, __LINE__
,
678 "Attempted to mark unpushed target \"%s\" as running",
681 ops
->to_has_execution
= 0;
682 ops
->to_has_all_memory
= 0;
683 ops
->to_has_memory
= 0;
684 ops
->to_has_stack
= 0;
685 ops
->to_has_registers
= 0;
687 update_current_target ();
690 /* Push a new target type into the stack of the existing target accessors,
691 possibly superseding some of the existing accessors.
693 Result is zero if the pushed target ended up on top of the stack,
694 nonzero if at least one target is on top of it.
696 Rather than allow an empty stack, we always have the dummy target at
697 the bottom stratum, so we can call the function vectors without
701 push_target (struct target_ops
*t
)
703 struct target_ops
**cur
;
705 /* Check magic number. If wrong, it probably means someone changed
706 the struct definition, but not all the places that initialize one. */
707 if (t
->to_magic
!= OPS_MAGIC
)
709 fprintf_unfiltered (gdb_stderr
,
710 "Magic number of %s target struct wrong\n",
712 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
715 /* Find the proper stratum to install this target in. */
716 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
718 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
722 /* If there's already targets at this stratum, remove them. */
723 /* FIXME: cagney/2003-10-15: I think this should be popping all
724 targets to CUR, and not just those at this stratum level. */
725 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
727 /* There's already something at this stratum level. Close it,
728 and un-hook it from the stack. */
729 struct target_ops
*tmp
= (*cur
);
730 (*cur
) = (*cur
)->beneath
;
732 target_close (tmp
, 0);
735 /* We have removed all targets in our stratum, now add the new one. */
739 update_current_target ();
742 return (t
!= target_stack
);
745 /* Remove a target_ops vector from the stack, wherever it may be.
746 Return how many times it was removed (0 or 1). */
749 unpush_target (struct target_ops
*t
)
751 struct target_ops
**cur
;
752 struct target_ops
*tmp
;
754 /* Look for the specified target. Note that we assume that a target
755 can only occur once in the target stack. */
757 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
764 return 0; /* Didn't find target_ops, quit now */
766 /* NOTE: cagney/2003-12-06: In '94 the close call was made
767 unconditional by moving it to before the above check that the
768 target was in the target stack (something about "Change the way
769 pushing and popping of targets work to support target overlays
770 and inheritance"). This doesn't make much sense - only open
771 targets should be closed. */
774 /* Unchain the target */
776 (*cur
) = (*cur
)->beneath
;
779 update_current_target ();
787 target_close (¤t_target
, 0); /* Let it clean up */
788 if (unpush_target (target_stack
) == 1)
791 fprintf_unfiltered (gdb_stderr
,
792 "pop_target couldn't find target %s\n",
793 current_target
.to_shortname
);
794 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
798 pop_all_targets_above (enum strata above_stratum
, int quitting
)
800 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
802 target_close (¤t_target
, quitting
);
803 if (!unpush_target (target_stack
))
805 fprintf_unfiltered (gdb_stderr
,
806 "pop_all_targets couldn't find target %s\n",
807 current_target
.to_shortname
);
808 internal_error (__FILE__
, __LINE__
,
809 _("failed internal consistency check"));
816 pop_all_targets (int quitting
)
818 pop_all_targets_above (dummy_stratum
, quitting
);
821 /* Using the objfile specified in OBJFILE, find the address for the
822 current thread's thread-local storage with offset OFFSET. */
824 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
826 volatile CORE_ADDR addr
= 0;
828 if (target_get_thread_local_address_p ()
829 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
831 ptid_t ptid
= inferior_ptid
;
832 volatile struct gdb_exception ex
;
834 TRY_CATCH (ex
, RETURN_MASK_ALL
)
838 /* Fetch the load module address for this objfile. */
839 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
841 /* If it's 0, throw the appropriate exception. */
843 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
844 _("TLS load module not found"));
846 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
848 /* If an error occurred, print TLS related messages here. Otherwise,
849 throw the error to some higher catcher. */
852 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
856 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
857 error (_("Cannot find thread-local variables in this thread library."));
859 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
860 if (objfile_is_library
)
861 error (_("Cannot find shared library `%s' in dynamic"
862 " linker's load module list"), objfile
->name
);
864 error (_("Cannot find executable file `%s' in dynamic"
865 " linker's load module list"), objfile
->name
);
867 case TLS_NOT_ALLOCATED_YET_ERROR
:
868 if (objfile_is_library
)
869 error (_("The inferior has not yet allocated storage for"
870 " thread-local variables in\n"
871 "the shared library `%s'\n"
873 objfile
->name
, target_pid_to_str (ptid
));
875 error (_("The inferior has not yet allocated storage for"
876 " thread-local variables in\n"
877 "the executable `%s'\n"
879 objfile
->name
, target_pid_to_str (ptid
));
881 case TLS_GENERIC_ERROR
:
882 if (objfile_is_library
)
883 error (_("Cannot find thread-local storage for %s, "
884 "shared library %s:\n%s"),
885 target_pid_to_str (ptid
),
886 objfile
->name
, ex
.message
);
888 error (_("Cannot find thread-local storage for %s, "
889 "executable file %s:\n%s"),
890 target_pid_to_str (ptid
),
891 objfile
->name
, ex
.message
);
894 throw_exception (ex
);
899 /* It wouldn't be wrong here to try a gdbarch method, too; finding
900 TLS is an ABI-specific thing. But we don't do that yet. */
902 error (_("Cannot find thread-local variables on this target"));
908 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
910 /* target_read_string -- read a null terminated string, up to LEN bytes,
911 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
912 Set *STRING to a pointer to malloc'd memory containing the data; the caller
913 is responsible for freeing it. Return the number of bytes successfully
917 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
919 int tlen
, origlen
, offset
, i
;
923 int buffer_allocated
;
925 unsigned int nbytes_read
= 0;
929 /* Small for testing. */
930 buffer_allocated
= 4;
931 buffer
= xmalloc (buffer_allocated
);
938 tlen
= MIN (len
, 4 - (memaddr
& 3));
939 offset
= memaddr
& 3;
941 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
944 /* The transfer request might have crossed the boundary to an
945 unallocated region of memory. Retry the transfer, requesting
949 errcode
= target_read_memory (memaddr
, buf
, 1);
954 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
957 bytes
= bufptr
- buffer
;
958 buffer_allocated
*= 2;
959 buffer
= xrealloc (buffer
, buffer_allocated
);
960 bufptr
= buffer
+ bytes
;
963 for (i
= 0; i
< tlen
; i
++)
965 *bufptr
++ = buf
[i
+ offset
];
966 if (buf
[i
+ offset
] == '\000')
968 nbytes_read
+= i
+ 1;
984 /* Find a section containing ADDR. */
985 struct section_table
*
986 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
988 struct section_table
*secp
;
989 for (secp
= target
->to_sections
;
990 secp
< target
->to_sections_end
;
993 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
999 /* Perform a partial memory transfer. The arguments and return
1000 value are just as for target_xfer_partial. */
1003 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1004 ULONGEST memaddr
, LONGEST len
)
1008 struct mem_region
*region
;
1010 /* Zero length requests are ok and require no work. */
1014 /* Try the executable file, if "trust-readonly-sections" is set. */
1015 if (readbuf
!= NULL
&& trust_readonly
)
1017 struct section_table
*secp
;
1019 secp
= target_section_by_addr (ops
, memaddr
);
1021 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1023 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1026 /* Likewise for accesses to unmapped overlay sections. */
1027 if (readbuf
!= NULL
&& overlay_debugging
)
1029 asection
*section
= find_pc_overlay (memaddr
);
1030 if (pc_in_unmapped_range (memaddr
, section
))
1031 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1034 /* Try GDB's internal data cache. */
1035 region
= lookup_mem_region (memaddr
);
1036 /* region->hi == 0 means there's no upper bound. */
1037 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1040 reg_len
= region
->hi
- memaddr
;
1042 switch (region
->attrib
.mode
)
1045 if (writebuf
!= NULL
)
1050 if (readbuf
!= NULL
)
1055 /* We only support writing to flash during "load" for now. */
1056 if (writebuf
!= NULL
)
1057 error (_("Writing to flash memory forbidden in this context"));
1064 if (region
->attrib
.cache
)
1066 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1067 memory request will start back at current_target. */
1068 if (readbuf
!= NULL
)
1069 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1072 /* FIXME drow/2006-08-09: If we're going to preserve const
1073 correctness dcache_xfer_memory should take readbuf and
1075 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1082 if (readbuf
&& !show_memory_breakpoints
)
1083 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1088 /* If none of those methods found the memory we wanted, fall back
1089 to a target partial transfer. Normally a single call to
1090 to_xfer_partial is enough; if it doesn't recognize an object
1091 it will call the to_xfer_partial of the next target down.
1092 But for memory this won't do. Memory is the only target
1093 object which can be read from more than one valid target.
1094 A core file, for instance, could have some of memory but
1095 delegate other bits to the target below it. So, we must
1096 manually try all targets. */
1100 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1101 readbuf
, writebuf
, memaddr
, reg_len
);
1105 /* We want to continue past core files to executables, but not
1106 past a running target's memory. */
1107 if (ops
->to_has_all_memory
)
1112 while (ops
!= NULL
);
1114 if (readbuf
&& !show_memory_breakpoints
)
1115 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1117 /* If we still haven't got anything, return the last error. We
1123 restore_show_memory_breakpoints (void *arg
)
1125 show_memory_breakpoints
= (uintptr_t) arg
;
1129 make_show_memory_breakpoints_cleanup (int show
)
1131 int current
= show_memory_breakpoints
;
1132 show_memory_breakpoints
= show
;
1134 return make_cleanup (restore_show_memory_breakpoints
,
1135 (void *) (uintptr_t) current
);
1139 target_xfer_partial (struct target_ops
*ops
,
1140 enum target_object object
, const char *annex
,
1141 void *readbuf
, const void *writebuf
,
1142 ULONGEST offset
, LONGEST len
)
1146 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1148 /* If this is a memory transfer, let the memory-specific code
1149 have a look at it instead. Memory transfers are more
1151 if (object
== TARGET_OBJECT_MEMORY
)
1152 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1155 enum target_object raw_object
= object
;
1157 /* If this is a raw memory transfer, request the normal
1158 memory object from other layers. */
1159 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1160 raw_object
= TARGET_OBJECT_MEMORY
;
1162 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1163 writebuf
, offset
, len
);
1168 const unsigned char *myaddr
= NULL
;
1170 fprintf_unfiltered (gdb_stdlog
,
1171 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1174 (annex
? annex
: "(null)"),
1175 (long) readbuf
, (long) writebuf
,
1176 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1182 if (retval
> 0 && myaddr
!= NULL
)
1186 fputs_unfiltered (", bytes =", gdb_stdlog
);
1187 for (i
= 0; i
< retval
; i
++)
1189 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1191 if (targetdebug
< 2 && i
> 0)
1193 fprintf_unfiltered (gdb_stdlog
, " ...");
1196 fprintf_unfiltered (gdb_stdlog
, "\n");
1199 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1203 fputc_unfiltered ('\n', gdb_stdlog
);
1208 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1209 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1210 if any error occurs.
1212 If an error occurs, no guarantee is made about the contents of the data at
1213 MYADDR. In particular, the caller should not depend upon partial reads
1214 filling the buffer with good data. There is no way for the caller to know
1215 how much good data might have been transfered anyway. Callers that can
1216 deal with partial reads should call target_read (which will retry until
1217 it makes no progress, and then return how much was transferred). */
1220 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1222 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1223 myaddr
, memaddr
, len
) == len
)
1230 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1232 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1233 myaddr
, memaddr
, len
) == len
)
1239 /* Fetch the target's memory map. */
1242 target_memory_map (void)
1244 VEC(mem_region_s
) *result
;
1245 struct mem_region
*last_one
, *this_one
;
1247 struct target_ops
*t
;
1250 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1252 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1253 if (t
->to_memory_map
!= NULL
)
1259 result
= t
->to_memory_map (t
);
1263 qsort (VEC_address (mem_region_s
, result
),
1264 VEC_length (mem_region_s
, result
),
1265 sizeof (struct mem_region
), mem_region_cmp
);
1267 /* Check that regions do not overlap. Simultaneously assign
1268 a numbering for the "mem" commands to use to refer to
1271 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1273 this_one
->number
= ix
;
1275 if (last_one
&& last_one
->hi
> this_one
->lo
)
1277 warning (_("Overlapping regions in memory map: ignoring"));
1278 VEC_free (mem_region_s
, result
);
1281 last_one
= this_one
;
1288 target_flash_erase (ULONGEST address
, LONGEST length
)
1290 struct target_ops
*t
;
1292 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1293 if (t
->to_flash_erase
!= NULL
)
1296 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1297 paddr (address
), phex (length
, 0));
1298 t
->to_flash_erase (t
, address
, length
);
1306 target_flash_done (void)
1308 struct target_ops
*t
;
1310 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1311 if (t
->to_flash_done
!= NULL
)
1314 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1315 t
->to_flash_done (t
);
1322 #ifndef target_stopped_data_address_p
1324 target_stopped_data_address_p (struct target_ops
*target
)
1326 if (target
->to_stopped_data_address
1327 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1329 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1330 && (debug_target
.to_stopped_data_address
1331 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1338 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1339 struct cmd_list_element
*c
, const char *value
)
1341 fprintf_filtered (file
, _("\
1342 Mode for reading from readonly sections is %s.\n"),
1346 /* More generic transfers. */
1349 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1350 const char *annex
, gdb_byte
*readbuf
,
1351 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1353 if (object
== TARGET_OBJECT_MEMORY
1354 && ops
->deprecated_xfer_memory
!= NULL
)
1355 /* If available, fall back to the target's
1356 "deprecated_xfer_memory" method. */
1360 if (writebuf
!= NULL
)
1362 void *buffer
= xmalloc (len
);
1363 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1364 memcpy (buffer
, writebuf
, len
);
1365 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1366 1/*write*/, NULL
, ops
);
1367 do_cleanups (cleanup
);
1369 if (readbuf
!= NULL
)
1370 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1371 0/*read*/, NULL
, ops
);
1374 else if (xfered
== 0 && errno
== 0)
1375 /* "deprecated_xfer_memory" uses 0, cross checked against
1376 ERRNO as one indication of an error. */
1381 else if (ops
->beneath
!= NULL
)
1382 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1383 readbuf
, writebuf
, offset
, len
);
1388 /* The xfer_partial handler for the topmost target. Unlike the default,
1389 it does not need to handle memory specially; it just passes all
1390 requests down the stack. */
1393 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1394 const char *annex
, gdb_byte
*readbuf
,
1395 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1397 if (ops
->beneath
!= NULL
)
1398 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1399 readbuf
, writebuf
, offset
, len
);
1404 /* Target vector read/write partial wrapper functions.
1406 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1407 (inbuf, outbuf)", instead of separate read/write methods, make life
1411 target_read_partial (struct target_ops
*ops
,
1412 enum target_object object
,
1413 const char *annex
, gdb_byte
*buf
,
1414 ULONGEST offset
, LONGEST len
)
1416 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1420 target_write_partial (struct target_ops
*ops
,
1421 enum target_object object
,
1422 const char *annex
, const gdb_byte
*buf
,
1423 ULONGEST offset
, LONGEST len
)
1425 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1428 /* Wrappers to perform the full transfer. */
1430 target_read (struct target_ops
*ops
,
1431 enum target_object object
,
1432 const char *annex
, gdb_byte
*buf
,
1433 ULONGEST offset
, LONGEST len
)
1436 while (xfered
< len
)
1438 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1439 (gdb_byte
*) buf
+ xfered
,
1440 offset
+ xfered
, len
- xfered
);
1441 /* Call an observer, notifying them of the xfer progress? */
1453 target_read_until_error (struct target_ops
*ops
,
1454 enum target_object object
,
1455 const char *annex
, gdb_byte
*buf
,
1456 ULONGEST offset
, LONGEST len
)
1459 while (xfered
< len
)
1461 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1462 (gdb_byte
*) buf
+ xfered
,
1463 offset
+ xfered
, len
- xfered
);
1464 /* Call an observer, notifying them of the xfer progress? */
1469 /* We've got an error. Try to read in smaller blocks. */
1470 ULONGEST start
= offset
+ xfered
;
1471 ULONGEST remaining
= len
- xfered
;
1474 /* If an attempt was made to read a random memory address,
1475 it's likely that the very first byte is not accessible.
1476 Try reading the first byte, to avoid doing log N tries
1478 xfer
= target_read_partial (ops
, object
, annex
,
1479 (gdb_byte
*) buf
+ xfered
, start
, 1);
1488 xfer
= target_read_partial (ops
, object
, annex
,
1489 (gdb_byte
*) buf
+ xfered
,
1499 /* We have successfully read the first half. So, the
1500 error must be in the second half. Adjust start and
1501 remaining to point at the second half. */
1518 /* An alternative to target_write with progress callbacks. */
1521 target_write_with_progress (struct target_ops
*ops
,
1522 enum target_object object
,
1523 const char *annex
, const gdb_byte
*buf
,
1524 ULONGEST offset
, LONGEST len
,
1525 void (*progress
) (ULONGEST
, void *), void *baton
)
1529 /* Give the progress callback a chance to set up. */
1531 (*progress
) (0, baton
);
1533 while (xfered
< len
)
1535 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1536 (gdb_byte
*) buf
+ xfered
,
1537 offset
+ xfered
, len
- xfered
);
1545 (*progress
) (xfer
, baton
);
1554 target_write (struct target_ops
*ops
,
1555 enum target_object object
,
1556 const char *annex
, const gdb_byte
*buf
,
1557 ULONGEST offset
, LONGEST len
)
1559 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1563 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1564 the size of the transferred data. PADDING additional bytes are
1565 available in *BUF_P. This is a helper function for
1566 target_read_alloc; see the declaration of that function for more
1570 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1571 const char *annex
, gdb_byte
**buf_p
, int padding
)
1573 size_t buf_alloc
, buf_pos
;
1577 /* This function does not have a length parameter; it reads the
1578 entire OBJECT). Also, it doesn't support objects fetched partly
1579 from one target and partly from another (in a different stratum,
1580 e.g. a core file and an executable). Both reasons make it
1581 unsuitable for reading memory. */
1582 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1584 /* Start by reading up to 4K at a time. The target will throttle
1585 this number down if necessary. */
1587 buf
= xmalloc (buf_alloc
);
1591 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1592 buf_pos
, buf_alloc
- buf_pos
- padding
);
1595 /* An error occurred. */
1601 /* Read all there was. */
1611 /* If the buffer is filling up, expand it. */
1612 if (buf_alloc
< buf_pos
* 2)
1615 buf
= xrealloc (buf
, buf_alloc
);
1622 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1623 the size of the transferred data. See the declaration in "target.h"
1624 function for more information about the return value. */
1627 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1628 const char *annex
, gdb_byte
**buf_p
)
1630 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1633 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1634 returned as a string, allocated using xmalloc. If an error occurs
1635 or the transfer is unsupported, NULL is returned. Empty objects
1636 are returned as allocated but empty strings. A warning is issued
1637 if the result contains any embedded NUL bytes. */
1640 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1644 LONGEST transferred
;
1646 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1648 if (transferred
< 0)
1651 if (transferred
== 0)
1652 return xstrdup ("");
1654 buffer
[transferred
] = 0;
1655 if (strlen (buffer
) < transferred
)
1656 warning (_("target object %d, annex %s, "
1657 "contained unexpected null characters"),
1658 (int) object
, annex
? annex
: "(none)");
1660 return (char *) buffer
;
1663 /* Memory transfer methods. */
1666 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1669 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1671 memory_error (EIO
, addr
);
1675 get_target_memory_unsigned (struct target_ops
*ops
,
1676 CORE_ADDR addr
, int len
)
1678 gdb_byte buf
[sizeof (ULONGEST
)];
1680 gdb_assert (len
<= sizeof (buf
));
1681 get_target_memory (ops
, addr
, buf
, len
);
1682 return extract_unsigned_integer (buf
, len
);
1686 target_info (char *args
, int from_tty
)
1688 struct target_ops
*t
;
1689 int has_all_mem
= 0;
1691 if (symfile_objfile
!= NULL
)
1692 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1694 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1696 if (!t
->to_has_memory
)
1699 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1702 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1703 printf_unfiltered ("%s:\n", t
->to_longname
);
1704 (t
->to_files_info
) (t
);
1705 has_all_mem
= t
->to_has_all_memory
;
1709 /* This function is called before any new inferior is created, e.g.
1710 by running a program, attaching, or connecting to a target.
1711 It cleans up any state from previous invocations which might
1712 change between runs. This is a subset of what target_preopen
1713 resets (things which might change between targets). */
1716 target_pre_inferior (int from_tty
)
1718 /* Clear out solib state. Otherwise the solib state of the previous
1719 inferior might have survived and is entirely wrong for the new
1720 target. This has been observed on GNU/Linux using glibc 2.3. How
1732 Cannot access memory at address 0xdeadbeef
1734 no_shared_libraries (NULL
, from_tty
);
1736 invalidate_target_mem_regions ();
1738 target_clear_description ();
1741 /* This is to be called by the open routine before it does
1745 target_preopen (int from_tty
)
1749 if (target_has_execution
)
1752 || query (_("A program is being debugged already. Kill it? ")))
1755 error (_("Program not killed."));
1758 /* Calling target_kill may remove the target from the stack. But if
1759 it doesn't (which seems like a win for UDI), remove it now. */
1760 /* Leave the exec target, though. The user may be switching from a
1761 live process to a core of the same program. */
1762 pop_all_targets_above (file_stratum
, 0);
1764 target_pre_inferior (from_tty
);
1767 /* Detach a target after doing deferred register stores. */
1770 target_detach (char *args
, int from_tty
)
1772 /* If we're in breakpoints-always-inserted mode, have to
1773 remove them before detaching. */
1774 remove_breakpoints ();
1776 (current_target
.to_detach
) (args
, from_tty
);
1780 target_disconnect (char *args
, int from_tty
)
1782 struct target_ops
*t
;
1784 /* If we're in breakpoints-always-inserted mode, have to
1785 remove them before disconnecting. */
1786 remove_breakpoints ();
1788 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1789 if (t
->to_disconnect
!= NULL
)
1792 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1794 t
->to_disconnect (t
, args
, from_tty
);
1802 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1804 dcache_invalidate (target_dcache
);
1805 (*current_target
.to_resume
) (ptid
, step
, signal
);
1806 set_executing (ptid
, 1);
1807 set_running (ptid
, 1);
1809 /* Look through the list of possible targets for a target that can
1813 target_follow_fork (int follow_child
)
1815 struct target_ops
*t
;
1817 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1819 if (t
->to_follow_fork
!= NULL
)
1821 int retval
= t
->to_follow_fork (t
, follow_child
);
1823 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1824 follow_child
, retval
);
1829 /* Some target returned a fork event, but did not know how to follow it. */
1830 internal_error (__FILE__
, __LINE__
,
1831 "could not find a target to follow fork");
1834 /* Look for a target which can describe architectural features, starting
1835 from TARGET. If we find one, return its description. */
1837 const struct target_desc
*
1838 target_read_description (struct target_ops
*target
)
1840 struct target_ops
*t
;
1842 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1843 if (t
->to_read_description
!= NULL
)
1845 const struct target_desc
*tdesc
;
1847 tdesc
= t
->to_read_description (t
);
1855 /* The default implementation of to_search_memory.
1856 This implements a basic search of memory, reading target memory and
1857 performing the search here (as opposed to performing the search in on the
1858 target side with, for example, gdbserver). */
1861 simple_search_memory (struct target_ops
*ops
,
1862 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1863 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1864 CORE_ADDR
*found_addrp
)
1866 /* NOTE: also defined in find.c testcase. */
1867 #define SEARCH_CHUNK_SIZE 16000
1868 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1869 /* Buffer to hold memory contents for searching. */
1870 gdb_byte
*search_buf
;
1871 unsigned search_buf_size
;
1872 struct cleanup
*old_cleanups
;
1874 search_buf_size
= chunk_size
+ pattern_len
- 1;
1876 /* No point in trying to allocate a buffer larger than the search space. */
1877 if (search_space_len
< search_buf_size
)
1878 search_buf_size
= search_space_len
;
1880 search_buf
= malloc (search_buf_size
);
1881 if (search_buf
== NULL
)
1882 error (_("Unable to allocate memory to perform the search."));
1883 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1885 /* Prime the search buffer. */
1887 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1888 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1890 warning (_("Unable to access target memory at %s, halting search."),
1891 hex_string (start_addr
));
1892 do_cleanups (old_cleanups
);
1896 /* Perform the search.
1898 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1899 When we've scanned N bytes we copy the trailing bytes to the start and
1900 read in another N bytes. */
1902 while (search_space_len
>= pattern_len
)
1904 gdb_byte
*found_ptr
;
1905 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1907 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1908 pattern
, pattern_len
);
1910 if (found_ptr
!= NULL
)
1912 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1913 *found_addrp
= found_addr
;
1914 do_cleanups (old_cleanups
);
1918 /* Not found in this chunk, skip to next chunk. */
1920 /* Don't let search_space_len wrap here, it's unsigned. */
1921 if (search_space_len
>= chunk_size
)
1922 search_space_len
-= chunk_size
;
1924 search_space_len
= 0;
1926 if (search_space_len
>= pattern_len
)
1928 unsigned keep_len
= search_buf_size
- chunk_size
;
1929 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1932 /* Copy the trailing part of the previous iteration to the front
1933 of the buffer for the next iteration. */
1934 gdb_assert (keep_len
== pattern_len
- 1);
1935 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1937 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1939 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1940 search_buf
+ keep_len
, read_addr
,
1941 nr_to_read
) != nr_to_read
)
1943 warning (_("Unable to access target memory at %s, halting search."),
1944 hex_string (read_addr
));
1945 do_cleanups (old_cleanups
);
1949 start_addr
+= chunk_size
;
1955 do_cleanups (old_cleanups
);
1959 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1960 sequence of bytes in PATTERN with length PATTERN_LEN.
1962 The result is 1 if found, 0 if not found, and -1 if there was an error
1963 requiring halting of the search (e.g. memory read error).
1964 If the pattern is found the address is recorded in FOUND_ADDRP. */
1967 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1968 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1969 CORE_ADDR
*found_addrp
)
1971 struct target_ops
*t
;
1974 /* We don't use INHERIT to set current_target.to_search_memory,
1975 so we have to scan the target stack and handle targetdebug
1979 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1980 hex_string (start_addr
));
1982 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1983 if (t
->to_search_memory
!= NULL
)
1988 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
1989 pattern
, pattern_len
, found_addrp
);
1993 /* If a special version of to_search_memory isn't available, use the
1995 found
= simple_search_memory (¤t_target
,
1996 start_addr
, search_space_len
,
1997 pattern
, pattern_len
, found_addrp
);
2001 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2006 /* Look through the currently pushed targets. If none of them will
2007 be able to restart the currently running process, issue an error
2011 target_require_runnable (void)
2013 struct target_ops
*t
;
2015 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2017 /* If this target knows how to create a new program, then
2018 assume we will still be able to after killing the current
2019 one. Either killing and mourning will not pop T, or else
2020 find_default_run_target will find it again. */
2021 if (t
->to_create_inferior
!= NULL
)
2024 /* Do not worry about thread_stratum targets that can not
2025 create inferiors. Assume they will be pushed again if
2026 necessary, and continue to the process_stratum. */
2027 if (t
->to_stratum
== thread_stratum
)
2031 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2035 /* This function is only called if the target is running. In that
2036 case there should have been a process_stratum target and it
2037 should either know how to create inferiors, or not... */
2038 internal_error (__FILE__
, __LINE__
, "No targets found");
2041 /* Look through the list of possible targets for a target that can
2042 execute a run or attach command without any other data. This is
2043 used to locate the default process stratum.
2045 If DO_MESG is not NULL, the result is always valid (error() is
2046 called for errors); else, return NULL on error. */
2048 static struct target_ops
*
2049 find_default_run_target (char *do_mesg
)
2051 struct target_ops
**t
;
2052 struct target_ops
*runable
= NULL
;
2057 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2060 if ((*t
)->to_can_run
&& target_can_run (*t
))
2070 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2079 find_default_attach (char *args
, int from_tty
)
2081 struct target_ops
*t
;
2083 t
= find_default_run_target ("attach");
2084 (t
->to_attach
) (args
, from_tty
);
2089 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2092 struct target_ops
*t
;
2094 t
= find_default_run_target ("run");
2095 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2100 find_default_can_async_p (void)
2102 struct target_ops
*t
;
2104 /* This may be called before the target is pushed on the stack;
2105 look for the default process stratum. If there's none, gdb isn't
2106 configured with a native debugger, and target remote isn't
2108 t
= find_default_run_target (NULL
);
2109 if (t
&& t
->to_can_async_p
)
2110 return (t
->to_can_async_p
) ();
2115 find_default_is_async_p (void)
2117 struct target_ops
*t
;
2119 /* This may be called before the target is pushed on the stack;
2120 look for the default process stratum. If there's none, gdb isn't
2121 configured with a native debugger, and target remote isn't
2123 t
= find_default_run_target (NULL
);
2124 if (t
&& t
->to_is_async_p
)
2125 return (t
->to_is_async_p
) ();
2130 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2132 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
2136 default_watchpoint_addr_within_range (struct target_ops
*target
,
2138 CORE_ADDR start
, int length
)
2140 return addr
>= start
&& addr
< start
+ length
;
2156 return_minus_one (void)
2162 * Resize the to_sections pointer. Also make sure that anyone that
2163 * was holding on to an old value of it gets updated.
2164 * Returns the old size.
2168 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2170 struct target_ops
**t
;
2171 struct section_table
*old_value
;
2174 old_value
= target
->to_sections
;
2176 if (target
->to_sections
)
2178 old_count
= target
->to_sections_end
- target
->to_sections
;
2179 target
->to_sections
= (struct section_table
*)
2180 xrealloc ((char *) target
->to_sections
,
2181 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2186 target
->to_sections
= (struct section_table
*)
2187 xmalloc ((sizeof (struct section_table
)) * num_added
);
2189 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2191 /* Check to see if anyone else was pointing to this structure.
2192 If old_value was null, then no one was. */
2196 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2199 if ((*t
)->to_sections
== old_value
)
2201 (*t
)->to_sections
= target
->to_sections
;
2202 (*t
)->to_sections_end
= target
->to_sections_end
;
2205 /* There is a flattened view of the target stack in current_target,
2206 so its to_sections pointer might also need updating. */
2207 if (current_target
.to_sections
== old_value
)
2209 current_target
.to_sections
= target
->to_sections
;
2210 current_target
.to_sections_end
= target
->to_sections_end
;
2218 /* Remove all target sections taken from ABFD.
2220 Scan the current target stack for targets whose section tables
2221 refer to sections from BFD, and remove those sections. We use this
2222 when we notice that the inferior has unloaded a shared object, for
2225 remove_target_sections (bfd
*abfd
)
2227 struct target_ops
**t
;
2229 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2231 struct section_table
*src
, *dest
;
2233 dest
= (*t
)->to_sections
;
2234 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2235 if (src
->bfd
!= abfd
)
2237 /* Keep this section. */
2238 if (dest
< src
) *dest
= *src
;
2242 /* If we've dropped any sections, resize the section table. */
2244 target_resize_to_sections (*t
, dest
- src
);
2251 /* Find a single runnable target in the stack and return it. If for
2252 some reason there is more than one, return NULL. */
2255 find_run_target (void)
2257 struct target_ops
**t
;
2258 struct target_ops
*runable
= NULL
;
2263 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2265 if ((*t
)->to_can_run
&& target_can_run (*t
))
2272 return (count
== 1 ? runable
: NULL
);
2275 /* Find a single core_stratum target in the list of targets and return it.
2276 If for some reason there is more than one, return NULL. */
2279 find_core_target (void)
2281 struct target_ops
**t
;
2282 struct target_ops
*runable
= NULL
;
2287 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2290 if ((*t
)->to_stratum
== core_stratum
)
2297 return (count
== 1 ? runable
: NULL
);
2301 * Find the next target down the stack from the specified target.
2305 find_target_beneath (struct target_ops
*t
)
2311 /* The inferior process has died. Long live the inferior! */
2314 generic_mourn_inferior (void)
2316 extern int show_breakpoint_hit_counts
;
2318 inferior_ptid
= null_ptid
;
2320 breakpoint_init_inferior (inf_exited
);
2321 registers_changed ();
2323 reopen_exec_file ();
2324 reinit_frame_cache ();
2326 /* It is confusing to the user for ignore counts to stick around
2327 from previous runs of the inferior. So clear them. */
2328 /* However, it is more confusing for the ignore counts to disappear when
2329 using hit counts. So don't clear them if we're counting hits. */
2330 if (!show_breakpoint_hit_counts
)
2331 breakpoint_clear_ignore_counts ();
2333 if (deprecated_detach_hook
)
2334 deprecated_detach_hook ();
2337 /* Helper function for child_wait and the derivatives of child_wait.
2338 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2339 translation of that in OURSTATUS. */
2341 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2343 if (WIFEXITED (hoststatus
))
2345 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2346 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2348 else if (!WIFSTOPPED (hoststatus
))
2350 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2351 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2355 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2356 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2360 /* Returns zero to leave the inferior alone, one to interrupt it. */
2361 int (*target_activity_function
) (void);
2362 int target_activity_fd
;
2364 /* Convert a normal process ID to a string. Returns the string in a
2368 normal_pid_to_str (ptid_t ptid
)
2370 static char buf
[32];
2372 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2376 /* Error-catcher for target_find_memory_regions */
2377 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2379 error (_("No target."));
2383 /* Error-catcher for target_make_corefile_notes */
2384 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2386 error (_("No target."));
2390 /* Set up the handful of non-empty slots needed by the dummy target
2394 init_dummy_target (void)
2396 dummy_target
.to_shortname
= "None";
2397 dummy_target
.to_longname
= "None";
2398 dummy_target
.to_doc
= "";
2399 dummy_target
.to_attach
= find_default_attach
;
2400 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2401 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2402 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2403 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2404 dummy_target
.to_stratum
= dummy_stratum
;
2405 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2406 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2407 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2408 dummy_target
.to_magic
= OPS_MAGIC
;
2412 debug_to_open (char *args
, int from_tty
)
2414 debug_target
.to_open (args
, from_tty
);
2416 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2420 debug_to_close (int quitting
)
2422 target_close (&debug_target
, quitting
);
2423 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2427 target_close (struct target_ops
*targ
, int quitting
)
2429 if (targ
->to_xclose
!= NULL
)
2430 targ
->to_xclose (targ
, quitting
);
2431 else if (targ
->to_close
!= NULL
)
2432 targ
->to_close (quitting
);
2436 debug_to_attach (char *args
, int from_tty
)
2438 debug_target
.to_attach (args
, from_tty
);
2440 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2445 debug_to_post_attach (int pid
)
2447 debug_target
.to_post_attach (pid
);
2449 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2453 debug_to_detach (char *args
, int from_tty
)
2455 debug_target
.to_detach (args
, from_tty
);
2457 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2461 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2463 debug_target
.to_resume (ptid
, step
, siggnal
);
2465 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2466 step
? "step" : "continue",
2467 target_signal_to_name (siggnal
));
2471 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2475 retval
= debug_target
.to_wait (ptid
, status
);
2477 fprintf_unfiltered (gdb_stdlog
,
2478 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2480 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2481 switch (status
->kind
)
2483 case TARGET_WAITKIND_EXITED
:
2484 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2485 status
->value
.integer
);
2487 case TARGET_WAITKIND_STOPPED
:
2488 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2489 target_signal_to_name (status
->value
.sig
));
2491 case TARGET_WAITKIND_SIGNALLED
:
2492 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2493 target_signal_to_name (status
->value
.sig
));
2495 case TARGET_WAITKIND_LOADED
:
2496 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2498 case TARGET_WAITKIND_FORKED
:
2499 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2501 case TARGET_WAITKIND_VFORKED
:
2502 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2504 case TARGET_WAITKIND_EXECD
:
2505 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2507 case TARGET_WAITKIND_SPURIOUS
:
2508 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2511 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2519 debug_print_register (const char * func
,
2520 struct regcache
*regcache
, int regno
)
2522 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2523 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2524 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2525 + gdbarch_num_pseudo_regs (gdbarch
)
2526 && gdbarch_register_name (gdbarch
, regno
) != NULL
2527 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2528 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2529 gdbarch_register_name (gdbarch
, regno
));
2531 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2534 int i
, size
= register_size (gdbarch
, regno
);
2535 unsigned char buf
[MAX_REGISTER_SIZE
];
2536 regcache_cooked_read (regcache
, regno
, buf
);
2537 fprintf_unfiltered (gdb_stdlog
, " = ");
2538 for (i
= 0; i
< size
; i
++)
2540 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2542 if (size
<= sizeof (LONGEST
))
2544 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2545 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2546 paddr_nz (val
), paddr_d (val
));
2549 fprintf_unfiltered (gdb_stdlog
, "\n");
2553 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2555 debug_target
.to_fetch_registers (regcache
, regno
);
2556 debug_print_register ("target_fetch_registers", regcache
, regno
);
2560 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2562 debug_target
.to_store_registers (regcache
, regno
);
2563 debug_print_register ("target_store_registers", regcache
, regno
);
2564 fprintf_unfiltered (gdb_stdlog
, "\n");
2568 debug_to_prepare_to_store (struct regcache
*regcache
)
2570 debug_target
.to_prepare_to_store (regcache
);
2572 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2576 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2577 int write
, struct mem_attrib
*attrib
,
2578 struct target_ops
*target
)
2582 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2585 fprintf_unfiltered (gdb_stdlog
,
2586 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2587 (unsigned int) memaddr
, /* possable truncate long long */
2588 len
, write
? "write" : "read", retval
);
2594 fputs_unfiltered (", bytes =", gdb_stdlog
);
2595 for (i
= 0; i
< retval
; i
++)
2597 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2599 if (targetdebug
< 2 && i
> 0)
2601 fprintf_unfiltered (gdb_stdlog
, " ...");
2604 fprintf_unfiltered (gdb_stdlog
, "\n");
2607 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2611 fputc_unfiltered ('\n', gdb_stdlog
);
2617 debug_to_files_info (struct target_ops
*target
)
2619 debug_target
.to_files_info (target
);
2621 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2625 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2629 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2631 fprintf_unfiltered (gdb_stdlog
,
2632 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2633 (unsigned long) bp_tgt
->placed_address
,
2634 (unsigned long) retval
);
2639 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2643 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2645 fprintf_unfiltered (gdb_stdlog
,
2646 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2647 (unsigned long) bp_tgt
->placed_address
,
2648 (unsigned long) retval
);
2653 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2657 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2659 fprintf_unfiltered (gdb_stdlog
,
2660 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2661 (unsigned long) type
,
2662 (unsigned long) cnt
,
2663 (unsigned long) from_tty
,
2664 (unsigned long) retval
);
2669 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2673 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2675 fprintf_unfiltered (gdb_stdlog
,
2676 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2677 (unsigned long) addr
,
2678 (unsigned long) len
,
2679 (unsigned long) retval
);
2684 debug_to_stopped_by_watchpoint (void)
2688 retval
= debug_target
.to_stopped_by_watchpoint ();
2690 fprintf_unfiltered (gdb_stdlog
,
2691 "STOPPED_BY_WATCHPOINT () = %ld\n",
2692 (unsigned long) retval
);
2697 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2701 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2703 fprintf_unfiltered (gdb_stdlog
,
2704 "target_stopped_data_address ([0x%lx]) = %ld\n",
2705 (unsigned long)*addr
,
2706 (unsigned long)retval
);
2711 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2713 CORE_ADDR start
, int length
)
2717 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2720 fprintf_filtered (gdb_stdlog
,
2721 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2722 (unsigned long) addr
, (unsigned long) start
, length
,
2728 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2732 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2734 fprintf_unfiltered (gdb_stdlog
,
2735 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2736 (unsigned long) bp_tgt
->placed_address
,
2737 (unsigned long) retval
);
2742 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2746 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2748 fprintf_unfiltered (gdb_stdlog
,
2749 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2750 (unsigned long) bp_tgt
->placed_address
,
2751 (unsigned long) retval
);
2756 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2760 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2762 fprintf_unfiltered (gdb_stdlog
,
2763 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2764 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2769 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2773 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2775 fprintf_unfiltered (gdb_stdlog
,
2776 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2777 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2782 debug_to_terminal_init (void)
2784 debug_target
.to_terminal_init ();
2786 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2790 debug_to_terminal_inferior (void)
2792 debug_target
.to_terminal_inferior ();
2794 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2798 debug_to_terminal_ours_for_output (void)
2800 debug_target
.to_terminal_ours_for_output ();
2802 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2806 debug_to_terminal_ours (void)
2808 debug_target
.to_terminal_ours ();
2810 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2814 debug_to_terminal_save_ours (void)
2816 debug_target
.to_terminal_save_ours ();
2818 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2822 debug_to_terminal_info (char *arg
, int from_tty
)
2824 debug_target
.to_terminal_info (arg
, from_tty
);
2826 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2831 debug_to_kill (void)
2833 debug_target
.to_kill ();
2835 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2839 debug_to_load (char *args
, int from_tty
)
2841 debug_target
.to_load (args
, from_tty
);
2843 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2847 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2851 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2853 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2859 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2862 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2864 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2865 exec_file
, args
, from_tty
);
2869 debug_to_post_startup_inferior (ptid_t ptid
)
2871 debug_target
.to_post_startup_inferior (ptid
);
2873 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2878 debug_to_acknowledge_created_inferior (int pid
)
2880 debug_target
.to_acknowledge_created_inferior (pid
);
2882 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2887 debug_to_insert_fork_catchpoint (int pid
)
2889 debug_target
.to_insert_fork_catchpoint (pid
);
2891 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2896 debug_to_remove_fork_catchpoint (int pid
)
2900 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2902 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2909 debug_to_insert_vfork_catchpoint (int pid
)
2911 debug_target
.to_insert_vfork_catchpoint (pid
);
2913 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2918 debug_to_remove_vfork_catchpoint (int pid
)
2922 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2924 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2931 debug_to_insert_exec_catchpoint (int pid
)
2933 debug_target
.to_insert_exec_catchpoint (pid
);
2935 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2940 debug_to_remove_exec_catchpoint (int pid
)
2944 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2946 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2953 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2957 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2959 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2960 pid
, wait_status
, *exit_status
, has_exited
);
2966 debug_to_mourn_inferior (void)
2968 debug_target
.to_mourn_inferior ();
2970 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2974 debug_to_can_run (void)
2978 retval
= debug_target
.to_can_run ();
2980 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2986 debug_to_notice_signals (ptid_t ptid
)
2988 debug_target
.to_notice_signals (ptid
);
2990 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2995 debug_to_thread_alive (ptid_t ptid
)
2999 retval
= debug_target
.to_thread_alive (ptid
);
3001 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3002 PIDGET (ptid
), retval
);
3008 debug_to_find_new_threads (void)
3010 debug_target
.to_find_new_threads ();
3012 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3016 debug_to_stop (ptid_t ptid
)
3018 debug_target
.to_stop (ptid
);
3020 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3021 target_pid_to_str (ptid
));
3025 debug_to_rcmd (char *command
,
3026 struct ui_file
*outbuf
)
3028 debug_target
.to_rcmd (command
, outbuf
);
3029 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3033 debug_to_pid_to_exec_file (int pid
)
3037 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3039 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3046 setup_target_debug (void)
3048 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3050 current_target
.to_open
= debug_to_open
;
3051 current_target
.to_close
= debug_to_close
;
3052 current_target
.to_attach
= debug_to_attach
;
3053 current_target
.to_post_attach
= debug_to_post_attach
;
3054 current_target
.to_detach
= debug_to_detach
;
3055 current_target
.to_resume
= debug_to_resume
;
3056 current_target
.to_wait
= debug_to_wait
;
3057 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3058 current_target
.to_store_registers
= debug_to_store_registers
;
3059 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3060 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3061 current_target
.to_files_info
= debug_to_files_info
;
3062 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3063 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3064 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3065 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3066 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3067 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3068 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3069 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3070 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3071 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3072 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3073 current_target
.to_terminal_init
= debug_to_terminal_init
;
3074 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3075 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3076 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3077 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3078 current_target
.to_terminal_info
= debug_to_terminal_info
;
3079 current_target
.to_kill
= debug_to_kill
;
3080 current_target
.to_load
= debug_to_load
;
3081 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3082 current_target
.to_create_inferior
= debug_to_create_inferior
;
3083 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3084 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3085 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3086 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3087 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3088 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3089 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3090 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3091 current_target
.to_has_exited
= debug_to_has_exited
;
3092 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3093 current_target
.to_can_run
= debug_to_can_run
;
3094 current_target
.to_notice_signals
= debug_to_notice_signals
;
3095 current_target
.to_thread_alive
= debug_to_thread_alive
;
3096 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3097 current_target
.to_stop
= debug_to_stop
;
3098 current_target
.to_rcmd
= debug_to_rcmd
;
3099 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3103 static char targ_desc
[] =
3104 "Names of targets and files being debugged.\n\
3105 Shows the entire stack of targets currently in use (including the exec-file,\n\
3106 core-file, and process, if any), as well as the symbol file name.";
3109 do_monitor_command (char *cmd
,
3112 if ((current_target
.to_rcmd
3113 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3114 || (current_target
.to_rcmd
== debug_to_rcmd
3115 && (debug_target
.to_rcmd
3116 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3117 error (_("\"monitor\" command not supported by this target."));
3118 target_rcmd (cmd
, gdb_stdtarg
);
3121 /* Print the name of each layers of our target stack. */
3124 maintenance_print_target_stack (char *cmd
, int from_tty
)
3126 struct target_ops
*t
;
3128 printf_filtered (_("The current target stack is:\n"));
3130 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3132 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3136 /* Controls if async mode is permitted. */
3137 int target_async_permitted
= 0;
3139 /* The set command writes to this variable. If the inferior is
3140 executing, linux_nat_async_permitted is *not* updated. */
3141 static int target_async_permitted_1
= 0;
3144 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3145 struct cmd_list_element
*c
)
3147 if (target_has_execution
)
3149 target_async_permitted_1
= target_async_permitted
;
3150 error (_("Cannot change this setting while the inferior is running."));
3153 target_async_permitted
= target_async_permitted_1
;
3157 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3158 struct cmd_list_element
*c
,
3161 fprintf_filtered (file
, _("\
3162 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3166 initialize_targets (void)
3168 init_dummy_target ();
3169 push_target (&dummy_target
);
3171 add_info ("target", target_info
, targ_desc
);
3172 add_info ("files", target_info
, targ_desc
);
3174 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3175 Set target debugging."), _("\
3176 Show target debugging."), _("\
3177 When non-zero, target debugging is enabled. Higher numbers are more\n\
3178 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3182 &setdebuglist
, &showdebuglist
);
3184 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3185 &trust_readonly
, _("\
3186 Set mode for reading from readonly sections."), _("\
3187 Show mode for reading from readonly sections."), _("\
3188 When this mode is on, memory reads from readonly sections (such as .text)\n\
3189 will be read from the object file instead of from the target. This will\n\
3190 result in significant performance improvement for remote targets."),
3192 show_trust_readonly
,
3193 &setlist
, &showlist
);
3195 add_com ("monitor", class_obscure
, do_monitor_command
,
3196 _("Send a command to the remote monitor (remote targets only)."));
3198 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3199 _("Print the name of each layer of the internal target stack."),
3200 &maintenanceprintlist
);
3202 add_setshow_boolean_cmd ("target-async", no_class
,
3203 &target_async_permitted_1
, _("\
3204 Set whether gdb controls the inferior in asynchronous mode."), _("\
3205 Show whether gdb controls the inferior in asynchronous mode."), _("\
3206 Tells gdb whether to control the inferior in asynchronous mode."),
3207 set_maintenance_target_async_permitted
,
3208 show_maintenance_target_async_permitted
,
3212 target_dcache
= dcache_init ();