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_magic
, t
);
475 /* Do not inherit to_memory_map. */
476 /* Do not inherit to_flash_erase. */
477 /* Do not inherit to_flash_done. */
481 /* Clean up a target struct so it no longer has any zero pointers in
482 it. Some entries are defaulted to a method that print an error,
483 others are hard-wired to a standard recursive default. */
485 #define de_fault(field, value) \
486 if (!current_target.field) \
487 current_target.field = value
490 (void (*) (char *, int))
495 de_fault (to_post_attach
,
499 (void (*) (char *, int))
502 (void (*) (ptid_t
, int, enum target_signal
))
505 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
507 de_fault (to_fetch_registers
,
508 (void (*) (struct regcache
*, int))
510 de_fault (to_store_registers
,
511 (void (*) (struct regcache
*, int))
513 de_fault (to_prepare_to_store
,
514 (void (*) (struct regcache
*))
516 de_fault (deprecated_xfer_memory
,
517 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
519 de_fault (to_files_info
,
520 (void (*) (struct target_ops
*))
522 de_fault (to_insert_breakpoint
,
523 memory_insert_breakpoint
);
524 de_fault (to_remove_breakpoint
,
525 memory_remove_breakpoint
);
526 de_fault (to_can_use_hw_breakpoint
,
527 (int (*) (int, int, int))
529 de_fault (to_insert_hw_breakpoint
,
530 (int (*) (struct bp_target_info
*))
532 de_fault (to_remove_hw_breakpoint
,
533 (int (*) (struct bp_target_info
*))
535 de_fault (to_insert_watchpoint
,
536 (int (*) (CORE_ADDR
, int, int))
538 de_fault (to_remove_watchpoint
,
539 (int (*) (CORE_ADDR
, int, int))
541 de_fault (to_stopped_by_watchpoint
,
544 de_fault (to_stopped_data_address
,
545 (int (*) (struct target_ops
*, CORE_ADDR
*))
547 de_fault (to_watchpoint_addr_within_range
,
548 default_watchpoint_addr_within_range
);
549 de_fault (to_region_ok_for_hw_watchpoint
,
550 default_region_ok_for_hw_watchpoint
);
551 de_fault (to_terminal_init
,
554 de_fault (to_terminal_inferior
,
557 de_fault (to_terminal_ours_for_output
,
560 de_fault (to_terminal_ours
,
563 de_fault (to_terminal_save_ours
,
566 de_fault (to_terminal_info
,
567 default_terminal_info
);
572 (void (*) (char *, int))
574 de_fault (to_lookup_symbol
,
575 (int (*) (char *, CORE_ADDR
*))
577 de_fault (to_post_startup_inferior
,
580 de_fault (to_acknowledge_created_inferior
,
583 de_fault (to_insert_fork_catchpoint
,
586 de_fault (to_remove_fork_catchpoint
,
589 de_fault (to_insert_vfork_catchpoint
,
592 de_fault (to_remove_vfork_catchpoint
,
595 de_fault (to_insert_exec_catchpoint
,
598 de_fault (to_remove_exec_catchpoint
,
601 de_fault (to_has_exited
,
602 (int (*) (int, int, int *))
604 de_fault (to_mourn_inferior
,
607 de_fault (to_can_run
,
609 de_fault (to_notice_signals
,
612 de_fault (to_thread_alive
,
615 de_fault (to_find_new_threads
,
618 de_fault (to_extra_thread_info
,
619 (char *(*) (struct thread_info
*))
624 current_target
.to_xfer_partial
= current_xfer_partial
;
626 (void (*) (char *, struct ui_file
*))
628 de_fault (to_pid_to_exec_file
,
632 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
634 de_fault (to_async_mask
,
637 current_target
.to_read_description
= NULL
;
638 de_fault (to_get_ada_task_ptid
,
639 (ptid_t (*) (long, long))
640 default_get_ada_task_ptid
);
643 /* Finally, position the target-stack beneath the squashed
644 "current_target". That way code looking for a non-inherited
645 target method can quickly and simply find it. */
646 current_target
.beneath
= target_stack
;
649 setup_target_debug ();
652 /* Mark OPS as a running target. This reverses the effect
653 of target_mark_exited. */
656 target_mark_running (struct target_ops
*ops
)
658 struct target_ops
*t
;
660 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
664 internal_error (__FILE__
, __LINE__
,
665 "Attempted to mark unpushed target \"%s\" as running",
668 ops
->to_has_execution
= 1;
669 ops
->to_has_all_memory
= 1;
670 ops
->to_has_memory
= 1;
671 ops
->to_has_stack
= 1;
672 ops
->to_has_registers
= 1;
674 update_current_target ();
677 /* Mark OPS as a non-running target. This reverses the effect
678 of target_mark_running. */
681 target_mark_exited (struct target_ops
*ops
)
683 struct target_ops
*t
;
685 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
689 internal_error (__FILE__
, __LINE__
,
690 "Attempted to mark unpushed target \"%s\" as running",
693 ops
->to_has_execution
= 0;
694 ops
->to_has_all_memory
= 0;
695 ops
->to_has_memory
= 0;
696 ops
->to_has_stack
= 0;
697 ops
->to_has_registers
= 0;
699 update_current_target ();
702 /* Push a new target type into the stack of the existing target accessors,
703 possibly superseding some of the existing accessors.
705 Result is zero if the pushed target ended up on top of the stack,
706 nonzero if at least one target is on top of it.
708 Rather than allow an empty stack, we always have the dummy target at
709 the bottom stratum, so we can call the function vectors without
713 push_target (struct target_ops
*t
)
715 struct target_ops
**cur
;
717 /* Check magic number. If wrong, it probably means someone changed
718 the struct definition, but not all the places that initialize one. */
719 if (t
->to_magic
!= OPS_MAGIC
)
721 fprintf_unfiltered (gdb_stderr
,
722 "Magic number of %s target struct wrong\n",
724 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
727 /* Find the proper stratum to install this target in. */
728 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
730 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
734 /* If there's already targets at this stratum, remove them. */
735 /* FIXME: cagney/2003-10-15: I think this should be popping all
736 targets to CUR, and not just those at this stratum level. */
737 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
739 /* There's already something at this stratum level. Close it,
740 and un-hook it from the stack. */
741 struct target_ops
*tmp
= (*cur
);
742 (*cur
) = (*cur
)->beneath
;
744 target_close (tmp
, 0);
747 /* We have removed all targets in our stratum, now add the new one. */
751 update_current_target ();
754 return (t
!= target_stack
);
757 /* Remove a target_ops vector from the stack, wherever it may be.
758 Return how many times it was removed (0 or 1). */
761 unpush_target (struct target_ops
*t
)
763 struct target_ops
**cur
;
764 struct target_ops
*tmp
;
766 if (t
->to_stratum
== dummy_stratum
)
767 internal_error (__FILE__
, __LINE__
,
768 "Attempt to unpush the dummy target");
770 /* Look for the specified target. Note that we assume that a target
771 can only occur once in the target stack. */
773 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
780 return 0; /* Didn't find target_ops, quit now */
782 /* NOTE: cagney/2003-12-06: In '94 the close call was made
783 unconditional by moving it to before the above check that the
784 target was in the target stack (something about "Change the way
785 pushing and popping of targets work to support target overlays
786 and inheritance"). This doesn't make much sense - only open
787 targets should be closed. */
790 /* Unchain the target */
792 (*cur
) = (*cur
)->beneath
;
795 update_current_target ();
803 target_close (target_stack
, 0); /* Let it clean up */
804 if (unpush_target (target_stack
) == 1)
807 fprintf_unfiltered (gdb_stderr
,
808 "pop_target couldn't find target %s\n",
809 current_target
.to_shortname
);
810 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
814 pop_all_targets_above (enum strata above_stratum
, int quitting
)
816 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
818 target_close (target_stack
, quitting
);
819 if (!unpush_target (target_stack
))
821 fprintf_unfiltered (gdb_stderr
,
822 "pop_all_targets couldn't find target %s\n",
823 target_stack
->to_shortname
);
824 internal_error (__FILE__
, __LINE__
,
825 _("failed internal consistency check"));
832 pop_all_targets (int quitting
)
834 pop_all_targets_above (dummy_stratum
, quitting
);
837 /* Using the objfile specified in OBJFILE, find the address for the
838 current thread's thread-local storage with offset OFFSET. */
840 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
842 volatile CORE_ADDR addr
= 0;
844 if (target_get_thread_local_address_p ()
845 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
847 ptid_t ptid
= inferior_ptid
;
848 volatile struct gdb_exception ex
;
850 TRY_CATCH (ex
, RETURN_MASK_ALL
)
854 /* Fetch the load module address for this objfile. */
855 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
857 /* If it's 0, throw the appropriate exception. */
859 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
860 _("TLS load module not found"));
862 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
864 /* If an error occurred, print TLS related messages here. Otherwise,
865 throw the error to some higher catcher. */
868 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
872 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
873 error (_("Cannot find thread-local variables in this thread library."));
875 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
876 if (objfile_is_library
)
877 error (_("Cannot find shared library `%s' in dynamic"
878 " linker's load module list"), objfile
->name
);
880 error (_("Cannot find executable file `%s' in dynamic"
881 " linker's load module list"), objfile
->name
);
883 case TLS_NOT_ALLOCATED_YET_ERROR
:
884 if (objfile_is_library
)
885 error (_("The inferior has not yet allocated storage for"
886 " thread-local variables in\n"
887 "the shared library `%s'\n"
889 objfile
->name
, target_pid_to_str (ptid
));
891 error (_("The inferior has not yet allocated storage for"
892 " thread-local variables in\n"
893 "the executable `%s'\n"
895 objfile
->name
, target_pid_to_str (ptid
));
897 case TLS_GENERIC_ERROR
:
898 if (objfile_is_library
)
899 error (_("Cannot find thread-local storage for %s, "
900 "shared library %s:\n%s"),
901 target_pid_to_str (ptid
),
902 objfile
->name
, ex
.message
);
904 error (_("Cannot find thread-local storage for %s, "
905 "executable file %s:\n%s"),
906 target_pid_to_str (ptid
),
907 objfile
->name
, ex
.message
);
910 throw_exception (ex
);
915 /* It wouldn't be wrong here to try a gdbarch method, too; finding
916 TLS is an ABI-specific thing. But we don't do that yet. */
918 error (_("Cannot find thread-local variables on this target"));
924 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
926 /* target_read_string -- read a null terminated string, up to LEN bytes,
927 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
928 Set *STRING to a pointer to malloc'd memory containing the data; the caller
929 is responsible for freeing it. Return the number of bytes successfully
933 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
935 int tlen
, origlen
, offset
, i
;
939 int buffer_allocated
;
941 unsigned int nbytes_read
= 0;
945 /* Small for testing. */
946 buffer_allocated
= 4;
947 buffer
= xmalloc (buffer_allocated
);
954 tlen
= MIN (len
, 4 - (memaddr
& 3));
955 offset
= memaddr
& 3;
957 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
960 /* The transfer request might have crossed the boundary to an
961 unallocated region of memory. Retry the transfer, requesting
965 errcode
= target_read_memory (memaddr
, buf
, 1);
970 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
973 bytes
= bufptr
- buffer
;
974 buffer_allocated
*= 2;
975 buffer
= xrealloc (buffer
, buffer_allocated
);
976 bufptr
= buffer
+ bytes
;
979 for (i
= 0; i
< tlen
; i
++)
981 *bufptr
++ = buf
[i
+ offset
];
982 if (buf
[i
+ offset
] == '\000')
984 nbytes_read
+= i
+ 1;
1000 /* Find a section containing ADDR. */
1001 struct section_table
*
1002 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1004 struct section_table
*secp
;
1005 for (secp
= target
->to_sections
;
1006 secp
< target
->to_sections_end
;
1009 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1015 /* Perform a partial memory transfer. The arguments and return
1016 value are just as for target_xfer_partial. */
1019 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1020 ULONGEST memaddr
, LONGEST len
)
1024 struct mem_region
*region
;
1026 /* Zero length requests are ok and require no work. */
1030 /* Try the executable file, if "trust-readonly-sections" is set. */
1031 if (readbuf
!= NULL
&& trust_readonly
)
1033 struct section_table
*secp
;
1035 secp
= target_section_by_addr (ops
, memaddr
);
1037 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1039 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1042 /* Likewise for accesses to unmapped overlay sections. */
1043 if (readbuf
!= NULL
&& overlay_debugging
)
1045 struct obj_section
*section
= find_pc_overlay (memaddr
);
1046 if (pc_in_unmapped_range (memaddr
, section
))
1047 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1050 /* Try GDB's internal data cache. */
1051 region
= lookup_mem_region (memaddr
);
1052 /* region->hi == 0 means there's no upper bound. */
1053 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1056 reg_len
= region
->hi
- memaddr
;
1058 switch (region
->attrib
.mode
)
1061 if (writebuf
!= NULL
)
1066 if (readbuf
!= NULL
)
1071 /* We only support writing to flash during "load" for now. */
1072 if (writebuf
!= NULL
)
1073 error (_("Writing to flash memory forbidden in this context"));
1080 if (region
->attrib
.cache
)
1082 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1083 memory request will start back at current_target. */
1084 if (readbuf
!= NULL
)
1085 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1088 /* FIXME drow/2006-08-09: If we're going to preserve const
1089 correctness dcache_xfer_memory should take readbuf and
1091 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1098 if (readbuf
&& !show_memory_breakpoints
)
1099 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1104 /* If none of those methods found the memory we wanted, fall back
1105 to a target partial transfer. Normally a single call to
1106 to_xfer_partial is enough; if it doesn't recognize an object
1107 it will call the to_xfer_partial of the next target down.
1108 But for memory this won't do. Memory is the only target
1109 object which can be read from more than one valid target.
1110 A core file, for instance, could have some of memory but
1111 delegate other bits to the target below it. So, we must
1112 manually try all targets. */
1116 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1117 readbuf
, writebuf
, memaddr
, reg_len
);
1121 /* We want to continue past core files to executables, but not
1122 past a running target's memory. */
1123 if (ops
->to_has_all_memory
)
1128 while (ops
!= NULL
);
1130 if (readbuf
&& !show_memory_breakpoints
)
1131 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1133 /* If we still haven't got anything, return the last error. We
1139 restore_show_memory_breakpoints (void *arg
)
1141 show_memory_breakpoints
= (uintptr_t) arg
;
1145 make_show_memory_breakpoints_cleanup (int show
)
1147 int current
= show_memory_breakpoints
;
1148 show_memory_breakpoints
= show
;
1150 return make_cleanup (restore_show_memory_breakpoints
,
1151 (void *) (uintptr_t) current
);
1155 target_xfer_partial (struct target_ops
*ops
,
1156 enum target_object object
, const char *annex
,
1157 void *readbuf
, const void *writebuf
,
1158 ULONGEST offset
, LONGEST len
)
1162 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1164 /* If this is a memory transfer, let the memory-specific code
1165 have a look at it instead. Memory transfers are more
1167 if (object
== TARGET_OBJECT_MEMORY
)
1168 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1171 enum target_object raw_object
= object
;
1173 /* If this is a raw memory transfer, request the normal
1174 memory object from other layers. */
1175 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1176 raw_object
= TARGET_OBJECT_MEMORY
;
1178 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1179 writebuf
, offset
, len
);
1184 const unsigned char *myaddr
= NULL
;
1186 fprintf_unfiltered (gdb_stdlog
,
1187 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, %s, %s) = %s",
1190 (annex
? annex
: "(null)"),
1191 (long) readbuf
, (long) writebuf
,
1192 core_addr_to_string_nz (offset
),
1193 plongest (len
), plongest (retval
));
1199 if (retval
> 0 && myaddr
!= NULL
)
1203 fputs_unfiltered (", bytes =", gdb_stdlog
);
1204 for (i
= 0; i
< retval
; i
++)
1206 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1208 if (targetdebug
< 2 && i
> 0)
1210 fprintf_unfiltered (gdb_stdlog
, " ...");
1213 fprintf_unfiltered (gdb_stdlog
, "\n");
1216 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1220 fputc_unfiltered ('\n', gdb_stdlog
);
1225 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1226 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1227 if any error occurs.
1229 If an error occurs, no guarantee is made about the contents of the data at
1230 MYADDR. In particular, the caller should not depend upon partial reads
1231 filling the buffer with good data. There is no way for the caller to know
1232 how much good data might have been transfered anyway. Callers that can
1233 deal with partial reads should call target_read (which will retry until
1234 it makes no progress, and then return how much was transferred). */
1237 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1239 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1240 myaddr
, memaddr
, len
) == len
)
1247 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1249 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1250 myaddr
, memaddr
, len
) == len
)
1256 /* Fetch the target's memory map. */
1259 target_memory_map (void)
1261 VEC(mem_region_s
) *result
;
1262 struct mem_region
*last_one
, *this_one
;
1264 struct target_ops
*t
;
1267 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1269 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1270 if (t
->to_memory_map
!= NULL
)
1276 result
= t
->to_memory_map (t
);
1280 qsort (VEC_address (mem_region_s
, result
),
1281 VEC_length (mem_region_s
, result
),
1282 sizeof (struct mem_region
), mem_region_cmp
);
1284 /* Check that regions do not overlap. Simultaneously assign
1285 a numbering for the "mem" commands to use to refer to
1288 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1290 this_one
->number
= ix
;
1292 if (last_one
&& last_one
->hi
> this_one
->lo
)
1294 warning (_("Overlapping regions in memory map: ignoring"));
1295 VEC_free (mem_region_s
, result
);
1298 last_one
= this_one
;
1305 target_flash_erase (ULONGEST address
, LONGEST length
)
1307 struct target_ops
*t
;
1309 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1310 if (t
->to_flash_erase
!= NULL
)
1313 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1314 paddr (address
), phex (length
, 0));
1315 t
->to_flash_erase (t
, address
, length
);
1323 target_flash_done (void)
1325 struct target_ops
*t
;
1327 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1328 if (t
->to_flash_done
!= NULL
)
1331 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1332 t
->to_flash_done (t
);
1339 #ifndef target_stopped_data_address_p
1341 target_stopped_data_address_p (struct target_ops
*target
)
1343 if (target
->to_stopped_data_address
1344 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1346 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1347 && (debug_target
.to_stopped_data_address
1348 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1355 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1356 struct cmd_list_element
*c
, const char *value
)
1358 fprintf_filtered (file
, _("\
1359 Mode for reading from readonly sections is %s.\n"),
1363 /* More generic transfers. */
1366 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1367 const char *annex
, gdb_byte
*readbuf
,
1368 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1370 if (object
== TARGET_OBJECT_MEMORY
1371 && ops
->deprecated_xfer_memory
!= NULL
)
1372 /* If available, fall back to the target's
1373 "deprecated_xfer_memory" method. */
1377 if (writebuf
!= NULL
)
1379 void *buffer
= xmalloc (len
);
1380 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1381 memcpy (buffer
, writebuf
, len
);
1382 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1383 1/*write*/, NULL
, ops
);
1384 do_cleanups (cleanup
);
1386 if (readbuf
!= NULL
)
1387 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1388 0/*read*/, NULL
, ops
);
1391 else if (xfered
== 0 && errno
== 0)
1392 /* "deprecated_xfer_memory" uses 0, cross checked against
1393 ERRNO as one indication of an error. */
1398 else if (ops
->beneath
!= NULL
)
1399 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1400 readbuf
, writebuf
, offset
, len
);
1405 /* The xfer_partial handler for the topmost target. Unlike the default,
1406 it does not need to handle memory specially; it just passes all
1407 requests down the stack. */
1410 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1411 const char *annex
, gdb_byte
*readbuf
,
1412 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1414 if (ops
->beneath
!= NULL
)
1415 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1416 readbuf
, writebuf
, offset
, len
);
1421 /* Target vector read/write partial wrapper functions.
1423 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1424 (inbuf, outbuf)", instead of separate read/write methods, make life
1428 target_read_partial (struct target_ops
*ops
,
1429 enum target_object object
,
1430 const char *annex
, gdb_byte
*buf
,
1431 ULONGEST offset
, LONGEST len
)
1433 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1437 target_write_partial (struct target_ops
*ops
,
1438 enum target_object object
,
1439 const char *annex
, const gdb_byte
*buf
,
1440 ULONGEST offset
, LONGEST len
)
1442 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1445 /* Wrappers to perform the full transfer. */
1447 target_read (struct target_ops
*ops
,
1448 enum target_object object
,
1449 const char *annex
, gdb_byte
*buf
,
1450 ULONGEST offset
, LONGEST len
)
1453 while (xfered
< len
)
1455 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1456 (gdb_byte
*) buf
+ xfered
,
1457 offset
+ xfered
, len
- xfered
);
1458 /* Call an observer, notifying them of the xfer progress? */
1470 target_read_until_error (struct target_ops
*ops
,
1471 enum target_object object
,
1472 const char *annex
, gdb_byte
*buf
,
1473 ULONGEST offset
, LONGEST len
)
1476 while (xfered
< len
)
1478 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1479 (gdb_byte
*) buf
+ xfered
,
1480 offset
+ xfered
, len
- xfered
);
1481 /* Call an observer, notifying them of the xfer progress? */
1486 /* We've got an error. Try to read in smaller blocks. */
1487 ULONGEST start
= offset
+ xfered
;
1488 ULONGEST remaining
= len
- xfered
;
1491 /* If an attempt was made to read a random memory address,
1492 it's likely that the very first byte is not accessible.
1493 Try reading the first byte, to avoid doing log N tries
1495 xfer
= target_read_partial (ops
, object
, annex
,
1496 (gdb_byte
*) buf
+ xfered
, start
, 1);
1505 xfer
= target_read_partial (ops
, object
, annex
,
1506 (gdb_byte
*) buf
+ xfered
,
1516 /* We have successfully read the first half. So, the
1517 error must be in the second half. Adjust start and
1518 remaining to point at the second half. */
1535 /* An alternative to target_write with progress callbacks. */
1538 target_write_with_progress (struct target_ops
*ops
,
1539 enum target_object object
,
1540 const char *annex
, const gdb_byte
*buf
,
1541 ULONGEST offset
, LONGEST len
,
1542 void (*progress
) (ULONGEST
, void *), void *baton
)
1546 /* Give the progress callback a chance to set up. */
1548 (*progress
) (0, baton
);
1550 while (xfered
< len
)
1552 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1553 (gdb_byte
*) buf
+ xfered
,
1554 offset
+ xfered
, len
- xfered
);
1562 (*progress
) (xfer
, baton
);
1571 target_write (struct target_ops
*ops
,
1572 enum target_object object
,
1573 const char *annex
, const gdb_byte
*buf
,
1574 ULONGEST offset
, LONGEST len
)
1576 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1580 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1581 the size of the transferred data. PADDING additional bytes are
1582 available in *BUF_P. This is a helper function for
1583 target_read_alloc; see the declaration of that function for more
1587 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1588 const char *annex
, gdb_byte
**buf_p
, int padding
)
1590 size_t buf_alloc
, buf_pos
;
1594 /* This function does not have a length parameter; it reads the
1595 entire OBJECT). Also, it doesn't support objects fetched partly
1596 from one target and partly from another (in a different stratum,
1597 e.g. a core file and an executable). Both reasons make it
1598 unsuitable for reading memory. */
1599 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1601 /* Start by reading up to 4K at a time. The target will throttle
1602 this number down if necessary. */
1604 buf
= xmalloc (buf_alloc
);
1608 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1609 buf_pos
, buf_alloc
- buf_pos
- padding
);
1612 /* An error occurred. */
1618 /* Read all there was. */
1628 /* If the buffer is filling up, expand it. */
1629 if (buf_alloc
< buf_pos
* 2)
1632 buf
= xrealloc (buf
, buf_alloc
);
1639 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1640 the size of the transferred data. See the declaration in "target.h"
1641 function for more information about the return value. */
1644 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1645 const char *annex
, gdb_byte
**buf_p
)
1647 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1650 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1651 returned as a string, allocated using xmalloc. If an error occurs
1652 or the transfer is unsupported, NULL is returned. Empty objects
1653 are returned as allocated but empty strings. A warning is issued
1654 if the result contains any embedded NUL bytes. */
1657 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1661 LONGEST transferred
;
1663 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1665 if (transferred
< 0)
1668 if (transferred
== 0)
1669 return xstrdup ("");
1671 buffer
[transferred
] = 0;
1672 if (strlen (buffer
) < transferred
)
1673 warning (_("target object %d, annex %s, "
1674 "contained unexpected null characters"),
1675 (int) object
, annex
? annex
: "(none)");
1677 return (char *) buffer
;
1680 /* Memory transfer methods. */
1683 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1686 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1688 memory_error (EIO
, addr
);
1692 get_target_memory_unsigned (struct target_ops
*ops
,
1693 CORE_ADDR addr
, int len
)
1695 gdb_byte buf
[sizeof (ULONGEST
)];
1697 gdb_assert (len
<= sizeof (buf
));
1698 get_target_memory (ops
, addr
, buf
, len
);
1699 return extract_unsigned_integer (buf
, len
);
1703 target_info (char *args
, int from_tty
)
1705 struct target_ops
*t
;
1706 int has_all_mem
= 0;
1708 if (symfile_objfile
!= NULL
)
1709 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1711 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1713 if (!t
->to_has_memory
)
1716 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1719 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1720 printf_unfiltered ("%s:\n", t
->to_longname
);
1721 (t
->to_files_info
) (t
);
1722 has_all_mem
= t
->to_has_all_memory
;
1726 /* This function is called before any new inferior is created, e.g.
1727 by running a program, attaching, or connecting to a target.
1728 It cleans up any state from previous invocations which might
1729 change between runs. This is a subset of what target_preopen
1730 resets (things which might change between targets). */
1733 target_pre_inferior (int from_tty
)
1735 /* Clear out solib state. Otherwise the solib state of the previous
1736 inferior might have survived and is entirely wrong for the new
1737 target. This has been observed on GNU/Linux using glibc 2.3. How
1749 Cannot access memory at address 0xdeadbeef
1751 no_shared_libraries (NULL
, from_tty
);
1753 invalidate_target_mem_regions ();
1755 target_clear_description ();
1758 /* This is to be called by the open routine before it does
1762 target_preopen (int from_tty
)
1766 if (target_has_execution
)
1769 || query (_("A program is being debugged already. Kill it? ")))
1772 error (_("Program not killed."));
1775 /* Calling target_kill may remove the target from the stack. But if
1776 it doesn't (which seems like a win for UDI), remove it now. */
1777 /* Leave the exec target, though. The user may be switching from a
1778 live process to a core of the same program. */
1779 pop_all_targets_above (file_stratum
, 0);
1781 target_pre_inferior (from_tty
);
1784 /* Detach a target after doing deferred register stores. */
1787 target_detach (char *args
, int from_tty
)
1789 /* If we're in breakpoints-always-inserted mode, have to
1790 remove them before detaching. */
1791 remove_breakpoints ();
1793 (current_target
.to_detach
) (args
, from_tty
);
1797 target_disconnect (char *args
, int from_tty
)
1799 struct target_ops
*t
;
1801 /* If we're in breakpoints-always-inserted mode, have to
1802 remove them before disconnecting. */
1803 remove_breakpoints ();
1805 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1806 if (t
->to_disconnect
!= NULL
)
1809 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1811 t
->to_disconnect (t
, args
, from_tty
);
1819 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1821 dcache_invalidate (target_dcache
);
1822 (*current_target
.to_resume
) (ptid
, step
, signal
);
1823 set_executing (ptid
, 1);
1824 set_running (ptid
, 1);
1826 /* Look through the list of possible targets for a target that can
1830 target_follow_fork (int follow_child
)
1832 struct target_ops
*t
;
1834 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1836 if (t
->to_follow_fork
!= NULL
)
1838 int retval
= t
->to_follow_fork (t
, follow_child
);
1840 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1841 follow_child
, retval
);
1846 /* Some target returned a fork event, but did not know how to follow it. */
1847 internal_error (__FILE__
, __LINE__
,
1848 "could not find a target to follow fork");
1851 /* Look for a target which can describe architectural features, starting
1852 from TARGET. If we find one, return its description. */
1854 const struct target_desc
*
1855 target_read_description (struct target_ops
*target
)
1857 struct target_ops
*t
;
1859 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1860 if (t
->to_read_description
!= NULL
)
1862 const struct target_desc
*tdesc
;
1864 tdesc
= t
->to_read_description (t
);
1872 /* The default implementation of to_search_memory.
1873 This implements a basic search of memory, reading target memory and
1874 performing the search here (as opposed to performing the search in on the
1875 target side with, for example, gdbserver). */
1878 simple_search_memory (struct target_ops
*ops
,
1879 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1880 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1881 CORE_ADDR
*found_addrp
)
1883 /* NOTE: also defined in find.c testcase. */
1884 #define SEARCH_CHUNK_SIZE 16000
1885 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1886 /* Buffer to hold memory contents for searching. */
1887 gdb_byte
*search_buf
;
1888 unsigned search_buf_size
;
1889 struct cleanup
*old_cleanups
;
1891 search_buf_size
= chunk_size
+ pattern_len
- 1;
1893 /* No point in trying to allocate a buffer larger than the search space. */
1894 if (search_space_len
< search_buf_size
)
1895 search_buf_size
= search_space_len
;
1897 search_buf
= malloc (search_buf_size
);
1898 if (search_buf
== NULL
)
1899 error (_("Unable to allocate memory to perform the search."));
1900 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1902 /* Prime the search buffer. */
1904 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1905 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1907 warning (_("Unable to access target memory at %s, halting search."),
1908 hex_string (start_addr
));
1909 do_cleanups (old_cleanups
);
1913 /* Perform the search.
1915 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1916 When we've scanned N bytes we copy the trailing bytes to the start and
1917 read in another N bytes. */
1919 while (search_space_len
>= pattern_len
)
1921 gdb_byte
*found_ptr
;
1922 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1924 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1925 pattern
, pattern_len
);
1927 if (found_ptr
!= NULL
)
1929 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1930 *found_addrp
= found_addr
;
1931 do_cleanups (old_cleanups
);
1935 /* Not found in this chunk, skip to next chunk. */
1937 /* Don't let search_space_len wrap here, it's unsigned. */
1938 if (search_space_len
>= chunk_size
)
1939 search_space_len
-= chunk_size
;
1941 search_space_len
= 0;
1943 if (search_space_len
>= pattern_len
)
1945 unsigned keep_len
= search_buf_size
- chunk_size
;
1946 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1949 /* Copy the trailing part of the previous iteration to the front
1950 of the buffer for the next iteration. */
1951 gdb_assert (keep_len
== pattern_len
- 1);
1952 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1954 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1956 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1957 search_buf
+ keep_len
, read_addr
,
1958 nr_to_read
) != nr_to_read
)
1960 warning (_("Unable to access target memory at %s, halting search."),
1961 hex_string (read_addr
));
1962 do_cleanups (old_cleanups
);
1966 start_addr
+= chunk_size
;
1972 do_cleanups (old_cleanups
);
1976 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1977 sequence of bytes in PATTERN with length PATTERN_LEN.
1979 The result is 1 if found, 0 if not found, and -1 if there was an error
1980 requiring halting of the search (e.g. memory read error).
1981 If the pattern is found the address is recorded in FOUND_ADDRP. */
1984 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1985 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1986 CORE_ADDR
*found_addrp
)
1988 struct target_ops
*t
;
1991 /* We don't use INHERIT to set current_target.to_search_memory,
1992 so we have to scan the target stack and handle targetdebug
1996 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1997 hex_string (start_addr
));
1999 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2000 if (t
->to_search_memory
!= NULL
)
2005 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2006 pattern
, pattern_len
, found_addrp
);
2010 /* If a special version of to_search_memory isn't available, use the
2012 found
= simple_search_memory (¤t_target
,
2013 start_addr
, search_space_len
,
2014 pattern
, pattern_len
, found_addrp
);
2018 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2023 /* Look through the currently pushed targets. If none of them will
2024 be able to restart the currently running process, issue an error
2028 target_require_runnable (void)
2030 struct target_ops
*t
;
2032 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2034 /* If this target knows how to create a new program, then
2035 assume we will still be able to after killing the current
2036 one. Either killing and mourning will not pop T, or else
2037 find_default_run_target will find it again. */
2038 if (t
->to_create_inferior
!= NULL
)
2041 /* Do not worry about thread_stratum targets that can not
2042 create inferiors. Assume they will be pushed again if
2043 necessary, and continue to the process_stratum. */
2044 if (t
->to_stratum
== thread_stratum
)
2048 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2052 /* This function is only called if the target is running. In that
2053 case there should have been a process_stratum target and it
2054 should either know how to create inferiors, or not... */
2055 internal_error (__FILE__
, __LINE__
, "No targets found");
2058 /* Look through the list of possible targets for a target that can
2059 execute a run or attach command without any other data. This is
2060 used to locate the default process stratum.
2062 If DO_MESG is not NULL, the result is always valid (error() is
2063 called for errors); else, return NULL on error. */
2065 static struct target_ops
*
2066 find_default_run_target (char *do_mesg
)
2068 struct target_ops
**t
;
2069 struct target_ops
*runable
= NULL
;
2074 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2077 if ((*t
)->to_can_run
&& target_can_run (*t
))
2087 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2096 find_default_attach (char *args
, int from_tty
)
2098 struct target_ops
*t
;
2100 t
= find_default_run_target ("attach");
2101 (t
->to_attach
) (args
, from_tty
);
2106 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2109 struct target_ops
*t
;
2111 t
= find_default_run_target ("run");
2112 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2117 find_default_can_async_p (void)
2119 struct target_ops
*t
;
2121 /* This may be called before the target is pushed on the stack;
2122 look for the default process stratum. If there's none, gdb isn't
2123 configured with a native debugger, and target remote isn't
2125 t
= find_default_run_target (NULL
);
2126 if (t
&& t
->to_can_async_p
)
2127 return (t
->to_can_async_p
) ();
2132 find_default_is_async_p (void)
2134 struct target_ops
*t
;
2136 /* This may be called before the target is pushed on the stack;
2137 look for the default process stratum. If there's none, gdb isn't
2138 configured with a native debugger, and target remote isn't
2140 t
= find_default_run_target (NULL
);
2141 if (t
&& t
->to_is_async_p
)
2142 return (t
->to_is_async_p
) ();
2147 find_default_supports_non_stop (void)
2149 struct target_ops
*t
;
2151 t
= find_default_run_target (NULL
);
2152 if (t
&& t
->to_supports_non_stop
)
2153 return (t
->to_supports_non_stop
) ();
2158 target_supports_non_stop ()
2160 struct target_ops
*t
;
2161 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2162 if (t
->to_supports_non_stop
)
2163 return t
->to_supports_non_stop ();
2170 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2172 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2176 default_watchpoint_addr_within_range (struct target_ops
*target
,
2178 CORE_ADDR start
, int length
)
2180 return addr
>= start
&& addr
< start
+ length
;
2196 return_minus_one (void)
2202 * Resize the to_sections pointer. Also make sure that anyone that
2203 * was holding on to an old value of it gets updated.
2204 * Returns the old size.
2208 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2210 struct target_ops
**t
;
2211 struct section_table
*old_value
;
2214 old_value
= target
->to_sections
;
2216 if (target
->to_sections
)
2218 old_count
= target
->to_sections_end
- target
->to_sections
;
2219 target
->to_sections
= (struct section_table
*)
2220 xrealloc ((char *) target
->to_sections
,
2221 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2226 target
->to_sections
= (struct section_table
*)
2227 xmalloc ((sizeof (struct section_table
)) * num_added
);
2229 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2231 /* Check to see if anyone else was pointing to this structure.
2232 If old_value was null, then no one was. */
2236 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2239 if ((*t
)->to_sections
== old_value
)
2241 (*t
)->to_sections
= target
->to_sections
;
2242 (*t
)->to_sections_end
= target
->to_sections_end
;
2245 /* There is a flattened view of the target stack in current_target,
2246 so its to_sections pointer might also need updating. */
2247 if (current_target
.to_sections
== old_value
)
2249 current_target
.to_sections
= target
->to_sections
;
2250 current_target
.to_sections_end
= target
->to_sections_end
;
2258 /* Remove all target sections taken from ABFD.
2260 Scan the current target stack for targets whose section tables
2261 refer to sections from BFD, and remove those sections. We use this
2262 when we notice that the inferior has unloaded a shared object, for
2265 remove_target_sections (bfd
*abfd
)
2267 struct target_ops
**t
;
2269 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2271 struct section_table
*src
, *dest
;
2273 dest
= (*t
)->to_sections
;
2274 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2275 if (src
->bfd
!= abfd
)
2277 /* Keep this section. */
2278 if (dest
< src
) *dest
= *src
;
2282 /* If we've dropped any sections, resize the section table. */
2284 target_resize_to_sections (*t
, dest
- src
);
2291 /* Find a single runnable target in the stack and return it. If for
2292 some reason there is more than one, return NULL. */
2295 find_run_target (void)
2297 struct target_ops
**t
;
2298 struct target_ops
*runable
= NULL
;
2303 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2305 if ((*t
)->to_can_run
&& target_can_run (*t
))
2312 return (count
== 1 ? runable
: NULL
);
2315 /* Find a single core_stratum target in the list of targets and return it.
2316 If for some reason there is more than one, return NULL. */
2319 find_core_target (void)
2321 struct target_ops
**t
;
2322 struct target_ops
*runable
= NULL
;
2327 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2330 if ((*t
)->to_stratum
== core_stratum
)
2337 return (count
== 1 ? runable
: NULL
);
2341 * Find the next target down the stack from the specified target.
2345 find_target_beneath (struct target_ops
*t
)
2351 /* The inferior process has died. Long live the inferior! */
2354 generic_mourn_inferior (void)
2358 ptid
= inferior_ptid
;
2359 inferior_ptid
= null_ptid
;
2361 if (!ptid_equal (ptid
, null_ptid
))
2363 int pid
= ptid_get_pid (ptid
);
2364 delete_inferior (pid
);
2367 breakpoint_init_inferior (inf_exited
);
2368 registers_changed ();
2370 reopen_exec_file ();
2371 reinit_frame_cache ();
2373 if (deprecated_detach_hook
)
2374 deprecated_detach_hook ();
2377 /* Helper function for child_wait and the derivatives of child_wait.
2378 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2379 translation of that in OURSTATUS. */
2381 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2383 if (WIFEXITED (hoststatus
))
2385 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2386 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2388 else if (!WIFSTOPPED (hoststatus
))
2390 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2391 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2395 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2396 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2400 /* Returns zero to leave the inferior alone, one to interrupt it. */
2401 int (*target_activity_function
) (void);
2402 int target_activity_fd
;
2404 /* Convert a normal process ID to a string. Returns the string in a
2408 normal_pid_to_str (ptid_t ptid
)
2410 static char buf
[32];
2412 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2416 /* Error-catcher for target_find_memory_regions */
2417 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2419 error (_("No target."));
2423 /* Error-catcher for target_make_corefile_notes */
2424 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2426 error (_("No target."));
2430 /* Set up the handful of non-empty slots needed by the dummy target
2434 init_dummy_target (void)
2436 dummy_target
.to_shortname
= "None";
2437 dummy_target
.to_longname
= "None";
2438 dummy_target
.to_doc
= "";
2439 dummy_target
.to_attach
= find_default_attach
;
2440 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2441 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2442 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2443 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2444 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2445 dummy_target
.to_stratum
= dummy_stratum
;
2446 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2447 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2448 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2449 dummy_target
.to_magic
= OPS_MAGIC
;
2453 debug_to_open (char *args
, int from_tty
)
2455 debug_target
.to_open (args
, from_tty
);
2457 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2461 debug_to_close (int quitting
)
2463 target_close (&debug_target
, quitting
);
2464 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2468 target_close (struct target_ops
*targ
, int quitting
)
2470 if (targ
->to_xclose
!= NULL
)
2471 targ
->to_xclose (targ
, quitting
);
2472 else if (targ
->to_close
!= NULL
)
2473 targ
->to_close (quitting
);
2477 debug_to_attach (char *args
, int from_tty
)
2479 debug_target
.to_attach (args
, from_tty
);
2481 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2486 debug_to_post_attach (int pid
)
2488 debug_target
.to_post_attach (pid
);
2490 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2494 debug_to_detach (char *args
, int from_tty
)
2496 debug_target
.to_detach (args
, from_tty
);
2498 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2502 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2504 debug_target
.to_resume (ptid
, step
, siggnal
);
2506 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2507 step
? "step" : "continue",
2508 target_signal_to_name (siggnal
));
2512 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2516 retval
= debug_target
.to_wait (ptid
, status
);
2518 fprintf_unfiltered (gdb_stdlog
,
2519 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2521 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2522 switch (status
->kind
)
2524 case TARGET_WAITKIND_EXITED
:
2525 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2526 status
->value
.integer
);
2528 case TARGET_WAITKIND_STOPPED
:
2529 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2530 target_signal_to_name (status
->value
.sig
));
2532 case TARGET_WAITKIND_SIGNALLED
:
2533 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2534 target_signal_to_name (status
->value
.sig
));
2536 case TARGET_WAITKIND_LOADED
:
2537 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2539 case TARGET_WAITKIND_FORKED
:
2540 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2542 case TARGET_WAITKIND_VFORKED
:
2543 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2545 case TARGET_WAITKIND_EXECD
:
2546 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2548 case TARGET_WAITKIND_SPURIOUS
:
2549 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2552 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2560 debug_print_register (const char * func
,
2561 struct regcache
*regcache
, int regno
)
2563 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2564 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2565 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2566 && gdbarch_register_name (gdbarch
, regno
) != NULL
2567 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2568 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2569 gdbarch_register_name (gdbarch
, regno
));
2571 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2572 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2574 int i
, size
= register_size (gdbarch
, regno
);
2575 unsigned char buf
[MAX_REGISTER_SIZE
];
2576 regcache_raw_collect (regcache
, regno
, buf
);
2577 fprintf_unfiltered (gdb_stdlog
, " = ");
2578 for (i
= 0; i
< size
; i
++)
2580 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2582 if (size
<= sizeof (LONGEST
))
2584 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2585 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2586 core_addr_to_string_nz (val
), plongest (val
));
2589 fprintf_unfiltered (gdb_stdlog
, "\n");
2593 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2595 debug_target
.to_fetch_registers (regcache
, regno
);
2596 debug_print_register ("target_fetch_registers", regcache
, regno
);
2600 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2602 debug_target
.to_store_registers (regcache
, regno
);
2603 debug_print_register ("target_store_registers", regcache
, regno
);
2604 fprintf_unfiltered (gdb_stdlog
, "\n");
2608 debug_to_prepare_to_store (struct regcache
*regcache
)
2610 debug_target
.to_prepare_to_store (regcache
);
2612 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2616 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2617 int write
, struct mem_attrib
*attrib
,
2618 struct target_ops
*target
)
2622 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2625 fprintf_unfiltered (gdb_stdlog
,
2626 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2627 (unsigned int) memaddr
, /* possable truncate long long */
2628 len
, write
? "write" : "read", retval
);
2634 fputs_unfiltered (", bytes =", gdb_stdlog
);
2635 for (i
= 0; i
< retval
; i
++)
2637 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2639 if (targetdebug
< 2 && i
> 0)
2641 fprintf_unfiltered (gdb_stdlog
, " ...");
2644 fprintf_unfiltered (gdb_stdlog
, "\n");
2647 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2651 fputc_unfiltered ('\n', gdb_stdlog
);
2657 debug_to_files_info (struct target_ops
*target
)
2659 debug_target
.to_files_info (target
);
2661 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2665 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2669 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2671 fprintf_unfiltered (gdb_stdlog
,
2672 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2673 (unsigned long) bp_tgt
->placed_address
,
2674 (unsigned long) retval
);
2679 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2683 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2685 fprintf_unfiltered (gdb_stdlog
,
2686 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2687 (unsigned long) bp_tgt
->placed_address
,
2688 (unsigned long) retval
);
2693 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2697 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2699 fprintf_unfiltered (gdb_stdlog
,
2700 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2701 (unsigned long) type
,
2702 (unsigned long) cnt
,
2703 (unsigned long) from_tty
,
2704 (unsigned long) retval
);
2709 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2713 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2715 fprintf_unfiltered (gdb_stdlog
,
2716 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2717 (unsigned long) addr
,
2718 (unsigned long) len
,
2719 (unsigned long) retval
);
2724 debug_to_stopped_by_watchpoint (void)
2728 retval
= debug_target
.to_stopped_by_watchpoint ();
2730 fprintf_unfiltered (gdb_stdlog
,
2731 "STOPPED_BY_WATCHPOINT () = %ld\n",
2732 (unsigned long) retval
);
2737 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2741 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2743 fprintf_unfiltered (gdb_stdlog
,
2744 "target_stopped_data_address ([0x%lx]) = %ld\n",
2745 (unsigned long)*addr
,
2746 (unsigned long)retval
);
2751 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2753 CORE_ADDR start
, int length
)
2757 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2760 fprintf_filtered (gdb_stdlog
,
2761 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2762 (unsigned long) addr
, (unsigned long) start
, length
,
2768 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2772 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2774 fprintf_unfiltered (gdb_stdlog
,
2775 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2776 (unsigned long) bp_tgt
->placed_address
,
2777 (unsigned long) retval
);
2782 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2786 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2788 fprintf_unfiltered (gdb_stdlog
,
2789 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2790 (unsigned long) bp_tgt
->placed_address
,
2791 (unsigned long) retval
);
2796 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2800 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2802 fprintf_unfiltered (gdb_stdlog
,
2803 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2804 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2809 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2813 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2815 fprintf_unfiltered (gdb_stdlog
,
2816 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2817 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2822 debug_to_terminal_init (void)
2824 debug_target
.to_terminal_init ();
2826 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2830 debug_to_terminal_inferior (void)
2832 debug_target
.to_terminal_inferior ();
2834 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2838 debug_to_terminal_ours_for_output (void)
2840 debug_target
.to_terminal_ours_for_output ();
2842 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2846 debug_to_terminal_ours (void)
2848 debug_target
.to_terminal_ours ();
2850 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2854 debug_to_terminal_save_ours (void)
2856 debug_target
.to_terminal_save_ours ();
2858 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2862 debug_to_terminal_info (char *arg
, int from_tty
)
2864 debug_target
.to_terminal_info (arg
, from_tty
);
2866 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2871 debug_to_kill (void)
2873 debug_target
.to_kill ();
2875 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2879 debug_to_load (char *args
, int from_tty
)
2881 debug_target
.to_load (args
, from_tty
);
2883 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2887 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2891 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2893 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2899 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2902 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2904 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2905 exec_file
, args
, from_tty
);
2909 debug_to_post_startup_inferior (ptid_t ptid
)
2911 debug_target
.to_post_startup_inferior (ptid
);
2913 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2918 debug_to_acknowledge_created_inferior (int pid
)
2920 debug_target
.to_acknowledge_created_inferior (pid
);
2922 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2927 debug_to_insert_fork_catchpoint (int pid
)
2929 debug_target
.to_insert_fork_catchpoint (pid
);
2931 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2936 debug_to_remove_fork_catchpoint (int pid
)
2940 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2942 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2949 debug_to_insert_vfork_catchpoint (int pid
)
2951 debug_target
.to_insert_vfork_catchpoint (pid
);
2953 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2958 debug_to_remove_vfork_catchpoint (int pid
)
2962 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2964 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2971 debug_to_insert_exec_catchpoint (int pid
)
2973 debug_target
.to_insert_exec_catchpoint (pid
);
2975 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2980 debug_to_remove_exec_catchpoint (int pid
)
2984 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2986 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2993 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2997 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2999 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
3000 pid
, wait_status
, *exit_status
, has_exited
);
3006 debug_to_mourn_inferior (void)
3008 debug_target
.to_mourn_inferior ();
3010 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
3014 debug_to_can_run (void)
3018 retval
= debug_target
.to_can_run ();
3020 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3026 debug_to_notice_signals (ptid_t ptid
)
3028 debug_target
.to_notice_signals (ptid
);
3030 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3035 debug_to_thread_alive (ptid_t ptid
)
3039 retval
= debug_target
.to_thread_alive (ptid
);
3041 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3042 PIDGET (ptid
), retval
);
3048 debug_to_find_new_threads (void)
3050 debug_target
.to_find_new_threads ();
3052 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3056 debug_to_stop (ptid_t ptid
)
3058 debug_target
.to_stop (ptid
);
3060 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3061 target_pid_to_str (ptid
));
3065 debug_to_rcmd (char *command
,
3066 struct ui_file
*outbuf
)
3068 debug_target
.to_rcmd (command
, outbuf
);
3069 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3073 debug_to_pid_to_exec_file (int pid
)
3077 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3079 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3086 setup_target_debug (void)
3088 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3090 current_target
.to_open
= debug_to_open
;
3091 current_target
.to_close
= debug_to_close
;
3092 current_target
.to_attach
= debug_to_attach
;
3093 current_target
.to_post_attach
= debug_to_post_attach
;
3094 current_target
.to_detach
= debug_to_detach
;
3095 current_target
.to_resume
= debug_to_resume
;
3096 current_target
.to_wait
= debug_to_wait
;
3097 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3098 current_target
.to_store_registers
= debug_to_store_registers
;
3099 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3100 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3101 current_target
.to_files_info
= debug_to_files_info
;
3102 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3103 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3104 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3105 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3106 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3107 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3108 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3109 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3110 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3111 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3112 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3113 current_target
.to_terminal_init
= debug_to_terminal_init
;
3114 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3115 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3116 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3117 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3118 current_target
.to_terminal_info
= debug_to_terminal_info
;
3119 current_target
.to_kill
= debug_to_kill
;
3120 current_target
.to_load
= debug_to_load
;
3121 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3122 current_target
.to_create_inferior
= debug_to_create_inferior
;
3123 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3124 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3125 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3126 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3127 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3128 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3129 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3130 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3131 current_target
.to_has_exited
= debug_to_has_exited
;
3132 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3133 current_target
.to_can_run
= debug_to_can_run
;
3134 current_target
.to_notice_signals
= debug_to_notice_signals
;
3135 current_target
.to_thread_alive
= debug_to_thread_alive
;
3136 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3137 current_target
.to_stop
= debug_to_stop
;
3138 current_target
.to_rcmd
= debug_to_rcmd
;
3139 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3143 static char targ_desc
[] =
3144 "Names of targets and files being debugged.\n\
3145 Shows the entire stack of targets currently in use (including the exec-file,\n\
3146 core-file, and process, if any), as well as the symbol file name.";
3149 do_monitor_command (char *cmd
,
3152 if ((current_target
.to_rcmd
3153 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3154 || (current_target
.to_rcmd
== debug_to_rcmd
3155 && (debug_target
.to_rcmd
3156 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3157 error (_("\"monitor\" command not supported by this target."));
3158 target_rcmd (cmd
, gdb_stdtarg
);
3161 /* Print the name of each layers of our target stack. */
3164 maintenance_print_target_stack (char *cmd
, int from_tty
)
3166 struct target_ops
*t
;
3168 printf_filtered (_("The current target stack is:\n"));
3170 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3172 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3176 /* Controls if async mode is permitted. */
3177 int target_async_permitted
= 0;
3179 /* The set command writes to this variable. If the inferior is
3180 executing, linux_nat_async_permitted is *not* updated. */
3181 static int target_async_permitted_1
= 0;
3184 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3185 struct cmd_list_element
*c
)
3187 if (target_has_execution
)
3189 target_async_permitted_1
= target_async_permitted
;
3190 error (_("Cannot change this setting while the inferior is running."));
3193 target_async_permitted
= target_async_permitted_1
;
3197 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3198 struct cmd_list_element
*c
,
3201 fprintf_filtered (file
, _("\
3202 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3206 initialize_targets (void)
3208 init_dummy_target ();
3209 push_target (&dummy_target
);
3211 add_info ("target", target_info
, targ_desc
);
3212 add_info ("files", target_info
, targ_desc
);
3214 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3215 Set target debugging."), _("\
3216 Show target debugging."), _("\
3217 When non-zero, target debugging is enabled. Higher numbers are more\n\
3218 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3222 &setdebuglist
, &showdebuglist
);
3224 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3225 &trust_readonly
, _("\
3226 Set mode for reading from readonly sections."), _("\
3227 Show mode for reading from readonly sections."), _("\
3228 When this mode is on, memory reads from readonly sections (such as .text)\n\
3229 will be read from the object file instead of from the target. This will\n\
3230 result in significant performance improvement for remote targets."),
3232 show_trust_readonly
,
3233 &setlist
, &showlist
);
3235 add_com ("monitor", class_obscure
, do_monitor_command
,
3236 _("Send a command to the remote monitor (remote targets only)."));
3238 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3239 _("Print the name of each layer of the internal target stack."),
3240 &maintenanceprintlist
);
3242 add_setshow_boolean_cmd ("target-async", no_class
,
3243 &target_async_permitted_1
, _("\
3244 Set whether gdb controls the inferior in asynchronous mode."), _("\
3245 Show whether gdb controls the inferior in asynchronous mode."), _("\
3246 Tells gdb whether to control the inferior in asynchronous mode."),
3247 set_maintenance_target_async_permitted
,
3248 show_maintenance_target_async_permitted
,
3252 target_dcache
= dcache_init ();