1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1992-1995, 1998-2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
38 static void target_info (char *, int);
40 static void cleanup_target (struct target_ops *);
42 static void maybe_kill_then_create_inferior (char *, char *, char **);
44 static void default_clone_and_follow_inferior (int, int *);
46 static void maybe_kill_then_attach (char *, int);
48 static void kill_or_be_killed (int);
50 static void default_terminal_info (char *, int);
52 static int nosymbol (char *, CORE_ADDR *);
54 static void tcomplain (void);
56 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
58 static int return_zero (void);
60 static int return_one (void);
62 void target_ignore (void);
64 static void target_command (char *, int);
66 static struct target_ops *find_default_run_target (char *);
68 static void update_current_target (void);
70 static void nosupport_runtime (void);
72 static void normal_target_post_startup_inferior (int pid);
74 /* Transfer LEN bytes between target address MEMADDR and GDB address
75 MYADDR. Returns 0 for success, errno code for failure (which
76 includes partial transfers -- if you want a more useful response to
77 partial transfers, try either target_read_memory_partial or
78 target_write_memory_partial). */
81 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write);
83 static void init_dummy_target (void);
85 static void debug_to_open (char *, int);
87 static void debug_to_close (int);
89 static void debug_to_attach (char *, int);
91 static void debug_to_detach (char *, int);
93 static void debug_to_resume (int, int, enum target_signal);
95 static int debug_to_wait (int, struct target_waitstatus *);
97 static void debug_to_fetch_registers (int);
99 static void debug_to_store_registers (int);
101 static void debug_to_prepare_to_store (void);
104 debug_to_xfer_memory (CORE_ADDR, char *, int, int, struct target_ops *);
106 static void debug_to_files_info (struct target_ops *);
108 static int debug_to_insert_breakpoint (CORE_ADDR, char *);
110 static int debug_to_remove_breakpoint (CORE_ADDR, char *);
112 static void debug_to_terminal_init (void);
114 static void debug_to_terminal_inferior (void);
116 static void debug_to_terminal_ours_for_output (void);
118 static void debug_to_terminal_ours (void);
120 static void debug_to_terminal_info (char *, int);
122 static void debug_to_kill (void);
124 static void debug_to_load (char *, int);
126 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
128 static void debug_to_create_inferior (char *, char *, char **);
130 static void debug_to_mourn_inferior (void);
132 static int debug_to_can_run (void);
134 static void debug_to_notice_signals (int);
136 static int debug_to_thread_alive (int);
138 static void debug_to_stop (void);
140 static int debug_to_query (int /*char */ , char *, char *, int *);
142 /* Pointer to array of target architecture structures; the size of the
143 array; the current index into the array; the allocated size of the
145 struct target_ops **target_structs;
146 unsigned target_struct_size;
147 unsigned target_struct_index;
148 unsigned target_struct_allocsize;
149 #define DEFAULT_ALLOCSIZE 10
151 /* The initial current target, so that there is always a semi-valid
154 static struct target_ops dummy_target;
156 /* Top of target stack. */
158 struct target_stack_item *target_stack;
160 /* The target structure we are currently using to talk to a process
161 or file or whatever "inferior" we have. */
163 struct target_ops current_target;
165 /* Command list for target. */
167 static struct cmd_list_element *targetlist = NULL;
169 /* Nonzero if we are debugging an attached outside process
170 rather than an inferior. */
174 /* Non-zero if we want to see trace of target level stuff. */
176 static int targetdebug = 0;
178 static void setup_target_debug (void);
180 /* The user just typed 'target' without the name of a target. */
184 target_command (char *arg, int from_tty)
186 fputs_filtered ("Argument required (target name). Try `help target'\n",
190 /* Add a possible target architecture to the list. */
193 add_target (struct target_ops *t)
197 target_struct_allocsize = DEFAULT_ALLOCSIZE;
198 target_structs = (struct target_ops **) xmalloc
199 (target_struct_allocsize * sizeof (*target_structs));
201 if (target_struct_size >= target_struct_allocsize)
203 target_struct_allocsize *= 2;
204 target_structs = (struct target_ops **)
205 xrealloc ((char *) target_structs,
206 target_struct_allocsize * sizeof (*target_structs));
208 target_structs[target_struct_size++] = t;
209 /* cleanup_target (t); */
211 if (targetlist == NULL)
212 add_prefix_cmd ("target", class_run, target_command,
213 "Connect to a target machine or process.\n\
214 The first argument is the type or protocol of the target machine.\n\
215 Remaining arguments are interpreted by the target protocol. For more\n\
216 information on the arguments for a particular protocol, type\n\
217 `help target ' followed by the protocol name.",
218 &targetlist, "target ", 0, &cmdlist);
219 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
230 target_load (char *arg, int from_tty)
232 (*current_target.to_load) (arg, from_tty);
237 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
238 struct target_ops *t)
240 errno = EIO; /* Can't read/write this location */
241 return 0; /* No bytes handled */
247 error ("You can't do that when your target is `%s'",
248 current_target.to_shortname);
254 error ("You can't do that without a process to debug.");
259 nosymbol (char *name, CORE_ADDR *addrp)
261 return 1; /* Symbol does not exist in target env */
266 nosupport_runtime (void)
271 error ("No run-time support for this");
277 default_terminal_info (char *args, int from_tty)
279 printf_unfiltered ("No saved terminal information.\n");
282 /* This is the default target_create_inferior and target_attach function.
283 If the current target is executing, it asks whether to kill it off.
284 If this function returns without calling error(), it has killed off
285 the target, and the operation should be attempted. */
288 kill_or_be_killed (int from_tty)
290 if (target_has_execution)
292 printf_unfiltered ("You are already running a program:\n");
293 target_files_info ();
294 if (query ("Kill it? "))
297 if (target_has_execution)
298 error ("Killing the program did not help.");
303 error ("Program not killed.");
310 maybe_kill_then_attach (char *args, int from_tty)
312 kill_or_be_killed (from_tty);
313 target_attach (args, from_tty);
317 maybe_kill_then_create_inferior (char *exec, char *args, char **env)
319 kill_or_be_killed (0);
320 target_create_inferior (exec, args, env);
324 default_clone_and_follow_inferior (int child_pid, int *followed_child)
326 target_clone_and_follow_inferior (child_pid, followed_child);
329 /* Clean up a target struct so it no longer has any zero pointers in it.
330 We default entries, at least to stubs that print error messages. */
333 cleanup_target (struct target_ops *t)
336 #define de_fault(field, value) \
341 (void (*) (char *, int))
347 maybe_kill_then_attach);
348 de_fault (to_post_attach,
351 de_fault (to_require_attach,
352 maybe_kill_then_attach);
354 (void (*) (char *, int))
356 de_fault (to_require_detach,
357 (void (*) (int, char *, int))
360 (void (*) (int, int, enum target_signal))
363 (int (*) (int, struct target_waitstatus *))
365 de_fault (to_post_wait,
366 (void (*) (int, int))
368 de_fault (to_fetch_registers,
371 de_fault (to_store_registers,
374 de_fault (to_prepare_to_store,
377 de_fault (to_xfer_memory,
378 (int (*) (CORE_ADDR, char *, int, int, struct target_ops *))
380 de_fault (to_files_info,
381 (void (*) (struct target_ops *))
383 de_fault (to_insert_breakpoint,
384 memory_insert_breakpoint);
385 de_fault (to_remove_breakpoint,
386 memory_remove_breakpoint);
387 de_fault (to_terminal_init,
390 de_fault (to_terminal_inferior,
393 de_fault (to_terminal_ours_for_output,
396 de_fault (to_terminal_ours,
399 de_fault (to_terminal_info,
400 default_terminal_info);
405 (void (*) (char *, int))
407 de_fault (to_lookup_symbol,
408 (int (*) (char *, CORE_ADDR *))
410 de_fault (to_create_inferior,
411 maybe_kill_then_create_inferior);
412 de_fault (to_post_startup_inferior,
415 de_fault (to_acknowledge_created_inferior,
418 de_fault (to_clone_and_follow_inferior,
419 default_clone_and_follow_inferior);
420 de_fault (to_post_follow_inferior_by_clone,
423 de_fault (to_insert_fork_catchpoint,
426 de_fault (to_remove_fork_catchpoint,
429 de_fault (to_insert_vfork_catchpoint,
432 de_fault (to_remove_vfork_catchpoint,
435 de_fault (to_has_forked,
436 (int (*) (int, int *))
438 de_fault (to_has_vforked,
439 (int (*) (int, int *))
441 de_fault (to_can_follow_vfork_prior_to_exec,
444 de_fault (to_post_follow_vfork,
445 (void (*) (int, int, int, int))
447 de_fault (to_insert_exec_catchpoint,
450 de_fault (to_remove_exec_catchpoint,
453 de_fault (to_has_execd,
454 (int (*) (int, char **))
456 de_fault (to_reported_exec_events_per_exec_call,
459 de_fault (to_has_syscall_event,
460 (int (*) (int, enum target_waitkind *, int *))
462 de_fault (to_has_exited,
463 (int (*) (int, int, int *))
465 de_fault (to_mourn_inferior,
468 de_fault (to_can_run,
470 de_fault (to_notice_signals,
473 de_fault (to_thread_alive,
476 de_fault (to_find_new_threads,
479 de_fault (to_extra_thread_info,
480 (char *(*) (struct thread_info *))
486 (int (*) (int, char *, char *, int *))
489 (void (*) (char *, struct ui_file *))
491 de_fault (to_enable_exception_callback,
492 (struct symtab_and_line * (*) (enum exception_event_kind, int))
494 de_fault (to_get_current_exception_event,
495 (struct exception_event_record * (*) (void))
497 de_fault (to_pid_to_exec_file,
500 de_fault (to_core_file_to_sym_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_core_file_to_sym_file, t);
597 INHERIT (to_stratum, t);
598 INHERIT (DONT_USE, t);
599 INHERIT (to_has_all_memory, t);
600 INHERIT (to_has_memory, t);
601 INHERIT (to_has_stack, t);
602 INHERIT (to_has_registers, t);
603 INHERIT (to_has_execution, t);
604 INHERIT (to_has_thread_control, t);
605 INHERIT (to_sections, t);
606 INHERIT (to_sections_end, t);
607 INHERIT (to_can_async_p, t);
608 INHERIT (to_is_async_p, t);
609 INHERIT (to_async, t);
610 INHERIT (to_async_mask_value, t);
611 INHERIT (to_magic, t);
617 /* Push a new target type into the stack of the existing target accessors,
618 possibly superseding some of the existing accessors.
620 Result is zero if the pushed target ended up on top of the stack,
621 nonzero if at least one target is on top of it.
623 Rather than allow an empty stack, we always have the dummy target at
624 the bottom stratum, so we can call the function vectors without
628 push_target (struct target_ops *t)
630 struct target_stack_item *cur, *prev, *tmp;
632 /* Check magic number. If wrong, it probably means someone changed
633 the struct definition, but not all the places that initialize one. */
634 if (t->to_magic != OPS_MAGIC)
636 fprintf_unfiltered (gdb_stderr,
637 "Magic number of %s target struct wrong\n",
642 /* Find the proper stratum to install this target in. */
644 for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
646 if ((int) (t->to_stratum) >= (int) (cur->target_ops->to_stratum))
650 /* If there's already targets at this stratum, remove them. */
653 while (t->to_stratum == cur->target_ops->to_stratum)
655 /* There's already something on this stratum. Close it off. */
656 if (cur->target_ops->to_close)
657 (cur->target_ops->to_close) (0);
659 prev->next = cur->next; /* Unchain old target_ops */
661 target_stack = cur->next; /* Unchain first on list */
667 /* We have removed all targets in our stratum, now add the new one. */
669 tmp = (struct target_stack_item *)
670 xmalloc (sizeof (struct target_stack_item));
679 update_current_target ();
681 cleanup_target (¤t_target); /* Fill in the gaps */
684 setup_target_debug ();
689 /* Remove a target_ops vector from the stack, wherever it may be.
690 Return how many times it was removed (0 or 1). */
693 unpush_target (struct target_ops *t)
695 struct target_stack_item *cur, *prev;
698 t->to_close (0); /* Let it clean up */
700 /* Look for the specified target. Note that we assume that a target
701 can only occur once in the target stack. */
703 for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
704 if (cur->target_ops == t)
708 return 0; /* Didn't find target_ops, quit now */
710 /* Unchain the target */
713 target_stack = cur->next;
715 prev->next = cur->next;
717 free (cur); /* Release the target_stack_item */
719 update_current_target ();
720 cleanup_target (¤t_target);
728 (current_target.to_close) (0); /* Let it clean up */
729 if (unpush_target (target_stack->target_ops) == 1)
732 fprintf_unfiltered (gdb_stderr,
733 "pop_target couldn't find target %s\n",
734 current_target.to_shortname);
739 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
741 /* target_read_string -- read a null terminated string, up to LEN bytes,
742 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
743 Set *STRING to a pointer to malloc'd memory containing the data; the caller
744 is responsible for freeing it. Return the number of bytes successfully
748 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
750 int tlen, origlen, offset, i;
754 int buffer_allocated;
756 unsigned int nbytes_read = 0;
758 /* Small for testing. */
759 buffer_allocated = 4;
760 buffer = xmalloc (buffer_allocated);
767 tlen = MIN (len, 4 - (memaddr & 3));
768 offset = memaddr & 3;
770 errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
773 /* The transfer request might have crossed the boundary to an
774 unallocated region of memory. Retry the transfer, requesting
778 errcode = target_xfer_memory (memaddr, buf, 1, 0);
783 if (bufptr - buffer + tlen > buffer_allocated)
786 bytes = bufptr - buffer;
787 buffer_allocated *= 2;
788 buffer = xrealloc (buffer, buffer_allocated);
789 bufptr = buffer + bytes;
792 for (i = 0; i < tlen; i++)
794 *bufptr++ = buf[i + offset];
795 if (buf[i + offset] == '\000')
797 nbytes_read += i + 1;
814 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
815 GDB's memory at MYADDR. Returns either 0 for success or an errno value
818 If an error occurs, no guarantee is made about the contents of the data at
819 MYADDR. In particular, the caller should not depend upon partial reads
820 filling the buffer with good data. There is no way for the caller to know
821 how much good data might have been transfered anyway. Callers that can
822 deal with partial reads should call target_read_memory_partial. */
825 target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
827 return target_xfer_memory (memaddr, myaddr, len, 0);
831 target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
833 return target_xfer_memory (memaddr, myaddr, len, 1);
836 /* Move memory to or from the targets. Iterate until all of it has
837 been moved, if necessary. The top target gets priority; anything
838 it doesn't want, is offered to the next one down, etc. Note the
839 business with curlen: if an early target says "no, but I have a
840 boundary overlapping this xfer" then we shorten what we offer to
841 the subsequent targets so the early guy will get a chance at the
842 tail before the subsequent ones do.
844 Result is 0 or errno value. */
847 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
851 struct target_ops *t;
852 struct target_stack_item *item;
854 /* Zero length requests are ok and require no work. */
858 /* to_xfer_memory is not guaranteed to set errno, even when it returns
862 /* The quick case is that the top target does it all. */
863 res = current_target.to_xfer_memory
864 (memaddr, myaddr, len, write, ¤t_target);
870 /* If res <= 0 then we call it again in the loop. Ah well. */
874 curlen = len; /* Want to do it all */
875 for (item = target_stack; item; item = item->next)
877 t = item->target_ops;
878 if (!t->to_has_memory)
881 res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
883 break; /* Handled all or part of xfer */
884 if (t->to_has_all_memory)
890 /* If this address is for nonexistent memory,
891 read zeros if reading, or do nothing if writing. Return error. */
893 memset (myaddr, 0, len);
904 return 0; /* We managed to cover it all somehow. */
908 /* Perform a partial memory transfer. */
911 target_xfer_memory_partial (CORE_ADDR memaddr, char *buf, int len,
912 int write_p, int *err)
917 struct target_ops *t;
918 struct target_stack_item *item;
920 /* Zero length requests are ok and require no work. */
927 /* The quick case is that the top target does it all. */
928 res = current_target.to_xfer_memory (memaddr, buf, len, write_p, ¤t_target);
935 /* xfer memory doesn't always reliably set errno. */
938 /* Try all levels of the target stack to see one can handle it. */
939 for (item = target_stack; item; item = item->next)
941 t = item->target_ops;
942 if (!t->to_has_memory)
944 res = t->to_xfer_memory (memaddr, buf, len, write_p, t);
947 /* Handled all or part of xfer */
951 if (t->to_has_all_memory)
955 /* Total failure. Return error. */
966 target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
968 return target_xfer_memory_partial (memaddr, buf, len, 0, err);
972 target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
974 return target_xfer_memory_partial (memaddr, buf, len, 1, err);
979 target_info (char *args, int from_tty)
981 struct target_ops *t;
982 struct target_stack_item *item;
985 if (symfile_objfile != NULL)
986 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
988 #ifdef FILES_INFO_HOOK
989 if (FILES_INFO_HOOK ())
993 for (item = target_stack; item; item = item->next)
995 t = item->target_ops;
997 if (!t->to_has_memory)
1000 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1003 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1004 printf_unfiltered ("%s:\n", t->to_longname);
1005 (t->to_files_info) (t);
1006 has_all_mem = t->to_has_all_memory;
1010 /* This is to be called by the open routine before it does
1014 target_preopen (int from_tty)
1018 if (target_has_execution)
1021 || query ("A program is being debugged already. Kill it? "))
1024 error ("Program not killed.");
1027 /* Calling target_kill may remove the target from the stack. But if
1028 it doesn't (which seems like a win for UDI), remove it now. */
1030 if (target_has_execution)
1034 /* Detach a target after doing deferred register stores. */
1037 target_detach (char *args, int from_tty)
1039 /* Handle any optimized stores to the inferior. */
1040 #ifdef DO_DEFERRED_STORES
1043 (current_target.to_detach) (args, from_tty);
1047 target_link (char *modname, CORE_ADDR *t_reloc)
1049 if (STREQ (current_target.to_shortname, "rombug"))
1051 (current_target.to_lookup_symbol) (modname, t_reloc);
1053 error ("Unable to link to %s and get relocation in rombug", modname);
1056 *t_reloc = (CORE_ADDR) -1;
1060 target_async_mask (int mask)
1062 int saved_async_masked_status = target_async_mask_value;
1063 target_async_mask_value = mask;
1064 return saved_async_masked_status;
1067 /* Look through the list of possible targets for a target that can
1068 execute a run or attach command without any other data. This is
1069 used to locate the default process stratum.
1071 Result is always valid (error() is called for errors). */
1073 static struct target_ops *
1074 find_default_run_target (char *do_mesg)
1076 struct target_ops **t;
1077 struct target_ops *runable = NULL;
1082 for (t = target_structs; t < target_structs + target_struct_size;
1085 if ((*t)->to_can_run && target_can_run (*t))
1093 error ("Don't know how to %s. Try \"help target\".", do_mesg);
1099 find_default_attach (char *args, int from_tty)
1101 struct target_ops *t;
1103 t = find_default_run_target ("attach");
1104 (t->to_attach) (args, from_tty);
1109 find_default_require_attach (char *args, int from_tty)
1111 struct target_ops *t;
1113 t = find_default_run_target ("require_attach");
1114 (t->to_require_attach) (args, from_tty);
1119 find_default_require_detach (int pid, char *args, int from_tty)
1121 struct target_ops *t;
1123 t = find_default_run_target ("require_detach");
1124 (t->to_require_detach) (pid, args, from_tty);
1129 find_default_create_inferior (char *exec_file, char *allargs, char **env)
1131 struct target_ops *t;
1133 t = find_default_run_target ("run");
1134 (t->to_create_inferior) (exec_file, allargs, env);
1139 find_default_clone_and_follow_inferior (int child_pid, int *followed_child)
1141 struct target_ops *t;
1143 t = find_default_run_target ("run");
1144 (t->to_clone_and_follow_inferior) (child_pid, followed_child);
1161 * Resize the to_sections pointer. Also make sure that anyone that
1162 * was holding on to an old value of it gets updated.
1163 * Returns the old size.
1167 target_resize_to_sections (struct target_ops *target, int num_added)
1169 struct target_ops **t;
1170 struct section_table *old_value;
1173 old_value = target->to_sections;
1175 if (target->to_sections)
1177 old_count = target->to_sections_end - target->to_sections;
1178 target->to_sections = (struct section_table *)
1179 xrealloc ((char *) target->to_sections,
1180 (sizeof (struct section_table)) * (num_added + old_count));
1185 target->to_sections = (struct section_table *)
1186 xmalloc ((sizeof (struct section_table)) * num_added);
1188 target->to_sections_end = target->to_sections + (num_added + old_count);
1190 /* Check to see if anyone else was pointing to this structure.
1191 If old_value was null, then no one was. */
1195 for (t = target_structs; t < target_structs + target_struct_size;
1198 if ((*t)->to_sections == old_value)
1200 (*t)->to_sections = target->to_sections;
1201 (*t)->to_sections_end = target->to_sections_end;
1210 /* Remove all target sections taken from ABFD.
1212 Scan the current target stack for targets whose section tables
1213 refer to sections from BFD, and remove those sections. We use this
1214 when we notice that the inferior has unloaded a shared object, for
1217 remove_target_sections (bfd *abfd)
1219 struct target_ops **t;
1221 for (t = target_structs; t < target_structs + target_struct_size; t++)
1223 struct section_table *src, *dest;
1225 dest = (*t)->to_sections;
1226 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1227 if (src->bfd != abfd)
1229 /* Keep this section. */
1230 if (dest < src) *dest = *src;
1234 /* If we've dropped any sections, resize the section table. */
1236 target_resize_to_sections (*t, dest - src);
1243 /* Find a single runnable target in the stack and return it. If for
1244 some reason there is more than one, return NULL. */
1247 find_run_target (void)
1249 struct target_ops **t;
1250 struct target_ops *runable = NULL;
1255 for (t = target_structs; t < target_structs + target_struct_size; ++t)
1257 if ((*t)->to_can_run && target_can_run (*t))
1264 return (count == 1 ? runable : NULL);
1267 /* Find a single core_stratum target in the list of targets and return it.
1268 If for some reason there is more than one, return NULL. */
1271 find_core_target (void)
1273 struct target_ops **t;
1274 struct target_ops *runable = NULL;
1279 for (t = target_structs; t < target_structs + target_struct_size;
1282 if ((*t)->to_stratum == core_stratum)
1289 return (count == 1 ? runable : NULL);
1293 * Find the next target down the stack from the specified target.
1297 find_target_beneath (struct target_ops *t)
1299 struct target_stack_item *cur;
1301 for (cur = target_stack; cur; cur = cur->next)
1302 if (cur->target_ops == t)
1305 if (cur == NULL || cur->next == NULL)
1308 return cur->next->target_ops;
1312 /* The inferior process has died. Long live the inferior! */
1315 generic_mourn_inferior (void)
1317 extern int show_breakpoint_hit_counts;
1321 breakpoint_init_inferior (inf_exited);
1322 registers_changed ();
1324 #ifdef CLEAR_DEFERRED_STORES
1325 /* Delete any pending stores to the inferior... */
1326 CLEAR_DEFERRED_STORES;
1329 reopen_exec_file ();
1330 reinit_frame_cache ();
1332 /* It is confusing to the user for ignore counts to stick around
1333 from previous runs of the inferior. So clear them. */
1334 /* However, it is more confusing for the ignore counts to disappear when
1335 using hit counts. So don't clear them if we're counting hits. */
1336 if (!show_breakpoint_hit_counts)
1337 breakpoint_clear_ignore_counts ();
1340 /* This table must match in order and size the signals in enum target_signal
1349 {"SIGHUP", "Hangup"},
1350 {"SIGINT", "Interrupt"},
1351 {"SIGQUIT", "Quit"},
1352 {"SIGILL", "Illegal instruction"},
1353 {"SIGTRAP", "Trace/breakpoint trap"},
1354 {"SIGABRT", "Aborted"},
1355 {"SIGEMT", "Emulation trap"},
1356 {"SIGFPE", "Arithmetic exception"},
1357 {"SIGKILL", "Killed"},
1358 {"SIGBUS", "Bus error"},
1359 {"SIGSEGV", "Segmentation fault"},
1360 {"SIGSYS", "Bad system call"},
1361 {"SIGPIPE", "Broken pipe"},
1362 {"SIGALRM", "Alarm clock"},
1363 {"SIGTERM", "Terminated"},
1364 {"SIGURG", "Urgent I/O condition"},
1365 {"SIGSTOP", "Stopped (signal)"},
1366 {"SIGTSTP", "Stopped (user)"},
1367 {"SIGCONT", "Continued"},
1368 {"SIGCHLD", "Child status changed"},
1369 {"SIGTTIN", "Stopped (tty input)"},
1370 {"SIGTTOU", "Stopped (tty output)"},
1371 {"SIGIO", "I/O possible"},
1372 {"SIGXCPU", "CPU time limit exceeded"},
1373 {"SIGXFSZ", "File size limit exceeded"},
1374 {"SIGVTALRM", "Virtual timer expired"},
1375 {"SIGPROF", "Profiling timer expired"},
1376 {"SIGWINCH", "Window size changed"},
1377 {"SIGLOST", "Resource lost"},
1378 {"SIGUSR1", "User defined signal 1"},
1379 {"SIGUSR2", "User defined signal 2"},
1380 {"SIGPWR", "Power fail/restart"},
1381 {"SIGPOLL", "Pollable event occurred"},
1382 {"SIGWIND", "SIGWIND"},
1383 {"SIGPHONE", "SIGPHONE"},
1384 {"SIGWAITING", "Process's LWPs are blocked"},
1385 {"SIGLWP", "Signal LWP"},
1386 {"SIGDANGER", "Swap space dangerously low"},
1387 {"SIGGRANT", "Monitor mode granted"},
1388 {"SIGRETRACT", "Need to relinquish monitor mode"},
1389 {"SIGMSG", "Monitor mode data available"},
1390 {"SIGSOUND", "Sound completed"},
1391 {"SIGSAK", "Secure attention"},
1392 {"SIGPRIO", "SIGPRIO"},
1393 {"SIG33", "Real-time event 33"},
1394 {"SIG34", "Real-time event 34"},
1395 {"SIG35", "Real-time event 35"},
1396 {"SIG36", "Real-time event 36"},
1397 {"SIG37", "Real-time event 37"},
1398 {"SIG38", "Real-time event 38"},
1399 {"SIG39", "Real-time event 39"},
1400 {"SIG40", "Real-time event 40"},
1401 {"SIG41", "Real-time event 41"},
1402 {"SIG42", "Real-time event 42"},
1403 {"SIG43", "Real-time event 43"},
1404 {"SIG44", "Real-time event 44"},
1405 {"SIG45", "Real-time event 45"},
1406 {"SIG46", "Real-time event 46"},
1407 {"SIG47", "Real-time event 47"},
1408 {"SIG48", "Real-time event 48"},
1409 {"SIG49", "Real-time event 49"},
1410 {"SIG50", "Real-time event 50"},
1411 {"SIG51", "Real-time event 51"},
1412 {"SIG52", "Real-time event 52"},
1413 {"SIG53", "Real-time event 53"},
1414 {"SIG54", "Real-time event 54"},
1415 {"SIG55", "Real-time event 55"},
1416 {"SIG56", "Real-time event 56"},
1417 {"SIG57", "Real-time event 57"},
1418 {"SIG58", "Real-time event 58"},
1419 {"SIG59", "Real-time event 59"},
1420 {"SIG60", "Real-time event 60"},
1421 {"SIG61", "Real-time event 61"},
1422 {"SIG62", "Real-time event 62"},
1423 {"SIG63", "Real-time event 63"},
1424 {"SIGCANCEL", "LWP internal signal"},
1425 {"SIG32", "Real-time event 32"},
1427 #if defined(MACH) || defined(__MACH__)
1428 /* Mach exceptions */
1429 {"EXC_BAD_ACCESS", "Could not access memory"},
1430 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1431 {"EXC_ARITHMETIC", "Arithmetic exception"},
1432 {"EXC_EMULATION", "Emulation instruction"},
1433 {"EXC_SOFTWARE", "Software generated exception"},
1434 {"EXC_BREAKPOINT", "Breakpoint"},
1436 {"SIGINFO", "Information request"},
1438 {NULL, "Unknown signal"},
1439 {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1441 /* Last entry, used to check whether the table is the right size. */
1442 {NULL, "TARGET_SIGNAL_MAGIC"}
1448 /* Return the string for a signal. */
1450 target_signal_to_string (enum target_signal sig)
1452 if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
1453 return signals[sig].string;
1455 return signals[TARGET_SIGNAL_UNKNOWN].string;
1458 /* Return the name for a signal. */
1460 target_signal_to_name (enum target_signal sig)
1462 if (sig == TARGET_SIGNAL_UNKNOWN)
1463 /* I think the code which prints this will always print it along with
1464 the string, so no need to be verbose. */
1466 return signals[sig].name;
1469 /* Given a name, return its signal. */
1471 target_signal_from_name (char *name)
1473 enum target_signal sig;
1475 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1476 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1477 questionable; seems like by now people should call it SIGABRT
1480 /* This ugly cast brought to you by the native VAX compiler. */
1481 for (sig = TARGET_SIGNAL_HUP;
1482 signals[sig].name != NULL;
1483 sig = (enum target_signal) ((int) sig + 1))
1484 if (STREQ (name, signals[sig].name))
1486 return TARGET_SIGNAL_UNKNOWN;
1489 /* The following functions are to help certain targets deal
1490 with the signal/waitstatus stuff. They could just as well be in
1491 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1493 /* Convert host signal to our signals. */
1495 target_signal_from_host (int hostsig)
1497 /* A switch statement would make sense but would require special kludges
1498 to deal with the cases where more than one signal has the same number. */
1501 return TARGET_SIGNAL_0;
1503 #if defined (SIGHUP)
1504 if (hostsig == SIGHUP)
1505 return TARGET_SIGNAL_HUP;
1507 #if defined (SIGINT)
1508 if (hostsig == SIGINT)
1509 return TARGET_SIGNAL_INT;
1511 #if defined (SIGQUIT)
1512 if (hostsig == SIGQUIT)
1513 return TARGET_SIGNAL_QUIT;
1515 #if defined (SIGILL)
1516 if (hostsig == SIGILL)
1517 return TARGET_SIGNAL_ILL;
1519 #if defined (SIGTRAP)
1520 if (hostsig == SIGTRAP)
1521 return TARGET_SIGNAL_TRAP;
1523 #if defined (SIGABRT)
1524 if (hostsig == SIGABRT)
1525 return TARGET_SIGNAL_ABRT;
1527 #if defined (SIGEMT)
1528 if (hostsig == SIGEMT)
1529 return TARGET_SIGNAL_EMT;
1531 #if defined (SIGFPE)
1532 if (hostsig == SIGFPE)
1533 return TARGET_SIGNAL_FPE;
1535 #if defined (SIGKILL)
1536 if (hostsig == SIGKILL)
1537 return TARGET_SIGNAL_KILL;
1539 #if defined (SIGBUS)
1540 if (hostsig == SIGBUS)
1541 return TARGET_SIGNAL_BUS;
1543 #if defined (SIGSEGV)
1544 if (hostsig == SIGSEGV)
1545 return TARGET_SIGNAL_SEGV;
1547 #if defined (SIGSYS)
1548 if (hostsig == SIGSYS)
1549 return TARGET_SIGNAL_SYS;
1551 #if defined (SIGPIPE)
1552 if (hostsig == SIGPIPE)
1553 return TARGET_SIGNAL_PIPE;
1555 #if defined (SIGALRM)
1556 if (hostsig == SIGALRM)
1557 return TARGET_SIGNAL_ALRM;
1559 #if defined (SIGTERM)
1560 if (hostsig == SIGTERM)
1561 return TARGET_SIGNAL_TERM;
1563 #if defined (SIGUSR1)
1564 if (hostsig == SIGUSR1)
1565 return TARGET_SIGNAL_USR1;
1567 #if defined (SIGUSR2)
1568 if (hostsig == SIGUSR2)
1569 return TARGET_SIGNAL_USR2;
1571 #if defined (SIGCLD)
1572 if (hostsig == SIGCLD)
1573 return TARGET_SIGNAL_CHLD;
1575 #if defined (SIGCHLD)
1576 if (hostsig == SIGCHLD)
1577 return TARGET_SIGNAL_CHLD;
1579 #if defined (SIGPWR)
1580 if (hostsig == SIGPWR)
1581 return TARGET_SIGNAL_PWR;
1583 #if defined (SIGWINCH)
1584 if (hostsig == SIGWINCH)
1585 return TARGET_SIGNAL_WINCH;
1587 #if defined (SIGURG)
1588 if (hostsig == SIGURG)
1589 return TARGET_SIGNAL_URG;
1592 if (hostsig == SIGIO)
1593 return TARGET_SIGNAL_IO;
1595 #if defined (SIGPOLL)
1596 if (hostsig == SIGPOLL)
1597 return TARGET_SIGNAL_POLL;
1599 #if defined (SIGSTOP)
1600 if (hostsig == SIGSTOP)
1601 return TARGET_SIGNAL_STOP;
1603 #if defined (SIGTSTP)
1604 if (hostsig == SIGTSTP)
1605 return TARGET_SIGNAL_TSTP;
1607 #if defined (SIGCONT)
1608 if (hostsig == SIGCONT)
1609 return TARGET_SIGNAL_CONT;
1611 #if defined (SIGTTIN)
1612 if (hostsig == SIGTTIN)
1613 return TARGET_SIGNAL_TTIN;
1615 #if defined (SIGTTOU)
1616 if (hostsig == SIGTTOU)
1617 return TARGET_SIGNAL_TTOU;
1619 #if defined (SIGVTALRM)
1620 if (hostsig == SIGVTALRM)
1621 return TARGET_SIGNAL_VTALRM;
1623 #if defined (SIGPROF)
1624 if (hostsig == SIGPROF)
1625 return TARGET_SIGNAL_PROF;
1627 #if defined (SIGXCPU)
1628 if (hostsig == SIGXCPU)
1629 return TARGET_SIGNAL_XCPU;
1631 #if defined (SIGXFSZ)
1632 if (hostsig == SIGXFSZ)
1633 return TARGET_SIGNAL_XFSZ;
1635 #if defined (SIGWIND)
1636 if (hostsig == SIGWIND)
1637 return TARGET_SIGNAL_WIND;
1639 #if defined (SIGPHONE)
1640 if (hostsig == SIGPHONE)
1641 return TARGET_SIGNAL_PHONE;
1643 #if defined (SIGLOST)
1644 if (hostsig == SIGLOST)
1645 return TARGET_SIGNAL_LOST;
1647 #if defined (SIGWAITING)
1648 if (hostsig == SIGWAITING)
1649 return TARGET_SIGNAL_WAITING;
1651 #if defined (SIGCANCEL)
1652 if (hostsig == SIGCANCEL)
1653 return TARGET_SIGNAL_CANCEL;
1655 #if defined (SIGLWP)
1656 if (hostsig == SIGLWP)
1657 return TARGET_SIGNAL_LWP;
1659 #if defined (SIGDANGER)
1660 if (hostsig == SIGDANGER)
1661 return TARGET_SIGNAL_DANGER;
1663 #if defined (SIGGRANT)
1664 if (hostsig == SIGGRANT)
1665 return TARGET_SIGNAL_GRANT;
1667 #if defined (SIGRETRACT)
1668 if (hostsig == SIGRETRACT)
1669 return TARGET_SIGNAL_RETRACT;
1671 #if defined (SIGMSG)
1672 if (hostsig == SIGMSG)
1673 return TARGET_SIGNAL_MSG;
1675 #if defined (SIGSOUND)
1676 if (hostsig == SIGSOUND)
1677 return TARGET_SIGNAL_SOUND;
1679 #if defined (SIGSAK)
1680 if (hostsig == SIGSAK)
1681 return TARGET_SIGNAL_SAK;
1683 #if defined (SIGPRIO)
1684 if (hostsig == SIGPRIO)
1685 return TARGET_SIGNAL_PRIO;
1688 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1689 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1690 if (hostsig == _NSIG + EXC_BAD_ACCESS)
1691 return TARGET_EXC_BAD_ACCESS;
1693 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1694 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
1695 return TARGET_EXC_BAD_INSTRUCTION;
1697 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1698 if (hostsig == _NSIG + EXC_ARITHMETIC)
1699 return TARGET_EXC_ARITHMETIC;
1701 #if defined (EXC_EMULATION) && defined (_NSIG)
1702 if (hostsig == _NSIG + EXC_EMULATION)
1703 return TARGET_EXC_EMULATION;
1705 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1706 if (hostsig == _NSIG + EXC_SOFTWARE)
1707 return TARGET_EXC_SOFTWARE;
1709 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1710 if (hostsig == _NSIG + EXC_BREAKPOINT)
1711 return TARGET_EXC_BREAKPOINT;
1714 #if defined (SIGINFO)
1715 if (hostsig == SIGINFO)
1716 return TARGET_SIGNAL_INFO;
1719 #if defined (REALTIME_LO)
1720 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
1722 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
1723 if (33 <= hostsig && hostsig <= 63)
1724 return (enum target_signal)
1725 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
1726 else if (hostsig == 32)
1727 return TARGET_SIGNAL_REALTIME_32;
1729 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
1732 return TARGET_SIGNAL_UNKNOWN;
1735 /* Convert a OURSIG (an enum target_signal) to the form used by the
1736 target operating system (refered to as the ``host'') or zero if the
1737 equivalent host signal is not available. Set/clear OURSIG_OK
1741 do_target_signal_to_host (enum target_signal oursig,
1747 case TARGET_SIGNAL_0:
1750 #if defined (SIGHUP)
1751 case TARGET_SIGNAL_HUP:
1754 #if defined (SIGINT)
1755 case TARGET_SIGNAL_INT:
1758 #if defined (SIGQUIT)
1759 case TARGET_SIGNAL_QUIT:
1762 #if defined (SIGILL)
1763 case TARGET_SIGNAL_ILL:
1766 #if defined (SIGTRAP)
1767 case TARGET_SIGNAL_TRAP:
1770 #if defined (SIGABRT)
1771 case TARGET_SIGNAL_ABRT:
1774 #if defined (SIGEMT)
1775 case TARGET_SIGNAL_EMT:
1778 #if defined (SIGFPE)
1779 case TARGET_SIGNAL_FPE:
1782 #if defined (SIGKILL)
1783 case TARGET_SIGNAL_KILL:
1786 #if defined (SIGBUS)
1787 case TARGET_SIGNAL_BUS:
1790 #if defined (SIGSEGV)
1791 case TARGET_SIGNAL_SEGV:
1794 #if defined (SIGSYS)
1795 case TARGET_SIGNAL_SYS:
1798 #if defined (SIGPIPE)
1799 case TARGET_SIGNAL_PIPE:
1802 #if defined (SIGALRM)
1803 case TARGET_SIGNAL_ALRM:
1806 #if defined (SIGTERM)
1807 case TARGET_SIGNAL_TERM:
1810 #if defined (SIGUSR1)
1811 case TARGET_SIGNAL_USR1:
1814 #if defined (SIGUSR2)
1815 case TARGET_SIGNAL_USR2:
1818 #if defined (SIGCHLD) || defined (SIGCLD)
1819 case TARGET_SIGNAL_CHLD:
1820 #if defined (SIGCHLD)
1825 #endif /* SIGCLD or SIGCHLD */
1826 #if defined (SIGPWR)
1827 case TARGET_SIGNAL_PWR:
1830 #if defined (SIGWINCH)
1831 case TARGET_SIGNAL_WINCH:
1834 #if defined (SIGURG)
1835 case TARGET_SIGNAL_URG:
1839 case TARGET_SIGNAL_IO:
1842 #if defined (SIGPOLL)
1843 case TARGET_SIGNAL_POLL:
1846 #if defined (SIGSTOP)
1847 case TARGET_SIGNAL_STOP:
1850 #if defined (SIGTSTP)
1851 case TARGET_SIGNAL_TSTP:
1854 #if defined (SIGCONT)
1855 case TARGET_SIGNAL_CONT:
1858 #if defined (SIGTTIN)
1859 case TARGET_SIGNAL_TTIN:
1862 #if defined (SIGTTOU)
1863 case TARGET_SIGNAL_TTOU:
1866 #if defined (SIGVTALRM)
1867 case TARGET_SIGNAL_VTALRM:
1870 #if defined (SIGPROF)
1871 case TARGET_SIGNAL_PROF:
1874 #if defined (SIGXCPU)
1875 case TARGET_SIGNAL_XCPU:
1878 #if defined (SIGXFSZ)
1879 case TARGET_SIGNAL_XFSZ:
1882 #if defined (SIGWIND)
1883 case TARGET_SIGNAL_WIND:
1886 #if defined (SIGPHONE)
1887 case TARGET_SIGNAL_PHONE:
1890 #if defined (SIGLOST)
1891 case TARGET_SIGNAL_LOST:
1894 #if defined (SIGWAITING)
1895 case TARGET_SIGNAL_WAITING:
1898 #if defined (SIGCANCEL)
1899 case TARGET_SIGNAL_CANCEL:
1902 #if defined (SIGLWP)
1903 case TARGET_SIGNAL_LWP:
1906 #if defined (SIGDANGER)
1907 case TARGET_SIGNAL_DANGER:
1910 #if defined (SIGGRANT)
1911 case TARGET_SIGNAL_GRANT:
1914 #if defined (SIGRETRACT)
1915 case TARGET_SIGNAL_RETRACT:
1918 #if defined (SIGMSG)
1919 case TARGET_SIGNAL_MSG:
1922 #if defined (SIGSOUND)
1923 case TARGET_SIGNAL_SOUND:
1926 #if defined (SIGSAK)
1927 case TARGET_SIGNAL_SAK:
1930 #if defined (SIGPRIO)
1931 case TARGET_SIGNAL_PRIO:
1935 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1936 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1937 case TARGET_EXC_BAD_ACCESS:
1938 return _NSIG + EXC_BAD_ACCESS;
1940 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1941 case TARGET_EXC_BAD_INSTRUCTION:
1942 return _NSIG + EXC_BAD_INSTRUCTION;
1944 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1945 case TARGET_EXC_ARITHMETIC:
1946 return _NSIG + EXC_ARITHMETIC;
1948 #if defined (EXC_EMULATION) && defined (_NSIG)
1949 case TARGET_EXC_EMULATION:
1950 return _NSIG + EXC_EMULATION;
1952 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1953 case TARGET_EXC_SOFTWARE:
1954 return _NSIG + EXC_SOFTWARE;
1956 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1957 case TARGET_EXC_BREAKPOINT:
1958 return _NSIG + EXC_BREAKPOINT;
1961 #if defined (SIGINFO)
1962 case TARGET_SIGNAL_INFO:
1967 #if defined (REALTIME_LO)
1968 if (oursig >= TARGET_SIGNAL_REALTIME_33
1969 && oursig <= TARGET_SIGNAL_REALTIME_63)
1971 /* This block of signals is continuous, and
1972 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
1974 (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
1975 if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
1978 #if (REALTIME_LO < 33)
1979 else if (oursig == TARGET_SIGNAL_REALTIME_32)
1981 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
1982 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */
1993 target_signal_to_host_p (enum target_signal oursig)
1996 do_target_signal_to_host (oursig, &oursig_ok);
2001 target_signal_to_host (enum target_signal oursig)
2004 int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
2007 /* The user might be trying to do "signal SIGSAK" where this system
2008 doesn't have SIGSAK. */
2009 warning ("Signal %s does not exist on this system.\n",
2010 target_signal_to_name (oursig));
2017 /* Helper function for child_wait and the Lynx derivatives of child_wait.
2018 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2019 translation of that in OURSTATUS. */
2021 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2023 #ifdef CHILD_SPECIAL_WAITSTATUS
2024 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
2025 if it wants to deal with hoststatus. */
2026 if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
2030 if (WIFEXITED (hoststatus))
2032 ourstatus->kind = TARGET_WAITKIND_EXITED;
2033 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2035 else if (!WIFSTOPPED (hoststatus))
2037 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2038 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2042 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2043 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2047 /* In some circumstances we allow a command to specify a numeric
2048 signal. The idea is to keep these circumstances limited so that
2049 users (and scripts) develop portable habits. For comparison,
2050 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
2051 numeric signal at all is obscelescent. We are slightly more
2052 lenient and allow 1-15 which should match host signal numbers on
2053 most systems. Use of symbolic signal names is strongly encouraged. */
2056 target_signal_from_command (int num)
2058 if (num >= 1 && num <= 15)
2059 return (enum target_signal) num;
2060 error ("Only signals 1-15 are valid as numeric signals.\n\
2061 Use \"info signals\" for a list of symbolic signals.");
2064 /* Returns zero to leave the inferior alone, one to interrupt it. */
2065 int (*target_activity_function) (void);
2066 int target_activity_fd;
2068 /* Convert a normal process ID to a string. Returns the string in a static
2072 normal_pid_to_str (int pid)
2074 static char buf[30];
2076 if (STREQ (current_target.to_shortname, "remote"))
2077 sprintf (buf, "thread %d", pid);
2079 sprintf (buf, "process %d", pid);
2084 /* Some targets (such as ttrace-based HPUX) don't allow us to request
2085 notification of inferior events such as fork and vork immediately
2086 after the inferior is created. (This because of how gdb gets an
2087 inferior created via invoking a shell to do it. In such a scenario,
2088 if the shell init file has commands in it, the shell will fork and
2089 exec for each of those commands, and we will see each such fork
2092 This function is used by all targets that allow us to request
2093 notification of forks, etc at inferior creation time; e.g., in
2094 target_acknowledge_forked_child.
2097 normal_target_post_startup_inferior (int pid)
2099 /* This space intentionally left blank. */
2102 /* Set up the handful of non-empty slots needed by the dummy target
2106 init_dummy_target (void)
2108 dummy_target.to_shortname = "None";
2109 dummy_target.to_longname = "None";
2110 dummy_target.to_doc = "";
2111 dummy_target.to_attach = find_default_attach;
2112 dummy_target.to_require_attach = find_default_require_attach;
2113 dummy_target.to_require_detach = find_default_require_detach;
2114 dummy_target.to_create_inferior = find_default_create_inferior;
2115 dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
2116 dummy_target.to_pid_to_str = normal_pid_to_str;
2117 dummy_target.to_stratum = dummy_stratum;
2118 dummy_target.to_magic = OPS_MAGIC;
2122 static struct target_ops debug_target;
2125 debug_to_open (char *args, int from_tty)
2127 debug_target.to_open (args, from_tty);
2129 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2133 debug_to_close (int quitting)
2135 debug_target.to_close (quitting);
2137 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2141 debug_to_attach (char *args, int from_tty)
2143 debug_target.to_attach (args, from_tty);
2145 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
2150 debug_to_post_attach (int pid)
2152 debug_target.to_post_attach (pid);
2154 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2158 debug_to_require_attach (char *args, int from_tty)
2160 debug_target.to_require_attach (args, from_tty);
2162 fprintf_unfiltered (gdb_stdlog,
2163 "target_require_attach (%s, %d)\n", args, from_tty);
2167 debug_to_detach (char *args, int from_tty)
2169 debug_target.to_detach (args, from_tty);
2171 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
2175 debug_to_require_detach (int pid, char *args, int from_tty)
2177 debug_target.to_require_detach (pid, args, from_tty);
2179 fprintf_unfiltered (gdb_stdlog,
2180 "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
2184 debug_to_resume (int pid, int step, enum target_signal siggnal)
2186 debug_target.to_resume (pid, step, siggnal);
2188 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", pid,
2189 step ? "step" : "continue",
2190 target_signal_to_name (siggnal));
2194 debug_to_wait (int pid, struct target_waitstatus *status)
2198 retval = debug_target.to_wait (pid, status);
2200 fprintf_unfiltered (gdb_stdlog,
2201 "target_wait (%d, status) = %d, ", pid, retval);
2202 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
2203 switch (status->kind)
2205 case TARGET_WAITKIND_EXITED:
2206 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
2207 status->value.integer);
2209 case TARGET_WAITKIND_STOPPED:
2210 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
2211 target_signal_to_name (status->value.sig));
2213 case TARGET_WAITKIND_SIGNALLED:
2214 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
2215 target_signal_to_name (status->value.sig));
2217 case TARGET_WAITKIND_LOADED:
2218 fprintf_unfiltered (gdb_stdlog, "loaded\n");
2220 case TARGET_WAITKIND_FORKED:
2221 fprintf_unfiltered (gdb_stdlog, "forked\n");
2223 case TARGET_WAITKIND_VFORKED:
2224 fprintf_unfiltered (gdb_stdlog, "vforked\n");
2226 case TARGET_WAITKIND_EXECD:
2227 fprintf_unfiltered (gdb_stdlog, "execd\n");
2229 case TARGET_WAITKIND_SPURIOUS:
2230 fprintf_unfiltered (gdb_stdlog, "spurious\n");
2233 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
2241 debug_to_post_wait (int pid, int status)
2243 debug_target.to_post_wait (pid, status);
2245 fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
2250 debug_to_fetch_registers (int regno)
2252 debug_target.to_fetch_registers (regno);
2254 fprintf_unfiltered (gdb_stdlog, "target_fetch_registers (%s)",
2255 regno != -1 ? REGISTER_NAME (regno) : "-1");
2257 fprintf_unfiltered (gdb_stdlog, " = 0x%lx %ld",
2258 (unsigned long) read_register (regno),
2259 (unsigned long) read_register (regno));
2260 fprintf_unfiltered (gdb_stdlog, "\n");
2264 debug_to_store_registers (int regno)
2266 debug_target.to_store_registers (regno);
2268 if (regno >= 0 && regno < NUM_REGS)
2269 fprintf_unfiltered (gdb_stdlog, "target_store_registers (%s) = 0x%lx %ld\n",
2270 REGISTER_NAME (regno),
2271 (unsigned long) read_register (regno),
2272 (unsigned long) read_register (regno));
2274 fprintf_unfiltered (gdb_stdlog, "target_store_registers (%d)\n", regno);
2278 debug_to_prepare_to_store (void)
2280 debug_target.to_prepare_to_store ();
2282 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2286 debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
2287 struct target_ops *target)
2291 retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
2293 fprintf_unfiltered (gdb_stdlog,
2294 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2295 (unsigned int) memaddr, /* possable truncate long long */
2296 len, write ? "write" : "read", retval);
2304 fputs_unfiltered (", bytes =", gdb_stdlog);
2305 for (i = 0; i < retval; i++)
2307 if ((((long) &(myaddr[i])) & 0xf) == 0)
2308 fprintf_unfiltered (gdb_stdlog, "\n");
2309 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2313 fputc_unfiltered ('\n', gdb_stdlog);
2319 debug_to_files_info (struct target_ops *target)
2321 debug_target.to_files_info (target);
2323 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2327 debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
2331 retval = debug_target.to_insert_breakpoint (addr, save);
2333 fprintf_unfiltered (gdb_stdlog,
2334 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2335 (unsigned long) addr,
2336 (unsigned long) retval);
2341 debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
2345 retval = debug_target.to_remove_breakpoint (addr, save);
2347 fprintf_unfiltered (gdb_stdlog,
2348 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2349 (unsigned long) addr,
2350 (unsigned long) retval);
2355 debug_to_terminal_init (void)
2357 debug_target.to_terminal_init ();
2359 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2363 debug_to_terminal_inferior (void)
2365 debug_target.to_terminal_inferior ();
2367 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2371 debug_to_terminal_ours_for_output (void)
2373 debug_target.to_terminal_ours_for_output ();
2375 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2379 debug_to_terminal_ours (void)
2381 debug_target.to_terminal_ours ();
2383 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2387 debug_to_terminal_info (char *arg, int from_tty)
2389 debug_target.to_terminal_info (arg, from_tty);
2391 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2396 debug_to_kill (void)
2398 debug_target.to_kill ();
2400 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2404 debug_to_load (char *args, int from_tty)
2406 debug_target.to_load (args, from_tty);
2408 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2412 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2416 retval = debug_target.to_lookup_symbol (name, addrp);
2418 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2424 debug_to_create_inferior (char *exec_file, char *args, char **env)
2426 debug_target.to_create_inferior (exec_file, args, env);
2428 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx)\n",
2433 debug_to_post_startup_inferior (int pid)
2435 debug_target.to_post_startup_inferior (pid);
2437 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2442 debug_to_acknowledge_created_inferior (int pid)
2444 debug_target.to_acknowledge_created_inferior (pid);
2446 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2451 debug_to_clone_and_follow_inferior (int child_pid, int *followed_child)
2453 debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
2455 fprintf_unfiltered (gdb_stdlog,
2456 "target_clone_and_follow_inferior (%d, %d)\n",
2457 child_pid, *followed_child);
2461 debug_to_post_follow_inferior_by_clone (void)
2463 debug_target.to_post_follow_inferior_by_clone ();
2465 fprintf_unfiltered (gdb_stdlog, "target_post_follow_inferior_by_clone ()\n");
2469 debug_to_insert_fork_catchpoint (int pid)
2473 retval = debug_target.to_insert_fork_catchpoint (pid);
2475 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
2482 debug_to_remove_fork_catchpoint (int pid)
2486 retval = debug_target.to_remove_fork_catchpoint (pid);
2488 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2495 debug_to_insert_vfork_catchpoint (int pid)
2499 retval = debug_target.to_insert_vfork_catchpoint (pid);
2501 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
2508 debug_to_remove_vfork_catchpoint (int pid)
2512 retval = debug_target.to_remove_vfork_catchpoint (pid);
2514 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2521 debug_to_has_forked (int pid, int *child_pid)
2525 has_forked = debug_target.to_has_forked (pid, child_pid);
2527 fprintf_unfiltered (gdb_stdlog, "target_has_forked (%d, %d) = %d\n",
2528 pid, *child_pid, has_forked);
2534 debug_to_has_vforked (int pid, int *child_pid)
2538 has_vforked = debug_target.to_has_vforked (pid, child_pid);
2540 fprintf_unfiltered (gdb_stdlog, "target_has_vforked (%d, %d) = %d\n",
2541 pid, *child_pid, has_vforked);
2547 debug_to_can_follow_vfork_prior_to_exec (void)
2549 int can_immediately_follow_vfork;
2551 can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
2553 fprintf_unfiltered (gdb_stdlog, "target_can_follow_vfork_prior_to_exec () = %d\n",
2554 can_immediately_follow_vfork);
2556 return can_immediately_follow_vfork;
2560 debug_to_post_follow_vfork (int parent_pid, int followed_parent, int child_pid,
2563 debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
2565 fprintf_unfiltered (gdb_stdlog,
2566 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2567 parent_pid, followed_parent, child_pid, followed_child);
2571 debug_to_insert_exec_catchpoint (int pid)
2575 retval = debug_target.to_insert_exec_catchpoint (pid);
2577 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
2584 debug_to_remove_exec_catchpoint (int pid)
2588 retval = debug_target.to_remove_exec_catchpoint (pid);
2590 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2597 debug_to_has_execd (int pid, char **execd_pathname)
2601 has_execd = debug_target.to_has_execd (pid, execd_pathname);
2603 fprintf_unfiltered (gdb_stdlog, "target_has_execd (%d, %s) = %d\n",
2604 pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
2611 debug_to_reported_exec_events_per_exec_call (void)
2613 int reported_exec_events;
2615 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2617 fprintf_unfiltered (gdb_stdlog,
2618 "target_reported_exec_events_per_exec_call () = %d\n",
2619 reported_exec_events);
2621 return reported_exec_events;
2625 debug_to_has_syscall_event (int pid, enum target_waitkind *kind,
2628 int has_syscall_event;
2629 char *kind_spelling = "??";
2631 has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
2632 if (has_syscall_event)
2636 case TARGET_WAITKIND_SYSCALL_ENTRY:
2637 kind_spelling = "SYSCALL_ENTRY";
2639 case TARGET_WAITKIND_SYSCALL_RETURN:
2640 kind_spelling = "SYSCALL_RETURN";
2647 fprintf_unfiltered (gdb_stdlog,
2648 "target_has_syscall_event (%d, %s, %d) = %d\n",
2649 pid, kind_spelling, *syscall_id, has_syscall_event);
2651 return has_syscall_event;
2655 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2659 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2661 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2662 pid, wait_status, *exit_status, has_exited);
2668 debug_to_mourn_inferior (void)
2670 debug_target.to_mourn_inferior ();
2672 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2676 debug_to_can_run (void)
2680 retval = debug_target.to_can_run ();
2682 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2688 debug_to_notice_signals (int pid)
2690 debug_target.to_notice_signals (pid);
2692 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n", pid);
2696 debug_to_thread_alive (int pid)
2700 retval = debug_target.to_thread_alive (pid);
2702 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2709 debug_to_find_new_threads (void)
2711 debug_target.to_find_new_threads ();
2713 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2717 debug_to_stop (void)
2719 debug_target.to_stop ();
2721 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2725 debug_to_query (int type, char *req, char *resp, int *siz)
2729 retval = debug_target.to_query (type, req, resp, siz);
2731 fprintf_unfiltered (gdb_stdlog, "target_query (%c, %s, %s, %d) = %d\n", type, req, resp, *siz, retval);
2737 debug_to_rcmd (char *command,
2738 struct ui_file *outbuf)
2740 debug_target.to_rcmd (command, outbuf);
2741 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2744 static struct symtab_and_line *
2745 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2747 struct symtab_and_line *result;
2748 result = debug_target.to_enable_exception_callback (kind, enable);
2749 fprintf_unfiltered (gdb_stdlog,
2750 "target get_exception_callback_sal (%d, %d)\n",
2755 static struct exception_event_record *
2756 debug_to_get_current_exception_event (void)
2758 struct exception_event_record *result;
2759 result = debug_target.to_get_current_exception_event ();
2760 fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2765 debug_to_pid_to_exec_file (int pid)
2769 exec_file = debug_target.to_pid_to_exec_file (pid);
2771 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2778 debug_to_core_file_to_sym_file (char *core)
2782 sym_file = debug_target.to_core_file_to_sym_file (core);
2784 fprintf_unfiltered (gdb_stdlog, "target_core_file_to_sym_file (%s) = %s\n",
2791 setup_target_debug (void)
2793 memcpy (&debug_target, ¤t_target, sizeof debug_target);
2795 current_target.to_open = debug_to_open;
2796 current_target.to_close = debug_to_close;
2797 current_target.to_attach = debug_to_attach;
2798 current_target.to_post_attach = debug_to_post_attach;
2799 current_target.to_require_attach = debug_to_require_attach;
2800 current_target.to_detach = debug_to_detach;
2801 current_target.to_require_detach = debug_to_require_detach;
2802 current_target.to_resume = debug_to_resume;
2803 current_target.to_wait = debug_to_wait;
2804 current_target.to_post_wait = debug_to_post_wait;
2805 current_target.to_fetch_registers = debug_to_fetch_registers;
2806 current_target.to_store_registers = debug_to_store_registers;
2807 current_target.to_prepare_to_store = debug_to_prepare_to_store;
2808 current_target.to_xfer_memory = debug_to_xfer_memory;
2809 current_target.to_files_info = debug_to_files_info;
2810 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2811 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2812 current_target.to_terminal_init = debug_to_terminal_init;
2813 current_target.to_terminal_inferior = debug_to_terminal_inferior;
2814 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2815 current_target.to_terminal_ours = debug_to_terminal_ours;
2816 current_target.to_terminal_info = debug_to_terminal_info;
2817 current_target.to_kill = debug_to_kill;
2818 current_target.to_load = debug_to_load;
2819 current_target.to_lookup_symbol = debug_to_lookup_symbol;
2820 current_target.to_create_inferior = debug_to_create_inferior;
2821 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2822 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2823 current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior;
2824 current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone;
2825 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2826 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2827 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2828 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2829 current_target.to_has_forked = debug_to_has_forked;
2830 current_target.to_has_vforked = debug_to_has_vforked;
2831 current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec;
2832 current_target.to_post_follow_vfork = debug_to_post_follow_vfork;
2833 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2834 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2835 current_target.to_has_execd = debug_to_has_execd;
2836 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2837 current_target.to_has_syscall_event = debug_to_has_syscall_event;
2838 current_target.to_has_exited = debug_to_has_exited;
2839 current_target.to_mourn_inferior = debug_to_mourn_inferior;
2840 current_target.to_can_run = debug_to_can_run;
2841 current_target.to_notice_signals = debug_to_notice_signals;
2842 current_target.to_thread_alive = debug_to_thread_alive;
2843 current_target.to_find_new_threads = debug_to_find_new_threads;
2844 current_target.to_stop = debug_to_stop;
2845 current_target.to_query = debug_to_query;
2846 current_target.to_rcmd = debug_to_rcmd;
2847 current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2848 current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2849 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2850 current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
2855 static char targ_desc[] =
2856 "Names of targets and files being debugged.\n\
2857 Shows the entire stack of targets currently in use (including the exec-file,\n\
2858 core-file, and process, if any), as well as the symbol file name.";
2861 do_monitor_command (char *cmd,
2864 if ((current_target.to_rcmd
2865 == (void (*) (char *, struct ui_file *)) tcomplain)
2866 || (current_target.to_rcmd == debug_to_rcmd
2867 && (debug_target.to_rcmd
2868 == (void (*) (char *, struct ui_file *)) tcomplain)))
2870 error ("\"monitor\" command not supported by this target.\n");
2872 target_rcmd (cmd, gdb_stdtarg);
2876 initialize_targets (void)
2878 init_dummy_target ();
2879 push_target (&dummy_target);
2881 add_info ("target", target_info, targ_desc);
2882 add_info ("files", target_info, targ_desc);
2885 add_set_cmd ("target", class_maintenance, var_zinteger,
2886 (char *) &targetdebug,
2887 "Set target debugging.\n\
2888 When non-zero, target debugging is enabled.", &setdebuglist),
2892 add_com ("monitor", class_obscure, do_monitor_command,
2893 "Send a command to the remote monitor (remote targets only).");
2895 if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))