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 /* Look for the specified target. Note that we assume that a target
750 can only occur once in the target stack. */
752 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
759 return 0; /* Didn't find target_ops, quit now */
761 /* NOTE: cagney/2003-12-06: In '94 the close call was made
762 unconditional by moving it to before the above check that the
763 target was in the target stack (something about "Change the way
764 pushing and popping of targets work to support target overlays
765 and inheritance"). This doesn't make much sense - only open
766 targets should be closed. */
769 /* Unchain the target */
771 (*cur
) = (*cur
)->beneath
;
774 update_current_target ();
782 target_close (target_stack
, 0); /* Let it clean up */
783 if (unpush_target (target_stack
) == 1)
786 fprintf_unfiltered (gdb_stderr
,
787 "pop_target couldn't find target %s\n",
788 current_target
.to_shortname
);
789 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
793 pop_all_targets_above (enum strata above_stratum
, int quitting
)
795 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
797 target_close (target_stack
, quitting
);
798 if (!unpush_target (target_stack
))
800 fprintf_unfiltered (gdb_stderr
,
801 "pop_all_targets couldn't find target %s\n",
802 target_stack
->to_shortname
);
803 internal_error (__FILE__
, __LINE__
,
804 _("failed internal consistency check"));
811 pop_all_targets (int quitting
)
813 pop_all_targets_above (dummy_stratum
, quitting
);
816 /* Using the objfile specified in OBJFILE, find the address for the
817 current thread's thread-local storage with offset OFFSET. */
819 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
821 volatile CORE_ADDR addr
= 0;
823 if (target_get_thread_local_address_p ()
824 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
826 ptid_t ptid
= inferior_ptid
;
827 volatile struct gdb_exception ex
;
829 TRY_CATCH (ex
, RETURN_MASK_ALL
)
833 /* Fetch the load module address for this objfile. */
834 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
836 /* If it's 0, throw the appropriate exception. */
838 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
839 _("TLS load module not found"));
841 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
843 /* If an error occurred, print TLS related messages here. Otherwise,
844 throw the error to some higher catcher. */
847 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
851 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
852 error (_("Cannot find thread-local variables in this thread library."));
854 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
855 if (objfile_is_library
)
856 error (_("Cannot find shared library `%s' in dynamic"
857 " linker's load module list"), objfile
->name
);
859 error (_("Cannot find executable file `%s' in dynamic"
860 " linker's load module list"), objfile
->name
);
862 case TLS_NOT_ALLOCATED_YET_ERROR
:
863 if (objfile_is_library
)
864 error (_("The inferior has not yet allocated storage for"
865 " thread-local variables in\n"
866 "the shared library `%s'\n"
868 objfile
->name
, target_pid_to_str (ptid
));
870 error (_("The inferior has not yet allocated storage for"
871 " thread-local variables in\n"
872 "the executable `%s'\n"
874 objfile
->name
, target_pid_to_str (ptid
));
876 case TLS_GENERIC_ERROR
:
877 if (objfile_is_library
)
878 error (_("Cannot find thread-local storage for %s, "
879 "shared library %s:\n%s"),
880 target_pid_to_str (ptid
),
881 objfile
->name
, ex
.message
);
883 error (_("Cannot find thread-local storage for %s, "
884 "executable file %s:\n%s"),
885 target_pid_to_str (ptid
),
886 objfile
->name
, ex
.message
);
889 throw_exception (ex
);
894 /* It wouldn't be wrong here to try a gdbarch method, too; finding
895 TLS is an ABI-specific thing. But we don't do that yet. */
897 error (_("Cannot find thread-local variables on this target"));
903 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
905 /* target_read_string -- read a null terminated string, up to LEN bytes,
906 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
907 Set *STRING to a pointer to malloc'd memory containing the data; the caller
908 is responsible for freeing it. Return the number of bytes successfully
912 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
914 int tlen
, origlen
, offset
, i
;
918 int buffer_allocated
;
920 unsigned int nbytes_read
= 0;
924 /* Small for testing. */
925 buffer_allocated
= 4;
926 buffer
= xmalloc (buffer_allocated
);
933 tlen
= MIN (len
, 4 - (memaddr
& 3));
934 offset
= memaddr
& 3;
936 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
939 /* The transfer request might have crossed the boundary to an
940 unallocated region of memory. Retry the transfer, requesting
944 errcode
= target_read_memory (memaddr
, buf
, 1);
949 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
952 bytes
= bufptr
- buffer
;
953 buffer_allocated
*= 2;
954 buffer
= xrealloc (buffer
, buffer_allocated
);
955 bufptr
= buffer
+ bytes
;
958 for (i
= 0; i
< tlen
; i
++)
960 *bufptr
++ = buf
[i
+ offset
];
961 if (buf
[i
+ offset
] == '\000')
963 nbytes_read
+= i
+ 1;
979 /* Find a section containing ADDR. */
980 struct section_table
*
981 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
983 struct section_table
*secp
;
984 for (secp
= target
->to_sections
;
985 secp
< target
->to_sections_end
;
988 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
994 /* Perform a partial memory transfer. The arguments and return
995 value are just as for target_xfer_partial. */
998 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
999 ULONGEST memaddr
, LONGEST len
)
1003 struct mem_region
*region
;
1005 /* Zero length requests are ok and require no work. */
1009 /* Try the executable file, if "trust-readonly-sections" is set. */
1010 if (readbuf
!= NULL
&& trust_readonly
)
1012 struct section_table
*secp
;
1014 secp
= target_section_by_addr (ops
, memaddr
);
1016 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1018 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1021 /* Likewise for accesses to unmapped overlay sections. */
1022 if (readbuf
!= NULL
&& overlay_debugging
)
1024 struct obj_section
*section
= find_pc_overlay (memaddr
);
1025 if (pc_in_unmapped_range (memaddr
, section
))
1026 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1029 /* Try GDB's internal data cache. */
1030 region
= lookup_mem_region (memaddr
);
1031 /* region->hi == 0 means there's no upper bound. */
1032 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1035 reg_len
= region
->hi
- memaddr
;
1037 switch (region
->attrib
.mode
)
1040 if (writebuf
!= NULL
)
1045 if (readbuf
!= NULL
)
1050 /* We only support writing to flash during "load" for now. */
1051 if (writebuf
!= NULL
)
1052 error (_("Writing to flash memory forbidden in this context"));
1059 if (region
->attrib
.cache
)
1061 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1062 memory request will start back at current_target. */
1063 if (readbuf
!= NULL
)
1064 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1067 /* FIXME drow/2006-08-09: If we're going to preserve const
1068 correctness dcache_xfer_memory should take readbuf and
1070 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1077 if (readbuf
&& !show_memory_breakpoints
)
1078 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1083 /* If none of those methods found the memory we wanted, fall back
1084 to a target partial transfer. Normally a single call to
1085 to_xfer_partial is enough; if it doesn't recognize an object
1086 it will call the to_xfer_partial of the next target down.
1087 But for memory this won't do. Memory is the only target
1088 object which can be read from more than one valid target.
1089 A core file, for instance, could have some of memory but
1090 delegate other bits to the target below it. So, we must
1091 manually try all targets. */
1095 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1096 readbuf
, writebuf
, memaddr
, reg_len
);
1100 /* We want to continue past core files to executables, but not
1101 past a running target's memory. */
1102 if (ops
->to_has_all_memory
)
1107 while (ops
!= NULL
);
1109 if (readbuf
&& !show_memory_breakpoints
)
1110 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1112 /* If we still haven't got anything, return the last error. We
1118 restore_show_memory_breakpoints (void *arg
)
1120 show_memory_breakpoints
= (uintptr_t) arg
;
1124 make_show_memory_breakpoints_cleanup (int show
)
1126 int current
= show_memory_breakpoints
;
1127 show_memory_breakpoints
= show
;
1129 return make_cleanup (restore_show_memory_breakpoints
,
1130 (void *) (uintptr_t) current
);
1134 target_xfer_partial (struct target_ops
*ops
,
1135 enum target_object object
, const char *annex
,
1136 void *readbuf
, const void *writebuf
,
1137 ULONGEST offset
, LONGEST len
)
1141 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1143 /* If this is a memory transfer, let the memory-specific code
1144 have a look at it instead. Memory transfers are more
1146 if (object
== TARGET_OBJECT_MEMORY
)
1147 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1150 enum target_object raw_object
= object
;
1152 /* If this is a raw memory transfer, request the normal
1153 memory object from other layers. */
1154 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1155 raw_object
= TARGET_OBJECT_MEMORY
;
1157 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1158 writebuf
, offset
, len
);
1163 const unsigned char *myaddr
= NULL
;
1165 fprintf_unfiltered (gdb_stdlog
,
1166 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
1169 (annex
? annex
: "(null)"),
1170 (long) readbuf
, (long) writebuf
,
1171 core_addr_to_string_nz (offset
),
1172 plongest (len
), plongest (retval
));
1178 if (retval
> 0 && myaddr
!= NULL
)
1182 fputs_unfiltered (", bytes =", gdb_stdlog
);
1183 for (i
= 0; i
< retval
; i
++)
1185 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1187 if (targetdebug
< 2 && i
> 0)
1189 fprintf_unfiltered (gdb_stdlog
, " ...");
1192 fprintf_unfiltered (gdb_stdlog
, "\n");
1195 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1199 fputc_unfiltered ('\n', gdb_stdlog
);
1204 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1205 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1206 if any error occurs.
1208 If an error occurs, no guarantee is made about the contents of the data at
1209 MYADDR. In particular, the caller should not depend upon partial reads
1210 filling the buffer with good data. There is no way for the caller to know
1211 how much good data might have been transfered anyway. Callers that can
1212 deal with partial reads should call target_read (which will retry until
1213 it makes no progress, and then return how much was transferred). */
1216 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1218 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1219 myaddr
, memaddr
, len
) == len
)
1226 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1228 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1229 myaddr
, memaddr
, len
) == len
)
1235 /* Fetch the target's memory map. */
1238 target_memory_map (void)
1240 VEC(mem_region_s
) *result
;
1241 struct mem_region
*last_one
, *this_one
;
1243 struct target_ops
*t
;
1246 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1248 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1249 if (t
->to_memory_map
!= NULL
)
1255 result
= t
->to_memory_map (t
);
1259 qsort (VEC_address (mem_region_s
, result
),
1260 VEC_length (mem_region_s
, result
),
1261 sizeof (struct mem_region
), mem_region_cmp
);
1263 /* Check that regions do not overlap. Simultaneously assign
1264 a numbering for the "mem" commands to use to refer to
1267 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1269 this_one
->number
= ix
;
1271 if (last_one
&& last_one
->hi
> this_one
->lo
)
1273 warning (_("Overlapping regions in memory map: ignoring"));
1274 VEC_free (mem_region_s
, result
);
1277 last_one
= this_one
;
1284 target_flash_erase (ULONGEST address
, LONGEST length
)
1286 struct target_ops
*t
;
1288 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1289 if (t
->to_flash_erase
!= NULL
)
1292 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1293 paddr (address
), phex (length
, 0));
1294 t
->to_flash_erase (t
, address
, length
);
1302 target_flash_done (void)
1304 struct target_ops
*t
;
1306 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1307 if (t
->to_flash_done
!= NULL
)
1310 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1311 t
->to_flash_done (t
);
1318 #ifndef target_stopped_data_address_p
1320 target_stopped_data_address_p (struct target_ops
*target
)
1322 if (target
->to_stopped_data_address
1323 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1325 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1326 && (debug_target
.to_stopped_data_address
1327 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1334 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1335 struct cmd_list_element
*c
, const char *value
)
1337 fprintf_filtered (file
, _("\
1338 Mode for reading from readonly sections is %s.\n"),
1342 /* More generic transfers. */
1345 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1346 const char *annex
, gdb_byte
*readbuf
,
1347 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1349 if (object
== TARGET_OBJECT_MEMORY
1350 && ops
->deprecated_xfer_memory
!= NULL
)
1351 /* If available, fall back to the target's
1352 "deprecated_xfer_memory" method. */
1356 if (writebuf
!= NULL
)
1358 void *buffer
= xmalloc (len
);
1359 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1360 memcpy (buffer
, writebuf
, len
);
1361 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1362 1/*write*/, NULL
, ops
);
1363 do_cleanups (cleanup
);
1365 if (readbuf
!= NULL
)
1366 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1367 0/*read*/, NULL
, ops
);
1370 else if (xfered
== 0 && errno
== 0)
1371 /* "deprecated_xfer_memory" uses 0, cross checked against
1372 ERRNO as one indication of an error. */
1377 else if (ops
->beneath
!= NULL
)
1378 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1379 readbuf
, writebuf
, offset
, len
);
1384 /* The xfer_partial handler for the topmost target. Unlike the default,
1385 it does not need to handle memory specially; it just passes all
1386 requests down the stack. */
1389 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1390 const char *annex
, gdb_byte
*readbuf
,
1391 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1393 if (ops
->beneath
!= NULL
)
1394 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1395 readbuf
, writebuf
, offset
, len
);
1400 /* Target vector read/write partial wrapper functions.
1402 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1403 (inbuf, outbuf)", instead of separate read/write methods, make life
1407 target_read_partial (struct target_ops
*ops
,
1408 enum target_object object
,
1409 const char *annex
, gdb_byte
*buf
,
1410 ULONGEST offset
, LONGEST len
)
1412 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1416 target_write_partial (struct target_ops
*ops
,
1417 enum target_object object
,
1418 const char *annex
, const gdb_byte
*buf
,
1419 ULONGEST offset
, LONGEST len
)
1421 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1424 /* Wrappers to perform the full transfer. */
1426 target_read (struct target_ops
*ops
,
1427 enum target_object object
,
1428 const char *annex
, gdb_byte
*buf
,
1429 ULONGEST offset
, LONGEST len
)
1432 while (xfered
< len
)
1434 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1435 (gdb_byte
*) buf
+ xfered
,
1436 offset
+ xfered
, len
- xfered
);
1437 /* Call an observer, notifying them of the xfer progress? */
1449 target_read_until_error (struct target_ops
*ops
,
1450 enum target_object object
,
1451 const char *annex
, gdb_byte
*buf
,
1452 ULONGEST offset
, LONGEST len
)
1455 while (xfered
< len
)
1457 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1458 (gdb_byte
*) buf
+ xfered
,
1459 offset
+ xfered
, len
- xfered
);
1460 /* Call an observer, notifying them of the xfer progress? */
1465 /* We've got an error. Try to read in smaller blocks. */
1466 ULONGEST start
= offset
+ xfered
;
1467 ULONGEST remaining
= len
- xfered
;
1470 /* If an attempt was made to read a random memory address,
1471 it's likely that the very first byte is not accessible.
1472 Try reading the first byte, to avoid doing log N tries
1474 xfer
= target_read_partial (ops
, object
, annex
,
1475 (gdb_byte
*) buf
+ xfered
, start
, 1);
1484 xfer
= target_read_partial (ops
, object
, annex
,
1485 (gdb_byte
*) buf
+ xfered
,
1495 /* We have successfully read the first half. So, the
1496 error must be in the second half. Adjust start and
1497 remaining to point at the second half. */
1514 /* An alternative to target_write with progress callbacks. */
1517 target_write_with_progress (struct target_ops
*ops
,
1518 enum target_object object
,
1519 const char *annex
, const gdb_byte
*buf
,
1520 ULONGEST offset
, LONGEST len
,
1521 void (*progress
) (ULONGEST
, void *), void *baton
)
1525 /* Give the progress callback a chance to set up. */
1527 (*progress
) (0, baton
);
1529 while (xfered
< len
)
1531 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1532 (gdb_byte
*) buf
+ xfered
,
1533 offset
+ xfered
, len
- xfered
);
1541 (*progress
) (xfer
, baton
);
1550 target_write (struct target_ops
*ops
,
1551 enum target_object object
,
1552 const char *annex
, const gdb_byte
*buf
,
1553 ULONGEST offset
, LONGEST len
)
1555 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1559 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1560 the size of the transferred data. PADDING additional bytes are
1561 available in *BUF_P. This is a helper function for
1562 target_read_alloc; see the declaration of that function for more
1566 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1567 const char *annex
, gdb_byte
**buf_p
, int padding
)
1569 size_t buf_alloc
, buf_pos
;
1573 /* This function does not have a length parameter; it reads the
1574 entire OBJECT). Also, it doesn't support objects fetched partly
1575 from one target and partly from another (in a different stratum,
1576 e.g. a core file and an executable). Both reasons make it
1577 unsuitable for reading memory. */
1578 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1580 /* Start by reading up to 4K at a time. The target will throttle
1581 this number down if necessary. */
1583 buf
= xmalloc (buf_alloc
);
1587 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1588 buf_pos
, buf_alloc
- buf_pos
- padding
);
1591 /* An error occurred. */
1597 /* Read all there was. */
1607 /* If the buffer is filling up, expand it. */
1608 if (buf_alloc
< buf_pos
* 2)
1611 buf
= xrealloc (buf
, buf_alloc
);
1618 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1619 the size of the transferred data. See the declaration in "target.h"
1620 function for more information about the return value. */
1623 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1624 const char *annex
, gdb_byte
**buf_p
)
1626 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1629 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1630 returned as a string, allocated using xmalloc. If an error occurs
1631 or the transfer is unsupported, NULL is returned. Empty objects
1632 are returned as allocated but empty strings. A warning is issued
1633 if the result contains any embedded NUL bytes. */
1636 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1640 LONGEST transferred
;
1642 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1644 if (transferred
< 0)
1647 if (transferred
== 0)
1648 return xstrdup ("");
1650 buffer
[transferred
] = 0;
1651 if (strlen (buffer
) < transferred
)
1652 warning (_("target object %d, annex %s, "
1653 "contained unexpected null characters"),
1654 (int) object
, annex
? annex
: "(none)");
1656 return (char *) buffer
;
1659 /* Memory transfer methods. */
1662 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1665 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1667 memory_error (EIO
, addr
);
1671 get_target_memory_unsigned (struct target_ops
*ops
,
1672 CORE_ADDR addr
, int len
)
1674 gdb_byte buf
[sizeof (ULONGEST
)];
1676 gdb_assert (len
<= sizeof (buf
));
1677 get_target_memory (ops
, addr
, buf
, len
);
1678 return extract_unsigned_integer (buf
, len
);
1682 target_info (char *args
, int from_tty
)
1684 struct target_ops
*t
;
1685 int has_all_mem
= 0;
1687 if (symfile_objfile
!= NULL
)
1688 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1690 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1692 if (!t
->to_has_memory
)
1695 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1698 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1699 printf_unfiltered ("%s:\n", t
->to_longname
);
1700 (t
->to_files_info
) (t
);
1701 has_all_mem
= t
->to_has_all_memory
;
1705 /* This function is called before any new inferior is created, e.g.
1706 by running a program, attaching, or connecting to a target.
1707 It cleans up any state from previous invocations which might
1708 change between runs. This is a subset of what target_preopen
1709 resets (things which might change between targets). */
1712 target_pre_inferior (int from_tty
)
1714 /* Clear out solib state. Otherwise the solib state of the previous
1715 inferior might have survived and is entirely wrong for the new
1716 target. This has been observed on GNU/Linux using glibc 2.3. How
1728 Cannot access memory at address 0xdeadbeef
1730 no_shared_libraries (NULL
, from_tty
);
1732 invalidate_target_mem_regions ();
1734 target_clear_description ();
1737 /* This is to be called by the open routine before it does
1741 target_preopen (int from_tty
)
1745 if (target_has_execution
)
1748 || query (_("A program is being debugged already. Kill it? ")))
1751 error (_("Program not killed."));
1754 /* Calling target_kill may remove the target from the stack. But if
1755 it doesn't (which seems like a win for UDI), remove it now. */
1756 /* Leave the exec target, though. The user may be switching from a
1757 live process to a core of the same program. */
1758 pop_all_targets_above (file_stratum
, 0);
1760 target_pre_inferior (from_tty
);
1763 /* Detach a target after doing deferred register stores. */
1766 target_detach (char *args
, int from_tty
)
1768 /* If we're in breakpoints-always-inserted mode, have to
1769 remove them before detaching. */
1770 remove_breakpoints ();
1772 (current_target
.to_detach
) (args
, from_tty
);
1776 target_disconnect (char *args
, int from_tty
)
1778 struct target_ops
*t
;
1780 /* If we're in breakpoints-always-inserted mode, have to
1781 remove them before disconnecting. */
1782 remove_breakpoints ();
1784 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1785 if (t
->to_disconnect
!= NULL
)
1788 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1790 t
->to_disconnect (t
, args
, from_tty
);
1798 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1800 dcache_invalidate (target_dcache
);
1801 (*current_target
.to_resume
) (ptid
, step
, signal
);
1802 set_executing (ptid
, 1);
1803 set_running (ptid
, 1);
1805 /* Look through the list of possible targets for a target that can
1809 target_follow_fork (int follow_child
)
1811 struct target_ops
*t
;
1813 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1815 if (t
->to_follow_fork
!= NULL
)
1817 int retval
= t
->to_follow_fork (t
, follow_child
);
1819 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1820 follow_child
, retval
);
1825 /* Some target returned a fork event, but did not know how to follow it. */
1826 internal_error (__FILE__
, __LINE__
,
1827 "could not find a target to follow fork");
1830 /* Look for a target which can describe architectural features, starting
1831 from TARGET. If we find one, return its description. */
1833 const struct target_desc
*
1834 target_read_description (struct target_ops
*target
)
1836 struct target_ops
*t
;
1838 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1839 if (t
->to_read_description
!= NULL
)
1841 const struct target_desc
*tdesc
;
1843 tdesc
= t
->to_read_description (t
);
1851 /* The default implementation of to_search_memory.
1852 This implements a basic search of memory, reading target memory and
1853 performing the search here (as opposed to performing the search in on the
1854 target side with, for example, gdbserver). */
1857 simple_search_memory (struct target_ops
*ops
,
1858 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1859 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1860 CORE_ADDR
*found_addrp
)
1862 /* NOTE: also defined in find.c testcase. */
1863 #define SEARCH_CHUNK_SIZE 16000
1864 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1865 /* Buffer to hold memory contents for searching. */
1866 gdb_byte
*search_buf
;
1867 unsigned search_buf_size
;
1868 struct cleanup
*old_cleanups
;
1870 search_buf_size
= chunk_size
+ pattern_len
- 1;
1872 /* No point in trying to allocate a buffer larger than the search space. */
1873 if (search_space_len
< search_buf_size
)
1874 search_buf_size
= search_space_len
;
1876 search_buf
= malloc (search_buf_size
);
1877 if (search_buf
== NULL
)
1878 error (_("Unable to allocate memory to perform the search."));
1879 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1881 /* Prime the search buffer. */
1883 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1884 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1886 warning (_("Unable to access target memory at %s, halting search."),
1887 hex_string (start_addr
));
1888 do_cleanups (old_cleanups
);
1892 /* Perform the search.
1894 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1895 When we've scanned N bytes we copy the trailing bytes to the start and
1896 read in another N bytes. */
1898 while (search_space_len
>= pattern_len
)
1900 gdb_byte
*found_ptr
;
1901 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1903 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1904 pattern
, pattern_len
);
1906 if (found_ptr
!= NULL
)
1908 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1909 *found_addrp
= found_addr
;
1910 do_cleanups (old_cleanups
);
1914 /* Not found in this chunk, skip to next chunk. */
1916 /* Don't let search_space_len wrap here, it's unsigned. */
1917 if (search_space_len
>= chunk_size
)
1918 search_space_len
-= chunk_size
;
1920 search_space_len
= 0;
1922 if (search_space_len
>= pattern_len
)
1924 unsigned keep_len
= search_buf_size
- chunk_size
;
1925 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1928 /* Copy the trailing part of the previous iteration to the front
1929 of the buffer for the next iteration. */
1930 gdb_assert (keep_len
== pattern_len
- 1);
1931 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1933 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1935 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1936 search_buf
+ keep_len
, read_addr
,
1937 nr_to_read
) != nr_to_read
)
1939 warning (_("Unable to access target memory at %s, halting search."),
1940 hex_string (read_addr
));
1941 do_cleanups (old_cleanups
);
1945 start_addr
+= chunk_size
;
1951 do_cleanups (old_cleanups
);
1955 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1956 sequence of bytes in PATTERN with length PATTERN_LEN.
1958 The result is 1 if found, 0 if not found, and -1 if there was an error
1959 requiring halting of the search (e.g. memory read error).
1960 If the pattern is found the address is recorded in FOUND_ADDRP. */
1963 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1964 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1965 CORE_ADDR
*found_addrp
)
1967 struct target_ops
*t
;
1970 /* We don't use INHERIT to set current_target.to_search_memory,
1971 so we have to scan the target stack and handle targetdebug
1975 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1976 hex_string (start_addr
));
1978 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1979 if (t
->to_search_memory
!= NULL
)
1984 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
1985 pattern
, pattern_len
, found_addrp
);
1989 /* If a special version of to_search_memory isn't available, use the
1991 found
= simple_search_memory (¤t_target
,
1992 start_addr
, search_space_len
,
1993 pattern
, pattern_len
, found_addrp
);
1997 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2002 /* Look through the currently pushed targets. If none of them will
2003 be able to restart the currently running process, issue an error
2007 target_require_runnable (void)
2009 struct target_ops
*t
;
2011 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2013 /* If this target knows how to create a new program, then
2014 assume we will still be able to after killing the current
2015 one. Either killing and mourning will not pop T, or else
2016 find_default_run_target will find it again. */
2017 if (t
->to_create_inferior
!= NULL
)
2020 /* Do not worry about thread_stratum targets that can not
2021 create inferiors. Assume they will be pushed again if
2022 necessary, and continue to the process_stratum. */
2023 if (t
->to_stratum
== thread_stratum
)
2027 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2031 /* This function is only called if the target is running. In that
2032 case there should have been a process_stratum target and it
2033 should either know how to create inferiors, or not... */
2034 internal_error (__FILE__
, __LINE__
, "No targets found");
2037 /* Look through the list of possible targets for a target that can
2038 execute a run or attach command without any other data. This is
2039 used to locate the default process stratum.
2041 If DO_MESG is not NULL, the result is always valid (error() is
2042 called for errors); else, return NULL on error. */
2044 static struct target_ops
*
2045 find_default_run_target (char *do_mesg
)
2047 struct target_ops
**t
;
2048 struct target_ops
*runable
= NULL
;
2053 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2056 if ((*t
)->to_can_run
&& target_can_run (*t
))
2066 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2075 find_default_attach (char *args
, int from_tty
)
2077 struct target_ops
*t
;
2079 t
= find_default_run_target ("attach");
2080 (t
->to_attach
) (args
, from_tty
);
2085 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2088 struct target_ops
*t
;
2090 t
= find_default_run_target ("run");
2091 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2096 find_default_can_async_p (void)
2098 struct target_ops
*t
;
2100 /* This may be called before the target is pushed on the stack;
2101 look for the default process stratum. If there's none, gdb isn't
2102 configured with a native debugger, and target remote isn't
2104 t
= find_default_run_target (NULL
);
2105 if (t
&& t
->to_can_async_p
)
2106 return (t
->to_can_async_p
) ();
2111 find_default_is_async_p (void)
2113 struct target_ops
*t
;
2115 /* This may be called before the target is pushed on the stack;
2116 look for the default process stratum. If there's none, gdb isn't
2117 configured with a native debugger, and target remote isn't
2119 t
= find_default_run_target (NULL
);
2120 if (t
&& t
->to_is_async_p
)
2121 return (t
->to_is_async_p
) ();
2126 find_default_supports_non_stop (void)
2128 struct target_ops
*t
;
2130 t
= find_default_run_target (NULL
);
2131 if (t
&& t
->to_supports_non_stop
)
2132 return (t
->to_supports_non_stop
) ();
2137 target_supports_non_stop ()
2139 struct target_ops
*t
;
2140 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2141 if (t
->to_supports_non_stop
)
2142 return t
->to_supports_non_stop ();
2149 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2151 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2155 default_watchpoint_addr_within_range (struct target_ops
*target
,
2157 CORE_ADDR start
, int length
)
2159 return addr
>= start
&& addr
< start
+ length
;
2175 return_minus_one (void)
2181 * Resize the to_sections pointer. Also make sure that anyone that
2182 * was holding on to an old value of it gets updated.
2183 * Returns the old size.
2187 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2189 struct target_ops
**t
;
2190 struct section_table
*old_value
;
2193 old_value
= target
->to_sections
;
2195 if (target
->to_sections
)
2197 old_count
= target
->to_sections_end
- target
->to_sections
;
2198 target
->to_sections
= (struct section_table
*)
2199 xrealloc ((char *) target
->to_sections
,
2200 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2205 target
->to_sections
= (struct section_table
*)
2206 xmalloc ((sizeof (struct section_table
)) * num_added
);
2208 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2210 /* Check to see if anyone else was pointing to this structure.
2211 If old_value was null, then no one was. */
2215 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2218 if ((*t
)->to_sections
== old_value
)
2220 (*t
)->to_sections
= target
->to_sections
;
2221 (*t
)->to_sections_end
= target
->to_sections_end
;
2224 /* There is a flattened view of the target stack in current_target,
2225 so its to_sections pointer might also need updating. */
2226 if (current_target
.to_sections
== old_value
)
2228 current_target
.to_sections
= target
->to_sections
;
2229 current_target
.to_sections_end
= target
->to_sections_end
;
2237 /* Remove all target sections taken from ABFD.
2239 Scan the current target stack for targets whose section tables
2240 refer to sections from BFD, and remove those sections. We use this
2241 when we notice that the inferior has unloaded a shared object, for
2244 remove_target_sections (bfd
*abfd
)
2246 struct target_ops
**t
;
2248 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2250 struct section_table
*src
, *dest
;
2252 dest
= (*t
)->to_sections
;
2253 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2254 if (src
->bfd
!= abfd
)
2256 /* Keep this section. */
2257 if (dest
< src
) *dest
= *src
;
2261 /* If we've dropped any sections, resize the section table. */
2263 target_resize_to_sections (*t
, dest
- src
);
2270 /* Find a single runnable target in the stack and return it. If for
2271 some reason there is more than one, return NULL. */
2274 find_run_target (void)
2276 struct target_ops
**t
;
2277 struct target_ops
*runable
= NULL
;
2282 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2284 if ((*t
)->to_can_run
&& target_can_run (*t
))
2291 return (count
== 1 ? runable
: NULL
);
2294 /* Find a single core_stratum target in the list of targets and return it.
2295 If for some reason there is more than one, return NULL. */
2298 find_core_target (void)
2300 struct target_ops
**t
;
2301 struct target_ops
*runable
= NULL
;
2306 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2309 if ((*t
)->to_stratum
== core_stratum
)
2316 return (count
== 1 ? runable
: NULL
);
2320 * Find the next target down the stack from the specified target.
2324 find_target_beneath (struct target_ops
*t
)
2330 /* The inferior process has died. Long live the inferior! */
2333 generic_mourn_inferior (void)
2335 extern int show_breakpoint_hit_counts
;
2338 ptid
= inferior_ptid
;
2339 inferior_ptid
= null_ptid
;
2341 if (!ptid_equal (ptid
, null_ptid
))
2343 int pid
= ptid_get_pid (ptid
);
2344 delete_inferior (pid
);
2347 breakpoint_init_inferior (inf_exited
);
2348 registers_changed ();
2350 reopen_exec_file ();
2351 reinit_frame_cache ();
2353 /* It is confusing to the user for ignore counts to stick around
2354 from previous runs of the inferior. So clear them. */
2355 /* However, it is more confusing for the ignore counts to disappear when
2356 using hit counts. So don't clear them if we're counting hits. */
2357 if (!show_breakpoint_hit_counts
)
2358 breakpoint_clear_ignore_counts ();
2360 if (deprecated_detach_hook
)
2361 deprecated_detach_hook ();
2364 /* Helper function for child_wait and the derivatives of child_wait.
2365 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2366 translation of that in OURSTATUS. */
2368 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2370 if (WIFEXITED (hoststatus
))
2372 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2373 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2375 else if (!WIFSTOPPED (hoststatus
))
2377 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2378 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2382 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2383 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2387 /* Returns zero to leave the inferior alone, one to interrupt it. */
2388 int (*target_activity_function
) (void);
2389 int target_activity_fd
;
2391 /* Convert a normal process ID to a string. Returns the string in a
2395 normal_pid_to_str (ptid_t ptid
)
2397 static char buf
[32];
2399 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2403 /* Error-catcher for target_find_memory_regions */
2404 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2406 error (_("No target."));
2410 /* Error-catcher for target_make_corefile_notes */
2411 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2413 error (_("No target."));
2417 /* Set up the handful of non-empty slots needed by the dummy target
2421 init_dummy_target (void)
2423 dummy_target
.to_shortname
= "None";
2424 dummy_target
.to_longname
= "None";
2425 dummy_target
.to_doc
= "";
2426 dummy_target
.to_attach
= find_default_attach
;
2427 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2428 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2429 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2430 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2431 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2432 dummy_target
.to_stratum
= dummy_stratum
;
2433 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2434 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2435 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2436 dummy_target
.to_magic
= OPS_MAGIC
;
2440 debug_to_open (char *args
, int from_tty
)
2442 debug_target
.to_open (args
, from_tty
);
2444 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2448 debug_to_close (int quitting
)
2450 target_close (&debug_target
, quitting
);
2451 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2455 target_close (struct target_ops
*targ
, int quitting
)
2457 if (targ
->to_xclose
!= NULL
)
2458 targ
->to_xclose (targ
, quitting
);
2459 else if (targ
->to_close
!= NULL
)
2460 targ
->to_close (quitting
);
2464 debug_to_attach (char *args
, int from_tty
)
2466 debug_target
.to_attach (args
, from_tty
);
2468 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2473 debug_to_post_attach (int pid
)
2475 debug_target
.to_post_attach (pid
);
2477 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2481 debug_to_detach (char *args
, int from_tty
)
2483 debug_target
.to_detach (args
, from_tty
);
2485 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2489 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2491 debug_target
.to_resume (ptid
, step
, siggnal
);
2493 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2494 step
? "step" : "continue",
2495 target_signal_to_name (siggnal
));
2499 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2503 retval
= debug_target
.to_wait (ptid
, status
);
2505 fprintf_unfiltered (gdb_stdlog
,
2506 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2508 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2509 switch (status
->kind
)
2511 case TARGET_WAITKIND_EXITED
:
2512 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2513 status
->value
.integer
);
2515 case TARGET_WAITKIND_STOPPED
:
2516 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2517 target_signal_to_name (status
->value
.sig
));
2519 case TARGET_WAITKIND_SIGNALLED
:
2520 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2521 target_signal_to_name (status
->value
.sig
));
2523 case TARGET_WAITKIND_LOADED
:
2524 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2526 case TARGET_WAITKIND_FORKED
:
2527 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2529 case TARGET_WAITKIND_VFORKED
:
2530 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2532 case TARGET_WAITKIND_EXECD
:
2533 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2535 case TARGET_WAITKIND_SPURIOUS
:
2536 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2539 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2547 debug_print_register (const char * func
,
2548 struct regcache
*regcache
, int regno
)
2550 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2551 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2552 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2553 && gdbarch_register_name (gdbarch
, regno
) != NULL
2554 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2555 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2556 gdbarch_register_name (gdbarch
, regno
));
2558 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2559 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2561 int i
, size
= register_size (gdbarch
, regno
);
2562 unsigned char buf
[MAX_REGISTER_SIZE
];
2563 regcache_raw_collect (regcache
, regno
, buf
);
2564 fprintf_unfiltered (gdb_stdlog
, " = ");
2565 for (i
= 0; i
< size
; i
++)
2567 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2569 if (size
<= sizeof (LONGEST
))
2571 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2572 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2573 core_addr_to_string_nz (val
), plongest (val
));
2576 fprintf_unfiltered (gdb_stdlog
, "\n");
2580 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2582 debug_target
.to_fetch_registers (regcache
, regno
);
2583 debug_print_register ("target_fetch_registers", regcache
, regno
);
2587 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2589 debug_target
.to_store_registers (regcache
, regno
);
2590 debug_print_register ("target_store_registers", regcache
, regno
);
2591 fprintf_unfiltered (gdb_stdlog
, "\n");
2595 debug_to_prepare_to_store (struct regcache
*regcache
)
2597 debug_target
.to_prepare_to_store (regcache
);
2599 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2603 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2604 int write
, struct mem_attrib
*attrib
,
2605 struct target_ops
*target
)
2609 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2612 fprintf_unfiltered (gdb_stdlog
,
2613 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2614 (unsigned int) memaddr
, /* possable truncate long long */
2615 len
, write
? "write" : "read", retval
);
2621 fputs_unfiltered (", bytes =", gdb_stdlog
);
2622 for (i
= 0; i
< retval
; i
++)
2624 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2626 if (targetdebug
< 2 && i
> 0)
2628 fprintf_unfiltered (gdb_stdlog
, " ...");
2631 fprintf_unfiltered (gdb_stdlog
, "\n");
2634 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2638 fputc_unfiltered ('\n', gdb_stdlog
);
2644 debug_to_files_info (struct target_ops
*target
)
2646 debug_target
.to_files_info (target
);
2648 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2652 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2656 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2658 fprintf_unfiltered (gdb_stdlog
,
2659 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2660 (unsigned long) bp_tgt
->placed_address
,
2661 (unsigned long) retval
);
2666 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2670 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2672 fprintf_unfiltered (gdb_stdlog
,
2673 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2674 (unsigned long) bp_tgt
->placed_address
,
2675 (unsigned long) retval
);
2680 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2684 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2686 fprintf_unfiltered (gdb_stdlog
,
2687 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2688 (unsigned long) type
,
2689 (unsigned long) cnt
,
2690 (unsigned long) from_tty
,
2691 (unsigned long) retval
);
2696 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2700 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2702 fprintf_unfiltered (gdb_stdlog
,
2703 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2704 (unsigned long) addr
,
2705 (unsigned long) len
,
2706 (unsigned long) retval
);
2711 debug_to_stopped_by_watchpoint (void)
2715 retval
= debug_target
.to_stopped_by_watchpoint ();
2717 fprintf_unfiltered (gdb_stdlog
,
2718 "STOPPED_BY_WATCHPOINT () = %ld\n",
2719 (unsigned long) retval
);
2724 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2728 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2730 fprintf_unfiltered (gdb_stdlog
,
2731 "target_stopped_data_address ([0x%lx]) = %ld\n",
2732 (unsigned long)*addr
,
2733 (unsigned long)retval
);
2738 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2740 CORE_ADDR start
, int length
)
2744 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2747 fprintf_filtered (gdb_stdlog
,
2748 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2749 (unsigned long) addr
, (unsigned long) start
, length
,
2755 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2759 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2761 fprintf_unfiltered (gdb_stdlog
,
2762 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2763 (unsigned long) bp_tgt
->placed_address
,
2764 (unsigned long) retval
);
2769 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2773 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2775 fprintf_unfiltered (gdb_stdlog
,
2776 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2777 (unsigned long) bp_tgt
->placed_address
,
2778 (unsigned long) retval
);
2783 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2787 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2789 fprintf_unfiltered (gdb_stdlog
,
2790 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2791 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2796 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2800 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2802 fprintf_unfiltered (gdb_stdlog
,
2803 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2804 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2809 debug_to_terminal_init (void)
2811 debug_target
.to_terminal_init ();
2813 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2817 debug_to_terminal_inferior (void)
2819 debug_target
.to_terminal_inferior ();
2821 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2825 debug_to_terminal_ours_for_output (void)
2827 debug_target
.to_terminal_ours_for_output ();
2829 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2833 debug_to_terminal_ours (void)
2835 debug_target
.to_terminal_ours ();
2837 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2841 debug_to_terminal_save_ours (void)
2843 debug_target
.to_terminal_save_ours ();
2845 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2849 debug_to_terminal_info (char *arg
, int from_tty
)
2851 debug_target
.to_terminal_info (arg
, from_tty
);
2853 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2858 debug_to_kill (void)
2860 debug_target
.to_kill ();
2862 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2866 debug_to_load (char *args
, int from_tty
)
2868 debug_target
.to_load (args
, from_tty
);
2870 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2874 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2878 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2880 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2886 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2889 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2891 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2892 exec_file
, args
, from_tty
);
2896 debug_to_post_startup_inferior (ptid_t ptid
)
2898 debug_target
.to_post_startup_inferior (ptid
);
2900 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2905 debug_to_acknowledge_created_inferior (int pid
)
2907 debug_target
.to_acknowledge_created_inferior (pid
);
2909 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2914 debug_to_insert_fork_catchpoint (int pid
)
2916 debug_target
.to_insert_fork_catchpoint (pid
);
2918 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2923 debug_to_remove_fork_catchpoint (int pid
)
2927 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2929 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2936 debug_to_insert_vfork_catchpoint (int pid
)
2938 debug_target
.to_insert_vfork_catchpoint (pid
);
2940 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2945 debug_to_remove_vfork_catchpoint (int pid
)
2949 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2951 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2958 debug_to_insert_exec_catchpoint (int pid
)
2960 debug_target
.to_insert_exec_catchpoint (pid
);
2962 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2967 debug_to_remove_exec_catchpoint (int pid
)
2971 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2973 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2980 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2984 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2986 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2987 pid
, wait_status
, *exit_status
, has_exited
);
2993 debug_to_mourn_inferior (void)
2995 debug_target
.to_mourn_inferior ();
2997 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3001 debug_to_can_run (void)
3005 retval
= debug_target
.to_can_run ();
3007 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3013 debug_to_notice_signals (ptid_t ptid
)
3015 debug_target
.to_notice_signals (ptid
);
3017 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3022 debug_to_thread_alive (ptid_t ptid
)
3026 retval
= debug_target
.to_thread_alive (ptid
);
3028 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3029 PIDGET (ptid
), retval
);
3035 debug_to_find_new_threads (void)
3037 debug_target
.to_find_new_threads ();
3039 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3043 debug_to_stop (ptid_t ptid
)
3045 debug_target
.to_stop (ptid
);
3047 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3048 target_pid_to_str (ptid
));
3052 debug_to_rcmd (char *command
,
3053 struct ui_file
*outbuf
)
3055 debug_target
.to_rcmd (command
, outbuf
);
3056 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3060 debug_to_pid_to_exec_file (int pid
)
3064 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3066 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3073 setup_target_debug (void)
3075 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3077 current_target
.to_open
= debug_to_open
;
3078 current_target
.to_close
= debug_to_close
;
3079 current_target
.to_attach
= debug_to_attach
;
3080 current_target
.to_post_attach
= debug_to_post_attach
;
3081 current_target
.to_detach
= debug_to_detach
;
3082 current_target
.to_resume
= debug_to_resume
;
3083 current_target
.to_wait
= debug_to_wait
;
3084 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3085 current_target
.to_store_registers
= debug_to_store_registers
;
3086 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3087 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3088 current_target
.to_files_info
= debug_to_files_info
;
3089 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3090 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3091 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3092 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3093 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3094 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3095 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3096 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3097 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3098 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3099 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3100 current_target
.to_terminal_init
= debug_to_terminal_init
;
3101 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3102 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3103 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3104 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3105 current_target
.to_terminal_info
= debug_to_terminal_info
;
3106 current_target
.to_kill
= debug_to_kill
;
3107 current_target
.to_load
= debug_to_load
;
3108 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3109 current_target
.to_create_inferior
= debug_to_create_inferior
;
3110 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3111 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3112 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3113 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3114 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3115 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3116 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3117 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3118 current_target
.to_has_exited
= debug_to_has_exited
;
3119 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3120 current_target
.to_can_run
= debug_to_can_run
;
3121 current_target
.to_notice_signals
= debug_to_notice_signals
;
3122 current_target
.to_thread_alive
= debug_to_thread_alive
;
3123 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3124 current_target
.to_stop
= debug_to_stop
;
3125 current_target
.to_rcmd
= debug_to_rcmd
;
3126 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3130 static char targ_desc
[] =
3131 "Names of targets and files being debugged.\n\
3132 Shows the entire stack of targets currently in use (including the exec-file,\n\
3133 core-file, and process, if any), as well as the symbol file name.";
3136 do_monitor_command (char *cmd
,
3139 if ((current_target
.to_rcmd
3140 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3141 || (current_target
.to_rcmd
== debug_to_rcmd
3142 && (debug_target
.to_rcmd
3143 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3144 error (_("\"monitor\" command not supported by this target."));
3145 target_rcmd (cmd
, gdb_stdtarg
);
3148 /* Print the name of each layers of our target stack. */
3151 maintenance_print_target_stack (char *cmd
, int from_tty
)
3153 struct target_ops
*t
;
3155 printf_filtered (_("The current target stack is:\n"));
3157 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3159 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3163 /* Controls if async mode is permitted. */
3164 int target_async_permitted
= 0;
3166 /* The set command writes to this variable. If the inferior is
3167 executing, linux_nat_async_permitted is *not* updated. */
3168 static int target_async_permitted_1
= 0;
3171 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3172 struct cmd_list_element
*c
)
3174 if (target_has_execution
)
3176 target_async_permitted_1
= target_async_permitted
;
3177 error (_("Cannot change this setting while the inferior is running."));
3180 target_async_permitted
= target_async_permitted_1
;
3184 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3185 struct cmd_list_element
*c
,
3188 fprintf_filtered (file
, _("\
3189 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3193 initialize_targets (void)
3195 init_dummy_target ();
3196 push_target (&dummy_target
);
3198 add_info ("target", target_info
, targ_desc
);
3199 add_info ("files", target_info
, targ_desc
);
3201 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3202 Set target debugging."), _("\
3203 Show target debugging."), _("\
3204 When non-zero, target debugging is enabled. Higher numbers are more\n\
3205 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3209 &setdebuglist
, &showdebuglist
);
3211 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3212 &trust_readonly
, _("\
3213 Set mode for reading from readonly sections."), _("\
3214 Show mode for reading from readonly sections."), _("\
3215 When this mode is on, memory reads from readonly sections (such as .text)\n\
3216 will be read from the object file instead of from the target. This will\n\
3217 result in significant performance improvement for remote targets."),
3219 show_trust_readonly
,
3220 &setlist
, &showlist
);
3222 add_com ("monitor", class_obscure
, do_monitor_command
,
3223 _("Send a command to the remote monitor (remote targets only)."));
3225 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3226 _("Print the name of each layer of the internal target stack."),
3227 &maintenanceprintlist
);
3229 add_setshow_boolean_cmd ("target-async", no_class
,
3230 &target_async_permitted_1
, _("\
3231 Set whether gdb controls the inferior in asynchronous mode."), _("\
3232 Show whether gdb controls the inferior in asynchronous mode."), _("\
3233 Tells gdb whether to control the inferior in asynchronous mode."),
3234 set_maintenance_target_async_permitted
,
3235 show_maintenance_target_async_permitted
,
3239 target_dcache
= dcache_init ();