1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
38 #include "gdb_assert.h"
40 #include "exceptions.h"
41 #include "target-descriptions.h"
43 static void target_info (char *, int);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
53 static int nosymbol (char *, CORE_ADDR
*);
55 static void tcomplain (void) ATTR_NORETURN
;
57 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
74 enum target_object object
,
75 const char *annex
, gdb_byte
*readbuf
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, LONGEST len
);
79 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
80 enum target_object object
,
81 const char *annex
, gdb_byte
*readbuf
,
82 const gdb_byte
*writebuf
,
83 ULONGEST offset
, LONGEST len
);
85 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
86 enum target_object object
,
88 void *readbuf
, const void *writebuf
,
89 ULONGEST offset
, LONGEST len
);
91 static void init_dummy_target (void);
93 static struct target_ops debug_target
;
95 static void debug_to_open (char *, int);
97 static void debug_to_close (int);
99 static void debug_to_attach (char *, int);
101 static void debug_to_detach (char *, int);
103 static void debug_to_resume (ptid_t
, int, enum target_signal
);
105 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
107 static void debug_to_fetch_registers (struct regcache
*, int);
109 static void debug_to_store_registers (struct regcache
*, int);
111 static void debug_to_prepare_to_store (struct regcache
*);
113 static void debug_to_files_info (struct target_ops
*);
115 static int debug_to_insert_breakpoint (struct bp_target_info
*);
117 static int debug_to_remove_breakpoint (struct bp_target_info
*);
119 static int debug_to_can_use_hw_breakpoint (int, int, int);
121 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
123 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
125 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_stopped_by_watchpoint (void);
131 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
133 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_terminal_info (char *, int);
147 static void debug_to_kill (void);
149 static void debug_to_load (char *, int);
151 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t
);
159 static int debug_to_thread_alive (ptid_t
);
161 static void debug_to_stop (void);
163 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
164 wierd and mysterious ways. Putting the variable here lets those
165 wierd and mysterious ways keep building while they are being
166 converted to the inferior inheritance structure. */
167 struct target_ops deprecated_child_ops
;
169 /* Pointer to array of target architecture structures; the size of the
170 array; the current index into the array; the allocated size of the
172 struct target_ops
**target_structs
;
173 unsigned target_struct_size
;
174 unsigned target_struct_index
;
175 unsigned target_struct_allocsize
;
176 #define DEFAULT_ALLOCSIZE 10
178 /* The initial current target, so that there is always a semi-valid
181 static struct target_ops dummy_target
;
183 /* Top of target stack. */
185 static struct target_ops
*target_stack
;
187 /* The target structure we are currently using to talk to a process
188 or file or whatever "inferior" we have. */
190 struct target_ops current_target
;
192 /* Command list for target. */
194 static struct cmd_list_element
*targetlist
= NULL
;
196 /* Nonzero if we are debugging an attached outside process
197 rather than an inferior. */
201 /* Nonzero if we should trust readonly sections from the
202 executable when reading memory. */
204 static int trust_readonly
= 0;
206 /* Non-zero if we want to see trace of target level stuff. */
208 static int targetdebug
= 0;
210 show_targetdebug (struct ui_file
*file
, int from_tty
,
211 struct cmd_list_element
*c
, const char *value
)
213 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
216 static void setup_target_debug (void);
218 DCACHE
*target_dcache
;
220 /* The user just typed 'target' without the name of a target. */
223 target_command (char *arg
, int from_tty
)
225 fputs_filtered ("Argument required (target name). Try `help target'\n",
229 /* Add a possible target architecture to the list. */
232 add_target (struct target_ops
*t
)
234 /* Provide default values for all "must have" methods. */
235 if (t
->to_xfer_partial
== NULL
)
236 t
->to_xfer_partial
= default_xfer_partial
;
240 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
241 target_structs
= (struct target_ops
**) xmalloc
242 (target_struct_allocsize
* sizeof (*target_structs
));
244 if (target_struct_size
>= target_struct_allocsize
)
246 target_struct_allocsize
*= 2;
247 target_structs
= (struct target_ops
**)
248 xrealloc ((char *) target_structs
,
249 target_struct_allocsize
* sizeof (*target_structs
));
251 target_structs
[target_struct_size
++] = t
;
253 if (targetlist
== NULL
)
254 add_prefix_cmd ("target", class_run
, target_command
, _("\
255 Connect to a target machine or process.\n\
256 The first argument is the type or protocol of the target machine.\n\
257 Remaining arguments are interpreted by the target protocol. For more\n\
258 information on the arguments for a particular protocol, type\n\
259 `help target ' followed by the protocol name."),
260 &targetlist
, "target ", 0, &cmdlist
);
261 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
272 target_load (char *arg
, int from_tty
)
274 dcache_invalidate (target_dcache
);
275 (*current_target
.to_load
) (arg
, from_tty
);
279 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
280 struct target_ops
*t
)
282 errno
= EIO
; /* Can't read/write this location */
283 return 0; /* No bytes handled */
289 error (_("You can't do that when your target is `%s'"),
290 current_target
.to_shortname
);
296 error (_("You can't do that without a process to debug."));
300 nosymbol (char *name
, CORE_ADDR
*addrp
)
302 return 1; /* Symbol does not exist in target env */
306 nosupport_runtime (void)
308 if (ptid_equal (inferior_ptid
, null_ptid
))
311 error (_("No run-time support for this"));
316 default_terminal_info (char *args
, int from_tty
)
318 printf_unfiltered (_("No saved terminal information.\n"));
321 /* This is the default target_create_inferior and target_attach function.
322 If the current target is executing, it asks whether to kill it off.
323 If this function returns without calling error(), it has killed off
324 the target, and the operation should be attempted. */
327 kill_or_be_killed (int from_tty
)
329 if (target_has_execution
)
331 printf_unfiltered (_("You are already running a program:\n"));
332 target_files_info ();
333 if (query ("Kill it? "))
336 if (target_has_execution
)
337 error (_("Killing the program did not help."));
342 error (_("Program not killed."));
349 maybe_kill_then_attach (char *args
, int from_tty
)
351 kill_or_be_killed (from_tty
);
352 target_attach (args
, from_tty
);
356 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
359 kill_or_be_killed (0);
360 target_create_inferior (exec
, args
, env
, from_tty
);
363 /* Go through the target stack from top to bottom, copying over zero
364 entries in current_target, then filling in still empty entries. In
365 effect, we are doing class inheritance through the pushed target
368 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
369 is currently implemented, is that it discards any knowledge of
370 which target an inherited method originally belonged to.
371 Consequently, new new target methods should instead explicitly and
372 locally search the target stack for the target that can handle the
376 update_current_target (void)
378 struct target_ops
*t
;
380 /* First, reset current's contents. */
381 memset (¤t_target
, 0, sizeof (current_target
));
383 #define INHERIT(FIELD, TARGET) \
384 if (!current_target.FIELD) \
385 current_target.FIELD = (TARGET)->FIELD
387 for (t
= target_stack
; t
; t
= t
->beneath
)
389 INHERIT (to_shortname
, t
);
390 INHERIT (to_longname
, t
);
392 INHERIT (to_open
, t
);
393 INHERIT (to_close
, t
);
394 INHERIT (to_attach
, t
);
395 INHERIT (to_post_attach
, t
);
396 INHERIT (to_detach
, t
);
397 /* Do not inherit to_disconnect. */
398 INHERIT (to_resume
, t
);
399 INHERIT (to_wait
, t
);
400 INHERIT (to_fetch_registers
, t
);
401 INHERIT (to_store_registers
, t
);
402 INHERIT (to_prepare_to_store
, t
);
403 INHERIT (deprecated_xfer_memory
, t
);
404 INHERIT (to_files_info
, t
);
405 INHERIT (to_insert_breakpoint
, t
);
406 INHERIT (to_remove_breakpoint
, t
);
407 INHERIT (to_can_use_hw_breakpoint
, t
);
408 INHERIT (to_insert_hw_breakpoint
, t
);
409 INHERIT (to_remove_hw_breakpoint
, t
);
410 INHERIT (to_insert_watchpoint
, t
);
411 INHERIT (to_remove_watchpoint
, t
);
412 INHERIT (to_stopped_data_address
, t
);
413 INHERIT (to_stopped_by_watchpoint
, t
);
414 INHERIT (to_have_steppable_watchpoint
, t
);
415 INHERIT (to_have_continuable_watchpoint
, t
);
416 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
417 INHERIT (to_terminal_init
, t
);
418 INHERIT (to_terminal_inferior
, t
);
419 INHERIT (to_terminal_ours_for_output
, t
);
420 INHERIT (to_terminal_ours
, t
);
421 INHERIT (to_terminal_save_ours
, t
);
422 INHERIT (to_terminal_info
, t
);
423 INHERIT (to_kill
, t
);
424 INHERIT (to_load
, t
);
425 INHERIT (to_lookup_symbol
, t
);
426 INHERIT (to_create_inferior
, t
);
427 INHERIT (to_post_startup_inferior
, t
);
428 INHERIT (to_acknowledge_created_inferior
, t
);
429 INHERIT (to_insert_fork_catchpoint
, t
);
430 INHERIT (to_remove_fork_catchpoint
, t
);
431 INHERIT (to_insert_vfork_catchpoint
, t
);
432 INHERIT (to_remove_vfork_catchpoint
, t
);
433 /* Do not inherit to_follow_fork. */
434 INHERIT (to_insert_exec_catchpoint
, t
);
435 INHERIT (to_remove_exec_catchpoint
, t
);
436 INHERIT (to_reported_exec_events_per_exec_call
, t
);
437 INHERIT (to_has_exited
, t
);
438 INHERIT (to_mourn_inferior
, t
);
439 INHERIT (to_can_run
, t
);
440 INHERIT (to_notice_signals
, t
);
441 INHERIT (to_thread_alive
, t
);
442 INHERIT (to_find_new_threads
, t
);
443 INHERIT (to_pid_to_str
, t
);
444 INHERIT (to_extra_thread_info
, t
);
445 INHERIT (to_stop
, t
);
446 /* Do not inherit to_xfer_partial. */
447 INHERIT (to_rcmd
, t
);
448 INHERIT (to_enable_exception_callback
, t
);
449 INHERIT (to_get_current_exception_event
, t
);
450 INHERIT (to_pid_to_exec_file
, t
);
451 INHERIT (to_stratum
, t
);
452 INHERIT (to_has_all_memory
, t
);
453 INHERIT (to_has_memory
, t
);
454 INHERIT (to_has_stack
, t
);
455 INHERIT (to_has_registers
, t
);
456 INHERIT (to_has_execution
, t
);
457 INHERIT (to_has_thread_control
, t
);
458 INHERIT (to_sections
, t
);
459 INHERIT (to_sections_end
, t
);
460 INHERIT (to_can_async_p
, t
);
461 INHERIT (to_is_async_p
, t
);
462 INHERIT (to_async
, t
);
463 INHERIT (to_async_mask_value
, t
);
464 INHERIT (to_find_memory_regions
, t
);
465 INHERIT (to_make_corefile_notes
, t
);
466 INHERIT (to_get_thread_local_address
, t
);
467 /* Do not inherit to_read_description. */
468 INHERIT (to_magic
, t
);
469 /* Do not inherit to_memory_map. */
470 /* Do not inherit to_flash_erase. */
471 /* Do not inherit to_flash_done. */
475 /* Clean up a target struct so it no longer has any zero pointers in
476 it. Some entries are defaulted to a method that print an error,
477 others are hard-wired to a standard recursive default. */
479 #define de_fault(field, value) \
480 if (!current_target.field) \
481 current_target.field = value
484 (void (*) (char *, int))
490 maybe_kill_then_attach
);
491 de_fault (to_post_attach
,
495 (void (*) (char *, int))
498 (void (*) (ptid_t
, int, enum target_signal
))
501 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
503 de_fault (to_fetch_registers
,
504 (void (*) (struct regcache
*, int))
506 de_fault (to_store_registers
,
507 (void (*) (struct regcache
*, int))
509 de_fault (to_prepare_to_store
,
510 (void (*) (struct regcache
*))
512 de_fault (deprecated_xfer_memory
,
513 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
515 de_fault (to_files_info
,
516 (void (*) (struct target_ops
*))
518 de_fault (to_insert_breakpoint
,
519 memory_insert_breakpoint
);
520 de_fault (to_remove_breakpoint
,
521 memory_remove_breakpoint
);
522 de_fault (to_can_use_hw_breakpoint
,
523 (int (*) (int, int, int))
525 de_fault (to_insert_hw_breakpoint
,
526 (int (*) (struct bp_target_info
*))
528 de_fault (to_remove_hw_breakpoint
,
529 (int (*) (struct bp_target_info
*))
531 de_fault (to_insert_watchpoint
,
532 (int (*) (CORE_ADDR
, int, int))
534 de_fault (to_remove_watchpoint
,
535 (int (*) (CORE_ADDR
, int, int))
537 de_fault (to_stopped_by_watchpoint
,
540 de_fault (to_stopped_data_address
,
541 (int (*) (struct target_ops
*, CORE_ADDR
*))
543 de_fault (to_region_ok_for_hw_watchpoint
,
544 default_region_ok_for_hw_watchpoint
);
545 de_fault (to_terminal_init
,
548 de_fault (to_terminal_inferior
,
551 de_fault (to_terminal_ours_for_output
,
554 de_fault (to_terminal_ours
,
557 de_fault (to_terminal_save_ours
,
560 de_fault (to_terminal_info
,
561 default_terminal_info
);
566 (void (*) (char *, int))
568 de_fault (to_lookup_symbol
,
569 (int (*) (char *, CORE_ADDR
*))
571 de_fault (to_create_inferior
,
572 maybe_kill_then_create_inferior
);
573 de_fault (to_post_startup_inferior
,
576 de_fault (to_acknowledge_created_inferior
,
579 de_fault (to_insert_fork_catchpoint
,
582 de_fault (to_remove_fork_catchpoint
,
585 de_fault (to_insert_vfork_catchpoint
,
588 de_fault (to_remove_vfork_catchpoint
,
591 de_fault (to_insert_exec_catchpoint
,
594 de_fault (to_remove_exec_catchpoint
,
597 de_fault (to_reported_exec_events_per_exec_call
,
600 de_fault (to_has_exited
,
601 (int (*) (int, int, int *))
603 de_fault (to_mourn_inferior
,
606 de_fault (to_can_run
,
608 de_fault (to_notice_signals
,
611 de_fault (to_thread_alive
,
614 de_fault (to_find_new_threads
,
617 de_fault (to_extra_thread_info
,
618 (char *(*) (struct thread_info
*))
623 current_target
.to_xfer_partial
= current_xfer_partial
;
625 (void (*) (char *, struct ui_file
*))
627 de_fault (to_enable_exception_callback
,
628 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
630 de_fault (to_get_current_exception_event
,
631 (struct exception_event_record
* (*) (void))
633 de_fault (to_pid_to_exec_file
,
636 de_fault (to_can_async_p
,
639 de_fault (to_is_async_p
,
643 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
645 current_target
.to_read_description
= NULL
;
648 /* Finally, position the target-stack beneath the squashed
649 "current_target". That way code looking for a non-inherited
650 target method can quickly and simply find it. */
651 current_target
.beneath
= target_stack
;
654 setup_target_debug ();
657 /* Mark OPS as a running target. This reverses the effect
658 of target_mark_exited. */
661 target_mark_running (struct target_ops
*ops
)
663 struct target_ops
*t
;
665 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
669 internal_error (__FILE__
, __LINE__
,
670 "Attempted to mark unpushed target \"%s\" as running",
673 ops
->to_has_execution
= 1;
674 ops
->to_has_all_memory
= 1;
675 ops
->to_has_memory
= 1;
676 ops
->to_has_stack
= 1;
677 ops
->to_has_registers
= 1;
679 update_current_target ();
682 /* Mark OPS as a non-running target. This reverses the effect
683 of target_mark_running. */
686 target_mark_exited (struct target_ops
*ops
)
688 struct target_ops
*t
;
690 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
694 internal_error (__FILE__
, __LINE__
,
695 "Attempted to mark unpushed target \"%s\" as running",
698 ops
->to_has_execution
= 0;
699 ops
->to_has_all_memory
= 0;
700 ops
->to_has_memory
= 0;
701 ops
->to_has_stack
= 0;
702 ops
->to_has_registers
= 0;
704 update_current_target ();
707 /* Push a new target type into the stack of the existing target accessors,
708 possibly superseding some of the existing accessors.
710 Result is zero if the pushed target ended up on top of the stack,
711 nonzero if at least one target is on top of it.
713 Rather than allow an empty stack, we always have the dummy target at
714 the bottom stratum, so we can call the function vectors without
718 push_target (struct target_ops
*t
)
720 struct target_ops
**cur
;
722 /* Check magic number. If wrong, it probably means someone changed
723 the struct definition, but not all the places that initialize one. */
724 if (t
->to_magic
!= OPS_MAGIC
)
726 fprintf_unfiltered (gdb_stderr
,
727 "Magic number of %s target struct wrong\n",
729 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
732 /* Find the proper stratum to install this target in. */
733 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
735 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
739 /* If there's already targets at this stratum, remove them. */
740 /* FIXME: cagney/2003-10-15: I think this should be popping all
741 targets to CUR, and not just those at this stratum level. */
742 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
744 /* There's already something at this stratum level. Close it,
745 and un-hook it from the stack. */
746 struct target_ops
*tmp
= (*cur
);
747 (*cur
) = (*cur
)->beneath
;
749 target_close (tmp
, 0);
752 /* We have removed all targets in our stratum, now add the new one. */
756 update_current_target ();
759 return (t
!= target_stack
);
762 /* Remove a target_ops vector from the stack, wherever it may be.
763 Return how many times it was removed (0 or 1). */
766 unpush_target (struct target_ops
*t
)
768 struct target_ops
**cur
;
769 struct target_ops
*tmp
;
771 /* Look for the specified target. Note that we assume that a target
772 can only occur once in the target stack. */
774 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
781 return 0; /* Didn't find target_ops, quit now */
783 /* NOTE: cagney/2003-12-06: In '94 the close call was made
784 unconditional by moving it to before the above check that the
785 target was in the target stack (something about "Change the way
786 pushing and popping of targets work to support target overlays
787 and inheritance"). This doesn't make much sense - only open
788 targets should be closed. */
791 /* Unchain the target */
793 (*cur
) = (*cur
)->beneath
;
796 update_current_target ();
804 target_close (¤t_target
, 0); /* Let it clean up */
805 if (unpush_target (target_stack
) == 1)
808 fprintf_unfiltered (gdb_stderr
,
809 "pop_target couldn't find target %s\n",
810 current_target
.to_shortname
);
811 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
814 /* Using the objfile specified in BATON, find the address for the
815 current thread's thread-local storage with offset OFFSET. */
817 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
819 volatile CORE_ADDR addr
= 0;
821 if (target_get_thread_local_address_p ()
822 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
824 ptid_t ptid
= inferior_ptid
;
825 volatile struct gdb_exception ex
;
827 TRY_CATCH (ex
, RETURN_MASK_ALL
)
831 /* Fetch the load module address for this objfile. */
832 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
834 /* If it's 0, throw the appropriate exception. */
836 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
837 _("TLS load module not found"));
839 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
841 /* If an error occurred, print TLS related messages here. Otherwise,
842 throw the error to some higher catcher. */
845 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
849 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
850 error (_("Cannot find thread-local variables in this thread library."));
852 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
853 if (objfile_is_library
)
854 error (_("Cannot find shared library `%s' in dynamic"
855 " linker's load module list"), objfile
->name
);
857 error (_("Cannot find executable file `%s' in dynamic"
858 " linker's load module list"), objfile
->name
);
860 case TLS_NOT_ALLOCATED_YET_ERROR
:
861 if (objfile_is_library
)
862 error (_("The inferior has not yet allocated storage for"
863 " thread-local variables in\n"
864 "the shared library `%s'\n"
866 objfile
->name
, target_pid_to_str (ptid
));
868 error (_("The inferior has not yet allocated storage for"
869 " thread-local variables in\n"
870 "the executable `%s'\n"
872 objfile
->name
, target_pid_to_str (ptid
));
874 case TLS_GENERIC_ERROR
:
875 if (objfile_is_library
)
876 error (_("Cannot find thread-local storage for %s, "
877 "shared library %s:\n%s"),
878 target_pid_to_str (ptid
),
879 objfile
->name
, ex
.message
);
881 error (_("Cannot find thread-local storage for %s, "
882 "executable file %s:\n%s"),
883 target_pid_to_str (ptid
),
884 objfile
->name
, ex
.message
);
887 throw_exception (ex
);
892 /* It wouldn't be wrong here to try a gdbarch method, too; finding
893 TLS is an ABI-specific thing. But we don't do that yet. */
895 error (_("Cannot find thread-local variables on this target"));
901 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
903 /* target_read_string -- read a null terminated string, up to LEN bytes,
904 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
905 Set *STRING to a pointer to malloc'd memory containing the data; the caller
906 is responsible for freeing it. Return the number of bytes successfully
910 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
912 int tlen
, origlen
, offset
, i
;
916 int buffer_allocated
;
918 unsigned int nbytes_read
= 0;
922 /* Small for testing. */
923 buffer_allocated
= 4;
924 buffer
= xmalloc (buffer_allocated
);
931 tlen
= MIN (len
, 4 - (memaddr
& 3));
932 offset
= memaddr
& 3;
934 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
937 /* The transfer request might have crossed the boundary to an
938 unallocated region of memory. Retry the transfer, requesting
942 errcode
= target_read_memory (memaddr
, buf
, 1);
947 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
950 bytes
= bufptr
- buffer
;
951 buffer_allocated
*= 2;
952 buffer
= xrealloc (buffer
, buffer_allocated
);
953 bufptr
= buffer
+ bytes
;
956 for (i
= 0; i
< tlen
; i
++)
958 *bufptr
++ = buf
[i
+ offset
];
959 if (buf
[i
+ offset
] == '\000')
961 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 /* Likewise for accesses to unmapped overlay sections. */
1020 if (readbuf
!= NULL
&& overlay_debugging
)
1022 asection
*section
= find_pc_overlay (memaddr
);
1023 if (pc_in_unmapped_range (memaddr
, section
))
1024 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1027 /* Try GDB's internal data cache. */
1028 region
= lookup_mem_region (memaddr
);
1029 /* region->hi == 0 means there's no upper bound. */
1030 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1033 reg_len
= region
->hi
- memaddr
;
1035 switch (region
->attrib
.mode
)
1038 if (writebuf
!= NULL
)
1043 if (readbuf
!= NULL
)
1048 /* We only support writing to flash during "load" for now. */
1049 if (writebuf
!= NULL
)
1050 error (_("Writing to flash memory forbidden in this context"));
1057 if (region
->attrib
.cache
)
1059 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1060 memory request will start back at current_target. */
1061 if (readbuf
!= NULL
)
1062 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1065 /* FIXME drow/2006-08-09: If we're going to preserve const
1066 correctness dcache_xfer_memory should take readbuf and
1068 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1077 /* If none of those methods found the memory we wanted, fall back
1078 to a target partial transfer. Normally a single call to
1079 to_xfer_partial is enough; if it doesn't recognize an object
1080 it will call the to_xfer_partial of the next target down.
1081 But for memory this won't do. Memory is the only target
1082 object which can be read from more than one valid target.
1083 A core file, for instance, could have some of memory but
1084 delegate other bits to the target below it. So, we must
1085 manually try all targets. */
1089 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1090 readbuf
, writebuf
, memaddr
, reg_len
);
1094 /* We want to continue past core files to executables, but not
1095 past a running target's memory. */
1096 if (ops
->to_has_all_memory
)
1101 while (ops
!= NULL
);
1103 /* If we still haven't got anything, return the last error. We
1109 target_xfer_partial (struct target_ops
*ops
,
1110 enum target_object object
, const char *annex
,
1111 void *readbuf
, const void *writebuf
,
1112 ULONGEST offset
, LONGEST len
)
1116 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1118 /* If this is a memory transfer, let the memory-specific code
1119 have a look at it instead. Memory transfers are more
1121 if (object
== TARGET_OBJECT_MEMORY
)
1122 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1125 enum target_object raw_object
= object
;
1127 /* If this is a raw memory transfer, request the normal
1128 memory object from other layers. */
1129 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1130 raw_object
= TARGET_OBJECT_MEMORY
;
1132 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1133 writebuf
, offset
, len
);
1138 const unsigned char *myaddr
= NULL
;
1140 fprintf_unfiltered (gdb_stdlog
,
1141 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1144 (annex
? annex
: "(null)"),
1145 (long) readbuf
, (long) writebuf
,
1146 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1152 if (retval
> 0 && myaddr
!= NULL
)
1156 fputs_unfiltered (", bytes =", gdb_stdlog
);
1157 for (i
= 0; i
< retval
; i
++)
1159 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1161 if (targetdebug
< 2 && i
> 0)
1163 fprintf_unfiltered (gdb_stdlog
, " ...");
1166 fprintf_unfiltered (gdb_stdlog
, "\n");
1169 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1173 fputc_unfiltered ('\n', gdb_stdlog
);
1178 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1179 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1180 if any error occurs.
1182 If an error occurs, no guarantee is made about the contents of the data at
1183 MYADDR. In particular, the caller should not depend upon partial reads
1184 filling the buffer with good data. There is no way for the caller to know
1185 how much good data might have been transfered anyway. Callers that can
1186 deal with partial reads should call target_read (which will retry until
1187 it makes no progress, and then return how much was transferred). */
1190 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1192 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1193 myaddr
, memaddr
, len
) == len
)
1200 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1202 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1203 myaddr
, memaddr
, len
) == len
)
1209 /* Fetch the target's memory map. */
1212 target_memory_map (void)
1214 VEC(mem_region_s
) *result
;
1215 struct mem_region
*last_one
, *this_one
;
1217 struct target_ops
*t
;
1220 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1222 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1223 if (t
->to_memory_map
!= NULL
)
1229 result
= t
->to_memory_map (t
);
1233 qsort (VEC_address (mem_region_s
, result
),
1234 VEC_length (mem_region_s
, result
),
1235 sizeof (struct mem_region
), mem_region_cmp
);
1237 /* Check that regions do not overlap. Simultaneously assign
1238 a numbering for the "mem" commands to use to refer to
1241 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1243 this_one
->number
= ix
;
1245 if (last_one
&& last_one
->hi
> this_one
->lo
)
1247 warning (_("Overlapping regions in memory map: ignoring"));
1248 VEC_free (mem_region_s
, result
);
1251 last_one
= this_one
;
1258 target_flash_erase (ULONGEST address
, LONGEST length
)
1260 struct target_ops
*t
;
1262 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1263 if (t
->to_flash_erase
!= NULL
)
1266 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1267 paddr (address
), phex (length
, 0));
1268 t
->to_flash_erase (t
, address
, length
);
1276 target_flash_done (void)
1278 struct target_ops
*t
;
1280 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1281 if (t
->to_flash_done
!= NULL
)
1284 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1285 t
->to_flash_done (t
);
1292 #ifndef target_stopped_data_address_p
1294 target_stopped_data_address_p (struct target_ops
*target
)
1296 if (target
->to_stopped_data_address
1297 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1299 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1300 && (debug_target
.to_stopped_data_address
1301 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1308 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1309 struct cmd_list_element
*c
, const char *value
)
1311 fprintf_filtered (file
, _("\
1312 Mode for reading from readonly sections is %s.\n"),
1316 /* More generic transfers. */
1319 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1320 const char *annex
, gdb_byte
*readbuf
,
1321 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1323 if (object
== TARGET_OBJECT_MEMORY
1324 && ops
->deprecated_xfer_memory
!= NULL
)
1325 /* If available, fall back to the target's
1326 "deprecated_xfer_memory" method. */
1330 if (writebuf
!= NULL
)
1332 void *buffer
= xmalloc (len
);
1333 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1334 memcpy (buffer
, writebuf
, len
);
1335 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1336 1/*write*/, NULL
, ops
);
1337 do_cleanups (cleanup
);
1339 if (readbuf
!= NULL
)
1340 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1344 else if (xfered
== 0 && errno
== 0)
1345 /* "deprecated_xfer_memory" uses 0, cross checked against
1346 ERRNO as one indication of an error. */
1351 else if (ops
->beneath
!= NULL
)
1352 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1353 readbuf
, writebuf
, offset
, len
);
1358 /* The xfer_partial handler for the topmost target. Unlike the default,
1359 it does not need to handle memory specially; it just passes all
1360 requests down the stack. */
1363 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1364 const char *annex
, gdb_byte
*readbuf
,
1365 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1367 if (ops
->beneath
!= NULL
)
1368 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1369 readbuf
, writebuf
, offset
, len
);
1374 /* Target vector read/write partial wrapper functions.
1376 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1377 (inbuf, outbuf)", instead of separate read/write methods, make life
1381 target_read_partial (struct target_ops
*ops
,
1382 enum target_object object
,
1383 const char *annex
, gdb_byte
*buf
,
1384 ULONGEST offset
, LONGEST len
)
1386 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1390 target_write_partial (struct target_ops
*ops
,
1391 enum target_object object
,
1392 const char *annex
, const gdb_byte
*buf
,
1393 ULONGEST offset
, LONGEST len
)
1395 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1398 /* Wrappers to perform the full transfer. */
1400 target_read (struct target_ops
*ops
,
1401 enum target_object object
,
1402 const char *annex
, gdb_byte
*buf
,
1403 ULONGEST offset
, LONGEST len
)
1406 while (xfered
< len
)
1408 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1409 (gdb_byte
*) buf
+ xfered
,
1410 offset
+ xfered
, len
- xfered
);
1411 /* Call an observer, notifying them of the xfer progress? */
1422 /* An alternative to target_write with progress callbacks. */
1425 target_write_with_progress (struct target_ops
*ops
,
1426 enum target_object object
,
1427 const char *annex
, const gdb_byte
*buf
,
1428 ULONGEST offset
, LONGEST len
,
1429 void (*progress
) (ULONGEST
, void *), void *baton
)
1433 /* Give the progress callback a chance to set up. */
1435 (*progress
) (0, baton
);
1437 while (xfered
< len
)
1439 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1440 (gdb_byte
*) buf
+ xfered
,
1441 offset
+ xfered
, len
- xfered
);
1449 (*progress
) (xfer
, baton
);
1458 target_write (struct target_ops
*ops
,
1459 enum target_object object
,
1460 const char *annex
, const gdb_byte
*buf
,
1461 ULONGEST offset
, LONGEST len
)
1463 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1467 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1468 the size of the transferred data. PADDING additional bytes are
1469 available in *BUF_P. This is a helper function for
1470 target_read_alloc; see the declaration of that function for more
1474 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1475 const char *annex
, gdb_byte
**buf_p
, int padding
)
1477 size_t buf_alloc
, buf_pos
;
1481 /* This function does not have a length parameter; it reads the
1482 entire OBJECT). Also, it doesn't support objects fetched partly
1483 from one target and partly from another (in a different stratum,
1484 e.g. a core file and an executable). Both reasons make it
1485 unsuitable for reading memory. */
1486 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1488 /* Start by reading up to 4K at a time. The target will throttle
1489 this number down if necessary. */
1491 buf
= xmalloc (buf_alloc
);
1495 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1496 buf_pos
, buf_alloc
- buf_pos
- padding
);
1499 /* An error occurred. */
1505 /* Read all there was. */
1515 /* If the buffer is filling up, expand it. */
1516 if (buf_alloc
< buf_pos
* 2)
1519 buf
= xrealloc (buf
, buf_alloc
);
1526 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1527 the size of the transferred data. See the declaration in "target.h"
1528 function for more information about the return value. */
1531 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1532 const char *annex
, gdb_byte
**buf_p
)
1534 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1537 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1538 returned as a string, allocated using xmalloc. If an error occurs
1539 or the transfer is unsupported, NULL is returned. Empty objects
1540 are returned as allocated but empty strings. A warning is issued
1541 if the result contains any embedded NUL bytes. */
1544 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1548 LONGEST transferred
;
1550 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1552 if (transferred
< 0)
1555 if (transferred
== 0)
1556 return xstrdup ("");
1558 buffer
[transferred
] = 0;
1559 if (strlen (buffer
) < transferred
)
1560 warning (_("target object %d, annex %s, "
1561 "contained unexpected null characters"),
1562 (int) object
, annex
? annex
: "(none)");
1564 return (char *) buffer
;
1567 /* Memory transfer methods. */
1570 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1573 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1575 memory_error (EIO
, addr
);
1579 get_target_memory_unsigned (struct target_ops
*ops
,
1580 CORE_ADDR addr
, int len
)
1582 gdb_byte buf
[sizeof (ULONGEST
)];
1584 gdb_assert (len
<= sizeof (buf
));
1585 get_target_memory (ops
, addr
, buf
, len
);
1586 return extract_unsigned_integer (buf
, len
);
1590 target_info (char *args
, int from_tty
)
1592 struct target_ops
*t
;
1593 int has_all_mem
= 0;
1595 if (symfile_objfile
!= NULL
)
1596 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1598 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1600 if (!t
->to_has_memory
)
1603 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1606 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1607 printf_unfiltered ("%s:\n", t
->to_longname
);
1608 (t
->to_files_info
) (t
);
1609 has_all_mem
= t
->to_has_all_memory
;
1613 /* This function is called before any new inferior is created, e.g.
1614 by running a program, attaching, or connecting to a target.
1615 It cleans up any state from previous invocations which might
1616 change between runs. This is a subset of what target_preopen
1617 resets (things which might change between targets). */
1620 target_pre_inferior (int from_tty
)
1622 invalidate_target_mem_regions ();
1624 target_clear_description ();
1627 /* This is to be called by the open routine before it does
1631 target_preopen (int from_tty
)
1635 if (target_has_execution
)
1638 || query (_("A program is being debugged already. Kill it? ")))
1641 error (_("Program not killed."));
1644 /* Calling target_kill may remove the target from the stack. But if
1645 it doesn't (which seems like a win for UDI), remove it now. */
1647 if (target_has_execution
)
1650 target_pre_inferior (from_tty
);
1653 /* Detach a target after doing deferred register stores. */
1656 target_detach (char *args
, int from_tty
)
1658 (current_target
.to_detach
) (args
, from_tty
);
1662 target_disconnect (char *args
, int from_tty
)
1664 struct target_ops
*t
;
1666 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1667 if (t
->to_disconnect
!= NULL
)
1670 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1672 t
->to_disconnect (t
, args
, from_tty
);
1680 target_async_mask (int mask
)
1682 int saved_async_masked_status
= target_async_mask_value
;
1683 target_async_mask_value
= mask
;
1684 return saved_async_masked_status
;
1687 /* Look through the list of possible targets for a target that can
1691 target_follow_fork (int follow_child
)
1693 struct target_ops
*t
;
1695 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1697 if (t
->to_follow_fork
!= NULL
)
1699 int retval
= t
->to_follow_fork (t
, follow_child
);
1701 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1702 follow_child
, retval
);
1707 /* Some target returned a fork event, but did not know how to follow it. */
1708 internal_error (__FILE__
, __LINE__
,
1709 "could not find a target to follow fork");
1712 /* Look for a target which can describe architectural features, starting
1713 from TARGET. If we find one, return its description. */
1715 const struct target_desc
*
1716 target_read_description (struct target_ops
*target
)
1718 struct target_ops
*t
;
1720 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1721 if (t
->to_read_description
!= NULL
)
1723 const struct target_desc
*tdesc
;
1725 tdesc
= t
->to_read_description (t
);
1733 /* Look through the list of possible targets for a target that can
1734 execute a run or attach command without any other data. This is
1735 used to locate the default process stratum.
1737 Result is always valid (error() is called for errors). */
1739 static struct target_ops
*
1740 find_default_run_target (char *do_mesg
)
1742 struct target_ops
**t
;
1743 struct target_ops
*runable
= NULL
;
1748 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1751 if ((*t
)->to_can_run
&& target_can_run (*t
))
1759 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1765 find_default_attach (char *args
, int from_tty
)
1767 struct target_ops
*t
;
1769 t
= find_default_run_target ("attach");
1770 (t
->to_attach
) (args
, from_tty
);
1775 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1778 struct target_ops
*t
;
1780 t
= find_default_run_target ("run");
1781 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1786 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1788 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1804 return_minus_one (void)
1810 * Resize the to_sections pointer. Also make sure that anyone that
1811 * was holding on to an old value of it gets updated.
1812 * Returns the old size.
1816 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1818 struct target_ops
**t
;
1819 struct section_table
*old_value
;
1822 old_value
= target
->to_sections
;
1824 if (target
->to_sections
)
1826 old_count
= target
->to_sections_end
- target
->to_sections
;
1827 target
->to_sections
= (struct section_table
*)
1828 xrealloc ((char *) target
->to_sections
,
1829 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1834 target
->to_sections
= (struct section_table
*)
1835 xmalloc ((sizeof (struct section_table
)) * num_added
);
1837 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1839 /* Check to see if anyone else was pointing to this structure.
1840 If old_value was null, then no one was. */
1844 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1847 if ((*t
)->to_sections
== old_value
)
1849 (*t
)->to_sections
= target
->to_sections
;
1850 (*t
)->to_sections_end
= target
->to_sections_end
;
1853 /* There is a flattened view of the target stack in current_target,
1854 so its to_sections pointer might also need updating. */
1855 if (current_target
.to_sections
== old_value
)
1857 current_target
.to_sections
= target
->to_sections
;
1858 current_target
.to_sections_end
= target
->to_sections_end
;
1866 /* Remove all target sections taken from ABFD.
1868 Scan the current target stack for targets whose section tables
1869 refer to sections from BFD, and remove those sections. We use this
1870 when we notice that the inferior has unloaded a shared object, for
1873 remove_target_sections (bfd
*abfd
)
1875 struct target_ops
**t
;
1877 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1879 struct section_table
*src
, *dest
;
1881 dest
= (*t
)->to_sections
;
1882 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1883 if (src
->bfd
!= abfd
)
1885 /* Keep this section. */
1886 if (dest
< src
) *dest
= *src
;
1890 /* If we've dropped any sections, resize the section table. */
1892 target_resize_to_sections (*t
, dest
- src
);
1899 /* Find a single runnable target in the stack and return it. If for
1900 some reason there is more than one, return NULL. */
1903 find_run_target (void)
1905 struct target_ops
**t
;
1906 struct target_ops
*runable
= NULL
;
1911 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1913 if ((*t
)->to_can_run
&& target_can_run (*t
))
1920 return (count
== 1 ? runable
: NULL
);
1923 /* Find a single core_stratum target in the list of targets and return it.
1924 If for some reason there is more than one, return NULL. */
1927 find_core_target (void)
1929 struct target_ops
**t
;
1930 struct target_ops
*runable
= NULL
;
1935 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1938 if ((*t
)->to_stratum
== core_stratum
)
1945 return (count
== 1 ? runable
: NULL
);
1949 * Find the next target down the stack from the specified target.
1953 find_target_beneath (struct target_ops
*t
)
1959 /* The inferior process has died. Long live the inferior! */
1962 generic_mourn_inferior (void)
1964 extern int show_breakpoint_hit_counts
;
1966 inferior_ptid
= null_ptid
;
1968 breakpoint_init_inferior (inf_exited
);
1969 registers_changed ();
1971 reopen_exec_file ();
1972 reinit_frame_cache ();
1974 /* It is confusing to the user for ignore counts to stick around
1975 from previous runs of the inferior. So clear them. */
1976 /* However, it is more confusing for the ignore counts to disappear when
1977 using hit counts. So don't clear them if we're counting hits. */
1978 if (!show_breakpoint_hit_counts
)
1979 breakpoint_clear_ignore_counts ();
1981 if (deprecated_detach_hook
)
1982 deprecated_detach_hook ();
1985 /* Helper function for child_wait and the derivatives of child_wait.
1986 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1987 translation of that in OURSTATUS. */
1989 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1991 if (WIFEXITED (hoststatus
))
1993 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1994 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1996 else if (!WIFSTOPPED (hoststatus
))
1998 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1999 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2003 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2004 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2008 /* Returns zero to leave the inferior alone, one to interrupt it. */
2009 int (*target_activity_function
) (void);
2010 int target_activity_fd
;
2012 /* Convert a normal process ID to a string. Returns the string in a
2016 normal_pid_to_str (ptid_t ptid
)
2018 static char buf
[32];
2020 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2024 /* Error-catcher for target_find_memory_regions */
2025 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2027 error (_("No target."));
2031 /* Error-catcher for target_make_corefile_notes */
2032 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2034 error (_("No target."));
2038 /* Set up the handful of non-empty slots needed by the dummy target
2042 init_dummy_target (void)
2044 dummy_target
.to_shortname
= "None";
2045 dummy_target
.to_longname
= "None";
2046 dummy_target
.to_doc
= "";
2047 dummy_target
.to_attach
= find_default_attach
;
2048 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2049 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2050 dummy_target
.to_stratum
= dummy_stratum
;
2051 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2052 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2053 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2054 dummy_target
.to_magic
= OPS_MAGIC
;
2058 debug_to_open (char *args
, int from_tty
)
2060 debug_target
.to_open (args
, from_tty
);
2062 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2066 debug_to_close (int quitting
)
2068 target_close (&debug_target
, quitting
);
2069 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2073 target_close (struct target_ops
*targ
, int quitting
)
2075 if (targ
->to_xclose
!= NULL
)
2076 targ
->to_xclose (targ
, quitting
);
2077 else if (targ
->to_close
!= NULL
)
2078 targ
->to_close (quitting
);
2082 debug_to_attach (char *args
, int from_tty
)
2084 debug_target
.to_attach (args
, from_tty
);
2086 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2091 debug_to_post_attach (int pid
)
2093 debug_target
.to_post_attach (pid
);
2095 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2099 debug_to_detach (char *args
, int from_tty
)
2101 debug_target
.to_detach (args
, from_tty
);
2103 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2107 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2109 debug_target
.to_resume (ptid
, step
, siggnal
);
2111 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2112 step
? "step" : "continue",
2113 target_signal_to_name (siggnal
));
2117 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2121 retval
= debug_target
.to_wait (ptid
, status
);
2123 fprintf_unfiltered (gdb_stdlog
,
2124 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2126 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2127 switch (status
->kind
)
2129 case TARGET_WAITKIND_EXITED
:
2130 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2131 status
->value
.integer
);
2133 case TARGET_WAITKIND_STOPPED
:
2134 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2135 target_signal_to_name (status
->value
.sig
));
2137 case TARGET_WAITKIND_SIGNALLED
:
2138 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2139 target_signal_to_name (status
->value
.sig
));
2141 case TARGET_WAITKIND_LOADED
:
2142 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2144 case TARGET_WAITKIND_FORKED
:
2145 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2147 case TARGET_WAITKIND_VFORKED
:
2148 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2150 case TARGET_WAITKIND_EXECD
:
2151 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2153 case TARGET_WAITKIND_SPURIOUS
:
2154 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2157 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2165 debug_print_register (const char * func
,
2166 struct regcache
*regcache
, int regno
)
2168 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2169 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2170 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2171 + gdbarch_num_pseudo_regs (gdbarch
)
2172 && gdbarch_register_name (gdbarch
, regno
) != NULL
2173 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2174 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2175 gdbarch_register_name (gdbarch
, regno
));
2177 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2180 int i
, size
= register_size (gdbarch
, regno
);
2181 unsigned char buf
[MAX_REGISTER_SIZE
];
2182 regcache_cooked_read (regcache
, regno
, buf
);
2183 fprintf_unfiltered (gdb_stdlog
, " = ");
2184 for (i
= 0; i
< size
; i
++)
2186 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2188 if (size
<= sizeof (LONGEST
))
2190 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2191 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2192 paddr_nz (val
), paddr_d (val
));
2195 fprintf_unfiltered (gdb_stdlog
, "\n");
2199 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2201 debug_target
.to_fetch_registers (regcache
, regno
);
2202 debug_print_register ("target_fetch_registers", regcache
, regno
);
2206 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2208 debug_target
.to_store_registers (regcache
, regno
);
2209 debug_print_register ("target_store_registers", regcache
, regno
);
2210 fprintf_unfiltered (gdb_stdlog
, "\n");
2214 debug_to_prepare_to_store (struct regcache
*regcache
)
2216 debug_target
.to_prepare_to_store (regcache
);
2218 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2222 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2223 int write
, struct mem_attrib
*attrib
,
2224 struct target_ops
*target
)
2228 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2231 fprintf_unfiltered (gdb_stdlog
,
2232 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2233 (unsigned int) memaddr
, /* possable truncate long long */
2234 len
, write
? "write" : "read", retval
);
2240 fputs_unfiltered (", bytes =", gdb_stdlog
);
2241 for (i
= 0; i
< retval
; i
++)
2243 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2245 if (targetdebug
< 2 && i
> 0)
2247 fprintf_unfiltered (gdb_stdlog
, " ...");
2250 fprintf_unfiltered (gdb_stdlog
, "\n");
2253 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2257 fputc_unfiltered ('\n', gdb_stdlog
);
2263 debug_to_files_info (struct target_ops
*target
)
2265 debug_target
.to_files_info (target
);
2267 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2271 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2275 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2277 fprintf_unfiltered (gdb_stdlog
,
2278 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2279 (unsigned long) bp_tgt
->placed_address
,
2280 (unsigned long) retval
);
2285 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2289 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2291 fprintf_unfiltered (gdb_stdlog
,
2292 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2293 (unsigned long) bp_tgt
->placed_address
,
2294 (unsigned long) retval
);
2299 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2303 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2305 fprintf_unfiltered (gdb_stdlog
,
2306 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2307 (unsigned long) type
,
2308 (unsigned long) cnt
,
2309 (unsigned long) from_tty
,
2310 (unsigned long) retval
);
2315 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2319 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2321 fprintf_unfiltered (gdb_stdlog
,
2322 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2323 (unsigned long) addr
,
2324 (unsigned long) len
,
2325 (unsigned long) retval
);
2330 debug_to_stopped_by_watchpoint (void)
2334 retval
= debug_target
.to_stopped_by_watchpoint ();
2336 fprintf_unfiltered (gdb_stdlog
,
2337 "STOPPED_BY_WATCHPOINT () = %ld\n",
2338 (unsigned long) retval
);
2343 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2347 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2349 fprintf_unfiltered (gdb_stdlog
,
2350 "target_stopped_data_address ([0x%lx]) = %ld\n",
2351 (unsigned long)*addr
,
2352 (unsigned long)retval
);
2357 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2361 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2363 fprintf_unfiltered (gdb_stdlog
,
2364 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2365 (unsigned long) bp_tgt
->placed_address
,
2366 (unsigned long) retval
);
2371 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2375 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2377 fprintf_unfiltered (gdb_stdlog
,
2378 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2379 (unsigned long) bp_tgt
->placed_address
,
2380 (unsigned long) retval
);
2385 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2389 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2391 fprintf_unfiltered (gdb_stdlog
,
2392 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2393 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2398 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2402 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2404 fprintf_unfiltered (gdb_stdlog
,
2405 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2406 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2411 debug_to_terminal_init (void)
2413 debug_target
.to_terminal_init ();
2415 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2419 debug_to_terminal_inferior (void)
2421 debug_target
.to_terminal_inferior ();
2423 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2427 debug_to_terminal_ours_for_output (void)
2429 debug_target
.to_terminal_ours_for_output ();
2431 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2435 debug_to_terminal_ours (void)
2437 debug_target
.to_terminal_ours ();
2439 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2443 debug_to_terminal_save_ours (void)
2445 debug_target
.to_terminal_save_ours ();
2447 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2451 debug_to_terminal_info (char *arg
, int from_tty
)
2453 debug_target
.to_terminal_info (arg
, from_tty
);
2455 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2460 debug_to_kill (void)
2462 debug_target
.to_kill ();
2464 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2468 debug_to_load (char *args
, int from_tty
)
2470 debug_target
.to_load (args
, from_tty
);
2472 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2476 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2480 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2482 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2488 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2491 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2493 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2494 exec_file
, args
, from_tty
);
2498 debug_to_post_startup_inferior (ptid_t ptid
)
2500 debug_target
.to_post_startup_inferior (ptid
);
2502 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2507 debug_to_acknowledge_created_inferior (int pid
)
2509 debug_target
.to_acknowledge_created_inferior (pid
);
2511 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2516 debug_to_insert_fork_catchpoint (int pid
)
2518 debug_target
.to_insert_fork_catchpoint (pid
);
2520 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2525 debug_to_remove_fork_catchpoint (int pid
)
2529 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2531 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2538 debug_to_insert_vfork_catchpoint (int pid
)
2540 debug_target
.to_insert_vfork_catchpoint (pid
);
2542 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2547 debug_to_remove_vfork_catchpoint (int pid
)
2551 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2553 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2560 debug_to_insert_exec_catchpoint (int pid
)
2562 debug_target
.to_insert_exec_catchpoint (pid
);
2564 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2569 debug_to_remove_exec_catchpoint (int pid
)
2573 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2575 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2582 debug_to_reported_exec_events_per_exec_call (void)
2584 int reported_exec_events
;
2586 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2588 fprintf_unfiltered (gdb_stdlog
,
2589 "target_reported_exec_events_per_exec_call () = %d\n",
2590 reported_exec_events
);
2592 return reported_exec_events
;
2596 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2600 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2602 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2603 pid
, wait_status
, *exit_status
, has_exited
);
2609 debug_to_mourn_inferior (void)
2611 debug_target
.to_mourn_inferior ();
2613 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2617 debug_to_can_run (void)
2621 retval
= debug_target
.to_can_run ();
2623 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2629 debug_to_notice_signals (ptid_t ptid
)
2631 debug_target
.to_notice_signals (ptid
);
2633 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2638 debug_to_thread_alive (ptid_t ptid
)
2642 retval
= debug_target
.to_thread_alive (ptid
);
2644 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2645 PIDGET (ptid
), retval
);
2651 debug_to_find_new_threads (void)
2653 debug_target
.to_find_new_threads ();
2655 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2659 debug_to_stop (void)
2661 debug_target
.to_stop ();
2663 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2667 debug_to_rcmd (char *command
,
2668 struct ui_file
*outbuf
)
2670 debug_target
.to_rcmd (command
, outbuf
);
2671 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2674 static struct symtab_and_line
*
2675 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2677 struct symtab_and_line
*result
;
2678 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2679 fprintf_unfiltered (gdb_stdlog
,
2680 "target get_exception_callback_sal (%d, %d)\n",
2685 static struct exception_event_record
*
2686 debug_to_get_current_exception_event (void)
2688 struct exception_event_record
*result
;
2689 result
= debug_target
.to_get_current_exception_event ();
2690 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2695 debug_to_pid_to_exec_file (int pid
)
2699 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2701 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2708 setup_target_debug (void)
2710 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2712 current_target
.to_open
= debug_to_open
;
2713 current_target
.to_close
= debug_to_close
;
2714 current_target
.to_attach
= debug_to_attach
;
2715 current_target
.to_post_attach
= debug_to_post_attach
;
2716 current_target
.to_detach
= debug_to_detach
;
2717 current_target
.to_resume
= debug_to_resume
;
2718 current_target
.to_wait
= debug_to_wait
;
2719 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2720 current_target
.to_store_registers
= debug_to_store_registers
;
2721 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2722 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2723 current_target
.to_files_info
= debug_to_files_info
;
2724 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2725 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2726 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2727 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2728 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2729 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2730 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2731 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2732 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2733 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2734 current_target
.to_terminal_init
= debug_to_terminal_init
;
2735 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2736 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2737 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2738 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2739 current_target
.to_terminal_info
= debug_to_terminal_info
;
2740 current_target
.to_kill
= debug_to_kill
;
2741 current_target
.to_load
= debug_to_load
;
2742 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2743 current_target
.to_create_inferior
= debug_to_create_inferior
;
2744 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2745 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2746 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2747 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2748 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2749 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2750 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2751 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2752 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2753 current_target
.to_has_exited
= debug_to_has_exited
;
2754 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2755 current_target
.to_can_run
= debug_to_can_run
;
2756 current_target
.to_notice_signals
= debug_to_notice_signals
;
2757 current_target
.to_thread_alive
= debug_to_thread_alive
;
2758 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2759 current_target
.to_stop
= debug_to_stop
;
2760 current_target
.to_rcmd
= debug_to_rcmd
;
2761 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2762 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2763 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2767 static char targ_desc
[] =
2768 "Names of targets and files being debugged.\n\
2769 Shows the entire stack of targets currently in use (including the exec-file,\n\
2770 core-file, and process, if any), as well as the symbol file name.";
2773 do_monitor_command (char *cmd
,
2776 if ((current_target
.to_rcmd
2777 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2778 || (current_target
.to_rcmd
== debug_to_rcmd
2779 && (debug_target
.to_rcmd
2780 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2781 error (_("\"monitor\" command not supported by this target."));
2782 target_rcmd (cmd
, gdb_stdtarg
);
2785 /* Print the name of each layers of our target stack. */
2788 maintenance_print_target_stack (char *cmd
, int from_tty
)
2790 struct target_ops
*t
;
2792 printf_filtered (_("The current target stack is:\n"));
2794 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2796 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
2801 initialize_targets (void)
2803 init_dummy_target ();
2804 push_target (&dummy_target
);
2806 add_info ("target", target_info
, targ_desc
);
2807 add_info ("files", target_info
, targ_desc
);
2809 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2810 Set target debugging."), _("\
2811 Show target debugging."), _("\
2812 When non-zero, target debugging is enabled. Higher numbers are more\n\
2813 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2817 &setdebuglist
, &showdebuglist
);
2819 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2820 &trust_readonly
, _("\
2821 Set mode for reading from readonly sections."), _("\
2822 Show mode for reading from readonly sections."), _("\
2823 When this mode is on, memory reads from readonly sections (such as .text)\n\
2824 will be read from the object file instead of from the target. This will\n\
2825 result in significant performance improvement for remote targets."),
2827 show_trust_readonly
,
2828 &setlist
, &showlist
);
2830 add_com ("monitor", class_obscure
, do_monitor_command
,
2831 _("Send a command to the remote monitor (remote targets only)."));
2833 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
2834 _("Print the name of each layer of the internal target stack."),
2835 &maintenanceprintlist
);
2837 target_dcache
= dcache_init ();