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 Free Software Foundation, Inc.
6 Contributed by Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
27 #include "gdb_string.h"
39 #include "gdb_assert.h"
42 static void target_info (char *, int);
44 static void maybe_kill_then_attach (char *, int);
46 static void kill_or_be_killed (int);
48 static void default_terminal_info (char *, int);
50 static int default_region_size_ok_for_hw_watchpoint (int);
52 static int nosymbol (char *, CORE_ADDR
*);
54 static void tcomplain (void);
56 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
58 static int return_zero (void);
60 static int return_one (void);
62 static int return_minus_one (void);
64 void target_ignore (void);
66 static void target_command (char *, int);
68 static struct target_ops
*find_default_run_target (char *);
70 static void nosupport_runtime (void);
72 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
73 enum target_object object
,
74 const char *annex
, gdb_byte
*readbuf
,
75 const gdb_byte
*writebuf
,
76 ULONGEST offset
, LONGEST len
);
78 /* Transfer LEN bytes between target address MEMADDR and GDB address
79 MYADDR. Returns 0 for success, errno code for failure (which
80 includes partial transfers -- if you want a more useful response to
81 partial transfers, try either target_read_memory_partial or
82 target_write_memory_partial). */
84 static int target_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
87 static void init_dummy_target (void);
89 static struct target_ops debug_target
;
91 static void debug_to_open (char *, int);
93 static void debug_to_close (int);
95 static void debug_to_attach (char *, int);
97 static void debug_to_detach (char *, int);
99 static void debug_to_disconnect (char *, int);
101 static void debug_to_resume (ptid_t
, int, enum target_signal
);
103 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
105 static void debug_to_fetch_registers (int);
107 static void debug_to_store_registers (int);
109 static void debug_to_prepare_to_store (void);
111 static void debug_to_files_info (struct target_ops
*);
113 static int debug_to_insert_breakpoint (CORE_ADDR
, gdb_byte
*);
115 static int debug_to_remove_breakpoint (CORE_ADDR
, gdb_byte
*);
117 static int debug_to_can_use_hw_breakpoint (int, int, int);
119 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, gdb_byte
*);
121 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, gdb_byte
*);
123 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
125 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_stopped_by_watchpoint (void);
129 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
131 static int debug_to_region_size_ok_for_hw_watchpoint (int);
133 static void debug_to_terminal_init (void);
135 static void debug_to_terminal_inferior (void);
137 static void debug_to_terminal_ours_for_output (void);
139 static void debug_to_terminal_save_ours (void);
141 static void debug_to_terminal_ours (void);
143 static void debug_to_terminal_info (char *, int);
145 static void debug_to_kill (void);
147 static void debug_to_load (char *, int);
149 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
151 static void debug_to_mourn_inferior (void);
153 static int debug_to_can_run (void);
155 static void debug_to_notice_signals (ptid_t
);
157 static int debug_to_thread_alive (ptid_t
);
159 static void debug_to_stop (void);
161 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
162 wierd and mysterious ways. Putting the variable here lets those
163 wierd and mysterious ways keep building while they are being
164 converted to the inferior inheritance structure. */
165 struct target_ops deprecated_child_ops
;
167 /* Pointer to array of target architecture structures; the size of the
168 array; the current index into the array; the allocated size of the
170 struct target_ops
**target_structs
;
171 unsigned target_struct_size
;
172 unsigned target_struct_index
;
173 unsigned target_struct_allocsize
;
174 #define DEFAULT_ALLOCSIZE 10
176 /* The initial current target, so that there is always a semi-valid
179 static struct target_ops dummy_target
;
181 /* Top of target stack. */
183 static struct target_ops
*target_stack
;
185 /* The target structure we are currently using to talk to a process
186 or file or whatever "inferior" we have. */
188 struct target_ops current_target
;
190 /* Command list for target. */
192 static struct cmd_list_element
*targetlist
= NULL
;
194 /* Nonzero if we are debugging an attached outside process
195 rather than an inferior. */
199 /* Non-zero if we want to see trace of target level stuff. */
201 static int targetdebug
= 0;
203 show_targetdebug (struct ui_file
*file
, int from_tty
,
204 struct cmd_list_element
*c
, const char *value
)
206 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
209 static void setup_target_debug (void);
211 DCACHE
*target_dcache
;
213 /* The user just typed 'target' without the name of a target. */
216 target_command (char *arg
, int from_tty
)
218 fputs_filtered ("Argument required (target name). Try `help target'\n",
222 /* Add a possible target architecture to the list. */
225 add_target (struct target_ops
*t
)
227 /* Provide default values for all "must have" methods. */
228 if (t
->to_xfer_partial
== NULL
)
229 t
->to_xfer_partial
= default_xfer_partial
;
233 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
234 target_structs
= (struct target_ops
**) xmalloc
235 (target_struct_allocsize
* sizeof (*target_structs
));
237 if (target_struct_size
>= target_struct_allocsize
)
239 target_struct_allocsize
*= 2;
240 target_structs
= (struct target_ops
**)
241 xrealloc ((char *) target_structs
,
242 target_struct_allocsize
* sizeof (*target_structs
));
244 target_structs
[target_struct_size
++] = t
;
246 if (targetlist
== NULL
)
247 add_prefix_cmd ("target", class_run
, target_command
, _("\
248 Connect to a target machine or process.\n\
249 The first argument is the type or protocol of the target machine.\n\
250 Remaining arguments are interpreted by the target protocol. For more\n\
251 information on the arguments for a particular protocol, type\n\
252 `help target ' followed by the protocol name."),
253 &targetlist
, "target ", 0, &cmdlist
);
254 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
265 target_load (char *arg
, int from_tty
)
267 dcache_invalidate (target_dcache
);
268 (*current_target
.to_load
) (arg
, from_tty
);
272 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
273 struct target_ops
*t
)
275 errno
= EIO
; /* Can't read/write this location */
276 return 0; /* No bytes handled */
282 error (_("You can't do that when your target is `%s'"),
283 current_target
.to_shortname
);
289 error (_("You can't do that without a process to debug."));
293 nosymbol (char *name
, CORE_ADDR
*addrp
)
295 return 1; /* Symbol does not exist in target env */
299 nosupport_runtime (void)
301 if (ptid_equal (inferior_ptid
, null_ptid
))
304 error (_("No run-time support for this"));
309 default_terminal_info (char *args
, int from_tty
)
311 printf_unfiltered (_("No saved terminal information.\n"));
314 /* This is the default target_create_inferior and target_attach function.
315 If the current target is executing, it asks whether to kill it off.
316 If this function returns without calling error(), it has killed off
317 the target, and the operation should be attempted. */
320 kill_or_be_killed (int from_tty
)
322 if (target_has_execution
)
324 printf_unfiltered (_("You are already running a program:\n"));
325 target_files_info ();
326 if (query ("Kill it? "))
329 if (target_has_execution
)
330 error (_("Killing the program did not help."));
335 error (_("Program not killed."));
342 maybe_kill_then_attach (char *args
, int from_tty
)
344 kill_or_be_killed (from_tty
);
345 target_attach (args
, from_tty
);
349 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
352 kill_or_be_killed (0);
353 target_create_inferior (exec
, args
, env
, from_tty
);
356 /* Go through the target stack from top to bottom, copying over zero
357 entries in current_target, then filling in still empty entries. In
358 effect, we are doing class inheritance through the pushed target
361 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
362 is currently implemented, is that it discards any knowledge of
363 which target an inherited method originally belonged to.
364 Consequently, new new target methods should instead explicitly and
365 locally search the target stack for the target that can handle the
369 update_current_target (void)
371 struct target_ops
*t
;
373 /* First, reset curren'ts contents. */
374 memset (¤t_target
, 0, sizeof (current_target
));
376 #define INHERIT(FIELD, TARGET) \
377 if (!current_target.FIELD) \
378 current_target.FIELD = (TARGET)->FIELD
380 for (t
= target_stack
; t
; t
= t
->beneath
)
382 INHERIT (to_shortname
, t
);
383 INHERIT (to_longname
, t
);
385 INHERIT (to_open
, t
);
386 INHERIT (to_close
, t
);
387 INHERIT (to_attach
, t
);
388 INHERIT (to_post_attach
, t
);
389 INHERIT (to_detach
, t
);
390 INHERIT (to_disconnect
, t
);
391 INHERIT (to_resume
, t
);
392 INHERIT (to_wait
, t
);
393 INHERIT (to_fetch_registers
, t
);
394 INHERIT (to_store_registers
, t
);
395 INHERIT (to_prepare_to_store
, t
);
396 INHERIT (deprecated_xfer_memory
, t
);
397 INHERIT (to_files_info
, t
);
398 INHERIT (to_insert_breakpoint
, t
);
399 INHERIT (to_remove_breakpoint
, t
);
400 INHERIT (to_can_use_hw_breakpoint
, t
);
401 INHERIT (to_insert_hw_breakpoint
, t
);
402 INHERIT (to_remove_hw_breakpoint
, t
);
403 INHERIT (to_insert_watchpoint
, t
);
404 INHERIT (to_remove_watchpoint
, t
);
405 INHERIT (to_stopped_data_address
, t
);
406 INHERIT (to_stopped_by_watchpoint
, t
);
407 INHERIT (to_have_continuable_watchpoint
, t
);
408 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
409 INHERIT (to_terminal_init
, t
);
410 INHERIT (to_terminal_inferior
, t
);
411 INHERIT (to_terminal_ours_for_output
, t
);
412 INHERIT (to_terminal_ours
, t
);
413 INHERIT (to_terminal_save_ours
, t
);
414 INHERIT (to_terminal_info
, t
);
415 INHERIT (to_kill
, t
);
416 INHERIT (to_load
, t
);
417 INHERIT (to_lookup_symbol
, t
);
418 INHERIT (to_create_inferior
, t
);
419 INHERIT (to_post_startup_inferior
, t
);
420 INHERIT (to_acknowledge_created_inferior
, t
);
421 INHERIT (to_insert_fork_catchpoint
, t
);
422 INHERIT (to_remove_fork_catchpoint
, t
);
423 INHERIT (to_insert_vfork_catchpoint
, t
);
424 INHERIT (to_remove_vfork_catchpoint
, t
);
425 /* Do not inherit to_follow_fork. */
426 INHERIT (to_insert_exec_catchpoint
, t
);
427 INHERIT (to_remove_exec_catchpoint
, t
);
428 INHERIT (to_reported_exec_events_per_exec_call
, t
);
429 INHERIT (to_has_exited
, t
);
430 INHERIT (to_mourn_inferior
, t
);
431 INHERIT (to_can_run
, t
);
432 INHERIT (to_notice_signals
, t
);
433 INHERIT (to_thread_alive
, t
);
434 INHERIT (to_find_new_threads
, t
);
435 INHERIT (to_pid_to_str
, t
);
436 INHERIT (to_extra_thread_info
, t
);
437 INHERIT (to_stop
, t
);
438 /* Do not inherit to_xfer_partial. */
439 INHERIT (to_rcmd
, t
);
440 INHERIT (to_enable_exception_callback
, t
);
441 INHERIT (to_get_current_exception_event
, t
);
442 INHERIT (to_pid_to_exec_file
, t
);
443 INHERIT (to_stratum
, t
);
444 INHERIT (to_has_all_memory
, t
);
445 INHERIT (to_has_memory
, t
);
446 INHERIT (to_has_stack
, t
);
447 INHERIT (to_has_registers
, t
);
448 INHERIT (to_has_execution
, t
);
449 INHERIT (to_has_thread_control
, t
);
450 INHERIT (to_sections
, t
);
451 INHERIT (to_sections_end
, t
);
452 INHERIT (to_can_async_p
, t
);
453 INHERIT (to_is_async_p
, t
);
454 INHERIT (to_async
, t
);
455 INHERIT (to_async_mask_value
, t
);
456 INHERIT (to_find_memory_regions
, t
);
457 INHERIT (to_make_corefile_notes
, t
);
458 INHERIT (to_get_thread_local_address
, t
);
459 INHERIT (to_magic
, t
);
463 /* Clean up a target struct so it no longer has any zero pointers in
464 it. Some entries are defaulted to a method that print an error,
465 others are hard-wired to a standard recursive default. */
467 #define de_fault(field, value) \
468 if (!current_target.field) \
469 current_target.field = value
472 (void (*) (char *, int))
478 maybe_kill_then_attach
);
479 de_fault (to_post_attach
,
483 (void (*) (char *, int))
485 de_fault (to_disconnect
,
486 (void (*) (char *, int))
489 (void (*) (ptid_t
, int, enum target_signal
))
492 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
494 de_fault (to_fetch_registers
,
497 de_fault (to_store_registers
,
500 de_fault (to_prepare_to_store
,
503 de_fault (deprecated_xfer_memory
,
504 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
506 de_fault (to_files_info
,
507 (void (*) (struct target_ops
*))
509 de_fault (to_insert_breakpoint
,
510 memory_insert_breakpoint
);
511 de_fault (to_remove_breakpoint
,
512 memory_remove_breakpoint
);
513 de_fault (to_can_use_hw_breakpoint
,
514 (int (*) (int, int, int))
516 de_fault (to_insert_hw_breakpoint
,
517 (int (*) (CORE_ADDR
, gdb_byte
*))
519 de_fault (to_remove_hw_breakpoint
,
520 (int (*) (CORE_ADDR
, gdb_byte
*))
522 de_fault (to_insert_watchpoint
,
523 (int (*) (CORE_ADDR
, int, int))
525 de_fault (to_remove_watchpoint
,
526 (int (*) (CORE_ADDR
, int, int))
528 de_fault (to_stopped_by_watchpoint
,
531 de_fault (to_stopped_data_address
,
532 (int (*) (struct target_ops
*, CORE_ADDR
*))
534 de_fault (to_region_size_ok_for_hw_watchpoint
,
535 default_region_size_ok_for_hw_watchpoint
);
536 de_fault (to_terminal_init
,
539 de_fault (to_terminal_inferior
,
542 de_fault (to_terminal_ours_for_output
,
545 de_fault (to_terminal_ours
,
548 de_fault (to_terminal_save_ours
,
551 de_fault (to_terminal_info
,
552 default_terminal_info
);
557 (void (*) (char *, int))
559 de_fault (to_lookup_symbol
,
560 (int (*) (char *, CORE_ADDR
*))
562 de_fault (to_create_inferior
,
563 maybe_kill_then_create_inferior
);
564 de_fault (to_post_startup_inferior
,
567 de_fault (to_acknowledge_created_inferior
,
570 de_fault (to_insert_fork_catchpoint
,
573 de_fault (to_remove_fork_catchpoint
,
576 de_fault (to_insert_vfork_catchpoint
,
579 de_fault (to_remove_vfork_catchpoint
,
582 de_fault (to_insert_exec_catchpoint
,
585 de_fault (to_remove_exec_catchpoint
,
588 de_fault (to_reported_exec_events_per_exec_call
,
591 de_fault (to_has_exited
,
592 (int (*) (int, int, int *))
594 de_fault (to_mourn_inferior
,
597 de_fault (to_can_run
,
599 de_fault (to_notice_signals
,
602 de_fault (to_thread_alive
,
605 de_fault (to_find_new_threads
,
608 de_fault (to_extra_thread_info
,
609 (char *(*) (struct thread_info
*))
614 current_target
.to_xfer_partial
= default_xfer_partial
;
616 (void (*) (char *, struct ui_file
*))
618 de_fault (to_enable_exception_callback
,
619 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
621 de_fault (to_get_current_exception_event
,
622 (struct exception_event_record
* (*) (void))
624 de_fault (to_pid_to_exec_file
,
627 de_fault (to_can_async_p
,
630 de_fault (to_is_async_p
,
634 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
638 /* Finally, position the target-stack beneath the squashed
639 "current_target". That way code looking for a non-inherited
640 target method can quickly and simply find it. */
641 current_target
.beneath
= target_stack
;
644 /* Push a new target type into the stack of the existing target accessors,
645 possibly superseding some of the existing accessors.
647 Result is zero if the pushed target ended up on top of the stack,
648 nonzero if at least one target is on top of it.
650 Rather than allow an empty stack, we always have the dummy target at
651 the bottom stratum, so we can call the function vectors without
655 push_target (struct target_ops
*t
)
657 struct target_ops
**cur
;
659 /* Check magic number. If wrong, it probably means someone changed
660 the struct definition, but not all the places that initialize one. */
661 if (t
->to_magic
!= OPS_MAGIC
)
663 fprintf_unfiltered (gdb_stderr
,
664 "Magic number of %s target struct wrong\n",
666 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
669 /* Find the proper stratum to install this target in. */
670 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
672 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
676 /* If there's already targets at this stratum, remove them. */
677 /* FIXME: cagney/2003-10-15: I think this should be poping all
678 targets to CUR, and not just those at this stratum level. */
679 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
681 /* There's already something at this stratum level. Close it,
682 and un-hook it from the stack. */
683 struct target_ops
*tmp
= (*cur
);
684 (*cur
) = (*cur
)->beneath
;
686 target_close (tmp
, 0);
689 /* We have removed all targets in our stratum, now add the new one. */
693 update_current_target ();
696 setup_target_debug ();
699 return (t
!= target_stack
);
702 /* Remove a target_ops vector from the stack, wherever it may be.
703 Return how many times it was removed (0 or 1). */
706 unpush_target (struct target_ops
*t
)
708 struct target_ops
**cur
;
709 struct target_ops
*tmp
;
711 /* Look for the specified target. Note that we assume that a target
712 can only occur once in the target stack. */
714 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
721 return 0; /* Didn't find target_ops, quit now */
723 /* NOTE: cagney/2003-12-06: In '94 the close call was made
724 unconditional by moving it to before the above check that the
725 target was in the target stack (something about "Change the way
726 pushing and popping of targets work to support target overlays
727 and inheritance"). This doesn't make much sense - only open
728 targets should be closed. */
731 /* Unchain the target */
733 (*cur
) = (*cur
)->beneath
;
736 update_current_target ();
744 target_close (¤t_target
, 0); /* Let it clean up */
745 if (unpush_target (target_stack
) == 1)
748 fprintf_unfiltered (gdb_stderr
,
749 "pop_target couldn't find target %s\n",
750 current_target
.to_shortname
);
751 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
755 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
757 /* target_read_string -- read a null terminated string, up to LEN bytes,
758 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
759 Set *STRING to a pointer to malloc'd memory containing the data; the caller
760 is responsible for freeing it. Return the number of bytes successfully
764 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
766 int tlen
, origlen
, offset
, i
;
770 int buffer_allocated
;
772 unsigned int nbytes_read
= 0;
774 /* Small for testing. */
775 buffer_allocated
= 4;
776 buffer
= xmalloc (buffer_allocated
);
783 tlen
= MIN (len
, 4 - (memaddr
& 3));
784 offset
= memaddr
& 3;
786 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
789 /* The transfer request might have crossed the boundary to an
790 unallocated region of memory. Retry the transfer, requesting
794 errcode
= target_read_memory (memaddr
, buf
, 1);
799 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
802 bytes
= bufptr
- buffer
;
803 buffer_allocated
*= 2;
804 buffer
= xrealloc (buffer
, buffer_allocated
);
805 bufptr
= buffer
+ bytes
;
808 for (i
= 0; i
< tlen
; i
++)
810 *bufptr
++ = buf
[i
+ offset
];
811 if (buf
[i
+ offset
] == '\000')
813 nbytes_read
+= i
+ 1;
830 /* Find a section containing ADDR. */
831 struct section_table
*
832 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
834 struct section_table
*secp
;
835 for (secp
= target
->to_sections
;
836 secp
< target
->to_sections_end
;
839 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
845 /* Return non-zero when the target vector has supplied an xfer_partial
846 method and it, rather than xfer_memory, should be used. */
848 target_xfer_partial_p (void)
850 return (target_stack
!= NULL
851 && target_stack
->to_xfer_partial
!= default_xfer_partial
);
855 target_xfer_partial (struct target_ops
*ops
,
856 enum target_object object
, const char *annex
,
857 void *readbuf
, const void *writebuf
,
858 ULONGEST offset
, LONGEST len
)
862 gdb_assert (ops
->to_xfer_partial
!= NULL
);
863 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
867 const unsigned char *myaddr
= NULL
;
869 fprintf_unfiltered (gdb_stdlog
,
870 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
873 (annex
? annex
: "(null)"),
874 (long) readbuf
, (long) writebuf
,
875 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
881 if (retval
> 0 && myaddr
!= NULL
)
885 fputs_unfiltered (", bytes =", gdb_stdlog
);
886 for (i
= 0; i
< retval
; i
++)
888 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
890 if (targetdebug
< 2 && i
> 0)
892 fprintf_unfiltered (gdb_stdlog
, " ...");
895 fprintf_unfiltered (gdb_stdlog
, "\n");
898 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
902 fputc_unfiltered ('\n', gdb_stdlog
);
907 /* Attempt a transfer all LEN bytes starting at OFFSET between the
908 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
909 the transfer succeeds, return zero, otherwize the host ERRNO is
912 The inferior is formed from several layers. In the case of
913 corefiles, inf-corefile is layered above inf-exec and a request for
914 text (corefiles do not include text pages) will be first sent to
915 the core-stratum, fail, and then sent to the object-file where it
918 NOTE: cagney/2004-09-30:
920 The old code tried to use four separate mechanisms for mapping an
921 object:offset:len tuple onto an inferior and its address space: the
922 target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
927 The code below is instead using a single mechanism (currently
928 strata). If that mechanism proves insufficient then re-factor it
929 implementing another singluar mechanism (for instance, a generic
930 object:annex onto inferior:object:annex say). */
933 xfer_using_stratum (enum target_object object
, const char *annex
,
934 ULONGEST offset
, LONGEST len
, void *readbuf
,
935 const void *writebuf
)
938 struct target_ops
*target
;
940 /* Always successful. */
943 /* Never successful. */
944 if (target_stack
== NULL
)
947 target
= target_stack
;
950 xfered
= target_xfer_partial (target
, object
, annex
,
951 readbuf
, writebuf
, offset
, len
);
954 /* The partial xfer succeeded, update the counts, check that
955 the xfer hasn't finished and if it hasn't set things up
956 for the next round. */
962 readbuf
= (gdb_byte
*) readbuf
+ xfered
;
963 if (writebuf
!= NULL
)
964 writebuf
= (gdb_byte
*) writebuf
+ xfered
;
965 target
= target_stack
;
969 /* Something totally screwed up, abandon the attempt to
978 /* This "stratum" didn't work, try the next one down. */
979 target
= target
->beneath
;
986 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
987 GDB's memory at MYADDR. Returns either 0 for success or an errno value
990 If an error occurs, no guarantee is made about the contents of the data at
991 MYADDR. In particular, the caller should not depend upon partial reads
992 filling the buffer with good data. There is no way for the caller to know
993 how much good data might have been transfered anyway. Callers that can
994 deal with partial reads should call target_read_memory_partial. */
997 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
999 if (target_xfer_partial_p ())
1000 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1001 memaddr
, len
, myaddr
, NULL
);
1003 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
1007 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1009 gdb_byte
*bytes
= alloca (len
);
1010 memcpy (bytes
, myaddr
, len
);
1011 if (target_xfer_partial_p ())
1012 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1013 memaddr
, len
, NULL
, bytes
);
1015 return target_xfer_memory (memaddr
, bytes
, len
, 1);
1018 #ifndef target_stopped_data_address_p
1020 target_stopped_data_address_p (struct target_ops
*target
)
1022 if (target
->to_stopped_data_address
1023 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1025 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1026 && (debug_target
.to_stopped_data_address
1027 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1033 static int trust_readonly
= 0;
1035 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1036 struct cmd_list_element
*c
, const char *value
)
1038 fprintf_filtered (file
, _("\
1039 Mode for reading from readonly sections is %s.\n"),
1043 /* Move memory to or from the targets. The top target gets priority;
1044 if it cannot handle it, it is offered to the next one down, etc.
1046 Result is -1 on error, or the number of bytes transfered. */
1049 do_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1050 struct mem_attrib
*attrib
)
1054 struct target_ops
*t
;
1056 /* Zero length requests are ok and require no work. */
1060 /* deprecated_xfer_memory is not guaranteed to set errno, even when
1064 if (!write
&& trust_readonly
)
1066 struct section_table
*secp
;
1067 /* User-settable option, "trust-readonly-sections". If true,
1068 then memory from any SEC_READONLY bfd section may be read
1069 directly from the bfd file. */
1070 secp
= target_section_by_addr (¤t_target
, memaddr
);
1072 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1074 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
1077 /* The quick case is that the top target can handle the transfer. */
1078 res
= current_target
.deprecated_xfer_memory
1079 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
1081 /* If res <= 0 then we call it again in the loop. Ah well. */
1084 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1086 if (!t
->to_has_memory
)
1089 res
= t
->deprecated_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1091 break; /* Handled all or part of xfer */
1092 if (t
->to_has_all_memory
)
1104 /* Perform a memory transfer. Iterate until the entire region has
1107 Result is 0 or errno value. */
1110 target_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
)
1114 struct mem_region
*region
;
1116 /* Zero length requests are ok and require no work. */
1124 region
= lookup_mem_region(memaddr
);
1125 if (memaddr
+ len
< region
->hi
)
1128 reg_len
= region
->hi
- memaddr
;
1130 switch (region
->attrib
.mode
)
1145 if (region
->attrib
.cache
)
1146 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1149 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1154 /* If this address is for nonexistent memory, read zeros
1155 if reading, or do nothing if writing. Return
1158 memset (myaddr
, 0, len
);
1172 return 0; /* We managed to cover it all somehow. */
1176 /* Perform a partial memory transfer.
1178 If we succeed, set *ERR to zero and return the number of bytes transferred.
1179 If we fail, set *ERR to a non-zero errno value, and return -1. */
1182 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1183 int write_p
, int *err
)
1187 struct mem_region
*region
;
1189 /* Zero length requests are ok and require no work. */
1196 region
= lookup_mem_region(memaddr
);
1197 if (memaddr
+ len
< region
->hi
)
1200 reg_len
= region
->hi
- memaddr
;
1202 switch (region
->attrib
.mode
)
1221 if (region
->attrib
.cache
)
1222 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1225 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1243 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1245 if (target_xfer_partial_p ())
1249 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1250 NULL
, buf
, NULL
, memaddr
, len
);
1267 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1271 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1273 if (target_xfer_partial_p ())
1277 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1278 NULL
, NULL
, buf
, memaddr
, len
);
1295 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1298 /* More generic transfers. */
1301 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1302 const char *annex
, gdb_byte
*readbuf
,
1303 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1305 if (object
== TARGET_OBJECT_MEMORY
1306 && ops
->deprecated_xfer_memory
!= NULL
)
1307 /* If available, fall back to the target's
1308 "deprecated_xfer_memory" method. */
1312 if (writebuf
!= NULL
)
1314 void *buffer
= xmalloc (len
);
1315 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1316 memcpy (buffer
, writebuf
, len
);
1317 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1318 1/*write*/, NULL
, ops
);
1319 do_cleanups (cleanup
);
1321 if (readbuf
!= NULL
)
1322 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1326 else if (xfered
== 0 && errno
== 0)
1327 /* "deprecated_xfer_memory" uses 0, cross checked against
1328 ERRNO as one indication of an error. */
1333 else if (ops
->beneath
!= NULL
)
1334 return target_xfer_partial (ops
->beneath
, object
, annex
,
1335 readbuf
, writebuf
, offset
, len
);
1340 /* Target vector read/write partial wrapper functions.
1342 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1343 (inbuf, outbuf)", instead of separate read/write methods, make life
1347 target_read_partial (struct target_ops
*ops
,
1348 enum target_object object
,
1349 const char *annex
, gdb_byte
*buf
,
1350 ULONGEST offset
, LONGEST len
)
1352 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1356 target_write_partial (struct target_ops
*ops
,
1357 enum target_object object
,
1358 const char *annex
, const gdb_byte
*buf
,
1359 ULONGEST offset
, LONGEST len
)
1361 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1364 /* Wrappers to perform the full transfer. */
1366 target_read (struct target_ops
*ops
,
1367 enum target_object object
,
1368 const char *annex
, gdb_byte
*buf
,
1369 ULONGEST offset
, LONGEST len
)
1372 while (xfered
< len
)
1374 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1375 (gdb_byte
*) buf
+ xfered
,
1376 offset
+ xfered
, len
- xfered
);
1377 /* Call an observer, notifying them of the xfer progress? */
1379 /* Call memory_error? */
1388 target_write (struct target_ops
*ops
,
1389 enum target_object object
,
1390 const char *annex
, const gdb_byte
*buf
,
1391 ULONGEST offset
, LONGEST len
)
1394 while (xfered
< len
)
1396 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1397 (gdb_byte
*) buf
+ xfered
,
1398 offset
+ xfered
, len
- xfered
);
1399 /* Call an observer, notifying them of the xfer progress? */
1401 /* Call memory_error? */
1409 /* Memory transfer methods. */
1412 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1415 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1417 memory_error (EIO
, addr
);
1421 get_target_memory_unsigned (struct target_ops
*ops
,
1422 CORE_ADDR addr
, int len
)
1424 char buf
[sizeof (ULONGEST
)];
1426 gdb_assert (len
<= sizeof (buf
));
1427 get_target_memory (ops
, addr
, buf
, len
);
1428 return extract_unsigned_integer (buf
, len
);
1432 target_info (char *args
, int from_tty
)
1434 struct target_ops
*t
;
1435 int has_all_mem
= 0;
1437 if (symfile_objfile
!= NULL
)
1438 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1440 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1442 if (!t
->to_has_memory
)
1445 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1448 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1449 printf_unfiltered ("%s:\n", t
->to_longname
);
1450 (t
->to_files_info
) (t
);
1451 has_all_mem
= t
->to_has_all_memory
;
1455 /* This is to be called by the open routine before it does
1459 target_preopen (int from_tty
)
1463 if (target_has_execution
)
1466 || query (_("A program is being debugged already. Kill it? ")))
1469 error (_("Program not killed."));
1472 /* Calling target_kill may remove the target from the stack. But if
1473 it doesn't (which seems like a win for UDI), remove it now. */
1475 if (target_has_execution
)
1479 /* Detach a target after doing deferred register stores. */
1482 target_detach (char *args
, int from_tty
)
1484 (current_target
.to_detach
) (args
, from_tty
);
1488 target_disconnect (char *args
, int from_tty
)
1490 (current_target
.to_disconnect
) (args
, from_tty
);
1494 target_async_mask (int mask
)
1496 int saved_async_masked_status
= target_async_mask_value
;
1497 target_async_mask_value
= mask
;
1498 return saved_async_masked_status
;
1501 /* Look through the list of possible targets for a target that can
1505 target_follow_fork (int follow_child
)
1507 struct target_ops
*t
;
1509 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1511 if (t
->to_follow_fork
!= NULL
)
1513 int retval
= t
->to_follow_fork (t
, follow_child
);
1515 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1516 follow_child
, retval
);
1521 /* Some target returned a fork event, but did not know how to follow it. */
1522 internal_error (__FILE__
, __LINE__
,
1523 "could not find a target to follow fork");
1526 /* Look through the list of possible targets for a target that can
1527 execute a run or attach command without any other data. This is
1528 used to locate the default process stratum.
1530 Result is always valid (error() is called for errors). */
1532 static struct target_ops
*
1533 find_default_run_target (char *do_mesg
)
1535 struct target_ops
**t
;
1536 struct target_ops
*runable
= NULL
;
1541 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1544 if ((*t
)->to_can_run
&& target_can_run (*t
))
1552 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1558 find_default_attach (char *args
, int from_tty
)
1560 struct target_ops
*t
;
1562 t
= find_default_run_target ("attach");
1563 (t
->to_attach
) (args
, from_tty
);
1568 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1571 struct target_ops
*t
;
1573 t
= find_default_run_target ("run");
1574 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1579 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1581 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1597 return_minus_one (void)
1603 * Resize the to_sections pointer. Also make sure that anyone that
1604 * was holding on to an old value of it gets updated.
1605 * Returns the old size.
1609 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1611 struct target_ops
**t
;
1612 struct section_table
*old_value
;
1615 old_value
= target
->to_sections
;
1617 if (target
->to_sections
)
1619 old_count
= target
->to_sections_end
- target
->to_sections
;
1620 target
->to_sections
= (struct section_table
*)
1621 xrealloc ((char *) target
->to_sections
,
1622 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1627 target
->to_sections
= (struct section_table
*)
1628 xmalloc ((sizeof (struct section_table
)) * num_added
);
1630 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1632 /* Check to see if anyone else was pointing to this structure.
1633 If old_value was null, then no one was. */
1637 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1640 if ((*t
)->to_sections
== old_value
)
1642 (*t
)->to_sections
= target
->to_sections
;
1643 (*t
)->to_sections_end
= target
->to_sections_end
;
1646 /* There is a flattened view of the target stack in current_target,
1647 so its to_sections pointer might also need updating. */
1648 if (current_target
.to_sections
== old_value
)
1650 current_target
.to_sections
= target
->to_sections
;
1651 current_target
.to_sections_end
= target
->to_sections_end
;
1659 /* Remove all target sections taken from ABFD.
1661 Scan the current target stack for targets whose section tables
1662 refer to sections from BFD, and remove those sections. We use this
1663 when we notice that the inferior has unloaded a shared object, for
1666 remove_target_sections (bfd
*abfd
)
1668 struct target_ops
**t
;
1670 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1672 struct section_table
*src
, *dest
;
1674 dest
= (*t
)->to_sections
;
1675 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1676 if (src
->bfd
!= abfd
)
1678 /* Keep this section. */
1679 if (dest
< src
) *dest
= *src
;
1683 /* If we've dropped any sections, resize the section table. */
1685 target_resize_to_sections (*t
, dest
- src
);
1692 /* Find a single runnable target in the stack and return it. If for
1693 some reason there is more than one, return NULL. */
1696 find_run_target (void)
1698 struct target_ops
**t
;
1699 struct target_ops
*runable
= NULL
;
1704 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1706 if ((*t
)->to_can_run
&& target_can_run (*t
))
1713 return (count
== 1 ? runable
: NULL
);
1716 /* Find a single core_stratum target in the list of targets and return it.
1717 If for some reason there is more than one, return NULL. */
1720 find_core_target (void)
1722 struct target_ops
**t
;
1723 struct target_ops
*runable
= NULL
;
1728 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1731 if ((*t
)->to_stratum
== core_stratum
)
1738 return (count
== 1 ? runable
: NULL
);
1742 * Find the next target down the stack from the specified target.
1746 find_target_beneath (struct target_ops
*t
)
1752 /* The inferior process has died. Long live the inferior! */
1755 generic_mourn_inferior (void)
1757 extern int show_breakpoint_hit_counts
;
1759 inferior_ptid
= null_ptid
;
1761 breakpoint_init_inferior (inf_exited
);
1762 registers_changed ();
1764 reopen_exec_file ();
1765 reinit_frame_cache ();
1767 /* It is confusing to the user for ignore counts to stick around
1768 from previous runs of the inferior. So clear them. */
1769 /* However, it is more confusing for the ignore counts to disappear when
1770 using hit counts. So don't clear them if we're counting hits. */
1771 if (!show_breakpoint_hit_counts
)
1772 breakpoint_clear_ignore_counts ();
1774 if (deprecated_detach_hook
)
1775 deprecated_detach_hook ();
1778 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1779 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1780 translation of that in OURSTATUS. */
1782 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1784 #ifdef CHILD_SPECIAL_WAITSTATUS
1785 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1786 if it wants to deal with hoststatus. */
1787 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1791 if (WIFEXITED (hoststatus
))
1793 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1794 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1796 else if (!WIFSTOPPED (hoststatus
))
1798 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1799 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1803 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1804 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1808 /* Returns zero to leave the inferior alone, one to interrupt it. */
1809 int (*target_activity_function
) (void);
1810 int target_activity_fd
;
1812 /* Convert a normal process ID to a string. Returns the string in a
1816 normal_pid_to_str (ptid_t ptid
)
1818 static char buf
[32];
1820 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1824 /* Error-catcher for target_find_memory_regions */
1825 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1827 error (_("No target."));
1831 /* Error-catcher for target_make_corefile_notes */
1832 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1834 error (_("No target."));
1838 /* Set up the handful of non-empty slots needed by the dummy target
1842 init_dummy_target (void)
1844 dummy_target
.to_shortname
= "None";
1845 dummy_target
.to_longname
= "None";
1846 dummy_target
.to_doc
= "";
1847 dummy_target
.to_attach
= find_default_attach
;
1848 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1849 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1850 dummy_target
.to_stratum
= dummy_stratum
;
1851 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1852 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1853 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1854 dummy_target
.to_magic
= OPS_MAGIC
;
1858 debug_to_open (char *args
, int from_tty
)
1860 debug_target
.to_open (args
, from_tty
);
1862 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1866 debug_to_close (int quitting
)
1868 target_close (&debug_target
, quitting
);
1869 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1873 target_close (struct target_ops
*targ
, int quitting
)
1875 if (targ
->to_xclose
!= NULL
)
1876 targ
->to_xclose (targ
, quitting
);
1877 else if (targ
->to_close
!= NULL
)
1878 targ
->to_close (quitting
);
1882 debug_to_attach (char *args
, int from_tty
)
1884 debug_target
.to_attach (args
, from_tty
);
1886 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1891 debug_to_post_attach (int pid
)
1893 debug_target
.to_post_attach (pid
);
1895 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1899 debug_to_detach (char *args
, int from_tty
)
1901 debug_target
.to_detach (args
, from_tty
);
1903 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1907 debug_to_disconnect (char *args
, int from_tty
)
1909 debug_target
.to_disconnect (args
, from_tty
);
1911 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1916 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1918 debug_target
.to_resume (ptid
, step
, siggnal
);
1920 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1921 step
? "step" : "continue",
1922 target_signal_to_name (siggnal
));
1926 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1930 retval
= debug_target
.to_wait (ptid
, status
);
1932 fprintf_unfiltered (gdb_stdlog
,
1933 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1935 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1936 switch (status
->kind
)
1938 case TARGET_WAITKIND_EXITED
:
1939 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1940 status
->value
.integer
);
1942 case TARGET_WAITKIND_STOPPED
:
1943 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1944 target_signal_to_name (status
->value
.sig
));
1946 case TARGET_WAITKIND_SIGNALLED
:
1947 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1948 target_signal_to_name (status
->value
.sig
));
1950 case TARGET_WAITKIND_LOADED
:
1951 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1953 case TARGET_WAITKIND_FORKED
:
1954 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1956 case TARGET_WAITKIND_VFORKED
:
1957 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1959 case TARGET_WAITKIND_EXECD
:
1960 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1962 case TARGET_WAITKIND_SPURIOUS
:
1963 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1966 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1974 debug_print_register (const char * func
, int regno
)
1976 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1977 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1978 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1979 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1981 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1985 unsigned char buf
[MAX_REGISTER_SIZE
];
1986 deprecated_read_register_gen (regno
, buf
);
1987 fprintf_unfiltered (gdb_stdlog
, " = ");
1988 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1990 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1992 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1994 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1995 paddr_nz (read_register (regno
)),
1996 paddr_d (read_register (regno
)));
1999 fprintf_unfiltered (gdb_stdlog
, "\n");
2003 debug_to_fetch_registers (int regno
)
2005 debug_target
.to_fetch_registers (regno
);
2006 debug_print_register ("target_fetch_registers", regno
);
2010 debug_to_store_registers (int regno
)
2012 debug_target
.to_store_registers (regno
);
2013 debug_print_register ("target_store_registers", regno
);
2014 fprintf_unfiltered (gdb_stdlog
, "\n");
2018 debug_to_prepare_to_store (void)
2020 debug_target
.to_prepare_to_store ();
2022 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2026 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2027 int write
, struct mem_attrib
*attrib
,
2028 struct target_ops
*target
)
2032 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2035 fprintf_unfiltered (gdb_stdlog
,
2036 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2037 (unsigned int) memaddr
, /* possable truncate long long */
2038 len
, write
? "write" : "read", retval
);
2044 fputs_unfiltered (", bytes =", gdb_stdlog
);
2045 for (i
= 0; i
< retval
; i
++)
2047 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2049 if (targetdebug
< 2 && i
> 0)
2051 fprintf_unfiltered (gdb_stdlog
, " ...");
2054 fprintf_unfiltered (gdb_stdlog
, "\n");
2057 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2061 fputc_unfiltered ('\n', gdb_stdlog
);
2067 debug_to_files_info (struct target_ops
*target
)
2069 debug_target
.to_files_info (target
);
2071 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2075 debug_to_insert_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2079 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2081 fprintf_unfiltered (gdb_stdlog
,
2082 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2083 (unsigned long) addr
,
2084 (unsigned long) retval
);
2089 debug_to_remove_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2093 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2095 fprintf_unfiltered (gdb_stdlog
,
2096 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2097 (unsigned long) addr
,
2098 (unsigned long) retval
);
2103 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2107 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2109 fprintf_unfiltered (gdb_stdlog
,
2110 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2111 (unsigned long) type
,
2112 (unsigned long) cnt
,
2113 (unsigned long) from_tty
,
2114 (unsigned long) retval
);
2119 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
2123 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
2125 fprintf_unfiltered (gdb_stdlog
,
2126 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2127 (unsigned long) byte_count
,
2128 (unsigned long) retval
);
2133 debug_to_stopped_by_watchpoint (void)
2137 retval
= debug_target
.to_stopped_by_watchpoint ();
2139 fprintf_unfiltered (gdb_stdlog
,
2140 "STOPPED_BY_WATCHPOINT () = %ld\n",
2141 (unsigned long) retval
);
2146 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2150 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2152 fprintf_unfiltered (gdb_stdlog
,
2153 "target_stopped_data_address ([0x%lx]) = %ld\n",
2154 (unsigned long)*addr
,
2155 (unsigned long)retval
);
2160 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2164 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2166 fprintf_unfiltered (gdb_stdlog
,
2167 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2168 (unsigned long) addr
,
2169 (unsigned long) retval
);
2174 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2178 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2180 fprintf_unfiltered (gdb_stdlog
,
2181 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2182 (unsigned long) addr
,
2183 (unsigned long) retval
);
2188 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2192 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2194 fprintf_unfiltered (gdb_stdlog
,
2195 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2196 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2201 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2205 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2207 fprintf_unfiltered (gdb_stdlog
,
2208 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2209 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2214 debug_to_terminal_init (void)
2216 debug_target
.to_terminal_init ();
2218 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2222 debug_to_terminal_inferior (void)
2224 debug_target
.to_terminal_inferior ();
2226 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2230 debug_to_terminal_ours_for_output (void)
2232 debug_target
.to_terminal_ours_for_output ();
2234 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2238 debug_to_terminal_ours (void)
2240 debug_target
.to_terminal_ours ();
2242 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2246 debug_to_terminal_save_ours (void)
2248 debug_target
.to_terminal_save_ours ();
2250 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2254 debug_to_terminal_info (char *arg
, int from_tty
)
2256 debug_target
.to_terminal_info (arg
, from_tty
);
2258 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2263 debug_to_kill (void)
2265 debug_target
.to_kill ();
2267 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2271 debug_to_load (char *args
, int from_tty
)
2273 debug_target
.to_load (args
, from_tty
);
2275 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2279 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2283 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2285 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2291 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2294 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2296 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2297 exec_file
, args
, from_tty
);
2301 debug_to_post_startup_inferior (ptid_t ptid
)
2303 debug_target
.to_post_startup_inferior (ptid
);
2305 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2310 debug_to_acknowledge_created_inferior (int pid
)
2312 debug_target
.to_acknowledge_created_inferior (pid
);
2314 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2319 debug_to_insert_fork_catchpoint (int pid
)
2321 debug_target
.to_insert_fork_catchpoint (pid
);
2323 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2328 debug_to_remove_fork_catchpoint (int pid
)
2332 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2334 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2341 debug_to_insert_vfork_catchpoint (int pid
)
2343 debug_target
.to_insert_vfork_catchpoint (pid
);
2345 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2350 debug_to_remove_vfork_catchpoint (int pid
)
2354 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2356 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2363 debug_to_insert_exec_catchpoint (int pid
)
2365 debug_target
.to_insert_exec_catchpoint (pid
);
2367 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2372 debug_to_remove_exec_catchpoint (int pid
)
2376 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2378 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2385 debug_to_reported_exec_events_per_exec_call (void)
2387 int reported_exec_events
;
2389 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2391 fprintf_unfiltered (gdb_stdlog
,
2392 "target_reported_exec_events_per_exec_call () = %d\n",
2393 reported_exec_events
);
2395 return reported_exec_events
;
2399 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2403 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2405 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2406 pid
, wait_status
, *exit_status
, has_exited
);
2412 debug_to_mourn_inferior (void)
2414 debug_target
.to_mourn_inferior ();
2416 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2420 debug_to_can_run (void)
2424 retval
= debug_target
.to_can_run ();
2426 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2432 debug_to_notice_signals (ptid_t ptid
)
2434 debug_target
.to_notice_signals (ptid
);
2436 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2441 debug_to_thread_alive (ptid_t ptid
)
2445 retval
= debug_target
.to_thread_alive (ptid
);
2447 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2448 PIDGET (ptid
), retval
);
2454 debug_to_find_new_threads (void)
2456 debug_target
.to_find_new_threads ();
2458 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2462 debug_to_stop (void)
2464 debug_target
.to_stop ();
2466 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2470 debug_to_rcmd (char *command
,
2471 struct ui_file
*outbuf
)
2473 debug_target
.to_rcmd (command
, outbuf
);
2474 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2477 static struct symtab_and_line
*
2478 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2480 struct symtab_and_line
*result
;
2481 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2482 fprintf_unfiltered (gdb_stdlog
,
2483 "target get_exception_callback_sal (%d, %d)\n",
2488 static struct exception_event_record
*
2489 debug_to_get_current_exception_event (void)
2491 struct exception_event_record
*result
;
2492 result
= debug_target
.to_get_current_exception_event ();
2493 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2498 debug_to_pid_to_exec_file (int pid
)
2502 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2504 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2511 setup_target_debug (void)
2513 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2515 current_target
.to_open
= debug_to_open
;
2516 current_target
.to_close
= debug_to_close
;
2517 current_target
.to_attach
= debug_to_attach
;
2518 current_target
.to_post_attach
= debug_to_post_attach
;
2519 current_target
.to_detach
= debug_to_detach
;
2520 current_target
.to_disconnect
= debug_to_disconnect
;
2521 current_target
.to_resume
= debug_to_resume
;
2522 current_target
.to_wait
= debug_to_wait
;
2523 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2524 current_target
.to_store_registers
= debug_to_store_registers
;
2525 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2526 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2527 current_target
.to_files_info
= debug_to_files_info
;
2528 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2529 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2530 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2531 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2532 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2533 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2534 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2535 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2536 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2537 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2538 current_target
.to_terminal_init
= debug_to_terminal_init
;
2539 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2540 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2541 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2542 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2543 current_target
.to_terminal_info
= debug_to_terminal_info
;
2544 current_target
.to_kill
= debug_to_kill
;
2545 current_target
.to_load
= debug_to_load
;
2546 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2547 current_target
.to_create_inferior
= debug_to_create_inferior
;
2548 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2549 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2550 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2551 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2552 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2553 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2554 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2555 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2556 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2557 current_target
.to_has_exited
= debug_to_has_exited
;
2558 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2559 current_target
.to_can_run
= debug_to_can_run
;
2560 current_target
.to_notice_signals
= debug_to_notice_signals
;
2561 current_target
.to_thread_alive
= debug_to_thread_alive
;
2562 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2563 current_target
.to_stop
= debug_to_stop
;
2564 current_target
.to_rcmd
= debug_to_rcmd
;
2565 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2566 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2567 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2572 static char targ_desc
[] =
2573 "Names of targets and files being debugged.\n\
2574 Shows the entire stack of targets currently in use (including the exec-file,\n\
2575 core-file, and process, if any), as well as the symbol file name.";
2578 do_monitor_command (char *cmd
,
2581 if ((current_target
.to_rcmd
2582 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2583 || (current_target
.to_rcmd
== debug_to_rcmd
2584 && (debug_target
.to_rcmd
2585 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2586 error (_("\"monitor\" command not supported by this target."));
2587 target_rcmd (cmd
, gdb_stdtarg
);
2591 initialize_targets (void)
2593 init_dummy_target ();
2594 push_target (&dummy_target
);
2596 add_info ("target", target_info
, targ_desc
);
2597 add_info ("files", target_info
, targ_desc
);
2599 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2600 Set target debugging."), _("\
2601 Show target debugging."), _("\
2602 When non-zero, target debugging is enabled. Higher numbers are more\n\
2603 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2607 &setdebuglist
, &showdebuglist
);
2609 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2610 &trust_readonly
, _("\
2611 Set mode for reading from readonly sections."), _("\
2612 Show mode for reading from readonly sections."), _("\
2613 When this mode is on, memory reads from readonly sections (such as .text)\n\
2614 will be read from the object file instead of from the target. This will\n\
2615 result in significant performance improvement for remote targets."),
2617 show_trust_readonly
,
2618 &setlist
, &showlist
);
2620 add_com ("monitor", class_obscure
, do_monitor_command
,
2621 _("Send a command to the remote monitor (remote targets only)."));
2623 target_dcache
= dcache_init ();