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