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_above (enum strata above_stratum
, int quitting
)
827 while ((int) (current_target
.to_stratum
) > (int) above_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"));
843 pop_all_targets (int quitting
)
845 pop_all_targets_above (dummy_stratum
, quitting
);
848 /* Using the objfile specified in OBJFILE, find the address for the
849 current thread's thread-local storage with offset OFFSET. */
851 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
853 volatile CORE_ADDR addr
= 0;
855 if (target_get_thread_local_address_p ()
856 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
858 ptid_t ptid
= inferior_ptid
;
859 volatile struct gdb_exception ex
;
861 TRY_CATCH (ex
, RETURN_MASK_ALL
)
865 /* Fetch the load module address for this objfile. */
866 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
868 /* If it's 0, throw the appropriate exception. */
870 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
871 _("TLS load module not found"));
873 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
875 /* If an error occurred, print TLS related messages here. Otherwise,
876 throw the error to some higher catcher. */
879 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
883 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
884 error (_("Cannot find thread-local variables in this thread library."));
886 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
887 if (objfile_is_library
)
888 error (_("Cannot find shared library `%s' in dynamic"
889 " linker's load module list"), objfile
->name
);
891 error (_("Cannot find executable file `%s' in dynamic"
892 " linker's load module list"), objfile
->name
);
894 case TLS_NOT_ALLOCATED_YET_ERROR
:
895 if (objfile_is_library
)
896 error (_("The inferior has not yet allocated storage for"
897 " thread-local variables in\n"
898 "the shared library `%s'\n"
900 objfile
->name
, target_pid_to_str (ptid
));
902 error (_("The inferior has not yet allocated storage for"
903 " thread-local variables in\n"
904 "the executable `%s'\n"
906 objfile
->name
, target_pid_to_str (ptid
));
908 case TLS_GENERIC_ERROR
:
909 if (objfile_is_library
)
910 error (_("Cannot find thread-local storage for %s, "
911 "shared library %s:\n%s"),
912 target_pid_to_str (ptid
),
913 objfile
->name
, ex
.message
);
915 error (_("Cannot find thread-local storage for %s, "
916 "executable file %s:\n%s"),
917 target_pid_to_str (ptid
),
918 objfile
->name
, ex
.message
);
921 throw_exception (ex
);
926 /* It wouldn't be wrong here to try a gdbarch method, too; finding
927 TLS is an ABI-specific thing. But we don't do that yet. */
929 error (_("Cannot find thread-local variables on this target"));
935 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
937 /* target_read_string -- read a null terminated string, up to LEN bytes,
938 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
939 Set *STRING to a pointer to malloc'd memory containing the data; the caller
940 is responsible for freeing it. Return the number of bytes successfully
944 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
946 int tlen
, origlen
, offset
, i
;
950 int buffer_allocated
;
952 unsigned int nbytes_read
= 0;
956 /* Small for testing. */
957 buffer_allocated
= 4;
958 buffer
= xmalloc (buffer_allocated
);
965 tlen
= MIN (len
, 4 - (memaddr
& 3));
966 offset
= memaddr
& 3;
968 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
971 /* The transfer request might have crossed the boundary to an
972 unallocated region of memory. Retry the transfer, requesting
976 errcode
= target_read_memory (memaddr
, buf
, 1);
981 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
984 bytes
= bufptr
- buffer
;
985 buffer_allocated
*= 2;
986 buffer
= xrealloc (buffer
, buffer_allocated
);
987 bufptr
= buffer
+ bytes
;
990 for (i
= 0; i
< tlen
; i
++)
992 *bufptr
++ = buf
[i
+ offset
];
993 if (buf
[i
+ offset
] == '\000')
995 nbytes_read
+= i
+ 1;
1002 nbytes_read
+= tlen
;
1011 /* Find a section containing ADDR. */
1012 struct section_table
*
1013 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1015 struct section_table
*secp
;
1016 for (secp
= target
->to_sections
;
1017 secp
< target
->to_sections_end
;
1020 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1026 /* Perform a partial memory transfer. The arguments and return
1027 value are just as for target_xfer_partial. */
1030 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1031 ULONGEST memaddr
, LONGEST len
)
1035 struct mem_region
*region
;
1037 /* Zero length requests are ok and require no work. */
1041 /* Try the executable file, if "trust-readonly-sections" is set. */
1042 if (readbuf
!= NULL
&& trust_readonly
)
1044 struct section_table
*secp
;
1046 secp
= target_section_by_addr (ops
, memaddr
);
1048 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1050 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1053 /* Likewise for accesses to unmapped overlay sections. */
1054 if (readbuf
!= NULL
&& overlay_debugging
)
1056 asection
*section
= find_pc_overlay (memaddr
);
1057 if (pc_in_unmapped_range (memaddr
, section
))
1058 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1061 /* Try GDB's internal data cache. */
1062 region
= lookup_mem_region (memaddr
);
1063 /* region->hi == 0 means there's no upper bound. */
1064 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1067 reg_len
= region
->hi
- memaddr
;
1069 switch (region
->attrib
.mode
)
1072 if (writebuf
!= NULL
)
1077 if (readbuf
!= NULL
)
1082 /* We only support writing to flash during "load" for now. */
1083 if (writebuf
!= NULL
)
1084 error (_("Writing to flash memory forbidden in this context"));
1091 if (region
->attrib
.cache
)
1093 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1094 memory request will start back at current_target. */
1095 if (readbuf
!= NULL
)
1096 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1099 /* FIXME drow/2006-08-09: If we're going to preserve const
1100 correctness dcache_xfer_memory should take readbuf and
1102 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1109 if (readbuf
&& !show_memory_breakpoints
)
1110 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1115 /* If none of those methods found the memory we wanted, fall back
1116 to a target partial transfer. Normally a single call to
1117 to_xfer_partial is enough; if it doesn't recognize an object
1118 it will call the to_xfer_partial of the next target down.
1119 But for memory this won't do. Memory is the only target
1120 object which can be read from more than one valid target.
1121 A core file, for instance, could have some of memory but
1122 delegate other bits to the target below it. So, we must
1123 manually try all targets. */
1127 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1128 readbuf
, writebuf
, memaddr
, reg_len
);
1132 /* We want to continue past core files to executables, but not
1133 past a running target's memory. */
1134 if (ops
->to_has_all_memory
)
1139 while (ops
!= NULL
);
1141 if (readbuf
&& !show_memory_breakpoints
)
1142 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1144 /* If we still haven't got anything, return the last error. We
1150 restore_show_memory_breakpoints (void *arg
)
1152 show_memory_breakpoints
= (uintptr_t) arg
;
1156 make_show_memory_breakpoints_cleanup (int show
)
1158 int current
= show_memory_breakpoints
;
1159 show_memory_breakpoints
= show
;
1161 return make_cleanup (restore_show_memory_breakpoints
,
1162 (void *) (uintptr_t) current
);
1166 target_xfer_partial (struct target_ops
*ops
,
1167 enum target_object object
, const char *annex
,
1168 void *readbuf
, const void *writebuf
,
1169 ULONGEST offset
, LONGEST len
)
1173 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1175 /* If this is a memory transfer, let the memory-specific code
1176 have a look at it instead. Memory transfers are more
1178 if (object
== TARGET_OBJECT_MEMORY
)
1179 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1182 enum target_object raw_object
= object
;
1184 /* If this is a raw memory transfer, request the normal
1185 memory object from other layers. */
1186 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1187 raw_object
= TARGET_OBJECT_MEMORY
;
1189 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1190 writebuf
, offset
, len
);
1195 const unsigned char *myaddr
= NULL
;
1197 fprintf_unfiltered (gdb_stdlog
,
1198 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1201 (annex
? annex
: "(null)"),
1202 (long) readbuf
, (long) writebuf
,
1203 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1209 if (retval
> 0 && myaddr
!= NULL
)
1213 fputs_unfiltered (", bytes =", gdb_stdlog
);
1214 for (i
= 0; i
< retval
; i
++)
1216 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1218 if (targetdebug
< 2 && i
> 0)
1220 fprintf_unfiltered (gdb_stdlog
, " ...");
1223 fprintf_unfiltered (gdb_stdlog
, "\n");
1226 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1230 fputc_unfiltered ('\n', gdb_stdlog
);
1235 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1236 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1237 if any error occurs.
1239 If an error occurs, no guarantee is made about the contents of the data at
1240 MYADDR. In particular, the caller should not depend upon partial reads
1241 filling the buffer with good data. There is no way for the caller to know
1242 how much good data might have been transfered anyway. Callers that can
1243 deal with partial reads should call target_read (which will retry until
1244 it makes no progress, and then return how much was transferred). */
1247 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1249 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1250 myaddr
, memaddr
, len
) == len
)
1257 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1259 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1260 myaddr
, memaddr
, len
) == len
)
1266 /* Fetch the target's memory map. */
1269 target_memory_map (void)
1271 VEC(mem_region_s
) *result
;
1272 struct mem_region
*last_one
, *this_one
;
1274 struct target_ops
*t
;
1277 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1279 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1280 if (t
->to_memory_map
!= NULL
)
1286 result
= t
->to_memory_map (t
);
1290 qsort (VEC_address (mem_region_s
, result
),
1291 VEC_length (mem_region_s
, result
),
1292 sizeof (struct mem_region
), mem_region_cmp
);
1294 /* Check that regions do not overlap. Simultaneously assign
1295 a numbering for the "mem" commands to use to refer to
1298 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1300 this_one
->number
= ix
;
1302 if (last_one
&& last_one
->hi
> this_one
->lo
)
1304 warning (_("Overlapping regions in memory map: ignoring"));
1305 VEC_free (mem_region_s
, result
);
1308 last_one
= this_one
;
1315 target_flash_erase (ULONGEST address
, LONGEST length
)
1317 struct target_ops
*t
;
1319 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1320 if (t
->to_flash_erase
!= NULL
)
1323 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1324 paddr (address
), phex (length
, 0));
1325 t
->to_flash_erase (t
, address
, length
);
1333 target_flash_done (void)
1335 struct target_ops
*t
;
1337 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1338 if (t
->to_flash_done
!= NULL
)
1341 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1342 t
->to_flash_done (t
);
1349 #ifndef target_stopped_data_address_p
1351 target_stopped_data_address_p (struct target_ops
*target
)
1353 if (target
->to_stopped_data_address
1354 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1356 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1357 && (debug_target
.to_stopped_data_address
1358 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1365 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1366 struct cmd_list_element
*c
, const char *value
)
1368 fprintf_filtered (file
, _("\
1369 Mode for reading from readonly sections is %s.\n"),
1373 /* More generic transfers. */
1376 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1377 const char *annex
, gdb_byte
*readbuf
,
1378 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1380 if (object
== TARGET_OBJECT_MEMORY
1381 && ops
->deprecated_xfer_memory
!= NULL
)
1382 /* If available, fall back to the target's
1383 "deprecated_xfer_memory" method. */
1387 if (writebuf
!= NULL
)
1389 void *buffer
= xmalloc (len
);
1390 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1391 memcpy (buffer
, writebuf
, len
);
1392 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1393 1/*write*/, NULL
, ops
);
1394 do_cleanups (cleanup
);
1396 if (readbuf
!= NULL
)
1397 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1398 0/*read*/, NULL
, ops
);
1401 else if (xfered
== 0 && errno
== 0)
1402 /* "deprecated_xfer_memory" uses 0, cross checked against
1403 ERRNO as one indication of an error. */
1408 else if (ops
->beneath
!= NULL
)
1409 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1410 readbuf
, writebuf
, offset
, len
);
1415 /* The xfer_partial handler for the topmost target. Unlike the default,
1416 it does not need to handle memory specially; it just passes all
1417 requests down the stack. */
1420 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1421 const char *annex
, gdb_byte
*readbuf
,
1422 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1424 if (ops
->beneath
!= NULL
)
1425 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1426 readbuf
, writebuf
, offset
, len
);
1431 /* Target vector read/write partial wrapper functions.
1433 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1434 (inbuf, outbuf)", instead of separate read/write methods, make life
1438 target_read_partial (struct target_ops
*ops
,
1439 enum target_object object
,
1440 const char *annex
, gdb_byte
*buf
,
1441 ULONGEST offset
, LONGEST len
)
1443 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1447 target_write_partial (struct target_ops
*ops
,
1448 enum target_object object
,
1449 const char *annex
, const gdb_byte
*buf
,
1450 ULONGEST offset
, LONGEST len
)
1452 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1455 /* Wrappers to perform the full transfer. */
1457 target_read (struct target_ops
*ops
,
1458 enum target_object object
,
1459 const char *annex
, gdb_byte
*buf
,
1460 ULONGEST offset
, LONGEST len
)
1463 while (xfered
< len
)
1465 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1466 (gdb_byte
*) buf
+ xfered
,
1467 offset
+ xfered
, len
- xfered
);
1468 /* Call an observer, notifying them of the xfer progress? */
1480 target_read_until_error (struct target_ops
*ops
,
1481 enum target_object object
,
1482 const char *annex
, gdb_byte
*buf
,
1483 ULONGEST offset
, LONGEST len
)
1486 while (xfered
< len
)
1488 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1489 (gdb_byte
*) buf
+ xfered
,
1490 offset
+ xfered
, len
- xfered
);
1491 /* Call an observer, notifying them of the xfer progress? */
1496 /* We've got an error. Try to read in smaller blocks. */
1497 ULONGEST start
= offset
+ xfered
;
1498 ULONGEST remaining
= len
- xfered
;
1501 /* If an attempt was made to read a random memory address,
1502 it's likely that the very first byte is not accessible.
1503 Try reading the first byte, to avoid doing log N tries
1505 xfer
= target_read_partial (ops
, object
, annex
,
1506 (gdb_byte
*) buf
+ xfered
, start
, 1);
1515 xfer
= target_read_partial (ops
, object
, annex
,
1516 (gdb_byte
*) buf
+ xfered
,
1526 /* We have successfully read the first half. So, the
1527 error must be in the second half. Adjust start and
1528 remaining to point at the second half. */
1545 /* An alternative to target_write with progress callbacks. */
1548 target_write_with_progress (struct target_ops
*ops
,
1549 enum target_object object
,
1550 const char *annex
, const gdb_byte
*buf
,
1551 ULONGEST offset
, LONGEST len
,
1552 void (*progress
) (ULONGEST
, void *), void *baton
)
1556 /* Give the progress callback a chance to set up. */
1558 (*progress
) (0, baton
);
1560 while (xfered
< len
)
1562 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1563 (gdb_byte
*) buf
+ xfered
,
1564 offset
+ xfered
, len
- xfered
);
1572 (*progress
) (xfer
, baton
);
1581 target_write (struct target_ops
*ops
,
1582 enum target_object object
,
1583 const char *annex
, const gdb_byte
*buf
,
1584 ULONGEST offset
, LONGEST len
)
1586 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1590 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1591 the size of the transferred data. PADDING additional bytes are
1592 available in *BUF_P. This is a helper function for
1593 target_read_alloc; see the declaration of that function for more
1597 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1598 const char *annex
, gdb_byte
**buf_p
, int padding
)
1600 size_t buf_alloc
, buf_pos
;
1604 /* This function does not have a length parameter; it reads the
1605 entire OBJECT). Also, it doesn't support objects fetched partly
1606 from one target and partly from another (in a different stratum,
1607 e.g. a core file and an executable). Both reasons make it
1608 unsuitable for reading memory. */
1609 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1611 /* Start by reading up to 4K at a time. The target will throttle
1612 this number down if necessary. */
1614 buf
= xmalloc (buf_alloc
);
1618 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1619 buf_pos
, buf_alloc
- buf_pos
- padding
);
1622 /* An error occurred. */
1628 /* Read all there was. */
1638 /* If the buffer is filling up, expand it. */
1639 if (buf_alloc
< buf_pos
* 2)
1642 buf
= xrealloc (buf
, buf_alloc
);
1649 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1650 the size of the transferred data. See the declaration in "target.h"
1651 function for more information about the return value. */
1654 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1655 const char *annex
, gdb_byte
**buf_p
)
1657 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1660 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1661 returned as a string, allocated using xmalloc. If an error occurs
1662 or the transfer is unsupported, NULL is returned. Empty objects
1663 are returned as allocated but empty strings. A warning is issued
1664 if the result contains any embedded NUL bytes. */
1667 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1671 LONGEST transferred
;
1673 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1675 if (transferred
< 0)
1678 if (transferred
== 0)
1679 return xstrdup ("");
1681 buffer
[transferred
] = 0;
1682 if (strlen (buffer
) < transferred
)
1683 warning (_("target object %d, annex %s, "
1684 "contained unexpected null characters"),
1685 (int) object
, annex
? annex
: "(none)");
1687 return (char *) buffer
;
1690 /* Memory transfer methods. */
1693 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1696 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1698 memory_error (EIO
, addr
);
1702 get_target_memory_unsigned (struct target_ops
*ops
,
1703 CORE_ADDR addr
, int len
)
1705 gdb_byte buf
[sizeof (ULONGEST
)];
1707 gdb_assert (len
<= sizeof (buf
));
1708 get_target_memory (ops
, addr
, buf
, len
);
1709 return extract_unsigned_integer (buf
, len
);
1713 target_info (char *args
, int from_tty
)
1715 struct target_ops
*t
;
1716 int has_all_mem
= 0;
1718 if (symfile_objfile
!= NULL
)
1719 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1721 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1723 if (!t
->to_has_memory
)
1726 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1729 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1730 printf_unfiltered ("%s:\n", t
->to_longname
);
1731 (t
->to_files_info
) (t
);
1732 has_all_mem
= t
->to_has_all_memory
;
1736 /* This function is called before any new inferior is created, e.g.
1737 by running a program, attaching, or connecting to a target.
1738 It cleans up any state from previous invocations which might
1739 change between runs. This is a subset of what target_preopen
1740 resets (things which might change between targets). */
1743 target_pre_inferior (int from_tty
)
1745 /* Clear out solib state. Otherwise the solib state of the previous
1746 inferior might have survived and is entirely wrong for the new
1747 target. This has been observed on GNU/Linux using glibc 2.3. How
1759 Cannot access memory at address 0xdeadbeef
1761 no_shared_libraries (NULL
, from_tty
);
1763 invalidate_target_mem_regions ();
1765 target_clear_description ();
1768 /* This is to be called by the open routine before it does
1772 target_preopen (int from_tty
)
1776 if (target_has_execution
)
1779 || query (_("A program is being debugged already. Kill it? ")))
1782 error (_("Program not killed."));
1785 /* Calling target_kill may remove the target from the stack. But if
1786 it doesn't (which seems like a win for UDI), remove it now. */
1787 /* Leave the exec target, though. The user may be switching from a
1788 live process to a core of the same program. */
1789 pop_all_targets_above (file_stratum
, 0);
1791 target_pre_inferior (from_tty
);
1794 /* Detach a target after doing deferred register stores. */
1797 target_detach (char *args
, int from_tty
)
1799 /* If we're in breakpoints-always-inserted mode, have to
1800 remove them before detaching. */
1801 remove_breakpoints ();
1803 (current_target
.to_detach
) (args
, from_tty
);
1807 target_disconnect (char *args
, int from_tty
)
1809 struct target_ops
*t
;
1811 /* If we're in breakpoints-always-inserted mode, have to
1812 remove them before disconnecting. */
1813 remove_breakpoints ();
1815 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1816 if (t
->to_disconnect
!= NULL
)
1819 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1821 t
->to_disconnect (t
, args
, from_tty
);
1829 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1831 dcache_invalidate (target_dcache
);
1832 (*current_target
.to_resume
) (ptid
, step
, signal
);
1833 set_executing (ptid
, 1);
1834 set_running (ptid
, 1);
1836 /* Look through the list of possible targets for a target that can
1840 target_follow_fork (int follow_child
)
1842 struct target_ops
*t
;
1844 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1846 if (t
->to_follow_fork
!= NULL
)
1848 int retval
= t
->to_follow_fork (t
, follow_child
);
1850 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1851 follow_child
, retval
);
1856 /* Some target returned a fork event, but did not know how to follow it. */
1857 internal_error (__FILE__
, __LINE__
,
1858 "could not find a target to follow fork");
1861 /* Look for a target which can describe architectural features, starting
1862 from TARGET. If we find one, return its description. */
1864 const struct target_desc
*
1865 target_read_description (struct target_ops
*target
)
1867 struct target_ops
*t
;
1869 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1870 if (t
->to_read_description
!= NULL
)
1872 const struct target_desc
*tdesc
;
1874 tdesc
= t
->to_read_description (t
);
1882 /* The default implementation of to_search_memory.
1883 This implements a basic search of memory, reading target memory and
1884 performing the search here (as opposed to performing the search in on the
1885 target side with, for example, gdbserver). */
1888 simple_search_memory (struct target_ops
*ops
,
1889 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1890 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1891 CORE_ADDR
*found_addrp
)
1893 /* NOTE: also defined in find.c testcase. */
1894 #define SEARCH_CHUNK_SIZE 16000
1895 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1896 /* Buffer to hold memory contents for searching. */
1897 gdb_byte
*search_buf
;
1898 unsigned search_buf_size
;
1899 struct cleanup
*old_cleanups
;
1901 search_buf_size
= chunk_size
+ pattern_len
- 1;
1903 /* No point in trying to allocate a buffer larger than the search space. */
1904 if (search_space_len
< search_buf_size
)
1905 search_buf_size
= search_space_len
;
1907 search_buf
= malloc (search_buf_size
);
1908 if (search_buf
== NULL
)
1909 error (_("Unable to allocate memory to perform the search."));
1910 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1912 /* Prime the search buffer. */
1914 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1915 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1917 warning (_("Unable to access target memory at %s, halting search."),
1918 hex_string (start_addr
));
1919 do_cleanups (old_cleanups
);
1923 /* Perform the search.
1925 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1926 When we've scanned N bytes we copy the trailing bytes to the start and
1927 read in another N bytes. */
1929 while (search_space_len
>= pattern_len
)
1931 gdb_byte
*found_ptr
;
1932 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1934 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1935 pattern
, pattern_len
);
1937 if (found_ptr
!= NULL
)
1939 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1940 *found_addrp
= found_addr
;
1941 do_cleanups (old_cleanups
);
1945 /* Not found in this chunk, skip to next chunk. */
1947 /* Don't let search_space_len wrap here, it's unsigned. */
1948 if (search_space_len
>= chunk_size
)
1949 search_space_len
-= chunk_size
;
1951 search_space_len
= 0;
1953 if (search_space_len
>= pattern_len
)
1955 unsigned keep_len
= search_buf_size
- chunk_size
;
1956 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1959 /* Copy the trailing part of the previous iteration to the front
1960 of the buffer for the next iteration. */
1961 gdb_assert (keep_len
== pattern_len
- 1);
1962 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1964 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1966 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1967 search_buf
+ keep_len
, read_addr
,
1968 nr_to_read
) != nr_to_read
)
1970 warning (_("Unable to access target memory at %s, halting search."),
1971 hex_string (read_addr
));
1972 do_cleanups (old_cleanups
);
1976 start_addr
+= chunk_size
;
1982 do_cleanups (old_cleanups
);
1986 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1987 sequence of bytes in PATTERN with length PATTERN_LEN.
1989 The result is 1 if found, 0 if not found, and -1 if there was an error
1990 requiring halting of the search (e.g. memory read error).
1991 If the pattern is found the address is recorded in FOUND_ADDRP. */
1994 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1995 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1996 CORE_ADDR
*found_addrp
)
1998 struct target_ops
*t
;
2001 /* We don't use INHERIT to set current_target.to_search_memory,
2002 so we have to scan the target stack and handle targetdebug
2006 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2007 hex_string (start_addr
));
2009 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2010 if (t
->to_search_memory
!= NULL
)
2015 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2016 pattern
, pattern_len
, found_addrp
);
2020 /* If a special version of to_search_memory isn't available, use the
2022 found
= simple_search_memory (¤t_target
,
2023 start_addr
, search_space_len
,
2024 pattern
, pattern_len
, found_addrp
);
2028 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2033 /* Look through the currently pushed targets. If none of them will
2034 be able to restart the currently running process, issue an error
2038 target_require_runnable (void)
2040 struct target_ops
*t
;
2042 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2044 /* If this target knows how to create a new program, then
2045 assume we will still be able to after killing the current
2046 one. Either killing and mourning will not pop T, or else
2047 find_default_run_target will find it again. */
2048 if (t
->to_create_inferior
!= NULL
)
2051 /* Do not worry about thread_stratum targets that can not
2052 create inferiors. Assume they will be pushed again if
2053 necessary, and continue to the process_stratum. */
2054 if (t
->to_stratum
== thread_stratum
)
2058 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2062 /* This function is only called if the target is running. In that
2063 case there should have been a process_stratum target and it
2064 should either know how to create inferiors, or not... */
2065 internal_error (__FILE__
, __LINE__
, "No targets found");
2068 /* Look through the list of possible targets for a target that can
2069 execute a run or attach command without any other data. This is
2070 used to locate the default process stratum.
2072 If DO_MESG is not NULL, the result is always valid (error() is
2073 called for errors); else, return NULL on error. */
2075 static struct target_ops
*
2076 find_default_run_target (char *do_mesg
)
2078 struct target_ops
**t
;
2079 struct target_ops
*runable
= NULL
;
2084 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2087 if ((*t
)->to_can_run
&& target_can_run (*t
))
2097 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2106 find_default_attach (char *args
, int from_tty
)
2108 struct target_ops
*t
;
2110 t
= find_default_run_target ("attach");
2111 (t
->to_attach
) (args
, from_tty
);
2116 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2119 struct target_ops
*t
;
2121 t
= find_default_run_target ("run");
2122 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2127 find_default_can_async_p (void)
2129 struct target_ops
*t
;
2131 /* This may be called before the target is pushed on the stack;
2132 look for the default process stratum. If there's none, gdb isn't
2133 configured with a native debugger, and target remote isn't
2135 t
= find_default_run_target (NULL
);
2136 if (t
&& t
->to_can_async_p
)
2137 return (t
->to_can_async_p
) ();
2142 find_default_is_async_p (void)
2144 struct target_ops
*t
;
2146 /* This may be called before the target is pushed on the stack;
2147 look for the default process stratum. If there's none, gdb isn't
2148 configured with a native debugger, and target remote isn't
2150 t
= find_default_run_target (NULL
);
2151 if (t
&& t
->to_is_async_p
)
2152 return (t
->to_is_async_p
) ();
2157 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2159 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
2163 default_watchpoint_addr_within_range (struct target_ops
*target
,
2165 CORE_ADDR start
, int length
)
2167 return addr
>= start
&& addr
< start
+ length
;
2183 return_minus_one (void)
2189 * Resize the to_sections pointer. Also make sure that anyone that
2190 * was holding on to an old value of it gets updated.
2191 * Returns the old size.
2195 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2197 struct target_ops
**t
;
2198 struct section_table
*old_value
;
2201 old_value
= target
->to_sections
;
2203 if (target
->to_sections
)
2205 old_count
= target
->to_sections_end
- target
->to_sections
;
2206 target
->to_sections
= (struct section_table
*)
2207 xrealloc ((char *) target
->to_sections
,
2208 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2213 target
->to_sections
= (struct section_table
*)
2214 xmalloc ((sizeof (struct section_table
)) * num_added
);
2216 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2218 /* Check to see if anyone else was pointing to this structure.
2219 If old_value was null, then no one was. */
2223 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2226 if ((*t
)->to_sections
== old_value
)
2228 (*t
)->to_sections
= target
->to_sections
;
2229 (*t
)->to_sections_end
= target
->to_sections_end
;
2232 /* There is a flattened view of the target stack in current_target,
2233 so its to_sections pointer might also need updating. */
2234 if (current_target
.to_sections
== old_value
)
2236 current_target
.to_sections
= target
->to_sections
;
2237 current_target
.to_sections_end
= target
->to_sections_end
;
2245 /* Remove all target sections taken from ABFD.
2247 Scan the current target stack for targets whose section tables
2248 refer to sections from BFD, and remove those sections. We use this
2249 when we notice that the inferior has unloaded a shared object, for
2252 remove_target_sections (bfd
*abfd
)
2254 struct target_ops
**t
;
2256 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2258 struct section_table
*src
, *dest
;
2260 dest
= (*t
)->to_sections
;
2261 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2262 if (src
->bfd
!= abfd
)
2264 /* Keep this section. */
2265 if (dest
< src
) *dest
= *src
;
2269 /* If we've dropped any sections, resize the section table. */
2271 target_resize_to_sections (*t
, dest
- src
);
2278 /* Find a single runnable target in the stack and return it. If for
2279 some reason there is more than one, return NULL. */
2282 find_run_target (void)
2284 struct target_ops
**t
;
2285 struct target_ops
*runable
= NULL
;
2290 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2292 if ((*t
)->to_can_run
&& target_can_run (*t
))
2299 return (count
== 1 ? runable
: NULL
);
2302 /* Find a single core_stratum target in the list of targets and return it.
2303 If for some reason there is more than one, return NULL. */
2306 find_core_target (void)
2308 struct target_ops
**t
;
2309 struct target_ops
*runable
= NULL
;
2314 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2317 if ((*t
)->to_stratum
== core_stratum
)
2324 return (count
== 1 ? runable
: NULL
);
2328 * Find the next target down the stack from the specified target.
2332 find_target_beneath (struct target_ops
*t
)
2338 /* The inferior process has died. Long live the inferior! */
2341 generic_mourn_inferior (void)
2343 extern int show_breakpoint_hit_counts
;
2345 inferior_ptid
= null_ptid
;
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_pid_to_str
= normal_pid_to_str
;
2431 dummy_target
.to_stratum
= dummy_stratum
;
2432 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2433 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2434 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2435 dummy_target
.to_magic
= OPS_MAGIC
;
2439 debug_to_open (char *args
, int from_tty
)
2441 debug_target
.to_open (args
, from_tty
);
2443 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2447 debug_to_close (int quitting
)
2449 target_close (&debug_target
, quitting
);
2450 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2454 target_close (struct target_ops
*targ
, int quitting
)
2456 if (targ
->to_xclose
!= NULL
)
2457 targ
->to_xclose (targ
, quitting
);
2458 else if (targ
->to_close
!= NULL
)
2459 targ
->to_close (quitting
);
2463 debug_to_attach (char *args
, int from_tty
)
2465 debug_target
.to_attach (args
, from_tty
);
2467 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2472 debug_to_post_attach (int pid
)
2474 debug_target
.to_post_attach (pid
);
2476 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2480 debug_to_detach (char *args
, int from_tty
)
2482 debug_target
.to_detach (args
, from_tty
);
2484 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2488 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2490 debug_target
.to_resume (ptid
, step
, siggnal
);
2492 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2493 step
? "step" : "continue",
2494 target_signal_to_name (siggnal
));
2498 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2502 retval
= debug_target
.to_wait (ptid
, status
);
2504 fprintf_unfiltered (gdb_stdlog
,
2505 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2507 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2508 switch (status
->kind
)
2510 case TARGET_WAITKIND_EXITED
:
2511 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2512 status
->value
.integer
);
2514 case TARGET_WAITKIND_STOPPED
:
2515 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2516 target_signal_to_name (status
->value
.sig
));
2518 case TARGET_WAITKIND_SIGNALLED
:
2519 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2520 target_signal_to_name (status
->value
.sig
));
2522 case TARGET_WAITKIND_LOADED
:
2523 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2525 case TARGET_WAITKIND_FORKED
:
2526 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2528 case TARGET_WAITKIND_VFORKED
:
2529 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2531 case TARGET_WAITKIND_EXECD
:
2532 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2534 case TARGET_WAITKIND_SPURIOUS
:
2535 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2538 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2546 debug_print_register (const char * func
,
2547 struct regcache
*regcache
, int regno
)
2549 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2550 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2551 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2552 + gdbarch_num_pseudo_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
);
2561 int i
, size
= register_size (gdbarch
, regno
);
2562 unsigned char buf
[MAX_REGISTER_SIZE
];
2563 regcache_cooked_read (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
, " 0x%s %s",
2573 paddr_nz (val
), paddr_d (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
);
3164 initialize_targets (void)
3166 init_dummy_target ();
3167 push_target (&dummy_target
);
3169 add_info ("target", target_info
, targ_desc
);
3170 add_info ("files", target_info
, targ_desc
);
3172 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3173 Set target debugging."), _("\
3174 Show target debugging."), _("\
3175 When non-zero, target debugging is enabled. Higher numbers are more\n\
3176 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3180 &setdebuglist
, &showdebuglist
);
3182 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3183 &trust_readonly
, _("\
3184 Set mode for reading from readonly sections."), _("\
3185 Show mode for reading from readonly sections."), _("\
3186 When this mode is on, memory reads from readonly sections (such as .text)\n\
3187 will be read from the object file instead of from the target. This will\n\
3188 result in significant performance improvement for remote targets."),
3190 show_trust_readonly
,
3191 &setlist
, &showlist
);
3193 add_com ("monitor", class_obscure
, do_monitor_command
,
3194 _("Send a command to the remote monitor (remote targets only)."));
3196 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3197 _("Print the name of each layer of the internal target stack."),
3198 &maintenanceprintlist
);
3200 target_dcache
= dcache_init ();