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_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_terminal_info (char *, int);
147 static void debug_to_kill (void);
149 static void debug_to_load (char *, int);
151 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
153 static void debug_to_create_inferior (char *, char *, char **);
155 static void debug_to_mourn_inferior (void);
157 static int debug_to_can_run (void);
159 static void debug_to_notice_signals (ptid_t
);
161 static int debug_to_thread_alive (ptid_t
);
163 static void debug_to_stop (void);
165 static int debug_to_query (int /*char */ , char *, char *, int *);
167 /* Pointer to array of target architecture structures; the size of the
168 array; the current index into the array; the allocated size of the
170 struct target_ops
**target_structs
;
171 unsigned target_struct_size
;
172 unsigned target_struct_index
;
173 unsigned target_struct_allocsize
;
174 #define DEFAULT_ALLOCSIZE 10
176 /* The initial current target, so that there is always a semi-valid
179 static struct target_ops dummy_target
;
181 /* Top of target stack. */
183 struct target_stack_item
*target_stack
;
185 /* The target structure we are currently using to talk to a process
186 or file or whatever "inferior" we have. */
188 struct target_ops current_target
;
190 /* Command list for target. */
192 static struct cmd_list_element
*targetlist
= NULL
;
194 /* Nonzero if we are debugging an attached outside process
195 rather than an inferior. */
199 /* Non-zero if we want to see trace of target level stuff. */
201 static int targetdebug
= 0;
203 static void setup_target_debug (void);
205 DCACHE
*target_dcache
;
207 /* 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
)
224 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
225 target_structs
= (struct target_ops
**) xmalloc
226 (target_struct_allocsize
* sizeof (*target_structs
));
228 if (target_struct_size
>= target_struct_allocsize
)
230 target_struct_allocsize
*= 2;
231 target_structs
= (struct target_ops
**)
232 xrealloc ((char *) target_structs
,
233 target_struct_allocsize
* sizeof (*target_structs
));
235 target_structs
[target_struct_size
++] = t
;
236 /* cleanup_target (t); */
238 if (targetlist
== NULL
)
239 add_prefix_cmd ("target", class_run
, target_command
,
240 "Connect to a target machine or process.\n\
241 The first argument is the type or protocol of the target machine.\n\
242 Remaining arguments are interpreted by the target protocol. For more\n\
243 information on the arguments for a particular protocol, type\n\
244 `help target ' followed by the protocol name.",
245 &targetlist
, "target ", 0, &cmdlist
);
246 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
257 target_load (char *arg
, int from_tty
)
259 dcache_invalidate (target_dcache
);
260 (*current_target
.to_load
) (arg
, from_tty
);
265 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
266 struct target_ops
*t
)
268 errno
= EIO
; /* Can't read/write this location */
269 return 0; /* No bytes handled */
275 error ("You can't do that when your target is `%s'",
276 current_target
.to_shortname
);
282 error ("You can't do that without a process to debug.");
287 nosymbol (char *name
, CORE_ADDR
*addrp
)
289 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");
305 default_terminal_info (char *args
, int from_tty
)
307 printf_unfiltered ("No saved terminal information.\n");
310 /* This is the default target_create_inferior and target_attach function.
311 If the current target is executing, it asks whether to kill it off.
312 If this function returns without calling error(), it has killed off
313 the target, and the operation should be attempted. */
316 kill_or_be_killed (int from_tty
)
318 if (target_has_execution
)
320 printf_unfiltered ("You are already running a program:\n");
321 target_files_info ();
322 if (query ("Kill it? "))
325 if (target_has_execution
)
326 error ("Killing the program did not help.");
331 error ("Program not killed.");
338 maybe_kill_then_attach (char *args
, int from_tty
)
340 kill_or_be_killed (from_tty
);
341 target_attach (args
, from_tty
);
345 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
347 kill_or_be_killed (0);
348 target_create_inferior (exec
, args
, env
);
352 default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
354 target_clone_and_follow_inferior (child_pid
, followed_child
);
357 /* Clean up a target struct so it no longer has any zero pointers in it.
358 We default entries, at least to stubs that print error messages. */
361 cleanup_target (struct target_ops
*t
)
364 #define de_fault(field, value) \
369 (void (*) (char *, int))
375 maybe_kill_then_attach
);
376 de_fault (to_post_attach
,
379 de_fault (to_require_attach
,
380 maybe_kill_then_attach
);
382 (void (*) (char *, int))
384 de_fault (to_require_detach
,
385 (void (*) (int, char *, int))
388 (void (*) (ptid_t
, int, enum target_signal
))
391 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
393 de_fault (to_post_wait
,
394 (void (*) (ptid_t
, int))
396 de_fault (to_fetch_registers
,
399 de_fault (to_store_registers
,
402 de_fault (to_prepare_to_store
,
405 de_fault (to_xfer_memory
,
406 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
408 de_fault (to_files_info
,
409 (void (*) (struct target_ops
*))
411 de_fault (to_insert_breakpoint
,
412 memory_insert_breakpoint
);
413 de_fault (to_remove_breakpoint
,
414 memory_remove_breakpoint
);
415 de_fault (to_can_use_hw_breakpoint
,
416 (int (*) (int, int, int))
418 de_fault (to_insert_hw_breakpoint
,
419 (int (*) (CORE_ADDR
, char *))
421 de_fault (to_remove_hw_breakpoint
,
422 (int (*) (CORE_ADDR
, char *))
424 de_fault (to_insert_watchpoint
,
425 (int (*) (CORE_ADDR
, int, int))
427 de_fault (to_remove_watchpoint
,
428 (int (*) (CORE_ADDR
, int, int))
430 de_fault (to_stopped_by_watchpoint
,
433 de_fault (to_stopped_data_address
,
434 (CORE_ADDR (*) (void))
436 de_fault (to_region_size_ok_for_hw_watchpoint
,
437 default_region_size_ok_for_hw_watchpoint
);
438 de_fault (to_terminal_init
,
441 de_fault (to_terminal_inferior
,
444 de_fault (to_terminal_ours_for_output
,
447 de_fault (to_terminal_ours
,
450 de_fault (to_terminal_save_ours
,
453 de_fault (to_terminal_info
,
454 default_terminal_info
);
459 (void (*) (char *, int))
461 de_fault (to_lookup_symbol
,
462 (int (*) (char *, CORE_ADDR
*))
464 de_fault (to_create_inferior
,
465 maybe_kill_then_create_inferior
);
466 de_fault (to_post_startup_inferior
,
469 de_fault (to_acknowledge_created_inferior
,
472 de_fault (to_clone_and_follow_inferior
,
473 default_clone_and_follow_inferior
);
474 de_fault (to_post_follow_inferior_by_clone
,
477 de_fault (to_insert_fork_catchpoint
,
480 de_fault (to_remove_fork_catchpoint
,
483 de_fault (to_insert_vfork_catchpoint
,
486 de_fault (to_remove_vfork_catchpoint
,
489 de_fault (to_has_forked
,
490 (int (*) (int, int *))
492 de_fault (to_has_vforked
,
493 (int (*) (int, int *))
495 de_fault (to_post_follow_vfork
,
496 (void (*) (int, int, int, int))
498 de_fault (to_insert_exec_catchpoint
,
501 de_fault (to_remove_exec_catchpoint
,
504 de_fault (to_has_execd
,
505 (int (*) (int, char **))
507 de_fault (to_reported_exec_events_per_exec_call
,
510 de_fault (to_has_syscall_event
,
511 (int (*) (int, enum target_waitkind
*, int *))
513 de_fault (to_has_exited
,
514 (int (*) (int, int, int *))
516 de_fault (to_mourn_inferior
,
519 de_fault (to_can_run
,
521 de_fault (to_notice_signals
,
524 de_fault (to_thread_alive
,
527 de_fault (to_find_new_threads
,
530 de_fault (to_extra_thread_info
,
531 (char *(*) (struct thread_info
*))
537 (void (*) (char *, struct ui_file
*))
539 de_fault (to_enable_exception_callback
,
540 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
542 de_fault (to_get_current_exception_event
,
543 (struct exception_event_record
* (*) (void))
545 de_fault (to_pid_to_exec_file
,
548 de_fault (to_can_async_p
,
551 de_fault (to_is_async_p
,
555 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
560 /* Go through the target stack from top to bottom, copying over zero entries in
561 current_target. In effect, we are doing class inheritance through the
562 pushed target vectors. */
565 update_current_target (void)
567 struct target_stack_item
*item
;
568 struct target_ops
*t
;
570 /* First, reset current_target */
571 memset (¤t_target
, 0, sizeof current_target
);
573 for (item
= target_stack
; item
; item
= item
->next
)
575 t
= item
->target_ops
;
577 #define INHERIT(FIELD, TARGET) \
578 if (!current_target.FIELD) \
579 current_target.FIELD = TARGET->FIELD
581 INHERIT (to_shortname
, t
);
582 INHERIT (to_longname
, t
);
584 INHERIT (to_open
, t
);
585 INHERIT (to_close
, t
);
586 INHERIT (to_attach
, t
);
587 INHERIT (to_post_attach
, t
);
588 INHERIT (to_require_attach
, t
);
589 INHERIT (to_detach
, t
);
590 INHERIT (to_require_detach
, t
);
591 INHERIT (to_resume
, t
);
592 INHERIT (to_wait
, t
);
593 INHERIT (to_post_wait
, t
);
594 INHERIT (to_fetch_registers
, t
);
595 INHERIT (to_store_registers
, t
);
596 INHERIT (to_prepare_to_store
, t
);
597 INHERIT (to_xfer_memory
, t
);
598 INHERIT (to_files_info
, t
);
599 INHERIT (to_insert_breakpoint
, t
);
600 INHERIT (to_remove_breakpoint
, t
);
601 INHERIT (to_can_use_hw_breakpoint
, t
);
602 INHERIT (to_insert_hw_breakpoint
, t
);
603 INHERIT (to_remove_hw_breakpoint
, t
);
604 INHERIT (to_insert_watchpoint
, t
);
605 INHERIT (to_remove_watchpoint
, t
);
606 INHERIT (to_stopped_data_address
, t
);
607 INHERIT (to_stopped_by_watchpoint
, t
);
608 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
609 INHERIT (to_terminal_init
, t
);
610 INHERIT (to_terminal_inferior
, t
);
611 INHERIT (to_terminal_ours_for_output
, t
);
612 INHERIT (to_terminal_ours
, t
);
613 INHERIT (to_terminal_save_ours
, t
);
614 INHERIT (to_terminal_info
, t
);
615 INHERIT (to_kill
, t
);
616 INHERIT (to_load
, t
);
617 INHERIT (to_lookup_symbol
, t
);
618 INHERIT (to_create_inferior
, t
);
619 INHERIT (to_post_startup_inferior
, t
);
620 INHERIT (to_acknowledge_created_inferior
, t
);
621 INHERIT (to_clone_and_follow_inferior
, t
);
622 INHERIT (to_post_follow_inferior_by_clone
, t
);
623 INHERIT (to_insert_fork_catchpoint
, t
);
624 INHERIT (to_remove_fork_catchpoint
, t
);
625 INHERIT (to_insert_vfork_catchpoint
, t
);
626 INHERIT (to_remove_vfork_catchpoint
, t
);
627 INHERIT (to_has_forked
, t
);
628 INHERIT (to_has_vforked
, t
);
629 INHERIT (to_post_follow_vfork
, t
);
630 INHERIT (to_insert_exec_catchpoint
, t
);
631 INHERIT (to_remove_exec_catchpoint
, t
);
632 INHERIT (to_has_execd
, t
);
633 INHERIT (to_reported_exec_events_per_exec_call
, t
);
634 INHERIT (to_has_syscall_event
, t
);
635 INHERIT (to_has_exited
, t
);
636 INHERIT (to_mourn_inferior
, t
);
637 INHERIT (to_can_run
, t
);
638 INHERIT (to_notice_signals
, t
);
639 INHERIT (to_thread_alive
, t
);
640 INHERIT (to_find_new_threads
, t
);
641 INHERIT (to_pid_to_str
, t
);
642 INHERIT (to_extra_thread_info
, t
);
643 INHERIT (to_stop
, t
);
644 INHERIT (to_query
, t
);
645 INHERIT (to_rcmd
, t
);
646 INHERIT (to_enable_exception_callback
, t
);
647 INHERIT (to_get_current_exception_event
, t
);
648 INHERIT (to_pid_to_exec_file
, t
);
649 INHERIT (to_stratum
, t
);
650 INHERIT (DONT_USE
, t
);
651 INHERIT (to_has_all_memory
, t
);
652 INHERIT (to_has_memory
, t
);
653 INHERIT (to_has_stack
, t
);
654 INHERIT (to_has_registers
, t
);
655 INHERIT (to_has_execution
, t
);
656 INHERIT (to_has_thread_control
, t
);
657 INHERIT (to_sections
, t
);
658 INHERIT (to_sections_end
, t
);
659 INHERIT (to_can_async_p
, t
);
660 INHERIT (to_is_async_p
, t
);
661 INHERIT (to_async
, t
);
662 INHERIT (to_async_mask_value
, t
);
663 INHERIT (to_find_memory_regions
, t
);
664 INHERIT (to_make_corefile_notes
, t
);
665 INHERIT (to_get_thread_local_address
, t
);
666 INHERIT (to_magic
, t
);
672 /* Push a new target type into the stack of the existing target accessors,
673 possibly superseding some of the existing accessors.
675 Result is zero if the pushed target ended up on top of the stack,
676 nonzero if at least one target is on top of it.
678 Rather than allow an empty stack, we always have the dummy target at
679 the bottom stratum, so we can call the function vectors without
683 push_target (struct target_ops
*t
)
685 struct target_stack_item
*cur
, *prev
, *tmp
;
687 /* Check magic number. If wrong, it probably means someone changed
688 the struct definition, but not all the places that initialize one. */
689 if (t
->to_magic
!= OPS_MAGIC
)
691 fprintf_unfiltered (gdb_stderr
,
692 "Magic number of %s target struct wrong\n",
694 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
697 /* Find the proper stratum to install this target in. */
699 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
701 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
705 /* If there's already targets at this stratum, remove them. */
708 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
710 /* There's already something on this stratum. Close it off. */
711 if (cur
->target_ops
->to_close
)
712 (cur
->target_ops
->to_close
) (0);
714 prev
->next
= cur
->next
; /* Unchain old target_ops */
716 target_stack
= cur
->next
; /* Unchain first on list */
722 /* We have removed all targets in our stratum, now add the new one. */
724 tmp
= (struct target_stack_item
*)
725 xmalloc (sizeof (struct target_stack_item
));
734 update_current_target ();
736 cleanup_target (¤t_target
); /* Fill in the gaps */
739 setup_target_debug ();
744 /* Remove a target_ops vector from the stack, wherever it may be.
745 Return how many times it was removed (0 or 1). */
748 unpush_target (struct target_ops
*t
)
750 struct target_stack_item
*cur
, *prev
;
753 t
->to_close (0); /* Let it clean up */
755 /* Look for the specified target. Note that we assume that a target
756 can only occur once in the target stack. */
758 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
759 if (cur
->target_ops
== t
)
763 return 0; /* Didn't find target_ops, quit now */
765 /* Unchain the target */
768 target_stack
= cur
->next
;
770 prev
->next
= cur
->next
;
772 xfree (cur
); /* Release the target_stack_item */
774 update_current_target ();
775 cleanup_target (¤t_target
);
783 (current_target
.to_close
) (0); /* Let it clean up */
784 if (unpush_target (target_stack
->target_ops
) == 1)
787 fprintf_unfiltered (gdb_stderr
,
788 "pop_target couldn't find target %s\n",
789 current_target
.to_shortname
);
790 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
794 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
796 /* target_read_string -- read a null terminated string, up to LEN bytes,
797 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
798 Set *STRING to a pointer to malloc'd memory containing the data; the caller
799 is responsible for freeing it. Return the number of bytes successfully
803 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
805 int tlen
, origlen
, offset
, i
;
809 int buffer_allocated
;
811 unsigned int nbytes_read
= 0;
813 /* Small for testing. */
814 buffer_allocated
= 4;
815 buffer
= xmalloc (buffer_allocated
);
822 tlen
= MIN (len
, 4 - (memaddr
& 3));
823 offset
= memaddr
& 3;
825 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
828 /* The transfer request might have crossed the boundary to an
829 unallocated region of memory. Retry the transfer, requesting
833 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
838 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
841 bytes
= bufptr
- buffer
;
842 buffer_allocated
*= 2;
843 buffer
= xrealloc (buffer
, buffer_allocated
);
844 bufptr
= buffer
+ bytes
;
847 for (i
= 0; i
< tlen
; i
++)
849 *bufptr
++ = buf
[i
+ offset
];
850 if (buf
[i
+ offset
] == '\000')
852 nbytes_read
+= i
+ 1;
869 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
870 GDB's memory at MYADDR. Returns either 0 for success or an errno value
873 If an error occurs, no guarantee is made about the contents of the data at
874 MYADDR. In particular, the caller should not depend upon partial reads
875 filling the buffer with good data. There is no way for the caller to know
876 how much good data might have been transfered anyway. Callers that can
877 deal with partial reads should call target_read_memory_partial. */
880 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
882 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
886 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
888 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
891 static int trust_readonly
= 0;
893 /* Move memory to or from the targets. The top target gets priority;
894 if it cannot handle it, it is offered to the next one down, etc.
896 Result is -1 on error, or the number of bytes transfered. */
899 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
900 struct mem_attrib
*attrib
)
904 struct target_ops
*t
;
905 struct target_stack_item
*item
;
907 /* Zero length requests are ok and require no work. */
911 /* to_xfer_memory is not guaranteed to set errno, even when it returns
915 if (!write
&& trust_readonly
)
917 /* User-settable option, "trust-readonly-sections". If true,
918 then memory from any SEC_READONLY bfd section may be read
919 directly from the bfd file. */
921 struct section_table
*secp
;
923 for (secp
= current_target
.to_sections
;
924 secp
< current_target
.to_sections_end
;
927 if (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
929 if (memaddr
>= secp
->addr
&& memaddr
< secp
->endaddr
)
930 return xfer_memory (memaddr
, myaddr
, len
, 0,
931 attrib
, ¤t_target
);
935 /* The quick case is that the top target can handle the transfer. */
936 res
= current_target
.to_xfer_memory
937 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
939 /* If res <= 0 then we call it again in the loop. Ah well. */
942 for (item
= target_stack
; item
; item
= item
->next
)
944 t
= item
->target_ops
;
945 if (!t
->to_has_memory
)
948 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
950 break; /* Handled all or part of xfer */
951 if (t
->to_has_all_memory
)
963 /* Perform a memory transfer. Iterate until the entire region has
966 Result is 0 or errno value. */
969 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
973 struct mem_region
*region
;
975 /* Zero length requests are ok and require no work. */
983 region
= lookup_mem_region(memaddr
);
984 if (memaddr
+ len
< region
->hi
)
987 reg_len
= region
->hi
- memaddr
;
989 switch (region
->attrib
.mode
)
1004 if (region
->attrib
.cache
)
1005 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1008 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1013 /* If this address is for nonexistent memory, read zeros
1014 if reading, or do nothing if writing. Return
1017 memset (myaddr
, 0, len
);
1031 return 0; /* We managed to cover it all somehow. */
1035 /* Perform a partial memory transfer.
1037 Result is -1 on error, or the number of bytes transfered. */
1040 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1041 int write_p
, int *err
)
1045 struct mem_region
*region
;
1047 /* Zero length requests are ok and require no work. */
1054 region
= lookup_mem_region(memaddr
);
1055 if (memaddr
+ len
< region
->hi
)
1058 reg_len
= region
->hi
- memaddr
;
1060 switch (region
->attrib
.mode
)
1079 if (region
->attrib
.cache
)
1080 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1083 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1101 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1103 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1107 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1109 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1114 target_info (char *args
, int from_tty
)
1116 struct target_ops
*t
;
1117 struct target_stack_item
*item
;
1118 int has_all_mem
= 0;
1120 if (symfile_objfile
!= NULL
)
1121 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1123 #ifdef FILES_INFO_HOOK
1124 if (FILES_INFO_HOOK ())
1128 for (item
= target_stack
; item
; item
= item
->next
)
1130 t
= item
->target_ops
;
1132 if (!t
->to_has_memory
)
1135 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1138 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1139 printf_unfiltered ("%s:\n", t
->to_longname
);
1140 (t
->to_files_info
) (t
);
1141 has_all_mem
= t
->to_has_all_memory
;
1145 /* This is to be called by the open routine before it does
1149 target_preopen (int from_tty
)
1153 if (target_has_execution
)
1156 || query ("A program is being debugged already. Kill it? "))
1159 error ("Program not killed.");
1162 /* Calling target_kill may remove the target from the stack. But if
1163 it doesn't (which seems like a win for UDI), remove it now. */
1165 if (target_has_execution
)
1169 /* Detach a target after doing deferred register stores. */
1172 target_detach (char *args
, int from_tty
)
1174 /* Handle any optimized stores to the inferior. */
1175 #ifdef DO_DEFERRED_STORES
1178 (current_target
.to_detach
) (args
, from_tty
);
1182 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1184 if (STREQ (current_target
.to_shortname
, "rombug"))
1186 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1188 error ("Unable to link to %s and get relocation in rombug", modname
);
1191 *t_reloc
= (CORE_ADDR
) -1;
1195 target_async_mask (int mask
)
1197 int saved_async_masked_status
= target_async_mask_value
;
1198 target_async_mask_value
= mask
;
1199 return saved_async_masked_status
;
1202 /* Look through the list of possible targets for a target that can
1203 execute a run or attach command without any other data. This is
1204 used to locate the default process stratum.
1206 Result is always valid (error() is called for errors). */
1208 static struct target_ops
*
1209 find_default_run_target (char *do_mesg
)
1211 struct target_ops
**t
;
1212 struct target_ops
*runable
= NULL
;
1217 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1220 if ((*t
)->to_can_run
&& target_can_run (*t
))
1228 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1234 find_default_attach (char *args
, int from_tty
)
1236 struct target_ops
*t
;
1238 t
= find_default_run_target ("attach");
1239 (t
->to_attach
) (args
, from_tty
);
1244 find_default_require_attach (char *args
, int from_tty
)
1246 struct target_ops
*t
;
1248 t
= find_default_run_target ("require_attach");
1249 (t
->to_require_attach
) (args
, from_tty
);
1254 find_default_require_detach (int pid
, char *args
, int from_tty
)
1256 struct target_ops
*t
;
1258 t
= find_default_run_target ("require_detach");
1259 (t
->to_require_detach
) (pid
, args
, from_tty
);
1264 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1266 struct target_ops
*t
;
1268 t
= find_default_run_target ("run");
1269 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1274 find_default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
1276 struct target_ops
*t
;
1278 t
= find_default_run_target ("run");
1279 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1284 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1286 return (byte_count
<= REGISTER_SIZE
);
1302 return_minus_one (void)
1308 * Resize the to_sections pointer. Also make sure that anyone that
1309 * was holding on to an old value of it gets updated.
1310 * Returns the old size.
1314 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1316 struct target_ops
**t
;
1317 struct section_table
*old_value
;
1320 old_value
= target
->to_sections
;
1322 if (target
->to_sections
)
1324 old_count
= target
->to_sections_end
- target
->to_sections
;
1325 target
->to_sections
= (struct section_table
*)
1326 xrealloc ((char *) target
->to_sections
,
1327 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1332 target
->to_sections
= (struct section_table
*)
1333 xmalloc ((sizeof (struct section_table
)) * num_added
);
1335 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1337 /* Check to see if anyone else was pointing to this structure.
1338 If old_value was null, then no one was. */
1342 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1345 if ((*t
)->to_sections
== old_value
)
1347 (*t
)->to_sections
= target
->to_sections
;
1348 (*t
)->to_sections_end
= target
->to_sections_end
;
1357 /* Remove all target sections taken from ABFD.
1359 Scan the current target stack for targets whose section tables
1360 refer to sections from BFD, and remove those sections. We use this
1361 when we notice that the inferior has unloaded a shared object, for
1364 remove_target_sections (bfd
*abfd
)
1366 struct target_ops
**t
;
1368 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1370 struct section_table
*src
, *dest
;
1372 dest
= (*t
)->to_sections
;
1373 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1374 if (src
->bfd
!= abfd
)
1376 /* Keep this section. */
1377 if (dest
< src
) *dest
= *src
;
1381 /* If we've dropped any sections, resize the section table. */
1383 target_resize_to_sections (*t
, dest
- src
);
1390 /* Find a single runnable target in the stack and return it. If for
1391 some reason there is more than one, return NULL. */
1394 find_run_target (void)
1396 struct target_ops
**t
;
1397 struct target_ops
*runable
= NULL
;
1402 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1404 if ((*t
)->to_can_run
&& target_can_run (*t
))
1411 return (count
== 1 ? runable
: NULL
);
1414 /* Find a single core_stratum target in the list of targets and return it.
1415 If for some reason there is more than one, return NULL. */
1418 find_core_target (void)
1420 struct target_ops
**t
;
1421 struct target_ops
*runable
= NULL
;
1426 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1429 if ((*t
)->to_stratum
== core_stratum
)
1436 return (count
== 1 ? runable
: NULL
);
1440 * Find the next target down the stack from the specified target.
1444 find_target_beneath (struct target_ops
*t
)
1446 struct target_stack_item
*cur
;
1448 for (cur
= target_stack
; cur
; cur
= cur
->next
)
1449 if (cur
->target_ops
== t
)
1452 if (cur
== NULL
|| cur
->next
== NULL
)
1455 return cur
->next
->target_ops
;
1459 /* The inferior process has died. Long live the inferior! */
1462 generic_mourn_inferior (void)
1464 extern int show_breakpoint_hit_counts
;
1466 inferior_ptid
= null_ptid
;
1468 breakpoint_init_inferior (inf_exited
);
1469 registers_changed ();
1471 #ifdef CLEAR_DEFERRED_STORES
1472 /* Delete any pending stores to the inferior... */
1473 CLEAR_DEFERRED_STORES
;
1476 reopen_exec_file ();
1477 reinit_frame_cache ();
1479 /* It is confusing to the user for ignore counts to stick around
1480 from previous runs of the inferior. So clear them. */
1481 /* However, it is more confusing for the ignore counts to disappear when
1482 using hit counts. So don't clear them if we're counting hits. */
1483 if (!show_breakpoint_hit_counts
)
1484 breakpoint_clear_ignore_counts ();
1490 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1491 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1492 translation of that in OURSTATUS. */
1494 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1496 #ifdef CHILD_SPECIAL_WAITSTATUS
1497 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1498 if it wants to deal with hoststatus. */
1499 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1503 if (WIFEXITED (hoststatus
))
1505 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1506 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1508 else if (!WIFSTOPPED (hoststatus
))
1510 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1511 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1515 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1516 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1520 /* Returns zero to leave the inferior alone, one to interrupt it. */
1521 int (*target_activity_function
) (void);
1522 int target_activity_fd
;
1524 /* Convert a normal process ID to a string. Returns the string in a static
1528 normal_pid_to_str (ptid_t ptid
)
1530 static char buf
[30];
1532 sprintf (buf
, "process %d", PIDGET (ptid
));
1536 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1537 notification of inferior events such as fork and vork immediately
1538 after the inferior is created. (This because of how gdb gets an
1539 inferior created via invoking a shell to do it. In such a scenario,
1540 if the shell init file has commands in it, the shell will fork and
1541 exec for each of those commands, and we will see each such fork
1544 This function is used by all targets that allow us to request
1545 notification of forks, etc at inferior creation time; e.g., in
1546 target_acknowledge_forked_child.
1549 normal_target_post_startup_inferior (ptid_t ptid
)
1551 /* This space intentionally left blank. */
1554 /* Error-catcher for target_find_memory_regions */
1556 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1558 error ("No target.");
1562 /* Error-catcher for target_make_corefile_notes */
1564 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1566 error ("No target.");
1570 /* Set up the handful of non-empty slots needed by the dummy target
1574 init_dummy_target (void)
1576 dummy_target
.to_shortname
= "None";
1577 dummy_target
.to_longname
= "None";
1578 dummy_target
.to_doc
= "";
1579 dummy_target
.to_attach
= find_default_attach
;
1580 dummy_target
.to_require_attach
= find_default_require_attach
;
1581 dummy_target
.to_require_detach
= find_default_require_detach
;
1582 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1583 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
1584 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1585 dummy_target
.to_stratum
= dummy_stratum
;
1586 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1587 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1588 dummy_target
.to_magic
= OPS_MAGIC
;
1592 static struct target_ops debug_target
;
1595 debug_to_open (char *args
, int from_tty
)
1597 debug_target
.to_open (args
, from_tty
);
1599 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1603 debug_to_close (int quitting
)
1605 debug_target
.to_close (quitting
);
1607 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1611 debug_to_attach (char *args
, int from_tty
)
1613 debug_target
.to_attach (args
, from_tty
);
1615 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1620 debug_to_post_attach (int pid
)
1622 debug_target
.to_post_attach (pid
);
1624 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1628 debug_to_require_attach (char *args
, int from_tty
)
1630 debug_target
.to_require_attach (args
, from_tty
);
1632 fprintf_unfiltered (gdb_stdlog
,
1633 "target_require_attach (%s, %d)\n", args
, from_tty
);
1637 debug_to_detach (char *args
, int from_tty
)
1639 debug_target
.to_detach (args
, from_tty
);
1641 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1645 debug_to_require_detach (int pid
, char *args
, int from_tty
)
1647 debug_target
.to_require_detach (pid
, args
, from_tty
);
1649 fprintf_unfiltered (gdb_stdlog
,
1650 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
1654 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1656 debug_target
.to_resume (ptid
, step
, siggnal
);
1658 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1659 step
? "step" : "continue",
1660 target_signal_to_name (siggnal
));
1664 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1668 retval
= debug_target
.to_wait (ptid
, status
);
1670 fprintf_unfiltered (gdb_stdlog
,
1671 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1673 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1674 switch (status
->kind
)
1676 case TARGET_WAITKIND_EXITED
:
1677 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1678 status
->value
.integer
);
1680 case TARGET_WAITKIND_STOPPED
:
1681 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1682 target_signal_to_name (status
->value
.sig
));
1684 case TARGET_WAITKIND_SIGNALLED
:
1685 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1686 target_signal_to_name (status
->value
.sig
));
1688 case TARGET_WAITKIND_LOADED
:
1689 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1691 case TARGET_WAITKIND_FORKED
:
1692 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1694 case TARGET_WAITKIND_VFORKED
:
1695 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1697 case TARGET_WAITKIND_EXECD
:
1698 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1700 case TARGET_WAITKIND_SPURIOUS
:
1701 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1704 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1712 debug_to_post_wait (ptid_t ptid
, int status
)
1714 debug_target
.to_post_wait (ptid
, status
);
1716 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1717 PIDGET (ptid
), status
);
1721 debug_print_register (const char * func
, int regno
)
1723 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1724 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1725 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1726 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1728 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1732 unsigned char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1733 deprecated_read_register_gen (regno
, buf
);
1734 fprintf_unfiltered (gdb_stdlog
, " = ");
1735 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
1737 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1739 if (REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1741 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1742 paddr_nz (read_register (regno
)),
1743 paddr_d (read_register (regno
)));
1746 fprintf_unfiltered (gdb_stdlog
, "\n");
1750 debug_to_fetch_registers (int regno
)
1752 debug_target
.to_fetch_registers (regno
);
1753 debug_print_register ("target_fetch_registers", regno
);
1757 debug_to_store_registers (int regno
)
1759 debug_target
.to_store_registers (regno
);
1760 debug_print_register ("target_store_registers", regno
);
1761 fprintf_unfiltered (gdb_stdlog
, "\n");
1765 debug_to_prepare_to_store (void)
1767 debug_target
.to_prepare_to_store ();
1769 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1773 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1774 struct mem_attrib
*attrib
,
1775 struct target_ops
*target
)
1779 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1782 fprintf_unfiltered (gdb_stdlog
,
1783 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1784 (unsigned int) memaddr
, /* possable truncate long long */
1785 len
, write
? "write" : "read", retval
);
1793 fputs_unfiltered (", bytes =", gdb_stdlog
);
1794 for (i
= 0; i
< retval
; i
++)
1796 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1797 fprintf_unfiltered (gdb_stdlog
, "\n");
1798 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1802 fputc_unfiltered ('\n', gdb_stdlog
);
1808 debug_to_files_info (struct target_ops
*target
)
1810 debug_target
.to_files_info (target
);
1812 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1816 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1820 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1822 fprintf_unfiltered (gdb_stdlog
,
1823 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1824 (unsigned long) addr
,
1825 (unsigned long) retval
);
1830 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1834 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1836 fprintf_unfiltered (gdb_stdlog
,
1837 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1838 (unsigned long) addr
,
1839 (unsigned long) retval
);
1844 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1848 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1850 fprintf_unfiltered (gdb_stdlog
,
1851 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1852 (unsigned long) type
,
1853 (unsigned long) cnt
,
1854 (unsigned long) from_tty
,
1855 (unsigned long) retval
);
1860 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1864 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1866 fprintf_unfiltered (gdb_stdlog
,
1867 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1868 (unsigned long) byte_count
,
1869 (unsigned long) retval
);
1874 debug_to_stopped_by_watchpoint (void)
1878 retval
= debug_target
.to_stopped_by_watchpoint ();
1880 fprintf_unfiltered (gdb_stdlog
,
1881 "STOPPED_BY_WATCHPOINT () = %ld\n",
1882 (unsigned long) retval
);
1887 debug_to_stopped_data_address (void)
1891 retval
= debug_target
.to_stopped_data_address ();
1893 fprintf_unfiltered (gdb_stdlog
,
1894 "target_stopped_data_address () = 0x%lx\n",
1895 (unsigned long) retval
);
1900 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1904 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1906 fprintf_unfiltered (gdb_stdlog
,
1907 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1908 (unsigned long) addr
,
1909 (unsigned long) retval
);
1914 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1918 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1920 fprintf_unfiltered (gdb_stdlog
,
1921 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1922 (unsigned long) addr
,
1923 (unsigned long) retval
);
1928 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1932 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1934 fprintf_unfiltered (gdb_stdlog
,
1935 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1936 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1941 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
1945 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1947 fprintf_unfiltered (gdb_stdlog
,
1948 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1949 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1954 debug_to_terminal_init (void)
1956 debug_target
.to_terminal_init ();
1958 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
1962 debug_to_terminal_inferior (void)
1964 debug_target
.to_terminal_inferior ();
1966 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
1970 debug_to_terminal_ours_for_output (void)
1972 debug_target
.to_terminal_ours_for_output ();
1974 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
1978 debug_to_terminal_ours (void)
1980 debug_target
.to_terminal_ours ();
1982 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
1986 debug_to_terminal_save_ours (void)
1988 debug_target
.to_terminal_save_ours ();
1990 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
1994 debug_to_terminal_info (char *arg
, int from_tty
)
1996 debug_target
.to_terminal_info (arg
, from_tty
);
1998 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2003 debug_to_kill (void)
2005 debug_target
.to_kill ();
2007 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2011 debug_to_load (char *args
, int from_tty
)
2013 debug_target
.to_load (args
, from_tty
);
2015 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2019 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2023 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2025 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2031 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2033 debug_target
.to_create_inferior (exec_file
, args
, env
);
2035 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2040 debug_to_post_startup_inferior (ptid_t ptid
)
2042 debug_target
.to_post_startup_inferior (ptid
);
2044 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2049 debug_to_acknowledge_created_inferior (int pid
)
2051 debug_target
.to_acknowledge_created_inferior (pid
);
2053 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2058 debug_to_clone_and_follow_inferior (int child_pid
, int *followed_child
)
2060 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
2062 fprintf_unfiltered (gdb_stdlog
,
2063 "target_clone_and_follow_inferior (%d, %d)\n",
2064 child_pid
, *followed_child
);
2068 debug_to_post_follow_inferior_by_clone (void)
2070 debug_target
.to_post_follow_inferior_by_clone ();
2072 fprintf_unfiltered (gdb_stdlog
, "target_post_follow_inferior_by_clone ()\n");
2076 debug_to_insert_fork_catchpoint (int pid
)
2080 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2082 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2089 debug_to_remove_fork_catchpoint (int pid
)
2093 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2095 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2102 debug_to_insert_vfork_catchpoint (int pid
)
2106 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2108 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2115 debug_to_remove_vfork_catchpoint (int pid
)
2119 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2121 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2128 debug_to_has_forked (int pid
, int *child_pid
)
2132 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
2134 fprintf_unfiltered (gdb_stdlog
, "target_has_forked (%d, %d) = %d\n",
2135 pid
, *child_pid
, has_forked
);
2141 debug_to_has_vforked (int pid
, int *child_pid
)
2145 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
2147 fprintf_unfiltered (gdb_stdlog
, "target_has_vforked (%d, %d) = %d\n",
2148 pid
, *child_pid
, has_vforked
);
2154 debug_to_post_follow_vfork (int parent_pid
, int followed_parent
, int child_pid
,
2157 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
2159 fprintf_unfiltered (gdb_stdlog
,
2160 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2161 parent_pid
, followed_parent
, child_pid
, followed_child
);
2165 debug_to_insert_exec_catchpoint (int pid
)
2169 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2171 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2178 debug_to_remove_exec_catchpoint (int pid
)
2182 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2184 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2191 debug_to_has_execd (int pid
, char **execd_pathname
)
2195 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2197 fprintf_unfiltered (gdb_stdlog
, "target_has_execd (%d, %s) = %d\n",
2198 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
2205 debug_to_reported_exec_events_per_exec_call (void)
2207 int reported_exec_events
;
2209 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2211 fprintf_unfiltered (gdb_stdlog
,
2212 "target_reported_exec_events_per_exec_call () = %d\n",
2213 reported_exec_events
);
2215 return reported_exec_events
;
2219 debug_to_has_syscall_event (int pid
, enum target_waitkind
*kind
,
2222 int has_syscall_event
;
2223 char *kind_spelling
= "??";
2225 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2226 if (has_syscall_event
)
2230 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2231 kind_spelling
= "SYSCALL_ENTRY";
2233 case TARGET_WAITKIND_SYSCALL_RETURN
:
2234 kind_spelling
= "SYSCALL_RETURN";
2241 fprintf_unfiltered (gdb_stdlog
,
2242 "target_has_syscall_event (%d, %s, %d) = %d\n",
2243 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2245 return has_syscall_event
;
2249 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2253 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2255 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2256 pid
, wait_status
, *exit_status
, has_exited
);
2262 debug_to_mourn_inferior (void)
2264 debug_target
.to_mourn_inferior ();
2266 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2270 debug_to_can_run (void)
2274 retval
= debug_target
.to_can_run ();
2276 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2282 debug_to_notice_signals (ptid_t ptid
)
2284 debug_target
.to_notice_signals (ptid
);
2286 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2291 debug_to_thread_alive (ptid_t ptid
)
2295 retval
= debug_target
.to_thread_alive (ptid
);
2297 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2298 PIDGET (ptid
), retval
);
2304 debug_to_find_new_threads (void)
2306 debug_target
.to_find_new_threads ();
2308 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2312 debug_to_stop (void)
2314 debug_target
.to_stop ();
2316 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2320 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2324 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2326 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2332 debug_to_rcmd (char *command
,
2333 struct ui_file
*outbuf
)
2335 debug_target
.to_rcmd (command
, outbuf
);
2336 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2339 static struct symtab_and_line
*
2340 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2342 struct symtab_and_line
*result
;
2343 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2344 fprintf_unfiltered (gdb_stdlog
,
2345 "target get_exception_callback_sal (%d, %d)\n",
2350 static struct exception_event_record
*
2351 debug_to_get_current_exception_event (void)
2353 struct exception_event_record
*result
;
2354 result
= debug_target
.to_get_current_exception_event ();
2355 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2360 debug_to_pid_to_exec_file (int pid
)
2364 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2366 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2373 setup_target_debug (void)
2375 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2377 current_target
.to_open
= debug_to_open
;
2378 current_target
.to_close
= debug_to_close
;
2379 current_target
.to_attach
= debug_to_attach
;
2380 current_target
.to_post_attach
= debug_to_post_attach
;
2381 current_target
.to_require_attach
= debug_to_require_attach
;
2382 current_target
.to_detach
= debug_to_detach
;
2383 current_target
.to_require_detach
= debug_to_require_detach
;
2384 current_target
.to_resume
= debug_to_resume
;
2385 current_target
.to_wait
= debug_to_wait
;
2386 current_target
.to_post_wait
= debug_to_post_wait
;
2387 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2388 current_target
.to_store_registers
= debug_to_store_registers
;
2389 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2390 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2391 current_target
.to_files_info
= debug_to_files_info
;
2392 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2393 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2394 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2395 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2396 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2397 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2398 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2399 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2400 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2401 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2402 current_target
.to_terminal_init
= debug_to_terminal_init
;
2403 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2404 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2405 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2406 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2407 current_target
.to_terminal_info
= debug_to_terminal_info
;
2408 current_target
.to_kill
= debug_to_kill
;
2409 current_target
.to_load
= debug_to_load
;
2410 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2411 current_target
.to_create_inferior
= debug_to_create_inferior
;
2412 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2413 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2414 current_target
.to_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2415 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2416 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2417 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2418 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2419 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2420 current_target
.to_has_forked
= debug_to_has_forked
;
2421 current_target
.to_has_vforked
= debug_to_has_vforked
;
2422 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2423 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2424 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2425 current_target
.to_has_execd
= debug_to_has_execd
;
2426 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2427 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2428 current_target
.to_has_exited
= debug_to_has_exited
;
2429 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2430 current_target
.to_can_run
= debug_to_can_run
;
2431 current_target
.to_notice_signals
= debug_to_notice_signals
;
2432 current_target
.to_thread_alive
= debug_to_thread_alive
;
2433 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2434 current_target
.to_stop
= debug_to_stop
;
2435 current_target
.to_query
= debug_to_query
;
2436 current_target
.to_rcmd
= debug_to_rcmd
;
2437 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2438 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2439 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2444 static char targ_desc
[] =
2445 "Names of targets and files being debugged.\n\
2446 Shows the entire stack of targets currently in use (including the exec-file,\n\
2447 core-file, and process, if any), as well as the symbol file name.";
2450 do_monitor_command (char *cmd
,
2453 if ((current_target
.to_rcmd
2454 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2455 || (current_target
.to_rcmd
== debug_to_rcmd
2456 && (debug_target
.to_rcmd
2457 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2459 error ("\"monitor\" command not supported by this target.\n");
2461 target_rcmd (cmd
, gdb_stdtarg
);
2465 initialize_targets (void)
2467 init_dummy_target ();
2468 push_target (&dummy_target
);
2470 add_info ("target", target_info
, targ_desc
);
2471 add_info ("files", target_info
, targ_desc
);
2474 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2475 (char *) &targetdebug
,
2476 "Set target debugging.\n\
2477 When non-zero, target debugging is enabled.", &setdebuglist
),
2480 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2482 Set mode for reading from readonly sections.\n\
2483 When this mode is on, memory reads from readonly sections (such as .text)\n\
2484 will be read from the object file instead of from the target. This will\n\
2485 result in significant performance improvement for remote targets.", "\
2486 Show mode for reading from readonly sections.\n",
2488 &setlist
, &showlist
);
2490 add_com ("monitor", class_obscure
, do_monitor_command
,
2491 "Send a command to the remote monitor (remote targets only).");
2493 target_dcache
= dcache_init ();