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 (int);
111 static void debug_to_store_registers (int);
113 static void debug_to_prepare_to_store (void);
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_continuable_watchpoint
, t
);
417 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
418 INHERIT (to_terminal_init
, t
);
419 INHERIT (to_terminal_inferior
, t
);
420 INHERIT (to_terminal_ours_for_output
, t
);
421 INHERIT (to_terminal_ours
, t
);
422 INHERIT (to_terminal_save_ours
, t
);
423 INHERIT (to_terminal_info
, t
);
424 INHERIT (to_kill
, t
);
425 INHERIT (to_load
, t
);
426 INHERIT (to_lookup_symbol
, t
);
427 INHERIT (to_create_inferior
, t
);
428 INHERIT (to_post_startup_inferior
, t
);
429 INHERIT (to_acknowledge_created_inferior
, t
);
430 INHERIT (to_insert_fork_catchpoint
, t
);
431 INHERIT (to_remove_fork_catchpoint
, t
);
432 INHERIT (to_insert_vfork_catchpoint
, t
);
433 INHERIT (to_remove_vfork_catchpoint
, t
);
434 /* Do not inherit to_follow_fork. */
435 INHERIT (to_insert_exec_catchpoint
, t
);
436 INHERIT (to_remove_exec_catchpoint
, t
);
437 INHERIT (to_reported_exec_events_per_exec_call
, t
);
438 INHERIT (to_has_exited
, t
);
439 INHERIT (to_mourn_inferior
, t
);
440 INHERIT (to_can_run
, t
);
441 INHERIT (to_notice_signals
, t
);
442 INHERIT (to_thread_alive
, t
);
443 INHERIT (to_find_new_threads
, t
);
444 INHERIT (to_pid_to_str
, t
);
445 INHERIT (to_extra_thread_info
, t
);
446 INHERIT (to_stop
, t
);
447 /* Do not inherit to_xfer_partial. */
448 INHERIT (to_rcmd
, t
);
449 INHERIT (to_enable_exception_callback
, t
);
450 INHERIT (to_get_current_exception_event
, t
);
451 INHERIT (to_pid_to_exec_file
, 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
,
507 de_fault (to_store_registers
,
510 de_fault (to_prepare_to_store
,
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 /* Mark OPS as a running target. This reverses the effect
656 of target_mark_exited. */
659 target_mark_running (struct target_ops
*ops
)
661 struct target_ops
*t
;
663 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
667 internal_error (__FILE__
, __LINE__
,
668 "Attempted to mark unpushed target \"%s\" as running",
671 ops
->to_has_execution
= 1;
672 ops
->to_has_all_memory
= 1;
673 ops
->to_has_memory
= 1;
674 ops
->to_has_stack
= 1;
675 ops
->to_has_registers
= 1;
677 update_current_target ();
680 /* Mark OPS as a non-running target. This reverses the effect
681 of target_mark_running. */
684 target_mark_exited (struct target_ops
*ops
)
686 struct target_ops
*t
;
688 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
692 internal_error (__FILE__
, __LINE__
,
693 "Attempted to mark unpushed target \"%s\" as running",
696 ops
->to_has_execution
= 0;
697 ops
->to_has_all_memory
= 0;
698 ops
->to_has_memory
= 0;
699 ops
->to_has_stack
= 0;
700 ops
->to_has_registers
= 0;
702 update_current_target ();
705 /* Push a new target type into the stack of the existing target accessors,
706 possibly superseding some of the existing accessors.
708 Result is zero if the pushed target ended up on top of the stack,
709 nonzero if at least one target is on top of it.
711 Rather than allow an empty stack, we always have the dummy target at
712 the bottom stratum, so we can call the function vectors without
716 push_target (struct target_ops
*t
)
718 struct target_ops
**cur
;
720 /* Check magic number. If wrong, it probably means someone changed
721 the struct definition, but not all the places that initialize one. */
722 if (t
->to_magic
!= OPS_MAGIC
)
724 fprintf_unfiltered (gdb_stderr
,
725 "Magic number of %s target struct wrong\n",
727 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
730 /* Find the proper stratum to install this target in. */
731 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
733 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
737 /* If there's already targets at this stratum, remove them. */
738 /* FIXME: cagney/2003-10-15: I think this should be popping all
739 targets to CUR, and not just those at this stratum level. */
740 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
742 /* There's already something at this stratum level. Close it,
743 and un-hook it from the stack. */
744 struct target_ops
*tmp
= (*cur
);
745 (*cur
) = (*cur
)->beneath
;
747 target_close (tmp
, 0);
750 /* We have removed all targets in our stratum, now add the new one. */
754 update_current_target ();
757 setup_target_debug ();
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;
921 /* Small for testing. */
922 buffer_allocated
= 4;
923 buffer
= xmalloc (buffer_allocated
);
930 tlen
= MIN (len
, 4 - (memaddr
& 3));
931 offset
= memaddr
& 3;
933 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
936 /* The transfer request might have crossed the boundary to an
937 unallocated region of memory. Retry the transfer, requesting
941 errcode
= target_read_memory (memaddr
, buf
, 1);
946 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
949 bytes
= bufptr
- buffer
;
950 buffer_allocated
*= 2;
951 buffer
= xrealloc (buffer
, buffer_allocated
);
952 bufptr
= buffer
+ bytes
;
955 for (i
= 0; i
< tlen
; i
++)
957 *bufptr
++ = buf
[i
+ offset
];
958 if (buf
[i
+ offset
] == '\000')
960 nbytes_read
+= i
+ 1;
977 /* Find a section containing ADDR. */
978 struct section_table
*
979 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
981 struct section_table
*secp
;
982 for (secp
= target
->to_sections
;
983 secp
< target
->to_sections_end
;
986 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
992 /* Perform a partial memory transfer. The arguments and return
993 value are just as for target_xfer_partial. */
996 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
997 ULONGEST memaddr
, LONGEST len
)
1001 struct mem_region
*region
;
1003 /* Zero length requests are ok and require no work. */
1007 /* Try the executable file, if "trust-readonly-sections" is set. */
1008 if (readbuf
!= NULL
&& trust_readonly
)
1010 struct section_table
*secp
;
1012 secp
= target_section_by_addr (ops
, memaddr
);
1014 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1016 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1019 /* Try GDB's internal data cache. */
1020 region
= lookup_mem_region (memaddr
);
1021 /* region->hi == 0 means there's no upper bound. */
1022 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1025 reg_len
= region
->hi
- memaddr
;
1027 switch (region
->attrib
.mode
)
1030 if (writebuf
!= NULL
)
1035 if (readbuf
!= NULL
)
1040 /* We only support writing to flash during "load" for now. */
1041 if (writebuf
!= NULL
)
1042 error (_("Writing to flash memory forbidden in this context"));
1049 if (region
->attrib
.cache
)
1051 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1052 memory request will start back at current_target. */
1053 if (readbuf
!= NULL
)
1054 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1057 /* FIXME drow/2006-08-09: If we're going to preserve const
1058 correctness dcache_xfer_memory should take readbuf and
1060 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1069 /* If none of those methods found the memory we wanted, fall back
1070 to a target partial transfer. Normally a single call to
1071 to_xfer_partial is enough; if it doesn't recognize an object
1072 it will call the to_xfer_partial of the next target down.
1073 But for memory this won't do. Memory is the only target
1074 object which can be read from more than one valid target.
1075 A core file, for instance, could have some of memory but
1076 delegate other bits to the target below it. So, we must
1077 manually try all targets. */
1081 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1082 readbuf
, writebuf
, memaddr
, reg_len
);
1088 while (ops
!= NULL
);
1090 /* If we still haven't got anything, return the last error. We
1096 target_xfer_partial (struct target_ops
*ops
,
1097 enum target_object object
, const char *annex
,
1098 void *readbuf
, const void *writebuf
,
1099 ULONGEST offset
, LONGEST len
)
1103 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1105 /* If this is a memory transfer, let the memory-specific code
1106 have a look at it instead. Memory transfers are more
1108 if (object
== TARGET_OBJECT_MEMORY
)
1109 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1112 enum target_object raw_object
= object
;
1114 /* If this is a raw memory transfer, request the normal
1115 memory object from other layers. */
1116 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1117 raw_object
= TARGET_OBJECT_MEMORY
;
1119 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1120 writebuf
, offset
, len
);
1125 const unsigned char *myaddr
= NULL
;
1127 fprintf_unfiltered (gdb_stdlog
,
1128 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1131 (annex
? annex
: "(null)"),
1132 (long) readbuf
, (long) writebuf
,
1133 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1139 if (retval
> 0 && myaddr
!= NULL
)
1143 fputs_unfiltered (", bytes =", gdb_stdlog
);
1144 for (i
= 0; i
< retval
; i
++)
1146 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1148 if (targetdebug
< 2 && i
> 0)
1150 fprintf_unfiltered (gdb_stdlog
, " ...");
1153 fprintf_unfiltered (gdb_stdlog
, "\n");
1156 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1160 fputc_unfiltered ('\n', gdb_stdlog
);
1165 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1166 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1167 if any error occurs.
1169 If an error occurs, no guarantee is made about the contents of the data at
1170 MYADDR. In particular, the caller should not depend upon partial reads
1171 filling the buffer with good data. There is no way for the caller to know
1172 how much good data might have been transfered anyway. Callers that can
1173 deal with partial reads should call target_read (which will retry until
1174 it makes no progress, and then return how much was transferred). */
1177 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1179 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1180 myaddr
, memaddr
, len
) == len
)
1187 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1189 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1190 myaddr
, memaddr
, len
) == len
)
1196 /* Fetch the target's memory map. */
1199 target_memory_map (void)
1201 VEC(mem_region_s
) *result
;
1202 struct mem_region
*last_one
, *this_one
;
1204 struct target_ops
*t
;
1207 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1209 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1210 if (t
->to_memory_map
!= NULL
)
1216 result
= t
->to_memory_map (t
);
1220 qsort (VEC_address (mem_region_s
, result
),
1221 VEC_length (mem_region_s
, result
),
1222 sizeof (struct mem_region
), mem_region_cmp
);
1224 /* Check that regions do not overlap. Simultaneously assign
1225 a numbering for the "mem" commands to use to refer to
1228 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1230 this_one
->number
= ix
;
1232 if (last_one
&& last_one
->hi
> this_one
->lo
)
1234 warning (_("Overlapping regions in memory map: ignoring"));
1235 VEC_free (mem_region_s
, result
);
1238 last_one
= this_one
;
1245 target_flash_erase (ULONGEST address
, LONGEST length
)
1247 struct target_ops
*t
;
1249 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1250 if (t
->to_flash_erase
!= NULL
)
1253 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1254 paddr (address
), phex (length
, 0));
1255 t
->to_flash_erase (t
, address
, length
);
1263 target_flash_done (void)
1265 struct target_ops
*t
;
1267 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1268 if (t
->to_flash_done
!= NULL
)
1271 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1272 t
->to_flash_done (t
);
1279 #ifndef target_stopped_data_address_p
1281 target_stopped_data_address_p (struct target_ops
*target
)
1283 if (target
->to_stopped_data_address
1284 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1286 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1287 && (debug_target
.to_stopped_data_address
1288 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1295 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1296 struct cmd_list_element
*c
, const char *value
)
1298 fprintf_filtered (file
, _("\
1299 Mode for reading from readonly sections is %s.\n"),
1303 /* More generic transfers. */
1306 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1307 const char *annex
, gdb_byte
*readbuf
,
1308 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1310 if (object
== TARGET_OBJECT_MEMORY
1311 && ops
->deprecated_xfer_memory
!= NULL
)
1312 /* If available, fall back to the target's
1313 "deprecated_xfer_memory" method. */
1317 if (writebuf
!= NULL
)
1319 void *buffer
= xmalloc (len
);
1320 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1321 memcpy (buffer
, writebuf
, len
);
1322 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1323 1/*write*/, NULL
, ops
);
1324 do_cleanups (cleanup
);
1326 if (readbuf
!= NULL
)
1327 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1331 else if (xfered
== 0 && errno
== 0)
1332 /* "deprecated_xfer_memory" uses 0, cross checked against
1333 ERRNO as one indication of an error. */
1338 else if (ops
->beneath
!= NULL
)
1339 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1340 readbuf
, writebuf
, offset
, len
);
1345 /* The xfer_partial handler for the topmost target. Unlike the default,
1346 it does not need to handle memory specially; it just passes all
1347 requests down the stack. */
1350 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1351 const char *annex
, gdb_byte
*readbuf
,
1352 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1354 if (ops
->beneath
!= NULL
)
1355 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1356 readbuf
, writebuf
, offset
, len
);
1361 /* Target vector read/write partial wrapper functions.
1363 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1364 (inbuf, outbuf)", instead of separate read/write methods, make life
1368 target_read_partial (struct target_ops
*ops
,
1369 enum target_object object
,
1370 const char *annex
, gdb_byte
*buf
,
1371 ULONGEST offset
, LONGEST len
)
1373 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1377 target_write_partial (struct target_ops
*ops
,
1378 enum target_object object
,
1379 const char *annex
, const gdb_byte
*buf
,
1380 ULONGEST offset
, LONGEST len
)
1382 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1385 /* Wrappers to perform the full transfer. */
1387 target_read (struct target_ops
*ops
,
1388 enum target_object object
,
1389 const char *annex
, gdb_byte
*buf
,
1390 ULONGEST offset
, LONGEST len
)
1393 while (xfered
< len
)
1395 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1396 (gdb_byte
*) buf
+ xfered
,
1397 offset
+ xfered
, len
- xfered
);
1398 /* Call an observer, notifying them of the xfer progress? */
1409 /* An alternative to target_write with progress callbacks. */
1412 target_write_with_progress (struct target_ops
*ops
,
1413 enum target_object object
,
1414 const char *annex
, const gdb_byte
*buf
,
1415 ULONGEST offset
, LONGEST len
,
1416 void (*progress
) (ULONGEST
, void *), void *baton
)
1420 /* Give the progress callback a chance to set up. */
1422 (*progress
) (0, baton
);
1424 while (xfered
< len
)
1426 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1427 (gdb_byte
*) buf
+ xfered
,
1428 offset
+ xfered
, len
- xfered
);
1436 (*progress
) (xfer
, baton
);
1445 target_write (struct target_ops
*ops
,
1446 enum target_object object
,
1447 const char *annex
, const gdb_byte
*buf
,
1448 ULONGEST offset
, LONGEST len
)
1450 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1454 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1455 the size of the transferred data. PADDING additional bytes are
1456 available in *BUF_P. This is a helper function for
1457 target_read_alloc; see the declaration of that function for more
1461 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1462 const char *annex
, gdb_byte
**buf_p
, int padding
)
1464 size_t buf_alloc
, buf_pos
;
1468 /* This function does not have a length parameter; it reads the
1469 entire OBJECT). Also, it doesn't support objects fetched partly
1470 from one target and partly from another (in a different stratum,
1471 e.g. a core file and an executable). Both reasons make it
1472 unsuitable for reading memory. */
1473 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1475 /* Start by reading up to 4K at a time. The target will throttle
1476 this number down if necessary. */
1478 buf
= xmalloc (buf_alloc
);
1482 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1483 buf_pos
, buf_alloc
- buf_pos
- padding
);
1486 /* An error occurred. */
1492 /* Read all there was. */
1502 /* If the buffer is filling up, expand it. */
1503 if (buf_alloc
< buf_pos
* 2)
1506 buf
= xrealloc (buf
, buf_alloc
);
1513 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1514 the size of the transferred data. See the declaration in "target.h"
1515 function for more information about the return value. */
1518 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1519 const char *annex
, gdb_byte
**buf_p
)
1521 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1524 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1525 returned as a string, allocated using xmalloc. If an error occurs
1526 or the transfer is unsupported, NULL is returned. Empty objects
1527 are returned as allocated but empty strings. A warning is issued
1528 if the result contains any embedded NUL bytes. */
1531 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1535 LONGEST transferred
;
1537 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1539 if (transferred
< 0)
1542 if (transferred
== 0)
1543 return xstrdup ("");
1545 buffer
[transferred
] = 0;
1546 if (strlen (buffer
) < transferred
)
1547 warning (_("target object %d, annex %s, "
1548 "contained unexpected null characters"),
1549 (int) object
, annex
? annex
: "(none)");
1551 return (char *) buffer
;
1554 /* Memory transfer methods. */
1557 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1560 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1562 memory_error (EIO
, addr
);
1566 get_target_memory_unsigned (struct target_ops
*ops
,
1567 CORE_ADDR addr
, int len
)
1569 gdb_byte buf
[sizeof (ULONGEST
)];
1571 gdb_assert (len
<= sizeof (buf
));
1572 get_target_memory (ops
, addr
, buf
, len
);
1573 return extract_unsigned_integer (buf
, len
);
1577 target_info (char *args
, int from_tty
)
1579 struct target_ops
*t
;
1580 int has_all_mem
= 0;
1582 if (symfile_objfile
!= NULL
)
1583 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1585 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1587 if (!t
->to_has_memory
)
1590 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1593 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1594 printf_unfiltered ("%s:\n", t
->to_longname
);
1595 (t
->to_files_info
) (t
);
1596 has_all_mem
= t
->to_has_all_memory
;
1600 /* This function is called before any new inferior is created, e.g.
1601 by running a program, attaching, or connecting to a target.
1602 It cleans up any state from previous invocations which might
1603 change between runs. This is a subset of what target_preopen
1604 resets (things which might change between targets). */
1607 target_pre_inferior (int from_tty
)
1609 invalidate_target_mem_regions ();
1611 target_clear_description ();
1614 /* This is to be called by the open routine before it does
1618 target_preopen (int from_tty
)
1622 if (target_has_execution
)
1625 || query (_("A program is being debugged already. Kill it? ")))
1628 error (_("Program not killed."));
1631 /* Calling target_kill may remove the target from the stack. But if
1632 it doesn't (which seems like a win for UDI), remove it now. */
1634 if (target_has_execution
)
1637 target_pre_inferior (from_tty
);
1640 /* Detach a target after doing deferred register stores. */
1643 target_detach (char *args
, int from_tty
)
1645 (current_target
.to_detach
) (args
, from_tty
);
1649 target_disconnect (char *args
, int from_tty
)
1651 struct target_ops
*t
;
1653 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1654 if (t
->to_disconnect
!= NULL
)
1657 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1659 t
->to_disconnect (t
, args
, from_tty
);
1667 target_async_mask (int mask
)
1669 int saved_async_masked_status
= target_async_mask_value
;
1670 target_async_mask_value
= mask
;
1671 return saved_async_masked_status
;
1674 /* Look through the list of possible targets for a target that can
1678 target_follow_fork (int follow_child
)
1680 struct target_ops
*t
;
1682 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1684 if (t
->to_follow_fork
!= NULL
)
1686 int retval
= t
->to_follow_fork (t
, follow_child
);
1688 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1689 follow_child
, retval
);
1694 /* Some target returned a fork event, but did not know how to follow it. */
1695 internal_error (__FILE__
, __LINE__
,
1696 "could not find a target to follow fork");
1699 /* Look for a target which can describe architectural features, starting
1700 from TARGET. If we find one, return its description. */
1702 const struct target_desc
*
1703 target_read_description (struct target_ops
*target
)
1705 struct target_ops
*t
;
1707 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1708 if (t
->to_read_description
!= NULL
)
1710 const struct target_desc
*tdesc
;
1712 tdesc
= t
->to_read_description (t
);
1720 /* Look through the list of possible targets for a target that can
1721 execute a run or attach command without any other data. This is
1722 used to locate the default process stratum.
1724 Result is always valid (error() is called for errors). */
1726 static struct target_ops
*
1727 find_default_run_target (char *do_mesg
)
1729 struct target_ops
**t
;
1730 struct target_ops
*runable
= NULL
;
1735 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1738 if ((*t
)->to_can_run
&& target_can_run (*t
))
1746 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1752 find_default_attach (char *args
, int from_tty
)
1754 struct target_ops
*t
;
1756 t
= find_default_run_target ("attach");
1757 (t
->to_attach
) (args
, from_tty
);
1762 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1765 struct target_ops
*t
;
1767 t
= find_default_run_target ("run");
1768 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1773 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1775 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1791 return_minus_one (void)
1797 * Resize the to_sections pointer. Also make sure that anyone that
1798 * was holding on to an old value of it gets updated.
1799 * Returns the old size.
1803 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1805 struct target_ops
**t
;
1806 struct section_table
*old_value
;
1809 old_value
= target
->to_sections
;
1811 if (target
->to_sections
)
1813 old_count
= target
->to_sections_end
- target
->to_sections
;
1814 target
->to_sections
= (struct section_table
*)
1815 xrealloc ((char *) target
->to_sections
,
1816 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1821 target
->to_sections
= (struct section_table
*)
1822 xmalloc ((sizeof (struct section_table
)) * num_added
);
1824 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1826 /* Check to see if anyone else was pointing to this structure.
1827 If old_value was null, then no one was. */
1831 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1834 if ((*t
)->to_sections
== old_value
)
1836 (*t
)->to_sections
= target
->to_sections
;
1837 (*t
)->to_sections_end
= target
->to_sections_end
;
1840 /* There is a flattened view of the target stack in current_target,
1841 so its to_sections pointer might also need updating. */
1842 if (current_target
.to_sections
== old_value
)
1844 current_target
.to_sections
= target
->to_sections
;
1845 current_target
.to_sections_end
= target
->to_sections_end
;
1853 /* Remove all target sections taken from ABFD.
1855 Scan the current target stack for targets whose section tables
1856 refer to sections from BFD, and remove those sections. We use this
1857 when we notice that the inferior has unloaded a shared object, for
1860 remove_target_sections (bfd
*abfd
)
1862 struct target_ops
**t
;
1864 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1866 struct section_table
*src
, *dest
;
1868 dest
= (*t
)->to_sections
;
1869 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1870 if (src
->bfd
!= abfd
)
1872 /* Keep this section. */
1873 if (dest
< src
) *dest
= *src
;
1877 /* If we've dropped any sections, resize the section table. */
1879 target_resize_to_sections (*t
, dest
- src
);
1886 /* Find a single runnable target in the stack and return it. If for
1887 some reason there is more than one, return NULL. */
1890 find_run_target (void)
1892 struct target_ops
**t
;
1893 struct target_ops
*runable
= NULL
;
1898 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1900 if ((*t
)->to_can_run
&& target_can_run (*t
))
1907 return (count
== 1 ? runable
: NULL
);
1910 /* Find a single core_stratum target in the list of targets and return it.
1911 If for some reason there is more than one, return NULL. */
1914 find_core_target (void)
1916 struct target_ops
**t
;
1917 struct target_ops
*runable
= NULL
;
1922 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1925 if ((*t
)->to_stratum
== core_stratum
)
1932 return (count
== 1 ? runable
: NULL
);
1936 * Find the next target down the stack from the specified target.
1940 find_target_beneath (struct target_ops
*t
)
1946 /* The inferior process has died. Long live the inferior! */
1949 generic_mourn_inferior (void)
1951 extern int show_breakpoint_hit_counts
;
1953 inferior_ptid
= null_ptid
;
1955 breakpoint_init_inferior (inf_exited
);
1956 registers_changed ();
1958 reopen_exec_file ();
1959 reinit_frame_cache ();
1961 /* It is confusing to the user for ignore counts to stick around
1962 from previous runs of the inferior. So clear them. */
1963 /* However, it is more confusing for the ignore counts to disappear when
1964 using hit counts. So don't clear them if we're counting hits. */
1965 if (!show_breakpoint_hit_counts
)
1966 breakpoint_clear_ignore_counts ();
1968 if (deprecated_detach_hook
)
1969 deprecated_detach_hook ();
1972 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1973 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1974 translation of that in OURSTATUS. */
1976 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1978 #ifdef CHILD_SPECIAL_WAITSTATUS
1979 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1980 if it wants to deal with hoststatus. */
1981 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1985 if (WIFEXITED (hoststatus
))
1987 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1988 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1990 else if (!WIFSTOPPED (hoststatus
))
1992 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1993 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1997 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1998 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2002 /* Returns zero to leave the inferior alone, one to interrupt it. */
2003 int (*target_activity_function
) (void);
2004 int target_activity_fd
;
2006 /* Convert a normal process ID to a string. Returns the string in a
2010 normal_pid_to_str (ptid_t ptid
)
2012 static char buf
[32];
2014 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2018 /* Error-catcher for target_find_memory_regions */
2019 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2021 error (_("No target."));
2025 /* Error-catcher for target_make_corefile_notes */
2026 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2028 error (_("No target."));
2032 /* Set up the handful of non-empty slots needed by the dummy target
2036 init_dummy_target (void)
2038 dummy_target
.to_shortname
= "None";
2039 dummy_target
.to_longname
= "None";
2040 dummy_target
.to_doc
= "";
2041 dummy_target
.to_attach
= find_default_attach
;
2042 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2043 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2044 dummy_target
.to_stratum
= dummy_stratum
;
2045 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2046 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2047 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2048 dummy_target
.to_magic
= OPS_MAGIC
;
2052 debug_to_open (char *args
, int from_tty
)
2054 debug_target
.to_open (args
, from_tty
);
2056 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2060 debug_to_close (int quitting
)
2062 target_close (&debug_target
, quitting
);
2063 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2067 target_close (struct target_ops
*targ
, int quitting
)
2069 if (targ
->to_xclose
!= NULL
)
2070 targ
->to_xclose (targ
, quitting
);
2071 else if (targ
->to_close
!= NULL
)
2072 targ
->to_close (quitting
);
2076 debug_to_attach (char *args
, int from_tty
)
2078 debug_target
.to_attach (args
, from_tty
);
2080 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2085 debug_to_post_attach (int pid
)
2087 debug_target
.to_post_attach (pid
);
2089 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2093 debug_to_detach (char *args
, int from_tty
)
2095 debug_target
.to_detach (args
, from_tty
);
2097 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2101 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2103 debug_target
.to_resume (ptid
, step
, siggnal
);
2105 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2106 step
? "step" : "continue",
2107 target_signal_to_name (siggnal
));
2111 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2115 retval
= debug_target
.to_wait (ptid
, status
);
2117 fprintf_unfiltered (gdb_stdlog
,
2118 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2120 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2121 switch (status
->kind
)
2123 case TARGET_WAITKIND_EXITED
:
2124 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2125 status
->value
.integer
);
2127 case TARGET_WAITKIND_STOPPED
:
2128 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2129 target_signal_to_name (status
->value
.sig
));
2131 case TARGET_WAITKIND_SIGNALLED
:
2132 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2133 target_signal_to_name (status
->value
.sig
));
2135 case TARGET_WAITKIND_LOADED
:
2136 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2138 case TARGET_WAITKIND_FORKED
:
2139 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2141 case TARGET_WAITKIND_VFORKED
:
2142 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2144 case TARGET_WAITKIND_EXECD
:
2145 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2147 case TARGET_WAITKIND_SPURIOUS
:
2148 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2151 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2159 debug_print_register (const char * func
, int regno
)
2161 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2162 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
2163 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
2164 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
2166 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2170 unsigned char buf
[MAX_REGISTER_SIZE
];
2171 deprecated_read_register_gen (regno
, buf
);
2172 fprintf_unfiltered (gdb_stdlog
, " = ");
2173 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
2175 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2177 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
2179 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2180 paddr_nz (read_register (regno
)),
2181 paddr_d (read_register (regno
)));
2184 fprintf_unfiltered (gdb_stdlog
, "\n");
2188 debug_to_fetch_registers (int regno
)
2190 debug_target
.to_fetch_registers (regno
);
2191 debug_print_register ("target_fetch_registers", regno
);
2195 debug_to_store_registers (int regno
)
2197 debug_target
.to_store_registers (regno
);
2198 debug_print_register ("target_store_registers", regno
);
2199 fprintf_unfiltered (gdb_stdlog
, "\n");
2203 debug_to_prepare_to_store (void)
2205 debug_target
.to_prepare_to_store ();
2207 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2211 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2212 int write
, struct mem_attrib
*attrib
,
2213 struct target_ops
*target
)
2217 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2220 fprintf_unfiltered (gdb_stdlog
,
2221 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2222 (unsigned int) memaddr
, /* possable truncate long long */
2223 len
, write
? "write" : "read", retval
);
2229 fputs_unfiltered (", bytes =", gdb_stdlog
);
2230 for (i
= 0; i
< retval
; i
++)
2232 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2234 if (targetdebug
< 2 && i
> 0)
2236 fprintf_unfiltered (gdb_stdlog
, " ...");
2239 fprintf_unfiltered (gdb_stdlog
, "\n");
2242 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2246 fputc_unfiltered ('\n', gdb_stdlog
);
2252 debug_to_files_info (struct target_ops
*target
)
2254 debug_target
.to_files_info (target
);
2256 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2260 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2264 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2266 fprintf_unfiltered (gdb_stdlog
,
2267 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2268 (unsigned long) bp_tgt
->placed_address
,
2269 (unsigned long) retval
);
2274 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2278 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2280 fprintf_unfiltered (gdb_stdlog
,
2281 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2282 (unsigned long) bp_tgt
->placed_address
,
2283 (unsigned long) retval
);
2288 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2292 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2294 fprintf_unfiltered (gdb_stdlog
,
2295 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2296 (unsigned long) type
,
2297 (unsigned long) cnt
,
2298 (unsigned long) from_tty
,
2299 (unsigned long) retval
);
2304 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2308 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2310 fprintf_unfiltered (gdb_stdlog
,
2311 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2312 (unsigned long) addr
,
2313 (unsigned long) len
,
2314 (unsigned long) retval
);
2319 debug_to_stopped_by_watchpoint (void)
2323 retval
= debug_target
.to_stopped_by_watchpoint ();
2325 fprintf_unfiltered (gdb_stdlog
,
2326 "STOPPED_BY_WATCHPOINT () = %ld\n",
2327 (unsigned long) retval
);
2332 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2336 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2338 fprintf_unfiltered (gdb_stdlog
,
2339 "target_stopped_data_address ([0x%lx]) = %ld\n",
2340 (unsigned long)*addr
,
2341 (unsigned long)retval
);
2346 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2350 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2352 fprintf_unfiltered (gdb_stdlog
,
2353 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2354 (unsigned long) bp_tgt
->placed_address
,
2355 (unsigned long) retval
);
2360 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2364 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2366 fprintf_unfiltered (gdb_stdlog
,
2367 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2368 (unsigned long) bp_tgt
->placed_address
,
2369 (unsigned long) retval
);
2374 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2378 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2380 fprintf_unfiltered (gdb_stdlog
,
2381 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2382 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2387 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2391 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2393 fprintf_unfiltered (gdb_stdlog
,
2394 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2395 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2400 debug_to_terminal_init (void)
2402 debug_target
.to_terminal_init ();
2404 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2408 debug_to_terminal_inferior (void)
2410 debug_target
.to_terminal_inferior ();
2412 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2416 debug_to_terminal_ours_for_output (void)
2418 debug_target
.to_terminal_ours_for_output ();
2420 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2424 debug_to_terminal_ours (void)
2426 debug_target
.to_terminal_ours ();
2428 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2432 debug_to_terminal_save_ours (void)
2434 debug_target
.to_terminal_save_ours ();
2436 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2440 debug_to_terminal_info (char *arg
, int from_tty
)
2442 debug_target
.to_terminal_info (arg
, from_tty
);
2444 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2449 debug_to_kill (void)
2451 debug_target
.to_kill ();
2453 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2457 debug_to_load (char *args
, int from_tty
)
2459 debug_target
.to_load (args
, from_tty
);
2461 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2465 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2469 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2471 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2477 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2480 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2482 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2483 exec_file
, args
, from_tty
);
2487 debug_to_post_startup_inferior (ptid_t ptid
)
2489 debug_target
.to_post_startup_inferior (ptid
);
2491 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2496 debug_to_acknowledge_created_inferior (int pid
)
2498 debug_target
.to_acknowledge_created_inferior (pid
);
2500 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2505 debug_to_insert_fork_catchpoint (int pid
)
2507 debug_target
.to_insert_fork_catchpoint (pid
);
2509 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2514 debug_to_remove_fork_catchpoint (int pid
)
2518 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2520 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2527 debug_to_insert_vfork_catchpoint (int pid
)
2529 debug_target
.to_insert_vfork_catchpoint (pid
);
2531 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2536 debug_to_remove_vfork_catchpoint (int pid
)
2540 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2542 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2549 debug_to_insert_exec_catchpoint (int pid
)
2551 debug_target
.to_insert_exec_catchpoint (pid
);
2553 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2558 debug_to_remove_exec_catchpoint (int pid
)
2562 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2564 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2571 debug_to_reported_exec_events_per_exec_call (void)
2573 int reported_exec_events
;
2575 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2577 fprintf_unfiltered (gdb_stdlog
,
2578 "target_reported_exec_events_per_exec_call () = %d\n",
2579 reported_exec_events
);
2581 return reported_exec_events
;
2585 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2589 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2591 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2592 pid
, wait_status
, *exit_status
, has_exited
);
2598 debug_to_mourn_inferior (void)
2600 debug_target
.to_mourn_inferior ();
2602 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2606 debug_to_can_run (void)
2610 retval
= debug_target
.to_can_run ();
2612 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2618 debug_to_notice_signals (ptid_t ptid
)
2620 debug_target
.to_notice_signals (ptid
);
2622 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2627 debug_to_thread_alive (ptid_t ptid
)
2631 retval
= debug_target
.to_thread_alive (ptid
);
2633 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2634 PIDGET (ptid
), retval
);
2640 debug_to_find_new_threads (void)
2642 debug_target
.to_find_new_threads ();
2644 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2648 debug_to_stop (void)
2650 debug_target
.to_stop ();
2652 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2656 debug_to_rcmd (char *command
,
2657 struct ui_file
*outbuf
)
2659 debug_target
.to_rcmd (command
, outbuf
);
2660 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2663 static struct symtab_and_line
*
2664 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2666 struct symtab_and_line
*result
;
2667 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2668 fprintf_unfiltered (gdb_stdlog
,
2669 "target get_exception_callback_sal (%d, %d)\n",
2674 static struct exception_event_record
*
2675 debug_to_get_current_exception_event (void)
2677 struct exception_event_record
*result
;
2678 result
= debug_target
.to_get_current_exception_event ();
2679 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2684 debug_to_pid_to_exec_file (int pid
)
2688 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2690 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2697 setup_target_debug (void)
2699 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2701 current_target
.to_open
= debug_to_open
;
2702 current_target
.to_close
= debug_to_close
;
2703 current_target
.to_attach
= debug_to_attach
;
2704 current_target
.to_post_attach
= debug_to_post_attach
;
2705 current_target
.to_detach
= debug_to_detach
;
2706 current_target
.to_resume
= debug_to_resume
;
2707 current_target
.to_wait
= debug_to_wait
;
2708 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2709 current_target
.to_store_registers
= debug_to_store_registers
;
2710 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2711 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2712 current_target
.to_files_info
= debug_to_files_info
;
2713 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2714 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2715 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2716 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2717 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2718 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2719 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2720 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2721 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2722 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2723 current_target
.to_terminal_init
= debug_to_terminal_init
;
2724 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2725 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2726 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2727 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2728 current_target
.to_terminal_info
= debug_to_terminal_info
;
2729 current_target
.to_kill
= debug_to_kill
;
2730 current_target
.to_load
= debug_to_load
;
2731 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2732 current_target
.to_create_inferior
= debug_to_create_inferior
;
2733 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2734 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2735 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2736 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2737 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2738 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2739 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2740 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2741 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2742 current_target
.to_has_exited
= debug_to_has_exited
;
2743 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2744 current_target
.to_can_run
= debug_to_can_run
;
2745 current_target
.to_notice_signals
= debug_to_notice_signals
;
2746 current_target
.to_thread_alive
= debug_to_thread_alive
;
2747 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2748 current_target
.to_stop
= debug_to_stop
;
2749 current_target
.to_rcmd
= debug_to_rcmd
;
2750 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2751 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2752 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2756 static char targ_desc
[] =
2757 "Names of targets and files being debugged.\n\
2758 Shows the entire stack of targets currently in use (including the exec-file,\n\
2759 core-file, and process, if any), as well as the symbol file name.";
2762 do_monitor_command (char *cmd
,
2765 if ((current_target
.to_rcmd
2766 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2767 || (current_target
.to_rcmd
== debug_to_rcmd
2768 && (debug_target
.to_rcmd
2769 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2770 error (_("\"monitor\" command not supported by this target."));
2771 target_rcmd (cmd
, gdb_stdtarg
);
2774 /* Print the name of each layers of our target stack. */
2777 maintenance_print_target_stack (char *cmd
, int from_tty
)
2779 struct target_ops
*t
;
2781 printf_filtered (_("The current target stack is:\n"));
2783 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2785 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
2790 initialize_targets (void)
2792 init_dummy_target ();
2793 push_target (&dummy_target
);
2795 add_info ("target", target_info
, targ_desc
);
2796 add_info ("files", target_info
, targ_desc
);
2798 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2799 Set target debugging."), _("\
2800 Show target debugging."), _("\
2801 When non-zero, target debugging is enabled. Higher numbers are more\n\
2802 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2806 &setdebuglist
, &showdebuglist
);
2808 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2809 &trust_readonly
, _("\
2810 Set mode for reading from readonly sections."), _("\
2811 Show mode for reading from readonly sections."), _("\
2812 When this mode is on, memory reads from readonly sections (such as .text)\n\
2813 will be read from the object file instead of from the target. This will\n\
2814 result in significant performance improvement for remote targets."),
2816 show_trust_readonly
,
2817 &setlist
, &showlist
);
2819 add_com ("monitor", class_obscure
, do_monitor_command
,
2820 _("Send a command to the remote monitor (remote targets only)."));
2822 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
2823 _("Print the name of each layer of the internal target stack."),
2824 &maintenanceprintlist
);
2826 target_dcache
= dcache_init ();