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 struct target_stack_item
*target_stack
;
185 /* The target structure we are currently using to talk to a process
186 or file or whatever "inferior" we have. */
188 struct target_ops current_target
;
190 /* Command list for target. */
192 static struct cmd_list_element
*targetlist
= NULL
;
194 /* Nonzero if we are debugging an attached outside process
195 rather than an inferior. */
199 /* Non-zero if we want to see trace of target level stuff. */
201 static int targetdebug
= 0;
203 static void setup_target_debug (void);
205 DCACHE
*target_dcache
;
207 /* The user just typed 'target' without the name of a target. */
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_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_disconnect
, t
);
560 INHERIT (to_resume
, t
);
561 INHERIT (to_wait
, t
);
562 INHERIT (to_post_wait
, t
);
563 INHERIT (to_fetch_registers
, t
);
564 INHERIT (to_store_registers
, t
);
565 INHERIT (to_prepare_to_store
, t
);
566 INHERIT (to_xfer_memory
, t
);
567 INHERIT (to_files_info
, t
);
568 INHERIT (to_insert_breakpoint
, t
);
569 INHERIT (to_remove_breakpoint
, t
);
570 INHERIT (to_can_use_hw_breakpoint
, t
);
571 INHERIT (to_insert_hw_breakpoint
, t
);
572 INHERIT (to_remove_hw_breakpoint
, t
);
573 INHERIT (to_insert_watchpoint
, t
);
574 INHERIT (to_remove_watchpoint
, t
);
575 INHERIT (to_stopped_data_address
, t
);
576 INHERIT (to_stopped_by_watchpoint
, t
);
577 INHERIT (to_have_continuable_watchpoint
, t
);
578 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
579 INHERIT (to_terminal_init
, t
);
580 INHERIT (to_terminal_inferior
, t
);
581 INHERIT (to_terminal_ours_for_output
, t
);
582 INHERIT (to_terminal_ours
, t
);
583 INHERIT (to_terminal_save_ours
, t
);
584 INHERIT (to_terminal_info
, t
);
585 INHERIT (to_kill
, t
);
586 INHERIT (to_load
, t
);
587 INHERIT (to_lookup_symbol
, t
);
588 INHERIT (to_create_inferior
, t
);
589 INHERIT (to_post_startup_inferior
, t
);
590 INHERIT (to_acknowledge_created_inferior
, t
);
591 INHERIT (to_insert_fork_catchpoint
, t
);
592 INHERIT (to_remove_fork_catchpoint
, t
);
593 INHERIT (to_insert_vfork_catchpoint
, t
);
594 INHERIT (to_remove_vfork_catchpoint
, t
);
595 INHERIT (to_follow_fork
, t
);
596 INHERIT (to_insert_exec_catchpoint
, t
);
597 INHERIT (to_remove_exec_catchpoint
, t
);
598 INHERIT (to_reported_exec_events_per_exec_call
, t
);
599 INHERIT (to_has_exited
, t
);
600 INHERIT (to_mourn_inferior
, t
);
601 INHERIT (to_can_run
, t
);
602 INHERIT (to_notice_signals
, t
);
603 INHERIT (to_thread_alive
, t
);
604 INHERIT (to_find_new_threads
, t
);
605 INHERIT (to_pid_to_str
, t
);
606 INHERIT (to_extra_thread_info
, t
);
607 INHERIT (to_stop
, t
);
608 INHERIT (to_query
, t
);
609 INHERIT (to_rcmd
, t
);
610 INHERIT (to_enable_exception_callback
, t
);
611 INHERIT (to_get_current_exception_event
, t
);
612 INHERIT (to_pid_to_exec_file
, t
);
613 INHERIT (to_stratum
, t
);
614 INHERIT (to_has_all_memory
, t
);
615 INHERIT (to_has_memory
, t
);
616 INHERIT (to_has_stack
, t
);
617 INHERIT (to_has_registers
, t
);
618 INHERIT (to_has_execution
, t
);
619 INHERIT (to_has_thread_control
, t
);
620 INHERIT (to_sections
, t
);
621 INHERIT (to_sections_end
, t
);
622 INHERIT (to_can_async_p
, t
);
623 INHERIT (to_is_async_p
, t
);
624 INHERIT (to_async
, t
);
625 INHERIT (to_async_mask_value
, t
);
626 INHERIT (to_find_memory_regions
, t
);
627 INHERIT (to_make_corefile_notes
, t
);
628 INHERIT (to_get_thread_local_address
, t
);
629 INHERIT (to_magic
, t
);
635 /* Push a new target type into the stack of the existing target accessors,
636 possibly superseding some of the existing accessors.
638 Result is zero if the pushed target ended up on top of the stack,
639 nonzero if at least one target is on top of it.
641 Rather than allow an empty stack, we always have the dummy target at
642 the bottom stratum, so we can call the function vectors without
646 push_target (struct target_ops
*t
)
648 struct target_stack_item
*cur
, *prev
, *tmp
;
650 /* Check magic number. If wrong, it probably means someone changed
651 the struct definition, but not all the places that initialize one. */
652 if (t
->to_magic
!= OPS_MAGIC
)
654 fprintf_unfiltered (gdb_stderr
,
655 "Magic number of %s target struct wrong\n",
657 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
660 /* Find the proper stratum to install this target in. */
662 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
664 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
668 /* If there's already targets at this stratum, remove them. */
671 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
673 /* There's already something on this stratum. Close it off. */
674 if (cur
->target_ops
->to_close
)
675 (cur
->target_ops
->to_close
) (0);
677 prev
->next
= cur
->next
; /* Unchain old target_ops */
679 target_stack
= cur
->next
; /* Unchain first on list */
685 /* We have removed all targets in our stratum, now add the new one. */
687 tmp
= (struct target_stack_item
*)
688 xmalloc (sizeof (struct target_stack_item
));
697 update_current_target ();
699 cleanup_target (¤t_target
); /* Fill in the gaps */
702 setup_target_debug ();
707 /* Remove a target_ops vector from the stack, wherever it may be.
708 Return how many times it was removed (0 or 1). */
711 unpush_target (struct target_ops
*t
)
713 struct target_stack_item
*cur
, *prev
;
716 t
->to_close (0); /* Let it clean up */
718 /* Look for the specified target. Note that we assume that a target
719 can only occur once in the target stack. */
721 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
722 if (cur
->target_ops
== t
)
726 return 0; /* Didn't find target_ops, quit now */
728 /* Unchain the target */
731 target_stack
= cur
->next
;
733 prev
->next
= cur
->next
;
735 xfree (cur
); /* Release the target_stack_item */
737 update_current_target ();
738 cleanup_target (¤t_target
);
746 (current_target
.to_close
) (0); /* Let it clean up */
747 if (unpush_target (target_stack
->target_ops
) == 1)
750 fprintf_unfiltered (gdb_stderr
,
751 "pop_target couldn't find target %s\n",
752 current_target
.to_shortname
);
753 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
757 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
759 /* target_read_string -- read a null terminated string, up to LEN bytes,
760 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
761 Set *STRING to a pointer to malloc'd memory containing the data; the caller
762 is responsible for freeing it. Return the number of bytes successfully
766 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
768 int tlen
, origlen
, offset
, i
;
772 int buffer_allocated
;
774 unsigned int nbytes_read
= 0;
776 /* Small for testing. */
777 buffer_allocated
= 4;
778 buffer
= xmalloc (buffer_allocated
);
785 tlen
= MIN (len
, 4 - (memaddr
& 3));
786 offset
= memaddr
& 3;
788 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
791 /* The transfer request might have crossed the boundary to an
792 unallocated region of memory. Retry the transfer, requesting
796 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
801 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
804 bytes
= bufptr
- buffer
;
805 buffer_allocated
*= 2;
806 buffer
= xrealloc (buffer
, buffer_allocated
);
807 bufptr
= buffer
+ bytes
;
810 for (i
= 0; i
< tlen
; i
++)
812 *bufptr
++ = buf
[i
+ offset
];
813 if (buf
[i
+ offset
] == '\000')
815 nbytes_read
+= i
+ 1;
832 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
833 GDB's memory at MYADDR. Returns either 0 for success or an errno value
836 If an error occurs, no guarantee is made about the contents of the data at
837 MYADDR. In particular, the caller should not depend upon partial reads
838 filling the buffer with good data. There is no way for the caller to know
839 how much good data might have been transfered anyway. Callers that can
840 deal with partial reads should call target_read_memory_partial. */
843 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
845 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
849 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
851 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
854 static int trust_readonly
= 0;
856 /* Move memory to or from the targets. The top target gets priority;
857 if it cannot handle it, it is offered to the next one down, etc.
859 Result is -1 on error, or the number of bytes transfered. */
862 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
863 struct mem_attrib
*attrib
)
867 struct target_ops
*t
;
868 struct target_stack_item
*item
;
870 /* Zero length requests are ok and require no work. */
874 /* to_xfer_memory is not guaranteed to set errno, even when it returns
878 if (!write
&& trust_readonly
)
880 /* User-settable option, "trust-readonly-sections". If true,
881 then memory from any SEC_READONLY bfd section may be read
882 directly from the bfd file. */
884 struct section_table
*secp
;
886 for (secp
= current_target
.to_sections
;
887 secp
< current_target
.to_sections_end
;
890 if (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
892 if (memaddr
>= secp
->addr
&& memaddr
< secp
->endaddr
)
893 return xfer_memory (memaddr
, myaddr
, len
, 0,
894 attrib
, ¤t_target
);
898 /* The quick case is that the top target can handle the transfer. */
899 res
= current_target
.to_xfer_memory
900 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
902 /* If res <= 0 then we call it again in the loop. Ah well. */
905 for (item
= target_stack
; item
; item
= item
->next
)
907 t
= item
->target_ops
;
908 if (!t
->to_has_memory
)
911 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
913 break; /* Handled all or part of xfer */
914 if (t
->to_has_all_memory
)
926 /* Perform a memory transfer. Iterate until the entire region has
929 Result is 0 or errno value. */
932 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
936 struct mem_region
*region
;
938 /* Zero length requests are ok and require no work. */
946 region
= lookup_mem_region(memaddr
);
947 if (memaddr
+ len
< region
->hi
)
950 reg_len
= region
->hi
- memaddr
;
952 switch (region
->attrib
.mode
)
967 if (region
->attrib
.cache
)
968 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
971 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
976 /* If this address is for nonexistent memory, read zeros
977 if reading, or do nothing if writing. Return
980 memset (myaddr
, 0, len
);
994 return 0; /* We managed to cover it all somehow. */
998 /* Perform a partial memory transfer.
1000 Result is -1 on error, or the number of bytes transfered. */
1003 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1004 int write_p
, int *err
)
1008 struct mem_region
*region
;
1010 /* Zero length requests are ok and require no work. */
1017 region
= lookup_mem_region(memaddr
);
1018 if (memaddr
+ len
< region
->hi
)
1021 reg_len
= region
->hi
- memaddr
;
1023 switch (region
->attrib
.mode
)
1042 if (region
->attrib
.cache
)
1043 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1046 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1064 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1066 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1070 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1072 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1076 target_info (char *args
, int from_tty
)
1078 struct target_ops
*t
;
1079 struct target_stack_item
*item
;
1080 int has_all_mem
= 0;
1082 if (symfile_objfile
!= NULL
)
1083 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1085 #ifdef FILES_INFO_HOOK
1086 if (FILES_INFO_HOOK ())
1090 for (item
= target_stack
; item
; item
= item
->next
)
1092 t
= item
->target_ops
;
1094 if (!t
->to_has_memory
)
1097 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1100 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1101 printf_unfiltered ("%s:\n", t
->to_longname
);
1102 (t
->to_files_info
) (t
);
1103 has_all_mem
= t
->to_has_all_memory
;
1107 /* This is to be called by the open routine before it does
1111 target_preopen (int from_tty
)
1115 if (target_has_execution
)
1118 || query ("A program is being debugged already. Kill it? "))
1121 error ("Program not killed.");
1124 /* Calling target_kill may remove the target from the stack. But if
1125 it doesn't (which seems like a win for UDI), remove it now. */
1127 if (target_has_execution
)
1131 /* Detach a target after doing deferred register stores. */
1134 target_detach (char *args
, int from_tty
)
1136 /* Handle any optimized stores to the inferior. */
1137 #ifdef DO_DEFERRED_STORES
1140 (current_target
.to_detach
) (args
, from_tty
);
1144 target_disconnect (char *args
, int from_tty
)
1146 /* Handle any optimized stores to the inferior. */
1147 #ifdef DO_DEFERRED_STORES
1150 (current_target
.to_disconnect
) (args
, from_tty
);
1154 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1156 if (STREQ (current_target
.to_shortname
, "rombug"))
1158 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1160 error ("Unable to link to %s and get relocation in rombug", modname
);
1163 *t_reloc
= (CORE_ADDR
) -1;
1167 target_async_mask (int mask
)
1169 int saved_async_masked_status
= target_async_mask_value
;
1170 target_async_mask_value
= mask
;
1171 return saved_async_masked_status
;
1174 /* Look through the list of possible targets for a target that can
1175 execute a run or attach command without any other data. This is
1176 used to locate the default process stratum.
1178 Result is always valid (error() is called for errors). */
1180 static struct target_ops
*
1181 find_default_run_target (char *do_mesg
)
1183 struct target_ops
**t
;
1184 struct target_ops
*runable
= NULL
;
1189 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1192 if ((*t
)->to_can_run
&& target_can_run (*t
))
1200 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1206 find_default_attach (char *args
, int from_tty
)
1208 struct target_ops
*t
;
1210 t
= find_default_run_target ("attach");
1211 (t
->to_attach
) (args
, from_tty
);
1216 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1218 struct target_ops
*t
;
1220 t
= find_default_run_target ("run");
1221 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1226 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1228 return (byte_count
<= DEPRECATED_REGISTER_SIZE
);
1244 return_minus_one (void)
1250 * Resize the to_sections pointer. Also make sure that anyone that
1251 * was holding on to an old value of it gets updated.
1252 * Returns the old size.
1256 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1258 struct target_ops
**t
;
1259 struct section_table
*old_value
;
1262 old_value
= target
->to_sections
;
1264 if (target
->to_sections
)
1266 old_count
= target
->to_sections_end
- target
->to_sections
;
1267 target
->to_sections
= (struct section_table
*)
1268 xrealloc ((char *) target
->to_sections
,
1269 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1274 target
->to_sections
= (struct section_table
*)
1275 xmalloc ((sizeof (struct section_table
)) * num_added
);
1277 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1279 /* Check to see if anyone else was pointing to this structure.
1280 If old_value was null, then no one was. */
1284 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1287 if ((*t
)->to_sections
== old_value
)
1289 (*t
)->to_sections
= target
->to_sections
;
1290 (*t
)->to_sections_end
= target
->to_sections_end
;
1299 /* Remove all target sections taken from ABFD.
1301 Scan the current target stack for targets whose section tables
1302 refer to sections from BFD, and remove those sections. We use this
1303 when we notice that the inferior has unloaded a shared object, for
1306 remove_target_sections (bfd
*abfd
)
1308 struct target_ops
**t
;
1310 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1312 struct section_table
*src
, *dest
;
1314 dest
= (*t
)->to_sections
;
1315 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1316 if (src
->bfd
!= abfd
)
1318 /* Keep this section. */
1319 if (dest
< src
) *dest
= *src
;
1323 /* If we've dropped any sections, resize the section table. */
1325 target_resize_to_sections (*t
, dest
- src
);
1332 /* Find a single runnable target in the stack and return it. If for
1333 some reason there is more than one, return NULL. */
1336 find_run_target (void)
1338 struct target_ops
**t
;
1339 struct target_ops
*runable
= NULL
;
1344 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1346 if ((*t
)->to_can_run
&& target_can_run (*t
))
1353 return (count
== 1 ? runable
: NULL
);
1356 /* Find a single core_stratum target in the list of targets and return it.
1357 If for some reason there is more than one, return NULL. */
1360 find_core_target (void)
1362 struct target_ops
**t
;
1363 struct target_ops
*runable
= NULL
;
1368 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1371 if ((*t
)->to_stratum
== core_stratum
)
1378 return (count
== 1 ? runable
: NULL
);
1382 * Find the next target down the stack from the specified target.
1386 find_target_beneath (struct target_ops
*t
)
1388 struct target_stack_item
*cur
;
1390 for (cur
= target_stack
; cur
; cur
= cur
->next
)
1391 if (cur
->target_ops
== t
)
1394 if (cur
== NULL
|| cur
->next
== NULL
)
1397 return cur
->next
->target_ops
;
1401 /* The inferior process has died. Long live the inferior! */
1404 generic_mourn_inferior (void)
1406 extern int show_breakpoint_hit_counts
;
1408 inferior_ptid
= null_ptid
;
1410 breakpoint_init_inferior (inf_exited
);
1411 registers_changed ();
1413 #ifdef CLEAR_DEFERRED_STORES
1414 /* Delete any pending stores to the inferior... */
1415 CLEAR_DEFERRED_STORES
;
1418 reopen_exec_file ();
1419 reinit_frame_cache ();
1421 /* It is confusing to the user for ignore counts to stick around
1422 from previous runs of the inferior. So clear them. */
1423 /* However, it is more confusing for the ignore counts to disappear when
1424 using hit counts. So don't clear them if we're counting hits. */
1425 if (!show_breakpoint_hit_counts
)
1426 breakpoint_clear_ignore_counts ();
1432 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1433 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1434 translation of that in OURSTATUS. */
1436 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1438 #ifdef CHILD_SPECIAL_WAITSTATUS
1439 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1440 if it wants to deal with hoststatus. */
1441 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1445 if (WIFEXITED (hoststatus
))
1447 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1448 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1450 else if (!WIFSTOPPED (hoststatus
))
1452 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1453 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1457 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1458 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1462 /* Returns zero to leave the inferior alone, one to interrupt it. */
1463 int (*target_activity_function
) (void);
1464 int target_activity_fd
;
1466 /* Convert a normal process ID to a string. Returns the string in a static
1470 normal_pid_to_str (ptid_t ptid
)
1472 static char buf
[30];
1474 sprintf (buf
, "process %d", PIDGET (ptid
));
1478 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1479 notification of inferior events such as fork and vork immediately
1480 after the inferior is created. (This because of how gdb gets an
1481 inferior created via invoking a shell to do it. In such a scenario,
1482 if the shell init file has commands in it, the shell will fork and
1483 exec for each of those commands, and we will see each such fork
1486 This function is used by all targets that allow us to request
1487 notification of forks, etc at inferior creation time; e.g., in
1488 target_acknowledge_forked_child.
1491 normal_target_post_startup_inferior (ptid_t ptid
)
1493 /* This space intentionally left blank. */
1496 /* Error-catcher for target_find_memory_regions */
1497 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1499 error ("No target.");
1503 /* Error-catcher for target_make_corefile_notes */
1504 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1506 error ("No target.");
1510 /* Set up the handful of non-empty slots needed by the dummy target
1514 init_dummy_target (void)
1516 dummy_target
.to_shortname
= "None";
1517 dummy_target
.to_longname
= "None";
1518 dummy_target
.to_doc
= "";
1519 dummy_target
.to_attach
= find_default_attach
;
1520 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1521 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1522 dummy_target
.to_stratum
= dummy_stratum
;
1523 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1524 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1525 dummy_target
.to_magic
= OPS_MAGIC
;
1529 static struct target_ops debug_target
;
1532 debug_to_open (char *args
, int from_tty
)
1534 debug_target
.to_open (args
, from_tty
);
1536 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1540 debug_to_close (int quitting
)
1542 debug_target
.to_close (quitting
);
1544 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1548 debug_to_attach (char *args
, int from_tty
)
1550 debug_target
.to_attach (args
, from_tty
);
1552 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1557 debug_to_post_attach (int pid
)
1559 debug_target
.to_post_attach (pid
);
1561 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1565 debug_to_detach (char *args
, int from_tty
)
1567 debug_target
.to_detach (args
, from_tty
);
1569 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1573 debug_to_disconnect (char *args
, int from_tty
)
1575 debug_target
.to_disconnect (args
, from_tty
);
1577 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1582 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1584 debug_target
.to_resume (ptid
, step
, siggnal
);
1586 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1587 step
? "step" : "continue",
1588 target_signal_to_name (siggnal
));
1592 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1596 retval
= debug_target
.to_wait (ptid
, status
);
1598 fprintf_unfiltered (gdb_stdlog
,
1599 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1601 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1602 switch (status
->kind
)
1604 case TARGET_WAITKIND_EXITED
:
1605 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1606 status
->value
.integer
);
1608 case TARGET_WAITKIND_STOPPED
:
1609 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1610 target_signal_to_name (status
->value
.sig
));
1612 case TARGET_WAITKIND_SIGNALLED
:
1613 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1614 target_signal_to_name (status
->value
.sig
));
1616 case TARGET_WAITKIND_LOADED
:
1617 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1619 case TARGET_WAITKIND_FORKED
:
1620 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1622 case TARGET_WAITKIND_VFORKED
:
1623 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1625 case TARGET_WAITKIND_EXECD
:
1626 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1628 case TARGET_WAITKIND_SPURIOUS
:
1629 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1632 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1640 debug_to_post_wait (ptid_t ptid
, int status
)
1642 debug_target
.to_post_wait (ptid
, status
);
1644 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1645 PIDGET (ptid
), status
);
1649 debug_print_register (const char * func
, int regno
)
1651 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1652 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1653 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1654 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1656 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1660 unsigned char buf
[MAX_REGISTER_SIZE
];
1661 deprecated_read_register_gen (regno
, buf
);
1662 fprintf_unfiltered (gdb_stdlog
, " = ");
1663 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
++)
1665 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1667 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1669 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1670 paddr_nz (read_register (regno
)),
1671 paddr_d (read_register (regno
)));
1674 fprintf_unfiltered (gdb_stdlog
, "\n");
1678 debug_to_fetch_registers (int regno
)
1680 debug_target
.to_fetch_registers (regno
);
1681 debug_print_register ("target_fetch_registers", regno
);
1685 debug_to_store_registers (int regno
)
1687 debug_target
.to_store_registers (regno
);
1688 debug_print_register ("target_store_registers", regno
);
1689 fprintf_unfiltered (gdb_stdlog
, "\n");
1693 debug_to_prepare_to_store (void)
1695 debug_target
.to_prepare_to_store ();
1697 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1701 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1702 struct mem_attrib
*attrib
,
1703 struct target_ops
*target
)
1707 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1710 fprintf_unfiltered (gdb_stdlog
,
1711 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1712 (unsigned int) memaddr
, /* possable truncate long long */
1713 len
, write
? "write" : "read", retval
);
1721 fputs_unfiltered (", bytes =", gdb_stdlog
);
1722 for (i
= 0; i
< retval
; i
++)
1724 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1725 fprintf_unfiltered (gdb_stdlog
, "\n");
1726 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1730 fputc_unfiltered ('\n', gdb_stdlog
);
1736 debug_to_files_info (struct target_ops
*target
)
1738 debug_target
.to_files_info (target
);
1740 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1744 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1748 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1750 fprintf_unfiltered (gdb_stdlog
,
1751 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1752 (unsigned long) addr
,
1753 (unsigned long) retval
);
1758 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1762 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1764 fprintf_unfiltered (gdb_stdlog
,
1765 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1766 (unsigned long) addr
,
1767 (unsigned long) retval
);
1772 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1776 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1778 fprintf_unfiltered (gdb_stdlog
,
1779 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1780 (unsigned long) type
,
1781 (unsigned long) cnt
,
1782 (unsigned long) from_tty
,
1783 (unsigned long) retval
);
1788 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1792 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1794 fprintf_unfiltered (gdb_stdlog
,
1795 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1796 (unsigned long) byte_count
,
1797 (unsigned long) retval
);
1802 debug_to_stopped_by_watchpoint (void)
1806 retval
= debug_target
.to_stopped_by_watchpoint ();
1808 fprintf_unfiltered (gdb_stdlog
,
1809 "STOPPED_BY_WATCHPOINT () = %ld\n",
1810 (unsigned long) retval
);
1815 debug_to_stopped_data_address (void)
1819 retval
= debug_target
.to_stopped_data_address ();
1821 fprintf_unfiltered (gdb_stdlog
,
1822 "target_stopped_data_address () = 0x%lx\n",
1823 (unsigned long) retval
);
1828 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1832 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1834 fprintf_unfiltered (gdb_stdlog
,
1835 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1836 (unsigned long) addr
,
1837 (unsigned long) retval
);
1842 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1846 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1848 fprintf_unfiltered (gdb_stdlog
,
1849 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1850 (unsigned long) addr
,
1851 (unsigned long) retval
);
1856 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1860 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1862 fprintf_unfiltered (gdb_stdlog
,
1863 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1864 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1869 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
1873 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1875 fprintf_unfiltered (gdb_stdlog
,
1876 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1877 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1882 debug_to_terminal_init (void)
1884 debug_target
.to_terminal_init ();
1886 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
1890 debug_to_terminal_inferior (void)
1892 debug_target
.to_terminal_inferior ();
1894 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
1898 debug_to_terminal_ours_for_output (void)
1900 debug_target
.to_terminal_ours_for_output ();
1902 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
1906 debug_to_terminal_ours (void)
1908 debug_target
.to_terminal_ours ();
1910 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
1914 debug_to_terminal_save_ours (void)
1916 debug_target
.to_terminal_save_ours ();
1918 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
1922 debug_to_terminal_info (char *arg
, int from_tty
)
1924 debug_target
.to_terminal_info (arg
, from_tty
);
1926 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
1931 debug_to_kill (void)
1933 debug_target
.to_kill ();
1935 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
1939 debug_to_load (char *args
, int from_tty
)
1941 debug_target
.to_load (args
, from_tty
);
1943 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
1947 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
1951 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1953 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
1959 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
1961 debug_target
.to_create_inferior (exec_file
, args
, env
);
1963 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
1968 debug_to_post_startup_inferior (ptid_t ptid
)
1970 debug_target
.to_post_startup_inferior (ptid
);
1972 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
1977 debug_to_acknowledge_created_inferior (int pid
)
1979 debug_target
.to_acknowledge_created_inferior (pid
);
1981 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
1986 debug_to_insert_fork_catchpoint (int pid
)
1990 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
1992 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
1999 debug_to_remove_fork_catchpoint (int pid
)
2003 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2005 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2012 debug_to_insert_vfork_catchpoint (int pid
)
2016 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2018 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2025 debug_to_remove_vfork_catchpoint (int pid
)
2029 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2031 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2038 debug_to_follow_fork (int follow_child
)
2040 int retval
= debug_target
.to_follow_fork (follow_child
);
2042 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2043 follow_child
, retval
);
2049 debug_to_insert_exec_catchpoint (int pid
)
2053 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2055 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2062 debug_to_remove_exec_catchpoint (int pid
)
2066 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2068 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2075 debug_to_reported_exec_events_per_exec_call (void)
2077 int reported_exec_events
;
2079 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2081 fprintf_unfiltered (gdb_stdlog
,
2082 "target_reported_exec_events_per_exec_call () = %d\n",
2083 reported_exec_events
);
2085 return reported_exec_events
;
2089 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2093 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2095 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2096 pid
, wait_status
, *exit_status
, has_exited
);
2102 debug_to_mourn_inferior (void)
2104 debug_target
.to_mourn_inferior ();
2106 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2110 debug_to_can_run (void)
2114 retval
= debug_target
.to_can_run ();
2116 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2122 debug_to_notice_signals (ptid_t ptid
)
2124 debug_target
.to_notice_signals (ptid
);
2126 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2131 debug_to_thread_alive (ptid_t ptid
)
2135 retval
= debug_target
.to_thread_alive (ptid
);
2137 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2138 PIDGET (ptid
), retval
);
2144 debug_to_find_new_threads (void)
2146 debug_target
.to_find_new_threads ();
2148 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2152 debug_to_stop (void)
2154 debug_target
.to_stop ();
2156 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2160 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2164 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2166 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2172 debug_to_rcmd (char *command
,
2173 struct ui_file
*outbuf
)
2175 debug_target
.to_rcmd (command
, outbuf
);
2176 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2179 static struct symtab_and_line
*
2180 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2182 struct symtab_and_line
*result
;
2183 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2184 fprintf_unfiltered (gdb_stdlog
,
2185 "target get_exception_callback_sal (%d, %d)\n",
2190 static struct exception_event_record
*
2191 debug_to_get_current_exception_event (void)
2193 struct exception_event_record
*result
;
2194 result
= debug_target
.to_get_current_exception_event ();
2195 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2200 debug_to_pid_to_exec_file (int pid
)
2204 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2206 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2213 setup_target_debug (void)
2215 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2217 current_target
.to_open
= debug_to_open
;
2218 current_target
.to_close
= debug_to_close
;
2219 current_target
.to_attach
= debug_to_attach
;
2220 current_target
.to_post_attach
= debug_to_post_attach
;
2221 current_target
.to_detach
= debug_to_detach
;
2222 current_target
.to_disconnect
= debug_to_disconnect
;
2223 current_target
.to_resume
= debug_to_resume
;
2224 current_target
.to_wait
= debug_to_wait
;
2225 current_target
.to_post_wait
= debug_to_post_wait
;
2226 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2227 current_target
.to_store_registers
= debug_to_store_registers
;
2228 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2229 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2230 current_target
.to_files_info
= debug_to_files_info
;
2231 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2232 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2233 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2234 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2235 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2236 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2237 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2238 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2239 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2240 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2241 current_target
.to_terminal_init
= debug_to_terminal_init
;
2242 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2243 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2244 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2245 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2246 current_target
.to_terminal_info
= debug_to_terminal_info
;
2247 current_target
.to_kill
= debug_to_kill
;
2248 current_target
.to_load
= debug_to_load
;
2249 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2250 current_target
.to_create_inferior
= debug_to_create_inferior
;
2251 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2252 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2253 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2254 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2255 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2256 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2257 current_target
.to_follow_fork
= debug_to_follow_fork
;
2258 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2259 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2260 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2261 current_target
.to_has_exited
= debug_to_has_exited
;
2262 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2263 current_target
.to_can_run
= debug_to_can_run
;
2264 current_target
.to_notice_signals
= debug_to_notice_signals
;
2265 current_target
.to_thread_alive
= debug_to_thread_alive
;
2266 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2267 current_target
.to_stop
= debug_to_stop
;
2268 current_target
.to_query
= debug_to_query
;
2269 current_target
.to_rcmd
= debug_to_rcmd
;
2270 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2271 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2272 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2277 static char targ_desc
[] =
2278 "Names of targets and files being debugged.\n\
2279 Shows the entire stack of targets currently in use (including the exec-file,\n\
2280 core-file, and process, if any), as well as the symbol file name.";
2283 do_monitor_command (char *cmd
,
2286 if ((current_target
.to_rcmd
2287 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2288 || (current_target
.to_rcmd
== debug_to_rcmd
2289 && (debug_target
.to_rcmd
2290 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2292 error ("\"monitor\" command not supported by this target.\n");
2294 target_rcmd (cmd
, gdb_stdtarg
);
2298 initialize_targets (void)
2300 init_dummy_target ();
2301 push_target (&dummy_target
);
2303 add_info ("target", target_info
, targ_desc
);
2304 add_info ("files", target_info
, targ_desc
);
2307 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2308 (char *) &targetdebug
,
2309 "Set target debugging.\n\
2310 When non-zero, target debugging is enabled.", &setdebuglist
),
2313 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2315 Set mode for reading from readonly sections.\n\
2316 When this mode is on, memory reads from readonly sections (such as .text)\n\
2317 will be read from the object file instead of from the target. This will\n\
2318 result in significant performance improvement for remote targets.", "\
2319 Show mode for reading from readonly sections.\n",
2321 &setlist
, &showlist
);
2323 add_com ("monitor", class_obscure
, do_monitor_command
,
2324 "Send a command to the remote monitor (remote targets only).");
2326 target_dcache
= dcache_init ();