?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Contribute CGEN simulator build support code.
[binutils-gdb.git] / gdb / target.c
blobb50ec1c94ab0068cbbe9066498fbb90b1149a83e
1 /* Select target systems and architectures at runtime for GDB.
2 Copyright 1990, 1992-1995, 1998-2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
4
5 This file is part of GDB.
6
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.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include "defs.h"
23 #include <errno.h>
24 #include <ctype.h>
25 #include "gdb_string.h"
26 #include "target.h"
27 #include "gdbcmd.h"
28 #include "symtab.h"
29 #include "inferior.h"
30 #include "bfd.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "gdb_wait.h"
34 #include <signal.h>
35
36 extern int errno;
37
38 static void target_info (char *, int);
39
40 static void cleanup_target (struct target_ops *);
41
42 static void maybe_kill_then_create_inferior (char *, char *, char **);
43
44 static void default_clone_and_follow_inferior (int, int *);
45
46 static void maybe_kill_then_attach (char *, int);
47
48 static void kill_or_be_killed (int);
49
50 static void default_terminal_info (char *, int);
51
52 static int nosymbol (char *, CORE_ADDR *);
53
54 static void tcomplain (void);
55
56 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
57
58 static int return_zero (void);
59
60 static int return_one (void);
61
62 void target_ignore (void);
63
64 static void target_command (char *, int);
65
66 static struct target_ops *find_default_run_target (char *);
67
68 static void update_current_target (void);
69
70 static void nosupport_runtime (void);
71
72 static void normal_target_post_startup_inferior (int pid);
73
74 /* Transfer LEN bytes between target address MEMADDR and GDB address
75 MYADDR. Returns 0 for success, errno code for failure (which
76 includes partial transfers -- if you want a more useful response to
77 partial transfers, try either target_read_memory_partial or
78 target_write_memory_partial). */
79
80 static int
81 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write);
82
83 static void init_dummy_target (void);
84
85 static void debug_to_open (char *, int);
86
87 static void debug_to_close (int);
88
89 static void debug_to_attach (char *, int);
90
91 static void debug_to_detach (char *, int);
92
93 static void debug_to_resume (int, int, enum target_signal);
94
95 static int debug_to_wait (int, struct target_waitstatus *);
96
97 static void debug_to_fetch_registers (int);
98
99 static void debug_to_store_registers (int);
100
101 static void debug_to_prepare_to_store (void);
102
103 static int
104 debug_to_xfer_memory (CORE_ADDR, char *, int, int, struct target_ops *);
105
106 static void debug_to_files_info (struct target_ops *);
107
108 static int debug_to_insert_breakpoint (CORE_ADDR, char *);
109
110 static int debug_to_remove_breakpoint (CORE_ADDR, char *);
111
112 static void debug_to_terminal_init (void);
113
114 static void debug_to_terminal_inferior (void);
115
116 static void debug_to_terminal_ours_for_output (void);
117
118 static void debug_to_terminal_ours (void);
119
120 static void debug_to_terminal_info (char *, int);
121
122 static void debug_to_kill (void);
123
124 static void debug_to_load (char *, int);
125
126 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
127
128 static void debug_to_create_inferior (char *, char *, char **);
129
130 static void debug_to_mourn_inferior (void);
131
132 static int debug_to_can_run (void);
133
134 static void debug_to_notice_signals (int);
135
136 static int debug_to_thread_alive (int);
137
138 static void debug_to_stop (void);
139
140 static int debug_to_query (int /*char */ , char *, char *, int *);
141
142 /* Pointer to array of target architecture structures; the size of the
143 array; the current index into the array; the allocated size of the
144 array. */
145 struct target_ops **target_structs;
146 unsigned target_struct_size;
147 unsigned target_struct_index;
148 unsigned target_struct_allocsize;
149 #define DEFAULT_ALLOCSIZE 10
150
151 /* The initial current target, so that there is always a semi-valid
152 current target. */
153
154 static struct target_ops dummy_target;
155
156 /* Top of target stack. */
157
158 struct target_stack_item *target_stack;
159
160 /* The target structure we are currently using to talk to a process
161 or file or whatever "inferior" we have. */
162
163 struct target_ops current_target;
164
165 /* Command list for target. */
166
167 static struct cmd_list_element *targetlist = NULL;
168
169 /* Nonzero if we are debugging an attached outside process
170 rather than an inferior. */
171
172 int attach_flag;
173
174 /* Non-zero if we want to see trace of target level stuff. */
175
176 static int targetdebug = 0;
177
178 static void setup_target_debug (void);
179
180 /* The user just typed 'target' without the name of a target. */
181
182 /* ARGSUSED */
183 static void
184 target_command (char *arg, int from_tty)
185 {
186 fputs_filtered ("Argument required (target name). Try `help target'\n",
187 gdb_stdout);
188 }
189
190 /* Add a possible target architecture to the list. */
191
192 void
193 add_target (struct target_ops *t)
194 {
195 if (!target_structs)
196 {
197 target_struct_allocsize = DEFAULT_ALLOCSIZE;
198 target_structs = (struct target_ops **) xmalloc
199 (target_struct_allocsize * sizeof (*target_structs));
200 }
201 if (target_struct_size >= target_struct_allocsize)
202 {
203 target_struct_allocsize *= 2;
204 target_structs = (struct target_ops **)
205 xrealloc ((char *) target_structs,
206 target_struct_allocsize * sizeof (*target_structs));
207 }
208 target_structs[target_struct_size++] = t;
209 /* cleanup_target (t); */
210
211 if (targetlist == NULL)
212 add_prefix_cmd ("target", class_run, target_command,
213 "Connect to a target machine or process.\n\
214 The first argument is the type or protocol of the target machine.\n\
215 Remaining arguments are interpreted by the target protocol. For more\n\
216 information on the arguments for a particular protocol, type\n\
217 `help target ' followed by the protocol name.",
218 &targetlist, "target ", 0, &cmdlist);
219 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
220 }
221
222 /* Stub functions */
223
224 void
225 target_ignore (void)
226 {
227 }
228
229 void
230 target_load (char *arg, int from_tty)
231 {
232 (*current_target.to_load) (arg, from_tty);
233 }
234
235 /* ARGSUSED */
236 static int
237 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
238 struct target_ops *t)
239 {
240 errno = EIO; /* Can't read/write this location */
241 return 0; /* No bytes handled */
242 }
243
244 static void
245 tcomplain (void)
246 {
247 error ("You can't do that when your target is `%s'",
248 current_target.to_shortname);
249 }
250
251 void
252 noprocess (void)
253 {
254 error ("You can't do that without a process to debug.");
255 }
256
257 /* ARGSUSED */
258 static int
259 nosymbol (char *name, CORE_ADDR *addrp)
260 {
261 return 1; /* Symbol does not exist in target env */
262 }
263
264 /* ARGSUSED */
265 static void
266 nosupport_runtime (void)
267 {
268 if (!inferior_pid)
269 noprocess ();
270 else
271 error ("No run-time support for this");
272 }
273
274
275 /* ARGSUSED */
276 static void
277 default_terminal_info (char *args, int from_tty)
278 {
279 printf_unfiltered ("No saved terminal information.\n");
280 }
281
282 /* This is the default target_create_inferior and target_attach function.
283 If the current target is executing, it asks whether to kill it off.
284 If this function returns without calling error(), it has killed off
285 the target, and the operation should be attempted. */
286
287 static void
288 kill_or_be_killed (int from_tty)
289 {
290 if (target_has_execution)
291 {
292 printf_unfiltered ("You are already running a program:\n");
293 target_files_info ();
294 if (query ("Kill it? "))
295 {
296 target_kill ();
297 if (target_has_execution)
298 error ("Killing the program did not help.");
299 return;
300 }
301 else
302 {
303 error ("Program not killed.");
304 }
305 }
306 tcomplain ();
307 }
308
309 static void
310 maybe_kill_then_attach (char *args, int from_tty)
311 {
312 kill_or_be_killed (from_tty);
313 target_attach (args, from_tty);
314 }
315
316 static void
317 maybe_kill_then_create_inferior (char *exec, char *args, char **env)
318 {
319 kill_or_be_killed (0);
320 target_create_inferior (exec, args, env);
321 }
322
323 static void
324 default_clone_and_follow_inferior (int child_pid, int *followed_child)
325 {
326 target_clone_and_follow_inferior (child_pid, followed_child);
327 }
328
329 /* Clean up a target struct so it no longer has any zero pointers in it.
330 We default entries, at least to stubs that print error messages. */
331
332 static void
333 cleanup_target (struct target_ops *t)
334 {
335
336 #define de_fault(field, value) \
337 if (!t->field) \
338 t->field = value
339
340 de_fault (to_open,
341 (void (*) (char *, int))
342 tcomplain);
343 de_fault (to_close,
344 (void (*) (int))
345 target_ignore);
346 de_fault (to_attach,
347 maybe_kill_then_attach);
348 de_fault (to_post_attach,
349 (void (*) (int))
350 target_ignore);
351 de_fault (to_require_attach,
352 maybe_kill_then_attach);
353 de_fault (to_detach,
354 (void (*) (char *, int))
355 target_ignore);
356 de_fault (to_require_detach,
357 (void (*) (int, char *, int))
358 target_ignore);
359 de_fault (to_resume,
360 (void (*) (int, int, enum target_signal))
361 noprocess);
362 de_fault (to_wait,
363 (int (*) (int, struct target_waitstatus *))
364 noprocess);
365 de_fault (to_post_wait,
366 (void (*) (int, int))
367 target_ignore);
368 de_fault (to_fetch_registers,
369 (void (*) (int))
370 target_ignore);
371 de_fault (to_store_registers,
372 (void (*) (int))
373 noprocess);
374 de_fault (to_prepare_to_store,
375 (void (*) (void))
376 noprocess);
377 de_fault (to_xfer_memory,
378 (int (*) (CORE_ADDR, char *, int, int, struct target_ops *))
379 nomemory);
380 de_fault (to_files_info,
381 (void (*) (struct target_ops *))
382 target_ignore);
383 de_fault (to_insert_breakpoint,
384 memory_insert_breakpoint);
385 de_fault (to_remove_breakpoint,
386 memory_remove_breakpoint);
387 de_fault (to_terminal_init,
388 (void (*) (void))
389 target_ignore);
390 de_fault (to_terminal_inferior,
391 (void (*) (void))
392 target_ignore);
393 de_fault (to_terminal_ours_for_output,
394 (void (*) (void))
395 target_ignore);
396 de_fault (to_terminal_ours,
397 (void (*) (void))
398 target_ignore);
399 de_fault (to_terminal_info,
400 default_terminal_info);
401 de_fault (to_kill,
402 (void (*) (void))
403 noprocess);
404 de_fault (to_load,
405 (void (*) (char *, int))
406 tcomplain);
407 de_fault (to_lookup_symbol,
408 (int (*) (char *, CORE_ADDR *))
409 nosymbol);
410 de_fault (to_create_inferior,
411 maybe_kill_then_create_inferior);
412 de_fault (to_post_startup_inferior,
413 (void (*) (int))
414 target_ignore);
415 de_fault (to_acknowledge_created_inferior,
416 (void (*) (int))
417 target_ignore);
418 de_fault (to_clone_and_follow_inferior,
419 default_clone_and_follow_inferior);
420 de_fault (to_post_follow_inferior_by_clone,
421 (void (*) (void))
422 target_ignore);
423 de_fault (to_insert_fork_catchpoint,
424 (int (*) (int))
425 tcomplain);
426 de_fault (to_remove_fork_catchpoint,
427 (int (*) (int))
428 tcomplain);
429 de_fault (to_insert_vfork_catchpoint,
430 (int (*) (int))
431 tcomplain);
432 de_fault (to_remove_vfork_catchpoint,
433 (int (*) (int))
434 tcomplain);
435 de_fault (to_has_forked,
436 (int (*) (int, int *))
437 return_zero);
438 de_fault (to_has_vforked,
439 (int (*) (int, int *))
440 return_zero);
441 de_fault (to_can_follow_vfork_prior_to_exec,
442 (int (*) (void))
443 return_zero);
444 de_fault (to_post_follow_vfork,
445 (void (*) (int, int, int, int))
446 target_ignore);
447 de_fault (to_insert_exec_catchpoint,
448 (int (*) (int))
449 tcomplain);
450 de_fault (to_remove_exec_catchpoint,
451 (int (*) (int))
452 tcomplain);
453 de_fault (to_has_execd,
454 (int (*) (int, char **))
455 return_zero);
456 de_fault (to_reported_exec_events_per_exec_call,
457 (int (*) (void))
458 return_one);
459 de_fault (to_has_syscall_event,
460 (int (*) (int, enum target_waitkind *, int *))
461 return_zero);
462 de_fault (to_has_exited,
463 (int (*) (int, int, int *))
464 return_zero);
465 de_fault (to_mourn_inferior,
466 (void (*) (void))
467 noprocess);
468 de_fault (to_can_run,
469 return_zero);
470 de_fault (to_notice_signals,
471 (void (*) (int))
472 target_ignore);
473 de_fault (to_thread_alive,
474 (int (*) (int))
475 return_zero);
476 de_fault (to_find_new_threads,
477 (void (*) (void))
478 target_ignore);
479 de_fault (to_extra_thread_info,
480 (char *(*) (struct thread_info *))
481 return_zero);
482 de_fault (to_stop,
483 (void (*) (void))
484 target_ignore);
485 de_fault (to_query,
486 (int (*) (int, char *, char *, int *))
487 return_zero);
488 de_fault (to_rcmd,
489 (void (*) (char *, struct ui_file *))
490 tcomplain);
491 de_fault (to_enable_exception_callback,
492 (struct symtab_and_line * (*) (enum exception_event_kind, int))
493 nosupport_runtime);
494 de_fault (to_get_current_exception_event,
495 (struct exception_event_record * (*) (void))
496 nosupport_runtime);
497 de_fault (to_pid_to_exec_file,
498 (char *(*) (int))
499 return_zero);
500 de_fault (to_core_file_to_sym_file,
501 (char *(*) (char *))
502 return_zero);
503 de_fault (to_can_async_p,
504 (int (*) (void))
505 return_zero);
506 de_fault (to_is_async_p,
507 (int (*) (void))
508 return_zero);
509 de_fault (to_async,
510 (void (*) (void (*) (enum inferior_event_type, void*), void*))
511 tcomplain);
512 #undef de_fault
513 }
514
515 /* Go through the target stack from top to bottom, copying over zero entries in
516 current_target. In effect, we are doing class inheritance through the
517 pushed target vectors. */
518
519 static void
520 update_current_target (void)
521 {
522 struct target_stack_item *item;
523 struct target_ops *t;
524
525 /* First, reset current_target */
526 memset (&current_target, 0, sizeof current_target);
527
528 for (item = target_stack; item; item = item->next)
529 {
530 t = item->target_ops;
531
532 #define INHERIT(FIELD, TARGET) \
533 if (!current_target.FIELD) \
534 current_target.FIELD = TARGET->FIELD
535
536 INHERIT (to_shortname, t);
537 INHERIT (to_longname, t);
538 INHERIT (to_doc, t);
539 INHERIT (to_open, t);
540 INHERIT (to_close, t);
541 INHERIT (to_attach, t);
542 INHERIT (to_post_attach, t);
543 INHERIT (to_require_attach, t);
544 INHERIT (to_detach, t);
545 INHERIT (to_require_detach, t);
546 INHERIT (to_resume, t);
547 INHERIT (to_wait, t);
548 INHERIT (to_post_wait, t);
549 INHERIT (to_fetch_registers, t);
550 INHERIT (to_store_registers, t);
551 INHERIT (to_prepare_to_store, t);
552 INHERIT (to_xfer_memory, t);
553 INHERIT (to_files_info, t);
554 INHERIT (to_insert_breakpoint, t);
555 INHERIT (to_remove_breakpoint, t);
556 INHERIT (to_terminal_init, t);
557 INHERIT (to_terminal_inferior, t);
558 INHERIT (to_terminal_ours_for_output, t);
559 INHERIT (to_terminal_ours, t);
560 INHERIT (to_terminal_info, t);
561 INHERIT (to_kill, t);
562 INHERIT (to_load, t);
563 INHERIT (to_lookup_symbol, t);
564 INHERIT (to_create_inferior, t);
565 INHERIT (to_post_startup_inferior, t);
566 INHERIT (to_acknowledge_created_inferior, t);
567 INHERIT (to_clone_and_follow_inferior, t);
568 INHERIT (to_post_follow_inferior_by_clone, t);
569 INHERIT (to_insert_fork_catchpoint, t);
570 INHERIT (to_remove_fork_catchpoint, t);
571 INHERIT (to_insert_vfork_catchpoint, t);
572 INHERIT (to_remove_vfork_catchpoint, t);
573 INHERIT (to_has_forked, t);
574 INHERIT (to_has_vforked, t);
575 INHERIT (to_can_follow_vfork_prior_to_exec, t);
576 INHERIT (to_post_follow_vfork, t);
577 INHERIT (to_insert_exec_catchpoint, t);
578 INHERIT (to_remove_exec_catchpoint, t);
579 INHERIT (to_has_execd, t);
580 INHERIT (to_reported_exec_events_per_exec_call, t);
581 INHERIT (to_has_syscall_event, t);
582 INHERIT (to_has_exited, t);
583 INHERIT (to_mourn_inferior, t);
584 INHERIT (to_can_run, t);
585 INHERIT (to_notice_signals, t);
586 INHERIT (to_thread_alive, t);
587 INHERIT (to_find_new_threads, t);
588 INHERIT (to_pid_to_str, t);
589 INHERIT (to_extra_thread_info, t);
590 INHERIT (to_stop, t);
591 INHERIT (to_query, t);
592 INHERIT (to_rcmd, t);
593 INHERIT (to_enable_exception_callback, t);
594 INHERIT (to_get_current_exception_event, t);
595 INHERIT (to_pid_to_exec_file, t);
596 INHERIT (to_core_file_to_sym_file, t);
597 INHERIT (to_stratum, t);
598 INHERIT (DONT_USE, t);
599 INHERIT (to_has_all_memory, t);
600 INHERIT (to_has_memory, t);
601 INHERIT (to_has_stack, t);
602 INHERIT (to_has_registers, t);
603 INHERIT (to_has_execution, t);
604 INHERIT (to_has_thread_control, t);
605 INHERIT (to_sections, t);
606 INHERIT (to_sections_end, t);
607 INHERIT (to_can_async_p, t);
608 INHERIT (to_is_async_p, t);
609 INHERIT (to_async, t);
610 INHERIT (to_async_mask_value, t);
611 INHERIT (to_magic, t);
612
613 #undef INHERIT
614 }
615 }
616
617 /* Push a new target type into the stack of the existing target accessors,
618 possibly superseding some of the existing accessors.
619
620 Result is zero if the pushed target ended up on top of the stack,
621 nonzero if at least one target is on top of it.
622
623 Rather than allow an empty stack, we always have the dummy target at
624 the bottom stratum, so we can call the function vectors without
625 checking them. */
626
627 int
628 push_target (struct target_ops *t)
629 {
630 struct target_stack_item *cur, *prev, *tmp;
631
632 /* Check magic number. If wrong, it probably means someone changed
633 the struct definition, but not all the places that initialize one. */
634 if (t->to_magic != OPS_MAGIC)
635 {
636 fprintf_unfiltered (gdb_stderr,
637 "Magic number of %s target struct wrong\n",
638 t->to_shortname);
639 abort ();
640 }
641
642 /* Find the proper stratum to install this target in. */
643
644 for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
645 {
646 if ((int) (t->to_stratum) >= (int) (cur->target_ops->to_stratum))
647 break;
648 }
649
650 /* If there's already targets at this stratum, remove them. */
651
652 if (cur)
653 while (t->to_stratum == cur->target_ops->to_stratum)
654 {
655 /* There's already something on this stratum. Close it off. */
656 if (cur->target_ops->to_close)
657 (cur->target_ops->to_close) (0);
658 if (prev)
659 prev->next = cur->next; /* Unchain old target_ops */
660 else
661 target_stack = cur->next; /* Unchain first on list */
662 tmp = cur->next;
663 free (cur);
664 cur = tmp;
665 }
666
667 /* We have removed all targets in our stratum, now add the new one. */
668
669 tmp = (struct target_stack_item *)
670 xmalloc (sizeof (struct target_stack_item));
671 tmp->next = cur;
672 tmp->target_ops = t;
673
674 if (prev)
675 prev->next = tmp;
676 else
677 target_stack = tmp;
678
679 update_current_target ();
680
681 cleanup_target (&current_target); /* Fill in the gaps */
682
683 if (targetdebug)
684 setup_target_debug ();
685
686 return prev != 0;
687 }
688
689 /* Remove a target_ops vector from the stack, wherever it may be.
690 Return how many times it was removed (0 or 1). */
691
692 int
693 unpush_target (struct target_ops *t)
694 {
695 struct target_stack_item *cur, *prev;
696
697 if (t->to_close)
698 t->to_close (0); /* Let it clean up */
699
700 /* Look for the specified target. Note that we assume that a target
701 can only occur once in the target stack. */
702
703 for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
704 if (cur->target_ops == t)
705 break;
706
707 if (!cur)
708 return 0; /* Didn't find target_ops, quit now */
709
710 /* Unchain the target */
711
712 if (!prev)
713 target_stack = cur->next;
714 else
715 prev->next = cur->next;
716
717 free (cur); /* Release the target_stack_item */
718
719 update_current_target ();
720 cleanup_target (&current_target);
721
722 return 1;
723 }
724
725 void
726 pop_target (void)
727 {
728 (current_target.to_close) (0); /* Let it clean up */
729 if (unpush_target (target_stack->target_ops) == 1)
730 return;
731
732 fprintf_unfiltered (gdb_stderr,
733 "pop_target couldn't find target %s\n",
734 current_target.to_shortname);
735 abort ();
736 }
737
738 #undef MIN
739 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
740
741 /* target_read_string -- read a null terminated string, up to LEN bytes,
742 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
743 Set *STRING to a pointer to malloc'd memory containing the data; the caller
744 is responsible for freeing it. Return the number of bytes successfully
745 read. */
746
747 int
748 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
749 {
750 int tlen, origlen, offset, i;
751 char buf[4];
752 int errcode = 0;
753 char *buffer;
754 int buffer_allocated;
755 char *bufptr;
756 unsigned int nbytes_read = 0;
757
758 /* Small for testing. */
759 buffer_allocated = 4;
760 buffer = xmalloc (buffer_allocated);
761 bufptr = buffer;
762
763 origlen = len;
764
765 while (len > 0)
766 {
767 tlen = MIN (len, 4 - (memaddr & 3));
768 offset = memaddr & 3;
769
770 errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
771 if (errcode != 0)
772 {
773 /* The transfer request might have crossed the boundary to an
774 unallocated region of memory. Retry the transfer, requesting
775 a single byte. */
776 tlen = 1;
777 offset = 0;
778 errcode = target_xfer_memory (memaddr, buf, 1, 0);
779 if (errcode != 0)
780 goto done;
781 }
782
783 if (bufptr - buffer + tlen > buffer_allocated)
784 {
785 unsigned int bytes;
786 bytes = bufptr - buffer;
787 buffer_allocated *= 2;
788 buffer = xrealloc (buffer, buffer_allocated);
789 bufptr = buffer + bytes;
790 }
791
792 for (i = 0; i < tlen; i++)
793 {
794 *bufptr++ = buf[i + offset];
795 if (buf[i + offset] == '\000')
796 {
797 nbytes_read += i + 1;
798 goto done;
799 }
800 }
801
802 memaddr += tlen;
803 len -= tlen;
804 nbytes_read += tlen;
805 }
806 done:
807 if (errnop != NULL)
808 *errnop = errcode;
809 if (string != NULL)
810 *string = buffer;
811 return nbytes_read;
812 }
813
814 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
815 GDB's memory at MYADDR. Returns either 0 for success or an errno value
816 if any error occurs.
817
818 If an error occurs, no guarantee is made about the contents of the data at
819 MYADDR. In particular, the caller should not depend upon partial reads
820 filling the buffer with good data. There is no way for the caller to know
821 how much good data might have been transfered anyway. Callers that can
822 deal with partial reads should call target_read_memory_partial. */
823
824 int
825 target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
826 {
827 return target_xfer_memory (memaddr, myaddr, len, 0);
828 }
829
830 int
831 target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
832 {
833 return target_xfer_memory (memaddr, myaddr, len, 1);
834 }
835
836 /* Move memory to or from the targets. Iterate until all of it has
837 been moved, if necessary. The top target gets priority; anything
838 it doesn't want, is offered to the next one down, etc. Note the
839 business with curlen: if an early target says "no, but I have a
840 boundary overlapping this xfer" then we shorten what we offer to
841 the subsequent targets so the early guy will get a chance at the
842 tail before the subsequent ones do.
843
844 Result is 0 or errno value. */
845
846 static int
847 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
848 {
849 int curlen;
850 int res;
851 struct target_ops *t;
852 struct target_stack_item *item;
853
854 /* Zero length requests are ok and require no work. */
855 if (len == 0)
856 return 0;
857
858 /* to_xfer_memory is not guaranteed to set errno, even when it returns
859 0. */
860 errno = 0;
861
862 /* The quick case is that the top target does it all. */
863 res = current_target.to_xfer_memory
864 (memaddr, myaddr, len, write, &current_target);
865 if (res == len)
866 return 0;
867
868 if (res > 0)
869 goto bump;
870 /* If res <= 0 then we call it again in the loop. Ah well. */
871
872 for (; len > 0;)
873 {
874 curlen = len; /* Want to do it all */
875 for (item = target_stack; item; item = item->next)
876 {
877 t = item->target_ops;
878 if (!t->to_has_memory)
879 continue;
880
881 res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
882 if (res > 0)
883 break; /* Handled all or part of xfer */
884 if (t->to_has_all_memory)
885 break;
886 }
887
888 if (res <= 0)
889 {
890 /* If this address is for nonexistent memory,
891 read zeros if reading, or do nothing if writing. Return error. */
892 if (!write)
893 memset (myaddr, 0, len);
894 if (errno == 0)
895 return EIO;
896 else
897 return errno;
898 }
899 bump:
900 memaddr += res;
901 myaddr += res;
902 len -= res;
903 }
904 return 0; /* We managed to cover it all somehow. */
905 }
906
907
908 /* Perform a partial memory transfer. */
909
910 static int
911 target_xfer_memory_partial (CORE_ADDR memaddr, char *buf, int len,
912 int write_p, int *err)
913 {
914 int res;
915 int err_res;
916 int len_res;
917 struct target_ops *t;
918 struct target_stack_item *item;
919
920 /* Zero length requests are ok and require no work. */
921 if (len == 0)
922 {
923 *err = 0;
924 return 0;
925 }
926
927 /* The quick case is that the top target does it all. */
928 res = current_target.to_xfer_memory (memaddr, buf, len, write_p, &current_target);
929 if (res > 0)
930 {
931 *err = 0;
932 return res;
933 }
934
935 /* xfer memory doesn't always reliably set errno. */
936 errno = 0;
937
938 /* Try all levels of the target stack to see one can handle it. */
939 for (item = target_stack; item; item = item->next)
940 {
941 t = item->target_ops;
942 if (!t->to_has_memory)
943 continue;
944 res = t->to_xfer_memory (memaddr, buf, len, write_p, t);
945 if (res > 0)
946 {
947 /* Handled all or part of xfer */
948 *err = 0;
949 return res;
950 }
951 if (t->to_has_all_memory)
952 break;
953 }
954
955 /* Total failure. Return error. */
956 if (errno != 0)
957 {
958 *err = errno;
959 return -1;
960 }
961 *err = EIO;
962 return -1;
963 }
964
965 int
966 target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
967 {
968 return target_xfer_memory_partial (memaddr, buf, len, 0, err);
969 }
970
971 int
972 target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
973 {
974 return target_xfer_memory_partial (memaddr, buf, len, 1, err);
975 }
976
977 /* ARGSUSED */
978 static void
979 target_info (char *args, int from_tty)
980 {
981 struct target_ops *t;
982 struct target_stack_item *item;
983 int has_all_mem = 0;
984
985 if (symfile_objfile != NULL)
986 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
987
988 #ifdef FILES_INFO_HOOK
989 if (FILES_INFO_HOOK ())
990 return;
991 #endif
992
993 for (item = target_stack; item; item = item->next)
994 {
995 t = item->target_ops;
996
997 if (!t->to_has_memory)
998 continue;
999
1000 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1001 continue;
1002 if (has_all_mem)
1003 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1004 printf_unfiltered ("%s:\n", t->to_longname);
1005 (t->to_files_info) (t);
1006 has_all_mem = t->to_has_all_memory;
1007 }
1008 }
1009
1010 /* This is to be called by the open routine before it does
1011 anything. */
1012
1013 void
1014 target_preopen (int from_tty)
1015 {
1016 dont_repeat ();
1017
1018 if (target_has_execution)
1019 {
1020 if (!from_tty
1021 || query ("A program is being debugged already. Kill it? "))
1022 target_kill ();
1023 else
1024 error ("Program not killed.");
1025 }
1026
1027 /* Calling target_kill may remove the target from the stack. But if
1028 it doesn't (which seems like a win for UDI), remove it now. */
1029
1030 if (target_has_execution)
1031 pop_target ();
1032 }
1033
1034 /* Detach a target after doing deferred register stores. */
1035
1036 void
1037 target_detach (char *args, int from_tty)
1038 {
1039 /* Handle any optimized stores to the inferior. */
1040 #ifdef DO_DEFERRED_STORES
1041 DO_DEFERRED_STORES;
1042 #endif
1043 (current_target.to_detach) (args, from_tty);
1044 }
1045
1046 void
1047 target_link (char *modname, CORE_ADDR *t_reloc)
1048 {
1049 if (STREQ (current_target.to_shortname, "rombug"))
1050 {
1051 (current_target.to_lookup_symbol) (modname, t_reloc);
1052 if (*t_reloc == 0)
1053 error ("Unable to link to %s and get relocation in rombug", modname);
1054 }
1055 else
1056 *t_reloc = (CORE_ADDR) -1;
1057 }
1058
1059 int
1060 target_async_mask (int mask)
1061 {
1062 int saved_async_masked_status = target_async_mask_value;
1063 target_async_mask_value = mask;
1064 return saved_async_masked_status;
1065 }
1066
1067 /* Look through the list of possible targets for a target that can
1068 execute a run or attach command without any other data. This is
1069 used to locate the default process stratum.
1070
1071 Result is always valid (error() is called for errors). */
1072
1073 static struct target_ops *
1074 find_default_run_target (char *do_mesg)
1075 {
1076 struct target_ops **t;
1077 struct target_ops *runable = NULL;
1078 int count;
1079
1080 count = 0;
1081
1082 for (t = target_structs; t < target_structs + target_struct_size;
1083 ++t)
1084 {
1085 if ((*t)->to_can_run && target_can_run (*t))
1086 {
1087 runable = *t;
1088 ++count;
1089 }
1090 }
1091
1092 if (count != 1)
1093 error ("Don't know how to %s. Try \"help target\".", do_mesg);
1094
1095 return runable;
1096 }
1097
1098 void
1099 find_default_attach (char *args, int from_tty)
1100 {
1101 struct target_ops *t;
1102
1103 t = find_default_run_target ("attach");
1104 (t->to_attach) (args, from_tty);
1105 return;
1106 }
1107
1108 void
1109 find_default_require_attach (char *args, int from_tty)
1110 {
1111 struct target_ops *t;
1112
1113 t = find_default_run_target ("require_attach");
1114 (t->to_require_attach) (args, from_tty);
1115 return;
1116 }
1117
1118 void
1119 find_default_require_detach (int pid, char *args, int from_tty)
1120 {
1121 struct target_ops *t;
1122
1123 t = find_default_run_target ("require_detach");
1124 (t->to_require_detach) (pid, args, from_tty);
1125 return;
1126 }
1127
1128 void
1129 find_default_create_inferior (char *exec_file, char *allargs, char **env)
1130 {
1131 struct target_ops *t;
1132
1133 t = find_default_run_target ("run");
1134 (t->to_create_inferior) (exec_file, allargs, env);
1135 return;
1136 }
1137
1138 void
1139 find_default_clone_and_follow_inferior (int child_pid, int *followed_child)
1140 {
1141 struct target_ops *t;
1142
1143 t = find_default_run_target ("run");
1144 (t->to_clone_and_follow_inferior) (child_pid, followed_child);
1145 return;
1146 }
1147
1148 static int
1149 return_zero (void)
1150 {
1151 return 0;
1152 }
1153
1154 static int
1155 return_one (void)
1156 {
1157 return 1;
1158 }
1159
1160 /*
1161 * Resize the to_sections pointer. Also make sure that anyone that
1162 * was holding on to an old value of it gets updated.
1163 * Returns the old size.
1164 */
1165
1166 int
1167 target_resize_to_sections (struct target_ops *target, int num_added)
1168 {
1169 struct target_ops **t;
1170 struct section_table *old_value;
1171 int old_count;
1172
1173 old_value = target->to_sections;
1174
1175 if (target->to_sections)
1176 {
1177 old_count = target->to_sections_end - target->to_sections;
1178 target->to_sections = (struct section_table *)
1179 xrealloc ((char *) target->to_sections,
1180 (sizeof (struct section_table)) * (num_added + old_count));
1181 }
1182 else
1183 {
1184 old_count = 0;
1185 target->to_sections = (struct section_table *)
1186 xmalloc ((sizeof (struct section_table)) * num_added);
1187 }
1188 target->to_sections_end = target->to_sections + (num_added + old_count);
1189
1190 /* Check to see if anyone else was pointing to this structure.
1191 If old_value was null, then no one was. */
1192
1193 if (old_value)
1194 {
1195 for (t = target_structs; t < target_structs + target_struct_size;
1196 ++t)
1197 {
1198 if ((*t)->to_sections == old_value)
1199 {
1200 (*t)->to_sections = target->to_sections;
1201 (*t)->to_sections_end = target->to_sections_end;
1202 }
1203 }
1204 }
1205
1206 return old_count;
1207
1208 }
1209
1210 /* Remove all target sections taken from ABFD.
1211
1212 Scan the current target stack for targets whose section tables
1213 refer to sections from BFD, and remove those sections. We use this
1214 when we notice that the inferior has unloaded a shared object, for
1215 example. */
1216 void
1217 remove_target_sections (bfd *abfd)
1218 {
1219 struct target_ops **t;
1220
1221 for (t = target_structs; t < target_structs + target_struct_size; t++)
1222 {
1223 struct section_table *src, *dest;
1224
1225 dest = (*t)->to_sections;
1226 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1227 if (src->bfd != abfd)
1228 {
1229 /* Keep this section. */
1230 if (dest < src) *dest = *src;
1231 dest++;
1232 }
1233
1234 /* If we've dropped any sections, resize the section table. */
1235 if (dest < src)
1236 target_resize_to_sections (*t, dest - src);
1237 }
1238 }
1239
1240
1241
1242
1243 /* Find a single runnable target in the stack and return it. If for
1244 some reason there is more than one, return NULL. */
1245
1246 struct target_ops *
1247 find_run_target (void)
1248 {
1249 struct target_ops **t;
1250 struct target_ops *runable = NULL;
1251 int count;
1252
1253 count = 0;
1254
1255 for (t = target_structs; t < target_structs + target_struct_size; ++t)
1256 {
1257 if ((*t)->to_can_run && target_can_run (*t))
1258 {
1259 runable = *t;
1260 ++count;
1261 }
1262 }
1263
1264 return (count == 1 ? runable : NULL);
1265 }
1266
1267 /* Find a single core_stratum target in the list of targets and return it.
1268 If for some reason there is more than one, return NULL. */
1269
1270 struct target_ops *
1271 find_core_target (void)
1272 {
1273 struct target_ops **t;
1274 struct target_ops *runable = NULL;
1275 int count;
1276
1277 count = 0;
1278
1279 for (t = target_structs; t < target_structs + target_struct_size;
1280 ++t)
1281 {
1282 if ((*t)->to_stratum == core_stratum)
1283 {
1284 runable = *t;
1285 ++count;
1286 }
1287 }
1288
1289 return (count == 1 ? runable : NULL);
1290 }
1291
1292 /*
1293 * Find the next target down the stack from the specified target.
1294 */
1295
1296 struct target_ops *
1297 find_target_beneath (struct target_ops *t)
1298 {
1299 struct target_stack_item *cur;
1300
1301 for (cur = target_stack; cur; cur = cur->next)
1302 if (cur->target_ops == t)
1303 break;
1304
1305 if (cur == NULL || cur->next == NULL)
1306 return NULL;
1307 else
1308 return cur->next->target_ops;
1309 }
1310
1311 \f
1312 /* The inferior process has died. Long live the inferior! */
1313
1314 void
1315 generic_mourn_inferior (void)
1316 {
1317 extern int show_breakpoint_hit_counts;
1318
1319 inferior_pid = 0;
1320 attach_flag = 0;
1321 breakpoint_init_inferior (inf_exited);
1322 registers_changed ();
1323
1324 #ifdef CLEAR_DEFERRED_STORES
1325 /* Delete any pending stores to the inferior... */
1326 CLEAR_DEFERRED_STORES;
1327 #endif
1328
1329 reopen_exec_file ();
1330 reinit_frame_cache ();
1331
1332 /* It is confusing to the user for ignore counts to stick around
1333 from previous runs of the inferior. So clear them. */
1334 /* However, it is more confusing for the ignore counts to disappear when
1335 using hit counts. So don't clear them if we're counting hits. */
1336 if (!show_breakpoint_hit_counts)
1337 breakpoint_clear_ignore_counts ();
1338 }
1339 \f
1340 /* This table must match in order and size the signals in enum target_signal
1341 in target.h. */
1342 /* *INDENT-OFF* */
1343 static struct {
1344 char *name;
1345 char *string;
1346 } signals [] =
1347 {
1348 {"0", "Signal 0"},
1349 {"SIGHUP", "Hangup"},
1350 {"SIGINT", "Interrupt"},
1351 {"SIGQUIT", "Quit"},
1352 {"SIGILL", "Illegal instruction"},
1353 {"SIGTRAP", "Trace/breakpoint trap"},
1354 {"SIGABRT", "Aborted"},
1355 {"SIGEMT", "Emulation trap"},
1356 {"SIGFPE", "Arithmetic exception"},
1357 {"SIGKILL", "Killed"},
1358 {"SIGBUS", "Bus error"},
1359 {"SIGSEGV", "Segmentation fault"},
1360 {"SIGSYS", "Bad system call"},
1361 {"SIGPIPE", "Broken pipe"},
1362 {"SIGALRM", "Alarm clock"},
1363 {"SIGTERM", "Terminated"},
1364 {"SIGURG", "Urgent I/O condition"},
1365 {"SIGSTOP", "Stopped (signal)"},
1366 {"SIGTSTP", "Stopped (user)"},
1367 {"SIGCONT", "Continued"},
1368 {"SIGCHLD", "Child status changed"},
1369 {"SIGTTIN", "Stopped (tty input)"},
1370 {"SIGTTOU", "Stopped (tty output)"},
1371 {"SIGIO", "I/O possible"},
1372 {"SIGXCPU", "CPU time limit exceeded"},
1373 {"SIGXFSZ", "File size limit exceeded"},
1374 {"SIGVTALRM", "Virtual timer expired"},
1375 {"SIGPROF", "Profiling timer expired"},
1376 {"SIGWINCH", "Window size changed"},
1377 {"SIGLOST", "Resource lost"},
1378 {"SIGUSR1", "User defined signal 1"},
1379 {"SIGUSR2", "User defined signal 2"},
1380 {"SIGPWR", "Power fail/restart"},
1381 {"SIGPOLL", "Pollable event occurred"},
1382 {"SIGWIND", "SIGWIND"},
1383 {"SIGPHONE", "SIGPHONE"},
1384 {"SIGWAITING", "Process's LWPs are blocked"},
1385 {"SIGLWP", "Signal LWP"},
1386 {"SIGDANGER", "Swap space dangerously low"},
1387 {"SIGGRANT", "Monitor mode granted"},
1388 {"SIGRETRACT", "Need to relinquish monitor mode"},
1389 {"SIGMSG", "Monitor mode data available"},
1390 {"SIGSOUND", "Sound completed"},
1391 {"SIGSAK", "Secure attention"},
1392 {"SIGPRIO", "SIGPRIO"},
1393 {"SIG33", "Real-time event 33"},
1394 {"SIG34", "Real-time event 34"},
1395 {"SIG35", "Real-time event 35"},
1396 {"SIG36", "Real-time event 36"},
1397 {"SIG37", "Real-time event 37"},
1398 {"SIG38", "Real-time event 38"},
1399 {"SIG39", "Real-time event 39"},
1400 {"SIG40", "Real-time event 40"},
1401 {"SIG41", "Real-time event 41"},
1402 {"SIG42", "Real-time event 42"},
1403 {"SIG43", "Real-time event 43"},
1404 {"SIG44", "Real-time event 44"},
1405 {"SIG45", "Real-time event 45"},
1406 {"SIG46", "Real-time event 46"},
1407 {"SIG47", "Real-time event 47"},
1408 {"SIG48", "Real-time event 48"},
1409 {"SIG49", "Real-time event 49"},
1410 {"SIG50", "Real-time event 50"},
1411 {"SIG51", "Real-time event 51"},
1412 {"SIG52", "Real-time event 52"},
1413 {"SIG53", "Real-time event 53"},
1414 {"SIG54", "Real-time event 54"},
1415 {"SIG55", "Real-time event 55"},
1416 {"SIG56", "Real-time event 56"},
1417 {"SIG57", "Real-time event 57"},
1418 {"SIG58", "Real-time event 58"},
1419 {"SIG59", "Real-time event 59"},
1420 {"SIG60", "Real-time event 60"},
1421 {"SIG61", "Real-time event 61"},
1422 {"SIG62", "Real-time event 62"},
1423 {"SIG63", "Real-time event 63"},
1424 {"SIGCANCEL", "LWP internal signal"},
1425 {"SIG32", "Real-time event 32"},
1426
1427 #if defined(MACH) || defined(__MACH__)
1428 /* Mach exceptions */
1429 {"EXC_BAD_ACCESS", "Could not access memory"},
1430 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1431 {"EXC_ARITHMETIC", "Arithmetic exception"},
1432 {"EXC_EMULATION", "Emulation instruction"},
1433 {"EXC_SOFTWARE", "Software generated exception"},
1434 {"EXC_BREAKPOINT", "Breakpoint"},
1435 #endif
1436 {"SIGINFO", "Information request"},
1437
1438 {NULL, "Unknown signal"},
1439 {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1440
1441 /* Last entry, used to check whether the table is the right size. */
1442 {NULL, "TARGET_SIGNAL_MAGIC"}
1443 };
1444 /* *INDENT-ON* */
1445
1446
1447
1448 /* Return the string for a signal. */
1449 char *
1450 target_signal_to_string (enum target_signal sig)
1451 {
1452 if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
1453 return signals[sig].string;
1454 else
1455 return signals[TARGET_SIGNAL_UNKNOWN].string;
1456 }
1457
1458 /* Return the name for a signal. */
1459 char *
1460 target_signal_to_name (enum target_signal sig)
1461 {
1462 if (sig == TARGET_SIGNAL_UNKNOWN)
1463 /* I think the code which prints this will always print it along with
1464 the string, so no need to be verbose. */
1465 return "?";
1466 return signals[sig].name;
1467 }
1468
1469 /* Given a name, return its signal. */
1470 enum target_signal
1471 target_signal_from_name (char *name)
1472 {
1473 enum target_signal sig;
1474
1475 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1476 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1477 questionable; seems like by now people should call it SIGABRT
1478 instead. */
1479
1480 /* This ugly cast brought to you by the native VAX compiler. */
1481 for (sig = TARGET_SIGNAL_HUP;
1482 signals[sig].name != NULL;
1483 sig = (enum target_signal) ((int) sig + 1))
1484 if (STREQ (name, signals[sig].name))
1485 return sig;
1486 return TARGET_SIGNAL_UNKNOWN;
1487 }
1488 \f
1489 /* The following functions are to help certain targets deal
1490 with the signal/waitstatus stuff. They could just as well be in
1491 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1492
1493 /* Convert host signal to our signals. */
1494 enum target_signal
1495 target_signal_from_host (int hostsig)
1496 {
1497 /* A switch statement would make sense but would require special kludges
1498 to deal with the cases where more than one signal has the same number. */
1499
1500 if (hostsig == 0)
1501 return TARGET_SIGNAL_0;
1502
1503 #if defined (SIGHUP)
1504 if (hostsig == SIGHUP)
1505 return TARGET_SIGNAL_HUP;
1506 #endif
1507 #if defined (SIGINT)
1508 if (hostsig == SIGINT)
1509 return TARGET_SIGNAL_INT;
1510 #endif
1511 #if defined (SIGQUIT)
1512 if (hostsig == SIGQUIT)
1513 return TARGET_SIGNAL_QUIT;
1514 #endif
1515 #if defined (SIGILL)
1516 if (hostsig == SIGILL)
1517 return TARGET_SIGNAL_ILL;
1518 #endif
1519 #if defined (SIGTRAP)
1520 if (hostsig == SIGTRAP)
1521 return TARGET_SIGNAL_TRAP;
1522 #endif
1523 #if defined (SIGABRT)
1524 if (hostsig == SIGABRT)
1525 return TARGET_SIGNAL_ABRT;
1526 #endif
1527 #if defined (SIGEMT)
1528 if (hostsig == SIGEMT)
1529 return TARGET_SIGNAL_EMT;
1530 #endif
1531 #if defined (SIGFPE)
1532 if (hostsig == SIGFPE)
1533 return TARGET_SIGNAL_FPE;
1534 #endif
1535 #if defined (SIGKILL)
1536 if (hostsig == SIGKILL)
1537 return TARGET_SIGNAL_KILL;
1538 #endif
1539 #if defined (SIGBUS)
1540 if (hostsig == SIGBUS)
1541 return TARGET_SIGNAL_BUS;
1542 #endif
1543 #if defined (SIGSEGV)
1544 if (hostsig == SIGSEGV)
1545 return TARGET_SIGNAL_SEGV;
1546 #endif
1547 #if defined (SIGSYS)
1548 if (hostsig == SIGSYS)
1549 return TARGET_SIGNAL_SYS;
1550 #endif
1551 #if defined (SIGPIPE)
1552 if (hostsig == SIGPIPE)
1553 return TARGET_SIGNAL_PIPE;
1554 #endif
1555 #if defined (SIGALRM)
1556 if (hostsig == SIGALRM)
1557 return TARGET_SIGNAL_ALRM;
1558 #endif
1559 #if defined (SIGTERM)
1560 if (hostsig == SIGTERM)
1561 return TARGET_SIGNAL_TERM;
1562 #endif
1563 #if defined (SIGUSR1)
1564 if (hostsig == SIGUSR1)
1565 return TARGET_SIGNAL_USR1;
1566 #endif
1567 #if defined (SIGUSR2)
1568 if (hostsig == SIGUSR2)
1569 return TARGET_SIGNAL_USR2;
1570 #endif
1571 #if defined (SIGCLD)
1572 if (hostsig == SIGCLD)
1573 return TARGET_SIGNAL_CHLD;
1574 #endif
1575 #if defined (SIGCHLD)
1576 if (hostsig == SIGCHLD)
1577 return TARGET_SIGNAL_CHLD;
1578 #endif
1579 #if defined (SIGPWR)
1580 if (hostsig == SIGPWR)
1581 return TARGET_SIGNAL_PWR;
1582 #endif
1583 #if defined (SIGWINCH)
1584 if (hostsig == SIGWINCH)
1585 return TARGET_SIGNAL_WINCH;
1586 #endif
1587 #if defined (SIGURG)
1588 if (hostsig == SIGURG)
1589 return TARGET_SIGNAL_URG;
1590 #endif
1591 #if defined (SIGIO)
1592 if (hostsig == SIGIO)
1593 return TARGET_SIGNAL_IO;
1594 #endif
1595 #if defined (SIGPOLL)
1596 if (hostsig == SIGPOLL)
1597 return TARGET_SIGNAL_POLL;
1598 #endif
1599 #if defined (SIGSTOP)
1600 if (hostsig == SIGSTOP)
1601 return TARGET_SIGNAL_STOP;
1602 #endif
1603 #if defined (SIGTSTP)
1604 if (hostsig == SIGTSTP)
1605 return TARGET_SIGNAL_TSTP;
1606 #endif
1607 #if defined (SIGCONT)
1608 if (hostsig == SIGCONT)
1609 return TARGET_SIGNAL_CONT;
1610 #endif
1611 #if defined (SIGTTIN)
1612 if (hostsig == SIGTTIN)
1613 return TARGET_SIGNAL_TTIN;
1614 #endif
1615 #if defined (SIGTTOU)
1616 if (hostsig == SIGTTOU)
1617 return TARGET_SIGNAL_TTOU;
1618 #endif
1619 #if defined (SIGVTALRM)
1620 if (hostsig == SIGVTALRM)
1621 return TARGET_SIGNAL_VTALRM;
1622 #endif
1623 #if defined (SIGPROF)
1624 if (hostsig == SIGPROF)
1625 return TARGET_SIGNAL_PROF;
1626 #endif
1627 #if defined (SIGXCPU)
1628 if (hostsig == SIGXCPU)
1629 return TARGET_SIGNAL_XCPU;
1630 #endif
1631 #if defined (SIGXFSZ)
1632 if (hostsig == SIGXFSZ)
1633 return TARGET_SIGNAL_XFSZ;
1634 #endif
1635 #if defined (SIGWIND)
1636 if (hostsig == SIGWIND)
1637 return TARGET_SIGNAL_WIND;
1638 #endif
1639 #if defined (SIGPHONE)
1640 if (hostsig == SIGPHONE)
1641 return TARGET_SIGNAL_PHONE;
1642 #endif
1643 #if defined (SIGLOST)
1644 if (hostsig == SIGLOST)
1645 return TARGET_SIGNAL_LOST;
1646 #endif
1647 #if defined (SIGWAITING)
1648 if (hostsig == SIGWAITING)
1649 return TARGET_SIGNAL_WAITING;
1650 #endif
1651 #if defined (SIGCANCEL)
1652 if (hostsig == SIGCANCEL)
1653 return TARGET_SIGNAL_CANCEL;
1654 #endif
1655 #if defined (SIGLWP)
1656 if (hostsig == SIGLWP)
1657 return TARGET_SIGNAL_LWP;
1658 #endif
1659 #if defined (SIGDANGER)
1660 if (hostsig == SIGDANGER)
1661 return TARGET_SIGNAL_DANGER;
1662 #endif
1663 #if defined (SIGGRANT)
1664 if (hostsig == SIGGRANT)
1665 return TARGET_SIGNAL_GRANT;
1666 #endif
1667 #if defined (SIGRETRACT)
1668 if (hostsig == SIGRETRACT)
1669 return TARGET_SIGNAL_RETRACT;
1670 #endif
1671 #if defined (SIGMSG)
1672 if (hostsig == SIGMSG)
1673 return TARGET_SIGNAL_MSG;
1674 #endif
1675 #if defined (SIGSOUND)
1676 if (hostsig == SIGSOUND)
1677 return TARGET_SIGNAL_SOUND;
1678 #endif
1679 #if defined (SIGSAK)
1680 if (hostsig == SIGSAK)
1681 return TARGET_SIGNAL_SAK;
1682 #endif
1683 #if defined (SIGPRIO)
1684 if (hostsig == SIGPRIO)
1685 return TARGET_SIGNAL_PRIO;
1686 #endif
1687
1688 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1689 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1690 if (hostsig == _NSIG + EXC_BAD_ACCESS)
1691 return TARGET_EXC_BAD_ACCESS;
1692 #endif
1693 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1694 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
1695 return TARGET_EXC_BAD_INSTRUCTION;
1696 #endif
1697 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1698 if (hostsig == _NSIG + EXC_ARITHMETIC)
1699 return TARGET_EXC_ARITHMETIC;
1700 #endif
1701 #if defined (EXC_EMULATION) && defined (_NSIG)
1702 if (hostsig == _NSIG + EXC_EMULATION)
1703 return TARGET_EXC_EMULATION;
1704 #endif
1705 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1706 if (hostsig == _NSIG + EXC_SOFTWARE)
1707 return TARGET_EXC_SOFTWARE;
1708 #endif
1709 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1710 if (hostsig == _NSIG + EXC_BREAKPOINT)
1711 return TARGET_EXC_BREAKPOINT;
1712 #endif
1713
1714 #if defined (SIGINFO)
1715 if (hostsig == SIGINFO)
1716 return TARGET_SIGNAL_INFO;
1717 #endif
1718
1719 #if defined (REALTIME_LO)
1720 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
1721 {
1722 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
1723 if (33 <= hostsig && hostsig <= 63)
1724 return (enum target_signal)
1725 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
1726 else if (hostsig == 32)
1727 return TARGET_SIGNAL_REALTIME_32;
1728 else
1729 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
1730 }
1731 #endif
1732 return TARGET_SIGNAL_UNKNOWN;
1733 }
1734
1735 /* Convert a OURSIG (an enum target_signal) to the form used by the
1736 target operating system (refered to as the ``host'') or zero if the
1737 equivalent host signal is not available. Set/clear OURSIG_OK
1738 accordingly. */
1739
1740 static int
1741 do_target_signal_to_host (enum target_signal oursig,
1742 int *oursig_ok)
1743 {
1744 *oursig_ok = 1;
1745 switch (oursig)
1746 {
1747 case TARGET_SIGNAL_0:
1748 return 0;
1749
1750 #if defined (SIGHUP)
1751 case TARGET_SIGNAL_HUP:
1752 return SIGHUP;
1753 #endif
1754 #if defined (SIGINT)
1755 case TARGET_SIGNAL_INT:
1756 return SIGINT;
1757 #endif
1758 #if defined (SIGQUIT)
1759 case TARGET_SIGNAL_QUIT:
1760 return SIGQUIT;
1761 #endif
1762 #if defined (SIGILL)
1763 case TARGET_SIGNAL_ILL:
1764 return SIGILL;
1765 #endif
1766 #if defined (SIGTRAP)
1767 case TARGET_SIGNAL_TRAP:
1768 return SIGTRAP;
1769 #endif
1770 #if defined (SIGABRT)
1771 case TARGET_SIGNAL_ABRT:
1772 return SIGABRT;
1773 #endif
1774 #if defined (SIGEMT)
1775 case TARGET_SIGNAL_EMT:
1776 return SIGEMT;
1777 #endif
1778 #if defined (SIGFPE)
1779 case TARGET_SIGNAL_FPE:
1780 return SIGFPE;
1781 #endif
1782 #if defined (SIGKILL)
1783 case TARGET_SIGNAL_KILL:
1784 return SIGKILL;
1785 #endif
1786 #if defined (SIGBUS)
1787 case TARGET_SIGNAL_BUS:
1788 return SIGBUS;
1789 #endif
1790 #if defined (SIGSEGV)
1791 case TARGET_SIGNAL_SEGV:
1792 return SIGSEGV;
1793 #endif
1794 #if defined (SIGSYS)
1795 case TARGET_SIGNAL_SYS:
1796 return SIGSYS;
1797 #endif
1798 #if defined (SIGPIPE)
1799 case TARGET_SIGNAL_PIPE:
1800 return SIGPIPE;
1801 #endif
1802 #if defined (SIGALRM)
1803 case TARGET_SIGNAL_ALRM:
1804 return SIGALRM;
1805 #endif
1806 #if defined (SIGTERM)
1807 case TARGET_SIGNAL_TERM:
1808 return SIGTERM;
1809 #endif
1810 #if defined (SIGUSR1)
1811 case TARGET_SIGNAL_USR1:
1812 return SIGUSR1;
1813 #endif
1814 #if defined (SIGUSR2)
1815 case TARGET_SIGNAL_USR2:
1816 return SIGUSR2;
1817 #endif
1818 #if defined (SIGCHLD) || defined (SIGCLD)
1819 case TARGET_SIGNAL_CHLD:
1820 #if defined (SIGCHLD)
1821 return SIGCHLD;
1822 #else
1823 return SIGCLD;
1824 #endif
1825 #endif /* SIGCLD or SIGCHLD */
1826 #if defined (SIGPWR)
1827 case TARGET_SIGNAL_PWR:
1828 return SIGPWR;
1829 #endif
1830 #if defined (SIGWINCH)
1831 case TARGET_SIGNAL_WINCH:
1832 return SIGWINCH;
1833 #endif
1834 #if defined (SIGURG)
1835 case TARGET_SIGNAL_URG:
1836 return SIGURG;
1837 #endif
1838 #if defined (SIGIO)
1839 case TARGET_SIGNAL_IO:
1840 return SIGIO;
1841 #endif
1842 #if defined (SIGPOLL)
1843 case TARGET_SIGNAL_POLL:
1844 return SIGPOLL;
1845 #endif
1846 #if defined (SIGSTOP)
1847 case TARGET_SIGNAL_STOP:
1848 return SIGSTOP;
1849 #endif
1850 #if defined (SIGTSTP)
1851 case TARGET_SIGNAL_TSTP:
1852 return SIGTSTP;
1853 #endif
1854 #if defined (SIGCONT)
1855 case TARGET_SIGNAL_CONT:
1856 return SIGCONT;
1857 #endif
1858 #if defined (SIGTTIN)
1859 case TARGET_SIGNAL_TTIN:
1860 return SIGTTIN;
1861 #endif
1862 #if defined (SIGTTOU)
1863 case TARGET_SIGNAL_TTOU:
1864 return SIGTTOU;
1865 #endif
1866 #if defined (SIGVTALRM)
1867 case TARGET_SIGNAL_VTALRM:
1868 return SIGVTALRM;
1869 #endif
1870 #if defined (SIGPROF)
1871 case TARGET_SIGNAL_PROF:
1872 return SIGPROF;
1873 #endif
1874 #if defined (SIGXCPU)
1875 case TARGET_SIGNAL_XCPU:
1876 return SIGXCPU;
1877 #endif
1878 #if defined (SIGXFSZ)
1879 case TARGET_SIGNAL_XFSZ:
1880 return SIGXFSZ;
1881 #endif
1882 #if defined (SIGWIND)
1883 case TARGET_SIGNAL_WIND:
1884 return SIGWIND;
1885 #endif
1886 #if defined (SIGPHONE)
1887 case TARGET_SIGNAL_PHONE:
1888 return SIGPHONE;
1889 #endif
1890 #if defined (SIGLOST)
1891 case TARGET_SIGNAL_LOST:
1892 return SIGLOST;
1893 #endif
1894 #if defined (SIGWAITING)
1895 case TARGET_SIGNAL_WAITING:
1896 return SIGWAITING;
1897 #endif
1898 #if defined (SIGCANCEL)
1899 case TARGET_SIGNAL_CANCEL:
1900 return SIGCANCEL;
1901 #endif
1902 #if defined (SIGLWP)
1903 case TARGET_SIGNAL_LWP:
1904 return SIGLWP;
1905 #endif
1906 #if defined (SIGDANGER)
1907 case TARGET_SIGNAL_DANGER:
1908 return SIGDANGER;
1909 #endif
1910 #if defined (SIGGRANT)
1911 case TARGET_SIGNAL_GRANT:
1912 return SIGGRANT;
1913 #endif
1914 #if defined (SIGRETRACT)
1915 case TARGET_SIGNAL_RETRACT:
1916 return SIGRETRACT;
1917 #endif
1918 #if defined (SIGMSG)
1919 case TARGET_SIGNAL_MSG:
1920 return SIGMSG;
1921 #endif
1922 #if defined (SIGSOUND)
1923 case TARGET_SIGNAL_SOUND:
1924 return SIGSOUND;
1925 #endif
1926 #if defined (SIGSAK)
1927 case TARGET_SIGNAL_SAK:
1928 return SIGSAK;
1929 #endif
1930 #if defined (SIGPRIO)
1931 case TARGET_SIGNAL_PRIO:
1932 return SIGPRIO;
1933 #endif
1934
1935 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1936 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1937 case TARGET_EXC_BAD_ACCESS:
1938 return _NSIG + EXC_BAD_ACCESS;
1939 #endif
1940 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1941 case TARGET_EXC_BAD_INSTRUCTION:
1942 return _NSIG + EXC_BAD_INSTRUCTION;
1943 #endif
1944 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1945 case TARGET_EXC_ARITHMETIC:
1946 return _NSIG + EXC_ARITHMETIC;
1947 #endif
1948 #if defined (EXC_EMULATION) && defined (_NSIG)
1949 case TARGET_EXC_EMULATION:
1950 return _NSIG + EXC_EMULATION;
1951 #endif
1952 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1953 case TARGET_EXC_SOFTWARE:
1954 return _NSIG + EXC_SOFTWARE;
1955 #endif
1956 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1957 case TARGET_EXC_BREAKPOINT:
1958 return _NSIG + EXC_BREAKPOINT;
1959 #endif
1960
1961 #if defined (SIGINFO)
1962 case TARGET_SIGNAL_INFO:
1963 return SIGINFO;
1964 #endif
1965
1966 default:
1967 #if defined (REALTIME_LO)
1968 if (oursig >= TARGET_SIGNAL_REALTIME_33
1969 && oursig <= TARGET_SIGNAL_REALTIME_63)
1970 {
1971 /* This block of signals is continuous, and
1972 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
1973 int retsig =
1974 (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
1975 if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
1976 return retsig;
1977 }
1978 #if (REALTIME_LO < 33)
1979 else if (oursig == TARGET_SIGNAL_REALTIME_32)
1980 {
1981 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
1982 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */
1983 return 32;
1984 }
1985 #endif
1986 #endif
1987 *oursig_ok = 0;
1988 return 0;
1989 }
1990 }
1991
1992 int
1993 target_signal_to_host_p (enum target_signal oursig)
1994 {
1995 int oursig_ok;
1996 do_target_signal_to_host (oursig, &oursig_ok);
1997 return oursig_ok;
1998 }
1999
2000 int
2001 target_signal_to_host (enum target_signal oursig)
2002 {
2003 int oursig_ok;
2004 int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
2005 if (!oursig_ok)
2006 {
2007 /* The user might be trying to do "signal SIGSAK" where this system
2008 doesn't have SIGSAK. */
2009 warning ("Signal %s does not exist on this system.\n",
2010 target_signal_to_name (oursig));
2011 return 0;
2012 }
2013 else
2014 return targ_signo;
2015 }
2016
2017 /* Helper function for child_wait and the Lynx derivatives of child_wait.
2018 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
2019 translation of that in OURSTATUS. */
2020 void
2021 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
2022 {
2023 #ifdef CHILD_SPECIAL_WAITSTATUS
2024 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
2025 if it wants to deal with hoststatus. */
2026 if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
2027 return;
2028 #endif
2029
2030 if (WIFEXITED (hoststatus))
2031 {
2032 ourstatus->kind = TARGET_WAITKIND_EXITED;
2033 ourstatus->value.integer = WEXITSTATUS (hoststatus);
2034 }
2035 else if (!WIFSTOPPED (hoststatus))
2036 {
2037 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
2038 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
2039 }
2040 else
2041 {
2042 ourstatus->kind = TARGET_WAITKIND_STOPPED;
2043 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
2044 }
2045 }
2046 \f
2047 /* In some circumstances we allow a command to specify a numeric
2048 signal. The idea is to keep these circumstances limited so that
2049 users (and scripts) develop portable habits. For comparison,
2050 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
2051 numeric signal at all is obscelescent. We are slightly more
2052 lenient and allow 1-15 which should match host signal numbers on
2053 most systems. Use of symbolic signal names is strongly encouraged. */
2054
2055 enum target_signal
2056 target_signal_from_command (int num)
2057 {
2058 if (num >= 1 && num <= 15)
2059 return (enum target_signal) num;
2060 error ("Only signals 1-15 are valid as numeric signals.\n\
2061 Use \"info signals\" for a list of symbolic signals.");
2062 }
2063 \f
2064 /* Returns zero to leave the inferior alone, one to interrupt it. */
2065 int (*target_activity_function) (void);
2066 int target_activity_fd;
2067 \f
2068 /* Convert a normal process ID to a string. Returns the string in a static
2069 buffer. */
2070
2071 char *
2072 normal_pid_to_str (int pid)
2073 {
2074 static char buf[30];
2075
2076 if (STREQ (current_target.to_shortname, "remote"))
2077 sprintf (buf, "thread %d", pid);
2078 else
2079 sprintf (buf, "process %d", pid);
2080
2081 return buf;
2082 }
2083
2084 /* Some targets (such as ttrace-based HPUX) don't allow us to request
2085 notification of inferior events such as fork and vork immediately
2086 after the inferior is created. (This because of how gdb gets an
2087 inferior created via invoking a shell to do it. In such a scenario,
2088 if the shell init file has commands in it, the shell will fork and
2089 exec for each of those commands, and we will see each such fork
2090 event. Very bad.)
2091
2092 This function is used by all targets that allow us to request
2093 notification of forks, etc at inferior creation time; e.g., in
2094 target_acknowledge_forked_child.
2095 */
2096 static void
2097 normal_target_post_startup_inferior (int pid)
2098 {
2099 /* This space intentionally left blank. */
2100 }
2101
2102 /* Set up the handful of non-empty slots needed by the dummy target
2103 vector. */
2104
2105 static void
2106 init_dummy_target (void)
2107 {
2108 dummy_target.to_shortname = "None";
2109 dummy_target.to_longname = "None";
2110 dummy_target.to_doc = "";
2111 dummy_target.to_attach = find_default_attach;
2112 dummy_target.to_require_attach = find_default_require_attach;
2113 dummy_target.to_require_detach = find_default_require_detach;
2114 dummy_target.to_create_inferior = find_default_create_inferior;
2115 dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
2116 dummy_target.to_pid_to_str = normal_pid_to_str;
2117 dummy_target.to_stratum = dummy_stratum;
2118 dummy_target.to_magic = OPS_MAGIC;
2119 }
2120 \f
2121
2122 static struct target_ops debug_target;
2123
2124 static void
2125 debug_to_open (char *args, int from_tty)
2126 {
2127 debug_target.to_open (args, from_tty);
2128
2129 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
2130 }
2131
2132 static void
2133 debug_to_close (int quitting)
2134 {
2135 debug_target.to_close (quitting);
2136
2137 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
2138 }
2139
2140 static void
2141 debug_to_attach (char *args, int from_tty)
2142 {
2143 debug_target.to_attach (args, from_tty);
2144
2145 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
2146 }
2147
2148
2149 static void
2150 debug_to_post_attach (int pid)
2151 {
2152 debug_target.to_post_attach (pid);
2153
2154 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
2155 }
2156
2157 static void
2158 debug_to_require_attach (char *args, int from_tty)
2159 {
2160 debug_target.to_require_attach (args, from_tty);
2161
2162 fprintf_unfiltered (gdb_stdlog,
2163 "target_require_attach (%s, %d)\n", args, from_tty);
2164 }
2165
2166 static void
2167 debug_to_detach (char *args, int from_tty)
2168 {
2169 debug_target.to_detach (args, from_tty);
2170
2171 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
2172 }
2173
2174 static void
2175 debug_to_require_detach (int pid, char *args, int from_tty)
2176 {
2177 debug_target.to_require_detach (pid, args, from_tty);
2178
2179 fprintf_unfiltered (gdb_stdlog,
2180 "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
2181 }
2182
2183 static void
2184 debug_to_resume (int pid, int step, enum target_signal siggnal)
2185 {
2186 debug_target.to_resume (pid, step, siggnal);
2187
2188 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", pid,
2189 step ? "step" : "continue",
2190 target_signal_to_name (siggnal));
2191 }
2192
2193 static int
2194 debug_to_wait (int pid, struct target_waitstatus *status)
2195 {
2196 int retval;
2197
2198 retval = debug_target.to_wait (pid, status);
2199
2200 fprintf_unfiltered (gdb_stdlog,
2201 "target_wait (%d, status) = %d, ", pid, retval);
2202 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
2203 switch (status->kind)
2204 {
2205 case TARGET_WAITKIND_EXITED:
2206 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
2207 status->value.integer);
2208 break;
2209 case TARGET_WAITKIND_STOPPED:
2210 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
2211 target_signal_to_name (status->value.sig));
2212 break;
2213 case TARGET_WAITKIND_SIGNALLED:
2214 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
2215 target_signal_to_name (status->value.sig));
2216 break;
2217 case TARGET_WAITKIND_LOADED:
2218 fprintf_unfiltered (gdb_stdlog, "loaded\n");
2219 break;
2220 case TARGET_WAITKIND_FORKED:
2221 fprintf_unfiltered (gdb_stdlog, "forked\n");
2222 break;
2223 case TARGET_WAITKIND_VFORKED:
2224 fprintf_unfiltered (gdb_stdlog, "vforked\n");
2225 break;
2226 case TARGET_WAITKIND_EXECD:
2227 fprintf_unfiltered (gdb_stdlog, "execd\n");
2228 break;
2229 case TARGET_WAITKIND_SPURIOUS:
2230 fprintf_unfiltered (gdb_stdlog, "spurious\n");
2231 break;
2232 default:
2233 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
2234 break;
2235 }
2236
2237 return retval;
2238 }
2239
2240 static void
2241 debug_to_post_wait (int pid, int status)
2242 {
2243 debug_target.to_post_wait (pid, status);
2244
2245 fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
2246 pid, status);
2247 }
2248
2249 static void
2250 debug_to_fetch_registers (int regno)
2251 {
2252 debug_target.to_fetch_registers (regno);
2253
2254 fprintf_unfiltered (gdb_stdlog, "target_fetch_registers (%s)",
2255 regno != -1 ? REGISTER_NAME (regno) : "-1");
2256 if (regno != -1)
2257 fprintf_unfiltered (gdb_stdlog, " = 0x%lx %ld",
2258 (unsigned long) read_register (regno),
2259 (unsigned long) read_register (regno));
2260 fprintf_unfiltered (gdb_stdlog, "\n");
2261 }
2262
2263 static void
2264 debug_to_store_registers (int regno)
2265 {
2266 debug_target.to_store_registers (regno);
2267
2268 if (regno >= 0 && regno < NUM_REGS)
2269 fprintf_unfiltered (gdb_stdlog, "target_store_registers (%s) = 0x%lx %ld\n",
2270 REGISTER_NAME (regno),
2271 (unsigned long) read_register (regno),
2272 (unsigned long) read_register (regno));
2273 else
2274 fprintf_unfiltered (gdb_stdlog, "target_store_registers (%d)\n", regno);
2275 }
2276
2277 static void
2278 debug_to_prepare_to_store (void)
2279 {
2280 debug_target.to_prepare_to_store ();
2281
2282 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2283 }
2284
2285 static int
2286 debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
2287 struct target_ops *target)
2288 {
2289 int retval;
2290
2291 retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
2292
2293 fprintf_unfiltered (gdb_stdlog,
2294 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2295 (unsigned int) memaddr, /* possable truncate long long */
2296 len, write ? "write" : "read", retval);
2297
2298
2299
2300 if (retval > 0)
2301 {
2302 int i;
2303
2304 fputs_unfiltered (", bytes =", gdb_stdlog);
2305 for (i = 0; i < retval; i++)
2306 {
2307 if ((((long) &(myaddr[i])) & 0xf) == 0)
2308 fprintf_unfiltered (gdb_stdlog, "\n");
2309 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2310 }
2311 }
2312
2313 fputc_unfiltered ('\n', gdb_stdlog);
2314
2315 return retval;
2316 }
2317
2318 static void
2319 debug_to_files_info (struct target_ops *target)
2320 {
2321 debug_target.to_files_info (target);
2322
2323 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2324 }
2325
2326 static int
2327 debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
2328 {
2329 int retval;
2330
2331 retval = debug_target.to_insert_breakpoint (addr, save);
2332
2333 fprintf_unfiltered (gdb_stdlog,
2334 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2335 (unsigned long) addr,
2336 (unsigned long) retval);
2337 return retval;
2338 }
2339
2340 static int
2341 debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
2342 {
2343 int retval;
2344
2345 retval = debug_target.to_remove_breakpoint (addr, save);
2346
2347 fprintf_unfiltered (gdb_stdlog,
2348 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2349 (unsigned long) addr,
2350 (unsigned long) retval);
2351 return retval;
2352 }
2353
2354 static void
2355 debug_to_terminal_init (void)
2356 {
2357 debug_target.to_terminal_init ();
2358
2359 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2360 }
2361
2362 static void
2363 debug_to_terminal_inferior (void)
2364 {
2365 debug_target.to_terminal_inferior ();
2366
2367 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2368 }
2369
2370 static void
2371 debug_to_terminal_ours_for_output (void)
2372 {
2373 debug_target.to_terminal_ours_for_output ();
2374
2375 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2376 }
2377
2378 static void
2379 debug_to_terminal_ours (void)
2380 {
2381 debug_target.to_terminal_ours ();
2382
2383 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2384 }
2385
2386 static void
2387 debug_to_terminal_info (char *arg, int from_tty)
2388 {
2389 debug_target.to_terminal_info (arg, from_tty);
2390
2391 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2392 from_tty);
2393 }
2394
2395 static void
2396 debug_to_kill (void)
2397 {
2398 debug_target.to_kill ();
2399
2400 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2401 }
2402
2403 static void
2404 debug_to_load (char *args, int from_tty)
2405 {
2406 debug_target.to_load (args, from_tty);
2407
2408 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2409 }
2410
2411 static int
2412 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2413 {
2414 int retval;
2415
2416 retval = debug_target.to_lookup_symbol (name, addrp);
2417
2418 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2419
2420 return retval;
2421 }
2422
2423 static void
2424 debug_to_create_inferior (char *exec_file, char *args, char **env)
2425 {
2426 debug_target.to_create_inferior (exec_file, args, env);
2427
2428 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx)\n",
2429 exec_file, args);
2430 }
2431
2432 static void
2433 debug_to_post_startup_inferior (int pid)
2434 {
2435 debug_target.to_post_startup_inferior (pid);
2436
2437 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2438 pid);
2439 }
2440
2441 static void
2442 debug_to_acknowledge_created_inferior (int pid)
2443 {
2444 debug_target.to_acknowledge_created_inferior (pid);
2445
2446 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2447 pid);
2448 }
2449
2450 static void
2451 debug_to_clone_and_follow_inferior (int child_pid, int *followed_child)
2452 {
2453 debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
2454
2455 fprintf_unfiltered (gdb_stdlog,
2456 "target_clone_and_follow_inferior (%d, %d)\n",
2457 child_pid, *followed_child);
2458 }
2459
2460 static void
2461 debug_to_post_follow_inferior_by_clone (void)
2462 {
2463 debug_target.to_post_follow_inferior_by_clone ();
2464
2465 fprintf_unfiltered (gdb_stdlog, "target_post_follow_inferior_by_clone ()\n");
2466 }
2467
2468 static int
2469 debug_to_insert_fork_catchpoint (int pid)
2470 {
2471 int retval;
2472
2473 retval = debug_target.to_insert_fork_catchpoint (pid);
2474
2475 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
2476 pid, retval);
2477
2478 return retval;
2479 }
2480
2481 static int
2482 debug_to_remove_fork_catchpoint (int pid)
2483 {
2484 int retval;
2485
2486 retval = debug_target.to_remove_fork_catchpoint (pid);
2487
2488 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2489 pid, retval);
2490
2491 return retval;
2492 }
2493
2494 static int
2495 debug_to_insert_vfork_catchpoint (int pid)
2496 {
2497 int retval;
2498
2499 retval = debug_target.to_insert_vfork_catchpoint (pid);
2500
2501 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
2502 pid, retval);
2503
2504 return retval;
2505 }
2506
2507 static int
2508 debug_to_remove_vfork_catchpoint (int pid)
2509 {
2510 int retval;
2511
2512 retval = debug_target.to_remove_vfork_catchpoint (pid);
2513
2514 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2515 pid, retval);
2516
2517 return retval;
2518 }
2519
2520 static int
2521 debug_to_has_forked (int pid, int *child_pid)
2522 {
2523 int has_forked;
2524
2525 has_forked = debug_target.to_has_forked (pid, child_pid);
2526
2527 fprintf_unfiltered (gdb_stdlog, "target_has_forked (%d, %d) = %d\n",
2528 pid, *child_pid, has_forked);
2529
2530 return has_forked;
2531 }
2532
2533 static int
2534 debug_to_has_vforked (int pid, int *child_pid)
2535 {
2536 int has_vforked;
2537
2538 has_vforked = debug_target.to_has_vforked (pid, child_pid);
2539
2540 fprintf_unfiltered (gdb_stdlog, "target_has_vforked (%d, %d) = %d\n",
2541 pid, *child_pid, has_vforked);
2542
2543 return has_vforked;
2544 }
2545
2546 static int
2547 debug_to_can_follow_vfork_prior_to_exec (void)
2548 {
2549 int can_immediately_follow_vfork;
2550
2551 can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
2552
2553 fprintf_unfiltered (gdb_stdlog, "target_can_follow_vfork_prior_to_exec () = %d\n",
2554 can_immediately_follow_vfork);
2555
2556 return can_immediately_follow_vfork;
2557 }
2558
2559 static void
2560 debug_to_post_follow_vfork (int parent_pid, int followed_parent, int child_pid,
2561 int followed_child)
2562 {
2563 debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
2564
2565 fprintf_unfiltered (gdb_stdlog,
2566 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2567 parent_pid, followed_parent, child_pid, followed_child);
2568 }
2569
2570 static int
2571 debug_to_insert_exec_catchpoint (int pid)
2572 {
2573 int retval;
2574
2575 retval = debug_target.to_insert_exec_catchpoint (pid);
2576
2577 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
2578 pid, retval);
2579
2580 return retval;
2581 }
2582
2583 static int
2584 debug_to_remove_exec_catchpoint (int pid)
2585 {
2586 int retval;
2587
2588 retval = debug_target.to_remove_exec_catchpoint (pid);
2589
2590 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2591 pid, retval);
2592
2593 return retval;
2594 }
2595
2596 static int
2597 debug_to_has_execd (int pid, char **execd_pathname)
2598 {
2599 int has_execd;
2600
2601 has_execd = debug_target.to_has_execd (pid, execd_pathname);
2602
2603 fprintf_unfiltered (gdb_stdlog, "target_has_execd (%d, %s) = %d\n",
2604 pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
2605 has_execd);
2606
2607 return has_execd;
2608 }
2609
2610 static int
2611 debug_to_reported_exec_events_per_exec_call (void)
2612 {
2613 int reported_exec_events;
2614
2615 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2616
2617 fprintf_unfiltered (gdb_stdlog,
2618 "target_reported_exec_events_per_exec_call () = %d\n",
2619 reported_exec_events);
2620
2621 return reported_exec_events;
2622 }
2623
2624 static int
2625 debug_to_has_syscall_event (int pid, enum target_waitkind *kind,
2626 int *syscall_id)
2627 {
2628 int has_syscall_event;
2629 char *kind_spelling = "??";
2630
2631 has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
2632 if (has_syscall_event)
2633 {
2634 switch (*kind)
2635 {
2636 case TARGET_WAITKIND_SYSCALL_ENTRY:
2637 kind_spelling = "SYSCALL_ENTRY";
2638 break;
2639 case TARGET_WAITKIND_SYSCALL_RETURN:
2640 kind_spelling = "SYSCALL_RETURN";
2641 break;
2642 default:
2643 break;
2644 }
2645 }
2646
2647 fprintf_unfiltered (gdb_stdlog,
2648 "target_has_syscall_event (%d, %s, %d) = %d\n",
2649 pid, kind_spelling, *syscall_id, has_syscall_event);
2650
2651 return has_syscall_event;
2652 }
2653
2654 static int
2655 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2656 {
2657 int has_exited;
2658
2659 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2660
2661 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2662 pid, wait_status, *exit_status, has_exited);
2663
2664 return has_exited;
2665 }
2666
2667 static void
2668 debug_to_mourn_inferior (void)
2669 {
2670 debug_target.to_mourn_inferior ();
2671
2672 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2673 }
2674
2675 static int
2676 debug_to_can_run (void)
2677 {
2678 int retval;
2679
2680 retval = debug_target.to_can_run ();
2681
2682 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2683
2684 return retval;
2685 }
2686
2687 static void
2688 debug_to_notice_signals (int pid)
2689 {
2690 debug_target.to_notice_signals (pid);
2691
2692 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n", pid);
2693 }
2694
2695 static int
2696 debug_to_thread_alive (int pid)
2697 {
2698 int retval;
2699
2700 retval = debug_target.to_thread_alive (pid);
2701
2702 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2703 pid, retval);
2704
2705 return retval;
2706 }
2707
2708 static void
2709 debug_to_find_new_threads (void)
2710 {
2711 debug_target.to_find_new_threads ();
2712
2713 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2714 }
2715
2716 static void
2717 debug_to_stop (void)
2718 {
2719 debug_target.to_stop ();
2720
2721 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2722 }
2723
2724 static int
2725 debug_to_query (int type, char *req, char *resp, int *siz)
2726 {
2727 int retval;
2728
2729 retval = debug_target.to_query (type, req, resp, siz);
2730
2731 fprintf_unfiltered (gdb_stdlog, "target_query (%c, %s, %s, %d) = %d\n", type, req, resp, *siz, retval);
2732
2733 return retval;
2734 }
2735
2736 static void
2737 debug_to_rcmd (char *command,
2738 struct ui_file *outbuf)
2739 {
2740 debug_target.to_rcmd (command, outbuf);
2741 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2742 }
2743
2744 static struct symtab_and_line *
2745 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2746 {
2747 struct symtab_and_line *result;
2748 result = debug_target.to_enable_exception_callback (kind, enable);
2749 fprintf_unfiltered (gdb_stdlog,
2750 "target get_exception_callback_sal (%d, %d)\n",
2751 kind, enable);
2752 return result;
2753 }
2754
2755 static struct exception_event_record *
2756 debug_to_get_current_exception_event (void)
2757 {
2758 struct exception_event_record *result;
2759 result = debug_target.to_get_current_exception_event ();
2760 fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2761 return result;
2762 }
2763
2764 static char *
2765 debug_to_pid_to_exec_file (int pid)
2766 {
2767 char *exec_file;
2768
2769 exec_file = debug_target.to_pid_to_exec_file (pid);
2770
2771 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2772 pid, exec_file);
2773
2774 return exec_file;
2775 }
2776
2777 static char *
2778 debug_to_core_file_to_sym_file (char *core)
2779 {
2780 char *sym_file;
2781
2782 sym_file = debug_target.to_core_file_to_sym_file (core);
2783
2784 fprintf_unfiltered (gdb_stdlog, "target_core_file_to_sym_file (%s) = %s\n",
2785 core, sym_file);
2786
2787 return sym_file;
2788 }
2789
2790 static void
2791 setup_target_debug (void)
2792 {
2793 memcpy (&debug_target, &current_target, sizeof debug_target);
2794
2795 current_target.to_open = debug_to_open;
2796 current_target.to_close = debug_to_close;
2797 current_target.to_attach = debug_to_attach;
2798 current_target.to_post_attach = debug_to_post_attach;
2799 current_target.to_require_attach = debug_to_require_attach;
2800 current_target.to_detach = debug_to_detach;
2801 current_target.to_require_detach = debug_to_require_detach;
2802 current_target.to_resume = debug_to_resume;
2803 current_target.to_wait = debug_to_wait;
2804 current_target.to_post_wait = debug_to_post_wait;
2805 current_target.to_fetch_registers = debug_to_fetch_registers;
2806 current_target.to_store_registers = debug_to_store_registers;
2807 current_target.to_prepare_to_store = debug_to_prepare_to_store;
2808 current_target.to_xfer_memory = debug_to_xfer_memory;
2809 current_target.to_files_info = debug_to_files_info;
2810 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2811 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2812 current_target.to_terminal_init = debug_to_terminal_init;
2813 current_target.to_terminal_inferior = debug_to_terminal_inferior;
2814 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2815 current_target.to_terminal_ours = debug_to_terminal_ours;
2816 current_target.to_terminal_info = debug_to_terminal_info;
2817 current_target.to_kill = debug_to_kill;
2818 current_target.to_load = debug_to_load;
2819 current_target.to_lookup_symbol = debug_to_lookup_symbol;
2820 current_target.to_create_inferior = debug_to_create_inferior;
2821 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2822 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2823 current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior;
2824 current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone;
2825 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2826 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2827 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2828 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2829 current_target.to_has_forked = debug_to_has_forked;
2830 current_target.to_has_vforked = debug_to_has_vforked;
2831 current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec;
2832 current_target.to_post_follow_vfork = debug_to_post_follow_vfork;
2833 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2834 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2835 current_target.to_has_execd = debug_to_has_execd;
2836 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2837 current_target.to_has_syscall_event = debug_to_has_syscall_event;
2838 current_target.to_has_exited = debug_to_has_exited;
2839 current_target.to_mourn_inferior = debug_to_mourn_inferior;
2840 current_target.to_can_run = debug_to_can_run;
2841 current_target.to_notice_signals = debug_to_notice_signals;
2842 current_target.to_thread_alive = debug_to_thread_alive;
2843 current_target.to_find_new_threads = debug_to_find_new_threads;
2844 current_target.to_stop = debug_to_stop;
2845 current_target.to_query = debug_to_query;
2846 current_target.to_rcmd = debug_to_rcmd;
2847 current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2848 current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2849 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2850 current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
2851
2852 }
2853 \f
2854
2855 static char targ_desc[] =
2856 "Names of targets and files being debugged.\n\
2857 Shows the entire stack of targets currently in use (including the exec-file,\n\
2858 core-file, and process, if any), as well as the symbol file name.";
2859
2860 static void
2861 do_monitor_command (char *cmd,
2862 int from_tty)
2863 {
2864 if ((current_target.to_rcmd
2865 == (void (*) (char *, struct ui_file *)) tcomplain)
2866 || (current_target.to_rcmd == debug_to_rcmd
2867 && (debug_target.to_rcmd
2868 == (void (*) (char *, struct ui_file *)) tcomplain)))
2869 {
2870 error ("\"monitor\" command not supported by this target.\n");
2871 }
2872 target_rcmd (cmd, gdb_stdtarg);
2873 }
2874
2875 void
2876 initialize_targets (void)
2877 {
2878 init_dummy_target ();
2879 push_target (&dummy_target);
2880
2881 add_info ("target", target_info, targ_desc);
2882 add_info ("files", target_info, targ_desc);
2883
2884 add_show_from_set (
2885 add_set_cmd ("target", class_maintenance, var_zinteger,
2886 (char *) &targetdebug,
2887 "Set target debugging.\n\
2888 When non-zero, target debugging is enabled.", &setdebuglist),
2889 &showdebuglist);
2890
2891
2892 add_com ("monitor", class_obscure, do_monitor_command,
2893 "Send a command to the remote monitor (remote targets only).");
2894
2895 if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
2896 abort ();
2897 }
The GNU Binutils are a collection of binary tools.