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). */
86 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
);
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_resume (ptid_t
, int, enum target_signal
);
100 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
102 static void debug_to_fetch_registers (int);
104 static void debug_to_store_registers (int);
106 static void debug_to_prepare_to_store (void);
108 static int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
109 struct mem_attrib
*, struct target_ops
*);
111 static void debug_to_files_info (struct target_ops
*);
113 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
115 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
117 static int debug_to_can_use_hw_breakpoint (int, int, int);
119 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
121 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
123 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
125 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_stopped_by_watchpoint (void);
129 static CORE_ADDR
debug_to_stopped_data_address (void);
131 static int debug_to_region_size_ok_for_hw_watchpoint (int);
133 static void debug_to_terminal_init (void);
135 static void debug_to_terminal_inferior (void);
137 static void debug_to_terminal_ours_for_output (void);
139 static void debug_to_terminal_save_ours (void);
141 static void debug_to_terminal_ours (void);
143 static void debug_to_terminal_info (char *, int);
145 static void debug_to_kill (void);
147 static void debug_to_load (char *, int);
149 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
151 static void debug_to_create_inferior (char *, char *, char **);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t
);
159 static int debug_to_thread_alive (ptid_t
);
161 static void debug_to_stop (void);
163 static int debug_to_query (int /*char */ , char *, char *, int *);
165 /* Pointer to array of target architecture structures; the size of the
166 array; the current index into the array; the allocated size of the
168 struct target_ops
**target_structs
;
169 unsigned target_struct_size
;
170 unsigned target_struct_index
;
171 unsigned target_struct_allocsize
;
172 #define DEFAULT_ALLOCSIZE 10
174 /* The initial current target, so that there is always a semi-valid
177 static struct target_ops dummy_target
;
179 /* Top of target stack. */
181 struct target_stack_item
*target_stack
;
183 /* The target structure we are currently using to talk to a process
184 or file or whatever "inferior" we have. */
186 struct target_ops current_target
;
188 /* Command list for target. */
190 static struct cmd_list_element
*targetlist
= NULL
;
192 /* Nonzero if we are debugging an attached outside process
193 rather than an inferior. */
197 /* Non-zero if we want to see trace of target level stuff. */
199 static int targetdebug
= 0;
201 static void setup_target_debug (void);
203 DCACHE
*target_dcache
;
205 /* The user just typed 'target' without the name of a target. */
209 target_command (char *arg
, int from_tty
)
211 fputs_filtered ("Argument required (target name). Try `help target'\n",
215 /* Add a possible target architecture to the list. */
218 add_target (struct target_ops
*t
)
222 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
223 target_structs
= (struct target_ops
**) xmalloc
224 (target_struct_allocsize
* sizeof (*target_structs
));
226 if (target_struct_size
>= target_struct_allocsize
)
228 target_struct_allocsize
*= 2;
229 target_structs
= (struct target_ops
**)
230 xrealloc ((char *) target_structs
,
231 target_struct_allocsize
* sizeof (*target_structs
));
233 target_structs
[target_struct_size
++] = t
;
234 /* cleanup_target (t); */
236 if (targetlist
== NULL
)
237 add_prefix_cmd ("target", class_run
, target_command
,
238 "Connect to a target machine or process.\n\
239 The first argument is the type or protocol of the target machine.\n\
240 Remaining arguments are interpreted by the target protocol. For more\n\
241 information on the arguments for a particular protocol, type\n\
242 `help target ' followed by the protocol name.",
243 &targetlist
, "target ", 0, &cmdlist
);
244 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
255 target_load (char *arg
, int from_tty
)
257 dcache_invalidate (target_dcache
);
258 (*current_target
.to_load
) (arg
, from_tty
);
263 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
264 struct target_ops
*t
)
266 errno
= EIO
; /* Can't read/write this location */
267 return 0; /* No bytes handled */
273 error ("You can't do that when your target is `%s'",
274 current_target
.to_shortname
);
280 error ("You can't do that without a process to debug.");
285 nosymbol (char *name
, CORE_ADDR
*addrp
)
287 return 1; /* Symbol does not exist in target env */
292 nosupport_runtime (void)
294 if (ptid_equal (inferior_ptid
, null_ptid
))
297 error ("No run-time support for this");
303 default_terminal_info (char *args
, int from_tty
)
305 printf_unfiltered ("No saved terminal information.\n");
308 /* This is the default target_create_inferior and target_attach function.
309 If the current target is executing, it asks whether to kill it off.
310 If this function returns without calling error(), it has killed off
311 the target, and the operation should be attempted. */
314 kill_or_be_killed (int from_tty
)
316 if (target_has_execution
)
318 printf_unfiltered ("You are already running a program:\n");
319 target_files_info ();
320 if (query ("Kill it? "))
323 if (target_has_execution
)
324 error ("Killing the program did not help.");
329 error ("Program not killed.");
336 maybe_kill_then_attach (char *args
, int from_tty
)
338 kill_or_be_killed (from_tty
);
339 target_attach (args
, from_tty
);
343 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
345 kill_or_be_killed (0);
346 target_create_inferior (exec
, args
, env
);
349 /* Clean up a target struct so it no longer has any zero pointers in it.
350 We default entries, at least to stubs that print error messages. */
353 cleanup_target (struct target_ops
*t
)
356 #define de_fault(field, value) \
361 (void (*) (char *, int))
367 maybe_kill_then_attach
);
368 de_fault (to_post_attach
,
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_stack_item
*item
;
538 struct target_ops
*t
;
540 /* First, reset current_target */
541 memset (¤t_target
, 0, sizeof current_target
);
543 for (item
= target_stack
; item
; item
= item
->next
)
545 t
= item
->target_ops
;
547 #define INHERIT(FIELD, TARGET) \
548 if (!current_target.FIELD) \
549 current_target.FIELD = TARGET->FIELD
551 INHERIT (to_shortname
, t
);
552 INHERIT (to_longname
, t
);
554 INHERIT (to_open
, t
);
555 INHERIT (to_close
, t
);
556 INHERIT (to_attach
, t
);
557 INHERIT (to_post_attach
, t
);
558 INHERIT (to_detach
, t
);
559 INHERIT (to_resume
, t
);
560 INHERIT (to_wait
, t
);
561 INHERIT (to_post_wait
, t
);
562 INHERIT (to_fetch_registers
, t
);
563 INHERIT (to_store_registers
, t
);
564 INHERIT (to_prepare_to_store
, t
);
565 INHERIT (to_xfer_memory
, t
);
566 INHERIT (to_files_info
, t
);
567 INHERIT (to_insert_breakpoint
, t
);
568 INHERIT (to_remove_breakpoint
, t
);
569 INHERIT (to_can_use_hw_breakpoint
, t
);
570 INHERIT (to_insert_hw_breakpoint
, t
);
571 INHERIT (to_remove_hw_breakpoint
, t
);
572 INHERIT (to_insert_watchpoint
, t
);
573 INHERIT (to_remove_watchpoint
, t
);
574 INHERIT (to_stopped_data_address
, t
);
575 INHERIT (to_stopped_by_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_stack_item
*cur
, *prev
, *tmp
;
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. */
660 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
662 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
666 /* If there's already targets at this stratum, remove them. */
669 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
671 /* There's already something on this stratum. Close it off. */
672 if (cur
->target_ops
->to_close
)
673 (cur
->target_ops
->to_close
) (0);
675 prev
->next
= cur
->next
; /* Unchain old target_ops */
677 target_stack
= cur
->next
; /* Unchain first on list */
683 /* We have removed all targets in our stratum, now add the new one. */
685 tmp
= (struct target_stack_item
*)
686 xmalloc (sizeof (struct target_stack_item
));
695 update_current_target ();
697 cleanup_target (¤t_target
); /* Fill in the gaps */
700 setup_target_debug ();
705 /* Remove a target_ops vector from the stack, wherever it may be.
706 Return how many times it was removed (0 or 1). */
709 unpush_target (struct target_ops
*t
)
711 struct target_stack_item
*cur
, *prev
;
714 t
->to_close (0); /* Let it clean up */
716 /* Look for the specified target. Note that we assume that a target
717 can only occur once in the target stack. */
719 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
720 if (cur
->target_ops
== t
)
724 return 0; /* Didn't find target_ops, quit now */
726 /* Unchain the target */
729 target_stack
= cur
->next
;
731 prev
->next
= cur
->next
;
733 xfree (cur
); /* Release the target_stack_item */
735 update_current_target ();
736 cleanup_target (¤t_target
);
744 (current_target
.to_close
) (0); /* Let it clean up */
745 if (unpush_target (target_stack
->target_ops
) == 1)
748 fprintf_unfiltered (gdb_stderr
,
749 "pop_target couldn't find target %s\n",
750 current_target
.to_shortname
);
751 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
755 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
757 /* target_read_string -- read a null terminated string, up to LEN bytes,
758 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
759 Set *STRING to a pointer to malloc'd memory containing the data; the caller
760 is responsible for freeing it. Return the number of bytes successfully
764 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
766 int tlen
, origlen
, offset
, i
;
770 int buffer_allocated
;
772 unsigned int nbytes_read
= 0;
774 /* Small for testing. */
775 buffer_allocated
= 4;
776 buffer
= xmalloc (buffer_allocated
);
783 tlen
= MIN (len
, 4 - (memaddr
& 3));
784 offset
= memaddr
& 3;
786 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
789 /* The transfer request might have crossed the boundary to an
790 unallocated region of memory. Retry the transfer, requesting
794 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
799 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
802 bytes
= bufptr
- buffer
;
803 buffer_allocated
*= 2;
804 buffer
= xrealloc (buffer
, buffer_allocated
);
805 bufptr
= buffer
+ bytes
;
808 for (i
= 0; i
< tlen
; i
++)
810 *bufptr
++ = buf
[i
+ offset
];
811 if (buf
[i
+ offset
] == '\000')
813 nbytes_read
+= i
+ 1;
830 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
831 GDB's memory at MYADDR. Returns either 0 for success or an errno value
834 If an error occurs, no guarantee is made about the contents of the data at
835 MYADDR. In particular, the caller should not depend upon partial reads
836 filling the buffer with good data. There is no way for the caller to know
837 how much good data might have been transfered anyway. Callers that can
838 deal with partial reads should call target_read_memory_partial. */
841 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
843 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
847 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
849 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
852 static int trust_readonly
= 0;
854 /* Move memory to or from the targets. The top target gets priority;
855 if it cannot handle it, it is offered to the next one down, etc.
857 Result is -1 on error, or the number of bytes transfered. */
860 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
861 struct mem_attrib
*attrib
)
865 struct target_ops
*t
;
866 struct target_stack_item
*item
;
868 /* Zero length requests are ok and require no work. */
872 /* to_xfer_memory is not guaranteed to set errno, even when it returns
876 if (!write
&& trust_readonly
)
878 /* User-settable option, "trust-readonly-sections". If true,
879 then memory from any SEC_READONLY bfd section may be read
880 directly from the bfd file. */
882 struct section_table
*secp
;
884 for (secp
= current_target
.to_sections
;
885 secp
< current_target
.to_sections_end
;
888 if (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
890 if (memaddr
>= secp
->addr
&& memaddr
< secp
->endaddr
)
891 return xfer_memory (memaddr
, myaddr
, len
, 0,
892 attrib
, ¤t_target
);
896 /* The quick case is that the top target can handle the transfer. */
897 res
= current_target
.to_xfer_memory
898 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
900 /* If res <= 0 then we call it again in the loop. Ah well. */
903 for (item
= target_stack
; item
; item
= item
->next
)
905 t
= item
->target_ops
;
906 if (!t
->to_has_memory
)
909 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
911 break; /* Handled all or part of xfer */
912 if (t
->to_has_all_memory
)
924 /* Perform a memory transfer. Iterate until the entire region has
927 Result is 0 or errno value. */
930 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
934 struct mem_region
*region
;
936 /* Zero length requests are ok and require no work. */
944 region
= lookup_mem_region(memaddr
);
945 if (memaddr
+ len
< region
->hi
)
948 reg_len
= region
->hi
- memaddr
;
950 switch (region
->attrib
.mode
)
965 if (region
->attrib
.cache
)
966 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
969 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
974 /* If this address is for nonexistent memory, read zeros
975 if reading, or do nothing if writing. Return
978 memset (myaddr
, 0, len
);
992 return 0; /* We managed to cover it all somehow. */
996 /* Perform a partial memory transfer.
998 Result is -1 on error, or the number of bytes transfered. */
1001 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1002 int write_p
, int *err
)
1006 struct mem_region
*region
;
1008 /* Zero length requests are ok and require no work. */
1015 region
= lookup_mem_region(memaddr
);
1016 if (memaddr
+ len
< region
->hi
)
1019 reg_len
= region
->hi
- memaddr
;
1021 switch (region
->attrib
.mode
)
1040 if (region
->attrib
.cache
)
1041 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1044 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1062 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1064 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1068 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1070 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1075 target_info (char *args
, int from_tty
)
1077 struct target_ops
*t
;
1078 struct target_stack_item
*item
;
1079 int has_all_mem
= 0;
1081 if (symfile_objfile
!= NULL
)
1082 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1084 #ifdef FILES_INFO_HOOK
1085 if (FILES_INFO_HOOK ())
1089 for (item
= target_stack
; item
; item
= item
->next
)
1091 t
= item
->target_ops
;
1093 if (!t
->to_has_memory
)
1096 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1099 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1100 printf_unfiltered ("%s:\n", t
->to_longname
);
1101 (t
->to_files_info
) (t
);
1102 has_all_mem
= t
->to_has_all_memory
;
1106 /* This is to be called by the open routine before it does
1110 target_preopen (int from_tty
)
1114 if (target_has_execution
)
1117 || query ("A program is being debugged already. Kill it? "))
1120 error ("Program not killed.");
1123 /* Calling target_kill may remove the target from the stack. But if
1124 it doesn't (which seems like a win for UDI), remove it now. */
1126 if (target_has_execution
)
1130 /* Detach a target after doing deferred register stores. */
1133 target_detach (char *args
, int from_tty
)
1135 /* Handle any optimized stores to the inferior. */
1136 #ifdef DO_DEFERRED_STORES
1139 (current_target
.to_detach
) (args
, from_tty
);
1143 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1145 if (STREQ (current_target
.to_shortname
, "rombug"))
1147 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1149 error ("Unable to link to %s and get relocation in rombug", modname
);
1152 *t_reloc
= (CORE_ADDR
) -1;
1156 target_async_mask (int mask
)
1158 int saved_async_masked_status
= target_async_mask_value
;
1159 target_async_mask_value
= mask
;
1160 return saved_async_masked_status
;
1163 /* Look through the list of possible targets for a target that can
1164 execute a run or attach command without any other data. This is
1165 used to locate the default process stratum.
1167 Result is always valid (error() is called for errors). */
1169 static struct target_ops
*
1170 find_default_run_target (char *do_mesg
)
1172 struct target_ops
**t
;
1173 struct target_ops
*runable
= NULL
;
1178 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1181 if ((*t
)->to_can_run
&& target_can_run (*t
))
1189 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1195 find_default_attach (char *args
, int from_tty
)
1197 struct target_ops
*t
;
1199 t
= find_default_run_target ("attach");
1200 (t
->to_attach
) (args
, from_tty
);
1205 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1207 struct target_ops
*t
;
1209 t
= find_default_run_target ("run");
1210 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1215 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1217 return (byte_count
<= REGISTER_SIZE
);
1233 return_minus_one (void)
1239 * Resize the to_sections pointer. Also make sure that anyone that
1240 * was holding on to an old value of it gets updated.
1241 * Returns the old size.
1245 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1247 struct target_ops
**t
;
1248 struct section_table
*old_value
;
1251 old_value
= target
->to_sections
;
1253 if (target
->to_sections
)
1255 old_count
= target
->to_sections_end
- target
->to_sections
;
1256 target
->to_sections
= (struct section_table
*)
1257 xrealloc ((char *) target
->to_sections
,
1258 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1263 target
->to_sections
= (struct section_table
*)
1264 xmalloc ((sizeof (struct section_table
)) * num_added
);
1266 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1268 /* Check to see if anyone else was pointing to this structure.
1269 If old_value was null, then no one was. */
1273 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1276 if ((*t
)->to_sections
== old_value
)
1278 (*t
)->to_sections
= target
->to_sections
;
1279 (*t
)->to_sections_end
= target
->to_sections_end
;
1288 /* Remove all target sections taken from ABFD.
1290 Scan the current target stack for targets whose section tables
1291 refer to sections from BFD, and remove those sections. We use this
1292 when we notice that the inferior has unloaded a shared object, for
1295 remove_target_sections (bfd
*abfd
)
1297 struct target_ops
**t
;
1299 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1301 struct section_table
*src
, *dest
;
1303 dest
= (*t
)->to_sections
;
1304 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1305 if (src
->bfd
!= abfd
)
1307 /* Keep this section. */
1308 if (dest
< src
) *dest
= *src
;
1312 /* If we've dropped any sections, resize the section table. */
1314 target_resize_to_sections (*t
, dest
- src
);
1321 /* Find a single runnable target in the stack and return it. If for
1322 some reason there is more than one, return NULL. */
1325 find_run_target (void)
1327 struct target_ops
**t
;
1328 struct target_ops
*runable
= NULL
;
1333 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1335 if ((*t
)->to_can_run
&& target_can_run (*t
))
1342 return (count
== 1 ? runable
: NULL
);
1345 /* Find a single core_stratum target in the list of targets and return it.
1346 If for some reason there is more than one, return NULL. */
1349 find_core_target (void)
1351 struct target_ops
**t
;
1352 struct target_ops
*runable
= NULL
;
1357 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1360 if ((*t
)->to_stratum
== core_stratum
)
1367 return (count
== 1 ? runable
: NULL
);
1371 * Find the next target down the stack from the specified target.
1375 find_target_beneath (struct target_ops
*t
)
1377 struct target_stack_item
*cur
;
1379 for (cur
= target_stack
; cur
; cur
= cur
->next
)
1380 if (cur
->target_ops
== t
)
1383 if (cur
== NULL
|| cur
->next
== NULL
)
1386 return cur
->next
->target_ops
;
1390 /* The inferior process has died. Long live the inferior! */
1393 generic_mourn_inferior (void)
1395 extern int show_breakpoint_hit_counts
;
1397 inferior_ptid
= null_ptid
;
1399 breakpoint_init_inferior (inf_exited
);
1400 registers_changed ();
1402 #ifdef CLEAR_DEFERRED_STORES
1403 /* Delete any pending stores to the inferior... */
1404 CLEAR_DEFERRED_STORES
;
1407 reopen_exec_file ();
1408 reinit_frame_cache ();
1410 /* It is confusing to the user for ignore counts to stick around
1411 from previous runs of the inferior. So clear them. */
1412 /* However, it is more confusing for the ignore counts to disappear when
1413 using hit counts. So don't clear them if we're counting hits. */
1414 if (!show_breakpoint_hit_counts
)
1415 breakpoint_clear_ignore_counts ();
1421 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1422 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1423 translation of that in OURSTATUS. */
1425 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1427 #ifdef CHILD_SPECIAL_WAITSTATUS
1428 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1429 if it wants to deal with hoststatus. */
1430 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1434 if (WIFEXITED (hoststatus
))
1436 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1437 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1439 else if (!WIFSTOPPED (hoststatus
))
1441 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1442 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1446 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1447 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1451 /* Returns zero to leave the inferior alone, one to interrupt it. */
1452 int (*target_activity_function
) (void);
1453 int target_activity_fd
;
1455 /* Convert a normal process ID to a string. Returns the string in a static
1459 normal_pid_to_str (ptid_t ptid
)
1461 static char buf
[30];
1463 sprintf (buf
, "process %d", PIDGET (ptid
));
1467 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1468 notification of inferior events such as fork and vork immediately
1469 after the inferior is created. (This because of how gdb gets an
1470 inferior created via invoking a shell to do it. In such a scenario,
1471 if the shell init file has commands in it, the shell will fork and
1472 exec for each of those commands, and we will see each such fork
1475 This function is used by all targets that allow us to request
1476 notification of forks, etc at inferior creation time; e.g., in
1477 target_acknowledge_forked_child.
1480 normal_target_post_startup_inferior (ptid_t ptid
)
1482 /* This space intentionally left blank. */
1485 /* Error-catcher for target_find_memory_regions */
1487 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1489 error ("No target.");
1493 /* Error-catcher for target_make_corefile_notes */
1495 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1497 error ("No target.");
1501 /* Set up the handful of non-empty slots needed by the dummy target
1505 init_dummy_target (void)
1507 dummy_target
.to_shortname
= "None";
1508 dummy_target
.to_longname
= "None";
1509 dummy_target
.to_doc
= "";
1510 dummy_target
.to_attach
= find_default_attach
;
1511 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1512 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1513 dummy_target
.to_stratum
= dummy_stratum
;
1514 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1515 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1516 dummy_target
.to_magic
= OPS_MAGIC
;
1520 static struct target_ops debug_target
;
1523 debug_to_open (char *args
, int from_tty
)
1525 debug_target
.to_open (args
, from_tty
);
1527 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1531 debug_to_close (int quitting
)
1533 debug_target
.to_close (quitting
);
1535 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1539 debug_to_attach (char *args
, int from_tty
)
1541 debug_target
.to_attach (args
, from_tty
);
1543 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1548 debug_to_post_attach (int pid
)
1550 debug_target
.to_post_attach (pid
);
1552 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1556 debug_to_detach (char *args
, int from_tty
)
1558 debug_target
.to_detach (args
, from_tty
);
1560 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1564 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1566 debug_target
.to_resume (ptid
, step
, siggnal
);
1568 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1569 step
? "step" : "continue",
1570 target_signal_to_name (siggnal
));
1574 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1578 retval
= debug_target
.to_wait (ptid
, status
);
1580 fprintf_unfiltered (gdb_stdlog
,
1581 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1583 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1584 switch (status
->kind
)
1586 case TARGET_WAITKIND_EXITED
:
1587 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1588 status
->value
.integer
);
1590 case TARGET_WAITKIND_STOPPED
:
1591 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1592 target_signal_to_name (status
->value
.sig
));
1594 case TARGET_WAITKIND_SIGNALLED
:
1595 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1596 target_signal_to_name (status
->value
.sig
));
1598 case TARGET_WAITKIND_LOADED
:
1599 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1601 case TARGET_WAITKIND_FORKED
:
1602 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1604 case TARGET_WAITKIND_VFORKED
:
1605 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1607 case TARGET_WAITKIND_EXECD
:
1608 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1610 case TARGET_WAITKIND_SPURIOUS
:
1611 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1614 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1622 debug_to_post_wait (ptid_t ptid
, int status
)
1624 debug_target
.to_post_wait (ptid
, status
);
1626 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1627 PIDGET (ptid
), status
);
1631 debug_print_register (const char * func
, int regno
)
1633 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1634 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1635 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1636 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1638 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1642 unsigned char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1643 deprecated_read_register_gen (regno
, buf
);
1644 fprintf_unfiltered (gdb_stdlog
, " = ");
1645 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
1647 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1649 if (REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1651 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1652 paddr_nz (read_register (regno
)),
1653 paddr_d (read_register (regno
)));
1656 fprintf_unfiltered (gdb_stdlog
, "\n");
1660 debug_to_fetch_registers (int regno
)
1662 debug_target
.to_fetch_registers (regno
);
1663 debug_print_register ("target_fetch_registers", regno
);
1667 debug_to_store_registers (int regno
)
1669 debug_target
.to_store_registers (regno
);
1670 debug_print_register ("target_store_registers", regno
);
1671 fprintf_unfiltered (gdb_stdlog
, "\n");
1675 debug_to_prepare_to_store (void)
1677 debug_target
.to_prepare_to_store ();
1679 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1683 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1684 struct mem_attrib
*attrib
,
1685 struct target_ops
*target
)
1689 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1692 fprintf_unfiltered (gdb_stdlog
,
1693 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1694 (unsigned int) memaddr
, /* possable truncate long long */
1695 len
, write
? "write" : "read", retval
);
1703 fputs_unfiltered (", bytes =", gdb_stdlog
);
1704 for (i
= 0; i
< retval
; i
++)
1706 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1707 fprintf_unfiltered (gdb_stdlog
, "\n");
1708 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1712 fputc_unfiltered ('\n', gdb_stdlog
);
1718 debug_to_files_info (struct target_ops
*target
)
1720 debug_target
.to_files_info (target
);
1722 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1726 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1730 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1732 fprintf_unfiltered (gdb_stdlog
,
1733 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1734 (unsigned long) addr
,
1735 (unsigned long) retval
);
1740 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1744 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1746 fprintf_unfiltered (gdb_stdlog
,
1747 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1748 (unsigned long) addr
,
1749 (unsigned long) retval
);
1754 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1758 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1760 fprintf_unfiltered (gdb_stdlog
,
1761 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1762 (unsigned long) type
,
1763 (unsigned long) cnt
,
1764 (unsigned long) from_tty
,
1765 (unsigned long) retval
);
1770 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1774 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1776 fprintf_unfiltered (gdb_stdlog
,
1777 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1778 (unsigned long) byte_count
,
1779 (unsigned long) retval
);
1784 debug_to_stopped_by_watchpoint (void)
1788 retval
= debug_target
.to_stopped_by_watchpoint ();
1790 fprintf_unfiltered (gdb_stdlog
,
1791 "STOPPED_BY_WATCHPOINT () = %ld\n",
1792 (unsigned long) retval
);
1797 debug_to_stopped_data_address (void)
1801 retval
= debug_target
.to_stopped_data_address ();
1803 fprintf_unfiltered (gdb_stdlog
,
1804 "target_stopped_data_address () = 0x%lx\n",
1805 (unsigned long) retval
);
1810 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1814 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1816 fprintf_unfiltered (gdb_stdlog
,
1817 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1818 (unsigned long) addr
,
1819 (unsigned long) retval
);
1824 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1828 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1830 fprintf_unfiltered (gdb_stdlog
,
1831 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1832 (unsigned long) addr
,
1833 (unsigned long) retval
);
1838 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1842 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1844 fprintf_unfiltered (gdb_stdlog
,
1845 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1846 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1851 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
1855 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1857 fprintf_unfiltered (gdb_stdlog
,
1858 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1859 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1864 debug_to_terminal_init (void)
1866 debug_target
.to_terminal_init ();
1868 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
1872 debug_to_terminal_inferior (void)
1874 debug_target
.to_terminal_inferior ();
1876 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
1880 debug_to_terminal_ours_for_output (void)
1882 debug_target
.to_terminal_ours_for_output ();
1884 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
1888 debug_to_terminal_ours (void)
1890 debug_target
.to_terminal_ours ();
1892 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
1896 debug_to_terminal_save_ours (void)
1898 debug_target
.to_terminal_save_ours ();
1900 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
1904 debug_to_terminal_info (char *arg
, int from_tty
)
1906 debug_target
.to_terminal_info (arg
, from_tty
);
1908 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
1913 debug_to_kill (void)
1915 debug_target
.to_kill ();
1917 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
1921 debug_to_load (char *args
, int from_tty
)
1923 debug_target
.to_load (args
, from_tty
);
1925 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
1929 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
1933 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1935 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
1941 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
1943 debug_target
.to_create_inferior (exec_file
, args
, env
);
1945 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
1950 debug_to_post_startup_inferior (ptid_t ptid
)
1952 debug_target
.to_post_startup_inferior (ptid
);
1954 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
1959 debug_to_acknowledge_created_inferior (int pid
)
1961 debug_target
.to_acknowledge_created_inferior (pid
);
1963 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
1968 debug_to_insert_fork_catchpoint (int pid
)
1972 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
1974 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
1981 debug_to_remove_fork_catchpoint (int pid
)
1985 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
1987 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
1994 debug_to_insert_vfork_catchpoint (int pid
)
1998 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2000 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2007 debug_to_remove_vfork_catchpoint (int pid
)
2011 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2013 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2020 debug_to_follow_fork (int follow_child
)
2022 int retval
= debug_target
.to_follow_fork (follow_child
);
2024 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2025 follow_child
, retval
);
2031 debug_to_insert_exec_catchpoint (int pid
)
2035 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2037 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2044 debug_to_remove_exec_catchpoint (int pid
)
2048 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2050 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2057 debug_to_reported_exec_events_per_exec_call (void)
2059 int reported_exec_events
;
2061 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2063 fprintf_unfiltered (gdb_stdlog
,
2064 "target_reported_exec_events_per_exec_call () = %d\n",
2065 reported_exec_events
);
2067 return reported_exec_events
;
2071 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2075 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2077 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2078 pid
, wait_status
, *exit_status
, has_exited
);
2084 debug_to_mourn_inferior (void)
2086 debug_target
.to_mourn_inferior ();
2088 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2092 debug_to_can_run (void)
2096 retval
= debug_target
.to_can_run ();
2098 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2104 debug_to_notice_signals (ptid_t ptid
)
2106 debug_target
.to_notice_signals (ptid
);
2108 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2113 debug_to_thread_alive (ptid_t ptid
)
2117 retval
= debug_target
.to_thread_alive (ptid
);
2119 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2120 PIDGET (ptid
), retval
);
2126 debug_to_find_new_threads (void)
2128 debug_target
.to_find_new_threads ();
2130 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2134 debug_to_stop (void)
2136 debug_target
.to_stop ();
2138 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2142 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2146 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2148 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2154 debug_to_rcmd (char *command
,
2155 struct ui_file
*outbuf
)
2157 debug_target
.to_rcmd (command
, outbuf
);
2158 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2161 static struct symtab_and_line
*
2162 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2164 struct symtab_and_line
*result
;
2165 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2166 fprintf_unfiltered (gdb_stdlog
,
2167 "target get_exception_callback_sal (%d, %d)\n",
2172 static struct exception_event_record
*
2173 debug_to_get_current_exception_event (void)
2175 struct exception_event_record
*result
;
2176 result
= debug_target
.to_get_current_exception_event ();
2177 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2182 debug_to_pid_to_exec_file (int pid
)
2186 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2188 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2195 setup_target_debug (void)
2197 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2199 current_target
.to_open
= debug_to_open
;
2200 current_target
.to_close
= debug_to_close
;
2201 current_target
.to_attach
= debug_to_attach
;
2202 current_target
.to_post_attach
= debug_to_post_attach
;
2203 current_target
.to_detach
= debug_to_detach
;
2204 current_target
.to_resume
= debug_to_resume
;
2205 current_target
.to_wait
= debug_to_wait
;
2206 current_target
.to_post_wait
= debug_to_post_wait
;
2207 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2208 current_target
.to_store_registers
= debug_to_store_registers
;
2209 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2210 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2211 current_target
.to_files_info
= debug_to_files_info
;
2212 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2213 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2214 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2215 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2216 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2217 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2218 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2219 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2220 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2221 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2222 current_target
.to_terminal_init
= debug_to_terminal_init
;
2223 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2224 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2225 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2226 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2227 current_target
.to_terminal_info
= debug_to_terminal_info
;
2228 current_target
.to_kill
= debug_to_kill
;
2229 current_target
.to_load
= debug_to_load
;
2230 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2231 current_target
.to_create_inferior
= debug_to_create_inferior
;
2232 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2233 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2234 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2235 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2236 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2237 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2238 current_target
.to_follow_fork
= debug_to_follow_fork
;
2239 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2240 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2241 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2242 current_target
.to_has_exited
= debug_to_has_exited
;
2243 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2244 current_target
.to_can_run
= debug_to_can_run
;
2245 current_target
.to_notice_signals
= debug_to_notice_signals
;
2246 current_target
.to_thread_alive
= debug_to_thread_alive
;
2247 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2248 current_target
.to_stop
= debug_to_stop
;
2249 current_target
.to_query
= debug_to_query
;
2250 current_target
.to_rcmd
= debug_to_rcmd
;
2251 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2252 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2253 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2258 static char targ_desc
[] =
2259 "Names of targets and files being debugged.\n\
2260 Shows the entire stack of targets currently in use (including the exec-file,\n\
2261 core-file, and process, if any), as well as the symbol file name.";
2264 do_monitor_command (char *cmd
,
2267 if ((current_target
.to_rcmd
2268 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2269 || (current_target
.to_rcmd
== debug_to_rcmd
2270 && (debug_target
.to_rcmd
2271 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2273 error ("\"monitor\" command not supported by this target.\n");
2275 target_rcmd (cmd
, gdb_stdtarg
);
2279 initialize_targets (void)
2281 init_dummy_target ();
2282 push_target (&dummy_target
);
2284 add_info ("target", target_info
, targ_desc
);
2285 add_info ("files", target_info
, targ_desc
);
2288 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2289 (char *) &targetdebug
,
2290 "Set target debugging.\n\
2291 When non-zero, target debugging is enabled.", &setdebuglist
),
2294 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2296 Set mode for reading from readonly sections.\n\
2297 When this mode is on, memory reads from readonly sections (such as .text)\n\
2298 will be read from the object file instead of from the target. This will\n\
2299 result in significant performance improvement for remote targets.", "\
2300 Show mode for reading from readonly sections.\n",
2302 &setlist
, &showlist
);
2304 add_com ("monitor", class_obscure
, do_monitor_command
,
2305 "Send a command to the remote monitor (remote targets only).");
2307 target_dcache
= dcache_init ();