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 "gdb_stdint.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? */
1453 /* An alternative to target_write with progress callbacks. */
1456 target_write_with_progress (struct target_ops
*ops
,
1457 enum target_object object
,
1458 const char *annex
, const gdb_byte
*buf
,
1459 ULONGEST offset
, LONGEST len
,
1460 void (*progress
) (ULONGEST
, void *), void *baton
)
1464 /* Give the progress callback a chance to set up. */
1466 (*progress
) (0, baton
);
1468 while (xfered
< len
)
1470 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1471 (gdb_byte
*) buf
+ xfered
,
1472 offset
+ xfered
, len
- xfered
);
1480 (*progress
) (xfer
, baton
);
1489 target_write (struct target_ops
*ops
,
1490 enum target_object object
,
1491 const char *annex
, const gdb_byte
*buf
,
1492 ULONGEST offset
, LONGEST len
)
1494 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1498 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1499 the size of the transferred data. PADDING additional bytes are
1500 available in *BUF_P. This is a helper function for
1501 target_read_alloc; see the declaration of that function for more
1505 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1506 const char *annex
, gdb_byte
**buf_p
, int padding
)
1508 size_t buf_alloc
, buf_pos
;
1512 /* This function does not have a length parameter; it reads the
1513 entire OBJECT). Also, it doesn't support objects fetched partly
1514 from one target and partly from another (in a different stratum,
1515 e.g. a core file and an executable). Both reasons make it
1516 unsuitable for reading memory. */
1517 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1519 /* Start by reading up to 4K at a time. The target will throttle
1520 this number down if necessary. */
1522 buf
= xmalloc (buf_alloc
);
1526 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1527 buf_pos
, buf_alloc
- buf_pos
- padding
);
1530 /* An error occurred. */
1536 /* Read all there was. */
1546 /* If the buffer is filling up, expand it. */
1547 if (buf_alloc
< buf_pos
* 2)
1550 buf
= xrealloc (buf
, buf_alloc
);
1557 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1558 the size of the transferred data. See the declaration in "target.h"
1559 function for more information about the return value. */
1562 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1563 const char *annex
, gdb_byte
**buf_p
)
1565 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1568 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1569 returned as a string, allocated using xmalloc. If an error occurs
1570 or the transfer is unsupported, NULL is returned. Empty objects
1571 are returned as allocated but empty strings. A warning is issued
1572 if the result contains any embedded NUL bytes. */
1575 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1579 LONGEST transferred
;
1581 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1583 if (transferred
< 0)
1586 if (transferred
== 0)
1587 return xstrdup ("");
1589 buffer
[transferred
] = 0;
1590 if (strlen (buffer
) < transferred
)
1591 warning (_("target object %d, annex %s, "
1592 "contained unexpected null characters"),
1593 (int) object
, annex
? annex
: "(none)");
1595 return (char *) buffer
;
1598 /* Memory transfer methods. */
1601 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1604 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1606 memory_error (EIO
, addr
);
1610 get_target_memory_unsigned (struct target_ops
*ops
,
1611 CORE_ADDR addr
, int len
)
1613 gdb_byte buf
[sizeof (ULONGEST
)];
1615 gdb_assert (len
<= sizeof (buf
));
1616 get_target_memory (ops
, addr
, buf
, len
);
1617 return extract_unsigned_integer (buf
, len
);
1621 target_info (char *args
, int from_tty
)
1623 struct target_ops
*t
;
1624 int has_all_mem
= 0;
1626 if (symfile_objfile
!= NULL
)
1627 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1629 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1631 if (!t
->to_has_memory
)
1634 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1637 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1638 printf_unfiltered ("%s:\n", t
->to_longname
);
1639 (t
->to_files_info
) (t
);
1640 has_all_mem
= t
->to_has_all_memory
;
1644 /* This function is called before any new inferior is created, e.g.
1645 by running a program, attaching, or connecting to a target.
1646 It cleans up any state from previous invocations which might
1647 change between runs. This is a subset of what target_preopen
1648 resets (things which might change between targets). */
1651 target_pre_inferior (int from_tty
)
1653 invalidate_target_mem_regions ();
1655 target_clear_description ();
1658 /* This is to be called by the open routine before it does
1662 target_preopen (int from_tty
)
1666 if (target_has_execution
)
1669 || query (_("A program is being debugged already. Kill it? ")))
1672 error (_("Program not killed."));
1675 /* Calling target_kill may remove the target from the stack. But if
1676 it doesn't (which seems like a win for UDI), remove it now. */
1678 if (target_has_execution
)
1681 target_pre_inferior (from_tty
);
1684 /* Detach a target after doing deferred register stores. */
1687 target_detach (char *args
, int from_tty
)
1689 /* If we're in breakpoints-always-inserted mode, have to
1690 remove them before detaching. */
1691 remove_breakpoints ();
1693 (current_target
.to_detach
) (args
, from_tty
);
1697 target_disconnect (char *args
, int from_tty
)
1699 struct target_ops
*t
;
1701 /* If we're in breakpoints-always-inserted mode, have to
1702 remove them before disconnecting. */
1703 remove_breakpoints ();
1705 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1706 if (t
->to_disconnect
!= NULL
)
1709 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1711 t
->to_disconnect (t
, args
, from_tty
);
1718 /* Look through the list of possible targets for a target that can
1722 target_follow_fork (int follow_child
)
1724 struct target_ops
*t
;
1726 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1728 if (t
->to_follow_fork
!= NULL
)
1730 int retval
= t
->to_follow_fork (t
, follow_child
);
1732 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1733 follow_child
, retval
);
1738 /* Some target returned a fork event, but did not know how to follow it. */
1739 internal_error (__FILE__
, __LINE__
,
1740 "could not find a target to follow fork");
1743 /* Look for a target which can describe architectural features, starting
1744 from TARGET. If we find one, return its description. */
1746 const struct target_desc
*
1747 target_read_description (struct target_ops
*target
)
1749 struct target_ops
*t
;
1751 for (t
= target
; t
!= NULL
; t
= t
->beneath
)
1752 if (t
->to_read_description
!= NULL
)
1754 const struct target_desc
*tdesc
;
1756 tdesc
= t
->to_read_description (t
);
1764 /* The default implementation of to_search_memory.
1765 This implements a basic search of memory, reading target memory and
1766 performing the search here (as opposed to performing the search in on the
1767 target side with, for example, gdbserver). */
1770 simple_search_memory (struct target_ops
*ops
,
1771 CORE_ADDR start_addr
, ULONGEST search_space_len
,
1772 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1773 CORE_ADDR
*found_addrp
)
1775 /* NOTE: also defined in find.c testcase. */
1776 #define SEARCH_CHUNK_SIZE 16000
1777 const unsigned chunk_size
= SEARCH_CHUNK_SIZE
;
1778 /* Buffer to hold memory contents for searching. */
1779 gdb_byte
*search_buf
;
1780 unsigned search_buf_size
;
1781 struct cleanup
*old_cleanups
;
1783 search_buf_size
= chunk_size
+ pattern_len
- 1;
1785 /* No point in trying to allocate a buffer larger than the search space. */
1786 if (search_space_len
< search_buf_size
)
1787 search_buf_size
= search_space_len
;
1789 search_buf
= malloc (search_buf_size
);
1790 if (search_buf
== NULL
)
1791 error (_("Unable to allocate memory to perform the search."));
1792 old_cleanups
= make_cleanup (free_current_contents
, &search_buf
);
1794 /* Prime the search buffer. */
1796 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1797 search_buf
, start_addr
, search_buf_size
) != search_buf_size
)
1799 warning (_("Unable to access target memory at %s, halting search."),
1800 hex_string (start_addr
));
1801 do_cleanups (old_cleanups
);
1805 /* Perform the search.
1807 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
1808 When we've scanned N bytes we copy the trailing bytes to the start and
1809 read in another N bytes. */
1811 while (search_space_len
>= pattern_len
)
1813 gdb_byte
*found_ptr
;
1814 unsigned nr_search_bytes
= min (search_space_len
, search_buf_size
);
1816 found_ptr
= memmem (search_buf
, nr_search_bytes
,
1817 pattern
, pattern_len
);
1819 if (found_ptr
!= NULL
)
1821 CORE_ADDR found_addr
= start_addr
+ (found_ptr
- search_buf
);
1822 *found_addrp
= found_addr
;
1823 do_cleanups (old_cleanups
);
1827 /* Not found in this chunk, skip to next chunk. */
1829 /* Don't let search_space_len wrap here, it's unsigned. */
1830 if (search_space_len
>= chunk_size
)
1831 search_space_len
-= chunk_size
;
1833 search_space_len
= 0;
1835 if (search_space_len
>= pattern_len
)
1837 unsigned keep_len
= search_buf_size
- chunk_size
;
1838 CORE_ADDR read_addr
= start_addr
+ keep_len
;
1841 /* Copy the trailing part of the previous iteration to the front
1842 of the buffer for the next iteration. */
1843 gdb_assert (keep_len
== pattern_len
- 1);
1844 memcpy (search_buf
, search_buf
+ chunk_size
, keep_len
);
1846 nr_to_read
= min (search_space_len
- keep_len
, chunk_size
);
1848 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
,
1849 search_buf
+ keep_len
, read_addr
,
1850 nr_to_read
) != nr_to_read
)
1852 warning (_("Unable to access target memory at %s, halting search."),
1853 hex_string (read_addr
));
1854 do_cleanups (old_cleanups
);
1858 start_addr
+= chunk_size
;
1864 do_cleanups (old_cleanups
);
1868 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
1869 sequence of bytes in PATTERN with length PATTERN_LEN.
1871 The result is 1 if found, 0 if not found, and -1 if there was an error
1872 requiring halting of the search (e.g. memory read error).
1873 If the pattern is found the address is recorded in FOUND_ADDRP. */
1876 target_search_memory (CORE_ADDR start_addr
, ULONGEST search_space_len
,
1877 const gdb_byte
*pattern
, ULONGEST pattern_len
,
1878 CORE_ADDR
*found_addrp
)
1880 struct target_ops
*t
;
1883 /* We don't use INHERIT to set current_target.to_search_memory,
1884 so we have to scan the target stack and handle targetdebug
1888 fprintf_unfiltered (gdb_stdlog
, "target_search_memory (%s, ...)\n",
1889 hex_string (start_addr
));
1891 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1892 if (t
->to_search_memory
!= NULL
)
1897 found
= t
->to_search_memory (t
, start_addr
, search_space_len
,
1898 pattern
, pattern_len
, found_addrp
);
1902 /* If a special version of to_search_memory isn't available, use the
1904 found
= simple_search_memory (¤t_target
,
1905 start_addr
, search_space_len
,
1906 pattern
, pattern_len
, found_addrp
);
1910 fprintf_unfiltered (gdb_stdlog
, " = %d\n", found
);
1915 /* Look through the currently pushed targets. If none of them will
1916 be able to restart the currently running process, issue an error
1920 target_require_runnable (void)
1922 struct target_ops
*t
;
1924 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1926 /* If this target knows how to create a new program, then
1927 assume we will still be able to after killing the current
1928 one. Either killing and mourning will not pop T, or else
1929 find_default_run_target will find it again. */
1930 if (t
->to_create_inferior
!= NULL
)
1933 /* Do not worry about thread_stratum targets that can not
1934 create inferiors. Assume they will be pushed again if
1935 necessary, and continue to the process_stratum. */
1936 if (t
->to_stratum
== thread_stratum
)
1940 The \"%s\" target does not support \"run\". Try \"help target\" or \"continue\"."),
1944 /* This function is only called if the target is running. In that
1945 case there should have been a process_stratum target and it
1946 should either know how to create inferiors, or not... */
1947 internal_error (__FILE__
, __LINE__
, "No targets found");
1950 /* Look through the list of possible targets for a target that can
1951 execute a run or attach command without any other data. This is
1952 used to locate the default process stratum.
1954 If DO_MESG is not NULL, the result is always valid (error() is
1955 called for errors); else, return NULL on error. */
1957 static struct target_ops
*
1958 find_default_run_target (char *do_mesg
)
1960 struct target_ops
**t
;
1961 struct target_ops
*runable
= NULL
;
1966 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1969 if ((*t
)->to_can_run
&& target_can_run (*t
))
1979 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1988 find_default_attach (char *args
, int from_tty
)
1990 struct target_ops
*t
;
1992 t
= find_default_run_target ("attach");
1993 (t
->to_attach
) (args
, from_tty
);
1998 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
2001 struct target_ops
*t
;
2003 t
= find_default_run_target ("run");
2004 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
2009 find_default_can_async_p (void)
2011 struct target_ops
*t
;
2013 /* This may be called before the target is pushed on the stack;
2014 look for the default process stratum. If there's none, gdb isn't
2015 configured with a native debugger, and target remote isn't
2017 t
= find_default_run_target (NULL
);
2018 if (t
&& t
->to_can_async_p
)
2019 return (t
->to_can_async_p
) ();
2024 find_default_is_async_p (void)
2026 struct target_ops
*t
;
2028 /* This may be called before the target is pushed on the stack;
2029 look for the default process stratum. If there's none, gdb isn't
2030 configured with a native debugger, and target remote isn't
2032 t
= find_default_run_target (NULL
);
2033 if (t
&& t
->to_is_async_p
)
2034 return (t
->to_is_async_p
) ();
2039 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2041 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
2045 default_watchpoint_addr_within_range (struct target_ops
*target
,
2047 CORE_ADDR start
, int length
)
2049 return addr
>= start
&& addr
< start
+ length
;
2065 return_minus_one (void)
2071 * Resize the to_sections pointer. Also make sure that anyone that
2072 * was holding on to an old value of it gets updated.
2073 * Returns the old size.
2077 target_resize_to_sections (struct target_ops
*target
, int num_added
)
2079 struct target_ops
**t
;
2080 struct section_table
*old_value
;
2083 old_value
= target
->to_sections
;
2085 if (target
->to_sections
)
2087 old_count
= target
->to_sections_end
- target
->to_sections
;
2088 target
->to_sections
= (struct section_table
*)
2089 xrealloc ((char *) target
->to_sections
,
2090 (sizeof (struct section_table
)) * (num_added
+ old_count
));
2095 target
->to_sections
= (struct section_table
*)
2096 xmalloc ((sizeof (struct section_table
)) * num_added
);
2098 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
2100 /* Check to see if anyone else was pointing to this structure.
2101 If old_value was null, then no one was. */
2105 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2108 if ((*t
)->to_sections
== old_value
)
2110 (*t
)->to_sections
= target
->to_sections
;
2111 (*t
)->to_sections_end
= target
->to_sections_end
;
2114 /* There is a flattened view of the target stack in current_target,
2115 so its to_sections pointer might also need updating. */
2116 if (current_target
.to_sections
== old_value
)
2118 current_target
.to_sections
= target
->to_sections
;
2119 current_target
.to_sections_end
= target
->to_sections_end
;
2127 /* Remove all target sections taken from ABFD.
2129 Scan the current target stack for targets whose section tables
2130 refer to sections from BFD, and remove those sections. We use this
2131 when we notice that the inferior has unloaded a shared object, for
2134 remove_target_sections (bfd
*abfd
)
2136 struct target_ops
**t
;
2138 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
2140 struct section_table
*src
, *dest
;
2142 dest
= (*t
)->to_sections
;
2143 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
2144 if (src
->bfd
!= abfd
)
2146 /* Keep this section. */
2147 if (dest
< src
) *dest
= *src
;
2151 /* If we've dropped any sections, resize the section table. */
2153 target_resize_to_sections (*t
, dest
- src
);
2160 /* Find a single runnable target in the stack and return it. If for
2161 some reason there is more than one, return NULL. */
2164 find_run_target (void)
2166 struct target_ops
**t
;
2167 struct target_ops
*runable
= NULL
;
2172 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
2174 if ((*t
)->to_can_run
&& target_can_run (*t
))
2181 return (count
== 1 ? runable
: NULL
);
2184 /* Find a single core_stratum target in the list of targets and return it.
2185 If for some reason there is more than one, return NULL. */
2188 find_core_target (void)
2190 struct target_ops
**t
;
2191 struct target_ops
*runable
= NULL
;
2196 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
2199 if ((*t
)->to_stratum
== core_stratum
)
2206 return (count
== 1 ? runable
: NULL
);
2210 * Find the next target down the stack from the specified target.
2214 find_target_beneath (struct target_ops
*t
)
2220 /* The inferior process has died. Long live the inferior! */
2223 generic_mourn_inferior (void)
2225 extern int show_breakpoint_hit_counts
;
2227 inferior_ptid
= null_ptid
;
2229 breakpoint_init_inferior (inf_exited
);
2230 registers_changed ();
2232 reopen_exec_file ();
2233 reinit_frame_cache ();
2235 /* It is confusing to the user for ignore counts to stick around
2236 from previous runs of the inferior. So clear them. */
2237 /* However, it is more confusing for the ignore counts to disappear when
2238 using hit counts. So don't clear them if we're counting hits. */
2239 if (!show_breakpoint_hit_counts
)
2240 breakpoint_clear_ignore_counts ();
2242 if (deprecated_detach_hook
)
2243 deprecated_detach_hook ();
2246 /* Helper function for child_wait and the derivatives of child_wait.
2247 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2248 translation of that in OURSTATUS. */
2250 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2252 if (WIFEXITED (hoststatus
))
2254 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2255 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2257 else if (!WIFSTOPPED (hoststatus
))
2259 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2260 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2264 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2265 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2269 /* Returns zero to leave the inferior alone, one to interrupt it. */
2270 int (*target_activity_function
) (void);
2271 int target_activity_fd
;
2273 /* Convert a normal process ID to a string. Returns the string in a
2277 normal_pid_to_str (ptid_t ptid
)
2279 static char buf
[32];
2281 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
2285 /* Error-catcher for target_find_memory_regions */
2286 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
2288 error (_("No target."));
2292 /* Error-catcher for target_make_corefile_notes */
2293 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
2295 error (_("No target."));
2299 /* Set up the handful of non-empty slots needed by the dummy target
2303 init_dummy_target (void)
2305 dummy_target
.to_shortname
= "None";
2306 dummy_target
.to_longname
= "None";
2307 dummy_target
.to_doc
= "";
2308 dummy_target
.to_attach
= find_default_attach
;
2309 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2310 dummy_target
.to_can_async_p
= find_default_can_async_p
;
2311 dummy_target
.to_is_async_p
= find_default_is_async_p
;
2312 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2313 dummy_target
.to_stratum
= dummy_stratum
;
2314 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
2315 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
2316 dummy_target
.to_xfer_partial
= default_xfer_partial
;
2317 dummy_target
.to_magic
= OPS_MAGIC
;
2321 debug_to_open (char *args
, int from_tty
)
2323 debug_target
.to_open (args
, from_tty
);
2325 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2329 debug_to_close (int quitting
)
2331 target_close (&debug_target
, quitting
);
2332 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2336 target_close (struct target_ops
*targ
, int quitting
)
2338 if (targ
->to_xclose
!= NULL
)
2339 targ
->to_xclose (targ
, quitting
);
2340 else if (targ
->to_close
!= NULL
)
2341 targ
->to_close (quitting
);
2345 debug_to_attach (char *args
, int from_tty
)
2347 debug_target
.to_attach (args
, from_tty
);
2349 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2354 debug_to_post_attach (int pid
)
2356 debug_target
.to_post_attach (pid
);
2358 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2362 debug_to_detach (char *args
, int from_tty
)
2364 debug_target
.to_detach (args
, from_tty
);
2366 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2370 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2372 debug_target
.to_resume (ptid
, step
, siggnal
);
2374 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2375 step
? "step" : "continue",
2376 target_signal_to_name (siggnal
));
2380 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2384 retval
= debug_target
.to_wait (ptid
, status
);
2386 fprintf_unfiltered (gdb_stdlog
,
2387 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2389 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2390 switch (status
->kind
)
2392 case TARGET_WAITKIND_EXITED
:
2393 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2394 status
->value
.integer
);
2396 case TARGET_WAITKIND_STOPPED
:
2397 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2398 target_signal_to_name (status
->value
.sig
));
2400 case TARGET_WAITKIND_SIGNALLED
:
2401 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2402 target_signal_to_name (status
->value
.sig
));
2404 case TARGET_WAITKIND_LOADED
:
2405 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2407 case TARGET_WAITKIND_FORKED
:
2408 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2410 case TARGET_WAITKIND_VFORKED
:
2411 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2413 case TARGET_WAITKIND_EXECD
:
2414 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2416 case TARGET_WAITKIND_SPURIOUS
:
2417 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2420 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2428 debug_print_register (const char * func
,
2429 struct regcache
*regcache
, int regno
)
2431 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
2432 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2433 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
2434 + gdbarch_num_pseudo_regs (gdbarch
)
2435 && gdbarch_register_name (gdbarch
, regno
) != NULL
2436 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
2437 fprintf_unfiltered (gdb_stdlog
, "(%s)",
2438 gdbarch_register_name (gdbarch
, regno
));
2440 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2443 int i
, size
= register_size (gdbarch
, regno
);
2444 unsigned char buf
[MAX_REGISTER_SIZE
];
2445 regcache_cooked_read (regcache
, regno
, buf
);
2446 fprintf_unfiltered (gdb_stdlog
, " = ");
2447 for (i
= 0; i
< size
; i
++)
2449 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2451 if (size
<= sizeof (LONGEST
))
2453 ULONGEST val
= extract_unsigned_integer (buf
, size
);
2454 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2455 paddr_nz (val
), paddr_d (val
));
2458 fprintf_unfiltered (gdb_stdlog
, "\n");
2462 debug_to_fetch_registers (struct regcache
*regcache
, int regno
)
2464 debug_target
.to_fetch_registers (regcache
, regno
);
2465 debug_print_register ("target_fetch_registers", regcache
, regno
);
2469 debug_to_store_registers (struct regcache
*regcache
, int regno
)
2471 debug_target
.to_store_registers (regcache
, regno
);
2472 debug_print_register ("target_store_registers", regcache
, regno
);
2473 fprintf_unfiltered (gdb_stdlog
, "\n");
2477 debug_to_prepare_to_store (struct regcache
*regcache
)
2479 debug_target
.to_prepare_to_store (regcache
);
2481 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2485 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2486 int write
, struct mem_attrib
*attrib
,
2487 struct target_ops
*target
)
2491 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2494 fprintf_unfiltered (gdb_stdlog
,
2495 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2496 (unsigned int) memaddr
, /* possable truncate long long */
2497 len
, write
? "write" : "read", retval
);
2503 fputs_unfiltered (", bytes =", gdb_stdlog
);
2504 for (i
= 0; i
< retval
; i
++)
2506 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2508 if (targetdebug
< 2 && i
> 0)
2510 fprintf_unfiltered (gdb_stdlog
, " ...");
2513 fprintf_unfiltered (gdb_stdlog
, "\n");
2516 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2520 fputc_unfiltered ('\n', gdb_stdlog
);
2526 debug_to_files_info (struct target_ops
*target
)
2528 debug_target
.to_files_info (target
);
2530 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2534 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2538 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2540 fprintf_unfiltered (gdb_stdlog
,
2541 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2542 (unsigned long) bp_tgt
->placed_address
,
2543 (unsigned long) retval
);
2548 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2552 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2554 fprintf_unfiltered (gdb_stdlog
,
2555 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2556 (unsigned long) bp_tgt
->placed_address
,
2557 (unsigned long) retval
);
2562 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2566 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2568 fprintf_unfiltered (gdb_stdlog
,
2569 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2570 (unsigned long) type
,
2571 (unsigned long) cnt
,
2572 (unsigned long) from_tty
,
2573 (unsigned long) retval
);
2578 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2582 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2584 fprintf_unfiltered (gdb_stdlog
,
2585 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2586 (unsigned long) addr
,
2587 (unsigned long) len
,
2588 (unsigned long) retval
);
2593 debug_to_stopped_by_watchpoint (void)
2597 retval
= debug_target
.to_stopped_by_watchpoint ();
2599 fprintf_unfiltered (gdb_stdlog
,
2600 "STOPPED_BY_WATCHPOINT () = %ld\n",
2601 (unsigned long) retval
);
2606 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2610 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2612 fprintf_unfiltered (gdb_stdlog
,
2613 "target_stopped_data_address ([0x%lx]) = %ld\n",
2614 (unsigned long)*addr
,
2615 (unsigned long)retval
);
2620 debug_to_watchpoint_addr_within_range (struct target_ops
*target
,
2622 CORE_ADDR start
, int length
)
2626 retval
= debug_target
.to_watchpoint_addr_within_range (target
, addr
,
2629 fprintf_filtered (gdb_stdlog
,
2630 "target_watchpoint_addr_within_range (0x%lx, 0x%lx, %d) = %d\n",
2631 (unsigned long) addr
, (unsigned long) start
, length
,
2637 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2641 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2643 fprintf_unfiltered (gdb_stdlog
,
2644 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2645 (unsigned long) bp_tgt
->placed_address
,
2646 (unsigned long) retval
);
2651 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2655 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2657 fprintf_unfiltered (gdb_stdlog
,
2658 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2659 (unsigned long) bp_tgt
->placed_address
,
2660 (unsigned long) retval
);
2665 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2669 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2671 fprintf_unfiltered (gdb_stdlog
,
2672 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2673 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2678 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2682 retval
= debug_target
.to_remove_watchpoint (addr
, len
, type
);
2684 fprintf_unfiltered (gdb_stdlog
,
2685 "target_remove_watchpoint (0x%lx, %d, %d) = %ld\n",
2686 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2691 debug_to_terminal_init (void)
2693 debug_target
.to_terminal_init ();
2695 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2699 debug_to_terminal_inferior (void)
2701 debug_target
.to_terminal_inferior ();
2703 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2707 debug_to_terminal_ours_for_output (void)
2709 debug_target
.to_terminal_ours_for_output ();
2711 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2715 debug_to_terminal_ours (void)
2717 debug_target
.to_terminal_ours ();
2719 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2723 debug_to_terminal_save_ours (void)
2725 debug_target
.to_terminal_save_ours ();
2727 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2731 debug_to_terminal_info (char *arg
, int from_tty
)
2733 debug_target
.to_terminal_info (arg
, from_tty
);
2735 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2740 debug_to_kill (void)
2742 debug_target
.to_kill ();
2744 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2748 debug_to_load (char *args
, int from_tty
)
2750 debug_target
.to_load (args
, from_tty
);
2752 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2756 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2760 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2762 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2768 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2771 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2773 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2774 exec_file
, args
, from_tty
);
2778 debug_to_post_startup_inferior (ptid_t ptid
)
2780 debug_target
.to_post_startup_inferior (ptid
);
2782 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2787 debug_to_acknowledge_created_inferior (int pid
)
2789 debug_target
.to_acknowledge_created_inferior (pid
);
2791 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2796 debug_to_insert_fork_catchpoint (int pid
)
2798 debug_target
.to_insert_fork_catchpoint (pid
);
2800 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2805 debug_to_remove_fork_catchpoint (int pid
)
2809 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2811 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2818 debug_to_insert_vfork_catchpoint (int pid
)
2820 debug_target
.to_insert_vfork_catchpoint (pid
);
2822 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2827 debug_to_remove_vfork_catchpoint (int pid
)
2831 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2833 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2840 debug_to_insert_exec_catchpoint (int pid
)
2842 debug_target
.to_insert_exec_catchpoint (pid
);
2844 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2849 debug_to_remove_exec_catchpoint (int pid
)
2853 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2855 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2862 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2866 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2868 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2869 pid
, wait_status
, *exit_status
, has_exited
);
2875 debug_to_mourn_inferior (void)
2877 debug_target
.to_mourn_inferior ();
2879 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2883 debug_to_can_run (void)
2887 retval
= debug_target
.to_can_run ();
2889 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2895 debug_to_notice_signals (ptid_t ptid
)
2897 debug_target
.to_notice_signals (ptid
);
2899 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2904 debug_to_thread_alive (ptid_t ptid
)
2908 retval
= debug_target
.to_thread_alive (ptid
);
2910 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2911 PIDGET (ptid
), retval
);
2917 debug_to_find_new_threads (void)
2919 debug_target
.to_find_new_threads ();
2921 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2925 debug_to_stop (void)
2927 debug_target
.to_stop ();
2929 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2933 debug_to_rcmd (char *command
,
2934 struct ui_file
*outbuf
)
2936 debug_target
.to_rcmd (command
, outbuf
);
2937 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2941 debug_to_pid_to_exec_file (int pid
)
2945 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2947 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2954 setup_target_debug (void)
2956 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2958 current_target
.to_open
= debug_to_open
;
2959 current_target
.to_close
= debug_to_close
;
2960 current_target
.to_attach
= debug_to_attach
;
2961 current_target
.to_post_attach
= debug_to_post_attach
;
2962 current_target
.to_detach
= debug_to_detach
;
2963 current_target
.to_resume
= debug_to_resume
;
2964 current_target
.to_wait
= debug_to_wait
;
2965 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2966 current_target
.to_store_registers
= debug_to_store_registers
;
2967 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2968 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2969 current_target
.to_files_info
= debug_to_files_info
;
2970 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2971 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2972 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2973 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2974 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2975 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2976 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2977 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2978 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2979 current_target
.to_watchpoint_addr_within_range
= debug_to_watchpoint_addr_within_range
;
2980 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2981 current_target
.to_terminal_init
= debug_to_terminal_init
;
2982 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2983 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2984 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2985 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2986 current_target
.to_terminal_info
= debug_to_terminal_info
;
2987 current_target
.to_kill
= debug_to_kill
;
2988 current_target
.to_load
= debug_to_load
;
2989 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2990 current_target
.to_create_inferior
= debug_to_create_inferior
;
2991 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2992 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2993 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2994 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2995 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2996 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2997 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2998 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2999 current_target
.to_has_exited
= debug_to_has_exited
;
3000 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
3001 current_target
.to_can_run
= debug_to_can_run
;
3002 current_target
.to_notice_signals
= debug_to_notice_signals
;
3003 current_target
.to_thread_alive
= debug_to_thread_alive
;
3004 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
3005 current_target
.to_stop
= debug_to_stop
;
3006 current_target
.to_rcmd
= debug_to_rcmd
;
3007 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
3011 static char targ_desc
[] =
3012 "Names of targets and files being debugged.\n\
3013 Shows the entire stack of targets currently in use (including the exec-file,\n\
3014 core-file, and process, if any), as well as the symbol file name.";
3017 do_monitor_command (char *cmd
,
3020 if ((current_target
.to_rcmd
3021 == (void (*) (char *, struct ui_file
*)) tcomplain
)
3022 || (current_target
.to_rcmd
== debug_to_rcmd
3023 && (debug_target
.to_rcmd
3024 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
3025 error (_("\"monitor\" command not supported by this target."));
3026 target_rcmd (cmd
, gdb_stdtarg
);
3029 /* Print the name of each layers of our target stack. */
3032 maintenance_print_target_stack (char *cmd
, int from_tty
)
3034 struct target_ops
*t
;
3036 printf_filtered (_("The current target stack is:\n"));
3038 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
3040 printf_filtered (" - %s (%s)\n", t
->to_shortname
, t
->to_longname
);
3045 initialize_targets (void)
3047 init_dummy_target ();
3048 push_target (&dummy_target
);
3050 add_info ("target", target_info
, targ_desc
);
3051 add_info ("files", target_info
, targ_desc
);
3053 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
3054 Set target debugging."), _("\
3055 Show target debugging."), _("\
3056 When non-zero, target debugging is enabled. Higher numbers are more\n\
3057 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
3061 &setdebuglist
, &showdebuglist
);
3063 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
3064 &trust_readonly
, _("\
3065 Set mode for reading from readonly sections."), _("\
3066 Show mode for reading from readonly sections."), _("\
3067 When this mode is on, memory reads from readonly sections (such as .text)\n\
3068 will be read from the object file instead of from the target. This will\n\
3069 result in significant performance improvement for remote targets."),
3071 show_trust_readonly
,
3072 &setlist
, &showlist
);
3074 add_com ("monitor", class_obscure
, do_monitor_command
,
3075 _("Send a command to the remote monitor (remote targets only)."));
3077 add_cmd ("target-stack", class_maintenance
, maintenance_print_target_stack
,
3078 _("Print the name of each layer of the internal target stack."),
3079 &maintenanceprintlist
);
3081 target_dcache
= dcache_init ();