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
, void *readbuf
,
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
, char *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 int deprecated_debug_xfer_memory (CORE_ADDR
, char *, int, int,
113 struct target_ops
*);
115 static void debug_to_files_info (struct target_ops
*);
117 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
119 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
121 static int debug_to_can_use_hw_breakpoint (int, int, int);
123 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
125 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
127 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
131 static int debug_to_stopped_by_watchpoint (void);
133 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
135 static int debug_to_region_size_ok_for_hw_watchpoint (int);
137 static void debug_to_terminal_init (void);
139 static void debug_to_terminal_inferior (void);
141 static void debug_to_terminal_ours_for_output (void);
143 static void debug_to_terminal_save_ours (void);
145 static void debug_to_terminal_ours (void);
147 static void debug_to_terminal_info (char *, int);
149 static void debug_to_kill (void);
151 static void debug_to_load (char *, int);
153 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
155 static void debug_to_mourn_inferior (void);
157 static int debug_to_can_run (void);
159 static void debug_to_notice_signals (ptid_t
);
161 static int debug_to_thread_alive (ptid_t
);
163 static void debug_to_stop (void);
165 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
166 wierd and mysterious ways. Putting the variable here lets those
167 wierd and mysterious ways keep building while they are being
168 converted to the inferior inheritance structure. */
169 struct target_ops deprecated_child_ops
;
171 /* Pointer to array of target architecture structures; the size of the
172 array; the current index into the array; the allocated size of the
174 struct target_ops
**target_structs
;
175 unsigned target_struct_size
;
176 unsigned target_struct_index
;
177 unsigned target_struct_allocsize
;
178 #define DEFAULT_ALLOCSIZE 10
180 /* The initial current target, so that there is always a semi-valid
183 static struct target_ops dummy_target
;
185 /* Top of target stack. */
187 static struct target_ops
*target_stack
;
189 /* The target structure we are currently using to talk to a process
190 or file or whatever "inferior" we have. */
192 struct target_ops current_target
;
194 /* Command list for target. */
196 static struct cmd_list_element
*targetlist
= NULL
;
198 /* Nonzero if we are debugging an attached outside process
199 rather than an inferior. */
203 /* Non-zero if we want to see trace of target level stuff. */
205 static int targetdebug
= 0;
207 show_targetdebug (struct ui_file
*file
, int from_tty
,
208 struct cmd_list_element
*c
, const char *value
)
210 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
213 static void setup_target_debug (void);
215 DCACHE
*target_dcache
;
217 /* The user just typed 'target' without the name of a target. */
220 target_command (char *arg
, int from_tty
)
222 fputs_filtered ("Argument required (target name). Try `help target'\n",
226 /* Add a possible target architecture to the list. */
229 add_target (struct target_ops
*t
)
231 /* Provide default values for all "must have" methods. */
232 if (t
->to_xfer_partial
== NULL
)
233 t
->to_xfer_partial
= default_xfer_partial
;
237 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
238 target_structs
= (struct target_ops
**) xmalloc
239 (target_struct_allocsize
* sizeof (*target_structs
));
241 if (target_struct_size
>= target_struct_allocsize
)
243 target_struct_allocsize
*= 2;
244 target_structs
= (struct target_ops
**)
245 xrealloc ((char *) target_structs
,
246 target_struct_allocsize
* sizeof (*target_structs
));
248 target_structs
[target_struct_size
++] = t
;
250 if (targetlist
== NULL
)
251 add_prefix_cmd ("target", class_run
, target_command
, _("\
252 Connect to a target machine or process.\n\
253 The first argument is the type or protocol of the target machine.\n\
254 Remaining arguments are interpreted by the target protocol. For more\n\
255 information on the arguments for a particular protocol, type\n\
256 `help target ' followed by the protocol name."),
257 &targetlist
, "target ", 0, &cmdlist
);
258 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
269 target_load (char *arg
, int from_tty
)
271 dcache_invalidate (target_dcache
);
272 (*current_target
.to_load
) (arg
, from_tty
);
276 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
277 struct target_ops
*t
)
279 errno
= EIO
; /* Can't read/write this location */
280 return 0; /* No bytes handled */
286 error (_("You can't do that when your target is `%s'"),
287 current_target
.to_shortname
);
293 error (_("You can't do that without a process to debug."));
297 nosymbol (char *name
, CORE_ADDR
*addrp
)
299 return 1; /* Symbol does not exist in target env */
303 nosupport_runtime (void)
305 if (ptid_equal (inferior_ptid
, null_ptid
))
308 error (_("No run-time support for this"));
313 default_terminal_info (char *args
, int from_tty
)
315 printf_unfiltered (_("No saved terminal information.\n"));
318 /* This is the default target_create_inferior and target_attach function.
319 If the current target is executing, it asks whether to kill it off.
320 If this function returns without calling error(), it has killed off
321 the target, and the operation should be attempted. */
324 kill_or_be_killed (int from_tty
)
326 if (target_has_execution
)
328 printf_unfiltered (_("You are already running a program:\n"));
329 target_files_info ();
330 if (query ("Kill it? "))
333 if (target_has_execution
)
334 error (_("Killing the program did not help."));
339 error (_("Program not killed."));
346 maybe_kill_then_attach (char *args
, int from_tty
)
348 kill_or_be_killed (from_tty
);
349 target_attach (args
, from_tty
);
353 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
356 kill_or_be_killed (0);
357 target_create_inferior (exec
, args
, env
, from_tty
);
360 /* Go through the target stack from top to bottom, copying over zero
361 entries in current_target, then filling in still empty entries. In
362 effect, we are doing class inheritance through the pushed target
365 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
366 is currently implemented, is that it discards any knowledge of
367 which target an inherited method originally belonged to.
368 Consequently, new new target methods should instead explicitly and
369 locally search the target stack for the target that can handle the
373 update_current_target (void)
375 struct target_ops
*t
;
377 /* First, reset curren'ts contents. */
378 memset (¤t_target
, 0, sizeof (current_target
));
380 #define INHERIT(FIELD, TARGET) \
381 if (!current_target.FIELD) \
382 current_target.FIELD = (TARGET)->FIELD
384 for (t
= target_stack
; t
; t
= t
->beneath
)
386 INHERIT (to_shortname
, t
);
387 INHERIT (to_longname
, t
);
389 INHERIT (to_open
, t
);
390 INHERIT (to_close
, t
);
391 INHERIT (to_attach
, t
);
392 INHERIT (to_post_attach
, t
);
393 INHERIT (to_detach
, t
);
394 INHERIT (to_disconnect
, t
);
395 INHERIT (to_resume
, t
);
396 INHERIT (to_wait
, t
);
397 INHERIT (to_fetch_registers
, t
);
398 INHERIT (to_store_registers
, t
);
399 INHERIT (to_prepare_to_store
, t
);
400 INHERIT (deprecated_xfer_memory
, t
);
401 INHERIT (to_files_info
, t
);
402 INHERIT (to_insert_breakpoint
, t
);
403 INHERIT (to_remove_breakpoint
, t
);
404 INHERIT (to_can_use_hw_breakpoint
, t
);
405 INHERIT (to_insert_hw_breakpoint
, t
);
406 INHERIT (to_remove_hw_breakpoint
, t
);
407 INHERIT (to_insert_watchpoint
, t
);
408 INHERIT (to_remove_watchpoint
, t
);
409 INHERIT (to_stopped_data_address
, t
);
410 INHERIT (to_stopped_by_watchpoint
, t
);
411 INHERIT (to_have_continuable_watchpoint
, t
);
412 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
413 INHERIT (to_terminal_init
, t
);
414 INHERIT (to_terminal_inferior
, t
);
415 INHERIT (to_terminal_ours_for_output
, t
);
416 INHERIT (to_terminal_ours
, t
);
417 INHERIT (to_terminal_save_ours
, t
);
418 INHERIT (to_terminal_info
, t
);
419 INHERIT (to_kill
, t
);
420 INHERIT (to_load
, t
);
421 INHERIT (to_lookup_symbol
, t
);
422 INHERIT (to_create_inferior
, t
);
423 INHERIT (to_post_startup_inferior
, t
);
424 INHERIT (to_acknowledge_created_inferior
, t
);
425 INHERIT (to_insert_fork_catchpoint
, t
);
426 INHERIT (to_remove_fork_catchpoint
, t
);
427 INHERIT (to_insert_vfork_catchpoint
, t
);
428 INHERIT (to_remove_vfork_catchpoint
, t
);
429 INHERIT (to_follow_fork
, t
);
430 INHERIT (to_insert_exec_catchpoint
, t
);
431 INHERIT (to_remove_exec_catchpoint
, t
);
432 INHERIT (to_reported_exec_events_per_exec_call
, t
);
433 INHERIT (to_has_exited
, t
);
434 INHERIT (to_mourn_inferior
, t
);
435 INHERIT (to_can_run
, t
);
436 INHERIT (to_notice_signals
, t
);
437 INHERIT (to_thread_alive
, t
);
438 INHERIT (to_find_new_threads
, t
);
439 INHERIT (to_pid_to_str
, t
);
440 INHERIT (to_extra_thread_info
, t
);
441 INHERIT (to_stop
, t
);
442 /* Do not inherit to_xfer_partial. */
443 INHERIT (to_rcmd
, t
);
444 INHERIT (to_enable_exception_callback
, t
);
445 INHERIT (to_get_current_exception_event
, t
);
446 INHERIT (to_pid_to_exec_file
, t
);
447 INHERIT (to_stratum
, t
);
448 INHERIT (to_has_all_memory
, t
);
449 INHERIT (to_has_memory
, t
);
450 INHERIT (to_has_stack
, t
);
451 INHERIT (to_has_registers
, t
);
452 INHERIT (to_has_execution
, t
);
453 INHERIT (to_has_thread_control
, t
);
454 INHERIT (to_sections
, t
);
455 INHERIT (to_sections_end
, t
);
456 INHERIT (to_can_async_p
, t
);
457 INHERIT (to_is_async_p
, t
);
458 INHERIT (to_async
, t
);
459 INHERIT (to_async_mask_value
, t
);
460 INHERIT (to_find_memory_regions
, t
);
461 INHERIT (to_make_corefile_notes
, t
);
462 INHERIT (to_get_thread_local_address
, t
);
463 INHERIT (to_magic
, t
);
467 /* Clean up a target struct so it no longer has any zero pointers in
468 it. Some entries are defaulted to a method that print an error,
469 others are hard-wired to a standard recursive default. */
471 #define de_fault(field, value) \
472 if (!current_target.field) \
473 current_target.field = value
476 (void (*) (char *, int))
482 maybe_kill_then_attach
);
483 de_fault (to_post_attach
,
487 (void (*) (char *, int))
489 de_fault (to_disconnect
,
490 (void (*) (char *, int))
493 (void (*) (ptid_t
, int, enum target_signal
))
496 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
498 de_fault (to_fetch_registers
,
501 de_fault (to_store_registers
,
504 de_fault (to_prepare_to_store
,
507 de_fault (deprecated_xfer_memory
,
508 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
510 de_fault (to_files_info
,
511 (void (*) (struct target_ops
*))
513 de_fault (to_insert_breakpoint
,
514 memory_insert_breakpoint
);
515 de_fault (to_remove_breakpoint
,
516 memory_remove_breakpoint
);
517 de_fault (to_can_use_hw_breakpoint
,
518 (int (*) (int, int, int))
520 de_fault (to_insert_hw_breakpoint
,
521 (int (*) (CORE_ADDR
, char *))
523 de_fault (to_remove_hw_breakpoint
,
524 (int (*) (CORE_ADDR
, char *))
526 de_fault (to_insert_watchpoint
,
527 (int (*) (CORE_ADDR
, int, int))
529 de_fault (to_remove_watchpoint
,
530 (int (*) (CORE_ADDR
, int, int))
532 de_fault (to_stopped_by_watchpoint
,
535 de_fault (to_stopped_data_address
,
536 (int (*) (struct target_ops
*, CORE_ADDR
*))
538 de_fault (to_region_size_ok_for_hw_watchpoint
,
539 default_region_size_ok_for_hw_watchpoint
);
540 de_fault (to_terminal_init
,
543 de_fault (to_terminal_inferior
,
546 de_fault (to_terminal_ours_for_output
,
549 de_fault (to_terminal_ours
,
552 de_fault (to_terminal_save_ours
,
555 de_fault (to_terminal_info
,
556 default_terminal_info
);
561 (void (*) (char *, int))
563 de_fault (to_lookup_symbol
,
564 (int (*) (char *, CORE_ADDR
*))
566 de_fault (to_create_inferior
,
567 maybe_kill_then_create_inferior
);
568 de_fault (to_post_startup_inferior
,
571 de_fault (to_acknowledge_created_inferior
,
574 de_fault (to_insert_fork_catchpoint
,
577 de_fault (to_remove_fork_catchpoint
,
580 de_fault (to_insert_vfork_catchpoint
,
583 de_fault (to_remove_vfork_catchpoint
,
586 de_fault (to_follow_fork
,
589 de_fault (to_insert_exec_catchpoint
,
592 de_fault (to_remove_exec_catchpoint
,
595 de_fault (to_reported_exec_events_per_exec_call
,
598 de_fault (to_has_exited
,
599 (int (*) (int, int, int *))
601 de_fault (to_mourn_inferior
,
604 de_fault (to_can_run
,
606 de_fault (to_notice_signals
,
609 de_fault (to_thread_alive
,
612 de_fault (to_find_new_threads
,
615 de_fault (to_extra_thread_info
,
616 (char *(*) (struct thread_info
*))
621 current_target
.to_xfer_partial
= default_xfer_partial
;
623 (void (*) (char *, struct ui_file
*))
625 de_fault (to_enable_exception_callback
,
626 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
628 de_fault (to_get_current_exception_event
,
629 (struct exception_event_record
* (*) (void))
631 de_fault (to_pid_to_exec_file
,
634 de_fault (to_can_async_p
,
637 de_fault (to_is_async_p
,
641 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
645 /* Finally, position the target-stack beneath the squashed
646 "current_target". That way code looking for a non-inherited
647 target method can quickly and simply find it. */
648 current_target
.beneath
= target_stack
;
651 /* Push a new target type into the stack of the existing target accessors,
652 possibly superseding some of the existing accessors.
654 Result is zero if the pushed target ended up on top of the stack,
655 nonzero if at least one target is on top of it.
657 Rather than allow an empty stack, we always have the dummy target at
658 the bottom stratum, so we can call the function vectors without
662 push_target (struct target_ops
*t
)
664 struct target_ops
**cur
;
666 /* Check magic number. If wrong, it probably means someone changed
667 the struct definition, but not all the places that initialize one. */
668 if (t
->to_magic
!= OPS_MAGIC
)
670 fprintf_unfiltered (gdb_stderr
,
671 "Magic number of %s target struct wrong\n",
673 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
676 /* Find the proper stratum to install this target in. */
677 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
679 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
683 /* If there's already targets at this stratum, remove them. */
684 /* FIXME: cagney/2003-10-15: I think this should be poping all
685 targets to CUR, and not just those at this stratum level. */
686 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
688 /* There's already something at this stratum level. Close it,
689 and un-hook it from the stack. */
690 struct target_ops
*tmp
= (*cur
);
691 (*cur
) = (*cur
)->beneath
;
693 target_close (tmp
, 0);
696 /* We have removed all targets in our stratum, now add the new one. */
700 update_current_target ();
703 setup_target_debug ();
706 return (t
!= target_stack
);
709 /* Remove a target_ops vector from the stack, wherever it may be.
710 Return how many times it was removed (0 or 1). */
713 unpush_target (struct target_ops
*t
)
715 struct target_ops
**cur
;
716 struct target_ops
*tmp
;
718 /* Look for the specified target. Note that we assume that a target
719 can only occur once in the target stack. */
721 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
728 return 0; /* Didn't find target_ops, quit now */
730 /* NOTE: cagney/2003-12-06: In '94 the close call was made
731 unconditional by moving it to before the above check that the
732 target was in the target stack (something about "Change the way
733 pushing and popping of targets work to support target overlays
734 and inheritance"). This doesn't make much sense - only open
735 targets should be closed. */
738 /* Unchain the target */
740 (*cur
) = (*cur
)->beneath
;
743 update_current_target ();
751 target_close (¤t_target
, 0); /* Let it clean up */
752 if (unpush_target (target_stack
) == 1)
755 fprintf_unfiltered (gdb_stderr
,
756 "pop_target couldn't find target %s\n",
757 current_target
.to_shortname
);
758 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
762 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
764 /* target_read_string -- read a null terminated string, up to LEN bytes,
765 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
766 Set *STRING to a pointer to malloc'd memory containing the data; the caller
767 is responsible for freeing it. Return the number of bytes successfully
771 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
773 int tlen
, origlen
, offset
, i
;
777 int buffer_allocated
;
779 unsigned int nbytes_read
= 0;
781 /* Small for testing. */
782 buffer_allocated
= 4;
783 buffer
= xmalloc (buffer_allocated
);
790 tlen
= MIN (len
, 4 - (memaddr
& 3));
791 offset
= memaddr
& 3;
793 errcode
= target_read_memory (memaddr
& ~3, buf
, 4);
796 /* The transfer request might have crossed the boundary to an
797 unallocated region of memory. Retry the transfer, requesting
801 errcode
= target_read_memory (memaddr
, buf
, 1);
806 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
809 bytes
= bufptr
- buffer
;
810 buffer_allocated
*= 2;
811 buffer
= xrealloc (buffer
, buffer_allocated
);
812 bufptr
= buffer
+ bytes
;
815 for (i
= 0; i
< tlen
; i
++)
817 *bufptr
++ = buf
[i
+ offset
];
818 if (buf
[i
+ offset
] == '\000')
820 nbytes_read
+= i
+ 1;
837 /* Find a section containing ADDR. */
838 struct section_table
*
839 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
841 struct section_table
*secp
;
842 for (secp
= target
->to_sections
;
843 secp
< target
->to_sections_end
;
846 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
852 /* Return non-zero when the target vector has supplied an xfer_partial
853 method and it, rather than xfer_memory, should be used. */
855 target_xfer_partial_p (void)
857 return (target_stack
!= NULL
858 && target_stack
->to_xfer_partial
!= default_xfer_partial
);
862 target_xfer_partial (struct target_ops
*ops
,
863 enum target_object object
, const char *annex
,
864 void *readbuf
, const void *writebuf
,
865 ULONGEST offset
, LONGEST len
)
869 gdb_assert (ops
->to_xfer_partial
!= NULL
);
870 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
874 const unsigned char *myaddr
= NULL
;
876 fprintf_unfiltered (gdb_stdlog
,
877 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
880 (annex
? annex
: "(null)"),
881 (long) readbuf
, (long) writebuf
,
882 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
888 if (retval
> 0 && myaddr
!= NULL
)
892 fputs_unfiltered (", bytes =", gdb_stdlog
);
893 for (i
= 0; i
< retval
; i
++)
895 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
897 if (targetdebug
< 2 && i
> 0)
899 fprintf_unfiltered (gdb_stdlog
, " ...");
902 fprintf_unfiltered (gdb_stdlog
, "\n");
905 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
909 fputc_unfiltered ('\n', gdb_stdlog
);
914 /* Attempt a transfer all LEN bytes starting at OFFSET between the
915 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
916 the transfer succeeds, return zero, otherwize the host ERRNO is
919 The inferior is formed from several layers. In the case of
920 corefiles, inf-corefile is layered above inf-exec and a request for
921 text (corefiles do not include text pages) will be first sent to
922 the core-stratum, fail, and then sent to the object-file where it
925 NOTE: cagney/2004-09-30:
927 The old code tried to use four separate mechanisms for mapping an
928 object:offset:len tuple onto an inferior and its address space: the
929 target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
934 The code below is instead using a single mechanism (currently
935 strata). If that mechanism proves insufficient then re-factor it
936 implementing another singluar mechanism (for instance, a generic
937 object:annex onto inferior:object:annex say). */
940 xfer_using_stratum (enum target_object object
, const char *annex
,
941 ULONGEST offset
, LONGEST len
, void *readbuf
,
942 const void *writebuf
)
945 struct target_ops
*target
;
947 /* Always successful. */
950 /* Never successful. */
951 if (target_stack
== NULL
)
954 target
= target_stack
;
957 xfered
= target_xfer_partial (target
, object
, annex
,
958 readbuf
, writebuf
, offset
, len
);
961 /* The partial xfer succeeded, update the counts, check that
962 the xfer hasn't finished and if it hasn't set things up
963 for the next round. */
969 readbuf
= (bfd_byte
*) readbuf
+ xfered
;
970 if (writebuf
!= NULL
)
971 writebuf
= (bfd_byte
*) writebuf
+ xfered
;
972 target
= target_stack
;
976 /* Something totally screwed up, abandon the attempt to
985 /* This "stratum" didn't work, try the next one down. */
986 target
= target
->beneath
;
993 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
994 GDB's memory at MYADDR. Returns either 0 for success or an errno value
997 If an error occurs, no guarantee is made about the contents of the data at
998 MYADDR. In particular, the caller should not depend upon partial reads
999 filling the buffer with good data. There is no way for the caller to know
1000 how much good data might have been transfered anyway. Callers that can
1001 deal with partial reads should call target_read_memory_partial. */
1004 target_read_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
)
1006 if (target_xfer_partial_p ())
1007 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1008 memaddr
, len
, myaddr
, NULL
);
1010 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
1014 target_write_memory (CORE_ADDR memaddr
, const bfd_byte
*myaddr
, int len
)
1016 bfd_byte
*bytes
= alloca (len
);
1017 memcpy (bytes
, myaddr
, len
);
1018 if (target_xfer_partial_p ())
1019 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1020 memaddr
, len
, NULL
, bytes
);
1022 return target_xfer_memory (memaddr
, bytes
, len
, 1);
1025 #ifndef target_stopped_data_address_p
1027 target_stopped_data_address_p (struct target_ops
*target
)
1029 if (target
->to_stopped_data_address
1030 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1032 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1033 && (debug_target
.to_stopped_data_address
1034 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1040 static int trust_readonly
= 0;
1042 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1043 struct cmd_list_element
*c
, const char *value
)
1045 fprintf_filtered (file
, _("\
1046 Mode for reading from readonly sections is %s.\n"),
1050 /* Move memory to or from the targets. The top target gets priority;
1051 if it cannot handle it, it is offered to the next one down, etc.
1053 Result is -1 on error, or the number of bytes transfered. */
1056 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1057 struct mem_attrib
*attrib
)
1061 struct target_ops
*t
;
1063 /* Zero length requests are ok and require no work. */
1067 /* deprecated_xfer_memory is not guaranteed to set errno, even when
1071 if (!write
&& trust_readonly
)
1073 struct section_table
*secp
;
1074 /* User-settable option, "trust-readonly-sections". If true,
1075 then memory from any SEC_READONLY bfd section may be read
1076 directly from the bfd file. */
1077 secp
= target_section_by_addr (¤t_target
, memaddr
);
1079 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1081 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
1084 /* The quick case is that the top target can handle the transfer. */
1085 res
= current_target
.deprecated_xfer_memory
1086 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
1088 /* If res <= 0 then we call it again in the loop. Ah well. */
1091 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1093 if (!t
->to_has_memory
)
1096 res
= t
->deprecated_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1098 break; /* Handled all or part of xfer */
1099 if (t
->to_has_all_memory
)
1111 /* Perform a memory transfer. Iterate until the entire region has
1114 Result is 0 or errno value. */
1117 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
1121 struct mem_region
*region
;
1123 /* Zero length requests are ok and require no work. */
1131 region
= lookup_mem_region(memaddr
);
1132 if (memaddr
+ len
< region
->hi
)
1135 reg_len
= region
->hi
- memaddr
;
1137 switch (region
->attrib
.mode
)
1152 if (region
->attrib
.cache
)
1153 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1156 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1161 /* If this address is for nonexistent memory, read zeros
1162 if reading, or do nothing if writing. Return
1165 memset (myaddr
, 0, len
);
1179 return 0; /* We managed to cover it all somehow. */
1183 /* Perform a partial memory transfer.
1185 Result is -1 on error, or the number of bytes transfered. */
1188 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1189 int write_p
, int *err
)
1193 struct mem_region
*region
;
1195 /* Zero length requests are ok and require no work. */
1202 region
= lookup_mem_region(memaddr
);
1203 if (memaddr
+ len
< region
->hi
)
1206 reg_len
= region
->hi
- memaddr
;
1208 switch (region
->attrib
.mode
)
1227 if (region
->attrib
.cache
)
1228 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1231 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1249 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1251 if (target_xfer_partial_p ())
1255 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1256 NULL
, buf
, NULL
, memaddr
, len
);
1273 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1277 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1279 if (target_xfer_partial_p ())
1283 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1284 NULL
, NULL
, buf
, memaddr
, len
);
1301 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1304 /* More generic transfers. */
1307 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1308 const char *annex
, void *readbuf
,
1309 const void *writebuf
, ULONGEST offset
, LONGEST len
)
1311 if (object
== TARGET_OBJECT_MEMORY
1312 && ops
->deprecated_xfer_memory
!= NULL
)
1313 /* If available, fall back to the target's
1314 "deprecated_xfer_memory" method. */
1318 if (writebuf
!= NULL
)
1320 void *buffer
= xmalloc (len
);
1321 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1322 memcpy (buffer
, writebuf
, len
);
1323 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1324 1/*write*/, NULL
, ops
);
1325 do_cleanups (cleanup
);
1327 if (readbuf
!= NULL
)
1328 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1332 else if (xfered
== 0 && errno
== 0)
1333 /* "deprecated_xfer_memory" uses 0, cross checked against
1334 ERRNO as one indication of an error. */
1339 else if (ops
->beneath
!= NULL
)
1340 return target_xfer_partial (ops
->beneath
, object
, annex
,
1341 readbuf
, writebuf
, offset
, len
);
1346 /* Target vector read/write partial wrapper functions.
1348 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1349 (inbuf, outbuf)", instead of separate read/write methods, make life
1353 target_read_partial (struct target_ops
*ops
,
1354 enum target_object object
,
1355 const char *annex
, void *buf
,
1356 ULONGEST offset
, LONGEST len
)
1358 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1362 target_write_partial (struct target_ops
*ops
,
1363 enum target_object object
,
1364 const char *annex
, const void *buf
,
1365 ULONGEST offset
, LONGEST len
)
1367 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1370 /* Wrappers to perform the full transfer. */
1372 target_read (struct target_ops
*ops
,
1373 enum target_object object
,
1374 const char *annex
, void *buf
,
1375 ULONGEST offset
, LONGEST len
)
1378 while (xfered
< len
)
1380 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1381 (bfd_byte
*) buf
+ xfered
,
1382 offset
+ xfered
, len
- xfered
);
1383 /* Call an observer, notifying them of the xfer progress? */
1385 /* Call memory_error? */
1394 target_write (struct target_ops
*ops
,
1395 enum target_object object
,
1396 const char *annex
, const void *buf
,
1397 ULONGEST offset
, LONGEST len
)
1400 while (xfered
< len
)
1402 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1403 (bfd_byte
*) buf
+ xfered
,
1404 offset
+ xfered
, len
- xfered
);
1405 /* Call an observer, notifying them of the xfer progress? */
1407 /* Call memory_error? */
1415 /* Memory transfer methods. */
1418 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1421 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1423 memory_error (EIO
, addr
);
1427 get_target_memory_unsigned (struct target_ops
*ops
,
1428 CORE_ADDR addr
, int len
)
1430 char buf
[sizeof (ULONGEST
)];
1432 gdb_assert (len
<= sizeof (buf
));
1433 get_target_memory (ops
, addr
, buf
, len
);
1434 return extract_unsigned_integer (buf
, len
);
1438 target_info (char *args
, int from_tty
)
1440 struct target_ops
*t
;
1441 int has_all_mem
= 0;
1443 if (symfile_objfile
!= NULL
)
1444 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1446 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1448 if (!t
->to_has_memory
)
1451 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1454 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1455 printf_unfiltered ("%s:\n", t
->to_longname
);
1456 (t
->to_files_info
) (t
);
1457 has_all_mem
= t
->to_has_all_memory
;
1461 /* This is to be called by the open routine before it does
1465 target_preopen (int from_tty
)
1469 if (target_has_execution
)
1472 || query (_("A program is being debugged already. Kill it? ")))
1475 error (_("Program not killed."));
1478 /* Calling target_kill may remove the target from the stack. But if
1479 it doesn't (which seems like a win for UDI), remove it now. */
1481 if (target_has_execution
)
1485 /* Detach a target after doing deferred register stores. */
1488 target_detach (char *args
, int from_tty
)
1490 (current_target
.to_detach
) (args
, from_tty
);
1494 target_disconnect (char *args
, int from_tty
)
1496 (current_target
.to_disconnect
) (args
, from_tty
);
1500 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1502 if (DEPRECATED_STREQ (current_target
.to_shortname
, "rombug"))
1504 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1506 error (_("Unable to link to %s and get relocation in rombug"), modname
);
1509 *t_reloc
= (CORE_ADDR
) -1;
1513 target_async_mask (int mask
)
1515 int saved_async_masked_status
= target_async_mask_value
;
1516 target_async_mask_value
= mask
;
1517 return saved_async_masked_status
;
1520 /* Look through the list of possible targets for a target that can
1521 execute a run or attach command without any other data. This is
1522 used to locate the default process stratum.
1524 Result is always valid (error() is called for errors). */
1526 static struct target_ops
*
1527 find_default_run_target (char *do_mesg
)
1529 struct target_ops
**t
;
1530 struct target_ops
*runable
= NULL
;
1535 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1538 if ((*t
)->to_can_run
&& target_can_run (*t
))
1546 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1552 find_default_attach (char *args
, int from_tty
)
1554 struct target_ops
*t
;
1556 t
= find_default_run_target ("attach");
1557 (t
->to_attach
) (args
, from_tty
);
1562 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1565 struct target_ops
*t
;
1567 t
= find_default_run_target ("run");
1568 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1573 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1575 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1591 return_minus_one (void)
1597 * Resize the to_sections pointer. Also make sure that anyone that
1598 * was holding on to an old value of it gets updated.
1599 * Returns the old size.
1603 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1605 struct target_ops
**t
;
1606 struct section_table
*old_value
;
1609 old_value
= target
->to_sections
;
1611 if (target
->to_sections
)
1613 old_count
= target
->to_sections_end
- target
->to_sections
;
1614 target
->to_sections
= (struct section_table
*)
1615 xrealloc ((char *) target
->to_sections
,
1616 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1621 target
->to_sections
= (struct section_table
*)
1622 xmalloc ((sizeof (struct section_table
)) * num_added
);
1624 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1626 /* Check to see if anyone else was pointing to this structure.
1627 If old_value was null, then no one was. */
1631 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1634 if ((*t
)->to_sections
== old_value
)
1636 (*t
)->to_sections
= target
->to_sections
;
1637 (*t
)->to_sections_end
= target
->to_sections_end
;
1640 /* There is a flattened view of the target stack in current_target,
1641 so its to_sections pointer might also need updating. */
1642 if (current_target
.to_sections
== old_value
)
1644 current_target
.to_sections
= target
->to_sections
;
1645 current_target
.to_sections_end
= target
->to_sections_end
;
1653 /* Remove all target sections taken from ABFD.
1655 Scan the current target stack for targets whose section tables
1656 refer to sections from BFD, and remove those sections. We use this
1657 when we notice that the inferior has unloaded a shared object, for
1660 remove_target_sections (bfd
*abfd
)
1662 struct target_ops
**t
;
1664 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1666 struct section_table
*src
, *dest
;
1668 dest
= (*t
)->to_sections
;
1669 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1670 if (src
->bfd
!= abfd
)
1672 /* Keep this section. */
1673 if (dest
< src
) *dest
= *src
;
1677 /* If we've dropped any sections, resize the section table. */
1679 target_resize_to_sections (*t
, dest
- src
);
1686 /* Find a single runnable target in the stack and return it. If for
1687 some reason there is more than one, return NULL. */
1690 find_run_target (void)
1692 struct target_ops
**t
;
1693 struct target_ops
*runable
= NULL
;
1698 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1700 if ((*t
)->to_can_run
&& target_can_run (*t
))
1707 return (count
== 1 ? runable
: NULL
);
1710 /* Find a single core_stratum target in the list of targets and return it.
1711 If for some reason there is more than one, return NULL. */
1714 find_core_target (void)
1716 struct target_ops
**t
;
1717 struct target_ops
*runable
= NULL
;
1722 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1725 if ((*t
)->to_stratum
== core_stratum
)
1732 return (count
== 1 ? runable
: NULL
);
1736 * Find the next target down the stack from the specified target.
1740 find_target_beneath (struct target_ops
*t
)
1746 /* The inferior process has died. Long live the inferior! */
1749 generic_mourn_inferior (void)
1751 extern int show_breakpoint_hit_counts
;
1753 inferior_ptid
= null_ptid
;
1755 breakpoint_init_inferior (inf_exited
);
1756 registers_changed ();
1758 reopen_exec_file ();
1759 reinit_frame_cache ();
1761 /* It is confusing to the user for ignore counts to stick around
1762 from previous runs of the inferior. So clear them. */
1763 /* However, it is more confusing for the ignore counts to disappear when
1764 using hit counts. So don't clear them if we're counting hits. */
1765 if (!show_breakpoint_hit_counts
)
1766 breakpoint_clear_ignore_counts ();
1768 if (deprecated_detach_hook
)
1769 deprecated_detach_hook ();
1772 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1773 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1774 translation of that in OURSTATUS. */
1776 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1778 #ifdef CHILD_SPECIAL_WAITSTATUS
1779 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1780 if it wants to deal with hoststatus. */
1781 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1785 if (WIFEXITED (hoststatus
))
1787 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1788 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1790 else if (!WIFSTOPPED (hoststatus
))
1792 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1793 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1797 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1798 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1802 /* Returns zero to leave the inferior alone, one to interrupt it. */
1803 int (*target_activity_function
) (void);
1804 int target_activity_fd
;
1806 /* Convert a normal process ID to a string. Returns the string in a
1810 normal_pid_to_str (ptid_t ptid
)
1812 static char buf
[32];
1815 size
= snprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1816 gdb_assert (size
< sizeof buf
);
1820 /* Error-catcher for target_find_memory_regions */
1821 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1823 error (_("No target."));
1827 /* Error-catcher for target_make_corefile_notes */
1828 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1830 error (_("No target."));
1834 /* Set up the handful of non-empty slots needed by the dummy target
1838 init_dummy_target (void)
1840 dummy_target
.to_shortname
= "None";
1841 dummy_target
.to_longname
= "None";
1842 dummy_target
.to_doc
= "";
1843 dummy_target
.to_attach
= find_default_attach
;
1844 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1845 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1846 dummy_target
.to_stratum
= dummy_stratum
;
1847 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1848 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1849 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1850 dummy_target
.to_magic
= OPS_MAGIC
;
1854 debug_to_open (char *args
, int from_tty
)
1856 debug_target
.to_open (args
, from_tty
);
1858 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1862 debug_to_close (int quitting
)
1864 target_close (&debug_target
, quitting
);
1865 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1869 target_close (struct target_ops
*targ
, int quitting
)
1871 if (targ
->to_xclose
!= NULL
)
1872 targ
->to_xclose (targ
, quitting
);
1873 else if (targ
->to_close
!= NULL
)
1874 targ
->to_close (quitting
);
1878 debug_to_attach (char *args
, int from_tty
)
1880 debug_target
.to_attach (args
, from_tty
);
1882 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1887 debug_to_post_attach (int pid
)
1889 debug_target
.to_post_attach (pid
);
1891 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1895 debug_to_detach (char *args
, int from_tty
)
1897 debug_target
.to_detach (args
, from_tty
);
1899 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1903 debug_to_disconnect (char *args
, int from_tty
)
1905 debug_target
.to_disconnect (args
, from_tty
);
1907 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1912 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1914 debug_target
.to_resume (ptid
, step
, siggnal
);
1916 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1917 step
? "step" : "continue",
1918 target_signal_to_name (siggnal
));
1922 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1926 retval
= debug_target
.to_wait (ptid
, status
);
1928 fprintf_unfiltered (gdb_stdlog
,
1929 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1931 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1932 switch (status
->kind
)
1934 case TARGET_WAITKIND_EXITED
:
1935 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1936 status
->value
.integer
);
1938 case TARGET_WAITKIND_STOPPED
:
1939 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1940 target_signal_to_name (status
->value
.sig
));
1942 case TARGET_WAITKIND_SIGNALLED
:
1943 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1944 target_signal_to_name (status
->value
.sig
));
1946 case TARGET_WAITKIND_LOADED
:
1947 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1949 case TARGET_WAITKIND_FORKED
:
1950 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1952 case TARGET_WAITKIND_VFORKED
:
1953 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1955 case TARGET_WAITKIND_EXECD
:
1956 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1958 case TARGET_WAITKIND_SPURIOUS
:
1959 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1962 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1970 debug_print_register (const char * func
, int regno
)
1972 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1973 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1974 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1975 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1977 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1981 unsigned char buf
[MAX_REGISTER_SIZE
];
1982 deprecated_read_register_gen (regno
, buf
);
1983 fprintf_unfiltered (gdb_stdlog
, " = ");
1984 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1986 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1988 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1990 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1991 paddr_nz (read_register (regno
)),
1992 paddr_d (read_register (regno
)));
1995 fprintf_unfiltered (gdb_stdlog
, "\n");
1999 debug_to_fetch_registers (int regno
)
2001 debug_target
.to_fetch_registers (regno
);
2002 debug_print_register ("target_fetch_registers", regno
);
2006 debug_to_store_registers (int regno
)
2008 debug_target
.to_store_registers (regno
);
2009 debug_print_register ("target_store_registers", regno
);
2010 fprintf_unfiltered (gdb_stdlog
, "\n");
2014 debug_to_prepare_to_store (void)
2016 debug_target
.to_prepare_to_store ();
2018 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2022 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
2023 int write
, struct mem_attrib
*attrib
,
2024 struct target_ops
*target
)
2028 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2031 fprintf_unfiltered (gdb_stdlog
,
2032 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2033 (unsigned int) memaddr
, /* possable truncate long long */
2034 len
, write
? "write" : "read", retval
);
2040 fputs_unfiltered (", bytes =", gdb_stdlog
);
2041 for (i
= 0; i
< retval
; i
++)
2043 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2045 if (targetdebug
< 2 && i
> 0)
2047 fprintf_unfiltered (gdb_stdlog
, " ...");
2050 fprintf_unfiltered (gdb_stdlog
, "\n");
2053 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2057 fputc_unfiltered ('\n', gdb_stdlog
);
2063 debug_to_files_info (struct target_ops
*target
)
2065 debug_target
.to_files_info (target
);
2067 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2071 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
2075 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2077 fprintf_unfiltered (gdb_stdlog
,
2078 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2079 (unsigned long) addr
,
2080 (unsigned long) retval
);
2085 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
2089 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2091 fprintf_unfiltered (gdb_stdlog
,
2092 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2093 (unsigned long) addr
,
2094 (unsigned long) retval
);
2099 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2103 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2105 fprintf_unfiltered (gdb_stdlog
,
2106 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2107 (unsigned long) type
,
2108 (unsigned long) cnt
,
2109 (unsigned long) from_tty
,
2110 (unsigned long) retval
);
2115 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
2119 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
2121 fprintf_unfiltered (gdb_stdlog
,
2122 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2123 (unsigned long) byte_count
,
2124 (unsigned long) retval
);
2129 debug_to_stopped_by_watchpoint (void)
2133 retval
= debug_target
.to_stopped_by_watchpoint ();
2135 fprintf_unfiltered (gdb_stdlog
,
2136 "STOPPED_BY_WATCHPOINT () = %ld\n",
2137 (unsigned long) retval
);
2142 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2146 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2148 fprintf_unfiltered (gdb_stdlog
,
2149 "target_stopped_data_address ([0x%lx]) = %ld\n",
2150 (unsigned long)*addr
,
2151 (unsigned long)retval
);
2156 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
2160 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2162 fprintf_unfiltered (gdb_stdlog
,
2163 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2164 (unsigned long) addr
,
2165 (unsigned long) retval
);
2170 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
2174 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2176 fprintf_unfiltered (gdb_stdlog
,
2177 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2178 (unsigned long) addr
,
2179 (unsigned long) retval
);
2184 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2188 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2190 fprintf_unfiltered (gdb_stdlog
,
2191 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2192 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2197 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2201 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2203 fprintf_unfiltered (gdb_stdlog
,
2204 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2205 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2210 debug_to_terminal_init (void)
2212 debug_target
.to_terminal_init ();
2214 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2218 debug_to_terminal_inferior (void)
2220 debug_target
.to_terminal_inferior ();
2222 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2226 debug_to_terminal_ours_for_output (void)
2228 debug_target
.to_terminal_ours_for_output ();
2230 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2234 debug_to_terminal_ours (void)
2236 debug_target
.to_terminal_ours ();
2238 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2242 debug_to_terminal_save_ours (void)
2244 debug_target
.to_terminal_save_ours ();
2246 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2250 debug_to_terminal_info (char *arg
, int from_tty
)
2252 debug_target
.to_terminal_info (arg
, from_tty
);
2254 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2259 debug_to_kill (void)
2261 debug_target
.to_kill ();
2263 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2267 debug_to_load (char *args
, int from_tty
)
2269 debug_target
.to_load (args
, from_tty
);
2271 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2275 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2279 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2281 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2287 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2290 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2292 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2293 exec_file
, args
, from_tty
);
2297 debug_to_post_startup_inferior (ptid_t ptid
)
2299 debug_target
.to_post_startup_inferior (ptid
);
2301 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2306 debug_to_acknowledge_created_inferior (int pid
)
2308 debug_target
.to_acknowledge_created_inferior (pid
);
2310 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2315 debug_to_insert_fork_catchpoint (int pid
)
2317 debug_target
.to_insert_fork_catchpoint (pid
);
2319 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2324 debug_to_remove_fork_catchpoint (int pid
)
2328 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2330 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2337 debug_to_insert_vfork_catchpoint (int pid
)
2339 debug_target
.to_insert_vfork_catchpoint (pid
);
2341 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2346 debug_to_remove_vfork_catchpoint (int pid
)
2350 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2352 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2359 debug_to_follow_fork (int follow_child
)
2361 int retval
= debug_target
.to_follow_fork (follow_child
);
2363 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2364 follow_child
, retval
);
2370 debug_to_insert_exec_catchpoint (int pid
)
2372 debug_target
.to_insert_exec_catchpoint (pid
);
2374 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2379 debug_to_remove_exec_catchpoint (int pid
)
2383 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2385 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2392 debug_to_reported_exec_events_per_exec_call (void)
2394 int reported_exec_events
;
2396 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2398 fprintf_unfiltered (gdb_stdlog
,
2399 "target_reported_exec_events_per_exec_call () = %d\n",
2400 reported_exec_events
);
2402 return reported_exec_events
;
2406 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2410 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2412 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2413 pid
, wait_status
, *exit_status
, has_exited
);
2419 debug_to_mourn_inferior (void)
2421 debug_target
.to_mourn_inferior ();
2423 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2427 debug_to_can_run (void)
2431 retval
= debug_target
.to_can_run ();
2433 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2439 debug_to_notice_signals (ptid_t ptid
)
2441 debug_target
.to_notice_signals (ptid
);
2443 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2448 debug_to_thread_alive (ptid_t ptid
)
2452 retval
= debug_target
.to_thread_alive (ptid
);
2454 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2455 PIDGET (ptid
), retval
);
2461 debug_to_find_new_threads (void)
2463 debug_target
.to_find_new_threads ();
2465 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2469 debug_to_stop (void)
2471 debug_target
.to_stop ();
2473 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2477 debug_to_rcmd (char *command
,
2478 struct ui_file
*outbuf
)
2480 debug_target
.to_rcmd (command
, outbuf
);
2481 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2484 static struct symtab_and_line
*
2485 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2487 struct symtab_and_line
*result
;
2488 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2489 fprintf_unfiltered (gdb_stdlog
,
2490 "target get_exception_callback_sal (%d, %d)\n",
2495 static struct exception_event_record
*
2496 debug_to_get_current_exception_event (void)
2498 struct exception_event_record
*result
;
2499 result
= debug_target
.to_get_current_exception_event ();
2500 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2505 debug_to_pid_to_exec_file (int pid
)
2509 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2511 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2518 setup_target_debug (void)
2520 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2522 current_target
.to_open
= debug_to_open
;
2523 current_target
.to_close
= debug_to_close
;
2524 current_target
.to_attach
= debug_to_attach
;
2525 current_target
.to_post_attach
= debug_to_post_attach
;
2526 current_target
.to_detach
= debug_to_detach
;
2527 current_target
.to_disconnect
= debug_to_disconnect
;
2528 current_target
.to_resume
= debug_to_resume
;
2529 current_target
.to_wait
= debug_to_wait
;
2530 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2531 current_target
.to_store_registers
= debug_to_store_registers
;
2532 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2533 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2534 current_target
.to_files_info
= debug_to_files_info
;
2535 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2536 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2537 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2538 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2539 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2540 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2541 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2542 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2543 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2544 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2545 current_target
.to_terminal_init
= debug_to_terminal_init
;
2546 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2547 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2548 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2549 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2550 current_target
.to_terminal_info
= debug_to_terminal_info
;
2551 current_target
.to_kill
= debug_to_kill
;
2552 current_target
.to_load
= debug_to_load
;
2553 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2554 current_target
.to_create_inferior
= debug_to_create_inferior
;
2555 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2556 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2557 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2558 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2559 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2560 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2561 current_target
.to_follow_fork
= debug_to_follow_fork
;
2562 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2563 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2564 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2565 current_target
.to_has_exited
= debug_to_has_exited
;
2566 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2567 current_target
.to_can_run
= debug_to_can_run
;
2568 current_target
.to_notice_signals
= debug_to_notice_signals
;
2569 current_target
.to_thread_alive
= debug_to_thread_alive
;
2570 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2571 current_target
.to_stop
= debug_to_stop
;
2572 current_target
.to_rcmd
= debug_to_rcmd
;
2573 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2574 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2575 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2580 static char targ_desc
[] =
2581 "Names of targets and files being debugged.\n\
2582 Shows the entire stack of targets currently in use (including the exec-file,\n\
2583 core-file, and process, if any), as well as the symbol file name.";
2586 do_monitor_command (char *cmd
,
2589 if ((current_target
.to_rcmd
2590 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2591 || (current_target
.to_rcmd
== debug_to_rcmd
2592 && (debug_target
.to_rcmd
2593 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2594 error (_("\"monitor\" command not supported by this target."));
2595 target_rcmd (cmd
, gdb_stdtarg
);
2599 initialize_targets (void)
2601 init_dummy_target ();
2602 push_target (&dummy_target
);
2604 add_info ("target", target_info
, targ_desc
);
2605 add_info ("files", target_info
, targ_desc
);
2607 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2608 Set target debugging."), _("\
2609 Show target debugging."), _("\
2610 When non-zero, target debugging is enabled. Higher numbers are more\n\
2611 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2615 &setdebuglist
, &showdebuglist
);
2617 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2618 &trust_readonly
, _("\
2619 Set mode for reading from readonly sections."), _("\
2620 Show mode for reading from readonly sections."), _("\
2621 When this mode is on, memory reads from readonly sections (such as .text)\n\
2622 will be read from the object file instead of from the target. This will\n\
2623 result in significant performance improvement for remote targets."),
2625 show_trust_readonly
,
2626 &setlist
, &showlist
);
2628 add_com ("monitor", class_obscure
, do_monitor_command
,
2629 _("Send a command to the remote monitor (remote targets only)."));
2631 target_dcache
= dcache_init ();