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., 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 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 if (cur
->target_ops
->to_close
)
449 (cur
->target_ops
->to_close
) (0);
451 prev
->next
= cur
->next
; /* Unchain old target_ops */
453 target_stack
= cur
->next
; /* Unchain first on list */
459 /* We have removed all targets in our stratum, now add the new one. */
461 tmp
= (struct target_stack_item
*)
462 xmalloc (sizeof (struct target_stack_item
));
471 update_current_target ();
473 cleanup_target (¤t_target
); /* Fill in the gaps */
475 #ifdef MAINTENANCE_CMDS
477 setup_target_debug ();
483 /* Remove a target_ops vector from the stack, wherever it may be.
484 Return how many times it was removed (0 or 1). */
488 struct target_ops
*t
;
490 struct target_stack_item
*cur
, *prev
;
493 t
->to_close (0); /* Let it clean up */
495 /* Look for the specified target. Note that we assume that a target
496 can only occur once in the target stack. */
498 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
499 if (cur
->target_ops
== t
)
503 return 0; /* Didn't find target_ops, quit now */
505 /* Unchain the target */
508 target_stack
= cur
->next
;
510 prev
->next
= cur
->next
;
512 free (cur
); /* Release the target_stack_item */
514 update_current_target ();
515 cleanup_target (¤t_target
);
523 (current_target
.to_close
)(0); /* Let it clean up */
524 if (unpush_target (target_stack
->target_ops
) == 1)
527 fprintf_unfiltered(gdb_stderr
,
528 "pop_target couldn't find target %s\n",
529 current_target
.to_shortname
);
534 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
536 /* target_read_string -- read a null terminated string, up to LEN bytes,
537 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
538 Set *STRING to a pointer to malloc'd memory containing the data; the caller
539 is responsible for freeing it. Return the number of bytes successfully
543 target_read_string (memaddr
, string
, len
, errnop
)
549 int tlen
, origlen
, offset
, i
;
553 int buffer_allocated
;
555 unsigned int nbytes_read
= 0;
557 /* Small for testing. */
558 buffer_allocated
= 4;
559 buffer
= xmalloc (buffer_allocated
);
566 tlen
= MIN (len
, 4 - (memaddr
& 3));
567 offset
= memaddr
& 3;
569 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
573 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
576 bytes
= bufptr
- buffer
;
577 buffer_allocated
*= 2;
578 buffer
= xrealloc (buffer
, buffer_allocated
);
579 bufptr
= buffer
+ bytes
;
582 for (i
= 0; i
< tlen
; i
++)
584 *bufptr
++ = buf
[i
+ offset
];
585 if (buf
[i
+ offset
] == '\000')
587 nbytes_read
+= i
+ 1;
604 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
605 GDB's memory at MYADDR. Returns either 0 for success or an errno value
608 If an error occurs, no guarantee is made about the contents of the data at
609 MYADDR. In particular, the caller should not depend upon partial reads
610 filling the buffer with good data. There is no way for the caller to know
611 how much good data might have been transfered anyway. Callers that can
612 deal with partial reads should call target_read_memory_partial. */
615 target_read_memory (memaddr
, myaddr
, len
)
620 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
623 /* Read LEN bytes of target memory at address MEMADDR, placing the results
624 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
625 and optionally an errno value in the location pointed to by ERRNOPTR
626 if ERRNOPTR is non-null. */
629 target_read_memory_partial (memaddr
, myaddr
, len
, errnoptr
)
635 int nread
; /* Number of bytes actually read. */
636 int errcode
; /* Error from last read. */
638 /* First try a complete read. */
639 errcode
= target_xfer_memory (memaddr
, myaddr
, len
, 0);
647 /* Loop, reading one byte at a time until we get as much as we can. */
648 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
650 errcode
= target_xfer_memory (memaddr
++, myaddr
++, 1, 0);
652 /* If an error, the last read was unsuccessful, so adjust count. */
658 if (errnoptr
!= NULL
)
666 target_write_memory (memaddr
, myaddr
, len
)
671 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
674 /* Move memory to or from the targets. Iterate until all of it has
675 been moved, if necessary. The top target gets priority; anything
676 it doesn't want, is offered to the next one down, etc. Note the
677 business with curlen: if an early target says "no, but I have a
678 boundary overlapping this xfer" then we shorten what we offer to
679 the subsequent targets so the early guy will get a chance at the
680 tail before the subsequent ones do.
682 Result is 0 or errno value. */
685 target_xfer_memory (memaddr
, myaddr
, len
, write
)
693 struct target_ops
*t
;
694 struct target_stack_item
*item
;
696 /* to_xfer_memory is not guaranteed to set errno, even when it returns
700 /* The quick case is that the top target does it all. */
701 res
= current_target
.to_xfer_memory
702 (memaddr
, myaddr
, len
, write
, ¤t_target
);
708 /* If res <= 0 then we call it again in the loop. Ah well. */
712 curlen
= len
; /* Want to do it all */
713 for (item
= target_stack
; item
; item
= item
->next
)
715 t
= item
->target_ops
;
716 if (!t
->to_has_memory
)
719 res
= t
->to_xfer_memory (memaddr
, myaddr
, curlen
, write
, t
);
721 break; /* Handled all or part of xfer */
722 if (t
->to_has_all_memory
)
728 /* If this address is for nonexistent memory,
729 read zeros if reading, or do nothing if writing. Return error. */
731 memset (myaddr
, 0, len
);
742 return 0; /* We managed to cover it all somehow. */
748 target_info (args
, from_tty
)
752 struct target_ops
*t
;
753 struct target_stack_item
*item
;
756 if (symfile_objfile
!= NULL
)
757 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
759 #ifdef FILES_INFO_HOOK
760 if (FILES_INFO_HOOK ())
764 for (item
= target_stack
; item
; item
= item
->next
)
766 t
= item
->target_ops
;
768 if (!t
->to_has_memory
)
771 if ((int)(t
->to_stratum
) <= (int)dummy_stratum
)
774 printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
775 printf_unfiltered("%s:\n", t
->to_longname
);
776 (t
->to_files_info
)(t
);
777 has_all_mem
= t
->to_has_all_memory
;
781 /* This is to be called by the open routine before it does
785 target_preopen (from_tty
)
790 if (target_has_execution
)
792 if (query ("A program is being debugged already. Kill it? "))
795 error ("Program not killed.");
798 /* Calling target_kill may remove the target from the stack. But if
799 it doesn't (which seems like a win for UDI), remove it now. */
801 if (target_has_execution
)
805 /* Detach a target after doing deferred register stores. */
808 target_detach (args
, from_tty
)
812 /* Handle any optimized stores to the inferior. */
813 #ifdef DO_DEFERRED_STORES
816 (current_target
.to_detach
) (args
, from_tty
);
820 target_link (modname
, t_reloc
)
824 if (STREQ(current_target
.to_shortname
, "rombug"))
826 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
828 error("Unable to link to %s and get relocation in rombug", modname
);
831 *t_reloc
= (CORE_ADDR
)-1;
834 /* Look through the list of possible targets for a target that can
835 execute a run or attach command without any other data. This is
836 used to locate the default process stratum.
838 Result is always valid (error() is called for errors). */
840 static struct target_ops
*
841 find_default_run_target (do_mesg
)
844 struct target_ops
**t
;
845 struct target_ops
*runable
= NULL
;
850 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
853 if ((*t
)->to_can_run
&& target_can_run(*t
))
861 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
867 find_default_attach (args
, from_tty
)
871 struct target_ops
*t
;
873 t
= find_default_run_target("attach");
874 (t
->to_attach
) (args
, from_tty
);
879 find_default_create_inferior (exec_file
, allargs
, env
)
884 struct target_ops
*t
;
886 t
= find_default_run_target("run");
887 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
900 struct target_ops
**t
;
901 struct target_ops
*runable
= NULL
;
906 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
909 if ((*t
)->to_stratum
== core_stratum
)
916 return(count
== 1 ? runable
: NULL
);
919 /* The inferior process has died. Long live the inferior! */
922 generic_mourn_inferior ()
924 extern int show_breakpoint_hit_counts
;
928 breakpoint_init_inferior ();
929 registers_changed ();
931 #ifdef CLEAR_DEFERRED_STORES
932 /* Delete any pending stores to the inferior... */
933 CLEAR_DEFERRED_STORES
;
937 reinit_frame_cache ();
939 /* It is confusing to the user for ignore counts to stick around
940 from previous runs of the inferior. So clear them. */
941 /* However, it is more confusing for the ignore counts to disappear when
942 using hit counts. So don't clear them if we're counting hits. */
943 if (!show_breakpoint_hit_counts
)
944 breakpoint_clear_ignore_counts ();
947 /* This table must match in order and size the signals in enum target_signal
955 {"SIGHUP", "Hangup"},
956 {"SIGINT", "Interrupt"},
958 {"SIGILL", "Illegal instruction"},
959 {"SIGTRAP", "Trace/breakpoint trap"},
960 {"SIGABRT", "Aborted"},
961 {"SIGEMT", "Emulation trap"},
962 {"SIGFPE", "Arithmetic exception"},
963 {"SIGKILL", "Killed"},
964 {"SIGBUS", "Bus error"},
965 {"SIGSEGV", "Segmentation fault"},
966 {"SIGSYS", "Bad system call"},
967 {"SIGPIPE", "Broken pipe"},
968 {"SIGALRM", "Alarm clock"},
969 {"SIGTERM", "Terminated"},
970 {"SIGURG", "Urgent I/O condition"},
971 {"SIGSTOP", "Stopped (signal)"},
972 {"SIGTSTP", "Stopped (user)"},
973 {"SIGCONT", "Continued"},
974 {"SIGCHLD", "Child status changed"},
975 {"SIGTTIN", "Stopped (tty input)"},
976 {"SIGTTOU", "Stopped (tty output)"},
977 {"SIGIO", "I/O possible"},
978 {"SIGXCPU", "CPU time limit exceeded"},
979 {"SIGXFSZ", "File size limit exceeded"},
980 {"SIGVTALRM", "Virtual timer expired"},
981 {"SIGPROF", "Profiling timer expired"},
982 {"SIGWINCH", "Window size changed"},
983 {"SIGLOST", "Resource lost"},
984 {"SIGUSR1", "User defined signal 1"},
985 {"SIGUSR2", "User defined signal 2"},
986 {"SIGPWR", "Power fail/restart"},
987 {"SIGPOLL", "Pollable event occurred"},
988 {"SIGWIND", "SIGWIND"},
989 {"SIGPHONE", "SIGPHONE"},
990 {"SIGWAITING", "Process's LWPs are blocked"},
991 {"SIGLWP", "Signal LWP"},
992 {"SIGDANGER", "Swap space dangerously low"},
993 {"SIGGRANT", "Monitor mode granted"},
994 {"SIGRETRACT", "Need to relinguish monitor mode"},
995 {"SIGMSG", "Monitor mode data available"},
996 {"SIGSOUND", "Sound completed"},
997 {"SIGSAK", "Secure attention"},
998 {"SIGPRIO", "SIGPRIO"},
999 {"SIG33", "Real-time event 33"},
1000 {"SIG34", "Real-time event 34"},
1001 {"SIG35", "Real-time event 35"},
1002 {"SIG36", "Real-time event 36"},
1003 {"SIG37", "Real-time event 37"},
1004 {"SIG38", "Real-time event 38"},
1005 {"SIG39", "Real-time event 39"},
1006 {"SIG40", "Real-time event 40"},
1007 {"SIG41", "Real-time event 41"},
1008 {"SIG42", "Real-time event 42"},
1009 {"SIG43", "Real-time event 43"},
1010 {"SIG44", "Real-time event 44"},
1011 {"SIG45", "Real-time event 45"},
1012 {"SIG46", "Real-time event 46"},
1013 {"SIG47", "Real-time event 47"},
1014 {"SIG48", "Real-time event 48"},
1015 {"SIG49", "Real-time event 49"},
1016 {"SIG50", "Real-time event 50"},
1017 {"SIG51", "Real-time event 51"},
1018 {"SIG52", "Real-time event 52"},
1019 {"SIG53", "Real-time event 53"},
1020 {"SIG54", "Real-time event 54"},
1021 {"SIG55", "Real-time event 55"},
1022 {"SIG56", "Real-time event 56"},
1023 {"SIG57", "Real-time event 57"},
1024 {"SIG58", "Real-time event 58"},
1025 {"SIG59", "Real-time event 59"},
1026 {"SIG60", "Real-time event 60"},
1027 {"SIG61", "Real-time event 61"},
1028 {"SIG62", "Real-time event 62"},
1029 {"SIG63", "Real-time event 63"},
1031 {NULL
, "Unknown signal"},
1032 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1034 /* Last entry, used to check whether the table is the right size. */
1035 {NULL
, "TARGET_SIGNAL_MAGIC"}
1038 /* Return the string for a signal. */
1040 target_signal_to_string (sig
)
1041 enum target_signal sig
;
1043 return signals
[sig
].string
;
1046 /* Return the name for a signal. */
1048 target_signal_to_name (sig
)
1049 enum target_signal sig
;
1051 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1052 /* I think the code which prints this will always print it along with
1053 the string, so no need to be verbose. */
1055 return signals
[sig
].name
;
1058 /* Given a name, return its signal. */
1060 target_signal_from_name (name
)
1063 enum target_signal sig
;
1065 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1066 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1067 questionable; seems like by now people should call it SIGABRT
1070 /* This ugly cast brought to you by the native VAX compiler. */
1071 for (sig
= TARGET_SIGNAL_HUP
;
1072 signals
[sig
].name
!= NULL
;
1073 sig
= (enum target_signal
)((int)sig
+ 1))
1074 if (STREQ (name
, signals
[sig
].name
))
1076 return TARGET_SIGNAL_UNKNOWN
;
1079 /* The following functions are to help certain targets deal
1080 with the signal/waitstatus stuff. They could just as well be in
1081 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1083 /* Convert host signal to our signals. */
1085 target_signal_from_host (hostsig
)
1088 /* A switch statement would make sense but would require special kludges
1089 to deal with the cases where more than one signal has the same number. */
1091 if (hostsig
== 0) return TARGET_SIGNAL_0
;
1093 #if defined (SIGHUP)
1094 if (hostsig
== SIGHUP
) return TARGET_SIGNAL_HUP
;
1096 #if defined (SIGINT)
1097 if (hostsig
== SIGINT
) return TARGET_SIGNAL_INT
;
1099 #if defined (SIGQUIT)
1100 if (hostsig
== SIGQUIT
) return TARGET_SIGNAL_QUIT
;
1102 #if defined (SIGILL)
1103 if (hostsig
== SIGILL
) return TARGET_SIGNAL_ILL
;
1105 #if defined (SIGTRAP)
1106 if (hostsig
== SIGTRAP
) return TARGET_SIGNAL_TRAP
;
1108 #if defined (SIGABRT)
1109 if (hostsig
== SIGABRT
) return TARGET_SIGNAL_ABRT
;
1111 #if defined (SIGEMT)
1112 if (hostsig
== SIGEMT
) return TARGET_SIGNAL_EMT
;
1114 #if defined (SIGFPE)
1115 if (hostsig
== SIGFPE
) return TARGET_SIGNAL_FPE
;
1117 #if defined (SIGKILL)
1118 if (hostsig
== SIGKILL
) return TARGET_SIGNAL_KILL
;
1120 #if defined (SIGBUS)
1121 if (hostsig
== SIGBUS
) return TARGET_SIGNAL_BUS
;
1123 #if defined (SIGSEGV)
1124 if (hostsig
== SIGSEGV
) return TARGET_SIGNAL_SEGV
;
1126 #if defined (SIGSYS)
1127 if (hostsig
== SIGSYS
) return TARGET_SIGNAL_SYS
;
1129 #if defined (SIGPIPE)
1130 if (hostsig
== SIGPIPE
) return TARGET_SIGNAL_PIPE
;
1132 #if defined (SIGALRM)
1133 if (hostsig
== SIGALRM
) return TARGET_SIGNAL_ALRM
;
1135 #if defined (SIGTERM)
1136 if (hostsig
== SIGTERM
) return TARGET_SIGNAL_TERM
;
1138 #if defined (SIGUSR1)
1139 if (hostsig
== SIGUSR1
) return TARGET_SIGNAL_USR1
;
1141 #if defined (SIGUSR2)
1142 if (hostsig
== SIGUSR2
) return TARGET_SIGNAL_USR2
;
1144 #if defined (SIGCLD)
1145 if (hostsig
== SIGCLD
) return TARGET_SIGNAL_CHLD
;
1147 #if defined (SIGCHLD)
1148 if (hostsig
== SIGCHLD
) return TARGET_SIGNAL_CHLD
;
1150 #if defined (SIGPWR)
1151 if (hostsig
== SIGPWR
) return TARGET_SIGNAL_PWR
;
1153 #if defined (SIGWINCH)
1154 if (hostsig
== SIGWINCH
) return TARGET_SIGNAL_WINCH
;
1156 #if defined (SIGURG)
1157 if (hostsig
== SIGURG
) return TARGET_SIGNAL_URG
;
1160 if (hostsig
== SIGIO
) return TARGET_SIGNAL_IO
;
1162 #if defined (SIGPOLL)
1163 if (hostsig
== SIGPOLL
) return TARGET_SIGNAL_POLL
;
1165 #if defined (SIGSTOP)
1166 if (hostsig
== SIGSTOP
) return TARGET_SIGNAL_STOP
;
1168 #if defined (SIGTSTP)
1169 if (hostsig
== SIGTSTP
) return TARGET_SIGNAL_TSTP
;
1171 #if defined (SIGCONT)
1172 if (hostsig
== SIGCONT
) return TARGET_SIGNAL_CONT
;
1174 #if defined (SIGTTIN)
1175 if (hostsig
== SIGTTIN
) return TARGET_SIGNAL_TTIN
;
1177 #if defined (SIGTTOU)
1178 if (hostsig
== SIGTTOU
) return TARGET_SIGNAL_TTOU
;
1180 #if defined (SIGVTALRM)
1181 if (hostsig
== SIGVTALRM
) return TARGET_SIGNAL_VTALRM
;
1183 #if defined (SIGPROF)
1184 if (hostsig
== SIGPROF
) return TARGET_SIGNAL_PROF
;
1186 #if defined (SIGXCPU)
1187 if (hostsig
== SIGXCPU
) return TARGET_SIGNAL_XCPU
;
1189 #if defined (SIGXFSZ)
1190 if (hostsig
== SIGXFSZ
) return TARGET_SIGNAL_XFSZ
;
1192 #if defined (SIGWIND)
1193 if (hostsig
== SIGWIND
) return TARGET_SIGNAL_WIND
;
1195 #if defined (SIGPHONE)
1196 if (hostsig
== SIGPHONE
) return TARGET_SIGNAL_PHONE
;
1198 #if defined (SIGLOST)
1199 if (hostsig
== SIGLOST
) return TARGET_SIGNAL_LOST
;
1201 #if defined (SIGWAITING)
1202 if (hostsig
== SIGWAITING
) return TARGET_SIGNAL_WAITING
;
1204 #if defined (SIGLWP)
1205 if (hostsig
== SIGLWP
) return TARGET_SIGNAL_LWP
;
1207 #if defined (SIGDANGER)
1208 if (hostsig
== SIGDANGER
) return TARGET_SIGNAL_DANGER
;
1210 #if defined (SIGGRANT)
1211 if (hostsig
== SIGGRANT
) return TARGET_SIGNAL_GRANT
;
1213 #if defined (SIGRETRACT)
1214 if (hostsig
== SIGRETRACT
) return TARGET_SIGNAL_RETRACT
;
1216 #if defined (SIGMSG)
1217 if (hostsig
== SIGMSG
) return TARGET_SIGNAL_MSG
;
1219 #if defined (SIGSOUND)
1220 if (hostsig
== SIGSOUND
) return TARGET_SIGNAL_SOUND
;
1222 #if defined (SIGSAK)
1223 if (hostsig
== SIGSAK
) return TARGET_SIGNAL_SAK
;
1225 #if defined (SIGPRIO)
1226 if (hostsig
== SIGPRIO
) return TARGET_SIGNAL_PRIO
;
1228 #if defined (REALTIME_LO)
1229 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1230 return (enum target_signal
)
1231 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1233 return TARGET_SIGNAL_UNKNOWN
;
1237 target_signal_to_host (oursig
)
1238 enum target_signal oursig
;
1242 case TARGET_SIGNAL_0
: return 0;
1244 #if defined (SIGHUP)
1245 case TARGET_SIGNAL_HUP
: return SIGHUP
;
1247 #if defined (SIGINT)
1248 case TARGET_SIGNAL_INT
: return SIGINT
;
1250 #if defined (SIGQUIT)
1251 case TARGET_SIGNAL_QUIT
: return SIGQUIT
;
1253 #if defined (SIGILL)
1254 case TARGET_SIGNAL_ILL
: return SIGILL
;
1256 #if defined (SIGTRAP)
1257 case TARGET_SIGNAL_TRAP
: return SIGTRAP
;
1259 #if defined (SIGABRT)
1260 case TARGET_SIGNAL_ABRT
: return SIGABRT
;
1262 #if defined (SIGEMT)
1263 case TARGET_SIGNAL_EMT
: return SIGEMT
;
1265 #if defined (SIGFPE)
1266 case TARGET_SIGNAL_FPE
: return SIGFPE
;
1268 #if defined (SIGKILL)
1269 case TARGET_SIGNAL_KILL
: return SIGKILL
;
1271 #if defined (SIGBUS)
1272 case TARGET_SIGNAL_BUS
: return SIGBUS
;
1274 #if defined (SIGSEGV)
1275 case TARGET_SIGNAL_SEGV
: return SIGSEGV
;
1277 #if defined (SIGSYS)
1278 case TARGET_SIGNAL_SYS
: return SIGSYS
;
1280 #if defined (SIGPIPE)
1281 case TARGET_SIGNAL_PIPE
: return SIGPIPE
;
1283 #if defined (SIGALRM)
1284 case TARGET_SIGNAL_ALRM
: return SIGALRM
;
1286 #if defined (SIGTERM)
1287 case TARGET_SIGNAL_TERM
: return SIGTERM
;
1289 #if defined (SIGUSR1)
1290 case TARGET_SIGNAL_USR1
: return SIGUSR1
;
1292 #if defined (SIGUSR2)
1293 case TARGET_SIGNAL_USR2
: return SIGUSR2
;
1295 #if defined (SIGCHLD) || defined (SIGCLD)
1296 case TARGET_SIGNAL_CHLD
:
1297 #if defined (SIGCHLD)
1302 #endif /* SIGCLD or SIGCHLD */
1303 #if defined (SIGPWR)
1304 case TARGET_SIGNAL_PWR
: return SIGPWR
;
1306 #if defined (SIGWINCH)
1307 case TARGET_SIGNAL_WINCH
: return SIGWINCH
;
1309 #if defined (SIGURG)
1310 case TARGET_SIGNAL_URG
: return SIGURG
;
1313 case TARGET_SIGNAL_IO
: return SIGIO
;
1315 #if defined (SIGPOLL)
1316 case TARGET_SIGNAL_POLL
: return SIGPOLL
;
1318 #if defined (SIGSTOP)
1319 case TARGET_SIGNAL_STOP
: return SIGSTOP
;
1321 #if defined (SIGTSTP)
1322 case TARGET_SIGNAL_TSTP
: return SIGTSTP
;
1324 #if defined (SIGCONT)
1325 case TARGET_SIGNAL_CONT
: return SIGCONT
;
1327 #if defined (SIGTTIN)
1328 case TARGET_SIGNAL_TTIN
: return SIGTTIN
;
1330 #if defined (SIGTTOU)
1331 case TARGET_SIGNAL_TTOU
: return SIGTTOU
;
1333 #if defined (SIGVTALRM)
1334 case TARGET_SIGNAL_VTALRM
: return SIGVTALRM
;
1336 #if defined (SIGPROF)
1337 case TARGET_SIGNAL_PROF
: return SIGPROF
;
1339 #if defined (SIGXCPU)
1340 case TARGET_SIGNAL_XCPU
: return SIGXCPU
;
1342 #if defined (SIGXFSZ)
1343 case TARGET_SIGNAL_XFSZ
: return SIGXFSZ
;
1345 #if defined (SIGWIND)
1346 case TARGET_SIGNAL_WIND
: return SIGWIND
;
1348 #if defined (SIGPHONE)
1349 case TARGET_SIGNAL_PHONE
: return SIGPHONE
;
1351 #if defined (SIGLOST)
1352 case TARGET_SIGNAL_LOST
: return SIGLOST
;
1354 #if defined (SIGWAITING)
1355 case TARGET_SIGNAL_WAITING
: return SIGWAITING
;
1357 #if defined (SIGLWP)
1358 case TARGET_SIGNAL_LWP
: return SIGLWP
;
1360 #if defined (SIGDANGER)
1361 case TARGET_SIGNAL_DANGER
: return SIGDANGER
;
1363 #if defined (SIGGRANT)
1364 case TARGET_SIGNAL_GRANT
: return SIGGRANT
;
1366 #if defined (SIGRETRACT)
1367 case TARGET_SIGNAL_RETRACT
: return SIGRETRACT
;
1369 #if defined (SIGMSG)
1370 case TARGET_SIGNAL_MSG
: return SIGMSG
;
1372 #if defined (SIGSOUND)
1373 case TARGET_SIGNAL_SOUND
: return SIGSOUND
;
1375 #if defined (SIGSAK)
1376 case TARGET_SIGNAL_SAK
: return SIGSAK
;
1378 #if defined (SIGPRIO)
1379 case TARGET_SIGNAL_PRIO
: return SIGPRIO
;
1382 #if defined (REALTIME_LO)
1383 if (oursig
>= TARGET_SIGNAL_REALTIME_33
1384 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
1387 (int)oursig
- (int)TARGET_SIGNAL_REALTIME_33
+ REALTIME_LO
;
1388 if (retsig
< REALTIME_HI
)
1392 /* The user might be trying to do "signal SIGSAK" where this system
1393 doesn't have SIGSAK. */
1394 warning ("Signal %s does not exist on this system.\n",
1395 target_signal_to_name (oursig
));
1400 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1401 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1402 translation of that in OURSTATUS. */
1404 store_waitstatus (ourstatus
, hoststatus
)
1405 struct target_waitstatus
*ourstatus
;
1408 #ifdef CHILD_SPECIAL_WAITSTATUS
1409 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1410 if it wants to deal with hoststatus. */
1411 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1415 if (WIFEXITED (hoststatus
))
1417 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1418 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1420 else if (!WIFSTOPPED (hoststatus
))
1422 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1423 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1427 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1428 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1432 /* In some circumstances we allow a command to specify a numeric
1433 signal. The idea is to keep these circumstances limited so that
1434 users (and scripts) develop portable habits. For comparison,
1435 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1436 numeric signal at all is obscelescent. We are slightly more
1437 lenient and allow 1-15 which should match host signal numbers on
1438 most systems. Use of symbolic signal names is strongly encouraged. */
1441 target_signal_from_command (num
)
1444 if (num
>= 1 && num
<= 15)
1445 return (enum target_signal
)num
;
1446 error ("Only signals 1-15 are valid as numeric signals.\n\
1447 Use \"info signals\" for a list of symbolic signals.");
1450 /* Returns zero to leave the inferior alone, one to interrupt it. */
1451 int (*target_activity_function
) PARAMS ((void));
1452 int target_activity_fd
;
1454 /* Convert a normal process ID to a string. Returns the string in a static
1458 normal_pid_to_str (pid
)
1461 static char buf
[30];
1463 if (STREQ (current_target
.to_shortname
, "remote"))
1464 sprintf (buf
, "thread %d", pid
);
1466 sprintf (buf
, "process %d", pid
);
1471 #ifdef MAINTENANCE_CMDS
1472 static struct target_ops debug_target
;
1475 debug_to_open (args
, from_tty
)
1479 debug_target
.to_open (args
, from_tty
);
1481 fprintf_unfiltered (stderr
, "target_open (%s, %d)\n", args
, from_tty
);
1485 debug_to_close (quitting
)
1488 debug_target
.to_close (quitting
);
1490 fprintf_unfiltered (stderr
, "target_close (%d)\n", quitting
);
1494 debug_to_attach (args
, from_tty
)
1498 debug_target
.to_attach (args
, from_tty
);
1500 fprintf_unfiltered (stderr
, "target_attach (%s, %d)\n", args
, from_tty
);
1504 debug_to_detach (args
, from_tty
)
1508 debug_target
.to_detach (args
, from_tty
);
1510 fprintf_unfiltered (stderr
, "target_detach (%s, %d)\n", args
, from_tty
);
1514 debug_to_resume (pid
, step
, siggnal
)
1517 enum target_signal siggnal
;
1519 debug_target
.to_resume (pid
, step
, siggnal
);
1521 fprintf_unfiltered (stderr
, "target_resume (%d, %s, %s)\n", pid
,
1522 step
? "step" : "continue",
1523 target_signal_to_name (siggnal
));
1527 debug_to_wait (pid
, status
)
1529 struct target_waitstatus
*status
;
1533 retval
= debug_target
.to_wait (pid
, status
);
1535 fprintf_unfiltered (stderr
, "target_wait (%d, status) = %d, ", pid
, retval
);
1536 fprintf_unfiltered (stderr
, "status->kind = ");
1537 switch (status
->kind
)
1539 case TARGET_WAITKIND_EXITED
:
1540 fprintf_unfiltered (stderr
, "exited, status = %d\n", status
->value
.integer
);
1542 case TARGET_WAITKIND_STOPPED
:
1543 fprintf_unfiltered (stderr
, "stopped, signal = %s\n",
1544 target_signal_to_name (status
->value
.sig
));
1546 case TARGET_WAITKIND_SIGNALLED
:
1547 fprintf_unfiltered (stderr
, "signalled, signal = %s\n",
1548 target_signal_to_name (status
->value
.sig
));
1550 case TARGET_WAITKIND_LOADED
:
1551 fprintf_unfiltered (stderr
, "loaded\n");
1553 case TARGET_WAITKIND_SPURIOUS
:
1554 fprintf_unfiltered (stderr
, "spurious\n");
1557 fprintf_unfiltered (stderr
, "unknown???\n");
1565 debug_to_fetch_registers (regno
)
1568 debug_target
.to_fetch_registers (regno
);
1570 fprintf_unfiltered (stderr
, "target_fetch_registers (%s)",
1571 regno
!= -1 ? reg_names
[regno
] : "-1");
1573 fprintf_unfiltered (stderr
, " = 0x%x %d", read_register (regno
),
1574 read_register (regno
));
1575 fprintf_unfiltered (stderr
, "\n");
1579 debug_to_store_registers (regno
)
1582 debug_target
.to_store_registers (regno
);
1584 if (regno
>= 0 && regno
< NUM_REGS
)
1585 fprintf_unfiltered (stderr
, "target_store_registers (%s) = 0x%x %d\n",
1586 reg_names
[regno
], read_register (regno
),
1587 read_register (regno
));
1589 fprintf_unfiltered (stderr
, "target_store_registers (%d)\n", regno
);
1593 debug_to_prepare_to_store ()
1595 debug_target
.to_prepare_to_store ();
1597 fprintf_unfiltered (stderr
, "target_prepare_to_store ()\n");
1601 debug_to_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1606 struct target_ops
*target
;
1610 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
1612 fprintf_unfiltered (stderr
, "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1613 memaddr
, len
, write
? "write" : "read", retval
);
1619 fputs_unfiltered (", bytes =", gdb_stderr
);
1620 for (i
= 0; i
< retval
; i
++)
1621 fprintf_unfiltered (stderr
, " %02x", myaddr
[i
] & 0xff);
1624 fputc_unfiltered ('\n', gdb_stderr
);
1630 debug_to_files_info (target
)
1631 struct target_ops
*target
;
1633 debug_target
.to_files_info (target
);
1635 fprintf_unfiltered (stderr
, "target_files_info (xxx)\n");
1639 debug_to_insert_breakpoint (addr
, save
)
1645 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1647 fprintf_unfiltered (stderr
, "target_insert_breakpoint (0x%x, xxx) = %d\n",
1653 debug_to_remove_breakpoint (addr
, save
)
1659 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1661 fprintf_unfiltered (stderr
, "target_remove_breakpoint (0x%x, xxx) = %d\n",
1667 debug_to_terminal_init ()
1669 debug_target
.to_terminal_init ();
1671 fprintf_unfiltered (stderr
, "target_terminal_init ()\n");
1675 debug_to_terminal_inferior ()
1677 debug_target
.to_terminal_inferior ();
1679 fprintf_unfiltered (stderr
, "target_terminal_inferior ()\n");
1683 debug_to_terminal_ours_for_output ()
1685 debug_target
.to_terminal_ours_for_output ();
1687 fprintf_unfiltered (stderr
, "target_terminal_ours_for_output ()\n");
1691 debug_to_terminal_ours ()
1693 debug_target
.to_terminal_ours ();
1695 fprintf_unfiltered (stderr
, "target_terminal_ours ()\n");
1699 debug_to_terminal_info (arg
, from_tty
)
1703 debug_target
.to_terminal_info (arg
, from_tty
);
1705 fprintf_unfiltered (stderr
, "target_terminal_info (%s, %d)\n", arg
,
1712 debug_target
.to_kill ();
1714 fprintf_unfiltered (stderr
, "target_kill ()\n");
1718 debug_to_load (args
, from_tty
)
1722 debug_target
.to_load (args
, from_tty
);
1724 fprintf_unfiltered (stderr
, "target_load (%s, %d)\n", args
, from_tty
);
1728 debug_to_lookup_symbol (name
, addrp
)
1734 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
1736 fprintf_unfiltered (stderr
, "target_lookup_symbol (%s, xxx)\n", name
);
1742 debug_to_create_inferior (exec_file
, args
, env
)
1747 debug_target
.to_create_inferior (exec_file
, args
, env
);
1749 fprintf_unfiltered (stderr
, "target_create_inferior (%s, %s, xxx)\n",
1754 debug_to_mourn_inferior ()
1756 debug_target
.to_mourn_inferior ();
1758 fprintf_unfiltered (stderr
, "target_mourn_inferior ()\n");
1766 retval
= debug_target
.to_can_run ();
1768 fprintf_unfiltered (stderr
, "target_can_run () = %d\n", retval
);
1774 debug_to_notice_signals (pid
)
1777 debug_target
.to_notice_signals (pid
);
1779 fprintf_unfiltered (stderr
, "target_notice_signals (%d)\n", pid
);
1783 debug_to_thread_alive (pid
)
1786 debug_target
.to_thread_alive (pid
);
1788 fprintf_unfiltered (stderr
, "target_thread_alive (%d)\n", pid
);
1795 debug_target
.to_stop ();
1797 fprintf_unfiltered (stderr
, "target_stop ()\n");
1801 setup_target_debug ()
1803 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
1805 current_target
.to_open
= debug_to_open
;
1806 current_target
.to_close
= debug_to_close
;
1807 current_target
.to_attach
= debug_to_attach
;
1808 current_target
.to_detach
= debug_to_detach
;
1809 current_target
.to_resume
= debug_to_resume
;
1810 current_target
.to_wait
= debug_to_wait
;
1811 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
1812 current_target
.to_store_registers
= debug_to_store_registers
;
1813 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
1814 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
1815 current_target
.to_files_info
= debug_to_files_info
;
1816 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
1817 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
1818 current_target
.to_terminal_init
= debug_to_terminal_init
;
1819 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
1820 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
1821 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
1822 current_target
.to_terminal_info
= debug_to_terminal_info
;
1823 current_target
.to_kill
= debug_to_kill
;
1824 current_target
.to_load
= debug_to_load
;
1825 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
1826 current_target
.to_create_inferior
= debug_to_create_inferior
;
1827 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
1828 current_target
.to_can_run
= debug_to_can_run
;
1829 current_target
.to_notice_signals
= debug_to_notice_signals
;
1830 current_target
.to_thread_alive
= debug_to_thread_alive
;
1831 current_target
.to_stop
= debug_to_stop
;
1833 #endif /* MAINTENANCE_CMDS */
1835 static char targ_desc
[] =
1836 "Names of targets and files being debugged.\n\
1837 Shows the entire stack of targets currently in use (including the exec-file,\n\
1838 core-file, and process, if any), as well as the symbol file name.";
1841 initialize_targets ()
1843 push_target (&dummy_target
);
1845 add_info ("target", target_info
, targ_desc
);
1846 add_info ("files", target_info
, targ_desc
);
1848 #ifdef MAINTENANCE_CMDS
1850 add_set_cmd ("targetdebug", class_maintenance
, var_zinteger
,
1851 (char *)&targetdebug
,
1852 "Set target debugging.\n\
1853 When non-zero, target debugging is enabled.", &setlist
),
1857 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))