1 /* Select target systems and architectures at runtime for GDB.
3 Copyright 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., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, 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 Result is -1 on error, or the number of bytes transfered. */
1181 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1182 int write_p
, int *err
)
1186 struct mem_region
*region
;
1188 /* Zero length requests are ok and require no work. */
1195 region
= lookup_mem_region(memaddr
);
1196 if (memaddr
+ len
< region
->hi
)
1199 reg_len
= region
->hi
- memaddr
;
1201 switch (region
->attrib
.mode
)
1220 if (region
->attrib
.cache
)
1221 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1224 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1242 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1244 if (target_xfer_partial_p ())
1248 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1249 NULL
, buf
, NULL
, memaddr
, len
);
1266 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1270 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1272 if (target_xfer_partial_p ())
1276 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1277 NULL
, NULL
, buf
, memaddr
, len
);
1294 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1297 /* More generic transfers. */
1300 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1301 const char *annex
, gdb_byte
*readbuf
,
1302 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1304 if (object
== TARGET_OBJECT_MEMORY
1305 && ops
->deprecated_xfer_memory
!= NULL
)
1306 /* If available, fall back to the target's
1307 "deprecated_xfer_memory" method. */
1311 if (writebuf
!= NULL
)
1313 void *buffer
= xmalloc (len
);
1314 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1315 memcpy (buffer
, writebuf
, len
);
1316 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1317 1/*write*/, NULL
, ops
);
1318 do_cleanups (cleanup
);
1320 if (readbuf
!= NULL
)
1321 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1325 else if (xfered
== 0 && errno
== 0)
1326 /* "deprecated_xfer_memory" uses 0, cross checked against
1327 ERRNO as one indication of an error. */
1332 else if (ops
->beneath
!= NULL
)
1333 return target_xfer_partial (ops
->beneath
, object
, annex
,
1334 readbuf
, writebuf
, offset
, len
);
1339 /* Target vector read/write partial wrapper functions.
1341 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1342 (inbuf, outbuf)", instead of separate read/write methods, make life
1346 target_read_partial (struct target_ops
*ops
,
1347 enum target_object object
,
1348 const char *annex
, gdb_byte
*buf
,
1349 ULONGEST offset
, LONGEST len
)
1351 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1355 target_write_partial (struct target_ops
*ops
,
1356 enum target_object object
,
1357 const char *annex
, const gdb_byte
*buf
,
1358 ULONGEST offset
, LONGEST len
)
1360 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1363 /* Wrappers to perform the full transfer. */
1365 target_read (struct target_ops
*ops
,
1366 enum target_object object
,
1367 const char *annex
, gdb_byte
*buf
,
1368 ULONGEST offset
, LONGEST len
)
1371 while (xfered
< len
)
1373 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1374 (gdb_byte
*) buf
+ xfered
,
1375 offset
+ xfered
, len
- xfered
);
1376 /* Call an observer, notifying them of the xfer progress? */
1378 /* Call memory_error? */
1387 target_write (struct target_ops
*ops
,
1388 enum target_object object
,
1389 const char *annex
, const gdb_byte
*buf
,
1390 ULONGEST offset
, LONGEST len
)
1393 while (xfered
< len
)
1395 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1396 (gdb_byte
*) buf
+ xfered
,
1397 offset
+ xfered
, len
- xfered
);
1398 /* Call an observer, notifying them of the xfer progress? */
1400 /* Call memory_error? */
1408 /* Memory transfer methods. */
1411 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1414 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1416 memory_error (EIO
, addr
);
1420 get_target_memory_unsigned (struct target_ops
*ops
,
1421 CORE_ADDR addr
, int len
)
1423 char buf
[sizeof (ULONGEST
)];
1425 gdb_assert (len
<= sizeof (buf
));
1426 get_target_memory (ops
, addr
, buf
, len
);
1427 return extract_unsigned_integer (buf
, len
);
1431 target_info (char *args
, int from_tty
)
1433 struct target_ops
*t
;
1434 int has_all_mem
= 0;
1436 if (symfile_objfile
!= NULL
)
1437 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1439 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1441 if (!t
->to_has_memory
)
1444 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1447 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1448 printf_unfiltered ("%s:\n", t
->to_longname
);
1449 (t
->to_files_info
) (t
);
1450 has_all_mem
= t
->to_has_all_memory
;
1454 /* This is to be called by the open routine before it does
1458 target_preopen (int from_tty
)
1462 if (target_has_execution
)
1465 || query (_("A program is being debugged already. Kill it? ")))
1468 error (_("Program not killed."));
1471 /* Calling target_kill may remove the target from the stack. But if
1472 it doesn't (which seems like a win for UDI), remove it now. */
1474 if (target_has_execution
)
1478 /* Detach a target after doing deferred register stores. */
1481 target_detach (char *args
, int from_tty
)
1483 (current_target
.to_detach
) (args
, from_tty
);
1487 target_disconnect (char *args
, int from_tty
)
1489 (current_target
.to_disconnect
) (args
, from_tty
);
1493 target_async_mask (int mask
)
1495 int saved_async_masked_status
= target_async_mask_value
;
1496 target_async_mask_value
= mask
;
1497 return saved_async_masked_status
;
1500 /* Look through the list of possible targets for a target that can
1504 target_follow_fork (int follow_child
)
1506 struct target_ops
*t
;
1508 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1510 if (t
->to_follow_fork
!= NULL
)
1512 int retval
= t
->to_follow_fork (t
, follow_child
);
1514 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1515 follow_child
, retval
);
1520 /* Some target returned a fork event, but did not know how to follow it. */
1521 internal_error (__FILE__
, __LINE__
,
1522 "could not find a target to follow fork");
1525 /* Look through the list of possible targets for a target that can
1526 execute a run or attach command without any other data. This is
1527 used to locate the default process stratum.
1529 Result is always valid (error() is called for errors). */
1531 static struct target_ops
*
1532 find_default_run_target (char *do_mesg
)
1534 struct target_ops
**t
;
1535 struct target_ops
*runable
= NULL
;
1540 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1543 if ((*t
)->to_can_run
&& target_can_run (*t
))
1551 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1557 find_default_attach (char *args
, int from_tty
)
1559 struct target_ops
*t
;
1561 t
= find_default_run_target ("attach");
1562 (t
->to_attach
) (args
, from_tty
);
1567 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1570 struct target_ops
*t
;
1572 t
= find_default_run_target ("run");
1573 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1578 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1580 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1596 return_minus_one (void)
1602 * Resize the to_sections pointer. Also make sure that anyone that
1603 * was holding on to an old value of it gets updated.
1604 * Returns the old size.
1608 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1610 struct target_ops
**t
;
1611 struct section_table
*old_value
;
1614 old_value
= target
->to_sections
;
1616 if (target
->to_sections
)
1618 old_count
= target
->to_sections_end
- target
->to_sections
;
1619 target
->to_sections
= (struct section_table
*)
1620 xrealloc ((char *) target
->to_sections
,
1621 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1626 target
->to_sections
= (struct section_table
*)
1627 xmalloc ((sizeof (struct section_table
)) * num_added
);
1629 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1631 /* Check to see if anyone else was pointing to this structure.
1632 If old_value was null, then no one was. */
1636 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1639 if ((*t
)->to_sections
== old_value
)
1641 (*t
)->to_sections
= target
->to_sections
;
1642 (*t
)->to_sections_end
= target
->to_sections_end
;
1645 /* There is a flattened view of the target stack in current_target,
1646 so its to_sections pointer might also need updating. */
1647 if (current_target
.to_sections
== old_value
)
1649 current_target
.to_sections
= target
->to_sections
;
1650 current_target
.to_sections_end
= target
->to_sections_end
;
1658 /* Remove all target sections taken from ABFD.
1660 Scan the current target stack for targets whose section tables
1661 refer to sections from BFD, and remove those sections. We use this
1662 when we notice that the inferior has unloaded a shared object, for
1665 remove_target_sections (bfd
*abfd
)
1667 struct target_ops
**t
;
1669 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1671 struct section_table
*src
, *dest
;
1673 dest
= (*t
)->to_sections
;
1674 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1675 if (src
->bfd
!= abfd
)
1677 /* Keep this section. */
1678 if (dest
< src
) *dest
= *src
;
1682 /* If we've dropped any sections, resize the section table. */
1684 target_resize_to_sections (*t
, dest
- src
);
1691 /* Find a single runnable target in the stack and return it. If for
1692 some reason there is more than one, return NULL. */
1695 find_run_target (void)
1697 struct target_ops
**t
;
1698 struct target_ops
*runable
= NULL
;
1703 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1705 if ((*t
)->to_can_run
&& target_can_run (*t
))
1712 return (count
== 1 ? runable
: NULL
);
1715 /* Find a single core_stratum target in the list of targets and return it.
1716 If for some reason there is more than one, return NULL. */
1719 find_core_target (void)
1721 struct target_ops
**t
;
1722 struct target_ops
*runable
= NULL
;
1727 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1730 if ((*t
)->to_stratum
== core_stratum
)
1737 return (count
== 1 ? runable
: NULL
);
1741 * Find the next target down the stack from the specified target.
1745 find_target_beneath (struct target_ops
*t
)
1751 /* The inferior process has died. Long live the inferior! */
1754 generic_mourn_inferior (void)
1756 extern int show_breakpoint_hit_counts
;
1758 inferior_ptid
= null_ptid
;
1760 breakpoint_init_inferior (inf_exited
);
1761 registers_changed ();
1763 reopen_exec_file ();
1764 reinit_frame_cache ();
1766 /* It is confusing to the user for ignore counts to stick around
1767 from previous runs of the inferior. So clear them. */
1768 /* However, it is more confusing for the ignore counts to disappear when
1769 using hit counts. So don't clear them if we're counting hits. */
1770 if (!show_breakpoint_hit_counts
)
1771 breakpoint_clear_ignore_counts ();
1773 if (deprecated_detach_hook
)
1774 deprecated_detach_hook ();
1777 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1778 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1779 translation of that in OURSTATUS. */
1781 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1783 #ifdef CHILD_SPECIAL_WAITSTATUS
1784 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1785 if it wants to deal with hoststatus. */
1786 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1790 if (WIFEXITED (hoststatus
))
1792 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1793 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1795 else if (!WIFSTOPPED (hoststatus
))
1797 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1798 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1802 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1803 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1807 /* Returns zero to leave the inferior alone, one to interrupt it. */
1808 int (*target_activity_function
) (void);
1809 int target_activity_fd
;
1811 /* Convert a normal process ID to a string. Returns the string in a
1815 normal_pid_to_str (ptid_t ptid
)
1817 static char buf
[32];
1819 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1823 /* Error-catcher for target_find_memory_regions */
1824 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1826 error (_("No target."));
1830 /* Error-catcher for target_make_corefile_notes */
1831 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1833 error (_("No target."));
1837 /* Set up the handful of non-empty slots needed by the dummy target
1841 init_dummy_target (void)
1843 dummy_target
.to_shortname
= "None";
1844 dummy_target
.to_longname
= "None";
1845 dummy_target
.to_doc
= "";
1846 dummy_target
.to_attach
= find_default_attach
;
1847 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1848 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1849 dummy_target
.to_stratum
= dummy_stratum
;
1850 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1851 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1852 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1853 dummy_target
.to_magic
= OPS_MAGIC
;
1857 debug_to_open (char *args
, int from_tty
)
1859 debug_target
.to_open (args
, from_tty
);
1861 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1865 debug_to_close (int quitting
)
1867 target_close (&debug_target
, quitting
);
1868 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1872 target_close (struct target_ops
*targ
, int quitting
)
1874 if (targ
->to_xclose
!= NULL
)
1875 targ
->to_xclose (targ
, quitting
);
1876 else if (targ
->to_close
!= NULL
)
1877 targ
->to_close (quitting
);
1881 debug_to_attach (char *args
, int from_tty
)
1883 debug_target
.to_attach (args
, from_tty
);
1885 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1890 debug_to_post_attach (int pid
)
1892 debug_target
.to_post_attach (pid
);
1894 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1898 debug_to_detach (char *args
, int from_tty
)
1900 debug_target
.to_detach (args
, from_tty
);
1902 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1906 debug_to_disconnect (char *args
, int from_tty
)
1908 debug_target
.to_disconnect (args
, from_tty
);
1910 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1915 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1917 debug_target
.to_resume (ptid
, step
, siggnal
);
1919 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1920 step
? "step" : "continue",
1921 target_signal_to_name (siggnal
));
1925 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1929 retval
= debug_target
.to_wait (ptid
, status
);
1931 fprintf_unfiltered (gdb_stdlog
,
1932 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1934 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1935 switch (status
->kind
)
1937 case TARGET_WAITKIND_EXITED
:
1938 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1939 status
->value
.integer
);
1941 case TARGET_WAITKIND_STOPPED
:
1942 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1943 target_signal_to_name (status
->value
.sig
));
1945 case TARGET_WAITKIND_SIGNALLED
:
1946 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1947 target_signal_to_name (status
->value
.sig
));
1949 case TARGET_WAITKIND_LOADED
:
1950 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1952 case TARGET_WAITKIND_FORKED
:
1953 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1955 case TARGET_WAITKIND_VFORKED
:
1956 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1958 case TARGET_WAITKIND_EXECD
:
1959 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1961 case TARGET_WAITKIND_SPURIOUS
:
1962 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1965 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1973 debug_print_register (const char * func
, int regno
)
1975 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1976 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1977 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1978 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1980 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1984 unsigned char buf
[MAX_REGISTER_SIZE
];
1985 deprecated_read_register_gen (regno
, buf
);
1986 fprintf_unfiltered (gdb_stdlog
, " = ");
1987 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1989 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1991 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1993 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1994 paddr_nz (read_register (regno
)),
1995 paddr_d (read_register (regno
)));
1998 fprintf_unfiltered (gdb_stdlog
, "\n");
2002 debug_to_fetch_registers (int regno
)
2004 debug_target
.to_fetch_registers (regno
);
2005 debug_print_register ("target_fetch_registers", regno
);
2009 debug_to_store_registers (int regno
)
2011 debug_target
.to_store_registers (regno
);
2012 debug_print_register ("target_store_registers", regno
);
2013 fprintf_unfiltered (gdb_stdlog
, "\n");
2017 debug_to_prepare_to_store (void)
2019 debug_target
.to_prepare_to_store ();
2021 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2025 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2026 int write
, struct mem_attrib
*attrib
,
2027 struct target_ops
*target
)
2031 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2034 fprintf_unfiltered (gdb_stdlog
,
2035 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2036 (unsigned int) memaddr
, /* possable truncate long long */
2037 len
, write
? "write" : "read", retval
);
2043 fputs_unfiltered (", bytes =", gdb_stdlog
);
2044 for (i
= 0; i
< retval
; i
++)
2046 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2048 if (targetdebug
< 2 && i
> 0)
2050 fprintf_unfiltered (gdb_stdlog
, " ...");
2053 fprintf_unfiltered (gdb_stdlog
, "\n");
2056 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2060 fputc_unfiltered ('\n', gdb_stdlog
);
2066 debug_to_files_info (struct target_ops
*target
)
2068 debug_target
.to_files_info (target
);
2070 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2074 debug_to_insert_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2078 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2080 fprintf_unfiltered (gdb_stdlog
,
2081 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2082 (unsigned long) addr
,
2083 (unsigned long) retval
);
2088 debug_to_remove_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2092 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2094 fprintf_unfiltered (gdb_stdlog
,
2095 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2096 (unsigned long) addr
,
2097 (unsigned long) retval
);
2102 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2106 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2108 fprintf_unfiltered (gdb_stdlog
,
2109 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2110 (unsigned long) type
,
2111 (unsigned long) cnt
,
2112 (unsigned long) from_tty
,
2113 (unsigned long) retval
);
2118 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
2122 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
2124 fprintf_unfiltered (gdb_stdlog
,
2125 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2126 (unsigned long) byte_count
,
2127 (unsigned long) retval
);
2132 debug_to_stopped_by_watchpoint (void)
2136 retval
= debug_target
.to_stopped_by_watchpoint ();
2138 fprintf_unfiltered (gdb_stdlog
,
2139 "STOPPED_BY_WATCHPOINT () = %ld\n",
2140 (unsigned long) retval
);
2145 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2149 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2151 fprintf_unfiltered (gdb_stdlog
,
2152 "target_stopped_data_address ([0x%lx]) = %ld\n",
2153 (unsigned long)*addr
,
2154 (unsigned long)retval
);
2159 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2163 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2165 fprintf_unfiltered (gdb_stdlog
,
2166 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2167 (unsigned long) addr
,
2168 (unsigned long) retval
);
2173 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, gdb_byte
*save
)
2177 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2179 fprintf_unfiltered (gdb_stdlog
,
2180 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2181 (unsigned long) addr
,
2182 (unsigned long) retval
);
2187 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2191 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2193 fprintf_unfiltered (gdb_stdlog
,
2194 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2195 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2200 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2204 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2206 fprintf_unfiltered (gdb_stdlog
,
2207 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2208 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2213 debug_to_terminal_init (void)
2215 debug_target
.to_terminal_init ();
2217 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2221 debug_to_terminal_inferior (void)
2223 debug_target
.to_terminal_inferior ();
2225 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2229 debug_to_terminal_ours_for_output (void)
2231 debug_target
.to_terminal_ours_for_output ();
2233 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2237 debug_to_terminal_ours (void)
2239 debug_target
.to_terminal_ours ();
2241 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2245 debug_to_terminal_save_ours (void)
2247 debug_target
.to_terminal_save_ours ();
2249 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2253 debug_to_terminal_info (char *arg
, int from_tty
)
2255 debug_target
.to_terminal_info (arg
, from_tty
);
2257 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2262 debug_to_kill (void)
2264 debug_target
.to_kill ();
2266 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2270 debug_to_load (char *args
, int from_tty
)
2272 debug_target
.to_load (args
, from_tty
);
2274 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2278 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2282 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2284 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2290 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2293 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2295 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2296 exec_file
, args
, from_tty
);
2300 debug_to_post_startup_inferior (ptid_t ptid
)
2302 debug_target
.to_post_startup_inferior (ptid
);
2304 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2309 debug_to_acknowledge_created_inferior (int pid
)
2311 debug_target
.to_acknowledge_created_inferior (pid
);
2313 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2318 debug_to_insert_fork_catchpoint (int pid
)
2320 debug_target
.to_insert_fork_catchpoint (pid
);
2322 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2327 debug_to_remove_fork_catchpoint (int pid
)
2331 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2333 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2340 debug_to_insert_vfork_catchpoint (int pid
)
2342 debug_target
.to_insert_vfork_catchpoint (pid
);
2344 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2349 debug_to_remove_vfork_catchpoint (int pid
)
2353 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2355 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2362 debug_to_insert_exec_catchpoint (int pid
)
2364 debug_target
.to_insert_exec_catchpoint (pid
);
2366 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2371 debug_to_remove_exec_catchpoint (int pid
)
2375 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2377 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2384 debug_to_reported_exec_events_per_exec_call (void)
2386 int reported_exec_events
;
2388 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2390 fprintf_unfiltered (gdb_stdlog
,
2391 "target_reported_exec_events_per_exec_call () = %d\n",
2392 reported_exec_events
);
2394 return reported_exec_events
;
2398 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2402 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2404 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2405 pid
, wait_status
, *exit_status
, has_exited
);
2411 debug_to_mourn_inferior (void)
2413 debug_target
.to_mourn_inferior ();
2415 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2419 debug_to_can_run (void)
2423 retval
= debug_target
.to_can_run ();
2425 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2431 debug_to_notice_signals (ptid_t ptid
)
2433 debug_target
.to_notice_signals (ptid
);
2435 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2440 debug_to_thread_alive (ptid_t ptid
)
2444 retval
= debug_target
.to_thread_alive (ptid
);
2446 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2447 PIDGET (ptid
), retval
);
2453 debug_to_find_new_threads (void)
2455 debug_target
.to_find_new_threads ();
2457 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2461 debug_to_stop (void)
2463 debug_target
.to_stop ();
2465 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2469 debug_to_rcmd (char *command
,
2470 struct ui_file
*outbuf
)
2472 debug_target
.to_rcmd (command
, outbuf
);
2473 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2476 static struct symtab_and_line
*
2477 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2479 struct symtab_and_line
*result
;
2480 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2481 fprintf_unfiltered (gdb_stdlog
,
2482 "target get_exception_callback_sal (%d, %d)\n",
2487 static struct exception_event_record
*
2488 debug_to_get_current_exception_event (void)
2490 struct exception_event_record
*result
;
2491 result
= debug_target
.to_get_current_exception_event ();
2492 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2497 debug_to_pid_to_exec_file (int pid
)
2501 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2503 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2510 setup_target_debug (void)
2512 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2514 current_target
.to_open
= debug_to_open
;
2515 current_target
.to_close
= debug_to_close
;
2516 current_target
.to_attach
= debug_to_attach
;
2517 current_target
.to_post_attach
= debug_to_post_attach
;
2518 current_target
.to_detach
= debug_to_detach
;
2519 current_target
.to_disconnect
= debug_to_disconnect
;
2520 current_target
.to_resume
= debug_to_resume
;
2521 current_target
.to_wait
= debug_to_wait
;
2522 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2523 current_target
.to_store_registers
= debug_to_store_registers
;
2524 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2525 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2526 current_target
.to_files_info
= debug_to_files_info
;
2527 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2528 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2529 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2530 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2531 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2532 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2533 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2534 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2535 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2536 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2537 current_target
.to_terminal_init
= debug_to_terminal_init
;
2538 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2539 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2540 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2541 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2542 current_target
.to_terminal_info
= debug_to_terminal_info
;
2543 current_target
.to_kill
= debug_to_kill
;
2544 current_target
.to_load
= debug_to_load
;
2545 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2546 current_target
.to_create_inferior
= debug_to_create_inferior
;
2547 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2548 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2549 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2550 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2551 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2552 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2553 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2554 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2555 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2556 current_target
.to_has_exited
= debug_to_has_exited
;
2557 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2558 current_target
.to_can_run
= debug_to_can_run
;
2559 current_target
.to_notice_signals
= debug_to_notice_signals
;
2560 current_target
.to_thread_alive
= debug_to_thread_alive
;
2561 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2562 current_target
.to_stop
= debug_to_stop
;
2563 current_target
.to_rcmd
= debug_to_rcmd
;
2564 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2565 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2566 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2571 static char targ_desc
[] =
2572 "Names of targets and files being debugged.\n\
2573 Shows the entire stack of targets currently in use (including the exec-file,\n\
2574 core-file, and process, if any), as well as the symbol file name.";
2577 do_monitor_command (char *cmd
,
2580 if ((current_target
.to_rcmd
2581 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2582 || (current_target
.to_rcmd
== debug_to_rcmd
2583 && (debug_target
.to_rcmd
2584 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2585 error (_("\"monitor\" command not supported by this target."));
2586 target_rcmd (cmd
, gdb_stdtarg
);
2590 initialize_targets (void)
2592 init_dummy_target ();
2593 push_target (&dummy_target
);
2595 add_info ("target", target_info
, targ_desc
);
2596 add_info ("files", target_info
, targ_desc
);
2598 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2599 Set target debugging."), _("\
2600 Show target debugging."), _("\
2601 When non-zero, target debugging is enabled. Higher numbers are more\n\
2602 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2606 &setdebuglist
, &showdebuglist
);
2608 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2609 &trust_readonly
, _("\
2610 Set mode for reading from readonly sections."), _("\
2611 Show mode for reading from readonly sections."), _("\
2612 When this mode is on, memory reads from readonly sections (such as .text)\n\
2613 will be read from the object file instead of from the target. This will\n\
2614 result in significant performance improvement for remote targets."),
2616 show_trust_readonly
,
2617 &setlist
, &showlist
);
2619 add_com ("monitor", class_obscure
, do_monitor_command
,
2620 _("Send a command to the remote monitor (remote targets only)."));
2622 target_dcache
= dcache_init ();