1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
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 2 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, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
28 #include "gdb_string.h"
40 #include "gdb_assert.h"
43 static void target_info (char *, int);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
53 static int nosymbol (char *, CORE_ADDR
*);
55 static void tcomplain (void);
57 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
74 enum target_object object
,
75 const char *annex
, gdb_byte
*readbuf
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, LONGEST len
);
79 /* Transfer LEN bytes between target address MEMADDR and GDB address
80 MYADDR. Returns 0 for success, errno code for failure (which
81 includes partial transfers -- if you want a more useful response to
82 partial transfers, try either target_read_memory_partial or
83 target_write_memory_partial). */
85 static int target_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
88 static void init_dummy_target (void);
90 static struct target_ops debug_target
;
92 static void debug_to_open (char *, int);
94 static void debug_to_close (int);
96 static void debug_to_attach (char *, int);
98 static void debug_to_detach (char *, int);
100 static void debug_to_disconnect (char *, int);
102 static void debug_to_resume (ptid_t
, int, enum target_signal
);
104 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
106 static void debug_to_fetch_registers (int);
108 static void debug_to_store_registers (int);
110 static void debug_to_prepare_to_store (void);
112 static void debug_to_files_info (struct target_ops
*);
114 static int debug_to_insert_breakpoint (CORE_ADDR
, gdb_byte
*);
116 static int debug_to_remove_breakpoint (CORE_ADDR
, gdb_byte
*);
118 static int debug_to_can_use_hw_breakpoint (int, int, int);
120 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, gdb_byte
*);
122 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, gdb_byte
*);
124 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
126 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
128 static int debug_to_stopped_by_watchpoint (void);
130 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
132 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
134 static void debug_to_terminal_init (void);
136 static void debug_to_terminal_inferior (void);
138 static void debug_to_terminal_ours_for_output (void);
140 static void debug_to_terminal_save_ours (void);
142 static void debug_to_terminal_ours (void);
144 static void debug_to_terminal_info (char *, int);
146 static void debug_to_kill (void);
148 static void debug_to_load (char *, int);
150 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
152 static void debug_to_mourn_inferior (void);
154 static int debug_to_can_run (void);
156 static void debug_to_notice_signals (ptid_t
);
158 static int debug_to_thread_alive (ptid_t
);
160 static void debug_to_stop (void);
162 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
163 wierd and mysterious ways. Putting the variable here lets those
164 wierd and mysterious ways keep building while they are being
165 converted to the inferior inheritance structure. */
166 struct target_ops deprecated_child_ops
;
168 /* Pointer to array of target architecture structures; the size of the
169 array; the current index into the array; the allocated size of the
171 struct target_ops
**target_structs
;
172 unsigned target_struct_size
;
173 unsigned target_struct_index
;
174 unsigned target_struct_allocsize
;
175 #define DEFAULT_ALLOCSIZE 10
177 /* The initial current target, so that there is always a semi-valid
180 static struct target_ops dummy_target
;
182 /* Top of target stack. */
184 static struct target_ops
*target_stack
;
186 /* The target structure we are currently using to talk to a process
187 or file or whatever "inferior" we have. */
189 struct target_ops current_target
;
191 /* Command list for target. */
193 static struct cmd_list_element
*targetlist
= NULL
;
195 /* Nonzero if we are debugging an attached outside process
196 rather than an inferior. */
200 /* Non-zero if we want to see trace of target level stuff. */
202 static int targetdebug
= 0;
204 show_targetdebug (struct ui_file
*file
, int from_tty
,
205 struct cmd_list_element
*c
, const char *value
)
207 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
210 static void setup_target_debug (void);
212 DCACHE
*target_dcache
;
214 /* The user just typed 'target' without the name of a target. */
217 target_command (char *arg
, int from_tty
)
219 fputs_filtered ("Argument required (target name). Try `help target'\n",
223 /* Add a possible target architecture to the list. */
226 add_target (struct target_ops
*t
)
228 /* Provide default values for all "must have" methods. */
229 if (t
->to_xfer_partial
== NULL
)
230 t
->to_xfer_partial
= default_xfer_partial
;
234 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
235 target_structs
= (struct target_ops
**) xmalloc
236 (target_struct_allocsize
* sizeof (*target_structs
));
238 if (target_struct_size
>= target_struct_allocsize
)
240 target_struct_allocsize
*= 2;
241 target_structs
= (struct target_ops
**)
242 xrealloc ((char *) target_structs
,
243 target_struct_allocsize
* sizeof (*target_structs
));
245 target_structs
[target_struct_size
++] = t
;
247 if (targetlist
== NULL
)
248 add_prefix_cmd ("target", class_run
, target_command
, _("\
249 Connect to a target machine or process.\n\
250 The first argument is the type or protocol of the target machine.\n\
251 Remaining arguments are interpreted by the target protocol. For more\n\
252 information on the arguments for a particular protocol, type\n\
253 `help target ' followed by the protocol name."),
254 &targetlist
, "target ", 0, &cmdlist
);
255 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
266 target_load (char *arg
, int from_tty
)
268 dcache_invalidate (target_dcache
);
269 (*current_target
.to_load
) (arg
, from_tty
);
273 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
274 struct target_ops
*t
)
276 errno
= EIO
; /* Can't read/write this location */
277 return 0; /* No bytes handled */
283 error (_("You can't do that when your target is `%s'"),
284 current_target
.to_shortname
);
290 error (_("You can't do that without a process to debug."));
294 nosymbol (char *name
, CORE_ADDR
*addrp
)
296 return 1; /* Symbol does not exist in target env */
300 nosupport_runtime (void)
302 if (ptid_equal (inferior_ptid
, null_ptid
))
305 error (_("No run-time support for this"));
310 default_terminal_info (char *args
, int from_tty
)
312 printf_unfiltered (_("No saved terminal information.\n"));
315 /* This is the default target_create_inferior and target_attach function.
316 If the current target is executing, it asks whether to kill it off.
317 If this function returns without calling error(), it has killed off
318 the target, and the operation should be attempted. */
321 kill_or_be_killed (int from_tty
)
323 if (target_has_execution
)
325 printf_unfiltered (_("You are already running a program:\n"));
326 target_files_info ();
327 if (query ("Kill it? "))
330 if (target_has_execution
)
331 error (_("Killing the program did not help."));
336 error (_("Program not killed."));
343 maybe_kill_then_attach (char *args
, int from_tty
)
345 kill_or_be_killed (from_tty
);
346 target_attach (args
, from_tty
);
350 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
353 kill_or_be_killed (0);
354 target_create_inferior (exec
, args
, env
, from_tty
);
357 /* Go through the target stack from top to bottom, copying over zero
358 entries in current_target, then filling in still empty entries. In
359 effect, we are doing class inheritance through the pushed target
362 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
363 is currently implemented, is that it discards any knowledge of
364 which target an inherited method originally belonged to.
365 Consequently, new new target methods should instead explicitly and
366 locally search the target stack for the target that can handle the
370 update_current_target (void)
372 struct target_ops
*t
;
374 /* First, reset curren'ts contents. */
375 memset (¤t_target
, 0, sizeof (current_target
));
377 #define INHERIT(FIELD, TARGET) \
378 if (!current_target.FIELD) \
379 current_target.FIELD = (TARGET)->FIELD
381 for (t
= target_stack
; t
; t
= t
->beneath
)
383 INHERIT (to_shortname
, t
);
384 INHERIT (to_longname
, t
);
386 INHERIT (to_open
, t
);
387 INHERIT (to_close
, t
);
388 INHERIT (to_attach
, t
);
389 INHERIT (to_post_attach
, t
);
390 INHERIT (to_detach
, t
);
391 INHERIT (to_disconnect
, t
);
392 INHERIT (to_resume
, t
);
393 INHERIT (to_wait
, t
);
394 INHERIT (to_fetch_registers
, t
);
395 INHERIT (to_store_registers
, t
);
396 INHERIT (to_prepare_to_store
, t
);
397 INHERIT (deprecated_xfer_memory
, t
);
398 INHERIT (to_files_info
, t
);
399 INHERIT (to_insert_breakpoint
, t
);
400 INHERIT (to_remove_breakpoint
, t
);
401 INHERIT (to_can_use_hw_breakpoint
, t
);
402 INHERIT (to_insert_hw_breakpoint
, t
);
403 INHERIT (to_remove_hw_breakpoint
, t
);
404 INHERIT (to_insert_watchpoint
, t
);
405 INHERIT (to_remove_watchpoint
, t
);
406 INHERIT (to_stopped_data_address
, t
);
407 INHERIT (to_stopped_by_watchpoint
, t
);
408 INHERIT (to_have_continuable_watchpoint
, t
);
409 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
410 INHERIT (to_terminal_init
, t
);
411 INHERIT (to_terminal_inferior
, t
);
412 INHERIT (to_terminal_ours_for_output
, t
);
413 INHERIT (to_terminal_ours
, t
);
414 INHERIT (to_terminal_save_ours
, t
);
415 INHERIT (to_terminal_info
, t
);
416 INHERIT (to_kill
, t
);
417 INHERIT (to_load
, t
);
418 INHERIT (to_lookup_symbol
, t
);
419 INHERIT (to_create_inferior
, t
);
420 INHERIT (to_post_startup_inferior
, t
);
421 INHERIT (to_acknowledge_created_inferior
, t
);
422 INHERIT (to_insert_fork_catchpoint
, t
);
423 INHERIT (to_remove_fork_catchpoint
, t
);
424 INHERIT (to_insert_vfork_catchpoint
, t
);
425 INHERIT (to_remove_vfork_catchpoint
, t
);
426 /* Do not inherit to_follow_fork. */
427 INHERIT (to_insert_exec_catchpoint
, t
);
428 INHERIT (to_remove_exec_catchpoint
, t
);
429 INHERIT (to_reported_exec_events_per_exec_call
, t
);
430 INHERIT (to_has_exited
, t
);
431 INHERIT (to_mourn_inferior
, t
);
432 INHERIT (to_can_run
, t
);
433 INHERIT (to_notice_signals
, t
);
434 INHERIT (to_thread_alive
, t
);
435 INHERIT (to_find_new_threads
, t
);
436 INHERIT (to_pid_to_str
, t
);
437 INHERIT (to_extra_thread_info
, t
);
438 INHERIT (to_stop
, t
);
439 /* Do not inherit to_xfer_partial. */
440 INHERIT (to_rcmd
, t
);
441 INHERIT (to_enable_exception_callback
, t
);
442 INHERIT (to_get_current_exception_event
, t
);
443 INHERIT (to_pid_to_exec_file
, t
);
444 INHERIT (to_stratum
, t
);
445 INHERIT (to_has_all_memory
, t
);
446 INHERIT (to_has_memory
, t
);
447 INHERIT (to_has_stack
, t
);
448 INHERIT (to_has_registers
, t
);
449 INHERIT (to_has_execution
, t
);
450 INHERIT (to_has_thread_control
, t
);
451 INHERIT (to_sections
, t
);
452 INHERIT (to_sections_end
, t
);
453 INHERIT (to_can_async_p
, t
);
454 INHERIT (to_is_async_p
, t
);
455 INHERIT (to_async
, t
);
456 INHERIT (to_async_mask_value
, t
);
457 INHERIT (to_find_memory_regions
, t
);
458 INHERIT (to_make_corefile_notes
, t
);
459 INHERIT (to_get_thread_local_address
, t
);
460 INHERIT (to_magic
, t
);
464 /* Clean up a target struct so it no longer has any zero pointers in
465 it. Some entries are defaulted to a method that print an error,
466 others are hard-wired to a standard recursive default. */
468 #define de_fault(field, value) \
469 if (!current_target.field) \
470 current_target.field = value
473 (void (*) (char *, int))
479 maybe_kill_then_attach
);
480 de_fault (to_post_attach
,
484 (void (*) (char *, int))
486 de_fault (to_disconnect
,
487 (void (*) (char *, int))
490 (void (*) (ptid_t
, int, enum target_signal
))
493 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
495 de_fault (to_fetch_registers
,
498 de_fault (to_store_registers
,
501 de_fault (to_prepare_to_store
,
504 de_fault (deprecated_xfer_memory
,
505 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
507 de_fault (to_files_info
,
508 (void (*) (struct target_ops
*))
510 de_fault (to_insert_breakpoint
,
511 memory_insert_breakpoint
);
512 de_fault (to_remove_breakpoint
,
513 memory_remove_breakpoint
);
514 de_fault (to_can_use_hw_breakpoint
,
515 (int (*) (int, int, int))
517 de_fault (to_insert_hw_breakpoint
,
518 (int (*) (CORE_ADDR
, gdb_byte
*))
520 de_fault (to_remove_hw_breakpoint
,
521 (int (*) (CORE_ADDR
, gdb_byte
*))
523 de_fault (to_insert_watchpoint
,
524 (int (*) (CORE_ADDR
, int, int))
526 de_fault (to_remove_watchpoint
,
527 (int (*) (CORE_ADDR
, int, int))
529 de_fault (to_stopped_by_watchpoint
,
532 de_fault (to_stopped_data_address
,
533 (int (*) (struct target_ops
*, CORE_ADDR
*))
535 de_fault (to_region_ok_for_hw_watchpoint
,
536 default_region_ok_for_hw_watchpoint
);
537 de_fault (to_terminal_init
,
540 de_fault (to_terminal_inferior
,
543 de_fault (to_terminal_ours_for_output
,
546 de_fault (to_terminal_ours
,
549 de_fault (to_terminal_save_ours
,
552 de_fault (to_terminal_info
,
553 default_terminal_info
);
558 (void (*) (char *, int))
560 de_fault (to_lookup_symbol
,
561 (int (*) (char *, CORE_ADDR
*))
563 de_fault (to_create_inferior
,
564 maybe_kill_then_create_inferior
);
565 de_fault (to_post_startup_inferior
,
568 de_fault (to_acknowledge_created_inferior
,
571 de_fault (to_insert_fork_catchpoint
,
574 de_fault (to_remove_fork_catchpoint
,
577 de_fault (to_insert_vfork_catchpoint
,
580 de_fault (to_remove_vfork_catchpoint
,
583 de_fault (to_insert_exec_catchpoint
,
586 de_fault (to_remove_exec_catchpoint
,
589 de_fault (to_reported_exec_events_per_exec_call
,
592 de_fault (to_has_exited
,
593 (int (*) (int, int, int *))
595 de_fault (to_mourn_inferior
,
598 de_fault (to_can_run
,
600 de_fault (to_notice_signals
,
603 de_fault (to_thread_alive
,
606 de_fault (to_find_new_threads
,
609 de_fault (to_extra_thread_info
,
610 (char *(*) (struct thread_info
*))
615 current_target
.to_xfer_partial
= default_xfer_partial
;
617 (void (*) (char *, struct ui_file
*))
619 de_fault (to_enable_exception_callback
,
620 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
622 de_fault (to_get_current_exception_event
,
623 (struct exception_event_record
* (*) (void))
625 de_fault (to_pid_to_exec_file
,
628 de_fault (to_can_async_p
,
631 de_fault (to_is_async_p
,
635 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
639 /* Finally, position the target-stack beneath the squashed
640 "current_target". That way code looking for a non-inherited
641 target method can quickly and simply find it. */
642 current_target
.beneath
= target_stack
;
645 /* Push a new target type into the stack of the existing target accessors,
646 possibly superseding some of the existing accessors.
648 Result is zero if the pushed target ended up on top of the stack,
649 nonzero if at least one target is on top of it.
651 Rather than allow an empty stack, we always have the dummy target at
652 the bottom stratum, so we can call the function vectors without
656 push_target (struct target_ops
*t
)
658 struct target_ops
**cur
;
660 /* Check magic number. If wrong, it probably means someone changed
661 the struct definition, but not all the places that initialize one. */
662 if (t
->to_magic
!= OPS_MAGIC
)
664 fprintf_unfiltered (gdb_stderr
,
665 "Magic number of %s target struct wrong\n",
667 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
670 /* Find the proper stratum to install this target in. */
671 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
673 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
677 /* If there's already targets at this stratum, remove them. */
678 /* FIXME: cagney/2003-10-15: I think this should be poping all
679 targets to CUR, and not just those at this stratum level. */
680 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
682 /* There's already something at this stratum level. Close it,
683 and un-hook it from the stack. */
684 struct target_ops
*tmp
= (*cur
);
685 (*cur
) = (*cur
)->beneath
;
687 target_close (tmp
, 0);
690 /* We have removed all targets in our stratum, now add the new one. */
694 update_current_target ();
697 setup_target_debug ();
700 return (t
!= target_stack
);
703 /* Remove a target_ops vector from the stack, wherever it may be.
704 Return how many times it was removed (0 or 1). */
707 unpush_target (struct target_ops
*t
)
709 struct target_ops
**cur
;
710 struct target_ops
*tmp
;
712 /* Look for the specified target. Note that we assume that a target
713 can only occur once in the target stack. */
715 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
722 return 0; /* Didn't find target_ops, quit now */
724 /* NOTE: cagney/2003-12-06: In '94 the close call was made
725 unconditional by moving it to before the above check that the
726 target was in the target stack (something about "Change the way
727 pushing and popping of targets work to support target overlays
728 and inheritance"). This doesn't make much sense - only open
729 targets should be closed. */
732 /* Unchain the target */
734 (*cur
) = (*cur
)->beneath
;
737 update_current_target ();
745 target_close (¤t_target
, 0); /* Let it clean up */
746 if (unpush_target (target_stack
) == 1)
749 fprintf_unfiltered (gdb_stderr
,
750 "pop_target couldn't find target %s\n",
751 current_target
.to_shortname
);
752 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
756 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
758 /* target_read_string -- read a null terminated string, up to LEN bytes,
759 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
760 Set *STRING to a pointer to malloc'd memory containing the data; the caller
761 is responsible for freeing it. Return the number of bytes successfully
765 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
767 int tlen
, origlen
, offset
, i
;
771 int buffer_allocated
;
773 unsigned int nbytes_read
= 0;
775 /* Small for testing. */
776 buffer_allocated
= 4;
777 buffer
= xmalloc (buffer_allocated
);
784 tlen
= MIN (len
, 4 - (memaddr
& 3));
785 offset
= memaddr
& 3;
787 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
790 /* The transfer request might have crossed the boundary to an
791 unallocated region of memory. Retry the transfer, requesting
795 errcode
= target_read_memory (memaddr
, buf
, 1);
800 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
803 bytes
= bufptr
- buffer
;
804 buffer_allocated
*= 2;
805 buffer
= xrealloc (buffer
, buffer_allocated
);
806 bufptr
= buffer
+ bytes
;
809 for (i
= 0; i
< tlen
; i
++)
811 *bufptr
++ = buf
[i
+ offset
];
812 if (buf
[i
+ offset
] == '\000')
814 nbytes_read
+= i
+ 1;
831 /* Find a section containing ADDR. */
832 struct section_table
*
833 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
835 struct section_table
*secp
;
836 for (secp
= target
->to_sections
;
837 secp
< target
->to_sections_end
;
840 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
846 /* Return non-zero when the target vector has supplied an xfer_partial
847 method and it, rather than xfer_memory, should be used. */
849 target_xfer_partial_p (void)
851 return (target_stack
!= NULL
852 && target_stack
->to_xfer_partial
!= default_xfer_partial
);
856 target_xfer_partial (struct target_ops
*ops
,
857 enum target_object object
, const char *annex
,
858 void *readbuf
, const void *writebuf
,
859 ULONGEST offset
, LONGEST len
)
863 gdb_assert (ops
->to_xfer_partial
!= NULL
);
864 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
868 const unsigned char *myaddr
= NULL
;
870 fprintf_unfiltered (gdb_stdlog
,
871 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
874 (annex
? annex
: "(null)"),
875 (long) readbuf
, (long) writebuf
,
876 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
882 if (retval
> 0 && myaddr
!= NULL
)
886 fputs_unfiltered (", bytes =", gdb_stdlog
);
887 for (i
= 0; i
< retval
; i
++)
889 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
891 if (targetdebug
< 2 && i
> 0)
893 fprintf_unfiltered (gdb_stdlog
, " ...");
896 fprintf_unfiltered (gdb_stdlog
, "\n");
899 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
903 fputc_unfiltered ('\n', gdb_stdlog
);
908 /* Attempt a transfer all LEN bytes starting at OFFSET between the
909 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
910 the transfer succeeds, return zero, otherwize the host ERRNO is
913 The inferior is formed from several layers. In the case of
914 corefiles, inf-corefile is layered above inf-exec and a request for
915 text (corefiles do not include text pages) will be first sent to
916 the core-stratum, fail, and then sent to the object-file where it
919 NOTE: cagney/2004-09-30:
921 The old code tried to use four separate mechanisms for mapping an
922 object:offset:len tuple onto an inferior and its address space: the
923 target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
928 The code below is instead using a single mechanism (currently
929 strata). If that mechanism proves insufficient then re-factor it
930 implementing another singluar mechanism (for instance, a generic
931 object:annex onto inferior:object:annex say). */
934 xfer_using_stratum (enum target_object object
, const char *annex
,
935 ULONGEST offset
, LONGEST len
, void *readbuf
,
936 const void *writebuf
)
939 struct target_ops
*target
;
941 /* Always successful. */
944 /* Never successful. */
945 if (target_stack
== NULL
)
948 target
= target_stack
;
951 xfered
= target_xfer_partial (target
, object
, annex
,
952 readbuf
, writebuf
, offset
, len
);
955 /* The partial xfer succeeded, update the counts, check that
956 the xfer hasn't finished and if it hasn't set things up
957 for the next round. */
963 readbuf
= (gdb_byte
*) readbuf
+ xfered
;
964 if (writebuf
!= NULL
)
965 writebuf
= (gdb_byte
*) writebuf
+ xfered
;
966 target
= target_stack
;
970 /* Something totally screwed up, abandon the attempt to
979 /* This "stratum" didn't work, try the next one down. */
980 target
= target
->beneath
;
987 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
988 GDB's memory at MYADDR. Returns either 0 for success or an errno value
991 If an error occurs, no guarantee is made about the contents of the data at
992 MYADDR. In particular, the caller should not depend upon partial reads
993 filling the buffer with good data. There is no way for the caller to know
994 how much good data might have been transfered anyway. Callers that can
995 deal with partial reads should call target_read_memory_partial. */
998 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1000 if (target_xfer_partial_p ())
1001 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1002 memaddr
, len
, myaddr
, NULL
);
1004 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
1008 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1010 gdb_byte
*bytes
= alloca (len
);
1011 memcpy (bytes
, myaddr
, len
);
1012 if (target_xfer_partial_p ())
1013 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1014 memaddr
, len
, NULL
, bytes
);
1016 return target_xfer_memory (memaddr
, bytes
, len
, 1);
1019 #ifndef target_stopped_data_address_p
1021 target_stopped_data_address_p (struct target_ops
*target
)
1023 if (target
->to_stopped_data_address
1024 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1026 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1027 && (debug_target
.to_stopped_data_address
1028 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1034 static int trust_readonly
= 0;
1036 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1037 struct cmd_list_element
*c
, const char *value
)
1039 fprintf_filtered (file
, _("\
1040 Mode for reading from readonly sections is %s.\n"),
1044 /* Move memory to or from the targets. The top target gets priority;
1045 if it cannot handle it, it is offered to the next one down, etc.
1047 Result is -1 on error, or the number of bytes transfered. */
1050 do_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1051 struct mem_attrib
*attrib
)
1055 struct target_ops
*t
;
1057 /* Zero length requests are ok and require no work. */
1061 /* deprecated_xfer_memory is not guaranteed to set errno, even when
1065 if (!write
&& trust_readonly
)
1067 struct section_table
*secp
;
1068 /* User-settable option, "trust-readonly-sections". If true,
1069 then memory from any SEC_READONLY bfd section may be read
1070 directly from the bfd file. */
1071 secp
= target_section_by_addr (¤t_target
, memaddr
);
1073 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1075 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
1078 /* The quick case is that the top target can handle the transfer. */
1079 res
= current_target
.deprecated_xfer_memory
1080 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
1082 /* If res <= 0 then we call it again in the loop. Ah well. */
1085 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1087 if (!t
->to_has_memory
)
1090 res
= t
->deprecated_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1092 break; /* Handled all or part of xfer */
1093 if (t
->to_has_all_memory
)
1105 /* Perform a memory transfer. Iterate until the entire region has
1108 Result is 0 or errno value. */
1111 target_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
)
1115 struct mem_region
*region
;
1117 /* Zero length requests are ok and require no work. */
1125 region
= lookup_mem_region(memaddr
);
1126 if (memaddr
+ len
< region
->hi
)
1129 reg_len
= region
->hi
- memaddr
;
1131 switch (region
->attrib
.mode
)
1146 if (region
->attrib
.cache
)
1147 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1150 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1155 /* If this address is for nonexistent memory, read zeros
1156 if reading, or do nothing if writing. Return
1159 memset (myaddr
, 0, len
);
1173 return 0; /* We managed to cover it all somehow. */
1177 /* Perform a partial memory transfer.
1179 If we succeed, set *ERR to zero and return the number of bytes transferred.
1180 If we fail, set *ERR to a non-zero errno value, and return -1. */
1183 target_xfer_memory_partial (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
1184 int write_p
, int *err
)
1188 struct mem_region
*region
;
1190 /* Zero length requests are ok and require no work. */
1197 region
= lookup_mem_region(memaddr
);
1198 if (memaddr
+ len
< region
->hi
)
1201 reg_len
= region
->hi
- memaddr
;
1203 switch (region
->attrib
.mode
)
1222 if (region
->attrib
.cache
)
1223 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1226 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1244 target_read_memory_partial (CORE_ADDR memaddr
, gdb_byte
*buf
,
1247 if (target_xfer_partial_p ())
1251 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1252 NULL
, buf
, NULL
, memaddr
, len
);
1269 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1273 target_write_memory_partial (CORE_ADDR memaddr
, gdb_byte
*buf
,
1276 if (target_xfer_partial_p ())
1280 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1281 NULL
, NULL
, buf
, memaddr
, len
);
1298 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1301 /* More generic transfers. */
1304 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1305 const char *annex
, gdb_byte
*readbuf
,
1306 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1308 if (object
== TARGET_OBJECT_MEMORY
1309 && ops
->deprecated_xfer_memory
!= NULL
)
1310 /* If available, fall back to the target's
1311 "deprecated_xfer_memory" method. */
1315 if (writebuf
!= NULL
)
1317 void *buffer
= xmalloc (len
);
1318 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1319 memcpy (buffer
, writebuf
, len
);
1320 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1321 1/*write*/, NULL
, ops
);
1322 do_cleanups (cleanup
);
1324 if (readbuf
!= NULL
)
1325 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1329 else if (xfered
== 0 && errno
== 0)
1330 /* "deprecated_xfer_memory" uses 0, cross checked against
1331 ERRNO as one indication of an error. */
1336 else if (ops
->beneath
!= NULL
)
1337 return target_xfer_partial (ops
->beneath
, object
, annex
,
1338 readbuf
, writebuf
, offset
, len
);
1343 /* Target vector read/write partial wrapper functions.
1345 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1346 (inbuf, outbuf)", instead of separate read/write methods, make life
1350 target_read_partial (struct target_ops
*ops
,
1351 enum target_object object
,
1352 const char *annex
, gdb_byte
*buf
,
1353 ULONGEST offset
, LONGEST len
)
1355 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1359 target_write_partial (struct target_ops
*ops
,
1360 enum target_object object
,
1361 const char *annex
, const gdb_byte
*buf
,
1362 ULONGEST offset
, LONGEST len
)
1364 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1367 /* Wrappers to perform the full transfer. */
1369 target_read (struct target_ops
*ops
,
1370 enum target_object object
,
1371 const char *annex
, gdb_byte
*buf
,
1372 ULONGEST offset
, LONGEST len
)
1375 while (xfered
< len
)
1377 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1378 (gdb_byte
*) buf
+ xfered
,
1379 offset
+ xfered
, len
- xfered
);
1380 /* Call an observer, notifying them of the xfer progress? */
1382 /* Call memory_error? */
1391 target_write (struct target_ops
*ops
,
1392 enum target_object object
,
1393 const char *annex
, const gdb_byte
*buf
,
1394 ULONGEST offset
, LONGEST len
)
1397 while (xfered
< len
)
1399 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1400 (gdb_byte
*) buf
+ xfered
,
1401 offset
+ xfered
, len
- xfered
);
1402 /* Call an observer, notifying them of the xfer progress? */
1404 /* Call memory_error? */
1412 /* Memory transfer methods. */
1415 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1418 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1420 memory_error (EIO
, addr
);
1424 get_target_memory_unsigned (struct target_ops
*ops
,
1425 CORE_ADDR addr
, int len
)
1427 gdb_byte buf
[sizeof (ULONGEST
)];
1429 gdb_assert (len
<= sizeof (buf
));
1430 get_target_memory (ops
, addr
, buf
, len
);
1431 return extract_unsigned_integer (buf
, len
);
1435 target_info (char *args
, int from_tty
)
1437 struct target_ops
*t
;
1438 int has_all_mem
= 0;
1440 if (symfile_objfile
!= NULL
)
1441 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1443 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1445 if (!t
->to_has_memory
)
1448 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1451 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1452 printf_unfiltered ("%s:\n", t
->to_longname
);
1453 (t
->to_files_info
) (t
);
1454 has_all_mem
= t
->to_has_all_memory
;
1458 /* This is to be called by the open routine before it does
1462 target_preopen (int from_tty
)
1466 if (target_has_execution
)
1469 || query (_("A program is being debugged already. Kill it? ")))
1472 error (_("Program not killed."));
1475 /* Calling target_kill may remove the target from the stack. But if
1476 it doesn't (which seems like a win for UDI), remove it now. */
1478 if (target_has_execution
)
1482 /* Detach a target after doing deferred register stores. */
1485 target_detach (char *args
, int from_tty
)
1487 (current_target
.to_detach
) (args
, from_tty
);
1491 target_disconnect (char *args
, int from_tty
)
1493 (current_target
.to_disconnect
) (args
, from_tty
);
1497 target_async_mask (int mask
)
1499 int saved_async_masked_status
= target_async_mask_value
;
1500 target_async_mask_value
= mask
;
1501 return saved_async_masked_status
;
1504 /* Look through the list of possible targets for a target that can
1508 target_follow_fork (int follow_child
)
1510 struct target_ops
*t
;
1512 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1514 if (t
->to_follow_fork
!= NULL
)
1516 int retval
= t
->to_follow_fork (t
, follow_child
);
1518 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1519 follow_child
, retval
);
1524 /* Some target returned a fork event, but did not know how to follow it. */
1525 internal_error (__FILE__
, __LINE__
,
1526 "could not find a target to follow fork");
1529 /* Look through the list of possible targets for a target that can
1530 execute a run or attach command without any other data. This is
1531 used to locate the default process stratum.
1533 Result is always valid (error() is called for errors). */
1535 static struct target_ops
*
1536 find_default_run_target (char *do_mesg
)
1538 struct target_ops
**t
;
1539 struct target_ops
*runable
= NULL
;
1544 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1547 if ((*t
)->to_can_run
&& target_can_run (*t
))
1555 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1561 find_default_attach (char *args
, int from_tty
)
1563 struct target_ops
*t
;
1565 t
= find_default_run_target ("attach");
1566 (t
->to_attach
) (args
, from_tty
);
1571 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1574 struct target_ops
*t
;
1576 t
= find_default_run_target ("run");
1577 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1582 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1584 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1600 return_minus_one (void)
1606 * Resize the to_sections pointer. Also make sure that anyone that
1607 * was holding on to an old value of it gets updated.
1608 * Returns the old size.
1612 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1614 struct target_ops
**t
;
1615 struct section_table
*old_value
;
1618 old_value
= target
->to_sections
;
1620 if (target
->to_sections
)
1622 old_count
= target
->to_sections_end
- target
->to_sections
;
1623 target
->to_sections
= (struct section_table
*)
1624 xrealloc ((char *) target
->to_sections
,
1625 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1630 target
->to_sections
= (struct section_table
*)
1631 xmalloc ((sizeof (struct section_table
)) * num_added
);
1633 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1635 /* Check to see if anyone else was pointing to this structure.
1636 If old_value was null, then no one was. */
1640 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1643 if ((*t
)->to_sections
== old_value
)
1645 (*t
)->to_sections
= target
->to_sections
;
1646 (*t
)->to_sections_end
= target
->to_sections_end
;
1649 /* There is a flattened view of the target stack in current_target,
1650 so its to_sections pointer might also need updating. */
1651 if (current_target
.to_sections
== old_value
)
1653 current_target
.to_sections
= target
->to_sections
;
1654 current_target
.to_sections_end
= target
->to_sections_end
;
1662 /* Remove all target sections taken from ABFD.
1664 Scan the current target stack for targets whose section tables
1665 refer to sections from BFD, and remove those sections. We use this
1666 when we notice that the inferior has unloaded a shared object, for
1669 remove_target_sections (bfd
*abfd
)
1671 struct target_ops
**t
;
1673 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1675 struct section_table
*src
, *dest
;
1677 dest
= (*t
)->to_sections
;
1678 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1679 if (src
->bfd
!= abfd
)
1681 /* Keep this section. */
1682 if (dest
< src
) *dest
= *src
;
1686 /* If we've dropped any sections, resize the section table. */
1688 target_resize_to_sections (*t
, dest
- src
);
1695 /* Find a single runnable target in the stack and return it. If for
1696 some reason there is more than one, return NULL. */
1699 find_run_target (void)
1701 struct target_ops
**t
;
1702 struct target_ops
*runable
= NULL
;
1707 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1709 if ((*t
)->to_can_run
&& target_can_run (*t
))
1716 return (count
== 1 ? runable
: NULL
);
1719 /* Find a single core_stratum target in the list of targets and return it.
1720 If for some reason there is more than one, return NULL. */
1723 find_core_target (void)
1725 struct target_ops
**t
;
1726 struct target_ops
*runable
= NULL
;
1731 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1734 if ((*t
)->to_stratum
== core_stratum
)
1741 return (count
== 1 ? runable
: NULL
);
1745 * Find the next target down the stack from the specified target.
1749 find_target_beneath (struct target_ops
*t
)
1755 /* The inferior process has died. Long live the inferior! */
1758 generic_mourn_inferior (void)
1760 extern int show_breakpoint_hit_counts
;
1762 inferior_ptid
= null_ptid
;
1764 breakpoint_init_inferior (inf_exited
);
1765 registers_changed ();
1767 reopen_exec_file ();
1768 reinit_frame_cache ();
1770 /* It is confusing to the user for ignore counts to stick around
1771 from previous runs of the inferior. So clear them. */
1772 /* However, it is more confusing for the ignore counts to disappear when
1773 using hit counts. So don't clear them if we're counting hits. */
1774 if (!show_breakpoint_hit_counts
)
1775 breakpoint_clear_ignore_counts ();
1777 if (deprecated_detach_hook
)
1778 deprecated_detach_hook ();
1781 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1782 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1783 translation of that in OURSTATUS. */
1785 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1787 #ifdef CHILD_SPECIAL_WAITSTATUS
1788 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1789 if it wants to deal with hoststatus. */
1790 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1794 if (WIFEXITED (hoststatus
))
1796 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1797 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1799 else if (!WIFSTOPPED (hoststatus
))
1801 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1802 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1806 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1807 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1811 /* Returns zero to leave the inferior alone, one to interrupt it. */
1812 int (*target_activity_function
) (void);
1813 int target_activity_fd
;
1815 /* Convert a normal process ID to a string. Returns the string in a
1819 normal_pid_to_str (ptid_t ptid
)
1821 static char buf
[32];
1823 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1827 /* Error-catcher for target_find_memory_regions */
1828 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1830 error (_("No target."));
1834 /* Error-catcher for target_make_corefile_notes */
1835 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1837 error (_("No target."));
1841 /* Set up the handful of non-empty slots needed by the dummy target
1845 init_dummy_target (void)
1847 dummy_target
.to_shortname
= "None";
1848 dummy_target
.to_longname
= "None";
1849 dummy_target
.to_doc
= "";
1850 dummy_target
.to_attach
= find_default_attach
;
1851 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1852 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1853 dummy_target
.to_stratum
= dummy_stratum
;
1854 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1855 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1856 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1857 dummy_target
.to_magic
= OPS_MAGIC
;
1861 debug_to_open (char *args
, int from_tty
)
1863 debug_target
.to_open (args
, from_tty
);
1865 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1869 debug_to_close (int quitting
)
1871 target_close (&debug_target
, quitting
);
1872 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1876 target_close (struct target_ops
*targ
, int quitting
)
1878 if (targ
->to_xclose
!= NULL
)
1879 targ
->to_xclose (targ
, quitting
);
1880 else if (targ
->to_close
!= NULL
)
1881 targ
->to_close (quitting
);
1885 debug_to_attach (char *args
, int from_tty
)
1887 debug_target
.to_attach (args
, from_tty
);
1889 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1894 debug_to_post_attach (int pid
)
1896 debug_target
.to_post_attach (pid
);
1898 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1902 debug_to_detach (char *args
, int from_tty
)
1904 debug_target
.to_detach (args
, from_tty
);
1906 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1910 debug_to_disconnect (char *args
, int from_tty
)
1912 debug_target
.to_disconnect (args
, from_tty
);
1914 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1919 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1921 debug_target
.to_resume (ptid
, step
, siggnal
);
1923 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1924 step
? "step" : "continue",
1925 target_signal_to_name (siggnal
));
1929 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1933 retval
= debug_target
.to_wait (ptid
, status
);
1935 fprintf_unfiltered (gdb_stdlog
,
1936 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1938 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1939 switch (status
->kind
)
1941 case TARGET_WAITKIND_EXITED
:
1942 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1943 status
->value
.integer
);
1945 case TARGET_WAITKIND_STOPPED
:
1946 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1947 target_signal_to_name (status
->value
.sig
));
1949 case TARGET_WAITKIND_SIGNALLED
:
1950 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1951 target_signal_to_name (status
->value
.sig
));
1953 case TARGET_WAITKIND_LOADED
:
1954 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1956 case TARGET_WAITKIND_FORKED
:
1957 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1959 case TARGET_WAITKIND_VFORKED
:
1960 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1962 case TARGET_WAITKIND_EXECD
:
1963 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1965 case TARGET_WAITKIND_SPURIOUS
:
1966 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1969 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1977 debug_print_register (const char * func
, int regno
)
1979 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1980 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1981 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1982 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1984 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1988 unsigned char buf
[MAX_REGISTER_SIZE
];
1989 deprecated_read_register_gen (regno
, buf
);
1990 fprintf_unfiltered (gdb_stdlog
, " = ");
1991 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1993 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1995 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1997 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1998 paddr_nz (read_register (regno
)),
1999 paddr_d (read_register (regno
)));
2002 fprintf_unfiltered (gdb_stdlog
, "\n");
2006 debug_to_fetch_registers (int regno
)
2008 debug_target
.to_fetch_registers (regno
);
2009 debug_print_register ("target_fetch_registers", regno
);
2013 debug_to_store_registers (int regno
)
2015 debug_target
.to_store_registers (regno
);
2016 debug_print_register ("target_store_registers", regno
);
2017 fprintf_unfiltered (gdb_stdlog
, "\n");
2021 debug_to_prepare_to_store (void)
2023 debug_target
.to_prepare_to_store ();
2025 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2029 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2030 int write
, struct mem_attrib
*attrib
,
2031 struct target_ops
*target
)
2035 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2038 fprintf_unfiltered (gdb_stdlog
,
2039 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2040 (unsigned int) memaddr
, /* possable truncate long long */
2041 len
, write
? "write" : "read", retval
);
2047 fputs_unfiltered (", bytes =", gdb_stdlog
);
2048 for (i
= 0; i
< retval
; i
++)
2050 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2052 if (targetdebug
< 2 && i
> 0)
2054 fprintf_unfiltered (gdb_stdlog
, " ...");
2057 fprintf_unfiltered (gdb_stdlog
, "\n");
2060 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2064 fputc_unfiltered ('\n', gdb_stdlog
);
2070 debug_to_files_info (struct target_ops
*target
)
2072 debug_target
.to_files_info (target
);
2074 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2078 debug_to_insert_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2082 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2084 fprintf_unfiltered (gdb_stdlog
,
2085 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2086 (unsigned long) addr
,
2087 (unsigned long) retval
);
2092 debug_to_remove_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2096 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2098 fprintf_unfiltered (gdb_stdlog
,
2099 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2100 (unsigned long) addr
,
2101 (unsigned long) retval
);
2106 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2110 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2112 fprintf_unfiltered (gdb_stdlog
,
2113 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2114 (unsigned long) type
,
2115 (unsigned long) cnt
,
2116 (unsigned long) from_tty
,
2117 (unsigned long) retval
);
2122 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2126 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2128 fprintf_unfiltered (gdb_stdlog
,
2129 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2130 (unsigned long) addr
,
2131 (unsigned long) len
,
2132 (unsigned long) retval
);
2137 debug_to_stopped_by_watchpoint (void)
2141 retval
= debug_target
.to_stopped_by_watchpoint ();
2143 fprintf_unfiltered (gdb_stdlog
,
2144 "STOPPED_BY_WATCHPOINT () = %ld\n",
2145 (unsigned long) retval
);
2150 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2154 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2156 fprintf_unfiltered (gdb_stdlog
,
2157 "target_stopped_data_address ([0x%lx]) = %ld\n",
2158 (unsigned long)*addr
,
2159 (unsigned long)retval
);
2164 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2168 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2170 fprintf_unfiltered (gdb_stdlog
,
2171 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2172 (unsigned long) addr
,
2173 (unsigned long) retval
);
2178 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2182 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2184 fprintf_unfiltered (gdb_stdlog
,
2185 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2186 (unsigned long) addr
,
2187 (unsigned long) retval
);
2192 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2196 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2198 fprintf_unfiltered (gdb_stdlog
,
2199 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2200 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2205 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2209 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2211 fprintf_unfiltered (gdb_stdlog
,
2212 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2213 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2218 debug_to_terminal_init (void)
2220 debug_target
.to_terminal_init ();
2222 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2226 debug_to_terminal_inferior (void)
2228 debug_target
.to_terminal_inferior ();
2230 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2234 debug_to_terminal_ours_for_output (void)
2236 debug_target
.to_terminal_ours_for_output ();
2238 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2242 debug_to_terminal_ours (void)
2244 debug_target
.to_terminal_ours ();
2246 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2250 debug_to_terminal_save_ours (void)
2252 debug_target
.to_terminal_save_ours ();
2254 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2258 debug_to_terminal_info (char *arg
, int from_tty
)
2260 debug_target
.to_terminal_info (arg
, from_tty
);
2262 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2267 debug_to_kill (void)
2269 debug_target
.to_kill ();
2271 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2275 debug_to_load (char *args
, int from_tty
)
2277 debug_target
.to_load (args
, from_tty
);
2279 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2283 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2287 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2289 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2295 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2298 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2300 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2301 exec_file
, args
, from_tty
);
2305 debug_to_post_startup_inferior (ptid_t ptid
)
2307 debug_target
.to_post_startup_inferior (ptid
);
2309 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2314 debug_to_acknowledge_created_inferior (int pid
)
2316 debug_target
.to_acknowledge_created_inferior (pid
);
2318 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2323 debug_to_insert_fork_catchpoint (int pid
)
2325 debug_target
.to_insert_fork_catchpoint (pid
);
2327 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2332 debug_to_remove_fork_catchpoint (int pid
)
2336 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2338 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2345 debug_to_insert_vfork_catchpoint (int pid
)
2347 debug_target
.to_insert_vfork_catchpoint (pid
);
2349 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2354 debug_to_remove_vfork_catchpoint (int pid
)
2358 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2360 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2367 debug_to_insert_exec_catchpoint (int pid
)
2369 debug_target
.to_insert_exec_catchpoint (pid
);
2371 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2376 debug_to_remove_exec_catchpoint (int pid
)
2380 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2382 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2389 debug_to_reported_exec_events_per_exec_call (void)
2391 int reported_exec_events
;
2393 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2395 fprintf_unfiltered (gdb_stdlog
,
2396 "target_reported_exec_events_per_exec_call () = %d\n",
2397 reported_exec_events
);
2399 return reported_exec_events
;
2403 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2407 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2409 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2410 pid
, wait_status
, *exit_status
, has_exited
);
2416 debug_to_mourn_inferior (void)
2418 debug_target
.to_mourn_inferior ();
2420 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2424 debug_to_can_run (void)
2428 retval
= debug_target
.to_can_run ();
2430 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2436 debug_to_notice_signals (ptid_t ptid
)
2438 debug_target
.to_notice_signals (ptid
);
2440 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2445 debug_to_thread_alive (ptid_t ptid
)
2449 retval
= debug_target
.to_thread_alive (ptid
);
2451 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2452 PIDGET (ptid
), retval
);
2458 debug_to_find_new_threads (void)
2460 debug_target
.to_find_new_threads ();
2462 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2466 debug_to_stop (void)
2468 debug_target
.to_stop ();
2470 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2474 debug_to_rcmd (char *command
,
2475 struct ui_file
*outbuf
)
2477 debug_target
.to_rcmd (command
, outbuf
);
2478 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2481 static struct symtab_and_line
*
2482 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2484 struct symtab_and_line
*result
;
2485 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2486 fprintf_unfiltered (gdb_stdlog
,
2487 "target get_exception_callback_sal (%d, %d)\n",
2492 static struct exception_event_record
*
2493 debug_to_get_current_exception_event (void)
2495 struct exception_event_record
*result
;
2496 result
= debug_target
.to_get_current_exception_event ();
2497 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2502 debug_to_pid_to_exec_file (int pid
)
2506 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2508 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2515 setup_target_debug (void)
2517 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2519 current_target
.to_open
= debug_to_open
;
2520 current_target
.to_close
= debug_to_close
;
2521 current_target
.to_attach
= debug_to_attach
;
2522 current_target
.to_post_attach
= debug_to_post_attach
;
2523 current_target
.to_detach
= debug_to_detach
;
2524 current_target
.to_disconnect
= debug_to_disconnect
;
2525 current_target
.to_resume
= debug_to_resume
;
2526 current_target
.to_wait
= debug_to_wait
;
2527 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2528 current_target
.to_store_registers
= debug_to_store_registers
;
2529 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2530 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2531 current_target
.to_files_info
= debug_to_files_info
;
2532 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2533 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2534 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2535 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2536 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2537 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2538 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2539 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2540 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2541 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2542 current_target
.to_terminal_init
= debug_to_terminal_init
;
2543 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2544 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2545 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2546 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2547 current_target
.to_terminal_info
= debug_to_terminal_info
;
2548 current_target
.to_kill
= debug_to_kill
;
2549 current_target
.to_load
= debug_to_load
;
2550 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2551 current_target
.to_create_inferior
= debug_to_create_inferior
;
2552 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2553 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2554 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2555 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2556 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2557 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2558 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2559 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2560 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2561 current_target
.to_has_exited
= debug_to_has_exited
;
2562 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2563 current_target
.to_can_run
= debug_to_can_run
;
2564 current_target
.to_notice_signals
= debug_to_notice_signals
;
2565 current_target
.to_thread_alive
= debug_to_thread_alive
;
2566 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2567 current_target
.to_stop
= debug_to_stop
;
2568 current_target
.to_rcmd
= debug_to_rcmd
;
2569 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2570 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2571 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2576 static char targ_desc
[] =
2577 "Names of targets and files being debugged.\n\
2578 Shows the entire stack of targets currently in use (including the exec-file,\n\
2579 core-file, and process, if any), as well as the symbol file name.";
2582 do_monitor_command (char *cmd
,
2585 if ((current_target
.to_rcmd
2586 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2587 || (current_target
.to_rcmd
== debug_to_rcmd
2588 && (debug_target
.to_rcmd
2589 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2590 error (_("\"monitor\" command not supported by this target."));
2591 target_rcmd (cmd
, gdb_stdtarg
);
2595 initialize_targets (void)
2597 init_dummy_target ();
2598 push_target (&dummy_target
);
2600 add_info ("target", target_info
, targ_desc
);
2601 add_info ("files", target_info
, targ_desc
);
2603 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2604 Set target debugging."), _("\
2605 Show target debugging."), _("\
2606 When non-zero, target debugging is enabled. Higher numbers are more\n\
2607 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2611 &setdebuglist
, &showdebuglist
);
2613 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2614 &trust_readonly
, _("\
2615 Set mode for reading from readonly sections."), _("\
2616 Show mode for reading from readonly sections."), _("\
2617 When this mode is on, memory reads from readonly sections (such as .text)\n\
2618 will be read from the object file instead of from the target. This will\n\
2619 result in significant performance improvement for remote targets."),
2621 show_trust_readonly
,
2622 &setlist
, &showlist
);
2624 add_com ("monitor", class_obscure
, do_monitor_command
,
2625 _("Send a command to the remote monitor (remote targets only)."));
2627 target_dcache
= dcache_init ();