1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1992, 1993, 1994 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
37 target_info
PARAMS ((char *, int));
40 cleanup_target
PARAMS ((struct target_ops
*));
43 maybe_kill_then_create_inferior
PARAMS ((char *, char *, char **));
46 maybe_kill_then_attach
PARAMS ((char *, int));
49 kill_or_be_killed
PARAMS ((int));
52 default_terminal_info
PARAMS ((char *, int));
55 nosymbol
PARAMS ((char *, CORE_ADDR
*));
58 tcomplain
PARAMS ((void));
61 nomemory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
64 return_zero
PARAMS ((void));
67 ignore
PARAMS ((void));
70 target_command
PARAMS ((char *, int));
72 static struct target_ops
*
73 find_default_run_target
PARAMS ((char *));
75 /* Pointer to array of target architecture structures; the size of the
76 array; the current index into the array; the allocated size of the
78 struct target_ops
**target_structs
;
79 unsigned target_struct_size
;
80 unsigned target_struct_index
;
81 unsigned target_struct_allocsize
;
82 #define DEFAULT_ALLOCSIZE 10
84 /* The initial current target, so that there is always a semi-valid
87 struct target_ops dummy_target
= {
88 "None", /* to_shortname */
89 "None", /* to_longname */
93 find_default_attach
, /* to_attach */
97 0, /* to_fetch_registers */
98 0, /* to_store_registers */
99 0, /* to_prepare_to_store */
100 0, /* to_xfer_memory */
101 0, /* to_files_info */
102 0, /* to_insert_breakpoint */
103 0, /* to_remove_breakpoint */
104 0, /* to_terminal_init */
105 0, /* to_terminal_inferior */
106 0, /* to_terminal_ours_for_output */
107 0, /* to_terminal_ours */
108 0, /* to_terminal_info */
111 0, /* to_lookup_symbol */
112 find_default_create_inferior
, /* to_create_inferior */
113 0, /* to_mourn_inferior */
115 0, /* to_notice_signals */
116 0, /* to_thread_alive */
118 dummy_stratum
, /* to_stratum */
121 0, /* to_has_all_memory */
122 0, /* to_has_memory */
123 0, /* to_has_registers */
124 0, /* to_has_execution */
126 0, /* to_sections_end */
127 OPS_MAGIC
, /* to_magic */
130 /* Top of target stack. */
132 struct target_stack_item
*target_stack
;
134 /* The target structure we are currently using to talk to a process
135 or file or whatever "inferior" we have. */
137 struct target_ops current_target
;
139 /* Command list for target. */
141 static struct cmd_list_element
*targetlist
= NULL
;
143 /* Nonzero if we are debugging an attached outside process
144 rather than an inferior. */
148 #ifdef MAINTENANCE_CMDS
149 /* Non-zero if we want to see trace of target level stuff. */
151 static int targetdebug
= 0;
153 static void setup_target_debug
PARAMS ((void));
157 /* The user just typed 'target' without the name of a target. */
161 target_command (arg
, from_tty
)
165 fputs_filtered ("Argument required (target name). Try `help target'\n",
169 /* Add a possible target architecture to the list. */
173 struct target_ops
*t
;
177 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
178 target_structs
= (struct target_ops
**) xmalloc
179 (target_struct_allocsize
* sizeof (*target_structs
));
181 if (target_struct_size
>= target_struct_allocsize
)
183 target_struct_allocsize
*= 2;
184 target_structs
= (struct target_ops
**)
185 xrealloc ((char *) target_structs
,
186 target_struct_allocsize
* sizeof (*target_structs
));
188 target_structs
[target_struct_size
++] = t
;
189 /* cleanup_target (t);*/
191 if (targetlist
== NULL
)
192 add_prefix_cmd ("target", class_run
, target_command
,
193 "Connect to a target machine or process.\n\
194 The first argument is the type or protocol of the target machine.\n\
195 Remaining arguments are interpreted by the target protocol. For more\n\
196 information on the arguments for a particular protocol, type\n\
197 `help target ' followed by the protocol name.",
198 &targetlist
, "target ", 0, &cmdlist
);
199 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
211 nomemory (memaddr
, myaddr
, len
, write
, t
)
216 struct target_ops
*t
;
218 errno
= EIO
; /* Can't read/write this location */
219 return 0; /* No bytes handled */
225 error ("You can't do that when your target is `%s'",
226 current_target
.to_shortname
);
232 error ("You can't do that without a process to debug");
237 nosymbol (name
, addrp
)
241 return 1; /* Symbol does not exist in target env */
246 default_terminal_info (args
, from_tty
)
250 printf_unfiltered("No saved terminal information.\n");
253 /* This is the default target_create_inferior and target_attach function.
254 If the current target is executing, it asks whether to kill it off.
255 If this function returns without calling error(), it has killed off
256 the target, and the operation should be attempted. */
259 kill_or_be_killed (from_tty
)
262 if (target_has_execution
)
264 printf_unfiltered ("You are already running a program:\n");
265 target_files_info ();
266 if (query ("Kill it? ")) {
268 if (target_has_execution
)
269 error ("Killing the program did not help.");
272 error ("Program not killed.");
279 maybe_kill_then_attach (args
, from_tty
)
283 kill_or_be_killed (from_tty
);
284 target_attach (args
, from_tty
);
288 maybe_kill_then_create_inferior (exec
, args
, env
)
293 kill_or_be_killed (0);
294 target_create_inferior (exec
, args
, env
);
297 /* Clean up a target struct so it no longer has any zero pointers in it.
298 We default entries, at least to stubs that print error messages. */
302 struct target_ops
*t
;
305 #define de_fault(field, value) \
306 if (!t->field) t->field = value
308 /* FIELD DEFAULT VALUE */
310 de_fault (to_open
, (void (*)())tcomplain
);
311 de_fault (to_close
, (void (*)())ignore
);
312 de_fault (to_attach
, maybe_kill_then_attach
);
313 de_fault (to_detach
, (void (*)())ignore
);
314 de_fault (to_resume
, (void (*)())noprocess
);
315 de_fault (to_wait
, (int (*)())noprocess
);
316 de_fault (to_fetch_registers
, (void (*)())ignore
);
317 de_fault (to_store_registers
, (void (*)())noprocess
);
318 de_fault (to_prepare_to_store
, (void (*)())noprocess
);
319 de_fault (to_xfer_memory
, (int (*)())nomemory
);
320 de_fault (to_files_info
, (void (*)())ignore
);
321 de_fault (to_insert_breakpoint
, memory_insert_breakpoint
);
322 de_fault (to_remove_breakpoint
, memory_remove_breakpoint
);
323 de_fault (to_terminal_init
, ignore
);
324 de_fault (to_terminal_inferior
, ignore
);
325 de_fault (to_terminal_ours_for_output
,ignore
);
326 de_fault (to_terminal_ours
, ignore
);
327 de_fault (to_terminal_info
, default_terminal_info
);
328 de_fault (to_kill
, (void (*)())noprocess
);
329 de_fault (to_load
, (void (*)())tcomplain
);
330 de_fault (to_lookup_symbol
, nosymbol
);
331 de_fault (to_create_inferior
, maybe_kill_then_create_inferior
);
332 de_fault (to_mourn_inferior
, (void (*)())noprocess
);
333 de_fault (to_can_run
, return_zero
);
334 de_fault (to_notice_signals
, (void (*)())ignore
);
335 de_fault (to_thread_alive
, (void (*)())ignore
);
336 de_fault (to_stop
, (void (*)())ignore
);
341 /* Go through the target stack from top to bottom, copying over zero entries in
342 current_target. In effect, we are doing class inheritance through the
343 pushed target vectors. */
346 update_current_target ()
348 struct target_stack_item
*item
;
349 struct target_ops
*t
;
351 /* First, reset current_target */
352 memset (¤t_target
, 0, sizeof current_target
);
354 for (item
= target_stack
; item
; item
= item
->next
)
356 t
= item
->target_ops
;
358 #define INHERIT(FIELD, TARGET) \
359 if (!current_target.FIELD) \
360 current_target.FIELD = TARGET->FIELD
362 INHERIT (to_shortname
, t
);
363 INHERIT (to_longname
, t
);
365 INHERIT (to_open
, t
);
366 INHERIT (to_close
, t
);
367 INHERIT (to_attach
, t
);
368 INHERIT (to_detach
, t
);
369 INHERIT (to_resume
, t
);
370 INHERIT (to_wait
, t
);
371 INHERIT (to_fetch_registers
, t
);
372 INHERIT (to_store_registers
, t
);
373 INHERIT (to_prepare_to_store
, t
);
374 INHERIT (to_xfer_memory
, t
);
375 INHERIT (to_files_info
, t
);
376 INHERIT (to_insert_breakpoint
, t
);
377 INHERIT (to_remove_breakpoint
, t
);
378 INHERIT (to_terminal_init
, t
);
379 INHERIT (to_terminal_inferior
, t
);
380 INHERIT (to_terminal_ours_for_output
, t
);
381 INHERIT (to_terminal_ours
, t
);
382 INHERIT (to_terminal_info
, t
);
383 INHERIT (to_kill
, t
);
384 INHERIT (to_load
, t
);
385 INHERIT (to_lookup_symbol
, t
);
386 INHERIT (to_create_inferior
, t
);
387 INHERIT (to_mourn_inferior
, t
);
388 INHERIT (to_can_run
, t
);
389 INHERIT (to_notice_signals
, t
);
390 INHERIT (to_thread_alive
, t
);
391 INHERIT (to_stop
, t
);
392 INHERIT (to_stratum
, t
);
393 INHERIT (DONT_USE
, t
);
394 INHERIT (to_has_all_memory
, t
);
395 INHERIT (to_has_memory
, t
);
396 INHERIT (to_has_stack
, t
);
397 INHERIT (to_has_registers
, t
);
398 INHERIT (to_has_execution
, t
);
399 INHERIT (to_sections
, t
);
400 INHERIT (to_sections_end
, t
);
401 INHERIT (to_magic
, t
);
407 /* Push a new target type into the stack of the existing target accessors,
408 possibly superseding some of the existing accessors.
410 Result is zero if the pushed target ended up on top of the stack,
411 nonzero if at least one target is on top of it.
413 Rather than allow an empty stack, we always have the dummy target at
414 the bottom stratum, so we can call the function vectors without
419 struct target_ops
*t
;
421 struct target_stack_item
*cur
, *prev
, *tmp
;
423 /* Check magic number. If wrong, it probably means someone changed
424 the struct definition, but not all the places that initialize one. */
425 if (t
->to_magic
!= OPS_MAGIC
)
427 fprintf_unfiltered(gdb_stderr
,
428 "Magic number of %s target struct wrong\n",
433 /* Find the proper stratum to install this target in. */
435 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
437 if ((int)(t
->to_stratum
) >= (int)(cur
->target_ops
->to_stratum
))
441 /* If there's already targets at this stratum, remove them. */
444 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
446 /* There's already something on this stratum. Close it off. */
447 (cur
->target_ops
->to_close
) (0);
449 prev
->next
= cur
->next
; /* Unchain old target_ops */
451 target_stack
= cur
->next
; /* Unchain first on list */
457 /* We have removed all targets in our stratum, now add the new one. */
459 tmp
= (struct target_stack_item
*)
460 xmalloc (sizeof (struct target_stack_item
));
469 update_current_target ();
471 cleanup_target (¤t_target
); /* Fill in the gaps */
473 #ifdef MAINTENANCE_CMDS
475 setup_target_debug ();
481 /* Remove a target_ops vector from the stack, wherever it may be.
482 Return how many times it was removed (0 or 1). */
486 struct target_ops
*t
;
488 struct target_stack_item
*cur
, *prev
;
491 t
->to_close (0); /* Let it clean up */
493 /* Look for the specified target. Note that we assume that a target
494 can only occur once in the target stack. */
496 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
497 if (cur
->target_ops
== t
)
501 return 0; /* Didn't find target_ops, quit now */
503 /* Unchain the target */
506 target_stack
= cur
->next
;
508 prev
->next
= cur
->next
;
510 free (cur
); /* Release the target_stack_item */
512 update_current_target ();
513 cleanup_target (¤t_target
);
521 (current_target
.to_close
)(0); /* Let it clean up */
522 if (unpush_target (target_stack
->target_ops
) == 1)
525 fprintf_unfiltered(gdb_stderr
,
526 "pop_target couldn't find target %s\n",
527 current_target
.to_shortname
);
532 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
534 /* target_read_string -- read a null terminated string, up to LEN bytes,
535 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
536 Set *STRING to a pointer to malloc'd memory containing the data; the caller
537 is responsible for freeing it. Return the number of bytes successfully
541 target_read_string (memaddr
, string
, len
, errnop
)
547 int tlen
, origlen
, offset
, i
;
551 int buffer_allocated
;
553 unsigned int nbytes_read
= 0;
555 /* Small for testing. */
556 buffer_allocated
= 4;
557 buffer
= xmalloc (buffer_allocated
);
564 tlen
= MIN (len
, 4 - (memaddr
& 3));
565 offset
= memaddr
& 3;
567 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
571 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
574 bytes
= bufptr
- buffer
;
575 buffer_allocated
*= 2;
576 buffer
= xrealloc (buffer
, buffer_allocated
);
577 bufptr
= buffer
+ bytes
;
580 for (i
= 0; i
< tlen
; i
++)
582 *bufptr
++ = buf
[i
+ offset
];
583 if (buf
[i
+ offset
] == '\000')
585 nbytes_read
+= i
+ 1;
602 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
603 GDB's memory at MYADDR. Returns either 0 for success or an errno value
606 If an error occurs, no guarantee is made about the contents of the data at
607 MYADDR. In particular, the caller should not depend upon partial reads
608 filling the buffer with good data. There is no way for the caller to know
609 how much good data might have been transfered anyway. Callers that can
610 deal with partial reads should call target_read_memory_partial. */
613 target_read_memory (memaddr
, myaddr
, len
)
618 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
621 /* Read LEN bytes of target memory at address MEMADDR, placing the results
622 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
623 and optionally an errno value in the location pointed to by ERRNOPTR
624 if ERRNOPTR is non-null. */
627 target_read_memory_partial (memaddr
, myaddr
, len
, errnoptr
)
633 int nread
; /* Number of bytes actually read. */
634 int errcode
; /* Error from last read. */
636 /* First try a complete read. */
637 errcode
= target_xfer_memory (memaddr
, myaddr
, len
, 0);
645 /* Loop, reading one byte at a time until we get as much as we can. */
646 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
648 errcode
= target_xfer_memory (memaddr
++, myaddr
++, 1, 0);
650 /* If an error, the last read was unsuccessful, so adjust count. */
656 if (errnoptr
!= NULL
)
664 target_write_memory (memaddr
, myaddr
, len
)
669 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
672 /* Move memory to or from the targets. Iterate until all of it has
673 been moved, if necessary. The top target gets priority; anything
674 it doesn't want, is offered to the next one down, etc. Note the
675 business with curlen: if an early target says "no, but I have a
676 boundary overlapping this xfer" then we shorten what we offer to
677 the subsequent targets so the early guy will get a chance at the
678 tail before the subsequent ones do.
680 Result is 0 or errno value. */
683 target_xfer_memory (memaddr
, myaddr
, len
, write
)
691 struct target_ops
*t
;
692 struct target_stack_item
*item
;
694 /* to_xfer_memory is not guaranteed to set errno, even when it returns
698 /* The quick case is that the top target does it all. */
699 res
= current_target
.to_xfer_memory
700 (memaddr
, myaddr
, len
, write
, ¤t_target
);
706 /* If res <= 0 then we call it again in the loop. Ah well. */
710 curlen
= len
; /* Want to do it all */
711 for (item
= target_stack
; item
; item
= item
->next
)
713 t
= item
->target_ops
;
714 if (!t
->to_has_memory
)
717 res
= t
->to_xfer_memory (memaddr
, myaddr
, curlen
, write
, t
);
719 break; /* Handled all or part of xfer */
720 if (t
->to_has_all_memory
)
726 /* If this address is for nonexistent memory,
727 read zeros if reading, or do nothing if writing. Return error. */
729 memset (myaddr
, 0, len
);
740 return 0; /* We managed to cover it all somehow. */
746 target_info (args
, from_tty
)
750 struct target_ops
*t
;
751 struct target_stack_item
*item
;
754 if (symfile_objfile
!= NULL
)
755 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
757 #ifdef FILES_INFO_HOOK
758 if (FILES_INFO_HOOK ())
762 for (item
= target_stack
; item
; item
= item
->next
)
764 t
= item
->target_ops
;
766 if (!t
->to_has_memory
)
769 if ((int)(t
->to_stratum
) <= (int)dummy_stratum
)
772 printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
773 printf_unfiltered("%s:\n", t
->to_longname
);
774 (t
->to_files_info
)(t
);
775 has_all_mem
= t
->to_has_all_memory
;
779 /* This is to be called by the open routine before it does
783 target_preopen (from_tty
)
788 if (target_has_execution
)
790 if (query ("A program is being debugged already. Kill it? "))
793 error ("Program not killed.");
796 /* Calling target_kill may remove the target from the stack. But if
797 it doesn't (which seems like a win for UDI), remove it now. */
799 if (target_has_execution
)
803 /* Detach a target after doing deferred register stores. */
806 target_detach (args
, from_tty
)
810 /* Handle any optimized stores to the inferior. */
811 #ifdef DO_DEFERRED_STORES
814 (current_target
.to_detach
) (args
, from_tty
);
818 target_link (modname
, t_reloc
)
822 if (STREQ(current_target
.to_shortname
, "rombug"))
824 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
826 error("Unable to link to %s and get relocation in rombug", modname
);
829 *t_reloc
= (CORE_ADDR
)-1;
832 /* Look through the list of possible targets for a target that can
833 execute a run or attach command without any other data. This is
834 used to locate the default process stratum.
836 Result is always valid (error() is called for errors). */
838 static struct target_ops
*
839 find_default_run_target (do_mesg
)
842 struct target_ops
**t
;
843 struct target_ops
*runable
= NULL
;
848 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
851 if ((*t
)->to_can_run
&& target_can_run(*t
))
859 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
865 find_default_attach (args
, from_tty
)
869 struct target_ops
*t
;
871 t
= find_default_run_target("attach");
872 (t
->to_attach
) (args
, from_tty
);
877 find_default_create_inferior (exec_file
, allargs
, env
)
882 struct target_ops
*t
;
884 t
= find_default_run_target("run");
885 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
898 struct target_ops
**t
;
899 struct target_ops
*runable
= NULL
;
904 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
907 if ((*t
)->to_stratum
== core_stratum
)
914 return(count
== 1 ? runable
: NULL
);
917 /* The inferior process has died. Long live the inferior! */
920 generic_mourn_inferior ()
922 extern int show_breakpoint_hit_counts
;
926 breakpoint_init_inferior ();
927 registers_changed ();
929 #ifdef CLEAR_DEFERRED_STORES
930 /* Delete any pending stores to the inferior... */
931 CLEAR_DEFERRED_STORES
;
935 reinit_frame_cache ();
937 /* It is confusing to the user for ignore counts to stick around
938 from previous runs of the inferior. So clear them. */
939 /* However, it is more confusing for the ignore counts to disappear when
940 using hit counts. So don't clear them if we're counting hits. */
941 if (!show_breakpoint_hit_counts
)
942 breakpoint_clear_ignore_counts ();
945 /* This table must match in order and size the signals in enum target_signal
953 {"SIGHUP", "Hangup"},
954 {"SIGINT", "Interrupt"},
956 {"SIGILL", "Illegal instruction"},
957 {"SIGTRAP", "Trace/breakpoint trap"},
958 {"SIGABRT", "Aborted"},
959 {"SIGEMT", "Emulation trap"},
960 {"SIGFPE", "Arithmetic exception"},
961 {"SIGKILL", "Killed"},
962 {"SIGBUS", "Bus error"},
963 {"SIGSEGV", "Segmentation fault"},
964 {"SIGSYS", "Bad system call"},
965 {"SIGPIPE", "Broken pipe"},
966 {"SIGALRM", "Alarm clock"},
967 {"SIGTERM", "Terminated"},
968 {"SIGURG", "Urgent I/O condition"},
969 {"SIGSTOP", "Stopped (signal)"},
970 {"SIGTSTP", "Stopped (user)"},
971 {"SIGCONT", "Continued"},
972 {"SIGCHLD", "Child status changed"},
973 {"SIGTTIN", "Stopped (tty input)"},
974 {"SIGTTOU", "Stopped (tty output)"},
975 {"SIGIO", "I/O possible"},
976 {"SIGXCPU", "CPU time limit exceeded"},
977 {"SIGXFSZ", "File size limit exceeded"},
978 {"SIGVTALRM", "Virtual timer expired"},
979 {"SIGPROF", "Profiling timer expired"},
980 {"SIGWINCH", "Window size changed"},
981 {"SIGLOST", "Resource lost"},
982 {"SIGUSR1", "User defined signal 1"},
983 {"SIGUSR2", "User defined signal 2"},
984 {"SIGPWR", "Power fail/restart"},
985 {"SIGPOLL", "Pollable event occurred"},
986 {"SIGWIND", "SIGWIND"},
987 {"SIGPHONE", "SIGPHONE"},
988 {"SIGWAITING", "Process's LWPs are blocked"},
989 {"SIGLWP", "Signal LWP"},
990 {"SIGDANGER", "Swap space dangerously low"},
991 {"SIGGRANT", "Monitor mode granted"},
992 {"SIGRETRACT", "Need to relinguish monitor mode"},
993 {"SIGMSG", "Monitor mode data available"},
994 {"SIGSOUND", "Sound completed"},
995 {"SIGSAK", "Secure attention"},
996 {"SIGPRIO", "SIGPRIO"},
997 {"SIG33", "Real-time event 33"},
998 {"SIG34", "Real-time event 34"},
999 {"SIG35", "Real-time event 35"},
1000 {"SIG36", "Real-time event 36"},
1001 {"SIG37", "Real-time event 37"},
1002 {"SIG38", "Real-time event 38"},
1003 {"SIG39", "Real-time event 39"},
1004 {"SIG40", "Real-time event 40"},
1005 {"SIG41", "Real-time event 41"},
1006 {"SIG42", "Real-time event 42"},
1007 {"SIG43", "Real-time event 43"},
1008 {"SIG44", "Real-time event 44"},
1009 {"SIG45", "Real-time event 45"},
1010 {"SIG46", "Real-time event 46"},
1011 {"SIG47", "Real-time event 47"},
1012 {"SIG48", "Real-time event 48"},
1013 {"SIG49", "Real-time event 49"},
1014 {"SIG50", "Real-time event 50"},
1015 {"SIG51", "Real-time event 51"},
1016 {"SIG52", "Real-time event 52"},
1017 {"SIG53", "Real-time event 53"},
1018 {"SIG54", "Real-time event 54"},
1019 {"SIG55", "Real-time event 55"},
1020 {"SIG56", "Real-time event 56"},
1021 {"SIG57", "Real-time event 57"},
1022 {"SIG58", "Real-time event 58"},
1023 {"SIG59", "Real-time event 59"},
1024 {"SIG60", "Real-time event 60"},
1025 {"SIG61", "Real-time event 61"},
1026 {"SIG62", "Real-time event 62"},
1027 {"SIG63", "Real-time event 63"},
1029 {NULL
, "Unknown signal"},
1030 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1032 /* Last entry, used to check whether the table is the right size. */
1033 {NULL
, "TARGET_SIGNAL_MAGIC"}
1036 /* Return the string for a signal. */
1038 target_signal_to_string (sig
)
1039 enum target_signal sig
;
1041 return signals
[sig
].string
;
1044 /* Return the name for a signal. */
1046 target_signal_to_name (sig
)
1047 enum target_signal sig
;
1049 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1050 /* I think the code which prints this will always print it along with
1051 the string, so no need to be verbose. */
1053 return signals
[sig
].name
;
1056 /* Given a name, return its signal. */
1058 target_signal_from_name (name
)
1061 enum target_signal sig
;
1063 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1064 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1065 questionable; seems like by now people should call it SIGABRT
1068 /* This ugly cast brought to you by the native VAX compiler. */
1069 for (sig
= TARGET_SIGNAL_HUP
;
1070 signals
[sig
].name
!= NULL
;
1071 sig
= (enum target_signal
)((int)sig
+ 1))
1072 if (STREQ (name
, signals
[sig
].name
))
1074 return TARGET_SIGNAL_UNKNOWN
;
1077 /* The following functions are to help certain targets deal
1078 with the signal/waitstatus stuff. They could just as well be in
1079 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1081 /* Convert host signal to our signals. */
1083 target_signal_from_host (hostsig
)
1086 /* A switch statement would make sense but would require special kludges
1087 to deal with the cases where more than one signal has the same number. */
1089 if (hostsig
== 0) return TARGET_SIGNAL_0
;
1091 #if defined (SIGHUP)
1092 if (hostsig
== SIGHUP
) return TARGET_SIGNAL_HUP
;
1094 #if defined (SIGINT)
1095 if (hostsig
== SIGINT
) return TARGET_SIGNAL_INT
;
1097 #if defined (SIGQUIT)
1098 if (hostsig
== SIGQUIT
) return TARGET_SIGNAL_QUIT
;
1100 #if defined (SIGILL)
1101 if (hostsig
== SIGILL
) return TARGET_SIGNAL_ILL
;
1103 #if defined (SIGTRAP)
1104 if (hostsig
== SIGTRAP
) return TARGET_SIGNAL_TRAP
;
1106 #if defined (SIGABRT)
1107 if (hostsig
== SIGABRT
) return TARGET_SIGNAL_ABRT
;
1109 #if defined (SIGEMT)
1110 if (hostsig
== SIGEMT
) return TARGET_SIGNAL_EMT
;
1112 #if defined (SIGFPE)
1113 if (hostsig
== SIGFPE
) return TARGET_SIGNAL_FPE
;
1115 #if defined (SIGKILL)
1116 if (hostsig
== SIGKILL
) return TARGET_SIGNAL_KILL
;
1118 #if defined (SIGBUS)
1119 if (hostsig
== SIGBUS
) return TARGET_SIGNAL_BUS
;
1121 #if defined (SIGSEGV)
1122 if (hostsig
== SIGSEGV
) return TARGET_SIGNAL_SEGV
;
1124 #if defined (SIGSYS)
1125 if (hostsig
== SIGSYS
) return TARGET_SIGNAL_SYS
;
1127 #if defined (SIGPIPE)
1128 if (hostsig
== SIGPIPE
) return TARGET_SIGNAL_PIPE
;
1130 #if defined (SIGALRM)
1131 if (hostsig
== SIGALRM
) return TARGET_SIGNAL_ALRM
;
1133 #if defined (SIGTERM)
1134 if (hostsig
== SIGTERM
) return TARGET_SIGNAL_TERM
;
1136 #if defined (SIGUSR1)
1137 if (hostsig
== SIGUSR1
) return TARGET_SIGNAL_USR1
;
1139 #if defined (SIGUSR2)
1140 if (hostsig
== SIGUSR2
) return TARGET_SIGNAL_USR2
;
1142 #if defined (SIGCLD)
1143 if (hostsig
== SIGCLD
) return TARGET_SIGNAL_CHLD
;
1145 #if defined (SIGCHLD)
1146 if (hostsig
== SIGCHLD
) return TARGET_SIGNAL_CHLD
;
1148 #if defined (SIGPWR)
1149 if (hostsig
== SIGPWR
) return TARGET_SIGNAL_PWR
;
1151 #if defined (SIGWINCH)
1152 if (hostsig
== SIGWINCH
) return TARGET_SIGNAL_WINCH
;
1154 #if defined (SIGURG)
1155 if (hostsig
== SIGURG
) return TARGET_SIGNAL_URG
;
1158 if (hostsig
== SIGIO
) return TARGET_SIGNAL_IO
;
1160 #if defined (SIGPOLL)
1161 if (hostsig
== SIGPOLL
) return TARGET_SIGNAL_POLL
;
1163 #if defined (SIGSTOP)
1164 if (hostsig
== SIGSTOP
) return TARGET_SIGNAL_STOP
;
1166 #if defined (SIGTSTP)
1167 if (hostsig
== SIGTSTP
) return TARGET_SIGNAL_TSTP
;
1169 #if defined (SIGCONT)
1170 if (hostsig
== SIGCONT
) return TARGET_SIGNAL_CONT
;
1172 #if defined (SIGTTIN)
1173 if (hostsig
== SIGTTIN
) return TARGET_SIGNAL_TTIN
;
1175 #if defined (SIGTTOU)
1176 if (hostsig
== SIGTTOU
) return TARGET_SIGNAL_TTOU
;
1178 #if defined (SIGVTALRM)
1179 if (hostsig
== SIGVTALRM
) return TARGET_SIGNAL_VTALRM
;
1181 #if defined (SIGPROF)
1182 if (hostsig
== SIGPROF
) return TARGET_SIGNAL_PROF
;
1184 #if defined (SIGXCPU)
1185 if (hostsig
== SIGXCPU
) return TARGET_SIGNAL_XCPU
;
1187 #if defined (SIGXFSZ)
1188 if (hostsig
== SIGXFSZ
) return TARGET_SIGNAL_XFSZ
;
1190 #if defined (SIGWIND)
1191 if (hostsig
== SIGWIND
) return TARGET_SIGNAL_WIND
;
1193 #if defined (SIGPHONE)
1194 if (hostsig
== SIGPHONE
) return TARGET_SIGNAL_PHONE
;
1196 #if defined (SIGLOST)
1197 if (hostsig
== SIGLOST
) return TARGET_SIGNAL_LOST
;
1199 #if defined (SIGWAITING)
1200 if (hostsig
== SIGWAITING
) return TARGET_SIGNAL_WAITING
;
1202 #if defined (SIGLWP)
1203 if (hostsig
== SIGLWP
) return TARGET_SIGNAL_LWP
;
1205 #if defined (SIGDANGER)
1206 if (hostsig
== SIGDANGER
) return TARGET_SIGNAL_DANGER
;
1208 #if defined (SIGGRANT)
1209 if (hostsig
== SIGGRANT
) return TARGET_SIGNAL_GRANT
;
1211 #if defined (SIGRETRACT)
1212 if (hostsig
== SIGRETRACT
) return TARGET_SIGNAL_RETRACT
;
1214 #if defined (SIGMSG)
1215 if (hostsig
== SIGMSG
) return TARGET_SIGNAL_MSG
;
1217 #if defined (SIGSOUND)
1218 if (hostsig
== SIGSOUND
) return TARGET_SIGNAL_SOUND
;
1220 #if defined (SIGSAK)
1221 if (hostsig
== SIGSAK
) return TARGET_SIGNAL_SAK
;
1223 #if defined (SIGPRIO)
1224 if (hostsig
== SIGPRIO
) return TARGET_SIGNAL_PRIO
;
1226 #if defined (REALTIME_LO)
1227 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1228 return (enum target_signal
)
1229 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1231 return TARGET_SIGNAL_UNKNOWN
;
1235 target_signal_to_host (oursig
)
1236 enum target_signal oursig
;
1240 case TARGET_SIGNAL_0
: return 0;
1242 #if defined (SIGHUP)
1243 case TARGET_SIGNAL_HUP
: return SIGHUP
;
1245 #if defined (SIGINT)
1246 case TARGET_SIGNAL_INT
: return SIGINT
;
1248 #if defined (SIGQUIT)
1249 case TARGET_SIGNAL_QUIT
: return SIGQUIT
;
1251 #if defined (SIGILL)
1252 case TARGET_SIGNAL_ILL
: return SIGILL
;
1254 #if defined (SIGTRAP)
1255 case TARGET_SIGNAL_TRAP
: return SIGTRAP
;
1257 #if defined (SIGABRT)
1258 case TARGET_SIGNAL_ABRT
: return SIGABRT
;
1260 #if defined (SIGEMT)
1261 case TARGET_SIGNAL_EMT
: return SIGEMT
;
1263 #if defined (SIGFPE)
1264 case TARGET_SIGNAL_FPE
: return SIGFPE
;
1266 #if defined (SIGKILL)
1267 case TARGET_SIGNAL_KILL
: return SIGKILL
;
1269 #if defined (SIGBUS)
1270 case TARGET_SIGNAL_BUS
: return SIGBUS
;
1272 #if defined (SIGSEGV)
1273 case TARGET_SIGNAL_SEGV
: return SIGSEGV
;
1275 #if defined (SIGSYS)
1276 case TARGET_SIGNAL_SYS
: return SIGSYS
;
1278 #if defined (SIGPIPE)
1279 case TARGET_SIGNAL_PIPE
: return SIGPIPE
;
1281 #if defined (SIGALRM)
1282 case TARGET_SIGNAL_ALRM
: return SIGALRM
;
1284 #if defined (SIGTERM)
1285 case TARGET_SIGNAL_TERM
: return SIGTERM
;
1287 #if defined (SIGUSR1)
1288 case TARGET_SIGNAL_USR1
: return SIGUSR1
;
1290 #if defined (SIGUSR2)
1291 case TARGET_SIGNAL_USR2
: return SIGUSR2
;
1293 #if defined (SIGCHLD) || defined (SIGCLD)
1294 case TARGET_SIGNAL_CHLD
:
1295 #if defined (SIGCHLD)
1300 #endif /* SIGCLD or SIGCHLD */
1301 #if defined (SIGPWR)
1302 case TARGET_SIGNAL_PWR
: return SIGPWR
;
1304 #if defined (SIGWINCH)
1305 case TARGET_SIGNAL_WINCH
: return SIGWINCH
;
1307 #if defined (SIGURG)
1308 case TARGET_SIGNAL_URG
: return SIGURG
;
1311 case TARGET_SIGNAL_IO
: return SIGIO
;
1313 #if defined (SIGPOLL)
1314 case TARGET_SIGNAL_POLL
: return SIGPOLL
;
1316 #if defined (SIGSTOP)
1317 case TARGET_SIGNAL_STOP
: return SIGSTOP
;
1319 #if defined (SIGTSTP)
1320 case TARGET_SIGNAL_TSTP
: return SIGTSTP
;
1322 #if defined (SIGCONT)
1323 case TARGET_SIGNAL_CONT
: return SIGCONT
;
1325 #if defined (SIGTTIN)
1326 case TARGET_SIGNAL_TTIN
: return SIGTTIN
;
1328 #if defined (SIGTTOU)
1329 case TARGET_SIGNAL_TTOU
: return SIGTTOU
;
1331 #if defined (SIGVTALRM)
1332 case TARGET_SIGNAL_VTALRM
: return SIGVTALRM
;
1334 #if defined (SIGPROF)
1335 case TARGET_SIGNAL_PROF
: return SIGPROF
;
1337 #if defined (SIGXCPU)
1338 case TARGET_SIGNAL_XCPU
: return SIGXCPU
;
1340 #if defined (SIGXFSZ)
1341 case TARGET_SIGNAL_XFSZ
: return SIGXFSZ
;
1343 #if defined (SIGWIND)
1344 case TARGET_SIGNAL_WIND
: return SIGWIND
;
1346 #if defined (SIGPHONE)
1347 case TARGET_SIGNAL_PHONE
: return SIGPHONE
;
1349 #if defined (SIGLOST)
1350 case TARGET_SIGNAL_LOST
: return SIGLOST
;
1352 #if defined (SIGWAITING)
1353 case TARGET_SIGNAL_WAITING
: return SIGWAITING
;
1355 #if defined (SIGLWP)
1356 case TARGET_SIGNAL_LWP
: return SIGLWP
;
1358 #if defined (SIGDANGER)
1359 case TARGET_SIGNAL_DANGER
: return SIGDANGER
;
1361 #if defined (SIGGRANT)
1362 case TARGET_SIGNAL_GRANT
: return SIGGRANT
;
1364 #if defined (SIGRETRACT)
1365 case TARGET_SIGNAL_RETRACT
: return SIGRETRACT
;
1367 #if defined (SIGMSG)
1368 case TARGET_SIGNAL_MSG
: return SIGMSG
;
1370 #if defined (SIGSOUND)
1371 case TARGET_SIGNAL_SOUND
: return SIGSOUND
;
1373 #if defined (SIGSAK)
1374 case TARGET_SIGNAL_SAK
: return SIGSAK
;
1376 #if defined (SIGPRIO)
1377 case TARGET_SIGNAL_PRIO
: return SIGPRIO
;
1380 #if defined (REALTIME_LO)
1381 if (oursig
>= TARGET_SIGNAL_REALTIME_33
1382 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
1385 (int)oursig
- (int)TARGET_SIGNAL_REALTIME_33
+ REALTIME_LO
;
1386 if (retsig
< REALTIME_HI
)
1390 /* The user might be trying to do "signal SIGSAK" where this system
1391 doesn't have SIGSAK. */
1392 warning ("Signal %s does not exist on this system.\n",
1393 target_signal_to_name (oursig
));
1398 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1399 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1400 translation of that in OURSTATUS. */
1402 store_waitstatus (ourstatus
, hoststatus
)
1403 struct target_waitstatus
*ourstatus
;
1406 #ifdef CHILD_SPECIAL_WAITSTATUS
1407 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1408 if it wants to deal with hoststatus. */
1409 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1413 if (WIFEXITED (hoststatus
))
1415 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1416 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1418 else if (!WIFSTOPPED (hoststatus
))
1420 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1421 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1425 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1426 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1430 /* In some circumstances we allow a command to specify a numeric
1431 signal. The idea is to keep these circumstances limited so that
1432 users (and scripts) develop portable habits. For comparison,
1433 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1434 numeric signal at all is obscelescent. We are slightly more
1435 lenient and allow 1-15 which should match host signal numbers on
1436 most systems. Use of symbolic signal names is strongly encouraged. */
1439 target_signal_from_command (num
)
1442 if (num
>= 1 && num
<= 15)
1443 return (enum target_signal
)num
;
1444 error ("Only signals 1-15 are valid as numeric signals.\n\
1445 Use \"info signals\" for a list of symbolic signals.");
1448 /* Returns zero to leave the inferior alone, one to interrupt it. */
1449 int (*target_activity_function
) PARAMS ((void));
1450 int target_activity_fd
;
1452 /* Convert a normal process ID to a string. Returns the string in a static
1456 normal_pid_to_str (pid
)
1459 static char buf
[30];
1461 if (STREQ (current_target
.to_shortname
, "remote"))
1462 sprintf (buf
, "thread %d", pid
);
1464 sprintf (buf
, "process %d", pid
);
1469 #ifdef MAINTENANCE_CMDS
1470 static struct target_ops debug_target
;
1473 debug_to_open (args
, from_tty
)
1477 debug_target
.to_open (args
, from_tty
);
1479 fprintf_unfiltered (stderr
, "target_open (%s, %d)\n", args
, from_tty
);
1483 debug_to_close (quitting
)
1486 debug_target
.to_close (quitting
);
1488 fprintf_unfiltered (stderr
, "target_close (%d)\n", quitting
);
1492 debug_to_attach (args
, from_tty
)
1496 debug_target
.to_attach (args
, from_tty
);
1498 fprintf_unfiltered (stderr
, "target_attach (%s, %d)\n", args
, from_tty
);
1502 debug_to_detach (args
, from_tty
)
1506 debug_target
.to_detach (args
, from_tty
);
1508 fprintf_unfiltered (stderr
, "target_detach (%s, %d)\n", args
, from_tty
);
1512 debug_to_resume (pid
, step
, siggnal
)
1515 enum target_signal siggnal
;
1517 debug_target
.to_resume (pid
, step
, siggnal
);
1519 fprintf_unfiltered (stderr
, "target_resume (%d, %s, %s)\n", pid
,
1520 step
? "step" : "continue",
1521 target_signal_to_name (siggnal
));
1525 debug_to_wait (pid
, status
)
1527 struct target_waitstatus
*status
;
1531 retval
= debug_target
.to_wait (pid
, status
);
1533 fprintf_unfiltered (stderr
, "target_wait (%d, status) = %d, ", pid
, retval
);
1534 fprintf_unfiltered (stderr
, "status->kind = ");
1535 switch (status
->kind
)
1537 case TARGET_WAITKIND_EXITED
:
1538 fprintf_unfiltered (stderr
, "exited, status = %d\n", status
->value
.integer
);
1540 case TARGET_WAITKIND_STOPPED
:
1541 fprintf_unfiltered (stderr
, "stopped, signal = %s\n",
1542 target_signal_to_name (status
->value
.sig
));
1544 case TARGET_WAITKIND_SIGNALLED
:
1545 fprintf_unfiltered (stderr
, "signalled, signal = %s\n",
1546 target_signal_to_name (status
->value
.sig
));
1548 case TARGET_WAITKIND_LOADED
:
1549 fprintf_unfiltered (stderr
, "loaded\n");
1551 case TARGET_WAITKIND_SPURIOUS
:
1552 fprintf_unfiltered (stderr
, "spurious\n");
1555 fprintf_unfiltered (stderr
, "unknown???\n");
1563 debug_to_fetch_registers (regno
)
1566 debug_target
.to_fetch_registers (regno
);
1568 fprintf_unfiltered (stderr
, "target_fetch_registers (%s)",
1569 regno
!= -1 ? reg_names
[regno
] : "-1");
1571 fprintf_unfiltered (stderr
, " = 0x%x %d", read_register (regno
),
1572 read_register (regno
));
1573 fprintf_unfiltered (stderr
, "\n");
1577 debug_to_store_registers (regno
)
1580 debug_target
.to_store_registers (regno
);
1582 if (regno
>= 0 && regno
< NUM_REGS
)
1583 fprintf_unfiltered (stderr
, "target_store_registers (%s) = 0x%x %d\n",
1584 reg_names
[regno
], read_register (regno
),
1585 read_register (regno
));
1587 fprintf_unfiltered (stderr
, "target_store_registers (%d)\n", regno
);
1591 debug_to_prepare_to_store ()
1593 debug_target
.to_prepare_to_store ();
1595 fprintf_unfiltered (stderr
, "target_prepare_to_store ()\n");
1599 debug_to_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1604 struct target_ops
*target
;
1608 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
1610 fprintf_unfiltered (stderr
, "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1611 memaddr
, len
, write
? "write" : "read", retval
);
1617 fputs_unfiltered (", bytes =", gdb_stderr
);
1618 for (i
= 0; i
< retval
; i
++)
1619 fprintf_unfiltered (stderr
, " %02x", myaddr
[i
] & 0xff);
1622 fputc_unfiltered ('\n', gdb_stderr
);
1628 debug_to_files_info (target
)
1629 struct target_ops
*target
;
1631 debug_target
.to_files_info (target
);
1633 fprintf_unfiltered (stderr
, "target_files_info (xxx)\n");
1637 debug_to_insert_breakpoint (addr
, save
)
1643 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1645 fprintf_unfiltered (stderr
, "target_insert_breakpoint (0x%x, xxx) = %d\n",
1651 debug_to_remove_breakpoint (addr
, save
)
1657 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1659 fprintf_unfiltered (stderr
, "target_remove_breakpoint (0x%x, xxx) = %d\n",
1665 debug_to_terminal_init ()
1667 debug_target
.to_terminal_init ();
1669 fprintf_unfiltered (stderr
, "target_terminal_init ()\n");
1673 debug_to_terminal_inferior ()
1675 debug_target
.to_terminal_inferior ();
1677 fprintf_unfiltered (stderr
, "target_terminal_inferior ()\n");
1681 debug_to_terminal_ours_for_output ()
1683 debug_target
.to_terminal_ours_for_output ();
1685 fprintf_unfiltered (stderr
, "target_terminal_ours_for_output ()\n");
1689 debug_to_terminal_ours ()
1691 debug_target
.to_terminal_ours ();
1693 fprintf_unfiltered (stderr
, "target_terminal_ours ()\n");
1697 debug_to_terminal_info (arg
, from_tty
)
1701 debug_target
.to_terminal_info (arg
, from_tty
);
1703 fprintf_unfiltered (stderr
, "target_terminal_info (%s, %d)\n", arg
,
1710 debug_target
.to_kill ();
1712 fprintf_unfiltered (stderr
, "target_kill ()\n");
1716 debug_to_load (args
, from_tty
)
1720 debug_target
.to_load (args
, from_tty
);
1722 fprintf_unfiltered (stderr
, "target_load (%s, %d)\n", args
, from_tty
);
1726 debug_to_lookup_symbol (name
, addrp
)
1732 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1734 fprintf_unfiltered (stderr
, "target_lookup_symbol (%s, xxx)\n", name
);
1740 debug_to_create_inferior (exec_file
, args
, env
)
1745 debug_target
.to_create_inferior (exec_file
, args
, env
);
1747 fprintf_unfiltered (stderr
, "target_create_inferior (%s, %s, xxx)\n",
1752 debug_to_mourn_inferior ()
1754 debug_target
.to_mourn_inferior ();
1756 fprintf_unfiltered (stderr
, "target_mourn_inferior ()\n");
1764 retval
= debug_target
.to_can_run ();
1766 fprintf_unfiltered (stderr
, "target_can_run () = %d\n", retval
);
1772 debug_to_notice_signals (pid
)
1775 debug_target
.to_notice_signals (pid
);
1777 fprintf_unfiltered (stderr
, "target_notice_signals (%d)\n", pid
);
1781 debug_to_thread_alive (pid
)
1784 debug_target
.to_thread_alive (pid
);
1786 fprintf_unfiltered (stderr
, "target_thread_alive (%d)\n", pid
);
1792 debug_target
.to_stop ();
1794 fprintf_unfiltered (stderr
, "target_stop ()\n");
1798 setup_target_debug ()
1800 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
1802 current_target
.to_open
= debug_to_open
;
1803 current_target
.to_close
= debug_to_close
;
1804 current_target
.to_attach
= debug_to_attach
;
1805 current_target
.to_detach
= debug_to_detach
;
1806 current_target
.to_resume
= debug_to_resume
;
1807 current_target
.to_wait
= debug_to_wait
;
1808 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
1809 current_target
.to_store_registers
= debug_to_store_registers
;
1810 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
1811 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
1812 current_target
.to_files_info
= debug_to_files_info
;
1813 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
1814 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
1815 current_target
.to_terminal_init
= debug_to_terminal_init
;
1816 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
1817 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
1818 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
1819 current_target
.to_terminal_info
= debug_to_terminal_info
;
1820 current_target
.to_kill
= debug_to_kill
;
1821 current_target
.to_load
= debug_to_load
;
1822 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
1823 current_target
.to_create_inferior
= debug_to_create_inferior
;
1824 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
1825 current_target
.to_can_run
= debug_to_can_run
;
1826 current_target
.to_notice_signals
= debug_to_notice_signals
;
1827 current_target
.to_thread_alive
= debug_to_thread_alive
;
1828 current_target
.to_stop
= debug_to_stop
;
1830 #endif /* MAINTENANCE_CMDS */
1832 static char targ_desc
[] =
1833 "Names of targets and files being debugged.\n\
1834 Shows the entire stack of targets currently in use (including the exec-file,\n\
1835 core-file, and process, if any), as well as the symbol file name.";
1838 initialize_targets ()
1840 push_target (&dummy_target
);
1842 add_info ("target", target_info
, targ_desc
);
1843 add_info ("files", target_info
, targ_desc
);
1845 #ifdef MAINTENANCE_CMDS
1847 add_set_cmd ("targetdebug", class_maintenance
, var_zinteger
,
1848 (char *)&targetdebug
,
1849 "Set target debugging.\n\
1850 When non-zero, target debugging is enabled.", &setlist
),
1854 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))