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 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_create_inferior (char *, char *, char **);
46 static void maybe_kill_then_attach (char *, int);
48 static void kill_or_be_killed (int);
50 static void default_terminal_info (char *, int);
52 static int default_region_size_ok_for_hw_watchpoint (int);
54 static int nosymbol (char *, CORE_ADDR
*);
56 static void tcomplain (void);
58 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
60 static int return_zero (void);
62 static int return_one (void);
64 static int return_minus_one (void);
66 void target_ignore (void);
68 static void target_command (char *, int);
70 static struct target_ops
*find_default_run_target (char *);
72 static void nosupport_runtime (void);
74 static void normal_target_post_startup_inferior (ptid_t ptid
);
76 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
77 enum target_object object
,
78 const char *annex
, void *readbuf
,
80 ULONGEST offset
, LONGEST len
);
82 /* Transfer LEN bytes between target address MEMADDR and GDB address
83 MYADDR. Returns 0 for success, errno code for failure (which
84 includes partial transfers -- if you want a more useful response to
85 partial transfers, try either target_read_memory_partial or
86 target_write_memory_partial). */
88 static int target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
91 static void init_dummy_target (void);
93 static void debug_to_open (char *, int);
95 static void debug_to_close (int);
97 static void debug_to_attach (char *, int);
99 static void debug_to_detach (char *, int);
101 static void debug_to_disconnect (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 int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
114 struct mem_attrib
*, struct target_ops
*);
116 static void debug_to_files_info (struct target_ops
*);
118 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
120 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
122 static int debug_to_can_use_hw_breakpoint (int, int, int);
124 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
126 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
128 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
130 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
132 static int debug_to_stopped_by_watchpoint (void);
134 static CORE_ADDR
debug_to_stopped_data_address (void);
136 static int debug_to_region_size_ok_for_hw_watchpoint (int);
138 static void debug_to_terminal_init (void);
140 static void debug_to_terminal_inferior (void);
142 static void debug_to_terminal_ours_for_output (void);
144 static void debug_to_terminal_save_ours (void);
146 static void debug_to_terminal_ours (void);
148 static void debug_to_terminal_info (char *, int);
150 static void debug_to_kill (void);
152 static void debug_to_load (char *, int);
154 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
156 static void debug_to_create_inferior (char *, char *, char **);
158 static void debug_to_mourn_inferior (void);
160 static int debug_to_can_run (void);
162 static void debug_to_notice_signals (ptid_t
);
164 static int debug_to_thread_alive (ptid_t
);
166 static void debug_to_stop (void);
168 /* Pointer to array of target architecture structures; the size of the
169 array; the current index into the array; the allocated size of the
171 struct target_ops
**target_structs
;
172 unsigned target_struct_size
;
173 unsigned target_struct_index
;
174 unsigned target_struct_allocsize
;
175 #define DEFAULT_ALLOCSIZE 10
177 /* The initial current target, so that there is always a semi-valid
180 static struct target_ops dummy_target
;
182 /* Top of target stack. */
184 static struct target_ops
*target_stack
;
186 /* The target structure we are currently using to talk to a process
187 or file or whatever "inferior" we have. */
189 struct target_ops current_target
;
191 /* Command list for target. */
193 static struct cmd_list_element
*targetlist
= NULL
;
195 /* Nonzero if we are debugging an attached outside process
196 rather than an inferior. */
200 /* Non-zero if we want to see trace of target level stuff. */
202 static int targetdebug
= 0;
204 static void setup_target_debug (void);
206 DCACHE
*target_dcache
;
208 /* The user just typed 'target' without the name of a target. */
211 target_command (char *arg
, int from_tty
)
213 fputs_filtered ("Argument required (target name). Try `help target'\n",
217 /* Add a possible target architecture to the list. */
220 add_target (struct target_ops
*t
)
222 /* Provide default values for all "must have" methods. */
223 if (t
->to_xfer_partial
== NULL
)
224 t
->to_xfer_partial
= default_xfer_partial
;
228 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
229 target_structs
= (struct target_ops
**) xmalloc
230 (target_struct_allocsize
* sizeof (*target_structs
));
232 if (target_struct_size
>= target_struct_allocsize
)
234 target_struct_allocsize
*= 2;
235 target_structs
= (struct target_ops
**)
236 xrealloc ((char *) target_structs
,
237 target_struct_allocsize
* sizeof (*target_structs
));
239 target_structs
[target_struct_size
++] = t
;
241 if (targetlist
== NULL
)
242 add_prefix_cmd ("target", class_run
, target_command
,
243 "Connect to a target machine or process.\n\
244 The first argument is the type or protocol of the target machine.\n\
245 Remaining arguments are interpreted by the target protocol. For more\n\
246 information on the arguments for a particular protocol, type\n\
247 `help target ' followed by the protocol name.",
248 &targetlist
, "target ", 0, &cmdlist
);
249 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
260 target_load (char *arg
, int from_tty
)
262 dcache_invalidate (target_dcache
);
263 (*current_target
.to_load
) (arg
, from_tty
);
267 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
268 struct target_ops
*t
)
270 errno
= EIO
; /* Can't read/write this location */
271 return 0; /* No bytes handled */
277 error ("You can't do that when your target is `%s'",
278 current_target
.to_shortname
);
284 error ("You can't do that without a process to debug.");
288 nosymbol (char *name
, CORE_ADDR
*addrp
)
290 return 1; /* Symbol does not exist in target env */
294 nosupport_runtime (void)
296 if (ptid_equal (inferior_ptid
, null_ptid
))
299 error ("No run-time support for this");
304 default_terminal_info (char *args
, int from_tty
)
306 printf_unfiltered ("No saved terminal information.\n");
309 /* This is the default target_create_inferior and target_attach function.
310 If the current target is executing, it asks whether to kill it off.
311 If this function returns without calling error(), it has killed off
312 the target, and the operation should be attempted. */
315 kill_or_be_killed (int from_tty
)
317 if (target_has_execution
)
319 printf_unfiltered ("You are already running a program:\n");
320 target_files_info ();
321 if (query ("Kill it? "))
324 if (target_has_execution
)
325 error ("Killing the program did not help.");
330 error ("Program not killed.");
337 maybe_kill_then_attach (char *args
, int from_tty
)
339 kill_or_be_killed (from_tty
);
340 target_attach (args
, from_tty
);
344 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
346 kill_or_be_killed (0);
347 target_create_inferior (exec
, args
, env
);
350 /* Go through the target stack from top to bottom, copying over zero
351 entries in current_target, then filling in still empty entries. In
352 effect, we are doing class inheritance through the pushed target
355 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
356 is currently implemented, is that it discards any knowledge of
357 which target an inherited method originally belonged to.
358 Consequently, new new target methods should instead explicitly and
359 locally search the target stack for the target that can handle the
363 update_current_target (void)
365 struct target_ops
*t
;
367 /* First, reset curren'ts contents. */
368 memset (¤t_target
, 0, sizeof (current_target
));
370 #define INHERIT(FIELD, TARGET) \
371 if (!current_target.FIELD) \
372 current_target.FIELD = (TARGET)->FIELD
374 for (t
= target_stack
; t
; t
= t
->beneath
)
376 INHERIT (to_shortname
, t
);
377 INHERIT (to_longname
, t
);
379 INHERIT (to_open
, t
);
380 INHERIT (to_close
, t
);
381 INHERIT (to_attach
, t
);
382 INHERIT (to_post_attach
, t
);
383 INHERIT (to_detach
, t
);
384 INHERIT (to_disconnect
, t
);
385 INHERIT (to_resume
, t
);
386 INHERIT (to_wait
, t
);
387 INHERIT (to_post_wait
, t
);
388 INHERIT (to_fetch_registers
, t
);
389 INHERIT (to_store_registers
, t
);
390 INHERIT (to_prepare_to_store
, t
);
391 INHERIT (to_xfer_memory
, t
);
392 INHERIT (to_files_info
, t
);
393 INHERIT (to_insert_breakpoint
, t
);
394 INHERIT (to_remove_breakpoint
, t
);
395 INHERIT (to_can_use_hw_breakpoint
, t
);
396 INHERIT (to_insert_hw_breakpoint
, t
);
397 INHERIT (to_remove_hw_breakpoint
, t
);
398 INHERIT (to_insert_watchpoint
, t
);
399 INHERIT (to_remove_watchpoint
, t
);
400 INHERIT (to_stopped_data_address
, t
);
401 INHERIT (to_stopped_by_watchpoint
, t
);
402 INHERIT (to_have_continuable_watchpoint
, t
);
403 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
404 INHERIT (to_terminal_init
, t
);
405 INHERIT (to_terminal_inferior
, t
);
406 INHERIT (to_terminal_ours_for_output
, t
);
407 INHERIT (to_terminal_ours
, t
);
408 INHERIT (to_terminal_save_ours
, t
);
409 INHERIT (to_terminal_info
, t
);
410 INHERIT (to_kill
, t
);
411 INHERIT (to_load
, t
);
412 INHERIT (to_lookup_symbol
, t
);
413 INHERIT (to_create_inferior
, t
);
414 INHERIT (to_post_startup_inferior
, t
);
415 INHERIT (to_acknowledge_created_inferior
, t
);
416 INHERIT (to_insert_fork_catchpoint
, t
);
417 INHERIT (to_remove_fork_catchpoint
, t
);
418 INHERIT (to_insert_vfork_catchpoint
, t
);
419 INHERIT (to_remove_vfork_catchpoint
, t
);
420 INHERIT (to_follow_fork
, t
);
421 INHERIT (to_insert_exec_catchpoint
, t
);
422 INHERIT (to_remove_exec_catchpoint
, t
);
423 INHERIT (to_reported_exec_events_per_exec_call
, t
);
424 INHERIT (to_has_exited
, t
);
425 INHERIT (to_mourn_inferior
, t
);
426 INHERIT (to_can_run
, t
);
427 INHERIT (to_notice_signals
, t
);
428 INHERIT (to_thread_alive
, t
);
429 INHERIT (to_find_new_threads
, t
);
430 INHERIT (to_pid_to_str
, t
);
431 INHERIT (to_extra_thread_info
, t
);
432 INHERIT (to_stop
, t
);
433 /* Do not inherit to_xfer_partial. */
434 INHERIT (to_rcmd
, t
);
435 INHERIT (to_enable_exception_callback
, t
);
436 INHERIT (to_get_current_exception_event
, t
);
437 INHERIT (to_pid_to_exec_file
, t
);
438 INHERIT (to_stratum
, t
);
439 INHERIT (to_has_all_memory
, t
);
440 INHERIT (to_has_memory
, t
);
441 INHERIT (to_has_stack
, t
);
442 INHERIT (to_has_registers
, t
);
443 INHERIT (to_has_execution
, t
);
444 INHERIT (to_has_thread_control
, t
);
445 INHERIT (to_sections
, t
);
446 INHERIT (to_sections_end
, t
);
447 INHERIT (to_can_async_p
, t
);
448 INHERIT (to_is_async_p
, t
);
449 INHERIT (to_async
, t
);
450 INHERIT (to_async_mask_value
, t
);
451 INHERIT (to_find_memory_regions
, t
);
452 INHERIT (to_make_corefile_notes
, t
);
453 INHERIT (to_get_thread_local_address
, t
);
454 INHERIT (to_magic
, t
);
458 /* Clean up a target struct so it no longer has any zero pointers in
459 it. Some entries are defaulted to a method that print an error,
460 others are hard-wired to a standard recursive default. */
462 #define de_fault(field, value) \
463 if (!current_target.field) \
464 current_target.field = value
467 (void (*) (char *, int))
473 maybe_kill_then_attach
);
474 de_fault (to_post_attach
,
478 (void (*) (char *, int))
480 de_fault (to_disconnect
,
481 (void (*) (char *, int))
484 (void (*) (ptid_t
, int, enum target_signal
))
487 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
489 de_fault (to_post_wait
,
490 (void (*) (ptid_t
, int))
492 de_fault (to_fetch_registers
,
495 de_fault (to_store_registers
,
498 de_fault (to_prepare_to_store
,
501 de_fault (to_xfer_memory
,
502 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
504 de_fault (to_files_info
,
505 (void (*) (struct target_ops
*))
507 de_fault (to_insert_breakpoint
,
508 memory_insert_breakpoint
);
509 de_fault (to_remove_breakpoint
,
510 memory_remove_breakpoint
);
511 de_fault (to_can_use_hw_breakpoint
,
512 (int (*) (int, int, int))
514 de_fault (to_insert_hw_breakpoint
,
515 (int (*) (CORE_ADDR
, char *))
517 de_fault (to_remove_hw_breakpoint
,
518 (int (*) (CORE_ADDR
, char *))
520 de_fault (to_insert_watchpoint
,
521 (int (*) (CORE_ADDR
, int, int))
523 de_fault (to_remove_watchpoint
,
524 (int (*) (CORE_ADDR
, int, int))
526 de_fault (to_stopped_by_watchpoint
,
529 de_fault (to_stopped_data_address
,
530 (CORE_ADDR (*) (void))
532 de_fault (to_region_size_ok_for_hw_watchpoint
,
533 default_region_size_ok_for_hw_watchpoint
);
534 de_fault (to_terminal_init
,
537 de_fault (to_terminal_inferior
,
540 de_fault (to_terminal_ours_for_output
,
543 de_fault (to_terminal_ours
,
546 de_fault (to_terminal_save_ours
,
549 de_fault (to_terminal_info
,
550 default_terminal_info
);
555 (void (*) (char *, int))
557 de_fault (to_lookup_symbol
,
558 (int (*) (char *, CORE_ADDR
*))
560 de_fault (to_create_inferior
,
561 maybe_kill_then_create_inferior
);
562 de_fault (to_post_startup_inferior
,
565 de_fault (to_acknowledge_created_inferior
,
568 de_fault (to_insert_fork_catchpoint
,
571 de_fault (to_remove_fork_catchpoint
,
574 de_fault (to_insert_vfork_catchpoint
,
577 de_fault (to_remove_vfork_catchpoint
,
580 de_fault (to_follow_fork
,
583 de_fault (to_insert_exec_catchpoint
,
586 de_fault (to_remove_exec_catchpoint
,
589 de_fault (to_reported_exec_events_per_exec_call
,
592 de_fault (to_has_exited
,
593 (int (*) (int, int, int *))
595 de_fault (to_mourn_inferior
,
598 de_fault (to_can_run
,
600 de_fault (to_notice_signals
,
603 de_fault (to_thread_alive
,
606 de_fault (to_find_new_threads
,
609 de_fault (to_extra_thread_info
,
610 (char *(*) (struct thread_info
*))
615 current_target
.to_xfer_partial
= default_xfer_partial
;
617 (void (*) (char *, struct ui_file
*))
619 de_fault (to_enable_exception_callback
,
620 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
622 de_fault (to_get_current_exception_event
,
623 (struct exception_event_record
* (*) (void))
625 de_fault (to_pid_to_exec_file
,
628 de_fault (to_can_async_p
,
631 de_fault (to_is_async_p
,
635 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
639 /* Finally, position the target-stack beneath the squashed
640 "current_target". That way code looking for a non-inherited
641 target method can quickly and simply find it. */
642 current_target
.beneath
= target_stack
;
645 /* Push a new target type into the stack of the existing target accessors,
646 possibly superseding some of the existing accessors.
648 Result is zero if the pushed target ended up on top of the stack,
649 nonzero if at least one target is on top of it.
651 Rather than allow an empty stack, we always have the dummy target at
652 the bottom stratum, so we can call the function vectors without
656 push_target (struct target_ops
*t
)
658 struct target_ops
**cur
;
660 /* Check magic number. If wrong, it probably means someone changed
661 the struct definition, but not all the places that initialize one. */
662 if (t
->to_magic
!= OPS_MAGIC
)
664 fprintf_unfiltered (gdb_stderr
,
665 "Magic number of %s target struct wrong\n",
667 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
670 /* Find the proper stratum to install this target in. */
671 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
673 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
677 /* If there's already targets at this stratum, remove them. */
678 /* FIXME: cagney/2003-10-15: I think this should be poping all
679 targets to CUR, and not just those at this stratum level. */
680 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
682 /* There's already something at this stratum level. Close it,
683 and un-hook it from the stack. */
684 struct target_ops
*tmp
= (*cur
);
685 (*cur
) = (*cur
)->beneath
;
687 target_close (tmp
, 0);
690 /* We have removed all targets in our stratum, now add the new one. */
694 update_current_target ();
697 setup_target_debug ();
700 return (t
!= target_stack
);
703 /* Remove a target_ops vector from the stack, wherever it may be.
704 Return how many times it was removed (0 or 1). */
707 unpush_target (struct target_ops
*t
)
709 struct target_ops
**cur
;
710 struct target_ops
*tmp
;
712 /* Look for the specified target. Note that we assume that a target
713 can only occur once in the target stack. */
715 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
722 return 0; /* Didn't find target_ops, quit now */
724 /* NOTE: cagney/2003-12-06: In '94 the close call was made
725 unconditional by moving it to before the above check that the
726 target was in the target stack (something about "Change the way
727 pushing and popping of targets work to support target overlays
728 and inheritance"). This doesn't make much sense - only open
729 targets should be closed. */
732 /* Unchain the target */
734 (*cur
) = (*cur
)->beneath
;
737 update_current_target ();
745 target_close (¤t_target
, 0); /* Let it clean up */
746 if (unpush_target (target_stack
) == 1)
749 fprintf_unfiltered (gdb_stderr
,
750 "pop_target couldn't find target %s\n",
751 current_target
.to_shortname
);
752 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
756 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
758 /* target_read_string -- read a null terminated string, up to LEN bytes,
759 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
760 Set *STRING to a pointer to malloc'd memory containing the data; the caller
761 is responsible for freeing it. Return the number of bytes successfully
765 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
767 int tlen
, origlen
, offset
, i
;
771 int buffer_allocated
;
773 unsigned int nbytes_read
= 0;
775 /* Small for testing. */
776 buffer_allocated
= 4;
777 buffer
= xmalloc (buffer_allocated
);
784 tlen
= MIN (len
, 4 - (memaddr
& 3));
785 offset
= memaddr
& 3;
787 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
790 /* The transfer request might have crossed the boundary to an
791 unallocated region of memory. Retry the transfer, requesting
795 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
800 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
803 bytes
= bufptr
- buffer
;
804 buffer_allocated
*= 2;
805 buffer
= xrealloc (buffer
, buffer_allocated
);
806 bufptr
= buffer
+ bytes
;
809 for (i
= 0; i
< tlen
; i
++)
811 *bufptr
++ = buf
[i
+ offset
];
812 if (buf
[i
+ offset
] == '\000')
814 nbytes_read
+= i
+ 1;
831 /* Find a section containing ADDR. */
832 struct section_table
*
833 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
835 struct section_table
*secp
;
836 for (secp
= target
->to_sections
;
837 secp
< target
->to_sections_end
;
840 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
846 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
847 GDB's memory at MYADDR. Returns either 0 for success or an errno value
850 If an error occurs, no guarantee is made about the contents of the data at
851 MYADDR. In particular, the caller should not depend upon partial reads
852 filling the buffer with good data. There is no way for the caller to know
853 how much good data might have been transfered anyway. Callers that can
854 deal with partial reads should call target_read_memory_partial. */
857 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
859 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
863 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
865 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
868 static int trust_readonly
= 0;
870 /* Move memory to or from the targets. The top target gets priority;
871 if it cannot handle it, it is offered to the next one down, etc.
873 Result is -1 on error, or the number of bytes transfered. */
876 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
877 struct mem_attrib
*attrib
)
881 struct target_ops
*t
;
883 /* Zero length requests are ok and require no work. */
887 /* to_xfer_memory is not guaranteed to set errno, even when it returns
891 if (!write
&& trust_readonly
)
893 struct section_table
*secp
;
894 /* User-settable option, "trust-readonly-sections". If true,
895 then memory from any SEC_READONLY bfd section may be read
896 directly from the bfd file. */
897 secp
= target_section_by_addr (¤t_target
, memaddr
);
899 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
901 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
904 /* The quick case is that the top target can handle the transfer. */
905 res
= current_target
.to_xfer_memory
906 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
908 /* If res <= 0 then we call it again in the loop. Ah well. */
911 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
913 if (!t
->to_has_memory
)
916 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
918 break; /* Handled all or part of xfer */
919 if (t
->to_has_all_memory
)
931 /* Perform a memory transfer. Iterate until the entire region has
934 Result is 0 or errno value. */
937 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
941 struct mem_region
*region
;
943 /* Zero length requests are ok and require no work. */
951 region
= lookup_mem_region(memaddr
);
952 if (memaddr
+ len
< region
->hi
)
955 reg_len
= region
->hi
- memaddr
;
957 switch (region
->attrib
.mode
)
972 if (region
->attrib
.cache
)
973 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
976 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
981 /* If this address is for nonexistent memory, read zeros
982 if reading, or do nothing if writing. Return
985 memset (myaddr
, 0, len
);
999 return 0; /* We managed to cover it all somehow. */
1003 /* Perform a partial memory transfer.
1005 Result is -1 on error, or the number of bytes transfered. */
1008 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1009 int write_p
, int *err
)
1013 struct mem_region
*region
;
1015 /* Zero length requests are ok and require no work. */
1022 region
= lookup_mem_region(memaddr
);
1023 if (memaddr
+ len
< region
->hi
)
1026 reg_len
= region
->hi
- memaddr
;
1028 switch (region
->attrib
.mode
)
1047 if (region
->attrib
.cache
)
1048 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1051 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1069 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1071 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1075 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1077 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1080 /* More generic transfers. */
1083 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1084 const char *annex
, void *readbuf
,
1085 const void *writebuf
, ULONGEST offset
, LONGEST len
)
1087 if (object
== TARGET_OBJECT_MEMORY
1088 && ops
->to_xfer_memory
!= NULL
)
1089 /* If available, fall back to the target's "to_xfer_memory"
1094 if (writebuf
!= NULL
)
1096 void *buffer
= xmalloc (len
);
1097 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1098 memcpy (buffer
, writebuf
, len
);
1099 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1101 do_cleanups (cleanup
);
1103 if (readbuf
!= NULL
)
1104 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1108 else if (xfered
== 0 && errno
== 0)
1109 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1110 indication of an error. */
1115 else if (ops
->beneath
!= NULL
)
1116 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1117 readbuf
, writebuf
, offset
, len
);
1122 /* Target vector read/write partial wrapper functions.
1124 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1125 (inbuf, outbuf)", instead of separate read/write methods, make life
1129 target_read_partial (struct target_ops
*ops
,
1130 enum target_object object
,
1131 const char *annex
, void *buf
,
1132 ULONGEST offset
, LONGEST len
)
1134 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1135 return ops
->to_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1139 target_write_partial (struct target_ops
*ops
,
1140 enum target_object object
,
1141 const char *annex
, const void *buf
,
1142 ULONGEST offset
, LONGEST len
)
1144 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1145 return ops
->to_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1148 /* Wrappers to perform the full transfer. */
1150 target_read (struct target_ops
*ops
,
1151 enum target_object object
,
1152 const char *annex
, void *buf
,
1153 ULONGEST offset
, LONGEST len
)
1156 while (xfered
< len
)
1158 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1159 (bfd_byte
*) buf
+ xfered
,
1160 offset
+ xfered
, len
- xfered
);
1161 /* Call an observer, notifying them of the xfer progress? */
1163 /* Call memory_error? */
1172 target_write (struct target_ops
*ops
,
1173 enum target_object object
,
1174 const char *annex
, const void *buf
,
1175 ULONGEST offset
, LONGEST len
)
1178 while (xfered
< len
)
1180 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1181 (bfd_byte
*) buf
+ xfered
,
1182 offset
+ xfered
, len
- xfered
);
1183 /* Call an observer, notifying them of the xfer progress? */
1185 /* Call memory_error? */
1193 /* Memory transfer methods. */
1196 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1199 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1201 memory_error (EIO
, addr
);
1205 get_target_memory_unsigned (struct target_ops
*ops
,
1206 CORE_ADDR addr
, int len
)
1208 char buf
[sizeof (ULONGEST
)];
1210 gdb_assert (len
<= sizeof (buf
));
1211 get_target_memory (ops
, addr
, buf
, len
);
1212 return extract_unsigned_integer (buf
, len
);
1216 target_info (char *args
, int from_tty
)
1218 struct target_ops
*t
;
1219 int has_all_mem
= 0;
1221 if (symfile_objfile
!= NULL
)
1222 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1224 #ifdef FILES_INFO_HOOK
1225 if (FILES_INFO_HOOK ())
1229 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1231 if (!t
->to_has_memory
)
1234 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1237 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1238 printf_unfiltered ("%s:\n", t
->to_longname
);
1239 (t
->to_files_info
) (t
);
1240 has_all_mem
= t
->to_has_all_memory
;
1244 /* This is to be called by the open routine before it does
1248 target_preopen (int from_tty
)
1252 if (target_has_execution
)
1255 || query ("A program is being debugged already. Kill it? "))
1258 error ("Program not killed.");
1261 /* Calling target_kill may remove the target from the stack. But if
1262 it doesn't (which seems like a win for UDI), remove it now. */
1264 if (target_has_execution
)
1268 /* Detach a target after doing deferred register stores. */
1271 target_detach (char *args
, int from_tty
)
1273 /* Handle any optimized stores to the inferior. */
1274 #ifdef DO_DEFERRED_STORES
1277 (current_target
.to_detach
) (args
, from_tty
);
1281 target_disconnect (char *args
, int from_tty
)
1283 /* Handle any optimized stores to the inferior. */
1284 #ifdef DO_DEFERRED_STORES
1287 (current_target
.to_disconnect
) (args
, from_tty
);
1291 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1293 if (DEPRECATED_STREQ (current_target
.to_shortname
, "rombug"))
1295 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1297 error ("Unable to link to %s and get relocation in rombug", modname
);
1300 *t_reloc
= (CORE_ADDR
) -1;
1304 target_async_mask (int mask
)
1306 int saved_async_masked_status
= target_async_mask_value
;
1307 target_async_mask_value
= mask
;
1308 return saved_async_masked_status
;
1311 /* Look through the list of possible targets for a target that can
1312 execute a run or attach command without any other data. This is
1313 used to locate the default process stratum.
1315 Result is always valid (error() is called for errors). */
1317 static struct target_ops
*
1318 find_default_run_target (char *do_mesg
)
1320 struct target_ops
**t
;
1321 struct target_ops
*runable
= NULL
;
1326 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1329 if ((*t
)->to_can_run
&& target_can_run (*t
))
1337 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1343 find_default_attach (char *args
, int from_tty
)
1345 struct target_ops
*t
;
1347 t
= find_default_run_target ("attach");
1348 (t
->to_attach
) (args
, from_tty
);
1353 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1355 struct target_ops
*t
;
1357 t
= find_default_run_target ("run");
1358 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1363 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1365 return (byte_count
<= DEPRECATED_REGISTER_SIZE
);
1381 return_minus_one (void)
1387 * Resize the to_sections pointer. Also make sure that anyone that
1388 * was holding on to an old value of it gets updated.
1389 * Returns the old size.
1393 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1395 struct target_ops
**t
;
1396 struct section_table
*old_value
;
1399 old_value
= target
->to_sections
;
1401 if (target
->to_sections
)
1403 old_count
= target
->to_sections_end
- target
->to_sections
;
1404 target
->to_sections
= (struct section_table
*)
1405 xrealloc ((char *) target
->to_sections
,
1406 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1411 target
->to_sections
= (struct section_table
*)
1412 xmalloc ((sizeof (struct section_table
)) * num_added
);
1414 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1416 /* Check to see if anyone else was pointing to this structure.
1417 If old_value was null, then no one was. */
1421 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1424 if ((*t
)->to_sections
== old_value
)
1426 (*t
)->to_sections
= target
->to_sections
;
1427 (*t
)->to_sections_end
= target
->to_sections_end
;
1436 /* Remove all target sections taken from ABFD.
1438 Scan the current target stack for targets whose section tables
1439 refer to sections from BFD, and remove those sections. We use this
1440 when we notice that the inferior has unloaded a shared object, for
1443 remove_target_sections (bfd
*abfd
)
1445 struct target_ops
**t
;
1447 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1449 struct section_table
*src
, *dest
;
1451 dest
= (*t
)->to_sections
;
1452 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1453 if (src
->bfd
!= abfd
)
1455 /* Keep this section. */
1456 if (dest
< src
) *dest
= *src
;
1460 /* If we've dropped any sections, resize the section table. */
1462 target_resize_to_sections (*t
, dest
- src
);
1469 /* Find a single runnable target in the stack and return it. If for
1470 some reason there is more than one, return NULL. */
1473 find_run_target (void)
1475 struct target_ops
**t
;
1476 struct target_ops
*runable
= NULL
;
1481 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1483 if ((*t
)->to_can_run
&& target_can_run (*t
))
1490 return (count
== 1 ? runable
: NULL
);
1493 /* Find a single core_stratum target in the list of targets and return it.
1494 If for some reason there is more than one, return NULL. */
1497 find_core_target (void)
1499 struct target_ops
**t
;
1500 struct target_ops
*runable
= NULL
;
1505 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1508 if ((*t
)->to_stratum
== core_stratum
)
1515 return (count
== 1 ? runable
: NULL
);
1519 * Find the next target down the stack from the specified target.
1523 find_target_beneath (struct target_ops
*t
)
1529 /* The inferior process has died. Long live the inferior! */
1532 generic_mourn_inferior (void)
1534 extern int show_breakpoint_hit_counts
;
1536 inferior_ptid
= null_ptid
;
1538 breakpoint_init_inferior (inf_exited
);
1539 registers_changed ();
1541 #ifdef CLEAR_DEFERRED_STORES
1542 /* Delete any pending stores to the inferior... */
1543 CLEAR_DEFERRED_STORES
;
1546 reopen_exec_file ();
1547 reinit_frame_cache ();
1549 /* It is confusing to the user for ignore counts to stick around
1550 from previous runs of the inferior. So clear them. */
1551 /* However, it is more confusing for the ignore counts to disappear when
1552 using hit counts. So don't clear them if we're counting hits. */
1553 if (!show_breakpoint_hit_counts
)
1554 breakpoint_clear_ignore_counts ();
1560 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1561 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1562 translation of that in OURSTATUS. */
1564 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1566 #ifdef CHILD_SPECIAL_WAITSTATUS
1567 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1568 if it wants to deal with hoststatus. */
1569 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1573 if (WIFEXITED (hoststatus
))
1575 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1576 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1578 else if (!WIFSTOPPED (hoststatus
))
1580 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1581 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1585 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1586 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1590 /* Returns zero to leave the inferior alone, one to interrupt it. */
1591 int (*target_activity_function
) (void);
1592 int target_activity_fd
;
1594 /* Convert a normal process ID to a string. Returns the string in a static
1598 normal_pid_to_str (ptid_t ptid
)
1600 static char buf
[30];
1602 sprintf (buf
, "process %d", PIDGET (ptid
));
1606 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1607 notification of inferior events such as fork and vork immediately
1608 after the inferior is created. (This because of how gdb gets an
1609 inferior created via invoking a shell to do it. In such a scenario,
1610 if the shell init file has commands in it, the shell will fork and
1611 exec for each of those commands, and we will see each such fork
1614 This function is used by all targets that allow us to request
1615 notification of forks, etc at inferior creation time; e.g., in
1616 target_acknowledge_forked_child.
1619 normal_target_post_startup_inferior (ptid_t ptid
)
1621 /* This space intentionally left blank. */
1624 /* Error-catcher for target_find_memory_regions */
1625 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1627 error ("No target.");
1631 /* Error-catcher for target_make_corefile_notes */
1632 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1634 error ("No target.");
1638 /* Set up the handful of non-empty slots needed by the dummy target
1642 init_dummy_target (void)
1644 dummy_target
.to_shortname
= "None";
1645 dummy_target
.to_longname
= "None";
1646 dummy_target
.to_doc
= "";
1647 dummy_target
.to_attach
= find_default_attach
;
1648 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1649 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1650 dummy_target
.to_stratum
= dummy_stratum
;
1651 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1652 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1653 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1654 dummy_target
.to_magic
= OPS_MAGIC
;
1658 static struct target_ops debug_target
;
1661 debug_to_open (char *args
, int from_tty
)
1663 debug_target
.to_open (args
, from_tty
);
1665 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1669 debug_to_close (int quitting
)
1671 target_close (&debug_target
, quitting
);
1672 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1676 target_close (struct target_ops
*targ
, int quitting
)
1678 if (targ
->to_xclose
!= NULL
)
1679 targ
->to_xclose (targ
, quitting
);
1680 else if (targ
->to_close
!= NULL
)
1681 targ
->to_close (quitting
);
1685 debug_to_attach (char *args
, int from_tty
)
1687 debug_target
.to_attach (args
, from_tty
);
1689 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1694 debug_to_post_attach (int pid
)
1696 debug_target
.to_post_attach (pid
);
1698 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1702 debug_to_detach (char *args
, int from_tty
)
1704 debug_target
.to_detach (args
, from_tty
);
1706 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1710 debug_to_disconnect (char *args
, int from_tty
)
1712 debug_target
.to_disconnect (args
, from_tty
);
1714 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1719 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1721 debug_target
.to_resume (ptid
, step
, siggnal
);
1723 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1724 step
? "step" : "continue",
1725 target_signal_to_name (siggnal
));
1729 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1733 retval
= debug_target
.to_wait (ptid
, status
);
1735 fprintf_unfiltered (gdb_stdlog
,
1736 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1738 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1739 switch (status
->kind
)
1741 case TARGET_WAITKIND_EXITED
:
1742 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1743 status
->value
.integer
);
1745 case TARGET_WAITKIND_STOPPED
:
1746 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1747 target_signal_to_name (status
->value
.sig
));
1749 case TARGET_WAITKIND_SIGNALLED
:
1750 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1751 target_signal_to_name (status
->value
.sig
));
1753 case TARGET_WAITKIND_LOADED
:
1754 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1756 case TARGET_WAITKIND_FORKED
:
1757 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1759 case TARGET_WAITKIND_VFORKED
:
1760 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1762 case TARGET_WAITKIND_EXECD
:
1763 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1765 case TARGET_WAITKIND_SPURIOUS
:
1766 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1769 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1777 debug_to_post_wait (ptid_t ptid
, int status
)
1779 debug_target
.to_post_wait (ptid
, status
);
1781 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1782 PIDGET (ptid
), status
);
1786 debug_print_register (const char * func
, int regno
)
1788 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1789 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1790 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1791 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1793 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1797 unsigned char buf
[MAX_REGISTER_SIZE
];
1798 deprecated_read_register_gen (regno
, buf
);
1799 fprintf_unfiltered (gdb_stdlog
, " = ");
1800 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
++)
1802 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1804 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1806 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1807 paddr_nz (read_register (regno
)),
1808 paddr_d (read_register (regno
)));
1811 fprintf_unfiltered (gdb_stdlog
, "\n");
1815 debug_to_fetch_registers (int regno
)
1817 debug_target
.to_fetch_registers (regno
);
1818 debug_print_register ("target_fetch_registers", regno
);
1822 debug_to_store_registers (int regno
)
1824 debug_target
.to_store_registers (regno
);
1825 debug_print_register ("target_store_registers", regno
);
1826 fprintf_unfiltered (gdb_stdlog
, "\n");
1830 debug_to_prepare_to_store (void)
1832 debug_target
.to_prepare_to_store ();
1834 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1838 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1839 struct mem_attrib
*attrib
,
1840 struct target_ops
*target
)
1844 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1847 fprintf_unfiltered (gdb_stdlog
,
1848 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1849 (unsigned int) memaddr
, /* possable truncate long long */
1850 len
, write
? "write" : "read", retval
);
1858 fputs_unfiltered (", bytes =", gdb_stdlog
);
1859 for (i
= 0; i
< retval
; i
++)
1861 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1862 fprintf_unfiltered (gdb_stdlog
, "\n");
1863 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1867 fputc_unfiltered ('\n', gdb_stdlog
);
1873 debug_to_files_info (struct target_ops
*target
)
1875 debug_target
.to_files_info (target
);
1877 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1881 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1885 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1887 fprintf_unfiltered (gdb_stdlog
,
1888 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1889 (unsigned long) addr
,
1890 (unsigned long) retval
);
1895 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1899 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1901 fprintf_unfiltered (gdb_stdlog
,
1902 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1903 (unsigned long) addr
,
1904 (unsigned long) retval
);
1909 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1913 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1915 fprintf_unfiltered (gdb_stdlog
,
1916 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1917 (unsigned long) type
,
1918 (unsigned long) cnt
,
1919 (unsigned long) from_tty
,
1920 (unsigned long) retval
);
1925 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1929 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1931 fprintf_unfiltered (gdb_stdlog
,
1932 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1933 (unsigned long) byte_count
,
1934 (unsigned long) retval
);
1939 debug_to_stopped_by_watchpoint (void)
1943 retval
= debug_target
.to_stopped_by_watchpoint ();
1945 fprintf_unfiltered (gdb_stdlog
,
1946 "STOPPED_BY_WATCHPOINT () = %ld\n",
1947 (unsigned long) retval
);
1952 debug_to_stopped_data_address (void)
1956 retval
= debug_target
.to_stopped_data_address ();
1958 fprintf_unfiltered (gdb_stdlog
,
1959 "target_stopped_data_address () = 0x%lx\n",
1960 (unsigned long) retval
);
1965 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1969 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1971 fprintf_unfiltered (gdb_stdlog
,
1972 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1973 (unsigned long) addr
,
1974 (unsigned long) retval
);
1979 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1983 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1985 fprintf_unfiltered (gdb_stdlog
,
1986 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1987 (unsigned long) addr
,
1988 (unsigned long) retval
);
1993 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1997 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1999 fprintf_unfiltered (gdb_stdlog
,
2000 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2001 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2006 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2010 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2012 fprintf_unfiltered (gdb_stdlog
,
2013 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2014 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2019 debug_to_terminal_init (void)
2021 debug_target
.to_terminal_init ();
2023 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2027 debug_to_terminal_inferior (void)
2029 debug_target
.to_terminal_inferior ();
2031 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2035 debug_to_terminal_ours_for_output (void)
2037 debug_target
.to_terminal_ours_for_output ();
2039 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2043 debug_to_terminal_ours (void)
2045 debug_target
.to_terminal_ours ();
2047 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2051 debug_to_terminal_save_ours (void)
2053 debug_target
.to_terminal_save_ours ();
2055 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2059 debug_to_terminal_info (char *arg
, int from_tty
)
2061 debug_target
.to_terminal_info (arg
, from_tty
);
2063 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2068 debug_to_kill (void)
2070 debug_target
.to_kill ();
2072 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2076 debug_to_load (char *args
, int from_tty
)
2078 debug_target
.to_load (args
, from_tty
);
2080 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2084 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2088 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2090 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2096 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2098 debug_target
.to_create_inferior (exec_file
, args
, env
);
2100 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2105 debug_to_post_startup_inferior (ptid_t ptid
)
2107 debug_target
.to_post_startup_inferior (ptid
);
2109 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2114 debug_to_acknowledge_created_inferior (int pid
)
2116 debug_target
.to_acknowledge_created_inferior (pid
);
2118 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2123 debug_to_insert_fork_catchpoint (int pid
)
2127 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2129 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2136 debug_to_remove_fork_catchpoint (int pid
)
2140 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2142 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2149 debug_to_insert_vfork_catchpoint (int pid
)
2153 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2155 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2162 debug_to_remove_vfork_catchpoint (int pid
)
2166 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2168 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2175 debug_to_follow_fork (int follow_child
)
2177 int retval
= debug_target
.to_follow_fork (follow_child
);
2179 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2180 follow_child
, retval
);
2186 debug_to_insert_exec_catchpoint (int pid
)
2190 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2192 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2199 debug_to_remove_exec_catchpoint (int pid
)
2203 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2205 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2212 debug_to_reported_exec_events_per_exec_call (void)
2214 int reported_exec_events
;
2216 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2218 fprintf_unfiltered (gdb_stdlog
,
2219 "target_reported_exec_events_per_exec_call () = %d\n",
2220 reported_exec_events
);
2222 return reported_exec_events
;
2226 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2230 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2232 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2233 pid
, wait_status
, *exit_status
, has_exited
);
2239 debug_to_mourn_inferior (void)
2241 debug_target
.to_mourn_inferior ();
2243 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2247 debug_to_can_run (void)
2251 retval
= debug_target
.to_can_run ();
2253 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2259 debug_to_notice_signals (ptid_t ptid
)
2261 debug_target
.to_notice_signals (ptid
);
2263 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2268 debug_to_thread_alive (ptid_t ptid
)
2272 retval
= debug_target
.to_thread_alive (ptid
);
2274 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2275 PIDGET (ptid
), retval
);
2281 debug_to_find_new_threads (void)
2283 debug_target
.to_find_new_threads ();
2285 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2289 debug_to_stop (void)
2291 debug_target
.to_stop ();
2293 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2297 debug_to_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2298 const char *annex
, void *readbuf
, const void *writebuf
,
2299 ULONGEST offset
, LONGEST len
)
2303 retval
= debug_target
.to_xfer_partial (&debug_target
, object
, annex
,
2304 readbuf
, writebuf
, offset
, len
);
2306 fprintf_unfiltered (gdb_stdlog
,
2307 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
2308 (int) object
, (annex
? annex
: "(null)"),
2309 (long) readbuf
, (long) writebuf
, paddr_nz (offset
),
2310 paddr_d (len
), paddr_d (retval
));
2316 debug_to_rcmd (char *command
,
2317 struct ui_file
*outbuf
)
2319 debug_target
.to_rcmd (command
, outbuf
);
2320 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2323 static struct symtab_and_line
*
2324 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2326 struct symtab_and_line
*result
;
2327 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2328 fprintf_unfiltered (gdb_stdlog
,
2329 "target get_exception_callback_sal (%d, %d)\n",
2334 static struct exception_event_record
*
2335 debug_to_get_current_exception_event (void)
2337 struct exception_event_record
*result
;
2338 result
= debug_target
.to_get_current_exception_event ();
2339 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2344 debug_to_pid_to_exec_file (int pid
)
2348 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2350 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2357 setup_target_debug (void)
2359 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2361 current_target
.to_open
= debug_to_open
;
2362 current_target
.to_close
= debug_to_close
;
2363 current_target
.to_attach
= debug_to_attach
;
2364 current_target
.to_post_attach
= debug_to_post_attach
;
2365 current_target
.to_detach
= debug_to_detach
;
2366 current_target
.to_disconnect
= debug_to_disconnect
;
2367 current_target
.to_resume
= debug_to_resume
;
2368 current_target
.to_wait
= debug_to_wait
;
2369 current_target
.to_post_wait
= debug_to_post_wait
;
2370 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2371 current_target
.to_store_registers
= debug_to_store_registers
;
2372 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2373 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2374 current_target
.to_files_info
= debug_to_files_info
;
2375 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2376 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2377 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2378 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2379 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2380 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2381 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2382 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2383 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2384 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2385 current_target
.to_terminal_init
= debug_to_terminal_init
;
2386 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2387 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2388 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2389 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2390 current_target
.to_terminal_info
= debug_to_terminal_info
;
2391 current_target
.to_kill
= debug_to_kill
;
2392 current_target
.to_load
= debug_to_load
;
2393 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2394 current_target
.to_create_inferior
= debug_to_create_inferior
;
2395 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2396 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2397 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2398 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2399 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2400 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2401 current_target
.to_follow_fork
= debug_to_follow_fork
;
2402 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2403 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2404 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2405 current_target
.to_has_exited
= debug_to_has_exited
;
2406 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2407 current_target
.to_can_run
= debug_to_can_run
;
2408 current_target
.to_notice_signals
= debug_to_notice_signals
;
2409 current_target
.to_thread_alive
= debug_to_thread_alive
;
2410 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2411 current_target
.to_stop
= debug_to_stop
;
2412 current_target
.to_xfer_partial
= debug_to_xfer_partial
;
2413 current_target
.to_rcmd
= debug_to_rcmd
;
2414 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2415 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2416 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2421 static char targ_desc
[] =
2422 "Names of targets and files being debugged.\n\
2423 Shows the entire stack of targets currently in use (including the exec-file,\n\
2424 core-file, and process, if any), as well as the symbol file name.";
2427 do_monitor_command (char *cmd
,
2430 if ((current_target
.to_rcmd
2431 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2432 || (current_target
.to_rcmd
== debug_to_rcmd
2433 && (debug_target
.to_rcmd
2434 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2436 error ("\"monitor\" command not supported by this target.\n");
2438 target_rcmd (cmd
, gdb_stdtarg
);
2442 initialize_targets (void)
2444 init_dummy_target ();
2445 push_target (&dummy_target
);
2447 add_info ("target", target_info
, targ_desc
);
2448 add_info ("files", target_info
, targ_desc
);
2451 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2452 (char *) &targetdebug
,
2453 "Set target debugging.\n\
2454 When non-zero, target debugging is enabled.", &setdebuglist
),
2457 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2459 Set mode for reading from readonly sections.\n\
2460 When this mode is on, memory reads from readonly sections (such as .text)\n\
2461 will be read from the object file instead of from the target. This will\n\
2462 result in significant performance improvement for remote targets.", "\
2463 Show mode for reading from readonly sections.\n",
2465 &setlist
, &showlist
);
2467 add_com ("monitor", class_obscure
, do_monitor_command
,
2468 "Send a command to the remote monitor (remote targets only).");
2470 target_dcache
= dcache_init ();