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 should trust readonly sections from the
203 executable when reading memory. */
205 static int trust_readonly
= 0;
207 /* Nonzero if we should show true memory content including
208 memory breakpoint inserted by gdb. */
210 static int show_memory_breakpoints
= 0;
212 /* Non-zero if we want to see trace of target level stuff. */
214 static int targetdebug
= 0;
216 show_targetdebug (struct ui_file
*file
, int from_tty
,
217 struct cmd_list_element
*c
, const char *value
)
219 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
222 static void setup_target_debug (void);
224 DCACHE
*target_dcache
;
226 /* The user just typed 'target' without the name of a target. */
229 target_command (char *arg
, int from_tty
)
231 fputs_filtered ("Argument required (target name). Try `help target'\n",
235 /* Add a possible target architecture to the list. */
238 add_target (struct target_ops
*t
)
240 /* Provide default values for all "must have" methods. */
241 if (t
->to_xfer_partial
== NULL
)
242 t
->to_xfer_partial
= default_xfer_partial
;
246 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
247 target_structs
= (struct target_ops
**) xmalloc
248 (target_struct_allocsize
* sizeof (*target_structs
));
250 if (target_struct_size
>= target_struct_allocsize
)
252 target_struct_allocsize
*= 2;
253 target_structs
= (struct target_ops
**)
254 xrealloc ((char *) target_structs
,
255 target_struct_allocsize
* sizeof (*target_structs
));
257 target_structs
[target_struct_size
++] = t
;
259 if (targetlist
== NULL
)
260 add_prefix_cmd ("target", class_run
, target_command
, _("\
261 Connect to a target machine or process.\n\
262 The first argument is the type or protocol of the target machine.\n\
263 Remaining arguments are interpreted by the target protocol. For more\n\
264 information on the arguments for a particular protocol, type\n\
265 `help target ' followed by the protocol name."),
266 &targetlist
, "target ", 0, &cmdlist
);
267 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
278 target_load (char *arg
, int from_tty
)
280 dcache_invalidate (target_dcache
);
281 (*current_target
.to_load
) (arg
, from_tty
);
285 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
286 struct target_ops
*t
)
288 errno
= EIO
; /* Can't read/write this location */
289 return 0; /* No bytes handled */
295 error (_("You can't do that when your target is `%s'"),
296 current_target
.to_shortname
);
302 error (_("You can't do that without a process to debug."));
306 nosymbol (char *name
, CORE_ADDR
*addrp
)
308 return 1; /* Symbol does not exist in target env */
312 nosupport_runtime (void)
314 if (ptid_equal (inferior_ptid
, null_ptid
))
317 error (_("No run-time support for this"));
322 default_terminal_info (char *args
, int from_tty
)
324 printf_unfiltered (_("No saved terminal information.\n"));
327 /* This is the default target_create_inferior and target_attach function.
328 If the current target is executing, it asks whether to kill it off.
329 If this function returns without calling error(), it has killed off
330 the target, and the operation should be attempted. */
333 kill_or_be_killed (int from_tty
)
335 if (target_has_execution
)
337 printf_unfiltered (_("You are already running a program:\n"));
338 target_files_info ();
339 if (query ("Kill it? "))
342 if (target_has_execution
)
343 error (_("Killing the program did not help."));
348 error (_("Program not killed."));
354 /* Go through the target stack from top to bottom, copying over zero
355 entries in current_target, then filling in still empty entries. In
356 effect, we are doing class inheritance through the pushed target
359 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
360 is currently implemented, is that it discards any knowledge of
361 which target an inherited method originally belonged to.
362 Consequently, new new target methods should instead explicitly and
363 locally search the target stack for the target that can handle the
367 update_current_target (void)
369 struct target_ops
*t
;
371 /* First, reset current's contents. */
372 memset (¤t_target
, 0, sizeof (current_target
));
374 #define INHERIT(FIELD, TARGET) \
375 if (!current_target.FIELD) \
376 current_target.FIELD = (TARGET)->FIELD
378 for (t
= target_stack
; t
; t
= t
->beneath
)
380 INHERIT (to_shortname
, t
);
381 INHERIT (to_longname
, t
);
383 /* Do not inherit to_open. */
384 /* Do not inherit to_close. */
385 INHERIT (to_attach
, t
);
386 INHERIT (to_post_attach
, t
);
387 INHERIT (to_attach_no_wait
, t
);
388 INHERIT (to_detach
, t
);
389 /* Do not inherit to_disconnect. */
390 INHERIT (to_resume
, t
);
391 INHERIT (to_wait
, t
);
392 INHERIT (to_fetch_registers
, t
);
393 INHERIT (to_store_registers
, t
);
394 INHERIT (to_prepare_to_store
, t
);
395 INHERIT (deprecated_xfer_memory
, t
);
396 INHERIT (to_files_info
, t
);
397 INHERIT (to_insert_breakpoint
, t
);
398 INHERIT (to_remove_breakpoint
, t
);
399 INHERIT (to_can_use_hw_breakpoint
, t
);
400 INHERIT (to_insert_hw_breakpoint
, t
);
401 INHERIT (to_remove_hw_breakpoint
, t
);
402 INHERIT (to_insert_watchpoint
, t
);
403 INHERIT (to_remove_watchpoint
, t
);
404 INHERIT (to_stopped_data_address
, t
);
405 INHERIT (to_have_steppable_watchpoint
, t
);
406 INHERIT (to_have_continuable_watchpoint
, t
);
407 INHERIT (to_stopped_by_watchpoint
, t
);
408 INHERIT (to_watchpoint_addr_within_range
, t
);
409 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
410 INHERIT (to_terminal_init
, t
);
411 INHERIT (to_terminal_inferior
, t
);
412 INHERIT (to_terminal_ours_for_output
, t
);
413 INHERIT (to_terminal_ours
, t
);
414 INHERIT (to_terminal_save_ours
, t
);
415 INHERIT (to_terminal_info
, t
);
416 INHERIT (to_kill
, t
);
417 INHERIT (to_load
, t
);
418 INHERIT (to_lookup_symbol
, t
);
419 INHERIT (to_create_inferior
, t
);
420 INHERIT (to_post_startup_inferior
, t
);
421 INHERIT (to_acknowledge_created_inferior
, t
);
422 INHERIT (to_insert_fork_catchpoint
, t
);
423 INHERIT (to_remove_fork_catchpoint
, t
);
424 INHERIT (to_insert_vfork_catchpoint
, t
);
425 INHERIT (to_remove_vfork_catchpoint
, t
);
426 /* Do not inherit to_follow_fork. */
427 INHERIT (to_insert_exec_catchpoint
, t
);
428 INHERIT (to_remove_exec_catchpoint
, t
);
429 INHERIT (to_has_exited
, t
);
430 INHERIT (to_mourn_inferior
, t
);
431 INHERIT (to_can_run
, t
);
432 INHERIT (to_notice_signals
, t
);
433 INHERIT (to_thread_alive
, t
);
434 INHERIT (to_find_new_threads
, t
);
435 INHERIT (to_pid_to_str
, t
);
436 INHERIT (to_extra_thread_info
, t
);
437 INHERIT (to_stop
, t
);
438 /* Do not inherit to_xfer_partial. */
439 INHERIT (to_rcmd
, t
);
440 INHERIT (to_pid_to_exec_file
, t
);
441 INHERIT (to_log_command
, t
);
442 INHERIT (to_stratum
, t
);
443 INHERIT (to_has_all_memory
, t
);
444 INHERIT (to_has_memory
, t
);
445 INHERIT (to_has_stack
, t
);
446 INHERIT (to_has_registers
, t
);
447 INHERIT (to_has_execution
, t
);
448 INHERIT (to_has_thread_control
, t
);
449 INHERIT (to_sections
, t
);
450 INHERIT (to_sections_end
, t
);
451 INHERIT (to_can_async_p
, t
);
452 INHERIT (to_is_async_p
, t
);
453 INHERIT (to_async
, t
);
454 INHERIT (to_async_mask
, t
);
455 INHERIT (to_find_memory_regions
, t
);
456 INHERIT (to_make_corefile_notes
, t
);
457 INHERIT (to_get_thread_local_address
, t
);
458 /* Do not inherit to_read_description. */
459 /* Do not inherit to_search_memory. */
460 INHERIT (to_magic
, t
);
461 /* Do not inherit to_memory_map. */
462 /* Do not inherit to_flash_erase. */
463 /* Do not inherit to_flash_done. */
467 /* Clean up a target struct so it no longer has any zero pointers in
468 it. Some entries are defaulted to a method that print an error,
469 others are hard-wired to a standard recursive default. */
471 #define de_fault(field, value) \
472 if (!current_target.field) \
473 current_target.field = value
476 (void (*) (char *, int))
481 de_fault (to_post_attach
,
485 (void (*) (char *, int))
488 (void (*) (ptid_t
, int, enum target_signal
))
491 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
493 de_fault (to_fetch_registers
,
494 (void (*) (struct regcache
*, int))
496 de_fault (to_store_registers
,
497 (void (*) (struct regcache
*, int))
499 de_fault (to_prepare_to_store
,
500 (void (*) (struct regcache
*))
502 de_fault (deprecated_xfer_memory
,
503 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
505 de_fault (to_files_info
,
506 (void (*) (struct target_ops
*))
508 de_fault (to_insert_breakpoint
,
509 memory_insert_breakpoint
);
510 de_fault (to_remove_breakpoint
,
511 memory_remove_breakpoint
);
512 de_fault (to_can_use_hw_breakpoint
,
513 (int (*) (int, int, int))
515 de_fault (to_insert_hw_breakpoint
,
516 (int (*) (struct bp_target_info
*))
518 de_fault (to_remove_hw_breakpoint
,
519 (int (*) (struct bp_target_info
*))
521 de_fault (to_insert_watchpoint
,
522 (int (*) (CORE_ADDR
, int, int))
524 de_fault (to_remove_watchpoint
,
525 (int (*) (CORE_ADDR
, int, int))
527 de_fault (to_stopped_by_watchpoint
,
530 de_fault (to_stopped_data_address
,
531 (int (*) (struct target_ops
*, CORE_ADDR
*))
533 de_fault (to_watchpoint_addr_within_range
,
534 default_watchpoint_addr_within_range
);
535 de_fault (to_region_ok_for_hw_watchpoint
,
536 default_region_ok_for_hw_watchpoint
);
537 de_fault (to_terminal_init
,
540 de_fault (to_terminal_inferior
,
543 de_fault (to_terminal_ours_for_output
,
546 de_fault (to_terminal_ours
,
549 de_fault (to_terminal_save_ours
,
552 de_fault (to_terminal_info
,
553 default_terminal_info
);
558 (void (*) (char *, int))
560 de_fault (to_lookup_symbol
,
561 (int (*) (char *, CORE_ADDR
*))
563 de_fault (to_post_startup_inferior
,
566 de_fault (to_acknowledge_created_inferior
,
569 de_fault (to_insert_fork_catchpoint
,
572 de_fault (to_remove_fork_catchpoint
,
575 de_fault (to_insert_vfork_catchpoint
,
578 de_fault (to_remove_vfork_catchpoint
,
581 de_fault (to_insert_exec_catchpoint
,
584 de_fault (to_remove_exec_catchpoint
,
587 de_fault (to_has_exited
,
588 (int (*) (int, int, int *))
590 de_fault (to_mourn_inferior
,
593 de_fault (to_can_run
,
595 de_fault (to_notice_signals
,
598 de_fault (to_thread_alive
,
601 de_fault (to_find_new_threads
,
604 de_fault (to_extra_thread_info
,
605 (char *(*) (struct thread_info
*))
610 current_target
.to_xfer_partial
= current_xfer_partial
;
612 (void (*) (char *, struct ui_file
*))
614 de_fault (to_pid_to_exec_file
,
618 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
620 de_fault (to_async_mask
,
623 current_target
.to_read_description
= NULL
;
626 /* Finally, position the target-stack beneath the squashed
627 "current_target". That way code looking for a non-inherited
628 target method can quickly and simply find it. */
629 current_target
.beneath
= target_stack
;
632 setup_target_debug ();
635 /* Mark OPS as a running target. This reverses the effect
636 of target_mark_exited. */
639 target_mark_running (struct target_ops
*ops
)
641 struct target_ops
*t
;
643 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
647 internal_error (__FILE__
, __LINE__
,
648 "Attempted to mark unpushed target \"%s\" as running",
651 ops
->to_has_execution
= 1;
652 ops
->to_has_all_memory
= 1;
653 ops
->to_has_memory
= 1;
654 ops
->to_has_stack
= 1;
655 ops
->to_has_registers
= 1;
657 update_current_target ();
660 /* Mark OPS as a non-running target. This reverses the effect
661 of target_mark_running. */
664 target_mark_exited (struct target_ops
*ops
)
666 struct target_ops
*t
;
668 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
672 internal_error (__FILE__
, __LINE__
,
673 "Attempted to mark unpushed target \"%s\" as running",
676 ops
->to_has_execution
= 0;
677 ops
->to_has_all_memory
= 0;
678 ops
->to_has_memory
= 0;
679 ops
->to_has_stack
= 0;
680 ops
->to_has_registers
= 0;
682 update_current_target ();
685 /* Push a new target type into the stack of the existing target accessors,
686 possibly superseding some of the existing accessors.
688 Result is zero if the pushed target ended up on top of the stack,
689 nonzero if at least one target is on top of it.
691 Rather than allow an empty stack, we always have the dummy target at
692 the bottom stratum, so we can call the function vectors without
696 push_target (struct target_ops
*t
)
698 struct target_ops
**cur
;
700 /* Check magic number. If wrong, it probably means someone changed
701 the struct definition, but not all the places that initialize one. */
702 if (t
->to_magic
!= OPS_MAGIC
)
704 fprintf_unfiltered (gdb_stderr
,
705 "Magic number of %s target struct wrong\n",
707 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
710 /* Find the proper stratum to install this target in. */
711 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
713 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
717 /* If there's already targets at this stratum, remove them. */
718 /* FIXME: cagney/2003-10-15: I think this should be popping all
719 targets to CUR, and not just those at this stratum level. */
720 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
722 /* There's already something at this stratum level. Close it,
723 and un-hook it from the stack. */
724 struct target_ops
*tmp
= (*cur
);
725 (*cur
) = (*cur
)->beneath
;
727 target_close (tmp
, 0);
730 /* We have removed all targets in our stratum, now add the new one. */
734 update_current_target ();
737 return (t
!= target_stack
);
740 /* Remove a target_ops vector from the stack, wherever it may be.
741 Return how many times it was removed (0 or 1). */
744 unpush_target (struct target_ops
*t
)
746 struct target_ops
**cur
;
747 struct target_ops
*tmp
;
749 if (t
->to_stratum
== dummy_stratum
)
750 internal_error (__FILE__
, __LINE__
,
751 "Attempt to unpush the dummy target");
753 /* Look for the specified target. Note that we assume that a target
754 can only occur once in the target stack. */
756 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
763 return 0; /* Didn't find target_ops, quit now */
765 /* NOTE: cagney/2003-12-06: In '94 the close call was made
766 unconditional by moving it to before the above check that the
767 target was in the target stack (something about "Change the way
768 pushing and popping of targets work to support target overlays
769 and inheritance"). This doesn't make much sense - only open
770 targets should be closed. */
773 /* Unchain the target */
775 (*cur
) = (*cur
)->beneath
;
778 update_current_target ();
786 target_close (target_stack
, 0); /* Let it clean up */
787 if (unpush_target (target_stack
) == 1)
790 fprintf_unfiltered (gdb_stderr
,
791 "pop_target couldn't find target %s\n",
792 current_target
.to_shortname
);
793 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
797 pop_all_targets_above (enum strata above_stratum
, int quitting
)
799 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
801 target_close (target_stack
, quitting
);
802 if (!unpush_target (target_stack
))
804 fprintf_unfiltered (gdb_stderr
,
805 "pop_all_targets couldn't find target %s\n",
806 target_stack
->to_shortname
);
807 internal_error (__FILE__
, __LINE__
,
808 _("failed internal consistency check"));
815 pop_all_targets (int quitting
)
817 pop_all_targets_above (dummy_stratum
, quitting
);
820 /* Using the objfile specified in OBJFILE, find the address for the
821 current thread's thread-local storage with offset OFFSET. */
823 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
825 volatile CORE_ADDR addr
= 0;
827 if (target_get_thread_local_address_p ()
828 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
830 ptid_t ptid
= inferior_ptid
;
831 volatile struct gdb_exception ex
;
833 TRY_CATCH (ex
, RETURN_MASK_ALL
)
837 /* Fetch the load module address for this objfile. */
838 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
840 /* If it's 0, throw the appropriate exception. */
842 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
843 _("TLS load module not found"));
845 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
847 /* If an error occurred, print TLS related messages here. Otherwise,
848 throw the error to some higher catcher. */
851 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
855 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
856 error (_("Cannot find thread-local variables in this thread library."));
858 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
859 if (objfile_is_library
)
860 error (_("Cannot find shared library `%s' in dynamic"
861 " linker's load module list"), objfile
->name
);
863 error (_("Cannot find executable file `%s' in dynamic"
864 " linker's load module list"), objfile
->name
);
866 case TLS_NOT_ALLOCATED_YET_ERROR
:
867 if (objfile_is_library
)
868 error (_("The inferior has not yet allocated storage for"
869 " thread-local variables in\n"
870 "the shared library `%s'\n"
872 objfile
->name
, target_pid_to_str (ptid
));
874 error (_("The inferior has not yet allocated storage for"
875 " thread-local variables in\n"
876 "the executable `%s'\n"
878 objfile
->name
, target_pid_to_str (ptid
));
880 case TLS_GENERIC_ERROR
:
881 if (objfile_is_library
)
882 error (_("Cannot find thread-local storage for %s, "
883 "shared library %s:\n%s"),
884 target_pid_to_str (ptid
),
885 objfile
->name
, ex
.message
);
887 error (_("Cannot find thread-local storage for %s, "
888 "executable file %s:\n%s"),
889 target_pid_to_str (ptid
),
890 objfile
->name
, ex
.message
);
893 throw_exception (ex
);
898 /* It wouldn't be wrong here to try a gdbarch method, too; finding
899 TLS is an ABI-specific thing. But we don't do that yet. */
901 error (_("Cannot find thread-local variables on this target"));
907 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
909 /* target_read_string -- read a null terminated string, up to LEN bytes,
910 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
911 Set *STRING to a pointer to malloc'd memory containing the data; the caller
912 is responsible for freeing it. Return the number of bytes successfully
916 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
918 int tlen
, origlen
, offset
, i
;
922 int buffer_allocated
;
924 unsigned int nbytes_read
= 0;
928 /* Small for testing. */
929 buffer_allocated
= 4;
930 buffer
= xmalloc (buffer_allocated
);
937 tlen
= MIN (len
, 4 - (memaddr
& 3));
938 offset
= memaddr
& 3;
940 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
943 /* The transfer request might have crossed the boundary to an
944 unallocated region of memory. Retry the transfer, requesting
948 errcode
= target_read_memory (memaddr
, buf
, 1);
953 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
956 bytes
= bufptr
- buffer
;
957 buffer_allocated
*= 2;
958 buffer
= xrealloc (buffer
, buffer_allocated
);
959 bufptr
= buffer
+ bytes
;
962 for (i
= 0; i
< tlen
; i
++)
964 *bufptr
++ = buf
[i
+ offset
];
965 if (buf
[i
+ offset
] == '\000')
967 nbytes_read
+= i
+ 1;
983 /* Find a section containing ADDR. */
984 struct section_table
*
985 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
987 struct section_table
*secp
;
988 for (secp
= target
->to_sections
;
989 secp
< target
->to_sections_end
;
992 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
998 /* Perform a partial memory transfer. The arguments and return
999 value are just as for target_xfer_partial. */
1002 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1003 ULONGEST memaddr
, LONGEST len
)
1007 struct mem_region
*region
;
1009 /* Zero length requests are ok and require no work. */
1013 /* Try the executable file, if "trust-readonly-sections" is set. */
1014 if (readbuf
!= NULL
&& trust_readonly
)
1016 struct section_table
*secp
;
1018 secp
= target_section_by_addr (ops
, memaddr
);
1020 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1022 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1025 /* Likewise for accesses to unmapped overlay sections. */
1026 if (readbuf
!= NULL
&& overlay_debugging
)
1028 struct obj_section
*section
= find_pc_overlay (memaddr
);
1029 if (pc_in_unmapped_range (memaddr
, section
))
1030 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1033 /* Try GDB's internal data cache. */
1034 region
= lookup_mem_region (memaddr
);
1035 /* region->hi == 0 means there's no upper bound. */
1036 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1039 reg_len
= region
->hi
- memaddr
;
1041 switch (region
->attrib
.mode
)
1044 if (writebuf
!= NULL
)
1049 if (readbuf
!= NULL
)
1054 /* We only support writing to flash during "load" for now. */
1055 if (writebuf
!= NULL
)
1056 error (_("Writing to flash memory forbidden in this context"));
1063 if (region
->attrib
.cache
)
1065 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1066 memory request will start back at current_target. */
1067 if (readbuf
!= NULL
)
1068 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1071 /* FIXME drow/2006-08-09: If we're going to preserve const
1072 correctness dcache_xfer_memory should take readbuf and
1074 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1081 if (readbuf
&& !show_memory_breakpoints
)
1082 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1087 /* If none of those methods found the memory we wanted, fall back
1088 to a target partial transfer. Normally a single call to
1089 to_xfer_partial is enough; if it doesn't recognize an object
1090 it will call the to_xfer_partial of the next target down.
1091 But for memory this won't do. Memory is the only target
1092 object which can be read from more than one valid target.
1093 A core file, for instance, could have some of memory but
1094 delegate other bits to the target below it. So, we must
1095 manually try all targets. */
1099 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1100 readbuf
, writebuf
, memaddr
, reg_len
);
1104 /* We want to continue past core files to executables, but not
1105 past a running target's memory. */
1106 if (ops
->to_has_all_memory
)
1111 while (ops
!= NULL
);
1113 if (readbuf
&& !show_memory_breakpoints
)
1114 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1116 /* If we still haven't got anything, return the last error. We
1122 restore_show_memory_breakpoints (void *arg
)
1124 show_memory_breakpoints
= (uintptr_t) arg
;
1128 make_show_memory_breakpoints_cleanup (int show
)
1130 int current
= show_memory_breakpoints
;
1131 show_memory_breakpoints
= show
;
1133 return make_cleanup (restore_show_memory_breakpoints
,
1134 (void *) (uintptr_t) current
);
1138 target_xfer_partial (struct target_ops
*ops
,
1139 enum target_object object
, const char *annex
,
1140 void *readbuf
, const void *writebuf
,
1141 ULONGEST offset
, LONGEST len
)
1145 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1147 /* If this is a memory transfer, let the memory-specific code
1148 have a look at it instead. Memory transfers are more
1150 if (object
== TARGET_OBJECT_MEMORY
)
1151 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1154 enum target_object raw_object
= object
;
1156 /* If this is a raw memory transfer, request the normal
1157 memory object from other layers. */
1158 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1159 raw_object
= TARGET_OBJECT_MEMORY
;
1161 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1162 writebuf
, offset
, len
);
1167 const unsigned char *myaddr
= NULL
;
1169 fprintf_unfiltered (gdb_stdlog
,
1170 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
1173 (annex
? annex
: "(null)"),
1174 (long) readbuf
, (long) writebuf
,
1175 core_addr_to_string_nz (offset
),
1176 plongest (len
), plongest (retval
));
1182 if (retval
> 0 && myaddr
!= NULL
)
1186 fputs_unfiltered (", bytes =", gdb_stdlog
);
1187 for (i
= 0; i
< retval
; i
++)
1189 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1191 if (targetdebug
< 2 && i
> 0)
1193 fprintf_unfiltered (gdb_stdlog
, " ...");
1196 fprintf_unfiltered (gdb_stdlog
, "\n");
1199 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1203 fputc_unfiltered ('\n', gdb_stdlog
);
1208 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1209 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1210 if any error occurs.
1212 If an error occurs, no guarantee is made about the contents of the data at
1213 MYADDR. In particular, the caller should not depend upon partial reads
1214 filling the buffer with good data. There is no way for the caller to know
1215 how much good data might have been transfered anyway. Callers that can
1216 deal with partial reads should call target_read (which will retry until
1217 it makes no progress, and then return how much was transferred). */
1220 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1222 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1223 myaddr
, memaddr
, len
) == len
)
1230 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1232 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1233 myaddr
, memaddr
, len
) == len
)
1239 /* Fetch the target's memory map. */
1242 target_memory_map (void)
1244 VEC(mem_region_s
) *result
;
1245 struct mem_region
*last_one
, *this_one
;
1247 struct target_ops
*t
;
1250 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1252 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1253 if (t
->to_memory_map
!= NULL
)
1259 result
= t
->to_memory_map (t
);
1263 qsort (VEC_address (mem_region_s
, result
),
1264 VEC_length (mem_region_s
, result
),
1265 sizeof (struct mem_region
), mem_region_cmp
);
1267 /* Check that regions do not overlap. Simultaneously assign
1268 a numbering for the "mem" commands to use to refer to
1271 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1273 this_one
->number
= ix
;
1275 if (last_one
&& last_one
->hi
> this_one
->lo
)
1277 warning (_("Overlapping regions in memory map: ignoring"));
1278 VEC_free (mem_region_s
, result
);
1281 last_one
= this_one
;
1288 target_flash_erase (ULONGEST address
, LONGEST length
)
1290 struct target_ops
*t
;
1292 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1293 if (t
->to_flash_erase
!= NULL
)
1296 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1297 paddr (address
), phex (length
, 0));
1298 t
->to_flash_erase (t
, address
, length
);
1306 target_flash_done (void)
1308 struct target_ops
*t
;
1310 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1311 if (t
->to_flash_done
!= NULL
)
1314 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1315 t
->to_flash_done (t
);
1322 #ifndef target_stopped_data_address_p
1324 target_stopped_data_address_p (struct target_ops
*target
)
1326 if (target
->to_stopped_data_address
1327 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1329 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1330 && (debug_target
.to_stopped_data_address
1331 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1338 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1339 struct cmd_list_element
*c
, const char *value
)
1341 fprintf_filtered (file
, _("\
1342 Mode for reading from readonly sections is %s.\n"),
1346 /* More generic transfers. */
1349 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1350 const char *annex
, gdb_byte
*readbuf
,
1351 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1353 if (object
== TARGET_OBJECT_MEMORY
1354 && ops
->deprecated_xfer_memory
!= NULL
)
1355 /* If available, fall back to the target's
1356 "deprecated_xfer_memory" method. */
1360 if (writebuf
!= NULL
)
1362 void *buffer
= xmalloc (len
);
1363 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1364 memcpy (buffer
, writebuf
, len
);
1365 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1366 1/*write*/, NULL
, ops
);
1367 do_cleanups (cleanup
);
1369 if (readbuf
!= NULL
)
1370 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1371 0/*read*/, NULL
, ops
);
1374 else if (xfered
== 0 && errno
== 0)
1375 /* "deprecated_xfer_memory" uses 0, cross checked against
1376 ERRNO as one indication of an error. */
1381 else if (ops
->beneath
!= NULL
)
1382 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1383 readbuf
, writebuf
, offset
, len
);
1388 /* The xfer_partial handler for the topmost target. Unlike the default,
1389 it does not need to handle memory specially; it just passes all
1390 requests down the stack. */
1393 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1394 const char *annex
, gdb_byte
*readbuf
,
1395 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1397 if (ops
->beneath
!= NULL
)
1398 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1399 readbuf
, writebuf
, offset
, len
);
1404 /* Target vector read/write partial wrapper functions.
1406 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1407 (inbuf, outbuf)", instead of separate read/write methods, make life
1411 target_read_partial (struct target_ops
*ops
,
1412 enum target_object object
,
1413 const char *annex
, gdb_byte
*buf
,
1414 ULONGEST offset
, LONGEST len
)
1416 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1420 target_write_partial (struct target_ops
*ops
,
1421 enum target_object object
,
1422 const char *annex
, const gdb_byte
*buf
,
1423 ULONGEST offset
, LONGEST len
)
1425 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1428 /* Wrappers to perform the full transfer. */
1430 target_read (struct target_ops
*ops
,
1431 enum target_object object
,
1432 const char *annex
, gdb_byte
*buf
,
1433 ULONGEST offset
, LONGEST len
)
1436 while (xfered
< len
)
1438 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1439 (gdb_byte
*) buf
+ xfered
,
1440 offset
+ xfered
, len
- xfered
);
1441 /* Call an observer, notifying them of the xfer progress? */
1453 target_read_until_error (struct target_ops
*ops
,
1454 enum target_object object
,
1455 const char *annex
, gdb_byte
*buf
,
1456 ULONGEST offset
, LONGEST len
)
1459 while (xfered
< len
)
1461 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1462 (gdb_byte
*) buf
+ xfered
,
1463 offset
+ xfered
, len
- xfered
);
1464 /* Call an observer, notifying them of the xfer progress? */
1469 /* We've got an error. Try to read in smaller blocks. */
1470 ULONGEST start
= offset
+ xfered
;
1471 ULONGEST remaining
= len
- xfered
;
1474 /* If an attempt was made to read a random memory address,
1475 it's likely that the very first byte is not accessible.
1476 Try reading the first byte, to avoid doing log N tries
1478 xfer
= target_read_partial (ops
, object
, annex
,
1479 (gdb_byte
*) buf
+ xfered
, start
, 1);
1488 xfer
= target_read_partial (ops
, object
, annex
,
1489 (gdb_byte
*) buf
+ xfered
,
1499 /* We have successfully read the first half. So, the
1500 error must be in the second half. Adjust start and
1501 remaining to point at the second half. */
1518 /* An alternative to target_write with progress callbacks. */
1521 target_write_with_progress (struct target_ops
*ops
,
1522 enum target_object object
,
1523 const char *annex
, const gdb_byte
*buf
,
1524 ULONGEST offset
, LONGEST len
,
1525 void (*progress
) (ULONGEST
, void *), void *baton
)
1529 /* Give the progress callback a chance to set up. */
1531 (*progress
) (0, baton
);
1533 while (xfered
< len
)
1535 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1536 (gdb_byte
*) buf
+ xfered
,
1537 offset
+ xfered
, len
- xfered
);
1545 (*progress
) (xfer
, baton
);
1554 target_write (struct target_ops
*ops
,
1555 enum target_object object
,
1556 const char *annex
, const gdb_byte
*buf
,
1557 ULONGEST offset
, LONGEST len
)
1559 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1563 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1564 the size of the transferred data. PADDING additional bytes are
1565 available in *BUF_P. This is a helper function for
1566 target_read_alloc; see the declaration of that function for more
1570 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1571 const char *annex
, gdb_byte
**buf_p
, int padding
)
1573 size_t buf_alloc
, buf_pos
;
1577 /* This function does not have a length parameter; it reads the
1578 entire OBJECT). Also, it doesn't support objects fetched partly
1579 from one target and partly from another (in a different stratum,
1580 e.g. a core file and an executable). Both reasons make it
1581 unsuitable for reading memory. */
1582 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1584 /* Start by reading up to 4K at a time. The target will throttle
1585 this number down if necessary. */
1587 buf
= xmalloc (buf_alloc
);
1591 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1592 buf_pos
, buf_alloc
- buf_pos
- padding
);
1595 /* An error occurred. */
1601 /* Read all there was. */
1611 /* If the buffer is filling up, expand it. */
1612 if (buf_alloc
< buf_pos
* 2)
1615 buf
= xrealloc (buf
, buf_alloc
);
1622 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1623 the size of the transferred data. See the declaration in "target.h"
1624 function for more information about the return value. */
1627 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1628 const char *annex
, gdb_byte
**buf_p
)
1630 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1633 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1634 returned as a string, allocated using xmalloc. If an error occurs
1635 or the transfer is unsupported, NULL is returned. Empty objects
1636 are returned as allocated but empty strings. A warning is issued
1637 if the result contains any embedded NUL bytes. */
1640 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1644 LONGEST transferred
;
1646 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1648 if (transferred
< 0)
1651 if (transferred
== 0)
1652 return xstrdup ("");
1654 buffer
[transferred
] = 0;
1655 if (strlen (buffer
) < transferred
)
1656 warning (_("target object %d, annex %s, "
1657 "contained unexpected null characters"),
1658 (int) object
, annex
? annex
: "(none)");
1660 return (char *) buffer
;
1663 /* Memory transfer methods. */
1666 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1669 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1671 memory_error (EIO
, addr
);
1675 get_target_memory_unsigned (struct target_ops
*ops
,
1676 CORE_ADDR addr
, int len
)
1678 gdb_byte buf
[sizeof (ULONGEST
)];
1680 gdb_assert (len
<= sizeof (buf
));
1681 get_target_memory (ops
, addr
, buf
, len
);
1682 return extract_unsigned_integer (buf
, len
);
1686 target_info (char *args
, int from_tty
)
1688 struct target_ops
*t
;
1689 int has_all_mem
= 0;
1691 if (symfile_objfile
!= NULL
)
1692 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1694 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1696 if (!t
->to_has_memory
)
1699 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1702 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1703 printf_unfiltered ("%s:\n", t
->to_longname
);
1704 (t
->to_files_info
) (t
);
1705 has_all_mem
= t
->to_has_all_memory
;
1709 /* This function is called before any new inferior is created, e.g.
1710 by running a program, attaching, or connecting to a target.
1711 It cleans up any state from previous invocations which might
1712 change between runs. This is a subset of what target_preopen
1713 resets (things which might change between targets). */
1716 target_pre_inferior (int from_tty
)
1718 /* Clear out solib state. Otherwise the solib state of the previous
1719 inferior might have survived and is entirely wrong for the new
1720 target. This has been observed on GNU/Linux using glibc 2.3. How
1732 Cannot access memory at address 0xdeadbeef
1734 no_shared_libraries (NULL
, from_tty
);
1736 invalidate_target_mem_regions ();
1738 target_clear_description ();
1741 /* This is to be called by the open routine before it does
1745 target_preopen (int from_tty
)
1749 if (target_has_execution
)
1752 || query (_("A program is being debugged already. Kill it? ")))
1755 error (_("Program not killed."));
1758 /* Calling target_kill may remove the target from the stack. But if
1759 it doesn't (which seems like a win for UDI), remove it now. */
1760 /* Leave the exec target, though. The user may be switching from a
1761 live process to a core of the same program. */
1762 pop_all_targets_above (file_stratum
, 0);
1764 target_pre_inferior (from_tty
);
1767 /* Detach a target after doing deferred register stores. */
1770 target_detach (char *args
, int from_tty
)
1772 /* If we're in breakpoints-always-inserted mode, have to
1773 remove them before detaching. */
1774 remove_breakpoints ();
1776 (current_target
.to_detach
) (args
, from_tty
);
1780 target_disconnect (char *args
, int from_tty
)
1782 struct target_ops
*t
;
1784 /* If we're in breakpoints-always-inserted mode, have to
1785 remove them before disconnecting. */
1786 remove_breakpoints ();
1788 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1789 if (t
->to_disconnect
!= NULL
)
1792 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1794 t
->to_disconnect (t
, args
, from_tty
);
1802 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1804 dcache_invalidate (target_dcache
);
1805 (*current_target
.to_resume
) (ptid
, step
, signal
);
1806 set_executing (ptid
, 1);
1807 set_running (ptid
, 1);
1809 /* Look through the list of possible targets for a target that can
1813 target_follow_fork (int follow_child
)
1815 struct target_ops
*t
;
1817 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1819 if (t
->to_follow_fork
!= NULL
)
1821 int retval
= t
->to_follow_fork (t
, follow_child
);
1823 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1824 follow_child
, retval
);
1829 /* Some target returned a fork event, but did not know how to follow it. */
1830 internal_error (__FILE__
, __LINE__
,
1831 "could not find a target to follow fork");
1834 /* Look for a target which can describe architectural features, starting
1835 from TARGET. If we find one, return its description. */
1837 const struct target_desc
*
1838 target_read_description (struct target_ops
*target
)
1840 struct target_ops
*t
;
1842 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1843 if (t
->to_read_description
!= NULL
)
1845 const struct target_desc
*tdesc
;
1847 tdesc
= t
->to_read_description (t
);
1855 /* The default implementation of to_search_memory.
1856 This implements a basic search of memory, reading target memory and
1857 performing the search here (as opposed to performing the search in on the
1858 target side with, for example, gdbserver). */
1861 simple_search_memory (struct target_ops
*ops
,
1862 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1863 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1864 CORE_ADDR
*found_addrp
)
1866 /* NOTE: also defined in find.c testcase. */
1867 #define SEARCH_CHUNK_SIZE 16000
1868 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1869 /* Buffer to hold memory contents for searching. */
1870 gdb_byte
*search_buf
;
1871 unsigned search_buf_size
;
1872 struct cleanup
*old_cleanups
;
1874 search_buf_size
= chunk_size
+ pattern_len
- 1;
1876 /* No point in trying to allocate a buffer larger than the search space. */
1877 if (search_space_len
< search_buf_size
)
1878 search_buf_size
= search_space_len
;
1880 search_buf
= malloc (search_buf_size
);
1881 if (search_buf
== NULL
)
1882 error (_("Unable to allocate memory to perform the search."));
1883 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1885 /* Prime the search buffer. */
1887 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1888 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1890 warning (_("Unable to access target memory at %s, halting search."),
1891 hex_string (start_addr
));
1892 do_cleanups (old_cleanups
);
1896 /* Perform the search.
1898 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1899 When we've scanned N bytes we copy the trailing bytes to the start and
1900 read in another N bytes. */
1902 while (search_space_len
>= pattern_len
)
1904 gdb_byte
*found_ptr
;
1905 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1907 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1908 pattern
, pattern_len
);
1910 if (found_ptr
!= NULL
)
1912 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1913 *found_addrp
= found_addr
;
1914 do_cleanups (old_cleanups
);
1918 /* Not found in this chunk, skip to next chunk. */
1920 /* Don't let search_space_len wrap here, it's unsigned. */
1921 if (search_space_len
>= chunk_size
)
1922 search_space_len
-= chunk_size
;
1924 search_space_len
= 0;
1926 if (search_space_len
>= pattern_len
)
1928 unsigned keep_len
= search_buf_size
- chunk_size
;
1929 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1932 /* Copy the trailing part of the previous iteration to the front
1933 of the buffer for the next iteration. */
1934 gdb_assert (keep_len
== pattern_len
- 1);
1935 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1937 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1939 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1940 search_buf
+ keep_len
, read_addr
,
1941 nr_to_read
) != nr_to_read
)
1943 warning (_("Unable to access target memory at %s, halting search."),
1944 hex_string (read_addr
));
1945 do_cleanups (old_cleanups
);
1949 start_addr
+= chunk_size
;
1955 do_cleanups (old_cleanups
);
1959 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1960 sequence of bytes in PATTERN with length PATTERN_LEN.
1962 The result is 1 if found, 0 if not found, and -1 if there was an error
1963 requiring halting of the search (e.g. memory read error).
1964 If the pattern is found the address is recorded in FOUND_ADDRP. */
1967 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1968 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1969 CORE_ADDR
*found_addrp
)
1971 struct target_ops
*t
;
1974 /* We don't use INHERIT to set current_target.to_search_memory,
1975 so we have to scan the target stack and handle targetdebug
1979 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1980 hex_string (start_addr
));
1982 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1983 if (t
->to_search_memory
!= NULL
)
1988 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
1989 pattern
, pattern_len
, found_addrp
);
1993 /* If a special version of to_search_memory isn't available, use the
1995 found
= simple_search_memory (¤t_target
,
1996 start_addr
, search_space_len
,
1997 pattern
, pattern_len
, found_addrp
);
2001 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2006 /* Look through the currently pushed targets. If none of them will
2007 be able to restart the currently running process, issue an error
2011 target_require_runnable (void)
2013 struct target_ops
*t
;
2015 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2017 /* If this target knows how to create a new program, then
2018 assume we will still be able to after killing the current
2019 one. Either killing and mourning will not pop T, or else
2020 find_default_run_target will find it again. */
2021 if (t
->to_create_inferior
!= NULL
)
2024 /* Do not worry about thread_stratum targets that can not
2025 create inferiors. Assume they will be pushed again if
2026 necessary, and continue to the process_stratum. */
2027 if (t
->to_stratum
== thread_stratum
)
2031 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2035 /* This function is only called if the target is running. In that
2036 case there should have been a process_stratum target and it
2037 should either know how to create inferiors, or not... */
2038 internal_error (__FILE__
, __LINE__
, "No targets found");
2041 /* Look through the list of possible targets for a target that can
2042 execute a run or attach command without any other data. This is
2043 used to locate the default process stratum.
2045 If DO_MESG is not NULL, the result is always valid (error() is
2046 called for errors); else, return NULL on error. */
2048 static struct target_ops
*
2049 find_default_run_target (char *do_mesg
)
2051 struct target_ops
**t
;
2052 struct target_ops
*runable
= NULL
;
2057 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2060 if ((*t
)->to_can_run
&& target_can_run (*t
))
2070 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2079 find_default_attach (char *args
, int from_tty
)
2081 struct target_ops
*t
;
2083 t
= find_default_run_target ("attach");
2084 (t
->to_attach
) (args
, from_tty
);
2089 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2092 struct target_ops
*t
;
2094 t
= find_default_run_target ("run");
2095 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2100 find_default_can_async_p (void)
2102 struct target_ops
*t
;
2104 /* This may be called before the target is pushed on the stack;
2105 look for the default process stratum. If there's none, gdb isn't
2106 configured with a native debugger, and target remote isn't
2108 t
= find_default_run_target (NULL
);
2109 if (t
&& t
->to_can_async_p
)
2110 return (t
->to_can_async_p
) ();
2115 find_default_is_async_p (void)
2117 struct target_ops
*t
;
2119 /* This may be called before the target is pushed on the stack;
2120 look for the default process stratum. If there's none, gdb isn't
2121 configured with a native debugger, and target remote isn't
2123 t
= find_default_run_target (NULL
);
2124 if (t
&& t
->to_is_async_p
)
2125 return (t
->to_is_async_p
) ();
2130 find_default_supports_non_stop (void)
2132 struct target_ops
*t
;
2134 t
= find_default_run_target (NULL
);
2135 if (t
&& t
->to_supports_non_stop
)
2136 return (t
->to_supports_non_stop
) ();
2141 target_supports_non_stop ()
2143 struct target_ops
*t
;
2144 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2145 if (t
->to_supports_non_stop
)
2146 return t
->to_supports_non_stop ();
2153 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2155 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2159 default_watchpoint_addr_within_range (struct target_ops
*target
,
2161 CORE_ADDR start
, int length
)
2163 return addr
>= start
&& addr
< start
+ length
;
2179 return_minus_one (void)
2185 * Resize the to_sections pointer. Also make sure that anyone that
2186 * was holding on to an old value of it gets updated.
2187 * Returns the old size.
2191 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2193 struct target_ops
**t
;
2194 struct section_table
*old_value
;
2197 old_value
= target
->to_sections
;
2199 if (target
->to_sections
)
2201 old_count
= target
->to_sections_end
- target
->to_sections
;
2202 target
->to_sections
= (struct section_table
*)
2203 xrealloc ((char *) target
->to_sections
,
2204 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2209 target
->to_sections
= (struct section_table
*)
2210 xmalloc ((sizeof (struct section_table
)) * num_added
);
2212 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2214 /* Check to see if anyone else was pointing to this structure.
2215 If old_value was null, then no one was. */
2219 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2222 if ((*t
)->to_sections
== old_value
)
2224 (*t
)->to_sections
= target
->to_sections
;
2225 (*t
)->to_sections_end
= target
->to_sections_end
;
2228 /* There is a flattened view of the target stack in current_target,
2229 so its to_sections pointer might also need updating. */
2230 if (current_target
.to_sections
== old_value
)
2232 current_target
.to_sections
= target
->to_sections
;
2233 current_target
.to_sections_end
= target
->to_sections_end
;
2241 /* Remove all target sections taken from ABFD.
2243 Scan the current target stack for targets whose section tables
2244 refer to sections from BFD, and remove those sections. We use this
2245 when we notice that the inferior has unloaded a shared object, for
2248 remove_target_sections (bfd
*abfd
)
2250 struct target_ops
**t
;
2252 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2254 struct section_table
*src
, *dest
;
2256 dest
= (*t
)->to_sections
;
2257 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2258 if (src
->bfd
!= abfd
)
2260 /* Keep this section. */
2261 if (dest
< src
) *dest
= *src
;
2265 /* If we've dropped any sections, resize the section table. */
2267 target_resize_to_sections (*t
, dest
- src
);
2274 /* Find a single runnable target in the stack and return it. If for
2275 some reason there is more than one, return NULL. */
2278 find_run_target (void)
2280 struct target_ops
**t
;
2281 struct target_ops
*runable
= NULL
;
2286 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2288 if ((*t
)->to_can_run
&& target_can_run (*t
))
2295 return (count
== 1 ? runable
: NULL
);
2298 /* Find a single core_stratum target in the list of targets and return it.
2299 If for some reason there is more than one, return NULL. */
2302 find_core_target (void)
2304 struct target_ops
**t
;
2305 struct target_ops
*runable
= NULL
;
2310 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2313 if ((*t
)->to_stratum
== core_stratum
)
2320 return (count
== 1 ? runable
: NULL
);
2324 * Find the next target down the stack from the specified target.
2328 find_target_beneath (struct target_ops
*t
)
2334 /* The inferior process has died. Long live the inferior! */
2337 generic_mourn_inferior (void)
2339 extern int show_breakpoint_hit_counts
;
2342 ptid
= inferior_ptid
;
2343 inferior_ptid
= null_ptid
;
2345 if (!ptid_equal (ptid
, null_ptid
))
2347 int pid
= ptid_get_pid (ptid
);
2348 delete_inferior (pid
);
2351 breakpoint_init_inferior (inf_exited
);
2352 registers_changed ();
2354 reopen_exec_file ();
2355 reinit_frame_cache ();
2357 /* It is confusing to the user for ignore counts to stick around
2358 from previous runs of the inferior. So clear them. */
2359 /* However, it is more confusing for the ignore counts to disappear when
2360 using hit counts. So don't clear them if we're counting hits. */
2361 if (!show_breakpoint_hit_counts
)
2362 breakpoint_clear_ignore_counts ();
2364 if (deprecated_detach_hook
)
2365 deprecated_detach_hook ();
2368 /* Helper function for child_wait and the derivatives of child_wait.
2369 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2370 translation of that in OURSTATUS. */
2372 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2374 if (WIFEXITED (hoststatus
))
2376 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2377 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2379 else if (!WIFSTOPPED (hoststatus
))
2381 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2382 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2386 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2387 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2391 /* Returns zero to leave the inferior alone, one to interrupt it. */
2392 int (*target_activity_function
) (void);
2393 int target_activity_fd
;
2395 /* Convert a normal process ID to a string. Returns the string in a
2399 normal_pid_to_str (ptid_t ptid
)
2401 static char buf
[32];
2403 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2407 /* Error-catcher for target_find_memory_regions */
2408 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2410 error (_("No target."));
2414 /* Error-catcher for target_make_corefile_notes */
2415 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2417 error (_("No target."));
2421 /* Set up the handful of non-empty slots needed by the dummy target
2425 init_dummy_target (void)
2427 dummy_target
.to_shortname
= "None";
2428 dummy_target
.to_longname
= "None";
2429 dummy_target
.to_doc
= "";
2430 dummy_target
.to_attach
= find_default_attach
;
2431 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2432 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2433 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2434 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2435 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2436 dummy_target
.to_stratum
= dummy_stratum
;
2437 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2438 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2439 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2440 dummy_target
.to_magic
= OPS_MAGIC
;
2444 debug_to_open (char *args
, int from_tty
)
2446 debug_target
.to_open (args
, from_tty
);
2448 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2452 debug_to_close (int quitting
)
2454 target_close (&debug_target
, quitting
);
2455 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2459 target_close (struct target_ops
*targ
, int quitting
)
2461 if (targ
->to_xclose
!= NULL
)
2462 targ
->to_xclose (targ
, quitting
);
2463 else if (targ
->to_close
!= NULL
)
2464 targ
->to_close (quitting
);
2468 debug_to_attach (char *args
, int from_tty
)
2470 debug_target
.to_attach (args
, from_tty
);
2472 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2477 debug_to_post_attach (int pid
)
2479 debug_target
.to_post_attach (pid
);
2481 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2485 debug_to_detach (char *args
, int from_tty
)
2487 debug_target
.to_detach (args
, from_tty
);
2489 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2493 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2495 debug_target
.to_resume (ptid
, step
, siggnal
);
2497 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2498 step
? "step" : "continue",
2499 target_signal_to_name (siggnal
));
2503 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2507 retval
= debug_target
.to_wait (ptid
, status
);
2509 fprintf_unfiltered (gdb_stdlog
,
2510 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2512 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2513 switch (status
->kind
)
2515 case TARGET_WAITKIND_EXITED
:
2516 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2517 status
->value
.integer
);
2519 case TARGET_WAITKIND_STOPPED
:
2520 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2521 target_signal_to_name (status
->value
.sig
));
2523 case TARGET_WAITKIND_SIGNALLED
:
2524 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2525 target_signal_to_name (status
->value
.sig
));
2527 case TARGET_WAITKIND_LOADED
:
2528 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2530 case TARGET_WAITKIND_FORKED
:
2531 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2533 case TARGET_WAITKIND_VFORKED
:
2534 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2536 case TARGET_WAITKIND_EXECD
:
2537 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2539 case TARGET_WAITKIND_SPURIOUS
:
2540 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2543 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2551 debug_print_register (const char * func
,
2552 struct regcache
*regcache
, int regno
)
2554 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2555 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2556 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2557 && gdbarch_register_name (gdbarch
, regno
) != NULL
2558 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2559 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2560 gdbarch_register_name (gdbarch
, regno
));
2562 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2563 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2565 int i
, size
= register_size (gdbarch
, regno
);
2566 unsigned char buf
[MAX_REGISTER_SIZE
];
2567 regcache_raw_collect (regcache
, regno
, buf
);
2568 fprintf_unfiltered (gdb_stdlog
, " = ");
2569 for (i
= 0; i
< size
; i
++)
2571 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2573 if (size
<= sizeof (LONGEST
))
2575 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2576 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2577 core_addr_to_string_nz (val
), plongest (val
));
2580 fprintf_unfiltered (gdb_stdlog
, "\n");
2584 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2586 debug_target
.to_fetch_registers (regcache
, regno
);
2587 debug_print_register ("target_fetch_registers", regcache
, regno
);
2591 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2593 debug_target
.to_store_registers (regcache
, regno
);
2594 debug_print_register ("target_store_registers", regcache
, regno
);
2595 fprintf_unfiltered (gdb_stdlog
, "\n");
2599 debug_to_prepare_to_store (struct regcache
*regcache
)
2601 debug_target
.to_prepare_to_store (regcache
);
2603 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2607 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2608 int write
, struct mem_attrib
*attrib
,
2609 struct target_ops
*target
)
2613 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2616 fprintf_unfiltered (gdb_stdlog
,
2617 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2618 (unsigned int) memaddr
, /* possable truncate long long */
2619 len
, write
? "write" : "read", retval
);
2625 fputs_unfiltered (", bytes =", gdb_stdlog
);
2626 for (i
= 0; i
< retval
; i
++)
2628 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2630 if (targetdebug
< 2 && i
> 0)
2632 fprintf_unfiltered (gdb_stdlog
, " ...");
2635 fprintf_unfiltered (gdb_stdlog
, "\n");
2638 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2642 fputc_unfiltered ('\n', gdb_stdlog
);
2648 debug_to_files_info (struct target_ops
*target
)
2650 debug_target
.to_files_info (target
);
2652 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2656 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2660 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2662 fprintf_unfiltered (gdb_stdlog
,
2663 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2664 (unsigned long) bp_tgt
->placed_address
,
2665 (unsigned long) retval
);
2670 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2674 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2676 fprintf_unfiltered (gdb_stdlog
,
2677 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2678 (unsigned long) bp_tgt
->placed_address
,
2679 (unsigned long) retval
);
2684 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2688 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2690 fprintf_unfiltered (gdb_stdlog
,
2691 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2692 (unsigned long) type
,
2693 (unsigned long) cnt
,
2694 (unsigned long) from_tty
,
2695 (unsigned long) retval
);
2700 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2704 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2706 fprintf_unfiltered (gdb_stdlog
,
2707 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2708 (unsigned long) addr
,
2709 (unsigned long) len
,
2710 (unsigned long) retval
);
2715 debug_to_stopped_by_watchpoint (void)
2719 retval
= debug_target
.to_stopped_by_watchpoint ();
2721 fprintf_unfiltered (gdb_stdlog
,
2722 "STOPPED_BY_WATCHPOINT () = %ld\n",
2723 (unsigned long) retval
);
2728 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2732 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2734 fprintf_unfiltered (gdb_stdlog
,
2735 "target_stopped_data_address ([0x%lx]) = %ld\n",
2736 (unsigned long)*addr
,
2737 (unsigned long)retval
);
2742 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2744 CORE_ADDR start
, int length
)
2748 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2751 fprintf_filtered (gdb_stdlog
,
2752 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2753 (unsigned long) addr
, (unsigned long) start
, length
,
2759 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2763 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2765 fprintf_unfiltered (gdb_stdlog
,
2766 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2767 (unsigned long) bp_tgt
->placed_address
,
2768 (unsigned long) retval
);
2773 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2777 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2779 fprintf_unfiltered (gdb_stdlog
,
2780 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2781 (unsigned long) bp_tgt
->placed_address
,
2782 (unsigned long) retval
);
2787 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2791 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2793 fprintf_unfiltered (gdb_stdlog
,
2794 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2795 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2800 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2804 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2806 fprintf_unfiltered (gdb_stdlog
,
2807 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2808 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2813 debug_to_terminal_init (void)
2815 debug_target
.to_terminal_init ();
2817 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2821 debug_to_terminal_inferior (void)
2823 debug_target
.to_terminal_inferior ();
2825 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2829 debug_to_terminal_ours_for_output (void)
2831 debug_target
.to_terminal_ours_for_output ();
2833 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2837 debug_to_terminal_ours (void)
2839 debug_target
.to_terminal_ours ();
2841 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2845 debug_to_terminal_save_ours (void)
2847 debug_target
.to_terminal_save_ours ();
2849 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2853 debug_to_terminal_info (char *arg
, int from_tty
)
2855 debug_target
.to_terminal_info (arg
, from_tty
);
2857 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2862 debug_to_kill (void)
2864 debug_target
.to_kill ();
2866 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2870 debug_to_load (char *args
, int from_tty
)
2872 debug_target
.to_load (args
, from_tty
);
2874 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2878 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2882 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2884 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2890 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2893 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2895 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2896 exec_file
, args
, from_tty
);
2900 debug_to_post_startup_inferior (ptid_t ptid
)
2902 debug_target
.to_post_startup_inferior (ptid
);
2904 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2909 debug_to_acknowledge_created_inferior (int pid
)
2911 debug_target
.to_acknowledge_created_inferior (pid
);
2913 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2918 debug_to_insert_fork_catchpoint (int pid
)
2920 debug_target
.to_insert_fork_catchpoint (pid
);
2922 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2927 debug_to_remove_fork_catchpoint (int pid
)
2931 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2933 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2940 debug_to_insert_vfork_catchpoint (int pid
)
2942 debug_target
.to_insert_vfork_catchpoint (pid
);
2944 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2949 debug_to_remove_vfork_catchpoint (int pid
)
2953 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2955 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2962 debug_to_insert_exec_catchpoint (int pid
)
2964 debug_target
.to_insert_exec_catchpoint (pid
);
2966 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2971 debug_to_remove_exec_catchpoint (int pid
)
2975 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2977 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2984 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2988 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2990 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2991 pid
, wait_status
, *exit_status
, has_exited
);
2997 debug_to_mourn_inferior (void)
2999 debug_target
.to_mourn_inferior ();
3001 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3005 debug_to_can_run (void)
3009 retval
= debug_target
.to_can_run ();
3011 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3017 debug_to_notice_signals (ptid_t ptid
)
3019 debug_target
.to_notice_signals (ptid
);
3021 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3026 debug_to_thread_alive (ptid_t ptid
)
3030 retval
= debug_target
.to_thread_alive (ptid
);
3032 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3033 PIDGET (ptid
), retval
);
3039 debug_to_find_new_threads (void)
3041 debug_target
.to_find_new_threads ();
3043 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3047 debug_to_stop (ptid_t ptid
)
3049 debug_target
.to_stop (ptid
);
3051 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3052 target_pid_to_str (ptid
));
3056 debug_to_rcmd (char *command
,
3057 struct ui_file
*outbuf
)
3059 debug_target
.to_rcmd (command
, outbuf
);
3060 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3064 debug_to_pid_to_exec_file (int pid
)
3068 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3070 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3077 setup_target_debug (void)
3079 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3081 current_target
.to_open
= debug_to_open
;
3082 current_target
.to_close
= debug_to_close
;
3083 current_target
.to_attach
= debug_to_attach
;
3084 current_target
.to_post_attach
= debug_to_post_attach
;
3085 current_target
.to_detach
= debug_to_detach
;
3086 current_target
.to_resume
= debug_to_resume
;
3087 current_target
.to_wait
= debug_to_wait
;
3088 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3089 current_target
.to_store_registers
= debug_to_store_registers
;
3090 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3091 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3092 current_target
.to_files_info
= debug_to_files_info
;
3093 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3094 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3095 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3096 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3097 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3098 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3099 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3100 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3101 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3102 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3103 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3104 current_target
.to_terminal_init
= debug_to_terminal_init
;
3105 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3106 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3107 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3108 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3109 current_target
.to_terminal_info
= debug_to_terminal_info
;
3110 current_target
.to_kill
= debug_to_kill
;
3111 current_target
.to_load
= debug_to_load
;
3112 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3113 current_target
.to_create_inferior
= debug_to_create_inferior
;
3114 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3115 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3116 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3117 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3118 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3119 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3120 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3121 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3122 current_target
.to_has_exited
= debug_to_has_exited
;
3123 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3124 current_target
.to_can_run
= debug_to_can_run
;
3125 current_target
.to_notice_signals
= debug_to_notice_signals
;
3126 current_target
.to_thread_alive
= debug_to_thread_alive
;
3127 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3128 current_target
.to_stop
= debug_to_stop
;
3129 current_target
.to_rcmd
= debug_to_rcmd
;
3130 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3134 static char targ_desc
[] =
3135 "Names of targets and files being debugged.\n\
3136 Shows the entire stack of targets currently in use (including the exec-file,\n\
3137 core-file, and process, if any), as well as the symbol file name.";
3140 do_monitor_command (char *cmd
,
3143 if ((current_target
.to_rcmd
3144 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3145 || (current_target
.to_rcmd
== debug_to_rcmd
3146 && (debug_target
.to_rcmd
3147 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3148 error (_("\"monitor\" command not supported by this target."));
3149 target_rcmd (cmd
, gdb_stdtarg
);
3152 /* Print the name of each layers of our target stack. */
3155 maintenance_print_target_stack (char *cmd
, int from_tty
)
3157 struct target_ops
*t
;
3159 printf_filtered (_("The current target stack is:\n"));
3161 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3163 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3167 /* Controls if async mode is permitted. */
3168 int target_async_permitted
= 0;
3170 /* The set command writes to this variable. If the inferior is
3171 executing, linux_nat_async_permitted is *not* updated. */
3172 static int target_async_permitted_1
= 0;
3175 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3176 struct cmd_list_element
*c
)
3178 if (target_has_execution
)
3180 target_async_permitted_1
= target_async_permitted
;
3181 error (_("Cannot change this setting while the inferior is running."));
3184 target_async_permitted
= target_async_permitted_1
;
3188 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3189 struct cmd_list_element
*c
,
3192 fprintf_filtered (file
, _("\
3193 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3197 initialize_targets (void)
3199 init_dummy_target ();
3200 push_target (&dummy_target
);
3202 add_info ("target", target_info
, targ_desc
);
3203 add_info ("files", target_info
, targ_desc
);
3205 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3206 Set target debugging."), _("\
3207 Show target debugging."), _("\
3208 When non-zero, target debugging is enabled. Higher numbers are more\n\
3209 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3213 &setdebuglist
, &showdebuglist
);
3215 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3216 &trust_readonly
, _("\
3217 Set mode for reading from readonly sections."), _("\
3218 Show mode for reading from readonly sections."), _("\
3219 When this mode is on, memory reads from readonly sections (such as .text)\n\
3220 will be read from the object file instead of from the target. This will\n\
3221 result in significant performance improvement for remote targets."),
3223 show_trust_readonly
,
3224 &setlist
, &showlist
);
3226 add_com ("monitor", class_obscure
, do_monitor_command
,
3227 _("Send a command to the remote monitor (remote targets only)."));
3229 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3230 _("Print the name of each layer of the internal target stack."),
3231 &maintenanceprintlist
);
3233 add_setshow_boolean_cmd ("target-async", no_class
,
3234 &target_async_permitted_1
, _("\
3235 Set whether gdb controls the inferior in asynchronous mode."), _("\
3236 Show whether gdb controls the inferior in asynchronous mode."), _("\
3237 Tells gdb whether to control the inferior in asynchronous mode."),
3238 set_maintenance_target_async_permitted
,
3239 show_maintenance_target_async_permitted
,
3243 target_dcache
= dcache_init ();