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 (target_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 (target_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
), plongest (len
), plongest (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 find_default_supports_non_stop (void)
2132 struct target_ops
*t
;
2134 t
= find_default_run_target (NULL
);
2135 if (t
&& t
->to_supports_non_stop
)
2136 return (t
->to_supports_non_stop
) ();
2141 target_supports_non_stop ()
2143 struct target_ops
*t
;
2144 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2145 if (t
->to_supports_non_stop
)
2146 return t
->to_supports_non_stop ();
2153 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2155 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
2159 default_watchpoint_addr_within_range (struct target_ops
*target
,
2161 CORE_ADDR start
, int length
)
2163 return addr
>= start
&& addr
< start
+ length
;
2179 return_minus_one (void)
2185 * Resize the to_sections pointer. Also make sure that anyone that
2186 * was holding on to an old value of it gets updated.
2187 * Returns the old size.
2191 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2193 struct target_ops
**t
;
2194 struct section_table
*old_value
;
2197 old_value
= target
->to_sections
;
2199 if (target
->to_sections
)
2201 old_count
= target
->to_sections_end
- target
->to_sections
;
2202 target
->to_sections
= (struct section_table
*)
2203 xrealloc ((char *) target
->to_sections
,
2204 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2209 target
->to_sections
= (struct section_table
*)
2210 xmalloc ((sizeof (struct section_table
)) * num_added
);
2212 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2214 /* Check to see if anyone else was pointing to this structure.
2215 If old_value was null, then no one was. */
2219 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2222 if ((*t
)->to_sections
== old_value
)
2224 (*t
)->to_sections
= target
->to_sections
;
2225 (*t
)->to_sections_end
= target
->to_sections_end
;
2228 /* There is a flattened view of the target stack in current_target,
2229 so its to_sections pointer might also need updating. */
2230 if (current_target
.to_sections
== old_value
)
2232 current_target
.to_sections
= target
->to_sections
;
2233 current_target
.to_sections_end
= target
->to_sections_end
;
2241 /* Remove all target sections taken from ABFD.
2243 Scan the current target stack for targets whose section tables
2244 refer to sections from BFD, and remove those sections. We use this
2245 when we notice that the inferior has unloaded a shared object, for
2248 remove_target_sections (bfd
*abfd
)
2250 struct target_ops
**t
;
2252 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2254 struct section_table
*src
, *dest
;
2256 dest
= (*t
)->to_sections
;
2257 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2258 if (src
->bfd
!= abfd
)
2260 /* Keep this section. */
2261 if (dest
< src
) *dest
= *src
;
2265 /* If we've dropped any sections, resize the section table. */
2267 target_resize_to_sections (*t
, dest
- src
);
2274 /* Find a single runnable target in the stack and return it. If for
2275 some reason there is more than one, return NULL. */
2278 find_run_target (void)
2280 struct target_ops
**t
;
2281 struct target_ops
*runable
= NULL
;
2286 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2288 if ((*t
)->to_can_run
&& target_can_run (*t
))
2295 return (count
== 1 ? runable
: NULL
);
2298 /* Find a single core_stratum target in the list of targets and return it.
2299 If for some reason there is more than one, return NULL. */
2302 find_core_target (void)
2304 struct target_ops
**t
;
2305 struct target_ops
*runable
= NULL
;
2310 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2313 if ((*t
)->to_stratum
== core_stratum
)
2320 return (count
== 1 ? runable
: NULL
);
2324 * Find the next target down the stack from the specified target.
2328 find_target_beneath (struct target_ops
*t
)
2334 /* The inferior process has died. Long live the inferior! */
2337 generic_mourn_inferior (void)
2339 extern int show_breakpoint_hit_counts
;
2341 inferior_ptid
= null_ptid
;
2343 breakpoint_init_inferior (inf_exited
);
2344 registers_changed ();
2346 reopen_exec_file ();
2347 reinit_frame_cache ();
2349 /* It is confusing to the user for ignore counts to stick around
2350 from previous runs of the inferior. So clear them. */
2351 /* However, it is more confusing for the ignore counts to disappear when
2352 using hit counts. So don't clear them if we're counting hits. */
2353 if (!show_breakpoint_hit_counts
)
2354 breakpoint_clear_ignore_counts ();
2356 if (deprecated_detach_hook
)
2357 deprecated_detach_hook ();
2360 /* Helper function for child_wait and the derivatives of child_wait.
2361 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2362 translation of that in OURSTATUS. */
2364 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2366 if (WIFEXITED (hoststatus
))
2368 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2369 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2371 else if (!WIFSTOPPED (hoststatus
))
2373 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2374 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2378 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2379 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2383 /* Returns zero to leave the inferior alone, one to interrupt it. */
2384 int (*target_activity_function
) (void);
2385 int target_activity_fd
;
2387 /* Convert a normal process ID to a string. Returns the string in a
2391 normal_pid_to_str (ptid_t ptid
)
2393 static char buf
[32];
2395 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2399 /* Error-catcher for target_find_memory_regions */
2400 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2402 error (_("No target."));
2406 /* Error-catcher for target_make_corefile_notes */
2407 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2409 error (_("No target."));
2413 /* Set up the handful of non-empty slots needed by the dummy target
2417 init_dummy_target (void)
2419 dummy_target
.to_shortname
= "None";
2420 dummy_target
.to_longname
= "None";
2421 dummy_target
.to_doc
= "";
2422 dummy_target
.to_attach
= find_default_attach
;
2423 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2424 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2425 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2426 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2427 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2428 dummy_target
.to_stratum
= dummy_stratum
;
2429 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2430 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2431 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2432 dummy_target
.to_magic
= OPS_MAGIC
;
2436 debug_to_open (char *args
, int from_tty
)
2438 debug_target
.to_open (args
, from_tty
);
2440 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2444 debug_to_close (int quitting
)
2446 target_close (&debug_target
, quitting
);
2447 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2451 target_close (struct target_ops
*targ
, int quitting
)
2453 if (targ
->to_xclose
!= NULL
)
2454 targ
->to_xclose (targ
, quitting
);
2455 else if (targ
->to_close
!= NULL
)
2456 targ
->to_close (quitting
);
2460 debug_to_attach (char *args
, int from_tty
)
2462 debug_target
.to_attach (args
, from_tty
);
2464 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2469 debug_to_post_attach (int pid
)
2471 debug_target
.to_post_attach (pid
);
2473 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2477 debug_to_detach (char *args
, int from_tty
)
2479 debug_target
.to_detach (args
, from_tty
);
2481 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2485 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2487 debug_target
.to_resume (ptid
, step
, siggnal
);
2489 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2490 step
? "step" : "continue",
2491 target_signal_to_name (siggnal
));
2495 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2499 retval
= debug_target
.to_wait (ptid
, status
);
2501 fprintf_unfiltered (gdb_stdlog
,
2502 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2504 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2505 switch (status
->kind
)
2507 case TARGET_WAITKIND_EXITED
:
2508 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2509 status
->value
.integer
);
2511 case TARGET_WAITKIND_STOPPED
:
2512 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2513 target_signal_to_name (status
->value
.sig
));
2515 case TARGET_WAITKIND_SIGNALLED
:
2516 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2517 target_signal_to_name (status
->value
.sig
));
2519 case TARGET_WAITKIND_LOADED
:
2520 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2522 case TARGET_WAITKIND_FORKED
:
2523 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2525 case TARGET_WAITKIND_VFORKED
:
2526 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2528 case TARGET_WAITKIND_EXECD
:
2529 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2531 case TARGET_WAITKIND_SPURIOUS
:
2532 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2535 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2543 debug_print_register (const char * func
,
2544 struct regcache
*regcache
, int regno
)
2546 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2547 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2548 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2549 && gdbarch_register_name (gdbarch
, regno
) != NULL
2550 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2551 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2552 gdbarch_register_name (gdbarch
, regno
));
2554 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2555 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2557 int i
, size
= register_size (gdbarch
, regno
);
2558 unsigned char buf
[MAX_REGISTER_SIZE
];
2559 regcache_raw_collect (regcache
, regno
, buf
);
2560 fprintf_unfiltered (gdb_stdlog
, " = ");
2561 for (i
= 0; i
< size
; i
++)
2563 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2565 if (size
<= sizeof (LONGEST
))
2567 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2568 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2569 paddr_nz (val
), plongest (val
));
2572 fprintf_unfiltered (gdb_stdlog
, "\n");
2576 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2578 debug_target
.to_fetch_registers (regcache
, regno
);
2579 debug_print_register ("target_fetch_registers", regcache
, regno
);
2583 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2585 debug_target
.to_store_registers (regcache
, regno
);
2586 debug_print_register ("target_store_registers", regcache
, regno
);
2587 fprintf_unfiltered (gdb_stdlog
, "\n");
2591 debug_to_prepare_to_store (struct regcache
*regcache
)
2593 debug_target
.to_prepare_to_store (regcache
);
2595 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2599 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2600 int write
, struct mem_attrib
*attrib
,
2601 struct target_ops
*target
)
2605 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2608 fprintf_unfiltered (gdb_stdlog
,
2609 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2610 (unsigned int) memaddr
, /* possable truncate long long */
2611 len
, write
? "write" : "read", retval
);
2617 fputs_unfiltered (", bytes =", gdb_stdlog
);
2618 for (i
= 0; i
< retval
; i
++)
2620 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2622 if (targetdebug
< 2 && i
> 0)
2624 fprintf_unfiltered (gdb_stdlog
, " ...");
2627 fprintf_unfiltered (gdb_stdlog
, "\n");
2630 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2634 fputc_unfiltered ('\n', gdb_stdlog
);
2640 debug_to_files_info (struct target_ops
*target
)
2642 debug_target
.to_files_info (target
);
2644 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2648 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2652 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2654 fprintf_unfiltered (gdb_stdlog
,
2655 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2656 (unsigned long) bp_tgt
->placed_address
,
2657 (unsigned long) retval
);
2662 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2666 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2668 fprintf_unfiltered (gdb_stdlog
,
2669 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2670 (unsigned long) bp_tgt
->placed_address
,
2671 (unsigned long) retval
);
2676 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2680 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2682 fprintf_unfiltered (gdb_stdlog
,
2683 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2684 (unsigned long) type
,
2685 (unsigned long) cnt
,
2686 (unsigned long) from_tty
,
2687 (unsigned long) retval
);
2692 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2696 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2698 fprintf_unfiltered (gdb_stdlog
,
2699 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2700 (unsigned long) addr
,
2701 (unsigned long) len
,
2702 (unsigned long) retval
);
2707 debug_to_stopped_by_watchpoint (void)
2711 retval
= debug_target
.to_stopped_by_watchpoint ();
2713 fprintf_unfiltered (gdb_stdlog
,
2714 "STOPPED_BY_WATCHPOINT () = %ld\n",
2715 (unsigned long) retval
);
2720 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2724 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2726 fprintf_unfiltered (gdb_stdlog
,
2727 "target_stopped_data_address ([0x%lx]) = %ld\n",
2728 (unsigned long)*addr
,
2729 (unsigned long)retval
);
2734 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2736 CORE_ADDR start
, int length
)
2740 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2743 fprintf_filtered (gdb_stdlog
,
2744 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2745 (unsigned long) addr
, (unsigned long) start
, length
,
2751 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2755 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2757 fprintf_unfiltered (gdb_stdlog
,
2758 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2759 (unsigned long) bp_tgt
->placed_address
,
2760 (unsigned long) retval
);
2765 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2769 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2771 fprintf_unfiltered (gdb_stdlog
,
2772 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2773 (unsigned long) bp_tgt
->placed_address
,
2774 (unsigned long) retval
);
2779 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2783 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2785 fprintf_unfiltered (gdb_stdlog
,
2786 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2787 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2792 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2796 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2798 fprintf_unfiltered (gdb_stdlog
,
2799 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2800 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2805 debug_to_terminal_init (void)
2807 debug_target
.to_terminal_init ();
2809 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2813 debug_to_terminal_inferior (void)
2815 debug_target
.to_terminal_inferior ();
2817 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2821 debug_to_terminal_ours_for_output (void)
2823 debug_target
.to_terminal_ours_for_output ();
2825 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2829 debug_to_terminal_ours (void)
2831 debug_target
.to_terminal_ours ();
2833 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2837 debug_to_terminal_save_ours (void)
2839 debug_target
.to_terminal_save_ours ();
2841 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2845 debug_to_terminal_info (char *arg
, int from_tty
)
2847 debug_target
.to_terminal_info (arg
, from_tty
);
2849 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2854 debug_to_kill (void)
2856 debug_target
.to_kill ();
2858 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2862 debug_to_load (char *args
, int from_tty
)
2864 debug_target
.to_load (args
, from_tty
);
2866 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2870 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2874 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2876 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2882 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2885 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2887 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2888 exec_file
, args
, from_tty
);
2892 debug_to_post_startup_inferior (ptid_t ptid
)
2894 debug_target
.to_post_startup_inferior (ptid
);
2896 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2901 debug_to_acknowledge_created_inferior (int pid
)
2903 debug_target
.to_acknowledge_created_inferior (pid
);
2905 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2910 debug_to_insert_fork_catchpoint (int pid
)
2912 debug_target
.to_insert_fork_catchpoint (pid
);
2914 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2919 debug_to_remove_fork_catchpoint (int pid
)
2923 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2925 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2932 debug_to_insert_vfork_catchpoint (int pid
)
2934 debug_target
.to_insert_vfork_catchpoint (pid
);
2936 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2941 debug_to_remove_vfork_catchpoint (int pid
)
2945 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2947 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2954 debug_to_insert_exec_catchpoint (int pid
)
2956 debug_target
.to_insert_exec_catchpoint (pid
);
2958 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2963 debug_to_remove_exec_catchpoint (int pid
)
2967 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2969 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2976 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2980 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2982 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2983 pid
, wait_status
, *exit_status
, has_exited
);
2989 debug_to_mourn_inferior (void)
2991 debug_target
.to_mourn_inferior ();
2993 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2997 debug_to_can_run (void)
3001 retval
= debug_target
.to_can_run ();
3003 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3009 debug_to_notice_signals (ptid_t ptid
)
3011 debug_target
.to_notice_signals (ptid
);
3013 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3018 debug_to_thread_alive (ptid_t ptid
)
3022 retval
= debug_target
.to_thread_alive (ptid
);
3024 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3025 PIDGET (ptid
), retval
);
3031 debug_to_find_new_threads (void)
3033 debug_target
.to_find_new_threads ();
3035 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3039 debug_to_stop (ptid_t ptid
)
3041 debug_target
.to_stop (ptid
);
3043 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3044 target_pid_to_str (ptid
));
3048 debug_to_rcmd (char *command
,
3049 struct ui_file
*outbuf
)
3051 debug_target
.to_rcmd (command
, outbuf
);
3052 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3056 debug_to_pid_to_exec_file (int pid
)
3060 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3062 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3069 setup_target_debug (void)
3071 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3073 current_target
.to_open
= debug_to_open
;
3074 current_target
.to_close
= debug_to_close
;
3075 current_target
.to_attach
= debug_to_attach
;
3076 current_target
.to_post_attach
= debug_to_post_attach
;
3077 current_target
.to_detach
= debug_to_detach
;
3078 current_target
.to_resume
= debug_to_resume
;
3079 current_target
.to_wait
= debug_to_wait
;
3080 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3081 current_target
.to_store_registers
= debug_to_store_registers
;
3082 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3083 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3084 current_target
.to_files_info
= debug_to_files_info
;
3085 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3086 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3087 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3088 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3089 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3090 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3091 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3092 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3093 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3094 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3095 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3096 current_target
.to_terminal_init
= debug_to_terminal_init
;
3097 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3098 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3099 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3100 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3101 current_target
.to_terminal_info
= debug_to_terminal_info
;
3102 current_target
.to_kill
= debug_to_kill
;
3103 current_target
.to_load
= debug_to_load
;
3104 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3105 current_target
.to_create_inferior
= debug_to_create_inferior
;
3106 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3107 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3108 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3109 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3110 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3111 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3112 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3113 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3114 current_target
.to_has_exited
= debug_to_has_exited
;
3115 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3116 current_target
.to_can_run
= debug_to_can_run
;
3117 current_target
.to_notice_signals
= debug_to_notice_signals
;
3118 current_target
.to_thread_alive
= debug_to_thread_alive
;
3119 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3120 current_target
.to_stop
= debug_to_stop
;
3121 current_target
.to_rcmd
= debug_to_rcmd
;
3122 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3126 static char targ_desc
[] =
3127 "Names of targets and files being debugged.\n\
3128 Shows the entire stack of targets currently in use (including the exec-file,\n\
3129 core-file, and process, if any), as well as the symbol file name.";
3132 do_monitor_command (char *cmd
,
3135 if ((current_target
.to_rcmd
3136 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3137 || (current_target
.to_rcmd
== debug_to_rcmd
3138 && (debug_target
.to_rcmd
3139 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3140 error (_("\"monitor\" command not supported by this target."));
3141 target_rcmd (cmd
, gdb_stdtarg
);
3144 /* Print the name of each layers of our target stack. */
3147 maintenance_print_target_stack (char *cmd
, int from_tty
)
3149 struct target_ops
*t
;
3151 printf_filtered (_("The current target stack is:\n"));
3153 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3155 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3159 /* Controls if async mode is permitted. */
3160 int target_async_permitted
= 0;
3162 /* The set command writes to this variable. If the inferior is
3163 executing, linux_nat_async_permitted is *not* updated. */
3164 static int target_async_permitted_1
= 0;
3167 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3168 struct cmd_list_element
*c
)
3170 if (target_has_execution
)
3172 target_async_permitted_1
= target_async_permitted
;
3173 error (_("Cannot change this setting while the inferior is running."));
3176 target_async_permitted
= target_async_permitted_1
;
3180 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3181 struct cmd_list_element
*c
,
3184 fprintf_filtered (file
, _("\
3185 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3189 initialize_targets (void)
3191 init_dummy_target ();
3192 push_target (&dummy_target
);
3194 add_info ("target", target_info
, targ_desc
);
3195 add_info ("files", target_info
, targ_desc
);
3197 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3198 Set target debugging."), _("\
3199 Show target debugging."), _("\
3200 When non-zero, target debugging is enabled. Higher numbers are more\n\
3201 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3205 &setdebuglist
, &showdebuglist
);
3207 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3208 &trust_readonly
, _("\
3209 Set mode for reading from readonly sections."), _("\
3210 Show mode for reading from readonly sections."), _("\
3211 When this mode is on, memory reads from readonly sections (such as .text)\n\
3212 will be read from the object file instead of from the target. This will\n\
3213 result in significant performance improvement for remote targets."),
3215 show_trust_readonly
,
3216 &setlist
, &showlist
);
3218 add_com ("monitor", class_obscure
, do_monitor_command
,
3219 _("Send a command to the remote monitor (remote targets only)."));
3221 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3222 _("Print the name of each layer of the internal target stack."),
3223 &maintenanceprintlist
);
3225 add_setshow_boolean_cmd ("target-async", no_class
,
3226 &target_async_permitted_1
, _("\
3227 Set whether gdb controls the inferior in asynchronous mode."), _("\
3228 Show whether gdb controls the inferior in asynchronous mode."), _("\
3229 Tells gdb whether to control the inferior in asynchronous mode."),
3230 set_maintenance_target_async_permitted
,
3231 show_maintenance_target_async_permitted
,
3235 target_dcache
= dcache_init ();