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 maybe_kill_then_attach (char *, int);
49 static void kill_or_be_killed (int);
51 static void default_terminal_info (char *, int);
53 static int default_region_size_ok_for_hw_watchpoint (int);
55 static int nosymbol (char *, CORE_ADDR
*);
57 static void tcomplain (void);
59 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
61 static int return_zero (void);
63 static int return_one (void);
65 static int return_minus_one (void);
67 void target_ignore (void);
69 static void target_command (char *, int);
71 static struct target_ops
*find_default_run_target (char *);
73 static void update_current_target (void);
75 static void nosupport_runtime (void);
77 static void normal_target_post_startup_inferior (ptid_t ptid
);
79 /* Transfer LEN bytes between target address MEMADDR and GDB address
80 MYADDR. Returns 0 for success, errno code for failure (which
81 includes partial transfers -- if you want a more useful response to
82 partial transfers, try either target_read_memory_partial or
83 target_write_memory_partial). */
85 static int target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
88 static void init_dummy_target (void);
90 static void debug_to_open (char *, int);
92 static void debug_to_close (int);
94 static void debug_to_attach (char *, int);
96 static void debug_to_detach (char *, int);
98 static void debug_to_disconnect (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 static struct target_ops
*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. */
210 target_command (char *arg
, int from_tty
)
212 fputs_filtered ("Argument required (target name). Try `help target'\n",
216 /* Add a possible target architecture to the list. */
219 add_target (struct target_ops
*t
)
223 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
224 target_structs
= (struct target_ops
**) xmalloc
225 (target_struct_allocsize
* sizeof (*target_structs
));
227 if (target_struct_size
>= target_struct_allocsize
)
229 target_struct_allocsize
*= 2;
230 target_structs
= (struct target_ops
**)
231 xrealloc ((char *) target_structs
,
232 target_struct_allocsize
* sizeof (*target_structs
));
234 target_structs
[target_struct_size
++] = t
;
235 /* cleanup_target (t); */
237 if (targetlist
== NULL
)
238 add_prefix_cmd ("target", class_run
, target_command
,
239 "Connect to a target machine or process.\n\
240 The first argument is the type or protocol of the target machine.\n\
241 Remaining arguments are interpreted by the target protocol. For more\n\
242 information on the arguments for a particular protocol, type\n\
243 `help target ' followed by the protocol name.",
244 &targetlist
, "target ", 0, &cmdlist
);
245 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
256 target_load (char *arg
, int from_tty
)
258 dcache_invalidate (target_dcache
);
259 (*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.");
284 nosymbol (char *name
, CORE_ADDR
*addrp
)
286 return 1; /* Symbol does not exist in target env */
290 nosupport_runtime (void)
292 if (ptid_equal (inferior_ptid
, null_ptid
))
295 error ("No run-time support for this");
300 default_terminal_info (char *args
, int from_tty
)
302 printf_unfiltered ("No saved terminal information.\n");
305 /* This is the default target_create_inferior and target_attach function.
306 If the current target is executing, it asks whether to kill it off.
307 If this function returns without calling error(), it has killed off
308 the target, and the operation should be attempted. */
311 kill_or_be_killed (int from_tty
)
313 if (target_has_execution
)
315 printf_unfiltered ("You are already running a program:\n");
316 target_files_info ();
317 if (query ("Kill it? "))
320 if (target_has_execution
)
321 error ("Killing the program did not help.");
326 error ("Program not killed.");
333 maybe_kill_then_attach (char *args
, int from_tty
)
335 kill_or_be_killed (from_tty
);
336 target_attach (args
, from_tty
);
340 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
342 kill_or_be_killed (0);
343 target_create_inferior (exec
, args
, env
);
346 /* Clean up a target struct so it no longer has any zero pointers in it.
347 We default entries, at least to stubs that print error messages. */
350 cleanup_target (struct target_ops
*t
)
353 #define de_fault(field, value) \
358 (void (*) (char *, int))
364 maybe_kill_then_attach
);
365 de_fault (to_post_attach
,
369 (void (*) (char *, int))
371 de_fault (to_disconnect
,
372 (void (*) (char *, int))
375 (void (*) (ptid_t
, int, enum target_signal
))
378 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
380 de_fault (to_post_wait
,
381 (void (*) (ptid_t
, int))
383 de_fault (to_fetch_registers
,
386 de_fault (to_store_registers
,
389 de_fault (to_prepare_to_store
,
392 de_fault (to_xfer_memory
,
393 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
395 de_fault (to_files_info
,
396 (void (*) (struct target_ops
*))
398 de_fault (to_insert_breakpoint
,
399 memory_insert_breakpoint
);
400 de_fault (to_remove_breakpoint
,
401 memory_remove_breakpoint
);
402 de_fault (to_can_use_hw_breakpoint
,
403 (int (*) (int, int, int))
405 de_fault (to_insert_hw_breakpoint
,
406 (int (*) (CORE_ADDR
, char *))
408 de_fault (to_remove_hw_breakpoint
,
409 (int (*) (CORE_ADDR
, char *))
411 de_fault (to_insert_watchpoint
,
412 (int (*) (CORE_ADDR
, int, int))
414 de_fault (to_remove_watchpoint
,
415 (int (*) (CORE_ADDR
, int, int))
417 de_fault (to_stopped_by_watchpoint
,
420 de_fault (to_stopped_data_address
,
421 (CORE_ADDR (*) (void))
423 de_fault (to_region_size_ok_for_hw_watchpoint
,
424 default_region_size_ok_for_hw_watchpoint
);
425 de_fault (to_terminal_init
,
428 de_fault (to_terminal_inferior
,
431 de_fault (to_terminal_ours_for_output
,
434 de_fault (to_terminal_ours
,
437 de_fault (to_terminal_save_ours
,
440 de_fault (to_terminal_info
,
441 default_terminal_info
);
446 (void (*) (char *, int))
448 de_fault (to_lookup_symbol
,
449 (int (*) (char *, CORE_ADDR
*))
451 de_fault (to_create_inferior
,
452 maybe_kill_then_create_inferior
);
453 de_fault (to_post_startup_inferior
,
456 de_fault (to_acknowledge_created_inferior
,
459 de_fault (to_insert_fork_catchpoint
,
462 de_fault (to_remove_fork_catchpoint
,
465 de_fault (to_insert_vfork_catchpoint
,
468 de_fault (to_remove_vfork_catchpoint
,
471 de_fault (to_follow_fork
,
474 de_fault (to_insert_exec_catchpoint
,
477 de_fault (to_remove_exec_catchpoint
,
480 de_fault (to_reported_exec_events_per_exec_call
,
483 de_fault (to_has_exited
,
484 (int (*) (int, int, int *))
486 de_fault (to_mourn_inferior
,
489 de_fault (to_can_run
,
491 de_fault (to_notice_signals
,
494 de_fault (to_thread_alive
,
497 de_fault (to_find_new_threads
,
500 de_fault (to_extra_thread_info
,
501 (char *(*) (struct thread_info
*))
507 (void (*) (char *, struct ui_file
*))
509 de_fault (to_enable_exception_callback
,
510 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
512 de_fault (to_get_current_exception_event
,
513 (struct exception_event_record
* (*) (void))
515 de_fault (to_pid_to_exec_file
,
518 de_fault (to_can_async_p
,
521 de_fault (to_is_async_p
,
525 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
530 /* Go through the target stack from top to bottom, copying over zero entries in
531 current_target. In effect, we are doing class inheritance through the
532 pushed target vectors. */
535 update_current_target (void)
537 struct target_ops
*t
;
539 /* First, reset current_target */
540 memset (¤t_target
, 0, sizeof current_target
);
542 for (t
= target_stack
; t
; t
= t
->beneath
)
545 #define INHERIT(FIELD, TARGET) \
546 if (!current_target.FIELD) \
547 current_target.FIELD = TARGET->FIELD
549 INHERIT (to_shortname
, t
);
550 INHERIT (to_longname
, t
);
552 INHERIT (to_open
, t
);
553 INHERIT (to_close
, t
);
554 INHERIT (to_attach
, t
);
555 INHERIT (to_post_attach
, t
);
556 INHERIT (to_detach
, t
);
557 INHERIT (to_disconnect
, t
);
558 INHERIT (to_resume
, t
);
559 INHERIT (to_wait
, t
);
560 INHERIT (to_post_wait
, t
);
561 INHERIT (to_fetch_registers
, t
);
562 INHERIT (to_store_registers
, t
);
563 INHERIT (to_prepare_to_store
, t
);
564 INHERIT (to_xfer_memory
, t
);
565 INHERIT (to_files_info
, t
);
566 INHERIT (to_insert_breakpoint
, t
);
567 INHERIT (to_remove_breakpoint
, t
);
568 INHERIT (to_can_use_hw_breakpoint
, t
);
569 INHERIT (to_insert_hw_breakpoint
, t
);
570 INHERIT (to_remove_hw_breakpoint
, t
);
571 INHERIT (to_insert_watchpoint
, t
);
572 INHERIT (to_remove_watchpoint
, t
);
573 INHERIT (to_stopped_data_address
, t
);
574 INHERIT (to_stopped_by_watchpoint
, t
);
575 INHERIT (to_have_continuable_watchpoint
, t
);
576 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
577 INHERIT (to_terminal_init
, t
);
578 INHERIT (to_terminal_inferior
, t
);
579 INHERIT (to_terminal_ours_for_output
, t
);
580 INHERIT (to_terminal_ours
, t
);
581 INHERIT (to_terminal_save_ours
, t
);
582 INHERIT (to_terminal_info
, t
);
583 INHERIT (to_kill
, t
);
584 INHERIT (to_load
, t
);
585 INHERIT (to_lookup_symbol
, t
);
586 INHERIT (to_create_inferior
, t
);
587 INHERIT (to_post_startup_inferior
, t
);
588 INHERIT (to_acknowledge_created_inferior
, t
);
589 INHERIT (to_insert_fork_catchpoint
, t
);
590 INHERIT (to_remove_fork_catchpoint
, t
);
591 INHERIT (to_insert_vfork_catchpoint
, t
);
592 INHERIT (to_remove_vfork_catchpoint
, t
);
593 INHERIT (to_follow_fork
, t
);
594 INHERIT (to_insert_exec_catchpoint
, t
);
595 INHERIT (to_remove_exec_catchpoint
, t
);
596 INHERIT (to_reported_exec_events_per_exec_call
, t
);
597 INHERIT (to_has_exited
, t
);
598 INHERIT (to_mourn_inferior
, t
);
599 INHERIT (to_can_run
, t
);
600 INHERIT (to_notice_signals
, t
);
601 INHERIT (to_thread_alive
, t
);
602 INHERIT (to_find_new_threads
, t
);
603 INHERIT (to_pid_to_str
, t
);
604 INHERIT (to_extra_thread_info
, t
);
605 INHERIT (to_stop
, t
);
606 INHERIT (to_query
, t
);
607 INHERIT (to_rcmd
, t
);
608 INHERIT (to_enable_exception_callback
, t
);
609 INHERIT (to_get_current_exception_event
, t
);
610 INHERIT (to_pid_to_exec_file
, t
);
611 INHERIT (to_stratum
, t
);
612 INHERIT (to_has_all_memory
, t
);
613 INHERIT (to_has_memory
, t
);
614 INHERIT (to_has_stack
, t
);
615 INHERIT (to_has_registers
, t
);
616 INHERIT (to_has_execution
, t
);
617 INHERIT (to_has_thread_control
, t
);
618 INHERIT (to_sections
, t
);
619 INHERIT (to_sections_end
, t
);
620 INHERIT (to_can_async_p
, t
);
621 INHERIT (to_is_async_p
, t
);
622 INHERIT (to_async
, t
);
623 INHERIT (to_async_mask_value
, t
);
624 INHERIT (to_find_memory_regions
, t
);
625 INHERIT (to_make_corefile_notes
, t
);
626 INHERIT (to_get_thread_local_address
, t
);
627 INHERIT (to_magic
, t
);
633 /* Push a new target type into the stack of the existing target accessors,
634 possibly superseding some of the existing accessors.
636 Result is zero if the pushed target ended up on top of the stack,
637 nonzero if at least one target is on top of it.
639 Rather than allow an empty stack, we always have the dummy target at
640 the bottom stratum, so we can call the function vectors without
644 push_target (struct target_ops
*t
)
646 struct target_ops
**cur
;
648 /* Check magic number. If wrong, it probably means someone changed
649 the struct definition, but not all the places that initialize one. */
650 if (t
->to_magic
!= OPS_MAGIC
)
652 fprintf_unfiltered (gdb_stderr
,
653 "Magic number of %s target struct wrong\n",
655 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
658 /* Find the proper stratum to install this target in. */
659 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
661 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
665 /* If there's already targets at this stratum, remove them. */
666 /* FIXME: cagney/2003-10-15: I think this should be poping all
667 targets to CUR, and not just those at this stratum level. */
668 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
670 /* There's already something at this stratum level. Close it,
671 and un-hook it from the stack. */
672 struct target_ops
*tmp
= (*cur
);
673 (*cur
) = (*cur
)->beneath
;
679 /* We have removed all targets in our stratum, now add the new one. */
683 update_current_target ();
685 cleanup_target (¤t_target
); /* Fill in the gaps */
688 setup_target_debug ();
691 return (t
!= target_stack
);
694 /* Remove a target_ops vector from the stack, wherever it may be.
695 Return how many times it was removed (0 or 1). */
698 unpush_target (struct target_ops
*t
)
700 struct target_ops
**cur
;
701 struct target_ops
*tmp
;
704 t
->to_close (0); /* Let it clean up */
706 /* Look for the specified target. Note that we assume that a target
707 can only occur once in the target stack. */
709 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
716 return 0; /* Didn't find target_ops, quit now */
718 /* Unchain the target */
720 (*cur
) = (*cur
)->beneath
;
723 update_current_target ();
724 cleanup_target (¤t_target
);
732 (current_target
.to_close
) (0); /* Let it clean up */
733 if (unpush_target (target_stack
) == 1)
736 fprintf_unfiltered (gdb_stderr
,
737 "pop_target couldn't find target %s\n",
738 current_target
.to_shortname
);
739 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
743 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
745 /* target_read_string -- read a null terminated string, up to LEN bytes,
746 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
747 Set *STRING to a pointer to malloc'd memory containing the data; the caller
748 is responsible for freeing it. Return the number of bytes successfully
752 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
754 int tlen
, origlen
, offset
, i
;
758 int buffer_allocated
;
760 unsigned int nbytes_read
= 0;
762 /* Small for testing. */
763 buffer_allocated
= 4;
764 buffer
= xmalloc (buffer_allocated
);
771 tlen
= MIN (len
, 4 - (memaddr
& 3));
772 offset
= memaddr
& 3;
774 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
777 /* The transfer request might have crossed the boundary to an
778 unallocated region of memory. Retry the transfer, requesting
782 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
787 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
790 bytes
= bufptr
- buffer
;
791 buffer_allocated
*= 2;
792 buffer
= xrealloc (buffer
, buffer_allocated
);
793 bufptr
= buffer
+ bytes
;
796 for (i
= 0; i
< tlen
; i
++)
798 *bufptr
++ = buf
[i
+ offset
];
799 if (buf
[i
+ offset
] == '\000')
801 nbytes_read
+= i
+ 1;
818 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
819 GDB's memory at MYADDR. Returns either 0 for success or an errno value
822 If an error occurs, no guarantee is made about the contents of the data at
823 MYADDR. In particular, the caller should not depend upon partial reads
824 filling the buffer with good data. There is no way for the caller to know
825 how much good data might have been transfered anyway. Callers that can
826 deal with partial reads should call target_read_memory_partial. */
829 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
831 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
835 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
837 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
840 static int trust_readonly
= 0;
842 /* Move memory to or from the targets. The top target gets priority;
843 if it cannot handle it, it is offered to the next one down, etc.
845 Result is -1 on error, or the number of bytes transfered. */
848 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
849 struct mem_attrib
*attrib
)
853 struct target_ops
*t
;
855 /* Zero length requests are ok and require no work. */
859 /* to_xfer_memory is not guaranteed to set errno, even when it returns
863 if (!write
&& trust_readonly
)
865 /* User-settable option, "trust-readonly-sections". If true,
866 then memory from any SEC_READONLY bfd section may be read
867 directly from the bfd file. */
869 struct section_table
*secp
;
871 for (secp
= current_target
.to_sections
;
872 secp
< current_target
.to_sections_end
;
875 if (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
877 if (memaddr
>= secp
->addr
&& memaddr
< secp
->endaddr
)
878 return xfer_memory (memaddr
, myaddr
, len
, 0,
879 attrib
, ¤t_target
);
883 /* The quick case is that the top target can handle the transfer. */
884 res
= current_target
.to_xfer_memory
885 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
887 /* If res <= 0 then we call it again in the loop. Ah well. */
890 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
892 if (!t
->to_has_memory
)
895 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
897 break; /* Handled all or part of xfer */
898 if (t
->to_has_all_memory
)
910 /* Perform a memory transfer. Iterate until the entire region has
913 Result is 0 or errno value. */
916 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
920 struct mem_region
*region
;
922 /* Zero length requests are ok and require no work. */
930 region
= lookup_mem_region(memaddr
);
931 if (memaddr
+ len
< region
->hi
)
934 reg_len
= region
->hi
- memaddr
;
936 switch (region
->attrib
.mode
)
951 if (region
->attrib
.cache
)
952 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
955 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
960 /* If this address is for nonexistent memory, read zeros
961 if reading, or do nothing if writing. Return
964 memset (myaddr
, 0, len
);
978 return 0; /* We managed to cover it all somehow. */
982 /* Perform a partial memory transfer.
984 Result is -1 on error, or the number of bytes transfered. */
987 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
988 int write_p
, int *err
)
992 struct mem_region
*region
;
994 /* Zero length requests are ok and require no work. */
1001 region
= lookup_mem_region(memaddr
);
1002 if (memaddr
+ len
< region
->hi
)
1005 reg_len
= region
->hi
- memaddr
;
1007 switch (region
->attrib
.mode
)
1026 if (region
->attrib
.cache
)
1027 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1030 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1048 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1050 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1054 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1056 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1060 target_info (char *args
, int from_tty
)
1062 struct target_ops
*t
;
1063 int has_all_mem
= 0;
1065 if (symfile_objfile
!= NULL
)
1066 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1068 #ifdef FILES_INFO_HOOK
1069 if (FILES_INFO_HOOK ())
1073 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1075 if (!t
->to_has_memory
)
1078 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1081 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1082 printf_unfiltered ("%s:\n", t
->to_longname
);
1083 (t
->to_files_info
) (t
);
1084 has_all_mem
= t
->to_has_all_memory
;
1088 /* This is to be called by the open routine before it does
1092 target_preopen (int from_tty
)
1096 if (target_has_execution
)
1099 || query ("A program is being debugged already. Kill it? "))
1102 error ("Program not killed.");
1105 /* Calling target_kill may remove the target from the stack. But if
1106 it doesn't (which seems like a win for UDI), remove it now. */
1108 if (target_has_execution
)
1112 /* Detach a target after doing deferred register stores. */
1115 target_detach (char *args
, int from_tty
)
1117 /* Handle any optimized stores to the inferior. */
1118 #ifdef DO_DEFERRED_STORES
1121 (current_target
.to_detach
) (args
, from_tty
);
1125 target_disconnect (char *args
, int from_tty
)
1127 /* Handle any optimized stores to the inferior. */
1128 #ifdef DO_DEFERRED_STORES
1131 (current_target
.to_disconnect
) (args
, from_tty
);
1135 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1137 if (STREQ (current_target
.to_shortname
, "rombug"))
1139 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1141 error ("Unable to link to %s and get relocation in rombug", modname
);
1144 *t_reloc
= (CORE_ADDR
) -1;
1148 target_async_mask (int mask
)
1150 int saved_async_masked_status
= target_async_mask_value
;
1151 target_async_mask_value
= mask
;
1152 return saved_async_masked_status
;
1155 /* Look through the list of possible targets for a target that can
1156 execute a run or attach command without any other data. This is
1157 used to locate the default process stratum.
1159 Result is always valid (error() is called for errors). */
1161 static struct target_ops
*
1162 find_default_run_target (char *do_mesg
)
1164 struct target_ops
**t
;
1165 struct target_ops
*runable
= NULL
;
1170 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1173 if ((*t
)->to_can_run
&& target_can_run (*t
))
1181 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1187 find_default_attach (char *args
, int from_tty
)
1189 struct target_ops
*t
;
1191 t
= find_default_run_target ("attach");
1192 (t
->to_attach
) (args
, from_tty
);
1197 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1199 struct target_ops
*t
;
1201 t
= find_default_run_target ("run");
1202 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1207 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1209 return (byte_count
<= DEPRECATED_REGISTER_SIZE
);
1225 return_minus_one (void)
1231 * Resize the to_sections pointer. Also make sure that anyone that
1232 * was holding on to an old value of it gets updated.
1233 * Returns the old size.
1237 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1239 struct target_ops
**t
;
1240 struct section_table
*old_value
;
1243 old_value
= target
->to_sections
;
1245 if (target
->to_sections
)
1247 old_count
= target
->to_sections_end
- target
->to_sections
;
1248 target
->to_sections
= (struct section_table
*)
1249 xrealloc ((char *) target
->to_sections
,
1250 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1255 target
->to_sections
= (struct section_table
*)
1256 xmalloc ((sizeof (struct section_table
)) * num_added
);
1258 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1260 /* Check to see if anyone else was pointing to this structure.
1261 If old_value was null, then no one was. */
1265 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1268 if ((*t
)->to_sections
== old_value
)
1270 (*t
)->to_sections
= target
->to_sections
;
1271 (*t
)->to_sections_end
= target
->to_sections_end
;
1280 /* Remove all target sections taken from ABFD.
1282 Scan the current target stack for targets whose section tables
1283 refer to sections from BFD, and remove those sections. We use this
1284 when we notice that the inferior has unloaded a shared object, for
1287 remove_target_sections (bfd
*abfd
)
1289 struct target_ops
**t
;
1291 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1293 struct section_table
*src
, *dest
;
1295 dest
= (*t
)->to_sections
;
1296 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1297 if (src
->bfd
!= abfd
)
1299 /* Keep this section. */
1300 if (dest
< src
) *dest
= *src
;
1304 /* If we've dropped any sections, resize the section table. */
1306 target_resize_to_sections (*t
, dest
- src
);
1313 /* Find a single runnable target in the stack and return it. If for
1314 some reason there is more than one, return NULL. */
1317 find_run_target (void)
1319 struct target_ops
**t
;
1320 struct target_ops
*runable
= NULL
;
1325 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1327 if ((*t
)->to_can_run
&& target_can_run (*t
))
1334 return (count
== 1 ? runable
: NULL
);
1337 /* Find a single core_stratum target in the list of targets and return it.
1338 If for some reason there is more than one, return NULL. */
1341 find_core_target (void)
1343 struct target_ops
**t
;
1344 struct target_ops
*runable
= NULL
;
1349 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1352 if ((*t
)->to_stratum
== core_stratum
)
1359 return (count
== 1 ? runable
: NULL
);
1363 * Find the next target down the stack from the specified target.
1367 find_target_beneath (struct target_ops
*t
)
1373 /* The inferior process has died. Long live the inferior! */
1376 generic_mourn_inferior (void)
1378 extern int show_breakpoint_hit_counts
;
1380 inferior_ptid
= null_ptid
;
1382 breakpoint_init_inferior (inf_exited
);
1383 registers_changed ();
1385 #ifdef CLEAR_DEFERRED_STORES
1386 /* Delete any pending stores to the inferior... */
1387 CLEAR_DEFERRED_STORES
;
1390 reopen_exec_file ();
1391 reinit_frame_cache ();
1393 /* It is confusing to the user for ignore counts to stick around
1394 from previous runs of the inferior. So clear them. */
1395 /* However, it is more confusing for the ignore counts to disappear when
1396 using hit counts. So don't clear them if we're counting hits. */
1397 if (!show_breakpoint_hit_counts
)
1398 breakpoint_clear_ignore_counts ();
1404 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1405 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1406 translation of that in OURSTATUS. */
1408 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1410 #ifdef CHILD_SPECIAL_WAITSTATUS
1411 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1412 if it wants to deal with hoststatus. */
1413 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1417 if (WIFEXITED (hoststatus
))
1419 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1420 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1422 else if (!WIFSTOPPED (hoststatus
))
1424 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1425 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1429 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1430 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1434 /* Returns zero to leave the inferior alone, one to interrupt it. */
1435 int (*target_activity_function
) (void);
1436 int target_activity_fd
;
1438 /* Convert a normal process ID to a string. Returns the string in a static
1442 normal_pid_to_str (ptid_t ptid
)
1444 static char buf
[30];
1446 sprintf (buf
, "process %d", PIDGET (ptid
));
1450 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1451 notification of inferior events such as fork and vork immediately
1452 after the inferior is created. (This because of how gdb gets an
1453 inferior created via invoking a shell to do it. In such a scenario,
1454 if the shell init file has commands in it, the shell will fork and
1455 exec for each of those commands, and we will see each such fork
1458 This function is used by all targets that allow us to request
1459 notification of forks, etc at inferior creation time; e.g., in
1460 target_acknowledge_forked_child.
1463 normal_target_post_startup_inferior (ptid_t ptid
)
1465 /* This space intentionally left blank. */
1468 /* Error-catcher for target_find_memory_regions */
1469 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1471 error ("No target.");
1475 /* Error-catcher for target_make_corefile_notes */
1476 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1478 error ("No target.");
1482 /* Set up the handful of non-empty slots needed by the dummy target
1486 init_dummy_target (void)
1488 dummy_target
.to_shortname
= "None";
1489 dummy_target
.to_longname
= "None";
1490 dummy_target
.to_doc
= "";
1491 dummy_target
.to_attach
= find_default_attach
;
1492 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1493 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1494 dummy_target
.to_stratum
= dummy_stratum
;
1495 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1496 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1497 dummy_target
.to_magic
= OPS_MAGIC
;
1501 static struct target_ops debug_target
;
1504 debug_to_open (char *args
, int from_tty
)
1506 debug_target
.to_open (args
, from_tty
);
1508 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1512 debug_to_close (int quitting
)
1514 debug_target
.to_close (quitting
);
1516 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1520 debug_to_attach (char *args
, int from_tty
)
1522 debug_target
.to_attach (args
, from_tty
);
1524 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1529 debug_to_post_attach (int pid
)
1531 debug_target
.to_post_attach (pid
);
1533 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1537 debug_to_detach (char *args
, int from_tty
)
1539 debug_target
.to_detach (args
, from_tty
);
1541 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1545 debug_to_disconnect (char *args
, int from_tty
)
1547 debug_target
.to_disconnect (args
, from_tty
);
1549 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1554 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1556 debug_target
.to_resume (ptid
, step
, siggnal
);
1558 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1559 step
? "step" : "continue",
1560 target_signal_to_name (siggnal
));
1564 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1568 retval
= debug_target
.to_wait (ptid
, status
);
1570 fprintf_unfiltered (gdb_stdlog
,
1571 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1573 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1574 switch (status
->kind
)
1576 case TARGET_WAITKIND_EXITED
:
1577 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1578 status
->value
.integer
);
1580 case TARGET_WAITKIND_STOPPED
:
1581 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1582 target_signal_to_name (status
->value
.sig
));
1584 case TARGET_WAITKIND_SIGNALLED
:
1585 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1586 target_signal_to_name (status
->value
.sig
));
1588 case TARGET_WAITKIND_LOADED
:
1589 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1591 case TARGET_WAITKIND_FORKED
:
1592 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1594 case TARGET_WAITKIND_VFORKED
:
1595 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1597 case TARGET_WAITKIND_EXECD
:
1598 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1600 case TARGET_WAITKIND_SPURIOUS
:
1601 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1604 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1612 debug_to_post_wait (ptid_t ptid
, int status
)
1614 debug_target
.to_post_wait (ptid
, status
);
1616 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1617 PIDGET (ptid
), status
);
1621 debug_print_register (const char * func
, int regno
)
1623 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1624 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1625 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1626 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1628 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1632 unsigned char buf
[MAX_REGISTER_SIZE
];
1633 deprecated_read_register_gen (regno
, buf
);
1634 fprintf_unfiltered (gdb_stdlog
, " = ");
1635 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
++)
1637 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1639 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1641 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1642 paddr_nz (read_register (regno
)),
1643 paddr_d (read_register (regno
)));
1646 fprintf_unfiltered (gdb_stdlog
, "\n");
1650 debug_to_fetch_registers (int regno
)
1652 debug_target
.to_fetch_registers (regno
);
1653 debug_print_register ("target_fetch_registers", regno
);
1657 debug_to_store_registers (int regno
)
1659 debug_target
.to_store_registers (regno
);
1660 debug_print_register ("target_store_registers", regno
);
1661 fprintf_unfiltered (gdb_stdlog
, "\n");
1665 debug_to_prepare_to_store (void)
1667 debug_target
.to_prepare_to_store ();
1669 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1673 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1674 struct mem_attrib
*attrib
,
1675 struct target_ops
*target
)
1679 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1682 fprintf_unfiltered (gdb_stdlog
,
1683 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1684 (unsigned int) memaddr
, /* possable truncate long long */
1685 len
, write
? "write" : "read", retval
);
1693 fputs_unfiltered (", bytes =", gdb_stdlog
);
1694 for (i
= 0; i
< retval
; i
++)
1696 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1697 fprintf_unfiltered (gdb_stdlog
, "\n");
1698 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1702 fputc_unfiltered ('\n', gdb_stdlog
);
1708 debug_to_files_info (struct target_ops
*target
)
1710 debug_target
.to_files_info (target
);
1712 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1716 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1720 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1722 fprintf_unfiltered (gdb_stdlog
,
1723 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1724 (unsigned long) addr
,
1725 (unsigned long) retval
);
1730 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1734 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1736 fprintf_unfiltered (gdb_stdlog
,
1737 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1738 (unsigned long) addr
,
1739 (unsigned long) retval
);
1744 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1748 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1750 fprintf_unfiltered (gdb_stdlog
,
1751 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1752 (unsigned long) type
,
1753 (unsigned long) cnt
,
1754 (unsigned long) from_tty
,
1755 (unsigned long) retval
);
1760 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1764 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1766 fprintf_unfiltered (gdb_stdlog
,
1767 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1768 (unsigned long) byte_count
,
1769 (unsigned long) retval
);
1774 debug_to_stopped_by_watchpoint (void)
1778 retval
= debug_target
.to_stopped_by_watchpoint ();
1780 fprintf_unfiltered (gdb_stdlog
,
1781 "STOPPED_BY_WATCHPOINT () = %ld\n",
1782 (unsigned long) retval
);
1787 debug_to_stopped_data_address (void)
1791 retval
= debug_target
.to_stopped_data_address ();
1793 fprintf_unfiltered (gdb_stdlog
,
1794 "target_stopped_data_address () = 0x%lx\n",
1795 (unsigned long) retval
);
1800 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1804 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1806 fprintf_unfiltered (gdb_stdlog
,
1807 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1808 (unsigned long) addr
,
1809 (unsigned long) retval
);
1814 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1818 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1820 fprintf_unfiltered (gdb_stdlog
,
1821 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1822 (unsigned long) addr
,
1823 (unsigned long) retval
);
1828 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1832 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1834 fprintf_unfiltered (gdb_stdlog
,
1835 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1836 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1841 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
1845 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1847 fprintf_unfiltered (gdb_stdlog
,
1848 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1849 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1854 debug_to_terminal_init (void)
1856 debug_target
.to_terminal_init ();
1858 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
1862 debug_to_terminal_inferior (void)
1864 debug_target
.to_terminal_inferior ();
1866 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
1870 debug_to_terminal_ours_for_output (void)
1872 debug_target
.to_terminal_ours_for_output ();
1874 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
1878 debug_to_terminal_ours (void)
1880 debug_target
.to_terminal_ours ();
1882 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
1886 debug_to_terminal_save_ours (void)
1888 debug_target
.to_terminal_save_ours ();
1890 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
1894 debug_to_terminal_info (char *arg
, int from_tty
)
1896 debug_target
.to_terminal_info (arg
, from_tty
);
1898 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
1903 debug_to_kill (void)
1905 debug_target
.to_kill ();
1907 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
1911 debug_to_load (char *args
, int from_tty
)
1913 debug_target
.to_load (args
, from_tty
);
1915 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
1919 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
1923 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1925 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
1931 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
1933 debug_target
.to_create_inferior (exec_file
, args
, env
);
1935 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
1940 debug_to_post_startup_inferior (ptid_t ptid
)
1942 debug_target
.to_post_startup_inferior (ptid
);
1944 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
1949 debug_to_acknowledge_created_inferior (int pid
)
1951 debug_target
.to_acknowledge_created_inferior (pid
);
1953 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
1958 debug_to_insert_fork_catchpoint (int pid
)
1962 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
1964 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
1971 debug_to_remove_fork_catchpoint (int pid
)
1975 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
1977 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
1984 debug_to_insert_vfork_catchpoint (int pid
)
1988 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
1990 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
1997 debug_to_remove_vfork_catchpoint (int pid
)
2001 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2003 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2010 debug_to_follow_fork (int follow_child
)
2012 int retval
= debug_target
.to_follow_fork (follow_child
);
2014 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2015 follow_child
, retval
);
2021 debug_to_insert_exec_catchpoint (int pid
)
2025 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2027 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2034 debug_to_remove_exec_catchpoint (int pid
)
2038 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2040 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2047 debug_to_reported_exec_events_per_exec_call (void)
2049 int reported_exec_events
;
2051 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2053 fprintf_unfiltered (gdb_stdlog
,
2054 "target_reported_exec_events_per_exec_call () = %d\n",
2055 reported_exec_events
);
2057 return reported_exec_events
;
2061 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2065 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2067 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2068 pid
, wait_status
, *exit_status
, has_exited
);
2074 debug_to_mourn_inferior (void)
2076 debug_target
.to_mourn_inferior ();
2078 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2082 debug_to_can_run (void)
2086 retval
= debug_target
.to_can_run ();
2088 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2094 debug_to_notice_signals (ptid_t ptid
)
2096 debug_target
.to_notice_signals (ptid
);
2098 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2103 debug_to_thread_alive (ptid_t ptid
)
2107 retval
= debug_target
.to_thread_alive (ptid
);
2109 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2110 PIDGET (ptid
), retval
);
2116 debug_to_find_new_threads (void)
2118 debug_target
.to_find_new_threads ();
2120 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2124 debug_to_stop (void)
2126 debug_target
.to_stop ();
2128 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2132 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2136 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2138 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2144 debug_to_rcmd (char *command
,
2145 struct ui_file
*outbuf
)
2147 debug_target
.to_rcmd (command
, outbuf
);
2148 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2151 static struct symtab_and_line
*
2152 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2154 struct symtab_and_line
*result
;
2155 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2156 fprintf_unfiltered (gdb_stdlog
,
2157 "target get_exception_callback_sal (%d, %d)\n",
2162 static struct exception_event_record
*
2163 debug_to_get_current_exception_event (void)
2165 struct exception_event_record
*result
;
2166 result
= debug_target
.to_get_current_exception_event ();
2167 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2172 debug_to_pid_to_exec_file (int pid
)
2176 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2178 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2185 setup_target_debug (void)
2187 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2189 current_target
.to_open
= debug_to_open
;
2190 current_target
.to_close
= debug_to_close
;
2191 current_target
.to_attach
= debug_to_attach
;
2192 current_target
.to_post_attach
= debug_to_post_attach
;
2193 current_target
.to_detach
= debug_to_detach
;
2194 current_target
.to_disconnect
= debug_to_disconnect
;
2195 current_target
.to_resume
= debug_to_resume
;
2196 current_target
.to_wait
= debug_to_wait
;
2197 current_target
.to_post_wait
= debug_to_post_wait
;
2198 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2199 current_target
.to_store_registers
= debug_to_store_registers
;
2200 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2201 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2202 current_target
.to_files_info
= debug_to_files_info
;
2203 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2204 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2205 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2206 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2207 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2208 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2209 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2210 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2211 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2212 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2213 current_target
.to_terminal_init
= debug_to_terminal_init
;
2214 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2215 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2216 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2217 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2218 current_target
.to_terminal_info
= debug_to_terminal_info
;
2219 current_target
.to_kill
= debug_to_kill
;
2220 current_target
.to_load
= debug_to_load
;
2221 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2222 current_target
.to_create_inferior
= debug_to_create_inferior
;
2223 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2224 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2225 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2226 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2227 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2228 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2229 current_target
.to_follow_fork
= debug_to_follow_fork
;
2230 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2231 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2232 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2233 current_target
.to_has_exited
= debug_to_has_exited
;
2234 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2235 current_target
.to_can_run
= debug_to_can_run
;
2236 current_target
.to_notice_signals
= debug_to_notice_signals
;
2237 current_target
.to_thread_alive
= debug_to_thread_alive
;
2238 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2239 current_target
.to_stop
= debug_to_stop
;
2240 current_target
.to_query
= debug_to_query
;
2241 current_target
.to_rcmd
= debug_to_rcmd
;
2242 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2243 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2244 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2249 static char targ_desc
[] =
2250 "Names of targets and files being debugged.\n\
2251 Shows the entire stack of targets currently in use (including the exec-file,\n\
2252 core-file, and process, if any), as well as the symbol file name.";
2255 do_monitor_command (char *cmd
,
2258 if ((current_target
.to_rcmd
2259 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2260 || (current_target
.to_rcmd
== debug_to_rcmd
2261 && (debug_target
.to_rcmd
2262 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2264 error ("\"monitor\" command not supported by this target.\n");
2266 target_rcmd (cmd
, gdb_stdtarg
);
2270 initialize_targets (void)
2272 init_dummy_target ();
2273 push_target (&dummy_target
);
2275 add_info ("target", target_info
, targ_desc
);
2276 add_info ("files", target_info
, targ_desc
);
2279 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2280 (char *) &targetdebug
,
2281 "Set target debugging.\n\
2282 When non-zero, target debugging is enabled.", &setdebuglist
),
2285 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2287 Set mode for reading from readonly sections.\n\
2288 When this mode is on, memory reads from readonly sections (such as .text)\n\
2289 will be read from the object file instead of from the target. This will\n\
2290 result in significant performance improvement for remote targets.", "\
2291 Show mode for reading from readonly sections.\n",
2293 &setlist
, &showlist
);
2295 add_com ("monitor", class_obscure
, do_monitor_command
,
2296 "Send a command to the remote monitor (remote targets only).");
2298 target_dcache
= dcache_init ();