1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1992, 1993, 1994, 1995 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. */
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 maybe_kill_then_attach
PARAMS ((char *, int));
50 kill_or_be_killed
PARAMS ((int));
53 default_terminal_info
PARAMS ((char *, int));
56 nosymbol
PARAMS ((char *, CORE_ADDR
*));
59 tcomplain
PARAMS ((void));
62 nomemory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
65 return_zero
PARAMS ((void));
68 ignore
PARAMS ((void));
71 target_command
PARAMS ((char *, int));
73 static struct target_ops
*
74 find_default_run_target
PARAMS ((char *));
76 /* Pointer to array of target architecture structures; the size of the
77 array; the current index into the array; the allocated size of the
79 struct target_ops
**target_structs
;
80 unsigned target_struct_size
;
81 unsigned target_struct_index
;
82 unsigned target_struct_allocsize
;
83 #define DEFAULT_ALLOCSIZE 10
85 /* The initial current target, so that there is always a semi-valid
88 struct target_ops dummy_target
= {
89 "None", /* to_shortname */
90 "None", /* to_longname */
94 find_default_attach
, /* to_attach */
98 0, /* to_fetch_registers */
99 0, /* to_store_registers */
100 0, /* to_prepare_to_store */
101 0, /* to_xfer_memory */
102 0, /* to_files_info */
103 0, /* to_insert_breakpoint */
104 0, /* to_remove_breakpoint */
105 0, /* to_terminal_init */
106 0, /* to_terminal_inferior */
107 0, /* to_terminal_ours_for_output */
108 0, /* to_terminal_ours */
109 0, /* to_terminal_info */
112 0, /* to_lookup_symbol */
113 find_default_create_inferior
, /* to_create_inferior */
114 0, /* to_mourn_inferior */
116 0, /* to_notice_signals */
117 0, /* to_thread_alive */
119 dummy_stratum
, /* to_stratum */
122 0, /* to_has_all_memory */
123 0, /* to_has_memory */
124 0, /* to_has_registers */
125 0, /* to_has_execution */
127 0, /* to_sections_end */
128 OPS_MAGIC
, /* to_magic */
131 /* Top of target stack. */
133 struct target_stack_item
*target_stack
;
135 /* The target structure we are currently using to talk to a process
136 or file or whatever "inferior" we have. */
138 struct target_ops current_target
;
140 /* Command list for target. */
142 static struct cmd_list_element
*targetlist
= NULL
;
144 /* Nonzero if we are debugging an attached outside process
145 rather than an inferior. */
149 #ifdef MAINTENANCE_CMDS
150 /* Non-zero if we want to see trace of target level stuff. */
152 static int targetdebug
= 0;
154 static void setup_target_debug
PARAMS ((void));
158 /* The user just typed 'target' without the name of a target. */
162 target_command (arg
, from_tty
)
166 fputs_filtered ("Argument required (target name). Try `help target'\n",
170 /* Add a possible target architecture to the list. */
174 struct target_ops
*t
;
178 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
179 target_structs
= (struct target_ops
**) xmalloc
180 (target_struct_allocsize
* sizeof (*target_structs
));
182 if (target_struct_size
>= target_struct_allocsize
)
184 target_struct_allocsize
*= 2;
185 target_structs
= (struct target_ops
**)
186 xrealloc ((char *) target_structs
,
187 target_struct_allocsize
* sizeof (*target_structs
));
189 target_structs
[target_struct_size
++] = t
;
190 /* cleanup_target (t);*/
192 if (targetlist
== NULL
)
193 add_prefix_cmd ("target", class_run
, target_command
,
194 "Connect to a target machine or process.\n\
195 The first argument is the type or protocol of the target machine.\n\
196 Remaining arguments are interpreted by the target protocol. For more\n\
197 information on the arguments for a particular protocol, type\n\
198 `help target ' followed by the protocol name.",
199 &targetlist
, "target ", 0, &cmdlist
);
200 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
212 nomemory (memaddr
, myaddr
, len
, write
, t
)
217 struct target_ops
*t
;
219 errno
= EIO
; /* Can't read/write this location */
220 return 0; /* No bytes handled */
226 error ("You can't do that when your target is `%s'",
227 current_target
.to_shortname
);
233 error ("You can't do that without a process to debug");
238 nosymbol (name
, addrp
)
242 return 1; /* Symbol does not exist in target env */
247 default_terminal_info (args
, from_tty
)
251 printf_unfiltered("No saved terminal information.\n");
254 /* This is the default target_create_inferior and target_attach function.
255 If the current target is executing, it asks whether to kill it off.
256 If this function returns without calling error(), it has killed off
257 the target, and the operation should be attempted. */
260 kill_or_be_killed (from_tty
)
263 if (target_has_execution
)
265 printf_unfiltered ("You are already running a program:\n");
266 target_files_info ();
267 if (query ("Kill it? ")) {
269 if (target_has_execution
)
270 error ("Killing the program did not help.");
273 error ("Program not killed.");
280 maybe_kill_then_attach (args
, from_tty
)
284 kill_or_be_killed (from_tty
);
285 target_attach (args
, from_tty
);
289 maybe_kill_then_create_inferior (exec
, args
, env
)
294 kill_or_be_killed (0);
295 target_create_inferior (exec
, args
, env
);
298 /* Clean up a target struct so it no longer has any zero pointers in it.
299 We default entries, at least to stubs that print error messages. */
303 struct target_ops
*t
;
306 #define de_fault(field, value) \
307 if (!t->field) t->field = value
309 /* FIELD DEFAULT VALUE */
311 de_fault (to_open
, (void (*)())tcomplain
);
312 de_fault (to_close
, (void (*)())ignore
);
313 de_fault (to_attach
, maybe_kill_then_attach
);
314 de_fault (to_detach
, (void (*)())ignore
);
315 de_fault (to_resume
, (void (*)())noprocess
);
316 de_fault (to_wait
, (int (*)())noprocess
);
317 de_fault (to_fetch_registers
, (void (*)())ignore
);
318 de_fault (to_store_registers
, (void (*)())noprocess
);
319 de_fault (to_prepare_to_store
, (void (*)())noprocess
);
320 de_fault (to_xfer_memory
, (int (*)())nomemory
);
321 de_fault (to_files_info
, (void (*)())ignore
);
322 de_fault (to_insert_breakpoint
, memory_insert_breakpoint
);
323 de_fault (to_remove_breakpoint
, memory_remove_breakpoint
);
324 de_fault (to_terminal_init
, ignore
);
325 de_fault (to_terminal_inferior
, ignore
);
326 de_fault (to_terminal_ours_for_output
,ignore
);
327 de_fault (to_terminal_ours
, ignore
);
328 de_fault (to_terminal_info
, default_terminal_info
);
329 de_fault (to_kill
, (void (*)())noprocess
);
330 de_fault (to_load
, (void (*)())tcomplain
);
331 de_fault (to_lookup_symbol
, nosymbol
);
332 de_fault (to_create_inferior
, maybe_kill_then_create_inferior
);
333 de_fault (to_mourn_inferior
, (void (*)())noprocess
);
334 de_fault (to_can_run
, return_zero
);
335 de_fault (to_notice_signals
, (void (*)())ignore
);
336 de_fault (to_thread_alive
, (int (*)())ignore
);
337 de_fault (to_stop
, (void (*)())ignore
);
342 /* Go through the target stack from top to bottom, copying over zero entries in
343 current_target. In effect, we are doing class inheritance through the
344 pushed target vectors. */
347 update_current_target ()
349 struct target_stack_item
*item
;
350 struct target_ops
*t
;
352 /* First, reset current_target */
353 memset (¤t_target
, 0, sizeof current_target
);
355 for (item
= target_stack
; item
; item
= item
->next
)
357 t
= item
->target_ops
;
359 #define INHERIT(FIELD, TARGET) \
360 if (!current_target.FIELD) \
361 current_target.FIELD = TARGET->FIELD
363 INHERIT (to_shortname
, t
);
364 INHERIT (to_longname
, t
);
366 INHERIT (to_open
, t
);
367 INHERIT (to_close
, t
);
368 INHERIT (to_attach
, t
);
369 INHERIT (to_detach
, t
);
370 INHERIT (to_resume
, t
);
371 INHERIT (to_wait
, t
);
372 INHERIT (to_fetch_registers
, t
);
373 INHERIT (to_store_registers
, t
);
374 INHERIT (to_prepare_to_store
, t
);
375 INHERIT (to_xfer_memory
, t
);
376 INHERIT (to_files_info
, t
);
377 INHERIT (to_insert_breakpoint
, t
);
378 INHERIT (to_remove_breakpoint
, t
);
379 INHERIT (to_terminal_init
, t
);
380 INHERIT (to_terminal_inferior
, t
);
381 INHERIT (to_terminal_ours_for_output
, t
);
382 INHERIT (to_terminal_ours
, t
);
383 INHERIT (to_terminal_info
, t
);
384 INHERIT (to_kill
, t
);
385 INHERIT (to_load
, t
);
386 INHERIT (to_lookup_symbol
, t
);
387 INHERIT (to_create_inferior
, t
);
388 INHERIT (to_mourn_inferior
, t
);
389 INHERIT (to_can_run
, t
);
390 INHERIT (to_notice_signals
, t
);
391 INHERIT (to_thread_alive
, t
);
392 INHERIT (to_stop
, t
);
393 INHERIT (to_stratum
, t
);
394 INHERIT (DONT_USE
, t
);
395 INHERIT (to_has_all_memory
, t
);
396 INHERIT (to_has_memory
, t
);
397 INHERIT (to_has_stack
, t
);
398 INHERIT (to_has_registers
, t
);
399 INHERIT (to_has_execution
, t
);
400 INHERIT (to_sections
, t
);
401 INHERIT (to_sections_end
, t
);
402 INHERIT (to_magic
, t
);
408 /* Push a new target type into the stack of the existing target accessors,
409 possibly superseding some of the existing accessors.
411 Result is zero if the pushed target ended up on top of the stack,
412 nonzero if at least one target is on top of it.
414 Rather than allow an empty stack, we always have the dummy target at
415 the bottom stratum, so we can call the function vectors without
420 struct target_ops
*t
;
422 struct target_stack_item
*cur
, *prev
, *tmp
;
424 /* Check magic number. If wrong, it probably means someone changed
425 the struct definition, but not all the places that initialize one. */
426 if (t
->to_magic
!= OPS_MAGIC
)
428 fprintf_unfiltered(gdb_stderr
,
429 "Magic number of %s target struct wrong\n",
434 /* Find the proper stratum to install this target in. */
436 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
438 if ((int)(t
->to_stratum
) >= (int)(cur
->target_ops
->to_stratum
))
442 /* If there's already targets at this stratum, remove them. */
445 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
447 /* There's already something on this stratum. Close it off. */
448 (cur
->target_ops
->to_close
) (0);
450 prev
->next
= cur
->next
; /* Unchain old target_ops */
452 target_stack
= cur
->next
; /* Unchain first on list */
458 /* We have removed all targets in our stratum, now add the new one. */
460 tmp
= (struct target_stack_item
*)
461 xmalloc (sizeof (struct target_stack_item
));
470 update_current_target ();
472 cleanup_target (¤t_target
); /* Fill in the gaps */
474 #ifdef MAINTENANCE_CMDS
476 setup_target_debug ();
482 /* Remove a target_ops vector from the stack, wherever it may be.
483 Return how many times it was removed (0 or 1). */
487 struct target_ops
*t
;
489 struct target_stack_item
*cur
, *prev
;
492 t
->to_close (0); /* Let it clean up */
494 /* Look for the specified target. Note that we assume that a target
495 can only occur once in the target stack. */
497 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
498 if (cur
->target_ops
== t
)
502 return 0; /* Didn't find target_ops, quit now */
504 /* Unchain the target */
507 target_stack
= cur
->next
;
509 prev
->next
= cur
->next
;
511 free (cur
); /* Release the target_stack_item */
513 update_current_target ();
514 cleanup_target (¤t_target
);
522 (current_target
.to_close
)(0); /* Let it clean up */
523 if (unpush_target (target_stack
->target_ops
) == 1)
526 fprintf_unfiltered(gdb_stderr
,
527 "pop_target couldn't find target %s\n",
528 current_target
.to_shortname
);
533 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
535 /* target_read_string -- read a null terminated string, up to LEN bytes,
536 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
537 Set *STRING to a pointer to malloc'd memory containing the data; the caller
538 is responsible for freeing it. Return the number of bytes successfully
542 target_read_string (memaddr
, string
, len
, errnop
)
548 int tlen
, origlen
, offset
, i
;
552 int buffer_allocated
;
554 unsigned int nbytes_read
= 0;
556 /* Small for testing. */
557 buffer_allocated
= 4;
558 buffer
= xmalloc (buffer_allocated
);
565 tlen
= MIN (len
, 4 - (memaddr
& 3));
566 offset
= memaddr
& 3;
568 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
572 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
575 bytes
= bufptr
- buffer
;
576 buffer_allocated
*= 2;
577 buffer
= xrealloc (buffer
, buffer_allocated
);
578 bufptr
= buffer
+ bytes
;
581 for (i
= 0; i
< tlen
; i
++)
583 *bufptr
++ = buf
[i
+ offset
];
584 if (buf
[i
+ offset
] == '\000')
586 nbytes_read
+= i
+ 1;
603 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
604 GDB's memory at MYADDR. Returns either 0 for success or an errno value
607 If an error occurs, no guarantee is made about the contents of the data at
608 MYADDR. In particular, the caller should not depend upon partial reads
609 filling the buffer with good data. There is no way for the caller to know
610 how much good data might have been transfered anyway. Callers that can
611 deal with partial reads should call target_read_memory_partial. */
614 target_read_memory (memaddr
, myaddr
, len
)
619 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
622 /* Read LEN bytes of target memory at address MEMADDR, placing the results
623 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
624 and optionally an errno value in the location pointed to by ERRNOPTR
625 if ERRNOPTR is non-null. */
628 target_read_memory_partial (memaddr
, myaddr
, len
, errnoptr
)
634 int nread
; /* Number of bytes actually read. */
635 int errcode
; /* Error from last read. */
637 /* First try a complete read. */
638 errcode
= target_xfer_memory (memaddr
, myaddr
, len
, 0);
646 /* Loop, reading one byte at a time until we get as much as we can. */
647 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
649 errcode
= target_xfer_memory (memaddr
++, myaddr
++, 1, 0);
651 /* If an error, the last read was unsuccessful, so adjust count. */
657 if (errnoptr
!= NULL
)
665 target_write_memory (memaddr
, myaddr
, len
)
670 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
673 /* Move memory to or from the targets. Iterate until all of it has
674 been moved, if necessary. The top target gets priority; anything
675 it doesn't want, is offered to the next one down, etc. Note the
676 business with curlen: if an early target says "no, but I have a
677 boundary overlapping this xfer" then we shorten what we offer to
678 the subsequent targets so the early guy will get a chance at the
679 tail before the subsequent ones do.
681 Result is 0 or errno value. */
684 target_xfer_memory (memaddr
, myaddr
, len
, write
)
692 struct target_ops
*t
;
693 struct target_stack_item
*item
;
695 /* to_xfer_memory is not guaranteed to set errno, even when it returns
699 /* The quick case is that the top target does it all. */
700 res
= current_target
.to_xfer_memory
701 (memaddr
, myaddr
, len
, write
, ¤t_target
);
707 /* If res <= 0 then we call it again in the loop. Ah well. */
711 curlen
= len
; /* Want to do it all */
712 for (item
= target_stack
; item
; item
= item
->next
)
714 t
= item
->target_ops
;
715 if (!t
->to_has_memory
)
718 res
= t
->to_xfer_memory (memaddr
, myaddr
, curlen
, write
, t
);
720 break; /* Handled all or part of xfer */
721 if (t
->to_has_all_memory
)
727 /* If this address is for nonexistent memory,
728 read zeros if reading, or do nothing if writing. Return error. */
730 memset (myaddr
, 0, len
);
741 return 0; /* We managed to cover it all somehow. */
747 target_info (args
, from_tty
)
751 struct target_ops
*t
;
752 struct target_stack_item
*item
;
755 if (symfile_objfile
!= NULL
)
756 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
758 #ifdef FILES_INFO_HOOK
759 if (FILES_INFO_HOOK ())
763 for (item
= target_stack
; item
; item
= item
->next
)
765 t
= item
->target_ops
;
767 if (!t
->to_has_memory
)
770 if ((int)(t
->to_stratum
) <= (int)dummy_stratum
)
773 printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
774 printf_unfiltered("%s:\n", t
->to_longname
);
775 (t
->to_files_info
)(t
);
776 has_all_mem
= t
->to_has_all_memory
;
780 /* This is to be called by the open routine before it does
784 target_preopen (from_tty
)
789 if (target_has_execution
)
791 if (query ("A program is being debugged already. Kill it? "))
794 error ("Program not killed.");
797 /* Calling target_kill may remove the target from the stack. But if
798 it doesn't (which seems like a win for UDI), remove it now. */
800 if (target_has_execution
)
804 /* Detach a target after doing deferred register stores. */
807 target_detach (args
, from_tty
)
811 /* Handle any optimized stores to the inferior. */
812 #ifdef DO_DEFERRED_STORES
815 (current_target
.to_detach
) (args
, from_tty
);
819 target_link (modname
, t_reloc
)
823 if (STREQ(current_target
.to_shortname
, "rombug"))
825 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
827 error("Unable to link to %s and get relocation in rombug", modname
);
830 *t_reloc
= (CORE_ADDR
)-1;
833 /* Look through the list of possible targets for a target that can
834 execute a run or attach command without any other data. This is
835 used to locate the default process stratum.
837 Result is always valid (error() is called for errors). */
839 static struct target_ops
*
840 find_default_run_target (do_mesg
)
843 struct target_ops
**t
;
844 struct target_ops
*runable
= NULL
;
849 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
852 if ((*t
)->to_can_run
&& target_can_run(*t
))
860 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
866 find_default_attach (args
, from_tty
)
870 struct target_ops
*t
;
872 t
= find_default_run_target("attach");
873 (t
->to_attach
) (args
, from_tty
);
878 find_default_create_inferior (exec_file
, allargs
, env
)
883 struct target_ops
*t
;
885 t
= find_default_run_target("run");
886 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
899 struct target_ops
**t
;
900 struct target_ops
*runable
= NULL
;
905 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
908 if ((*t
)->to_stratum
== core_stratum
)
915 return(count
== 1 ? runable
: NULL
);
918 /* The inferior process has died. Long live the inferior! */
921 generic_mourn_inferior ()
923 extern int show_breakpoint_hit_counts
;
927 breakpoint_init_inferior ();
928 registers_changed ();
930 #ifdef CLEAR_DEFERRED_STORES
931 /* Delete any pending stores to the inferior... */
932 CLEAR_DEFERRED_STORES
;
936 reinit_frame_cache ();
938 /* It is confusing to the user for ignore counts to stick around
939 from previous runs of the inferior. So clear them. */
940 /* However, it is more confusing for the ignore counts to disappear when
941 using hit counts. So don't clear them if we're counting hits. */
942 if (!show_breakpoint_hit_counts
)
943 breakpoint_clear_ignore_counts ();
946 /* This table must match in order and size the signals in enum target_signal
954 {"SIGHUP", "Hangup"},
955 {"SIGINT", "Interrupt"},
957 {"SIGILL", "Illegal instruction"},
958 {"SIGTRAP", "Trace/breakpoint trap"},
959 {"SIGABRT", "Aborted"},
960 {"SIGEMT", "Emulation trap"},
961 {"SIGFPE", "Arithmetic exception"},
962 {"SIGKILL", "Killed"},
963 {"SIGBUS", "Bus error"},
964 {"SIGSEGV", "Segmentation fault"},
965 {"SIGSYS", "Bad system call"},
966 {"SIGPIPE", "Broken pipe"},
967 {"SIGALRM", "Alarm clock"},
968 {"SIGTERM", "Terminated"},
969 {"SIGURG", "Urgent I/O condition"},
970 {"SIGSTOP", "Stopped (signal)"},
971 {"SIGTSTP", "Stopped (user)"},
972 {"SIGCONT", "Continued"},
973 {"SIGCHLD", "Child status changed"},
974 {"SIGTTIN", "Stopped (tty input)"},
975 {"SIGTTOU", "Stopped (tty output)"},
976 {"SIGIO", "I/O possible"},
977 {"SIGXCPU", "CPU time limit exceeded"},
978 {"SIGXFSZ", "File size limit exceeded"},
979 {"SIGVTALRM", "Virtual timer expired"},
980 {"SIGPROF", "Profiling timer expired"},
981 {"SIGWINCH", "Window size changed"},
982 {"SIGLOST", "Resource lost"},
983 {"SIGUSR1", "User defined signal 1"},
984 {"SIGUSR2", "User defined signal 2"},
985 {"SIGPWR", "Power fail/restart"},
986 {"SIGPOLL", "Pollable event occurred"},
987 {"SIGWIND", "SIGWIND"},
988 {"SIGPHONE", "SIGPHONE"},
989 {"SIGWAITING", "Process's LWPs are blocked"},
990 {"SIGLWP", "Signal LWP"},
991 {"SIGDANGER", "Swap space dangerously low"},
992 {"SIGGRANT", "Monitor mode granted"},
993 {"SIGRETRACT", "Need to relinguish monitor mode"},
994 {"SIGMSG", "Monitor mode data available"},
995 {"SIGSOUND", "Sound completed"},
996 {"SIGSAK", "Secure attention"},
997 {"SIGPRIO", "SIGPRIO"},
998 {"SIG33", "Real-time event 33"},
999 {"SIG34", "Real-time event 34"},
1000 {"SIG35", "Real-time event 35"},
1001 {"SIG36", "Real-time event 36"},
1002 {"SIG37", "Real-time event 37"},
1003 {"SIG38", "Real-time event 38"},
1004 {"SIG39", "Real-time event 39"},
1005 {"SIG40", "Real-time event 40"},
1006 {"SIG41", "Real-time event 41"},
1007 {"SIG42", "Real-time event 42"},
1008 {"SIG43", "Real-time event 43"},
1009 {"SIG44", "Real-time event 44"},
1010 {"SIG45", "Real-time event 45"},
1011 {"SIG46", "Real-time event 46"},
1012 {"SIG47", "Real-time event 47"},
1013 {"SIG48", "Real-time event 48"},
1014 {"SIG49", "Real-time event 49"},
1015 {"SIG50", "Real-time event 50"},
1016 {"SIG51", "Real-time event 51"},
1017 {"SIG52", "Real-time event 52"},
1018 {"SIG53", "Real-time event 53"},
1019 {"SIG54", "Real-time event 54"},
1020 {"SIG55", "Real-time event 55"},
1021 {"SIG56", "Real-time event 56"},
1022 {"SIG57", "Real-time event 57"},
1023 {"SIG58", "Real-time event 58"},
1024 {"SIG59", "Real-time event 59"},
1025 {"SIG60", "Real-time event 60"},
1026 {"SIG61", "Real-time event 61"},
1027 {"SIG62", "Real-time event 62"},
1028 {"SIG63", "Real-time event 63"},
1030 {NULL
, "Unknown signal"},
1031 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1033 /* Last entry, used to check whether the table is the right size. */
1034 {NULL
, "TARGET_SIGNAL_MAGIC"}
1037 /* Return the string for a signal. */
1039 target_signal_to_string (sig
)
1040 enum target_signal sig
;
1042 return signals
[sig
].string
;
1045 /* Return the name for a signal. */
1047 target_signal_to_name (sig
)
1048 enum target_signal sig
;
1050 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1051 /* I think the code which prints this will always print it along with
1052 the string, so no need to be verbose. */
1054 return signals
[sig
].name
;
1057 /* Given a name, return its signal. */
1059 target_signal_from_name (name
)
1062 enum target_signal sig
;
1064 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1065 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1066 questionable; seems like by now people should call it SIGABRT
1069 /* This ugly cast brought to you by the native VAX compiler. */
1070 for (sig
= TARGET_SIGNAL_HUP
;
1071 signals
[sig
].name
!= NULL
;
1072 sig
= (enum target_signal
)((int)sig
+ 1))
1073 if (STREQ (name
, signals
[sig
].name
))
1075 return TARGET_SIGNAL_UNKNOWN
;
1078 /* The following functions are to help certain targets deal
1079 with the signal/waitstatus stuff. They could just as well be in
1080 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1082 /* Convert host signal to our signals. */
1084 target_signal_from_host (hostsig
)
1087 /* A switch statement would make sense but would require special kludges
1088 to deal with the cases where more than one signal has the same number. */
1090 if (hostsig
== 0) return TARGET_SIGNAL_0
;
1092 #if defined (SIGHUP)
1093 if (hostsig
== SIGHUP
) return TARGET_SIGNAL_HUP
;
1095 #if defined (SIGINT)
1096 if (hostsig
== SIGINT
) return TARGET_SIGNAL_INT
;
1098 #if defined (SIGQUIT)
1099 if (hostsig
== SIGQUIT
) return TARGET_SIGNAL_QUIT
;
1101 #if defined (SIGILL)
1102 if (hostsig
== SIGILL
) return TARGET_SIGNAL_ILL
;
1104 #if defined (SIGTRAP)
1105 if (hostsig
== SIGTRAP
) return TARGET_SIGNAL_TRAP
;
1107 #if defined (SIGABRT)
1108 if (hostsig
== SIGABRT
) return TARGET_SIGNAL_ABRT
;
1110 #if defined (SIGEMT)
1111 if (hostsig
== SIGEMT
) return TARGET_SIGNAL_EMT
;
1113 #if defined (SIGFPE)
1114 if (hostsig
== SIGFPE
) return TARGET_SIGNAL_FPE
;
1116 #if defined (SIGKILL)
1117 if (hostsig
== SIGKILL
) return TARGET_SIGNAL_KILL
;
1119 #if defined (SIGBUS)
1120 if (hostsig
== SIGBUS
) return TARGET_SIGNAL_BUS
;
1122 #if defined (SIGSEGV)
1123 if (hostsig
== SIGSEGV
) return TARGET_SIGNAL_SEGV
;
1125 #if defined (SIGSYS)
1126 if (hostsig
== SIGSYS
) return TARGET_SIGNAL_SYS
;
1128 #if defined (SIGPIPE)
1129 if (hostsig
== SIGPIPE
) return TARGET_SIGNAL_PIPE
;
1131 #if defined (SIGALRM)
1132 if (hostsig
== SIGALRM
) return TARGET_SIGNAL_ALRM
;
1134 #if defined (SIGTERM)
1135 if (hostsig
== SIGTERM
) return TARGET_SIGNAL_TERM
;
1137 #if defined (SIGUSR1)
1138 if (hostsig
== SIGUSR1
) return TARGET_SIGNAL_USR1
;
1140 #if defined (SIGUSR2)
1141 if (hostsig
== SIGUSR2
) return TARGET_SIGNAL_USR2
;
1143 #if defined (SIGCLD)
1144 if (hostsig
== SIGCLD
) return TARGET_SIGNAL_CHLD
;
1146 #if defined (SIGCHLD)
1147 if (hostsig
== SIGCHLD
) return TARGET_SIGNAL_CHLD
;
1149 #if defined (SIGPWR)
1150 if (hostsig
== SIGPWR
) return TARGET_SIGNAL_PWR
;
1152 #if defined (SIGWINCH)
1153 if (hostsig
== SIGWINCH
) return TARGET_SIGNAL_WINCH
;
1155 #if defined (SIGURG)
1156 if (hostsig
== SIGURG
) return TARGET_SIGNAL_URG
;
1159 if (hostsig
== SIGIO
) return TARGET_SIGNAL_IO
;
1161 #if defined (SIGPOLL)
1162 if (hostsig
== SIGPOLL
) return TARGET_SIGNAL_POLL
;
1164 #if defined (SIGSTOP)
1165 if (hostsig
== SIGSTOP
) return TARGET_SIGNAL_STOP
;
1167 #if defined (SIGTSTP)
1168 if (hostsig
== SIGTSTP
) return TARGET_SIGNAL_TSTP
;
1170 #if defined (SIGCONT)
1171 if (hostsig
== SIGCONT
) return TARGET_SIGNAL_CONT
;
1173 #if defined (SIGTTIN)
1174 if (hostsig
== SIGTTIN
) return TARGET_SIGNAL_TTIN
;
1176 #if defined (SIGTTOU)
1177 if (hostsig
== SIGTTOU
) return TARGET_SIGNAL_TTOU
;
1179 #if defined (SIGVTALRM)
1180 if (hostsig
== SIGVTALRM
) return TARGET_SIGNAL_VTALRM
;
1182 #if defined (SIGPROF)
1183 if (hostsig
== SIGPROF
) return TARGET_SIGNAL_PROF
;
1185 #if defined (SIGXCPU)
1186 if (hostsig
== SIGXCPU
) return TARGET_SIGNAL_XCPU
;
1188 #if defined (SIGXFSZ)
1189 if (hostsig
== SIGXFSZ
) return TARGET_SIGNAL_XFSZ
;
1191 #if defined (SIGWIND)
1192 if (hostsig
== SIGWIND
) return TARGET_SIGNAL_WIND
;
1194 #if defined (SIGPHONE)
1195 if (hostsig
== SIGPHONE
) return TARGET_SIGNAL_PHONE
;
1197 #if defined (SIGLOST)
1198 if (hostsig
== SIGLOST
) return TARGET_SIGNAL_LOST
;
1200 #if defined (SIGWAITING)
1201 if (hostsig
== SIGWAITING
) return TARGET_SIGNAL_WAITING
;
1203 #if defined (SIGLWP)
1204 if (hostsig
== SIGLWP
) return TARGET_SIGNAL_LWP
;
1206 #if defined (SIGDANGER)
1207 if (hostsig
== SIGDANGER
) return TARGET_SIGNAL_DANGER
;
1209 #if defined (SIGGRANT)
1210 if (hostsig
== SIGGRANT
) return TARGET_SIGNAL_GRANT
;
1212 #if defined (SIGRETRACT)
1213 if (hostsig
== SIGRETRACT
) return TARGET_SIGNAL_RETRACT
;
1215 #if defined (SIGMSG)
1216 if (hostsig
== SIGMSG
) return TARGET_SIGNAL_MSG
;
1218 #if defined (SIGSOUND)
1219 if (hostsig
== SIGSOUND
) return TARGET_SIGNAL_SOUND
;
1221 #if defined (SIGSAK)
1222 if (hostsig
== SIGSAK
) return TARGET_SIGNAL_SAK
;
1224 #if defined (SIGPRIO)
1225 if (hostsig
== SIGPRIO
) return TARGET_SIGNAL_PRIO
;
1227 #if defined (REALTIME_LO)
1228 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1229 return (enum target_signal
)
1230 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1232 return TARGET_SIGNAL_UNKNOWN
;
1236 target_signal_to_host (oursig
)
1237 enum target_signal oursig
;
1241 case TARGET_SIGNAL_0
: return 0;
1243 #if defined (SIGHUP)
1244 case TARGET_SIGNAL_HUP
: return SIGHUP
;
1246 #if defined (SIGINT)
1247 case TARGET_SIGNAL_INT
: return SIGINT
;
1249 #if defined (SIGQUIT)
1250 case TARGET_SIGNAL_QUIT
: return SIGQUIT
;
1252 #if defined (SIGILL)
1253 case TARGET_SIGNAL_ILL
: return SIGILL
;
1255 #if defined (SIGTRAP)
1256 case TARGET_SIGNAL_TRAP
: return SIGTRAP
;
1258 #if defined (SIGABRT)
1259 case TARGET_SIGNAL_ABRT
: return SIGABRT
;
1261 #if defined (SIGEMT)
1262 case TARGET_SIGNAL_EMT
: return SIGEMT
;
1264 #if defined (SIGFPE)
1265 case TARGET_SIGNAL_FPE
: return SIGFPE
;
1267 #if defined (SIGKILL)
1268 case TARGET_SIGNAL_KILL
: return SIGKILL
;
1270 #if defined (SIGBUS)
1271 case TARGET_SIGNAL_BUS
: return SIGBUS
;
1273 #if defined (SIGSEGV)
1274 case TARGET_SIGNAL_SEGV
: return SIGSEGV
;
1276 #if defined (SIGSYS)
1277 case TARGET_SIGNAL_SYS
: return SIGSYS
;
1279 #if defined (SIGPIPE)
1280 case TARGET_SIGNAL_PIPE
: return SIGPIPE
;
1282 #if defined (SIGALRM)
1283 case TARGET_SIGNAL_ALRM
: return SIGALRM
;
1285 #if defined (SIGTERM)
1286 case TARGET_SIGNAL_TERM
: return SIGTERM
;
1288 #if defined (SIGUSR1)
1289 case TARGET_SIGNAL_USR1
: return SIGUSR1
;
1291 #if defined (SIGUSR2)
1292 case TARGET_SIGNAL_USR2
: return SIGUSR2
;
1294 #if defined (SIGCHLD) || defined (SIGCLD)
1295 case TARGET_SIGNAL_CHLD
:
1296 #if defined (SIGCHLD)
1301 #endif /* SIGCLD or SIGCHLD */
1302 #if defined (SIGPWR)
1303 case TARGET_SIGNAL_PWR
: return SIGPWR
;
1305 #if defined (SIGWINCH)
1306 case TARGET_SIGNAL_WINCH
: return SIGWINCH
;
1308 #if defined (SIGURG)
1309 case TARGET_SIGNAL_URG
: return SIGURG
;
1312 case TARGET_SIGNAL_IO
: return SIGIO
;
1314 #if defined (SIGPOLL)
1315 case TARGET_SIGNAL_POLL
: return SIGPOLL
;
1317 #if defined (SIGSTOP)
1318 case TARGET_SIGNAL_STOP
: return SIGSTOP
;
1320 #if defined (SIGTSTP)
1321 case TARGET_SIGNAL_TSTP
: return SIGTSTP
;
1323 #if defined (SIGCONT)
1324 case TARGET_SIGNAL_CONT
: return SIGCONT
;
1326 #if defined (SIGTTIN)
1327 case TARGET_SIGNAL_TTIN
: return SIGTTIN
;
1329 #if defined (SIGTTOU)
1330 case TARGET_SIGNAL_TTOU
: return SIGTTOU
;
1332 #if defined (SIGVTALRM)
1333 case TARGET_SIGNAL_VTALRM
: return SIGVTALRM
;
1335 #if defined (SIGPROF)
1336 case TARGET_SIGNAL_PROF
: return SIGPROF
;
1338 #if defined (SIGXCPU)
1339 case TARGET_SIGNAL_XCPU
: return SIGXCPU
;
1341 #if defined (SIGXFSZ)
1342 case TARGET_SIGNAL_XFSZ
: return SIGXFSZ
;
1344 #if defined (SIGWIND)
1345 case TARGET_SIGNAL_WIND
: return SIGWIND
;
1347 #if defined (SIGPHONE)
1348 case TARGET_SIGNAL_PHONE
: return SIGPHONE
;
1350 #if defined (SIGLOST)
1351 case TARGET_SIGNAL_LOST
: return SIGLOST
;
1353 #if defined (SIGWAITING)
1354 case TARGET_SIGNAL_WAITING
: return SIGWAITING
;
1356 #if defined (SIGLWP)
1357 case TARGET_SIGNAL_LWP
: return SIGLWP
;
1359 #if defined (SIGDANGER)
1360 case TARGET_SIGNAL_DANGER
: return SIGDANGER
;
1362 #if defined (SIGGRANT)
1363 case TARGET_SIGNAL_GRANT
: return SIGGRANT
;
1365 #if defined (SIGRETRACT)
1366 case TARGET_SIGNAL_RETRACT
: return SIGRETRACT
;
1368 #if defined (SIGMSG)
1369 case TARGET_SIGNAL_MSG
: return SIGMSG
;
1371 #if defined (SIGSOUND)
1372 case TARGET_SIGNAL_SOUND
: return SIGSOUND
;
1374 #if defined (SIGSAK)
1375 case TARGET_SIGNAL_SAK
: return SIGSAK
;
1377 #if defined (SIGPRIO)
1378 case TARGET_SIGNAL_PRIO
: return SIGPRIO
;
1381 #if defined (REALTIME_LO)
1382 if (oursig
>= TARGET_SIGNAL_REALTIME_33
1383 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
1386 (int)oursig
- (int)TARGET_SIGNAL_REALTIME_33
+ REALTIME_LO
;
1387 if (retsig
< REALTIME_HI
)
1391 /* The user might be trying to do "signal SIGSAK" where this system
1392 doesn't have SIGSAK. */
1393 warning ("Signal %s does not exist on this system.\n",
1394 target_signal_to_name (oursig
));
1399 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1400 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1401 translation of that in OURSTATUS. */
1403 store_waitstatus (ourstatus
, hoststatus
)
1404 struct target_waitstatus
*ourstatus
;
1407 #ifdef CHILD_SPECIAL_WAITSTATUS
1408 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1409 if it wants to deal with hoststatus. */
1410 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1414 if (WIFEXITED (hoststatus
))
1416 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1417 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1419 else if (!WIFSTOPPED (hoststatus
))
1421 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1422 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1426 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1427 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1431 /* In some circumstances we allow a command to specify a numeric
1432 signal. The idea is to keep these circumstances limited so that
1433 users (and scripts) develop portable habits. For comparison,
1434 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1435 numeric signal at all is obscelescent. We are slightly more
1436 lenient and allow 1-15 which should match host signal numbers on
1437 most systems. Use of symbolic signal names is strongly encouraged. */
1440 target_signal_from_command (num
)
1443 if (num
>= 1 && num
<= 15)
1444 return (enum target_signal
)num
;
1445 error ("Only signals 1-15 are valid as numeric signals.\n\
1446 Use \"info signals\" for a list of symbolic signals.");
1449 /* Returns zero to leave the inferior alone, one to interrupt it. */
1450 int (*target_activity_function
) PARAMS ((void));
1451 int target_activity_fd
;
1453 /* Convert a normal process ID to a string. Returns the string in a static
1457 normal_pid_to_str (pid
)
1460 static char buf
[30];
1462 if (STREQ (current_target
.to_shortname
, "remote"))
1463 sprintf (buf
, "thread %d", pid
);
1465 sprintf (buf
, "process %d", pid
);
1470 #ifdef MAINTENANCE_CMDS
1471 static struct target_ops debug_target
;
1474 debug_to_open (args
, from_tty
)
1478 debug_target
.to_open (args
, from_tty
);
1480 fprintf_unfiltered (stderr
, "target_open (%s, %d)\n", args
, from_tty
);
1484 debug_to_close (quitting
)
1487 debug_target
.to_close (quitting
);
1489 fprintf_unfiltered (stderr
, "target_close (%d)\n", quitting
);
1493 debug_to_attach (args
, from_tty
)
1497 debug_target
.to_attach (args
, from_tty
);
1499 fprintf_unfiltered (stderr
, "target_attach (%s, %d)\n", args
, from_tty
);
1503 debug_to_detach (args
, from_tty
)
1507 debug_target
.to_detach (args
, from_tty
);
1509 fprintf_unfiltered (stderr
, "target_detach (%s, %d)\n", args
, from_tty
);
1513 debug_to_resume (pid
, step
, siggnal
)
1516 enum target_signal siggnal
;
1518 debug_target
.to_resume (pid
, step
, siggnal
);
1520 fprintf_unfiltered (stderr
, "target_resume (%d, %s, %s)\n", pid
,
1521 step
? "step" : "continue",
1522 target_signal_to_name (siggnal
));
1526 debug_to_wait (pid
, status
)
1528 struct target_waitstatus
*status
;
1532 retval
= debug_target
.to_wait (pid
, status
);
1534 fprintf_unfiltered (stderr
, "target_wait (%d, status) = %d, ", pid
, retval
);
1535 fprintf_unfiltered (stderr
, "status->kind = ");
1536 switch (status
->kind
)
1538 case TARGET_WAITKIND_EXITED
:
1539 fprintf_unfiltered (stderr
, "exited, status = %d\n", status
->value
.integer
);
1541 case TARGET_WAITKIND_STOPPED
:
1542 fprintf_unfiltered (stderr
, "stopped, signal = %s\n",
1543 target_signal_to_name (status
->value
.sig
));
1545 case TARGET_WAITKIND_SIGNALLED
:
1546 fprintf_unfiltered (stderr
, "signalled, signal = %s\n",
1547 target_signal_to_name (status
->value
.sig
));
1549 case TARGET_WAITKIND_LOADED
:
1550 fprintf_unfiltered (stderr
, "loaded\n");
1552 case TARGET_WAITKIND_SPURIOUS
:
1553 fprintf_unfiltered (stderr
, "spurious\n");
1556 fprintf_unfiltered (stderr
, "unknown???\n");
1564 debug_to_fetch_registers (regno
)
1567 debug_target
.to_fetch_registers (regno
);
1569 fprintf_unfiltered (stderr
, "target_fetch_registers (%s)",
1570 regno
!= -1 ? reg_names
[regno
] : "-1");
1572 fprintf_unfiltered (stderr
, " = 0x%x %d", read_register (regno
),
1573 read_register (regno
));
1574 fprintf_unfiltered (stderr
, "\n");
1578 debug_to_store_registers (regno
)
1581 debug_target
.to_store_registers (regno
);
1583 if (regno
>= 0 && regno
< NUM_REGS
)
1584 fprintf_unfiltered (stderr
, "target_store_registers (%s) = 0x%x %d\n",
1585 reg_names
[regno
], read_register (regno
),
1586 read_register (regno
));
1588 fprintf_unfiltered (stderr
, "target_store_registers (%d)\n", regno
);
1592 debug_to_prepare_to_store ()
1594 debug_target
.to_prepare_to_store ();
1596 fprintf_unfiltered (stderr
, "target_prepare_to_store ()\n");
1600 debug_to_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1605 struct target_ops
*target
;
1609 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
1611 fprintf_unfiltered (stderr
, "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1612 memaddr
, len
, write
? "write" : "read", retval
);
1618 fputs_unfiltered (", bytes =", gdb_stderr
);
1619 for (i
= 0; i
< retval
; i
++)
1620 fprintf_unfiltered (stderr
, " %02x", myaddr
[i
] & 0xff);
1623 fputc_unfiltered ('\n', gdb_stderr
);
1629 debug_to_files_info (target
)
1630 struct target_ops
*target
;
1632 debug_target
.to_files_info (target
);
1634 fprintf_unfiltered (stderr
, "target_files_info (xxx)\n");
1638 debug_to_insert_breakpoint (addr
, save
)
1644 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1646 fprintf_unfiltered (stderr
, "target_insert_breakpoint (0x%x, xxx) = %d\n",
1652 debug_to_remove_breakpoint (addr
, save
)
1658 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1660 fprintf_unfiltered (stderr
, "target_remove_breakpoint (0x%x, xxx) = %d\n",
1666 debug_to_terminal_init ()
1668 debug_target
.to_terminal_init ();
1670 fprintf_unfiltered (stderr
, "target_terminal_init ()\n");
1674 debug_to_terminal_inferior ()
1676 debug_target
.to_terminal_inferior ();
1678 fprintf_unfiltered (stderr
, "target_terminal_inferior ()\n");
1682 debug_to_terminal_ours_for_output ()
1684 debug_target
.to_terminal_ours_for_output ();
1686 fprintf_unfiltered (stderr
, "target_terminal_ours_for_output ()\n");
1690 debug_to_terminal_ours ()
1692 debug_target
.to_terminal_ours ();
1694 fprintf_unfiltered (stderr
, "target_terminal_ours ()\n");
1698 debug_to_terminal_info (arg
, from_tty
)
1702 debug_target
.to_terminal_info (arg
, from_tty
);
1704 fprintf_unfiltered (stderr
, "target_terminal_info (%s, %d)\n", arg
,
1711 debug_target
.to_kill ();
1713 fprintf_unfiltered (stderr
, "target_kill ()\n");
1717 debug_to_load (args
, from_tty
)
1721 debug_target
.to_load (args
, from_tty
);
1723 fprintf_unfiltered (stderr
, "target_load (%s, %d)\n", args
, from_tty
);
1727 debug_to_lookup_symbol (name
, addrp
)
1733 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1735 fprintf_unfiltered (stderr
, "target_lookup_symbol (%s, xxx)\n", name
);
1741 debug_to_create_inferior (exec_file
, args
, env
)
1746 debug_target
.to_create_inferior (exec_file
, args
, env
);
1748 fprintf_unfiltered (stderr
, "target_create_inferior (%s, %s, xxx)\n",
1753 debug_to_mourn_inferior ()
1755 debug_target
.to_mourn_inferior ();
1757 fprintf_unfiltered (stderr
, "target_mourn_inferior ()\n");
1765 retval
= debug_target
.to_can_run ();
1767 fprintf_unfiltered (stderr
, "target_can_run () = %d\n", retval
);
1773 debug_to_notice_signals (pid
)
1776 debug_target
.to_notice_signals (pid
);
1778 fprintf_unfiltered (stderr
, "target_notice_signals (%d)\n", pid
);
1782 debug_to_thread_alive (pid
)
1785 debug_target
.to_thread_alive (pid
);
1787 fprintf_unfiltered (stderr
, "target_thread_alive (%d)\n", pid
);
1794 debug_target
.to_stop ();
1796 fprintf_unfiltered (stderr
, "target_stop ()\n");
1800 setup_target_debug ()
1802 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
1804 current_target
.to_open
= debug_to_open
;
1805 current_target
.to_close
= debug_to_close
;
1806 current_target
.to_attach
= debug_to_attach
;
1807 current_target
.to_detach
= debug_to_detach
;
1808 current_target
.to_resume
= debug_to_resume
;
1809 current_target
.to_wait
= debug_to_wait
;
1810 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
1811 current_target
.to_store_registers
= debug_to_store_registers
;
1812 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
1813 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
1814 current_target
.to_files_info
= debug_to_files_info
;
1815 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
1816 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
1817 current_target
.to_terminal_init
= debug_to_terminal_init
;
1818 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
1819 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
1820 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
1821 current_target
.to_terminal_info
= debug_to_terminal_info
;
1822 current_target
.to_kill
= debug_to_kill
;
1823 current_target
.to_load
= debug_to_load
;
1824 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
1825 current_target
.to_create_inferior
= debug_to_create_inferior
;
1826 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
1827 current_target
.to_can_run
= debug_to_can_run
;
1828 current_target
.to_notice_signals
= debug_to_notice_signals
;
1829 current_target
.to_thread_alive
= debug_to_thread_alive
;
1830 current_target
.to_stop
= debug_to_stop
;
1832 #endif /* MAINTENANCE_CMDS */
1834 static char targ_desc
[] =
1835 "Names of targets and files being debugged.\n\
1836 Shows the entire stack of targets currently in use (including the exec-file,\n\
1837 core-file, and process, if any), as well as the symbol file name.";
1840 initialize_targets ()
1842 push_target (&dummy_target
);
1844 add_info ("target", target_info
, targ_desc
);
1845 add_info ("files", target_info
, targ_desc
);
1847 #ifdef MAINTENANCE_CMDS
1849 add_set_cmd ("targetdebug", class_maintenance
, var_zinteger
,
1850 (char *)&targetdebug
,
1851 "Set target debugging.\n\
1852 When non-zero, target debugging is enabled.", &setlist
),
1856 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))