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 2 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, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
28 #include "gdb_string.h"
40 #include "gdb_assert.h"
42 #include "exceptions.h"
43 #include "target-descriptions.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_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
55 static int nosymbol (char *, CORE_ADDR
*);
57 static void tcomplain (void) ATTR_NORETURN
;
59 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
61 static int return_zero (void);
63 static int return_one (void);
65 static int return_minus_one (void);
67 void target_ignore (void);
69 static void target_command (char *, int);
71 static struct target_ops
*find_default_run_target (char *);
73 static void nosupport_runtime (void);
75 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
76 enum target_object object
,
77 const char *annex
, gdb_byte
*readbuf
,
78 const gdb_byte
*writebuf
,
79 ULONGEST offset
, LONGEST len
);
81 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
82 enum target_object object
,
83 const char *annex
, gdb_byte
*readbuf
,
84 const gdb_byte
*writebuf
,
85 ULONGEST offset
, LONGEST len
);
87 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
88 enum target_object object
,
90 void *readbuf
, const void *writebuf
,
91 ULONGEST offset
, LONGEST len
);
93 static void init_dummy_target (void);
95 static struct target_ops debug_target
;
97 static void debug_to_open (char *, int);
99 static void debug_to_close (int);
101 static void debug_to_attach (char *, int);
103 static void debug_to_detach (char *, int);
105 static void debug_to_resume (ptid_t
, int, enum target_signal
);
107 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
109 static void debug_to_fetch_registers (struct regcache
*, int);
111 static void debug_to_store_registers (struct regcache
*, int);
113 static void debug_to_prepare_to_store (struct regcache
*);
115 static void debug_to_files_info (struct target_ops
*);
117 static int debug_to_insert_breakpoint (struct bp_target_info
*);
119 static int debug_to_remove_breakpoint (struct bp_target_info
*);
121 static int debug_to_can_use_hw_breakpoint (int, int, int);
123 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
125 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
127 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
131 static int debug_to_stopped_by_watchpoint (void);
133 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
135 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
137 static void debug_to_terminal_init (void);
139 static void debug_to_terminal_inferior (void);
141 static void debug_to_terminal_ours_for_output (void);
143 static void debug_to_terminal_save_ours (void);
145 static void debug_to_terminal_ours (void);
147 static void debug_to_terminal_info (char *, int);
149 static void debug_to_kill (void);
151 static void debug_to_load (char *, int);
153 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
155 static void debug_to_mourn_inferior (void);
157 static int debug_to_can_run (void);
159 static void debug_to_notice_signals (ptid_t
);
161 static int debug_to_thread_alive (ptid_t
);
163 static void debug_to_stop (void);
165 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
166 wierd and mysterious ways. Putting the variable here lets those
167 wierd and mysterious ways keep building while they are being
168 converted to the inferior inheritance structure. */
169 struct target_ops deprecated_child_ops
;
171 /* Pointer to array of target architecture structures; the size of the
172 array; the current index into the array; the allocated size of the
174 struct target_ops
**target_structs
;
175 unsigned target_struct_size
;
176 unsigned target_struct_index
;
177 unsigned target_struct_allocsize
;
178 #define DEFAULT_ALLOCSIZE 10
180 /* The initial current target, so that there is always a semi-valid
183 static struct target_ops dummy_target
;
185 /* Top of target stack. */
187 static struct target_ops
*target_stack
;
189 /* The target structure we are currently using to talk to a process
190 or file or whatever "inferior" we have. */
192 struct target_ops current_target
;
194 /* Command list for target. */
196 static struct cmd_list_element
*targetlist
= NULL
;
198 /* Nonzero if we are debugging an attached outside process
199 rather than an inferior. */
203 /* Nonzero if we should trust readonly sections from the
204 executable when reading memory. */
206 static int trust_readonly
= 0;
208 /* Non-zero if we want to see trace of target level stuff. */
210 static int targetdebug
= 0;
212 show_targetdebug (struct ui_file
*file
, int from_tty
,
213 struct cmd_list_element
*c
, const char *value
)
215 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
218 static void setup_target_debug (void);
220 DCACHE
*target_dcache
;
222 /* The user just typed 'target' without the name of a target. */
225 target_command (char *arg
, int from_tty
)
227 fputs_filtered ("Argument required (target name). Try `help target'\n",
231 /* Add a possible target architecture to the list. */
234 add_target (struct target_ops
*t
)
236 /* Provide default values for all "must have" methods. */
237 if (t
->to_xfer_partial
== NULL
)
238 t
->to_xfer_partial
= default_xfer_partial
;
242 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
243 target_structs
= (struct target_ops
**) xmalloc
244 (target_struct_allocsize
* sizeof (*target_structs
));
246 if (target_struct_size
>= target_struct_allocsize
)
248 target_struct_allocsize
*= 2;
249 target_structs
= (struct target_ops
**)
250 xrealloc ((char *) target_structs
,
251 target_struct_allocsize
* sizeof (*target_structs
));
253 target_structs
[target_struct_size
++] = t
;
255 if (targetlist
== NULL
)
256 add_prefix_cmd ("target", class_run
, target_command
, _("\
257 Connect to a target machine or process.\n\
258 The first argument is the type or protocol of the target machine.\n\
259 Remaining arguments are interpreted by the target protocol. For more\n\
260 information on the arguments for a particular protocol, type\n\
261 `help target ' followed by the protocol name."),
262 &targetlist
, "target ", 0, &cmdlist
);
263 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
274 target_load (char *arg
, int from_tty
)
276 dcache_invalidate (target_dcache
);
277 (*current_target
.to_load
) (arg
, from_tty
);
281 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
282 struct target_ops
*t
)
284 errno
= EIO
; /* Can't read/write this location */
285 return 0; /* No bytes handled */
291 error (_("You can't do that when your target is `%s'"),
292 current_target
.to_shortname
);
298 error (_("You can't do that without a process to debug."));
302 nosymbol (char *name
, CORE_ADDR
*addrp
)
304 return 1; /* Symbol does not exist in target env */
308 nosupport_runtime (void)
310 if (ptid_equal (inferior_ptid
, null_ptid
))
313 error (_("No run-time support for this"));
318 default_terminal_info (char *args
, int from_tty
)
320 printf_unfiltered (_("No saved terminal information.\n"));
323 /* This is the default target_create_inferior and target_attach function.
324 If the current target is executing, it asks whether to kill it off.
325 If this function returns without calling error(), it has killed off
326 the target, and the operation should be attempted. */
329 kill_or_be_killed (int from_tty
)
331 if (target_has_execution
)
333 printf_unfiltered (_("You are already running a program:\n"));
334 target_files_info ();
335 if (query ("Kill it? "))
338 if (target_has_execution
)
339 error (_("Killing the program did not help."));
344 error (_("Program not killed."));
351 maybe_kill_then_attach (char *args
, int from_tty
)
353 kill_or_be_killed (from_tty
);
354 target_attach (args
, from_tty
);
358 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
361 kill_or_be_killed (0);
362 target_create_inferior (exec
, args
, env
, from_tty
);
365 /* Go through the target stack from top to bottom, copying over zero
366 entries in current_target, then filling in still empty entries. In
367 effect, we are doing class inheritance through the pushed target
370 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
371 is currently implemented, is that it discards any knowledge of
372 which target an inherited method originally belonged to.
373 Consequently, new new target methods should instead explicitly and
374 locally search the target stack for the target that can handle the
378 update_current_target (void)
380 struct target_ops
*t
;
382 /* First, reset current's contents. */
383 memset (¤t_target
, 0, sizeof (current_target
));
385 #define INHERIT(FIELD, TARGET) \
386 if (!current_target.FIELD) \
387 current_target.FIELD = (TARGET)->FIELD
389 for (t
= target_stack
; t
; t
= t
->beneath
)
391 INHERIT (to_shortname
, t
);
392 INHERIT (to_longname
, t
);
394 INHERIT (to_open
, t
);
395 INHERIT (to_close
, t
);
396 INHERIT (to_attach
, t
);
397 INHERIT (to_post_attach
, t
);
398 INHERIT (to_detach
, t
);
399 /* Do not inherit to_disconnect. */
400 INHERIT (to_resume
, t
);
401 INHERIT (to_wait
, t
);
402 INHERIT (to_fetch_registers
, t
);
403 INHERIT (to_store_registers
, t
);
404 INHERIT (to_prepare_to_store
, t
);
405 INHERIT (deprecated_xfer_memory
, t
);
406 INHERIT (to_files_info
, t
);
407 INHERIT (to_insert_breakpoint
, t
);
408 INHERIT (to_remove_breakpoint
, t
);
409 INHERIT (to_can_use_hw_breakpoint
, t
);
410 INHERIT (to_insert_hw_breakpoint
, t
);
411 INHERIT (to_remove_hw_breakpoint
, t
);
412 INHERIT (to_insert_watchpoint
, t
);
413 INHERIT (to_remove_watchpoint
, t
);
414 INHERIT (to_stopped_data_address
, t
);
415 INHERIT (to_stopped_by_watchpoint
, t
);
416 INHERIT (to_have_steppable_watchpoint
, t
);
417 INHERIT (to_have_continuable_watchpoint
, t
);
418 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
419 INHERIT (to_terminal_init
, t
);
420 INHERIT (to_terminal_inferior
, t
);
421 INHERIT (to_terminal_ours_for_output
, t
);
422 INHERIT (to_terminal_ours
, t
);
423 INHERIT (to_terminal_save_ours
, t
);
424 INHERIT (to_terminal_info
, t
);
425 INHERIT (to_kill
, t
);
426 INHERIT (to_load
, t
);
427 INHERIT (to_lookup_symbol
, t
);
428 INHERIT (to_create_inferior
, t
);
429 INHERIT (to_post_startup_inferior
, t
);
430 INHERIT (to_acknowledge_created_inferior
, t
);
431 INHERIT (to_insert_fork_catchpoint
, t
);
432 INHERIT (to_remove_fork_catchpoint
, t
);
433 INHERIT (to_insert_vfork_catchpoint
, t
);
434 INHERIT (to_remove_vfork_catchpoint
, t
);
435 /* Do not inherit to_follow_fork. */
436 INHERIT (to_insert_exec_catchpoint
, t
);
437 INHERIT (to_remove_exec_catchpoint
, t
);
438 INHERIT (to_reported_exec_events_per_exec_call
, t
);
439 INHERIT (to_has_exited
, t
);
440 INHERIT (to_mourn_inferior
, t
);
441 INHERIT (to_can_run
, t
);
442 INHERIT (to_notice_signals
, t
);
443 INHERIT (to_thread_alive
, t
);
444 INHERIT (to_find_new_threads
, t
);
445 INHERIT (to_pid_to_str
, t
);
446 INHERIT (to_extra_thread_info
, t
);
447 INHERIT (to_stop
, t
);
448 /* Do not inherit to_xfer_partial. */
449 INHERIT (to_rcmd
, t
);
450 INHERIT (to_enable_exception_callback
, t
);
451 INHERIT (to_get_current_exception_event
, t
);
452 INHERIT (to_pid_to_exec_file
, t
);
453 INHERIT (to_stratum
, t
);
454 INHERIT (to_has_all_memory
, t
);
455 INHERIT (to_has_memory
, t
);
456 INHERIT (to_has_stack
, t
);
457 INHERIT (to_has_registers
, t
);
458 INHERIT (to_has_execution
, t
);
459 INHERIT (to_has_thread_control
, t
);
460 INHERIT (to_sections
, t
);
461 INHERIT (to_sections_end
, t
);
462 INHERIT (to_can_async_p
, t
);
463 INHERIT (to_is_async_p
, t
);
464 INHERIT (to_async
, t
);
465 INHERIT (to_async_mask_value
, t
);
466 INHERIT (to_find_memory_regions
, t
);
467 INHERIT (to_make_corefile_notes
, t
);
468 INHERIT (to_get_thread_local_address
, t
);
469 /* Do not inherit to_read_description. */
470 INHERIT (to_magic
, t
);
471 /* Do not inherit to_memory_map. */
472 /* Do not inherit to_flash_erase. */
473 /* Do not inherit to_flash_done. */
477 /* Clean up a target struct so it no longer has any zero pointers in
478 it. Some entries are defaulted to a method that print an error,
479 others are hard-wired to a standard recursive default. */
481 #define de_fault(field, value) \
482 if (!current_target.field) \
483 current_target.field = value
486 (void (*) (char *, int))
492 maybe_kill_then_attach
);
493 de_fault (to_post_attach
,
497 (void (*) (char *, int))
500 (void (*) (ptid_t
, int, enum target_signal
))
503 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
505 de_fault (to_fetch_registers
,
506 (void (*) (struct regcache
*, int))
508 de_fault (to_store_registers
,
509 (void (*) (struct regcache
*, int))
511 de_fault (to_prepare_to_store
,
512 (void (*) (struct regcache
*))
514 de_fault (deprecated_xfer_memory
,
515 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
517 de_fault (to_files_info
,
518 (void (*) (struct target_ops
*))
520 de_fault (to_insert_breakpoint
,
521 memory_insert_breakpoint
);
522 de_fault (to_remove_breakpoint
,
523 memory_remove_breakpoint
);
524 de_fault (to_can_use_hw_breakpoint
,
525 (int (*) (int, int, int))
527 de_fault (to_insert_hw_breakpoint
,
528 (int (*) (struct bp_target_info
*))
530 de_fault (to_remove_hw_breakpoint
,
531 (int (*) (struct bp_target_info
*))
533 de_fault (to_insert_watchpoint
,
534 (int (*) (CORE_ADDR
, int, int))
536 de_fault (to_remove_watchpoint
,
537 (int (*) (CORE_ADDR
, int, int))
539 de_fault (to_stopped_by_watchpoint
,
542 de_fault (to_stopped_data_address
,
543 (int (*) (struct target_ops
*, CORE_ADDR
*))
545 de_fault (to_region_ok_for_hw_watchpoint
,
546 default_region_ok_for_hw_watchpoint
);
547 de_fault (to_terminal_init
,
550 de_fault (to_terminal_inferior
,
553 de_fault (to_terminal_ours_for_output
,
556 de_fault (to_terminal_ours
,
559 de_fault (to_terminal_save_ours
,
562 de_fault (to_terminal_info
,
563 default_terminal_info
);
568 (void (*) (char *, int))
570 de_fault (to_lookup_symbol
,
571 (int (*) (char *, CORE_ADDR
*))
573 de_fault (to_create_inferior
,
574 maybe_kill_then_create_inferior
);
575 de_fault (to_post_startup_inferior
,
578 de_fault (to_acknowledge_created_inferior
,
581 de_fault (to_insert_fork_catchpoint
,
584 de_fault (to_remove_fork_catchpoint
,
587 de_fault (to_insert_vfork_catchpoint
,
590 de_fault (to_remove_vfork_catchpoint
,
593 de_fault (to_insert_exec_catchpoint
,
596 de_fault (to_remove_exec_catchpoint
,
599 de_fault (to_reported_exec_events_per_exec_call
,
602 de_fault (to_has_exited
,
603 (int (*) (int, int, int *))
605 de_fault (to_mourn_inferior
,
608 de_fault (to_can_run
,
610 de_fault (to_notice_signals
,
613 de_fault (to_thread_alive
,
616 de_fault (to_find_new_threads
,
619 de_fault (to_extra_thread_info
,
620 (char *(*) (struct thread_info
*))
625 current_target
.to_xfer_partial
= current_xfer_partial
;
627 (void (*) (char *, struct ui_file
*))
629 de_fault (to_enable_exception_callback
,
630 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
632 de_fault (to_get_current_exception_event
,
633 (struct exception_event_record
* (*) (void))
635 de_fault (to_pid_to_exec_file
,
638 de_fault (to_can_async_p
,
641 de_fault (to_is_async_p
,
645 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
647 current_target
.to_read_description
= NULL
;
650 /* Finally, position the target-stack beneath the squashed
651 "current_target". That way code looking for a non-inherited
652 target method can quickly and simply find it. */
653 current_target
.beneath
= target_stack
;
656 /* Mark OPS as a running target. This reverses the effect
657 of target_mark_exited. */
660 target_mark_running (struct target_ops
*ops
)
662 struct target_ops
*t
;
664 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
668 internal_error (__FILE__
, __LINE__
,
669 "Attempted to mark unpushed target \"%s\" as running",
672 ops
->to_has_execution
= 1;
673 ops
->to_has_all_memory
= 1;
674 ops
->to_has_memory
= 1;
675 ops
->to_has_stack
= 1;
676 ops
->to_has_registers
= 1;
678 update_current_target ();
681 /* Mark OPS as a non-running target. This reverses the effect
682 of target_mark_running. */
685 target_mark_exited (struct target_ops
*ops
)
687 struct target_ops
*t
;
689 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
693 internal_error (__FILE__
, __LINE__
,
694 "Attempted to mark unpushed target \"%s\" as running",
697 ops
->to_has_execution
= 0;
698 ops
->to_has_all_memory
= 0;
699 ops
->to_has_memory
= 0;
700 ops
->to_has_stack
= 0;
701 ops
->to_has_registers
= 0;
703 update_current_target ();
706 /* Push a new target type into the stack of the existing target accessors,
707 possibly superseding some of the existing accessors.
709 Result is zero if the pushed target ended up on top of the stack,
710 nonzero if at least one target is on top of it.
712 Rather than allow an empty stack, we always have the dummy target at
713 the bottom stratum, so we can call the function vectors without
717 push_target (struct target_ops
*t
)
719 struct target_ops
**cur
;
721 /* Check magic number. If wrong, it probably means someone changed
722 the struct definition, but not all the places that initialize one. */
723 if (t
->to_magic
!= OPS_MAGIC
)
725 fprintf_unfiltered (gdb_stderr
,
726 "Magic number of %s target struct wrong\n",
728 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
731 /* Find the proper stratum to install this target in. */
732 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
734 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
738 /* If there's already targets at this stratum, remove them. */
739 /* FIXME: cagney/2003-10-15: I think this should be popping all
740 targets to CUR, and not just those at this stratum level. */
741 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
743 /* There's already something at this stratum level. Close it,
744 and un-hook it from the stack. */
745 struct target_ops
*tmp
= (*cur
);
746 (*cur
) = (*cur
)->beneath
;
748 target_close (tmp
, 0);
751 /* We have removed all targets in our stratum, now add the new one. */
755 update_current_target ();
758 setup_target_debug ();
761 return (t
!= target_stack
);
764 /* Remove a target_ops vector from the stack, wherever it may be.
765 Return how many times it was removed (0 or 1). */
768 unpush_target (struct target_ops
*t
)
770 struct target_ops
**cur
;
771 struct target_ops
*tmp
;
773 /* Look for the specified target. Note that we assume that a target
774 can only occur once in the target stack. */
776 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
783 return 0; /* Didn't find target_ops, quit now */
785 /* NOTE: cagney/2003-12-06: In '94 the close call was made
786 unconditional by moving it to before the above check that the
787 target was in the target stack (something about "Change the way
788 pushing and popping of targets work to support target overlays
789 and inheritance"). This doesn't make much sense - only open
790 targets should be closed. */
793 /* Unchain the target */
795 (*cur
) = (*cur
)->beneath
;
798 update_current_target ();
806 target_close (¤t_target
, 0); /* Let it clean up */
807 if (unpush_target (target_stack
) == 1)
810 fprintf_unfiltered (gdb_stderr
,
811 "pop_target couldn't find target %s\n",
812 current_target
.to_shortname
);
813 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
816 /* Using the objfile specified in BATON, find the address for the
817 current thread's thread-local storage with offset OFFSET. */
819 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
821 volatile CORE_ADDR addr
= 0;
823 if (target_get_thread_local_address_p ()
824 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
826 ptid_t ptid
= inferior_ptid
;
827 volatile struct gdb_exception ex
;
829 TRY_CATCH (ex
, RETURN_MASK_ALL
)
833 /* Fetch the load module address for this objfile. */
834 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
836 /* If it's 0, throw the appropriate exception. */
838 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
839 _("TLS load module not found"));
841 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
843 /* If an error occurred, print TLS related messages here. Otherwise,
844 throw the error to some higher catcher. */
847 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
851 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
852 error (_("Cannot find thread-local variables in this thread library."));
854 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
855 if (objfile_is_library
)
856 error (_("Cannot find shared library `%s' in dynamic"
857 " linker's load module list"), objfile
->name
);
859 error (_("Cannot find executable file `%s' in dynamic"
860 " linker's load module list"), objfile
->name
);
862 case TLS_NOT_ALLOCATED_YET_ERROR
:
863 if (objfile_is_library
)
864 error (_("The inferior has not yet allocated storage for"
865 " thread-local variables in\n"
866 "the shared library `%s'\n"
868 objfile
->name
, target_pid_to_str (ptid
));
870 error (_("The inferior has not yet allocated storage for"
871 " thread-local variables in\n"
872 "the executable `%s'\n"
874 objfile
->name
, target_pid_to_str (ptid
));
876 case TLS_GENERIC_ERROR
:
877 if (objfile_is_library
)
878 error (_("Cannot find thread-local storage for %s, "
879 "shared library %s:\n%s"),
880 target_pid_to_str (ptid
),
881 objfile
->name
, ex
.message
);
883 error (_("Cannot find thread-local storage for %s, "
884 "executable file %s:\n%s"),
885 target_pid_to_str (ptid
),
886 objfile
->name
, ex
.message
);
889 throw_exception (ex
);
894 /* It wouldn't be wrong here to try a gdbarch method, too; finding
895 TLS is an ABI-specific thing. But we don't do that yet. */
897 error (_("Cannot find thread-local variables on this target"));
903 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
905 /* target_read_string -- read a null terminated string, up to LEN bytes,
906 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
907 Set *STRING to a pointer to malloc'd memory containing the data; the caller
908 is responsible for freeing it. Return the number of bytes successfully
912 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
914 int tlen
, origlen
, offset
, i
;
918 int buffer_allocated
;
920 unsigned int nbytes_read
= 0;
924 /* Small for testing. */
925 buffer_allocated
= 4;
926 buffer
= xmalloc (buffer_allocated
);
933 tlen
= MIN (len
, 4 - (memaddr
& 3));
934 offset
= memaddr
& 3;
936 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
939 /* The transfer request might have crossed the boundary to an
940 unallocated region of memory. Retry the transfer, requesting
944 errcode
= target_read_memory (memaddr
, buf
, 1);
949 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
952 bytes
= bufptr
- buffer
;
953 buffer_allocated
*= 2;
954 buffer
= xrealloc (buffer
, buffer_allocated
);
955 bufptr
= buffer
+ bytes
;
958 for (i
= 0; i
< tlen
; i
++)
960 *bufptr
++ = buf
[i
+ offset
];
961 if (buf
[i
+ offset
] == '\000')
963 nbytes_read
+= i
+ 1;
979 /* Find a section containing ADDR. */
980 struct section_table
*
981 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
983 struct section_table
*secp
;
984 for (secp
= target
->to_sections
;
985 secp
< target
->to_sections_end
;
988 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
994 /* Perform a partial memory transfer. The arguments and return
995 value are just as for target_xfer_partial. */
998 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
999 ULONGEST memaddr
, LONGEST len
)
1003 struct mem_region
*region
;
1005 /* Zero length requests are ok and require no work. */
1009 /* Try the executable file, if "trust-readonly-sections" is set. */
1010 if (readbuf
!= NULL
&& trust_readonly
)
1012 struct section_table
*secp
;
1014 secp
= target_section_by_addr (ops
, memaddr
);
1016 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1018 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1021 /* Likewise for accesses to unmapped overlay sections. */
1022 if (readbuf
!= NULL
&& overlay_debugging
)
1024 asection
*section
= find_pc_overlay (memaddr
);
1025 if (pc_in_unmapped_range (memaddr
, section
))
1026 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1029 /* Try GDB's internal data cache. */
1030 region
= lookup_mem_region (memaddr
);
1031 /* region->hi == 0 means there's no upper bound. */
1032 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1035 reg_len
= region
->hi
- memaddr
;
1037 switch (region
->attrib
.mode
)
1040 if (writebuf
!= NULL
)
1045 if (readbuf
!= NULL
)
1050 /* We only support writing to flash during "load" for now. */
1051 if (writebuf
!= NULL
)
1052 error (_("Writing to flash memory forbidden in this context"));
1059 if (region
->attrib
.cache
)
1061 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1062 memory request will start back at current_target. */
1063 if (readbuf
!= NULL
)
1064 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1067 /* FIXME drow/2006-08-09: If we're going to preserve const
1068 correctness dcache_xfer_memory should take readbuf and
1070 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1079 /* If none of those methods found the memory we wanted, fall back
1080 to a target partial transfer. Normally a single call to
1081 to_xfer_partial is enough; if it doesn't recognize an object
1082 it will call the to_xfer_partial of the next target down.
1083 But for memory this won't do. Memory is the only target
1084 object which can be read from more than one valid target.
1085 A core file, for instance, could have some of memory but
1086 delegate other bits to the target below it. So, we must
1087 manually try all targets. */
1091 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1092 readbuf
, writebuf
, memaddr
, reg_len
);
1096 /* We want to continue past core files to executables, but not
1097 past a running target's memory. */
1098 if (ops
->to_has_all_memory
)
1103 while (ops
!= NULL
);
1105 /* If we still haven't got anything, return the last error. We
1111 target_xfer_partial (struct target_ops
*ops
,
1112 enum target_object object
, const char *annex
,
1113 void *readbuf
, const void *writebuf
,
1114 ULONGEST offset
, LONGEST len
)
1118 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1120 /* If this is a memory transfer, let the memory-specific code
1121 have a look at it instead. Memory transfers are more
1123 if (object
== TARGET_OBJECT_MEMORY
)
1124 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1127 enum target_object raw_object
= object
;
1129 /* If this is a raw memory transfer, request the normal
1130 memory object from other layers. */
1131 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1132 raw_object
= TARGET_OBJECT_MEMORY
;
1134 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1135 writebuf
, offset
, len
);
1140 const unsigned char *myaddr
= NULL
;
1142 fprintf_unfiltered (gdb_stdlog
,
1143 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1146 (annex
? annex
: "(null)"),
1147 (long) readbuf
, (long) writebuf
,
1148 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1154 if (retval
> 0 && myaddr
!= NULL
)
1158 fputs_unfiltered (", bytes =", gdb_stdlog
);
1159 for (i
= 0; i
< retval
; i
++)
1161 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1163 if (targetdebug
< 2 && i
> 0)
1165 fprintf_unfiltered (gdb_stdlog
, " ...");
1168 fprintf_unfiltered (gdb_stdlog
, "\n");
1171 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1175 fputc_unfiltered ('\n', gdb_stdlog
);
1180 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1181 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1182 if any error occurs.
1184 If an error occurs, no guarantee is made about the contents of the data at
1185 MYADDR. In particular, the caller should not depend upon partial reads
1186 filling the buffer with good data. There is no way for the caller to know
1187 how much good data might have been transfered anyway. Callers that can
1188 deal with partial reads should call target_read (which will retry until
1189 it makes no progress, and then return how much was transferred). */
1192 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1194 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1195 myaddr
, memaddr
, len
) == len
)
1202 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1204 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1205 myaddr
, memaddr
, len
) == len
)
1211 /* Fetch the target's memory map. */
1214 target_memory_map (void)
1216 VEC(mem_region_s
) *result
;
1217 struct mem_region
*last_one
, *this_one
;
1219 struct target_ops
*t
;
1222 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1224 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1225 if (t
->to_memory_map
!= NULL
)
1231 result
= t
->to_memory_map (t
);
1235 qsort (VEC_address (mem_region_s
, result
),
1236 VEC_length (mem_region_s
, result
),
1237 sizeof (struct mem_region
), mem_region_cmp
);
1239 /* Check that regions do not overlap. Simultaneously assign
1240 a numbering for the "mem" commands to use to refer to
1243 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1245 this_one
->number
= ix
;
1247 if (last_one
&& last_one
->hi
> this_one
->lo
)
1249 warning (_("Overlapping regions in memory map: ignoring"));
1250 VEC_free (mem_region_s
, result
);
1253 last_one
= this_one
;
1260 target_flash_erase (ULONGEST address
, LONGEST length
)
1262 struct target_ops
*t
;
1264 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1265 if (t
->to_flash_erase
!= NULL
)
1268 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1269 paddr (address
), phex (length
, 0));
1270 t
->to_flash_erase (t
, address
, length
);
1278 target_flash_done (void)
1280 struct target_ops
*t
;
1282 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1283 if (t
->to_flash_done
!= NULL
)
1286 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1287 t
->to_flash_done (t
);
1294 #ifndef target_stopped_data_address_p
1296 target_stopped_data_address_p (struct target_ops
*target
)
1298 if (target
->to_stopped_data_address
1299 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1301 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1302 && (debug_target
.to_stopped_data_address
1303 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1310 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1311 struct cmd_list_element
*c
, const char *value
)
1313 fprintf_filtered (file
, _("\
1314 Mode for reading from readonly sections is %s.\n"),
1318 /* More generic transfers. */
1321 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1322 const char *annex
, gdb_byte
*readbuf
,
1323 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1325 if (object
== TARGET_OBJECT_MEMORY
1326 && ops
->deprecated_xfer_memory
!= NULL
)
1327 /* If available, fall back to the target's
1328 "deprecated_xfer_memory" method. */
1332 if (writebuf
!= NULL
)
1334 void *buffer
= xmalloc (len
);
1335 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1336 memcpy (buffer
, writebuf
, len
);
1337 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1338 1/*write*/, NULL
, ops
);
1339 do_cleanups (cleanup
);
1341 if (readbuf
!= NULL
)
1342 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1346 else if (xfered
== 0 && errno
== 0)
1347 /* "deprecated_xfer_memory" uses 0, cross checked against
1348 ERRNO as one indication of an error. */
1353 else if (ops
->beneath
!= NULL
)
1354 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1355 readbuf
, writebuf
, offset
, len
);
1360 /* The xfer_partial handler for the topmost target. Unlike the default,
1361 it does not need to handle memory specially; it just passes all
1362 requests down the stack. */
1365 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1366 const char *annex
, gdb_byte
*readbuf
,
1367 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1369 if (ops
->beneath
!= NULL
)
1370 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1371 readbuf
, writebuf
, offset
, len
);
1376 /* Target vector read/write partial wrapper functions.
1378 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1379 (inbuf, outbuf)", instead of separate read/write methods, make life
1383 target_read_partial (struct target_ops
*ops
,
1384 enum target_object object
,
1385 const char *annex
, gdb_byte
*buf
,
1386 ULONGEST offset
, LONGEST len
)
1388 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1392 target_write_partial (struct target_ops
*ops
,
1393 enum target_object object
,
1394 const char *annex
, const gdb_byte
*buf
,
1395 ULONGEST offset
, LONGEST len
)
1397 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1400 /* Wrappers to perform the full transfer. */
1402 target_read (struct target_ops
*ops
,
1403 enum target_object object
,
1404 const char *annex
, gdb_byte
*buf
,
1405 ULONGEST offset
, LONGEST len
)
1408 while (xfered
< len
)
1410 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1411 (gdb_byte
*) buf
+ xfered
,
1412 offset
+ xfered
, len
- xfered
);
1413 /* Call an observer, notifying them of the xfer progress? */
1424 /* An alternative to target_write with progress callbacks. */
1427 target_write_with_progress (struct target_ops
*ops
,
1428 enum target_object object
,
1429 const char *annex
, const gdb_byte
*buf
,
1430 ULONGEST offset
, LONGEST len
,
1431 void (*progress
) (ULONGEST
, void *), void *baton
)
1435 /* Give the progress callback a chance to set up. */
1437 (*progress
) (0, baton
);
1439 while (xfered
< len
)
1441 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1442 (gdb_byte
*) buf
+ xfered
,
1443 offset
+ xfered
, len
- xfered
);
1451 (*progress
) (xfer
, baton
);
1460 target_write (struct target_ops
*ops
,
1461 enum target_object object
,
1462 const char *annex
, const gdb_byte
*buf
,
1463 ULONGEST offset
, LONGEST len
)
1465 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1469 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1470 the size of the transferred data. PADDING additional bytes are
1471 available in *BUF_P. This is a helper function for
1472 target_read_alloc; see the declaration of that function for more
1476 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1477 const char *annex
, gdb_byte
**buf_p
, int padding
)
1479 size_t buf_alloc
, buf_pos
;
1483 /* This function does not have a length parameter; it reads the
1484 entire OBJECT). Also, it doesn't support objects fetched partly
1485 from one target and partly from another (in a different stratum,
1486 e.g. a core file and an executable). Both reasons make it
1487 unsuitable for reading memory. */
1488 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1490 /* Start by reading up to 4K at a time. The target will throttle
1491 this number down if necessary. */
1493 buf
= xmalloc (buf_alloc
);
1497 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1498 buf_pos
, buf_alloc
- buf_pos
- padding
);
1501 /* An error occurred. */
1507 /* Read all there was. */
1517 /* If the buffer is filling up, expand it. */
1518 if (buf_alloc
< buf_pos
* 2)
1521 buf
= xrealloc (buf
, buf_alloc
);
1528 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1529 the size of the transferred data. See the declaration in "target.h"
1530 function for more information about the return value. */
1533 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1534 const char *annex
, gdb_byte
**buf_p
)
1536 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1539 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1540 returned as a string, allocated using xmalloc. If an error occurs
1541 or the transfer is unsupported, NULL is returned. Empty objects
1542 are returned as allocated but empty strings. A warning is issued
1543 if the result contains any embedded NUL bytes. */
1546 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1550 LONGEST transferred
;
1552 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1554 if (transferred
< 0)
1557 if (transferred
== 0)
1558 return xstrdup ("");
1560 buffer
[transferred
] = 0;
1561 if (strlen (buffer
) < transferred
)
1562 warning (_("target object %d, annex %s, "
1563 "contained unexpected null characters"),
1564 (int) object
, annex
? annex
: "(none)");
1566 return (char *) buffer
;
1569 /* Memory transfer methods. */
1572 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1575 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1577 memory_error (EIO
, addr
);
1581 get_target_memory_unsigned (struct target_ops
*ops
,
1582 CORE_ADDR addr
, int len
)
1584 gdb_byte buf
[sizeof (ULONGEST
)];
1586 gdb_assert (len
<= sizeof (buf
));
1587 get_target_memory (ops
, addr
, buf
, len
);
1588 return extract_unsigned_integer (buf
, len
);
1592 target_info (char *args
, int from_tty
)
1594 struct target_ops
*t
;
1595 int has_all_mem
= 0;
1597 if (symfile_objfile
!= NULL
)
1598 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1600 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1602 if (!t
->to_has_memory
)
1605 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1608 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1609 printf_unfiltered ("%s:\n", t
->to_longname
);
1610 (t
->to_files_info
) (t
);
1611 has_all_mem
= t
->to_has_all_memory
;
1615 /* This function is called before any new inferior is created, e.g.
1616 by running a program, attaching, or connecting to a target.
1617 It cleans up any state from previous invocations which might
1618 change between runs. This is a subset of what target_preopen
1619 resets (things which might change between targets). */
1622 target_pre_inferior (int from_tty
)
1624 invalidate_target_mem_regions ();
1626 target_clear_description ();
1629 /* This is to be called by the open routine before it does
1633 target_preopen (int from_tty
)
1637 if (target_has_execution
)
1640 || query (_("A program is being debugged already. Kill it? ")))
1643 error (_("Program not killed."));
1646 /* Calling target_kill may remove the target from the stack. But if
1647 it doesn't (which seems like a win for UDI), remove it now. */
1649 if (target_has_execution
)
1652 target_pre_inferior (from_tty
);
1655 /* Detach a target after doing deferred register stores. */
1658 target_detach (char *args
, int from_tty
)
1660 (current_target
.to_detach
) (args
, from_tty
);
1664 target_disconnect (char *args
, int from_tty
)
1666 struct target_ops
*t
;
1668 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1669 if (t
->to_disconnect
!= NULL
)
1672 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1674 t
->to_disconnect (t
, args
, from_tty
);
1682 target_async_mask (int mask
)
1684 int saved_async_masked_status
= target_async_mask_value
;
1685 target_async_mask_value
= mask
;
1686 return saved_async_masked_status
;
1689 /* Look through the list of possible targets for a target that can
1693 target_follow_fork (int follow_child
)
1695 struct target_ops
*t
;
1697 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1699 if (t
->to_follow_fork
!= NULL
)
1701 int retval
= t
->to_follow_fork (t
, follow_child
);
1703 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1704 follow_child
, retval
);
1709 /* Some target returned a fork event, but did not know how to follow it. */
1710 internal_error (__FILE__
, __LINE__
,
1711 "could not find a target to follow fork");
1714 /* Look for a target which can describe architectural features, starting
1715 from TARGET. If we find one, return its description. */
1717 const struct target_desc
*
1718 target_read_description (struct target_ops
*target
)
1720 struct target_ops
*t
;
1722 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1723 if (t
->to_read_description
!= NULL
)
1725 const struct target_desc
*tdesc
;
1727 tdesc
= t
->to_read_description (t
);
1735 /* Look through the list of possible targets for a target that can
1736 execute a run or attach command without any other data. This is
1737 used to locate the default process stratum.
1739 Result is always valid (error() is called for errors). */
1741 static struct target_ops
*
1742 find_default_run_target (char *do_mesg
)
1744 struct target_ops
**t
;
1745 struct target_ops
*runable
= NULL
;
1750 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1753 if ((*t
)->to_can_run
&& target_can_run (*t
))
1761 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1767 find_default_attach (char *args
, int from_tty
)
1769 struct target_ops
*t
;
1771 t
= find_default_run_target ("attach");
1772 (t
->to_attach
) (args
, from_tty
);
1777 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1780 struct target_ops
*t
;
1782 t
= find_default_run_target ("run");
1783 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1788 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1790 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1806 return_minus_one (void)
1812 * Resize the to_sections pointer. Also make sure that anyone that
1813 * was holding on to an old value of it gets updated.
1814 * Returns the old size.
1818 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1820 struct target_ops
**t
;
1821 struct section_table
*old_value
;
1824 old_value
= target
->to_sections
;
1826 if (target
->to_sections
)
1828 old_count
= target
->to_sections_end
- target
->to_sections
;
1829 target
->to_sections
= (struct section_table
*)
1830 xrealloc ((char *) target
->to_sections
,
1831 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1836 target
->to_sections
= (struct section_table
*)
1837 xmalloc ((sizeof (struct section_table
)) * num_added
);
1839 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1841 /* Check to see if anyone else was pointing to this structure.
1842 If old_value was null, then no one was. */
1846 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1849 if ((*t
)->to_sections
== old_value
)
1851 (*t
)->to_sections
= target
->to_sections
;
1852 (*t
)->to_sections_end
= target
->to_sections_end
;
1855 /* There is a flattened view of the target stack in current_target,
1856 so its to_sections pointer might also need updating. */
1857 if (current_target
.to_sections
== old_value
)
1859 current_target
.to_sections
= target
->to_sections
;
1860 current_target
.to_sections_end
= target
->to_sections_end
;
1868 /* Remove all target sections taken from ABFD.
1870 Scan the current target stack for targets whose section tables
1871 refer to sections from BFD, and remove those sections. We use this
1872 when we notice that the inferior has unloaded a shared object, for
1875 remove_target_sections (bfd
*abfd
)
1877 struct target_ops
**t
;
1879 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1881 struct section_table
*src
, *dest
;
1883 dest
= (*t
)->to_sections
;
1884 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1885 if (src
->bfd
!= abfd
)
1887 /* Keep this section. */
1888 if (dest
< src
) *dest
= *src
;
1892 /* If we've dropped any sections, resize the section table. */
1894 target_resize_to_sections (*t
, dest
- src
);
1901 /* Find a single runnable target in the stack and return it. If for
1902 some reason there is more than one, return NULL. */
1905 find_run_target (void)
1907 struct target_ops
**t
;
1908 struct target_ops
*runable
= NULL
;
1913 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1915 if ((*t
)->to_can_run
&& target_can_run (*t
))
1922 return (count
== 1 ? runable
: NULL
);
1925 /* Find a single core_stratum target in the list of targets and return it.
1926 If for some reason there is more than one, return NULL. */
1929 find_core_target (void)
1931 struct target_ops
**t
;
1932 struct target_ops
*runable
= NULL
;
1937 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1940 if ((*t
)->to_stratum
== core_stratum
)
1947 return (count
== 1 ? runable
: NULL
);
1951 * Find the next target down the stack from the specified target.
1955 find_target_beneath (struct target_ops
*t
)
1961 /* The inferior process has died. Long live the inferior! */
1964 generic_mourn_inferior (void)
1966 extern int show_breakpoint_hit_counts
;
1968 inferior_ptid
= null_ptid
;
1970 breakpoint_init_inferior (inf_exited
);
1971 registers_changed ();
1973 reopen_exec_file ();
1974 reinit_frame_cache ();
1976 /* It is confusing to the user for ignore counts to stick around
1977 from previous runs of the inferior. So clear them. */
1978 /* However, it is more confusing for the ignore counts to disappear when
1979 using hit counts. So don't clear them if we're counting hits. */
1980 if (!show_breakpoint_hit_counts
)
1981 breakpoint_clear_ignore_counts ();
1983 if (deprecated_detach_hook
)
1984 deprecated_detach_hook ();
1987 /* Helper function for child_wait and the derivatives of child_wait.
1988 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1989 translation of that in OURSTATUS. */
1991 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1993 if (WIFEXITED (hoststatus
))
1995 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1996 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1998 else if (!WIFSTOPPED (hoststatus
))
2000 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2001 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2005 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2006 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2010 /* Returns zero to leave the inferior alone, one to interrupt it. */
2011 int (*target_activity_function
) (void);
2012 int target_activity_fd
;
2014 /* Convert a normal process ID to a string. Returns the string in a
2018 normal_pid_to_str (ptid_t ptid
)
2020 static char buf
[32];
2022 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2026 /* Error-catcher for target_find_memory_regions */
2027 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2029 error (_("No target."));
2033 /* Error-catcher for target_make_corefile_notes */
2034 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2036 error (_("No target."));
2040 /* Set up the handful of non-empty slots needed by the dummy target
2044 init_dummy_target (void)
2046 dummy_target
.to_shortname
= "None";
2047 dummy_target
.to_longname
= "None";
2048 dummy_target
.to_doc
= "";
2049 dummy_target
.to_attach
= find_default_attach
;
2050 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2051 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2052 dummy_target
.to_stratum
= dummy_stratum
;
2053 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2054 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2055 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2056 dummy_target
.to_magic
= OPS_MAGIC
;
2060 debug_to_open (char *args
, int from_tty
)
2062 debug_target
.to_open (args
, from_tty
);
2064 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2068 debug_to_close (int quitting
)
2070 target_close (&debug_target
, quitting
);
2071 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2075 target_close (struct target_ops
*targ
, int quitting
)
2077 if (targ
->to_xclose
!= NULL
)
2078 targ
->to_xclose (targ
, quitting
);
2079 else if (targ
->to_close
!= NULL
)
2080 targ
->to_close (quitting
);
2084 debug_to_attach (char *args
, int from_tty
)
2086 debug_target
.to_attach (args
, from_tty
);
2088 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2093 debug_to_post_attach (int pid
)
2095 debug_target
.to_post_attach (pid
);
2097 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2101 debug_to_detach (char *args
, int from_tty
)
2103 debug_target
.to_detach (args
, from_tty
);
2105 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2109 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2111 debug_target
.to_resume (ptid
, step
, siggnal
);
2113 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2114 step
? "step" : "continue",
2115 target_signal_to_name (siggnal
));
2119 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2123 retval
= debug_target
.to_wait (ptid
, status
);
2125 fprintf_unfiltered (gdb_stdlog
,
2126 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2128 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2129 switch (status
->kind
)
2131 case TARGET_WAITKIND_EXITED
:
2132 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2133 status
->value
.integer
);
2135 case TARGET_WAITKIND_STOPPED
:
2136 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2137 target_signal_to_name (status
->value
.sig
));
2139 case TARGET_WAITKIND_SIGNALLED
:
2140 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2141 target_signal_to_name (status
->value
.sig
));
2143 case TARGET_WAITKIND_LOADED
:
2144 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2146 case TARGET_WAITKIND_FORKED
:
2147 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2149 case TARGET_WAITKIND_VFORKED
:
2150 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2152 case TARGET_WAITKIND_EXECD
:
2153 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2155 case TARGET_WAITKIND_SPURIOUS
:
2156 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2159 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2167 debug_print_register (const char * func
,
2168 struct regcache
*regcache
, int regno
)
2170 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2171 if (regno
>= 0 && regno
< gdbarch_num_regs (current_gdbarch
)
2172 + gdbarch_num_pseudo_regs (current_gdbarch
)
2173 && gdbarch_register_name (current_gdbarch
, regno
) != NULL
2174 && gdbarch_register_name (current_gdbarch
, regno
)[0] != '\0')
2175 fprintf_unfiltered (gdb_stdlog
, "(%s)", gdbarch_register_name
2176 (current_gdbarch
, regno
));
2178 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2181 int i
, size
= register_size (current_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 ();