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
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"
43 static void target_info (char *, int);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
53 static int nosymbol (char *, CORE_ADDR
*);
55 static void tcomplain (void) ATTR_NORETURN
;
57 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
74 enum target_object object
,
75 const char *annex
, gdb_byte
*readbuf
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, LONGEST len
);
79 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
80 enum target_object object
,
81 const char *annex
, gdb_byte
*readbuf
,
82 const gdb_byte
*writebuf
,
83 ULONGEST offset
, LONGEST len
);
85 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
86 enum target_object object
,
88 void *readbuf
, const void *writebuf
,
89 ULONGEST offset
, LONGEST len
);
91 static void init_dummy_target (void);
93 static struct target_ops debug_target
;
95 static void debug_to_open (char *, int);
97 static void debug_to_close (int);
99 static void debug_to_attach (char *, int);
101 static void debug_to_detach (char *, int);
103 static void debug_to_resume (ptid_t
, int, enum target_signal
);
105 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
107 static void debug_to_fetch_registers (struct regcache
*, int);
109 static void debug_to_store_registers (struct regcache
*, int);
111 static void debug_to_prepare_to_store (struct regcache
*);
113 static void debug_to_files_info (struct target_ops
*);
115 static int debug_to_insert_breakpoint (struct bp_target_info
*);
117 static int debug_to_remove_breakpoint (struct bp_target_info
*);
119 static int debug_to_can_use_hw_breakpoint (int, int, int);
121 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
123 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
125 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_stopped_by_watchpoint (void);
131 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
133 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_terminal_info (char *, int);
147 static void debug_to_kill (void);
149 static void debug_to_load (char *, int);
151 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t
);
159 static int debug_to_thread_alive (ptid_t
);
161 static void debug_to_stop (void);
163 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
164 wierd and mysterious ways. Putting the variable here lets those
165 wierd and mysterious ways keep building while they are being
166 converted to the inferior inheritance structure. */
167 struct target_ops deprecated_child_ops
;
169 /* Pointer to array of target architecture structures; the size of the
170 array; the current index into the array; the allocated size of the
172 struct target_ops
**target_structs
;
173 unsigned target_struct_size
;
174 unsigned target_struct_index
;
175 unsigned target_struct_allocsize
;
176 #define DEFAULT_ALLOCSIZE 10
178 /* The initial current target, so that there is always a semi-valid
181 static struct target_ops dummy_target
;
183 /* Top of target stack. */
185 static struct target_ops
*target_stack
;
187 /* The target structure we are currently using to talk to a process
188 or file or whatever "inferior" we have. */
190 struct target_ops current_target
;
192 /* Command list for target. */
194 static struct cmd_list_element
*targetlist
= NULL
;
196 /* Nonzero if we are debugging an attached outside process
197 rather than an inferior. */
201 /* Nonzero if we should trust readonly sections from the
202 executable when reading memory. */
204 static int trust_readonly
= 0;
206 /* Non-zero if we want to see trace of target level stuff. */
208 static int targetdebug
= 0;
210 show_targetdebug (struct ui_file
*file
, int from_tty
,
211 struct cmd_list_element
*c
, const char *value
)
213 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
216 static void setup_target_debug (void);
218 DCACHE
*target_dcache
;
220 /* The user just typed 'target' without the name of a target. */
223 target_command (char *arg
, int from_tty
)
225 fputs_filtered ("Argument required (target name). Try `help target'\n",
229 /* Add a possible target architecture to the list. */
232 add_target (struct target_ops
*t
)
234 /* Provide default values for all "must have" methods. */
235 if (t
->to_xfer_partial
== NULL
)
236 t
->to_xfer_partial
= default_xfer_partial
;
240 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
241 target_structs
= (struct target_ops
**) xmalloc
242 (target_struct_allocsize
* sizeof (*target_structs
));
244 if (target_struct_size
>= target_struct_allocsize
)
246 target_struct_allocsize
*= 2;
247 target_structs
= (struct target_ops
**)
248 xrealloc ((char *) target_structs
,
249 target_struct_allocsize
* sizeof (*target_structs
));
251 target_structs
[target_struct_size
++] = t
;
253 if (targetlist
== NULL
)
254 add_prefix_cmd ("target", class_run
, target_command
, _("\
255 Connect to a target machine or process.\n\
256 The first argument is the type or protocol of the target machine.\n\
257 Remaining arguments are interpreted by the target protocol. For more\n\
258 information on the arguments for a particular protocol, type\n\
259 `help target ' followed by the protocol name."),
260 &targetlist
, "target ", 0, &cmdlist
);
261 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
272 target_load (char *arg
, int from_tty
)
274 dcache_invalidate (target_dcache
);
275 (*current_target
.to_load
) (arg
, from_tty
);
279 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
280 struct target_ops
*t
)
282 errno
= EIO
; /* Can't read/write this location */
283 return 0; /* No bytes handled */
289 error (_("You can't do that when your target is `%s'"),
290 current_target
.to_shortname
);
296 error (_("You can't do that without a process to debug."));
300 nosymbol (char *name
, CORE_ADDR
*addrp
)
302 return 1; /* Symbol does not exist in target env */
306 nosupport_runtime (void)
308 if (ptid_equal (inferior_ptid
, null_ptid
))
311 error (_("No run-time support for this"));
316 default_terminal_info (char *args
, int from_tty
)
318 printf_unfiltered (_("No saved terminal information.\n"));
321 /* This is the default target_create_inferior and target_attach function.
322 If the current target is executing, it asks whether to kill it off.
323 If this function returns without calling error(), it has killed off
324 the target, and the operation should be attempted. */
327 kill_or_be_killed (int from_tty
)
329 if (target_has_execution
)
331 printf_unfiltered (_("You are already running a program:\n"));
332 target_files_info ();
333 if (query ("Kill it? "))
336 if (target_has_execution
)
337 error (_("Killing the program did not help."));
342 error (_("Program not killed."));
349 maybe_kill_then_attach (char *args
, int from_tty
)
351 kill_or_be_killed (from_tty
);
352 target_attach (args
, from_tty
);
356 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
359 kill_or_be_killed (0);
360 target_create_inferior (exec
, args
, env
, from_tty
);
363 /* Go through the target stack from top to bottom, copying over zero
364 entries in current_target, then filling in still empty entries. In
365 effect, we are doing class inheritance through the pushed target
368 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
369 is currently implemented, is that it discards any knowledge of
370 which target an inherited method originally belonged to.
371 Consequently, new new target methods should instead explicitly and
372 locally search the target stack for the target that can handle the
376 update_current_target (void)
378 struct target_ops
*t
;
380 /* First, reset current's contents. */
381 memset (¤t_target
, 0, sizeof (current_target
));
383 #define INHERIT(FIELD, TARGET) \
384 if (!current_target.FIELD) \
385 current_target.FIELD = (TARGET)->FIELD
387 for (t
= target_stack
; t
; t
= t
->beneath
)
389 INHERIT (to_shortname
, t
);
390 INHERIT (to_longname
, t
);
392 INHERIT (to_open
, t
);
393 INHERIT (to_close
, t
);
394 INHERIT (to_attach
, t
);
395 INHERIT (to_post_attach
, t
);
396 INHERIT (to_detach
, t
);
397 /* Do not inherit to_disconnect. */
398 INHERIT (to_resume
, t
);
399 INHERIT (to_wait
, t
);
400 INHERIT (to_fetch_registers
, t
);
401 INHERIT (to_store_registers
, t
);
402 INHERIT (to_prepare_to_store
, t
);
403 INHERIT (deprecated_xfer_memory
, t
);
404 INHERIT (to_files_info
, t
);
405 INHERIT (to_insert_breakpoint
, t
);
406 INHERIT (to_remove_breakpoint
, t
);
407 INHERIT (to_can_use_hw_breakpoint
, t
);
408 INHERIT (to_insert_hw_breakpoint
, t
);
409 INHERIT (to_remove_hw_breakpoint
, t
);
410 INHERIT (to_insert_watchpoint
, t
);
411 INHERIT (to_remove_watchpoint
, t
);
412 INHERIT (to_stopped_data_address
, t
);
413 INHERIT (to_stopped_by_watchpoint
, t
);
414 INHERIT (to_have_steppable_watchpoint
, t
);
415 INHERIT (to_have_continuable_watchpoint
, t
);
416 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
417 INHERIT (to_terminal_init
, t
);
418 INHERIT (to_terminal_inferior
, t
);
419 INHERIT (to_terminal_ours_for_output
, t
);
420 INHERIT (to_terminal_ours
, t
);
421 INHERIT (to_terminal_save_ours
, t
);
422 INHERIT (to_terminal_info
, t
);
423 INHERIT (to_kill
, t
);
424 INHERIT (to_load
, t
);
425 INHERIT (to_lookup_symbol
, t
);
426 INHERIT (to_create_inferior
, t
);
427 INHERIT (to_post_startup_inferior
, t
);
428 INHERIT (to_acknowledge_created_inferior
, t
);
429 INHERIT (to_insert_fork_catchpoint
, t
);
430 INHERIT (to_remove_fork_catchpoint
, t
);
431 INHERIT (to_insert_vfork_catchpoint
, t
);
432 INHERIT (to_remove_vfork_catchpoint
, t
);
433 /* Do not inherit to_follow_fork. */
434 INHERIT (to_insert_exec_catchpoint
, t
);
435 INHERIT (to_remove_exec_catchpoint
, t
);
436 INHERIT (to_reported_exec_events_per_exec_call
, t
);
437 INHERIT (to_has_exited
, t
);
438 INHERIT (to_mourn_inferior
, t
);
439 INHERIT (to_can_run
, t
);
440 INHERIT (to_notice_signals
, t
);
441 INHERIT (to_thread_alive
, t
);
442 INHERIT (to_find_new_threads
, t
);
443 INHERIT (to_pid_to_str
, t
);
444 INHERIT (to_extra_thread_info
, t
);
445 INHERIT (to_stop
, t
);
446 /* Do not inherit to_xfer_partial. */
447 INHERIT (to_rcmd
, t
);
448 INHERIT (to_enable_exception_callback
, t
);
449 INHERIT (to_get_current_exception_event
, t
);
450 INHERIT (to_pid_to_exec_file
, t
);
451 INHERIT (to_log_command
, t
);
452 INHERIT (to_stratum
, t
);
453 INHERIT (to_has_all_memory
, t
);
454 INHERIT (to_has_memory
, t
);
455 INHERIT (to_has_stack
, t
);
456 INHERIT (to_has_registers
, t
);
457 INHERIT (to_has_execution
, t
);
458 INHERIT (to_has_thread_control
, t
);
459 INHERIT (to_sections
, t
);
460 INHERIT (to_sections_end
, t
);
461 INHERIT (to_can_async_p
, t
);
462 INHERIT (to_is_async_p
, t
);
463 INHERIT (to_async
, t
);
464 INHERIT (to_async_mask_value
, t
);
465 INHERIT (to_find_memory_regions
, t
);
466 INHERIT (to_make_corefile_notes
, t
);
467 INHERIT (to_get_thread_local_address
, t
);
468 /* Do not inherit to_read_description. */
469 INHERIT (to_magic
, t
);
470 /* Do not inherit to_memory_map. */
471 /* Do not inherit to_flash_erase. */
472 /* Do not inherit to_flash_done. */
476 /* Clean up a target struct so it no longer has any zero pointers in
477 it. Some entries are defaulted to a method that print an error,
478 others are hard-wired to a standard recursive default. */
480 #define de_fault(field, value) \
481 if (!current_target.field) \
482 current_target.field = value
485 (void (*) (char *, int))
491 maybe_kill_then_attach
);
492 de_fault (to_post_attach
,
496 (void (*) (char *, int))
499 (void (*) (ptid_t
, int, enum target_signal
))
502 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
504 de_fault (to_fetch_registers
,
505 (void (*) (struct regcache
*, int))
507 de_fault (to_store_registers
,
508 (void (*) (struct regcache
*, int))
510 de_fault (to_prepare_to_store
,
511 (void (*) (struct regcache
*))
513 de_fault (deprecated_xfer_memory
,
514 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
516 de_fault (to_files_info
,
517 (void (*) (struct target_ops
*))
519 de_fault (to_insert_breakpoint
,
520 memory_insert_breakpoint
);
521 de_fault (to_remove_breakpoint
,
522 memory_remove_breakpoint
);
523 de_fault (to_can_use_hw_breakpoint
,
524 (int (*) (int, int, int))
526 de_fault (to_insert_hw_breakpoint
,
527 (int (*) (struct bp_target_info
*))
529 de_fault (to_remove_hw_breakpoint
,
530 (int (*) (struct bp_target_info
*))
532 de_fault (to_insert_watchpoint
,
533 (int (*) (CORE_ADDR
, int, int))
535 de_fault (to_remove_watchpoint
,
536 (int (*) (CORE_ADDR
, int, int))
538 de_fault (to_stopped_by_watchpoint
,
541 de_fault (to_stopped_data_address
,
542 (int (*) (struct target_ops
*, CORE_ADDR
*))
544 de_fault (to_region_ok_for_hw_watchpoint
,
545 default_region_ok_for_hw_watchpoint
);
546 de_fault (to_terminal_init
,
549 de_fault (to_terminal_inferior
,
552 de_fault (to_terminal_ours_for_output
,
555 de_fault (to_terminal_ours
,
558 de_fault (to_terminal_save_ours
,
561 de_fault (to_terminal_info
,
562 default_terminal_info
);
567 (void (*) (char *, int))
569 de_fault (to_lookup_symbol
,
570 (int (*) (char *, CORE_ADDR
*))
572 de_fault (to_create_inferior
,
573 maybe_kill_then_create_inferior
);
574 de_fault (to_post_startup_inferior
,
577 de_fault (to_acknowledge_created_inferior
,
580 de_fault (to_insert_fork_catchpoint
,
583 de_fault (to_remove_fork_catchpoint
,
586 de_fault (to_insert_vfork_catchpoint
,
589 de_fault (to_remove_vfork_catchpoint
,
592 de_fault (to_insert_exec_catchpoint
,
595 de_fault (to_remove_exec_catchpoint
,
598 de_fault (to_reported_exec_events_per_exec_call
,
601 de_fault (to_has_exited
,
602 (int (*) (int, int, int *))
604 de_fault (to_mourn_inferior
,
607 de_fault (to_can_run
,
609 de_fault (to_notice_signals
,
612 de_fault (to_thread_alive
,
615 de_fault (to_find_new_threads
,
618 de_fault (to_extra_thread_info
,
619 (char *(*) (struct thread_info
*))
624 current_target
.to_xfer_partial
= current_xfer_partial
;
626 (void (*) (char *, struct ui_file
*))
628 de_fault (to_enable_exception_callback
,
629 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
631 de_fault (to_get_current_exception_event
,
632 (struct exception_event_record
* (*) (void))
634 de_fault (to_pid_to_exec_file
,
637 de_fault (to_can_async_p
,
640 de_fault (to_is_async_p
,
644 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
646 current_target
.to_read_description
= NULL
;
649 /* Finally, position the target-stack beneath the squashed
650 "current_target". That way code looking for a non-inherited
651 target method can quickly and simply find it. */
652 current_target
.beneath
= target_stack
;
655 setup_target_debug ();
658 /* Mark OPS as a running target. This reverses the effect
659 of target_mark_exited. */
662 target_mark_running (struct target_ops
*ops
)
664 struct target_ops
*t
;
666 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
670 internal_error (__FILE__
, __LINE__
,
671 "Attempted to mark unpushed target \"%s\" as running",
674 ops
->to_has_execution
= 1;
675 ops
->to_has_all_memory
= 1;
676 ops
->to_has_memory
= 1;
677 ops
->to_has_stack
= 1;
678 ops
->to_has_registers
= 1;
680 update_current_target ();
683 /* Mark OPS as a non-running target. This reverses the effect
684 of target_mark_running. */
687 target_mark_exited (struct target_ops
*ops
)
689 struct target_ops
*t
;
691 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
695 internal_error (__FILE__
, __LINE__
,
696 "Attempted to mark unpushed target \"%s\" as running",
699 ops
->to_has_execution
= 0;
700 ops
->to_has_all_memory
= 0;
701 ops
->to_has_memory
= 0;
702 ops
->to_has_stack
= 0;
703 ops
->to_has_registers
= 0;
705 update_current_target ();
708 /* Push a new target type into the stack of the existing target accessors,
709 possibly superseding some of the existing accessors.
711 Result is zero if the pushed target ended up on top of the stack,
712 nonzero if at least one target is on top of it.
714 Rather than allow an empty stack, we always have the dummy target at
715 the bottom stratum, so we can call the function vectors without
719 push_target (struct target_ops
*t
)
721 struct target_ops
**cur
;
723 /* Check magic number. If wrong, it probably means someone changed
724 the struct definition, but not all the places that initialize one. */
725 if (t
->to_magic
!= OPS_MAGIC
)
727 fprintf_unfiltered (gdb_stderr
,
728 "Magic number of %s target struct wrong\n",
730 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
733 /* Find the proper stratum to install this target in. */
734 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
736 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
740 /* If there's already targets at this stratum, remove them. */
741 /* FIXME: cagney/2003-10-15: I think this should be popping all
742 targets to CUR, and not just those at this stratum level. */
743 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
745 /* There's already something at this stratum level. Close it,
746 and un-hook it from the stack. */
747 struct target_ops
*tmp
= (*cur
);
748 (*cur
) = (*cur
)->beneath
;
750 target_close (tmp
, 0);
753 /* We have removed all targets in our stratum, now add the new one. */
757 update_current_target ();
760 return (t
!= target_stack
);
763 /* Remove a target_ops vector from the stack, wherever it may be.
764 Return how many times it was removed (0 or 1). */
767 unpush_target (struct target_ops
*t
)
769 struct target_ops
**cur
;
770 struct target_ops
*tmp
;
772 /* Look for the specified target. Note that we assume that a target
773 can only occur once in the target stack. */
775 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
782 return 0; /* Didn't find target_ops, quit now */
784 /* NOTE: cagney/2003-12-06: In '94 the close call was made
785 unconditional by moving it to before the above check that the
786 target was in the target stack (something about "Change the way
787 pushing and popping of targets work to support target overlays
788 and inheritance"). This doesn't make much sense - only open
789 targets should be closed. */
792 /* Unchain the target */
794 (*cur
) = (*cur
)->beneath
;
797 update_current_target ();
805 target_close (¤t_target
, 0); /* Let it clean up */
806 if (unpush_target (target_stack
) == 1)
809 fprintf_unfiltered (gdb_stderr
,
810 "pop_target couldn't find target %s\n",
811 current_target
.to_shortname
);
812 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
815 /* Using the objfile specified in BATON, find the address for the
816 current thread's thread-local storage with offset OFFSET. */
818 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
820 volatile CORE_ADDR addr
= 0;
822 if (target_get_thread_local_address_p ()
823 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
825 ptid_t ptid
= inferior_ptid
;
826 volatile struct gdb_exception ex
;
828 TRY_CATCH (ex
, RETURN_MASK_ALL
)
832 /* Fetch the load module address for this objfile. */
833 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
835 /* If it's 0, throw the appropriate exception. */
837 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
838 _("TLS load module not found"));
840 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
842 /* If an error occurred, print TLS related messages here. Otherwise,
843 throw the error to some higher catcher. */
846 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
850 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
851 error (_("Cannot find thread-local variables in this thread library."));
853 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
854 if (objfile_is_library
)
855 error (_("Cannot find shared library `%s' in dynamic"
856 " linker's load module list"), objfile
->name
);
858 error (_("Cannot find executable file `%s' in dynamic"
859 " linker's load module list"), objfile
->name
);
861 case TLS_NOT_ALLOCATED_YET_ERROR
:
862 if (objfile_is_library
)
863 error (_("The inferior has not yet allocated storage for"
864 " thread-local variables in\n"
865 "the shared library `%s'\n"
867 objfile
->name
, target_pid_to_str (ptid
));
869 error (_("The inferior has not yet allocated storage for"
870 " thread-local variables in\n"
871 "the executable `%s'\n"
873 objfile
->name
, target_pid_to_str (ptid
));
875 case TLS_GENERIC_ERROR
:
876 if (objfile_is_library
)
877 error (_("Cannot find thread-local storage for %s, "
878 "shared library %s:\n%s"),
879 target_pid_to_str (ptid
),
880 objfile
->name
, ex
.message
);
882 error (_("Cannot find thread-local storage for %s, "
883 "executable file %s:\n%s"),
884 target_pid_to_str (ptid
),
885 objfile
->name
, ex
.message
);
888 throw_exception (ex
);
893 /* It wouldn't be wrong here to try a gdbarch method, too; finding
894 TLS is an ABI-specific thing. But we don't do that yet. */
896 error (_("Cannot find thread-local variables on this target"));
902 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
904 /* target_read_string -- read a null terminated string, up to LEN bytes,
905 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
906 Set *STRING to a pointer to malloc'd memory containing the data; the caller
907 is responsible for freeing it. Return the number of bytes successfully
911 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
913 int tlen
, origlen
, offset
, i
;
917 int buffer_allocated
;
919 unsigned int nbytes_read
= 0;
923 /* Small for testing. */
924 buffer_allocated
= 4;
925 buffer
= xmalloc (buffer_allocated
);
932 tlen
= MIN (len
, 4 - (memaddr
& 3));
933 offset
= memaddr
& 3;
935 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
938 /* The transfer request might have crossed the boundary to an
939 unallocated region of memory. Retry the transfer, requesting
943 errcode
= target_read_memory (memaddr
, buf
, 1);
948 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
951 bytes
= bufptr
- buffer
;
952 buffer_allocated
*= 2;
953 buffer
= xrealloc (buffer
, buffer_allocated
);
954 bufptr
= buffer
+ bytes
;
957 for (i
= 0; i
< tlen
; i
++)
959 *bufptr
++ = buf
[i
+ offset
];
960 if (buf
[i
+ offset
] == '\000')
962 nbytes_read
+= i
+ 1;
978 /* Find a section containing ADDR. */
979 struct section_table
*
980 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
982 struct section_table
*secp
;
983 for (secp
= target
->to_sections
;
984 secp
< target
->to_sections_end
;
987 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
993 /* Perform a partial memory transfer. The arguments and return
994 value are just as for target_xfer_partial. */
997 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
998 ULONGEST memaddr
, LONGEST len
)
1002 struct mem_region
*region
;
1004 /* Zero length requests are ok and require no work. */
1008 /* Try the executable file, if "trust-readonly-sections" is set. */
1009 if (readbuf
!= NULL
&& trust_readonly
)
1011 struct section_table
*secp
;
1013 secp
= target_section_by_addr (ops
, memaddr
);
1015 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1017 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1020 /* Likewise for accesses to unmapped overlay sections. */
1021 if (readbuf
!= NULL
&& overlay_debugging
)
1023 asection
*section
= find_pc_overlay (memaddr
);
1024 if (pc_in_unmapped_range (memaddr
, section
))
1025 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1028 /* Try GDB's internal data cache. */
1029 region
= lookup_mem_region (memaddr
);
1030 /* region->hi == 0 means there's no upper bound. */
1031 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1034 reg_len
= region
->hi
- memaddr
;
1036 switch (region
->attrib
.mode
)
1039 if (writebuf
!= NULL
)
1044 if (readbuf
!= NULL
)
1049 /* We only support writing to flash during "load" for now. */
1050 if (writebuf
!= NULL
)
1051 error (_("Writing to flash memory forbidden in this context"));
1058 if (region
->attrib
.cache
)
1060 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1061 memory request will start back at current_target. */
1062 if (readbuf
!= NULL
)
1063 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1066 /* FIXME drow/2006-08-09: If we're going to preserve const
1067 correctness dcache_xfer_memory should take readbuf and
1069 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1078 /* If none of those methods found the memory we wanted, fall back
1079 to a target partial transfer. Normally a single call to
1080 to_xfer_partial is enough; if it doesn't recognize an object
1081 it will call the to_xfer_partial of the next target down.
1082 But for memory this won't do. Memory is the only target
1083 object which can be read from more than one valid target.
1084 A core file, for instance, could have some of memory but
1085 delegate other bits to the target below it. So, we must
1086 manually try all targets. */
1090 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1091 readbuf
, writebuf
, memaddr
, reg_len
);
1095 /* We want to continue past core files to executables, but not
1096 past a running target's memory. */
1097 if (ops
->to_has_all_memory
)
1102 while (ops
!= NULL
);
1104 /* If we still haven't got anything, return the last error. We
1110 target_xfer_partial (struct target_ops
*ops
,
1111 enum target_object object
, const char *annex
,
1112 void *readbuf
, const void *writebuf
,
1113 ULONGEST offset
, LONGEST len
)
1117 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1119 /* If this is a memory transfer, let the memory-specific code
1120 have a look at it instead. Memory transfers are more
1122 if (object
== TARGET_OBJECT_MEMORY
)
1123 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1126 enum target_object raw_object
= object
;
1128 /* If this is a raw memory transfer, request the normal
1129 memory object from other layers. */
1130 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1131 raw_object
= TARGET_OBJECT_MEMORY
;
1133 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1134 writebuf
, offset
, len
);
1139 const unsigned char *myaddr
= NULL
;
1141 fprintf_unfiltered (gdb_stdlog
,
1142 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1145 (annex
? annex
: "(null)"),
1146 (long) readbuf
, (long) writebuf
,
1147 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1153 if (retval
> 0 && myaddr
!= NULL
)
1157 fputs_unfiltered (", bytes =", gdb_stdlog
);
1158 for (i
= 0; i
< retval
; i
++)
1160 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1162 if (targetdebug
< 2 && i
> 0)
1164 fprintf_unfiltered (gdb_stdlog
, " ...");
1167 fprintf_unfiltered (gdb_stdlog
, "\n");
1170 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1174 fputc_unfiltered ('\n', gdb_stdlog
);
1179 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1180 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1181 if any error occurs.
1183 If an error occurs, no guarantee is made about the contents of the data at
1184 MYADDR. In particular, the caller should not depend upon partial reads
1185 filling the buffer with good data. There is no way for the caller to know
1186 how much good data might have been transfered anyway. Callers that can
1187 deal with partial reads should call target_read (which will retry until
1188 it makes no progress, and then return how much was transferred). */
1191 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1193 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1194 myaddr
, memaddr
, len
) == len
)
1201 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1203 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1204 myaddr
, memaddr
, len
) == len
)
1210 /* Fetch the target's memory map. */
1213 target_memory_map (void)
1215 VEC(mem_region_s
) *result
;
1216 struct mem_region
*last_one
, *this_one
;
1218 struct target_ops
*t
;
1221 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1223 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1224 if (t
->to_memory_map
!= NULL
)
1230 result
= t
->to_memory_map (t
);
1234 qsort (VEC_address (mem_region_s
, result
),
1235 VEC_length (mem_region_s
, result
),
1236 sizeof (struct mem_region
), mem_region_cmp
);
1238 /* Check that regions do not overlap. Simultaneously assign
1239 a numbering for the "mem" commands to use to refer to
1242 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1244 this_one
->number
= ix
;
1246 if (last_one
&& last_one
->hi
> this_one
->lo
)
1248 warning (_("Overlapping regions in memory map: ignoring"));
1249 VEC_free (mem_region_s
, result
);
1252 last_one
= this_one
;
1259 target_flash_erase (ULONGEST address
, LONGEST length
)
1261 struct target_ops
*t
;
1263 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1264 if (t
->to_flash_erase
!= NULL
)
1267 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1268 paddr (address
), phex (length
, 0));
1269 t
->to_flash_erase (t
, address
, length
);
1277 target_flash_done (void)
1279 struct target_ops
*t
;
1281 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1282 if (t
->to_flash_done
!= NULL
)
1285 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1286 t
->to_flash_done (t
);
1293 #ifndef target_stopped_data_address_p
1295 target_stopped_data_address_p (struct target_ops
*target
)
1297 if (target
->to_stopped_data_address
1298 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1300 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1301 && (debug_target
.to_stopped_data_address
1302 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1309 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1310 struct cmd_list_element
*c
, const char *value
)
1312 fprintf_filtered (file
, _("\
1313 Mode for reading from readonly sections is %s.\n"),
1317 /* More generic transfers. */
1320 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1321 const char *annex
, gdb_byte
*readbuf
,
1322 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1324 if (object
== TARGET_OBJECT_MEMORY
1325 && ops
->deprecated_xfer_memory
!= NULL
)
1326 /* If available, fall back to the target's
1327 "deprecated_xfer_memory" method. */
1331 if (writebuf
!= NULL
)
1333 void *buffer
= xmalloc (len
);
1334 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1335 memcpy (buffer
, writebuf
, len
);
1336 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1337 1/*write*/, NULL
, ops
);
1338 do_cleanups (cleanup
);
1340 if (readbuf
!= NULL
)
1341 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1345 else if (xfered
== 0 && errno
== 0)
1346 /* "deprecated_xfer_memory" uses 0, cross checked against
1347 ERRNO as one indication of an error. */
1352 else if (ops
->beneath
!= NULL
)
1353 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1354 readbuf
, writebuf
, offset
, len
);
1359 /* The xfer_partial handler for the topmost target. Unlike the default,
1360 it does not need to handle memory specially; it just passes all
1361 requests down the stack. */
1364 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1365 const char *annex
, gdb_byte
*readbuf
,
1366 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1368 if (ops
->beneath
!= NULL
)
1369 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1370 readbuf
, writebuf
, offset
, len
);
1375 /* Target vector read/write partial wrapper functions.
1377 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1378 (inbuf, outbuf)", instead of separate read/write methods, make life
1382 target_read_partial (struct target_ops
*ops
,
1383 enum target_object object
,
1384 const char *annex
, gdb_byte
*buf
,
1385 ULONGEST offset
, LONGEST len
)
1387 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1391 target_write_partial (struct target_ops
*ops
,
1392 enum target_object object
,
1393 const char *annex
, const gdb_byte
*buf
,
1394 ULONGEST offset
, LONGEST len
)
1396 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1399 /* Wrappers to perform the full transfer. */
1401 target_read (struct target_ops
*ops
,
1402 enum target_object object
,
1403 const char *annex
, gdb_byte
*buf
,
1404 ULONGEST offset
, LONGEST len
)
1407 while (xfered
< len
)
1409 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1410 (gdb_byte
*) buf
+ xfered
,
1411 offset
+ xfered
, len
- xfered
);
1412 /* Call an observer, notifying them of the xfer progress? */
1423 /* An alternative to target_write with progress callbacks. */
1426 target_write_with_progress (struct target_ops
*ops
,
1427 enum target_object object
,
1428 const char *annex
, const gdb_byte
*buf
,
1429 ULONGEST offset
, LONGEST len
,
1430 void (*progress
) (ULONGEST
, void *), void *baton
)
1434 /* Give the progress callback a chance to set up. */
1436 (*progress
) (0, baton
);
1438 while (xfered
< len
)
1440 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1441 (gdb_byte
*) buf
+ xfered
,
1442 offset
+ xfered
, len
- xfered
);
1450 (*progress
) (xfer
, baton
);
1459 target_write (struct target_ops
*ops
,
1460 enum target_object object
,
1461 const char *annex
, const gdb_byte
*buf
,
1462 ULONGEST offset
, LONGEST len
)
1464 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1468 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1469 the size of the transferred data. PADDING additional bytes are
1470 available in *BUF_P. This is a helper function for
1471 target_read_alloc; see the declaration of that function for more
1475 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1476 const char *annex
, gdb_byte
**buf_p
, int padding
)
1478 size_t buf_alloc
, buf_pos
;
1482 /* This function does not have a length parameter; it reads the
1483 entire OBJECT). Also, it doesn't support objects fetched partly
1484 from one target and partly from another (in a different stratum,
1485 e.g. a core file and an executable). Both reasons make it
1486 unsuitable for reading memory. */
1487 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1489 /* Start by reading up to 4K at a time. The target will throttle
1490 this number down if necessary. */
1492 buf
= xmalloc (buf_alloc
);
1496 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1497 buf_pos
, buf_alloc
- buf_pos
- padding
);
1500 /* An error occurred. */
1506 /* Read all there was. */
1516 /* If the buffer is filling up, expand it. */
1517 if (buf_alloc
< buf_pos
* 2)
1520 buf
= xrealloc (buf
, buf_alloc
);
1527 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1528 the size of the transferred data. See the declaration in "target.h"
1529 function for more information about the return value. */
1532 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1533 const char *annex
, gdb_byte
**buf_p
)
1535 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1538 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1539 returned as a string, allocated using xmalloc. If an error occurs
1540 or the transfer is unsupported, NULL is returned. Empty objects
1541 are returned as allocated but empty strings. A warning is issued
1542 if the result contains any embedded NUL bytes. */
1545 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1549 LONGEST transferred
;
1551 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1553 if (transferred
< 0)
1556 if (transferred
== 0)
1557 return xstrdup ("");
1559 buffer
[transferred
] = 0;
1560 if (strlen (buffer
) < transferred
)
1561 warning (_("target object %d, annex %s, "
1562 "contained unexpected null characters"),
1563 (int) object
, annex
? annex
: "(none)");
1565 return (char *) buffer
;
1568 /* Memory transfer methods. */
1571 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1574 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1576 memory_error (EIO
, addr
);
1580 get_target_memory_unsigned (struct target_ops
*ops
,
1581 CORE_ADDR addr
, int len
)
1583 gdb_byte buf
[sizeof (ULONGEST
)];
1585 gdb_assert (len
<= sizeof (buf
));
1586 get_target_memory (ops
, addr
, buf
, len
);
1587 return extract_unsigned_integer (buf
, len
);
1591 target_info (char *args
, int from_tty
)
1593 struct target_ops
*t
;
1594 int has_all_mem
= 0;
1596 if (symfile_objfile
!= NULL
)
1597 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1599 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1601 if (!t
->to_has_memory
)
1604 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1607 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1608 printf_unfiltered ("%s:\n", t
->to_longname
);
1609 (t
->to_files_info
) (t
);
1610 has_all_mem
= t
->to_has_all_memory
;
1614 /* This function is called before any new inferior is created, e.g.
1615 by running a program, attaching, or connecting to a target.
1616 It cleans up any state from previous invocations which might
1617 change between runs. This is a subset of what target_preopen
1618 resets (things which might change between targets). */
1621 target_pre_inferior (int from_tty
)
1623 invalidate_target_mem_regions ();
1625 target_clear_description ();
1628 /* This is to be called by the open routine before it does
1632 target_preopen (int from_tty
)
1636 if (target_has_execution
)
1639 || query (_("A program is being debugged already. Kill it? ")))
1642 error (_("Program not killed."));
1645 /* Calling target_kill may remove the target from the stack. But if
1646 it doesn't (which seems like a win for UDI), remove it now. */
1648 if (target_has_execution
)
1651 target_pre_inferior (from_tty
);
1654 /* Detach a target after doing deferred register stores. */
1657 target_detach (char *args
, int from_tty
)
1659 (current_target
.to_detach
) (args
, from_tty
);
1663 target_disconnect (char *args
, int from_tty
)
1665 struct target_ops
*t
;
1667 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1668 if (t
->to_disconnect
!= NULL
)
1671 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1673 t
->to_disconnect (t
, args
, from_tty
);
1681 target_async_mask (int mask
)
1683 int saved_async_masked_status
= target_async_mask_value
;
1684 target_async_mask_value
= mask
;
1685 return saved_async_masked_status
;
1688 /* Look through the list of possible targets for a target that can
1692 target_follow_fork (int follow_child
)
1694 struct target_ops
*t
;
1696 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1698 if (t
->to_follow_fork
!= NULL
)
1700 int retval
= t
->to_follow_fork (t
, follow_child
);
1702 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1703 follow_child
, retval
);
1708 /* Some target returned a fork event, but did not know how to follow it. */
1709 internal_error (__FILE__
, __LINE__
,
1710 "could not find a target to follow fork");
1713 /* Look for a target which can describe architectural features, starting
1714 from TARGET. If we find one, return its description. */
1716 const struct target_desc
*
1717 target_read_description (struct target_ops
*target
)
1719 struct target_ops
*t
;
1721 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1722 if (t
->to_read_description
!= NULL
)
1724 const struct target_desc
*tdesc
;
1726 tdesc
= t
->to_read_description (t
);
1734 /* Look through the list of possible targets for a target that can
1735 execute a run or attach command without any other data. This is
1736 used to locate the default process stratum.
1738 Result is always valid (error() is called for errors). */
1740 static struct target_ops
*
1741 find_default_run_target (char *do_mesg
)
1743 struct target_ops
**t
;
1744 struct target_ops
*runable
= NULL
;
1749 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1752 if ((*t
)->to_can_run
&& target_can_run (*t
))
1760 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1766 find_default_attach (char *args
, int from_tty
)
1768 struct target_ops
*t
;
1770 t
= find_default_run_target ("attach");
1771 (t
->to_attach
) (args
, from_tty
);
1776 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1779 struct target_ops
*t
;
1781 t
= find_default_run_target ("run");
1782 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1787 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1789 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1805 return_minus_one (void)
1811 * Resize the to_sections pointer. Also make sure that anyone that
1812 * was holding on to an old value of it gets updated.
1813 * Returns the old size.
1817 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1819 struct target_ops
**t
;
1820 struct section_table
*old_value
;
1823 old_value
= target
->to_sections
;
1825 if (target
->to_sections
)
1827 old_count
= target
->to_sections_end
- target
->to_sections
;
1828 target
->to_sections
= (struct section_table
*)
1829 xrealloc ((char *) target
->to_sections
,
1830 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1835 target
->to_sections
= (struct section_table
*)
1836 xmalloc ((sizeof (struct section_table
)) * num_added
);
1838 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1840 /* Check to see if anyone else was pointing to this structure.
1841 If old_value was null, then no one was. */
1845 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1848 if ((*t
)->to_sections
== old_value
)
1850 (*t
)->to_sections
= target
->to_sections
;
1851 (*t
)->to_sections_end
= target
->to_sections_end
;
1854 /* There is a flattened view of the target stack in current_target,
1855 so its to_sections pointer might also need updating. */
1856 if (current_target
.to_sections
== old_value
)
1858 current_target
.to_sections
= target
->to_sections
;
1859 current_target
.to_sections_end
= target
->to_sections_end
;
1867 /* Remove all target sections taken from ABFD.
1869 Scan the current target stack for targets whose section tables
1870 refer to sections from BFD, and remove those sections. We use this
1871 when we notice that the inferior has unloaded a shared object, for
1874 remove_target_sections (bfd
*abfd
)
1876 struct target_ops
**t
;
1878 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1880 struct section_table
*src
, *dest
;
1882 dest
= (*t
)->to_sections
;
1883 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1884 if (src
->bfd
!= abfd
)
1886 /* Keep this section. */
1887 if (dest
< src
) *dest
= *src
;
1891 /* If we've dropped any sections, resize the section table. */
1893 target_resize_to_sections (*t
, dest
- src
);
1900 /* Find a single runnable target in the stack and return it. If for
1901 some reason there is more than one, return NULL. */
1904 find_run_target (void)
1906 struct target_ops
**t
;
1907 struct target_ops
*runable
= NULL
;
1912 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1914 if ((*t
)->to_can_run
&& target_can_run (*t
))
1921 return (count
== 1 ? runable
: NULL
);
1924 /* Find a single core_stratum target in the list of targets and return it.
1925 If for some reason there is more than one, return NULL. */
1928 find_core_target (void)
1930 struct target_ops
**t
;
1931 struct target_ops
*runable
= NULL
;
1936 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1939 if ((*t
)->to_stratum
== core_stratum
)
1946 return (count
== 1 ? runable
: NULL
);
1950 * Find the next target down the stack from the specified target.
1954 find_target_beneath (struct target_ops
*t
)
1960 /* The inferior process has died. Long live the inferior! */
1963 generic_mourn_inferior (void)
1965 extern int show_breakpoint_hit_counts
;
1967 inferior_ptid
= null_ptid
;
1969 breakpoint_init_inferior (inf_exited
);
1970 registers_changed ();
1972 reopen_exec_file ();
1973 reinit_frame_cache ();
1975 /* It is confusing to the user for ignore counts to stick around
1976 from previous runs of the inferior. So clear them. */
1977 /* However, it is more confusing for the ignore counts to disappear when
1978 using hit counts. So don't clear them if we're counting hits. */
1979 if (!show_breakpoint_hit_counts
)
1980 breakpoint_clear_ignore_counts ();
1982 if (deprecated_detach_hook
)
1983 deprecated_detach_hook ();
1986 /* Helper function for child_wait and the derivatives of child_wait.
1987 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1988 translation of that in OURSTATUS. */
1990 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1992 if (WIFEXITED (hoststatus
))
1994 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1995 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1997 else if (!WIFSTOPPED (hoststatus
))
1999 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2000 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2004 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2005 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2009 /* Returns zero to leave the inferior alone, one to interrupt it. */
2010 int (*target_activity_function
) (void);
2011 int target_activity_fd
;
2013 /* Convert a normal process ID to a string. Returns the string in a
2017 normal_pid_to_str (ptid_t ptid
)
2019 static char buf
[32];
2021 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2025 /* Error-catcher for target_find_memory_regions */
2026 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2028 error (_("No target."));
2032 /* Error-catcher for target_make_corefile_notes */
2033 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2035 error (_("No target."));
2039 /* Set up the handful of non-empty slots needed by the dummy target
2043 init_dummy_target (void)
2045 dummy_target
.to_shortname
= "None";
2046 dummy_target
.to_longname
= "None";
2047 dummy_target
.to_doc
= "";
2048 dummy_target
.to_attach
= find_default_attach
;
2049 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2050 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2051 dummy_target
.to_stratum
= dummy_stratum
;
2052 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2053 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2054 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2055 dummy_target
.to_magic
= OPS_MAGIC
;
2059 debug_to_open (char *args
, int from_tty
)
2061 debug_target
.to_open (args
, from_tty
);
2063 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2067 debug_to_close (int quitting
)
2069 target_close (&debug_target
, quitting
);
2070 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2074 target_close (struct target_ops
*targ
, int quitting
)
2076 if (targ
->to_xclose
!= NULL
)
2077 targ
->to_xclose (targ
, quitting
);
2078 else if (targ
->to_close
!= NULL
)
2079 targ
->to_close (quitting
);
2083 debug_to_attach (char *args
, int from_tty
)
2085 debug_target
.to_attach (args
, from_tty
);
2087 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2092 debug_to_post_attach (int pid
)
2094 debug_target
.to_post_attach (pid
);
2096 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2100 debug_to_detach (char *args
, int from_tty
)
2102 debug_target
.to_detach (args
, from_tty
);
2104 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2108 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2110 debug_target
.to_resume (ptid
, step
, siggnal
);
2112 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2113 step
? "step" : "continue",
2114 target_signal_to_name (siggnal
));
2118 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2122 retval
= debug_target
.to_wait (ptid
, status
);
2124 fprintf_unfiltered (gdb_stdlog
,
2125 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2127 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2128 switch (status
->kind
)
2130 case TARGET_WAITKIND_EXITED
:
2131 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2132 status
->value
.integer
);
2134 case TARGET_WAITKIND_STOPPED
:
2135 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2136 target_signal_to_name (status
->value
.sig
));
2138 case TARGET_WAITKIND_SIGNALLED
:
2139 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2140 target_signal_to_name (status
->value
.sig
));
2142 case TARGET_WAITKIND_LOADED
:
2143 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2145 case TARGET_WAITKIND_FORKED
:
2146 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2148 case TARGET_WAITKIND_VFORKED
:
2149 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2151 case TARGET_WAITKIND_EXECD
:
2152 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2154 case TARGET_WAITKIND_SPURIOUS
:
2155 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2158 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2166 debug_print_register (const char * func
,
2167 struct regcache
*regcache
, int regno
)
2169 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2170 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2171 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2172 + gdbarch_num_pseudo_regs (gdbarch
)
2173 && gdbarch_register_name (gdbarch
, regno
) != NULL
2174 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2175 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2176 gdbarch_register_name (gdbarch
, regno
));
2178 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2181 int i
, size
= register_size (gdbarch
, regno
);
2182 unsigned char buf
[MAX_REGISTER_SIZE
];
2183 regcache_cooked_read (regcache
, regno
, buf
);
2184 fprintf_unfiltered (gdb_stdlog
, " = ");
2185 for (i
= 0; i
< size
; i
++)
2187 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2189 if (size
<= sizeof (LONGEST
))
2191 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2192 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2193 paddr_nz (val
), paddr_d (val
));
2196 fprintf_unfiltered (gdb_stdlog
, "\n");
2200 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2202 debug_target
.to_fetch_registers (regcache
, regno
);
2203 debug_print_register ("target_fetch_registers", regcache
, regno
);
2207 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2209 debug_target
.to_store_registers (regcache
, regno
);
2210 debug_print_register ("target_store_registers", regcache
, regno
);
2211 fprintf_unfiltered (gdb_stdlog
, "\n");
2215 debug_to_prepare_to_store (struct regcache
*regcache
)
2217 debug_target
.to_prepare_to_store (regcache
);
2219 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2223 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2224 int write
, struct mem_attrib
*attrib
,
2225 struct target_ops
*target
)
2229 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2232 fprintf_unfiltered (gdb_stdlog
,
2233 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2234 (unsigned int) memaddr
, /* possable truncate long long */
2235 len
, write
? "write" : "read", retval
);
2241 fputs_unfiltered (", bytes =", gdb_stdlog
);
2242 for (i
= 0; i
< retval
; i
++)
2244 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2246 if (targetdebug
< 2 && i
> 0)
2248 fprintf_unfiltered (gdb_stdlog
, " ...");
2251 fprintf_unfiltered (gdb_stdlog
, "\n");
2254 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2258 fputc_unfiltered ('\n', gdb_stdlog
);
2264 debug_to_files_info (struct target_ops
*target
)
2266 debug_target
.to_files_info (target
);
2268 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2272 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2276 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2278 fprintf_unfiltered (gdb_stdlog
,
2279 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2280 (unsigned long) bp_tgt
->placed_address
,
2281 (unsigned long) retval
);
2286 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2290 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2292 fprintf_unfiltered (gdb_stdlog
,
2293 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2294 (unsigned long) bp_tgt
->placed_address
,
2295 (unsigned long) retval
);
2300 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2304 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2306 fprintf_unfiltered (gdb_stdlog
,
2307 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2308 (unsigned long) type
,
2309 (unsigned long) cnt
,
2310 (unsigned long) from_tty
,
2311 (unsigned long) retval
);
2316 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2320 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2322 fprintf_unfiltered (gdb_stdlog
,
2323 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2324 (unsigned long) addr
,
2325 (unsigned long) len
,
2326 (unsigned long) retval
);
2331 debug_to_stopped_by_watchpoint (void)
2335 retval
= debug_target
.to_stopped_by_watchpoint ();
2337 fprintf_unfiltered (gdb_stdlog
,
2338 "STOPPED_BY_WATCHPOINT () = %ld\n",
2339 (unsigned long) retval
);
2344 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2348 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2350 fprintf_unfiltered (gdb_stdlog
,
2351 "target_stopped_data_address ([0x%lx]) = %ld\n",
2352 (unsigned long)*addr
,
2353 (unsigned long)retval
);
2358 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2362 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2364 fprintf_unfiltered (gdb_stdlog
,
2365 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2366 (unsigned long) bp_tgt
->placed_address
,
2367 (unsigned long) retval
);
2372 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2376 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2378 fprintf_unfiltered (gdb_stdlog
,
2379 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2380 (unsigned long) bp_tgt
->placed_address
,
2381 (unsigned long) retval
);
2386 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2390 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2392 fprintf_unfiltered (gdb_stdlog
,
2393 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2394 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2399 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2403 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2405 fprintf_unfiltered (gdb_stdlog
,
2406 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2407 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2412 debug_to_terminal_init (void)
2414 debug_target
.to_terminal_init ();
2416 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2420 debug_to_terminal_inferior (void)
2422 debug_target
.to_terminal_inferior ();
2424 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2428 debug_to_terminal_ours_for_output (void)
2430 debug_target
.to_terminal_ours_for_output ();
2432 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2436 debug_to_terminal_ours (void)
2438 debug_target
.to_terminal_ours ();
2440 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2444 debug_to_terminal_save_ours (void)
2446 debug_target
.to_terminal_save_ours ();
2448 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2452 debug_to_terminal_info (char *arg
, int from_tty
)
2454 debug_target
.to_terminal_info (arg
, from_tty
);
2456 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2461 debug_to_kill (void)
2463 debug_target
.to_kill ();
2465 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2469 debug_to_load (char *args
, int from_tty
)
2471 debug_target
.to_load (args
, from_tty
);
2473 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2477 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2481 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2483 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2489 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2492 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2494 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2495 exec_file
, args
, from_tty
);
2499 debug_to_post_startup_inferior (ptid_t ptid
)
2501 debug_target
.to_post_startup_inferior (ptid
);
2503 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2508 debug_to_acknowledge_created_inferior (int pid
)
2510 debug_target
.to_acknowledge_created_inferior (pid
);
2512 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2517 debug_to_insert_fork_catchpoint (int pid
)
2519 debug_target
.to_insert_fork_catchpoint (pid
);
2521 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2526 debug_to_remove_fork_catchpoint (int pid
)
2530 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2532 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2539 debug_to_insert_vfork_catchpoint (int pid
)
2541 debug_target
.to_insert_vfork_catchpoint (pid
);
2543 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2548 debug_to_remove_vfork_catchpoint (int pid
)
2552 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2554 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2561 debug_to_insert_exec_catchpoint (int pid
)
2563 debug_target
.to_insert_exec_catchpoint (pid
);
2565 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2570 debug_to_remove_exec_catchpoint (int pid
)
2574 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2576 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2583 debug_to_reported_exec_events_per_exec_call (void)
2585 int reported_exec_events
;
2587 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2589 fprintf_unfiltered (gdb_stdlog
,
2590 "target_reported_exec_events_per_exec_call () = %d\n",
2591 reported_exec_events
);
2593 return reported_exec_events
;
2597 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2601 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2603 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2604 pid
, wait_status
, *exit_status
, has_exited
);
2610 debug_to_mourn_inferior (void)
2612 debug_target
.to_mourn_inferior ();
2614 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2618 debug_to_can_run (void)
2622 retval
= debug_target
.to_can_run ();
2624 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2630 debug_to_notice_signals (ptid_t ptid
)
2632 debug_target
.to_notice_signals (ptid
);
2634 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2639 debug_to_thread_alive (ptid_t ptid
)
2643 retval
= debug_target
.to_thread_alive (ptid
);
2645 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2646 PIDGET (ptid
), retval
);
2652 debug_to_find_new_threads (void)
2654 debug_target
.to_find_new_threads ();
2656 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2660 debug_to_stop (void)
2662 debug_target
.to_stop ();
2664 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2668 debug_to_rcmd (char *command
,
2669 struct ui_file
*outbuf
)
2671 debug_target
.to_rcmd (command
, outbuf
);
2672 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2675 static struct symtab_and_line
*
2676 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2678 struct symtab_and_line
*result
;
2679 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2680 fprintf_unfiltered (gdb_stdlog
,
2681 "target get_exception_callback_sal (%d, %d)\n",
2686 static struct exception_event_record
*
2687 debug_to_get_current_exception_event (void)
2689 struct exception_event_record
*result
;
2690 result
= debug_target
.to_get_current_exception_event ();
2691 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2696 debug_to_pid_to_exec_file (int pid
)
2700 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2702 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2709 setup_target_debug (void)
2711 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2713 current_target
.to_open
= debug_to_open
;
2714 current_target
.to_close
= debug_to_close
;
2715 current_target
.to_attach
= debug_to_attach
;
2716 current_target
.to_post_attach
= debug_to_post_attach
;
2717 current_target
.to_detach
= debug_to_detach
;
2718 current_target
.to_resume
= debug_to_resume
;
2719 current_target
.to_wait
= debug_to_wait
;
2720 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2721 current_target
.to_store_registers
= debug_to_store_registers
;
2722 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2723 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2724 current_target
.to_files_info
= debug_to_files_info
;
2725 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2726 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2727 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2728 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2729 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2730 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2731 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2732 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2733 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2734 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2735 current_target
.to_terminal_init
= debug_to_terminal_init
;
2736 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2737 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2738 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2739 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2740 current_target
.to_terminal_info
= debug_to_terminal_info
;
2741 current_target
.to_kill
= debug_to_kill
;
2742 current_target
.to_load
= debug_to_load
;
2743 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2744 current_target
.to_create_inferior
= debug_to_create_inferior
;
2745 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2746 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2747 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2748 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2749 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2750 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2751 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2752 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2753 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2754 current_target
.to_has_exited
= debug_to_has_exited
;
2755 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2756 current_target
.to_can_run
= debug_to_can_run
;
2757 current_target
.to_notice_signals
= debug_to_notice_signals
;
2758 current_target
.to_thread_alive
= debug_to_thread_alive
;
2759 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2760 current_target
.to_stop
= debug_to_stop
;
2761 current_target
.to_rcmd
= debug_to_rcmd
;
2762 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2763 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2764 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2768 static char targ_desc
[] =
2769 "Names of targets and files being debugged.\n\
2770 Shows the entire stack of targets currently in use (including the exec-file,\n\
2771 core-file, and process, if any), as well as the symbol file name.";
2774 do_monitor_command (char *cmd
,
2777 if ((current_target
.to_rcmd
2778 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2779 || (current_target
.to_rcmd
== debug_to_rcmd
2780 && (debug_target
.to_rcmd
2781 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2782 error (_("\"monitor\" command not supported by this target."));
2783 target_rcmd (cmd
, gdb_stdtarg
);
2786 /* Print the name of each layers of our target stack. */
2789 maintenance_print_target_stack (char *cmd
, int from_tty
)
2791 struct target_ops
*t
;
2793 printf_filtered (_("The current target stack is:\n"));
2795 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2797 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
2802 initialize_targets (void)
2804 init_dummy_target ();
2805 push_target (&dummy_target
);
2807 add_info ("target", target_info
, targ_desc
);
2808 add_info ("files", target_info
, targ_desc
);
2810 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2811 Set target debugging."), _("\
2812 Show target debugging."), _("\
2813 When non-zero, target debugging is enabled. Higher numbers are more\n\
2814 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2818 &setdebuglist
, &showdebuglist
);
2820 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2821 &trust_readonly
, _("\
2822 Set mode for reading from readonly sections."), _("\
2823 Show mode for reading from readonly sections."), _("\
2824 When this mode is on, memory reads from readonly sections (such as .text)\n\
2825 will be read from the object file instead of from the target. This will\n\
2826 result in significant performance improvement for remote targets."),
2828 show_trust_readonly
,
2829 &setlist
, &showlist
);
2831 add_com ("monitor", class_obscure
, do_monitor_command
,
2832 _("Send a command to the remote monitor (remote targets only)."));
2834 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
2835 _("Print the name of each layer of the internal target stack."),
2836 &maintenanceprintlist
);
2838 target_dcache
= dcache_init ();