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
, const void *writebuf
,
79 void *readbuf
, ULONGEST offset
,
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
;
714 /* Look for the specified target. Note that we assume that a target
715 can only occur once in the target stack. */
717 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
724 return 0; /* Didn't find target_ops, quit now */
726 /* Unchain the target */
728 (*cur
) = (*cur
)->beneath
;
731 update_current_target ();
739 target_close (¤t_target
, 0); /* Let it clean up */
740 if (unpush_target (target_stack
) == 1)
743 fprintf_unfiltered (gdb_stderr
,
744 "pop_target couldn't find target %s\n",
745 current_target
.to_shortname
);
746 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
750 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
752 /* target_read_string -- read a null terminated string, up to LEN bytes,
753 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
754 Set *STRING to a pointer to malloc'd memory containing the data; the caller
755 is responsible for freeing it. Return the number of bytes successfully
759 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
761 int tlen
, origlen
, offset
, i
;
765 int buffer_allocated
;
767 unsigned int nbytes_read
= 0;
769 /* Small for testing. */
770 buffer_allocated
= 4;
771 buffer
= xmalloc (buffer_allocated
);
778 tlen
= MIN (len
, 4 - (memaddr
& 3));
779 offset
= memaddr
& 3;
781 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
784 /* The transfer request might have crossed the boundary to an
785 unallocated region of memory. Retry the transfer, requesting
789 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
794 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
797 bytes
= bufptr
- buffer
;
798 buffer_allocated
*= 2;
799 buffer
= xrealloc (buffer
, buffer_allocated
);
800 bufptr
= buffer
+ bytes
;
803 for (i
= 0; i
< tlen
; i
++)
805 *bufptr
++ = buf
[i
+ offset
];
806 if (buf
[i
+ offset
] == '\000')
808 nbytes_read
+= i
+ 1;
825 /* Find a section containing ADDR. */
826 struct section_table
*
827 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
829 struct section_table
*secp
;
830 for (secp
= target
->to_sections
;
831 secp
< target
->to_sections_end
;
834 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
840 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
841 GDB's memory at MYADDR. Returns either 0 for success or an errno value
844 If an error occurs, no guarantee is made about the contents of the data at
845 MYADDR. In particular, the caller should not depend upon partial reads
846 filling the buffer with good data. There is no way for the caller to know
847 how much good data might have been transfered anyway. Callers that can
848 deal with partial reads should call target_read_memory_partial. */
851 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
853 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
857 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
859 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
862 static int trust_readonly
= 0;
864 /* Move memory to or from the targets. The top target gets priority;
865 if it cannot handle it, it is offered to the next one down, etc.
867 Result is -1 on error, or the number of bytes transfered. */
870 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
871 struct mem_attrib
*attrib
)
875 struct target_ops
*t
;
877 /* Zero length requests are ok and require no work. */
881 /* to_xfer_memory is not guaranteed to set errno, even when it returns
885 if (!write
&& trust_readonly
)
887 struct section_table
*secp
;
888 /* User-settable option, "trust-readonly-sections". If true,
889 then memory from any SEC_READONLY bfd section may be read
890 directly from the bfd file. */
891 secp
= target_section_by_addr (¤t_target
, memaddr
);
893 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
895 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
898 /* The quick case is that the top target can handle the transfer. */
899 res
= current_target
.to_xfer_memory
900 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
902 /* If res <= 0 then we call it again in the loop. Ah well. */
905 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
907 if (!t
->to_has_memory
)
910 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
912 break; /* Handled all or part of xfer */
913 if (t
->to_has_all_memory
)
925 /* Perform a memory transfer. Iterate until the entire region has
928 Result is 0 or errno value. */
931 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
935 struct mem_region
*region
;
937 /* Zero length requests are ok and require no work. */
945 region
= lookup_mem_region(memaddr
);
946 if (memaddr
+ len
< region
->hi
)
949 reg_len
= region
->hi
- memaddr
;
951 switch (region
->attrib
.mode
)
966 if (region
->attrib
.cache
)
967 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
970 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
975 /* If this address is for nonexistent memory, read zeros
976 if reading, or do nothing if writing. Return
979 memset (myaddr
, 0, len
);
993 return 0; /* We managed to cover it all somehow. */
997 /* Perform a partial memory transfer.
999 Result is -1 on error, or the number of bytes transfered. */
1002 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1003 int write_p
, int *err
)
1007 struct mem_region
*region
;
1009 /* Zero length requests are ok and require no work. */
1016 region
= lookup_mem_region(memaddr
);
1017 if (memaddr
+ len
< region
->hi
)
1020 reg_len
= region
->hi
- memaddr
;
1022 switch (region
->attrib
.mode
)
1041 if (region
->attrib
.cache
)
1042 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1045 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1063 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1065 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1069 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1071 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1074 /* More generic transfers. */
1077 default_xfer_partial (struct target_ops
*ops
,
1078 enum target_object object
,
1079 const char *annex
, const void *writebuf
,
1080 void *readbuf
, ULONGEST offset
, LONGEST len
)
1082 if (object
== TARGET_OBJECT_MEMORY
1083 && ops
->to_xfer_memory
!= NULL
)
1084 /* If available, fall back to the target's "to_xfer_memory"
1089 if (writebuf
!= NULL
)
1091 void *buffer
= xmalloc (len
);
1092 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1093 memcpy (buffer
, writebuf
, len
);
1094 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1096 do_cleanups (cleanup
);
1098 if (readbuf
!= NULL
)
1099 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1103 else if (xfered
== 0 && errno
== 0)
1104 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1105 indication of an error. */
1110 else if (ops
->beneath
!= NULL
)
1111 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1112 writebuf
, readbuf
, offset
, len
);
1117 /* Target vector read/write partial wrapper functions.
1119 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1120 (inbuf, outbuf)", instead of separate read/write methods, make life
1124 target_read_partial (struct target_ops
*ops
,
1125 enum target_object object
,
1126 const char *annex
, void *buf
,
1127 ULONGEST offset
, LONGEST len
)
1129 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1130 return ops
->to_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1134 target_write_partial (struct target_ops
*ops
,
1135 enum target_object object
,
1136 const char *annex
, const void *buf
,
1137 ULONGEST offset
, LONGEST len
)
1139 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1140 return ops
->to_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1143 /* Wrappers to perform the full transfer. */
1145 target_read (struct target_ops
*ops
,
1146 enum target_object object
,
1147 const char *annex
, void *buf
,
1148 ULONGEST offset
, LONGEST len
)
1151 while (xfered
< len
)
1153 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1154 (bfd_byte
*) buf
+ xfered
,
1155 offset
+ xfered
, len
- xfered
);
1156 /* Call an observer, notifying them of the xfer progress? */
1158 /* Call memory_error? */
1167 target_write (struct target_ops
*ops
,
1168 enum target_object object
,
1169 const char *annex
, const void *buf
,
1170 ULONGEST offset
, LONGEST len
)
1173 while (xfered
< len
)
1175 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1176 (bfd_byte
*) buf
+ xfered
,
1177 offset
+ xfered
, len
- xfered
);
1178 /* Call an observer, notifying them of the xfer progress? */
1180 /* Call memory_error? */
1188 /* Memory transfer methods. */
1191 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1194 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1196 memory_error (EIO
, addr
);
1200 get_target_memory_unsigned (struct target_ops
*ops
,
1201 CORE_ADDR addr
, int len
)
1203 char buf
[sizeof (ULONGEST
)];
1205 gdb_assert (len
<= sizeof (buf
));
1206 get_target_memory (ops
, addr
, buf
, len
);
1207 return extract_unsigned_integer (buf
, len
);
1211 target_info (char *args
, int from_tty
)
1213 struct target_ops
*t
;
1214 int has_all_mem
= 0;
1216 if (symfile_objfile
!= NULL
)
1217 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1219 #ifdef FILES_INFO_HOOK
1220 if (FILES_INFO_HOOK ())
1224 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1226 if (!t
->to_has_memory
)
1229 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1232 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1233 printf_unfiltered ("%s:\n", t
->to_longname
);
1234 (t
->to_files_info
) (t
);
1235 has_all_mem
= t
->to_has_all_memory
;
1239 /* This is to be called by the open routine before it does
1243 target_preopen (int from_tty
)
1247 if (target_has_execution
)
1250 || query ("A program is being debugged already. Kill it? "))
1253 error ("Program not killed.");
1256 /* Calling target_kill may remove the target from the stack. But if
1257 it doesn't (which seems like a win for UDI), remove it now. */
1259 if (target_has_execution
)
1263 /* Detach a target after doing deferred register stores. */
1266 target_detach (char *args
, int from_tty
)
1268 /* Handle any optimized stores to the inferior. */
1269 #ifdef DO_DEFERRED_STORES
1272 (current_target
.to_detach
) (args
, from_tty
);
1276 target_disconnect (char *args
, int from_tty
)
1278 /* Handle any optimized stores to the inferior. */
1279 #ifdef DO_DEFERRED_STORES
1282 (current_target
.to_disconnect
) (args
, from_tty
);
1286 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1288 if (STREQ (current_target
.to_shortname
, "rombug"))
1290 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1292 error ("Unable to link to %s and get relocation in rombug", modname
);
1295 *t_reloc
= (CORE_ADDR
) -1;
1299 target_async_mask (int mask
)
1301 int saved_async_masked_status
= target_async_mask_value
;
1302 target_async_mask_value
= mask
;
1303 return saved_async_masked_status
;
1306 /* Look through the list of possible targets for a target that can
1307 execute a run or attach command without any other data. This is
1308 used to locate the default process stratum.
1310 Result is always valid (error() is called for errors). */
1312 static struct target_ops
*
1313 find_default_run_target (char *do_mesg
)
1315 struct target_ops
**t
;
1316 struct target_ops
*runable
= NULL
;
1321 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1324 if ((*t
)->to_can_run
&& target_can_run (*t
))
1332 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1338 find_default_attach (char *args
, int from_tty
)
1340 struct target_ops
*t
;
1342 t
= find_default_run_target ("attach");
1343 (t
->to_attach
) (args
, from_tty
);
1348 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1350 struct target_ops
*t
;
1352 t
= find_default_run_target ("run");
1353 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1358 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1360 return (byte_count
<= DEPRECATED_REGISTER_SIZE
);
1376 return_minus_one (void)
1382 * Resize the to_sections pointer. Also make sure that anyone that
1383 * was holding on to an old value of it gets updated.
1384 * Returns the old size.
1388 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1390 struct target_ops
**t
;
1391 struct section_table
*old_value
;
1394 old_value
= target
->to_sections
;
1396 if (target
->to_sections
)
1398 old_count
= target
->to_sections_end
- target
->to_sections
;
1399 target
->to_sections
= (struct section_table
*)
1400 xrealloc ((char *) target
->to_sections
,
1401 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1406 target
->to_sections
= (struct section_table
*)
1407 xmalloc ((sizeof (struct section_table
)) * num_added
);
1409 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1411 /* Check to see if anyone else was pointing to this structure.
1412 If old_value was null, then no one was. */
1416 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1419 if ((*t
)->to_sections
== old_value
)
1421 (*t
)->to_sections
= target
->to_sections
;
1422 (*t
)->to_sections_end
= target
->to_sections_end
;
1431 /* Remove all target sections taken from ABFD.
1433 Scan the current target stack for targets whose section tables
1434 refer to sections from BFD, and remove those sections. We use this
1435 when we notice that the inferior has unloaded a shared object, for
1438 remove_target_sections (bfd
*abfd
)
1440 struct target_ops
**t
;
1442 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1444 struct section_table
*src
, *dest
;
1446 dest
= (*t
)->to_sections
;
1447 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1448 if (src
->bfd
!= abfd
)
1450 /* Keep this section. */
1451 if (dest
< src
) *dest
= *src
;
1455 /* If we've dropped any sections, resize the section table. */
1457 target_resize_to_sections (*t
, dest
- src
);
1464 /* Find a single runnable target in the stack and return it. If for
1465 some reason there is more than one, return NULL. */
1468 find_run_target (void)
1470 struct target_ops
**t
;
1471 struct target_ops
*runable
= NULL
;
1476 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1478 if ((*t
)->to_can_run
&& target_can_run (*t
))
1485 return (count
== 1 ? runable
: NULL
);
1488 /* Find a single core_stratum target in the list of targets and return it.
1489 If for some reason there is more than one, return NULL. */
1492 find_core_target (void)
1494 struct target_ops
**t
;
1495 struct target_ops
*runable
= NULL
;
1500 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1503 if ((*t
)->to_stratum
== core_stratum
)
1510 return (count
== 1 ? runable
: NULL
);
1514 * Find the next target down the stack from the specified target.
1518 find_target_beneath (struct target_ops
*t
)
1524 /* The inferior process has died. Long live the inferior! */
1527 generic_mourn_inferior (void)
1529 extern int show_breakpoint_hit_counts
;
1531 inferior_ptid
= null_ptid
;
1533 breakpoint_init_inferior (inf_exited
);
1534 registers_changed ();
1536 #ifdef CLEAR_DEFERRED_STORES
1537 /* Delete any pending stores to the inferior... */
1538 CLEAR_DEFERRED_STORES
;
1541 reopen_exec_file ();
1542 reinit_frame_cache ();
1544 /* It is confusing to the user for ignore counts to stick around
1545 from previous runs of the inferior. So clear them. */
1546 /* However, it is more confusing for the ignore counts to disappear when
1547 using hit counts. So don't clear them if we're counting hits. */
1548 if (!show_breakpoint_hit_counts
)
1549 breakpoint_clear_ignore_counts ();
1555 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1556 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1557 translation of that in OURSTATUS. */
1559 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1561 #ifdef CHILD_SPECIAL_WAITSTATUS
1562 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1563 if it wants to deal with hoststatus. */
1564 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1568 if (WIFEXITED (hoststatus
))
1570 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1571 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1573 else if (!WIFSTOPPED (hoststatus
))
1575 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1576 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1580 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1581 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1585 /* Returns zero to leave the inferior alone, one to interrupt it. */
1586 int (*target_activity_function
) (void);
1587 int target_activity_fd
;
1589 /* Convert a normal process ID to a string. Returns the string in a static
1593 normal_pid_to_str (ptid_t ptid
)
1595 static char buf
[30];
1597 sprintf (buf
, "process %d", PIDGET (ptid
));
1601 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1602 notification of inferior events such as fork and vork immediately
1603 after the inferior is created. (This because of how gdb gets an
1604 inferior created via invoking a shell to do it. In such a scenario,
1605 if the shell init file has commands in it, the shell will fork and
1606 exec for each of those commands, and we will see each such fork
1609 This function is used by all targets that allow us to request
1610 notification of forks, etc at inferior creation time; e.g., in
1611 target_acknowledge_forked_child.
1614 normal_target_post_startup_inferior (ptid_t ptid
)
1616 /* This space intentionally left blank. */
1619 /* Error-catcher for target_find_memory_regions */
1620 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1622 error ("No target.");
1626 /* Error-catcher for target_make_corefile_notes */
1627 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1629 error ("No target.");
1633 /* Set up the handful of non-empty slots needed by the dummy target
1637 init_dummy_target (void)
1639 dummy_target
.to_shortname
= "None";
1640 dummy_target
.to_longname
= "None";
1641 dummy_target
.to_doc
= "";
1642 dummy_target
.to_attach
= find_default_attach
;
1643 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1644 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1645 dummy_target
.to_stratum
= dummy_stratum
;
1646 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1647 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1648 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1649 dummy_target
.to_magic
= OPS_MAGIC
;
1653 static struct target_ops debug_target
;
1656 debug_to_open (char *args
, int from_tty
)
1658 debug_target
.to_open (args
, from_tty
);
1660 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1664 debug_to_close (int quitting
)
1666 target_close (&debug_target
, quitting
);
1667 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1671 target_close (struct target_ops
*targ
, int quitting
)
1673 if (targ
->to_xclose
!= NULL
)
1674 targ
->to_xclose (targ
, quitting
);
1675 else if (targ
->to_close
!= NULL
)
1676 targ
->to_close (quitting
);
1680 debug_to_attach (char *args
, int from_tty
)
1682 debug_target
.to_attach (args
, from_tty
);
1684 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1689 debug_to_post_attach (int pid
)
1691 debug_target
.to_post_attach (pid
);
1693 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1697 debug_to_detach (char *args
, int from_tty
)
1699 debug_target
.to_detach (args
, from_tty
);
1701 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1705 debug_to_disconnect (char *args
, int from_tty
)
1707 debug_target
.to_disconnect (args
, from_tty
);
1709 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1714 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1716 debug_target
.to_resume (ptid
, step
, siggnal
);
1718 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1719 step
? "step" : "continue",
1720 target_signal_to_name (siggnal
));
1724 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1728 retval
= debug_target
.to_wait (ptid
, status
);
1730 fprintf_unfiltered (gdb_stdlog
,
1731 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1733 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1734 switch (status
->kind
)
1736 case TARGET_WAITKIND_EXITED
:
1737 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1738 status
->value
.integer
);
1740 case TARGET_WAITKIND_STOPPED
:
1741 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1742 target_signal_to_name (status
->value
.sig
));
1744 case TARGET_WAITKIND_SIGNALLED
:
1745 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1746 target_signal_to_name (status
->value
.sig
));
1748 case TARGET_WAITKIND_LOADED
:
1749 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1751 case TARGET_WAITKIND_FORKED
:
1752 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1754 case TARGET_WAITKIND_VFORKED
:
1755 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1757 case TARGET_WAITKIND_EXECD
:
1758 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1760 case TARGET_WAITKIND_SPURIOUS
:
1761 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1764 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1772 debug_to_post_wait (ptid_t ptid
, int status
)
1774 debug_target
.to_post_wait (ptid
, status
);
1776 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1777 PIDGET (ptid
), status
);
1781 debug_print_register (const char * func
, int regno
)
1783 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1784 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1785 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1786 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1788 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1792 unsigned char buf
[MAX_REGISTER_SIZE
];
1793 deprecated_read_register_gen (regno
, buf
);
1794 fprintf_unfiltered (gdb_stdlog
, " = ");
1795 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
++)
1797 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1799 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1801 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1802 paddr_nz (read_register (regno
)),
1803 paddr_d (read_register (regno
)));
1806 fprintf_unfiltered (gdb_stdlog
, "\n");
1810 debug_to_fetch_registers (int regno
)
1812 debug_target
.to_fetch_registers (regno
);
1813 debug_print_register ("target_fetch_registers", regno
);
1817 debug_to_store_registers (int regno
)
1819 debug_target
.to_store_registers (regno
);
1820 debug_print_register ("target_store_registers", regno
);
1821 fprintf_unfiltered (gdb_stdlog
, "\n");
1825 debug_to_prepare_to_store (void)
1827 debug_target
.to_prepare_to_store ();
1829 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1833 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1834 struct mem_attrib
*attrib
,
1835 struct target_ops
*target
)
1839 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1842 fprintf_unfiltered (gdb_stdlog
,
1843 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1844 (unsigned int) memaddr
, /* possable truncate long long */
1845 len
, write
? "write" : "read", retval
);
1853 fputs_unfiltered (", bytes =", gdb_stdlog
);
1854 for (i
= 0; i
< retval
; i
++)
1856 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1857 fprintf_unfiltered (gdb_stdlog
, "\n");
1858 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1862 fputc_unfiltered ('\n', gdb_stdlog
);
1868 debug_to_files_info (struct target_ops
*target
)
1870 debug_target
.to_files_info (target
);
1872 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1876 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1880 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1882 fprintf_unfiltered (gdb_stdlog
,
1883 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1884 (unsigned long) addr
,
1885 (unsigned long) retval
);
1890 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1894 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1896 fprintf_unfiltered (gdb_stdlog
,
1897 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1898 (unsigned long) addr
,
1899 (unsigned long) retval
);
1904 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1908 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1910 fprintf_unfiltered (gdb_stdlog
,
1911 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1912 (unsigned long) type
,
1913 (unsigned long) cnt
,
1914 (unsigned long) from_tty
,
1915 (unsigned long) retval
);
1920 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1924 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1926 fprintf_unfiltered (gdb_stdlog
,
1927 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1928 (unsigned long) byte_count
,
1929 (unsigned long) retval
);
1934 debug_to_stopped_by_watchpoint (void)
1938 retval
= debug_target
.to_stopped_by_watchpoint ();
1940 fprintf_unfiltered (gdb_stdlog
,
1941 "STOPPED_BY_WATCHPOINT () = %ld\n",
1942 (unsigned long) retval
);
1947 debug_to_stopped_data_address (void)
1951 retval
= debug_target
.to_stopped_data_address ();
1953 fprintf_unfiltered (gdb_stdlog
,
1954 "target_stopped_data_address () = 0x%lx\n",
1955 (unsigned long) retval
);
1960 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1964 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1966 fprintf_unfiltered (gdb_stdlog
,
1967 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1968 (unsigned long) addr
,
1969 (unsigned long) retval
);
1974 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1978 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1980 fprintf_unfiltered (gdb_stdlog
,
1981 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1982 (unsigned long) addr
,
1983 (unsigned long) retval
);
1988 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1992 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1994 fprintf_unfiltered (gdb_stdlog
,
1995 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1996 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2001 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2005 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2007 fprintf_unfiltered (gdb_stdlog
,
2008 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2009 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2014 debug_to_terminal_init (void)
2016 debug_target
.to_terminal_init ();
2018 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2022 debug_to_terminal_inferior (void)
2024 debug_target
.to_terminal_inferior ();
2026 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2030 debug_to_terminal_ours_for_output (void)
2032 debug_target
.to_terminal_ours_for_output ();
2034 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2038 debug_to_terminal_ours (void)
2040 debug_target
.to_terminal_ours ();
2042 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2046 debug_to_terminal_save_ours (void)
2048 debug_target
.to_terminal_save_ours ();
2050 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2054 debug_to_terminal_info (char *arg
, int from_tty
)
2056 debug_target
.to_terminal_info (arg
, from_tty
);
2058 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2063 debug_to_kill (void)
2065 debug_target
.to_kill ();
2067 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2071 debug_to_load (char *args
, int from_tty
)
2073 debug_target
.to_load (args
, from_tty
);
2075 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2079 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2083 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2085 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2091 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2093 debug_target
.to_create_inferior (exec_file
, args
, env
);
2095 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2100 debug_to_post_startup_inferior (ptid_t ptid
)
2102 debug_target
.to_post_startup_inferior (ptid
);
2104 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2109 debug_to_acknowledge_created_inferior (int pid
)
2111 debug_target
.to_acknowledge_created_inferior (pid
);
2113 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2118 debug_to_insert_fork_catchpoint (int pid
)
2122 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2124 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2131 debug_to_remove_fork_catchpoint (int pid
)
2135 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2137 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2144 debug_to_insert_vfork_catchpoint (int pid
)
2148 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2150 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2157 debug_to_remove_vfork_catchpoint (int pid
)
2161 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2163 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2170 debug_to_follow_fork (int follow_child
)
2172 int retval
= debug_target
.to_follow_fork (follow_child
);
2174 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2175 follow_child
, retval
);
2181 debug_to_insert_exec_catchpoint (int pid
)
2185 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2187 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2194 debug_to_remove_exec_catchpoint (int pid
)
2198 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2200 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2207 debug_to_reported_exec_events_per_exec_call (void)
2209 int reported_exec_events
;
2211 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2213 fprintf_unfiltered (gdb_stdlog
,
2214 "target_reported_exec_events_per_exec_call () = %d\n",
2215 reported_exec_events
);
2217 return reported_exec_events
;
2221 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2225 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2227 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2228 pid
, wait_status
, *exit_status
, has_exited
);
2234 debug_to_mourn_inferior (void)
2236 debug_target
.to_mourn_inferior ();
2238 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2242 debug_to_can_run (void)
2246 retval
= debug_target
.to_can_run ();
2248 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2254 debug_to_notice_signals (ptid_t ptid
)
2256 debug_target
.to_notice_signals (ptid
);
2258 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2263 debug_to_thread_alive (ptid_t ptid
)
2267 retval
= debug_target
.to_thread_alive (ptid
);
2269 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2270 PIDGET (ptid
), retval
);
2276 debug_to_find_new_threads (void)
2278 debug_target
.to_find_new_threads ();
2280 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2284 debug_to_stop (void)
2286 debug_target
.to_stop ();
2288 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2292 debug_to_xfer_partial (struct target_ops
*ops
,
2293 enum target_object object
,
2294 const char *annex
, const void *writebuf
,
2295 void *readbuf
, ULONGEST offset
, LONGEST len
)
2299 retval
= debug_target
.to_xfer_partial (&debug_target
, object
, annex
,
2300 writebuf
, readbuf
, offset
, len
);
2302 fprintf_unfiltered (gdb_stdlog
,
2303 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
2304 (int) object
, (annex
? annex
: "(null)"),
2305 (long) writebuf
, (long) readbuf
, paddr_nz (offset
),
2306 paddr_d (len
), paddr_d (retval
));
2312 debug_to_rcmd (char *command
,
2313 struct ui_file
*outbuf
)
2315 debug_target
.to_rcmd (command
, outbuf
);
2316 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2319 static struct symtab_and_line
*
2320 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2322 struct symtab_and_line
*result
;
2323 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2324 fprintf_unfiltered (gdb_stdlog
,
2325 "target get_exception_callback_sal (%d, %d)\n",
2330 static struct exception_event_record
*
2331 debug_to_get_current_exception_event (void)
2333 struct exception_event_record
*result
;
2334 result
= debug_target
.to_get_current_exception_event ();
2335 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2340 debug_to_pid_to_exec_file (int pid
)
2344 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2346 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2353 setup_target_debug (void)
2355 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2357 current_target
.to_open
= debug_to_open
;
2358 current_target
.to_close
= debug_to_close
;
2359 current_target
.to_attach
= debug_to_attach
;
2360 current_target
.to_post_attach
= debug_to_post_attach
;
2361 current_target
.to_detach
= debug_to_detach
;
2362 current_target
.to_disconnect
= debug_to_disconnect
;
2363 current_target
.to_resume
= debug_to_resume
;
2364 current_target
.to_wait
= debug_to_wait
;
2365 current_target
.to_post_wait
= debug_to_post_wait
;
2366 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2367 current_target
.to_store_registers
= debug_to_store_registers
;
2368 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2369 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2370 current_target
.to_files_info
= debug_to_files_info
;
2371 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2372 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2373 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2374 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2375 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2376 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2377 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2378 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2379 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2380 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2381 current_target
.to_terminal_init
= debug_to_terminal_init
;
2382 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2383 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2384 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2385 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2386 current_target
.to_terminal_info
= debug_to_terminal_info
;
2387 current_target
.to_kill
= debug_to_kill
;
2388 current_target
.to_load
= debug_to_load
;
2389 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2390 current_target
.to_create_inferior
= debug_to_create_inferior
;
2391 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2392 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2393 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2394 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2395 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2396 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2397 current_target
.to_follow_fork
= debug_to_follow_fork
;
2398 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2399 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2400 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2401 current_target
.to_has_exited
= debug_to_has_exited
;
2402 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2403 current_target
.to_can_run
= debug_to_can_run
;
2404 current_target
.to_notice_signals
= debug_to_notice_signals
;
2405 current_target
.to_thread_alive
= debug_to_thread_alive
;
2406 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2407 current_target
.to_stop
= debug_to_stop
;
2408 current_target
.to_xfer_partial
= debug_to_xfer_partial
;
2409 current_target
.to_rcmd
= debug_to_rcmd
;
2410 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2411 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2412 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2417 static char targ_desc
[] =
2418 "Names of targets and files being debugged.\n\
2419 Shows the entire stack of targets currently in use (including the exec-file,\n\
2420 core-file, and process, if any), as well as the symbol file name.";
2423 do_monitor_command (char *cmd
,
2426 if ((current_target
.to_rcmd
2427 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2428 || (current_target
.to_rcmd
== debug_to_rcmd
2429 && (debug_target
.to_rcmd
2430 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2432 error ("\"monitor\" command not supported by this target.\n");
2434 target_rcmd (cmd
, gdb_stdtarg
);
2438 initialize_targets (void)
2440 init_dummy_target ();
2441 push_target (&dummy_target
);
2443 add_info ("target", target_info
, targ_desc
);
2444 add_info ("files", target_info
, targ_desc
);
2447 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2448 (char *) &targetdebug
,
2449 "Set target debugging.\n\
2450 When non-zero, target debugging is enabled.", &setdebuglist
),
2453 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2455 Set mode for reading from readonly sections.\n\
2456 When this mode is on, memory reads from readonly sections (such as .text)\n\
2457 will be read from the object file instead of from the target. This will\n\
2458 result in significant performance improvement for remote targets.", "\
2459 Show mode for reading from readonly sections.\n",
2461 &setlist
, &showlist
);
2463 add_com ("monitor", class_obscure
, do_monitor_command
,
2464 "Send a command to the remote monitor (remote targets only).");
2466 target_dcache
= dcache_init ();