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 /* Do not inherit to_open. */
389 /* Do not inherit to_close. */
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 (target_stack
, 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 (target_stack
, quitting
);
803 if (!unpush_target (target_stack
))
805 fprintf_unfiltered (gdb_stderr
,
806 "pop_all_targets couldn't find target %s\n",
807 target_stack
->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 struct obj_section
*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, %s, %s) = %s",
1174 (annex
? annex
: "(null)"),
1175 (long) readbuf
, (long) writebuf
,
1176 core_addr_to_string_nz (offset
),
1177 plongest (len
), plongest (retval
));
1183 if (retval
> 0 && myaddr
!= NULL
)
1187 fputs_unfiltered (", bytes =", gdb_stdlog
);
1188 for (i
= 0; i
< retval
; i
++)
1190 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1192 if (targetdebug
< 2 && i
> 0)
1194 fprintf_unfiltered (gdb_stdlog
, " ...");
1197 fprintf_unfiltered (gdb_stdlog
, "\n");
1200 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1204 fputc_unfiltered ('\n', gdb_stdlog
);
1209 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1210 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1211 if any error occurs.
1213 If an error occurs, no guarantee is made about the contents of the data at
1214 MYADDR. In particular, the caller should not depend upon partial reads
1215 filling the buffer with good data. There is no way for the caller to know
1216 how much good data might have been transfered anyway. Callers that can
1217 deal with partial reads should call target_read (which will retry until
1218 it makes no progress, and then return how much was transferred). */
1221 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1223 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1224 myaddr
, memaddr
, len
) == len
)
1231 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1233 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1234 myaddr
, memaddr
, len
) == len
)
1240 /* Fetch the target's memory map. */
1243 target_memory_map (void)
1245 VEC(mem_region_s
) *result
;
1246 struct mem_region
*last_one
, *this_one
;
1248 struct target_ops
*t
;
1251 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1253 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1254 if (t
->to_memory_map
!= NULL
)
1260 result
= t
->to_memory_map (t
);
1264 qsort (VEC_address (mem_region_s
, result
),
1265 VEC_length (mem_region_s
, result
),
1266 sizeof (struct mem_region
), mem_region_cmp
);
1268 /* Check that regions do not overlap. Simultaneously assign
1269 a numbering for the "mem" commands to use to refer to
1272 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1274 this_one
->number
= ix
;
1276 if (last_one
&& last_one
->hi
> this_one
->lo
)
1278 warning (_("Overlapping regions in memory map: ignoring"));
1279 VEC_free (mem_region_s
, result
);
1282 last_one
= this_one
;
1289 target_flash_erase (ULONGEST address
, LONGEST length
)
1291 struct target_ops
*t
;
1293 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1294 if (t
->to_flash_erase
!= NULL
)
1297 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1298 paddr (address
), phex (length
, 0));
1299 t
->to_flash_erase (t
, address
, length
);
1307 target_flash_done (void)
1309 struct target_ops
*t
;
1311 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1312 if (t
->to_flash_done
!= NULL
)
1315 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1316 t
->to_flash_done (t
);
1323 #ifndef target_stopped_data_address_p
1325 target_stopped_data_address_p (struct target_ops
*target
)
1327 if (target
->to_stopped_data_address
1328 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1330 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1331 && (debug_target
.to_stopped_data_address
1332 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1339 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1340 struct cmd_list_element
*c
, const char *value
)
1342 fprintf_filtered (file
, _("\
1343 Mode for reading from readonly sections is %s.\n"),
1347 /* More generic transfers. */
1350 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1351 const char *annex
, gdb_byte
*readbuf
,
1352 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1354 if (object
== TARGET_OBJECT_MEMORY
1355 && ops
->deprecated_xfer_memory
!= NULL
)
1356 /* If available, fall back to the target's
1357 "deprecated_xfer_memory" method. */
1361 if (writebuf
!= NULL
)
1363 void *buffer
= xmalloc (len
);
1364 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1365 memcpy (buffer
, writebuf
, len
);
1366 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1367 1/*write*/, NULL
, ops
);
1368 do_cleanups (cleanup
);
1370 if (readbuf
!= NULL
)
1371 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1372 0/*read*/, NULL
, ops
);
1375 else if (xfered
== 0 && errno
== 0)
1376 /* "deprecated_xfer_memory" uses 0, cross checked against
1377 ERRNO as one indication of an error. */
1382 else if (ops
->beneath
!= NULL
)
1383 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1384 readbuf
, writebuf
, offset
, len
);
1389 /* The xfer_partial handler for the topmost target. Unlike the default,
1390 it does not need to handle memory specially; it just passes all
1391 requests down the stack. */
1394 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1395 const char *annex
, gdb_byte
*readbuf
,
1396 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1398 if (ops
->beneath
!= NULL
)
1399 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1400 readbuf
, writebuf
, offset
, len
);
1405 /* Target vector read/write partial wrapper functions.
1407 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1408 (inbuf, outbuf)", instead of separate read/write methods, make life
1412 target_read_partial (struct target_ops
*ops
,
1413 enum target_object object
,
1414 const char *annex
, gdb_byte
*buf
,
1415 ULONGEST offset
, LONGEST len
)
1417 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1421 target_write_partial (struct target_ops
*ops
,
1422 enum target_object object
,
1423 const char *annex
, const gdb_byte
*buf
,
1424 ULONGEST offset
, LONGEST len
)
1426 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1429 /* Wrappers to perform the full transfer. */
1431 target_read (struct target_ops
*ops
,
1432 enum target_object object
,
1433 const char *annex
, gdb_byte
*buf
,
1434 ULONGEST offset
, LONGEST len
)
1437 while (xfered
< len
)
1439 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1440 (gdb_byte
*) buf
+ xfered
,
1441 offset
+ xfered
, len
- xfered
);
1442 /* Call an observer, notifying them of the xfer progress? */
1454 target_read_until_error (struct target_ops
*ops
,
1455 enum target_object object
,
1456 const char *annex
, gdb_byte
*buf
,
1457 ULONGEST offset
, LONGEST len
)
1460 while (xfered
< len
)
1462 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1463 (gdb_byte
*) buf
+ xfered
,
1464 offset
+ xfered
, len
- xfered
);
1465 /* Call an observer, notifying them of the xfer progress? */
1470 /* We've got an error. Try to read in smaller blocks. */
1471 ULONGEST start
= offset
+ xfered
;
1472 ULONGEST remaining
= len
- xfered
;
1475 /* If an attempt was made to read a random memory address,
1476 it's likely that the very first byte is not accessible.
1477 Try reading the first byte, to avoid doing log N tries
1479 xfer
= target_read_partial (ops
, object
, annex
,
1480 (gdb_byte
*) buf
+ xfered
, start
, 1);
1489 xfer
= target_read_partial (ops
, object
, annex
,
1490 (gdb_byte
*) buf
+ xfered
,
1500 /* We have successfully read the first half. So, the
1501 error must be in the second half. Adjust start and
1502 remaining to point at the second half. */
1519 /* An alternative to target_write with progress callbacks. */
1522 target_write_with_progress (struct target_ops
*ops
,
1523 enum target_object object
,
1524 const char *annex
, const gdb_byte
*buf
,
1525 ULONGEST offset
, LONGEST len
,
1526 void (*progress
) (ULONGEST
, void *), void *baton
)
1530 /* Give the progress callback a chance to set up. */
1532 (*progress
) (0, baton
);
1534 while (xfered
< len
)
1536 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1537 (gdb_byte
*) buf
+ xfered
,
1538 offset
+ xfered
, len
- xfered
);
1546 (*progress
) (xfer
, baton
);
1555 target_write (struct target_ops
*ops
,
1556 enum target_object object
,
1557 const char *annex
, const gdb_byte
*buf
,
1558 ULONGEST offset
, LONGEST len
)
1560 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1564 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1565 the size of the transferred data. PADDING additional bytes are
1566 available in *BUF_P. This is a helper function for
1567 target_read_alloc; see the declaration of that function for more
1571 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1572 const char *annex
, gdb_byte
**buf_p
, int padding
)
1574 size_t buf_alloc
, buf_pos
;
1578 /* This function does not have a length parameter; it reads the
1579 entire OBJECT). Also, it doesn't support objects fetched partly
1580 from one target and partly from another (in a different stratum,
1581 e.g. a core file and an executable). Both reasons make it
1582 unsuitable for reading memory. */
1583 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1585 /* Start by reading up to 4K at a time. The target will throttle
1586 this number down if necessary. */
1588 buf
= xmalloc (buf_alloc
);
1592 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1593 buf_pos
, buf_alloc
- buf_pos
- padding
);
1596 /* An error occurred. */
1602 /* Read all there was. */
1612 /* If the buffer is filling up, expand it. */
1613 if (buf_alloc
< buf_pos
* 2)
1616 buf
= xrealloc (buf
, buf_alloc
);
1623 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1624 the size of the transferred data. See the declaration in "target.h"
1625 function for more information about the return value. */
1628 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1629 const char *annex
, gdb_byte
**buf_p
)
1631 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1634 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1635 returned as a string, allocated using xmalloc. If an error occurs
1636 or the transfer is unsupported, NULL is returned. Empty objects
1637 are returned as allocated but empty strings. A warning is issued
1638 if the result contains any embedded NUL bytes. */
1641 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1645 LONGEST transferred
;
1647 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1649 if (transferred
< 0)
1652 if (transferred
== 0)
1653 return xstrdup ("");
1655 buffer
[transferred
] = 0;
1656 if (strlen (buffer
) < transferred
)
1657 warning (_("target object %d, annex %s, "
1658 "contained unexpected null characters"),
1659 (int) object
, annex
? annex
: "(none)");
1661 return (char *) buffer
;
1664 /* Memory transfer methods. */
1667 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1670 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1672 memory_error (EIO
, addr
);
1676 get_target_memory_unsigned (struct target_ops
*ops
,
1677 CORE_ADDR addr
, int len
)
1679 gdb_byte buf
[sizeof (ULONGEST
)];
1681 gdb_assert (len
<= sizeof (buf
));
1682 get_target_memory (ops
, addr
, buf
, len
);
1683 return extract_unsigned_integer (buf
, len
);
1687 target_info (char *args
, int from_tty
)
1689 struct target_ops
*t
;
1690 int has_all_mem
= 0;
1692 if (symfile_objfile
!= NULL
)
1693 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1695 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1697 if (!t
->to_has_memory
)
1700 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1703 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1704 printf_unfiltered ("%s:\n", t
->to_longname
);
1705 (t
->to_files_info
) (t
);
1706 has_all_mem
= t
->to_has_all_memory
;
1710 /* This function is called before any new inferior is created, e.g.
1711 by running a program, attaching, or connecting to a target.
1712 It cleans up any state from previous invocations which might
1713 change between runs. This is a subset of what target_preopen
1714 resets (things which might change between targets). */
1717 target_pre_inferior (int from_tty
)
1719 /* Clear out solib state. Otherwise the solib state of the previous
1720 inferior might have survived and is entirely wrong for the new
1721 target. This has been observed on GNU/Linux using glibc 2.3. How
1733 Cannot access memory at address 0xdeadbeef
1735 no_shared_libraries (NULL
, from_tty
);
1737 invalidate_target_mem_regions ();
1739 target_clear_description ();
1742 /* This is to be called by the open routine before it does
1746 target_preopen (int from_tty
)
1750 if (target_has_execution
)
1753 || query (_("A program is being debugged already. Kill it? ")))
1756 error (_("Program not killed."));
1759 /* Calling target_kill may remove the target from the stack. But if
1760 it doesn't (which seems like a win for UDI), remove it now. */
1761 /* Leave the exec target, though. The user may be switching from a
1762 live process to a core of the same program. */
1763 pop_all_targets_above (file_stratum
, 0);
1765 target_pre_inferior (from_tty
);
1768 /* Detach a target after doing deferred register stores. */
1771 target_detach (char *args
, int from_tty
)
1773 /* If we're in breakpoints-always-inserted mode, have to
1774 remove them before detaching. */
1775 remove_breakpoints ();
1777 (current_target
.to_detach
) (args
, from_tty
);
1781 target_disconnect (char *args
, int from_tty
)
1783 struct target_ops
*t
;
1785 /* If we're in breakpoints-always-inserted mode, have to
1786 remove them before disconnecting. */
1787 remove_breakpoints ();
1789 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1790 if (t
->to_disconnect
!= NULL
)
1793 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1795 t
->to_disconnect (t
, args
, from_tty
);
1803 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1805 dcache_invalidate (target_dcache
);
1806 (*current_target
.to_resume
) (ptid
, step
, signal
);
1807 set_executing (ptid
, 1);
1808 set_running (ptid
, 1);
1810 /* Look through the list of possible targets for a target that can
1814 target_follow_fork (int follow_child
)
1816 struct target_ops
*t
;
1818 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1820 if (t
->to_follow_fork
!= NULL
)
1822 int retval
= t
->to_follow_fork (t
, follow_child
);
1824 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1825 follow_child
, retval
);
1830 /* Some target returned a fork event, but did not know how to follow it. */
1831 internal_error (__FILE__
, __LINE__
,
1832 "could not find a target to follow fork");
1835 /* Look for a target which can describe architectural features, starting
1836 from TARGET. If we find one, return its description. */
1838 const struct target_desc
*
1839 target_read_description (struct target_ops
*target
)
1841 struct target_ops
*t
;
1843 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1844 if (t
->to_read_description
!= NULL
)
1846 const struct target_desc
*tdesc
;
1848 tdesc
= t
->to_read_description (t
);
1856 /* The default implementation of to_search_memory.
1857 This implements a basic search of memory, reading target memory and
1858 performing the search here (as opposed to performing the search in on the
1859 target side with, for example, gdbserver). */
1862 simple_search_memory (struct target_ops
*ops
,
1863 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1864 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1865 CORE_ADDR
*found_addrp
)
1867 /* NOTE: also defined in find.c testcase. */
1868 #define SEARCH_CHUNK_SIZE 16000
1869 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1870 /* Buffer to hold memory contents for searching. */
1871 gdb_byte
*search_buf
;
1872 unsigned search_buf_size
;
1873 struct cleanup
*old_cleanups
;
1875 search_buf_size
= chunk_size
+ pattern_len
- 1;
1877 /* No point in trying to allocate a buffer larger than the search space. */
1878 if (search_space_len
< search_buf_size
)
1879 search_buf_size
= search_space_len
;
1881 search_buf
= malloc (search_buf_size
);
1882 if (search_buf
== NULL
)
1883 error (_("Unable to allocate memory to perform the search."));
1884 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1886 /* Prime the search buffer. */
1888 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1889 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1891 warning (_("Unable to access target memory at %s, halting search."),
1892 hex_string (start_addr
));
1893 do_cleanups (old_cleanups
);
1897 /* Perform the search.
1899 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1900 When we've scanned N bytes we copy the trailing bytes to the start and
1901 read in another N bytes. */
1903 while (search_space_len
>= pattern_len
)
1905 gdb_byte
*found_ptr
;
1906 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1908 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1909 pattern
, pattern_len
);
1911 if (found_ptr
!= NULL
)
1913 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1914 *found_addrp
= found_addr
;
1915 do_cleanups (old_cleanups
);
1919 /* Not found in this chunk, skip to next chunk. */
1921 /* Don't let search_space_len wrap here, it's unsigned. */
1922 if (search_space_len
>= chunk_size
)
1923 search_space_len
-= chunk_size
;
1925 search_space_len
= 0;
1927 if (search_space_len
>= pattern_len
)
1929 unsigned keep_len
= search_buf_size
- chunk_size
;
1930 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1933 /* Copy the trailing part of the previous iteration to the front
1934 of the buffer for the next iteration. */
1935 gdb_assert (keep_len
== pattern_len
- 1);
1936 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1938 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1940 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1941 search_buf
+ keep_len
, read_addr
,
1942 nr_to_read
) != nr_to_read
)
1944 warning (_("Unable to access target memory at %s, halting search."),
1945 hex_string (read_addr
));
1946 do_cleanups (old_cleanups
);
1950 start_addr
+= chunk_size
;
1956 do_cleanups (old_cleanups
);
1960 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1961 sequence of bytes in PATTERN with length PATTERN_LEN.
1963 The result is 1 if found, 0 if not found, and -1 if there was an error
1964 requiring halting of the search (e.g. memory read error).
1965 If the pattern is found the address is recorded in FOUND_ADDRP. */
1968 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1969 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1970 CORE_ADDR
*found_addrp
)
1972 struct target_ops
*t
;
1975 /* We don't use INHERIT to set current_target.to_search_memory,
1976 so we have to scan the target stack and handle targetdebug
1980 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1981 hex_string (start_addr
));
1983 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1984 if (t
->to_search_memory
!= NULL
)
1989 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
1990 pattern
, pattern_len
, found_addrp
);
1994 /* If a special version of to_search_memory isn't available, use the
1996 found
= simple_search_memory (¤t_target
,
1997 start_addr
, search_space_len
,
1998 pattern
, pattern_len
, found_addrp
);
2002 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2007 /* Look through the currently pushed targets. If none of them will
2008 be able to restart the currently running process, issue an error
2012 target_require_runnable (void)
2014 struct target_ops
*t
;
2016 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2018 /* If this target knows how to create a new program, then
2019 assume we will still be able to after killing the current
2020 one. Either killing and mourning will not pop T, or else
2021 find_default_run_target will find it again. */
2022 if (t
->to_create_inferior
!= NULL
)
2025 /* Do not worry about thread_stratum targets that can not
2026 create inferiors. Assume they will be pushed again if
2027 necessary, and continue to the process_stratum. */
2028 if (t
->to_stratum
== thread_stratum
)
2032 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2036 /* This function is only called if the target is running. In that
2037 case there should have been a process_stratum target and it
2038 should either know how to create inferiors, or not... */
2039 internal_error (__FILE__
, __LINE__
, "No targets found");
2042 /* Look through the list of possible targets for a target that can
2043 execute a run or attach command without any other data. This is
2044 used to locate the default process stratum.
2046 If DO_MESG is not NULL, the result is always valid (error() is
2047 called for errors); else, return NULL on error. */
2049 static struct target_ops
*
2050 find_default_run_target (char *do_mesg
)
2052 struct target_ops
**t
;
2053 struct target_ops
*runable
= NULL
;
2058 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2061 if ((*t
)->to_can_run
&& target_can_run (*t
))
2071 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2080 find_default_attach (char *args
, int from_tty
)
2082 struct target_ops
*t
;
2084 t
= find_default_run_target ("attach");
2085 (t
->to_attach
) (args
, from_tty
);
2090 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2093 struct target_ops
*t
;
2095 t
= find_default_run_target ("run");
2096 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2101 find_default_can_async_p (void)
2103 struct target_ops
*t
;
2105 /* This may be called before the target is pushed on the stack;
2106 look for the default process stratum. If there's none, gdb isn't
2107 configured with a native debugger, and target remote isn't
2109 t
= find_default_run_target (NULL
);
2110 if (t
&& t
->to_can_async_p
)
2111 return (t
->to_can_async_p
) ();
2116 find_default_is_async_p (void)
2118 struct target_ops
*t
;
2120 /* This may be called before the target is pushed on the stack;
2121 look for the default process stratum. If there's none, gdb isn't
2122 configured with a native debugger, and target remote isn't
2124 t
= find_default_run_target (NULL
);
2125 if (t
&& t
->to_is_async_p
)
2126 return (t
->to_is_async_p
) ();
2131 find_default_supports_non_stop (void)
2133 struct target_ops
*t
;
2135 t
= find_default_run_target (NULL
);
2136 if (t
&& t
->to_supports_non_stop
)
2137 return (t
->to_supports_non_stop
) ();
2142 target_supports_non_stop ()
2144 struct target_ops
*t
;
2145 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2146 if (t
->to_supports_non_stop
)
2147 return t
->to_supports_non_stop ();
2154 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2156 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2160 default_watchpoint_addr_within_range (struct target_ops
*target
,
2162 CORE_ADDR start
, int length
)
2164 return addr
>= start
&& addr
< start
+ length
;
2180 return_minus_one (void)
2186 * Resize the to_sections pointer. Also make sure that anyone that
2187 * was holding on to an old value of it gets updated.
2188 * Returns the old size.
2192 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2194 struct target_ops
**t
;
2195 struct section_table
*old_value
;
2198 old_value
= target
->to_sections
;
2200 if (target
->to_sections
)
2202 old_count
= target
->to_sections_end
- target
->to_sections
;
2203 target
->to_sections
= (struct section_table
*)
2204 xrealloc ((char *) target
->to_sections
,
2205 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2210 target
->to_sections
= (struct section_table
*)
2211 xmalloc ((sizeof (struct section_table
)) * num_added
);
2213 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2215 /* Check to see if anyone else was pointing to this structure.
2216 If old_value was null, then no one was. */
2220 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2223 if ((*t
)->to_sections
== old_value
)
2225 (*t
)->to_sections
= target
->to_sections
;
2226 (*t
)->to_sections_end
= target
->to_sections_end
;
2229 /* There is a flattened view of the target stack in current_target,
2230 so its to_sections pointer might also need updating. */
2231 if (current_target
.to_sections
== old_value
)
2233 current_target
.to_sections
= target
->to_sections
;
2234 current_target
.to_sections_end
= target
->to_sections_end
;
2242 /* Remove all target sections taken from ABFD.
2244 Scan the current target stack for targets whose section tables
2245 refer to sections from BFD, and remove those sections. We use this
2246 when we notice that the inferior has unloaded a shared object, for
2249 remove_target_sections (bfd
*abfd
)
2251 struct target_ops
**t
;
2253 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2255 struct section_table
*src
, *dest
;
2257 dest
= (*t
)->to_sections
;
2258 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2259 if (src
->bfd
!= abfd
)
2261 /* Keep this section. */
2262 if (dest
< src
) *dest
= *src
;
2266 /* If we've dropped any sections, resize the section table. */
2268 target_resize_to_sections (*t
, dest
- src
);
2275 /* Find a single runnable target in the stack and return it. If for
2276 some reason there is more than one, return NULL. */
2279 find_run_target (void)
2281 struct target_ops
**t
;
2282 struct target_ops
*runable
= NULL
;
2287 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2289 if ((*t
)->to_can_run
&& target_can_run (*t
))
2296 return (count
== 1 ? runable
: NULL
);
2299 /* Find a single core_stratum target in the list of targets and return it.
2300 If for some reason there is more than one, return NULL. */
2303 find_core_target (void)
2305 struct target_ops
**t
;
2306 struct target_ops
*runable
= NULL
;
2311 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2314 if ((*t
)->to_stratum
== core_stratum
)
2321 return (count
== 1 ? runable
: NULL
);
2325 * Find the next target down the stack from the specified target.
2329 find_target_beneath (struct target_ops
*t
)
2335 /* The inferior process has died. Long live the inferior! */
2338 generic_mourn_inferior (void)
2340 extern int show_breakpoint_hit_counts
;
2343 ptid
= inferior_ptid
;
2344 inferior_ptid
= null_ptid
;
2346 if (!ptid_equal (ptid
, null_ptid
))
2348 int pid
= ptid_get_pid (ptid
);
2349 delete_inferior (pid
);
2353 breakpoint_init_inferior (inf_exited
);
2354 registers_changed ();
2356 reopen_exec_file ();
2357 reinit_frame_cache ();
2359 /* It is confusing to the user for ignore counts to stick around
2360 from previous runs of the inferior. So clear them. */
2361 /* However, it is more confusing for the ignore counts to disappear when
2362 using hit counts. So don't clear them if we're counting hits. */
2363 if (!show_breakpoint_hit_counts
)
2364 breakpoint_clear_ignore_counts ();
2366 if (deprecated_detach_hook
)
2367 deprecated_detach_hook ();
2370 /* Helper function for child_wait and the derivatives of child_wait.
2371 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2372 translation of that in OURSTATUS. */
2374 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2376 if (WIFEXITED (hoststatus
))
2378 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2379 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2381 else if (!WIFSTOPPED (hoststatus
))
2383 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2384 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2388 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2389 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2393 /* Returns zero to leave the inferior alone, one to interrupt it. */
2394 int (*target_activity_function
) (void);
2395 int target_activity_fd
;
2397 /* Convert a normal process ID to a string. Returns the string in a
2401 normal_pid_to_str (ptid_t ptid
)
2403 static char buf
[32];
2405 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2409 /* Error-catcher for target_find_memory_regions */
2410 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2412 error (_("No target."));
2416 /* Error-catcher for target_make_corefile_notes */
2417 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2419 error (_("No target."));
2423 /* Set up the handful of non-empty slots needed by the dummy target
2427 init_dummy_target (void)
2429 dummy_target
.to_shortname
= "None";
2430 dummy_target
.to_longname
= "None";
2431 dummy_target
.to_doc
= "";
2432 dummy_target
.to_attach
= find_default_attach
;
2433 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2434 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2435 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2436 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2437 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2438 dummy_target
.to_stratum
= dummy_stratum
;
2439 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2440 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2441 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2442 dummy_target
.to_magic
= OPS_MAGIC
;
2446 debug_to_open (char *args
, int from_tty
)
2448 debug_target
.to_open (args
, from_tty
);
2450 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2454 debug_to_close (int quitting
)
2456 target_close (&debug_target
, quitting
);
2457 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2461 target_close (struct target_ops
*targ
, int quitting
)
2463 if (targ
->to_xclose
!= NULL
)
2464 targ
->to_xclose (targ
, quitting
);
2465 else if (targ
->to_close
!= NULL
)
2466 targ
->to_close (quitting
);
2470 debug_to_attach (char *args
, int from_tty
)
2472 debug_target
.to_attach (args
, from_tty
);
2474 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2479 debug_to_post_attach (int pid
)
2481 debug_target
.to_post_attach (pid
);
2483 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2487 debug_to_detach (char *args
, int from_tty
)
2489 debug_target
.to_detach (args
, from_tty
);
2491 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2495 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2497 debug_target
.to_resume (ptid
, step
, siggnal
);
2499 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2500 step
? "step" : "continue",
2501 target_signal_to_name (siggnal
));
2505 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2509 retval
= debug_target
.to_wait (ptid
, status
);
2511 fprintf_unfiltered (gdb_stdlog
,
2512 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2514 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2515 switch (status
->kind
)
2517 case TARGET_WAITKIND_EXITED
:
2518 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2519 status
->value
.integer
);
2521 case TARGET_WAITKIND_STOPPED
:
2522 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2523 target_signal_to_name (status
->value
.sig
));
2525 case TARGET_WAITKIND_SIGNALLED
:
2526 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2527 target_signal_to_name (status
->value
.sig
));
2529 case TARGET_WAITKIND_LOADED
:
2530 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2532 case TARGET_WAITKIND_FORKED
:
2533 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2535 case TARGET_WAITKIND_VFORKED
:
2536 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2538 case TARGET_WAITKIND_EXECD
:
2539 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2541 case TARGET_WAITKIND_SPURIOUS
:
2542 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2545 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2553 debug_print_register (const char * func
,
2554 struct regcache
*regcache
, int regno
)
2556 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2557 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2558 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2559 && gdbarch_register_name (gdbarch
, regno
) != NULL
2560 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2561 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2562 gdbarch_register_name (gdbarch
, regno
));
2564 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2565 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2567 int i
, size
= register_size (gdbarch
, regno
);
2568 unsigned char buf
[MAX_REGISTER_SIZE
];
2569 regcache_raw_collect (regcache
, regno
, buf
);
2570 fprintf_unfiltered (gdb_stdlog
, " = ");
2571 for (i
= 0; i
< size
; i
++)
2573 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2575 if (size
<= sizeof (LONGEST
))
2577 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2578 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2579 core_addr_to_string_nz (val
), plongest (val
));
2582 fprintf_unfiltered (gdb_stdlog
, "\n");
2586 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2588 debug_target
.to_fetch_registers (regcache
, regno
);
2589 debug_print_register ("target_fetch_registers", regcache
, regno
);
2593 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2595 debug_target
.to_store_registers (regcache
, regno
);
2596 debug_print_register ("target_store_registers", regcache
, regno
);
2597 fprintf_unfiltered (gdb_stdlog
, "\n");
2601 debug_to_prepare_to_store (struct regcache
*regcache
)
2603 debug_target
.to_prepare_to_store (regcache
);
2605 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2609 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2610 int write
, struct mem_attrib
*attrib
,
2611 struct target_ops
*target
)
2615 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2618 fprintf_unfiltered (gdb_stdlog
,
2619 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2620 (unsigned int) memaddr
, /* possable truncate long long */
2621 len
, write
? "write" : "read", retval
);
2627 fputs_unfiltered (", bytes =", gdb_stdlog
);
2628 for (i
= 0; i
< retval
; i
++)
2630 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2632 if (targetdebug
< 2 && i
> 0)
2634 fprintf_unfiltered (gdb_stdlog
, " ...");
2637 fprintf_unfiltered (gdb_stdlog
, "\n");
2640 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2644 fputc_unfiltered ('\n', gdb_stdlog
);
2650 debug_to_files_info (struct target_ops
*target
)
2652 debug_target
.to_files_info (target
);
2654 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2658 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2662 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2664 fprintf_unfiltered (gdb_stdlog
,
2665 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2666 (unsigned long) bp_tgt
->placed_address
,
2667 (unsigned long) retval
);
2672 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2676 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2678 fprintf_unfiltered (gdb_stdlog
,
2679 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2680 (unsigned long) bp_tgt
->placed_address
,
2681 (unsigned long) retval
);
2686 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2690 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2692 fprintf_unfiltered (gdb_stdlog
,
2693 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2694 (unsigned long) type
,
2695 (unsigned long) cnt
,
2696 (unsigned long) from_tty
,
2697 (unsigned long) retval
);
2702 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2706 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2708 fprintf_unfiltered (gdb_stdlog
,
2709 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2710 (unsigned long) addr
,
2711 (unsigned long) len
,
2712 (unsigned long) retval
);
2717 debug_to_stopped_by_watchpoint (void)
2721 retval
= debug_target
.to_stopped_by_watchpoint ();
2723 fprintf_unfiltered (gdb_stdlog
,
2724 "STOPPED_BY_WATCHPOINT () = %ld\n",
2725 (unsigned long) retval
);
2730 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2734 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2736 fprintf_unfiltered (gdb_stdlog
,
2737 "target_stopped_data_address ([0x%lx]) = %ld\n",
2738 (unsigned long)*addr
,
2739 (unsigned long)retval
);
2744 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2746 CORE_ADDR start
, int length
)
2750 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2753 fprintf_filtered (gdb_stdlog
,
2754 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2755 (unsigned long) addr
, (unsigned long) start
, length
,
2761 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2765 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2767 fprintf_unfiltered (gdb_stdlog
,
2768 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2769 (unsigned long) bp_tgt
->placed_address
,
2770 (unsigned long) retval
);
2775 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2779 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2781 fprintf_unfiltered (gdb_stdlog
,
2782 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2783 (unsigned long) bp_tgt
->placed_address
,
2784 (unsigned long) retval
);
2789 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2793 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2795 fprintf_unfiltered (gdb_stdlog
,
2796 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2797 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2802 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2806 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2808 fprintf_unfiltered (gdb_stdlog
,
2809 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2810 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2815 debug_to_terminal_init (void)
2817 debug_target
.to_terminal_init ();
2819 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2823 debug_to_terminal_inferior (void)
2825 debug_target
.to_terminal_inferior ();
2827 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2831 debug_to_terminal_ours_for_output (void)
2833 debug_target
.to_terminal_ours_for_output ();
2835 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2839 debug_to_terminal_ours (void)
2841 debug_target
.to_terminal_ours ();
2843 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2847 debug_to_terminal_save_ours (void)
2849 debug_target
.to_terminal_save_ours ();
2851 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2855 debug_to_terminal_info (char *arg
, int from_tty
)
2857 debug_target
.to_terminal_info (arg
, from_tty
);
2859 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2864 debug_to_kill (void)
2866 debug_target
.to_kill ();
2868 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2872 debug_to_load (char *args
, int from_tty
)
2874 debug_target
.to_load (args
, from_tty
);
2876 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2880 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2884 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2886 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2892 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2895 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2897 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2898 exec_file
, args
, from_tty
);
2902 debug_to_post_startup_inferior (ptid_t ptid
)
2904 debug_target
.to_post_startup_inferior (ptid
);
2906 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2911 debug_to_acknowledge_created_inferior (int pid
)
2913 debug_target
.to_acknowledge_created_inferior (pid
);
2915 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2920 debug_to_insert_fork_catchpoint (int pid
)
2922 debug_target
.to_insert_fork_catchpoint (pid
);
2924 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2929 debug_to_remove_fork_catchpoint (int pid
)
2933 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2935 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2942 debug_to_insert_vfork_catchpoint (int pid
)
2944 debug_target
.to_insert_vfork_catchpoint (pid
);
2946 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2951 debug_to_remove_vfork_catchpoint (int pid
)
2955 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2957 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2964 debug_to_insert_exec_catchpoint (int pid
)
2966 debug_target
.to_insert_exec_catchpoint (pid
);
2968 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2973 debug_to_remove_exec_catchpoint (int pid
)
2977 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2979 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2986 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2990 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2992 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2993 pid
, wait_status
, *exit_status
, has_exited
);
2999 debug_to_mourn_inferior (void)
3001 debug_target
.to_mourn_inferior ();
3003 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3007 debug_to_can_run (void)
3011 retval
= debug_target
.to_can_run ();
3013 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3019 debug_to_notice_signals (ptid_t ptid
)
3021 debug_target
.to_notice_signals (ptid
);
3023 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3028 debug_to_thread_alive (ptid_t ptid
)
3032 retval
= debug_target
.to_thread_alive (ptid
);
3034 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3035 PIDGET (ptid
), retval
);
3041 debug_to_find_new_threads (void)
3043 debug_target
.to_find_new_threads ();
3045 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3049 debug_to_stop (ptid_t ptid
)
3051 debug_target
.to_stop (ptid
);
3053 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3054 target_pid_to_str (ptid
));
3058 debug_to_rcmd (char *command
,
3059 struct ui_file
*outbuf
)
3061 debug_target
.to_rcmd (command
, outbuf
);
3062 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3066 debug_to_pid_to_exec_file (int pid
)
3070 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3072 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3079 setup_target_debug (void)
3081 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3083 current_target
.to_open
= debug_to_open
;
3084 current_target
.to_close
= debug_to_close
;
3085 current_target
.to_attach
= debug_to_attach
;
3086 current_target
.to_post_attach
= debug_to_post_attach
;
3087 current_target
.to_detach
= debug_to_detach
;
3088 current_target
.to_resume
= debug_to_resume
;
3089 current_target
.to_wait
= debug_to_wait
;
3090 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3091 current_target
.to_store_registers
= debug_to_store_registers
;
3092 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3093 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3094 current_target
.to_files_info
= debug_to_files_info
;
3095 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3096 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3097 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3098 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3099 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3100 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3101 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3102 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3103 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3104 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3105 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3106 current_target
.to_terminal_init
= debug_to_terminal_init
;
3107 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3108 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3109 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3110 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3111 current_target
.to_terminal_info
= debug_to_terminal_info
;
3112 current_target
.to_kill
= debug_to_kill
;
3113 current_target
.to_load
= debug_to_load
;
3114 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3115 current_target
.to_create_inferior
= debug_to_create_inferior
;
3116 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3117 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3118 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3119 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3120 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3121 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3122 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3123 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3124 current_target
.to_has_exited
= debug_to_has_exited
;
3125 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3126 current_target
.to_can_run
= debug_to_can_run
;
3127 current_target
.to_notice_signals
= debug_to_notice_signals
;
3128 current_target
.to_thread_alive
= debug_to_thread_alive
;
3129 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3130 current_target
.to_stop
= debug_to_stop
;
3131 current_target
.to_rcmd
= debug_to_rcmd
;
3132 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3136 static char targ_desc
[] =
3137 "Names of targets and files being debugged.\n\
3138 Shows the entire stack of targets currently in use (including the exec-file,\n\
3139 core-file, and process, if any), as well as the symbol file name.";
3142 do_monitor_command (char *cmd
,
3145 if ((current_target
.to_rcmd
3146 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3147 || (current_target
.to_rcmd
== debug_to_rcmd
3148 && (debug_target
.to_rcmd
3149 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3150 error (_("\"monitor\" command not supported by this target."));
3151 target_rcmd (cmd
, gdb_stdtarg
);
3154 /* Print the name of each layers of our target stack. */
3157 maintenance_print_target_stack (char *cmd
, int from_tty
)
3159 struct target_ops
*t
;
3161 printf_filtered (_("The current target stack is:\n"));
3163 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3165 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3169 /* Controls if async mode is permitted. */
3170 int target_async_permitted
= 0;
3172 /* The set command writes to this variable. If the inferior is
3173 executing, linux_nat_async_permitted is *not* updated. */
3174 static int target_async_permitted_1
= 0;
3177 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3178 struct cmd_list_element
*c
)
3180 if (target_has_execution
)
3182 target_async_permitted_1
= target_async_permitted
;
3183 error (_("Cannot change this setting while the inferior is running."));
3186 target_async_permitted
= target_async_permitted_1
;
3190 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3191 struct cmd_list_element
*c
,
3194 fprintf_filtered (file
, _("\
3195 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3199 initialize_targets (void)
3201 init_dummy_target ();
3202 push_target (&dummy_target
);
3204 add_info ("target", target_info
, targ_desc
);
3205 add_info ("files", target_info
, targ_desc
);
3207 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3208 Set target debugging."), _("\
3209 Show target debugging."), _("\
3210 When non-zero, target debugging is enabled. Higher numbers are more\n\
3211 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3215 &setdebuglist
, &showdebuglist
);
3217 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3218 &trust_readonly
, _("\
3219 Set mode for reading from readonly sections."), _("\
3220 Show mode for reading from readonly sections."), _("\
3221 When this mode is on, memory reads from readonly sections (such as .text)\n\
3222 will be read from the object file instead of from the target. This will\n\
3223 result in significant performance improvement for remote targets."),
3225 show_trust_readonly
,
3226 &setlist
, &showlist
);
3228 add_com ("monitor", class_obscure
, do_monitor_command
,
3229 _("Send a command to the remote monitor (remote targets only)."));
3231 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3232 _("Print the name of each layer of the internal target stack."),
3233 &maintenanceprintlist
);
3235 add_setshow_boolean_cmd ("target-async", no_class
,
3236 &target_async_permitted_1
, _("\
3237 Set whether gdb controls the inferior in asynchronous mode."), _("\
3238 Show whether gdb controls the inferior in asynchronous mode."), _("\
3239 Tells gdb whether to control the inferior in asynchronous mode."),
3240 set_maintenance_target_async_permitted
,
3241 show_maintenance_target_async_permitted
,
3245 target_dcache
= dcache_init ();