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
;
2342 inferior_ptid
= null_ptid
;
2344 breakpoint_init_inferior (inf_exited
);
2345 registers_changed ();
2347 reopen_exec_file ();
2348 reinit_frame_cache ();
2350 /* It is confusing to the user for ignore counts to stick around
2351 from previous runs of the inferior. So clear them. */
2352 /* However, it is more confusing for the ignore counts to disappear when
2353 using hit counts. So don't clear them if we're counting hits. */
2354 if (!show_breakpoint_hit_counts
)
2355 breakpoint_clear_ignore_counts ();
2357 if (deprecated_detach_hook
)
2358 deprecated_detach_hook ();
2361 /* Helper function for child_wait and the derivatives of child_wait.
2362 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2363 translation of that in OURSTATUS. */
2365 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2367 if (WIFEXITED (hoststatus
))
2369 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2370 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2372 else if (!WIFSTOPPED (hoststatus
))
2374 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2375 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2379 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2380 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2384 /* Returns zero to leave the inferior alone, one to interrupt it. */
2385 int (*target_activity_function
) (void);
2386 int target_activity_fd
;
2388 /* Convert a normal process ID to a string. Returns the string in a
2392 normal_pid_to_str (ptid_t ptid
)
2394 static char buf
[32];
2396 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2400 /* Error-catcher for target_find_memory_regions */
2401 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2403 error (_("No target."));
2407 /* Error-catcher for target_make_corefile_notes */
2408 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2410 error (_("No target."));
2414 /* Set up the handful of non-empty slots needed by the dummy target
2418 init_dummy_target (void)
2420 dummy_target
.to_shortname
= "None";
2421 dummy_target
.to_longname
= "None";
2422 dummy_target
.to_doc
= "";
2423 dummy_target
.to_attach
= find_default_attach
;
2424 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2425 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2426 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2427 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2428 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2429 dummy_target
.to_stratum
= dummy_stratum
;
2430 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2431 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2432 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2433 dummy_target
.to_magic
= OPS_MAGIC
;
2437 debug_to_open (char *args
, int from_tty
)
2439 debug_target
.to_open (args
, from_tty
);
2441 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2445 debug_to_close (int quitting
)
2447 target_close (&debug_target
, quitting
);
2448 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2452 target_close (struct target_ops
*targ
, int quitting
)
2454 if (targ
->to_xclose
!= NULL
)
2455 targ
->to_xclose (targ
, quitting
);
2456 else if (targ
->to_close
!= NULL
)
2457 targ
->to_close (quitting
);
2461 debug_to_attach (char *args
, int from_tty
)
2463 debug_target
.to_attach (args
, from_tty
);
2465 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2470 debug_to_post_attach (int pid
)
2472 debug_target
.to_post_attach (pid
);
2474 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2478 debug_to_detach (char *args
, int from_tty
)
2480 debug_target
.to_detach (args
, from_tty
);
2482 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2486 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2488 debug_target
.to_resume (ptid
, step
, siggnal
);
2490 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2491 step
? "step" : "continue",
2492 target_signal_to_name (siggnal
));
2496 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2500 retval
= debug_target
.to_wait (ptid
, status
);
2502 fprintf_unfiltered (gdb_stdlog
,
2503 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2505 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2506 switch (status
->kind
)
2508 case TARGET_WAITKIND_EXITED
:
2509 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2510 status
->value
.integer
);
2512 case TARGET_WAITKIND_STOPPED
:
2513 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2514 target_signal_to_name (status
->value
.sig
));
2516 case TARGET_WAITKIND_SIGNALLED
:
2517 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2518 target_signal_to_name (status
->value
.sig
));
2520 case TARGET_WAITKIND_LOADED
:
2521 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2523 case TARGET_WAITKIND_FORKED
:
2524 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2526 case TARGET_WAITKIND_VFORKED
:
2527 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2529 case TARGET_WAITKIND_EXECD
:
2530 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2532 case TARGET_WAITKIND_SPURIOUS
:
2533 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2536 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2544 debug_print_register (const char * func
,
2545 struct regcache
*regcache
, int regno
)
2547 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2548 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2549 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2550 && gdbarch_register_name (gdbarch
, regno
) != NULL
2551 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2552 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2553 gdbarch_register_name (gdbarch
, regno
));
2555 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2556 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2558 int i
, size
= register_size (gdbarch
, regno
);
2559 unsigned char buf
[MAX_REGISTER_SIZE
];
2560 regcache_raw_collect (regcache
, regno
, buf
);
2561 fprintf_unfiltered (gdb_stdlog
, " = ");
2562 for (i
= 0; i
< size
; i
++)
2564 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2566 if (size
<= sizeof (LONGEST
))
2568 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2569 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2570 core_addr_to_string_nz (val
), plongest (val
));
2573 fprintf_unfiltered (gdb_stdlog
, "\n");
2577 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2579 debug_target
.to_fetch_registers (regcache
, regno
);
2580 debug_print_register ("target_fetch_registers", regcache
, regno
);
2584 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2586 debug_target
.to_store_registers (regcache
, regno
);
2587 debug_print_register ("target_store_registers", regcache
, regno
);
2588 fprintf_unfiltered (gdb_stdlog
, "\n");
2592 debug_to_prepare_to_store (struct regcache
*regcache
)
2594 debug_target
.to_prepare_to_store (regcache
);
2596 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2600 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2601 int write
, struct mem_attrib
*attrib
,
2602 struct target_ops
*target
)
2606 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2609 fprintf_unfiltered (gdb_stdlog
,
2610 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2611 (unsigned int) memaddr
, /* possable truncate long long */
2612 len
, write
? "write" : "read", retval
);
2618 fputs_unfiltered (", bytes =", gdb_stdlog
);
2619 for (i
= 0; i
< retval
; i
++)
2621 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2623 if (targetdebug
< 2 && i
> 0)
2625 fprintf_unfiltered (gdb_stdlog
, " ...");
2628 fprintf_unfiltered (gdb_stdlog
, "\n");
2631 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2635 fputc_unfiltered ('\n', gdb_stdlog
);
2641 debug_to_files_info (struct target_ops
*target
)
2643 debug_target
.to_files_info (target
);
2645 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2649 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2653 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2655 fprintf_unfiltered (gdb_stdlog
,
2656 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2657 (unsigned long) bp_tgt
->placed_address
,
2658 (unsigned long) retval
);
2663 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2667 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2669 fprintf_unfiltered (gdb_stdlog
,
2670 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2671 (unsigned long) bp_tgt
->placed_address
,
2672 (unsigned long) retval
);
2677 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2681 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2683 fprintf_unfiltered (gdb_stdlog
,
2684 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2685 (unsigned long) type
,
2686 (unsigned long) cnt
,
2687 (unsigned long) from_tty
,
2688 (unsigned long) retval
);
2693 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2697 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2699 fprintf_unfiltered (gdb_stdlog
,
2700 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2701 (unsigned long) addr
,
2702 (unsigned long) len
,
2703 (unsigned long) retval
);
2708 debug_to_stopped_by_watchpoint (void)
2712 retval
= debug_target
.to_stopped_by_watchpoint ();
2714 fprintf_unfiltered (gdb_stdlog
,
2715 "STOPPED_BY_WATCHPOINT () = %ld\n",
2716 (unsigned long) retval
);
2721 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2725 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2727 fprintf_unfiltered (gdb_stdlog
,
2728 "target_stopped_data_address ([0x%lx]) = %ld\n",
2729 (unsigned long)*addr
,
2730 (unsigned long)retval
);
2735 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2737 CORE_ADDR start
, int length
)
2741 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2744 fprintf_filtered (gdb_stdlog
,
2745 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2746 (unsigned long) addr
, (unsigned long) start
, length
,
2752 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2756 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2758 fprintf_unfiltered (gdb_stdlog
,
2759 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2760 (unsigned long) bp_tgt
->placed_address
,
2761 (unsigned long) retval
);
2766 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2770 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2772 fprintf_unfiltered (gdb_stdlog
,
2773 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2774 (unsigned long) bp_tgt
->placed_address
,
2775 (unsigned long) retval
);
2780 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2784 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2786 fprintf_unfiltered (gdb_stdlog
,
2787 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2788 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2793 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2797 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2799 fprintf_unfiltered (gdb_stdlog
,
2800 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2801 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2806 debug_to_terminal_init (void)
2808 debug_target
.to_terminal_init ();
2810 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2814 debug_to_terminal_inferior (void)
2816 debug_target
.to_terminal_inferior ();
2818 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2822 debug_to_terminal_ours_for_output (void)
2824 debug_target
.to_terminal_ours_for_output ();
2826 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2830 debug_to_terminal_ours (void)
2832 debug_target
.to_terminal_ours ();
2834 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2838 debug_to_terminal_save_ours (void)
2840 debug_target
.to_terminal_save_ours ();
2842 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2846 debug_to_terminal_info (char *arg
, int from_tty
)
2848 debug_target
.to_terminal_info (arg
, from_tty
);
2850 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2855 debug_to_kill (void)
2857 debug_target
.to_kill ();
2859 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2863 debug_to_load (char *args
, int from_tty
)
2865 debug_target
.to_load (args
, from_tty
);
2867 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2871 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2875 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2877 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2883 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2886 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2888 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2889 exec_file
, args
, from_tty
);
2893 debug_to_post_startup_inferior (ptid_t ptid
)
2895 debug_target
.to_post_startup_inferior (ptid
);
2897 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2902 debug_to_acknowledge_created_inferior (int pid
)
2904 debug_target
.to_acknowledge_created_inferior (pid
);
2906 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2911 debug_to_insert_fork_catchpoint (int pid
)
2913 debug_target
.to_insert_fork_catchpoint (pid
);
2915 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2920 debug_to_remove_fork_catchpoint (int pid
)
2924 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2926 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2933 debug_to_insert_vfork_catchpoint (int pid
)
2935 debug_target
.to_insert_vfork_catchpoint (pid
);
2937 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2942 debug_to_remove_vfork_catchpoint (int pid
)
2946 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2948 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2955 debug_to_insert_exec_catchpoint (int pid
)
2957 debug_target
.to_insert_exec_catchpoint (pid
);
2959 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2964 debug_to_remove_exec_catchpoint (int pid
)
2968 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2970 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2977 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2981 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2983 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2984 pid
, wait_status
, *exit_status
, has_exited
);
2990 debug_to_mourn_inferior (void)
2992 debug_target
.to_mourn_inferior ();
2994 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2998 debug_to_can_run (void)
3002 retval
= debug_target
.to_can_run ();
3004 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3010 debug_to_notice_signals (ptid_t ptid
)
3012 debug_target
.to_notice_signals (ptid
);
3014 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3019 debug_to_thread_alive (ptid_t ptid
)
3023 retval
= debug_target
.to_thread_alive (ptid
);
3025 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3026 PIDGET (ptid
), retval
);
3032 debug_to_find_new_threads (void)
3034 debug_target
.to_find_new_threads ();
3036 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3040 debug_to_stop (ptid_t ptid
)
3042 debug_target
.to_stop (ptid
);
3044 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3045 target_pid_to_str (ptid
));
3049 debug_to_rcmd (char *command
,
3050 struct ui_file
*outbuf
)
3052 debug_target
.to_rcmd (command
, outbuf
);
3053 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3057 debug_to_pid_to_exec_file (int pid
)
3061 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3063 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3070 setup_target_debug (void)
3072 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3074 current_target
.to_open
= debug_to_open
;
3075 current_target
.to_close
= debug_to_close
;
3076 current_target
.to_attach
= debug_to_attach
;
3077 current_target
.to_post_attach
= debug_to_post_attach
;
3078 current_target
.to_detach
= debug_to_detach
;
3079 current_target
.to_resume
= debug_to_resume
;
3080 current_target
.to_wait
= debug_to_wait
;
3081 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3082 current_target
.to_store_registers
= debug_to_store_registers
;
3083 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3084 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3085 current_target
.to_files_info
= debug_to_files_info
;
3086 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3087 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3088 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3089 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3090 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3091 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3092 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3093 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3094 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3095 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3096 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3097 current_target
.to_terminal_init
= debug_to_terminal_init
;
3098 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3099 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3100 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3101 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3102 current_target
.to_terminal_info
= debug_to_terminal_info
;
3103 current_target
.to_kill
= debug_to_kill
;
3104 current_target
.to_load
= debug_to_load
;
3105 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3106 current_target
.to_create_inferior
= debug_to_create_inferior
;
3107 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3108 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3109 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3110 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3111 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3112 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3113 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3114 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3115 current_target
.to_has_exited
= debug_to_has_exited
;
3116 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3117 current_target
.to_can_run
= debug_to_can_run
;
3118 current_target
.to_notice_signals
= debug_to_notice_signals
;
3119 current_target
.to_thread_alive
= debug_to_thread_alive
;
3120 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3121 current_target
.to_stop
= debug_to_stop
;
3122 current_target
.to_rcmd
= debug_to_rcmd
;
3123 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3127 static char targ_desc
[] =
3128 "Names of targets and files being debugged.\n\
3129 Shows the entire stack of targets currently in use (including the exec-file,\n\
3130 core-file, and process, if any), as well as the symbol file name.";
3133 do_monitor_command (char *cmd
,
3136 if ((current_target
.to_rcmd
3137 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3138 || (current_target
.to_rcmd
== debug_to_rcmd
3139 && (debug_target
.to_rcmd
3140 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3141 error (_("\"monitor\" command not supported by this target."));
3142 target_rcmd (cmd
, gdb_stdtarg
);
3145 /* Print the name of each layers of our target stack. */
3148 maintenance_print_target_stack (char *cmd
, int from_tty
)
3150 struct target_ops
*t
;
3152 printf_filtered (_("The current target stack is:\n"));
3154 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3156 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3160 /* Controls if async mode is permitted. */
3161 int target_async_permitted
= 0;
3163 /* The set command writes to this variable. If the inferior is
3164 executing, linux_nat_async_permitted is *not* updated. */
3165 static int target_async_permitted_1
= 0;
3168 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3169 struct cmd_list_element
*c
)
3171 if (target_has_execution
)
3173 target_async_permitted_1
= target_async_permitted
;
3174 error (_("Cannot change this setting while the inferior is running."));
3177 target_async_permitted
= target_async_permitted_1
;
3181 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3182 struct cmd_list_element
*c
,
3185 fprintf_filtered (file
, _("\
3186 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3190 initialize_targets (void)
3192 init_dummy_target ();
3193 push_target (&dummy_target
);
3195 add_info ("target", target_info
, targ_desc
);
3196 add_info ("files", target_info
, targ_desc
);
3198 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3199 Set target debugging."), _("\
3200 Show target debugging."), _("\
3201 When non-zero, target debugging is enabled. Higher numbers are more\n\
3202 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3206 &setdebuglist
, &showdebuglist
);
3208 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3209 &trust_readonly
, _("\
3210 Set mode for reading from readonly sections."), _("\
3211 Show mode for reading from readonly sections."), _("\
3212 When this mode is on, memory reads from readonly sections (such as .text)\n\
3213 will be read from the object file instead of from the target. This will\n\
3214 result in significant performance improvement for remote targets."),
3216 show_trust_readonly
,
3217 &setlist
, &showlist
);
3219 add_com ("monitor", class_obscure
, do_monitor_command
,
3220 _("Send a command to the remote monitor (remote targets only)."));
3222 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3223 _("Print the name of each layer of the internal target stack."),
3224 &maintenanceprintlist
);
3226 add_setshow_boolean_cmd ("target-async", no_class
,
3227 &target_async_permitted_1
, _("\
3228 Set whether gdb controls the inferior in asynchronous mode."), _("\
3229 Show whether gdb controls the inferior in asynchronous mode."), _("\
3230 Tells gdb whether to control the inferior in asynchronous mode."),
3231 set_maintenance_target_async_permitted
,
3232 show_maintenance_target_async_permitted
,
3236 target_dcache
= dcache_init ();