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"
44 static void target_info (char *, int);
46 static void maybe_kill_then_attach (char *, int);
48 static void kill_or_be_killed (int);
50 static void default_terminal_info (char *, int);
52 static int default_watchpoint_addr_within_range (struct target_ops
*,
53 CORE_ADDR
, CORE_ADDR
, int);
55 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
57 static int nosymbol (char *, CORE_ADDR
*);
59 static void tcomplain (void) ATTR_NORETURN
;
61 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
63 static int return_zero (void);
65 static int return_one (void);
67 static int return_minus_one (void);
69 void target_ignore (void);
71 static void target_command (char *, int);
73 static struct target_ops
*find_default_run_target (char *);
75 static void nosupport_runtime (void);
77 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
78 enum target_object object
,
79 const char *annex
, gdb_byte
*readbuf
,
80 const gdb_byte
*writebuf
,
81 ULONGEST offset
, LONGEST len
);
83 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
84 enum target_object object
,
85 const char *annex
, gdb_byte
*readbuf
,
86 const gdb_byte
*writebuf
,
87 ULONGEST offset
, LONGEST len
);
89 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
90 enum target_object object
,
92 void *readbuf
, const void *writebuf
,
93 ULONGEST offset
, LONGEST len
);
95 static void init_dummy_target (void);
97 static struct target_ops debug_target
;
99 static void debug_to_open (char *, int);
101 static void debug_to_close (int);
103 static void debug_to_attach (char *, int);
105 static void debug_to_detach (char *, int);
107 static void debug_to_resume (ptid_t
, int, enum target_signal
);
109 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
111 static void debug_to_fetch_registers (struct regcache
*, int);
113 static void debug_to_store_registers (struct regcache
*, int);
115 static void debug_to_prepare_to_store (struct regcache
*);
117 static void debug_to_files_info (struct target_ops
*);
119 static int debug_to_insert_breakpoint (struct bp_target_info
*);
121 static int debug_to_remove_breakpoint (struct bp_target_info
*);
123 static int debug_to_can_use_hw_breakpoint (int, int, int);
125 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
127 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
129 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
131 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
133 static int debug_to_stopped_by_watchpoint (void);
135 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
137 static int debug_to_watchpoint_addr_within_range (struct target_ops
*,
138 CORE_ADDR
, CORE_ADDR
, int);
140 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
142 static void debug_to_terminal_init (void);
144 static void debug_to_terminal_inferior (void);
146 static void debug_to_terminal_ours_for_output (void);
148 static void debug_to_terminal_save_ours (void);
150 static void debug_to_terminal_ours (void);
152 static void debug_to_terminal_info (char *, int);
154 static void debug_to_kill (void);
156 static void debug_to_load (char *, int);
158 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
160 static void debug_to_mourn_inferior (void);
162 static int debug_to_can_run (void);
164 static void debug_to_notice_signals (ptid_t
);
166 static int debug_to_thread_alive (ptid_t
);
168 static void debug_to_stop (void);
170 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
171 wierd and mysterious ways. Putting the variable here lets those
172 wierd and mysterious ways keep building while they are being
173 converted to the inferior inheritance structure. */
174 struct target_ops deprecated_child_ops
;
176 /* Pointer to array of target architecture structures; the size of the
177 array; the current index into the array; the allocated size of the
179 struct target_ops
**target_structs
;
180 unsigned target_struct_size
;
181 unsigned target_struct_index
;
182 unsigned target_struct_allocsize
;
183 #define DEFAULT_ALLOCSIZE 10
185 /* The initial current target, so that there is always a semi-valid
188 static struct target_ops dummy_target
;
190 /* Top of target stack. */
192 static struct target_ops
*target_stack
;
194 /* The target structure we are currently using to talk to a process
195 or file or whatever "inferior" we have. */
197 struct target_ops current_target
;
199 /* Command list for target. */
201 static struct cmd_list_element
*targetlist
= NULL
;
203 /* Nonzero if we are debugging an attached outside process
204 rather than an inferior. */
208 /* Nonzero if we should trust readonly sections from the
209 executable when reading memory. */
211 static int trust_readonly
= 0;
213 /* Nonzero if we should show true memory content including
214 memory breakpoint inserted by gdb. */
216 static int show_memory_breakpoints
= 0;
218 /* Non-zero if we want to see trace of target level stuff. */
220 static int targetdebug
= 0;
222 show_targetdebug (struct ui_file
*file
, int from_tty
,
223 struct cmd_list_element
*c
, const char *value
)
225 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
228 static void setup_target_debug (void);
230 DCACHE
*target_dcache
;
232 /* The user just typed 'target' without the name of a target. */
235 target_command (char *arg
, int from_tty
)
237 fputs_filtered ("Argument required (target name). Try `help target'\n",
241 /* Add a possible target architecture to the list. */
244 add_target (struct target_ops
*t
)
246 /* Provide default values for all "must have" methods. */
247 if (t
->to_xfer_partial
== NULL
)
248 t
->to_xfer_partial
= default_xfer_partial
;
252 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
253 target_structs
= (struct target_ops
**) xmalloc
254 (target_struct_allocsize
* sizeof (*target_structs
));
256 if (target_struct_size
>= target_struct_allocsize
)
258 target_struct_allocsize
*= 2;
259 target_structs
= (struct target_ops
**)
260 xrealloc ((char *) target_structs
,
261 target_struct_allocsize
* sizeof (*target_structs
));
263 target_structs
[target_struct_size
++] = t
;
265 if (targetlist
== NULL
)
266 add_prefix_cmd ("target", class_run
, target_command
, _("\
267 Connect to a target machine or process.\n\
268 The first argument is the type or protocol of the target machine.\n\
269 Remaining arguments are interpreted by the target protocol. For more\n\
270 information on the arguments for a particular protocol, type\n\
271 `help target ' followed by the protocol name."),
272 &targetlist
, "target ", 0, &cmdlist
);
273 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
284 target_load (char *arg
, int from_tty
)
286 dcache_invalidate (target_dcache
);
287 (*current_target
.to_load
) (arg
, from_tty
);
291 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
292 struct target_ops
*t
)
294 errno
= EIO
; /* Can't read/write this location */
295 return 0; /* No bytes handled */
301 error (_("You can't do that when your target is `%s'"),
302 current_target
.to_shortname
);
308 error (_("You can't do that without a process to debug."));
312 nosymbol (char *name
, CORE_ADDR
*addrp
)
314 return 1; /* Symbol does not exist in target env */
318 nosupport_runtime (void)
320 if (ptid_equal (inferior_ptid
, null_ptid
))
323 error (_("No run-time support for this"));
328 default_terminal_info (char *args
, int from_tty
)
330 printf_unfiltered (_("No saved terminal information.\n"));
333 /* This is the default target_create_inferior and target_attach function.
334 If the current target is executing, it asks whether to kill it off.
335 If this function returns without calling error(), it has killed off
336 the target, and the operation should be attempted. */
339 kill_or_be_killed (int from_tty
)
341 if (target_has_execution
)
343 printf_unfiltered (_("You are already running a program:\n"));
344 target_files_info ();
345 if (query ("Kill it? "))
348 if (target_has_execution
)
349 error (_("Killing the program did not help."));
354 error (_("Program not killed."));
361 maybe_kill_then_attach (char *args
, int from_tty
)
363 kill_or_be_killed (from_tty
);
364 target_attach (args
, from_tty
);
368 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
371 kill_or_be_killed (0);
372 target_create_inferior (exec
, args
, env
, from_tty
);
375 /* Go through the target stack from top to bottom, copying over zero
376 entries in current_target, then filling in still empty entries. In
377 effect, we are doing class inheritance through the pushed target
380 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
381 is currently implemented, is that it discards any knowledge of
382 which target an inherited method originally belonged to.
383 Consequently, new new target methods should instead explicitly and
384 locally search the target stack for the target that can handle the
388 update_current_target (void)
390 struct target_ops
*t
;
392 /* First, reset current's contents. */
393 memset (¤t_target
, 0, sizeof (current_target
));
395 #define INHERIT(FIELD, TARGET) \
396 if (!current_target.FIELD) \
397 current_target.FIELD = (TARGET)->FIELD
399 for (t
= target_stack
; t
; t
= t
->beneath
)
401 INHERIT (to_shortname
, t
);
402 INHERIT (to_longname
, t
);
404 INHERIT (to_open
, t
);
405 INHERIT (to_close
, t
);
406 INHERIT (to_attach
, t
);
407 INHERIT (to_post_attach
, t
);
408 INHERIT (to_detach
, t
);
409 /* Do not inherit to_disconnect. */
410 INHERIT (to_resume
, t
);
411 INHERIT (to_wait
, t
);
412 INHERIT (to_fetch_registers
, t
);
413 INHERIT (to_store_registers
, t
);
414 INHERIT (to_prepare_to_store
, t
);
415 INHERIT (deprecated_xfer_memory
, t
);
416 INHERIT (to_files_info
, t
);
417 INHERIT (to_insert_breakpoint
, t
);
418 INHERIT (to_remove_breakpoint
, t
);
419 INHERIT (to_can_use_hw_breakpoint
, t
);
420 INHERIT (to_insert_hw_breakpoint
, t
);
421 INHERIT (to_remove_hw_breakpoint
, t
);
422 INHERIT (to_insert_watchpoint
, t
);
423 INHERIT (to_remove_watchpoint
, t
);
424 INHERIT (to_stopped_data_address
, t
);
425 INHERIT (to_have_steppable_watchpoint
, t
);
426 INHERIT (to_have_continuable_watchpoint
, t
);
427 INHERIT (to_stopped_by_watchpoint
, t
);
428 INHERIT (to_watchpoint_addr_within_range
, t
);
429 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
430 INHERIT (to_terminal_init
, t
);
431 INHERIT (to_terminal_inferior
, t
);
432 INHERIT (to_terminal_ours_for_output
, t
);
433 INHERIT (to_terminal_ours
, t
);
434 INHERIT (to_terminal_save_ours
, t
);
435 INHERIT (to_terminal_info
, t
);
436 INHERIT (to_kill
, t
);
437 INHERIT (to_load
, t
);
438 INHERIT (to_lookup_symbol
, t
);
439 INHERIT (to_create_inferior
, t
);
440 INHERIT (to_post_startup_inferior
, t
);
441 INHERIT (to_acknowledge_created_inferior
, t
);
442 INHERIT (to_insert_fork_catchpoint
, t
);
443 INHERIT (to_remove_fork_catchpoint
, t
);
444 INHERIT (to_insert_vfork_catchpoint
, t
);
445 INHERIT (to_remove_vfork_catchpoint
, t
);
446 /* Do not inherit to_follow_fork. */
447 INHERIT (to_insert_exec_catchpoint
, t
);
448 INHERIT (to_remove_exec_catchpoint
, t
);
449 INHERIT (to_has_exited
, t
);
450 INHERIT (to_mourn_inferior
, t
);
451 INHERIT (to_can_run
, t
);
452 INHERIT (to_notice_signals
, t
);
453 INHERIT (to_thread_alive
, t
);
454 INHERIT (to_find_new_threads
, t
);
455 INHERIT (to_pid_to_str
, t
);
456 INHERIT (to_extra_thread_info
, t
);
457 INHERIT (to_stop
, t
);
458 /* Do not inherit to_xfer_partial. */
459 INHERIT (to_rcmd
, t
);
460 INHERIT (to_pid_to_exec_file
, t
);
461 INHERIT (to_log_command
, t
);
462 INHERIT (to_stratum
, t
);
463 INHERIT (to_has_all_memory
, t
);
464 INHERIT (to_has_memory
, t
);
465 INHERIT (to_has_stack
, t
);
466 INHERIT (to_has_registers
, t
);
467 INHERIT (to_has_execution
, t
);
468 INHERIT (to_has_thread_control
, t
);
469 INHERIT (to_sections
, t
);
470 INHERIT (to_sections_end
, t
);
471 INHERIT (to_can_async_p
, t
);
472 INHERIT (to_is_async_p
, t
);
473 INHERIT (to_async
, t
);
474 INHERIT (to_async_mask
, t
);
475 INHERIT (to_find_memory_regions
, t
);
476 INHERIT (to_make_corefile_notes
, t
);
477 INHERIT (to_get_thread_local_address
, t
);
478 /* Do not inherit to_read_description. */
479 /* Do not inherit to_search_memory. */
480 INHERIT (to_magic
, t
);
481 /* Do not inherit to_memory_map. */
482 /* Do not inherit to_flash_erase. */
483 /* Do not inherit to_flash_done. */
487 /* Clean up a target struct so it no longer has any zero pointers in
488 it. Some entries are defaulted to a method that print an error,
489 others are hard-wired to a standard recursive default. */
491 #define de_fault(field, value) \
492 if (!current_target.field) \
493 current_target.field = value
496 (void (*) (char *, int))
502 maybe_kill_then_attach
);
503 de_fault (to_post_attach
,
507 (void (*) (char *, int))
510 (void (*) (ptid_t
, int, enum target_signal
))
513 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
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_create_inferior
,
586 maybe_kill_then_create_inferior
);
587 de_fault (to_post_startup_inferior
,
590 de_fault (to_acknowledge_created_inferior
,
593 de_fault (to_insert_fork_catchpoint
,
596 de_fault (to_remove_fork_catchpoint
,
599 de_fault (to_insert_vfork_catchpoint
,
602 de_fault (to_remove_vfork_catchpoint
,
605 de_fault (to_insert_exec_catchpoint
,
608 de_fault (to_remove_exec_catchpoint
,
611 de_fault (to_has_exited
,
612 (int (*) (int, int, int *))
614 de_fault (to_mourn_inferior
,
617 de_fault (to_can_run
,
619 de_fault (to_notice_signals
,
622 de_fault (to_thread_alive
,
625 de_fault (to_find_new_threads
,
628 de_fault (to_extra_thread_info
,
629 (char *(*) (struct thread_info
*))
634 current_target
.to_xfer_partial
= current_xfer_partial
;
636 (void (*) (char *, struct ui_file
*))
638 de_fault (to_pid_to_exec_file
,
641 de_fault (to_can_async_p
,
644 de_fault (to_is_async_p
,
648 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
650 de_fault (to_async_mask
,
653 current_target
.to_read_description
= NULL
;
656 /* Finally, position the target-stack beneath the squashed
657 "current_target". That way code looking for a non-inherited
658 target method can quickly and simply find it. */
659 current_target
.beneath
= target_stack
;
662 setup_target_debug ();
665 /* Mark OPS as a running target. This reverses the effect
666 of target_mark_exited. */
669 target_mark_running (struct target_ops
*ops
)
671 struct target_ops
*t
;
673 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
677 internal_error (__FILE__
, __LINE__
,
678 "Attempted to mark unpushed target \"%s\" as running",
681 ops
->to_has_execution
= 1;
682 ops
->to_has_all_memory
= 1;
683 ops
->to_has_memory
= 1;
684 ops
->to_has_stack
= 1;
685 ops
->to_has_registers
= 1;
687 update_current_target ();
690 /* Mark OPS as a non-running target. This reverses the effect
691 of target_mark_running. */
694 target_mark_exited (struct target_ops
*ops
)
696 struct target_ops
*t
;
698 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
702 internal_error (__FILE__
, __LINE__
,
703 "Attempted to mark unpushed target \"%s\" as running",
706 ops
->to_has_execution
= 0;
707 ops
->to_has_all_memory
= 0;
708 ops
->to_has_memory
= 0;
709 ops
->to_has_stack
= 0;
710 ops
->to_has_registers
= 0;
712 update_current_target ();
715 /* Push a new target type into the stack of the existing target accessors,
716 possibly superseding some of the existing accessors.
718 Result is zero if the pushed target ended up on top of the stack,
719 nonzero if at least one target is on top of it.
721 Rather than allow an empty stack, we always have the dummy target at
722 the bottom stratum, so we can call the function vectors without
726 push_target (struct target_ops
*t
)
728 struct target_ops
**cur
;
730 /* Check magic number. If wrong, it probably means someone changed
731 the struct definition, but not all the places that initialize one. */
732 if (t
->to_magic
!= OPS_MAGIC
)
734 fprintf_unfiltered (gdb_stderr
,
735 "Magic number of %s target struct wrong\n",
737 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
740 /* Find the proper stratum to install this target in. */
741 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
743 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
747 /* If there's already targets at this stratum, remove them. */
748 /* FIXME: cagney/2003-10-15: I think this should be popping all
749 targets to CUR, and not just those at this stratum level. */
750 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
752 /* There's already something at this stratum level. Close it,
753 and un-hook it from the stack. */
754 struct target_ops
*tmp
= (*cur
);
755 (*cur
) = (*cur
)->beneath
;
757 target_close (tmp
, 0);
760 /* We have removed all targets in our stratum, now add the new one. */
764 update_current_target ();
767 return (t
!= target_stack
);
770 /* Remove a target_ops vector from the stack, wherever it may be.
771 Return how many times it was removed (0 or 1). */
774 unpush_target (struct target_ops
*t
)
776 struct target_ops
**cur
;
777 struct target_ops
*tmp
;
779 /* Look for the specified target. Note that we assume that a target
780 can only occur once in the target stack. */
782 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
789 return 0; /* Didn't find target_ops, quit now */
791 /* NOTE: cagney/2003-12-06: In '94 the close call was made
792 unconditional by moving it to before the above check that the
793 target was in the target stack (something about "Change the way
794 pushing and popping of targets work to support target overlays
795 and inheritance"). This doesn't make much sense - only open
796 targets should be closed. */
799 /* Unchain the target */
801 (*cur
) = (*cur
)->beneath
;
804 update_current_target ();
812 target_close (¤t_target
, 0); /* Let it clean up */
813 if (unpush_target (target_stack
) == 1)
816 fprintf_unfiltered (gdb_stderr
,
817 "pop_target couldn't find target %s\n",
818 current_target
.to_shortname
);
819 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
822 /* Using the objfile specified in OBJFILE, find the address for the
823 current thread's thread-local storage with offset OFFSET. */
825 target_translate_tls_address (struct objfile
*objfile
, CORE_ADDR offset
)
827 volatile CORE_ADDR addr
= 0;
829 if (target_get_thread_local_address_p ()
830 && gdbarch_fetch_tls_load_module_address_p (current_gdbarch
))
832 ptid_t ptid
= inferior_ptid
;
833 volatile struct gdb_exception ex
;
835 TRY_CATCH (ex
, RETURN_MASK_ALL
)
839 /* Fetch the load module address for this objfile. */
840 lm_addr
= gdbarch_fetch_tls_load_module_address (current_gdbarch
,
842 /* If it's 0, throw the appropriate exception. */
844 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
845 _("TLS load module not found"));
847 addr
= target_get_thread_local_address (ptid
, lm_addr
, offset
);
849 /* If an error occurred, print TLS related messages here. Otherwise,
850 throw the error to some higher catcher. */
853 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
857 case TLS_NO_LIBRARY_SUPPORT_ERROR
:
858 error (_("Cannot find thread-local variables in this thread library."));
860 case TLS_LOAD_MODULE_NOT_FOUND_ERROR
:
861 if (objfile_is_library
)
862 error (_("Cannot find shared library `%s' in dynamic"
863 " linker's load module list"), objfile
->name
);
865 error (_("Cannot find executable file `%s' in dynamic"
866 " linker's load module list"), objfile
->name
);
868 case TLS_NOT_ALLOCATED_YET_ERROR
:
869 if (objfile_is_library
)
870 error (_("The inferior has not yet allocated storage for"
871 " thread-local variables in\n"
872 "the shared library `%s'\n"
874 objfile
->name
, target_pid_to_str (ptid
));
876 error (_("The inferior has not yet allocated storage for"
877 " thread-local variables in\n"
878 "the executable `%s'\n"
880 objfile
->name
, target_pid_to_str (ptid
));
882 case TLS_GENERIC_ERROR
:
883 if (objfile_is_library
)
884 error (_("Cannot find thread-local storage for %s, "
885 "shared library %s:\n%s"),
886 target_pid_to_str (ptid
),
887 objfile
->name
, ex
.message
);
889 error (_("Cannot find thread-local storage for %s, "
890 "executable file %s:\n%s"),
891 target_pid_to_str (ptid
),
892 objfile
->name
, ex
.message
);
895 throw_exception (ex
);
900 /* It wouldn't be wrong here to try a gdbarch method, too; finding
901 TLS is an ABI-specific thing. But we don't do that yet. */
903 error (_("Cannot find thread-local variables on this target"));
909 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
911 /* target_read_string -- read a null terminated string, up to LEN bytes,
912 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
913 Set *STRING to a pointer to malloc'd memory containing the data; the caller
914 is responsible for freeing it. Return the number of bytes successfully
918 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
920 int tlen
, origlen
, offset
, i
;
924 int buffer_allocated
;
926 unsigned int nbytes_read
= 0;
930 /* Small for testing. */
931 buffer_allocated
= 4;
932 buffer
= xmalloc (buffer_allocated
);
939 tlen
= MIN (len
, 4 - (memaddr
& 3));
940 offset
= memaddr
& 3;
942 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
945 /* The transfer request might have crossed the boundary to an
946 unallocated region of memory. Retry the transfer, requesting
950 errcode
= target_read_memory (memaddr
, buf
, 1);
955 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
958 bytes
= bufptr
- buffer
;
959 buffer_allocated
*= 2;
960 buffer
= xrealloc (buffer
, buffer_allocated
);
961 bufptr
= buffer
+ bytes
;
964 for (i
= 0; i
< tlen
; i
++)
966 *bufptr
++ = buf
[i
+ offset
];
967 if (buf
[i
+ offset
] == '\000')
969 nbytes_read
+= i
+ 1;
985 /* Find a section containing ADDR. */
986 struct section_table
*
987 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
989 struct section_table
*secp
;
990 for (secp
= target
->to_sections
;
991 secp
< target
->to_sections_end
;
994 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
1000 /* Perform a partial memory transfer. The arguments and return
1001 value are just as for target_xfer_partial. */
1004 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
1005 ULONGEST memaddr
, LONGEST len
)
1009 struct mem_region
*region
;
1011 /* Zero length requests are ok and require no work. */
1015 /* Try the executable file, if "trust-readonly-sections" is set. */
1016 if (readbuf
!= NULL
&& trust_readonly
)
1018 struct section_table
*secp
;
1020 secp
= target_section_by_addr (ops
, memaddr
);
1022 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1024 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1027 /* Likewise for accesses to unmapped overlay sections. */
1028 if (readbuf
!= NULL
&& overlay_debugging
)
1030 asection
*section
= find_pc_overlay (memaddr
);
1031 if (pc_in_unmapped_range (memaddr
, section
))
1032 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
1035 /* Try GDB's internal data cache. */
1036 region
= lookup_mem_region (memaddr
);
1037 /* region->hi == 0 means there's no upper bound. */
1038 if (memaddr
+ len
< region
->hi
|| region
->hi
== 0)
1041 reg_len
= region
->hi
- memaddr
;
1043 switch (region
->attrib
.mode
)
1046 if (writebuf
!= NULL
)
1051 if (readbuf
!= NULL
)
1056 /* We only support writing to flash during "load" for now. */
1057 if (writebuf
!= NULL
)
1058 error (_("Writing to flash memory forbidden in this context"));
1065 if (region
->attrib
.cache
)
1067 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
1068 memory request will start back at current_target. */
1069 if (readbuf
!= NULL
)
1070 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
1073 /* FIXME drow/2006-08-09: If we're going to preserve const
1074 correctness dcache_xfer_memory should take readbuf and
1076 res
= dcache_xfer_memory (target_dcache
, memaddr
,
1083 if (readbuf
&& !show_memory_breakpoints
)
1084 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1089 /* If none of those methods found the memory we wanted, fall back
1090 to a target partial transfer. Normally a single call to
1091 to_xfer_partial is enough; if it doesn't recognize an object
1092 it will call the to_xfer_partial of the next target down.
1093 But for memory this won't do. Memory is the only target
1094 object which can be read from more than one valid target.
1095 A core file, for instance, could have some of memory but
1096 delegate other bits to the target below it. So, we must
1097 manually try all targets. */
1101 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1102 readbuf
, writebuf
, memaddr
, reg_len
);
1106 /* We want to continue past core files to executables, but not
1107 past a running target's memory. */
1108 if (ops
->to_has_all_memory
)
1113 while (ops
!= NULL
);
1115 if (readbuf
&& !show_memory_breakpoints
)
1116 breakpoint_restore_shadows (readbuf
, memaddr
, reg_len
);
1118 /* If we still haven't got anything, return the last error. We
1124 restore_show_memory_breakpoints (void *arg
)
1126 show_memory_breakpoints
= (uintptr_t) arg
;
1130 make_show_memory_breakpoints_cleanup (int show
)
1132 int current
= show_memory_breakpoints
;
1133 show_memory_breakpoints
= show
;
1135 return make_cleanup (restore_show_memory_breakpoints
,
1136 (void *) (uintptr_t) current
);
1140 target_xfer_partial (struct target_ops
*ops
,
1141 enum target_object object
, const char *annex
,
1142 void *readbuf
, const void *writebuf
,
1143 ULONGEST offset
, LONGEST len
)
1147 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1149 /* If this is a memory transfer, let the memory-specific code
1150 have a look at it instead. Memory transfers are more
1152 if (object
== TARGET_OBJECT_MEMORY
)
1153 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
1156 enum target_object raw_object
= object
;
1158 /* If this is a raw memory transfer, request the normal
1159 memory object from other layers. */
1160 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
1161 raw_object
= TARGET_OBJECT_MEMORY
;
1163 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
1164 writebuf
, offset
, len
);
1169 const unsigned char *myaddr
= NULL
;
1171 fprintf_unfiltered (gdb_stdlog
,
1172 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
1175 (annex
? annex
: "(null)"),
1176 (long) readbuf
, (long) writebuf
,
1177 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
1183 if (retval
> 0 && myaddr
!= NULL
)
1187 fputs_unfiltered (", bytes =", gdb_stdlog
);
1188 for (i
= 0; i
< retval
; i
++)
1190 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1192 if (targetdebug
< 2 && i
> 0)
1194 fprintf_unfiltered (gdb_stdlog
, " ...");
1197 fprintf_unfiltered (gdb_stdlog
, "\n");
1200 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1204 fputc_unfiltered ('\n', gdb_stdlog
);
1209 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1210 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1211 if any error occurs.
1213 If an error occurs, no guarantee is made about the contents of the data at
1214 MYADDR. In particular, the caller should not depend upon partial reads
1215 filling the buffer with good data. There is no way for the caller to know
1216 how much good data might have been transfered anyway. Callers that can
1217 deal with partial reads should call target_read (which will retry until
1218 it makes no progress, and then return how much was transferred). */
1221 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1223 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1224 myaddr
, memaddr
, len
) == len
)
1231 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1233 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1234 myaddr
, memaddr
, len
) == len
)
1240 /* Fetch the target's memory map. */
1243 target_memory_map (void)
1245 VEC(mem_region_s
) *result
;
1246 struct mem_region
*last_one
, *this_one
;
1248 struct target_ops
*t
;
1251 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1253 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1254 if (t
->to_memory_map
!= NULL
)
1260 result
= t
->to_memory_map (t
);
1264 qsort (VEC_address (mem_region_s
, result
),
1265 VEC_length (mem_region_s
, result
),
1266 sizeof (struct mem_region
), mem_region_cmp
);
1268 /* Check that regions do not overlap. Simultaneously assign
1269 a numbering for the "mem" commands to use to refer to
1272 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1274 this_one
->number
= ix
;
1276 if (last_one
&& last_one
->hi
> this_one
->lo
)
1278 warning (_("Overlapping regions in memory map: ignoring"));
1279 VEC_free (mem_region_s
, result
);
1282 last_one
= this_one
;
1289 target_flash_erase (ULONGEST address
, LONGEST length
)
1291 struct target_ops
*t
;
1293 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1294 if (t
->to_flash_erase
!= NULL
)
1297 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1298 paddr (address
), phex (length
, 0));
1299 t
->to_flash_erase (t
, address
, length
);
1307 target_flash_done (void)
1309 struct target_ops
*t
;
1311 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1312 if (t
->to_flash_done
!= NULL
)
1315 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1316 t
->to_flash_done (t
);
1323 #ifndef target_stopped_data_address_p
1325 target_stopped_data_address_p (struct target_ops
*target
)
1327 if (target
->to_stopped_data_address
1328 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1330 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1331 && (debug_target
.to_stopped_data_address
1332 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1339 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1340 struct cmd_list_element
*c
, const char *value
)
1342 fprintf_filtered (file
, _("\
1343 Mode for reading from readonly sections is %s.\n"),
1347 /* More generic transfers. */
1350 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1351 const char *annex
, gdb_byte
*readbuf
,
1352 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1354 if (object
== TARGET_OBJECT_MEMORY
1355 && ops
->deprecated_xfer_memory
!= NULL
)
1356 /* If available, fall back to the target's
1357 "deprecated_xfer_memory" method. */
1361 if (writebuf
!= NULL
)
1363 void *buffer
= xmalloc (len
);
1364 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1365 memcpy (buffer
, writebuf
, len
);
1366 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1367 1/*write*/, NULL
, ops
);
1368 do_cleanups (cleanup
);
1370 if (readbuf
!= NULL
)
1371 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
,
1372 0/*read*/, NULL
, ops
);
1375 else if (xfered
== 0 && errno
== 0)
1376 /* "deprecated_xfer_memory" uses 0, cross checked against
1377 ERRNO as one indication of an error. */
1382 else if (ops
->beneath
!= NULL
)
1383 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1384 readbuf
, writebuf
, offset
, len
);
1389 /* The xfer_partial handler for the topmost target. Unlike the default,
1390 it does not need to handle memory specially; it just passes all
1391 requests down the stack. */
1394 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1395 const char *annex
, gdb_byte
*readbuf
,
1396 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1398 if (ops
->beneath
!= NULL
)
1399 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1400 readbuf
, writebuf
, offset
, len
);
1405 /* Target vector read/write partial wrapper functions.
1407 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1408 (inbuf, outbuf)", instead of separate read/write methods, make life
1412 target_read_partial (struct target_ops
*ops
,
1413 enum target_object object
,
1414 const char *annex
, gdb_byte
*buf
,
1415 ULONGEST offset
, LONGEST len
)
1417 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1421 target_write_partial (struct target_ops
*ops
,
1422 enum target_object object
,
1423 const char *annex
, const gdb_byte
*buf
,
1424 ULONGEST offset
, LONGEST len
)
1426 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1429 /* Wrappers to perform the full transfer. */
1431 target_read (struct target_ops
*ops
,
1432 enum target_object object
,
1433 const char *annex
, gdb_byte
*buf
,
1434 ULONGEST offset
, LONGEST len
)
1437 while (xfered
< len
)
1439 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1440 (gdb_byte
*) buf
+ xfered
,
1441 offset
+ xfered
, len
- xfered
);
1442 /* Call an observer, notifying them of the xfer progress? */
1454 target_read_until_error (struct target_ops
*ops
,
1455 enum target_object object
,
1456 const char *annex
, gdb_byte
*buf
,
1457 ULONGEST offset
, LONGEST len
)
1460 while (xfered
< len
)
1462 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1463 (gdb_byte
*) buf
+ xfered
,
1464 offset
+ xfered
, len
- xfered
);
1465 /* Call an observer, notifying them of the xfer progress? */
1470 /* We've got an error. Try to read in smaller blocks. */
1471 ULONGEST start
= offset
+ xfered
;
1472 ULONGEST remaining
= len
- xfered
;
1475 /* If an attempt was made to read a random memory address,
1476 it's likely that the very first byte is not accessible.
1477 Try reading the first byte, to avoid doing log N tries
1479 xfer
= target_read_partial (ops
, object
, annex
,
1480 (gdb_byte
*) buf
+ xfered
, start
, 1);
1489 xfer
= target_read_partial (ops
, object
, annex
,
1490 (gdb_byte
*) buf
+ xfered
,
1500 /* We have successfully read the first half. So, the
1501 error must be in the second half. Adjust start and
1502 remaining to point at the second half. */
1519 /* An alternative to target_write with progress callbacks. */
1522 target_write_with_progress (struct target_ops
*ops
,
1523 enum target_object object
,
1524 const char *annex
, const gdb_byte
*buf
,
1525 ULONGEST offset
, LONGEST len
,
1526 void (*progress
) (ULONGEST
, void *), void *baton
)
1530 /* Give the progress callback a chance to set up. */
1532 (*progress
) (0, baton
);
1534 while (xfered
< len
)
1536 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1537 (gdb_byte
*) buf
+ xfered
,
1538 offset
+ xfered
, len
- xfered
);
1546 (*progress
) (xfer
, baton
);
1555 target_write (struct target_ops
*ops
,
1556 enum target_object object
,
1557 const char *annex
, const gdb_byte
*buf
,
1558 ULONGEST offset
, LONGEST len
)
1560 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1564 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1565 the size of the transferred data. PADDING additional bytes are
1566 available in *BUF_P. This is a helper function for
1567 target_read_alloc; see the declaration of that function for more
1571 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1572 const char *annex
, gdb_byte
**buf_p
, int padding
)
1574 size_t buf_alloc
, buf_pos
;
1578 /* This function does not have a length parameter; it reads the
1579 entire OBJECT). Also, it doesn't support objects fetched partly
1580 from one target and partly from another (in a different stratum,
1581 e.g. a core file and an executable). Both reasons make it
1582 unsuitable for reading memory. */
1583 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1585 /* Start by reading up to 4K at a time. The target will throttle
1586 this number down if necessary. */
1588 buf
= xmalloc (buf_alloc
);
1592 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1593 buf_pos
, buf_alloc
- buf_pos
- padding
);
1596 /* An error occurred. */
1602 /* Read all there was. */
1612 /* If the buffer is filling up, expand it. */
1613 if (buf_alloc
< buf_pos
* 2)
1616 buf
= xrealloc (buf
, buf_alloc
);
1623 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1624 the size of the transferred data. See the declaration in "target.h"
1625 function for more information about the return value. */
1628 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1629 const char *annex
, gdb_byte
**buf_p
)
1631 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1634 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1635 returned as a string, allocated using xmalloc. If an error occurs
1636 or the transfer is unsupported, NULL is returned. Empty objects
1637 are returned as allocated but empty strings. A warning is issued
1638 if the result contains any embedded NUL bytes. */
1641 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1645 LONGEST transferred
;
1647 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1649 if (transferred
< 0)
1652 if (transferred
== 0)
1653 return xstrdup ("");
1655 buffer
[transferred
] = 0;
1656 if (strlen (buffer
) < transferred
)
1657 warning (_("target object %d, annex %s, "
1658 "contained unexpected null characters"),
1659 (int) object
, annex
? annex
: "(none)");
1661 return (char *) buffer
;
1664 /* Memory transfer methods. */
1667 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1670 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1672 memory_error (EIO
, addr
);
1676 get_target_memory_unsigned (struct target_ops
*ops
,
1677 CORE_ADDR addr
, int len
)
1679 gdb_byte buf
[sizeof (ULONGEST
)];
1681 gdb_assert (len
<= sizeof (buf
));
1682 get_target_memory (ops
, addr
, buf
, len
);
1683 return extract_unsigned_integer (buf
, len
);
1687 target_info (char *args
, int from_tty
)
1689 struct target_ops
*t
;
1690 int has_all_mem
= 0;
1692 if (symfile_objfile
!= NULL
)
1693 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1695 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1697 if (!t
->to_has_memory
)
1700 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1703 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1704 printf_unfiltered ("%s:\n", t
->to_longname
);
1705 (t
->to_files_info
) (t
);
1706 has_all_mem
= t
->to_has_all_memory
;
1710 /* This function is called before any new inferior is created, e.g.
1711 by running a program, attaching, or connecting to a target.
1712 It cleans up any state from previous invocations which might
1713 change between runs. This is a subset of what target_preopen
1714 resets (things which might change between targets). */
1717 target_pre_inferior (int from_tty
)
1719 invalidate_target_mem_regions ();
1721 target_clear_description ();
1724 /* This is to be called by the open routine before it does
1728 target_preopen (int from_tty
)
1732 if (target_has_execution
)
1735 || query (_("A program is being debugged already. Kill it? ")))
1738 error (_("Program not killed."));
1741 /* Calling target_kill may remove the target from the stack. But if
1742 it doesn't (which seems like a win for UDI), remove it now. */
1744 if (target_has_execution
)
1747 target_pre_inferior (from_tty
);
1750 /* Detach a target after doing deferred register stores. */
1753 target_detach (char *args
, int from_tty
)
1755 /* If we're in breakpoints-always-inserted mode, have to
1756 remove them before detaching. */
1757 remove_breakpoints ();
1759 (current_target
.to_detach
) (args
, from_tty
);
1763 target_disconnect (char *args
, int from_tty
)
1765 struct target_ops
*t
;
1767 /* If we're in breakpoints-always-inserted mode, have to
1768 remove them before disconnecting. */
1769 remove_breakpoints ();
1771 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1772 if (t
->to_disconnect
!= NULL
)
1775 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1777 t
->to_disconnect (t
, args
, from_tty
);
1785 target_resume (ptid_t ptid
, int step
, enum target_signal signal
)
1787 dcache_invalidate (target_dcache
);
1788 (*current_target
.to_resume
) (ptid
, step
, signal
);
1789 set_running (ptid
, 1);
1792 /* Look through the list of possible targets for a target that can
1796 target_follow_fork (int follow_child
)
1798 struct target_ops
*t
;
1800 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1802 if (t
->to_follow_fork
!= NULL
)
1804 int retval
= t
->to_follow_fork (t
, follow_child
);
1806 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1807 follow_child
, retval
);
1812 /* Some target returned a fork event, but did not know how to follow it. */
1813 internal_error (__FILE__
, __LINE__
,
1814 "could not find a target to follow fork");
1817 /* Look for a target which can describe architectural features, starting
1818 from TARGET. If we find one, return its description. */
1820 const struct target_desc
*
1821 target_read_description (struct target_ops
*target
)
1823 struct target_ops
*t
;
1825 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1826 if (t
->to_read_description
!= NULL
)
1828 const struct target_desc
*tdesc
;
1830 tdesc
= t
->to_read_description (t
);
1838 /* The default implementation of to_search_memory.
1839 This implements a basic search of memory, reading target memory and
1840 performing the search here (as opposed to performing the search in on the
1841 target side with, for example, gdbserver). */
1844 simple_search_memory (struct target_ops
*ops
,
1845 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1846 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1847 CORE_ADDR
*found_addrp
)
1849 /* NOTE: also defined in find.c testcase. */
1850 #define SEARCH_CHUNK_SIZE 16000
1851 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1852 /* Buffer to hold memory contents for searching. */
1853 gdb_byte
*search_buf
;
1854 unsigned search_buf_size
;
1855 struct cleanup
*old_cleanups
;
1857 search_buf_size
= chunk_size
+ pattern_len
- 1;
1859 /* No point in trying to allocate a buffer larger than the search space. */
1860 if (search_space_len
< search_buf_size
)
1861 search_buf_size
= search_space_len
;
1863 search_buf
= malloc (search_buf_size
);
1864 if (search_buf
== NULL
)
1865 error (_("Unable to allocate memory to perform the search."));
1866 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1868 /* Prime the search buffer. */
1870 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1871 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1873 warning (_("Unable to access target memory at %s, halting search."),
1874 hex_string (start_addr
));
1875 do_cleanups (old_cleanups
);
1879 /* Perform the search.
1881 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1882 When we've scanned N bytes we copy the trailing bytes to the start and
1883 read in another N bytes. */
1885 while (search_space_len
>= pattern_len
)
1887 gdb_byte
*found_ptr
;
1888 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1890 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1891 pattern
, pattern_len
);
1893 if (found_ptr
!= NULL
)
1895 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1896 *found_addrp
= found_addr
;
1897 do_cleanups (old_cleanups
);
1901 /* Not found in this chunk, skip to next chunk. */
1903 /* Don't let search_space_len wrap here, it's unsigned. */
1904 if (search_space_len
>= chunk_size
)
1905 search_space_len
-= chunk_size
;
1907 search_space_len
= 0;
1909 if (search_space_len
>= pattern_len
)
1911 unsigned keep_len
= search_buf_size
- chunk_size
;
1912 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1915 /* Copy the trailing part of the previous iteration to the front
1916 of the buffer for the next iteration. */
1917 gdb_assert (keep_len
== pattern_len
- 1);
1918 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1920 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1922 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1923 search_buf
+ keep_len
, read_addr
,
1924 nr_to_read
) != nr_to_read
)
1926 warning (_("Unable to access target memory at %s, halting search."),
1927 hex_string (read_addr
));
1928 do_cleanups (old_cleanups
);
1932 start_addr
+= chunk_size
;
1938 do_cleanups (old_cleanups
);
1942 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1943 sequence of bytes in PATTERN with length PATTERN_LEN.
1945 The result is 1 if found, 0 if not found, and -1 if there was an error
1946 requiring halting of the search (e.g. memory read error).
1947 If the pattern is found the address is recorded in FOUND_ADDRP. */
1950 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1951 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1952 CORE_ADDR
*found_addrp
)
1954 struct target_ops
*t
;
1957 /* We don't use INHERIT to set current_target.to_search_memory,
1958 so we have to scan the target stack and handle targetdebug
1962 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1963 hex_string (start_addr
));
1965 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1966 if (t
->to_search_memory
!= NULL
)
1971 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
1972 pattern
, pattern_len
, found_addrp
);
1976 /* If a special version of to_search_memory isn't available, use the
1978 found
= simple_search_memory (¤t_target
,
1979 start_addr
, search_space_len
,
1980 pattern
, pattern_len
, found_addrp
);
1984 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
1989 /* Look through the currently pushed targets. If none of them will
1990 be able to restart the currently running process, issue an error
1994 target_require_runnable (void)
1996 struct target_ops
*t
;
1998 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
2000 /* If this target knows how to create a new program, then
2001 assume we will still be able to after killing the current
2002 one. Either killing and mourning will not pop T, or else
2003 find_default_run_target will find it again. */
2004 if (t
->to_create_inferior
!= NULL
)
2007 /* Do not worry about thread_stratum targets that can not
2008 create inferiors. Assume they will be pushed again if
2009 necessary, and continue to the process_stratum. */
2010 if (t
->to_stratum
== thread_stratum
)
2014 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
2018 /* This function is only called if the target is running. In that
2019 case there should have been a process_stratum target and it
2020 should either know how to create inferiors, or not... */
2021 internal_error (__FILE__
, __LINE__
, "No targets found");
2024 /* Look through the list of possible targets for a target that can
2025 execute a run or attach command without any other data. This is
2026 used to locate the default process stratum.
2028 If DO_MESG is not NULL, the result is always valid (error() is
2029 called for errors); else, return NULL on error. */
2031 static struct target_ops
*
2032 find_default_run_target (char *do_mesg
)
2034 struct target_ops
**t
;
2035 struct target_ops
*runable
= NULL
;
2040 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2043 if ((*t
)->to_can_run
&& target_can_run (*t
))
2053 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
2062 find_default_attach (char *args
, int from_tty
)
2064 struct target_ops
*t
;
2066 t
= find_default_run_target ("attach");
2067 (t
->to_attach
) (args
, from_tty
);
2072 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2075 struct target_ops
*t
;
2077 t
= find_default_run_target ("run");
2078 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2083 find_default_can_async_p (void)
2085 struct target_ops
*t
;
2087 /* This may be called before the target is pushed on the stack;
2088 look for the default process stratum. If there's none, gdb isn't
2089 configured with a native debugger, and target remote isn't
2091 t
= find_default_run_target (NULL
);
2092 if (t
&& t
->to_can_async_p
)
2093 return (t
->to_can_async_p
) ();
2098 find_default_is_async_p (void)
2100 struct target_ops
*t
;
2102 /* This may be called before the target is pushed on the stack;
2103 look for the default process stratum. If there's none, gdb isn't
2104 configured with a native debugger, and target remote isn't
2106 t
= find_default_run_target (NULL
);
2107 if (t
&& t
->to_is_async_p
)
2108 return (t
->to_is_async_p
) ();
2113 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2115 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
2119 default_watchpoint_addr_within_range (struct target_ops
*target
,
2121 CORE_ADDR start
, int length
)
2123 return addr
>= start
&& addr
< start
+ length
;
2139 return_minus_one (void)
2145 * Resize the to_sections pointer. Also make sure that anyone that
2146 * was holding on to an old value of it gets updated.
2147 * Returns the old size.
2151 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2153 struct target_ops
**t
;
2154 struct section_table
*old_value
;
2157 old_value
= target
->to_sections
;
2159 if (target
->to_sections
)
2161 old_count
= target
->to_sections_end
- target
->to_sections
;
2162 target
->to_sections
= (struct section_table
*)
2163 xrealloc ((char *) target
->to_sections
,
2164 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2169 target
->to_sections
= (struct section_table
*)
2170 xmalloc ((sizeof (struct section_table
)) * num_added
);
2172 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2174 /* Check to see if anyone else was pointing to this structure.
2175 If old_value was null, then no one was. */
2179 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2182 if ((*t
)->to_sections
== old_value
)
2184 (*t
)->to_sections
= target
->to_sections
;
2185 (*t
)->to_sections_end
= target
->to_sections_end
;
2188 /* There is a flattened view of the target stack in current_target,
2189 so its to_sections pointer might also need updating. */
2190 if (current_target
.to_sections
== old_value
)
2192 current_target
.to_sections
= target
->to_sections
;
2193 current_target
.to_sections_end
= target
->to_sections_end
;
2201 /* Remove all target sections taken from ABFD.
2203 Scan the current target stack for targets whose section tables
2204 refer to sections from BFD, and remove those sections. We use this
2205 when we notice that the inferior has unloaded a shared object, for
2208 remove_target_sections (bfd
*abfd
)
2210 struct target_ops
**t
;
2212 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2214 struct section_table
*src
, *dest
;
2216 dest
= (*t
)->to_sections
;
2217 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2218 if (src
->bfd
!= abfd
)
2220 /* Keep this section. */
2221 if (dest
< src
) *dest
= *src
;
2225 /* If we've dropped any sections, resize the section table. */
2227 target_resize_to_sections (*t
, dest
- src
);
2234 /* Find a single runnable target in the stack and return it. If for
2235 some reason there is more than one, return NULL. */
2238 find_run_target (void)
2240 struct target_ops
**t
;
2241 struct target_ops
*runable
= NULL
;
2246 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2248 if ((*t
)->to_can_run
&& target_can_run (*t
))
2255 return (count
== 1 ? runable
: NULL
);
2258 /* Find a single core_stratum target in the list of targets and return it.
2259 If for some reason there is more than one, return NULL. */
2262 find_core_target (void)
2264 struct target_ops
**t
;
2265 struct target_ops
*runable
= NULL
;
2270 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2273 if ((*t
)->to_stratum
== core_stratum
)
2280 return (count
== 1 ? runable
: NULL
);
2284 * Find the next target down the stack from the specified target.
2288 find_target_beneath (struct target_ops
*t
)
2294 /* The inferior process has died. Long live the inferior! */
2297 generic_mourn_inferior (void)
2299 extern int show_breakpoint_hit_counts
;
2301 inferior_ptid
= null_ptid
;
2303 breakpoint_init_inferior (inf_exited
);
2304 registers_changed ();
2306 reopen_exec_file ();
2307 reinit_frame_cache ();
2309 /* It is confusing to the user for ignore counts to stick around
2310 from previous runs of the inferior. So clear them. */
2311 /* However, it is more confusing for the ignore counts to disappear when
2312 using hit counts. So don't clear them if we're counting hits. */
2313 if (!show_breakpoint_hit_counts
)
2314 breakpoint_clear_ignore_counts ();
2316 if (deprecated_detach_hook
)
2317 deprecated_detach_hook ();
2320 /* Helper function for child_wait and the derivatives of child_wait.
2321 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2322 translation of that in OURSTATUS. */
2324 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2326 if (WIFEXITED (hoststatus
))
2328 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2329 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2331 else if (!WIFSTOPPED (hoststatus
))
2333 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2334 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2338 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2339 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2343 /* Returns zero to leave the inferior alone, one to interrupt it. */
2344 int (*target_activity_function
) (void);
2345 int target_activity_fd
;
2347 /* Convert a normal process ID to a string. Returns the string in a
2351 normal_pid_to_str (ptid_t ptid
)
2353 static char buf
[32];
2355 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2359 /* Error-catcher for target_find_memory_regions */
2360 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2362 error (_("No target."));
2366 /* Error-catcher for target_make_corefile_notes */
2367 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2369 error (_("No target."));
2373 /* Set up the handful of non-empty slots needed by the dummy target
2377 init_dummy_target (void)
2379 dummy_target
.to_shortname
= "None";
2380 dummy_target
.to_longname
= "None";
2381 dummy_target
.to_doc
= "";
2382 dummy_target
.to_attach
= find_default_attach
;
2383 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2384 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2385 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2386 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2387 dummy_target
.to_stratum
= dummy_stratum
;
2388 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2389 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2390 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2391 dummy_target
.to_magic
= OPS_MAGIC
;
2395 debug_to_open (char *args
, int from_tty
)
2397 debug_target
.to_open (args
, from_tty
);
2399 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2403 debug_to_close (int quitting
)
2405 target_close (&debug_target
, quitting
);
2406 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2410 target_close (struct target_ops
*targ
, int quitting
)
2412 if (targ
->to_xclose
!= NULL
)
2413 targ
->to_xclose (targ
, quitting
);
2414 else if (targ
->to_close
!= NULL
)
2415 targ
->to_close (quitting
);
2419 debug_to_attach (char *args
, int from_tty
)
2421 debug_target
.to_attach (args
, from_tty
);
2423 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2428 debug_to_post_attach (int pid
)
2430 debug_target
.to_post_attach (pid
);
2432 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2436 debug_to_detach (char *args
, int from_tty
)
2438 debug_target
.to_detach (args
, from_tty
);
2440 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2444 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2446 debug_target
.to_resume (ptid
, step
, siggnal
);
2448 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2449 step
? "step" : "continue",
2450 target_signal_to_name (siggnal
));
2454 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2458 retval
= debug_target
.to_wait (ptid
, status
);
2460 fprintf_unfiltered (gdb_stdlog
,
2461 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2463 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2464 switch (status
->kind
)
2466 case TARGET_WAITKIND_EXITED
:
2467 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2468 status
->value
.integer
);
2470 case TARGET_WAITKIND_STOPPED
:
2471 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2472 target_signal_to_name (status
->value
.sig
));
2474 case TARGET_WAITKIND_SIGNALLED
:
2475 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2476 target_signal_to_name (status
->value
.sig
));
2478 case TARGET_WAITKIND_LOADED
:
2479 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2481 case TARGET_WAITKIND_FORKED
:
2482 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2484 case TARGET_WAITKIND_VFORKED
:
2485 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2487 case TARGET_WAITKIND_EXECD
:
2488 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2490 case TARGET_WAITKIND_SPURIOUS
:
2491 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2494 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2502 debug_print_register (const char * func
,
2503 struct regcache
*regcache
, int regno
)
2505 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2506 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2507 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2508 + gdbarch_num_pseudo_regs (gdbarch
)
2509 && gdbarch_register_name (gdbarch
, regno
) != NULL
2510 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2511 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2512 gdbarch_register_name (gdbarch
, regno
));
2514 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2517 int i
, size
= register_size (gdbarch
, regno
);
2518 unsigned char buf
[MAX_REGISTER_SIZE
];
2519 regcache_cooked_read (regcache
, regno
, buf
);
2520 fprintf_unfiltered (gdb_stdlog
, " = ");
2521 for (i
= 0; i
< size
; i
++)
2523 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2525 if (size
<= sizeof (LONGEST
))
2527 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2528 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2529 paddr_nz (val
), paddr_d (val
));
2532 fprintf_unfiltered (gdb_stdlog
, "\n");
2536 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2538 debug_target
.to_fetch_registers (regcache
, regno
);
2539 debug_print_register ("target_fetch_registers", regcache
, regno
);
2543 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2545 debug_target
.to_store_registers (regcache
, regno
);
2546 debug_print_register ("target_store_registers", regcache
, regno
);
2547 fprintf_unfiltered (gdb_stdlog
, "\n");
2551 debug_to_prepare_to_store (struct regcache
*regcache
)
2553 debug_target
.to_prepare_to_store (regcache
);
2555 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2559 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2560 int write
, struct mem_attrib
*attrib
,
2561 struct target_ops
*target
)
2565 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2568 fprintf_unfiltered (gdb_stdlog
,
2569 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2570 (unsigned int) memaddr
, /* possable truncate long long */
2571 len
, write
? "write" : "read", retval
);
2577 fputs_unfiltered (", bytes =", gdb_stdlog
);
2578 for (i
= 0; i
< retval
; i
++)
2580 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2582 if (targetdebug
< 2 && i
> 0)
2584 fprintf_unfiltered (gdb_stdlog
, " ...");
2587 fprintf_unfiltered (gdb_stdlog
, "\n");
2590 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2594 fputc_unfiltered ('\n', gdb_stdlog
);
2600 debug_to_files_info (struct target_ops
*target
)
2602 debug_target
.to_files_info (target
);
2604 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2608 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2612 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2614 fprintf_unfiltered (gdb_stdlog
,
2615 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2616 (unsigned long) bp_tgt
->placed_address
,
2617 (unsigned long) retval
);
2622 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2626 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2628 fprintf_unfiltered (gdb_stdlog
,
2629 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2630 (unsigned long) bp_tgt
->placed_address
,
2631 (unsigned long) retval
);
2636 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2640 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2642 fprintf_unfiltered (gdb_stdlog
,
2643 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2644 (unsigned long) type
,
2645 (unsigned long) cnt
,
2646 (unsigned long) from_tty
,
2647 (unsigned long) retval
);
2652 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2656 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2658 fprintf_unfiltered (gdb_stdlog
,
2659 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2660 (unsigned long) addr
,
2661 (unsigned long) len
,
2662 (unsigned long) retval
);
2667 debug_to_stopped_by_watchpoint (void)
2671 retval
= debug_target
.to_stopped_by_watchpoint ();
2673 fprintf_unfiltered (gdb_stdlog
,
2674 "STOPPED_BY_WATCHPOINT () = %ld\n",
2675 (unsigned long) retval
);
2680 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2684 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2686 fprintf_unfiltered (gdb_stdlog
,
2687 "target_stopped_data_address ([0x%lx]) = %ld\n",
2688 (unsigned long)*addr
,
2689 (unsigned long)retval
);
2694 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2696 CORE_ADDR start
, int length
)
2700 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2703 fprintf_filtered (gdb_stdlog
,
2704 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2705 (unsigned long) addr
, (unsigned long) start
, length
,
2711 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2715 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2717 fprintf_unfiltered (gdb_stdlog
,
2718 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2719 (unsigned long) bp_tgt
->placed_address
,
2720 (unsigned long) retval
);
2725 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2729 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2731 fprintf_unfiltered (gdb_stdlog
,
2732 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2733 (unsigned long) bp_tgt
->placed_address
,
2734 (unsigned long) retval
);
2739 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2743 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2745 fprintf_unfiltered (gdb_stdlog
,
2746 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2747 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2752 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2756 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2758 fprintf_unfiltered (gdb_stdlog
,
2759 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2760 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2765 debug_to_terminal_init (void)
2767 debug_target
.to_terminal_init ();
2769 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2773 debug_to_terminal_inferior (void)
2775 debug_target
.to_terminal_inferior ();
2777 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2781 debug_to_terminal_ours_for_output (void)
2783 debug_target
.to_terminal_ours_for_output ();
2785 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2789 debug_to_terminal_ours (void)
2791 debug_target
.to_terminal_ours ();
2793 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2797 debug_to_terminal_save_ours (void)
2799 debug_target
.to_terminal_save_ours ();
2801 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2805 debug_to_terminal_info (char *arg
, int from_tty
)
2807 debug_target
.to_terminal_info (arg
, from_tty
);
2809 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2814 debug_to_kill (void)
2816 debug_target
.to_kill ();
2818 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2822 debug_to_load (char *args
, int from_tty
)
2824 debug_target
.to_load (args
, from_tty
);
2826 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2830 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2834 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2836 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2842 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2845 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2847 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2848 exec_file
, args
, from_tty
);
2852 debug_to_post_startup_inferior (ptid_t ptid
)
2854 debug_target
.to_post_startup_inferior (ptid
);
2856 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2861 debug_to_acknowledge_created_inferior (int pid
)
2863 debug_target
.to_acknowledge_created_inferior (pid
);
2865 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2870 debug_to_insert_fork_catchpoint (int pid
)
2872 debug_target
.to_insert_fork_catchpoint (pid
);
2874 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2879 debug_to_remove_fork_catchpoint (int pid
)
2883 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2885 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2892 debug_to_insert_vfork_catchpoint (int pid
)
2894 debug_target
.to_insert_vfork_catchpoint (pid
);
2896 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2901 debug_to_remove_vfork_catchpoint (int pid
)
2905 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2907 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2914 debug_to_insert_exec_catchpoint (int pid
)
2916 debug_target
.to_insert_exec_catchpoint (pid
);
2918 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2923 debug_to_remove_exec_catchpoint (int pid
)
2927 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2929 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2936 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2940 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2942 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2943 pid
, wait_status
, *exit_status
, has_exited
);
2949 debug_to_mourn_inferior (void)
2951 debug_target
.to_mourn_inferior ();
2953 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2957 debug_to_can_run (void)
2961 retval
= debug_target
.to_can_run ();
2963 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2969 debug_to_notice_signals (ptid_t ptid
)
2971 debug_target
.to_notice_signals (ptid
);
2973 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2978 debug_to_thread_alive (ptid_t ptid
)
2982 retval
= debug_target
.to_thread_alive (ptid
);
2984 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2985 PIDGET (ptid
), retval
);
2991 debug_to_find_new_threads (void)
2993 debug_target
.to_find_new_threads ();
2995 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2999 debug_to_stop (void)
3001 debug_target
.to_stop ();
3003 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
3007 debug_to_rcmd (char *command
,
3008 struct ui_file
*outbuf
)
3010 debug_target
.to_rcmd (command
, outbuf
);
3011 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
3015 debug_to_pid_to_exec_file (int pid
)
3019 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
3021 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
3028 setup_target_debug (void)
3030 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
3032 current_target
.to_open
= debug_to_open
;
3033 current_target
.to_close
= debug_to_close
;
3034 current_target
.to_attach
= debug_to_attach
;
3035 current_target
.to_post_attach
= debug_to_post_attach
;
3036 current_target
.to_detach
= debug_to_detach
;
3037 current_target
.to_resume
= debug_to_resume
;
3038 current_target
.to_wait
= debug_to_wait
;
3039 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
3040 current_target
.to_store_registers
= debug_to_store_registers
;
3041 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
3042 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
3043 current_target
.to_files_info
= debug_to_files_info
;
3044 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
3045 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
3046 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
3047 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
3048 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
3049 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
3050 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
3051 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
3052 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
3053 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
3054 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
3055 current_target
.to_terminal_init
= debug_to_terminal_init
;
3056 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
3057 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
3058 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
3059 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
3060 current_target
.to_terminal_info
= debug_to_terminal_info
;
3061 current_target
.to_kill
= debug_to_kill
;
3062 current_target
.to_load
= debug_to_load
;
3063 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
3064 current_target
.to_create_inferior
= debug_to_create_inferior
;
3065 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
3066 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
3067 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
3068 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
3069 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
3070 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
3071 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
3072 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
3073 current_target
.to_has_exited
= debug_to_has_exited
;
3074 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3075 current_target
.to_can_run
= debug_to_can_run
;
3076 current_target
.to_notice_signals
= debug_to_notice_signals
;
3077 current_target
.to_thread_alive
= debug_to_thread_alive
;
3078 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3079 current_target
.to_stop
= debug_to_stop
;
3080 current_target
.to_rcmd
= debug_to_rcmd
;
3081 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3085 static char targ_desc
[] =
3086 "Names of targets and files being debugged.\n\
3087 Shows the entire stack of targets currently in use (including the exec-file,\n\
3088 core-file, and process, if any), as well as the symbol file name.";
3091 do_monitor_command (char *cmd
,
3094 if ((current_target
.to_rcmd
3095 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3096 || (current_target
.to_rcmd
== debug_to_rcmd
3097 && (debug_target
.to_rcmd
3098 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3099 error (_("\"monitor\" command not supported by this target."));
3100 target_rcmd (cmd
, gdb_stdtarg
);
3103 /* Print the name of each layers of our target stack. */
3106 maintenance_print_target_stack (char *cmd
, int from_tty
)
3108 struct target_ops
*t
;
3110 printf_filtered (_("The current target stack is:\n"));
3112 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3114 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3119 initialize_targets (void)
3121 init_dummy_target ();
3122 push_target (&dummy_target
);
3124 add_info ("target", target_info
, targ_desc
);
3125 add_info ("files", target_info
, targ_desc
);
3127 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3128 Set target debugging."), _("\
3129 Show target debugging."), _("\
3130 When non-zero, target debugging is enabled. Higher numbers are more\n\
3131 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3135 &setdebuglist
, &showdebuglist
);
3137 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3138 &trust_readonly
, _("\
3139 Set mode for reading from readonly sections."), _("\
3140 Show mode for reading from readonly sections."), _("\
3141 When this mode is on, memory reads from readonly sections (such as .text)\n\
3142 will be read from the object file instead of from the target. This will\n\
3143 result in significant performance improvement for remote targets."),
3145 show_trust_readonly
,
3146 &setlist
, &showlist
);
3148 add_com ("monitor", class_obscure
, do_monitor_command
,
3149 _("Send a command to the remote monitor (remote targets only)."));
3151 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3152 _("Print the name of each layer of the internal target stack."),
3153 &maintenanceprintlist
);
3155 target_dcache
= dcache_init ();