1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Cygnus Support.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
40 static void target_info (char *, int);
42 static void cleanup_target (struct target_ops
*);
44 static void maybe_kill_then_create_inferior (char *, char *, char **);
46 static void default_clone_and_follow_inferior (int, int *);
48 static void maybe_kill_then_attach (char *, int);
50 static void kill_or_be_killed (int);
52 static void default_terminal_info (char *, int);
54 static int nosymbol (char *, CORE_ADDR
*);
56 static void tcomplain (void);
58 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
60 static int return_zero (void);
62 static int return_one (void);
64 void target_ignore (void);
66 static void target_command (char *, int);
68 static struct target_ops
*find_default_run_target (char *);
70 static void update_current_target (void);
72 static void nosupport_runtime (void);
74 static void normal_target_post_startup_inferior (int pid
);
76 /* Transfer LEN bytes between target address MEMADDR and GDB address
77 MYADDR. Returns 0 for success, errno code for failure (which
78 includes partial transfers -- if you want a more useful response to
79 partial transfers, try either target_read_memory_partial or
80 target_write_memory_partial). */
83 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
);
85 static void init_dummy_target (void);
87 static void debug_to_open (char *, int);
89 static void debug_to_close (int);
91 static void debug_to_attach (char *, int);
93 static void debug_to_detach (char *, int);
95 static void debug_to_resume (int, int, enum target_signal
);
97 static int debug_to_wait (int, struct target_waitstatus
*);
99 static void debug_to_fetch_registers (int);
101 static void debug_to_store_registers (int);
103 static void debug_to_prepare_to_store (void);
106 debug_to_xfer_memory (CORE_ADDR
, char *, int, int, struct mem_attrib
*,
107 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 (int);
139 static int debug_to_thread_alive (int);
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)
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 (*) (int, int, enum target_signal
))
369 (int (*) (int, struct target_waitstatus
*))
371 de_fault (to_post_wait
,
372 (void (*) (int, 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 (int (*) (int, char *, char *, int *))
495 (void (*) (char *, struct ui_file
*))
497 de_fault (to_enable_exception_callback
,
498 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
500 de_fault (to_get_current_exception_event
,
501 (struct exception_event_record
* (*) (void))
503 de_fault (to_pid_to_exec_file
,
506 de_fault (to_core_file_to_sym_file
,
509 de_fault (to_can_async_p
,
512 de_fault (to_is_async_p
,
516 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
521 /* Go through the target stack from top to bottom, copying over zero entries in
522 current_target. In effect, we are doing class inheritance through the
523 pushed target vectors. */
526 update_current_target (void)
528 struct target_stack_item
*item
;
529 struct target_ops
*t
;
531 /* First, reset current_target */
532 memset (¤t_target
, 0, sizeof current_target
);
534 for (item
= target_stack
; item
; item
= item
->next
)
536 t
= item
->target_ops
;
538 #define INHERIT(FIELD, TARGET) \
539 if (!current_target.FIELD) \
540 current_target.FIELD = TARGET->FIELD
542 INHERIT (to_shortname
, t
);
543 INHERIT (to_longname
, t
);
545 INHERIT (to_open
, t
);
546 INHERIT (to_close
, t
);
547 INHERIT (to_attach
, t
);
548 INHERIT (to_post_attach
, t
);
549 INHERIT (to_require_attach
, t
);
550 INHERIT (to_detach
, t
);
551 INHERIT (to_require_detach
, t
);
552 INHERIT (to_resume
, t
);
553 INHERIT (to_wait
, t
);
554 INHERIT (to_post_wait
, t
);
555 INHERIT (to_fetch_registers
, t
);
556 INHERIT (to_store_registers
, t
);
557 INHERIT (to_prepare_to_store
, t
);
558 INHERIT (to_xfer_memory
, t
);
559 INHERIT (to_files_info
, t
);
560 INHERIT (to_insert_breakpoint
, t
);
561 INHERIT (to_remove_breakpoint
, t
);
562 INHERIT (to_terminal_init
, t
);
563 INHERIT (to_terminal_inferior
, t
);
564 INHERIT (to_terminal_ours_for_output
, t
);
565 INHERIT (to_terminal_ours
, t
);
566 INHERIT (to_terminal_info
, t
);
567 INHERIT (to_kill
, t
);
568 INHERIT (to_load
, t
);
569 INHERIT (to_lookup_symbol
, t
);
570 INHERIT (to_create_inferior
, t
);
571 INHERIT (to_post_startup_inferior
, t
);
572 INHERIT (to_acknowledge_created_inferior
, t
);
573 INHERIT (to_clone_and_follow_inferior
, t
);
574 INHERIT (to_post_follow_inferior_by_clone
, t
);
575 INHERIT (to_insert_fork_catchpoint
, t
);
576 INHERIT (to_remove_fork_catchpoint
, t
);
577 INHERIT (to_insert_vfork_catchpoint
, t
);
578 INHERIT (to_remove_vfork_catchpoint
, t
);
579 INHERIT (to_has_forked
, t
);
580 INHERIT (to_has_vforked
, t
);
581 INHERIT (to_can_follow_vfork_prior_to_exec
, t
);
582 INHERIT (to_post_follow_vfork
, t
);
583 INHERIT (to_insert_exec_catchpoint
, t
);
584 INHERIT (to_remove_exec_catchpoint
, t
);
585 INHERIT (to_has_execd
, t
);
586 INHERIT (to_reported_exec_events_per_exec_call
, t
);
587 INHERIT (to_has_syscall_event
, t
);
588 INHERIT (to_has_exited
, t
);
589 INHERIT (to_mourn_inferior
, t
);
590 INHERIT (to_can_run
, t
);
591 INHERIT (to_notice_signals
, t
);
592 INHERIT (to_thread_alive
, t
);
593 INHERIT (to_find_new_threads
, t
);
594 INHERIT (to_pid_to_str
, t
);
595 INHERIT (to_extra_thread_info
, t
);
596 INHERIT (to_stop
, t
);
597 INHERIT (to_query
, t
);
598 INHERIT (to_rcmd
, t
);
599 INHERIT (to_enable_exception_callback
, t
);
600 INHERIT (to_get_current_exception_event
, t
);
601 INHERIT (to_pid_to_exec_file
, t
);
602 INHERIT (to_core_file_to_sym_file
, t
);
603 INHERIT (to_stratum
, t
);
604 INHERIT (DONT_USE
, t
);
605 INHERIT (to_has_all_memory
, t
);
606 INHERIT (to_has_memory
, t
);
607 INHERIT (to_has_stack
, t
);
608 INHERIT (to_has_registers
, t
);
609 INHERIT (to_has_execution
, t
);
610 INHERIT (to_has_thread_control
, t
);
611 INHERIT (to_sections
, t
);
612 INHERIT (to_sections_end
, t
);
613 INHERIT (to_can_async_p
, t
);
614 INHERIT (to_is_async_p
, t
);
615 INHERIT (to_async
, t
);
616 INHERIT (to_async_mask_value
, t
);
617 INHERIT (to_magic
, t
);
623 /* Push a new target type into the stack of the existing target accessors,
624 possibly superseding some of the existing accessors.
626 Result is zero if the pushed target ended up on top of the stack,
627 nonzero if at least one target is on top of it.
629 Rather than allow an empty stack, we always have the dummy target at
630 the bottom stratum, so we can call the function vectors without
634 push_target (struct target_ops
*t
)
636 struct target_stack_item
*cur
, *prev
, *tmp
;
638 /* Check magic number. If wrong, it probably means someone changed
639 the struct definition, but not all the places that initialize one. */
640 if (t
->to_magic
!= OPS_MAGIC
)
642 fprintf_unfiltered (gdb_stderr
,
643 "Magic number of %s target struct wrong\n",
645 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
648 /* Find the proper stratum to install this target in. */
650 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
652 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
656 /* If there's already targets at this stratum, remove them. */
659 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
661 /* There's already something on this stratum. Close it off. */
662 if (cur
->target_ops
->to_close
)
663 (cur
->target_ops
->to_close
) (0);
665 prev
->next
= cur
->next
; /* Unchain old target_ops */
667 target_stack
= cur
->next
; /* Unchain first on list */
673 /* We have removed all targets in our stratum, now add the new one. */
675 tmp
= (struct target_stack_item
*)
676 xmalloc (sizeof (struct target_stack_item
));
685 update_current_target ();
687 cleanup_target (¤t_target
); /* Fill in the gaps */
690 setup_target_debug ();
695 /* Remove a target_ops vector from the stack, wherever it may be.
696 Return how many times it was removed (0 or 1). */
699 unpush_target (struct target_ops
*t
)
701 struct target_stack_item
*cur
, *prev
;
704 t
->to_close (0); /* Let it clean up */
706 /* Look for the specified target. Note that we assume that a target
707 can only occur once in the target stack. */
709 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
710 if (cur
->target_ops
== t
)
714 return 0; /* Didn't find target_ops, quit now */
716 /* Unchain the target */
719 target_stack
= cur
->next
;
721 prev
->next
= cur
->next
;
723 xfree (cur
); /* Release the target_stack_item */
725 update_current_target ();
726 cleanup_target (¤t_target
);
734 (current_target
.to_close
) (0); /* Let it clean up */
735 if (unpush_target (target_stack
->target_ops
) == 1)
738 fprintf_unfiltered (gdb_stderr
,
739 "pop_target couldn't find target %s\n",
740 current_target
.to_shortname
);
741 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
745 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
747 /* target_read_string -- read a null terminated string, up to LEN bytes,
748 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
749 Set *STRING to a pointer to malloc'd memory containing the data; the caller
750 is responsible for freeing it. Return the number of bytes successfully
754 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
756 int tlen
, origlen
, offset
, i
;
760 int buffer_allocated
;
762 unsigned int nbytes_read
= 0;
764 /* Small for testing. */
765 buffer_allocated
= 4;
766 buffer
= xmalloc (buffer_allocated
);
773 tlen
= MIN (len
, 4 - (memaddr
& 3));
774 offset
= memaddr
& 3;
776 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
779 /* The transfer request might have crossed the boundary to an
780 unallocated region of memory. Retry the transfer, requesting
784 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
789 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
792 bytes
= bufptr
- buffer
;
793 buffer_allocated
*= 2;
794 buffer
= xrealloc (buffer
, buffer_allocated
);
795 bufptr
= buffer
+ bytes
;
798 for (i
= 0; i
< tlen
; i
++)
800 *bufptr
++ = buf
[i
+ offset
];
801 if (buf
[i
+ offset
] == '\000')
803 nbytes_read
+= i
+ 1;
820 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
821 GDB's memory at MYADDR. Returns either 0 for success or an errno value
824 If an error occurs, no guarantee is made about the contents of the data at
825 MYADDR. In particular, the caller should not depend upon partial reads
826 filling the buffer with good data. There is no way for the caller to know
827 how much good data might have been transfered anyway. Callers that can
828 deal with partial reads should call target_read_memory_partial. */
831 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
833 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
837 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
839 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
842 /* Move memory to or from the targets. The top target gets priority;
843 if it cannot handle it, it is offered to the next one down, etc.
845 Result is -1 on error, or the number of bytes transfered. */
848 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
849 struct mem_attrib
*attrib
)
853 struct target_ops
*t
;
854 struct target_stack_item
*item
;
856 /* Zero length requests are ok and require no work. */
860 /* to_xfer_memory is not guaranteed to set errno, even when it returns
864 /* The quick case is that the top target can handle the transfer. */
865 res
= current_target
.to_xfer_memory
866 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
868 /* If res <= 0 then we call it again in the loop. Ah well. */
871 for (item
= target_stack
; item
; item
= item
->next
)
873 t
= item
->target_ops
;
874 if (!t
->to_has_memory
)
877 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
879 break; /* Handled all or part of xfer */
880 if (t
->to_has_all_memory
)
892 /* Perform a memory transfer. Iterate until the entire region has
895 Result is 0 or errno value. */
898 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
902 struct mem_region
*region
;
904 /* Zero length requests are ok and require no work. */
912 region
= lookup_mem_region(memaddr
);
913 if (memaddr
+ len
< region
->hi
)
916 reg_len
= region
->hi
- memaddr
;
918 switch (region
->attrib
.mode
)
933 if (region
->attrib
.cache
)
934 res
= dcache_xfer_memory(target_dcache
, memaddr
, myaddr
,
937 res
= do_xfer_memory(memaddr
, myaddr
, reg_len
, write
,
942 /* If this address is for nonexistent memory, read zeros
943 if reading, or do nothing if writing. Return
946 memset (myaddr
, 0, len
);
960 return 0; /* We managed to cover it all somehow. */
964 /* Perform a partial memory transfer.
966 Result is -1 on error, or the number of bytes transfered. */
969 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
970 int write_p
, int *err
)
974 struct mem_region
*region
;
976 /* Zero length requests are ok and require no work. */
983 region
= lookup_mem_region(memaddr
);
984 if (memaddr
+ len
< region
->hi
)
987 reg_len
= region
->hi
- memaddr
;
989 switch (region
->attrib
.mode
)
1008 if (region
->attrib
.cache
)
1009 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1012 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1030 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1032 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1036 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1038 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1043 target_info (char *args
, int from_tty
)
1045 struct target_ops
*t
;
1046 struct target_stack_item
*item
;
1047 int has_all_mem
= 0;
1049 if (symfile_objfile
!= NULL
)
1050 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1052 #ifdef FILES_INFO_HOOK
1053 if (FILES_INFO_HOOK ())
1057 for (item
= target_stack
; item
; item
= item
->next
)
1059 t
= item
->target_ops
;
1061 if (!t
->to_has_memory
)
1064 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1067 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1068 printf_unfiltered ("%s:\n", t
->to_longname
);
1069 (t
->to_files_info
) (t
);
1070 has_all_mem
= t
->to_has_all_memory
;
1074 /* This is to be called by the open routine before it does
1078 target_preopen (int from_tty
)
1082 if (target_has_execution
)
1085 || query ("A program is being debugged already. Kill it? "))
1088 error ("Program not killed.");
1091 /* Calling target_kill may remove the target from the stack. But if
1092 it doesn't (which seems like a win for UDI), remove it now. */
1094 if (target_has_execution
)
1098 /* Detach a target after doing deferred register stores. */
1101 target_detach (char *args
, int from_tty
)
1103 /* Handle any optimized stores to the inferior. */
1104 #ifdef DO_DEFERRED_STORES
1107 (current_target
.to_detach
) (args
, from_tty
);
1111 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1113 if (STREQ (current_target
.to_shortname
, "rombug"))
1115 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1117 error ("Unable to link to %s and get relocation in rombug", modname
);
1120 *t_reloc
= (CORE_ADDR
) -1;
1124 target_async_mask (int mask
)
1126 int saved_async_masked_status
= target_async_mask_value
;
1127 target_async_mask_value
= mask
;
1128 return saved_async_masked_status
;
1131 /* Look through the list of possible targets for a target that can
1132 execute a run or attach command without any other data. This is
1133 used to locate the default process stratum.
1135 Result is always valid (error() is called for errors). */
1137 static struct target_ops
*
1138 find_default_run_target (char *do_mesg
)
1140 struct target_ops
**t
;
1141 struct target_ops
*runable
= NULL
;
1146 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1149 if ((*t
)->to_can_run
&& target_can_run (*t
))
1157 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1163 find_default_attach (char *args
, int from_tty
)
1165 struct target_ops
*t
;
1167 t
= find_default_run_target ("attach");
1168 (t
->to_attach
) (args
, from_tty
);
1173 find_default_require_attach (char *args
, int from_tty
)
1175 struct target_ops
*t
;
1177 t
= find_default_run_target ("require_attach");
1178 (t
->to_require_attach
) (args
, from_tty
);
1183 find_default_require_detach (int pid
, char *args
, int from_tty
)
1185 struct target_ops
*t
;
1187 t
= find_default_run_target ("require_detach");
1188 (t
->to_require_detach
) (pid
, args
, from_tty
);
1193 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1195 struct target_ops
*t
;
1197 t
= find_default_run_target ("run");
1198 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1203 find_default_clone_and_follow_inferior (int child_pid
, int *followed_child
)
1205 struct target_ops
*t
;
1207 t
= find_default_run_target ("run");
1208 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1225 * Resize the to_sections pointer. Also make sure that anyone that
1226 * was holding on to an old value of it gets updated.
1227 * Returns the old size.
1231 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1233 struct target_ops
**t
;
1234 struct section_table
*old_value
;
1237 old_value
= target
->to_sections
;
1239 if (target
->to_sections
)
1241 old_count
= target
->to_sections_end
- target
->to_sections
;
1242 target
->to_sections
= (struct section_table
*)
1243 xrealloc ((char *) target
->to_sections
,
1244 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1249 target
->to_sections
= (struct section_table
*)
1250 xmalloc ((sizeof (struct section_table
)) * num_added
);
1252 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1254 /* Check to see if anyone else was pointing to this structure.
1255 If old_value was null, then no one was. */
1259 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1262 if ((*t
)->to_sections
== old_value
)
1264 (*t
)->to_sections
= target
->to_sections
;
1265 (*t
)->to_sections_end
= target
->to_sections_end
;
1274 /* Remove all target sections taken from ABFD.
1276 Scan the current target stack for targets whose section tables
1277 refer to sections from BFD, and remove those sections. We use this
1278 when we notice that the inferior has unloaded a shared object, for
1281 remove_target_sections (bfd
*abfd
)
1283 struct target_ops
**t
;
1285 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1287 struct section_table
*src
, *dest
;
1289 dest
= (*t
)->to_sections
;
1290 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1291 if (src
->bfd
!= abfd
)
1293 /* Keep this section. */
1294 if (dest
< src
) *dest
= *src
;
1298 /* If we've dropped any sections, resize the section table. */
1300 target_resize_to_sections (*t
, dest
- src
);
1307 /* Find a single runnable target in the stack and return it. If for
1308 some reason there is more than one, return NULL. */
1311 find_run_target (void)
1313 struct target_ops
**t
;
1314 struct target_ops
*runable
= NULL
;
1319 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1321 if ((*t
)->to_can_run
&& target_can_run (*t
))
1328 return (count
== 1 ? runable
: NULL
);
1331 /* Find a single core_stratum target in the list of targets and return it.
1332 If for some reason there is more than one, return NULL. */
1335 find_core_target (void)
1337 struct target_ops
**t
;
1338 struct target_ops
*runable
= NULL
;
1343 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1346 if ((*t
)->to_stratum
== core_stratum
)
1353 return (count
== 1 ? runable
: NULL
);
1357 * Find the next target down the stack from the specified target.
1361 find_target_beneath (struct target_ops
*t
)
1363 struct target_stack_item
*cur
;
1365 for (cur
= target_stack
; cur
; cur
= cur
->next
)
1366 if (cur
->target_ops
== t
)
1369 if (cur
== NULL
|| cur
->next
== NULL
)
1372 return cur
->next
->target_ops
;
1376 /* The inferior process has died. Long live the inferior! */
1379 generic_mourn_inferior (void)
1381 extern int show_breakpoint_hit_counts
;
1385 breakpoint_init_inferior (inf_exited
);
1386 registers_changed ();
1388 #ifdef CLEAR_DEFERRED_STORES
1389 /* Delete any pending stores to the inferior... */
1390 CLEAR_DEFERRED_STORES
;
1393 reopen_exec_file ();
1394 reinit_frame_cache ();
1396 /* It is confusing to the user for ignore counts to stick around
1397 from previous runs of the inferior. So clear them. */
1398 /* However, it is more confusing for the ignore counts to disappear when
1399 using hit counts. So don't clear them if we're counting hits. */
1400 if (!show_breakpoint_hit_counts
)
1401 breakpoint_clear_ignore_counts ();
1407 /* This table must match in order and size the signals in enum target_signal
1416 {"SIGHUP", "Hangup"},
1417 {"SIGINT", "Interrupt"},
1418 {"SIGQUIT", "Quit"},
1419 {"SIGILL", "Illegal instruction"},
1420 {"SIGTRAP", "Trace/breakpoint trap"},
1421 {"SIGABRT", "Aborted"},
1422 {"SIGEMT", "Emulation trap"},
1423 {"SIGFPE", "Arithmetic exception"},
1424 {"SIGKILL", "Killed"},
1425 {"SIGBUS", "Bus error"},
1426 {"SIGSEGV", "Segmentation fault"},
1427 {"SIGSYS", "Bad system call"},
1428 {"SIGPIPE", "Broken pipe"},
1429 {"SIGALRM", "Alarm clock"},
1430 {"SIGTERM", "Terminated"},
1431 {"SIGURG", "Urgent I/O condition"},
1432 {"SIGSTOP", "Stopped (signal)"},
1433 {"SIGTSTP", "Stopped (user)"},
1434 {"SIGCONT", "Continued"},
1435 {"SIGCHLD", "Child status changed"},
1436 {"SIGTTIN", "Stopped (tty input)"},
1437 {"SIGTTOU", "Stopped (tty output)"},
1438 {"SIGIO", "I/O possible"},
1439 {"SIGXCPU", "CPU time limit exceeded"},
1440 {"SIGXFSZ", "File size limit exceeded"},
1441 {"SIGVTALRM", "Virtual timer expired"},
1442 {"SIGPROF", "Profiling timer expired"},
1443 {"SIGWINCH", "Window size changed"},
1444 {"SIGLOST", "Resource lost"},
1445 {"SIGUSR1", "User defined signal 1"},
1446 {"SIGUSR2", "User defined signal 2"},
1447 {"SIGPWR", "Power fail/restart"},
1448 {"SIGPOLL", "Pollable event occurred"},
1449 {"SIGWIND", "SIGWIND"},
1450 {"SIGPHONE", "SIGPHONE"},
1451 {"SIGWAITING", "Process's LWPs are blocked"},
1452 {"SIGLWP", "Signal LWP"},
1453 {"SIGDANGER", "Swap space dangerously low"},
1454 {"SIGGRANT", "Monitor mode granted"},
1455 {"SIGRETRACT", "Need to relinquish monitor mode"},
1456 {"SIGMSG", "Monitor mode data available"},
1457 {"SIGSOUND", "Sound completed"},
1458 {"SIGSAK", "Secure attention"},
1459 {"SIGPRIO", "SIGPRIO"},
1460 {"SIG33", "Real-time event 33"},
1461 {"SIG34", "Real-time event 34"},
1462 {"SIG35", "Real-time event 35"},
1463 {"SIG36", "Real-time event 36"},
1464 {"SIG37", "Real-time event 37"},
1465 {"SIG38", "Real-time event 38"},
1466 {"SIG39", "Real-time event 39"},
1467 {"SIG40", "Real-time event 40"},
1468 {"SIG41", "Real-time event 41"},
1469 {"SIG42", "Real-time event 42"},
1470 {"SIG43", "Real-time event 43"},
1471 {"SIG44", "Real-time event 44"},
1472 {"SIG45", "Real-time event 45"},
1473 {"SIG46", "Real-time event 46"},
1474 {"SIG47", "Real-time event 47"},
1475 {"SIG48", "Real-time event 48"},
1476 {"SIG49", "Real-time event 49"},
1477 {"SIG50", "Real-time event 50"},
1478 {"SIG51", "Real-time event 51"},
1479 {"SIG52", "Real-time event 52"},
1480 {"SIG53", "Real-time event 53"},
1481 {"SIG54", "Real-time event 54"},
1482 {"SIG55", "Real-time event 55"},
1483 {"SIG56", "Real-time event 56"},
1484 {"SIG57", "Real-time event 57"},
1485 {"SIG58", "Real-time event 58"},
1486 {"SIG59", "Real-time event 59"},
1487 {"SIG60", "Real-time event 60"},
1488 {"SIG61", "Real-time event 61"},
1489 {"SIG62", "Real-time event 62"},
1490 {"SIG63", "Real-time event 63"},
1491 {"SIGCANCEL", "LWP internal signal"},
1492 {"SIG32", "Real-time event 32"},
1493 {"SIG64", "Real-time event 64"},
1495 #if defined(MACH) || defined(__MACH__)
1496 /* Mach exceptions */
1497 {"EXC_BAD_ACCESS", "Could not access memory"},
1498 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1499 {"EXC_ARITHMETIC", "Arithmetic exception"},
1500 {"EXC_EMULATION", "Emulation instruction"},
1501 {"EXC_SOFTWARE", "Software generated exception"},
1502 {"EXC_BREAKPOINT", "Breakpoint"},
1504 {"SIGINFO", "Information request"},
1506 {NULL
, "Unknown signal"},
1507 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1509 /* Last entry, used to check whether the table is the right size. */
1510 {NULL
, "TARGET_SIGNAL_MAGIC"}
1516 /* Return the string for a signal. */
1518 target_signal_to_string (enum target_signal sig
)
1520 if ((sig
>= TARGET_SIGNAL_FIRST
) && (sig
<= TARGET_SIGNAL_LAST
))
1521 return signals
[sig
].string
;
1523 return signals
[TARGET_SIGNAL_UNKNOWN
].string
;
1526 /* Return the name for a signal. */
1528 target_signal_to_name (enum target_signal sig
)
1530 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1531 /* I think the code which prints this will always print it along with
1532 the string, so no need to be verbose. */
1534 return signals
[sig
].name
;
1537 /* Given a name, return its signal. */
1539 target_signal_from_name (char *name
)
1541 enum target_signal sig
;
1543 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1544 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1545 questionable; seems like by now people should call it SIGABRT
1548 /* This ugly cast brought to you by the native VAX compiler. */
1549 for (sig
= TARGET_SIGNAL_HUP
;
1550 signals
[sig
].name
!= NULL
;
1551 sig
= (enum target_signal
) ((int) sig
+ 1))
1552 if (STREQ (name
, signals
[sig
].name
))
1554 return TARGET_SIGNAL_UNKNOWN
;
1557 /* The following functions are to help certain targets deal
1558 with the signal/waitstatus stuff. They could just as well be in
1559 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1561 /* Convert host signal to our signals. */
1563 target_signal_from_host (int hostsig
)
1565 /* A switch statement would make sense but would require special kludges
1566 to deal with the cases where more than one signal has the same number. */
1569 return TARGET_SIGNAL_0
;
1571 #if defined (SIGHUP)
1572 if (hostsig
== SIGHUP
)
1573 return TARGET_SIGNAL_HUP
;
1575 #if defined (SIGINT)
1576 if (hostsig
== SIGINT
)
1577 return TARGET_SIGNAL_INT
;
1579 #if defined (SIGQUIT)
1580 if (hostsig
== SIGQUIT
)
1581 return TARGET_SIGNAL_QUIT
;
1583 #if defined (SIGILL)
1584 if (hostsig
== SIGILL
)
1585 return TARGET_SIGNAL_ILL
;
1587 #if defined (SIGTRAP)
1588 if (hostsig
== SIGTRAP
)
1589 return TARGET_SIGNAL_TRAP
;
1591 #if defined (SIGABRT)
1592 if (hostsig
== SIGABRT
)
1593 return TARGET_SIGNAL_ABRT
;
1595 #if defined (SIGEMT)
1596 if (hostsig
== SIGEMT
)
1597 return TARGET_SIGNAL_EMT
;
1599 #if defined (SIGFPE)
1600 if (hostsig
== SIGFPE
)
1601 return TARGET_SIGNAL_FPE
;
1603 #if defined (SIGKILL)
1604 if (hostsig
== SIGKILL
)
1605 return TARGET_SIGNAL_KILL
;
1607 #if defined (SIGBUS)
1608 if (hostsig
== SIGBUS
)
1609 return TARGET_SIGNAL_BUS
;
1611 #if defined (SIGSEGV)
1612 if (hostsig
== SIGSEGV
)
1613 return TARGET_SIGNAL_SEGV
;
1615 #if defined (SIGSYS)
1616 if (hostsig
== SIGSYS
)
1617 return TARGET_SIGNAL_SYS
;
1619 #if defined (SIGPIPE)
1620 if (hostsig
== SIGPIPE
)
1621 return TARGET_SIGNAL_PIPE
;
1623 #if defined (SIGALRM)
1624 if (hostsig
== SIGALRM
)
1625 return TARGET_SIGNAL_ALRM
;
1627 #if defined (SIGTERM)
1628 if (hostsig
== SIGTERM
)
1629 return TARGET_SIGNAL_TERM
;
1631 #if defined (SIGUSR1)
1632 if (hostsig
== SIGUSR1
)
1633 return TARGET_SIGNAL_USR1
;
1635 #if defined (SIGUSR2)
1636 if (hostsig
== SIGUSR2
)
1637 return TARGET_SIGNAL_USR2
;
1639 #if defined (SIGCLD)
1640 if (hostsig
== SIGCLD
)
1641 return TARGET_SIGNAL_CHLD
;
1643 #if defined (SIGCHLD)
1644 if (hostsig
== SIGCHLD
)
1645 return TARGET_SIGNAL_CHLD
;
1647 #if defined (SIGPWR)
1648 if (hostsig
== SIGPWR
)
1649 return TARGET_SIGNAL_PWR
;
1651 #if defined (SIGWINCH)
1652 if (hostsig
== SIGWINCH
)
1653 return TARGET_SIGNAL_WINCH
;
1655 #if defined (SIGURG)
1656 if (hostsig
== SIGURG
)
1657 return TARGET_SIGNAL_URG
;
1660 if (hostsig
== SIGIO
)
1661 return TARGET_SIGNAL_IO
;
1663 #if defined (SIGPOLL)
1664 if (hostsig
== SIGPOLL
)
1665 return TARGET_SIGNAL_POLL
;
1667 #if defined (SIGSTOP)
1668 if (hostsig
== SIGSTOP
)
1669 return TARGET_SIGNAL_STOP
;
1671 #if defined (SIGTSTP)
1672 if (hostsig
== SIGTSTP
)
1673 return TARGET_SIGNAL_TSTP
;
1675 #if defined (SIGCONT)
1676 if (hostsig
== SIGCONT
)
1677 return TARGET_SIGNAL_CONT
;
1679 #if defined (SIGTTIN)
1680 if (hostsig
== SIGTTIN
)
1681 return TARGET_SIGNAL_TTIN
;
1683 #if defined (SIGTTOU)
1684 if (hostsig
== SIGTTOU
)
1685 return TARGET_SIGNAL_TTOU
;
1687 #if defined (SIGVTALRM)
1688 if (hostsig
== SIGVTALRM
)
1689 return TARGET_SIGNAL_VTALRM
;
1691 #if defined (SIGPROF)
1692 if (hostsig
== SIGPROF
)
1693 return TARGET_SIGNAL_PROF
;
1695 #if defined (SIGXCPU)
1696 if (hostsig
== SIGXCPU
)
1697 return TARGET_SIGNAL_XCPU
;
1699 #if defined (SIGXFSZ)
1700 if (hostsig
== SIGXFSZ
)
1701 return TARGET_SIGNAL_XFSZ
;
1703 #if defined (SIGWIND)
1704 if (hostsig
== SIGWIND
)
1705 return TARGET_SIGNAL_WIND
;
1707 #if defined (SIGPHONE)
1708 if (hostsig
== SIGPHONE
)
1709 return TARGET_SIGNAL_PHONE
;
1711 #if defined (SIGLOST)
1712 if (hostsig
== SIGLOST
)
1713 return TARGET_SIGNAL_LOST
;
1715 #if defined (SIGWAITING)
1716 if (hostsig
== SIGWAITING
)
1717 return TARGET_SIGNAL_WAITING
;
1719 #if defined (SIGCANCEL)
1720 if (hostsig
== SIGCANCEL
)
1721 return TARGET_SIGNAL_CANCEL
;
1723 #if defined (SIGLWP)
1724 if (hostsig
== SIGLWP
)
1725 return TARGET_SIGNAL_LWP
;
1727 #if defined (SIGDANGER)
1728 if (hostsig
== SIGDANGER
)
1729 return TARGET_SIGNAL_DANGER
;
1731 #if defined (SIGGRANT)
1732 if (hostsig
== SIGGRANT
)
1733 return TARGET_SIGNAL_GRANT
;
1735 #if defined (SIGRETRACT)
1736 if (hostsig
== SIGRETRACT
)
1737 return TARGET_SIGNAL_RETRACT
;
1739 #if defined (SIGMSG)
1740 if (hostsig
== SIGMSG
)
1741 return TARGET_SIGNAL_MSG
;
1743 #if defined (SIGSOUND)
1744 if (hostsig
== SIGSOUND
)
1745 return TARGET_SIGNAL_SOUND
;
1747 #if defined (SIGSAK)
1748 if (hostsig
== SIGSAK
)
1749 return TARGET_SIGNAL_SAK
;
1751 #if defined (SIGPRIO)
1752 if (hostsig
== SIGPRIO
)
1753 return TARGET_SIGNAL_PRIO
;
1756 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1757 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1758 if (hostsig
== _NSIG
+ EXC_BAD_ACCESS
)
1759 return TARGET_EXC_BAD_ACCESS
;
1761 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1762 if (hostsig
== _NSIG
+ EXC_BAD_INSTRUCTION
)
1763 return TARGET_EXC_BAD_INSTRUCTION
;
1765 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1766 if (hostsig
== _NSIG
+ EXC_ARITHMETIC
)
1767 return TARGET_EXC_ARITHMETIC
;
1769 #if defined (EXC_EMULATION) && defined (_NSIG)
1770 if (hostsig
== _NSIG
+ EXC_EMULATION
)
1771 return TARGET_EXC_EMULATION
;
1773 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1774 if (hostsig
== _NSIG
+ EXC_SOFTWARE
)
1775 return TARGET_EXC_SOFTWARE
;
1777 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1778 if (hostsig
== _NSIG
+ EXC_BREAKPOINT
)
1779 return TARGET_EXC_BREAKPOINT
;
1782 #if defined (SIGINFO)
1783 if (hostsig
== SIGINFO
)
1784 return TARGET_SIGNAL_INFO
;
1787 #if defined (REALTIME_LO)
1788 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1790 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
1791 if (33 <= hostsig
&& hostsig
<= 63)
1792 return (enum target_signal
)
1793 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1794 else if (hostsig
== 32)
1795 return TARGET_SIGNAL_REALTIME_32
;
1797 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
1801 #if defined (SIGRTMIN)
1802 if (hostsig
>= SIGRTMIN
&& hostsig
<= SIGRTMAX
)
1804 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
1805 if (33 <= hostsig
&& hostsig
<= 63)
1806 return (enum target_signal
)
1807 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1808 else if (hostsig
== 64)
1809 return TARGET_SIGNAL_REALTIME_64
;
1811 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
1814 return TARGET_SIGNAL_UNKNOWN
;
1817 /* Convert a OURSIG (an enum target_signal) to the form used by the
1818 target operating system (refered to as the ``host'') or zero if the
1819 equivalent host signal is not available. Set/clear OURSIG_OK
1823 do_target_signal_to_host (enum target_signal oursig
,
1829 case TARGET_SIGNAL_0
:
1832 #if defined (SIGHUP)
1833 case TARGET_SIGNAL_HUP
:
1836 #if defined (SIGINT)
1837 case TARGET_SIGNAL_INT
:
1840 #if defined (SIGQUIT)
1841 case TARGET_SIGNAL_QUIT
:
1844 #if defined (SIGILL)
1845 case TARGET_SIGNAL_ILL
:
1848 #if defined (SIGTRAP)
1849 case TARGET_SIGNAL_TRAP
:
1852 #if defined (SIGABRT)
1853 case TARGET_SIGNAL_ABRT
:
1856 #if defined (SIGEMT)
1857 case TARGET_SIGNAL_EMT
:
1860 #if defined (SIGFPE)
1861 case TARGET_SIGNAL_FPE
:
1864 #if defined (SIGKILL)
1865 case TARGET_SIGNAL_KILL
:
1868 #if defined (SIGBUS)
1869 case TARGET_SIGNAL_BUS
:
1872 #if defined (SIGSEGV)
1873 case TARGET_SIGNAL_SEGV
:
1876 #if defined (SIGSYS)
1877 case TARGET_SIGNAL_SYS
:
1880 #if defined (SIGPIPE)
1881 case TARGET_SIGNAL_PIPE
:
1884 #if defined (SIGALRM)
1885 case TARGET_SIGNAL_ALRM
:
1888 #if defined (SIGTERM)
1889 case TARGET_SIGNAL_TERM
:
1892 #if defined (SIGUSR1)
1893 case TARGET_SIGNAL_USR1
:
1896 #if defined (SIGUSR2)
1897 case TARGET_SIGNAL_USR2
:
1900 #if defined (SIGCHLD) || defined (SIGCLD)
1901 case TARGET_SIGNAL_CHLD
:
1902 #if defined (SIGCHLD)
1907 #endif /* SIGCLD or SIGCHLD */
1908 #if defined (SIGPWR)
1909 case TARGET_SIGNAL_PWR
:
1912 #if defined (SIGWINCH)
1913 case TARGET_SIGNAL_WINCH
:
1916 #if defined (SIGURG)
1917 case TARGET_SIGNAL_URG
:
1921 case TARGET_SIGNAL_IO
:
1924 #if defined (SIGPOLL)
1925 case TARGET_SIGNAL_POLL
:
1928 #if defined (SIGSTOP)
1929 case TARGET_SIGNAL_STOP
:
1932 #if defined (SIGTSTP)
1933 case TARGET_SIGNAL_TSTP
:
1936 #if defined (SIGCONT)
1937 case TARGET_SIGNAL_CONT
:
1940 #if defined (SIGTTIN)
1941 case TARGET_SIGNAL_TTIN
:
1944 #if defined (SIGTTOU)
1945 case TARGET_SIGNAL_TTOU
:
1948 #if defined (SIGVTALRM)
1949 case TARGET_SIGNAL_VTALRM
:
1952 #if defined (SIGPROF)
1953 case TARGET_SIGNAL_PROF
:
1956 #if defined (SIGXCPU)
1957 case TARGET_SIGNAL_XCPU
:
1960 #if defined (SIGXFSZ)
1961 case TARGET_SIGNAL_XFSZ
:
1964 #if defined (SIGWIND)
1965 case TARGET_SIGNAL_WIND
:
1968 #if defined (SIGPHONE)
1969 case TARGET_SIGNAL_PHONE
:
1972 #if defined (SIGLOST)
1973 case TARGET_SIGNAL_LOST
:
1976 #if defined (SIGWAITING)
1977 case TARGET_SIGNAL_WAITING
:
1980 #if defined (SIGCANCEL)
1981 case TARGET_SIGNAL_CANCEL
:
1984 #if defined (SIGLWP)
1985 case TARGET_SIGNAL_LWP
:
1988 #if defined (SIGDANGER)
1989 case TARGET_SIGNAL_DANGER
:
1992 #if defined (SIGGRANT)
1993 case TARGET_SIGNAL_GRANT
:
1996 #if defined (SIGRETRACT)
1997 case TARGET_SIGNAL_RETRACT
:
2000 #if defined (SIGMSG)
2001 case TARGET_SIGNAL_MSG
:
2004 #if defined (SIGSOUND)
2005 case TARGET_SIGNAL_SOUND
:
2008 #if defined (SIGSAK)
2009 case TARGET_SIGNAL_SAK
:
2012 #if defined (SIGPRIO)
2013 case TARGET_SIGNAL_PRIO
:
2017 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
2018 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
2019 case TARGET_EXC_BAD_ACCESS
:
2020 return _NSIG
+ EXC_BAD_ACCESS
;
2022 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
2023 case TARGET_EXC_BAD_INSTRUCTION
:
2024 return _NSIG
+ EXC_BAD_INSTRUCTION
;
2026 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
2027 case TARGET_EXC_ARITHMETIC
:
2028 return _NSIG
+ EXC_ARITHMETIC
;
2030 #if defined (EXC_EMULATION) && defined (_NSIG)
2031 case TARGET_EXC_EMULATION
:
2032 return _NSIG
+ EXC_EMULATION
;
2034 #if defined (EXC_SOFTWARE) && defined (_NSIG)
2035 case TARGET_EXC_SOFTWARE
:
2036 return _NSIG
+ EXC_SOFTWARE
;
2038 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
2039 case TARGET_EXC_BREAKPOINT
:
2040 return _NSIG
+ EXC_BREAKPOINT
;
2043 #if defined (SIGINFO)
2044 case TARGET_SIGNAL_INFO
:
2049 #if defined (REALTIME_LO)
2050 if (oursig
>= TARGET_SIGNAL_REALTIME_33
2051 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
2053 /* This block of signals is continuous, and
2054 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
2056 (int) oursig
- (int) TARGET_SIGNAL_REALTIME_33
+ 33;
2057 if (retsig
>= REALTIME_LO
&& retsig
< REALTIME_HI
)
2060 #if (REALTIME_LO < 33)
2061 else if (oursig
== TARGET_SIGNAL_REALTIME_32
)
2063 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
2064 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */
2070 #if defined (SIGRTMIN)
2071 if (oursig
>= TARGET_SIGNAL_REALTIME_33
2072 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
2074 /* This block of signals is continuous, and
2075 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
2077 (int) oursig
- (int) TARGET_SIGNAL_REALTIME_33
+ 33;
2078 if (retsig
>= SIGRTMIN
&& retsig
<= SIGRTMAX
)
2081 else if (oursig
== TARGET_SIGNAL_REALTIME_64
)
2090 target_signal_to_host_p (enum target_signal oursig
)
2093 do_target_signal_to_host (oursig
, &oursig_ok
);
2098 target_signal_to_host (enum target_signal oursig
)
2101 int targ_signo
= do_target_signal_to_host (oursig
, &oursig_ok
);
2104 /* The user might be trying to do "signal SIGSAK" where this system
2105 doesn't have SIGSAK. */
2106 warning ("Signal %s does not exist on this system.\n",
2107 target_signal_to_name (oursig
));
2114 /* Helper function for child_wait and the Lynx derivatives of child_wait.
2115 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2116 translation of that in OURSTATUS. */
2118 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
2120 #ifdef CHILD_SPECIAL_WAITSTATUS
2121 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
2122 if it wants to deal with hoststatus. */
2123 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
2127 if (WIFEXITED (hoststatus
))
2129 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
2130 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
2132 else if (!WIFSTOPPED (hoststatus
))
2134 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
2135 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
2139 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
2140 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
2144 /* In some circumstances we allow a command to specify a numeric
2145 signal. The idea is to keep these circumstances limited so that
2146 users (and scripts) develop portable habits. For comparison,
2147 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
2148 numeric signal at all is obsolescent. We are slightly more
2149 lenient and allow 1-15 which should match host signal numbers on
2150 most systems. Use of symbolic signal names is strongly encouraged. */
2153 target_signal_from_command (int num
)
2155 if (num
>= 1 && num
<= 15)
2156 return (enum target_signal
) num
;
2157 error ("Only signals 1-15 are valid as numeric signals.\n\
2158 Use \"info signals\" for a list of symbolic signals.");
2161 /* Returns zero to leave the inferior alone, one to interrupt it. */
2162 int (*target_activity_function
) (void);
2163 int target_activity_fd
;
2165 /* Convert a normal process ID to a string. Returns the string in a static
2169 normal_pid_to_str (int pid
)
2171 static char buf
[30];
2173 if (STREQ (current_target
.to_shortname
, "remote"))
2174 sprintf (buf
, "thread %d", pid
);
2176 sprintf (buf
, "process %d", pid
);
2181 /* Some targets (such as ttrace-based HPUX) don't allow us to request
2182 notification of inferior events such as fork and vork immediately
2183 after the inferior is created. (This because of how gdb gets an
2184 inferior created via invoking a shell to do it. In such a scenario,
2185 if the shell init file has commands in it, the shell will fork and
2186 exec for each of those commands, and we will see each such fork
2189 This function is used by all targets that allow us to request
2190 notification of forks, etc at inferior creation time; e.g., in
2191 target_acknowledge_forked_child.
2194 normal_target_post_startup_inferior (int pid
)
2196 /* This space intentionally left blank. */
2199 /* Set up the handful of non-empty slots needed by the dummy target
2203 init_dummy_target (void)
2205 dummy_target
.to_shortname
= "None";
2206 dummy_target
.to_longname
= "None";
2207 dummy_target
.to_doc
= "";
2208 dummy_target
.to_attach
= find_default_attach
;
2209 dummy_target
.to_require_attach
= find_default_require_attach
;
2210 dummy_target
.to_require_detach
= find_default_require_detach
;
2211 dummy_target
.to_create_inferior
= find_default_create_inferior
;
2212 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
2213 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
2214 dummy_target
.to_stratum
= dummy_stratum
;
2215 dummy_target
.to_magic
= OPS_MAGIC
;
2219 static struct target_ops debug_target
;
2222 debug_to_open (char *args
, int from_tty
)
2224 debug_target
.to_open (args
, from_tty
);
2226 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
2230 debug_to_close (int quitting
)
2232 debug_target
.to_close (quitting
);
2234 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
2238 debug_to_attach (char *args
, int from_tty
)
2240 debug_target
.to_attach (args
, from_tty
);
2242 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2247 debug_to_post_attach (int pid
)
2249 debug_target
.to_post_attach (pid
);
2251 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2255 debug_to_require_attach (char *args
, int from_tty
)
2257 debug_target
.to_require_attach (args
, from_tty
);
2259 fprintf_unfiltered (gdb_stdlog
,
2260 "target_require_attach (%s, %d)\n", args
, from_tty
);
2264 debug_to_detach (char *args
, int from_tty
)
2266 debug_target
.to_detach (args
, from_tty
);
2268 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2272 debug_to_require_detach (int pid
, char *args
, int from_tty
)
2274 debug_target
.to_require_detach (pid
, args
, from_tty
);
2276 fprintf_unfiltered (gdb_stdlog
,
2277 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
2281 debug_to_resume (int pid
, int step
, enum target_signal siggnal
)
2283 debug_target
.to_resume (pid
, step
, siggnal
);
2285 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", pid
,
2286 step
? "step" : "continue",
2287 target_signal_to_name (siggnal
));
2291 debug_to_wait (int pid
, struct target_waitstatus
*status
)
2295 retval
= debug_target
.to_wait (pid
, status
);
2297 fprintf_unfiltered (gdb_stdlog
,
2298 "target_wait (%d, status) = %d, ", pid
, retval
);
2299 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2300 switch (status
->kind
)
2302 case TARGET_WAITKIND_EXITED
:
2303 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2304 status
->value
.integer
);
2306 case TARGET_WAITKIND_STOPPED
:
2307 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2308 target_signal_to_name (status
->value
.sig
));
2310 case TARGET_WAITKIND_SIGNALLED
:
2311 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2312 target_signal_to_name (status
->value
.sig
));
2314 case TARGET_WAITKIND_LOADED
:
2315 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2317 case TARGET_WAITKIND_FORKED
:
2318 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2320 case TARGET_WAITKIND_VFORKED
:
2321 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2323 case TARGET_WAITKIND_EXECD
:
2324 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2326 case TARGET_WAITKIND_SPURIOUS
:
2327 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2330 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2338 debug_to_post_wait (int pid
, int status
)
2340 debug_target
.to_post_wait (pid
, status
);
2342 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
2347 debug_to_fetch_registers (int regno
)
2349 debug_target
.to_fetch_registers (regno
);
2351 fprintf_unfiltered (gdb_stdlog
, "target_fetch_registers (%s)",
2352 regno
!= -1 ? REGISTER_NAME (regno
) : "-1");
2354 fprintf_unfiltered (gdb_stdlog
, " = 0x%lx %ld",
2355 (unsigned long) read_register (regno
),
2356 (unsigned long) read_register (regno
));
2357 fprintf_unfiltered (gdb_stdlog
, "\n");
2361 debug_to_store_registers (int regno
)
2363 debug_target
.to_store_registers (regno
);
2365 if (regno
>= 0 && regno
< NUM_REGS
)
2366 fprintf_unfiltered (gdb_stdlog
, "target_store_registers (%s) = 0x%lx %ld\n",
2367 REGISTER_NAME (regno
),
2368 (unsigned long) read_register (regno
),
2369 (unsigned long) read_register (regno
));
2371 fprintf_unfiltered (gdb_stdlog
, "target_store_registers (%d)\n", regno
);
2375 debug_to_prepare_to_store (void)
2377 debug_target
.to_prepare_to_store ();
2379 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2383 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
2384 struct mem_attrib
*attrib
,
2385 struct target_ops
*target
)
2389 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
2392 fprintf_unfiltered (gdb_stdlog
,
2393 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2394 (unsigned int) memaddr
, /* possable truncate long long */
2395 len
, write
? "write" : "read", retval
);
2403 fputs_unfiltered (", bytes =", gdb_stdlog
);
2404 for (i
= 0; i
< retval
; i
++)
2406 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2407 fprintf_unfiltered (gdb_stdlog
, "\n");
2408 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2412 fputc_unfiltered ('\n', gdb_stdlog
);
2418 debug_to_files_info (struct target_ops
*target
)
2420 debug_target
.to_files_info (target
);
2422 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2426 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
2430 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2432 fprintf_unfiltered (gdb_stdlog
,
2433 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2434 (unsigned long) addr
,
2435 (unsigned long) retval
);
2440 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
2444 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2446 fprintf_unfiltered (gdb_stdlog
,
2447 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2448 (unsigned long) addr
,
2449 (unsigned long) retval
);
2454 debug_to_terminal_init (void)
2456 debug_target
.to_terminal_init ();
2458 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2462 debug_to_terminal_inferior (void)
2464 debug_target
.to_terminal_inferior ();
2466 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2470 debug_to_terminal_ours_for_output (void)
2472 debug_target
.to_terminal_ours_for_output ();
2474 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2478 debug_to_terminal_ours (void)
2480 debug_target
.to_terminal_ours ();
2482 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2486 debug_to_terminal_info (char *arg
, int from_tty
)
2488 debug_target
.to_terminal_info (arg
, from_tty
);
2490 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2495 debug_to_kill (void)
2497 debug_target
.to_kill ();
2499 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2503 debug_to_load (char *args
, int from_tty
)
2505 debug_target
.to_load (args
, from_tty
);
2507 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2511 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2515 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2517 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2523 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2525 debug_target
.to_create_inferior (exec_file
, args
, env
);
2527 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2532 debug_to_post_startup_inferior (int pid
)
2534 debug_target
.to_post_startup_inferior (pid
);
2536 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2541 debug_to_acknowledge_created_inferior (int pid
)
2543 debug_target
.to_acknowledge_created_inferior (pid
);
2545 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2550 debug_to_clone_and_follow_inferior (int child_pid
, int *followed_child
)
2552 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
2554 fprintf_unfiltered (gdb_stdlog
,
2555 "target_clone_and_follow_inferior (%d, %d)\n",
2556 child_pid
, *followed_child
);
2560 debug_to_post_follow_inferior_by_clone (void)
2562 debug_target
.to_post_follow_inferior_by_clone ();
2564 fprintf_unfiltered (gdb_stdlog
, "target_post_follow_inferior_by_clone ()\n");
2568 debug_to_insert_fork_catchpoint (int pid
)
2572 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2574 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2581 debug_to_remove_fork_catchpoint (int pid
)
2585 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2587 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2594 debug_to_insert_vfork_catchpoint (int pid
)
2598 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2600 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2607 debug_to_remove_vfork_catchpoint (int pid
)
2611 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2613 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2620 debug_to_has_forked (int pid
, int *child_pid
)
2624 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
2626 fprintf_unfiltered (gdb_stdlog
, "target_has_forked (%d, %d) = %d\n",
2627 pid
, *child_pid
, has_forked
);
2633 debug_to_has_vforked (int pid
, int *child_pid
)
2637 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
2639 fprintf_unfiltered (gdb_stdlog
, "target_has_vforked (%d, %d) = %d\n",
2640 pid
, *child_pid
, has_vforked
);
2646 debug_to_can_follow_vfork_prior_to_exec (void)
2648 int can_immediately_follow_vfork
;
2650 can_immediately_follow_vfork
= debug_target
.to_can_follow_vfork_prior_to_exec ();
2652 fprintf_unfiltered (gdb_stdlog
, "target_can_follow_vfork_prior_to_exec () = %d\n",
2653 can_immediately_follow_vfork
);
2655 return can_immediately_follow_vfork
;
2659 debug_to_post_follow_vfork (int parent_pid
, int followed_parent
, int child_pid
,
2662 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
2664 fprintf_unfiltered (gdb_stdlog
,
2665 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2666 parent_pid
, followed_parent
, child_pid
, followed_child
);
2670 debug_to_insert_exec_catchpoint (int pid
)
2674 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2676 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2683 debug_to_remove_exec_catchpoint (int pid
)
2687 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2689 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2696 debug_to_has_execd (int pid
, char **execd_pathname
)
2700 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2702 fprintf_unfiltered (gdb_stdlog
, "target_has_execd (%d, %s) = %d\n",
2703 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
2710 debug_to_reported_exec_events_per_exec_call (void)
2712 int reported_exec_events
;
2714 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2716 fprintf_unfiltered (gdb_stdlog
,
2717 "target_reported_exec_events_per_exec_call () = %d\n",
2718 reported_exec_events
);
2720 return reported_exec_events
;
2724 debug_to_has_syscall_event (int pid
, enum target_waitkind
*kind
,
2727 int has_syscall_event
;
2728 char *kind_spelling
= "??";
2730 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2731 if (has_syscall_event
)
2735 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2736 kind_spelling
= "SYSCALL_ENTRY";
2738 case TARGET_WAITKIND_SYSCALL_RETURN
:
2739 kind_spelling
= "SYSCALL_RETURN";
2746 fprintf_unfiltered (gdb_stdlog
,
2747 "target_has_syscall_event (%d, %s, %d) = %d\n",
2748 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2750 return has_syscall_event
;
2754 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2758 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2760 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2761 pid
, wait_status
, *exit_status
, has_exited
);
2767 debug_to_mourn_inferior (void)
2769 debug_target
.to_mourn_inferior ();
2771 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2775 debug_to_can_run (void)
2779 retval
= debug_target
.to_can_run ();
2781 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2787 debug_to_notice_signals (int pid
)
2789 debug_target
.to_notice_signals (pid
);
2791 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n", pid
);
2795 debug_to_thread_alive (int pid
)
2799 retval
= debug_target
.to_thread_alive (pid
);
2801 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2808 debug_to_find_new_threads (void)
2810 debug_target
.to_find_new_threads ();
2812 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2816 debug_to_stop (void)
2818 debug_target
.to_stop ();
2820 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2824 debug_to_query (int type
, char *req
, char *resp
, int *siz
)
2828 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2830 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2836 debug_to_rcmd (char *command
,
2837 struct ui_file
*outbuf
)
2839 debug_target
.to_rcmd (command
, outbuf
);
2840 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2843 static struct symtab_and_line
*
2844 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2846 struct symtab_and_line
*result
;
2847 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2848 fprintf_unfiltered (gdb_stdlog
,
2849 "target get_exception_callback_sal (%d, %d)\n",
2854 static struct exception_event_record
*
2855 debug_to_get_current_exception_event (void)
2857 struct exception_event_record
*result
;
2858 result
= debug_target
.to_get_current_exception_event ();
2859 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2864 debug_to_pid_to_exec_file (int pid
)
2868 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2870 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2877 debug_to_core_file_to_sym_file (char *core
)
2881 sym_file
= debug_target
.to_core_file_to_sym_file (core
);
2883 fprintf_unfiltered (gdb_stdlog
, "target_core_file_to_sym_file (%s) = %s\n",
2890 setup_target_debug (void)
2892 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2894 current_target
.to_open
= debug_to_open
;
2895 current_target
.to_close
= debug_to_close
;
2896 current_target
.to_attach
= debug_to_attach
;
2897 current_target
.to_post_attach
= debug_to_post_attach
;
2898 current_target
.to_require_attach
= debug_to_require_attach
;
2899 current_target
.to_detach
= debug_to_detach
;
2900 current_target
.to_require_detach
= debug_to_require_detach
;
2901 current_target
.to_resume
= debug_to_resume
;
2902 current_target
.to_wait
= debug_to_wait
;
2903 current_target
.to_post_wait
= debug_to_post_wait
;
2904 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2905 current_target
.to_store_registers
= debug_to_store_registers
;
2906 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2907 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2908 current_target
.to_files_info
= debug_to_files_info
;
2909 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2910 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2911 current_target
.to_terminal_init
= debug_to_terminal_init
;
2912 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2913 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2914 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2915 current_target
.to_terminal_info
= debug_to_terminal_info
;
2916 current_target
.to_kill
= debug_to_kill
;
2917 current_target
.to_load
= debug_to_load
;
2918 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2919 current_target
.to_create_inferior
= debug_to_create_inferior
;
2920 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2921 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2922 current_target
.to_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2923 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2924 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2925 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2926 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2927 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2928 current_target
.to_has_forked
= debug_to_has_forked
;
2929 current_target
.to_has_vforked
= debug_to_has_vforked
;
2930 current_target
.to_can_follow_vfork_prior_to_exec
= debug_to_can_follow_vfork_prior_to_exec
;
2931 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2932 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2933 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2934 current_target
.to_has_execd
= debug_to_has_execd
;
2935 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2936 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2937 current_target
.to_has_exited
= debug_to_has_exited
;
2938 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2939 current_target
.to_can_run
= debug_to_can_run
;
2940 current_target
.to_notice_signals
= debug_to_notice_signals
;
2941 current_target
.to_thread_alive
= debug_to_thread_alive
;
2942 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2943 current_target
.to_stop
= debug_to_stop
;
2944 current_target
.to_query
= debug_to_query
;
2945 current_target
.to_rcmd
= debug_to_rcmd
;
2946 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2947 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2948 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2949 current_target
.to_core_file_to_sym_file
= debug_to_core_file_to_sym_file
;
2954 static char targ_desc
[] =
2955 "Names of targets and files being debugged.\n\
2956 Shows the entire stack of targets currently in use (including the exec-file,\n\
2957 core-file, and process, if any), as well as the symbol file name.";
2960 do_monitor_command (char *cmd
,
2963 if ((current_target
.to_rcmd
2964 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2965 || (current_target
.to_rcmd
== debug_to_rcmd
2966 && (debug_target
.to_rcmd
2967 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2969 error ("\"monitor\" command not supported by this target.\n");
2971 target_rcmd (cmd
, gdb_stdtarg
);
2975 initialize_targets (void)
2977 init_dummy_target ();
2978 push_target (&dummy_target
);
2980 add_info ("target", target_info
, targ_desc
);
2981 add_info ("files", target_info
, targ_desc
);
2984 add_set_cmd ("target", class_maintenance
, var_zinteger
,
2985 (char *) &targetdebug
,
2986 "Set target debugging.\n\
2987 When non-zero, target debugging is enabled.", &setdebuglist
),
2991 add_com ("monitor", class_obscure
, do_monitor_command
,
2992 "Send a command to the remote monitor (remote targets only).");
2994 target_dcache
= dcache_init();
2996 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))
2997 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");