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 maybe_kill_then_attach (char *, int);
49 static void kill_or_be_killed (int);
51 static void default_terminal_info (char *, int);
53 static int default_watchpoint_addr_within_range (struct target_ops
*,
54 CORE_ADDR
, CORE_ADDR
, int);
56 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
58 static int nosymbol (char *, CORE_ADDR
*);
60 static void tcomplain (void) ATTR_NORETURN
;
62 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
64 static int return_zero (void);
66 static int return_one (void);
68 static int return_minus_one (void);
70 void target_ignore (void);
72 static void target_command (char *, int);
74 static struct target_ops
*find_default_run_target (char *);
76 static void nosupport_runtime (void);
78 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
79 enum target_object object
,
80 const char *annex
, gdb_byte
*readbuf
,
81 const gdb_byte
*writebuf
,
82 ULONGEST offset
, LONGEST len
);
84 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
85 enum target_object object
,
86 const char *annex
, gdb_byte
*readbuf
,
87 const gdb_byte
*writebuf
,
88 ULONGEST offset
, LONGEST len
);
90 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
91 enum target_object object
,
93 void *readbuf
, const void *writebuf
,
94 ULONGEST offset
, LONGEST len
);
96 static void init_dummy_target (void);
98 static struct target_ops debug_target
;
100 static void debug_to_open (char *, int);
102 static void debug_to_close (int);
104 static void debug_to_attach (char *, int);
106 static void debug_to_detach (char *, int);
108 static void debug_to_resume (ptid_t
, int, enum target_signal
);
110 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
112 static void debug_to_fetch_registers (struct regcache
*, int);
114 static void debug_to_store_registers (struct regcache
*, int);
116 static void debug_to_prepare_to_store (struct regcache
*);
118 static void debug_to_files_info (struct target_ops
*);
120 static int debug_to_insert_breakpoint (struct bp_target_info
*);
122 static int debug_to_remove_breakpoint (struct bp_target_info
*);
124 static int debug_to_can_use_hw_breakpoint (int, int, int);
126 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
128 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
130 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
132 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
134 static int debug_to_stopped_by_watchpoint (void);
136 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
138 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
139 CORE_ADDR
, CORE_ADDR
, int);
141 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
143 static void debug_to_terminal_init (void);
145 static void debug_to_terminal_inferior (void);
147 static void debug_to_terminal_ours_for_output (void);
149 static void debug_to_terminal_save_ours (void);
151 static void debug_to_terminal_ours (void);
153 static void debug_to_terminal_info (char *, int);
155 static void debug_to_kill (void);
157 static void debug_to_load (char *, int);
159 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
161 static void debug_to_mourn_inferior (void);
163 static int debug_to_can_run (void);
165 static void debug_to_notice_signals (ptid_t
);
167 static int debug_to_thread_alive (ptid_t
);
169 static void debug_to_stop (ptid_t
);
171 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
172 wierd and mysterious ways. Putting the variable here lets those
173 wierd and mysterious ways keep building while they are being
174 converted to the inferior inheritance structure. */
175 struct target_ops deprecated_child_ops
;
177 /* Pointer to array of target architecture structures; the size of the
178 array; the current index into the array; the allocated size of the
180 struct target_ops
**target_structs
;
181 unsigned target_struct_size
;
182 unsigned target_struct_index
;
183 unsigned target_struct_allocsize
;
184 #define DEFAULT_ALLOCSIZE 10
186 /* The initial current target, so that there is always a semi-valid
189 static struct target_ops dummy_target
;
191 /* Top of target stack. */
193 static struct target_ops
*target_stack
;
195 /* The target structure we are currently using to talk to a process
196 or file or whatever "inferior" we have. */
198 struct target_ops current_target
;
200 /* Command list for target. */
202 static struct cmd_list_element
*targetlist
= NULL
;
204 /* Nonzero if we are debugging an attached outside process
205 rather than an inferior. */
209 /* Nonzero if we should trust readonly sections from the
210 executable when reading memory. */
212 static int trust_readonly
= 0;
214 /* Nonzero if we should show true memory content including
215 memory breakpoint inserted by gdb. */
217 static int show_memory_breakpoints
= 0;
219 /* Non-zero if we want to see trace of target level stuff. */
221 static int targetdebug
= 0;
223 show_targetdebug (struct ui_file
*file
, int from_tty
,
224 struct cmd_list_element
*c
, const char *value
)
226 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
229 static void setup_target_debug (void);
231 DCACHE
*target_dcache
;
233 /* The user just typed 'target' without the name of a target. */
236 target_command (char *arg
, int from_tty
)
238 fputs_filtered ("Argument required (target name). Try `help target'\n",
242 /* Add a possible target architecture to the list. */
245 add_target (struct target_ops
*t
)
247 /* Provide default values for all "must have" methods. */
248 if (t
->to_xfer_partial
== NULL
)
249 t
->to_xfer_partial
= default_xfer_partial
;
253 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
254 target_structs
= (struct target_ops
**) xmalloc
255 (target_struct_allocsize
* sizeof (*target_structs
));
257 if (target_struct_size
>= target_struct_allocsize
)
259 target_struct_allocsize
*= 2;
260 target_structs
= (struct target_ops
**)
261 xrealloc ((char *) target_structs
,
262 target_struct_allocsize
* sizeof (*target_structs
));
264 target_structs
[target_struct_size
++] = t
;
266 if (targetlist
== NULL
)
267 add_prefix_cmd ("target", class_run
, target_command
, _("\
268 Connect to a target machine or process.\n\
269 The first argument is the type or protocol of the target machine.\n\
270 Remaining arguments are interpreted by the target protocol. For more\n\
271 information on the arguments for a particular protocol, type\n\
272 `help target ' followed by the protocol name."),
273 &targetlist
, "target ", 0, &cmdlist
);
274 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
285 target_load (char *arg
, int from_tty
)
287 dcache_invalidate (target_dcache
);
288 (*current_target
.to_load
) (arg
, from_tty
);
292 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
293 struct target_ops
*t
)
295 errno
= EIO
; /* Can't read/write this location */
296 return 0; /* No bytes handled */
302 error (_("You can't do that when your target is `%s'"),
303 current_target
.to_shortname
);
309 error (_("You can't do that without a process to debug."));
313 nosymbol (char *name
, CORE_ADDR
*addrp
)
315 return 1; /* Symbol does not exist in target env */
319 nosupport_runtime (void)
321 if (ptid_equal (inferior_ptid
, null_ptid
))
324 error (_("No run-time support for this"));
329 default_terminal_info (char *args
, int from_tty
)
331 printf_unfiltered (_("No saved terminal information.\n"));
334 /* This is the default target_create_inferior and target_attach function.
335 If the current target is executing, it asks whether to kill it off.
336 If this function returns without calling error(), it has killed off
337 the target, and the operation should be attempted. */
340 kill_or_be_killed (int from_tty
)
342 if (target_has_execution
)
344 printf_unfiltered (_("You are already running a program:\n"));
345 target_files_info ();
346 if (query ("Kill it? "))
349 if (target_has_execution
)
350 error (_("Killing the program did not help."));
355 error (_("Program not killed."));
362 maybe_kill_then_attach (char *args
, int from_tty
)
364 kill_or_be_killed (from_tty
);
365 target_attach (args
, from_tty
);
369 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
372 kill_or_be_killed (0);
373 target_create_inferior (exec
, args
, env
, from_tty
);
376 /* Go through the target stack from top to bottom, copying over zero
377 entries in current_target, then filling in still empty entries. In
378 effect, we are doing class inheritance through the pushed target
381 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
382 is currently implemented, is that it discards any knowledge of
383 which target an inherited method originally belonged to.
384 Consequently, new new target methods should instead explicitly and
385 locally search the target stack for the target that can handle the
389 update_current_target (void)
391 struct target_ops
*t
;
393 /* First, reset current's contents. */
394 memset (¤t_target
, 0, sizeof (current_target
));
396 #define INHERIT(FIELD, TARGET) \
397 if (!current_target.FIELD) \
398 current_target.FIELD = (TARGET)->FIELD
400 for (t
= target_stack
; t
; t
= t
->beneath
)
402 INHERIT (to_shortname
, t
);
403 INHERIT (to_longname
, t
);
405 INHERIT (to_open
, t
);
406 INHERIT (to_close
, t
);
407 INHERIT (to_attach
, t
);
408 INHERIT (to_post_attach
, t
);
409 INHERIT (to_attach_no_wait
, t
);
410 INHERIT (to_detach
, t
);
411 /* Do not inherit to_disconnect. */
412 INHERIT (to_resume
, t
);
413 INHERIT (to_wait
, t
);
414 INHERIT (to_fetch_registers
, t
);
415 INHERIT (to_store_registers
, t
);
416 INHERIT (to_prepare_to_store
, t
);
417 INHERIT (deprecated_xfer_memory
, t
);
418 INHERIT (to_files_info
, t
);
419 INHERIT (to_insert_breakpoint
, t
);
420 INHERIT (to_remove_breakpoint
, t
);
421 INHERIT (to_can_use_hw_breakpoint
, t
);
422 INHERIT (to_insert_hw_breakpoint
, t
);
423 INHERIT (to_remove_hw_breakpoint
, t
);
424 INHERIT (to_insert_watchpoint
, t
);
425 INHERIT (to_remove_watchpoint
, t
);
426 INHERIT (to_stopped_data_address
, t
);
427 INHERIT (to_have_steppable_watchpoint
, t
);
428 INHERIT (to_have_continuable_watchpoint
, t
);
429 INHERIT (to_stopped_by_watchpoint
, t
);
430 INHERIT (to_watchpoint_addr_within_range
, t
);
431 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
432 INHERIT (to_terminal_init
, t
);
433 INHERIT (to_terminal_inferior
, t
);
434 INHERIT (to_terminal_ours_for_output
, t
);
435 INHERIT (to_terminal_ours
, t
);
436 INHERIT (to_terminal_save_ours
, t
);
437 INHERIT (to_terminal_info
, t
);
438 INHERIT (to_kill
, t
);
439 INHERIT (to_load
, t
);
440 INHERIT (to_lookup_symbol
, t
);
441 INHERIT (to_create_inferior
, t
);
442 INHERIT (to_post_startup_inferior
, t
);
443 INHERIT (to_acknowledge_created_inferior
, t
);
444 INHERIT (to_insert_fork_catchpoint
, t
);
445 INHERIT (to_remove_fork_catchpoint
, t
);
446 INHERIT (to_insert_vfork_catchpoint
, t
);
447 INHERIT (to_remove_vfork_catchpoint
, t
);
448 /* Do not inherit to_follow_fork. */
449 INHERIT (to_insert_exec_catchpoint
, t
);
450 INHERIT (to_remove_exec_catchpoint
, t
);
451 INHERIT (to_has_exited
, t
);
452 INHERIT (to_mourn_inferior
, t
);
453 INHERIT (to_can_run
, t
);
454 INHERIT (to_notice_signals
, t
);
455 INHERIT (to_thread_alive
, t
);
456 INHERIT (to_find_new_threads
, t
);
457 INHERIT (to_pid_to_str
, t
);
458 INHERIT (to_extra_thread_info
, t
);
459 INHERIT (to_stop
, t
);
460 /* Do not inherit to_xfer_partial. */
461 INHERIT (to_rcmd
, t
);
462 INHERIT (to_pid_to_exec_file
, t
);
463 INHERIT (to_log_command
, t
);
464 INHERIT (to_stratum
, t
);
465 INHERIT (to_has_all_memory
, t
);
466 INHERIT (to_has_memory
, t
);
467 INHERIT (to_has_stack
, t
);
468 INHERIT (to_has_registers
, t
);
469 INHERIT (to_has_execution
, t
);
470 INHERIT (to_has_thread_control
, t
);
471 INHERIT (to_sections
, t
);
472 INHERIT (to_sections_end
, t
);
473 INHERIT (to_can_async_p
, t
);
474 INHERIT (to_is_async_p
, t
);
475 INHERIT (to_async
, t
);
476 INHERIT (to_async_mask
, t
);
477 INHERIT (to_find_memory_regions
, t
);
478 INHERIT (to_make_corefile_notes
, t
);
479 INHERIT (to_get_thread_local_address
, t
);
480 /* Do not inherit to_read_description. */
481 /* Do not inherit to_search_memory. */
482 INHERIT (to_magic
, t
);
483 /* Do not inherit to_memory_map. */
484 /* Do not inherit to_flash_erase. */
485 /* Do not inherit to_flash_done. */
489 /* Clean up a target struct so it no longer has any zero pointers in
490 it. Some entries are defaulted to a method that print an error,
491 others are hard-wired to a standard recursive default. */
493 #define de_fault(field, value) \
494 if (!current_target.field) \
495 current_target.field = value
498 (void (*) (char *, int))
504 maybe_kill_then_attach
);
505 de_fault (to_post_attach
,
509 (void (*) (char *, int))
512 (void (*) (ptid_t
, int, enum target_signal
))
515 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
517 de_fault (to_fetch_registers
,
518 (void (*) (struct regcache
*, int))
520 de_fault (to_store_registers
,
521 (void (*) (struct regcache
*, int))
523 de_fault (to_prepare_to_store
,
524 (void (*) (struct regcache
*))
526 de_fault (deprecated_xfer_memory
,
527 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
529 de_fault (to_files_info
,
530 (void (*) (struct target_ops
*))
532 de_fault (to_insert_breakpoint
,
533 memory_insert_breakpoint
);
534 de_fault (to_remove_breakpoint
,
535 memory_remove_breakpoint
);
536 de_fault (to_can_use_hw_breakpoint
,
537 (int (*) (int, int, int))
539 de_fault (to_insert_hw_breakpoint
,
540 (int (*) (struct bp_target_info
*))
542 de_fault (to_remove_hw_breakpoint
,
543 (int (*) (struct bp_target_info
*))
545 de_fault (to_insert_watchpoint
,
546 (int (*) (CORE_ADDR
, int, int))
548 de_fault (to_remove_watchpoint
,
549 (int (*) (CORE_ADDR
, int, int))
551 de_fault (to_stopped_by_watchpoint
,
554 de_fault (to_stopped_data_address
,
555 (int (*) (struct target_ops
*, CORE_ADDR
*))
557 de_fault (to_watchpoint_addr_within_range
,
558 default_watchpoint_addr_within_range
);
559 de_fault (to_region_ok_for_hw_watchpoint
,
560 default_region_ok_for_hw_watchpoint
);
561 de_fault (to_terminal_init
,
564 de_fault (to_terminal_inferior
,
567 de_fault (to_terminal_ours_for_output
,
570 de_fault (to_terminal_ours
,
573 de_fault (to_terminal_save_ours
,
576 de_fault (to_terminal_info
,
577 default_terminal_info
);
582 (void (*) (char *, int))
584 de_fault (to_lookup_symbol
,
585 (int (*) (char *, CORE_ADDR
*))
587 de_fault (to_create_inferior
,
588 maybe_kill_then_create_inferior
);
589 de_fault (to_post_startup_inferior
,
592 de_fault (to_acknowledge_created_inferior
,
595 de_fault (to_insert_fork_catchpoint
,
598 de_fault (to_remove_fork_catchpoint
,
601 de_fault (to_insert_vfork_catchpoint
,
604 de_fault (to_remove_vfork_catchpoint
,
607 de_fault (to_insert_exec_catchpoint
,
610 de_fault (to_remove_exec_catchpoint
,
613 de_fault (to_has_exited
,
614 (int (*) (int, int, int *))
616 de_fault (to_mourn_inferior
,
619 de_fault (to_can_run
,
621 de_fault (to_notice_signals
,
624 de_fault (to_thread_alive
,
627 de_fault (to_find_new_threads
,
630 de_fault (to_extra_thread_info
,
631 (char *(*) (struct thread_info
*))
636 current_target
.to_xfer_partial
= current_xfer_partial
;
638 (void (*) (char *, struct ui_file
*))
640 de_fault (to_pid_to_exec_file
,
643 de_fault (to_can_async_p
,
646 de_fault (to_is_async_p
,
650 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
652 de_fault (to_async_mask
,
655 current_target
.to_read_description
= NULL
;
658 /* Finally, position the target-stack beneath the squashed
659 "current_target". That way code looking for a non-inherited
660 target method can quickly and simply find it. */
661 current_target
.beneath
= target_stack
;
664 setup_target_debug ();
667 /* Mark OPS as a running target. This reverses the effect
668 of target_mark_exited. */
671 target_mark_running (struct target_ops
*ops
)
673 struct target_ops
*t
;
675 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
679 internal_error (__FILE__
, __LINE__
,
680 "Attempted to mark unpushed target \"%s\" as running",
683 ops
->to_has_execution
= 1;
684 ops
->to_has_all_memory
= 1;
685 ops
->to_has_memory
= 1;
686 ops
->to_has_stack
= 1;
687 ops
->to_has_registers
= 1;
689 update_current_target ();
692 /* Mark OPS as a non-running target. This reverses the effect
693 of target_mark_running. */
696 target_mark_exited (struct target_ops
*ops
)
698 struct target_ops
*t
;
700 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
704 internal_error (__FILE__
, __LINE__
,
705 "Attempted to mark unpushed target \"%s\" as running",
708 ops
->to_has_execution
= 0;
709 ops
->to_has_all_memory
= 0;
710 ops
->to_has_memory
= 0;
711 ops
->to_has_stack
= 0;
712 ops
->to_has_registers
= 0;
714 update_current_target ();
717 /* Push a new target type into the stack of the existing target accessors,
718 possibly superseding some of the existing accessors.
720 Result is zero if the pushed target ended up on top of the stack,
721 nonzero if at least one target is on top of it.
723 Rather than allow an empty stack, we always have the dummy target at
724 the bottom stratum, so we can call the function vectors without
728 push_target (struct target_ops
*t
)
730 struct target_ops
**cur
;
732 /* Check magic number. If wrong, it probably means someone changed
733 the struct definition, but not all the places that initialize one. */
734 if (t
->to_magic
!= OPS_MAGIC
)
736 fprintf_unfiltered (gdb_stderr
,
737 "Magic number of %s target struct wrong\n",
739 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
742 /* Find the proper stratum to install this target in. */
743 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
745 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
749 /* If there's already targets at this stratum, remove them. */
750 /* FIXME: cagney/2003-10-15: I think this should be popping all
751 targets to CUR, and not just those at this stratum level. */
752 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
754 /* There's already something at this stratum level. Close it,
755 and un-hook it from the stack. */
756 struct target_ops
*tmp
= (*cur
);
757 (*cur
) = (*cur
)->beneath
;
759 target_close (tmp
, 0);
762 /* We have removed all targets in our stratum, now add the new one. */
766 update_current_target ();
769 return (t
!= target_stack
);
772 /* Remove a target_ops vector from the stack, wherever it may be.
773 Return how many times it was removed (0 or 1). */
776 unpush_target (struct target_ops
*t
)
778 struct target_ops
**cur
;
779 struct target_ops
*tmp
;
781 /* Look for the specified target. Note that we assume that a target
782 can only occur once in the target stack. */
784 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
791 return 0; /* Didn't find target_ops, quit now */
793 /* NOTE: cagney/2003-12-06: In '94 the close call was made
794 unconditional by moving it to before the above check that the
795 target was in the target stack (something about "Change the way
796 pushing and popping of targets work to support target overlays
797 and inheritance"). This doesn't make much sense - only open
798 targets should be closed. */
801 /* Unchain the target */
803 (*cur
) = (*cur
)->beneath
;
806 update_current_target ();
814 target_close (¤t_target
, 0); /* Let it clean up */
815 if (unpush_target (target_stack
) == 1)
818 fprintf_unfiltered (gdb_stderr
,
819 "pop_target couldn't find target %s\n",
820 current_target
.to_shortname
);
821 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
825 pop_all_targets (int quitting
)
827 while ((int) (current_target
.to_stratum
) > (int) dummy_stratum
)
829 target_close (¤t_target
, quitting
);
830 if (!unpush_target (target_stack
))
832 fprintf_unfiltered (gdb_stderr
,
833 "pop_all_targets couldn't find target %s\n",
834 current_target
.to_shortname
);
835 internal_error (__FILE__
, __LINE__
,
836 _("failed internal consistency check"));
842 /* Using the objfile specified in OBJFILE, find the address for the
843 current thread's thread-local storage with offset OFFSET. */
845 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
847 volatile CORE_ADDR addr
= 0;
849 if (target_get_thread_local_address_p ()
850 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
852 ptid_t ptid
= inferior_ptid
;
853 volatile struct gdb_exception ex
;
855 TRY_CATCH (ex
, RETURN_MASK_ALL
)
859 /* Fetch the load module address for this objfile. */
860 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
862 /* If it's 0, throw the appropriate exception. */
864 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
865 _("TLS load module not found"));
867 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
869 /* If an error occurred, print TLS related messages here. Otherwise,
870 throw the error to some higher catcher. */
873 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
877 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
878 error (_("Cannot find thread-local variables in this thread library."));
880 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
881 if (objfile_is_library
)
882 error (_("Cannot find shared library `%s' in dynamic"
883 " linker's load module list"), objfile
->name
);
885 error (_("Cannot find executable file `%s' in dynamic"
886 " linker's load module list"), objfile
->name
);
888 case TLS_NOT_ALLOCATED_YET_ERROR
:
889 if (objfile_is_library
)
890 error (_("The inferior has not yet allocated storage for"
891 " thread-local variables in\n"
892 "the shared library `%s'\n"
894 objfile
->name
, target_pid_to_str (ptid
));
896 error (_("The inferior has not yet allocated storage for"
897 " thread-local variables in\n"
898 "the executable `%s'\n"
900 objfile
->name
, target_pid_to_str (ptid
));
902 case TLS_GENERIC_ERROR
:
903 if (objfile_is_library
)
904 error (_("Cannot find thread-local storage for %s, "
905 "shared library %s:\n%s"),
906 target_pid_to_str (ptid
),
907 objfile
->name
, ex
.message
);
909 error (_("Cannot find thread-local storage for %s, "
910 "executable file %s:\n%s"),
911 target_pid_to_str (ptid
),
912 objfile
->name
, ex
.message
);
915 throw_exception (ex
);
920 /* It wouldn't be wrong here to try a gdbarch method, too; finding
921 TLS is an ABI-specific thing. But we don't do that yet. */
923 error (_("Cannot find thread-local variables on this target"));
929 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
931 /* target_read_string -- read a null terminated string, up to LEN bytes,
932 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
933 Set *STRING to a pointer to malloc'd memory containing the data; the caller
934 is responsible for freeing it. Return the number of bytes successfully
938 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
940 int tlen
, origlen
, offset
, i
;
944 int buffer_allocated
;
946 unsigned int nbytes_read
= 0;
950 /* Small for testing. */
951 buffer_allocated
= 4;
952 buffer
= xmalloc (buffer_allocated
);
959 tlen
= MIN (len
, 4 - (memaddr
& 3));
960 offset
= memaddr
& 3;
962 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
965 /* The transfer request might have crossed the boundary to an
966 unallocated region of memory. Retry the transfer, requesting
970 errcode
= target_read_memory (memaddr
, buf
, 1);
975 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
978 bytes
= bufptr
- buffer
;
979 buffer_allocated
*= 2;
980 buffer
= xrealloc (buffer
, buffer_allocated
);
981 bufptr
= buffer
+ bytes
;
984 for (i
= 0; i
< tlen
; i
++)
986 *bufptr
++ = buf
[i
+ offset
];
987 if (buf
[i
+ offset
] == '\000')
989 nbytes_read
+= i
+ 1;
1005 /* Find a section containing ADDR. */
1006 struct section_table
*
1007 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1009 struct section_table
*secp
;
1010 for (secp
= target
->to_sections
;
1011 secp
< target
->to_sections_end
;
1014 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1020 /* Perform a partial memory transfer. The arguments and return
1021 value are just as for target_xfer_partial. */
1024 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1025 ULONGEST memaddr
, LONGEST len
)
1029 struct mem_region
*region
;
1031 /* Zero length requests are ok and require no work. */
1035 /* Try the executable file, if "trust-readonly-sections" is set. */
1036 if (readbuf
!= NULL
&& trust_readonly
)
1038 struct section_table
*secp
;
1040 secp
= target_section_by_addr (ops
, memaddr
);
1042 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1044 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1047 /* Likewise for accesses to unmapped overlay sections. */
1048 if (readbuf
!= NULL
&& overlay_debugging
)
1050 asection
*section
= find_pc_overlay (memaddr
);
1051 if (pc_in_unmapped_range (memaddr
, section
))
1052 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1055 /* Try GDB's internal data cache. */
1056 region
= lookup_mem_region (memaddr
);
1057 /* region->hi == 0 means there's no upper bound. */
1058 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1061 reg_len
= region
->hi
- memaddr
;
1063 switch (region
->attrib
.mode
)
1066 if (writebuf
!= NULL
)
1071 if (readbuf
!= NULL
)
1076 /* We only support writing to flash during "load" for now. */
1077 if (writebuf
!= NULL
)
1078 error (_("Writing to flash memory forbidden in this context"));
1085 if (region
->attrib
.cache
)
1087 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1088 memory request will start back at current_target. */
1089 if (readbuf
!= NULL
)
1090 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1093 /* FIXME drow/2006-08-09: If we're going to preserve const
1094 correctness dcache_xfer_memory should take readbuf and
1096 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1103 if (readbuf
&& !show_memory_breakpoints
)
1104 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1109 /* If none of those methods found the memory we wanted, fall back
1110 to a target partial transfer. Normally a single call to
1111 to_xfer_partial is enough; if it doesn't recognize an object
1112 it will call the to_xfer_partial of the next target down.
1113 But for memory this won't do. Memory is the only target
1114 object which can be read from more than one valid target.
1115 A core file, for instance, could have some of memory but
1116 delegate other bits to the target below it. So, we must
1117 manually try all targets. */
1121 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1122 readbuf
, writebuf
, memaddr
, reg_len
);
1126 /* We want to continue past core files to executables, but not
1127 past a running target's memory. */
1128 if (ops
->to_has_all_memory
)
1133 while (ops
!= NULL
);
1135 if (readbuf
&& !show_memory_breakpoints
)
1136 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1138 /* If we still haven't got anything, return the last error. We
1144 restore_show_memory_breakpoints (void *arg
)
1146 show_memory_breakpoints
= (uintptr_t) arg
;
1150 make_show_memory_breakpoints_cleanup (int show
)
1152 int current
= show_memory_breakpoints
;
1153 show_memory_breakpoints
= show
;
1155 return make_cleanup (restore_show_memory_breakpoints
,
1156 (void *) (uintptr_t) current
);
1160 target_xfer_partial (struct target_ops
*ops
,
1161 enum target_object object
, const char *annex
,
1162 void *readbuf
, const void *writebuf
,
1163 ULONGEST offset
, LONGEST len
)
1167 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1169 /* If this is a memory transfer, let the memory-specific code
1170 have a look at it instead. Memory transfers are more
1172 if (object
== TARGET_OBJECT_MEMORY
)
1173 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1176 enum target_object raw_object
= object
;
1178 /* If this is a raw memory transfer, request the normal
1179 memory object from other layers. */
1180 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1181 raw_object
= TARGET_OBJECT_MEMORY
;
1183 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1184 writebuf
, offset
, len
);
1189 const unsigned char *myaddr
= NULL
;
1191 fprintf_unfiltered (gdb_stdlog
,
1192 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1195 (annex
? annex
: "(null)"),
1196 (long) readbuf
, (long) writebuf
,
1197 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1203 if (retval
> 0 && myaddr
!= NULL
)
1207 fputs_unfiltered (", bytes =", gdb_stdlog
);
1208 for (i
= 0; i
< retval
; i
++)
1210 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1212 if (targetdebug
< 2 && i
> 0)
1214 fprintf_unfiltered (gdb_stdlog
, " ...");
1217 fprintf_unfiltered (gdb_stdlog
, "\n");
1220 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1224 fputc_unfiltered ('\n', gdb_stdlog
);
1229 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1230 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1231 if any error occurs.
1233 If an error occurs, no guarantee is made about the contents of the data at
1234 MYADDR. In particular, the caller should not depend upon partial reads
1235 filling the buffer with good data. There is no way for the caller to know
1236 how much good data might have been transfered anyway. Callers that can
1237 deal with partial reads should call target_read (which will retry until
1238 it makes no progress, and then return how much was transferred). */
1241 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1243 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1244 myaddr
, memaddr
, len
) == len
)
1251 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1253 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1254 myaddr
, memaddr
, len
) == len
)
1260 /* Fetch the target's memory map. */
1263 target_memory_map (void)
1265 VEC(mem_region_s
) *result
;
1266 struct mem_region
*last_one
, *this_one
;
1268 struct target_ops
*t
;
1271 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1273 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1274 if (t
->to_memory_map
!= NULL
)
1280 result
= t
->to_memory_map (t
);
1284 qsort (VEC_address (mem_region_s
, result
),
1285 VEC_length (mem_region_s
, result
),
1286 sizeof (struct mem_region
), mem_region_cmp
);
1288 /* Check that regions do not overlap. Simultaneously assign
1289 a numbering for the "mem" commands to use to refer to
1292 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1294 this_one
->number
= ix
;
1296 if (last_one
&& last_one
->hi
> this_one
->lo
)
1298 warning (_("Overlapping regions in memory map: ignoring"));
1299 VEC_free (mem_region_s
, result
);
1302 last_one
= this_one
;
1309 target_flash_erase (ULONGEST address
, LONGEST length
)
1311 struct target_ops
*t
;
1313 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1314 if (t
->to_flash_erase
!= NULL
)
1317 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1318 paddr (address
), phex (length
, 0));
1319 t
->to_flash_erase (t
, address
, length
);
1327 target_flash_done (void)
1329 struct target_ops
*t
;
1331 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1332 if (t
->to_flash_done
!= NULL
)
1335 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1336 t
->to_flash_done (t
);
1343 #ifndef target_stopped_data_address_p
1345 target_stopped_data_address_p (struct target_ops
*target
)
1347 if (target
->to_stopped_data_address
1348 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1350 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1351 && (debug_target
.to_stopped_data_address
1352 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1359 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1360 struct cmd_list_element
*c
, const char *value
)
1362 fprintf_filtered (file
, _("\
1363 Mode for reading from readonly sections is %s.\n"),
1367 /* More generic transfers. */
1370 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1371 const char *annex
, gdb_byte
*readbuf
,
1372 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1374 if (object
== TARGET_OBJECT_MEMORY
1375 && ops
->deprecated_xfer_memory
!= NULL
)
1376 /* If available, fall back to the target's
1377 "deprecated_xfer_memory" method. */
1381 if (writebuf
!= NULL
)
1383 void *buffer
= xmalloc (len
);
1384 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1385 memcpy (buffer
, writebuf
, len
);
1386 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1387 1/*write*/, NULL
, ops
);
1388 do_cleanups (cleanup
);
1390 if (readbuf
!= NULL
)
1391 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1392 0/*read*/, NULL
, ops
);
1395 else if (xfered
== 0 && errno
== 0)
1396 /* "deprecated_xfer_memory" uses 0, cross checked against
1397 ERRNO as one indication of an error. */
1402 else if (ops
->beneath
!= NULL
)
1403 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1404 readbuf
, writebuf
, offset
, len
);
1409 /* The xfer_partial handler for the topmost target. Unlike the default,
1410 it does not need to handle memory specially; it just passes all
1411 requests down the stack. */
1414 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1415 const char *annex
, gdb_byte
*readbuf
,
1416 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1418 if (ops
->beneath
!= NULL
)
1419 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1420 readbuf
, writebuf
, offset
, len
);
1425 /* Target vector read/write partial wrapper functions.
1427 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1428 (inbuf, outbuf)", instead of separate read/write methods, make life
1432 target_read_partial (struct target_ops
*ops
,
1433 enum target_object object
,
1434 const char *annex
, gdb_byte
*buf
,
1435 ULONGEST offset
, LONGEST len
)
1437 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1441 target_write_partial (struct target_ops
*ops
,
1442 enum target_object object
,
1443 const char *annex
, const gdb_byte
*buf
,
1444 ULONGEST offset
, LONGEST len
)
1446 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1449 /* Wrappers to perform the full transfer. */
1451 target_read (struct target_ops
*ops
,
1452 enum target_object object
,
1453 const char *annex
, gdb_byte
*buf
,
1454 ULONGEST offset
, LONGEST len
)
1457 while (xfered
< len
)
1459 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1460 (gdb_byte
*) buf
+ xfered
,
1461 offset
+ xfered
, len
- xfered
);
1462 /* Call an observer, notifying them of the xfer progress? */
1474 target_read_until_error (struct target_ops
*ops
,
1475 enum target_object object
,
1476 const char *annex
, gdb_byte
*buf
,
1477 ULONGEST offset
, LONGEST len
)
1480 while (xfered
< len
)
1482 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1483 (gdb_byte
*) buf
+ xfered
,
1484 offset
+ xfered
, len
- xfered
);
1485 /* Call an observer, notifying them of the xfer progress? */
1490 /* We've got an error. Try to read in smaller blocks. */
1491 ULONGEST start
= offset
+ xfered
;
1492 ULONGEST remaining
= len
- xfered
;
1495 /* If an attempt was made to read a random memory address,
1496 it's likely that the very first byte is not accessible.
1497 Try reading the first byte, to avoid doing log N tries
1499 xfer
= target_read_partial (ops
, object
, annex
,
1500 (gdb_byte
*) buf
+ xfered
, start
, 1);
1509 xfer
= target_read_partial (ops
, object
, annex
,
1510 (gdb_byte
*) buf
+ xfered
,
1520 /* We have successfully read the first half. So, the
1521 error must be in the second half. Adjust start and
1522 remaining to point at the second half. */
1539 /* An alternative to target_write with progress callbacks. */
1542 target_write_with_progress (struct target_ops
*ops
,
1543 enum target_object object
,
1544 const char *annex
, const gdb_byte
*buf
,
1545 ULONGEST offset
, LONGEST len
,
1546 void (*progress
) (ULONGEST
, void *), void *baton
)
1550 /* Give the progress callback a chance to set up. */
1552 (*progress
) (0, baton
);
1554 while (xfered
< len
)
1556 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1557 (gdb_byte
*) buf
+ xfered
,
1558 offset
+ xfered
, len
- xfered
);
1566 (*progress
) (xfer
, baton
);
1575 target_write (struct target_ops
*ops
,
1576 enum target_object object
,
1577 const char *annex
, const gdb_byte
*buf
,
1578 ULONGEST offset
, LONGEST len
)
1580 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1584 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1585 the size of the transferred data. PADDING additional bytes are
1586 available in *BUF_P. This is a helper function for
1587 target_read_alloc; see the declaration of that function for more
1591 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1592 const char *annex
, gdb_byte
**buf_p
, int padding
)
1594 size_t buf_alloc
, buf_pos
;
1598 /* This function does not have a length parameter; it reads the
1599 entire OBJECT). Also, it doesn't support objects fetched partly
1600 from one target and partly from another (in a different stratum,
1601 e.g. a core file and an executable). Both reasons make it
1602 unsuitable for reading memory. */
1603 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1605 /* Start by reading up to 4K at a time. The target will throttle
1606 this number down if necessary. */
1608 buf
= xmalloc (buf_alloc
);
1612 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1613 buf_pos
, buf_alloc
- buf_pos
- padding
);
1616 /* An error occurred. */
1622 /* Read all there was. */
1632 /* If the buffer is filling up, expand it. */
1633 if (buf_alloc
< buf_pos
* 2)
1636 buf
= xrealloc (buf
, buf_alloc
);
1643 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1644 the size of the transferred data. See the declaration in "target.h"
1645 function for more information about the return value. */
1648 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1649 const char *annex
, gdb_byte
**buf_p
)
1651 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1654 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1655 returned as a string, allocated using xmalloc. If an error occurs
1656 or the transfer is unsupported, NULL is returned. Empty objects
1657 are returned as allocated but empty strings. A warning is issued
1658 if the result contains any embedded NUL bytes. */
1661 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1665 LONGEST transferred
;
1667 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1669 if (transferred
< 0)
1672 if (transferred
== 0)
1673 return xstrdup ("");
1675 buffer
[transferred
] = 0;
1676 if (strlen (buffer
) < transferred
)
1677 warning (_("target object %d, annex %s, "
1678 "contained unexpected null characters"),
1679 (int) object
, annex
? annex
: "(none)");
1681 return (char *) buffer
;
1684 /* Memory transfer methods. */
1687 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1690 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1692 memory_error (EIO
, addr
);
1696 get_target_memory_unsigned (struct target_ops
*ops
,
1697 CORE_ADDR addr
, int len
)
1699 gdb_byte buf
[sizeof (ULONGEST
)];
1701 gdb_assert (len
<= sizeof (buf
));
1702 get_target_memory (ops
, addr
, buf
, len
);
1703 return extract_unsigned_integer (buf
, len
);
1707 target_info (char *args
, int from_tty
)
1709 struct target_ops
*t
;
1710 int has_all_mem
= 0;
1712 if (symfile_objfile
!= NULL
)
1713 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1715 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1717 if (!t
->to_has_memory
)
1720 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1723 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1724 printf_unfiltered ("%s:\n", t
->to_longname
);
1725 (t
->to_files_info
) (t
);
1726 has_all_mem
= t
->to_has_all_memory
;
1730 /* This function is called before any new inferior is created, e.g.
1731 by running a program, attaching, or connecting to a target.
1732 It cleans up any state from previous invocations which might
1733 change between runs. This is a subset of what target_preopen
1734 resets (things which might change between targets). */
1737 target_pre_inferior (int from_tty
)
1739 /* Clear out solib state. Otherwise the solib state of the previous
1740 inferior might have survived and is entirely wrong for the new
1741 target. This has been observed on GNU/Linux using glibc 2.3. How
1753 Cannot access memory at address 0xdeadbeef
1755 no_shared_libraries (NULL
, from_tty
);
1757 invalidate_target_mem_regions ();
1759 target_clear_description ();
1762 /* This is to be called by the open routine before it does
1766 target_preopen (int from_tty
)
1770 if (target_has_execution
)
1773 || query (_("A program is being debugged already. Kill it? ")))
1776 error (_("Program not killed."));
1779 /* Calling target_kill may remove the target from the stack. But if
1780 it doesn't (which seems like a win for UDI), remove it now. */
1782 if (target_has_execution
)
1785 target_pre_inferior (from_tty
);
1788 /* Detach a target after doing deferred register stores. */
1791 target_detach (char *args
, int from_tty
)
1793 /* If we're in breakpoints-always-inserted mode, have to
1794 remove them before detaching. */
1795 remove_breakpoints ();
1797 (current_target
.to_detach
) (args
, from_tty
);
1801 target_disconnect (char *args
, int from_tty
)
1803 struct target_ops
*t
;
1805 /* If we're in breakpoints-always-inserted mode, have to
1806 remove them before disconnecting. */
1807 remove_breakpoints ();
1809 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1810 if (t
->to_disconnect
!= NULL
)
1813 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1815 t
->to_disconnect (t
, args
, from_tty
);
1823 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1825 dcache_invalidate (target_dcache
);
1826 (*current_target
.to_resume
) (ptid
, step
, signal
);
1827 set_executing (ptid
, 1);
1828 set_running (ptid
, 1);
1830 /* Look through the list of possible targets for a target that can
1834 target_follow_fork (int follow_child
)
1836 struct target_ops
*t
;
1838 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1840 if (t
->to_follow_fork
!= NULL
)
1842 int retval
= t
->to_follow_fork (t
, follow_child
);
1844 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1845 follow_child
, retval
);
1850 /* Some target returned a fork event, but did not know how to follow it. */
1851 internal_error (__FILE__
, __LINE__
,
1852 "could not find a target to follow fork");
1855 /* Look for a target which can describe architectural features, starting
1856 from TARGET. If we find one, return its description. */
1858 const struct target_desc
*
1859 target_read_description (struct target_ops
*target
)
1861 struct target_ops
*t
;
1863 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1864 if (t
->to_read_description
!= NULL
)
1866 const struct target_desc
*tdesc
;
1868 tdesc
= t
->to_read_description (t
);
1876 /* The default implementation of to_search_memory.
1877 This implements a basic search of memory, reading target memory and
1878 performing the search here (as opposed to performing the search in on the
1879 target side with, for example, gdbserver). */
1882 simple_search_memory (struct target_ops
*ops
,
1883 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1884 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1885 CORE_ADDR
*found_addrp
)
1887 /* NOTE: also defined in find.c testcase. */
1888 #define SEARCH_CHUNK_SIZE 16000
1889 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1890 /* Buffer to hold memory contents for searching. */
1891 gdb_byte
*search_buf
;
1892 unsigned search_buf_size
;
1893 struct cleanup
*old_cleanups
;
1895 search_buf_size
= chunk_size
+ pattern_len
- 1;
1897 /* No point in trying to allocate a buffer larger than the search space. */
1898 if (search_space_len
< search_buf_size
)
1899 search_buf_size
= search_space_len
;
1901 search_buf
= malloc (search_buf_size
);
1902 if (search_buf
== NULL
)
1903 error (_("Unable to allocate memory to perform the search."));
1904 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1906 /* Prime the search buffer. */
1908 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1909 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1911 warning (_("Unable to access target memory at %s, halting search."),
1912 hex_string (start_addr
));
1913 do_cleanups (old_cleanups
);
1917 /* Perform the search.
1919 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1920 When we've scanned N bytes we copy the trailing bytes to the start and
1921 read in another N bytes. */
1923 while (search_space_len
>= pattern_len
)
1925 gdb_byte
*found_ptr
;
1926 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1928 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1929 pattern
, pattern_len
);
1931 if (found_ptr
!= NULL
)
1933 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1934 *found_addrp
= found_addr
;
1935 do_cleanups (old_cleanups
);
1939 /* Not found in this chunk, skip to next chunk. */
1941 /* Don't let search_space_len wrap here, it's unsigned. */
1942 if (search_space_len
>= chunk_size
)
1943 search_space_len
-= chunk_size
;
1945 search_space_len
= 0;
1947 if (search_space_len
>= pattern_len
)
1949 unsigned keep_len
= search_buf_size
- chunk_size
;
1950 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1953 /* Copy the trailing part of the previous iteration to the front
1954 of the buffer for the next iteration. */
1955 gdb_assert (keep_len
== pattern_len
- 1);
1956 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1958 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1960 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1961 search_buf
+ keep_len
, read_addr
,
1962 nr_to_read
) != nr_to_read
)
1964 warning (_("Unable to access target memory at %s, halting search."),
1965 hex_string (read_addr
));
1966 do_cleanups (old_cleanups
);
1970 start_addr
+= chunk_size
;
1976 do_cleanups (old_cleanups
);
1980 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1981 sequence of bytes in PATTERN with length PATTERN_LEN.
1983 The result is 1 if found, 0 if not found, and -1 if there was an error
1984 requiring halting of the search (e.g. memory read error).
1985 If the pattern is found the address is recorded in FOUND_ADDRP. */
1988 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1989 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1990 CORE_ADDR
*found_addrp
)
1992 struct target_ops
*t
;
1995 /* We don't use INHERIT to set current_target.to_search_memory,
1996 so we have to scan the target stack and handle targetdebug
2000 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2001 hex_string (start_addr
));
2003 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2004 if (t
->to_search_memory
!= NULL
)
2009 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2010 pattern
, pattern_len
, found_addrp
);
2014 /* If a special version of to_search_memory isn't available, use the
2016 found
= simple_search_memory (¤t_target
,
2017 start_addr
, search_space_len
,
2018 pattern
, pattern_len
, found_addrp
);
2022 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2027 /* Look through the currently pushed targets. If none of them will
2028 be able to restart the currently running process, issue an error
2032 target_require_runnable (void)
2034 struct target_ops
*t
;
2036 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2038 /* If this target knows how to create a new program, then
2039 assume we will still be able to after killing the current
2040 one. Either killing and mourning will not pop T, or else
2041 find_default_run_target will find it again. */
2042 if (t
->to_create_inferior
!= NULL
)
2045 /* Do not worry about thread_stratum targets that can not
2046 create inferiors. Assume they will be pushed again if
2047 necessary, and continue to the process_stratum. */
2048 if (t
->to_stratum
== thread_stratum
)
2052 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2056 /* This function is only called if the target is running. In that
2057 case there should have been a process_stratum target and it
2058 should either know how to create inferiors, or not... */
2059 internal_error (__FILE__
, __LINE__
, "No targets found");
2062 /* Look through the list of possible targets for a target that can
2063 execute a run or attach command without any other data. This is
2064 used to locate the default process stratum.
2066 If DO_MESG is not NULL, the result is always valid (error() is
2067 called for errors); else, return NULL on error. */
2069 static struct target_ops
*
2070 find_default_run_target (char *do_mesg
)
2072 struct target_ops
**t
;
2073 struct target_ops
*runable
= NULL
;
2078 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2081 if ((*t
)->to_can_run
&& target_can_run (*t
))
2091 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2100 find_default_attach (char *args
, int from_tty
)
2102 struct target_ops
*t
;
2104 t
= find_default_run_target ("attach");
2105 (t
->to_attach
) (args
, from_tty
);
2110 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2113 struct target_ops
*t
;
2115 t
= find_default_run_target ("run");
2116 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2121 find_default_can_async_p (void)
2123 struct target_ops
*t
;
2125 /* This may be called before the target is pushed on the stack;
2126 look for the default process stratum. If there's none, gdb isn't
2127 configured with a native debugger, and target remote isn't
2129 t
= find_default_run_target (NULL
);
2130 if (t
&& t
->to_can_async_p
)
2131 return (t
->to_can_async_p
) ();
2136 find_default_is_async_p (void)
2138 struct target_ops
*t
;
2140 /* This may be called before the target is pushed on the stack;
2141 look for the default process stratum. If there's none, gdb isn't
2142 configured with a native debugger, and target remote isn't
2144 t
= find_default_run_target (NULL
);
2145 if (t
&& t
->to_is_async_p
)
2146 return (t
->to_is_async_p
) ();
2151 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2153 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
2157 default_watchpoint_addr_within_range (struct target_ops
*target
,
2159 CORE_ADDR start
, int length
)
2161 return addr
>= start
&& addr
< start
+ length
;
2177 return_minus_one (void)
2183 * Resize the to_sections pointer. Also make sure that anyone that
2184 * was holding on to an old value of it gets updated.
2185 * Returns the old size.
2189 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2191 struct target_ops
**t
;
2192 struct section_table
*old_value
;
2195 old_value
= target
->to_sections
;
2197 if (target
->to_sections
)
2199 old_count
= target
->to_sections_end
- target
->to_sections
;
2200 target
->to_sections
= (struct section_table
*)
2201 xrealloc ((char *) target
->to_sections
,
2202 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2207 target
->to_sections
= (struct section_table
*)
2208 xmalloc ((sizeof (struct section_table
)) * num_added
);
2210 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2212 /* Check to see if anyone else was pointing to this structure.
2213 If old_value was null, then no one was. */
2217 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2220 if ((*t
)->to_sections
== old_value
)
2222 (*t
)->to_sections
= target
->to_sections
;
2223 (*t
)->to_sections_end
= target
->to_sections_end
;
2226 /* There is a flattened view of the target stack in current_target,
2227 so its to_sections pointer might also need updating. */
2228 if (current_target
.to_sections
== old_value
)
2230 current_target
.to_sections
= target
->to_sections
;
2231 current_target
.to_sections_end
= target
->to_sections_end
;
2239 /* Remove all target sections taken from ABFD.
2241 Scan the current target stack for targets whose section tables
2242 refer to sections from BFD, and remove those sections. We use this
2243 when we notice that the inferior has unloaded a shared object, for
2246 remove_target_sections (bfd
*abfd
)
2248 struct target_ops
**t
;
2250 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2252 struct section_table
*src
, *dest
;
2254 dest
= (*t
)->to_sections
;
2255 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2256 if (src
->bfd
!= abfd
)
2258 /* Keep this section. */
2259 if (dest
< src
) *dest
= *src
;
2263 /* If we've dropped any sections, resize the section table. */
2265 target_resize_to_sections (*t
, dest
- src
);
2272 /* Find a single runnable target in the stack and return it. If for
2273 some reason there is more than one, return NULL. */
2276 find_run_target (void)
2278 struct target_ops
**t
;
2279 struct target_ops
*runable
= NULL
;
2284 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2286 if ((*t
)->to_can_run
&& target_can_run (*t
))
2293 return (count
== 1 ? runable
: NULL
);
2296 /* Find a single core_stratum target in the list of targets and return it.
2297 If for some reason there is more than one, return NULL. */
2300 find_core_target (void)
2302 struct target_ops
**t
;
2303 struct target_ops
*runable
= NULL
;
2308 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2311 if ((*t
)->to_stratum
== core_stratum
)
2318 return (count
== 1 ? runable
: NULL
);
2322 * Find the next target down the stack from the specified target.
2326 find_target_beneath (struct target_ops
*t
)
2332 /* The inferior process has died. Long live the inferior! */
2335 generic_mourn_inferior (void)
2337 extern int show_breakpoint_hit_counts
;
2339 inferior_ptid
= null_ptid
;
2341 breakpoint_init_inferior (inf_exited
);
2342 registers_changed ();
2344 reopen_exec_file ();
2345 reinit_frame_cache ();
2347 /* It is confusing to the user for ignore counts to stick around
2348 from previous runs of the inferior. So clear them. */
2349 /* However, it is more confusing for the ignore counts to disappear when
2350 using hit counts. So don't clear them if we're counting hits. */
2351 if (!show_breakpoint_hit_counts
)
2352 breakpoint_clear_ignore_counts ();
2354 if (deprecated_detach_hook
)
2355 deprecated_detach_hook ();
2358 /* Helper function for child_wait and the derivatives of child_wait.
2359 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2360 translation of that in OURSTATUS. */
2362 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2364 if (WIFEXITED (hoststatus
))
2366 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2367 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2369 else if (!WIFSTOPPED (hoststatus
))
2371 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2372 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2376 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2377 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2381 /* Returns zero to leave the inferior alone, one to interrupt it. */
2382 int (*target_activity_function
) (void);
2383 int target_activity_fd
;
2385 /* Convert a normal process ID to a string. Returns the string in a
2389 normal_pid_to_str (ptid_t ptid
)
2391 static char buf
[32];
2393 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2397 /* Error-catcher for target_find_memory_regions */
2398 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2400 error (_("No target."));
2404 /* Error-catcher for target_make_corefile_notes */
2405 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2407 error (_("No target."));
2411 /* Set up the handful of non-empty slots needed by the dummy target
2415 init_dummy_target (void)
2417 dummy_target
.to_shortname
= "None";
2418 dummy_target
.to_longname
= "None";
2419 dummy_target
.to_doc
= "";
2420 dummy_target
.to_attach
= find_default_attach
;
2421 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2422 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2423 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2424 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2425 dummy_target
.to_stratum
= dummy_stratum
;
2426 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2427 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2428 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2429 dummy_target
.to_magic
= OPS_MAGIC
;
2433 debug_to_open (char *args
, int from_tty
)
2435 debug_target
.to_open (args
, from_tty
);
2437 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2441 debug_to_close (int quitting
)
2443 target_close (&debug_target
, quitting
);
2444 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2448 target_close (struct target_ops
*targ
, int quitting
)
2450 if (targ
->to_xclose
!= NULL
)
2451 targ
->to_xclose (targ
, quitting
);
2452 else if (targ
->to_close
!= NULL
)
2453 targ
->to_close (quitting
);
2457 debug_to_attach (char *args
, int from_tty
)
2459 debug_target
.to_attach (args
, from_tty
);
2461 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2466 debug_to_post_attach (int pid
)
2468 debug_target
.to_post_attach (pid
);
2470 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2474 debug_to_detach (char *args
, int from_tty
)
2476 debug_target
.to_detach (args
, from_tty
);
2478 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2482 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2484 debug_target
.to_resume (ptid
, step
, siggnal
);
2486 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2487 step
? "step" : "continue",
2488 target_signal_to_name (siggnal
));
2492 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2496 retval
= debug_target
.to_wait (ptid
, status
);
2498 fprintf_unfiltered (gdb_stdlog
,
2499 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2501 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2502 switch (status
->kind
)
2504 case TARGET_WAITKIND_EXITED
:
2505 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2506 status
->value
.integer
);
2508 case TARGET_WAITKIND_STOPPED
:
2509 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2510 target_signal_to_name (status
->value
.sig
));
2512 case TARGET_WAITKIND_SIGNALLED
:
2513 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2514 target_signal_to_name (status
->value
.sig
));
2516 case TARGET_WAITKIND_LOADED
:
2517 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2519 case TARGET_WAITKIND_FORKED
:
2520 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2522 case TARGET_WAITKIND_VFORKED
:
2523 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2525 case TARGET_WAITKIND_EXECD
:
2526 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2528 case TARGET_WAITKIND_SPURIOUS
:
2529 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2532 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2540 debug_print_register (const char * func
,
2541 struct regcache
*regcache
, int regno
)
2543 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2544 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2545 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2546 + gdbarch_num_pseudo_regs (gdbarch
)
2547 && gdbarch_register_name (gdbarch
, regno
) != NULL
2548 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2549 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2550 gdbarch_register_name (gdbarch
, regno
));
2552 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2555 int i
, size
= register_size (gdbarch
, regno
);
2556 unsigned char buf
[MAX_REGISTER_SIZE
];
2557 regcache_cooked_read (regcache
, regno
, buf
);
2558 fprintf_unfiltered (gdb_stdlog
, " = ");
2559 for (i
= 0; i
< size
; i
++)
2561 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2563 if (size
<= sizeof (LONGEST
))
2565 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2566 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2567 paddr_nz (val
), paddr_d (val
));
2570 fprintf_unfiltered (gdb_stdlog
, "\n");
2574 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2576 debug_target
.to_fetch_registers (regcache
, regno
);
2577 debug_print_register ("target_fetch_registers", regcache
, regno
);
2581 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2583 debug_target
.to_store_registers (regcache
, regno
);
2584 debug_print_register ("target_store_registers", regcache
, regno
);
2585 fprintf_unfiltered (gdb_stdlog
, "\n");
2589 debug_to_prepare_to_store (struct regcache
*regcache
)
2591 debug_target
.to_prepare_to_store (regcache
);
2593 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2597 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2598 int write
, struct mem_attrib
*attrib
,
2599 struct target_ops
*target
)
2603 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2606 fprintf_unfiltered (gdb_stdlog
,
2607 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2608 (unsigned int) memaddr
, /* possable truncate long long */
2609 len
, write
? "write" : "read", retval
);
2615 fputs_unfiltered (", bytes =", gdb_stdlog
);
2616 for (i
= 0; i
< retval
; i
++)
2618 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2620 if (targetdebug
< 2 && i
> 0)
2622 fprintf_unfiltered (gdb_stdlog
, " ...");
2625 fprintf_unfiltered (gdb_stdlog
, "\n");
2628 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2632 fputc_unfiltered ('\n', gdb_stdlog
);
2638 debug_to_files_info (struct target_ops
*target
)
2640 debug_target
.to_files_info (target
);
2642 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2646 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2650 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2652 fprintf_unfiltered (gdb_stdlog
,
2653 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2654 (unsigned long) bp_tgt
->placed_address
,
2655 (unsigned long) retval
);
2660 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2664 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2666 fprintf_unfiltered (gdb_stdlog
,
2667 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2668 (unsigned long) bp_tgt
->placed_address
,
2669 (unsigned long) retval
);
2674 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2678 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2680 fprintf_unfiltered (gdb_stdlog
,
2681 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2682 (unsigned long) type
,
2683 (unsigned long) cnt
,
2684 (unsigned long) from_tty
,
2685 (unsigned long) retval
);
2690 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2694 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2696 fprintf_unfiltered (gdb_stdlog
,
2697 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2698 (unsigned long) addr
,
2699 (unsigned long) len
,
2700 (unsigned long) retval
);
2705 debug_to_stopped_by_watchpoint (void)
2709 retval
= debug_target
.to_stopped_by_watchpoint ();
2711 fprintf_unfiltered (gdb_stdlog
,
2712 "STOPPED_BY_WATCHPOINT () = %ld\n",
2713 (unsigned long) retval
);
2718 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2722 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2724 fprintf_unfiltered (gdb_stdlog
,
2725 "target_stopped_data_address ([0x%lx]) = %ld\n",
2726 (unsigned long)*addr
,
2727 (unsigned long)retval
);
2732 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2734 CORE_ADDR start
, int length
)
2738 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2741 fprintf_filtered (gdb_stdlog
,
2742 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2743 (unsigned long) addr
, (unsigned long) start
, length
,
2749 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2753 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2755 fprintf_unfiltered (gdb_stdlog
,
2756 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2757 (unsigned long) bp_tgt
->placed_address
,
2758 (unsigned long) retval
);
2763 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2767 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2769 fprintf_unfiltered (gdb_stdlog
,
2770 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2771 (unsigned long) bp_tgt
->placed_address
,
2772 (unsigned long) retval
);
2777 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2781 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2783 fprintf_unfiltered (gdb_stdlog
,
2784 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2785 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2790 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2794 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2796 fprintf_unfiltered (gdb_stdlog
,
2797 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2798 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2803 debug_to_terminal_init (void)
2805 debug_target
.to_terminal_init ();
2807 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2811 debug_to_terminal_inferior (void)
2813 debug_target
.to_terminal_inferior ();
2815 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2819 debug_to_terminal_ours_for_output (void)
2821 debug_target
.to_terminal_ours_for_output ();
2823 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2827 debug_to_terminal_ours (void)
2829 debug_target
.to_terminal_ours ();
2831 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2835 debug_to_terminal_save_ours (void)
2837 debug_target
.to_terminal_save_ours ();
2839 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2843 debug_to_terminal_info (char *arg
, int from_tty
)
2845 debug_target
.to_terminal_info (arg
, from_tty
);
2847 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2852 debug_to_kill (void)
2854 debug_target
.to_kill ();
2856 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2860 debug_to_load (char *args
, int from_tty
)
2862 debug_target
.to_load (args
, from_tty
);
2864 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2868 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2872 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2874 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2880 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2883 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2885 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2886 exec_file
, args
, from_tty
);
2890 debug_to_post_startup_inferior (ptid_t ptid
)
2892 debug_target
.to_post_startup_inferior (ptid
);
2894 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2899 debug_to_acknowledge_created_inferior (int pid
)
2901 debug_target
.to_acknowledge_created_inferior (pid
);
2903 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2908 debug_to_insert_fork_catchpoint (int pid
)
2910 debug_target
.to_insert_fork_catchpoint (pid
);
2912 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2917 debug_to_remove_fork_catchpoint (int pid
)
2921 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2923 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2930 debug_to_insert_vfork_catchpoint (int pid
)
2932 debug_target
.to_insert_vfork_catchpoint (pid
);
2934 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2939 debug_to_remove_vfork_catchpoint (int pid
)
2943 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2945 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2952 debug_to_insert_exec_catchpoint (int pid
)
2954 debug_target
.to_insert_exec_catchpoint (pid
);
2956 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2961 debug_to_remove_exec_catchpoint (int pid
)
2965 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2967 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2974 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2978 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2980 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2981 pid
, wait_status
, *exit_status
, has_exited
);
2987 debug_to_mourn_inferior (void)
2989 debug_target
.to_mourn_inferior ();
2991 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2995 debug_to_can_run (void)
2999 retval
= debug_target
.to_can_run ();
3001 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3007 debug_to_notice_signals (ptid_t ptid
)
3009 debug_target
.to_notice_signals (ptid
);
3011 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3016 debug_to_thread_alive (ptid_t ptid
)
3020 retval
= debug_target
.to_thread_alive (ptid
);
3022 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3023 PIDGET (ptid
), retval
);
3029 debug_to_find_new_threads (void)
3031 debug_target
.to_find_new_threads ();
3033 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3037 debug_to_stop (ptid_t ptid
)
3039 debug_target
.to_stop (ptid
);
3041 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3042 target_pid_to_str (ptid
));
3046 debug_to_rcmd (char *command
,
3047 struct ui_file
*outbuf
)
3049 debug_target
.to_rcmd (command
, outbuf
);
3050 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3054 debug_to_pid_to_exec_file (int pid
)
3058 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3060 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3067 setup_target_debug (void)
3069 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3071 current_target
.to_open
= debug_to_open
;
3072 current_target
.to_close
= debug_to_close
;
3073 current_target
.to_attach
= debug_to_attach
;
3074 current_target
.to_post_attach
= debug_to_post_attach
;
3075 current_target
.to_detach
= debug_to_detach
;
3076 current_target
.to_resume
= debug_to_resume
;
3077 current_target
.to_wait
= debug_to_wait
;
3078 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3079 current_target
.to_store_registers
= debug_to_store_registers
;
3080 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3081 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3082 current_target
.to_files_info
= debug_to_files_info
;
3083 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3084 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3085 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3086 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3087 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3088 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3089 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3090 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3091 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3092 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3093 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3094 current_target
.to_terminal_init
= debug_to_terminal_init
;
3095 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3096 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3097 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3098 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3099 current_target
.to_terminal_info
= debug_to_terminal_info
;
3100 current_target
.to_kill
= debug_to_kill
;
3101 current_target
.to_load
= debug_to_load
;
3102 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3103 current_target
.to_create_inferior
= debug_to_create_inferior
;
3104 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3105 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3106 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3107 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3108 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3109 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3110 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3111 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3112 current_target
.to_has_exited
= debug_to_has_exited
;
3113 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3114 current_target
.to_can_run
= debug_to_can_run
;
3115 current_target
.to_notice_signals
= debug_to_notice_signals
;
3116 current_target
.to_thread_alive
= debug_to_thread_alive
;
3117 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3118 current_target
.to_stop
= debug_to_stop
;
3119 current_target
.to_rcmd
= debug_to_rcmd
;
3120 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3124 static char targ_desc
[] =
3125 "Names of targets and files being debugged.\n\
3126 Shows the entire stack of targets currently in use (including the exec-file,\n\
3127 core-file, and process, if any), as well as the symbol file name.";
3130 do_monitor_command (char *cmd
,
3133 if ((current_target
.to_rcmd
3134 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3135 || (current_target
.to_rcmd
== debug_to_rcmd
3136 && (debug_target
.to_rcmd
3137 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3138 error (_("\"monitor\" command not supported by this target."));
3139 target_rcmd (cmd
, gdb_stdtarg
);
3142 /* Print the name of each layers of our target stack. */
3145 maintenance_print_target_stack (char *cmd
, int from_tty
)
3147 struct target_ops
*t
;
3149 printf_filtered (_("The current target stack is:\n"));
3151 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3153 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3158 initialize_targets (void)
3160 init_dummy_target ();
3161 push_target (&dummy_target
);
3163 add_info ("target", target_info
, targ_desc
);
3164 add_info ("files", target_info
, targ_desc
);
3166 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3167 Set target debugging."), _("\
3168 Show target debugging."), _("\
3169 When non-zero, target debugging is enabled. Higher numbers are more\n\
3170 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3174 &setdebuglist
, &showdebuglist
);
3176 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3177 &trust_readonly
, _("\
3178 Set mode for reading from readonly sections."), _("\
3179 Show mode for reading from readonly sections."), _("\
3180 When this mode is on, memory reads from readonly sections (such as .text)\n\
3181 will be read from the object file instead of from the target. This will\n\
3182 result in significant performance improvement for remote targets."),
3184 show_trust_readonly
,
3185 &setlist
, &showlist
);
3187 add_com ("monitor", class_obscure
, do_monitor_command
,
3188 _("Send a command to the remote monitor (remote targets only)."));
3190 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3191 _("Print the name of each layer of the internal target stack."),
3192 &maintenanceprintlist
);
3194 target_dcache
= dcache_init ();