1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
41 static void target_info (char *, int);
43 static void cleanup_target (struct target_ops
*);
45 static void maybe_kill_then_create_inferior (char *, char *, char **);
47 static void default_clone_and_follow_inferior (int, int *);
49 static void maybe_kill_then_attach (char *, int);
51 static void kill_or_be_killed (int);
53 static void default_terminal_info (char *, int);
55 static int default_region_size_ok_for_hw_watchpoint (int);
57 static int nosymbol (char *, CORE_ADDR
*);
59 static void tcomplain (void);
61 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
63 static int return_zero (void);
65 static int return_one (void);
67 static int return_minus_one (void);
69 void target_ignore (void);
71 static void target_command (char *, int);
73 static struct target_ops
*find_default_run_target (char *);
75 static void update_current_target (void);
77 static void nosupport_runtime (void);
79 static void normal_target_post_startup_inferior (ptid_t ptid
);
81 /* Transfer LEN bytes between target address MEMADDR and GDB address
82 MYADDR. Returns 0 for success, errno code for failure (which
83 includes partial transfers -- if you want a more useful response to
84 partial transfers, try either target_read_memory_partial or
85 target_write_memory_partial). */
88 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
);
90 static void init_dummy_target (void);
92 static void debug_to_open (char *, int);
94 static void debug_to_close (int);
96 static void debug_to_attach (char *, int);
98 static void debug_to_detach (char *, int);
100 static void debug_to_resume (ptid_t
, int, enum target_signal
);
102 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
104 static void debug_to_fetch_registers (int);
106 static void debug_to_store_registers (int);
108 static void debug_to_prepare_to_store (void);
110 static int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
111 struct mem_attrib
*, struct target_ops
*);
113 static void debug_to_files_info (struct target_ops
*);
115 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
117 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
119 static int debug_to_can_use_hw_breakpoint (int, int, int);
121 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
123 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
125 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_stopped_by_watchpoint (void);
131 static CORE_ADDR
debug_to_stopped_data_address (void);
133 static int debug_to_region_size_ok_for_hw_watchpoint (int);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_ours (void);
143 static void debug_to_terminal_info (char *, int);
145 static void debug_to_kill (void);
147 static void debug_to_load (char *, int);
149 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
151 static void debug_to_create_inferior (char *, char *, char **);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t
);
159 static int debug_to_thread_alive (ptid_t
);
161 static void debug_to_stop (void);
163 static int debug_to_query (int /*char */ , char *, char *, int *);
165 /* Pointer to array of target architecture structures; the size of the
166 array; the current index into the array; the allocated size of the
168 struct target_ops
**target_structs
;
169 unsigned target_struct_size
;
170 unsigned target_struct_index
;
171 unsigned target_struct_allocsize
;
172 #define DEFAULT_ALLOCSIZE 10
174 /* The initial current target, so that there is always a semi-valid
177 static struct target_ops dummy_target
;
179 /* Top of target stack. */
181 struct target_stack_item
*target_stack
;
183 /* The target structure we are currently using to talk to a process
184 or file or whatever "inferior" we have. */
186 struct target_ops current_target
;
188 /* Command list for target. */
190 static struct cmd_list_element
*targetlist
= NULL
;
192 /* Nonzero if we are debugging an attached outside process
193 rather than an inferior. */
197 /* Non-zero if we want to see trace of target level stuff. */
199 static int targetdebug
= 0;
201 static void setup_target_debug (void);
203 DCACHE
*target_dcache
;
205 /* The user just typed 'target' without the name of a target. */
209 target_command (char *arg
, int from_tty
)
211 fputs_filtered ("Argument required (target name). Try `help target'\n",
215 /* Add a possible target architecture to the list. */
218 add_target (struct target_ops
*t
)
222 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
223 target_structs
= (struct target_ops
**) xmalloc
224 (target_struct_allocsize
* sizeof (*target_structs
));
226 if (target_struct_size
>= target_struct_allocsize
)
228 target_struct_allocsize
*= 2;
229 target_structs
= (struct target_ops
**)
230 xrealloc ((char *) target_structs
,
231 target_struct_allocsize
* sizeof (*target_structs
));
233 target_structs
[target_struct_size
++] = t
;
234 /* cleanup_target (t); */
236 if (targetlist
== NULL
)
237 add_prefix_cmd ("target", class_run
, target_command
,
238 "Connect to a target machine or process.\n\
239 The first argument is the type or protocol of the target machine.\n\
240 Remaining arguments are interpreted by the target protocol. For more\n\
241 information on the arguments for a particular protocol, type\n\
242 `help target ' followed by the protocol name.",
243 &targetlist
, "target ", 0, &cmdlist
);
244 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
255 target_load (char *arg
, int from_tty
)
257 dcache_invalidate (target_dcache
);
258 (*current_target
.to_load
) (arg
, from_tty
);
263 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
264 struct target_ops
*t
)
266 errno
= EIO
; /* Can't read/write this location */
267 return 0; /* No bytes handled */
273 error ("You can't do that when your target is `%s'",
274 current_target
.to_shortname
);
280 error ("You can't do that without a process to debug.");
285 nosymbol (char *name
, CORE_ADDR
*addrp
)
287 return 1; /* Symbol does not exist in target env */
292 nosupport_runtime (void)
294 if (ptid_equal (inferior_ptid
, null_ptid
))
297 error ("No run-time support for this");
303 default_terminal_info (char *args
, int from_tty
)
305 printf_unfiltered ("No saved terminal information.\n");
308 /* This is the default target_create_inferior and target_attach function.
309 If the current target is executing, it asks whether to kill it off.
310 If this function returns without calling error(), it has killed off
311 the target, and the operation should be attempted. */
314 kill_or_be_killed (int from_tty
)
316 if (target_has_execution
)
318 printf_unfiltered ("You are already running a program:\n");
319 target_files_info ();
320 if (query ("Kill it? "))
323 if (target_has_execution
)
324 error ("Killing the program did not help.");
329 error ("Program not killed.");
336 maybe_kill_then_attach (char *args
, int from_tty
)
338 kill_or_be_killed (from_tty
);
339 target_attach (args
, from_tty
);
343 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
345 kill_or_be_killed (0);
346 target_create_inferior (exec
, args
, env
);
350 default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
352 target_clone_and_follow_inferior (child_pid
, followed_child
);
355 /* Clean up a target struct so it no longer has any zero pointers in it.
356 We default entries, at least to stubs that print error messages. */
359 cleanup_target (struct target_ops
*t
)
362 #define de_fault(field, value) \
367 (void (*) (char *, int))
373 maybe_kill_then_attach
);
374 de_fault (to_post_attach
,
377 de_fault (to_require_attach
,
378 maybe_kill_then_attach
);
380 (void (*) (char *, int))
382 de_fault (to_require_detach
,
383 (void (*) (int, char *, int))
386 (void (*) (ptid_t
, int, enum target_signal
))
389 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
391 de_fault (to_post_wait
,
392 (void (*) (ptid_t
, int))
394 de_fault (to_fetch_registers
,
397 de_fault (to_store_registers
,
400 de_fault (to_prepare_to_store
,
403 de_fault (to_xfer_memory
,
404 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
406 de_fault (to_files_info
,
407 (void (*) (struct target_ops
*))
409 de_fault (to_insert_breakpoint
,
410 memory_insert_breakpoint
);
411 de_fault (to_remove_breakpoint
,
412 memory_remove_breakpoint
);
413 de_fault (to_can_use_hw_breakpoint
,
414 (int (*) (int, int, int))
416 de_fault (to_insert_hw_breakpoint
,
417 (int (*) (CORE_ADDR
, char *))
419 de_fault (to_remove_hw_breakpoint
,
420 (int (*) (CORE_ADDR
, char *))
422 de_fault (to_insert_watchpoint
,
423 (int (*) (CORE_ADDR
, int, int))
425 de_fault (to_remove_watchpoint
,
426 (int (*) (CORE_ADDR
, int, int))
428 de_fault (to_stopped_by_watchpoint
,
431 de_fault (to_stopped_data_address
,
432 (CORE_ADDR (*) (void))
434 de_fault (to_region_size_ok_for_hw_watchpoint
,
435 default_region_size_ok_for_hw_watchpoint
);
436 de_fault (to_terminal_init
,
439 de_fault (to_terminal_inferior
,
442 de_fault (to_terminal_ours_for_output
,
445 de_fault (to_terminal_ours
,
448 de_fault (to_terminal_info
,
449 default_terminal_info
);
454 (void (*) (char *, int))
456 de_fault (to_lookup_symbol
,
457 (int (*) (char *, CORE_ADDR
*))
459 de_fault (to_create_inferior
,
460 maybe_kill_then_create_inferior
);
461 de_fault (to_post_startup_inferior
,
464 de_fault (to_acknowledge_created_inferior
,
467 de_fault (to_clone_and_follow_inferior
,
468 default_clone_and_follow_inferior
);
469 de_fault (to_post_follow_inferior_by_clone
,
472 de_fault (to_insert_fork_catchpoint
,
475 de_fault (to_remove_fork_catchpoint
,
478 de_fault (to_insert_vfork_catchpoint
,
481 de_fault (to_remove_vfork_catchpoint
,
484 de_fault (to_has_forked
,
485 (int (*) (int, int *))
487 de_fault (to_has_vforked
,
488 (int (*) (int, int *))
490 de_fault (to_can_follow_vfork_prior_to_exec
,
493 de_fault (to_post_follow_vfork
,
494 (void (*) (int, int, int, int))
496 de_fault (to_insert_exec_catchpoint
,
499 de_fault (to_remove_exec_catchpoint
,
502 de_fault (to_has_execd
,
503 (int (*) (int, char **))
505 de_fault (to_reported_exec_events_per_exec_call
,
508 de_fault (to_has_syscall_event
,
509 (int (*) (int, enum target_waitkind
*, int *))
511 de_fault (to_has_exited
,
512 (int (*) (int, int, int *))
514 de_fault (to_mourn_inferior
,
517 de_fault (to_can_run
,
519 de_fault (to_notice_signals
,
522 de_fault (to_thread_alive
,
525 de_fault (to_find_new_threads
,
528 de_fault (to_extra_thread_info
,
529 (char *(*) (struct thread_info
*))
535 (void (*) (char *, struct ui_file
*))
537 de_fault (to_enable_exception_callback
,
538 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
540 de_fault (to_get_current_exception_event
,
541 (struct exception_event_record
* (*) (void))
543 de_fault (to_pid_to_exec_file
,
546 de_fault (to_can_async_p
,
549 de_fault (to_is_async_p
,
553 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
558 /* Go through the target stack from top to bottom, copying over zero entries in
559 current_target. In effect, we are doing class inheritance through the
560 pushed target vectors. */
563 update_current_target (void)
565 struct target_stack_item
*item
;
566 struct target_ops
*t
;
568 /* First, reset current_target */
569 memset (¤t_target
, 0, sizeof current_target
);
571 for (item
= target_stack
; item
; item
= item
->next
)
573 t
= item
->target_ops
;
575 #define INHERIT(FIELD, TARGET) \
576 if (!current_target.FIELD) \
577 current_target.FIELD = TARGET->FIELD
579 INHERIT (to_shortname
, t
);
580 INHERIT (to_longname
, t
);
582 INHERIT (to_open
, t
);
583 INHERIT (to_close
, t
);
584 INHERIT (to_attach
, t
);
585 INHERIT (to_post_attach
, t
);
586 INHERIT (to_require_attach
, t
);
587 INHERIT (to_detach
, t
);
588 INHERIT (to_require_detach
, t
);
589 INHERIT (to_resume
, t
);
590 INHERIT (to_wait
, t
);
591 INHERIT (to_post_wait
, t
);
592 INHERIT (to_fetch_registers
, t
);
593 INHERIT (to_store_registers
, t
);
594 INHERIT (to_prepare_to_store
, t
);
595 INHERIT (to_xfer_memory
, t
);
596 INHERIT (to_files_info
, t
);
597 INHERIT (to_insert_breakpoint
, t
);
598 INHERIT (to_remove_breakpoint
, t
);
599 INHERIT (to_can_use_hw_breakpoint
, t
);
600 INHERIT (to_insert_hw_breakpoint
, t
);
601 INHERIT (to_remove_hw_breakpoint
, t
);
602 INHERIT (to_insert_watchpoint
, t
);
603 INHERIT (to_remove_watchpoint
, t
);
604 INHERIT (to_stopped_data_address
, t
);
605 INHERIT (to_stopped_by_watchpoint
, t
);
606 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
607 INHERIT (to_terminal_init
, t
);
608 INHERIT (to_terminal_inferior
, t
);
609 INHERIT (to_terminal_ours_for_output
, t
);
610 INHERIT (to_terminal_ours
, t
);
611 INHERIT (to_terminal_info
, t
);
612 INHERIT (to_kill
, t
);
613 INHERIT (to_load
, t
);
614 INHERIT (to_lookup_symbol
, t
);
615 INHERIT (to_create_inferior
, t
);
616 INHERIT (to_post_startup_inferior
, t
);
617 INHERIT (to_acknowledge_created_inferior
, t
);
618 INHERIT (to_clone_and_follow_inferior
, t
);
619 INHERIT (to_post_follow_inferior_by_clone
, t
);
620 INHERIT (to_insert_fork_catchpoint
, t
);
621 INHERIT (to_remove_fork_catchpoint
, t
);
622 INHERIT (to_insert_vfork_catchpoint
, t
);
623 INHERIT (to_remove_vfork_catchpoint
, t
);
624 INHERIT (to_has_forked
, t
);
625 INHERIT (to_has_vforked
, t
);
626 INHERIT (to_can_follow_vfork_prior_to_exec
, t
);
627 INHERIT (to_post_follow_vfork
, t
);
628 INHERIT (to_insert_exec_catchpoint
, t
);
629 INHERIT (to_remove_exec_catchpoint
, t
);
630 INHERIT (to_has_execd
, t
);
631 INHERIT (to_reported_exec_events_per_exec_call
, t
);
632 INHERIT (to_has_syscall_event
, t
);
633 INHERIT (to_has_exited
, t
);
634 INHERIT (to_mourn_inferior
, t
);
635 INHERIT (to_can_run
, t
);
636 INHERIT (to_notice_signals
, t
);
637 INHERIT (to_thread_alive
, t
);
638 INHERIT (to_find_new_threads
, t
);
639 INHERIT (to_pid_to_str
, t
);
640 INHERIT (to_extra_thread_info
, t
);
641 INHERIT (to_stop
, t
);
642 INHERIT (to_query
, t
);
643 INHERIT (to_rcmd
, t
);
644 INHERIT (to_enable_exception_callback
, t
);
645 INHERIT (to_get_current_exception_event
, t
);
646 INHERIT (to_pid_to_exec_file
, t
);
647 INHERIT (to_stratum
, t
);
648 INHERIT (DONT_USE
, t
);
649 INHERIT (to_has_all_memory
, t
);
650 INHERIT (to_has_memory
, t
);
651 INHERIT (to_has_stack
, t
);
652 INHERIT (to_has_registers
, t
);
653 INHERIT (to_has_execution
, t
);
654 INHERIT (to_has_thread_control
, t
);
655 INHERIT (to_sections
, t
);
656 INHERIT (to_sections_end
, t
);
657 INHERIT (to_can_async_p
, t
);
658 INHERIT (to_is_async_p
, t
);
659 INHERIT (to_async
, t
);
660 INHERIT (to_async_mask_value
, t
);
661 INHERIT (to_find_memory_regions
, t
);
662 INHERIT (to_make_corefile_notes
, t
);
663 INHERIT (to_magic
, t
);
669 /* Push a new target type into the stack of the existing target accessors,
670 possibly superseding some of the existing accessors.
672 Result is zero if the pushed target ended up on top of the stack,
673 nonzero if at least one target is on top of it.
675 Rather than allow an empty stack, we always have the dummy target at
676 the bottom stratum, so we can call the function vectors without
680 push_target (struct target_ops
*t
)
682 struct target_stack_item
*cur
, *prev
, *tmp
;
684 /* Check magic number. If wrong, it probably means someone changed
685 the struct definition, but not all the places that initialize one. */
686 if (t
->to_magic
!= OPS_MAGIC
)
688 fprintf_unfiltered (gdb_stderr
,
689 "Magic number of %s target struct wrong\n",
691 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
694 /* Find the proper stratum to install this target in. */
696 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
698 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
702 /* If there's already targets at this stratum, remove them. */
705 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
707 /* There's already something on this stratum. Close it off. */
708 if (cur
->target_ops
->to_close
)
709 (cur
->target_ops
->to_close
) (0);
711 prev
->next
= cur
->next
; /* Unchain old target_ops */
713 target_stack
= cur
->next
; /* Unchain first on list */
719 /* We have removed all targets in our stratum, now add the new one. */
721 tmp
= (struct target_stack_item
*)
722 xmalloc (sizeof (struct target_stack_item
));
731 update_current_target ();
733 cleanup_target (¤t_target
); /* Fill in the gaps */
736 setup_target_debug ();
741 /* Remove a target_ops vector from the stack, wherever it may be.
742 Return how many times it was removed (0 or 1). */
745 unpush_target (struct target_ops
*t
)
747 struct target_stack_item
*cur
, *prev
;
750 t
->to_close (0); /* Let it clean up */
752 /* Look for the specified target. Note that we assume that a target
753 can only occur once in the target stack. */
755 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
756 if (cur
->target_ops
== t
)
760 return 0; /* Didn't find target_ops, quit now */
762 /* Unchain the target */
765 target_stack
= cur
->next
;
767 prev
->next
= cur
->next
;
769 xfree (cur
); /* Release the target_stack_item */
771 update_current_target ();
772 cleanup_target (¤t_target
);
780 (current_target
.to_close
) (0); /* Let it clean up */
781 if (unpush_target (target_stack
->target_ops
) == 1)
784 fprintf_unfiltered (gdb_stderr
,
785 "pop_target couldn't find target %s\n",
786 current_target
.to_shortname
);
787 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
791 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
793 /* target_read_string -- read a null terminated string, up to LEN bytes,
794 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
795 Set *STRING to a pointer to malloc'd memory containing the data; the caller
796 is responsible for freeing it. Return the number of bytes successfully
800 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
802 int tlen
, origlen
, offset
, i
;
806 int buffer_allocated
;
808 unsigned int nbytes_read
= 0;
810 /* Small for testing. */
811 buffer_allocated
= 4;
812 buffer
= xmalloc (buffer_allocated
);
819 tlen
= MIN (len
, 4 - (memaddr
& 3));
820 offset
= memaddr
& 3;
822 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
825 /* The transfer request might have crossed the boundary to an
826 unallocated region of memory. Retry the transfer, requesting
830 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
835 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
838 bytes
= bufptr
- buffer
;
839 buffer_allocated
*= 2;
840 buffer
= xrealloc (buffer
, buffer_allocated
);
841 bufptr
= buffer
+ bytes
;
844 for (i
= 0; i
< tlen
; i
++)
846 *bufptr
++ = buf
[i
+ offset
];
847 if (buf
[i
+ offset
] == '\000')
849 nbytes_read
+= i
+ 1;
866 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
867 GDB's memory at MYADDR. Returns either 0 for success or an errno value
870 If an error occurs, no guarantee is made about the contents of the data at
871 MYADDR. In particular, the caller should not depend upon partial reads
872 filling the buffer with good data. There is no way for the caller to know
873 how much good data might have been transfered anyway. Callers that can
874 deal with partial reads should call target_read_memory_partial. */
877 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
879 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
883 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
885 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
888 static int trust_readonly
= 0;
890 /* Move memory to or from the targets. The top target gets priority;
891 if it cannot handle it, it is offered to the next one down, etc.
893 Result is -1 on error, or the number of bytes transfered. */
896 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
897 struct mem_attrib
*attrib
)
901 struct target_ops
*t
;
902 struct target_stack_item
*item
;
904 /* Zero length requests are ok and require no work. */
908 /* to_xfer_memory is not guaranteed to set errno, even when it returns
912 if (!write
&& trust_readonly
)
914 /* User-settable option, "trust-readonly-sections". If true,
915 then memory from any SEC_READONLY bfd section may be read
916 directly from the bfd file. */
918 struct section_table
*secp
;
920 for (secp
= current_target
.to_sections
;
921 secp
< current_target
.to_sections_end
;
924 if (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
926 if (memaddr
>= secp
->addr
&& memaddr
< secp
->endaddr
)
927 return xfer_memory (memaddr
, myaddr
, len
, 0,
928 attrib
, ¤t_target
);
932 /* The quick case is that the top target can handle the transfer. */
933 res
= current_target
.to_xfer_memory
934 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
936 /* If res <= 0 then we call it again in the loop. Ah well. */
939 for (item
= target_stack
; item
; item
= item
->next
)
941 t
= item
->target_ops
;
942 if (!t
->to_has_memory
)
945 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
947 break; /* Handled all or part of xfer */
948 if (t
->to_has_all_memory
)
960 /* Perform a memory transfer. Iterate until the entire region has
963 Result is 0 or errno value. */
966 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
970 struct mem_region
*region
;
972 /* Zero length requests are ok and require no work. */
980 region
= lookup_mem_region(memaddr
);
981 if (memaddr
+ len
< region
->hi
)
984 reg_len
= region
->hi
- memaddr
;
986 switch (region
->attrib
.mode
)
1001 if (region
->attrib
.cache
)
1002 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1005 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1010 /* If this address is for nonexistent memory, read zeros
1011 if reading, or do nothing if writing. Return
1014 memset (myaddr
, 0, len
);
1028 return 0; /* We managed to cover it all somehow. */
1032 /* Perform a partial memory transfer.
1034 Result is -1 on error, or the number of bytes transfered. */
1037 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1038 int write_p
, int *err
)
1042 struct mem_region
*region
;
1044 /* Zero length requests are ok and require no work. */
1051 region
= lookup_mem_region(memaddr
);
1052 if (memaddr
+ len
< region
->hi
)
1055 reg_len
= region
->hi
- memaddr
;
1057 switch (region
->attrib
.mode
)
1076 if (region
->attrib
.cache
)
1077 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1080 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1098 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1100 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1104 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1106 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1111 target_info (char *args
, int from_tty
)
1113 struct target_ops
*t
;
1114 struct target_stack_item
*item
;
1115 int has_all_mem
= 0;
1117 if (symfile_objfile
!= NULL
)
1118 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1120 #ifdef FILES_INFO_HOOK
1121 if (FILES_INFO_HOOK ())
1125 for (item
= target_stack
; item
; item
= item
->next
)
1127 t
= item
->target_ops
;
1129 if (!t
->to_has_memory
)
1132 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1135 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1136 printf_unfiltered ("%s:\n", t
->to_longname
);
1137 (t
->to_files_info
) (t
);
1138 has_all_mem
= t
->to_has_all_memory
;
1142 /* This is to be called by the open routine before it does
1146 target_preopen (int from_tty
)
1150 if (target_has_execution
)
1153 || query ("A program is being debugged already. Kill it? "))
1156 error ("Program not killed.");
1159 /* Calling target_kill may remove the target from the stack. But if
1160 it doesn't (which seems like a win for UDI), remove it now. */
1162 if (target_has_execution
)
1166 /* Detach a target after doing deferred register stores. */
1169 target_detach (char *args
, int from_tty
)
1171 /* Handle any optimized stores to the inferior. */
1172 #ifdef DO_DEFERRED_STORES
1175 (current_target
.to_detach
) (args
, from_tty
);
1179 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1181 if (STREQ (current_target
.to_shortname
, "rombug"))
1183 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1185 error ("Unable to link to %s and get relocation in rombug", modname
);
1188 *t_reloc
= (CORE_ADDR
) -1;
1192 target_async_mask (int mask
)
1194 int saved_async_masked_status
= target_async_mask_value
;
1195 target_async_mask_value
= mask
;
1196 return saved_async_masked_status
;
1199 /* Look through the list of possible targets for a target that can
1200 execute a run or attach command without any other data. This is
1201 used to locate the default process stratum.
1203 Result is always valid (error() is called for errors). */
1205 static struct target_ops
*
1206 find_default_run_target (char *do_mesg
)
1208 struct target_ops
**t
;
1209 struct target_ops
*runable
= NULL
;
1214 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1217 if ((*t
)->to_can_run
&& target_can_run (*t
))
1225 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1231 find_default_attach (char *args
, int from_tty
)
1233 struct target_ops
*t
;
1235 t
= find_default_run_target ("attach");
1236 (t
->to_attach
) (args
, from_tty
);
1241 find_default_require_attach (char *args
, int from_tty
)
1243 struct target_ops
*t
;
1245 t
= find_default_run_target ("require_attach");
1246 (t
->to_require_attach
) (args
, from_tty
);
1251 find_default_require_detach (int pid
, char *args
, int from_tty
)
1253 struct target_ops
*t
;
1255 t
= find_default_run_target ("require_detach");
1256 (t
->to_require_detach
) (pid
, args
, from_tty
);
1261 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1263 struct target_ops
*t
;
1265 t
= find_default_run_target ("run");
1266 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1271 find_default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
1273 struct target_ops
*t
;
1275 t
= find_default_run_target ("run");
1276 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1281 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1283 return (byte_count
<= REGISTER_SIZE
);
1299 return_minus_one (void)
1305 * Resize the to_sections pointer. Also make sure that anyone that
1306 * was holding on to an old value of it gets updated.
1307 * Returns the old size.
1311 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1313 struct target_ops
**t
;
1314 struct section_table
*old_value
;
1317 old_value
= target
->to_sections
;
1319 if (target
->to_sections
)
1321 old_count
= target
->to_sections_end
- target
->to_sections
;
1322 target
->to_sections
= (struct section_table
*)
1323 xrealloc ((char *) target
->to_sections
,
1324 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1329 target
->to_sections
= (struct section_table
*)
1330 xmalloc ((sizeof (struct section_table
)) * num_added
);
1332 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1334 /* Check to see if anyone else was pointing to this structure.
1335 If old_value was null, then no one was. */
1339 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1342 if ((*t
)->to_sections
== old_value
)
1344 (*t
)->to_sections
= target
->to_sections
;
1345 (*t
)->to_sections_end
= target
->to_sections_end
;
1354 /* Remove all target sections taken from ABFD.
1356 Scan the current target stack for targets whose section tables
1357 refer to sections from BFD, and remove those sections. We use this
1358 when we notice that the inferior has unloaded a shared object, for
1361 remove_target_sections (bfd
*abfd
)
1363 struct target_ops
**t
;
1365 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1367 struct section_table
*src
, *dest
;
1369 dest
= (*t
)->to_sections
;
1370 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1371 if (src
->bfd
!= abfd
)
1373 /* Keep this section. */
1374 if (dest
< src
) *dest
= *src
;
1378 /* If we've dropped any sections, resize the section table. */
1380 target_resize_to_sections (*t
, dest
- src
);
1387 /* Find a single runnable target in the stack and return it. If for
1388 some reason there is more than one, return NULL. */
1391 find_run_target (void)
1393 struct target_ops
**t
;
1394 struct target_ops
*runable
= NULL
;
1399 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1401 if ((*t
)->to_can_run
&& target_can_run (*t
))
1408 return (count
== 1 ? runable
: NULL
);
1411 /* Find a single core_stratum target in the list of targets and return it.
1412 If for some reason there is more than one, return NULL. */
1415 find_core_target (void)
1417 struct target_ops
**t
;
1418 struct target_ops
*runable
= NULL
;
1423 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1426 if ((*t
)->to_stratum
== core_stratum
)
1433 return (count
== 1 ? runable
: NULL
);
1437 * Find the next target down the stack from the specified target.
1441 find_target_beneath (struct target_ops
*t
)
1443 struct target_stack_item
*cur
;
1445 for (cur
= target_stack
; cur
; cur
= cur
->next
)
1446 if (cur
->target_ops
== t
)
1449 if (cur
== NULL
|| cur
->next
== NULL
)
1452 return cur
->next
->target_ops
;
1456 /* The inferior process has died. Long live the inferior! */
1459 generic_mourn_inferior (void)
1461 extern int show_breakpoint_hit_counts
;
1463 inferior_ptid
= null_ptid
;
1465 breakpoint_init_inferior (inf_exited
);
1466 registers_changed ();
1468 #ifdef CLEAR_DEFERRED_STORES
1469 /* Delete any pending stores to the inferior... */
1470 CLEAR_DEFERRED_STORES
;
1473 reopen_exec_file ();
1474 reinit_frame_cache ();
1476 /* It is confusing to the user for ignore counts to stick around
1477 from previous runs of the inferior. So clear them. */
1478 /* However, it is more confusing for the ignore counts to disappear when
1479 using hit counts. So don't clear them if we're counting hits. */
1480 if (!show_breakpoint_hit_counts
)
1481 breakpoint_clear_ignore_counts ();
1487 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1488 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1489 translation of that in OURSTATUS. */
1491 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1493 #ifdef CHILD_SPECIAL_WAITSTATUS
1494 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1495 if it wants to deal with hoststatus. */
1496 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1500 if (WIFEXITED (hoststatus
))
1502 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1503 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1505 else if (!WIFSTOPPED (hoststatus
))
1507 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1508 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1512 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1513 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1517 /* Returns zero to leave the inferior alone, one to interrupt it. */
1518 int (*target_activity_function
) (void);
1519 int target_activity_fd
;
1521 /* Convert a normal process ID to a string. Returns the string in a static
1525 normal_pid_to_str (ptid_t ptid
)
1527 static char buf
[30];
1529 sprintf (buf
, "process %d", PIDGET (ptid
));
1533 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1534 notification of inferior events such as fork and vork immediately
1535 after the inferior is created. (This because of how gdb gets an
1536 inferior created via invoking a shell to do it. In such a scenario,
1537 if the shell init file has commands in it, the shell will fork and
1538 exec for each of those commands, and we will see each such fork
1541 This function is used by all targets that allow us to request
1542 notification of forks, etc at inferior creation time; e.g., in
1543 target_acknowledge_forked_child.
1546 normal_target_post_startup_inferior (ptid_t ptid
)
1548 /* This space intentionally left blank. */
1551 /* Error-catcher for target_find_memory_regions */
1553 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1555 error ("No target.");
1559 /* Error-catcher for target_make_corefile_notes */
1561 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1563 error ("No target.");
1567 /* Set up the handful of non-empty slots needed by the dummy target
1571 init_dummy_target (void)
1573 dummy_target
.to_shortname
= "None";
1574 dummy_target
.to_longname
= "None";
1575 dummy_target
.to_doc
= "";
1576 dummy_target
.to_attach
= find_default_attach
;
1577 dummy_target
.to_require_attach
= find_default_require_attach
;
1578 dummy_target
.to_require_detach
= find_default_require_detach
;
1579 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1580 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
1581 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1582 dummy_target
.to_stratum
= dummy_stratum
;
1583 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1584 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1585 dummy_target
.to_magic
= OPS_MAGIC
;
1589 static struct target_ops debug_target
;
1592 debug_to_open (char *args
, int from_tty
)
1594 debug_target
.to_open (args
, from_tty
);
1596 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1600 debug_to_close (int quitting
)
1602 debug_target
.to_close (quitting
);
1604 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1608 debug_to_attach (char *args
, int from_tty
)
1610 debug_target
.to_attach (args
, from_tty
);
1612 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1617 debug_to_post_attach (int pid
)
1619 debug_target
.to_post_attach (pid
);
1621 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1625 debug_to_require_attach (char *args
, int from_tty
)
1627 debug_target
.to_require_attach (args
, from_tty
);
1629 fprintf_unfiltered (gdb_stdlog
,
1630 "target_require_attach (%s, %d)\n", args
, from_tty
);
1634 debug_to_detach (char *args
, int from_tty
)
1636 debug_target
.to_detach (args
, from_tty
);
1638 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1642 debug_to_require_detach (int pid
, char *args
, int from_tty
)
1644 debug_target
.to_require_detach (pid
, args
, from_tty
);
1646 fprintf_unfiltered (gdb_stdlog
,
1647 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
1651 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1653 debug_target
.to_resume (ptid
, step
, siggnal
);
1655 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1656 step
? "step" : "continue",
1657 target_signal_to_name (siggnal
));
1661 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1665 retval
= debug_target
.to_wait (ptid
, status
);
1667 fprintf_unfiltered (gdb_stdlog
,
1668 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1670 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1671 switch (status
->kind
)
1673 case TARGET_WAITKIND_EXITED
:
1674 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1675 status
->value
.integer
);
1677 case TARGET_WAITKIND_STOPPED
:
1678 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1679 target_signal_to_name (status
->value
.sig
));
1681 case TARGET_WAITKIND_SIGNALLED
:
1682 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1683 target_signal_to_name (status
->value
.sig
));
1685 case TARGET_WAITKIND_LOADED
:
1686 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1688 case TARGET_WAITKIND_FORKED
:
1689 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1691 case TARGET_WAITKIND_VFORKED
:
1692 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1694 case TARGET_WAITKIND_EXECD
:
1695 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1697 case TARGET_WAITKIND_SPURIOUS
:
1698 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1701 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1709 debug_to_post_wait (ptid_t ptid
, int status
)
1711 debug_target
.to_post_wait (ptid
, status
);
1713 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1714 PIDGET (ptid
), status
);
1718 debug_print_register (const char * func
, int regno
)
1720 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1721 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1722 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1723 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1725 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1729 unsigned char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1730 read_register_gen (regno
, buf
);
1731 fprintf_unfiltered (gdb_stdlog
, " = ");
1732 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
1734 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1736 if (REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1738 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1739 paddr_nz (read_register (regno
)),
1740 paddr_d (read_register (regno
)));
1743 fprintf_unfiltered (gdb_stdlog
, "\n");
1747 debug_to_fetch_registers (int regno
)
1749 debug_target
.to_fetch_registers (regno
);
1750 debug_print_register ("target_fetch_registers", regno
);
1754 debug_to_store_registers (int regno
)
1756 debug_target
.to_store_registers (regno
);
1757 debug_print_register ("target_store_registers", regno
);
1758 fprintf_unfiltered (gdb_stdlog
, "\n");
1762 debug_to_prepare_to_store (void)
1764 debug_target
.to_prepare_to_store ();
1766 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1770 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1771 struct mem_attrib
*attrib
,
1772 struct target_ops
*target
)
1776 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1779 fprintf_unfiltered (gdb_stdlog
,
1780 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1781 (unsigned int) memaddr
, /* possable truncate long long */
1782 len
, write
? "write" : "read", retval
);
1790 fputs_unfiltered (", bytes =", gdb_stdlog
);
1791 for (i
= 0; i
< retval
; i
++)
1793 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1794 fprintf_unfiltered (gdb_stdlog
, "\n");
1795 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1799 fputc_unfiltered ('\n', gdb_stdlog
);
1805 debug_to_files_info (struct target_ops
*target
)
1807 debug_target
.to_files_info (target
);
1809 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1813 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1817 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1819 fprintf_unfiltered (gdb_stdlog
,
1820 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1821 (unsigned long) addr
,
1822 (unsigned long) retval
);
1827 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1831 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1833 fprintf_unfiltered (gdb_stdlog
,
1834 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1835 (unsigned long) addr
,
1836 (unsigned long) retval
);
1841 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1845 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1847 fprintf_unfiltered (gdb_stdlog
,
1848 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1849 (unsigned long) type
,
1850 (unsigned long) cnt
,
1851 (unsigned long) from_tty
,
1852 (unsigned long) retval
);
1857 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1861 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1863 fprintf_unfiltered (gdb_stdlog
,
1864 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1865 (unsigned long) byte_count
,
1866 (unsigned long) retval
);
1871 debug_to_stopped_by_watchpoint (void)
1875 retval
= debug_target
.to_stopped_by_watchpoint ();
1877 fprintf_unfiltered (gdb_stdlog
,
1878 "STOPPED_BY_WATCHPOINT () = %ld\n",
1879 (unsigned long) retval
);
1884 debug_to_stopped_data_address (void)
1888 retval
= debug_target
.to_stopped_data_address ();
1890 fprintf_unfiltered (gdb_stdlog
,
1891 "target_stopped_data_address () = 0x%lx\n",
1892 (unsigned long) retval
);
1897 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1901 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1903 fprintf_unfiltered (gdb_stdlog
,
1904 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1905 (unsigned long) addr
,
1906 (unsigned long) retval
);
1911 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1915 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1917 fprintf_unfiltered (gdb_stdlog
,
1918 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1919 (unsigned long) addr
,
1920 (unsigned long) retval
);
1925 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1929 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1931 fprintf_unfiltered (gdb_stdlog
,
1932 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1933 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1938 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
1942 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1944 fprintf_unfiltered (gdb_stdlog
,
1945 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1946 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1951 debug_to_terminal_init (void)
1953 debug_target
.to_terminal_init ();
1955 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
1959 debug_to_terminal_inferior (void)
1961 debug_target
.to_terminal_inferior ();
1963 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
1967 debug_to_terminal_ours_for_output (void)
1969 debug_target
.to_terminal_ours_for_output ();
1971 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
1975 debug_to_terminal_ours (void)
1977 debug_target
.to_terminal_ours ();
1979 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
1983 debug_to_terminal_info (char *arg
, int from_tty
)
1985 debug_target
.to_terminal_info (arg
, from_tty
);
1987 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
1992 debug_to_kill (void)
1994 debug_target
.to_kill ();
1996 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2000 debug_to_load (char *args
, int from_tty
)
2002 debug_target
.to_load (args
, from_tty
);
2004 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2008 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2012 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2014 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2020 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2022 debug_target
.to_create_inferior (exec_file
, args
, env
);
2024 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2029 debug_to_post_startup_inferior (ptid_t ptid
)
2031 debug_target
.to_post_startup_inferior (ptid
);
2033 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2038 debug_to_acknowledge_created_inferior (int pid
)
2040 debug_target
.to_acknowledge_created_inferior (pid
);
2042 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2047 debug_to_clone_and_follow_inferior (int child_pid
, int *followed_child
)
2049 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
2051 fprintf_unfiltered (gdb_stdlog
,
2052 "target_clone_and_follow_inferior (%d, %d)\n",
2053 child_pid
, *followed_child
);
2057 debug_to_post_follow_inferior_by_clone (void)
2059 debug_target
.to_post_follow_inferior_by_clone ();
2061 fprintf_unfiltered (gdb_stdlog
, "target_post_follow_inferior_by_clone ()\n");
2065 debug_to_insert_fork_catchpoint (int pid
)
2069 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2071 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2078 debug_to_remove_fork_catchpoint (int pid
)
2082 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2084 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2091 debug_to_insert_vfork_catchpoint (int pid
)
2095 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2097 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2104 debug_to_remove_vfork_catchpoint (int pid
)
2108 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2110 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2117 debug_to_has_forked (int pid
, int *child_pid
)
2121 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
2123 fprintf_unfiltered (gdb_stdlog
, "target_has_forked (%d, %d) = %d\n",
2124 pid
, *child_pid
, has_forked
);
2130 debug_to_has_vforked (int pid
, int *child_pid
)
2134 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
2136 fprintf_unfiltered (gdb_stdlog
, "target_has_vforked (%d, %d) = %d\n",
2137 pid
, *child_pid
, has_vforked
);
2143 debug_to_can_follow_vfork_prior_to_exec (void)
2145 int can_immediately_follow_vfork
;
2147 can_immediately_follow_vfork
= debug_target
.to_can_follow_vfork_prior_to_exec ();
2149 fprintf_unfiltered (gdb_stdlog
, "target_can_follow_vfork_prior_to_exec () = %d\n",
2150 can_immediately_follow_vfork
);
2152 return can_immediately_follow_vfork
;
2156 debug_to_post_follow_vfork (int parent_pid
, int followed_parent
, int child_pid
,
2159 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
2161 fprintf_unfiltered (gdb_stdlog
,
2162 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2163 parent_pid
, followed_parent
, child_pid
, followed_child
);
2167 debug_to_insert_exec_catchpoint (int pid
)
2171 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2173 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2180 debug_to_remove_exec_catchpoint (int pid
)
2184 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2186 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2193 debug_to_has_execd (int pid
, char **execd_pathname
)
2197 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2199 fprintf_unfiltered (gdb_stdlog
, "target_has_execd (%d, %s) = %d\n",
2200 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
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_syscall_event (int pid
, enum target_waitkind
*kind
,
2224 int has_syscall_event
;
2225 char *kind_spelling
= "??";
2227 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2228 if (has_syscall_event
)
2232 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2233 kind_spelling
= "SYSCALL_ENTRY";
2235 case TARGET_WAITKIND_SYSCALL_RETURN
:
2236 kind_spelling
= "SYSCALL_RETURN";
2243 fprintf_unfiltered (gdb_stdlog
,
2244 "target_has_syscall_event (%d, %s, %d) = %d\n",
2245 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2247 return has_syscall_event
;
2251 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2255 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2257 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2258 pid
, wait_status
, *exit_status
, has_exited
);
2264 debug_to_mourn_inferior (void)
2266 debug_target
.to_mourn_inferior ();
2268 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2272 debug_to_can_run (void)
2276 retval
= debug_target
.to_can_run ();
2278 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2284 debug_to_notice_signals (ptid_t ptid
)
2286 debug_target
.to_notice_signals (ptid
);
2288 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2293 debug_to_thread_alive (ptid_t ptid
)
2297 retval
= debug_target
.to_thread_alive (ptid
);
2299 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2300 PIDGET (ptid
), retval
);
2306 debug_to_find_new_threads (void)
2308 debug_target
.to_find_new_threads ();
2310 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2314 debug_to_stop (void)
2316 debug_target
.to_stop ();
2318 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2322 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2326 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2328 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2334 debug_to_rcmd (char *command
,
2335 struct ui_file
*outbuf
)
2337 debug_target
.to_rcmd (command
, outbuf
);
2338 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2341 static struct symtab_and_line
*
2342 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2344 struct symtab_and_line
*result
;
2345 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2346 fprintf_unfiltered (gdb_stdlog
,
2347 "target get_exception_callback_sal (%d, %d)\n",
2352 static struct exception_event_record
*
2353 debug_to_get_current_exception_event (void)
2355 struct exception_event_record
*result
;
2356 result
= debug_target
.to_get_current_exception_event ();
2357 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2362 debug_to_pid_to_exec_file (int pid
)
2366 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2368 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2375 setup_target_debug (void)
2377 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2379 current_target
.to_open
= debug_to_open
;
2380 current_target
.to_close
= debug_to_close
;
2381 current_target
.to_attach
= debug_to_attach
;
2382 current_target
.to_post_attach
= debug_to_post_attach
;
2383 current_target
.to_require_attach
= debug_to_require_attach
;
2384 current_target
.to_detach
= debug_to_detach
;
2385 current_target
.to_require_detach
= debug_to_require_detach
;
2386 current_target
.to_resume
= debug_to_resume
;
2387 current_target
.to_wait
= debug_to_wait
;
2388 current_target
.to_post_wait
= debug_to_post_wait
;
2389 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2390 current_target
.to_store_registers
= debug_to_store_registers
;
2391 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2392 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2393 current_target
.to_files_info
= debug_to_files_info
;
2394 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2395 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2396 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2397 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2398 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2399 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2400 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2401 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2402 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2403 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2404 current_target
.to_terminal_init
= debug_to_terminal_init
;
2405 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2406 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2407 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2408 current_target
.to_terminal_info
= debug_to_terminal_info
;
2409 current_target
.to_kill
= debug_to_kill
;
2410 current_target
.to_load
= debug_to_load
;
2411 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2412 current_target
.to_create_inferior
= debug_to_create_inferior
;
2413 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2414 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2415 current_target
.to_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2416 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2417 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2418 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2419 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2420 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2421 current_target
.to_has_forked
= debug_to_has_forked
;
2422 current_target
.to_has_vforked
= debug_to_has_vforked
;
2423 current_target
.to_can_follow_vfork_prior_to_exec
= debug_to_can_follow_vfork_prior_to_exec
;
2424 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2425 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2426 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2427 current_target
.to_has_execd
= debug_to_has_execd
;
2428 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2429 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2430 current_target
.to_has_exited
= debug_to_has_exited
;
2431 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2432 current_target
.to_can_run
= debug_to_can_run
;
2433 current_target
.to_notice_signals
= debug_to_notice_signals
;
2434 current_target
.to_thread_alive
= debug_to_thread_alive
;
2435 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2436 current_target
.to_stop
= debug_to_stop
;
2437 current_target
.to_query
= debug_to_query
;
2438 current_target
.to_rcmd
= debug_to_rcmd
;
2439 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2440 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2441 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2446 static char targ_desc
[] =
2447 "Names of targets and files being debugged.\n\
2448 Shows the entire stack of targets currently in use (including the exec-file,\n\
2449 core-file, and process, if any), as well as the symbol file name.";
2452 do_monitor_command (char *cmd
,
2455 if ((current_target
.to_rcmd
2456 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2457 || (current_target
.to_rcmd
== debug_to_rcmd
2458 && (debug_target
.to_rcmd
2459 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2461 error ("\"monitor\" command not supported by this target.\n");
2463 target_rcmd (cmd
, gdb_stdtarg
);
2467 initialize_targets (void)
2469 init_dummy_target ();
2470 push_target (&dummy_target
);
2472 add_info ("target", target_info
, targ_desc
);
2473 add_info ("files", target_info
, targ_desc
);
2476 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2477 (char *) &targetdebug
,
2478 "Set target debugging.\n\
2479 When non-zero, target debugging is enabled.", &setdebuglist
),
2482 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2484 Set mode for reading from readonly sections.\n\
2485 When this mode is on, memory reads from readonly sections (such as .text)\n\
2486 will be read from the object file instead of from the target. This will\n\
2487 result in significant performance improvement for remote targets.", "\
2488 Show mode for reading from readonly sections.\n",
2490 &setlist
, &showlist
);
2492 add_com ("monitor", class_obscure
, do_monitor_command
,
2493 "Send a command to the remote monitor (remote targets only).");
2495 target_dcache
= dcache_init ();