1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
28 #include "gdb_string.h"
40 #include "gdb_assert.h"
43 static void target_info (char *, int);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
53 static int nosymbol (char *, CORE_ADDR
*);
55 static void tcomplain (void) ATTR_NORETURN
;
57 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
74 enum target_object object
,
75 const char *annex
, gdb_byte
*readbuf
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, LONGEST len
);
79 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
80 enum target_object object
,
81 const char *annex
, gdb_byte
*readbuf
,
82 const gdb_byte
*writebuf
,
83 ULONGEST offset
, LONGEST len
);
85 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
86 enum target_object object
,
88 void *readbuf
, const void *writebuf
,
89 ULONGEST offset
, LONGEST len
);
91 static void init_dummy_target (void);
93 static struct target_ops debug_target
;
95 static void debug_to_open (char *, int);
97 static void debug_to_close (int);
99 static void debug_to_attach (char *, int);
101 static void debug_to_detach (char *, int);
103 static void debug_to_resume (ptid_t
, int, enum target_signal
);
105 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
107 static void debug_to_fetch_registers (int);
109 static void debug_to_store_registers (int);
111 static void debug_to_prepare_to_store (void);
113 static void debug_to_files_info (struct target_ops
*);
115 static int debug_to_insert_breakpoint (struct bp_target_info
*);
117 static int debug_to_remove_breakpoint (struct bp_target_info
*);
119 static int debug_to_can_use_hw_breakpoint (int, int, int);
121 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
123 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
125 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_stopped_by_watchpoint (void);
131 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
133 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_terminal_info (char *, int);
147 static void debug_to_kill (void);
149 static void debug_to_load (char *, int);
151 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t
);
159 static int debug_to_thread_alive (ptid_t
);
161 static void debug_to_stop (void);
163 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
164 wierd and mysterious ways. Putting the variable here lets those
165 wierd and mysterious ways keep building while they are being
166 converted to the inferior inheritance structure. */
167 struct target_ops deprecated_child_ops
;
169 /* Pointer to array of target architecture structures; the size of the
170 array; the current index into the array; the allocated size of the
172 struct target_ops
**target_structs
;
173 unsigned target_struct_size
;
174 unsigned target_struct_index
;
175 unsigned target_struct_allocsize
;
176 #define DEFAULT_ALLOCSIZE 10
178 /* The initial current target, so that there is always a semi-valid
181 static struct target_ops dummy_target
;
183 /* Top of target stack. */
185 static struct target_ops
*target_stack
;
187 /* The target structure we are currently using to talk to a process
188 or file or whatever "inferior" we have. */
190 struct target_ops current_target
;
192 /* Command list for target. */
194 static struct cmd_list_element
*targetlist
= NULL
;
196 /* Nonzero if we are debugging an attached outside process
197 rather than an inferior. */
201 /* Nonzero if we should trust readonly sections from the
202 executable when reading memory. */
204 static int trust_readonly
= 0;
206 /* Non-zero if we want to see trace of target level stuff. */
208 static int targetdebug
= 0;
210 show_targetdebug (struct ui_file
*file
, int from_tty
,
211 struct cmd_list_element
*c
, const char *value
)
213 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
216 static void setup_target_debug (void);
218 DCACHE
*target_dcache
;
220 /* The user just typed 'target' without the name of a target. */
223 target_command (char *arg
, int from_tty
)
225 fputs_filtered ("Argument required (target name). Try `help target'\n",
229 /* Add a possible target architecture to the list. */
232 add_target (struct target_ops
*t
)
234 /* Provide default values for all "must have" methods. */
235 if (t
->to_xfer_partial
== NULL
)
236 t
->to_xfer_partial
= default_xfer_partial
;
240 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
241 target_structs
= (struct target_ops
**) xmalloc
242 (target_struct_allocsize
* sizeof (*target_structs
));
244 if (target_struct_size
>= target_struct_allocsize
)
246 target_struct_allocsize
*= 2;
247 target_structs
= (struct target_ops
**)
248 xrealloc ((char *) target_structs
,
249 target_struct_allocsize
* sizeof (*target_structs
));
251 target_structs
[target_struct_size
++] = t
;
253 if (targetlist
== NULL
)
254 add_prefix_cmd ("target", class_run
, target_command
, _("\
255 Connect to a target machine or process.\n\
256 The first argument is the type or protocol of the target machine.\n\
257 Remaining arguments are interpreted by the target protocol. For more\n\
258 information on the arguments for a particular protocol, type\n\
259 `help target ' followed by the protocol name."),
260 &targetlist
, "target ", 0, &cmdlist
);
261 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
272 target_load (char *arg
, int from_tty
)
274 dcache_invalidate (target_dcache
);
275 (*current_target
.to_load
) (arg
, from_tty
);
279 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
280 struct target_ops
*t
)
282 errno
= EIO
; /* Can't read/write this location */
283 return 0; /* No bytes handled */
289 error (_("You can't do that when your target is `%s'"),
290 current_target
.to_shortname
);
296 error (_("You can't do that without a process to debug."));
300 nosymbol (char *name
, CORE_ADDR
*addrp
)
302 return 1; /* Symbol does not exist in target env */
306 nosupport_runtime (void)
308 if (ptid_equal (inferior_ptid
, null_ptid
))
311 error (_("No run-time support for this"));
316 default_terminal_info (char *args
, int from_tty
)
318 printf_unfiltered (_("No saved terminal information.\n"));
321 /* This is the default target_create_inferior and target_attach function.
322 If the current target is executing, it asks whether to kill it off.
323 If this function returns without calling error(), it has killed off
324 the target, and the operation should be attempted. */
327 kill_or_be_killed (int from_tty
)
329 if (target_has_execution
)
331 printf_unfiltered (_("You are already running a program:\n"));
332 target_files_info ();
333 if (query ("Kill it? "))
336 if (target_has_execution
)
337 error (_("Killing the program did not help."));
342 error (_("Program not killed."));
349 maybe_kill_then_attach (char *args
, int from_tty
)
351 kill_or_be_killed (from_tty
);
352 target_attach (args
, from_tty
);
356 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
359 kill_or_be_killed (0);
360 target_create_inferior (exec
, args
, env
, from_tty
);
363 /* Go through the target stack from top to bottom, copying over zero
364 entries in current_target, then filling in still empty entries. In
365 effect, we are doing class inheritance through the pushed target
368 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
369 is currently implemented, is that it discards any knowledge of
370 which target an inherited method originally belonged to.
371 Consequently, new new target methods should instead explicitly and
372 locally search the target stack for the target that can handle the
376 update_current_target (void)
378 struct target_ops
*t
;
380 /* First, reset curren'ts contents. */
381 memset (¤t_target
, 0, sizeof (current_target
));
383 #define INHERIT(FIELD, TARGET) \
384 if (!current_target.FIELD) \
385 current_target.FIELD = (TARGET)->FIELD
387 for (t
= target_stack
; t
; t
= t
->beneath
)
389 INHERIT (to_shortname
, t
);
390 INHERIT (to_longname
, t
);
392 INHERIT (to_open
, t
);
393 INHERIT (to_close
, t
);
394 INHERIT (to_attach
, t
);
395 INHERIT (to_post_attach
, t
);
396 INHERIT (to_detach
, t
);
397 /* Do not inherit to_disconnect. */
398 INHERIT (to_resume
, t
);
399 INHERIT (to_wait
, t
);
400 INHERIT (to_fetch_registers
, t
);
401 INHERIT (to_store_registers
, t
);
402 INHERIT (to_prepare_to_store
, t
);
403 INHERIT (deprecated_xfer_memory
, t
);
404 INHERIT (to_files_info
, t
);
405 INHERIT (to_insert_breakpoint
, t
);
406 INHERIT (to_remove_breakpoint
, t
);
407 INHERIT (to_can_use_hw_breakpoint
, t
);
408 INHERIT (to_insert_hw_breakpoint
, t
);
409 INHERIT (to_remove_hw_breakpoint
, t
);
410 INHERIT (to_insert_watchpoint
, t
);
411 INHERIT (to_remove_watchpoint
, t
);
412 INHERIT (to_stopped_data_address
, t
);
413 INHERIT (to_stopped_by_watchpoint
, t
);
414 INHERIT (to_have_continuable_watchpoint
, t
);
415 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
416 INHERIT (to_terminal_init
, t
);
417 INHERIT (to_terminal_inferior
, t
);
418 INHERIT (to_terminal_ours_for_output
, t
);
419 INHERIT (to_terminal_ours
, t
);
420 INHERIT (to_terminal_save_ours
, t
);
421 INHERIT (to_terminal_info
, t
);
422 INHERIT (to_kill
, t
);
423 INHERIT (to_load
, t
);
424 INHERIT (to_lookup_symbol
, t
);
425 INHERIT (to_create_inferior
, t
);
426 INHERIT (to_post_startup_inferior
, t
);
427 INHERIT (to_acknowledge_created_inferior
, t
);
428 INHERIT (to_insert_fork_catchpoint
, t
);
429 INHERIT (to_remove_fork_catchpoint
, t
);
430 INHERIT (to_insert_vfork_catchpoint
, t
);
431 INHERIT (to_remove_vfork_catchpoint
, t
);
432 /* Do not inherit to_follow_fork. */
433 INHERIT (to_insert_exec_catchpoint
, t
);
434 INHERIT (to_remove_exec_catchpoint
, t
);
435 INHERIT (to_reported_exec_events_per_exec_call
, t
);
436 INHERIT (to_has_exited
, t
);
437 INHERIT (to_mourn_inferior
, t
);
438 INHERIT (to_can_run
, t
);
439 INHERIT (to_notice_signals
, t
);
440 INHERIT (to_thread_alive
, t
);
441 INHERIT (to_find_new_threads
, t
);
442 INHERIT (to_pid_to_str
, t
);
443 INHERIT (to_extra_thread_info
, t
);
444 INHERIT (to_stop
, t
);
445 /* Do not inherit to_xfer_partial. */
446 INHERIT (to_rcmd
, t
);
447 INHERIT (to_enable_exception_callback
, t
);
448 INHERIT (to_get_current_exception_event
, t
);
449 INHERIT (to_pid_to_exec_file
, t
);
450 INHERIT (to_stratum
, t
);
451 INHERIT (to_has_all_memory
, t
);
452 INHERIT (to_has_memory
, t
);
453 INHERIT (to_has_stack
, t
);
454 INHERIT (to_has_registers
, t
);
455 INHERIT (to_has_execution
, t
);
456 INHERIT (to_has_thread_control
, t
);
457 INHERIT (to_sections
, t
);
458 INHERIT (to_sections_end
, t
);
459 INHERIT (to_can_async_p
, t
);
460 INHERIT (to_is_async_p
, t
);
461 INHERIT (to_async
, t
);
462 INHERIT (to_async_mask_value
, t
);
463 INHERIT (to_find_memory_regions
, t
);
464 INHERIT (to_make_corefile_notes
, t
);
465 INHERIT (to_get_thread_local_address
, t
);
466 INHERIT (to_magic
, t
);
467 /* Do not inherit to_memory_map. */
471 /* Clean up a target struct so it no longer has any zero pointers in
472 it. Some entries are defaulted to a method that print an error,
473 others are hard-wired to a standard recursive default. */
475 #define de_fault(field, value) \
476 if (!current_target.field) \
477 current_target.field = value
480 (void (*) (char *, int))
486 maybe_kill_then_attach
);
487 de_fault (to_post_attach
,
491 (void (*) (char *, int))
494 (void (*) (ptid_t
, int, enum target_signal
))
497 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
499 de_fault (to_fetch_registers
,
502 de_fault (to_store_registers
,
505 de_fault (to_prepare_to_store
,
508 de_fault (deprecated_xfer_memory
,
509 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
511 de_fault (to_files_info
,
512 (void (*) (struct target_ops
*))
514 de_fault (to_insert_breakpoint
,
515 memory_insert_breakpoint
);
516 de_fault (to_remove_breakpoint
,
517 memory_remove_breakpoint
);
518 de_fault (to_can_use_hw_breakpoint
,
519 (int (*) (int, int, int))
521 de_fault (to_insert_hw_breakpoint
,
522 (int (*) (struct bp_target_info
*))
524 de_fault (to_remove_hw_breakpoint
,
525 (int (*) (struct bp_target_info
*))
527 de_fault (to_insert_watchpoint
,
528 (int (*) (CORE_ADDR
, int, int))
530 de_fault (to_remove_watchpoint
,
531 (int (*) (CORE_ADDR
, int, int))
533 de_fault (to_stopped_by_watchpoint
,
536 de_fault (to_stopped_data_address
,
537 (int (*) (struct target_ops
*, CORE_ADDR
*))
539 de_fault (to_region_ok_for_hw_watchpoint
,
540 default_region_ok_for_hw_watchpoint
);
541 de_fault (to_terminal_init
,
544 de_fault (to_terminal_inferior
,
547 de_fault (to_terminal_ours_for_output
,
550 de_fault (to_terminal_ours
,
553 de_fault (to_terminal_save_ours
,
556 de_fault (to_terminal_info
,
557 default_terminal_info
);
562 (void (*) (char *, int))
564 de_fault (to_lookup_symbol
,
565 (int (*) (char *, CORE_ADDR
*))
567 de_fault (to_create_inferior
,
568 maybe_kill_then_create_inferior
);
569 de_fault (to_post_startup_inferior
,
572 de_fault (to_acknowledge_created_inferior
,
575 de_fault (to_insert_fork_catchpoint
,
578 de_fault (to_remove_fork_catchpoint
,
581 de_fault (to_insert_vfork_catchpoint
,
584 de_fault (to_remove_vfork_catchpoint
,
587 de_fault (to_insert_exec_catchpoint
,
590 de_fault (to_remove_exec_catchpoint
,
593 de_fault (to_reported_exec_events_per_exec_call
,
596 de_fault (to_has_exited
,
597 (int (*) (int, int, int *))
599 de_fault (to_mourn_inferior
,
602 de_fault (to_can_run
,
604 de_fault (to_notice_signals
,
607 de_fault (to_thread_alive
,
610 de_fault (to_find_new_threads
,
613 de_fault (to_extra_thread_info
,
614 (char *(*) (struct thread_info
*))
619 current_target
.to_xfer_partial
= current_xfer_partial
;
621 (void (*) (char *, struct ui_file
*))
623 de_fault (to_enable_exception_callback
,
624 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
626 de_fault (to_get_current_exception_event
,
627 (struct exception_event_record
* (*) (void))
629 de_fault (to_pid_to_exec_file
,
632 de_fault (to_can_async_p
,
635 de_fault (to_is_async_p
,
639 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
643 /* Finally, position the target-stack beneath the squashed
644 "current_target". That way code looking for a non-inherited
645 target method can quickly and simply find it. */
646 current_target
.beneath
= target_stack
;
649 /* Push a new target type into the stack of the existing target accessors,
650 possibly superseding some of the existing accessors.
652 Result is zero if the pushed target ended up on top of the stack,
653 nonzero if at least one target is on top of it.
655 Rather than allow an empty stack, we always have the dummy target at
656 the bottom stratum, so we can call the function vectors without
660 push_target (struct target_ops
*t
)
662 struct target_ops
**cur
;
664 /* Check magic number. If wrong, it probably means someone changed
665 the struct definition, but not all the places that initialize one. */
666 if (t
->to_magic
!= OPS_MAGIC
)
668 fprintf_unfiltered (gdb_stderr
,
669 "Magic number of %s target struct wrong\n",
671 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
674 /* Find the proper stratum to install this target in. */
675 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
677 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
681 /* If there's already targets at this stratum, remove them. */
682 /* FIXME: cagney/2003-10-15: I think this should be popping all
683 targets to CUR, and not just those at this stratum level. */
684 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
686 /* There's already something at this stratum level. Close it,
687 and un-hook it from the stack. */
688 struct target_ops
*tmp
= (*cur
);
689 (*cur
) = (*cur
)->beneath
;
691 target_close (tmp
, 0);
694 /* We have removed all targets in our stratum, now add the new one. */
698 update_current_target ();
701 setup_target_debug ();
704 return (t
!= target_stack
);
707 /* Remove a target_ops vector from the stack, wherever it may be.
708 Return how many times it was removed (0 or 1). */
711 unpush_target (struct target_ops
*t
)
713 struct target_ops
**cur
;
714 struct target_ops
*tmp
;
716 /* Look for the specified target. Note that we assume that a target
717 can only occur once in the target stack. */
719 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
726 return 0; /* Didn't find target_ops, quit now */
728 /* NOTE: cagney/2003-12-06: In '94 the close call was made
729 unconditional by moving it to before the above check that the
730 target was in the target stack (something about "Change the way
731 pushing and popping of targets work to support target overlays
732 and inheritance"). This doesn't make much sense - only open
733 targets should be closed. */
736 /* Unchain the target */
738 (*cur
) = (*cur
)->beneath
;
741 update_current_target ();
749 target_close (¤t_target
, 0); /* Let it clean up */
750 if (unpush_target (target_stack
) == 1)
753 fprintf_unfiltered (gdb_stderr
,
754 "pop_target couldn't find target %s\n",
755 current_target
.to_shortname
);
756 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
760 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
762 /* target_read_string -- read a null terminated string, up to LEN bytes,
763 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
764 Set *STRING to a pointer to malloc'd memory containing the data; the caller
765 is responsible for freeing it. Return the number of bytes successfully
769 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
771 int tlen
, origlen
, offset
, i
;
775 int buffer_allocated
;
777 unsigned int nbytes_read
= 0;
779 /* Small for testing. */
780 buffer_allocated
= 4;
781 buffer
= xmalloc (buffer_allocated
);
788 tlen
= MIN (len
, 4 - (memaddr
& 3));
789 offset
= memaddr
& 3;
791 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
794 /* The transfer request might have crossed the boundary to an
795 unallocated region of memory. Retry the transfer, requesting
799 errcode
= target_read_memory (memaddr
, buf
, 1);
804 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
807 bytes
= bufptr
- buffer
;
808 buffer_allocated
*= 2;
809 buffer
= xrealloc (buffer
, buffer_allocated
);
810 bufptr
= buffer
+ bytes
;
813 for (i
= 0; i
< tlen
; i
++)
815 *bufptr
++ = buf
[i
+ offset
];
816 if (buf
[i
+ offset
] == '\000')
818 nbytes_read
+= i
+ 1;
835 /* Find a section containing ADDR. */
836 struct section_table
*
837 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
839 struct section_table
*secp
;
840 for (secp
= target
->to_sections
;
841 secp
< target
->to_sections_end
;
844 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
850 /* Perform a partial memory transfer. The arguments and return
851 value are just as for target_xfer_partial. */
854 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
855 ULONGEST memaddr
, LONGEST len
)
859 struct mem_region
*region
;
861 /* Zero length requests are ok and require no work. */
865 /* Try the executable file, if "trust-readonly-sections" is set. */
866 if (readbuf
!= NULL
&& trust_readonly
)
868 struct section_table
*secp
;
870 secp
= target_section_by_addr (ops
, memaddr
);
872 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
874 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
877 /* Try GDB's internal data cache. */
878 region
= lookup_mem_region (memaddr
);
879 if (memaddr
+ len
< region
->hi
)
882 reg_len
= region
->hi
- memaddr
;
884 switch (region
->attrib
.mode
)
887 if (writebuf
!= NULL
)
897 if (region
->attrib
.cache
)
899 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
900 memory request will start back at current_target. */
902 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
905 /* FIXME drow/2006-08-09: If we're going to preserve const
906 correctness dcache_xfer_memory should take readbuf and
908 res
= dcache_xfer_memory (target_dcache
, memaddr
,
917 /* If none of those methods found the memory we wanted, fall back
918 to a target partial transfer. Normally a single call to
919 to_xfer_partial is enough; if it doesn't recognize an object
920 it will call the to_xfer_partial of the next target down.
921 But for memory this won't do. Memory is the only target
922 object which can be read from more than one valid target.
923 A core file, for instance, could have some of memory but
924 delegate other bits to the target below it. So, we must
925 manually try all targets. */
929 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
930 readbuf
, writebuf
, memaddr
, len
);
938 /* If we still haven't got anything, return the last error. We
944 target_xfer_partial (struct target_ops
*ops
,
945 enum target_object object
, const char *annex
,
946 void *readbuf
, const void *writebuf
,
947 ULONGEST offset
, LONGEST len
)
951 gdb_assert (ops
->to_xfer_partial
!= NULL
);
953 /* If this is a memory transfer, let the memory-specific code
954 have a look at it instead. Memory transfers are more
956 if (object
== TARGET_OBJECT_MEMORY
)
957 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
960 enum target_object raw_object
= object
;
962 /* If this is a raw memory transfer, request the normal
963 memory object from other layers. */
964 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
965 raw_object
= TARGET_OBJECT_MEMORY
;
967 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
968 writebuf
, offset
, len
);
973 const unsigned char *myaddr
= NULL
;
975 fprintf_unfiltered (gdb_stdlog
,
976 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
979 (annex
? annex
: "(null)"),
980 (long) readbuf
, (long) writebuf
,
981 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
987 if (retval
> 0 && myaddr
!= NULL
)
991 fputs_unfiltered (", bytes =", gdb_stdlog
);
992 for (i
= 0; i
< retval
; i
++)
994 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
996 if (targetdebug
< 2 && i
> 0)
998 fprintf_unfiltered (gdb_stdlog
, " ...");
1001 fprintf_unfiltered (gdb_stdlog
, "\n");
1004 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1008 fputc_unfiltered ('\n', gdb_stdlog
);
1013 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1014 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1015 if any error occurs.
1017 If an error occurs, no guarantee is made about the contents of the data at
1018 MYADDR. In particular, the caller should not depend upon partial reads
1019 filling the buffer with good data. There is no way for the caller to know
1020 how much good data might have been transfered anyway. Callers that can
1021 deal with partial reads should call target_read (which will retry until
1022 it makes no progress, and then return how much was transferred). */
1025 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1027 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1028 myaddr
, memaddr
, len
) == len
)
1035 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1037 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1038 myaddr
, memaddr
, len
) == len
)
1044 /* Fetch the target's memory map. */
1047 target_memory_map (void)
1049 VEC(mem_region_s
) *result
;
1050 struct mem_region
*last_one
, *this_one
;
1052 struct target_ops
*t
;
1055 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1057 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1058 if (t
->to_memory_map
!= NULL
)
1064 result
= t
->to_memory_map (t
);
1068 qsort (VEC_address (mem_region_s
, result
),
1069 VEC_length (mem_region_s
, result
),
1070 sizeof (struct mem_region
), mem_region_cmp
);
1072 /* Check that regions do not overlap. Simultaneously assign
1073 a numbering for the "mem" commands to use to refer to
1076 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1078 this_one
->number
= ix
;
1080 if (last_one
&& last_one
->hi
> this_one
->lo
)
1082 warning (_("Overlapping regions in memory map: ignoring"));
1083 VEC_free (mem_region_s
, result
);
1086 last_one
= this_one
;
1092 #ifndef target_stopped_data_address_p
1094 target_stopped_data_address_p (struct target_ops
*target
)
1096 if (target
->to_stopped_data_address
1097 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1099 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1100 && (debug_target
.to_stopped_data_address
1101 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1108 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1109 struct cmd_list_element
*c
, const char *value
)
1111 fprintf_filtered (file
, _("\
1112 Mode for reading from readonly sections is %s.\n"),
1116 /* More generic transfers. */
1119 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1120 const char *annex
, gdb_byte
*readbuf
,
1121 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1123 if (object
== TARGET_OBJECT_MEMORY
1124 && ops
->deprecated_xfer_memory
!= NULL
)
1125 /* If available, fall back to the target's
1126 "deprecated_xfer_memory" method. */
1130 if (writebuf
!= NULL
)
1132 void *buffer
= xmalloc (len
);
1133 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1134 memcpy (buffer
, writebuf
, len
);
1135 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1136 1/*write*/, NULL
, ops
);
1137 do_cleanups (cleanup
);
1139 if (readbuf
!= NULL
)
1140 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1144 else if (xfered
== 0 && errno
== 0)
1145 /* "deprecated_xfer_memory" uses 0, cross checked against
1146 ERRNO as one indication of an error. */
1151 else if (ops
->beneath
!= NULL
)
1152 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1153 readbuf
, writebuf
, offset
, len
);
1158 /* The xfer_partial handler for the topmost target. Unlike the default,
1159 it does not need to handle memory specially; it just passes all
1160 requests down the stack. */
1163 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1164 const char *annex
, gdb_byte
*readbuf
,
1165 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1167 if (ops
->beneath
!= NULL
)
1168 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1169 readbuf
, writebuf
, offset
, len
);
1174 /* Target vector read/write partial wrapper functions.
1176 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1177 (inbuf, outbuf)", instead of separate read/write methods, make life
1181 target_read_partial (struct target_ops
*ops
,
1182 enum target_object object
,
1183 const char *annex
, gdb_byte
*buf
,
1184 ULONGEST offset
, LONGEST len
)
1186 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1190 target_write_partial (struct target_ops
*ops
,
1191 enum target_object object
,
1192 const char *annex
, const gdb_byte
*buf
,
1193 ULONGEST offset
, LONGEST len
)
1195 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1198 /* Wrappers to perform the full transfer. */
1200 target_read (struct target_ops
*ops
,
1201 enum target_object object
,
1202 const char *annex
, gdb_byte
*buf
,
1203 ULONGEST offset
, LONGEST len
)
1206 while (xfered
< len
)
1208 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1209 (gdb_byte
*) buf
+ xfered
,
1210 offset
+ xfered
, len
- xfered
);
1211 /* Call an observer, notifying them of the xfer progress? */
1222 /* An alternative to target_write with progress callbacks. */
1225 target_write_with_progress (struct target_ops
*ops
,
1226 enum target_object object
,
1227 const char *annex
, const gdb_byte
*buf
,
1228 ULONGEST offset
, LONGEST len
,
1229 void (*progress
) (ULONGEST
, void *), void *baton
)
1232 while (xfered
< len
)
1234 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1235 (gdb_byte
*) buf
+ xfered
,
1236 offset
+ xfered
, len
- xfered
);
1244 (*progress
) (xfer
, baton
);
1253 target_write (struct target_ops
*ops
,
1254 enum target_object object
,
1255 const char *annex
, const gdb_byte
*buf
,
1256 ULONGEST offset
, LONGEST len
)
1258 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1262 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1263 the size of the transferred data. PADDING additional bytes are
1264 available in *BUF_P. This is a helper function for
1265 target_read_alloc; see the declaration of that function for more
1269 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1270 const char *annex
, gdb_byte
**buf_p
, int padding
)
1272 size_t buf_alloc
, buf_pos
;
1276 /* This function does not have a length parameter; it reads the
1277 entire OBJECT). Also, it doesn't support objects fetched partly
1278 from one target and partly from another (in a different stratum,
1279 e.g. a core file and an executable). Both reasons make it
1280 unsuitable for reading memory. */
1281 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1283 /* Start by reading up to 4K at a time. The target will throttle
1284 this number down if necessary. */
1286 buf
= xmalloc (buf_alloc
);
1290 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1291 buf_pos
, buf_alloc
- buf_pos
- padding
);
1294 /* An error occurred. */
1300 /* Read all there was. */
1310 /* If the buffer is filling up, expand it. */
1311 if (buf_alloc
< buf_pos
* 2)
1314 buf
= xrealloc (buf
, buf_alloc
);
1321 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1322 the size of the transferred data. See the declaration in "target.h"
1323 function for more information about the return value. */
1326 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1327 const char *annex
, gdb_byte
**buf_p
)
1329 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1332 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1333 returned as a string, allocated using xmalloc. If an error occurs
1334 or the transfer is unsupported, NULL is returned. Empty objects
1335 are returned as allocated but empty strings. A warning is issued
1336 if the result contains any embedded NUL bytes. */
1339 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1343 LONGEST transferred
;
1345 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1347 if (transferred
< 0)
1350 if (transferred
== 0)
1351 return xstrdup ("");
1353 buffer
[transferred
] = 0;
1354 if (strlen (buffer
) < transferred
)
1355 warning (_("target object %d, annex %s, "
1356 "contained unexpected null characters"),
1357 (int) object
, annex
? annex
: "(none)");
1359 return (char *) buffer
;
1362 /* Memory transfer methods. */
1365 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1368 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1370 memory_error (EIO
, addr
);
1374 get_target_memory_unsigned (struct target_ops
*ops
,
1375 CORE_ADDR addr
, int len
)
1377 gdb_byte buf
[sizeof (ULONGEST
)];
1379 gdb_assert (len
<= sizeof (buf
));
1380 get_target_memory (ops
, addr
, buf
, len
);
1381 return extract_unsigned_integer (buf
, len
);
1385 target_info (char *args
, int from_tty
)
1387 struct target_ops
*t
;
1388 int has_all_mem
= 0;
1390 if (symfile_objfile
!= NULL
)
1391 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1393 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1395 if (!t
->to_has_memory
)
1398 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1401 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1402 printf_unfiltered ("%s:\n", t
->to_longname
);
1403 (t
->to_files_info
) (t
);
1404 has_all_mem
= t
->to_has_all_memory
;
1408 /* This function is called before any new inferior is created, e.g.
1409 by running a program, attaching, or connecting to a target.
1410 It cleans up any state from previous invocations which might
1411 change between runs. This is a subset of what target_preopen
1412 resets (things which might change between targets). */
1415 target_pre_inferior (int from_tty
)
1417 invalidate_target_mem_regions ();
1420 /* This is to be called by the open routine before it does
1424 target_preopen (int from_tty
)
1428 if (target_has_execution
)
1431 || query (_("A program is being debugged already. Kill it? ")))
1434 error (_("Program not killed."));
1437 /* Calling target_kill may remove the target from the stack. But if
1438 it doesn't (which seems like a win for UDI), remove it now. */
1440 if (target_has_execution
)
1443 target_pre_inferior (from_tty
);
1446 /* Detach a target after doing deferred register stores. */
1449 target_detach (char *args
, int from_tty
)
1451 (current_target
.to_detach
) (args
, from_tty
);
1455 target_disconnect (char *args
, int from_tty
)
1457 struct target_ops
*t
;
1459 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1460 if (t
->to_disconnect
!= NULL
)
1463 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1465 t
->to_disconnect (t
, args
, from_tty
);
1473 target_async_mask (int mask
)
1475 int saved_async_masked_status
= target_async_mask_value
;
1476 target_async_mask_value
= mask
;
1477 return saved_async_masked_status
;
1480 /* Look through the list of possible targets for a target that can
1484 target_follow_fork (int follow_child
)
1486 struct target_ops
*t
;
1488 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1490 if (t
->to_follow_fork
!= NULL
)
1492 int retval
= t
->to_follow_fork (t
, follow_child
);
1494 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1495 follow_child
, retval
);
1500 /* Some target returned a fork event, but did not know how to follow it. */
1501 internal_error (__FILE__
, __LINE__
,
1502 "could not find a target to follow fork");
1505 /* Look through the list of possible targets for a target that can
1506 execute a run or attach command without any other data. This is
1507 used to locate the default process stratum.
1509 Result is always valid (error() is called for errors). */
1511 static struct target_ops
*
1512 find_default_run_target (char *do_mesg
)
1514 struct target_ops
**t
;
1515 struct target_ops
*runable
= NULL
;
1520 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1523 if ((*t
)->to_can_run
&& target_can_run (*t
))
1531 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1537 find_default_attach (char *args
, int from_tty
)
1539 struct target_ops
*t
;
1541 t
= find_default_run_target ("attach");
1542 (t
->to_attach
) (args
, from_tty
);
1547 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1550 struct target_ops
*t
;
1552 t
= find_default_run_target ("run");
1553 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1558 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1560 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1576 return_minus_one (void)
1582 * Resize the to_sections pointer. Also make sure that anyone that
1583 * was holding on to an old value of it gets updated.
1584 * Returns the old size.
1588 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1590 struct target_ops
**t
;
1591 struct section_table
*old_value
;
1594 old_value
= target
->to_sections
;
1596 if (target
->to_sections
)
1598 old_count
= target
->to_sections_end
- target
->to_sections
;
1599 target
->to_sections
= (struct section_table
*)
1600 xrealloc ((char *) target
->to_sections
,
1601 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1606 target
->to_sections
= (struct section_table
*)
1607 xmalloc ((sizeof (struct section_table
)) * num_added
);
1609 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1611 /* Check to see if anyone else was pointing to this structure.
1612 If old_value was null, then no one was. */
1616 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1619 if ((*t
)->to_sections
== old_value
)
1621 (*t
)->to_sections
= target
->to_sections
;
1622 (*t
)->to_sections_end
= target
->to_sections_end
;
1625 /* There is a flattened view of the target stack in current_target,
1626 so its to_sections pointer might also need updating. */
1627 if (current_target
.to_sections
== old_value
)
1629 current_target
.to_sections
= target
->to_sections
;
1630 current_target
.to_sections_end
= target
->to_sections_end
;
1638 /* Remove all target sections taken from ABFD.
1640 Scan the current target stack for targets whose section tables
1641 refer to sections from BFD, and remove those sections. We use this
1642 when we notice that the inferior has unloaded a shared object, for
1645 remove_target_sections (bfd
*abfd
)
1647 struct target_ops
**t
;
1649 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1651 struct section_table
*src
, *dest
;
1653 dest
= (*t
)->to_sections
;
1654 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1655 if (src
->bfd
!= abfd
)
1657 /* Keep this section. */
1658 if (dest
< src
) *dest
= *src
;
1662 /* If we've dropped any sections, resize the section table. */
1664 target_resize_to_sections (*t
, dest
- src
);
1671 /* Find a single runnable target in the stack and return it. If for
1672 some reason there is more than one, return NULL. */
1675 find_run_target (void)
1677 struct target_ops
**t
;
1678 struct target_ops
*runable
= NULL
;
1683 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1685 if ((*t
)->to_can_run
&& target_can_run (*t
))
1692 return (count
== 1 ? runable
: NULL
);
1695 /* Find a single core_stratum target in the list of targets and return it.
1696 If for some reason there is more than one, return NULL. */
1699 find_core_target (void)
1701 struct target_ops
**t
;
1702 struct target_ops
*runable
= NULL
;
1707 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1710 if ((*t
)->to_stratum
== core_stratum
)
1717 return (count
== 1 ? runable
: NULL
);
1721 * Find the next target down the stack from the specified target.
1725 find_target_beneath (struct target_ops
*t
)
1731 /* The inferior process has died. Long live the inferior! */
1734 generic_mourn_inferior (void)
1736 extern int show_breakpoint_hit_counts
;
1738 inferior_ptid
= null_ptid
;
1740 breakpoint_init_inferior (inf_exited
);
1741 registers_changed ();
1743 reopen_exec_file ();
1744 reinit_frame_cache ();
1746 /* It is confusing to the user for ignore counts to stick around
1747 from previous runs of the inferior. So clear them. */
1748 /* However, it is more confusing for the ignore counts to disappear when
1749 using hit counts. So don't clear them if we're counting hits. */
1750 if (!show_breakpoint_hit_counts
)
1751 breakpoint_clear_ignore_counts ();
1753 if (deprecated_detach_hook
)
1754 deprecated_detach_hook ();
1757 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1758 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1759 translation of that in OURSTATUS. */
1761 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1763 #ifdef CHILD_SPECIAL_WAITSTATUS
1764 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1765 if it wants to deal with hoststatus. */
1766 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1770 if (WIFEXITED (hoststatus
))
1772 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1773 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1775 else if (!WIFSTOPPED (hoststatus
))
1777 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1778 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1782 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1783 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1787 /* Returns zero to leave the inferior alone, one to interrupt it. */
1788 int (*target_activity_function
) (void);
1789 int target_activity_fd
;
1791 /* Convert a normal process ID to a string. Returns the string in a
1795 normal_pid_to_str (ptid_t ptid
)
1797 static char buf
[32];
1799 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1803 /* Error-catcher for target_find_memory_regions */
1804 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1806 error (_("No target."));
1810 /* Error-catcher for target_make_corefile_notes */
1811 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1813 error (_("No target."));
1817 /* Set up the handful of non-empty slots needed by the dummy target
1821 init_dummy_target (void)
1823 dummy_target
.to_shortname
= "None";
1824 dummy_target
.to_longname
= "None";
1825 dummy_target
.to_doc
= "";
1826 dummy_target
.to_attach
= find_default_attach
;
1827 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1828 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1829 dummy_target
.to_stratum
= dummy_stratum
;
1830 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1831 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1832 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1833 dummy_target
.to_magic
= OPS_MAGIC
;
1837 debug_to_open (char *args
, int from_tty
)
1839 debug_target
.to_open (args
, from_tty
);
1841 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1845 debug_to_close (int quitting
)
1847 target_close (&debug_target
, quitting
);
1848 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1852 target_close (struct target_ops
*targ
, int quitting
)
1854 if (targ
->to_xclose
!= NULL
)
1855 targ
->to_xclose (targ
, quitting
);
1856 else if (targ
->to_close
!= NULL
)
1857 targ
->to_close (quitting
);
1861 debug_to_attach (char *args
, int from_tty
)
1863 debug_target
.to_attach (args
, from_tty
);
1865 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1870 debug_to_post_attach (int pid
)
1872 debug_target
.to_post_attach (pid
);
1874 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1878 debug_to_detach (char *args
, int from_tty
)
1880 debug_target
.to_detach (args
, from_tty
);
1882 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1886 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1888 debug_target
.to_resume (ptid
, step
, siggnal
);
1890 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1891 step
? "step" : "continue",
1892 target_signal_to_name (siggnal
));
1896 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1900 retval
= debug_target
.to_wait (ptid
, status
);
1902 fprintf_unfiltered (gdb_stdlog
,
1903 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1905 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1906 switch (status
->kind
)
1908 case TARGET_WAITKIND_EXITED
:
1909 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1910 status
->value
.integer
);
1912 case TARGET_WAITKIND_STOPPED
:
1913 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1914 target_signal_to_name (status
->value
.sig
));
1916 case TARGET_WAITKIND_SIGNALLED
:
1917 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1918 target_signal_to_name (status
->value
.sig
));
1920 case TARGET_WAITKIND_LOADED
:
1921 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1923 case TARGET_WAITKIND_FORKED
:
1924 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1926 case TARGET_WAITKIND_VFORKED
:
1927 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1929 case TARGET_WAITKIND_EXECD
:
1930 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1932 case TARGET_WAITKIND_SPURIOUS
:
1933 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1936 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1944 debug_print_register (const char * func
, int regno
)
1946 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1947 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1948 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1949 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1951 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1955 unsigned char buf
[MAX_REGISTER_SIZE
];
1956 deprecated_read_register_gen (regno
, buf
);
1957 fprintf_unfiltered (gdb_stdlog
, " = ");
1958 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1960 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1962 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1964 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1965 paddr_nz (read_register (regno
)),
1966 paddr_d (read_register (regno
)));
1969 fprintf_unfiltered (gdb_stdlog
, "\n");
1973 debug_to_fetch_registers (int regno
)
1975 debug_target
.to_fetch_registers (regno
);
1976 debug_print_register ("target_fetch_registers", regno
);
1980 debug_to_store_registers (int regno
)
1982 debug_target
.to_store_registers (regno
);
1983 debug_print_register ("target_store_registers", regno
);
1984 fprintf_unfiltered (gdb_stdlog
, "\n");
1988 debug_to_prepare_to_store (void)
1990 debug_target
.to_prepare_to_store ();
1992 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1996 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
1997 int write
, struct mem_attrib
*attrib
,
1998 struct target_ops
*target
)
2002 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2005 fprintf_unfiltered (gdb_stdlog
,
2006 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2007 (unsigned int) memaddr
, /* possable truncate long long */
2008 len
, write
? "write" : "read", retval
);
2014 fputs_unfiltered (", bytes =", gdb_stdlog
);
2015 for (i
= 0; i
< retval
; i
++)
2017 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2019 if (targetdebug
< 2 && i
> 0)
2021 fprintf_unfiltered (gdb_stdlog
, " ...");
2024 fprintf_unfiltered (gdb_stdlog
, "\n");
2027 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2031 fputc_unfiltered ('\n', gdb_stdlog
);
2037 debug_to_files_info (struct target_ops
*target
)
2039 debug_target
.to_files_info (target
);
2041 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2045 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2049 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2051 fprintf_unfiltered (gdb_stdlog
,
2052 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2053 (unsigned long) bp_tgt
->placed_address
,
2054 (unsigned long) retval
);
2059 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2063 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2065 fprintf_unfiltered (gdb_stdlog
,
2066 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2067 (unsigned long) bp_tgt
->placed_address
,
2068 (unsigned long) retval
);
2073 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2077 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2079 fprintf_unfiltered (gdb_stdlog
,
2080 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2081 (unsigned long) type
,
2082 (unsigned long) cnt
,
2083 (unsigned long) from_tty
,
2084 (unsigned long) retval
);
2089 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2093 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2095 fprintf_unfiltered (gdb_stdlog
,
2096 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2097 (unsigned long) addr
,
2098 (unsigned long) len
,
2099 (unsigned long) retval
);
2104 debug_to_stopped_by_watchpoint (void)
2108 retval
= debug_target
.to_stopped_by_watchpoint ();
2110 fprintf_unfiltered (gdb_stdlog
,
2111 "STOPPED_BY_WATCHPOINT () = %ld\n",
2112 (unsigned long) retval
);
2117 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2121 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2123 fprintf_unfiltered (gdb_stdlog
,
2124 "target_stopped_data_address ([0x%lx]) = %ld\n",
2125 (unsigned long)*addr
,
2126 (unsigned long)retval
);
2131 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2135 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2137 fprintf_unfiltered (gdb_stdlog
,
2138 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2139 (unsigned long) bp_tgt
->placed_address
,
2140 (unsigned long) retval
);
2145 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2149 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2151 fprintf_unfiltered (gdb_stdlog
,
2152 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2153 (unsigned long) bp_tgt
->placed_address
,
2154 (unsigned long) retval
);
2159 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2163 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2165 fprintf_unfiltered (gdb_stdlog
,
2166 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2167 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2172 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2176 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2178 fprintf_unfiltered (gdb_stdlog
,
2179 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2180 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2185 debug_to_terminal_init (void)
2187 debug_target
.to_terminal_init ();
2189 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2193 debug_to_terminal_inferior (void)
2195 debug_target
.to_terminal_inferior ();
2197 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2201 debug_to_terminal_ours_for_output (void)
2203 debug_target
.to_terminal_ours_for_output ();
2205 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2209 debug_to_terminal_ours (void)
2211 debug_target
.to_terminal_ours ();
2213 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2217 debug_to_terminal_save_ours (void)
2219 debug_target
.to_terminal_save_ours ();
2221 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2225 debug_to_terminal_info (char *arg
, int from_tty
)
2227 debug_target
.to_terminal_info (arg
, from_tty
);
2229 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2234 debug_to_kill (void)
2236 debug_target
.to_kill ();
2238 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2242 debug_to_load (char *args
, int from_tty
)
2244 debug_target
.to_load (args
, from_tty
);
2246 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2250 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2254 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2256 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2262 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2265 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2267 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2268 exec_file
, args
, from_tty
);
2272 debug_to_post_startup_inferior (ptid_t ptid
)
2274 debug_target
.to_post_startup_inferior (ptid
);
2276 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2281 debug_to_acknowledge_created_inferior (int pid
)
2283 debug_target
.to_acknowledge_created_inferior (pid
);
2285 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2290 debug_to_insert_fork_catchpoint (int pid
)
2292 debug_target
.to_insert_fork_catchpoint (pid
);
2294 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2299 debug_to_remove_fork_catchpoint (int pid
)
2303 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2305 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2312 debug_to_insert_vfork_catchpoint (int pid
)
2314 debug_target
.to_insert_vfork_catchpoint (pid
);
2316 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2321 debug_to_remove_vfork_catchpoint (int pid
)
2325 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2327 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2334 debug_to_insert_exec_catchpoint (int pid
)
2336 debug_target
.to_insert_exec_catchpoint (pid
);
2338 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2343 debug_to_remove_exec_catchpoint (int pid
)
2347 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2349 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2356 debug_to_reported_exec_events_per_exec_call (void)
2358 int reported_exec_events
;
2360 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2362 fprintf_unfiltered (gdb_stdlog
,
2363 "target_reported_exec_events_per_exec_call () = %d\n",
2364 reported_exec_events
);
2366 return reported_exec_events
;
2370 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2374 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2376 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2377 pid
, wait_status
, *exit_status
, has_exited
);
2383 debug_to_mourn_inferior (void)
2385 debug_target
.to_mourn_inferior ();
2387 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2391 debug_to_can_run (void)
2395 retval
= debug_target
.to_can_run ();
2397 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2403 debug_to_notice_signals (ptid_t ptid
)
2405 debug_target
.to_notice_signals (ptid
);
2407 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2412 debug_to_thread_alive (ptid_t ptid
)
2416 retval
= debug_target
.to_thread_alive (ptid
);
2418 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2419 PIDGET (ptid
), retval
);
2425 debug_to_find_new_threads (void)
2427 debug_target
.to_find_new_threads ();
2429 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2433 debug_to_stop (void)
2435 debug_target
.to_stop ();
2437 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2441 debug_to_rcmd (char *command
,
2442 struct ui_file
*outbuf
)
2444 debug_target
.to_rcmd (command
, outbuf
);
2445 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2448 static struct symtab_and_line
*
2449 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2451 struct symtab_and_line
*result
;
2452 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2453 fprintf_unfiltered (gdb_stdlog
,
2454 "target get_exception_callback_sal (%d, %d)\n",
2459 static struct exception_event_record
*
2460 debug_to_get_current_exception_event (void)
2462 struct exception_event_record
*result
;
2463 result
= debug_target
.to_get_current_exception_event ();
2464 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2469 debug_to_pid_to_exec_file (int pid
)
2473 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2475 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2482 setup_target_debug (void)
2484 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2486 current_target
.to_open
= debug_to_open
;
2487 current_target
.to_close
= debug_to_close
;
2488 current_target
.to_attach
= debug_to_attach
;
2489 current_target
.to_post_attach
= debug_to_post_attach
;
2490 current_target
.to_detach
= debug_to_detach
;
2491 current_target
.to_resume
= debug_to_resume
;
2492 current_target
.to_wait
= debug_to_wait
;
2493 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2494 current_target
.to_store_registers
= debug_to_store_registers
;
2495 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2496 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2497 current_target
.to_files_info
= debug_to_files_info
;
2498 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2499 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2500 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2501 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2502 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2503 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2504 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2505 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2506 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2507 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2508 current_target
.to_terminal_init
= debug_to_terminal_init
;
2509 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2510 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2511 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2512 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2513 current_target
.to_terminal_info
= debug_to_terminal_info
;
2514 current_target
.to_kill
= debug_to_kill
;
2515 current_target
.to_load
= debug_to_load
;
2516 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2517 current_target
.to_create_inferior
= debug_to_create_inferior
;
2518 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2519 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2520 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2521 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2522 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2523 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2524 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2525 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2526 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2527 current_target
.to_has_exited
= debug_to_has_exited
;
2528 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2529 current_target
.to_can_run
= debug_to_can_run
;
2530 current_target
.to_notice_signals
= debug_to_notice_signals
;
2531 current_target
.to_thread_alive
= debug_to_thread_alive
;
2532 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2533 current_target
.to_stop
= debug_to_stop
;
2534 current_target
.to_rcmd
= debug_to_rcmd
;
2535 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2536 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2537 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2541 static char targ_desc
[] =
2542 "Names of targets and files being debugged.\n\
2543 Shows the entire stack of targets currently in use (including the exec-file,\n\
2544 core-file, and process, if any), as well as the symbol file name.";
2547 do_monitor_command (char *cmd
,
2550 if ((current_target
.to_rcmd
2551 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2552 || (current_target
.to_rcmd
== debug_to_rcmd
2553 && (debug_target
.to_rcmd
2554 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2555 error (_("\"monitor\" command not supported by this target."));
2556 target_rcmd (cmd
, gdb_stdtarg
);
2560 initialize_targets (void)
2562 init_dummy_target ();
2563 push_target (&dummy_target
);
2565 add_info ("target", target_info
, targ_desc
);
2566 add_info ("files", target_info
, targ_desc
);
2568 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2569 Set target debugging."), _("\
2570 Show target debugging."), _("\
2571 When non-zero, target debugging is enabled. Higher numbers are more\n\
2572 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2576 &setdebuglist
, &showdebuglist
);
2578 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2579 &trust_readonly
, _("\
2580 Set mode for reading from readonly sections."), _("\
2581 Show mode for reading from readonly sections."), _("\
2582 When this mode is on, memory reads from readonly sections (such as .text)\n\
2583 will be read from the object file instead of from the target. This will\n\
2584 result in significant performance improvement for remote targets."),
2586 show_trust_readonly
,
2587 &setlist
, &showlist
);
2589 add_com ("monitor", class_obscure
, do_monitor_command
,
2590 _("Send a command to the remote monitor (remote targets only)."));
2592 target_dcache
= dcache_init ();