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, 2009
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_resume (ptid_t
, int, enum target_signal
);
102 static void debug_to_fetch_registers (struct regcache
*, int);
104 static void debug_to_store_registers (struct regcache
*, int);
106 static void debug_to_prepare_to_store (struct regcache
*);
108 static void debug_to_files_info (struct target_ops
*);
110 static int debug_to_insert_breakpoint (struct bp_target_info
*);
112 static int debug_to_remove_breakpoint (struct bp_target_info
*);
114 static int debug_to_can_use_hw_breakpoint (int, int, int);
116 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
118 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
120 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
122 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
124 static int debug_to_stopped_by_watchpoint (void);
126 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
128 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
129 CORE_ADDR
, CORE_ADDR
, int);
131 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
133 static void debug_to_terminal_init (void);
135 static void debug_to_terminal_inferior (void);
137 static void debug_to_terminal_ours_for_output (void);
139 static void debug_to_terminal_save_ours (void);
141 static void debug_to_terminal_ours (void);
143 static void debug_to_terminal_info (char *, int);
145 static void debug_to_kill (void);
147 static void debug_to_load (char *, int);
149 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
151 static int debug_to_can_run (void);
153 static void debug_to_notice_signals (ptid_t
);
155 static int debug_to_thread_alive (ptid_t
);
157 static void debug_to_stop (ptid_t
);
159 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
160 wierd and mysterious ways. Putting the variable here lets those
161 wierd and mysterious ways keep building while they are being
162 converted to the inferior inheritance structure. */
163 struct target_ops deprecated_child_ops
;
165 /* Pointer to array of target architecture structures; the size of the
166 array; the current index into the array; the allocated size of the
168 struct target_ops
**target_structs
;
169 unsigned target_struct_size
;
170 unsigned target_struct_index
;
171 unsigned target_struct_allocsize
;
172 #define DEFAULT_ALLOCSIZE 10
174 /* The initial current target, so that there is always a semi-valid
177 static struct target_ops dummy_target
;
179 /* Top of target stack. */
181 static struct target_ops
*target_stack
;
183 /* The target structure we are currently using to talk to a process
184 or file or whatever "inferior" we have. */
186 struct target_ops current_target
;
188 /* Command list for target. */
190 static struct cmd_list_element
*targetlist
= NULL
;
192 /* Nonzero if we should trust readonly sections from the
193 executable when reading memory. */
195 static int trust_readonly
= 0;
197 /* Nonzero if we should show true memory content including
198 memory breakpoint inserted by gdb. */
200 static int show_memory_breakpoints
= 0;
202 /* Non-zero if we want to see trace of target level stuff. */
204 static int targetdebug
= 0;
206 show_targetdebug (struct ui_file
*file
, int from_tty
,
207 struct cmd_list_element
*c
, const char *value
)
209 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
212 static void setup_target_debug (void);
214 DCACHE
*target_dcache
;
216 /* The user just typed 'target' without the name of a target. */
219 target_command (char *arg
, int from_tty
)
221 fputs_filtered ("Argument required (target name). Try `help target'\n",
225 /* Add a possible target architecture to the list. */
228 add_target (struct target_ops
*t
)
230 /* Provide default values for all "must have" methods. */
231 if (t
->to_xfer_partial
== NULL
)
232 t
->to_xfer_partial
= default_xfer_partial
;
236 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
237 target_structs
= (struct target_ops
**) xmalloc
238 (target_struct_allocsize
* sizeof (*target_structs
));
240 if (target_struct_size
>= target_struct_allocsize
)
242 target_struct_allocsize
*= 2;
243 target_structs
= (struct target_ops
**)
244 xrealloc ((char *) target_structs
,
245 target_struct_allocsize
* sizeof (*target_structs
));
247 target_structs
[target_struct_size
++] = t
;
249 if (targetlist
== NULL
)
250 add_prefix_cmd ("target", class_run
, target_command
, _("\
251 Connect to a target machine or process.\n\
252 The first argument is the type or protocol of the target machine.\n\
253 Remaining arguments are interpreted by the target protocol. For more\n\
254 information on the arguments for a particular protocol, type\n\
255 `help target ' followed by the protocol name."),
256 &targetlist
, "target ", 0, &cmdlist
);
257 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
268 target_load (char *arg
, int from_tty
)
270 dcache_invalidate (target_dcache
);
271 (*current_target
.to_load
) (arg
, from_tty
);
275 target_create_inferior (char *exec_file
, char *args
,
276 char **env
, int from_tty
)
278 struct target_ops
*t
;
279 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
281 if (t
->to_create_inferior
!= NULL
)
283 t
->to_create_inferior (t
, exec_file
, args
, env
, from_tty
);
285 fprintf_unfiltered (gdb_stdlog
,
286 "target_create_inferior (%s, %s, xxx, %d)\n",
287 exec_file
, args
, from_tty
);
292 internal_error (__FILE__
, __LINE__
,
293 "could not find a target to create inferior");
298 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
299 struct target_ops
*t
)
301 errno
= EIO
; /* Can't read/write this location */
302 return 0; /* No bytes handled */
308 error (_("You can't do that when your target is `%s'"),
309 current_target
.to_shortname
);
315 error (_("You can't do that without a process to debug."));
319 nosymbol (char *name
, CORE_ADDR
*addrp
)
321 return 1; /* Symbol does not exist in target env */
325 nosupport_runtime (void)
327 if (ptid_equal (inferior_ptid
, null_ptid
))
330 error (_("No run-time support for this"));
335 default_terminal_info (char *args
, int from_tty
)
337 printf_unfiltered (_("No saved terminal information.\n"));
340 /* This is the default target_create_inferior and target_attach function.
341 If the current target is executing, it asks whether to kill it off.
342 If this function returns without calling error(), it has killed off
343 the target, and the operation should be attempted. */
346 kill_or_be_killed (int from_tty
)
348 if (target_has_execution
)
350 printf_unfiltered (_("You are already running a program:\n"));
351 target_files_info ();
352 if (query ("Kill it? "))
355 if (target_has_execution
)
356 error (_("Killing the program did not help."));
361 error (_("Program not killed."));
367 /* A default implementation for the to_get_ada_task_ptid target method.
369 This function builds the PTID by using both LWP and TID as part of
370 the PTID lwp and tid elements. The pid used is the pid of the
374 default_get_ada_task_ptid (long lwp
, long tid
)
376 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, tid
);
379 /* Go through the target stack from top to bottom, copying over zero
380 entries in current_target, then filling in still empty entries. In
381 effect, we are doing class inheritance through the pushed target
384 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
385 is currently implemented, is that it discards any knowledge of
386 which target an inherited method originally belonged to.
387 Consequently, new new target methods should instead explicitly and
388 locally search the target stack for the target that can handle the
392 update_current_target (void)
394 struct target_ops
*t
;
396 /* First, reset current's contents. */
397 memset (¤t_target
, 0, sizeof (current_target
));
399 #define INHERIT(FIELD, TARGET) \
400 if (!current_target.FIELD) \
401 current_target.FIELD = (TARGET)->FIELD
403 for (t
= target_stack
; t
; t
= t
->beneath
)
405 INHERIT (to_shortname
, t
);
406 INHERIT (to_longname
, t
);
408 /* Do not inherit to_open. */
409 /* Do not inherit to_close. */
410 /* Do not inherit to_attach. */
411 INHERIT (to_post_attach
, t
);
412 INHERIT (to_attach_no_wait
, t
);
413 /* Do not inherit to_detach. */
414 /* Do not inherit to_disconnect. */
415 INHERIT (to_resume
, t
);
416 /* Do not inherit to_wait. */
417 INHERIT (to_fetch_registers
, t
);
418 INHERIT (to_store_registers
, t
);
419 INHERIT (to_prepare_to_store
, t
);
420 INHERIT (deprecated_xfer_memory
, t
);
421 INHERIT (to_files_info
, t
);
422 INHERIT (to_insert_breakpoint
, t
);
423 INHERIT (to_remove_breakpoint
, t
);
424 INHERIT (to_can_use_hw_breakpoint
, t
);
425 INHERIT (to_insert_hw_breakpoint
, t
);
426 INHERIT (to_remove_hw_breakpoint
, t
);
427 INHERIT (to_insert_watchpoint
, t
);
428 INHERIT (to_remove_watchpoint
, t
);
429 INHERIT (to_stopped_data_address
, t
);
430 INHERIT (to_have_steppable_watchpoint
, t
);
431 INHERIT (to_have_continuable_watchpoint
, t
);
432 INHERIT (to_stopped_by_watchpoint
, t
);
433 INHERIT (to_watchpoint_addr_within_range
, t
);
434 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
435 INHERIT (to_terminal_init
, t
);
436 INHERIT (to_terminal_inferior
, t
);
437 INHERIT (to_terminal_ours_for_output
, t
);
438 INHERIT (to_terminal_ours
, t
);
439 INHERIT (to_terminal_save_ours
, t
);
440 INHERIT (to_terminal_info
, t
);
441 INHERIT (to_kill
, t
);
442 INHERIT (to_load
, t
);
443 INHERIT (to_lookup_symbol
, t
);
444 /* Do no inherit to_create_inferior. */
445 INHERIT (to_post_startup_inferior
, t
);
446 INHERIT (to_acknowledge_created_inferior
, t
);
447 INHERIT (to_insert_fork_catchpoint
, t
);
448 INHERIT (to_remove_fork_catchpoint
, t
);
449 INHERIT (to_insert_vfork_catchpoint
, t
);
450 INHERIT (to_remove_vfork_catchpoint
, t
);
451 /* Do not inherit to_follow_fork. */
452 INHERIT (to_insert_exec_catchpoint
, t
);
453 INHERIT (to_remove_exec_catchpoint
, t
);
454 INHERIT (to_has_exited
, t
);
455 /* Do not inherit to_mourn_inferiour. */
456 INHERIT (to_can_run
, t
);
457 INHERIT (to_notice_signals
, t
);
458 INHERIT (to_thread_alive
, t
);
459 INHERIT (to_find_new_threads
, t
);
460 /* Do not inherit to_pid_to_str. */
461 INHERIT (to_extra_thread_info
, t
);
462 INHERIT (to_stop
, t
);
463 /* Do not inherit to_xfer_partial. */
464 INHERIT (to_rcmd
, t
);
465 INHERIT (to_pid_to_exec_file
, t
);
466 INHERIT (to_log_command
, t
);
467 INHERIT (to_stratum
, t
);
468 INHERIT (to_has_all_memory
, t
);
469 INHERIT (to_has_memory
, t
);
470 INHERIT (to_has_stack
, t
);
471 INHERIT (to_has_registers
, t
);
472 INHERIT (to_has_execution
, t
);
473 INHERIT (to_has_thread_control
, t
);
474 INHERIT (to_sections
, t
);
475 INHERIT (to_sections_end
, t
);
476 INHERIT (to_can_async_p
, t
);
477 INHERIT (to_is_async_p
, t
);
478 INHERIT (to_async
, t
);
479 INHERIT (to_async_mask
, t
);
480 INHERIT (to_find_memory_regions
, t
);
481 INHERIT (to_make_corefile_notes
, t
);
482 /* Do not inherit to_get_thread_local_address. */
483 INHERIT (to_can_execute_reverse
, t
);
484 /* Do not inherit to_read_description. */
485 INHERIT (to_get_ada_task_ptid
, t
);
486 /* Do not inherit to_search_memory. */
487 INHERIT (to_supports_multi_process
, t
);
488 INHERIT (to_magic
, t
);
489 /* Do not inherit to_memory_map. */
490 /* Do not inherit to_flash_erase. */
491 /* Do not inherit to_flash_done. */
495 /* Clean up a target struct so it no longer has any zero pointers in
496 it. Some entries are defaulted to a method that print an error,
497 others are hard-wired to a standard recursive default. */
499 #define de_fault(field, value) \
500 if (!current_target.field) \
501 current_target.field = value
504 (void (*) (char *, int))
509 de_fault (to_post_attach
,
513 (void (*) (ptid_t
, int, enum target_signal
))
515 de_fault (to_fetch_registers
,
516 (void (*) (struct regcache
*, int))
518 de_fault (to_store_registers
,
519 (void (*) (struct regcache
*, int))
521 de_fault (to_prepare_to_store
,
522 (void (*) (struct regcache
*))
524 de_fault (deprecated_xfer_memory
,
525 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
527 de_fault (to_files_info
,
528 (void (*) (struct target_ops
*))
530 de_fault (to_insert_breakpoint
,
531 memory_insert_breakpoint
);
532 de_fault (to_remove_breakpoint
,
533 memory_remove_breakpoint
);
534 de_fault (to_can_use_hw_breakpoint
,
535 (int (*) (int, int, int))
537 de_fault (to_insert_hw_breakpoint
,
538 (int (*) (struct bp_target_info
*))
540 de_fault (to_remove_hw_breakpoint
,
541 (int (*) (struct bp_target_info
*))
543 de_fault (to_insert_watchpoint
,
544 (int (*) (CORE_ADDR
, int, int))
546 de_fault (to_remove_watchpoint
,
547 (int (*) (CORE_ADDR
, int, int))
549 de_fault (to_stopped_by_watchpoint
,
552 de_fault (to_stopped_data_address
,
553 (int (*) (struct target_ops
*, CORE_ADDR
*))
555 de_fault (to_watchpoint_addr_within_range
,
556 default_watchpoint_addr_within_range
);
557 de_fault (to_region_ok_for_hw_watchpoint
,
558 default_region_ok_for_hw_watchpoint
);
559 de_fault (to_terminal_init
,
562 de_fault (to_terminal_inferior
,
565 de_fault (to_terminal_ours_for_output
,
568 de_fault (to_terminal_ours
,
571 de_fault (to_terminal_save_ours
,
574 de_fault (to_terminal_info
,
575 default_terminal_info
);
580 (void (*) (char *, int))
582 de_fault (to_lookup_symbol
,
583 (int (*) (char *, CORE_ADDR
*))
585 de_fault (to_post_startup_inferior
,
588 de_fault (to_acknowledge_created_inferior
,
591 de_fault (to_insert_fork_catchpoint
,
594 de_fault (to_remove_fork_catchpoint
,
597 de_fault (to_insert_vfork_catchpoint
,
600 de_fault (to_remove_vfork_catchpoint
,
603 de_fault (to_insert_exec_catchpoint
,
606 de_fault (to_remove_exec_catchpoint
,
609 de_fault (to_has_exited
,
610 (int (*) (int, int, int *))
612 de_fault (to_can_run
,
614 de_fault (to_notice_signals
,
617 de_fault (to_thread_alive
,
620 de_fault (to_find_new_threads
,
623 de_fault (to_extra_thread_info
,
624 (char *(*) (struct thread_info
*))
629 current_target
.to_xfer_partial
= current_xfer_partial
;
631 (void (*) (char *, struct ui_file
*))
633 de_fault (to_pid_to_exec_file
,
637 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
639 de_fault (to_async_mask
,
642 current_target
.to_read_description
= NULL
;
643 de_fault (to_get_ada_task_ptid
,
644 (ptid_t (*) (long, long))
645 default_get_ada_task_ptid
);
646 de_fault (to_supports_multi_process
,
651 /* Finally, position the target-stack beneath the squashed
652 "current_target". That way code looking for a non-inherited
653 target method can quickly and simply find it. */
654 current_target
.beneath
= target_stack
;
657 setup_target_debug ();
660 /* Mark OPS as a running target. This reverses the effect
661 of target_mark_exited. */
664 target_mark_running (struct target_ops
*ops
)
666 struct target_ops
*t
;
668 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
672 internal_error (__FILE__
, __LINE__
,
673 "Attempted to mark unpushed target \"%s\" as running",
676 ops
->to_has_execution
= 1;
677 ops
->to_has_all_memory
= 1;
678 ops
->to_has_memory
= 1;
679 ops
->to_has_stack
= 1;
680 ops
->to_has_registers
= 1;
682 update_current_target ();
685 /* Mark OPS as a non-running target. This reverses the effect
686 of target_mark_running. */
689 target_mark_exited (struct target_ops
*ops
)
691 struct target_ops
*t
;
693 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
697 internal_error (__FILE__
, __LINE__
,
698 "Attempted to mark unpushed target \"%s\" as running",
701 ops
->to_has_execution
= 0;
702 ops
->to_has_all_memory
= 0;
703 ops
->to_has_memory
= 0;
704 ops
->to_has_stack
= 0;
705 ops
->to_has_registers
= 0;
707 update_current_target ();
710 /* Push a new target type into the stack of the existing target accessors,
711 possibly superseding some of the existing accessors.
713 Result is zero if the pushed target ended up on top of the stack,
714 nonzero if at least one target is on top of it.
716 Rather than allow an empty stack, we always have the dummy target at
717 the bottom stratum, so we can call the function vectors without
721 push_target (struct target_ops
*t
)
723 struct target_ops
**cur
;
725 /* Check magic number. If wrong, it probably means someone changed
726 the struct definition, but not all the places that initialize one. */
727 if (t
->to_magic
!= OPS_MAGIC
)
729 fprintf_unfiltered (gdb_stderr
,
730 "Magic number of %s target struct wrong\n",
732 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
735 /* Find the proper stratum to install this target in. */
736 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
738 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
742 /* If there's already targets at this stratum, remove them. */
743 /* FIXME: cagney/2003-10-15: I think this should be popping all
744 targets to CUR, and not just those at this stratum level. */
745 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
747 /* There's already something at this stratum level. Close it,
748 and un-hook it from the stack. */
749 struct target_ops
*tmp
= (*cur
);
750 (*cur
) = (*cur
)->beneath
;
752 target_close (tmp
, 0);
755 /* We have removed all targets in our stratum, now add the new one. */
759 update_current_target ();
762 return (t
!= target_stack
);
765 /* Remove a target_ops vector from the stack, wherever it may be.
766 Return how many times it was removed (0 or 1). */
769 unpush_target (struct target_ops
*t
)
771 struct target_ops
**cur
;
772 struct target_ops
*tmp
;
774 if (t
->to_stratum
== dummy_stratum
)
775 internal_error (__FILE__
, __LINE__
,
776 "Attempt to unpush the dummy target");
778 /* Look for the specified target. Note that we assume that a target
779 can only occur once in the target stack. */
781 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
788 return 0; /* Didn't find target_ops, quit now */
790 /* NOTE: cagney/2003-12-06: In '94 the close call was made
791 unconditional by moving it to before the above check that the
792 target was in the target stack (something about "Change the way
793 pushing and popping of targets work to support target overlays
794 and inheritance"). This doesn't make much sense - only open
795 targets should be closed. */
798 /* Unchain the target */
800 (*cur
) = (*cur
)->beneath
;
803 update_current_target ();
811 target_close (target_stack
, 0); /* Let it clean up */
812 if (unpush_target (target_stack
) == 1)
815 fprintf_unfiltered (gdb_stderr
,
816 "pop_target couldn't find target %s\n",
817 current_target
.to_shortname
);
818 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
822 pop_all_targets_above (enum strata above_stratum
, int quitting
)
824 while ((int) (current_target
.to_stratum
) > (int) above_stratum
)
826 target_close (target_stack
, quitting
);
827 if (!unpush_target (target_stack
))
829 fprintf_unfiltered (gdb_stderr
,
830 "pop_all_targets couldn't find target %s\n",
831 target_stack
->to_shortname
);
832 internal_error (__FILE__
, __LINE__
,
833 _("failed internal consistency check"));
840 pop_all_targets (int quitting
)
842 pop_all_targets_above (dummy_stratum
, quitting
);
845 /* Using the objfile specified in OBJFILE, find the address for the
846 current thread's thread-local storage with offset OFFSET. */
848 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
850 volatile CORE_ADDR addr
= 0;
851 struct target_ops
*target
;
853 for (target
= current_target
.beneath
;
855 target
= target
->beneath
)
857 if (target
->to_get_thread_local_address
!= NULL
)
862 && gdbarch_fetch_tls_load_module_address_p (target_gdbarch
))
864 ptid_t ptid
= inferior_ptid
;
865 volatile struct gdb_exception ex
;
867 TRY_CATCH (ex
, RETURN_MASK_ALL
)
871 /* Fetch the load module address for this objfile. */
872 lm_addr
= gdbarch_fetch_tls_load_module_address (target_gdbarch
,
874 /* If it's 0, throw the appropriate exception. */
876 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
877 _("TLS load module not found"));
879 addr
= target
->to_get_thread_local_address (target
, ptid
, lm_addr
, offset
);
881 /* If an error occurred, print TLS related messages here. Otherwise,
882 throw the error to some higher catcher. */
885 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
889 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
890 error (_("Cannot find thread-local variables in this thread library."));
892 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
893 if (objfile_is_library
)
894 error (_("Cannot find shared library `%s' in dynamic"
895 " linker's load module list"), objfile
->name
);
897 error (_("Cannot find executable file `%s' in dynamic"
898 " linker's load module list"), objfile
->name
);
900 case TLS_NOT_ALLOCATED_YET_ERROR
:
901 if (objfile_is_library
)
902 error (_("The inferior has not yet allocated storage for"
903 " thread-local variables in\n"
904 "the shared library `%s'\n"
906 objfile
->name
, target_pid_to_str (ptid
));
908 error (_("The inferior has not yet allocated storage for"
909 " thread-local variables in\n"
910 "the executable `%s'\n"
912 objfile
->name
, target_pid_to_str (ptid
));
914 case TLS_GENERIC_ERROR
:
915 if (objfile_is_library
)
916 error (_("Cannot find thread-local storage for %s, "
917 "shared library %s:\n%s"),
918 target_pid_to_str (ptid
),
919 objfile
->name
, ex
.message
);
921 error (_("Cannot find thread-local storage for %s, "
922 "executable file %s:\n%s"),
923 target_pid_to_str (ptid
),
924 objfile
->name
, ex
.message
);
927 throw_exception (ex
);
932 /* It wouldn't be wrong here to try a gdbarch method, too; finding
933 TLS is an ABI-specific thing. But we don't do that yet. */
935 error (_("Cannot find thread-local variables on this target"));
941 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
943 /* target_read_string -- read a null terminated string, up to LEN bytes,
944 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
945 Set *STRING to a pointer to malloc'd memory containing the data; the caller
946 is responsible for freeing it. Return the number of bytes successfully
950 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
952 int tlen
, origlen
, offset
, i
;
956 int buffer_allocated
;
958 unsigned int nbytes_read
= 0;
962 /* Small for testing. */
963 buffer_allocated
= 4;
964 buffer
= xmalloc (buffer_allocated
);
971 tlen
= MIN (len
, 4 - (memaddr
& 3));
972 offset
= memaddr
& 3;
974 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
977 /* The transfer request might have crossed the boundary to an
978 unallocated region of memory. Retry the transfer, requesting
982 errcode
= target_read_memory (memaddr
, buf
, 1);
987 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
990 bytes
= bufptr
- buffer
;
991 buffer_allocated
*= 2;
992 buffer
= xrealloc (buffer
, buffer_allocated
);
993 bufptr
= buffer
+ bytes
;
996 for (i
= 0; i
< tlen
; i
++)
998 *bufptr
++ = buf
[i
+ offset
];
999 if (buf
[i
+ offset
] == '\000')
1001 nbytes_read
+= i
+ 1;
1008 nbytes_read
+= tlen
;
1017 /* Find a section containing ADDR. */
1018 struct section_table
*
1019 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
1021 struct section_table
*secp
;
1022 for (secp
= target
->to_sections
;
1023 secp
< target
->to_sections_end
;
1026 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1032 /* Perform a partial memory transfer. The arguments and return
1033 value are just as for target_xfer_partial. */
1036 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1037 ULONGEST memaddr
, LONGEST len
)
1041 struct mem_region
*region
;
1043 /* Zero length requests are ok and require no work. */
1047 /* Try the executable file, if "trust-readonly-sections" is set. */
1048 if (readbuf
!= NULL
&& trust_readonly
)
1050 struct section_table
*secp
;
1052 secp
= target_section_by_addr (ops
, memaddr
);
1054 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1056 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1059 /* Likewise for accesses to unmapped overlay sections. */
1060 if (readbuf
!= NULL
&& overlay_debugging
)
1062 struct obj_section
*section
= find_pc_overlay (memaddr
);
1063 if (pc_in_unmapped_range (memaddr
, section
))
1064 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1067 /* Try GDB's internal data cache. */
1068 region
= lookup_mem_region (memaddr
);
1069 /* region->hi == 0 means there's no upper bound. */
1070 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1073 reg_len
= region
->hi
- memaddr
;
1075 switch (region
->attrib
.mode
)
1078 if (writebuf
!= NULL
)
1083 if (readbuf
!= NULL
)
1088 /* We only support writing to flash during "load" for now. */
1089 if (writebuf
!= NULL
)
1090 error (_("Writing to flash memory forbidden in this context"));
1097 if (region
->attrib
.cache
)
1099 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1100 memory request will start back at current_target. */
1101 if (readbuf
!= NULL
)
1102 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1105 /* FIXME drow/2006-08-09: If we're going to preserve const
1106 correctness dcache_xfer_memory should take readbuf and
1108 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1115 if (readbuf
&& !show_memory_breakpoints
)
1116 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1121 /* If none of those methods found the memory we wanted, fall back
1122 to a target partial transfer. Normally a single call to
1123 to_xfer_partial is enough; if it doesn't recognize an object
1124 it will call the to_xfer_partial of the next target down.
1125 But for memory this won't do. Memory is the only target
1126 object which can be read from more than one valid target.
1127 A core file, for instance, could have some of memory but
1128 delegate other bits to the target below it. So, we must
1129 manually try all targets. */
1133 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1134 readbuf
, writebuf
, memaddr
, reg_len
);
1138 /* We want to continue past core files to executables, but not
1139 past a running target's memory. */
1140 if (ops
->to_has_all_memory
)
1145 while (ops
!= NULL
);
1147 if (readbuf
&& !show_memory_breakpoints
)
1148 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1150 /* If we still haven't got anything, return the last error. We
1156 restore_show_memory_breakpoints (void *arg
)
1158 show_memory_breakpoints
= (uintptr_t) arg
;
1162 make_show_memory_breakpoints_cleanup (int show
)
1164 int current
= show_memory_breakpoints
;
1165 show_memory_breakpoints
= show
;
1167 return make_cleanup (restore_show_memory_breakpoints
,
1168 (void *) (uintptr_t) current
);
1172 target_xfer_partial (struct target_ops
*ops
,
1173 enum target_object object
, const char *annex
,
1174 void *readbuf
, const void *writebuf
,
1175 ULONGEST offset
, LONGEST len
)
1179 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1181 /* If this is a memory transfer, let the memory-specific code
1182 have a look at it instead. Memory transfers are more
1184 if (object
== TARGET_OBJECT_MEMORY
)
1185 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1188 enum target_object raw_object
= object
;
1190 /* If this is a raw memory transfer, request the normal
1191 memory object from other layers. */
1192 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1193 raw_object
= TARGET_OBJECT_MEMORY
;
1195 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1196 writebuf
, offset
, len
);
1201 const unsigned char *myaddr
= NULL
;
1203 fprintf_unfiltered (gdb_stdlog
,
1204 "%s:target_xfer_partial (%d, %s, %s, %s, %s, %s) = %s",
1207 (annex
? annex
: "(null)"),
1208 host_address_to_string (readbuf
),
1209 host_address_to_string (writebuf
),
1210 core_addr_to_string_nz (offset
),
1211 plongest (len
), plongest (retval
));
1217 if (retval
> 0 && myaddr
!= NULL
)
1221 fputs_unfiltered (", bytes =", gdb_stdlog
);
1222 for (i
= 0; i
< retval
; i
++)
1224 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
1226 if (targetdebug
< 2 && i
> 0)
1228 fprintf_unfiltered (gdb_stdlog
, " ...");
1231 fprintf_unfiltered (gdb_stdlog
, "\n");
1234 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1238 fputc_unfiltered ('\n', gdb_stdlog
);
1243 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1244 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1245 if any error occurs.
1247 If an error occurs, no guarantee is made about the contents of the data at
1248 MYADDR. In particular, the caller should not depend upon partial reads
1249 filling the buffer with good data. There is no way for the caller to know
1250 how much good data might have been transfered anyway. Callers that can
1251 deal with partial reads should call target_read (which will retry until
1252 it makes no progress, and then return how much was transferred). */
1255 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1257 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1258 myaddr
, memaddr
, len
) == len
)
1265 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1267 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1268 myaddr
, memaddr
, len
) == len
)
1274 /* Fetch the target's memory map. */
1277 target_memory_map (void)
1279 VEC(mem_region_s
) *result
;
1280 struct mem_region
*last_one
, *this_one
;
1282 struct target_ops
*t
;
1285 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1287 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1288 if (t
->to_memory_map
!= NULL
)
1294 result
= t
->to_memory_map (t
);
1298 qsort (VEC_address (mem_region_s
, result
),
1299 VEC_length (mem_region_s
, result
),
1300 sizeof (struct mem_region
), mem_region_cmp
);
1302 /* Check that regions do not overlap. Simultaneously assign
1303 a numbering for the "mem" commands to use to refer to
1306 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1308 this_one
->number
= ix
;
1310 if (last_one
&& last_one
->hi
> this_one
->lo
)
1312 warning (_("Overlapping regions in memory map: ignoring"));
1313 VEC_free (mem_region_s
, result
);
1316 last_one
= this_one
;
1323 target_flash_erase (ULONGEST address
, LONGEST length
)
1325 struct target_ops
*t
;
1327 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1328 if (t
->to_flash_erase
!= NULL
)
1331 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1332 paddr (address
), phex (length
, 0));
1333 t
->to_flash_erase (t
, address
, length
);
1341 target_flash_done (void)
1343 struct target_ops
*t
;
1345 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1346 if (t
->to_flash_done
!= NULL
)
1349 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1350 t
->to_flash_done (t
);
1358 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1359 struct cmd_list_element
*c
, const char *value
)
1361 fprintf_filtered (file
, _("\
1362 Mode for reading from readonly sections is %s.\n"),
1366 /* More generic transfers. */
1369 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1370 const char *annex
, gdb_byte
*readbuf
,
1371 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1373 if (object
== TARGET_OBJECT_MEMORY
1374 && ops
->deprecated_xfer_memory
!= NULL
)
1375 /* If available, fall back to the target's
1376 "deprecated_xfer_memory" method. */
1380 if (writebuf
!= NULL
)
1382 void *buffer
= xmalloc (len
);
1383 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1384 memcpy (buffer
, writebuf
, len
);
1385 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1386 1/*write*/, NULL
, ops
);
1387 do_cleanups (cleanup
);
1389 if (readbuf
!= NULL
)
1390 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1391 0/*read*/, NULL
, ops
);
1394 else if (xfered
== 0 && errno
== 0)
1395 /* "deprecated_xfer_memory" uses 0, cross checked against
1396 ERRNO as one indication of an error. */
1401 else if (ops
->beneath
!= NULL
)
1402 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1403 readbuf
, writebuf
, offset
, len
);
1408 /* The xfer_partial handler for the topmost target. Unlike the default,
1409 it does not need to handle memory specially; it just passes all
1410 requests down the stack. */
1413 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1414 const char *annex
, gdb_byte
*readbuf
,
1415 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1417 if (ops
->beneath
!= NULL
)
1418 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1419 readbuf
, writebuf
, offset
, len
);
1424 /* Target vector read/write partial wrapper functions.
1426 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1427 (inbuf, outbuf)", instead of separate read/write methods, make life
1431 target_read_partial (struct target_ops
*ops
,
1432 enum target_object object
,
1433 const char *annex
, gdb_byte
*buf
,
1434 ULONGEST offset
, LONGEST len
)
1436 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1440 target_write_partial (struct target_ops
*ops
,
1441 enum target_object object
,
1442 const char *annex
, const gdb_byte
*buf
,
1443 ULONGEST offset
, LONGEST len
)
1445 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1448 /* Wrappers to perform the full transfer. */
1450 target_read (struct target_ops
*ops
,
1451 enum target_object object
,
1452 const char *annex
, gdb_byte
*buf
,
1453 ULONGEST offset
, LONGEST len
)
1456 while (xfered
< len
)
1458 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1459 (gdb_byte
*) buf
+ xfered
,
1460 offset
+ xfered
, len
- xfered
);
1461 /* Call an observer, notifying them of the xfer progress? */
1473 target_read_until_error (struct target_ops
*ops
,
1474 enum target_object object
,
1475 const char *annex
, gdb_byte
*buf
,
1476 ULONGEST offset
, LONGEST len
)
1479 while (xfered
< len
)
1481 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1482 (gdb_byte
*) buf
+ xfered
,
1483 offset
+ xfered
, len
- xfered
);
1484 /* Call an observer, notifying them of the xfer progress? */
1489 /* We've got an error. Try to read in smaller blocks. */
1490 ULONGEST start
= offset
+ xfered
;
1491 ULONGEST remaining
= len
- xfered
;
1494 /* If an attempt was made to read a random memory address,
1495 it's likely that the very first byte is not accessible.
1496 Try reading the first byte, to avoid doing log N tries
1498 xfer
= target_read_partial (ops
, object
, annex
,
1499 (gdb_byte
*) buf
+ xfered
, start
, 1);
1508 xfer
= target_read_partial (ops
, object
, annex
,
1509 (gdb_byte
*) buf
+ xfered
,
1519 /* We have successfully read the first half. So, the
1520 error must be in the second half. Adjust start and
1521 remaining to point at the second half. */
1538 /* An alternative to target_write with progress callbacks. */
1541 target_write_with_progress (struct target_ops
*ops
,
1542 enum target_object object
,
1543 const char *annex
, const gdb_byte
*buf
,
1544 ULONGEST offset
, LONGEST len
,
1545 void (*progress
) (ULONGEST
, void *), void *baton
)
1549 /* Give the progress callback a chance to set up. */
1551 (*progress
) (0, baton
);
1553 while (xfered
< len
)
1555 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1556 (gdb_byte
*) buf
+ xfered
,
1557 offset
+ xfered
, len
- xfered
);
1565 (*progress
) (xfer
, baton
);
1574 target_write (struct target_ops
*ops
,
1575 enum target_object object
,
1576 const char *annex
, const gdb_byte
*buf
,
1577 ULONGEST offset
, LONGEST len
)
1579 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1583 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1584 the size of the transferred data. PADDING additional bytes are
1585 available in *BUF_P. This is a helper function for
1586 target_read_alloc; see the declaration of that function for more
1590 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1591 const char *annex
, gdb_byte
**buf_p
, int padding
)
1593 size_t buf_alloc
, buf_pos
;
1597 /* This function does not have a length parameter; it reads the
1598 entire OBJECT). Also, it doesn't support objects fetched partly
1599 from one target and partly from another (in a different stratum,
1600 e.g. a core file and an executable). Both reasons make it
1601 unsuitable for reading memory. */
1602 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1604 /* Start by reading up to 4K at a time. The target will throttle
1605 this number down if necessary. */
1607 buf
= xmalloc (buf_alloc
);
1611 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1612 buf_pos
, buf_alloc
- buf_pos
- padding
);
1615 /* An error occurred. */
1621 /* Read all there was. */
1631 /* If the buffer is filling up, expand it. */
1632 if (buf_alloc
< buf_pos
* 2)
1635 buf
= xrealloc (buf
, buf_alloc
);
1642 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1643 the size of the transferred data. See the declaration in "target.h"
1644 function for more information about the return value. */
1647 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1648 const char *annex
, gdb_byte
**buf_p
)
1650 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1653 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1654 returned as a string, allocated using xmalloc. If an error occurs
1655 or the transfer is unsupported, NULL is returned. Empty objects
1656 are returned as allocated but empty strings. A warning is issued
1657 if the result contains any embedded NUL bytes. */
1660 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1664 LONGEST transferred
;
1666 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1668 if (transferred
< 0)
1671 if (transferred
== 0)
1672 return xstrdup ("");
1674 buffer
[transferred
] = 0;
1675 if (strlen (buffer
) < transferred
)
1676 warning (_("target object %d, annex %s, "
1677 "contained unexpected null characters"),
1678 (int) object
, annex
? annex
: "(none)");
1680 return (char *) buffer
;
1683 /* Memory transfer methods. */
1686 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1689 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1691 memory_error (EIO
, addr
);
1695 get_target_memory_unsigned (struct target_ops
*ops
,
1696 CORE_ADDR addr
, int len
)
1698 gdb_byte buf
[sizeof (ULONGEST
)];
1700 gdb_assert (len
<= sizeof (buf
));
1701 get_target_memory (ops
, addr
, buf
, len
);
1702 return extract_unsigned_integer (buf
, len
);
1706 target_info (char *args
, int from_tty
)
1708 struct target_ops
*t
;
1709 int has_all_mem
= 0;
1711 if (symfile_objfile
!= NULL
)
1712 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1714 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1716 if (!t
->to_has_memory
)
1719 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1722 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1723 printf_unfiltered ("%s:\n", t
->to_longname
);
1724 (t
->to_files_info
) (t
);
1725 has_all_mem
= t
->to_has_all_memory
;
1729 /* This function is called before any new inferior is created, e.g.
1730 by running a program, attaching, or connecting to a target.
1731 It cleans up any state from previous invocations which might
1732 change between runs. This is a subset of what target_preopen
1733 resets (things which might change between targets). */
1736 target_pre_inferior (int from_tty
)
1738 /* Clear out solib state. Otherwise the solib state of the previous
1739 inferior might have survived and is entirely wrong for the new
1740 target. This has been observed on GNU/Linux using glibc 2.3. How
1752 Cannot access memory at address 0xdeadbeef
1755 /* In some OSs, the shared library list is the same/global/shared
1756 across inferiors. If code is shared between processes, so are
1757 memory regions and features. */
1758 if (!gdbarch_has_global_solist (target_gdbarch
))
1760 no_shared_libraries (NULL
, from_tty
);
1762 invalidate_target_mem_regions ();
1764 target_clear_description ();
1768 /* This is to be called by the open routine before it does
1772 target_preopen (int from_tty
)
1776 if (target_has_execution
)
1779 || query (_("A program is being debugged already. Kill it? ")))
1782 error (_("Program not killed."));
1785 /* Calling target_kill may remove the target from the stack. But if
1786 it doesn't (which seems like a win for UDI), remove it now. */
1787 /* Leave the exec target, though. The user may be switching from a
1788 live process to a core of the same program. */
1789 pop_all_targets_above (file_stratum
, 0);
1791 target_pre_inferior (from_tty
);
1794 /* Detach a target after doing deferred register stores. */
1797 target_detach (char *args
, int from_tty
)
1799 struct target_ops
* t
;
1801 if (gdbarch_has_global_solist (target_gdbarch
))
1802 /* Don't remove global breakpoints here. They're removed on
1803 disconnection from the target. */
1806 /* If we're in breakpoints-always-inserted mode, have to remove
1807 them before detaching. */
1808 remove_breakpoints ();
1810 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1812 if (t
->to_detach
!= NULL
)
1814 t
->to_detach (t
, args
, from_tty
);
1816 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n",
1822 internal_error (__FILE__
, __LINE__
, "could not find a target to detach");
1826 target_disconnect (char *args
, int from_tty
)
1828 struct target_ops
*t
;
1830 /* If we're in breakpoints-always-inserted mode or if breakpoints
1831 are global across processes, we have to remove them before
1833 remove_breakpoints ();
1835 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1836 if (t
->to_disconnect
!= NULL
)
1839 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1841 t
->to_disconnect (t
, args
, from_tty
);
1849 target_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1851 struct target_ops
*t
;
1853 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1855 if (t
->to_wait
!= NULL
)
1857 ptid_t retval
= (*t
->to_wait
) (t
, ptid
, status
);
1861 char *status_string
;
1863 status_string
= target_waitstatus_to_string (status
);
1864 fprintf_unfiltered (gdb_stdlog
,
1865 "target_wait (%d, status) = %d, %s\n",
1866 PIDGET (ptid
), PIDGET (retval
),
1868 xfree (status_string
);
1879 target_pid_to_str (ptid_t ptid
)
1881 struct target_ops
*t
;
1883 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1885 if (t
->to_pid_to_str
!= NULL
)
1886 return (*t
->to_pid_to_str
) (t
, ptid
);
1889 return normal_pid_to_str (ptid
);
1893 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1895 dcache_invalidate (target_dcache
);
1896 (*current_target
.to_resume
) (ptid
, step
, signal
);
1897 set_executing (ptid
, 1);
1898 set_running (ptid
, 1);
1900 /* Look through the list of possible targets for a target that can
1904 target_follow_fork (int follow_child
)
1906 struct target_ops
*t
;
1908 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1910 if (t
->to_follow_fork
!= NULL
)
1912 int retval
= t
->to_follow_fork (t
, follow_child
);
1914 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1915 follow_child
, retval
);
1920 /* Some target returned a fork event, but did not know how to follow it. */
1921 internal_error (__FILE__
, __LINE__
,
1922 "could not find a target to follow fork");
1926 target_mourn_inferior (void)
1928 struct target_ops
*t
;
1929 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1931 if (t
->to_mourn_inferior
!= NULL
)
1933 t
->to_mourn_inferior (t
);
1935 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
1940 internal_error (__FILE__
, __LINE__
,
1941 "could not find a target to follow mourn inferiour");
1944 /* Look for a target which can describe architectural features, starting
1945 from TARGET. If we find one, return its description. */
1947 const struct target_desc
*
1948 target_read_description (struct target_ops
*target
)
1950 struct target_ops
*t
;
1952 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1953 if (t
->to_read_description
!= NULL
)
1955 const struct target_desc
*tdesc
;
1957 tdesc
= t
->to_read_description (t
);
1965 /* The default implementation of to_search_memory.
1966 This implements a basic search of memory, reading target memory and
1967 performing the search here (as opposed to performing the search in on the
1968 target side with, for example, gdbserver). */
1971 simple_search_memory (struct target_ops
*ops
,
1972 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1973 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1974 CORE_ADDR
*found_addrp
)
1976 /* NOTE: also defined in find.c testcase. */
1977 #define SEARCH_CHUNK_SIZE 16000
1978 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1979 /* Buffer to hold memory contents for searching. */
1980 gdb_byte
*search_buf
;
1981 unsigned search_buf_size
;
1982 struct cleanup
*old_cleanups
;
1984 search_buf_size
= chunk_size
+ pattern_len
- 1;
1986 /* No point in trying to allocate a buffer larger than the search space. */
1987 if (search_space_len
< search_buf_size
)
1988 search_buf_size
= search_space_len
;
1990 search_buf
= malloc (search_buf_size
);
1991 if (search_buf
== NULL
)
1992 error (_("Unable to allocate memory to perform the search."));
1993 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1995 /* Prime the search buffer. */
1997 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1998 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
2000 warning (_("Unable to access target memory at %s, halting search."),
2001 hex_string (start_addr
));
2002 do_cleanups (old_cleanups
);
2006 /* Perform the search.
2008 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2009 When we've scanned N bytes we copy the trailing bytes to the start and
2010 read in another N bytes. */
2012 while (search_space_len
>= pattern_len
)
2014 gdb_byte
*found_ptr
;
2015 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
2017 found_ptr
= memmem (search_buf
, nr_search_bytes
,
2018 pattern
, pattern_len
);
2020 if (found_ptr
!= NULL
)
2022 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
2023 *found_addrp
= found_addr
;
2024 do_cleanups (old_cleanups
);
2028 /* Not found in this chunk, skip to next chunk. */
2030 /* Don't let search_space_len wrap here, it's unsigned. */
2031 if (search_space_len
>= chunk_size
)
2032 search_space_len
-= chunk_size
;
2034 search_space_len
= 0;
2036 if (search_space_len
>= pattern_len
)
2038 unsigned keep_len
= search_buf_size
- chunk_size
;
2039 CORE_ADDR read_addr
= start_addr
+ keep_len
;
2042 /* Copy the trailing part of the previous iteration to the front
2043 of the buffer for the next iteration. */
2044 gdb_assert (keep_len
== pattern_len
- 1);
2045 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
2047 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
2049 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
2050 search_buf
+ keep_len
, read_addr
,
2051 nr_to_read
) != nr_to_read
)
2053 warning (_("Unable to access target memory at %s, halting search."),
2054 hex_string (read_addr
));
2055 do_cleanups (old_cleanups
);
2059 start_addr
+= chunk_size
;
2065 do_cleanups (old_cleanups
);
2069 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2070 sequence of bytes in PATTERN with length PATTERN_LEN.
2072 The result is 1 if found, 0 if not found, and -1 if there was an error
2073 requiring halting of the search (e.g. memory read error).
2074 If the pattern is found the address is recorded in FOUND_ADDRP. */
2077 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
2078 const gdb_byte
*pattern
, ULONGEST pattern_len
,
2079 CORE_ADDR
*found_addrp
)
2081 struct target_ops
*t
;
2084 /* We don't use INHERIT to set current_target.to_search_memory,
2085 so we have to scan the target stack and handle targetdebug
2089 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
2090 hex_string (start_addr
));
2092 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2093 if (t
->to_search_memory
!= NULL
)
2098 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
2099 pattern
, pattern_len
, found_addrp
);
2103 /* If a special version of to_search_memory isn't available, use the
2105 found
= simple_search_memory (¤t_target
,
2106 start_addr
, search_space_len
,
2107 pattern
, pattern_len
, found_addrp
);
2111 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
2116 /* Look through the currently pushed targets. If none of them will
2117 be able to restart the currently running process, issue an error
2121 target_require_runnable (void)
2123 struct target_ops
*t
;
2125 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2127 /* If this target knows how to create a new program, then
2128 assume we will still be able to after killing the current
2129 one. Either killing and mourning will not pop T, or else
2130 find_default_run_target will find it again. */
2131 if (t
->to_create_inferior
!= NULL
)
2134 /* Do not worry about thread_stratum targets that can not
2135 create inferiors. Assume they will be pushed again if
2136 necessary, and continue to the process_stratum. */
2137 if (t
->to_stratum
== thread_stratum
)
2141 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2145 /* This function is only called if the target is running. In that
2146 case there should have been a process_stratum target and it
2147 should either know how to create inferiors, or not... */
2148 internal_error (__FILE__
, __LINE__
, "No targets found");
2151 /* Look through the list of possible targets for a target that can
2152 execute a run or attach command without any other data. This is
2153 used to locate the default process stratum.
2155 If DO_MESG is not NULL, the result is always valid (error() is
2156 called for errors); else, return NULL on error. */
2158 static struct target_ops
*
2159 find_default_run_target (char *do_mesg
)
2161 struct target_ops
**t
;
2162 struct target_ops
*runable
= NULL
;
2167 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2170 if ((*t
)->to_can_run
&& target_can_run (*t
))
2180 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2189 find_default_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2191 struct target_ops
*t
;
2193 t
= find_default_run_target ("attach");
2194 (t
->to_attach
) (t
, args
, from_tty
);
2199 find_default_create_inferior (struct target_ops
*ops
,
2200 char *exec_file
, char *allargs
, char **env
,
2203 struct target_ops
*t
;
2205 t
= find_default_run_target ("run");
2206 (t
->to_create_inferior
) (t
, exec_file
, allargs
, env
, from_tty
);
2211 find_default_can_async_p (void)
2213 struct target_ops
*t
;
2215 /* This may be called before the target is pushed on the stack;
2216 look for the default process stratum. If there's none, gdb isn't
2217 configured with a native debugger, and target remote isn't
2219 t
= find_default_run_target (NULL
);
2220 if (t
&& t
->to_can_async_p
)
2221 return (t
->to_can_async_p
) ();
2226 find_default_is_async_p (void)
2228 struct target_ops
*t
;
2230 /* This may be called before the target is pushed on the stack;
2231 look for the default process stratum. If there's none, gdb isn't
2232 configured with a native debugger, and target remote isn't
2234 t
= find_default_run_target (NULL
);
2235 if (t
&& t
->to_is_async_p
)
2236 return (t
->to_is_async_p
) ();
2241 find_default_supports_non_stop (void)
2243 struct target_ops
*t
;
2245 t
= find_default_run_target (NULL
);
2246 if (t
&& t
->to_supports_non_stop
)
2247 return (t
->to_supports_non_stop
) ();
2252 target_supports_non_stop ()
2254 struct target_ops
*t
;
2255 for (t
= ¤t_target
; t
!= NULL
; t
= t
->beneath
)
2256 if (t
->to_supports_non_stop
)
2257 return t
->to_supports_non_stop ();
2264 target_get_osdata (const char *type
)
2267 struct target_ops
*t
;
2269 /* If we're already connected to something that can get us OS
2270 related data, use it. Otherwise, try using the native
2272 if (current_target
.to_stratum
>= process_stratum
)
2273 t
= current_target
.beneath
;
2275 t
= find_default_run_target ("get OS data");
2280 return target_read_stralloc (t
, TARGET_OBJECT_OSDATA
, type
);
2284 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2286 return (len
<= gdbarch_ptr_bit (target_gdbarch
) / TARGET_CHAR_BIT
);
2290 default_watchpoint_addr_within_range (struct target_ops
*target
,
2292 CORE_ADDR start
, int length
)
2294 return addr
>= start
&& addr
< start
+ length
;
2310 return_minus_one (void)
2316 * Resize the to_sections pointer. Also make sure that anyone that
2317 * was holding on to an old value of it gets updated.
2318 * Returns the old size.
2322 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2324 struct target_ops
**t
;
2325 struct section_table
*old_value
;
2328 old_value
= target
->to_sections
;
2330 if (target
->to_sections
)
2332 old_count
= target
->to_sections_end
- target
->to_sections
;
2333 target
->to_sections
= (struct section_table
*)
2334 xrealloc ((char *) target
->to_sections
,
2335 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2340 target
->to_sections
= (struct section_table
*)
2341 xmalloc ((sizeof (struct section_table
)) * num_added
);
2343 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2345 /* Check to see if anyone else was pointing to this structure.
2346 If old_value was null, then no one was. */
2350 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2353 if ((*t
)->to_sections
== old_value
)
2355 (*t
)->to_sections
= target
->to_sections
;
2356 (*t
)->to_sections_end
= target
->to_sections_end
;
2359 /* There is a flattened view of the target stack in current_target,
2360 so its to_sections pointer might also need updating. */
2361 if (current_target
.to_sections
== old_value
)
2363 current_target
.to_sections
= target
->to_sections
;
2364 current_target
.to_sections_end
= target
->to_sections_end
;
2372 /* Remove all target sections taken from ABFD.
2374 Scan the current target stack for targets whose section tables
2375 refer to sections from BFD, and remove those sections. We use this
2376 when we notice that the inferior has unloaded a shared object, for
2379 remove_target_sections (bfd
*abfd
)
2381 struct target_ops
**t
;
2383 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2385 struct section_table
*src
, *dest
;
2387 dest
= (*t
)->to_sections
;
2388 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2389 if (src
->bfd
!= abfd
)
2391 /* Keep this section. */
2392 if (dest
< src
) *dest
= *src
;
2396 /* If we've dropped any sections, resize the section table. */
2398 target_resize_to_sections (*t
, dest
- src
);
2405 /* Find a single runnable target in the stack and return it. If for
2406 some reason there is more than one, return NULL. */
2409 find_run_target (void)
2411 struct target_ops
**t
;
2412 struct target_ops
*runable
= NULL
;
2417 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2419 if ((*t
)->to_can_run
&& target_can_run (*t
))
2426 return (count
== 1 ? runable
: NULL
);
2429 /* Find a single core_stratum target in the list of targets and return it.
2430 If for some reason there is more than one, return NULL. */
2433 find_core_target (void)
2435 struct target_ops
**t
;
2436 struct target_ops
*runable
= NULL
;
2441 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2444 if ((*t
)->to_stratum
== core_stratum
)
2451 return (count
== 1 ? runable
: NULL
);
2455 * Find the next target down the stack from the specified target.
2459 find_target_beneath (struct target_ops
*t
)
2465 /* The inferior process has died. Long live the inferior! */
2468 generic_mourn_inferior (void)
2472 ptid
= inferior_ptid
;
2473 inferior_ptid
= null_ptid
;
2475 if (!ptid_equal (ptid
, null_ptid
))
2477 int pid
= ptid_get_pid (ptid
);
2478 delete_inferior (pid
);
2481 breakpoint_init_inferior (inf_exited
);
2482 registers_changed ();
2484 reopen_exec_file ();
2485 reinit_frame_cache ();
2487 if (deprecated_detach_hook
)
2488 deprecated_detach_hook ();
2491 /* Helper function for child_wait and the derivatives of child_wait.
2492 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2493 translation of that in OURSTATUS. */
2495 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2497 if (WIFEXITED (hoststatus
))
2499 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2500 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2502 else if (!WIFSTOPPED (hoststatus
))
2504 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2505 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2509 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2510 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2514 /* Convert a normal process ID to a string. Returns the string in a
2518 normal_pid_to_str (ptid_t ptid
)
2520 static char buf
[32];
2522 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2527 dummy_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2529 return normal_pid_to_str (ptid
);
2532 /* Error-catcher for target_find_memory_regions */
2533 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2535 error (_("No target."));
2539 /* Error-catcher for target_make_corefile_notes */
2540 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2542 error (_("No target."));
2546 /* Set up the handful of non-empty slots needed by the dummy target
2550 init_dummy_target (void)
2552 dummy_target
.to_shortname
= "None";
2553 dummy_target
.to_longname
= "None";
2554 dummy_target
.to_doc
= "";
2555 dummy_target
.to_attach
= find_default_attach
;
2556 dummy_target
.to_detach
=
2557 (void (*)(struct target_ops
*, char *, int))target_ignore
;
2558 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2559 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2560 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2561 dummy_target
.to_supports_non_stop
= find_default_supports_non_stop
;
2562 dummy_target
.to_pid_to_str
= dummy_pid_to_str
;
2563 dummy_target
.to_stratum
= dummy_stratum
;
2564 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2565 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2566 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2567 dummy_target
.to_magic
= OPS_MAGIC
;
2571 debug_to_open (char *args
, int from_tty
)
2573 debug_target
.to_open (args
, from_tty
);
2575 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2579 target_close (struct target_ops
*targ
, int quitting
)
2581 if (targ
->to_xclose
!= NULL
)
2582 targ
->to_xclose (targ
, quitting
);
2583 else if (targ
->to_close
!= NULL
)
2584 targ
->to_close (quitting
);
2587 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2591 target_attach (char *args
, int from_tty
)
2593 struct target_ops
*t
;
2594 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
2596 if (t
->to_attach
!= NULL
)
2598 t
->to_attach (t
, args
, from_tty
);
2600 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n",
2606 internal_error (__FILE__
, __LINE__
,
2607 "could not find a target to attach");
2611 debug_to_post_attach (int pid
)
2613 debug_target
.to_post_attach (pid
);
2615 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2619 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2621 debug_target
.to_resume (ptid
, step
, siggnal
);
2623 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2624 step
? "step" : "continue",
2625 target_signal_to_name (siggnal
));
2628 /* Return a pretty printed form of target_waitstatus.
2629 Space for the result is malloc'd, caller must free. */
2632 target_waitstatus_to_string (const struct target_waitstatus
*ws
)
2634 const char *kind_str
= "status->kind = ";
2638 case TARGET_WAITKIND_EXITED
:
2639 return xstrprintf ("%sexited, status = %d",
2640 kind_str
, ws
->value
.integer
);
2641 case TARGET_WAITKIND_STOPPED
:
2642 return xstrprintf ("%sstopped, signal = %s",
2643 kind_str
, target_signal_to_name (ws
->value
.sig
));
2644 case TARGET_WAITKIND_SIGNALLED
:
2645 return xstrprintf ("%ssignalled, signal = %s",
2646 kind_str
, target_signal_to_name (ws
->value
.sig
));
2647 case TARGET_WAITKIND_LOADED
:
2648 return xstrprintf ("%sloaded", kind_str
);
2649 case TARGET_WAITKIND_FORKED
:
2650 return xstrprintf ("%sforked", kind_str
);
2651 case TARGET_WAITKIND_VFORKED
:
2652 return xstrprintf ("%svforked", kind_str
);
2653 case TARGET_WAITKIND_EXECD
:
2654 return xstrprintf ("%sexecd", kind_str
);
2655 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2656 return xstrprintf ("%ssyscall-entry", kind_str
);
2657 case TARGET_WAITKIND_SYSCALL_RETURN
:
2658 return xstrprintf ("%ssyscall-return", kind_str
);
2659 case TARGET_WAITKIND_SPURIOUS
:
2660 return xstrprintf ("%sspurious", kind_str
);
2661 case TARGET_WAITKIND_IGNORE
:
2662 return xstrprintf ("%signore", kind_str
);
2663 case TARGET_WAITKIND_NO_HISTORY
:
2664 return xstrprintf ("%sno-history", kind_str
);
2666 return xstrprintf ("%sunknown???", kind_str
);
2671 debug_print_register (const char * func
,
2672 struct regcache
*regcache
, int regno
)
2674 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2675 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2676 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2677 && gdbarch_register_name (gdbarch
, regno
) != NULL
2678 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2679 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2680 gdbarch_register_name (gdbarch
, regno
));
2682 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2683 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
2685 int i
, size
= register_size (gdbarch
, regno
);
2686 unsigned char buf
[MAX_REGISTER_SIZE
];
2687 regcache_raw_collect (regcache
, regno
, buf
);
2688 fprintf_unfiltered (gdb_stdlog
, " = ");
2689 for (i
= 0; i
< size
; i
++)
2691 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2693 if (size
<= sizeof (LONGEST
))
2695 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2696 fprintf_unfiltered (gdb_stdlog
, " %s %s",
2697 core_addr_to_string_nz (val
), plongest (val
));
2700 fprintf_unfiltered (gdb_stdlog
, "\n");
2704 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2706 debug_target
.to_fetch_registers (regcache
, regno
);
2707 debug_print_register ("target_fetch_registers", regcache
, regno
);
2711 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2713 debug_target
.to_store_registers (regcache
, regno
);
2714 debug_print_register ("target_store_registers", regcache
, regno
);
2715 fprintf_unfiltered (gdb_stdlog
, "\n");
2719 debug_to_prepare_to_store (struct regcache
*regcache
)
2721 debug_target
.to_prepare_to_store (regcache
);
2723 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2727 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2728 int write
, struct mem_attrib
*attrib
,
2729 struct target_ops
*target
)
2733 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2736 fprintf_unfiltered (gdb_stdlog
,
2737 "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
2738 paddress (memaddr
), len
, write
? "write" : "read",
2745 fputs_unfiltered (", bytes =", gdb_stdlog
);
2746 for (i
= 0; i
< retval
; i
++)
2748 if ((((intptr_t) &(myaddr
[i
])) & 0xf) == 0)
2750 if (targetdebug
< 2 && i
> 0)
2752 fprintf_unfiltered (gdb_stdlog
, " ...");
2755 fprintf_unfiltered (gdb_stdlog
, "\n");
2758 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2762 fputc_unfiltered ('\n', gdb_stdlog
);
2768 debug_to_files_info (struct target_ops
*target
)
2770 debug_target
.to_files_info (target
);
2772 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2776 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2780 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2782 fprintf_unfiltered (gdb_stdlog
,
2783 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2784 (unsigned long) bp_tgt
->placed_address
,
2785 (unsigned long) retval
);
2790 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2794 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2796 fprintf_unfiltered (gdb_stdlog
,
2797 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2798 (unsigned long) bp_tgt
->placed_address
,
2799 (unsigned long) retval
);
2804 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2808 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2810 fprintf_unfiltered (gdb_stdlog
,
2811 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2812 (unsigned long) type
,
2813 (unsigned long) cnt
,
2814 (unsigned long) from_tty
,
2815 (unsigned long) retval
);
2820 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2824 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2826 fprintf_unfiltered (gdb_stdlog
,
2827 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2828 (unsigned long) addr
,
2829 (unsigned long) len
,
2830 (unsigned long) retval
);
2835 debug_to_stopped_by_watchpoint (void)
2839 retval
= debug_target
.to_stopped_by_watchpoint ();
2841 fprintf_unfiltered (gdb_stdlog
,
2842 "STOPPED_BY_WATCHPOINT () = %ld\n",
2843 (unsigned long) retval
);
2848 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2852 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2854 fprintf_unfiltered (gdb_stdlog
,
2855 "target_stopped_data_address ([0x%lx]) = %ld\n",
2856 (unsigned long)*addr
,
2857 (unsigned long)retval
);
2862 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2864 CORE_ADDR start
, int length
)
2868 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2871 fprintf_filtered (gdb_stdlog
,
2872 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2873 (unsigned long) addr
, (unsigned long) start
, length
,
2879 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2883 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2885 fprintf_unfiltered (gdb_stdlog
,
2886 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2887 (unsigned long) bp_tgt
->placed_address
,
2888 (unsigned long) retval
);
2893 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2897 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2899 fprintf_unfiltered (gdb_stdlog
,
2900 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2901 (unsigned long) bp_tgt
->placed_address
,
2902 (unsigned long) retval
);
2907 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2911 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2913 fprintf_unfiltered (gdb_stdlog
,
2914 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2915 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2920 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2924 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2926 fprintf_unfiltered (gdb_stdlog
,
2927 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2928 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2933 debug_to_terminal_init (void)
2935 debug_target
.to_terminal_init ();
2937 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2941 debug_to_terminal_inferior (void)
2943 debug_target
.to_terminal_inferior ();
2945 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2949 debug_to_terminal_ours_for_output (void)
2951 debug_target
.to_terminal_ours_for_output ();
2953 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2957 debug_to_terminal_ours (void)
2959 debug_target
.to_terminal_ours ();
2961 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2965 debug_to_terminal_save_ours (void)
2967 debug_target
.to_terminal_save_ours ();
2969 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2973 debug_to_terminal_info (char *arg
, int from_tty
)
2975 debug_target
.to_terminal_info (arg
, from_tty
);
2977 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2982 debug_to_kill (void)
2984 debug_target
.to_kill ();
2986 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2990 debug_to_load (char *args
, int from_tty
)
2992 debug_target
.to_load (args
, from_tty
);
2994 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2998 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
3002 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
3004 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
3010 debug_to_post_startup_inferior (ptid_t ptid
)
3012 debug_target
.to_post_startup_inferior (ptid
);
3014 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
3019 debug_to_acknowledge_created_inferior (int pid
)
3021 debug_target
.to_acknowledge_created_inferior (pid
);
3023 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
3028 debug_to_insert_fork_catchpoint (int pid
)
3030 debug_target
.to_insert_fork_catchpoint (pid
);
3032 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
3037 debug_to_remove_fork_catchpoint (int pid
)
3041 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
3043 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
3050 debug_to_insert_vfork_catchpoint (int pid
)
3052 debug_target
.to_insert_vfork_catchpoint (pid
);
3054 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
3059 debug_to_remove_vfork_catchpoint (int pid
)
3063 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
3065 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
3072 debug_to_insert_exec_catchpoint (int pid
)
3074 debug_target
.to_insert_exec_catchpoint (pid
);
3076 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
3081 debug_to_remove_exec_catchpoint (int pid
)
3085 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
3087 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
3094 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
3098 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
3100 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
3101 pid
, wait_status
, *exit_status
, has_exited
);
3107 debug_to_can_run (void)
3111 retval
= debug_target
.to_can_run ();
3113 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
3119 debug_to_notice_signals (ptid_t ptid
)
3121 debug_target
.to_notice_signals (ptid
);
3123 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
3128 debug_to_thread_alive (ptid_t ptid
)
3132 retval
= debug_target
.to_thread_alive (ptid
);
3134 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
3135 PIDGET (ptid
), retval
);
3141 debug_to_find_new_threads (void)
3143 debug_target
.to_find_new_threads ();
3145 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
3149 debug_to_stop (ptid_t ptid
)
3151 debug_target
.to_stop (ptid
);
3153 fprintf_unfiltered (gdb_stdlog
, "target_stop (%s)\n",
3154 target_pid_to_str (ptid
));
3158 debug_to_rcmd (char *command
,
3159 struct ui_file
*outbuf
)
3161 debug_target
.to_rcmd (command
, outbuf
);
3162 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3166 debug_to_pid_to_exec_file (int pid
)
3170 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3172 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3179 setup_target_debug (void)
3181 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3183 current_target
.to_open
= debug_to_open
;
3184 current_target
.to_post_attach
= debug_to_post_attach
;
3185 current_target
.to_resume
= debug_to_resume
;
3186 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3187 current_target
.to_store_registers
= debug_to_store_registers
;
3188 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3189 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3190 current_target
.to_files_info
= debug_to_files_info
;
3191 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3192 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3193 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3194 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3195 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3196 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3197 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3198 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3199 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3200 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3201 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3202 current_target
.to_terminal_init
= debug_to_terminal_init
;
3203 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3204 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3205 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3206 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3207 current_target
.to_terminal_info
= debug_to_terminal_info
;
3208 current_target
.to_kill
= debug_to_kill
;
3209 current_target
.to_load
= debug_to_load
;
3210 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3211 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3212 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3213 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3214 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3215 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3216 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3217 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3218 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3219 current_target
.to_has_exited
= debug_to_has_exited
;
3220 current_target
.to_can_run
= debug_to_can_run
;
3221 current_target
.to_notice_signals
= debug_to_notice_signals
;
3222 current_target
.to_thread_alive
= debug_to_thread_alive
;
3223 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3224 current_target
.to_stop
= debug_to_stop
;
3225 current_target
.to_rcmd
= debug_to_rcmd
;
3226 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3230 static char targ_desc
[] =
3231 "Names of targets and files being debugged.\n\
3232 Shows the entire stack of targets currently in use (including the exec-file,\n\
3233 core-file, and process, if any), as well as the symbol file name.";
3236 do_monitor_command (char *cmd
,
3239 if ((current_target
.to_rcmd
3240 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3241 || (current_target
.to_rcmd
== debug_to_rcmd
3242 && (debug_target
.to_rcmd
3243 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3244 error (_("\"monitor\" command not supported by this target."));
3245 target_rcmd (cmd
, gdb_stdtarg
);
3248 /* Print the name of each layers of our target stack. */
3251 maintenance_print_target_stack (char *cmd
, int from_tty
)
3253 struct target_ops
*t
;
3255 printf_filtered (_("The current target stack is:\n"));
3257 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3259 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3263 /* Controls if async mode is permitted. */
3264 int target_async_permitted
= 0;
3266 /* The set command writes to this variable. If the inferior is
3267 executing, linux_nat_async_permitted is *not* updated. */
3268 static int target_async_permitted_1
= 0;
3271 set_maintenance_target_async_permitted (char *args
, int from_tty
,
3272 struct cmd_list_element
*c
)
3274 if (target_has_execution
)
3276 target_async_permitted_1
= target_async_permitted
;
3277 error (_("Cannot change this setting while the inferior is running."));
3280 target_async_permitted
= target_async_permitted_1
;
3284 show_maintenance_target_async_permitted (struct ui_file
*file
, int from_tty
,
3285 struct cmd_list_element
*c
,
3288 fprintf_filtered (file
, _("\
3289 Controlling the inferior in asynchronous mode is %s.\n"), value
);
3293 initialize_targets (void)
3295 init_dummy_target ();
3296 push_target (&dummy_target
);
3298 add_info ("target", target_info
, targ_desc
);
3299 add_info ("files", target_info
, targ_desc
);
3301 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3302 Set target debugging."), _("\
3303 Show target debugging."), _("\
3304 When non-zero, target debugging is enabled. Higher numbers are more\n\
3305 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3309 &setdebuglist
, &showdebuglist
);
3311 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3312 &trust_readonly
, _("\
3313 Set mode for reading from readonly sections."), _("\
3314 Show mode for reading from readonly sections."), _("\
3315 When this mode is on, memory reads from readonly sections (such as .text)\n\
3316 will be read from the object file instead of from the target. This will\n\
3317 result in significant performance improvement for remote targets."),
3319 show_trust_readonly
,
3320 &setlist
, &showlist
);
3322 add_com ("monitor", class_obscure
, do_monitor_command
,
3323 _("Send a command to the remote monitor (remote targets only)."));
3325 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3326 _("Print the name of each layer of the internal target stack."),
3327 &maintenanceprintlist
);
3329 add_setshow_boolean_cmd ("target-async", no_class
,
3330 &target_async_permitted_1
, _("\
3331 Set whether gdb controls the inferior in asynchronous mode."), _("\
3332 Show whether gdb controls the inferior in asynchronous mode."), _("\
3333 Tells gdb whether to control the inferior in asynchronous mode."),
3334 set_maintenance_target_async_permitted
,
3335 show_maintenance_target_async_permitted
,
3339 target_dcache
= dcache_init ();