1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
38 #include "gdb_assert.h"
40 #include "exceptions.h"
41 #include "target-descriptions.h"
42 #include "gdbthread.h"
45 static void target_info (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_watchpoint_addr_within_range (struct target_ops
*,
52 CORE_ADDR
, CORE_ADDR
, int);
54 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
56 static int nosymbol (char *, CORE_ADDR
*);
58 static void tcomplain (void) ATTR_NORETURN
;
60 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
62 static int return_zero (void);
64 static int return_one (void);
66 static int return_minus_one (void);
68 void target_ignore (void);
70 static void target_command (char *, int);
72 static struct target_ops
*find_default_run_target (char *);
74 static void nosupport_runtime (void);
76 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
77 enum target_object object
,
78 const char *annex
, gdb_byte
*readbuf
,
79 const gdb_byte
*writebuf
,
80 ULONGEST offset
, LONGEST len
);
82 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
83 enum target_object object
,
84 const char *annex
, gdb_byte
*readbuf
,
85 const gdb_byte
*writebuf
,
86 ULONGEST offset
, LONGEST len
);
88 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
89 enum target_object object
,
91 void *readbuf
, const void *writebuf
,
92 ULONGEST offset
, LONGEST len
);
94 static void init_dummy_target (void);
96 static struct target_ops debug_target
;
98 static void debug_to_open (char *, int);
100 static void debug_to_close (int);
102 static void debug_to_attach (char *, int);
104 static void debug_to_detach (char *, int);
106 static void debug_to_resume (ptid_t
, int, enum target_signal
);
108 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
110 static void debug_to_fetch_registers (struct regcache
*, int);
112 static void debug_to_store_registers (struct regcache
*, int);
114 static void debug_to_prepare_to_store (struct regcache
*);
116 static void debug_to_files_info (struct target_ops
*);
118 static int debug_to_insert_breakpoint (struct bp_target_info
*);
120 static int debug_to_remove_breakpoint (struct bp_target_info
*);
122 static int debug_to_can_use_hw_breakpoint (int, int, int);
124 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
126 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
128 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
130 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
132 static int debug_to_stopped_by_watchpoint (void);
134 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
136 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
137 CORE_ADDR
, CORE_ADDR
, int);
139 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
141 static void debug_to_terminal_init (void);
143 static void debug_to_terminal_inferior (void);
145 static void debug_to_terminal_ours_for_output (void);
147 static void debug_to_terminal_save_ours (void);
149 static void debug_to_terminal_ours (void);
151 static void debug_to_terminal_info (char *, int);
153 static void debug_to_kill (void);
155 static void debug_to_load (char *, int);
157 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
159 static void debug_to_mourn_inferior (void);
161 static int debug_to_can_run (void);
163 static void debug_to_notice_signals (ptid_t
);
165 static int debug_to_thread_alive (ptid_t
);
167 static void debug_to_stop (ptid_t
);
169 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
170 wierd and mysterious ways. Putting the variable here lets those
171 wierd and mysterious ways keep building while they are being
172 converted to the inferior inheritance structure. */
173 struct target_ops deprecated_child_ops
;
175 /* Pointer to array of target architecture structures; the size of the
176 array; the current index into the array; the allocated size of the
178 struct target_ops
**target_structs
;
179 unsigned target_struct_size
;
180 unsigned target_struct_index
;
181 unsigned target_struct_allocsize
;
182 #define DEFAULT_ALLOCSIZE 10
184 /* The initial current target, so that there is always a semi-valid
187 static struct target_ops dummy_target
;
189 /* Top of target stack. */
191 static struct target_ops
*target_stack
;
193 /* The target structure we are currently using to talk to a process
194 or file or whatever "inferior" we have. */
196 struct target_ops current_target
;
198 /* Command list for target. */
200 static struct cmd_list_element
*targetlist
= NULL
;
202 /* Nonzero if we should trust readonly sections from the
203 executable when reading memory. */
205 static int trust_readonly
= 0;
207 /* Nonzero if we should show true memory content including
208 memory breakpoint inserted by gdb. */
210 static int show_memory_breakpoints
= 0;
212 /* Non-zero if we want to see trace of target level stuff. */
214 static int targetdebug
= 0;
216 show_targetdebug (struct ui_file
*file
, int from_tty
,
217 struct cmd_list_element
*c
, const char *value
)
219 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
222 static void setup_target_debug (void);
224 DCACHE
*target_dcache
;
226 /* The user just typed 'target' without the name of a target. */
229 target_command (char *arg
, int from_tty
)
231 fputs_filtered ("Argument required (target name). Try `help target'\n",
235 /* Add a possible target architecture to the list. */
238 add_target (struct target_ops
*t
)
240 /* Provide default values for all "must have" methods. */
241 if (t
->to_xfer_partial
== NULL
)
242 t
->to_xfer_partial
= default_xfer_partial
;
246 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
247 target_structs
= (struct target_ops
**) xmalloc
248 (target_struct_allocsize
* sizeof (*target_structs
));
250 if (target_struct_size
>= target_struct_allocsize
)
252 target_struct_allocsize
*= 2;
253 target_structs
= (struct target_ops
**)
254 xrealloc ((char *) target_structs
,
255 target_struct_allocsize
* sizeof (*target_structs
));
257 target_structs
[target_struct_size
++] = t
;
259 if (targetlist
== NULL
)
260 add_prefix_cmd ("target", class_run
, target_command
, _("\
261 Connect to a target machine or process.\n\
262 The first argument is the type or protocol of the target machine.\n\
263 Remaining arguments are interpreted by the target protocol. For more\n\
264 information on the arguments for a particular protocol, type\n\
265 `help target ' followed by the protocol name."),
266 &targetlist
, "target ", 0, &cmdlist
);
267 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
278 target_load (char *arg
, int from_tty
)
280 dcache_invalidate (target_dcache
);
281 (*current_target
.to_load
) (arg
, from_tty
);
285 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
286 struct target_ops
*t
)
288 errno
= EIO
; /* Can't read/write this location */
289 return 0; /* No bytes handled */
295 error (_("You can't do that when your target is `%s'"),
296 current_target
.to_shortname
);
302 error (_("You can't do that without a process to debug."));
306 nosymbol (char *name
, CORE_ADDR
*addrp
)
308 return 1; /* Symbol does not exist in target env */
312 nosupport_runtime (void)
314 if (ptid_equal (inferior_ptid
, null_ptid
))
317 error (_("No run-time support for this"));
322 default_terminal_info (char *args
, int from_tty
)
324 printf_unfiltered (_("No saved terminal information.\n"));
327 /* This is the default target_create_inferior and target_attach function.
328 If the current target is executing, it asks whether to kill it off.
329 If this function returns without calling error(), it has killed off
330 the target, and the operation should be attempted. */
333 kill_or_be_killed (int from_tty
)
335 if (target_has_execution
)
337 printf_unfiltered (_("You are already running a program:\n"));
338 target_files_info ();
339 if (query ("Kill it? "))
342 if (target_has_execution
)
343 error (_("Killing the program did not help."));
348 error (_("Program not killed."));
354 /* A default implementation for the to_get_ada_task_ptid target method.
356 This function builds the PTID by using both LWP and TID as part of
357 the PTID lwp and tid elements. The pid used is the pid of the
361 default_get_ada_task_ptid (long lwp
, long tid
)
363 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
366 /* Go through the target stack from top to bottom, copying over zero
367 entries in current_target, then filling in still empty entries. In
368 effect, we are doing class inheritance through the pushed target
371 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
372 is currently implemented, is that it discards any knowledge of
373 which target an inherited method originally belonged to.
374 Consequently, new new target methods should instead explicitly and
375 locally search the target stack for the target that can handle the
379 update_current_target (void)
381 struct target_ops
*t
;
383 /* First, reset current's contents. */
384 memset (¤t_target
, 0, sizeof (current_target
));
386 #define INHERIT(FIELD, TARGET) \
387 if (!current_target.FIELD) \
388 current_target.FIELD = (TARGET)->FIELD
390 for (t
= target_stack
; t
; t
= t
->beneath
)
392 INHERIT (to_shortname
, t
);
393 INHERIT (to_longname
, t
);
395 /* Do not inherit to_open. */
396 /* Do not inherit to_close. */
397 INHERIT (to_attach
, t
);
398 INHERIT (to_post_attach
, t
);
399 INHERIT (to_attach_no_wait
, t
);
400 INHERIT (to_detach
, t
);
401 /* Do not inherit to_disconnect. */
402 INHERIT (to_resume
, t
);
403 INHERIT (to_wait
, t
);
404 INHERIT (to_fetch_registers
, t
);
405 INHERIT (to_store_registers
, t
);
406 INHERIT (to_prepare_to_store
, t
);
407 INHERIT (deprecated_xfer_memory
, t
);
408 INHERIT (to_files_info
, t
);
409 INHERIT (to_insert_breakpoint
, t
);
410 INHERIT (to_remove_breakpoint
, t
);
411 INHERIT (to_can_use_hw_breakpoint
, t
);
412 INHERIT (to_insert_hw_breakpoint
, t
);
413 INHERIT (to_remove_hw_breakpoint
, t
);
414 INHERIT (to_insert_watchpoint
, t
);
415 INHERIT (to_remove_watchpoint
, t
);
416 INHERIT (to_stopped_data_address
, t
);
417 INHERIT (to_have_steppable_watchpoint
, t
);
418 INHERIT (to_have_continuable_watchpoint
, t
);
419 INHERIT (to_stopped_by_watchpoint
, t
);
420 INHERIT (to_watchpoint_addr_within_range
, t
);
421 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
422 INHERIT (to_terminal_init
, t
);
423 INHERIT (to_terminal_inferior
, t
);
424 INHERIT (to_terminal_ours_for_output
, t
);
425 INHERIT (to_terminal_ours
, t
);
426 INHERIT (to_terminal_save_ours
, t
);
427 INHERIT (to_terminal_info
, t
);
428 INHERIT (to_kill
, t
);
429 INHERIT (to_load
, t
);
430 INHERIT (to_lookup_symbol
, t
);
431 INHERIT (to_create_inferior
, t
);
432 INHERIT (to_post_startup_inferior
, t
);
433 INHERIT (to_acknowledge_created_inferior
, t
);
434 INHERIT (to_insert_fork_catchpoint
, t
);
435 INHERIT (to_remove_fork_catchpoint
, t
);
436 INHERIT (to_insert_vfork_catchpoint
, t
);
437 INHERIT (to_remove_vfork_catchpoint
, t
);
438 /* Do not inherit to_follow_fork. */
439 INHERIT (to_insert_exec_catchpoint
, t
);
440 INHERIT (to_remove_exec_catchpoint
, t
);
441 INHERIT (to_has_exited
, t
);
442 INHERIT (to_mourn_inferior
, t
);
443 INHERIT (to_can_run
, t
);
444 INHERIT (to_notice_signals
, t
);
445 INHERIT (to_thread_alive
, t
);
446 INHERIT (to_find_new_threads
, t
);
447 INHERIT (to_pid_to_str
, t
);
448 INHERIT (to_extra_thread_info
, t
);
449 INHERIT (to_stop
, t
);
450 /* Do not inherit to_xfer_partial. */
451 INHERIT (to_rcmd
, t
);
452 INHERIT (to_pid_to_exec_file
, t
);
453 INHERIT (to_log_command
, t
);
454 INHERIT (to_stratum
, t
);
455 INHERIT (to_has_all_memory
, t
);
456 INHERIT (to_has_memory
, t
);
457 INHERIT (to_has_stack
, t
);
458 INHERIT (to_has_registers
, t
);
459 INHERIT (to_has_execution
, t
);
460 INHERIT (to_has_thread_control
, t
);
461 INHERIT (to_sections
, t
);
462 INHERIT (to_sections_end
, t
);
463 INHERIT (to_can_async_p
, t
);
464 INHERIT (to_is_async_p
, t
);
465 INHERIT (to_async
, t
);
466 INHERIT (to_async_mask
, t
);
467 INHERIT (to_find_memory_regions
, t
);
468 INHERIT (to_make_corefile_notes
, t
);
469 INHERIT (to_get_thread_local_address
, t
);
470 INHERIT (to_can_execute_reverse
, t
);
471 /* Do not inherit to_read_description. */
472 INHERIT (to_get_ada_task_ptid
, t
);
473 /* Do not inherit to_search_memory. */
474 INHERIT (to_supports_multi_process
, t
);
475 INHERIT (to_magic
, t
);
476 /* Do not inherit to_memory_map. */
477 /* Do not inherit to_flash_erase. */
478 /* Do not inherit to_flash_done. */
482 /* Clean up a target struct so it no longer has any zero pointers in
483 it. Some entries are defaulted to a method that print an error,
484 others are hard-wired to a standard recursive default. */
486 #define de_fault(field, value) \
487 if (!current_target.field) \
488 current_target.field = value
491 (void (*) (char *, int))
496 de_fault (to_post_attach
,
500 (void (*) (char *, int))
503 (void (*) (ptid_t
, int, enum target_signal
))
506 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
508 de_fault (to_fetch_registers
,
509 (void (*) (struct regcache
*, int))
511 de_fault (to_store_registers
,
512 (void (*) (struct regcache
*, int))
514 de_fault (to_prepare_to_store
,
515 (void (*) (struct regcache
*))
517 de_fault (deprecated_xfer_memory
,
518 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
520 de_fault (to_files_info
,
521 (void (*) (struct target_ops
*))
523 de_fault (to_insert_breakpoint
,
524 memory_insert_breakpoint
);
525 de_fault (to_remove_breakpoint
,
526 memory_remove_breakpoint
);
527 de_fault (to_can_use_hw_breakpoint
,
528 (int (*) (int, int, int))
530 de_fault (to_insert_hw_breakpoint
,
531 (int (*) (struct bp_target_info
*))
533 de_fault (to_remove_hw_breakpoint
,
534 (int (*) (struct bp_target_info
*))
536 de_fault (to_insert_watchpoint
,
537 (int (*) (CORE_ADDR
, int, int))
539 de_fault (to_remove_watchpoint
,
540 (int (*) (CORE_ADDR
, int, int))
542 de_fault (to_stopped_by_watchpoint
,
545 de_fault (to_stopped_data_address
,
546 (int (*) (struct target_ops
*, CORE_ADDR
*))
548 de_fault (to_watchpoint_addr_within_range
,
549 default_watchpoint_addr_within_range
);
550 de_fault (to_region_ok_for_hw_watchpoint
,
551 default_region_ok_for_hw_watchpoint
);
552 de_fault (to_terminal_init
,
555 de_fault (to_terminal_inferior
,
558 de_fault (to_terminal_ours_for_output
,
561 de_fault (to_terminal_ours
,
564 de_fault (to_terminal_save_ours
,
567 de_fault (to_terminal_info
,
568 default_terminal_info
);
573 (void (*) (char *, int))
575 de_fault (to_lookup_symbol
,
576 (int (*) (char *, CORE_ADDR
*))
578 de_fault (to_post_startup_inferior
,
581 de_fault (to_acknowledge_created_inferior
,
584 de_fault (to_insert_fork_catchpoint
,
587 de_fault (to_remove_fork_catchpoint
,
590 de_fault (to_insert_vfork_catchpoint
,
593 de_fault (to_remove_vfork_catchpoint
,
596 de_fault (to_insert_exec_catchpoint
,
599 de_fault (to_remove_exec_catchpoint
,
602 de_fault (to_has_exited
,
603 (int (*) (int, int, int *))
605 de_fault (to_mourn_inferior
,
608 de_fault (to_can_run
,
610 de_fault (to_notice_signals
,
613 de_fault (to_thread_alive
,
616 de_fault (to_find_new_threads
,
619 de_fault (to_extra_thread_info
,
620 (char *(*) (struct thread_info
*))
625 current_target
.to_xfer_partial
= current_xfer_partial
;
627 (void (*) (char *, struct ui_file
*))
629 de_fault (to_pid_to_exec_file
,
633 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
635 de_fault (to_async_mask
,
638 current_target
.to_read_description
= NULL
;
639 de_fault (to_get_ada_task_ptid
,
640 (ptid_t (*) (long, long))
641 default_get_ada_task_ptid
);
642 de_fault (to_supports_multi_process
,
647 /* Finally, position the target-stack beneath the squashed
648 "current_target". That way code looking for a non-inherited
649 target method can quickly and simply find it. */
650 current_target
.beneath
= target_stack
;
653 setup_target_debug ();
656 /* Mark OPS as a running target. This reverses the effect
657 of target_mark_exited. */
660 target_mark_running (struct target_ops
*ops
)
662 struct target_ops
*t
;
664 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
668 internal_error (__FILE__
, __LINE__
,
669 "Attempted to mark unpushed target \"%s\" as running",
672 ops
->to_has_execution
= 1;
673 ops
->to_has_all_memory
= 1;
674 ops
->to_has_memory
= 1;
675 ops
->to_has_stack
= 1;
676 ops
->to_has_registers
= 1;
678 update_current_target ();
681 /* Mark OPS as a non-running target. This reverses the effect
682 of target_mark_running. */
685 target_mark_exited (struct target_ops
*ops
)
687 struct target_ops
*t
;
689 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
693 internal_error (__FILE__
, __LINE__
,
694 "Attempted to mark unpushed target \"%s\" as running",
697 ops
->to_has_execution
= 0;
698 ops
->to_has_all_memory
= 0;
699 ops
->to_has_memory
= 0;
700 ops
->to_has_stack
= 0;
701 ops
->to_has_registers
= 0;
703 update_current_target ();
706 /* Push a new target type into the stack of the existing target accessors,
707 possibly superseding some of the existing accessors.
709 Result is zero if the pushed target ended up on top of the stack,
710 nonzero if at least one target is on top of it.
712 Rather than allow an empty stack, we always have the dummy target at
713 the bottom stratum, so we can call the function vectors without
717 push_target (struct target_ops
*t
)
719 struct target_ops
**cur
;
721 /* Check magic number. If wrong, it probably means someone changed
722 the struct definition, but not all the places that initialize one. */
723 if (t
->to_magic
!= OPS_MAGIC
)
725 fprintf_unfiltered (gdb_stderr
,
726 "Magic number of %s target struct wrong\n",
728 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
731 /* Find the proper stratum to install this target in. */
732 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
734 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
738 /* If there's already targets at this stratum, remove them. */
739 /* FIXME: cagney/2003-10-15: I think this should be popping all
740 targets to CUR, and not just those at this stratum level. */
741 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
743 /* There's already something at this stratum level. Close it,
744 and un-hook it from the stack. */
745 struct target_ops
*tmp
= (*cur
);
746 (*cur
) = (*cur
)->beneath
;
748 target_close (tmp
, 0);
751 /* We have removed all targets in our stratum, now add the new one. */
755 update_current_target ();
758 return (t
!= target_stack
);
761 /* Remove a target_ops vector from the stack, wherever it may be.
762 Return how many times it was removed (0 or 1). */
765 unpush_target (struct target_ops
*t
)
767 struct target_ops
**cur
;
768 struct target_ops
*tmp
;
770 if (t
->to_stratum
== dummy_stratum
)
771 internal_error (__FILE__
, __LINE__
,
772 "Attempt to unpush the dummy target");
774 /* Look for the specified target. Note that we assume that a target
775 can only occur once in the target stack. */
777 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
784 return 0; /* Didn't find target_ops, quit now */
786 /* NOTE: cagney/2003-12-06: In '94 the close call was made
787 unconditional by moving it to before the above check that the
788 target was in the target stack (something about "Change the way
789 pushing and popping of targets work to support target overlays
790 and inheritance"). This doesn't make much sense - only open
791 targets should be closed. */
794 /* Unchain the target */
796 (*cur
) = (*cur
)->beneath
;
799 update_current_target ();
807 target_close (target_stack
, 0); /* Let it clean up */
808 if (unpush_target (target_stack
) == 1)
811 fprintf_unfiltered (gdb_stderr
,
812 "pop_target couldn't find target %s\n",
813 current_target
.to_shortname
);
814 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
818 pop_all_targets_above (enum strata above_stratum
, int quitting
)
820 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
822 target_close (target_stack
, quitting
);
823 if (!unpush_target (target_stack
))
825 fprintf_unfiltered (gdb_stderr
,
826 "pop_all_targets couldn't find target %s\n",
827 target_stack
->to_shortname
);
828 internal_error (__FILE__
, __LINE__
,
829 _("failed internal consistency check"));
836 pop_all_targets (int quitting
)
838 pop_all_targets_above (dummy_stratum
, quitting
);
841 /* Using the objfile specified in OBJFILE, find the address for the
842 current thread's thread-local storage with offset OFFSET. */
844 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
846 volatile CORE_ADDR addr
= 0;
848 if (target_get_thread_local_address_p ()
849 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
851 ptid_t ptid
= inferior_ptid
;
852 volatile struct gdb_exception ex
;
854 TRY_CATCH (ex
, RETURN_MASK_ALL
)
858 /* Fetch the load module address for this objfile. */
859 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
861 /* If it's 0, throw the appropriate exception. */
863 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
864 _("TLS load module not found"));
866 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
868 /* If an error occurred, print TLS related messages here. Otherwise,
869 throw the error to some higher catcher. */
872 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
876 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
877 error (_("Cannot find thread-local variables in this thread library."));
879 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
880 if (objfile_is_library
)
881 error (_("Cannot find shared library `%s' in dynamic"
882 " linker's load module list"), objfile
->name
);
884 error (_("Cannot find executable file `%s' in dynamic"
885 " linker's load module list"), objfile
->name
);
887 case TLS_NOT_ALLOCATED_YET_ERROR
:
888 if (objfile_is_library
)
889 error (_("The inferior has not yet allocated storage for"
890 " thread-local variables in\n"
891 "the shared library `%s'\n"
893 objfile
->name
, target_pid_to_str (ptid
));
895 error (_("The inferior has not yet allocated storage for"
896 " thread-local variables in\n"
897 "the executable `%s'\n"
899 objfile
->name
, target_pid_to_str (ptid
));
901 case TLS_GENERIC_ERROR
:
902 if (objfile_is_library
)
903 error (_("Cannot find thread-local storage for %s, "
904 "shared library %s:\n%s"),
905 target_pid_to_str (ptid
),
906 objfile
->name
, ex
.message
);
908 error (_("Cannot find thread-local storage for %s, "
909 "executable file %s:\n%s"),
910 target_pid_to_str (ptid
),
911 objfile
->name
, ex
.message
);
914 throw_exception (ex
);
919 /* It wouldn't be wrong here to try a gdbarch method, too; finding
920 TLS is an ABI-specific thing. But we don't do that yet. */
922 error (_("Cannot find thread-local variables on this target"));
928 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
930 /* target_read_string -- read a null terminated string, up to LEN bytes,
931 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
932 Set *STRING to a pointer to malloc'd memory containing the data; the caller
933 is responsible for freeing it. Return the number of bytes successfully
937 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
939 int tlen
, origlen
, offset
, i
;
943 int buffer_allocated
;
945 unsigned int nbytes_read
= 0;
949 /* Small for testing. */
950 buffer_allocated
= 4;
951 buffer
= xmalloc (buffer_allocated
);
958 tlen
= MIN (len
, 4 - (memaddr
& 3));
959 offset
= memaddr
& 3;
961 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
964 /* The transfer request might have crossed the boundary to an
965 unallocated region of memory. Retry the transfer, requesting
969 errcode
= target_read_memory (memaddr
, buf
, 1);
974 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
977 bytes
= bufptr
- buffer
;
978 buffer_allocated
*= 2;
979 buffer
= xrealloc (buffer
, buffer_allocated
);
980 bufptr
= buffer
+ bytes
;
983 for (i
= 0; i
< tlen
; i
++)
985 *bufptr
++ = buf
[i
+ offset
];
986 if (buf
[i
+ offset
] == '\000')
988 nbytes_read
+= i
+ 1;
1004 /* Find a section containing ADDR. */
1005 struct section_table
*
1006 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1008 struct section_table
*secp
;
1009 for (secp
= target
->to_sections
;
1010 secp
< target
->to_sections_end
;
1013 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1019 /* Perform a partial memory transfer. The arguments and return
1020 value are just as for target_xfer_partial. */
1023 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1024 ULONGEST memaddr
, LONGEST len
)
1028 struct mem_region
*region
;
1030 /* Zero length requests are ok and require no work. */
1034 /* Try the executable file, if "trust-readonly-sections" is set. */
1035 if (readbuf
!= NULL
&& trust_readonly
)
1037 struct section_table
*secp
;
1039 secp
= target_section_by_addr (ops
, memaddr
);
1041 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1043 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1046 /* Likewise for accesses to unmapped overlay sections. */
1047 if (readbuf
!= NULL
&& overlay_debugging
)
1049 struct obj_section
*section
= find_pc_overlay (memaddr
);
1050 if (pc_in_unmapped_range (memaddr
, section
))
1051 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1054 /* Try GDB's internal data cache. */
1055 region
= lookup_mem_region (memaddr
);
1056 /* region->hi == 0 means there's no upper bound. */
1057 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1060 reg_len
= region
->hi
- memaddr
;
1062 switch (region
->attrib
.mode
)
1065 if (writebuf
!= NULL
)
1070 if (readbuf
!= NULL
)
1075 /* We only support writing to flash during "load" for now. */
1076 if (writebuf
!= NULL
)
1077 error (_("Writing to flash memory forbidden in this context"));
1084 if (region
->attrib
.cache
)
1086 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1087 memory request will start back at current_target. */
1088 if (readbuf
!= NULL
)
1089 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1092 /* FIXME drow/2006-08-09: If we're going to preserve const
1093 correctness dcache_xfer_memory should take readbuf and
1095 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1102 if (readbuf
&& !show_memory_breakpoints
)
1103 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1108 /* If none of those methods found the memory we wanted, fall back
1109 to a target partial transfer. Normally a single call to
1110 to_xfer_partial is enough; if it doesn't recognize an object
1111 it will call the to_xfer_partial of the next target down.
1112 But for memory this won't do. Memory is the only target
1113 object which can be read from more than one valid target.
1114 A core file, for instance, could have some of memory but
1115 delegate other bits to the target below it. So, we must
1116 manually try all targets. */
1120 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1121 readbuf
, writebuf
, memaddr
, reg_len
);
1125 /* We want to continue past core files to executables, but not
1126 past a running target's memory. */
1127 if (ops
->to_has_all_memory
)
1132 while (ops
!= NULL
);
1134 if (readbuf
&& !show_memory_breakpoints
)
1135 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1137 /* If we still haven't got anything, return the last error. We
1143 restore_show_memory_breakpoints (void *arg
)
1145 show_memory_breakpoints
= (uintptr_t) arg
;
1149 make_show_memory_breakpoints_cleanup (int show
)
1151 int current
= show_memory_breakpoints
;
1152 show_memory_breakpoints
= show
;
1154 return make_cleanup (restore_show_memory_breakpoints
,
1155 (void *) (uintptr_t) current
);
1159 target_xfer_partial (struct target_ops
*ops
,
1160 enum target_object object
, const char *annex
,
1161 void *readbuf
, const void *writebuf
,
1162 ULONGEST offset
, LONGEST len
)
1166 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1168 /* If this is a memory transfer, let the memory-specific code
1169 have a look at it instead. Memory transfers are more
1171 if (object
== TARGET_OBJECT_MEMORY
)
1172 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1175 enum target_object raw_object
= object
;
1177 /* If this is a raw memory transfer, request the normal
1178 memory object from other layers. */
1179 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1180 raw_object
= TARGET_OBJECT_MEMORY
;
1182 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1183 writebuf
, offset
, len
);
1188 const unsigned char *myaddr
= NULL
;
1190 fprintf_unfiltered (gdb_stdlog
,
1191 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
1194 (annex
? annex
: "(null)"),
1195 (long) readbuf
, (long) writebuf
,
1196 core_addr_to_string_nz (offset
),
1197 plongest (len
), plongest (retval
));
1203 if (retval
> 0 && myaddr
!= NULL
)
1207 fputs_unfiltered (", bytes =", gdb_stdlog
);
1208 for (i
= 0; i
< retval
; i
++)
1210 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1212 if (targetdebug
< 2 && i
> 0)
1214 fprintf_unfiltered (gdb_stdlog
, " ...");
1217 fprintf_unfiltered (gdb_stdlog
, "\n");
1220 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1224 fputc_unfiltered ('\n', gdb_stdlog
);
1229 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1230 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1231 if any error occurs.
1233 If an error occurs, no guarantee is made about the contents of the data at
1234 MYADDR. In particular, the caller should not depend upon partial reads
1235 filling the buffer with good data. There is no way for the caller to know
1236 how much good data might have been transfered anyway. Callers that can
1237 deal with partial reads should call target_read (which will retry until
1238 it makes no progress, and then return how much was transferred). */
1241 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1243 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1244 myaddr
, memaddr
, len
) == len
)
1251 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1253 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1254 myaddr
, memaddr
, len
) == len
)
1260 /* Fetch the target's memory map. */
1263 target_memory_map (void)
1265 VEC(mem_region_s
) *result
;
1266 struct mem_region
*last_one
, *this_one
;
1268 struct target_ops
*t
;
1271 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1273 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1274 if (t
->to_memory_map
!= NULL
)
1280 result
= t
->to_memory_map (t
);
1284 qsort (VEC_address (mem_region_s
, result
),
1285 VEC_length (mem_region_s
, result
),
1286 sizeof (struct mem_region
), mem_region_cmp
);
1288 /* Check that regions do not overlap. Simultaneously assign
1289 a numbering for the "mem" commands to use to refer to
1292 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1294 this_one
->number
= ix
;
1296 if (last_one
&& last_one
->hi
> this_one
->lo
)
1298 warning (_("Overlapping regions in memory map: ignoring"));
1299 VEC_free (mem_region_s
, result
);
1302 last_one
= this_one
;
1309 target_flash_erase (ULONGEST address
, LONGEST length
)
1311 struct target_ops
*t
;
1313 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1314 if (t
->to_flash_erase
!= NULL
)
1317 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1318 paddr (address
), phex (length
, 0));
1319 t
->to_flash_erase (t
, address
, length
);
1327 target_flash_done (void)
1329 struct target_ops
*t
;
1331 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1332 if (t
->to_flash_done
!= NULL
)
1335 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1336 t
->to_flash_done (t
);
1343 #ifndef target_stopped_data_address_p
1345 target_stopped_data_address_p (struct target_ops
*target
)
1347 if (target
->to_stopped_data_address
1348 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1350 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1351 && (debug_target
.to_stopped_data_address
1352 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1359 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1360 struct cmd_list_element
*c
, const char *value
)
1362 fprintf_filtered (file
, _("\
1363 Mode for reading from readonly sections is %s.\n"),
1367 /* More generic transfers. */
1370 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1371 const char *annex
, gdb_byte
*readbuf
,
1372 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1374 if (object
== TARGET_OBJECT_MEMORY
1375 && ops
->deprecated_xfer_memory
!= NULL
)
1376 /* If available, fall back to the target's
1377 "deprecated_xfer_memory" method. */
1381 if (writebuf
!= NULL
)
1383 void *buffer
= xmalloc (len
);
1384 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1385 memcpy (buffer
, writebuf
, len
);
1386 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1387 1/*write*/, NULL
, ops
);
1388 do_cleanups (cleanup
);
1390 if (readbuf
!= NULL
)
1391 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1392 0/*read*/, NULL
, ops
);
1395 else if (xfered
== 0 && errno
== 0)
1396 /* "deprecated_xfer_memory" uses 0, cross checked against
1397 ERRNO as one indication of an error. */
1402 else if (ops
->beneath
!= NULL
)
1403 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1404 readbuf
, writebuf
, offset
, len
);
1409 /* The xfer_partial handler for the topmost target. Unlike the default,
1410 it does not need to handle memory specially; it just passes all
1411 requests down the stack. */
1414 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1415 const char *annex
, gdb_byte
*readbuf
,
1416 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1418 if (ops
->beneath
!= NULL
)
1419 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1420 readbuf
, writebuf
, offset
, len
);
1425 /* Target vector read/write partial wrapper functions.
1427 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1428 (inbuf, outbuf)", instead of separate read/write methods, make life
1432 target_read_partial (struct target_ops
*ops
,
1433 enum target_object object
,
1434 const char *annex
, gdb_byte
*buf
,
1435 ULONGEST offset
, LONGEST len
)
1437 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1441 target_write_partial (struct target_ops
*ops
,
1442 enum target_object object
,
1443 const char *annex
, const gdb_byte
*buf
,
1444 ULONGEST offset
, LONGEST len
)
1446 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1449 /* Wrappers to perform the full transfer. */
1451 target_read (struct target_ops
*ops
,
1452 enum target_object object
,
1453 const char *annex
, gdb_byte
*buf
,
1454 ULONGEST offset
, LONGEST len
)
1457 while (xfered
< len
)
1459 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1460 (gdb_byte
*) buf
+ xfered
,
1461 offset
+ xfered
, len
- xfered
);
1462 /* Call an observer, notifying them of the xfer progress? */
1474 target_read_until_error (struct target_ops
*ops
,
1475 enum target_object object
,
1476 const char *annex
, gdb_byte
*buf
,
1477 ULONGEST offset
, LONGEST len
)
1480 while (xfered
< len
)
1482 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1483 (gdb_byte
*) buf
+ xfered
,
1484 offset
+ xfered
, len
- xfered
);
1485 /* Call an observer, notifying them of the xfer progress? */
1490 /* We've got an error. Try to read in smaller blocks. */
1491 ULONGEST start
= offset
+ xfered
;
1492 ULONGEST remaining
= len
- xfered
;
1495 /* If an attempt was made to read a random memory address,
1496 it's likely that the very first byte is not accessible.
1497 Try reading the first byte, to avoid doing log N tries
1499 xfer
= target_read_partial (ops
, object
, annex
,
1500 (gdb_byte
*) buf
+ xfered
, start
, 1);
1509 xfer
= target_read_partial (ops
, object
, annex
,
1510 (gdb_byte
*) buf
+ xfered
,
1520 /* We have successfully read the first half. So, the
1521 error must be in the second half. Adjust start and
1522 remaining to point at the second half. */
1539 /* An alternative to target_write with progress callbacks. */
1542 target_write_with_progress (struct target_ops
*ops
,
1543 enum target_object object
,
1544 const char *annex
, const gdb_byte
*buf
,
1545 ULONGEST offset
, LONGEST len
,
1546 void (*progress
) (ULONGEST
, void *), void *baton
)
1550 /* Give the progress callback a chance to set up. */
1552 (*progress
) (0, baton
);
1554 while (xfered
< len
)
1556 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1557 (gdb_byte
*) buf
+ xfered
,
1558 offset
+ xfered
, len
- xfered
);
1566 (*progress
) (xfer
, baton
);
1575 target_write (struct target_ops
*ops
,
1576 enum target_object object
,
1577 const char *annex
, const gdb_byte
*buf
,
1578 ULONGEST offset
, LONGEST len
)
1580 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1584 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1585 the size of the transferred data. PADDING additional bytes are
1586 available in *BUF_P. This is a helper function for
1587 target_read_alloc; see the declaration of that function for more
1591 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1592 const char *annex
, gdb_byte
**buf_p
, int padding
)
1594 size_t buf_alloc
, buf_pos
;
1598 /* This function does not have a length parameter; it reads the
1599 entire OBJECT). Also, it doesn't support objects fetched partly
1600 from one target and partly from another (in a different stratum,
1601 e.g. a core file and an executable). Both reasons make it
1602 unsuitable for reading memory. */
1603 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1605 /* Start by reading up to 4K at a time. The target will throttle
1606 this number down if necessary. */
1608 buf
= xmalloc (buf_alloc
);
1612 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1613 buf_pos
, buf_alloc
- buf_pos
- padding
);
1616 /* An error occurred. */
1622 /* Read all there was. */
1632 /* If the buffer is filling up, expand it. */
1633 if (buf_alloc
< buf_pos
* 2)
1636 buf
= xrealloc (buf
, buf_alloc
);
1643 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1644 the size of the transferred data. See the declaration in "target.h"
1645 function for more information about the return value. */
1648 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1649 const char *annex
, gdb_byte
**buf_p
)
1651 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1654 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1655 returned as a string, allocated using xmalloc. If an error occurs
1656 or the transfer is unsupported, NULL is returned. Empty objects
1657 are returned as allocated but empty strings. A warning is issued
1658 if the result contains any embedded NUL bytes. */
1661 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1665 LONGEST transferred
;
1667 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1669 if (transferred
< 0)
1672 if (transferred
== 0)
1673 return xstrdup ("");
1675 buffer
[transferred
] = 0;
1676 if (strlen (buffer
) < transferred
)
1677 warning (_("target object %d, annex %s, "
1678 "contained unexpected null characters"),
1679 (int) object
, annex
? annex
: "(none)");
1681 return (char *) buffer
;
1684 /* Memory transfer methods. */
1687 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1690 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1692 memory_error (EIO
, addr
);
1696 get_target_memory_unsigned (struct target_ops
*ops
,
1697 CORE_ADDR addr
, int len
)
1699 gdb_byte buf
[sizeof (ULONGEST
)];
1701 gdb_assert (len
<= sizeof (buf
));
1702 get_target_memory (ops
, addr
, buf
, len
);
1703 return extract_unsigned_integer (buf
, len
);
1707 target_info (char *args
, int from_tty
)
1709 struct target_ops
*t
;
1710 int has_all_mem
= 0;
1712 if (symfile_objfile
!= NULL
)
1713 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1715 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1717 if (!t
->to_has_memory
)
1720 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1723 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1724 printf_unfiltered ("%s:\n", t
->to_longname
);
1725 (t
->to_files_info
) (t
);
1726 has_all_mem
= t
->to_has_all_memory
;
1730 /* This function is called before any new inferior is created, e.g.
1731 by running a program, attaching, or connecting to a target.
1732 It cleans up any state from previous invocations which might
1733 change between runs. This is a subset of what target_preopen
1734 resets (things which might change between targets). */
1737 target_pre_inferior (int from_tty
)
1739 /* Clear out solib state. Otherwise the solib state of the previous
1740 inferior might have survived and is entirely wrong for the new
1741 target. This has been observed on GNU/Linux using glibc 2.3. How
1753 Cannot access memory at address 0xdeadbeef
1756 /* In some OSs, the shared library list is the same/global/shared
1757 across inferiors. If code is shared between processes, so are
1758 memory regions and features. */
1759 if (!gdbarch_has_global_solist (target_gdbarch
))
1761 no_shared_libraries (NULL
, from_tty
);
1763 invalidate_target_mem_regions ();
1765 target_clear_description ();
1769 /* This is to be called by the open routine before it does
1773 target_preopen (int from_tty
)
1777 if (target_has_execution
)
1780 || query (_("A program is being debugged already. Kill it? ")))
1783 error (_("Program not killed."));
1786 /* Calling target_kill may remove the target from the stack. But if
1787 it doesn't (which seems like a win for UDI), remove it now. */
1788 /* Leave the exec target, though. The user may be switching from a
1789 live process to a core of the same program. */
1790 pop_all_targets_above (file_stratum
, 0);
1792 target_pre_inferior (from_tty
);
1795 /* Detach a target after doing deferred register stores. */
1798 target_detach (char *args
, int from_tty
)
1800 if (gdbarch_has_global_solist (target_gdbarch
))
1801 /* Don't remove global breakpoints here. They're removed on
1802 disconnection from the target. */
1805 /* If we're in breakpoints-always-inserted mode, have to remove
1806 them before detaching. */
1807 remove_breakpoints ();
1809 (current_target
.to_detach
) (args
, from_tty
);
1813 target_disconnect (char *args
, int from_tty
)
1815 struct target_ops
*t
;
1817 /* If we're in breakpoints-always-inserted mode or if breakpoints
1818 are global across processes, we have to remove them before
1820 remove_breakpoints ();
1822 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1823 if (t
->to_disconnect
!= NULL
)
1826 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1828 t
->to_disconnect (t
, args
, from_tty
);
1836 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1838 dcache_invalidate (target_dcache
);
1839 (*current_target
.to_resume
) (ptid
, step
, signal
);
1840 set_executing (ptid
, 1);
1841 set_running (ptid
, 1);
1843 /* Look through the list of possible targets for a target that can
1847 target_follow_fork (int follow_child
)
1849 struct target_ops
*t
;
1851 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1853 if (t
->to_follow_fork
!= NULL
)
1855 int retval
= t
->to_follow_fork (t
, follow_child
);
1857 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1858 follow_child
, retval
);
1863 /* Some target returned a fork event, but did not know how to follow it. */
1864 internal_error (__FILE__
, __LINE__
,
1865 "could not find a target to follow fork");
1868 /* Look for a target which can describe architectural features, starting
1869 from TARGET. If we find one, return its description. */
1871 const struct target_desc
*
1872 target_read_description (struct target_ops
*target
)
1874 struct target_ops
*t
;
1876 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1877 if (t
->to_read_description
!= NULL
)
1879 const struct target_desc
*tdesc
;
1881 tdesc
= t
->to_read_description (t
);
1889 /* The default implementation of to_search_memory.
1890 This implements a basic search of memory, reading target memory and
1891 performing the search here (as opposed to performing the search in on the
1892 target side with, for example, gdbserver). */
1895 simple_search_memory (struct target_ops
*ops
,
1896 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1897 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1898 CORE_ADDR
*found_addrp
)
1900 /* NOTE: also defined in find.c testcase. */
1901 #define SEARCH_CHUNK_SIZE 16000
1902 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1903 /* Buffer to hold memory contents for searching. */
1904 gdb_byte
*search_buf
;
1905 unsigned search_buf_size
;
1906 struct cleanup
*old_cleanups
;
1908 search_buf_size
= chunk_size
+ pattern_len
- 1;
1910 /* No point in trying to allocate a buffer larger than the search space. */
1911 if (search_space_len
< search_buf_size
)
1912 search_buf_size
= search_space_len
;
1914 search_buf
= malloc (search_buf_size
);
1915 if (search_buf
== NULL
)
1916 error (_("Unable to allocate memory to perform the search."));
1917 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1919 /* Prime the search buffer. */
1921 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1922 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1924 warning (_("Unable to access target memory at %s, halting search."),
1925 hex_string (start_addr
));
1926 do_cleanups (old_cleanups
);
1930 /* Perform the search.
1932 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1933 When we've scanned N bytes we copy the trailing bytes to the start and
1934 read in another N bytes. */
1936 while (search_space_len
>= pattern_len
)
1938 gdb_byte
*found_ptr
;
1939 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1941 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1942 pattern
, pattern_len
);
1944 if (found_ptr
!= NULL
)
1946 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1947 *found_addrp
= found_addr
;
1948 do_cleanups (old_cleanups
);
1952 /* Not found in this chunk, skip to next chunk. */
1954 /* Don't let search_space_len wrap here, it's unsigned. */
1955 if (search_space_len
>= chunk_size
)
1956 search_space_len
-= chunk_size
;
1958 search_space_len
= 0;
1960 if (search_space_len
>= pattern_len
)
1962 unsigned keep_len
= search_buf_size
- chunk_size
;
1963 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1966 /* Copy the trailing part of the previous iteration to the front
1967 of the buffer for the next iteration. */
1968 gdb_assert (keep_len
== pattern_len
- 1);
1969 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1971 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1973 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1974 search_buf
+ keep_len
, read_addr
,
1975 nr_to_read
) != nr_to_read
)
1977 warning (_("Unable to access target memory at %s, halting search."),
1978 hex_string (read_addr
));
1979 do_cleanups (old_cleanups
);
1983 start_addr
+= chunk_size
;
1989 do_cleanups (old_cleanups
);
1993 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1994 sequence of bytes in PATTERN with length PATTERN_LEN.
1996 The result is 1 if found, 0 if not found, and -1 if there was an error
1997 requiring halting of the search (e.g. memory read error).
1998 If the pattern is found the address is recorded in FOUND_ADDRP. */
2001 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2002 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2003 CORE_ADDR
*found_addrp
)
2005 struct target_ops
*t
;
2008 /* We don't use INHERIT to set current_target.to_search_memory,
2009 so we have to scan the target stack and handle targetdebug
2013 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2014 hex_string (start_addr
));
2016 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2017 if (t
->to_search_memory
!= NULL
)
2022 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2023 pattern
, pattern_len
, found_addrp
);
2027 /* If a special version of to_search_memory isn't available, use the
2029 found
= simple_search_memory (¤t_target
,
2030 start_addr
, search_space_len
,
2031 pattern
, pattern_len
, found_addrp
);
2035 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2040 /* Look through the currently pushed targets. If none of them will
2041 be able to restart the currently running process, issue an error
2045 target_require_runnable (void)
2047 struct target_ops
*t
;
2049 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2051 /* If this target knows how to create a new program, then
2052 assume we will still be able to after killing the current
2053 one. Either killing and mourning will not pop T, or else
2054 find_default_run_target will find it again. */
2055 if (t
->to_create_inferior
!= NULL
)
2058 /* Do not worry about thread_stratum targets that can not
2059 create inferiors. Assume they will be pushed again if
2060 necessary, and continue to the process_stratum. */
2061 if (t
->to_stratum
== thread_stratum
)
2065 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2069 /* This function is only called if the target is running. In that
2070 case there should have been a process_stratum target and it
2071 should either know how to create inferiors, or not... */
2072 internal_error (__FILE__
, __LINE__
, "No targets found");
2075 /* Look through the list of possible targets for a target that can
2076 execute a run or attach command without any other data. This is
2077 used to locate the default process stratum.
2079 If DO_MESG is not NULL, the result is always valid (error() is
2080 called for errors); else, return NULL on error. */
2082 static struct target_ops
*
2083 find_default_run_target (char *do_mesg
)
2085 struct target_ops
**t
;
2086 struct target_ops
*runable
= NULL
;
2091 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2094 if ((*t
)->to_can_run
&& target_can_run (*t
))
2104 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2113 find_default_attach (char *args
, int from_tty
)
2115 struct target_ops
*t
;
2117 t
= find_default_run_target ("attach");
2118 (t
->to_attach
) (args
, from_tty
);
2123 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2126 struct target_ops
*t
;
2128 t
= find_default_run_target ("run");
2129 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2134 find_default_can_async_p (void)
2136 struct target_ops
*t
;
2138 /* This may be called before the target is pushed on the stack;
2139 look for the default process stratum. If there's none, gdb isn't
2140 configured with a native debugger, and target remote isn't
2142 t
= find_default_run_target (NULL
);
2143 if (t
&& t
->to_can_async_p
)
2144 return (t
->to_can_async_p
) ();
2149 find_default_is_async_p (void)
2151 struct target_ops
*t
;
2153 /* This may be called before the target is pushed on the stack;
2154 look for the default process stratum. If there's none, gdb isn't
2155 configured with a native debugger, and target remote isn't
2157 t
= find_default_run_target (NULL
);
2158 if (t
&& t
->to_is_async_p
)
2159 return (t
->to_is_async_p
) ();
2164 find_default_supports_non_stop (void)
2166 struct target_ops
*t
;
2168 t
= find_default_run_target (NULL
);
2169 if (t
&& t
->to_supports_non_stop
)
2170 return (t
->to_supports_non_stop
) ();
2175 target_supports_non_stop ()
2177 struct target_ops
*t
;
2178 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2179 if (t
->to_supports_non_stop
)
2180 return t
->to_supports_non_stop ();
2187 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2189 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2193 default_watchpoint_addr_within_range (struct target_ops
*target
,
2195 CORE_ADDR start
, int length
)
2197 return addr
>= start
&& addr
< start
+ length
;
2213 return_minus_one (void)
2219 * Resize the to_sections pointer. Also make sure that anyone that
2220 * was holding on to an old value of it gets updated.
2221 * Returns the old size.
2225 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2227 struct target_ops
**t
;
2228 struct section_table
*old_value
;
2231 old_value
= target
->to_sections
;
2233 if (target
->to_sections
)
2235 old_count
= target
->to_sections_end
- target
->to_sections
;
2236 target
->to_sections
= (struct section_table
*)
2237 xrealloc ((char *) target
->to_sections
,
2238 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2243 target
->to_sections
= (struct section_table
*)
2244 xmalloc ((sizeof (struct section_table
)) * num_added
);
2246 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2248 /* Check to see if anyone else was pointing to this structure.
2249 If old_value was null, then no one was. */
2253 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2256 if ((*t
)->to_sections
== old_value
)
2258 (*t
)->to_sections
= target
->to_sections
;
2259 (*t
)->to_sections_end
= target
->to_sections_end
;
2262 /* There is a flattened view of the target stack in current_target,
2263 so its to_sections pointer might also need updating. */
2264 if (current_target
.to_sections
== old_value
)
2266 current_target
.to_sections
= target
->to_sections
;
2267 current_target
.to_sections_end
= target
->to_sections_end
;
2275 /* Remove all target sections taken from ABFD.
2277 Scan the current target stack for targets whose section tables
2278 refer to sections from BFD, and remove those sections. We use this
2279 when we notice that the inferior has unloaded a shared object, for
2282 remove_target_sections (bfd
*abfd
)
2284 struct target_ops
**t
;
2286 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2288 struct section_table
*src
, *dest
;
2290 dest
= (*t
)->to_sections
;
2291 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2292 if (src
->bfd
!= abfd
)
2294 /* Keep this section. */
2295 if (dest
< src
) *dest
= *src
;
2299 /* If we've dropped any sections, resize the section table. */
2301 target_resize_to_sections (*t
, dest
- src
);
2308 /* Find a single runnable target in the stack and return it. If for
2309 some reason there is more than one, return NULL. */
2312 find_run_target (void)
2314 struct target_ops
**t
;
2315 struct target_ops
*runable
= NULL
;
2320 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2322 if ((*t
)->to_can_run
&& target_can_run (*t
))
2329 return (count
== 1 ? runable
: NULL
);
2332 /* Find a single core_stratum target in the list of targets and return it.
2333 If for some reason there is more than one, return NULL. */
2336 find_core_target (void)
2338 struct target_ops
**t
;
2339 struct target_ops
*runable
= NULL
;
2344 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2347 if ((*t
)->to_stratum
== core_stratum
)
2354 return (count
== 1 ? runable
: NULL
);
2358 * Find the next target down the stack from the specified target.
2362 find_target_beneath (struct target_ops
*t
)
2368 /* The inferior process has died. Long live the inferior! */
2371 generic_mourn_inferior (void)
2375 ptid
= inferior_ptid
;
2376 inferior_ptid
= null_ptid
;
2378 if (!ptid_equal (ptid
, null_ptid
))
2380 int pid
= ptid_get_pid (ptid
);
2381 delete_inferior (pid
);
2384 breakpoint_init_inferior (inf_exited
);
2385 registers_changed ();
2387 reopen_exec_file ();
2388 reinit_frame_cache ();
2390 if (deprecated_detach_hook
)
2391 deprecated_detach_hook ();
2394 /* Helper function for child_wait and the derivatives of child_wait.
2395 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2396 translation of that in OURSTATUS. */
2398 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2400 if (WIFEXITED (hoststatus
))
2402 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2403 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2405 else if (!WIFSTOPPED (hoststatus
))
2407 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2408 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2412 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2413 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2417 /* Returns zero to leave the inferior alone, one to interrupt it. */
2418 int (*target_activity_function
) (void);
2419 int target_activity_fd
;
2421 /* Convert a normal process ID to a string. Returns the string in a
2425 normal_pid_to_str (ptid_t ptid
)
2427 static char buf
[32];
2429 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2433 /* Error-catcher for target_find_memory_regions */
2434 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2436 error (_("No target."));
2440 /* Error-catcher for target_make_corefile_notes */
2441 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2443 error (_("No target."));
2447 /* Set up the handful of non-empty slots needed by the dummy target
2451 init_dummy_target (void)
2453 dummy_target
.to_shortname
= "None";
2454 dummy_target
.to_longname
= "None";
2455 dummy_target
.to_doc
= "";
2456 dummy_target
.to_attach
= find_default_attach
;
2457 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2458 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2459 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2460 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2461 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2462 dummy_target
.to_stratum
= dummy_stratum
;
2463 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2464 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2465 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2466 dummy_target
.to_magic
= OPS_MAGIC
;
2470 debug_to_open (char *args
, int from_tty
)
2472 debug_target
.to_open (args
, from_tty
);
2474 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2478 debug_to_close (int quitting
)
2480 target_close (&debug_target
, quitting
);
2481 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2485 target_close (struct target_ops
*targ
, int quitting
)
2487 if (targ
->to_xclose
!= NULL
)
2488 targ
->to_xclose (targ
, quitting
);
2489 else if (targ
->to_close
!= NULL
)
2490 targ
->to_close (quitting
);
2494 debug_to_attach (char *args
, int from_tty
)
2496 debug_target
.to_attach (args
, from_tty
);
2498 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2503 debug_to_post_attach (int pid
)
2505 debug_target
.to_post_attach (pid
);
2507 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2511 debug_to_detach (char *args
, int from_tty
)
2513 debug_target
.to_detach (args
, from_tty
);
2515 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2519 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2521 debug_target
.to_resume (ptid
, step
, siggnal
);
2523 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2524 step
? "step" : "continue",
2525 target_signal_to_name (siggnal
));
2529 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2533 retval
= debug_target
.to_wait (ptid
, status
);
2535 fprintf_unfiltered (gdb_stdlog
,
2536 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2538 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2539 switch (status
->kind
)
2541 case TARGET_WAITKIND_EXITED
:
2542 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2543 status
->value
.integer
);
2545 case TARGET_WAITKIND_STOPPED
:
2546 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2547 target_signal_to_name (status
->value
.sig
));
2549 case TARGET_WAITKIND_SIGNALLED
:
2550 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2551 target_signal_to_name (status
->value
.sig
));
2553 case TARGET_WAITKIND_LOADED
:
2554 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2556 case TARGET_WAITKIND_FORKED
:
2557 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2559 case TARGET_WAITKIND_VFORKED
:
2560 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2562 case TARGET_WAITKIND_EXECD
:
2563 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2565 case TARGET_WAITKIND_SPURIOUS
:
2566 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2569 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2577 debug_print_register (const char * func
,
2578 struct regcache
*regcache
, int regno
)
2580 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2581 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2582 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2583 && gdbarch_register_name (gdbarch
, regno
) != NULL
2584 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2585 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2586 gdbarch_register_name (gdbarch
, regno
));
2588 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2589 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2591 int i
, size
= register_size (gdbarch
, regno
);
2592 unsigned char buf
[MAX_REGISTER_SIZE
];
2593 regcache_raw_collect (regcache
, regno
, buf
);
2594 fprintf_unfiltered (gdb_stdlog
, " = ");
2595 for (i
= 0; i
< size
; i
++)
2597 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2599 if (size
<= sizeof (LONGEST
))
2601 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2602 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2603 core_addr_to_string_nz (val
), plongest (val
));
2606 fprintf_unfiltered (gdb_stdlog
, "\n");
2610 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2612 debug_target
.to_fetch_registers (regcache
, regno
);
2613 debug_print_register ("target_fetch_registers", regcache
, regno
);
2617 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2619 debug_target
.to_store_registers (regcache
, regno
);
2620 debug_print_register ("target_store_registers", regcache
, regno
);
2621 fprintf_unfiltered (gdb_stdlog
, "\n");
2625 debug_to_prepare_to_store (struct regcache
*regcache
)
2627 debug_target
.to_prepare_to_store (regcache
);
2629 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2633 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2634 int write
, struct mem_attrib
*attrib
,
2635 struct target_ops
*target
)
2639 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2642 fprintf_unfiltered (gdb_stdlog
,
2643 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2644 (unsigned int) memaddr
, /* possable truncate long long */
2645 len
, write
? "write" : "read", retval
);
2651 fputs_unfiltered (", bytes =", gdb_stdlog
);
2652 for (i
= 0; i
< retval
; i
++)
2654 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2656 if (targetdebug
< 2 && i
> 0)
2658 fprintf_unfiltered (gdb_stdlog
, " ...");
2661 fprintf_unfiltered (gdb_stdlog
, "\n");
2664 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2668 fputc_unfiltered ('\n', gdb_stdlog
);
2674 debug_to_files_info (struct target_ops
*target
)
2676 debug_target
.to_files_info (target
);
2678 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2682 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2686 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2688 fprintf_unfiltered (gdb_stdlog
,
2689 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2690 (unsigned long) bp_tgt
->placed_address
,
2691 (unsigned long) retval
);
2696 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2700 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2702 fprintf_unfiltered (gdb_stdlog
,
2703 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2704 (unsigned long) bp_tgt
->placed_address
,
2705 (unsigned long) retval
);
2710 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2714 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2716 fprintf_unfiltered (gdb_stdlog
,
2717 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2718 (unsigned long) type
,
2719 (unsigned long) cnt
,
2720 (unsigned long) from_tty
,
2721 (unsigned long) retval
);
2726 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2730 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2732 fprintf_unfiltered (gdb_stdlog
,
2733 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2734 (unsigned long) addr
,
2735 (unsigned long) len
,
2736 (unsigned long) retval
);
2741 debug_to_stopped_by_watchpoint (void)
2745 retval
= debug_target
.to_stopped_by_watchpoint ();
2747 fprintf_unfiltered (gdb_stdlog
,
2748 "STOPPED_BY_WATCHPOINT () = %ld\n",
2749 (unsigned long) retval
);
2754 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2758 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2760 fprintf_unfiltered (gdb_stdlog
,
2761 "target_stopped_data_address ([0x%lx]) = %ld\n",
2762 (unsigned long)*addr
,
2763 (unsigned long)retval
);
2768 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2770 CORE_ADDR start
, int length
)
2774 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2777 fprintf_filtered (gdb_stdlog
,
2778 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2779 (unsigned long) addr
, (unsigned long) start
, length
,
2785 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2789 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2791 fprintf_unfiltered (gdb_stdlog
,
2792 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2793 (unsigned long) bp_tgt
->placed_address
,
2794 (unsigned long) retval
);
2799 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2803 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2805 fprintf_unfiltered (gdb_stdlog
,
2806 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2807 (unsigned long) bp_tgt
->placed_address
,
2808 (unsigned long) retval
);
2813 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2817 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2819 fprintf_unfiltered (gdb_stdlog
,
2820 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2821 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2826 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2830 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2832 fprintf_unfiltered (gdb_stdlog
,
2833 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2834 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2839 debug_to_terminal_init (void)
2841 debug_target
.to_terminal_init ();
2843 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2847 debug_to_terminal_inferior (void)
2849 debug_target
.to_terminal_inferior ();
2851 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2855 debug_to_terminal_ours_for_output (void)
2857 debug_target
.to_terminal_ours_for_output ();
2859 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2863 debug_to_terminal_ours (void)
2865 debug_target
.to_terminal_ours ();
2867 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2871 debug_to_terminal_save_ours (void)
2873 debug_target
.to_terminal_save_ours ();
2875 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2879 debug_to_terminal_info (char *arg
, int from_tty
)
2881 debug_target
.to_terminal_info (arg
, from_tty
);
2883 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2888 debug_to_kill (void)
2890 debug_target
.to_kill ();
2892 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2896 debug_to_load (char *args
, int from_tty
)
2898 debug_target
.to_load (args
, from_tty
);
2900 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2904 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2908 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2910 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2916 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2919 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2921 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2922 exec_file
, args
, from_tty
);
2926 debug_to_post_startup_inferior (ptid_t ptid
)
2928 debug_target
.to_post_startup_inferior (ptid
);
2930 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2935 debug_to_acknowledge_created_inferior (int pid
)
2937 debug_target
.to_acknowledge_created_inferior (pid
);
2939 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2944 debug_to_insert_fork_catchpoint (int pid
)
2946 debug_target
.to_insert_fork_catchpoint (pid
);
2948 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2953 debug_to_remove_fork_catchpoint (int pid
)
2957 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2959 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2966 debug_to_insert_vfork_catchpoint (int pid
)
2968 debug_target
.to_insert_vfork_catchpoint (pid
);
2970 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2975 debug_to_remove_vfork_catchpoint (int pid
)
2979 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2981 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2988 debug_to_insert_exec_catchpoint (int pid
)
2990 debug_target
.to_insert_exec_catchpoint (pid
);
2992 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2997 debug_to_remove_exec_catchpoint (int pid
)
3001 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
3003 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
3010 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
3014 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
3016 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
3017 pid
, wait_status
, *exit_status
, has_exited
);
3023 debug_to_mourn_inferior (void)
3025 debug_target
.to_mourn_inferior ();
3027 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3031 debug_to_can_run (void)
3035 retval
= debug_target
.to_can_run ();
3037 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3043 debug_to_notice_signals (ptid_t ptid
)
3045 debug_target
.to_notice_signals (ptid
);
3047 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3052 debug_to_thread_alive (ptid_t ptid
)
3056 retval
= debug_target
.to_thread_alive (ptid
);
3058 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3059 PIDGET (ptid
), retval
);
3065 debug_to_find_new_threads (void)
3067 debug_target
.to_find_new_threads ();
3069 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3073 debug_to_stop (ptid_t ptid
)
3075 debug_target
.to_stop (ptid
);
3077 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3078 target_pid_to_str (ptid
));
3082 debug_to_rcmd (char *command
,
3083 struct ui_file
*outbuf
)
3085 debug_target
.to_rcmd (command
, outbuf
);
3086 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3090 debug_to_pid_to_exec_file (int pid
)
3094 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3096 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3103 setup_target_debug (void)
3105 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3107 current_target
.to_open
= debug_to_open
;
3108 current_target
.to_close
= debug_to_close
;
3109 current_target
.to_attach
= debug_to_attach
;
3110 current_target
.to_post_attach
= debug_to_post_attach
;
3111 current_target
.to_detach
= debug_to_detach
;
3112 current_target
.to_resume
= debug_to_resume
;
3113 current_target
.to_wait
= debug_to_wait
;
3114 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3115 current_target
.to_store_registers
= debug_to_store_registers
;
3116 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3117 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3118 current_target
.to_files_info
= debug_to_files_info
;
3119 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3120 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3121 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3122 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3123 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3124 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3125 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3126 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3127 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3128 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3129 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3130 current_target
.to_terminal_init
= debug_to_terminal_init
;
3131 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3132 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3133 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3134 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3135 current_target
.to_terminal_info
= debug_to_terminal_info
;
3136 current_target
.to_kill
= debug_to_kill
;
3137 current_target
.to_load
= debug_to_load
;
3138 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3139 current_target
.to_create_inferior
= debug_to_create_inferior
;
3140 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3141 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3142 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3143 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3144 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3145 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3146 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3147 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3148 current_target
.to_has_exited
= debug_to_has_exited
;
3149 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3150 current_target
.to_can_run
= debug_to_can_run
;
3151 current_target
.to_notice_signals
= debug_to_notice_signals
;
3152 current_target
.to_thread_alive
= debug_to_thread_alive
;
3153 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3154 current_target
.to_stop
= debug_to_stop
;
3155 current_target
.to_rcmd
= debug_to_rcmd
;
3156 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3160 static char targ_desc
[] =
3161 "Names of targets and files being debugged.\n\
3162 Shows the entire stack of targets currently in use (including the exec-file,\n\
3163 core-file, and process, if any), as well as the symbol file name.";
3166 do_monitor_command (char *cmd
,
3169 if ((current_target
.to_rcmd
3170 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3171 || (current_target
.to_rcmd
== debug_to_rcmd
3172 && (debug_target
.to_rcmd
3173 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3174 error (_("\"monitor\" command not supported by this target."));
3175 target_rcmd (cmd
, gdb_stdtarg
);
3178 /* Print the name of each layers of our target stack. */
3181 maintenance_print_target_stack (char *cmd
, int from_tty
)
3183 struct target_ops
*t
;
3185 printf_filtered (_("The current target stack is:\n"));
3187 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3189 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3193 /* Controls if async mode is permitted. */
3194 int target_async_permitted
= 0;
3196 /* The set command writes to this variable. If the inferior is
3197 executing, linux_nat_async_permitted is *not* updated. */
3198 static int target_async_permitted_1
= 0;
3201 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3202 struct cmd_list_element
*c
)
3204 if (target_has_execution
)
3206 target_async_permitted_1
= target_async_permitted
;
3207 error (_("Cannot change this setting while the inferior is running."));
3210 target_async_permitted
= target_async_permitted_1
;
3214 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3215 struct cmd_list_element
*c
,
3218 fprintf_filtered (file
, _("\
3219 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3223 initialize_targets (void)
3225 init_dummy_target ();
3226 push_target (&dummy_target
);
3228 add_info ("target", target_info
, targ_desc
);
3229 add_info ("files", target_info
, targ_desc
);
3231 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3232 Set target debugging."), _("\
3233 Show target debugging."), _("\
3234 When non-zero, target debugging is enabled. Higher numbers are more\n\
3235 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3239 &setdebuglist
, &showdebuglist
);
3241 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3242 &trust_readonly
, _("\
3243 Set mode for reading from readonly sections."), _("\
3244 Show mode for reading from readonly sections."), _("\
3245 When this mode is on, memory reads from readonly sections (such as .text)\n\
3246 will be read from the object file instead of from the target. This will\n\
3247 result in significant performance improvement for remote targets."),
3249 show_trust_readonly
,
3250 &setlist
, &showlist
);
3252 add_com ("monitor", class_obscure
, do_monitor_command
,
3253 _("Send a command to the remote monitor (remote targets only)."));
3255 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3256 _("Print the name of each layer of the internal target stack."),
3257 &maintenanceprintlist
);
3259 add_setshow_boolean_cmd ("target-async", no_class
,
3260 &target_async_permitted_1
, _("\
3261 Set whether gdb controls the inferior in asynchronous mode."), _("\
3262 Show whether gdb controls the inferior in asynchronous mode."), _("\
3263 Tells gdb whether to control the inferior in asynchronous mode."),
3264 set_maintenance_target_async_permitted
,
3265 show_maintenance_target_async_permitted
,
3269 target_dcache
= dcache_init ();