1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1992, 1993, 1994, 1995, 1998 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, Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
38 target_info PARAMS ((char *, int));
41 cleanup_target PARAMS ((struct target_ops *));
44 maybe_kill_then_create_inferior PARAMS ((char *, char *, char **));
47 default_clone_and_follow_inferior PARAMS ((int, int *));
50 maybe_kill_then_attach PARAMS ((char *, int));
53 kill_or_be_killed PARAMS ((int));
56 default_terminal_info PARAMS ((char *, int));
59 nosymbol PARAMS ((char *, CORE_ADDR *));
62 tcomplain PARAMS ((void));
65 nomemory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
68 return_zero PARAMS ((void));
71 return_one PARAMS ((void));
74 target_ignore PARAMS ((void));
77 target_command PARAMS ((char *, int));
79 static struct target_ops *
80 find_default_run_target PARAMS ((char *));
83 update_current_target PARAMS ((void));
85 /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
86 Returns 0 for success, errno code for failure (which includes partial
87 transfers--if you want a more useful response to partial transfers, try
88 target_read_memory_partial). */
91 target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
92 int write, asection *bfd_section));
95 debug_to_open PARAMS ((char *, int));
98 debug_to_close PARAMS ((int));
101 debug_to_attach PARAMS ((char *, int));
104 debug_to_detach PARAMS ((char *, int));
107 debug_to_resume PARAMS ((int, int, enum target_signal));
110 debug_to_wait PARAMS ((int, struct target_waitstatus *));
113 debug_to_fetch_registers PARAMS ((int));
116 debug_to_store_registers PARAMS ((int));
119 debug_to_prepare_to_store PARAMS ((void));
122 debug_to_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
125 debug_to_files_info PARAMS ((struct target_ops *));
128 debug_to_insert_breakpoint PARAMS ((CORE_ADDR, char *));
131 debug_to_remove_breakpoint PARAMS ((CORE_ADDR, char *));
134 debug_to_terminal_init PARAMS ((void));
137 debug_to_terminal_inferior PARAMS ((void));
140 debug_to_terminal_ours_for_output PARAMS ((void));
143 debug_to_terminal_ours PARAMS ((void));
146 debug_to_terminal_info PARAMS ((char *, int));
149 debug_to_kill PARAMS ((void));
152 debug_to_load PARAMS ((char *, int));
155 debug_to_lookup_symbol PARAMS ((char *, CORE_ADDR *));
158 debug_to_create_inferior PARAMS ((char *, char *, char **));
161 debug_to_mourn_inferior PARAMS ((void));
164 debug_to_can_run PARAMS ((void));
167 debug_to_notice_signals PARAMS ((int));
170 debug_to_thread_alive PARAMS ((int));
173 debug_to_stop PARAMS ((void));
175 /* Pointer to array of target architecture structures; the size of the
176 array; the current index into the array; the allocated size of the
178 struct target_ops **target_structs;
179 unsigned target_struct_size;
180 unsigned target_struct_index;
181 unsigned target_struct_allocsize;
182 #define DEFAULT_ALLOCSIZE 10
184 /* The initial current target, so that there is always a semi-valid
187 struct target_ops dummy_target = {
188 "None", /* to_shortname */
189 "None", /* to_longname */
193 find_default_attach, /* to_attach */
194 NULL, /* to_post_attach */
195 find_default_require_attach, /* to_require_attach */
197 find_default_require_detach, /* to_require_detach */
200 NULL, /* to_post_wait */
201 0, /* to_fetch_registers */
202 0, /* to_store_registers */
203 0, /* to_prepare_to_store */
204 0, /* to_xfer_memory */
205 0, /* to_files_info */
206 0, /* to_insert_breakpoint */
207 0, /* to_remove_breakpoint */
208 0, /* to_terminal_init */
209 0, /* to_terminal_inferior */
210 0, /* to_terminal_ours_for_output */
211 0, /* to_terminal_ours */
212 0, /* to_terminal_info */
215 0, /* to_lookup_symbol */
216 find_default_create_inferior, /* to_create_inferior */
217 NULL, /* to_post_startup_inferior */
218 NULL, /* to_acknowledge_created_inferior */
219 find_default_clone_and_follow_inferior, /* to_clone_and_follow_inferior */
220 NULL, /* to_post_follow_inferior_by_clone */
221 NULL, /* to_insert_fork_catchpoint */
222 NULL, /* to_remove_fork_catchpoint */
223 NULL, /* to_insert_vfork_catchpoint */
224 NULL, /* to_remove_vfork_catchpoint */
225 NULL, /* to_has_forked */
226 NULL, /* to_has_vforked */
227 NULL, /* to_can_follow_vfork_prior_to_exec */
228 NULL, /* to_post_follow_vfork */
229 NULL, /* to_insert_exec_catchpoint */
230 NULL, /* to_remove_exec_catchpoint */
231 NULL, /* to_has_execd */
232 NULL, /* to_reported_exec_events_per_exec_call */
233 NULL, /* to_has_syscall_event */
234 NULL, /* to_has_exited */
235 0, /* to_mourn_inferior */
237 0, /* to_notice_signals */
238 0, /* to_thread_alive */
240 NULL, /* to_enable_exception_callback */
241 NULL, /* to_get_current_exception_event */
242 NULL, /* to_pid_to_exec_file */
243 NULL, /* to_core_file_to_sym_file */
244 dummy_stratum, /* to_stratum */
246 0, /* to_has_all_memory */
247 0, /* to_has_memory */
248 0, /* to_has_stack */
249 0, /* to_has_registers */
250 0, /* to_has_execution */
252 0, /* to_sections_end */
253 OPS_MAGIC, /* to_magic */
256 /* Top of target stack. */
258 struct target_stack_item *target_stack;
260 /* The target structure we are currently using to talk to a process
261 or file or whatever "inferior" we have. */
263 struct target_ops current_target;
265 /* Command list for target. */
267 static struct cmd_list_element *targetlist = NULL;
269 /* Nonzero if we are debugging an attached outside process
270 rather than an inferior. */
274 #ifdef MAINTENANCE_CMDS
275 /* Non-zero if we want to see trace of target level stuff. */
277 static int targetdebug = 0;
279 static void setup_target_debug PARAMS ((void));
283 /* The user just typed 'target' without the name of a target. */
287 target_command (arg, from_tty)
291 fputs_filtered ("Argument required (target name). Try `help target'\n",
295 /* Add a possible target architecture to the list. */
299 struct target_ops *t;
303 target_struct_allocsize = DEFAULT_ALLOCSIZE;
304 target_structs = (struct target_ops **) xmalloc
305 (target_struct_allocsize * sizeof (*target_structs));
307 if (target_struct_size >= target_struct_allocsize)
309 target_struct_allocsize *= 2;
310 target_structs = (struct target_ops **)
311 xrealloc ((char *) target_structs,
312 target_struct_allocsize * sizeof (*target_structs));
314 target_structs[target_struct_size++] = t;
315 /* cleanup_target (t);*/
317 if (targetlist == NULL)
318 add_prefix_cmd ("target", class_run, target_command,
319 "Connect to a target machine or process.\n\
320 The first argument is the type or protocol of the target machine.\n\
321 Remaining arguments are interpreted by the target protocol. For more\n\
322 information on the arguments for a particular protocol, type\n\
323 `help target ' followed by the protocol name.",
324 &targetlist, "target ", 0, &cmdlist);
325 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
337 nomemory (memaddr, myaddr, len, write, t)
342 struct target_ops *t;
344 errno = EIO; /* Can't read/write this location */
345 return 0; /* No bytes handled */
351 error ("You can't do that when your target is `%s'",
352 current_target.to_shortname);
358 error ("You can't do that without a process to debug");
363 nosymbol (name, addrp)
367 return 1; /* Symbol does not exist in target env */
377 error ("No run-time support for this");
383 default_terminal_info (args, from_tty)
387 printf_unfiltered("No saved terminal information.\n");
390 /* This is the default target_create_inferior and target_attach function.
391 If the current target is executing, it asks whether to kill it off.
392 If this function returns without calling error(), it has killed off
393 the target, and the operation should be attempted. */
396 kill_or_be_killed (from_tty)
399 if (target_has_execution)
401 printf_unfiltered ("You are already running a program:\n");
402 target_files_info ();
403 if (query ("Kill it? ")) {
405 if (target_has_execution)
406 error ("Killing the program did not help.");
409 error ("Program not killed.");
416 maybe_kill_then_attach (args, from_tty)
420 kill_or_be_killed (from_tty);
421 target_attach (args, from_tty);
425 maybe_kill_then_create_inferior (exec, args, env)
430 kill_or_be_killed (0);
431 target_create_inferior (exec, args, env);
435 default_clone_and_follow_inferior (child_pid, followed_child)
439 target_clone_and_follow_inferior (child_pid, followed_child);
442 /* Clean up a target struct so it no longer has any zero pointers in it.
443 We default entries, at least to stubs that print error messages. */
447 struct target_ops *t;
450 #define de_fault(field, value) \
451 if (!t->field) t->field = value
453 /* FIELD DEFAULT VALUE */
455 de_fault (to_open, (void (*) PARAMS((char *, int))) tcomplain);
456 de_fault (to_close, (void (*) PARAMS((int))) target_ignore);
457 de_fault (to_attach, maybe_kill_then_attach);
458 de_fault (to_post_attach, (void (*) PARAMS ((int))) target_ignore);
459 de_fault (to_require_attach, maybe_kill_then_attach);
460 de_fault (to_detach, (void (*) PARAMS((char *, int))) target_ignore);
461 de_fault (to_require_detach, (void (*) PARAMS((int, char *, int))) target_ignore);
462 de_fault (to_resume, (void (*) PARAMS((int, int, enum target_signal))) noprocess);
463 de_fault (to_wait, (int (*) PARAMS((int, struct target_waitstatus *))) noprocess);
464 de_fault (to_post_wait, (void (*) PARAMS ((int, int))) target_ignore);
465 de_fault (to_fetch_registers, (void (*) PARAMS((int))) target_ignore);
466 de_fault (to_store_registers, (void (*) PARAMS((int))) noprocess);
467 de_fault (to_prepare_to_store, (void (*) PARAMS((void))) noprocess);
468 de_fault (to_xfer_memory, (int (*) PARAMS((CORE_ADDR, char *, int, int, struct target_ops *))) nomemory);
469 de_fault (to_files_info, (void (*) PARAMS((struct target_ops *))) target_ignore);
470 de_fault (to_insert_breakpoint, memory_insert_breakpoint);
471 de_fault (to_remove_breakpoint, memory_remove_breakpoint);
472 de_fault (to_terminal_init, (void (*) PARAMS((void))) target_ignore);
473 de_fault (to_terminal_inferior, (void (*) PARAMS ((void))) target_ignore);
474 de_fault (to_terminal_ours_for_output,(void (*) PARAMS ((void))) target_ignore);
475 de_fault (to_terminal_ours, (void (*) PARAMS ((void))) target_ignore);
476 de_fault (to_terminal_info, default_terminal_info);
477 de_fault (to_kill, (void (*) PARAMS((void))) noprocess);
478 de_fault (to_load, (void (*) PARAMS((char *, int))) tcomplain);
479 de_fault (to_lookup_symbol, (int (*) PARAMS ((char *, CORE_ADDR *))) nosymbol);
480 de_fault (to_create_inferior, maybe_kill_then_create_inferior);
481 de_fault (to_post_startup_inferior, (void (*) PARAMS ((int))) target_ignore);
482 de_fault (to_acknowledge_created_inferior, (void (*) PARAMS((int))) target_ignore);
483 de_fault (to_clone_and_follow_inferior, default_clone_and_follow_inferior);
484 de_fault (to_post_follow_inferior_by_clone, (void (*) PARAMS ((void))) target_ignore);
485 de_fault (to_insert_fork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
486 de_fault (to_remove_fork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
487 de_fault (to_insert_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
488 de_fault (to_remove_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
489 de_fault (to_has_forked, (int (*) PARAMS ((int, int *))) return_zero);
490 de_fault (to_has_vforked, (int (*) PARAMS ((int, int *))) return_zero);
491 de_fault (to_can_follow_vfork_prior_to_exec, (int (*) PARAMS ((void ))) return_zero);
492 de_fault (to_post_follow_vfork, (void (*) PARAMS ((int, int, int, int))) target_ignore);
493 de_fault (to_insert_exec_catchpoint, (int (*) PARAMS ((int))) tcomplain);
494 de_fault (to_remove_exec_catchpoint, (int (*) PARAMS ((int))) tcomplain);
495 de_fault (to_has_execd, (int (*) PARAMS ((int, char **))) return_zero);
496 de_fault (to_reported_exec_events_per_exec_call, (int (*) PARAMS ((void))) return_one);
497 de_fault (to_has_syscall_event, (int (*) PARAMS ((int, enum target_waitkind *, int *))) return_zero);
498 de_fault (to_has_exited, (int (*) PARAMS ((int, int, int *))) return_zero);
499 de_fault (to_mourn_inferior, (void (*) PARAMS ((void))) noprocess);
500 de_fault (to_can_run, return_zero);
501 de_fault (to_notice_signals, (void (*) PARAMS((int))) target_ignore);
502 de_fault (to_thread_alive, (int (*) PARAMS((int))) target_ignore);
503 de_fault (to_stop, (void (*) PARAMS((void))) target_ignore);
504 de_fault (to_enable_exception_callback, (struct symtab_and_line * (*) PARAMS((enum exception_event_kind, int))) nosupport_runtime);
505 de_fault (to_get_current_exception_event, (struct exception_event_record * (*) PARAMS((void))) nosupport_runtime);
507 de_fault (to_pid_to_exec_file, (char* (*) PARAMS((int))) return_zero);
508 de_fault (to_core_file_to_sym_file, (char* (*) PARAMS ((char *))) return_zero);
512 /* Go through the target stack from top to bottom, copying over zero entries in
513 current_target. In effect, we are doing class inheritance through the
514 pushed target vectors. */
517 update_current_target ()
519 struct target_stack_item *item;
520 struct target_ops *t;
522 /* First, reset current_target */
523 memset (¤t_target, 0, sizeof current_target);
525 for (item = target_stack; item; item = item->next)
527 t = item->target_ops;
529 #define INHERIT(FIELD, TARGET) \
530 if (!current_target.FIELD) \
531 current_target.FIELD = TARGET->FIELD
533 INHERIT (to_shortname, t);
534 INHERIT (to_longname, t);
536 INHERIT (to_open, t);
537 INHERIT (to_close, t);
538 INHERIT (to_attach, t);
539 INHERIT (to_post_attach, t);
540 INHERIT (to_require_attach, t);
541 INHERIT (to_detach, t);
542 INHERIT (to_require_detach, t);
543 INHERIT (to_resume, t);
544 INHERIT (to_wait, t);
545 INHERIT (to_post_wait, t);
546 INHERIT (to_fetch_registers, t);
547 INHERIT (to_store_registers, t);
548 INHERIT (to_prepare_to_store, t);
549 INHERIT (to_xfer_memory, t);
550 INHERIT (to_files_info, t);
551 INHERIT (to_insert_breakpoint, t);
552 INHERIT (to_remove_breakpoint, t);
553 INHERIT (to_terminal_init, t);
554 INHERIT (to_terminal_inferior, t);
555 INHERIT (to_terminal_ours_for_output, t);
556 INHERIT (to_terminal_ours, t);
557 INHERIT (to_terminal_info, t);
558 INHERIT (to_kill, t);
559 INHERIT (to_load, t);
560 INHERIT (to_lookup_symbol, t);
561 INHERIT (to_create_inferior, t);
562 INHERIT (to_post_startup_inferior, t);
563 INHERIT (to_acknowledge_created_inferior, t);
564 INHERIT (to_clone_and_follow_inferior, t);
565 INHERIT (to_post_follow_inferior_by_clone, t);
566 INHERIT (to_insert_fork_catchpoint, t);
567 INHERIT (to_remove_fork_catchpoint, t);
568 INHERIT (to_insert_vfork_catchpoint, t);
569 INHERIT (to_remove_vfork_catchpoint, t);
570 INHERIT (to_has_forked, t);
571 INHERIT (to_has_vforked, t);
572 INHERIT (to_can_follow_vfork_prior_to_exec, t);
573 INHERIT (to_post_follow_vfork, t);
574 INHERIT (to_insert_exec_catchpoint, t);
575 INHERIT (to_remove_exec_catchpoint, t);
576 INHERIT (to_has_execd, t);
577 INHERIT (to_reported_exec_events_per_exec_call, t);
578 INHERIT (to_has_syscall_event, t);
579 INHERIT (to_has_exited, t);
580 INHERIT (to_mourn_inferior, t);
581 INHERIT (to_can_run, t);
582 INHERIT (to_notice_signals, t);
583 INHERIT (to_thread_alive, t);
584 INHERIT (to_stop, t);
585 INHERIT (to_enable_exception_callback, t);
586 INHERIT (to_get_current_exception_event, t);
587 INHERIT (to_pid_to_exec_file, t);
588 INHERIT (to_core_file_to_sym_file, t);
589 INHERIT (to_stratum, t);
590 INHERIT (DONT_USE, t);
591 INHERIT (to_has_all_memory, t);
592 INHERIT (to_has_memory, t);
593 INHERIT (to_has_stack, t);
594 INHERIT (to_has_registers, t);
595 INHERIT (to_has_execution, t);
596 INHERIT (to_sections, t);
597 INHERIT (to_sections_end, t);
598 INHERIT (to_magic, t);
604 /* Push a new target type into the stack of the existing target accessors,
605 possibly superseding some of the existing accessors.
607 Result is zero if the pushed target ended up on top of the stack,
608 nonzero if at least one target is on top of it.
610 Rather than allow an empty stack, we always have the dummy target at
611 the bottom stratum, so we can call the function vectors without
616 struct target_ops *t;
618 struct target_stack_item *cur, *prev, *tmp;
620 /* Check magic number. If wrong, it probably means someone changed
621 the struct definition, but not all the places that initialize one. */
622 if (t->to_magic != OPS_MAGIC)
624 fprintf_unfiltered(gdb_stderr,
625 "Magic number of %s target struct wrong\n",
630 /* Find the proper stratum to install this target in. */
632 for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
634 if ((int)(t->to_stratum) >= (int)(cur->target_ops->to_stratum))
638 /* If there's already targets at this stratum, remove them. */
641 while (t->to_stratum == cur->target_ops->to_stratum)
643 /* There's already something on this stratum. Close it off. */
644 if (cur->target_ops->to_close)
645 (cur->target_ops->to_close) (0);
647 prev->next = cur->next; /* Unchain old target_ops */
649 target_stack = cur->next; /* Unchain first on list */
655 /* We have removed all targets in our stratum, now add the new one. */
657 tmp = (struct target_stack_item *)
658 xmalloc (sizeof (struct target_stack_item));
667 update_current_target ();
669 cleanup_target (¤t_target); /* Fill in the gaps */
671 #ifdef MAINTENANCE_CMDS
673 setup_target_debug ();
679 /* Remove a target_ops vector from the stack, wherever it may be.
680 Return how many times it was removed (0 or 1). */
684 struct target_ops *t;
686 struct target_stack_item *cur, *prev;
689 t->to_close (0); /* Let it clean up */
691 /* Look for the specified target. Note that we assume that a target
692 can only occur once in the target stack. */
694 for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
695 if (cur->target_ops == t)
699 return 0; /* Didn't find target_ops, quit now */
701 /* Unchain the target */
704 target_stack = cur->next;
706 prev->next = cur->next;
708 free (cur); /* Release the target_stack_item */
710 update_current_target ();
711 cleanup_target (¤t_target);
719 (current_target.to_close)(0); /* Let it clean up */
720 if (unpush_target (target_stack->target_ops) == 1)
723 fprintf_unfiltered(gdb_stderr,
724 "pop_target couldn't find target %s\n",
725 current_target.to_shortname);
730 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
732 /* target_read_string -- read a null terminated string, up to LEN bytes,
733 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
734 Set *STRING to a pointer to malloc'd memory containing the data; the caller
735 is responsible for freeing it. Return the number of bytes successfully
739 target_read_string (memaddr, string, len, errnop)
745 int tlen, origlen, offset, i;
749 int buffer_allocated;
751 unsigned int nbytes_read = 0;
753 /* Small for testing. */
754 buffer_allocated = 4;
755 buffer = xmalloc (buffer_allocated);
762 tlen = MIN (len, 4 - (memaddr & 3));
763 offset = memaddr & 3;
765 errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0, NULL);
768 /* The transfer request might have crossed the boundary to an
769 unallocated region of memory. Retry the transfer, requesting
773 errcode = target_xfer_memory (memaddr, buf, 1, 0, NULL);
778 if (bufptr - buffer + tlen > buffer_allocated)
781 bytes = bufptr - buffer;
782 buffer_allocated *= 2;
783 buffer = xrealloc (buffer, buffer_allocated);
784 bufptr = buffer + bytes;
787 for (i = 0; i < tlen; i++)
789 *bufptr++ = buf[i + offset];
790 if (buf[i + offset] == '\000')
792 nbytes_read += i + 1;
809 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
810 GDB's memory at MYADDR. Returns either 0 for success or an errno value
813 If an error occurs, no guarantee is made about the contents of the data at
814 MYADDR. In particular, the caller should not depend upon partial reads
815 filling the buffer with good data. There is no way for the caller to know
816 how much good data might have been transfered anyway. Callers that can
817 deal with partial reads should call target_read_memory_partial. */
820 target_read_memory (memaddr, myaddr, len)
825 return target_xfer_memory (memaddr, myaddr, len, 0, NULL);
829 target_read_memory_section (memaddr, myaddr, len, bfd_section)
833 asection *bfd_section;
835 return target_xfer_memory (memaddr, myaddr, len, 0, bfd_section);
838 /* Read LEN bytes of target memory at address MEMADDR, placing the results
839 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
840 and optionally an errno value in the location pointed to by ERRNOPTR
841 if ERRNOPTR is non-null. */
844 target_read_memory_partial (memaddr, myaddr, len, errnoptr)
850 int nread; /* Number of bytes actually read. */
851 int errcode; /* Error from last read. */
853 /* First try a complete read. */
854 errcode = target_xfer_memory (memaddr, myaddr, len, 0, NULL);
862 /* Loop, reading one byte at a time until we get as much as we can. */
863 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
865 errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0, NULL);
867 /* If an error, the last read was unsuccessful, so adjust count. */
873 if (errnoptr != NULL)
881 target_write_memory (memaddr, myaddr, len)
886 return target_xfer_memory (memaddr, myaddr, len, 1, NULL);
889 /* This variable is used to pass section information down to targets. This
890 *should* be done by adding an argument to the target_xfer_memory function
891 of all the targets, but I didn't feel like changing 50+ files. */
893 asection *target_memory_bfd_section = NULL;
895 /* Move memory to or from the targets. Iterate until all of it has
896 been moved, if necessary. The top target gets priority; anything
897 it doesn't want, is offered to the next one down, etc. Note the
898 business with curlen: if an early target says "no, but I have a
899 boundary overlapping this xfer" then we shorten what we offer to
900 the subsequent targets so the early guy will get a chance at the
901 tail before the subsequent ones do.
903 Result is 0 or errno value. */
906 target_xfer_memory (memaddr, myaddr, len, write, bfd_section)
911 asection *bfd_section;
915 struct target_ops *t;
916 struct target_stack_item *item;
918 /* Zero length requests are ok and require no work. */
922 target_memory_bfd_section = bfd_section;
924 /* to_xfer_memory is not guaranteed to set errno, even when it returns
928 /* The quick case is that the top target does it all. */
929 res = current_target.to_xfer_memory
930 (memaddr, myaddr, len, write, ¤t_target);
936 /* If res <= 0 then we call it again in the loop. Ah well. */
940 curlen = len; /* Want to do it all */
941 for (item = target_stack; item; item = item->next)
943 t = item->target_ops;
944 if (!t->to_has_memory)
947 res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
949 break; /* Handled all or part of xfer */
950 if (t->to_has_all_memory)
956 /* If this address is for nonexistent memory,
957 read zeros if reading, or do nothing if writing. Return error. */
959 memset (myaddr, 0, len);
970 return 0; /* We managed to cover it all somehow. */
976 target_info (args, from_tty)
980 struct target_ops *t;
981 struct target_stack_item *item;
984 if (symfile_objfile != NULL)
985 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
987 #ifdef FILES_INFO_HOOK
988 if (FILES_INFO_HOOK ())
992 for (item = target_stack; item; item = item->next)
994 t = item->target_ops;
996 if (!t->to_has_memory)
999 if ((int)(t->to_stratum) <= (int)dummy_stratum)
1002 printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
1003 printf_unfiltered("%s:\n", t->to_longname);
1004 (t->to_files_info)(t);
1005 has_all_mem = t->to_has_all_memory;
1009 /* This is to be called by the open routine before it does
1013 target_preopen (from_tty)
1018 if (target_has_execution)
1020 if (query ("A program is being debugged already. Kill it? "))
1023 error ("Program not killed.");
1026 /* Calling target_kill may remove the target from the stack. But if
1027 it doesn't (which seems like a win for UDI), remove it now. */
1029 if (target_has_execution)
1033 /* Detach a target after doing deferred register stores. */
1036 target_detach (args, from_tty)
1040 /* Handle any optimized stores to the inferior. */
1041 #ifdef DO_DEFERRED_STORES
1044 (current_target.to_detach) (args, from_tty);
1048 target_link (modname, t_reloc)
1052 if (STREQ(current_target.to_shortname, "rombug"))
1054 (current_target.to_lookup_symbol) (modname, t_reloc);
1056 error("Unable to link to %s and get relocation in rombug", modname);
1059 *t_reloc = (CORE_ADDR)-1;
1062 /* Look through the list of possible targets for a target that can
1063 execute a run or attach command without any other data. This is
1064 used to locate the default process stratum.
1066 Result is always valid (error() is called for errors). */
1068 static struct target_ops *
1069 find_default_run_target (do_mesg)
1072 struct target_ops **t;
1073 struct target_ops *runable = NULL;
1078 for (t = target_structs; t < target_structs + target_struct_size;
1081 if ((*t)->to_can_run && target_can_run(*t))
1089 error ("Don't know how to %s. Try \"help target\".", do_mesg);
1095 find_default_attach (args, from_tty)
1099 struct target_ops *t;
1101 t = find_default_run_target("attach");
1102 (t->to_attach) (args, from_tty);
1107 find_default_require_attach (args, 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 (pid, args, from_tty)
1124 struct target_ops *t;
1126 t = find_default_run_target("require_detach");
1127 (t->to_require_detach) (pid, args, from_tty);
1132 find_default_create_inferior (exec_file, allargs, env)
1137 struct target_ops *t;
1139 t = find_default_run_target("run");
1140 (t->to_create_inferior) (exec_file, allargs, env);
1145 find_default_clone_and_follow_inferior (child_pid, followed_child)
1147 int *followed_child;
1149 struct target_ops *t;
1151 t = find_default_run_target("run");
1152 (t->to_clone_and_follow_inferior) (child_pid, followed_child);
1171 struct target_ops **t;
1172 struct target_ops *runable = NULL;
1177 for (t = target_structs; t < target_structs + target_struct_size;
1180 if ((*t)->to_stratum == core_stratum)
1187 return(count == 1 ? runable : NULL);
1190 /* The inferior process has died. Long live the inferior! */
1193 generic_mourn_inferior ()
1195 extern int show_breakpoint_hit_counts;
1199 breakpoint_init_inferior (inf_exited);
1200 registers_changed ();
1202 #ifdef CLEAR_DEFERRED_STORES
1203 /* Delete any pending stores to the inferior... */
1204 CLEAR_DEFERRED_STORES;
1207 reopen_exec_file ();
1208 reinit_frame_cache ();
1210 /* It is confusing to the user for ignore counts to stick around
1211 from previous runs of the inferior. So clear them. */
1212 /* However, it is more confusing for the ignore counts to disappear when
1213 using hit counts. So don't clear them if we're counting hits. */
1214 if (!show_breakpoint_hit_counts)
1215 breakpoint_clear_ignore_counts ();
1218 /* This table must match in order and size the signals in enum target_signal
1226 {"SIGHUP", "Hangup"},
1227 {"SIGINT", "Interrupt"},
1228 {"SIGQUIT", "Quit"},
1229 {"SIGILL", "Illegal instruction"},
1230 {"SIGTRAP", "Trace/breakpoint trap"},
1231 {"SIGABRT", "Aborted"},
1232 {"SIGEMT", "Emulation trap"},
1233 {"SIGFPE", "Arithmetic exception"},
1234 {"SIGKILL", "Killed"},
1235 {"SIGBUS", "Bus error"},
1236 {"SIGSEGV", "Segmentation fault"},
1237 {"SIGSYS", "Bad system call"},
1238 {"SIGPIPE", "Broken pipe"},
1239 {"SIGALRM", "Alarm clock"},
1240 {"SIGTERM", "Terminated"},
1241 {"SIGURG", "Urgent I/O condition"},
1242 {"SIGSTOP", "Stopped (signal)"},
1243 {"SIGTSTP", "Stopped (user)"},
1244 {"SIGCONT", "Continued"},
1245 {"SIGCHLD", "Child status changed"},
1246 {"SIGTTIN", "Stopped (tty input)"},
1247 {"SIGTTOU", "Stopped (tty output)"},
1248 {"SIGIO", "I/O possible"},
1249 {"SIGXCPU", "CPU time limit exceeded"},
1250 {"SIGXFSZ", "File size limit exceeded"},
1251 {"SIGVTALRM", "Virtual timer expired"},
1252 {"SIGPROF", "Profiling timer expired"},
1253 {"SIGWINCH", "Window size changed"},
1254 {"SIGLOST", "Resource lost"},
1255 {"SIGUSR1", "User defined signal 1"},
1256 {"SIGUSR2", "User defined signal 2"},
1257 {"SIGPWR", "Power fail/restart"},
1258 {"SIGPOLL", "Pollable event occurred"},
1259 {"SIGWIND", "SIGWIND"},
1260 {"SIGPHONE", "SIGPHONE"},
1261 {"SIGWAITING", "Process's LWPs are blocked"},
1262 {"SIGLWP", "Signal LWP"},
1263 {"SIGDANGER", "Swap space dangerously low"},
1264 {"SIGGRANT", "Monitor mode granted"},
1265 {"SIGRETRACT", "Need to relinquish monitor mode"},
1266 {"SIGMSG", "Monitor mode data available"},
1267 {"SIGSOUND", "Sound completed"},
1268 {"SIGSAK", "Secure attention"},
1269 {"SIGPRIO", "SIGPRIO"},
1270 {"SIG33", "Real-time event 33"},
1271 {"SIG34", "Real-time event 34"},
1272 {"SIG35", "Real-time event 35"},
1273 {"SIG36", "Real-time event 36"},
1274 {"SIG37", "Real-time event 37"},
1275 {"SIG38", "Real-time event 38"},
1276 {"SIG39", "Real-time event 39"},
1277 {"SIG40", "Real-time event 40"},
1278 {"SIG41", "Real-time event 41"},
1279 {"SIG42", "Real-time event 42"},
1280 {"SIG43", "Real-time event 43"},
1281 {"SIG44", "Real-time event 44"},
1282 {"SIG45", "Real-time event 45"},
1283 {"SIG46", "Real-time event 46"},
1284 {"SIG47", "Real-time event 47"},
1285 {"SIG48", "Real-time event 48"},
1286 {"SIG49", "Real-time event 49"},
1287 {"SIG50", "Real-time event 50"},
1288 {"SIG51", "Real-time event 51"},
1289 {"SIG52", "Real-time event 52"},
1290 {"SIG53", "Real-time event 53"},
1291 {"SIG54", "Real-time event 54"},
1292 {"SIG55", "Real-time event 55"},
1293 {"SIG56", "Real-time event 56"},
1294 {"SIG57", "Real-time event 57"},
1295 {"SIG58", "Real-time event 58"},
1296 {"SIG59", "Real-time event 59"},
1297 {"SIG60", "Real-time event 60"},
1298 {"SIG61", "Real-time event 61"},
1299 {"SIG62", "Real-time event 62"},
1300 {"SIG63", "Real-time event 63"},
1302 #if defined(MACH) || defined(__MACH__)
1303 /* Mach exceptions */
1304 {"EXC_BAD_ACCESS", "Could not access memory"},
1305 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1306 {"EXC_ARITHMETIC", "Arithmetic exception"},
1307 {"EXC_EMULATION", "Emulation instruction"},
1308 {"EXC_SOFTWARE", "Software generated exception"},
1309 {"EXC_BREAKPOINT", "Breakpoint"},
1311 {NULL, "Unknown signal"},
1312 {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1314 /* Last entry, used to check whether the table is the right size. */
1315 {NULL, "TARGET_SIGNAL_MAGIC"}
1318 /* Return the string for a signal. */
1320 target_signal_to_string (sig)
1321 enum target_signal sig;
1323 return signals[sig].string;
1326 /* Return the name for a signal. */
1328 target_signal_to_name (sig)
1329 enum target_signal sig;
1331 if (sig == TARGET_SIGNAL_UNKNOWN)
1332 /* I think the code which prints this will always print it along with
1333 the string, so no need to be verbose. */
1335 return signals[sig].name;
1338 /* Given a name, return its signal. */
1340 target_signal_from_name (name)
1343 enum target_signal sig;
1345 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1346 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1347 questionable; seems like by now people should call it SIGABRT
1350 /* This ugly cast brought to you by the native VAX compiler. */
1351 for (sig = TARGET_SIGNAL_HUP;
1352 signals[sig].name != NULL;
1353 sig = (enum target_signal)((int)sig + 1))
1354 if (STREQ (name, signals[sig].name))
1356 return TARGET_SIGNAL_UNKNOWN;
1359 /* The following functions are to help certain targets deal
1360 with the signal/waitstatus stuff. They could just as well be in
1361 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1363 /* Convert host signal to our signals. */
1365 target_signal_from_host (hostsig)
1368 /* A switch statement would make sense but would require special kludges
1369 to deal with the cases where more than one signal has the same number. */
1371 if (hostsig == 0) return TARGET_SIGNAL_0;
1373 #if defined (SIGHUP)
1374 if (hostsig == SIGHUP) return TARGET_SIGNAL_HUP;
1376 #if defined (SIGINT)
1377 if (hostsig == SIGINT) return TARGET_SIGNAL_INT;
1379 #if defined (SIGQUIT)
1380 if (hostsig == SIGQUIT) return TARGET_SIGNAL_QUIT;
1382 #if defined (SIGILL)
1383 if (hostsig == SIGILL) return TARGET_SIGNAL_ILL;
1385 #if defined (SIGTRAP)
1386 if (hostsig == SIGTRAP) return TARGET_SIGNAL_TRAP;
1388 #if defined (SIGABRT)
1389 if (hostsig == SIGABRT) return TARGET_SIGNAL_ABRT;
1391 #if defined (SIGEMT)
1392 if (hostsig == SIGEMT) return TARGET_SIGNAL_EMT;
1394 #if defined (SIGFPE)
1395 if (hostsig == SIGFPE) return TARGET_SIGNAL_FPE;
1397 #if defined (SIGKILL)
1398 if (hostsig == SIGKILL) return TARGET_SIGNAL_KILL;
1400 #if defined (SIGBUS)
1401 if (hostsig == SIGBUS) return TARGET_SIGNAL_BUS;
1403 #if defined (SIGSEGV)
1404 if (hostsig == SIGSEGV) return TARGET_SIGNAL_SEGV;
1406 #if defined (SIGSYS)
1407 if (hostsig == SIGSYS) return TARGET_SIGNAL_SYS;
1409 #if defined (SIGPIPE)
1410 if (hostsig == SIGPIPE) return TARGET_SIGNAL_PIPE;
1412 #if defined (SIGALRM)
1413 if (hostsig == SIGALRM) return TARGET_SIGNAL_ALRM;
1415 #if defined (SIGTERM)
1416 if (hostsig == SIGTERM) return TARGET_SIGNAL_TERM;
1418 #if defined (SIGUSR1)
1419 if (hostsig == SIGUSR1) return TARGET_SIGNAL_USR1;
1421 #if defined (SIGUSR2)
1422 if (hostsig == SIGUSR2) return TARGET_SIGNAL_USR2;
1424 #if defined (SIGCLD)
1425 if (hostsig == SIGCLD) return TARGET_SIGNAL_CHLD;
1427 #if defined (SIGCHLD)
1428 if (hostsig == SIGCHLD) return TARGET_SIGNAL_CHLD;
1430 #if defined (SIGPWR)
1431 if (hostsig == SIGPWR) return TARGET_SIGNAL_PWR;
1433 #if defined (SIGWINCH)
1434 if (hostsig == SIGWINCH) return TARGET_SIGNAL_WINCH;
1436 #if defined (SIGURG)
1437 if (hostsig == SIGURG) return TARGET_SIGNAL_URG;
1440 if (hostsig == SIGIO) return TARGET_SIGNAL_IO;
1442 #if defined (SIGPOLL)
1443 if (hostsig == SIGPOLL) return TARGET_SIGNAL_POLL;
1445 #if defined (SIGSTOP)
1446 if (hostsig == SIGSTOP) return TARGET_SIGNAL_STOP;
1448 #if defined (SIGTSTP)
1449 if (hostsig == SIGTSTP) return TARGET_SIGNAL_TSTP;
1451 #if defined (SIGCONT)
1452 if (hostsig == SIGCONT) return TARGET_SIGNAL_CONT;
1454 #if defined (SIGTTIN)
1455 if (hostsig == SIGTTIN) return TARGET_SIGNAL_TTIN;
1457 #if defined (SIGTTOU)
1458 if (hostsig == SIGTTOU) return TARGET_SIGNAL_TTOU;
1460 #if defined (SIGVTALRM)
1461 if (hostsig == SIGVTALRM) return TARGET_SIGNAL_VTALRM;
1463 #if defined (SIGPROF)
1464 if (hostsig == SIGPROF) return TARGET_SIGNAL_PROF;
1466 #if defined (SIGXCPU)
1467 if (hostsig == SIGXCPU) return TARGET_SIGNAL_XCPU;
1469 #if defined (SIGXFSZ)
1470 if (hostsig == SIGXFSZ) return TARGET_SIGNAL_XFSZ;
1472 #if defined (SIGWIND)
1473 if (hostsig == SIGWIND) return TARGET_SIGNAL_WIND;
1475 #if defined (SIGPHONE)
1476 if (hostsig == SIGPHONE) return TARGET_SIGNAL_PHONE;
1478 #if defined (SIGLOST)
1479 if (hostsig == SIGLOST) return TARGET_SIGNAL_LOST;
1481 #if defined (SIGWAITING)
1482 if (hostsig == SIGWAITING) return TARGET_SIGNAL_WAITING;
1484 #if defined (SIGLWP)
1485 if (hostsig == SIGLWP) return TARGET_SIGNAL_LWP;
1487 #if defined (SIGDANGER)
1488 if (hostsig == SIGDANGER) return TARGET_SIGNAL_DANGER;
1490 #if defined (SIGGRANT)
1491 if (hostsig == SIGGRANT) return TARGET_SIGNAL_GRANT;
1493 #if defined (SIGRETRACT)
1494 if (hostsig == SIGRETRACT) return TARGET_SIGNAL_RETRACT;
1496 #if defined (SIGMSG)
1497 if (hostsig == SIGMSG) return TARGET_SIGNAL_MSG;
1499 #if defined (SIGSOUND)
1500 if (hostsig == SIGSOUND) return TARGET_SIGNAL_SOUND;
1502 #if defined (SIGSAK)
1503 if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK;
1505 #if defined (SIGPRIO)
1506 if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO;
1509 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1510 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1511 if (hostsig == _NSIG + EXC_BAD_ACCESS) return TARGET_EXC_BAD_ACCESS;
1513 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1514 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) return TARGET_EXC_BAD_INSTRUCTION;
1516 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1517 if (hostsig == _NSIG + EXC_ARITHMETIC) return TARGET_EXC_ARITHMETIC;
1519 #if defined (EXC_EMULATION) && defined (_NSIG)
1520 if (hostsig == _NSIG + EXC_EMULATION) return TARGET_EXC_EMULATION;
1522 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1523 if (hostsig == _NSIG + EXC_SOFTWARE) return TARGET_EXC_SOFTWARE;
1525 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1526 if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
1529 #if defined (REALTIME_LO)
1530 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
1531 return (enum target_signal)
1532 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
1534 return TARGET_SIGNAL_UNKNOWN;
1538 target_signal_to_host (oursig)
1539 enum target_signal oursig;
1543 case TARGET_SIGNAL_0: return 0;
1545 #if defined (SIGHUP)
1546 case TARGET_SIGNAL_HUP: return SIGHUP;
1548 #if defined (SIGINT)
1549 case TARGET_SIGNAL_INT: return SIGINT;
1551 #if defined (SIGQUIT)
1552 case TARGET_SIGNAL_QUIT: return SIGQUIT;
1554 #if defined (SIGILL)
1555 case TARGET_SIGNAL_ILL: return SIGILL;
1557 #if defined (SIGTRAP)
1558 case TARGET_SIGNAL_TRAP: return SIGTRAP;
1560 #if defined (SIGABRT)
1561 case TARGET_SIGNAL_ABRT: return SIGABRT;
1563 #if defined (SIGEMT)
1564 case TARGET_SIGNAL_EMT: return SIGEMT;
1566 #if defined (SIGFPE)
1567 case TARGET_SIGNAL_FPE: return SIGFPE;
1569 #if defined (SIGKILL)
1570 case TARGET_SIGNAL_KILL: return SIGKILL;
1572 #if defined (SIGBUS)
1573 case TARGET_SIGNAL_BUS: return SIGBUS;
1575 #if defined (SIGSEGV)
1576 case TARGET_SIGNAL_SEGV: return SIGSEGV;
1578 #if defined (SIGSYS)
1579 case TARGET_SIGNAL_SYS: return SIGSYS;
1581 #if defined (SIGPIPE)
1582 case TARGET_SIGNAL_PIPE: return SIGPIPE;
1584 #if defined (SIGALRM)
1585 case TARGET_SIGNAL_ALRM: return SIGALRM;
1587 #if defined (SIGTERM)
1588 case TARGET_SIGNAL_TERM: return SIGTERM;
1590 #if defined (SIGUSR1)
1591 case TARGET_SIGNAL_USR1: return SIGUSR1;
1593 #if defined (SIGUSR2)
1594 case TARGET_SIGNAL_USR2: return SIGUSR2;
1596 #if defined (SIGCHLD) || defined (SIGCLD)
1597 case TARGET_SIGNAL_CHLD:
1598 #if defined (SIGCHLD)
1603 #endif /* SIGCLD or SIGCHLD */
1604 #if defined (SIGPWR)
1605 case TARGET_SIGNAL_PWR: return SIGPWR;
1607 #if defined (SIGWINCH)
1608 case TARGET_SIGNAL_WINCH: return SIGWINCH;
1610 #if defined (SIGURG)
1611 case TARGET_SIGNAL_URG: return SIGURG;
1614 case TARGET_SIGNAL_IO: return SIGIO;
1616 #if defined (SIGPOLL)
1617 case TARGET_SIGNAL_POLL: return SIGPOLL;
1619 #if defined (SIGSTOP)
1620 case TARGET_SIGNAL_STOP: return SIGSTOP;
1622 #if defined (SIGTSTP)
1623 case TARGET_SIGNAL_TSTP: return SIGTSTP;
1625 #if defined (SIGCONT)
1626 case TARGET_SIGNAL_CONT: return SIGCONT;
1628 #if defined (SIGTTIN)
1629 case TARGET_SIGNAL_TTIN: return SIGTTIN;
1631 #if defined (SIGTTOU)
1632 case TARGET_SIGNAL_TTOU: return SIGTTOU;
1634 #if defined (SIGVTALRM)
1635 case TARGET_SIGNAL_VTALRM: return SIGVTALRM;
1637 #if defined (SIGPROF)
1638 case TARGET_SIGNAL_PROF: return SIGPROF;
1640 #if defined (SIGXCPU)
1641 case TARGET_SIGNAL_XCPU: return SIGXCPU;
1643 #if defined (SIGXFSZ)
1644 case TARGET_SIGNAL_XFSZ: return SIGXFSZ;
1646 #if defined (SIGWIND)
1647 case TARGET_SIGNAL_WIND: return SIGWIND;
1649 #if defined (SIGPHONE)
1650 case TARGET_SIGNAL_PHONE: return SIGPHONE;
1652 #if defined (SIGLOST)
1653 case TARGET_SIGNAL_LOST: return SIGLOST;
1655 #if defined (SIGWAITING)
1656 case TARGET_SIGNAL_WAITING: return SIGWAITING;
1658 #if defined (SIGLWP)
1659 case TARGET_SIGNAL_LWP: return SIGLWP;
1661 #if defined (SIGDANGER)
1662 case TARGET_SIGNAL_DANGER: return SIGDANGER;
1664 #if defined (SIGGRANT)
1665 case TARGET_SIGNAL_GRANT: return SIGGRANT;
1667 #if defined (SIGRETRACT)
1668 case TARGET_SIGNAL_RETRACT: return SIGRETRACT;
1670 #if defined (SIGMSG)
1671 case TARGET_SIGNAL_MSG: return SIGMSG;
1673 #if defined (SIGSOUND)
1674 case TARGET_SIGNAL_SOUND: return SIGSOUND;
1676 #if defined (SIGSAK)
1677 case TARGET_SIGNAL_SAK: return SIGSAK;
1679 #if defined (SIGPRIO)
1680 case TARGET_SIGNAL_PRIO: return SIGPRIO;
1683 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1684 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1685 case TARGET_EXC_BAD_ACCESS: return _NSIG + EXC_BAD_ACCESS;
1687 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1688 case TARGET_EXC_BAD_INSTRUCTION: return _NSIG + EXC_BAD_INSTRUCTION;
1690 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1691 case TARGET_EXC_ARITHMETIC: return _NSIG + EXC_ARITHMETIC;
1693 #if defined (EXC_EMULATION) && defined (_NSIG)
1694 case TARGET_EXC_EMULATION: return _NSIG + EXC_EMULATION;
1696 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1697 case TARGET_EXC_SOFTWARE: return _NSIG + EXC_SOFTWARE;
1699 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1700 case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
1704 #if defined (REALTIME_LO)
1705 if (oursig >= TARGET_SIGNAL_REALTIME_33
1706 && oursig <= TARGET_SIGNAL_REALTIME_63)
1709 (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + REALTIME_LO;
1710 if (retsig < REALTIME_HI)
1714 /* The user might be trying to do "signal SIGSAK" where this system
1715 doesn't have SIGSAK. */
1716 warning ("Signal %s does not exist on this system.\n",
1717 target_signal_to_name (oursig));
1722 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1723 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1724 translation of that in OURSTATUS. */
1726 store_waitstatus (ourstatus, hoststatus)
1727 struct target_waitstatus *ourstatus;
1730 #ifdef CHILD_SPECIAL_WAITSTATUS
1731 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1732 if it wants to deal with hoststatus. */
1733 if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1737 if (WIFEXITED (hoststatus))
1739 ourstatus->kind = TARGET_WAITKIND_EXITED;
1740 ourstatus->value.integer = WEXITSTATUS (hoststatus);
1742 else if (!WIFSTOPPED (hoststatus))
1744 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1745 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1749 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1750 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1754 /* In some circumstances we allow a command to specify a numeric
1755 signal. The idea is to keep these circumstances limited so that
1756 users (and scripts) develop portable habits. For comparison,
1757 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1758 numeric signal at all is obscelescent. We are slightly more
1759 lenient and allow 1-15 which should match host signal numbers on
1760 most systems. Use of symbolic signal names is strongly encouraged. */
1763 target_signal_from_command (num)
1766 if (num >= 1 && num <= 15)
1767 return (enum target_signal)num;
1768 error ("Only signals 1-15 are valid as numeric signals.\n\
1769 Use \"info signals\" for a list of symbolic signals.");
1772 /* Returns zero to leave the inferior alone, one to interrupt it. */
1773 int (*target_activity_function) PARAMS ((void));
1774 int target_activity_fd;
1776 /* Convert a normal process ID to a string. Returns the string in a static
1780 normal_pid_to_str (pid)
1783 static char buf[30];
1785 if (STREQ (current_target.to_shortname, "remote"))
1786 sprintf (buf, "thread %d\0", pid);
1788 sprintf (buf, "process %d\0", pid);
1793 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1794 notification of inferior events such as fork and vork immediately
1795 after the inferior is created. (This because of how gdb gets an
1796 inferior created via invoking a shell to do it. In such a scenario,
1797 if the shell init file has commands in it, the shell will fork and
1798 exec for each of those commands, and we will see each such fork
1801 This function is used by all targets that allow us to request
1802 notification of forks, etc at inferior creation time; e.g., in
1803 target_acknowledge_forked_child.
1806 normal_target_post_startup_inferior (pid)
1809 /* This space intentionally left blank. */
1813 #ifdef MAINTENANCE_CMDS
1814 static struct target_ops debug_target;
1817 debug_to_open (args, from_tty)
1821 debug_target.to_open (args, from_tty);
1823 fprintf_unfiltered (gdb_stderr, "target_open (%s, %d)\n", args, from_tty);
1827 debug_to_close (quitting)
1830 debug_target.to_close (quitting);
1832 fprintf_unfiltered (gdb_stderr, "target_close (%d)\n", quitting);
1836 debug_to_attach (args, from_tty)
1840 debug_target.to_attach (args, from_tty);
1842 fprintf_unfiltered (gdb_stderr, "target_attach (%s, %d)\n", args, from_tty);
1847 debug_to_post_attach (pid)
1850 debug_target.to_post_attach (pid);
1852 fprintf_unfiltered (gdb_stderr, "target_post_attach (%d)\n", pid);
1856 debug_to_require_attach (args, from_tty)
1860 debug_target.to_require_attach (args, from_tty);
1862 fprintf_unfiltered (gdb_stderr,
1863 "target_require_attach (%s, %d)\n", args, from_tty);
1867 debug_to_detach (args, from_tty)
1871 debug_target.to_detach (args, from_tty);
1873 fprintf_unfiltered (gdb_stderr, "target_detach (%s, %d)\n", args, from_tty);
1877 debug_to_require_detach (pid, args, from_tty)
1882 debug_target.to_require_detach (pid, args, from_tty);
1884 fprintf_unfiltered (gdb_stderr,
1885 "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
1889 debug_to_resume (pid, step, siggnal)
1892 enum target_signal siggnal;
1894 debug_target.to_resume (pid, step, siggnal);
1896 fprintf_unfiltered (gdb_stderr, "target_resume (%d, %s, %s)\n", pid,
1897 step ? "step" : "continue",
1898 target_signal_to_name (siggnal));
1902 debug_to_wait (pid, status)
1904 struct target_waitstatus *status;
1908 retval = debug_target.to_wait (pid, status);
1910 fprintf_unfiltered (gdb_stderr,
1911 "target_wait (%d, status) = %d, ", pid, retval);
1912 fprintf_unfiltered (gdb_stderr, "status->kind = ");
1913 switch (status->kind)
1915 case TARGET_WAITKIND_EXITED:
1916 fprintf_unfiltered (gdb_stderr, "exited, status = %d\n",
1917 status->value.integer);
1919 case TARGET_WAITKIND_STOPPED:
1920 fprintf_unfiltered (gdb_stderr, "stopped, signal = %s\n",
1921 target_signal_to_name (status->value.sig));
1923 case TARGET_WAITKIND_SIGNALLED:
1924 fprintf_unfiltered (gdb_stderr, "signalled, signal = %s\n",
1925 target_signal_to_name (status->value.sig));
1927 case TARGET_WAITKIND_LOADED:
1928 fprintf_unfiltered (gdb_stderr, "loaded\n");
1930 case TARGET_WAITKIND_FORKED:
1931 fprintf_unfiltered (gdb_stderr, "forked\n");
1933 case TARGET_WAITKIND_VFORKED:
1934 fprintf_unfiltered (gdb_stderr, "vforked\n");
1936 case TARGET_WAITKIND_EXECD:
1937 fprintf_unfiltered (gdb_stderr, "execd\n");
1939 case TARGET_WAITKIND_SPURIOUS:
1940 fprintf_unfiltered (gdb_stderr, "spurious\n");
1943 fprintf_unfiltered (gdb_stderr, "unknown???\n");
1951 debug_to_post_wait (pid, status)
1955 debug_target.to_post_wait (pid, status);
1957 fprintf_unfiltered (gdb_stderr, "target_post_wait (%d, %d)\n",
1962 debug_to_fetch_registers (regno)
1965 debug_target.to_fetch_registers (regno);
1967 fprintf_unfiltered (gdb_stderr, "target_fetch_registers (%s)",
1968 regno != -1 ? REGISTER_NAME (regno) : "-1");
1970 fprintf_unfiltered (gdb_stderr, " = 0x%x %d",
1971 (unsigned long) read_register (regno),
1972 read_register (regno));
1973 fprintf_unfiltered (gdb_stderr, "\n");
1977 debug_to_store_registers (regno)
1980 debug_target.to_store_registers (regno);
1982 if (regno >= 0 && regno < NUM_REGS)
1983 fprintf_unfiltered (gdb_stderr, "target_store_registers (%s) = 0x%x %d\n",
1984 REGISTER_NAME (regno),
1985 (unsigned long) read_register (regno),
1986 (unsigned long) read_register (regno));
1988 fprintf_unfiltered (gdb_stderr, "target_store_registers (%d)\n", regno);
1992 debug_to_prepare_to_store ()
1994 debug_target.to_prepare_to_store ();
1996 fprintf_unfiltered (gdb_stderr, "target_prepare_to_store ()\n");
2000 debug_to_xfer_memory (memaddr, myaddr, len, write, target)
2005 struct target_ops *target;
2009 retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
2011 fprintf_unfiltered (gdb_stderr,
2012 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2013 (unsigned int) memaddr, /* possable truncate long long */
2014 len, write ? "write" : "read", retval);
2022 fputs_unfiltered (", bytes =", gdb_stderr);
2023 for (i = 0; i < retval; i++)
2025 if ((((long) &(myaddr[i])) & 0xf) == 0)
2026 fprintf_unfiltered (gdb_stderr, "\n");
2027 fprintf_unfiltered (gdb_stderr, " %02x", myaddr[i] & 0xff);
2031 fputc_unfiltered ('\n', gdb_stderr);
2037 debug_to_files_info (target)
2038 struct target_ops *target;
2040 debug_target.to_files_info (target);
2042 fprintf_unfiltered (gdb_stderr, "target_files_info (xxx)\n");
2046 debug_to_insert_breakpoint (addr, save)
2052 retval = debug_target.to_insert_breakpoint (addr, save);
2054 fprintf_unfiltered (gdb_stderr,
2055 "target_insert_breakpoint (0x%x, xxx) = %d\n",
2056 (unsigned long) addr, retval);
2061 debug_to_remove_breakpoint (addr, save)
2067 retval = debug_target.to_remove_breakpoint (addr, save);
2069 fprintf_unfiltered (gdb_stderr,
2070 "target_remove_breakpoint (0x%x, xxx) = %d\n",
2071 (unsigned long)addr, retval);
2076 debug_to_terminal_init ()
2078 debug_target.to_terminal_init ();
2080 fprintf_unfiltered (gdb_stderr, "target_terminal_init ()\n");
2084 debug_to_terminal_inferior ()
2086 debug_target.to_terminal_inferior ();
2088 fprintf_unfiltered (gdb_stderr, "target_terminal_inferior ()\n");
2092 debug_to_terminal_ours_for_output ()
2094 debug_target.to_terminal_ours_for_output ();
2096 fprintf_unfiltered (gdb_stderr, "target_terminal_ours_for_output ()\n");
2100 debug_to_terminal_ours ()
2102 debug_target.to_terminal_ours ();
2104 fprintf_unfiltered (gdb_stderr, "target_terminal_ours ()\n");
2108 debug_to_terminal_info (arg, from_tty)
2112 debug_target.to_terminal_info (arg, from_tty);
2114 fprintf_unfiltered (gdb_stderr, "target_terminal_info (%s, %d)\n", arg,
2121 debug_target.to_kill ();
2123 fprintf_unfiltered (gdb_stderr, "target_kill ()\n");
2127 debug_to_load (args, from_tty)
2131 debug_target.to_load (args, from_tty);
2133 fprintf_unfiltered (gdb_stderr, "target_load (%s, %d)\n", args, from_tty);
2137 debug_to_lookup_symbol (name, addrp)
2143 retval = debug_target.to_lookup_symbol (name, addrp);
2145 fprintf_unfiltered (gdb_stderr, "target_lookup_symbol (%s, xxx)\n", name);
2151 debug_to_create_inferior (exec_file, args, env)
2156 debug_target.to_create_inferior (exec_file, args, env);
2158 fprintf_unfiltered (gdb_stderr, "target_create_inferior (%s, %s, xxx)\n",
2163 debug_to_post_startup_inferior (pid)
2166 debug_target.to_post_startup_inferior (pid);
2168 fprintf_unfiltered (gdb_stderr, "target_post_startup_inferior (%d)\n",
2173 debug_to_acknowledge_created_inferior (pid)
2176 debug_target.to_acknowledge_created_inferior (pid);
2178 fprintf_unfiltered (gdb_stderr, "target_acknowledge_created_inferior (%d)\n",
2183 debug_to_clone_and_follow_inferior (child_pid, followed_child)
2185 int *followed_child;
2187 debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
2189 fprintf_unfiltered (gdb_stderr,
2190 "target_clone_and_follow_inferior (%d, %d)\n",
2191 child_pid, *followed_child);
2195 debug_to_post_follow_inferior_by_clone ()
2197 debug_target.to_post_follow_inferior_by_clone ();
2199 fprintf_unfiltered (gdb_stderr, "target_post_follow_inferior_by_clone ()\n");
2203 debug_to_insert_fork_catchpoint (pid)
2208 retval = debug_target.to_insert_fork_catchpoint (pid);
2210 fprintf_unfiltered (gdb_stderr, "target_insert_fork_catchpoint (%d) = %d\n",
2217 debug_to_remove_fork_catchpoint (pid)
2222 retval = debug_target.to_remove_fork_catchpoint (pid);
2224 fprintf_unfiltered (gdb_stderr, "target_remove_fork_catchpoint (%d) = %d\n",
2231 debug_to_insert_vfork_catchpoint (pid)
2236 retval = debug_target.to_insert_vfork_catchpoint (pid);
2238 fprintf_unfiltered (gdb_stderr, "target_insert_vfork_catchpoint (%d)= %d\n",
2245 debug_to_remove_vfork_catchpoint (pid)
2250 retval = debug_target.to_remove_vfork_catchpoint (pid);
2252 fprintf_unfiltered (gdb_stderr, "target_remove_vfork_catchpoint (%d) = %d\n",
2259 debug_to_has_forked (pid, child_pid)
2265 has_forked = debug_target.to_has_forked (pid, child_pid);
2267 fprintf_unfiltered (gdb_stderr, "target_has_forked (%d, %d) = %d\n",
2268 pid, *child_pid, has_forked);
2274 debug_to_has_vforked (pid, child_pid)
2280 has_vforked = debug_target.to_has_vforked (pid, child_pid);
2282 fprintf_unfiltered (gdb_stderr, "target_has_vforked (%d, %d) = %d\n",
2283 pid, *child_pid, has_vforked);
2289 debug_to_can_follow_vfork_prior_to_exec ()
2291 int can_immediately_follow_vfork;
2293 can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
2295 fprintf_unfiltered (gdb_stderr, "target_can_follow_vfork_prior_to_exec () = %d\n",
2296 can_immediately_follow_vfork);
2298 return can_immediately_follow_vfork;
2302 debug_to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
2304 int followed_parent;
2308 debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
2310 fprintf_unfiltered (gdb_stderr,
2311 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2312 parent_pid, followed_parent, child_pid, followed_child);
2316 debug_to_insert_exec_catchpoint (pid)
2321 retval = debug_target.to_insert_exec_catchpoint (pid);
2323 fprintf_unfiltered (gdb_stderr, "target_insert_exec_catchpoint (%d) = %d\n",
2330 debug_to_remove_exec_catchpoint (pid)
2335 retval = debug_target.to_remove_exec_catchpoint (pid);
2337 fprintf_unfiltered (gdb_stderr, "target_remove_exec_catchpoint (%d) = %d\n",
2344 debug_to_has_execd (pid, execd_pathname)
2346 char ** execd_pathname;
2350 has_execd = debug_target.to_has_execd (pid, execd_pathname);
2352 fprintf_unfiltered (gdb_stderr, "target_has_execd (%d, %s) = %d\n",
2353 pid, *execd_pathname, has_execd);
2359 debug_to_reported_exec_events_per_exec_call ()
2361 int reported_exec_events;
2363 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2365 fprintf_unfiltered (gdb_stderr,
2366 "target_reported_exec_events_per_exec_call () = %d\n",
2367 reported_exec_events);
2369 return reported_exec_events;
2373 debug_to_has_syscall_event (pid, kind, syscall_id)
2375 enum target_waitkind * kind;
2378 int has_syscall_event;
2379 char * kind_spelling = "??";
2381 has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
2382 if (has_syscall_event)
2386 case TARGET_WAITKIND_SYSCALL_ENTRY:
2387 kind_spelling = "SYSCALL_ENTRY";
2389 case TARGET_WAITKIND_SYSCALL_RETURN:
2390 kind_spelling = "SYSCALL_RETURN";
2397 fprintf_unfiltered (gdb_stderr,
2398 "target_has_syscall_event (%d, %s, %d) = %d\n",
2399 pid, kind_spelling, *syscall_id, has_syscall_event);
2401 return has_syscall_event;
2405 debug_to_has_exited (pid, wait_status, exit_status)
2412 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2414 fprintf_unfiltered (gdb_stderr, "target_has_exited (%d, %d, %d) = %d\n",
2415 pid, wait_status, *exit_status, has_exited);
2421 debug_to_mourn_inferior ()
2423 debug_target.to_mourn_inferior ();
2425 fprintf_unfiltered (gdb_stderr, "target_mourn_inferior ()\n");
2433 retval = debug_target.to_can_run ();
2435 fprintf_unfiltered (gdb_stderr, "target_can_run () = %d\n", retval);
2441 debug_to_notice_signals (pid)
2444 debug_target.to_notice_signals (pid);
2446 fprintf_unfiltered (gdb_stderr, "target_notice_signals (%d)\n", pid);
2450 debug_to_thread_alive (pid)
2455 retval = debug_target.to_thread_alive (pid);
2457 fprintf_unfiltered (gdb_stderr, "target_thread_alive (%d) = %d\n",
2466 debug_target.to_stop ();
2468 fprintf_unfiltered (gdb_stderr, "target_stop ()\n");
2471 static struct symtab_and_line *
2472 debug_to_enable_exception_callback (kind, enable)
2473 enum exception_event_kind kind;
2476 debug_target.to_enable_exception_callback (kind, enable);
2478 fprintf_unfiltered (gdb_stderr,
2479 "target get_exception_callback_sal (%d, %d)\n",
2483 static struct exception_event_record *
2484 debug_to_get_current_exception_event ()
2486 debug_target.to_get_current_exception_event();
2488 fprintf_unfiltered (gdb_stderr, "target get_current_exception_event ()\n");
2492 debug_to_pid_to_exec_file (pid)
2497 exec_file = debug_target.to_pid_to_exec_file (pid);
2499 fprintf_unfiltered (gdb_stderr, "target_pid_to_exec_file (%d) = %s\n",
2506 debug_to_core_file_to_sym_file (core)
2511 sym_file = debug_target.to_core_file_to_sym_file (core);
2513 fprintf_unfiltered (gdb_stderr, "target_core_file_to_sym_file (%s) = %s\n",
2520 setup_target_debug ()
2522 memcpy (&debug_target, ¤t_target, sizeof debug_target);
2524 current_target.to_open = debug_to_open;
2525 current_target.to_close = debug_to_close;
2526 current_target.to_attach = debug_to_attach;
2527 current_target.to_post_attach = debug_to_post_attach;
2528 current_target.to_require_attach = debug_to_require_attach;
2529 current_target.to_detach = debug_to_detach;
2530 current_target.to_require_detach = debug_to_require_detach;
2531 current_target.to_resume = debug_to_resume;
2532 current_target.to_wait = debug_to_wait;
2533 current_target.to_post_wait = debug_to_post_wait;
2534 current_target.to_fetch_registers = debug_to_fetch_registers;
2535 current_target.to_store_registers = debug_to_store_registers;
2536 current_target.to_prepare_to_store = debug_to_prepare_to_store;
2537 current_target.to_xfer_memory = debug_to_xfer_memory;
2538 current_target.to_files_info = debug_to_files_info;
2539 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2540 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2541 current_target.to_terminal_init = debug_to_terminal_init;
2542 current_target.to_terminal_inferior = debug_to_terminal_inferior;
2543 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2544 current_target.to_terminal_ours = debug_to_terminal_ours;
2545 current_target.to_terminal_info = debug_to_terminal_info;
2546 current_target.to_kill = debug_to_kill;
2547 current_target.to_load = debug_to_load;
2548 current_target.to_lookup_symbol = debug_to_lookup_symbol;
2549 current_target.to_create_inferior = debug_to_create_inferior;
2550 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2551 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2552 current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior;
2553 current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone;
2554 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2555 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2556 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2557 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2558 current_target.to_has_forked = debug_to_has_forked;
2559 current_target.to_has_vforked = debug_to_has_vforked;
2560 current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec;
2561 current_target.to_post_follow_vfork = debug_to_post_follow_vfork;
2562 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2563 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2564 current_target.to_has_execd = debug_to_has_execd;
2565 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2566 current_target.to_has_syscall_event = debug_to_has_syscall_event;
2567 current_target.to_has_exited = debug_to_has_exited;
2568 current_target.to_mourn_inferior = debug_to_mourn_inferior;
2569 current_target.to_can_run = debug_to_can_run;
2570 current_target.to_notice_signals = debug_to_notice_signals;
2571 current_target.to_thread_alive = debug_to_thread_alive;
2572 current_target.to_stop = debug_to_stop;
2573 current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2574 current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2575 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2576 current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
2579 #endif /* MAINTENANCE_CMDS */
2581 static char targ_desc[] =
2582 "Names of targets and files being debugged.\n\
2583 Shows the entire stack of targets currently in use (including the exec-file,\n\
2584 core-file, and process, if any), as well as the symbol file name.";
2587 initialize_targets ()
2589 push_target (&dummy_target);
2591 add_info ("target", target_info, targ_desc);
2592 add_info ("files", target_info, targ_desc);
2594 #ifdef MAINTENANCE_CMDS
2596 add_set_cmd ("targetdebug", class_maintenance, var_zinteger,
2597 (char *)&targetdebug,
2598 "Set target debugging.\n\
2599 When non-zero, target debugging is enabled.", &setlist),
2603 if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))