1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
41 static void target_info (char *, int);
43 static void cleanup_target (struct target_ops
*);
45 static void maybe_kill_then_create_inferior (char *, char *, char **);
47 static void default_clone_and_follow_inferior (int, int *);
49 static void maybe_kill_then_attach (char *, int);
51 static void kill_or_be_killed (int);
53 static void default_terminal_info (char *, int);
55 static int 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 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void update_current_target (void);
73 static void nosupport_runtime (void);
75 static void normal_target_post_startup_inferior (ptid_t ptid
);
77 /* Transfer LEN bytes between target address MEMADDR and GDB address
78 MYADDR. Returns 0 for success, errno code for failure (which
79 includes partial transfers -- if you want a more useful response to
80 partial transfers, try either target_read_memory_partial or
81 target_write_memory_partial). */
84 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
);
86 static void init_dummy_target (void);
88 static void debug_to_open (char *, int);
90 static void debug_to_close (int);
92 static void debug_to_attach (char *, int);
94 static void debug_to_detach (char *, int);
96 static void debug_to_resume (ptid_t
, int, enum target_signal
);
98 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
100 static void debug_to_fetch_registers (int);
102 static void debug_to_store_registers (int);
104 static void debug_to_prepare_to_store (void);
106 static int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
107 struct mem_attrib
*, struct target_ops
*);
109 static void debug_to_files_info (struct target_ops
*);
111 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
113 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
115 static void debug_to_terminal_init (void);
117 static void debug_to_terminal_inferior (void);
119 static void debug_to_terminal_ours_for_output (void);
121 static void debug_to_terminal_ours (void);
123 static void debug_to_terminal_info (char *, int);
125 static void debug_to_kill (void);
127 static void debug_to_load (char *, int);
129 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
131 static void debug_to_create_inferior (char *, char *, char **);
133 static void debug_to_mourn_inferior (void);
135 static int debug_to_can_run (void);
137 static void debug_to_notice_signals (ptid_t
);
139 static int debug_to_thread_alive (ptid_t
);
141 static void debug_to_stop (void);
143 static int debug_to_query (int /*char */ , char *, char *, int *);
145 /* Pointer to array of target architecture structures; the size of the
146 array; the current index into the array; the allocated size of the
148 struct target_ops
**target_structs
;
149 unsigned target_struct_size
;
150 unsigned target_struct_index
;
151 unsigned target_struct_allocsize
;
152 #define DEFAULT_ALLOCSIZE 10
154 /* The initial current target, so that there is always a semi-valid
157 static struct target_ops dummy_target
;
159 /* Top of target stack. */
161 struct target_stack_item
*target_stack
;
163 /* The target structure we are currently using to talk to a process
164 or file or whatever "inferior" we have. */
166 struct target_ops current_target
;
168 /* Command list for target. */
170 static struct cmd_list_element
*targetlist
= NULL
;
172 /* Nonzero if we are debugging an attached outside process
173 rather than an inferior. */
177 /* Non-zero if we want to see trace of target level stuff. */
179 static int targetdebug
= 0;
181 static void setup_target_debug (void);
183 DCACHE
*target_dcache
;
185 /* The user just typed 'target' without the name of a target. */
189 target_command (char *arg
, int from_tty
)
191 fputs_filtered ("Argument required (target name). Try `help target'\n",
195 /* Add a possible target architecture to the list. */
198 add_target (struct target_ops
*t
)
202 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
203 target_structs
= (struct target_ops
**) xmalloc
204 (target_struct_allocsize
* sizeof (*target_structs
));
206 if (target_struct_size
>= target_struct_allocsize
)
208 target_struct_allocsize
*= 2;
209 target_structs
= (struct target_ops
**)
210 xrealloc ((char *) target_structs
,
211 target_struct_allocsize
* sizeof (*target_structs
));
213 target_structs
[target_struct_size
++] = t
;
214 /* cleanup_target (t); */
216 if (targetlist
== NULL
)
217 add_prefix_cmd ("target", class_run
, target_command
,
218 "Connect to a target machine or process.\n\
219 The first argument is the type or protocol of the target machine.\n\
220 Remaining arguments are interpreted by the target protocol. For more\n\
221 information on the arguments for a particular protocol, type\n\
222 `help target ' followed by the protocol name.",
223 &targetlist
, "target ", 0, &cmdlist
);
224 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
235 target_load (char *arg
, int from_tty
)
237 dcache_invalidate (target_dcache
);
238 (*current_target
.to_load
) (arg
, from_tty
);
243 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
244 struct target_ops
*t
)
246 errno
= EIO
; /* Can't read/write this location */
247 return 0; /* No bytes handled */
253 error ("You can't do that when your target is `%s'",
254 current_target
.to_shortname
);
260 error ("You can't do that without a process to debug.");
265 nosymbol (char *name
, CORE_ADDR
*addrp
)
267 return 1; /* Symbol does not exist in target env */
272 nosupport_runtime (void)
274 if (ptid_equal (inferior_ptid
, null_ptid
))
277 error ("No run-time support for this");
283 default_terminal_info (char *args
, int from_tty
)
285 printf_unfiltered ("No saved terminal information.\n");
288 /* This is the default target_create_inferior and target_attach function.
289 If the current target is executing, it asks whether to kill it off.
290 If this function returns without calling error(), it has killed off
291 the target, and the operation should be attempted. */
294 kill_or_be_killed (int from_tty
)
296 if (target_has_execution
)
298 printf_unfiltered ("You are already running a program:\n");
299 target_files_info ();
300 if (query ("Kill it? "))
303 if (target_has_execution
)
304 error ("Killing the program did not help.");
309 error ("Program not killed.");
316 maybe_kill_then_attach (char *args
, int from_tty
)
318 kill_or_be_killed (from_tty
);
319 target_attach (args
, from_tty
);
323 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
325 kill_or_be_killed (0);
326 target_create_inferior (exec
, args
, env
);
330 default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
332 target_clone_and_follow_inferior (child_pid
, followed_child
);
335 /* Clean up a target struct so it no longer has any zero pointers in it.
336 We default entries, at least to stubs that print error messages. */
339 cleanup_target (struct target_ops
*t
)
342 #define de_fault(field, value) \
347 (void (*) (char *, int))
353 maybe_kill_then_attach
);
354 de_fault (to_post_attach
,
357 de_fault (to_require_attach
,
358 maybe_kill_then_attach
);
360 (void (*) (char *, int))
362 de_fault (to_require_detach
,
363 (void (*) (int, char *, int))
366 (void (*) (ptid_t
, int, enum target_signal
))
369 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
371 de_fault (to_post_wait
,
372 (void (*) (ptid_t
, int))
374 de_fault (to_fetch_registers
,
377 de_fault (to_store_registers
,
380 de_fault (to_prepare_to_store
,
383 de_fault (to_xfer_memory
,
384 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
386 de_fault (to_files_info
,
387 (void (*) (struct target_ops
*))
389 de_fault (to_insert_breakpoint
,
390 memory_insert_breakpoint
);
391 de_fault (to_remove_breakpoint
,
392 memory_remove_breakpoint
);
393 de_fault (to_terminal_init
,
396 de_fault (to_terminal_inferior
,
399 de_fault (to_terminal_ours_for_output
,
402 de_fault (to_terminal_ours
,
405 de_fault (to_terminal_info
,
406 default_terminal_info
);
411 (void (*) (char *, int))
413 de_fault (to_lookup_symbol
,
414 (int (*) (char *, CORE_ADDR
*))
416 de_fault (to_create_inferior
,
417 maybe_kill_then_create_inferior
);
418 de_fault (to_post_startup_inferior
,
421 de_fault (to_acknowledge_created_inferior
,
424 de_fault (to_clone_and_follow_inferior
,
425 default_clone_and_follow_inferior
);
426 de_fault (to_post_follow_inferior_by_clone
,
429 de_fault (to_insert_fork_catchpoint
,
432 de_fault (to_remove_fork_catchpoint
,
435 de_fault (to_insert_vfork_catchpoint
,
438 de_fault (to_remove_vfork_catchpoint
,
441 de_fault (to_has_forked
,
442 (int (*) (int, int *))
444 de_fault (to_has_vforked
,
445 (int (*) (int, int *))
447 de_fault (to_can_follow_vfork_prior_to_exec
,
450 de_fault (to_post_follow_vfork
,
451 (void (*) (int, int, int, int))
453 de_fault (to_insert_exec_catchpoint
,
456 de_fault (to_remove_exec_catchpoint
,
459 de_fault (to_has_execd
,
460 (int (*) (int, char **))
462 de_fault (to_reported_exec_events_per_exec_call
,
465 de_fault (to_has_syscall_event
,
466 (int (*) (int, enum target_waitkind
*, int *))
468 de_fault (to_has_exited
,
469 (int (*) (int, int, int *))
471 de_fault (to_mourn_inferior
,
474 de_fault (to_can_run
,
476 de_fault (to_notice_signals
,
479 de_fault (to_thread_alive
,
482 de_fault (to_find_new_threads
,
485 de_fault (to_extra_thread_info
,
486 (char *(*) (struct thread_info
*))
492 (void (*) (char *, struct ui_file
*))
494 de_fault (to_enable_exception_callback
,
495 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
497 de_fault (to_get_current_exception_event
,
498 (struct exception_event_record
* (*) (void))
500 de_fault (to_pid_to_exec_file
,
503 de_fault (to_can_async_p
,
506 de_fault (to_is_async_p
,
510 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
515 /* Go through the target stack from top to bottom, copying over zero entries in
516 current_target. In effect, we are doing class inheritance through the
517 pushed target vectors. */
520 update_current_target (void)
522 struct target_stack_item
*item
;
523 struct target_ops
*t
;
525 /* First, reset current_target */
526 memset (¤t_target
, 0, sizeof current_target
);
528 for (item
= target_stack
; item
; item
= item
->next
)
530 t
= item
->target_ops
;
532 #define INHERIT(FIELD, TARGET) \
533 if (!current_target.FIELD) \
534 current_target.FIELD = TARGET->FIELD
536 INHERIT (to_shortname
, t
);
537 INHERIT (to_longname
, t
);
539 INHERIT (to_open
, t
);
540 INHERIT (to_close
, t
);
541 INHERIT (to_attach
, t
);
542 INHERIT (to_post_attach
, t
);
543 INHERIT (to_require_attach
, t
);
544 INHERIT (to_detach
, t
);
545 INHERIT (to_require_detach
, t
);
546 INHERIT (to_resume
, t
);
547 INHERIT (to_wait
, t
);
548 INHERIT (to_post_wait
, t
);
549 INHERIT (to_fetch_registers
, t
);
550 INHERIT (to_store_registers
, t
);
551 INHERIT (to_prepare_to_store
, t
);
552 INHERIT (to_xfer_memory
, t
);
553 INHERIT (to_files_info
, t
);
554 INHERIT (to_insert_breakpoint
, t
);
555 INHERIT (to_remove_breakpoint
, t
);
556 INHERIT (to_terminal_init
, t
);
557 INHERIT (to_terminal_inferior
, t
);
558 INHERIT (to_terminal_ours_for_output
, t
);
559 INHERIT (to_terminal_ours
, t
);
560 INHERIT (to_terminal_info
, t
);
561 INHERIT (to_kill
, t
);
562 INHERIT (to_load
, t
);
563 INHERIT (to_lookup_symbol
, t
);
564 INHERIT (to_create_inferior
, t
);
565 INHERIT (to_post_startup_inferior
, t
);
566 INHERIT (to_acknowledge_created_inferior
, t
);
567 INHERIT (to_clone_and_follow_inferior
, t
);
568 INHERIT (to_post_follow_inferior_by_clone
, t
);
569 INHERIT (to_insert_fork_catchpoint
, t
);
570 INHERIT (to_remove_fork_catchpoint
, t
);
571 INHERIT (to_insert_vfork_catchpoint
, t
);
572 INHERIT (to_remove_vfork_catchpoint
, t
);
573 INHERIT (to_has_forked
, t
);
574 INHERIT (to_has_vforked
, t
);
575 INHERIT (to_can_follow_vfork_prior_to_exec
, t
);
576 INHERIT (to_post_follow_vfork
, t
);
577 INHERIT (to_insert_exec_catchpoint
, t
);
578 INHERIT (to_remove_exec_catchpoint
, t
);
579 INHERIT (to_has_execd
, t
);
580 INHERIT (to_reported_exec_events_per_exec_call
, t
);
581 INHERIT (to_has_syscall_event
, t
);
582 INHERIT (to_has_exited
, t
);
583 INHERIT (to_mourn_inferior
, t
);
584 INHERIT (to_can_run
, t
);
585 INHERIT (to_notice_signals
, t
);
586 INHERIT (to_thread_alive
, t
);
587 INHERIT (to_find_new_threads
, t
);
588 INHERIT (to_pid_to_str
, t
);
589 INHERIT (to_extra_thread_info
, t
);
590 INHERIT (to_stop
, t
);
591 INHERIT (to_query
, t
);
592 INHERIT (to_rcmd
, t
);
593 INHERIT (to_enable_exception_callback
, t
);
594 INHERIT (to_get_current_exception_event
, t
);
595 INHERIT (to_pid_to_exec_file
, t
);
596 INHERIT (to_stratum
, t
);
597 INHERIT (DONT_USE
, t
);
598 INHERIT (to_has_all_memory
, t
);
599 INHERIT (to_has_memory
, t
);
600 INHERIT (to_has_stack
, t
);
601 INHERIT (to_has_registers
, t
);
602 INHERIT (to_has_execution
, t
);
603 INHERIT (to_has_thread_control
, t
);
604 INHERIT (to_sections
, t
);
605 INHERIT (to_sections_end
, t
);
606 INHERIT (to_can_async_p
, t
);
607 INHERIT (to_is_async_p
, t
);
608 INHERIT (to_async
, t
);
609 INHERIT (to_async_mask_value
, t
);
610 INHERIT (to_find_memory_regions
, t
);
611 INHERIT (to_make_corefile_notes
, t
);
612 INHERIT (to_magic
, t
);
618 /* Push a new target type into the stack of the existing target accessors,
619 possibly superseding some of the existing accessors.
621 Result is zero if the pushed target ended up on top of the stack,
622 nonzero if at least one target is on top of it.
624 Rather than allow an empty stack, we always have the dummy target at
625 the bottom stratum, so we can call the function vectors without
629 push_target (struct target_ops
*t
)
631 struct target_stack_item
*cur
, *prev
, *tmp
;
633 /* Check magic number. If wrong, it probably means someone changed
634 the struct definition, but not all the places that initialize one. */
635 if (t
->to_magic
!= OPS_MAGIC
)
637 fprintf_unfiltered (gdb_stderr
,
638 "Magic number of %s target struct wrong\n",
640 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
643 /* Find the proper stratum to install this target in. */
645 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
647 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
651 /* If there's already targets at this stratum, remove them. */
654 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
656 /* There's already something on this stratum. Close it off. */
657 if (cur
->target_ops
->to_close
)
658 (cur
->target_ops
->to_close
) (0);
660 prev
->next
= cur
->next
; /* Unchain old target_ops */
662 target_stack
= cur
->next
; /* Unchain first on list */
668 /* We have removed all targets in our stratum, now add the new one. */
670 tmp
= (struct target_stack_item
*)
671 xmalloc (sizeof (struct target_stack_item
));
680 update_current_target ();
682 cleanup_target (¤t_target
); /* Fill in the gaps */
685 setup_target_debug ();
690 /* Remove a target_ops vector from the stack, wherever it may be.
691 Return how many times it was removed (0 or 1). */
694 unpush_target (struct target_ops
*t
)
696 struct target_stack_item
*cur
, *prev
;
699 t
->to_close (0); /* Let it clean up */
701 /* Look for the specified target. Note that we assume that a target
702 can only occur once in the target stack. */
704 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
705 if (cur
->target_ops
== t
)
709 return 0; /* Didn't find target_ops, quit now */
711 /* Unchain the target */
714 target_stack
= cur
->next
;
716 prev
->next
= cur
->next
;
718 xfree (cur
); /* Release the target_stack_item */
720 update_current_target ();
721 cleanup_target (¤t_target
);
729 (current_target
.to_close
) (0); /* Let it clean up */
730 if (unpush_target (target_stack
->target_ops
) == 1)
733 fprintf_unfiltered (gdb_stderr
,
734 "pop_target couldn't find target %s\n",
735 current_target
.to_shortname
);
736 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
740 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
742 /* target_read_string -- read a null terminated string, up to LEN bytes,
743 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
744 Set *STRING to a pointer to malloc'd memory containing the data; the caller
745 is responsible for freeing it. Return the number of bytes successfully
749 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
751 int tlen
, origlen
, offset
, i
;
755 int buffer_allocated
;
757 unsigned int nbytes_read
= 0;
759 /* Small for testing. */
760 buffer_allocated
= 4;
761 buffer
= xmalloc (buffer_allocated
);
768 tlen
= MIN (len
, 4 - (memaddr
& 3));
769 offset
= memaddr
& 3;
771 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
774 /* The transfer request might have crossed the boundary to an
775 unallocated region of memory. Retry the transfer, requesting
779 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
784 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
787 bytes
= bufptr
- buffer
;
788 buffer_allocated
*= 2;
789 buffer
= xrealloc (buffer
, buffer_allocated
);
790 bufptr
= buffer
+ bytes
;
793 for (i
= 0; i
< tlen
; i
++)
795 *bufptr
++ = buf
[i
+ offset
];
796 if (buf
[i
+ offset
] == '\000')
798 nbytes_read
+= i
+ 1;
815 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
816 GDB's memory at MYADDR. Returns either 0 for success or an errno value
819 If an error occurs, no guarantee is made about the contents of the data at
820 MYADDR. In particular, the caller should not depend upon partial reads
821 filling the buffer with good data. There is no way for the caller to know
822 how much good data might have been transfered anyway. Callers that can
823 deal with partial reads should call target_read_memory_partial. */
826 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
828 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
832 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
834 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
837 static int trust_readonly
= 0;
839 /* Move memory to or from the targets. The top target gets priority;
840 if it cannot handle it, it is offered to the next one down, etc.
842 Result is -1 on error, or the number of bytes transfered. */
845 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
846 struct mem_attrib
*attrib
)
850 struct target_ops
*t
;
851 struct target_stack_item
*item
;
853 /* Zero length requests are ok and require no work. */
857 /* to_xfer_memory is not guaranteed to set errno, even when it returns
861 if (!write
&& trust_readonly
)
863 /* User-settable option, "trust-readonly-sections". If true,
864 then memory from any SEC_READONLY bfd section may be read
865 directly from the bfd file. */
867 struct section_table
*secp
;
869 for (secp
= current_target
.to_sections
;
870 secp
< current_target
.to_sections_end
;
873 if (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
875 if (memaddr
>= secp
->addr
&& memaddr
< secp
->endaddr
)
876 return xfer_memory (memaddr
, myaddr
, len
, 0,
877 attrib
, ¤t_target
);
881 /* The quick case is that the top target can handle the transfer. */
882 res
= current_target
.to_xfer_memory
883 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
885 /* If res <= 0 then we call it again in the loop. Ah well. */
888 for (item
= target_stack
; item
; item
= item
->next
)
890 t
= item
->target_ops
;
891 if (!t
->to_has_memory
)
894 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
896 break; /* Handled all or part of xfer */
897 if (t
->to_has_all_memory
)
909 /* Perform a memory transfer. Iterate until the entire region has
912 Result is 0 or errno value. */
915 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
919 struct mem_region
*region
;
921 /* Zero length requests are ok and require no work. */
929 region
= lookup_mem_region(memaddr
);
930 if (memaddr
+ len
< region
->hi
)
933 reg_len
= region
->hi
- memaddr
;
935 switch (region
->attrib
.mode
)
950 if (region
->attrib
.cache
)
951 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
954 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
959 /* If this address is for nonexistent memory, read zeros
960 if reading, or do nothing if writing. Return
963 memset (myaddr
, 0, len
);
977 return 0; /* We managed to cover it all somehow. */
981 /* Perform a partial memory transfer.
983 Result is -1 on error, or the number of bytes transfered. */
986 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
987 int write_p
, int *err
)
991 struct mem_region
*region
;
993 /* Zero length requests are ok and require no work. */
1000 region
= lookup_mem_region(memaddr
);
1001 if (memaddr
+ len
< region
->hi
)
1004 reg_len
= region
->hi
- memaddr
;
1006 switch (region
->attrib
.mode
)
1025 if (region
->attrib
.cache
)
1026 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1029 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1047 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1049 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1053 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1055 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1060 target_info (char *args
, int from_tty
)
1062 struct target_ops
*t
;
1063 struct target_stack_item
*item
;
1064 int has_all_mem
= 0;
1066 if (symfile_objfile
!= NULL
)
1067 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1069 #ifdef FILES_INFO_HOOK
1070 if (FILES_INFO_HOOK ())
1074 for (item
= target_stack
; item
; item
= item
->next
)
1076 t
= item
->target_ops
;
1078 if (!t
->to_has_memory
)
1081 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1084 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1085 printf_unfiltered ("%s:\n", t
->to_longname
);
1086 (t
->to_files_info
) (t
);
1087 has_all_mem
= t
->to_has_all_memory
;
1091 /* This is to be called by the open routine before it does
1095 target_preopen (int from_tty
)
1099 if (target_has_execution
)
1102 || query ("A program is being debugged already. Kill it? "))
1105 error ("Program not killed.");
1108 /* Calling target_kill may remove the target from the stack. But if
1109 it doesn't (which seems like a win for UDI), remove it now. */
1111 if (target_has_execution
)
1115 /* Detach a target after doing deferred register stores. */
1118 target_detach (char *args
, int from_tty
)
1120 /* Handle any optimized stores to the inferior. */
1121 #ifdef DO_DEFERRED_STORES
1124 (current_target
.to_detach
) (args
, from_tty
);
1128 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1130 if (STREQ (current_target
.to_shortname
, "rombug"))
1132 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1134 error ("Unable to link to %s and get relocation in rombug", modname
);
1137 *t_reloc
= (CORE_ADDR
) -1;
1141 target_async_mask (int mask
)
1143 int saved_async_masked_status
= target_async_mask_value
;
1144 target_async_mask_value
= mask
;
1145 return saved_async_masked_status
;
1148 /* Look through the list of possible targets for a target that can
1149 execute a run or attach command without any other data. This is
1150 used to locate the default process stratum.
1152 Result is always valid (error() is called for errors). */
1154 static struct target_ops
*
1155 find_default_run_target (char *do_mesg
)
1157 struct target_ops
**t
;
1158 struct target_ops
*runable
= NULL
;
1163 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1166 if ((*t
)->to_can_run
&& target_can_run (*t
))
1174 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1180 find_default_attach (char *args
, int from_tty
)
1182 struct target_ops
*t
;
1184 t
= find_default_run_target ("attach");
1185 (t
->to_attach
) (args
, from_tty
);
1190 find_default_require_attach (char *args
, int from_tty
)
1192 struct target_ops
*t
;
1194 t
= find_default_run_target ("require_attach");
1195 (t
->to_require_attach
) (args
, from_tty
);
1200 find_default_require_detach (int pid
, char *args
, int from_tty
)
1202 struct target_ops
*t
;
1204 t
= find_default_run_target ("require_detach");
1205 (t
->to_require_detach
) (pid
, args
, from_tty
);
1210 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1212 struct target_ops
*t
;
1214 t
= find_default_run_target ("run");
1215 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1220 find_default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
1222 struct target_ops
*t
;
1224 t
= find_default_run_target ("run");
1225 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1242 * Resize the to_sections pointer. Also make sure that anyone that
1243 * was holding on to an old value of it gets updated.
1244 * Returns the old size.
1248 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1250 struct target_ops
**t
;
1251 struct section_table
*old_value
;
1254 old_value
= target
->to_sections
;
1256 if (target
->to_sections
)
1258 old_count
= target
->to_sections_end
- target
->to_sections
;
1259 target
->to_sections
= (struct section_table
*)
1260 xrealloc ((char *) target
->to_sections
,
1261 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1266 target
->to_sections
= (struct section_table
*)
1267 xmalloc ((sizeof (struct section_table
)) * num_added
);
1269 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1271 /* Check to see if anyone else was pointing to this structure.
1272 If old_value was null, then no one was. */
1276 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1279 if ((*t
)->to_sections
== old_value
)
1281 (*t
)->to_sections
= target
->to_sections
;
1282 (*t
)->to_sections_end
= target
->to_sections_end
;
1291 /* Remove all target sections taken from ABFD.
1293 Scan the current target stack for targets whose section tables
1294 refer to sections from BFD, and remove those sections. We use this
1295 when we notice that the inferior has unloaded a shared object, for
1298 remove_target_sections (bfd
*abfd
)
1300 struct target_ops
**t
;
1302 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1304 struct section_table
*src
, *dest
;
1306 dest
= (*t
)->to_sections
;
1307 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1308 if (src
->bfd
!= abfd
)
1310 /* Keep this section. */
1311 if (dest
< src
) *dest
= *src
;
1315 /* If we've dropped any sections, resize the section table. */
1317 target_resize_to_sections (*t
, dest
- src
);
1324 /* Find a single runnable target in the stack and return it. If for
1325 some reason there is more than one, return NULL. */
1328 find_run_target (void)
1330 struct target_ops
**t
;
1331 struct target_ops
*runable
= NULL
;
1336 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1338 if ((*t
)->to_can_run
&& target_can_run (*t
))
1345 return (count
== 1 ? runable
: NULL
);
1348 /* Find a single core_stratum target in the list of targets and return it.
1349 If for some reason there is more than one, return NULL. */
1352 find_core_target (void)
1354 struct target_ops
**t
;
1355 struct target_ops
*runable
= NULL
;
1360 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1363 if ((*t
)->to_stratum
== core_stratum
)
1370 return (count
== 1 ? runable
: NULL
);
1374 * Find the next target down the stack from the specified target.
1378 find_target_beneath (struct target_ops
*t
)
1380 struct target_stack_item
*cur
;
1382 for (cur
= target_stack
; cur
; cur
= cur
->next
)
1383 if (cur
->target_ops
== t
)
1386 if (cur
== NULL
|| cur
->next
== NULL
)
1389 return cur
->next
->target_ops
;
1393 /* The inferior process has died. Long live the inferior! */
1396 generic_mourn_inferior (void)
1398 extern int show_breakpoint_hit_counts
;
1400 inferior_ptid
= null_ptid
;
1402 breakpoint_init_inferior (inf_exited
);
1403 registers_changed ();
1405 #ifdef CLEAR_DEFERRED_STORES
1406 /* Delete any pending stores to the inferior... */
1407 CLEAR_DEFERRED_STORES
;
1410 reopen_exec_file ();
1411 reinit_frame_cache ();
1413 /* It is confusing to the user for ignore counts to stick around
1414 from previous runs of the inferior. So clear them. */
1415 /* However, it is more confusing for the ignore counts to disappear when
1416 using hit counts. So don't clear them if we're counting hits. */
1417 if (!show_breakpoint_hit_counts
)
1418 breakpoint_clear_ignore_counts ();
1424 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1425 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1426 translation of that in OURSTATUS. */
1428 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1430 #ifdef CHILD_SPECIAL_WAITSTATUS
1431 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1432 if it wants to deal with hoststatus. */
1433 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1437 if (WIFEXITED (hoststatus
))
1439 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1440 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1442 else if (!WIFSTOPPED (hoststatus
))
1444 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1445 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1449 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1450 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1454 /* Returns zero to leave the inferior alone, one to interrupt it. */
1455 int (*target_activity_function
) (void);
1456 int target_activity_fd
;
1458 /* Convert a normal process ID to a string. Returns the string in a static
1462 normal_pid_to_str (ptid_t ptid
)
1464 static char buf
[30];
1466 sprintf (buf
, "process %d", PIDGET (ptid
));
1470 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1471 notification of inferior events such as fork and vork immediately
1472 after the inferior is created. (This because of how gdb gets an
1473 inferior created via invoking a shell to do it. In such a scenario,
1474 if the shell init file has commands in it, the shell will fork and
1475 exec for each of those commands, and we will see each such fork
1478 This function is used by all targets that allow us to request
1479 notification of forks, etc at inferior creation time; e.g., in
1480 target_acknowledge_forked_child.
1483 normal_target_post_startup_inferior (ptid_t ptid
)
1485 /* This space intentionally left blank. */
1488 /* Error-catcher for target_find_memory_regions */
1490 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1492 error ("No target.");
1496 /* Error-catcher for target_make_corefile_notes */
1498 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1500 error ("No target.");
1504 /* Set up the handful of non-empty slots needed by the dummy target
1508 init_dummy_target (void)
1510 dummy_target
.to_shortname
= "None";
1511 dummy_target
.to_longname
= "None";
1512 dummy_target
.to_doc
= "";
1513 dummy_target
.to_attach
= find_default_attach
;
1514 dummy_target
.to_require_attach
= find_default_require_attach
;
1515 dummy_target
.to_require_detach
= find_default_require_detach
;
1516 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1517 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
1518 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1519 dummy_target
.to_stratum
= dummy_stratum
;
1520 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1521 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1522 dummy_target
.to_magic
= OPS_MAGIC
;
1526 static struct target_ops debug_target
;
1529 debug_to_open (char *args
, int from_tty
)
1531 debug_target
.to_open (args
, from_tty
);
1533 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1537 debug_to_close (int quitting
)
1539 debug_target
.to_close (quitting
);
1541 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1545 debug_to_attach (char *args
, int from_tty
)
1547 debug_target
.to_attach (args
, from_tty
);
1549 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1554 debug_to_post_attach (int pid
)
1556 debug_target
.to_post_attach (pid
);
1558 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1562 debug_to_require_attach (char *args
, int from_tty
)
1564 debug_target
.to_require_attach (args
, from_tty
);
1566 fprintf_unfiltered (gdb_stdlog
,
1567 "target_require_attach (%s, %d)\n", args
, from_tty
);
1571 debug_to_detach (char *args
, int from_tty
)
1573 debug_target
.to_detach (args
, from_tty
);
1575 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1579 debug_to_require_detach (int pid
, char *args
, int from_tty
)
1581 debug_target
.to_require_detach (pid
, args
, from_tty
);
1583 fprintf_unfiltered (gdb_stdlog
,
1584 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
1588 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1590 debug_target
.to_resume (ptid
, step
, siggnal
);
1592 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1593 step
? "step" : "continue",
1594 target_signal_to_name (siggnal
));
1598 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1602 retval
= debug_target
.to_wait (ptid
, status
);
1604 fprintf_unfiltered (gdb_stdlog
,
1605 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1607 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1608 switch (status
->kind
)
1610 case TARGET_WAITKIND_EXITED
:
1611 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1612 status
->value
.integer
);
1614 case TARGET_WAITKIND_STOPPED
:
1615 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1616 target_signal_to_name (status
->value
.sig
));
1618 case TARGET_WAITKIND_SIGNALLED
:
1619 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1620 target_signal_to_name (status
->value
.sig
));
1622 case TARGET_WAITKIND_LOADED
:
1623 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1625 case TARGET_WAITKIND_FORKED
:
1626 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1628 case TARGET_WAITKIND_VFORKED
:
1629 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1631 case TARGET_WAITKIND_EXECD
:
1632 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1634 case TARGET_WAITKIND_SPURIOUS
:
1635 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1638 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1646 debug_to_post_wait (ptid_t ptid
, int status
)
1648 debug_target
.to_post_wait (ptid
, status
);
1650 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1651 PIDGET (ptid
), status
);
1655 debug_print_register (const char * func
, int regno
)
1657 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1658 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1659 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1660 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1662 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1666 unsigned char *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
1667 read_register_gen (regno
, buf
);
1668 fprintf_unfiltered (gdb_stdlog
, " = ");
1669 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
1671 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1673 if (REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1675 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1676 paddr_nz (read_register (regno
)),
1677 paddr_d (read_register (regno
)));
1680 fprintf_unfiltered (gdb_stdlog
, "\n");
1684 debug_to_fetch_registers (int regno
)
1686 debug_target
.to_fetch_registers (regno
);
1687 debug_print_register ("target_fetch_registers", regno
);
1691 debug_to_store_registers (int regno
)
1693 debug_target
.to_store_registers (regno
);
1694 debug_print_register ("target_store_registers", regno
);
1695 fprintf_unfiltered (gdb_stdlog
, "\n");
1699 debug_to_prepare_to_store (void)
1701 debug_target
.to_prepare_to_store ();
1703 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1707 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1708 struct mem_attrib
*attrib
,
1709 struct target_ops
*target
)
1713 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1716 fprintf_unfiltered (gdb_stdlog
,
1717 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1718 (unsigned int) memaddr
, /* possable truncate long long */
1719 len
, write
? "write" : "read", retval
);
1727 fputs_unfiltered (", bytes =", gdb_stdlog
);
1728 for (i
= 0; i
< retval
; i
++)
1730 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1731 fprintf_unfiltered (gdb_stdlog
, "\n");
1732 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1736 fputc_unfiltered ('\n', gdb_stdlog
);
1742 debug_to_files_info (struct target_ops
*target
)
1744 debug_target
.to_files_info (target
);
1746 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1750 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1754 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1756 fprintf_unfiltered (gdb_stdlog
,
1757 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1758 (unsigned long) addr
,
1759 (unsigned long) retval
);
1764 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1768 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1770 fprintf_unfiltered (gdb_stdlog
,
1771 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1772 (unsigned long) addr
,
1773 (unsigned long) retval
);
1778 debug_to_terminal_init (void)
1780 debug_target
.to_terminal_init ();
1782 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
1786 debug_to_terminal_inferior (void)
1788 debug_target
.to_terminal_inferior ();
1790 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
1794 debug_to_terminal_ours_for_output (void)
1796 debug_target
.to_terminal_ours_for_output ();
1798 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
1802 debug_to_terminal_ours (void)
1804 debug_target
.to_terminal_ours ();
1806 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
1810 debug_to_terminal_info (char *arg
, int from_tty
)
1812 debug_target
.to_terminal_info (arg
, from_tty
);
1814 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
1819 debug_to_kill (void)
1821 debug_target
.to_kill ();
1823 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
1827 debug_to_load (char *args
, int from_tty
)
1829 debug_target
.to_load (args
, from_tty
);
1831 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
1835 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
1839 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1841 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
1847 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
1849 debug_target
.to_create_inferior (exec_file
, args
, env
);
1851 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
1856 debug_to_post_startup_inferior (ptid_t ptid
)
1858 debug_target
.to_post_startup_inferior (ptid
);
1860 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
1865 debug_to_acknowledge_created_inferior (int pid
)
1867 debug_target
.to_acknowledge_created_inferior (pid
);
1869 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
1874 debug_to_clone_and_follow_inferior (int child_pid
, int *followed_child
)
1876 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
1878 fprintf_unfiltered (gdb_stdlog
,
1879 "target_clone_and_follow_inferior (%d, %d)\n",
1880 child_pid
, *followed_child
);
1884 debug_to_post_follow_inferior_by_clone (void)
1886 debug_target
.to_post_follow_inferior_by_clone ();
1888 fprintf_unfiltered (gdb_stdlog
, "target_post_follow_inferior_by_clone ()\n");
1892 debug_to_insert_fork_catchpoint (int pid
)
1896 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
1898 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
1905 debug_to_remove_fork_catchpoint (int pid
)
1909 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
1911 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
1918 debug_to_insert_vfork_catchpoint (int pid
)
1922 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
1924 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
1931 debug_to_remove_vfork_catchpoint (int pid
)
1935 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
1937 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
1944 debug_to_has_forked (int pid
, int *child_pid
)
1948 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
1950 fprintf_unfiltered (gdb_stdlog
, "target_has_forked (%d, %d) = %d\n",
1951 pid
, *child_pid
, has_forked
);
1957 debug_to_has_vforked (int pid
, int *child_pid
)
1961 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
1963 fprintf_unfiltered (gdb_stdlog
, "target_has_vforked (%d, %d) = %d\n",
1964 pid
, *child_pid
, has_vforked
);
1970 debug_to_can_follow_vfork_prior_to_exec (void)
1972 int can_immediately_follow_vfork
;
1974 can_immediately_follow_vfork
= debug_target
.to_can_follow_vfork_prior_to_exec ();
1976 fprintf_unfiltered (gdb_stdlog
, "target_can_follow_vfork_prior_to_exec () = %d\n",
1977 can_immediately_follow_vfork
);
1979 return can_immediately_follow_vfork
;
1983 debug_to_post_follow_vfork (int parent_pid
, int followed_parent
, int child_pid
,
1986 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
1988 fprintf_unfiltered (gdb_stdlog
,
1989 "target_post_follow_vfork (%d, %d, %d, %d)\n",
1990 parent_pid
, followed_parent
, child_pid
, followed_child
);
1994 debug_to_insert_exec_catchpoint (int pid
)
1998 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2000 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2007 debug_to_remove_exec_catchpoint (int pid
)
2011 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2013 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2020 debug_to_has_execd (int pid
, char **execd_pathname
)
2024 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2026 fprintf_unfiltered (gdb_stdlog
, "target_has_execd (%d, %s) = %d\n",
2027 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
2034 debug_to_reported_exec_events_per_exec_call (void)
2036 int reported_exec_events
;
2038 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2040 fprintf_unfiltered (gdb_stdlog
,
2041 "target_reported_exec_events_per_exec_call () = %d\n",
2042 reported_exec_events
);
2044 return reported_exec_events
;
2048 debug_to_has_syscall_event (int pid
, enum target_waitkind
*kind
,
2051 int has_syscall_event
;
2052 char *kind_spelling
= "??";
2054 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2055 if (has_syscall_event
)
2059 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2060 kind_spelling
= "SYSCALL_ENTRY";
2062 case TARGET_WAITKIND_SYSCALL_RETURN
:
2063 kind_spelling
= "SYSCALL_RETURN";
2070 fprintf_unfiltered (gdb_stdlog
,
2071 "target_has_syscall_event (%d, %s, %d) = %d\n",
2072 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2074 return has_syscall_event
;
2078 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2082 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2084 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2085 pid
, wait_status
, *exit_status
, has_exited
);
2091 debug_to_mourn_inferior (void)
2093 debug_target
.to_mourn_inferior ();
2095 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2099 debug_to_can_run (void)
2103 retval
= debug_target
.to_can_run ();
2105 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2111 debug_to_notice_signals (ptid_t ptid
)
2113 debug_target
.to_notice_signals (ptid
);
2115 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2120 debug_to_thread_alive (ptid_t ptid
)
2124 retval
= debug_target
.to_thread_alive (ptid
);
2126 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2127 PIDGET (ptid
), retval
);
2133 debug_to_find_new_threads (void)
2135 debug_target
.to_find_new_threads ();
2137 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2141 debug_to_stop (void)
2143 debug_target
.to_stop ();
2145 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2149 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2153 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2155 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2161 debug_to_rcmd (char *command
,
2162 struct ui_file
*outbuf
)
2164 debug_target
.to_rcmd (command
, outbuf
);
2165 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2168 static struct symtab_and_line
*
2169 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2171 struct symtab_and_line
*result
;
2172 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2173 fprintf_unfiltered (gdb_stdlog
,
2174 "target get_exception_callback_sal (%d, %d)\n",
2179 static struct exception_event_record
*
2180 debug_to_get_current_exception_event (void)
2182 struct exception_event_record
*result
;
2183 result
= debug_target
.to_get_current_exception_event ();
2184 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2189 debug_to_pid_to_exec_file (int pid
)
2193 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2195 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2202 setup_target_debug (void)
2204 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2206 current_target
.to_open
= debug_to_open
;
2207 current_target
.to_close
= debug_to_close
;
2208 current_target
.to_attach
= debug_to_attach
;
2209 current_target
.to_post_attach
= debug_to_post_attach
;
2210 current_target
.to_require_attach
= debug_to_require_attach
;
2211 current_target
.to_detach
= debug_to_detach
;
2212 current_target
.to_require_detach
= debug_to_require_detach
;
2213 current_target
.to_resume
= debug_to_resume
;
2214 current_target
.to_wait
= debug_to_wait
;
2215 current_target
.to_post_wait
= debug_to_post_wait
;
2216 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2217 current_target
.to_store_registers
= debug_to_store_registers
;
2218 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2219 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2220 current_target
.to_files_info
= debug_to_files_info
;
2221 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2222 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2223 current_target
.to_terminal_init
= debug_to_terminal_init
;
2224 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2225 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2226 current_target
.to_terminal_ours
= debug_to_terminal_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_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2235 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2236 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2237 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2238 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2239 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2240 current_target
.to_has_forked
= debug_to_has_forked
;
2241 current_target
.to_has_vforked
= debug_to_has_vforked
;
2242 current_target
.to_can_follow_vfork_prior_to_exec
= debug_to_can_follow_vfork_prior_to_exec
;
2243 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2244 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2245 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2246 current_target
.to_has_execd
= debug_to_has_execd
;
2247 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2248 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2249 current_target
.to_has_exited
= debug_to_has_exited
;
2250 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2251 current_target
.to_can_run
= debug_to_can_run
;
2252 current_target
.to_notice_signals
= debug_to_notice_signals
;
2253 current_target
.to_thread_alive
= debug_to_thread_alive
;
2254 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2255 current_target
.to_stop
= debug_to_stop
;
2256 current_target
.to_query
= debug_to_query
;
2257 current_target
.to_rcmd
= debug_to_rcmd
;
2258 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2259 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2260 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2265 static char targ_desc
[] =
2266 "Names of targets and files being debugged.\n\
2267 Shows the entire stack of targets currently in use (including the exec-file,\n\
2268 core-file, and process, if any), as well as the symbol file name.";
2271 do_monitor_command (char *cmd
,
2274 if ((current_target
.to_rcmd
2275 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2276 || (current_target
.to_rcmd
== debug_to_rcmd
2277 && (debug_target
.to_rcmd
2278 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2280 error ("\"monitor\" command not supported by this target.\n");
2282 target_rcmd (cmd
, gdb_stdtarg
);
2286 initialize_targets (void)
2288 init_dummy_target ();
2289 push_target (&dummy_target
);
2291 add_info ("target", target_info
, targ_desc
);
2292 add_info ("files", target_info
, targ_desc
);
2295 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2296 (char *) &targetdebug
,
2297 "Set target debugging.\n\
2298 When non-zero, target debugging is enabled.", &setdebuglist
),
2301 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2303 Set mode for reading from readonly sections.\n\
2304 When this mode is on, memory reads from readonly sections (such as .text)\n\
2305 will be read from the object file instead of from the target. This will\n\
2306 result in significant performance improvement for remote targets.", "\
2307 Show mode for reading from readonly sections.\n",
2309 &setlist
, &showlist
);
2311 add_com ("monitor", class_obscure
, do_monitor_command
,
2312 "Send a command to the remote monitor (remote targets only).");
2314 target_dcache
= dcache_init ();