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.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
38 target_info
PARAMS ((char *, int));
41 cleanup_target
PARAMS ((struct target_ops
*));
44 maybe_kill_then_create_inferior
PARAMS ((char *, char *, char **));
47 default_clone_and_follow_inferior
PARAMS ((int, int *));
50 maybe_kill_then_attach
PARAMS ((char *, int));
53 kill_or_be_killed
PARAMS ((int));
56 default_terminal_info
PARAMS ((char *, int));
59 nosymbol
PARAMS ((char *, CORE_ADDR
*));
62 tcomplain
PARAMS ((void));
65 nomemory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
68 return_zero
PARAMS ((void));
71 return_one
PARAMS ((void));
74 target_ignore
PARAMS ((void));
77 target_command
PARAMS ((char *, int));
79 static struct target_ops
*
80 find_default_run_target
PARAMS ((char *));
83 update_current_target
PARAMS ((void));
85 /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
86 Returns 0 for success, errno code for failure (which includes partial
87 transfers--if you want a more useful response to partial transfers, try
88 target_read_memory_partial). */
91 target_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
,
92 int write
, asection
*bfd_section
));
94 static void init_dummy_target
PARAMS ((void));
97 debug_to_open
PARAMS ((char *, int));
100 debug_to_close
PARAMS ((int));
103 debug_to_attach
PARAMS ((char *, int));
106 debug_to_detach
PARAMS ((char *, int));
109 debug_to_resume
PARAMS ((int, int, enum target_signal
));
112 debug_to_wait
PARAMS ((int, struct target_waitstatus
*));
115 debug_to_fetch_registers
PARAMS ((int));
118 debug_to_store_registers
PARAMS ((int));
121 debug_to_prepare_to_store
PARAMS ((void));
124 debug_to_xfer_memory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
127 debug_to_files_info
PARAMS ((struct target_ops
*));
130 debug_to_insert_breakpoint
PARAMS ((CORE_ADDR
, char *));
133 debug_to_remove_breakpoint
PARAMS ((CORE_ADDR
, char *));
136 debug_to_terminal_init
PARAMS ((void));
139 debug_to_terminal_inferior
PARAMS ((void));
142 debug_to_terminal_ours_for_output
PARAMS ((void));
145 debug_to_terminal_ours
PARAMS ((void));
148 debug_to_terminal_info
PARAMS ((char *, int));
151 debug_to_kill
PARAMS ((void));
154 debug_to_load
PARAMS ((char *, int));
157 debug_to_lookup_symbol
PARAMS ((char *, CORE_ADDR
*));
160 debug_to_create_inferior
PARAMS ((char *, char *, char **));
163 debug_to_mourn_inferior
PARAMS ((void));
166 debug_to_can_run
PARAMS ((void));
169 debug_to_notice_signals
PARAMS ((int));
172 debug_to_thread_alive
PARAMS ((int));
175 debug_to_stop
PARAMS ((void));
177 static int debug_to_query
PARAMS ((int/*char*/, char *, char *, int *));
179 /* Pointer to array of target architecture structures; the size of the
180 array; the current index into the array; the allocated size of the
182 struct target_ops
**target_structs
;
183 unsigned target_struct_size
;
184 unsigned target_struct_index
;
185 unsigned target_struct_allocsize
;
186 #define DEFAULT_ALLOCSIZE 10
188 /* The initial current target, so that there is always a semi-valid
191 static struct target_ops dummy_target
;
193 /* Top of target stack. */
195 struct target_stack_item
*target_stack
;
197 /* The target structure we are currently using to talk to a process
198 or file or whatever "inferior" we have. */
200 struct target_ops current_target
;
202 /* Command list for target. */
204 static struct cmd_list_element
*targetlist
= NULL
;
206 /* Nonzero if we are debugging an attached outside process
207 rather than an inferior. */
211 /* Non-zero if we want to see trace of target level stuff. */
213 static int targetdebug
= 0;
215 static void setup_target_debug
PARAMS ((void));
217 /* The user just typed 'target' without the name of a target. */
221 target_command (arg
, from_tty
)
225 fputs_filtered ("Argument required (target name). Try `help target'\n",
229 /* Add a possible target architecture to the list. */
233 struct target_ops
*t
;
237 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
238 target_structs
= (struct target_ops
**) xmalloc
239 (target_struct_allocsize
* sizeof (*target_structs
));
241 if (target_struct_size
>= target_struct_allocsize
)
243 target_struct_allocsize
*= 2;
244 target_structs
= (struct target_ops
**)
245 xrealloc ((char *) target_structs
,
246 target_struct_allocsize
* sizeof (*target_structs
));
248 target_structs
[target_struct_size
++] = t
;
249 /* cleanup_target (t);*/
251 if (targetlist
== NULL
)
252 add_prefix_cmd ("target", class_run
, target_command
,
253 "Connect to a target machine or process.\n\
254 The first argument is the type or protocol of the target machine.\n\
255 Remaining arguments are interpreted by the target protocol. For more\n\
256 information on the arguments for a particular protocol, type\n\
257 `help target ' followed by the protocol name.",
258 &targetlist
, "target ", 0, &cmdlist
);
259 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
271 nomemory (memaddr
, myaddr
, len
, write
, t
)
276 struct target_ops
*t
;
278 errno
= EIO
; /* Can't read/write this location */
279 return 0; /* No bytes handled */
285 error ("You can't do that when your target is `%s'",
286 current_target
.to_shortname
);
292 error ("You can't do that without a process to debug.");
297 nosymbol (name
, addrp
)
301 return 1; /* Symbol does not exist in target env */
311 error ("No run-time support for this");
317 default_terminal_info (args
, from_tty
)
321 printf_unfiltered("No saved terminal information.\n");
324 /* This is the default target_create_inferior and target_attach function.
325 If the current target is executing, it asks whether to kill it off.
326 If this function returns without calling error(), it has killed off
327 the target, and the operation should be attempted. */
330 kill_or_be_killed (from_tty
)
333 if (target_has_execution
)
335 printf_unfiltered ("You are already running a program:\n");
336 target_files_info ();
337 if (query ("Kill it? ")) {
339 if (target_has_execution
)
340 error ("Killing the program did not help.");
343 error ("Program not killed.");
350 maybe_kill_then_attach (args
, from_tty
)
354 kill_or_be_killed (from_tty
);
355 target_attach (args
, from_tty
);
359 maybe_kill_then_create_inferior (exec
, args
, env
)
364 kill_or_be_killed (0);
365 target_create_inferior (exec
, args
, env
);
369 default_clone_and_follow_inferior (child_pid
, followed_child
)
373 target_clone_and_follow_inferior (child_pid
, followed_child
);
376 /* Clean up a target struct so it no longer has any zero pointers in it.
377 We default entries, at least to stubs that print error messages. */
381 struct target_ops
*t
;
384 #define de_fault(field, value) \
385 if (!t->field) t->field = value
387 /* FIELD DEFAULT VALUE */
389 de_fault (to_open
, (void (*) PARAMS((char *, int))) tcomplain
);
390 de_fault (to_close
, (void (*) PARAMS((int))) target_ignore
);
391 de_fault (to_attach
, maybe_kill_then_attach
);
392 de_fault (to_post_attach
, (void (*) PARAMS ((int))) target_ignore
);
393 de_fault (to_require_attach
, maybe_kill_then_attach
);
394 de_fault (to_detach
, (void (*) PARAMS((char *, int))) target_ignore
);
395 de_fault (to_require_detach
, (void (*) PARAMS((int, char *, int))) target_ignore
);
396 de_fault (to_resume
, (void (*) PARAMS((int, int, enum target_signal
))) noprocess
);
397 de_fault (to_wait
, (int (*) PARAMS((int, struct target_waitstatus
*))) noprocess
);
398 de_fault (to_post_wait
, (void (*) PARAMS ((int, int))) target_ignore
);
399 de_fault (to_fetch_registers
, (void (*) PARAMS((int))) target_ignore
);
400 de_fault (to_store_registers
, (void (*) PARAMS((int))) noprocess
);
401 de_fault (to_prepare_to_store
, (void (*) PARAMS((void))) noprocess
);
402 de_fault (to_xfer_memory
, (int (*) PARAMS((CORE_ADDR
, char *, int, int, struct target_ops
*))) nomemory
);
403 de_fault (to_files_info
, (void (*) PARAMS((struct target_ops
*))) target_ignore
);
404 de_fault (to_insert_breakpoint
, memory_insert_breakpoint
);
405 de_fault (to_remove_breakpoint
, memory_remove_breakpoint
);
406 de_fault (to_terminal_init
, (void (*) PARAMS((void))) target_ignore
);
407 de_fault (to_terminal_inferior
, (void (*) PARAMS ((void))) target_ignore
);
408 de_fault (to_terminal_ours_for_output
,(void (*) PARAMS ((void))) target_ignore
);
409 de_fault (to_terminal_ours
, (void (*) PARAMS ((void))) target_ignore
);
410 de_fault (to_terminal_info
, default_terminal_info
);
411 de_fault (to_kill
, (void (*) PARAMS((void))) noprocess
);
412 de_fault (to_load
, (void (*) PARAMS((char *, int))) tcomplain
);
413 de_fault (to_lookup_symbol
, (int (*) PARAMS ((char *, CORE_ADDR
*))) nosymbol
);
414 de_fault (to_create_inferior
, maybe_kill_then_create_inferior
);
415 de_fault (to_post_startup_inferior
, (void (*) PARAMS ((int))) target_ignore
);
416 de_fault (to_acknowledge_created_inferior
, (void (*) PARAMS((int))) target_ignore
);
417 de_fault (to_clone_and_follow_inferior
, default_clone_and_follow_inferior
);
418 de_fault (to_post_follow_inferior_by_clone
, (void (*) PARAMS ((void))) target_ignore
);
419 de_fault (to_insert_fork_catchpoint
, (int (*) PARAMS ((int))) tcomplain
);
420 de_fault (to_remove_fork_catchpoint
, (int (*) PARAMS ((int))) tcomplain
);
421 de_fault (to_insert_vfork_catchpoint
, (int (*) PARAMS ((int))) tcomplain
);
422 de_fault (to_remove_vfork_catchpoint
, (int (*) PARAMS ((int))) tcomplain
);
423 de_fault (to_has_forked
, (int (*) PARAMS ((int, int *))) return_zero
);
424 de_fault (to_has_vforked
, (int (*) PARAMS ((int, int *))) return_zero
);
425 de_fault (to_can_follow_vfork_prior_to_exec
, (int (*) PARAMS ((void ))) return_zero
);
426 de_fault (to_post_follow_vfork
, (void (*) PARAMS ((int, int, int, int))) target_ignore
);
427 de_fault (to_insert_exec_catchpoint
, (int (*) PARAMS ((int))) tcomplain
);
428 de_fault (to_remove_exec_catchpoint
, (int (*) PARAMS ((int))) tcomplain
);
429 de_fault (to_has_execd
, (int (*) PARAMS ((int, char **))) return_zero
);
430 de_fault (to_reported_exec_events_per_exec_call
, (int (*) PARAMS ((void))) return_one
);
431 de_fault (to_has_syscall_event
, (int (*) PARAMS ((int, enum target_waitkind
*, int *))) return_zero
);
432 de_fault (to_has_exited
, (int (*) PARAMS ((int, int, int *))) return_zero
);
433 de_fault (to_mourn_inferior
, (void (*) PARAMS ((void))) noprocess
);
434 de_fault (to_can_run
, return_zero
);
435 de_fault (to_notice_signals
, (void (*) PARAMS((int))) target_ignore
);
436 de_fault (to_thread_alive
, (int (*) PARAMS((int))) target_ignore
);
437 de_fault (to_stop
, (void (*) PARAMS((void))) target_ignore
);
438 de_fault (to_query
, (int (*) PARAMS((int/*char*/, char*, char *, int *))) target_ignore
);
439 de_fault (to_enable_exception_callback
, (struct symtab_and_line
* (*) PARAMS((enum exception_event_kind
, int))) nosupport_runtime
);
440 de_fault (to_get_current_exception_event
, (struct exception_event_record
* (*) PARAMS((void))) nosupport_runtime
);
442 de_fault (to_pid_to_exec_file
, (char* (*) PARAMS((int))) return_zero
);
443 de_fault (to_core_file_to_sym_file
, (char* (*) PARAMS ((char *))) return_zero
);
447 /* Go through the target stack from top to bottom, copying over zero entries in
448 current_target. In effect, we are doing class inheritance through the
449 pushed target vectors. */
452 update_current_target ()
454 struct target_stack_item
*item
;
455 struct target_ops
*t
;
457 /* First, reset current_target */
458 memset (¤t_target
, 0, sizeof current_target
);
460 for (item
= target_stack
; item
; item
= item
->next
)
462 t
= item
->target_ops
;
464 #define INHERIT(FIELD, TARGET) \
465 if (!current_target.FIELD) \
466 current_target.FIELD = TARGET->FIELD
468 INHERIT (to_shortname
, t
);
469 INHERIT (to_longname
, t
);
471 INHERIT (to_open
, t
);
472 INHERIT (to_close
, t
);
473 INHERIT (to_attach
, t
);
474 INHERIT (to_post_attach
, t
);
475 INHERIT (to_require_attach
, t
);
476 INHERIT (to_detach
, t
);
477 INHERIT (to_require_detach
, t
);
478 INHERIT (to_resume
, t
);
479 INHERIT (to_wait
, t
);
480 INHERIT (to_post_wait
, t
);
481 INHERIT (to_fetch_registers
, t
);
482 INHERIT (to_store_registers
, t
);
483 INHERIT (to_prepare_to_store
, t
);
484 INHERIT (to_xfer_memory
, t
);
485 INHERIT (to_files_info
, t
);
486 INHERIT (to_insert_breakpoint
, t
);
487 INHERIT (to_remove_breakpoint
, t
);
488 INHERIT (to_terminal_init
, t
);
489 INHERIT (to_terminal_inferior
, t
);
490 INHERIT (to_terminal_ours_for_output
, t
);
491 INHERIT (to_terminal_ours
, t
);
492 INHERIT (to_terminal_info
, t
);
493 INHERIT (to_kill
, t
);
494 INHERIT (to_load
, t
);
495 INHERIT (to_lookup_symbol
, t
);
496 INHERIT (to_create_inferior
, t
);
497 INHERIT (to_post_startup_inferior
, t
);
498 INHERIT (to_acknowledge_created_inferior
, t
);
499 INHERIT (to_clone_and_follow_inferior
, t
);
500 INHERIT (to_post_follow_inferior_by_clone
, t
);
501 INHERIT (to_insert_fork_catchpoint
, t
);
502 INHERIT (to_remove_fork_catchpoint
, t
);
503 INHERIT (to_insert_vfork_catchpoint
, t
);
504 INHERIT (to_remove_vfork_catchpoint
, t
);
505 INHERIT (to_has_forked
, t
);
506 INHERIT (to_has_vforked
, t
);
507 INHERIT (to_can_follow_vfork_prior_to_exec
, t
);
508 INHERIT (to_post_follow_vfork
, t
);
509 INHERIT (to_insert_exec_catchpoint
, t
);
510 INHERIT (to_remove_exec_catchpoint
, t
);
511 INHERIT (to_has_execd
, t
);
512 INHERIT (to_reported_exec_events_per_exec_call
, t
);
513 INHERIT (to_has_syscall_event
, t
);
514 INHERIT (to_has_exited
, t
);
515 INHERIT (to_mourn_inferior
, t
);
516 INHERIT (to_can_run
, t
);
517 INHERIT (to_notice_signals
, t
);
518 INHERIT (to_thread_alive
, t
);
519 INHERIT (to_find_new_threads
, t
);
520 INHERIT (to_stop
, t
);
521 INHERIT (to_query
, t
);
522 INHERIT (to_enable_exception_callback
, t
);
523 INHERIT (to_get_current_exception_event
, t
);
524 INHERIT (to_pid_to_exec_file
, t
);
525 INHERIT (to_core_file_to_sym_file
, t
);
526 INHERIT (to_stratum
, t
);
527 INHERIT (DONT_USE
, t
);
528 INHERIT (to_has_all_memory
, t
);
529 INHERIT (to_has_memory
, t
);
530 INHERIT (to_has_stack
, t
);
531 INHERIT (to_has_registers
, t
);
532 INHERIT (to_has_execution
, t
);
533 INHERIT (to_has_thread_control
, t
);
534 INHERIT (to_sections
, t
);
535 INHERIT (to_sections_end
, t
);
536 INHERIT (to_magic
, t
);
542 /* Push a new target type into the stack of the existing target accessors,
543 possibly superseding some of the existing accessors.
545 Result is zero if the pushed target ended up on top of the stack,
546 nonzero if at least one target is on top of it.
548 Rather than allow an empty stack, we always have the dummy target at
549 the bottom stratum, so we can call the function vectors without
554 struct target_ops
*t
;
556 struct target_stack_item
*cur
, *prev
, *tmp
;
558 /* Check magic number. If wrong, it probably means someone changed
559 the struct definition, but not all the places that initialize one. */
560 if (t
->to_magic
!= OPS_MAGIC
)
562 fprintf_unfiltered(gdb_stderr
,
563 "Magic number of %s target struct wrong\n",
568 /* Find the proper stratum to install this target in. */
570 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
572 if ((int)(t
->to_stratum
) >= (int)(cur
->target_ops
->to_stratum
))
576 /* If there's already targets at this stratum, remove them. */
579 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
581 /* There's already something on this stratum. Close it off. */
582 if (cur
->target_ops
->to_close
)
583 (cur
->target_ops
->to_close
) (0);
585 prev
->next
= cur
->next
; /* Unchain old target_ops */
587 target_stack
= cur
->next
; /* Unchain first on list */
593 /* We have removed all targets in our stratum, now add the new one. */
595 tmp
= (struct target_stack_item
*)
596 xmalloc (sizeof (struct target_stack_item
));
605 update_current_target ();
607 cleanup_target (¤t_target
); /* Fill in the gaps */
610 setup_target_debug ();
615 /* Remove a target_ops vector from the stack, wherever it may be.
616 Return how many times it was removed (0 or 1). */
620 struct target_ops
*t
;
622 struct target_stack_item
*cur
, *prev
;
625 t
->to_close (0); /* Let it clean up */
627 /* Look for the specified target. Note that we assume that a target
628 can only occur once in the target stack. */
630 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
631 if (cur
->target_ops
== t
)
635 return 0; /* Didn't find target_ops, quit now */
637 /* Unchain the target */
640 target_stack
= cur
->next
;
642 prev
->next
= cur
->next
;
644 free (cur
); /* Release the target_stack_item */
646 update_current_target ();
647 cleanup_target (¤t_target
);
655 (current_target
.to_close
)(0); /* Let it clean up */
656 if (unpush_target (target_stack
->target_ops
) == 1)
659 fprintf_unfiltered(gdb_stderr
,
660 "pop_target couldn't find target %s\n",
661 current_target
.to_shortname
);
666 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
668 /* target_read_string -- read a null terminated string, up to LEN bytes,
669 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
670 Set *STRING to a pointer to malloc'd memory containing the data; the caller
671 is responsible for freeing it. Return the number of bytes successfully
675 target_read_string (memaddr
, string
, len
, errnop
)
681 int tlen
, origlen
, offset
, i
;
685 int buffer_allocated
;
687 unsigned int nbytes_read
= 0;
689 /* Small for testing. */
690 buffer_allocated
= 4;
691 buffer
= xmalloc (buffer_allocated
);
698 tlen
= MIN (len
, 4 - (memaddr
& 3));
699 offset
= memaddr
& 3;
701 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0, NULL
);
704 /* The transfer request might have crossed the boundary to an
705 unallocated region of memory. Retry the transfer, requesting
709 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0, NULL
);
714 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
717 bytes
= bufptr
- buffer
;
718 buffer_allocated
*= 2;
719 buffer
= xrealloc (buffer
, buffer_allocated
);
720 bufptr
= buffer
+ bytes
;
723 for (i
= 0; i
< tlen
; i
++)
725 *bufptr
++ = buf
[i
+ offset
];
726 if (buf
[i
+ offset
] == '\000')
728 nbytes_read
+= i
+ 1;
745 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
746 GDB's memory at MYADDR. Returns either 0 for success or an errno value
749 If an error occurs, no guarantee is made about the contents of the data at
750 MYADDR. In particular, the caller should not depend upon partial reads
751 filling the buffer with good data. There is no way for the caller to know
752 how much good data might have been transfered anyway. Callers that can
753 deal with partial reads should call target_read_memory_partial. */
756 target_read_memory (memaddr
, myaddr
, len
)
761 return target_xfer_memory (memaddr
, myaddr
, len
, 0, NULL
);
765 target_read_memory_section (memaddr
, myaddr
, len
, bfd_section
)
769 asection
*bfd_section
;
771 return target_xfer_memory (memaddr
, myaddr
, len
, 0, bfd_section
);
774 /* Read LEN bytes of target memory at address MEMADDR, placing the results
775 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
776 and optionally an errno value in the location pointed to by ERRNOPTR
777 if ERRNOPTR is non-null. */
780 target_read_memory_partial (memaddr
, myaddr
, len
, errnoptr
)
786 int nread
; /* Number of bytes actually read. */
787 int errcode
; /* Error from last read. */
789 /* First try a complete read. */
790 errcode
= target_xfer_memory (memaddr
, myaddr
, len
, 0, NULL
);
798 /* Loop, reading one byte at a time until we get as much as we can. */
799 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
801 errcode
= target_xfer_memory (memaddr
++, myaddr
++, 1, 0, NULL
);
803 /* If an error, the last read was unsuccessful, so adjust count. */
809 if (errnoptr
!= NULL
)
817 target_write_memory (memaddr
, myaddr
, len
)
822 return target_xfer_memory (memaddr
, myaddr
, len
, 1, NULL
);
825 /* This variable is used to pass section information down to targets. This
826 *should* be done by adding an argument to the target_xfer_memory function
827 of all the targets, but I didn't feel like changing 50+ files. */
829 asection
*target_memory_bfd_section
= NULL
;
831 /* Move memory to or from the targets. Iterate until all of it has
832 been moved, if necessary. The top target gets priority; anything
833 it doesn't want, is offered to the next one down, etc. Note the
834 business with curlen: if an early target says "no, but I have a
835 boundary overlapping this xfer" then we shorten what we offer to
836 the subsequent targets so the early guy will get a chance at the
837 tail before the subsequent ones do.
839 Result is 0 or errno value. */
842 target_xfer_memory (memaddr
, myaddr
, len
, write
, bfd_section
)
847 asection
*bfd_section
;
851 struct target_ops
*t
;
852 struct target_stack_item
*item
;
854 /* Zero length requests are ok and require no work. */
858 target_memory_bfd_section
= bfd_section
;
860 /* to_xfer_memory is not guaranteed to set errno, even when it returns
864 /* The quick case is that the top target does it all. */
865 res
= current_target
.to_xfer_memory
866 (memaddr
, myaddr
, len
, write
, ¤t_target
);
872 /* If res <= 0 then we call it again in the loop. Ah well. */
876 curlen
= len
; /* Want to do it all */
877 for (item
= target_stack
; item
; item
= item
->next
)
879 t
= item
->target_ops
;
880 if (!t
->to_has_memory
)
883 res
= t
->to_xfer_memory (memaddr
, myaddr
, curlen
, write
, t
);
885 break; /* Handled all or part of xfer */
886 if (t
->to_has_all_memory
)
892 /* If this address is for nonexistent memory,
893 read zeros if reading, or do nothing if writing. Return error. */
895 memset (myaddr
, 0, len
);
906 return 0; /* We managed to cover it all somehow. */
912 target_info (args
, from_tty
)
916 struct target_ops
*t
;
917 struct target_stack_item
*item
;
920 if (symfile_objfile
!= NULL
)
921 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
923 #ifdef FILES_INFO_HOOK
924 if (FILES_INFO_HOOK ())
928 for (item
= target_stack
; item
; item
= item
->next
)
930 t
= item
->target_ops
;
932 if (!t
->to_has_memory
)
935 if ((int)(t
->to_stratum
) <= (int)dummy_stratum
)
938 printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
939 printf_unfiltered("%s:\n", t
->to_longname
);
940 (t
->to_files_info
)(t
);
941 has_all_mem
= t
->to_has_all_memory
;
945 /* This is to be called by the open routine before it does
949 target_preopen (from_tty
)
954 if (target_has_execution
)
956 if (query ("A program is being debugged already. Kill it? "))
959 error ("Program not killed.");
962 /* Calling target_kill may remove the target from the stack. But if
963 it doesn't (which seems like a win for UDI), remove it now. */
965 if (target_has_execution
)
969 /* Detach a target after doing deferred register stores. */
972 target_detach (args
, from_tty
)
976 /* Handle any optimized stores to the inferior. */
977 #ifdef DO_DEFERRED_STORES
980 (current_target
.to_detach
) (args
, from_tty
);
984 target_link (modname
, t_reloc
)
988 if (STREQ(current_target
.to_shortname
, "rombug"))
990 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
992 error("Unable to link to %s and get relocation in rombug", modname
);
995 *t_reloc
= (CORE_ADDR
)-1;
998 /* Look through the list of possible targets for a target that can
999 execute a run or attach command without any other data. This is
1000 used to locate the default process stratum.
1002 Result is always valid (error() is called for errors). */
1004 static struct target_ops
*
1005 find_default_run_target (do_mesg
)
1008 struct target_ops
**t
;
1009 struct target_ops
*runable
= NULL
;
1014 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1017 if ((*t
)->to_can_run
&& target_can_run(*t
))
1025 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1031 find_default_attach (args
, from_tty
)
1035 struct target_ops
*t
;
1037 t
= find_default_run_target("attach");
1038 (t
->to_attach
) (args
, from_tty
);
1043 find_default_require_attach (args
, from_tty
)
1047 struct target_ops
*t
;
1049 t
= find_default_run_target("require_attach");
1050 (t
->to_require_attach
) (args
, from_tty
);
1055 find_default_require_detach (pid
, args
, from_tty
)
1060 struct target_ops
*t
;
1062 t
= find_default_run_target("require_detach");
1063 (t
->to_require_detach
) (pid
, args
, from_tty
);
1068 find_default_create_inferior (exec_file
, allargs
, env
)
1073 struct target_ops
*t
;
1075 t
= find_default_run_target("run");
1076 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1081 find_default_clone_and_follow_inferior (child_pid
, followed_child
)
1083 int *followed_child
;
1085 struct target_ops
*t
;
1087 t
= find_default_run_target("run");
1088 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1104 /* Find a single runnable target in the stack and return it. If for
1105 some reason there is more than one, return NULL. */
1110 struct target_ops
**t
;
1111 struct target_ops
*runable
= NULL
;
1116 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1118 if ((*t
)->to_can_run
&& target_can_run(*t
))
1125 return (count
== 1 ? runable
: NULL
);
1131 struct target_ops
**t
;
1132 struct target_ops
*runable
= NULL
;
1137 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1140 if ((*t
)->to_stratum
== core_stratum
)
1147 return(count
== 1 ? runable
: NULL
);
1150 /* The inferior process has died. Long live the inferior! */
1153 generic_mourn_inferior ()
1155 extern int show_breakpoint_hit_counts
;
1159 breakpoint_init_inferior (inf_exited
);
1160 registers_changed ();
1162 #ifdef CLEAR_DEFERRED_STORES
1163 /* Delete any pending stores to the inferior... */
1164 CLEAR_DEFERRED_STORES
;
1167 reopen_exec_file ();
1168 reinit_frame_cache ();
1170 /* It is confusing to the user for ignore counts to stick around
1171 from previous runs of the inferior. So clear them. */
1172 /* However, it is more confusing for the ignore counts to disappear when
1173 using hit counts. So don't clear them if we're counting hits. */
1174 if (!show_breakpoint_hit_counts
)
1175 breakpoint_clear_ignore_counts ();
1178 /* This table must match in order and size the signals in enum target_signal
1186 {"SIGHUP", "Hangup"},
1187 {"SIGINT", "Interrupt"},
1188 {"SIGQUIT", "Quit"},
1189 {"SIGILL", "Illegal instruction"},
1190 {"SIGTRAP", "Trace/breakpoint trap"},
1191 {"SIGABRT", "Aborted"},
1192 {"SIGEMT", "Emulation trap"},
1193 {"SIGFPE", "Arithmetic exception"},
1194 {"SIGKILL", "Killed"},
1195 {"SIGBUS", "Bus error"},
1196 {"SIGSEGV", "Segmentation fault"},
1197 {"SIGSYS", "Bad system call"},
1198 {"SIGPIPE", "Broken pipe"},
1199 {"SIGALRM", "Alarm clock"},
1200 {"SIGTERM", "Terminated"},
1201 {"SIGURG", "Urgent I/O condition"},
1202 {"SIGSTOP", "Stopped (signal)"},
1203 {"SIGTSTP", "Stopped (user)"},
1204 {"SIGCONT", "Continued"},
1205 {"SIGCHLD", "Child status changed"},
1206 {"SIGTTIN", "Stopped (tty input)"},
1207 {"SIGTTOU", "Stopped (tty output)"},
1208 {"SIGIO", "I/O possible"},
1209 {"SIGXCPU", "CPU time limit exceeded"},
1210 {"SIGXFSZ", "File size limit exceeded"},
1211 {"SIGVTALRM", "Virtual timer expired"},
1212 {"SIGPROF", "Profiling timer expired"},
1213 {"SIGWINCH", "Window size changed"},
1214 {"SIGLOST", "Resource lost"},
1215 {"SIGUSR1", "User defined signal 1"},
1216 {"SIGUSR2", "User defined signal 2"},
1217 {"SIGPWR", "Power fail/restart"},
1218 {"SIGPOLL", "Pollable event occurred"},
1219 {"SIGWIND", "SIGWIND"},
1220 {"SIGPHONE", "SIGPHONE"},
1221 {"SIGWAITING", "Process's LWPs are blocked"},
1222 {"SIGLWP", "Signal LWP"},
1223 {"SIGDANGER", "Swap space dangerously low"},
1224 {"SIGGRANT", "Monitor mode granted"},
1225 {"SIGRETRACT", "Need to relinquish monitor mode"},
1226 {"SIGMSG", "Monitor mode data available"},
1227 {"SIGSOUND", "Sound completed"},
1228 {"SIGSAK", "Secure attention"},
1229 {"SIGPRIO", "SIGPRIO"},
1230 {"SIG33", "Real-time event 33"},
1231 {"SIG34", "Real-time event 34"},
1232 {"SIG35", "Real-time event 35"},
1233 {"SIG36", "Real-time event 36"},
1234 {"SIG37", "Real-time event 37"},
1235 {"SIG38", "Real-time event 38"},
1236 {"SIG39", "Real-time event 39"},
1237 {"SIG40", "Real-time event 40"},
1238 {"SIG41", "Real-time event 41"},
1239 {"SIG42", "Real-time event 42"},
1240 {"SIG43", "Real-time event 43"},
1241 {"SIG44", "Real-time event 44"},
1242 {"SIG45", "Real-time event 45"},
1243 {"SIG46", "Real-time event 46"},
1244 {"SIG47", "Real-time event 47"},
1245 {"SIG48", "Real-time event 48"},
1246 {"SIG49", "Real-time event 49"},
1247 {"SIG50", "Real-time event 50"},
1248 {"SIG51", "Real-time event 51"},
1249 {"SIG52", "Real-time event 52"},
1250 {"SIG53", "Real-time event 53"},
1251 {"SIG54", "Real-time event 54"},
1252 {"SIG55", "Real-time event 55"},
1253 {"SIG56", "Real-time event 56"},
1254 {"SIG57", "Real-time event 57"},
1255 {"SIG58", "Real-time event 58"},
1256 {"SIG59", "Real-time event 59"},
1257 {"SIG60", "Real-time event 60"},
1258 {"SIG61", "Real-time event 61"},
1259 {"SIG62", "Real-time event 62"},
1260 {"SIG63", "Real-time event 63"},
1262 #if defined(MACH) || defined(__MACH__)
1263 /* Mach exceptions */
1264 {"EXC_BAD_ACCESS", "Could not access memory"},
1265 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1266 {"EXC_ARITHMETIC", "Arithmetic exception"},
1267 {"EXC_EMULATION", "Emulation instruction"},
1268 {"EXC_SOFTWARE", "Software generated exception"},
1269 {"EXC_BREAKPOINT", "Breakpoint"},
1271 {"SIGINFO", "Information request"},
1273 {NULL
, "Unknown signal"},
1274 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1276 /* Last entry, used to check whether the table is the right size. */
1277 {NULL
, "TARGET_SIGNAL_MAGIC"}
1280 /* Return the string for a signal. */
1282 target_signal_to_string (sig
)
1283 enum target_signal sig
;
1285 if ((sig
>= TARGET_SIGNAL_FIRST
) && (sig
<= TARGET_SIGNAL_LAST
))
1286 return signals
[sig
].string
;
1288 return signals
[TARGET_SIGNAL_UNKNOWN
].string
;
1291 /* Return the name for a signal. */
1293 target_signal_to_name (sig
)
1294 enum target_signal sig
;
1296 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1297 /* I think the code which prints this will always print it along with
1298 the string, so no need to be verbose. */
1300 return signals
[sig
].name
;
1303 /* Given a name, return its signal. */
1305 target_signal_from_name (name
)
1308 enum target_signal sig
;
1310 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1311 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1312 questionable; seems like by now people should call it SIGABRT
1315 /* This ugly cast brought to you by the native VAX compiler. */
1316 for (sig
= TARGET_SIGNAL_HUP
;
1317 signals
[sig
].name
!= NULL
;
1318 sig
= (enum target_signal
)((int)sig
+ 1))
1319 if (STREQ (name
, signals
[sig
].name
))
1321 return TARGET_SIGNAL_UNKNOWN
;
1324 /* The following functions are to help certain targets deal
1325 with the signal/waitstatus stuff. They could just as well be in
1326 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1328 /* Convert host signal to our signals. */
1330 target_signal_from_host (hostsig
)
1333 /* A switch statement would make sense but would require special kludges
1334 to deal with the cases where more than one signal has the same number. */
1336 if (hostsig
== 0) return TARGET_SIGNAL_0
;
1338 #if defined (SIGHUP)
1339 if (hostsig
== SIGHUP
) return TARGET_SIGNAL_HUP
;
1341 #if defined (SIGINT)
1342 if (hostsig
== SIGINT
) return TARGET_SIGNAL_INT
;
1344 #if defined (SIGQUIT)
1345 if (hostsig
== SIGQUIT
) return TARGET_SIGNAL_QUIT
;
1347 #if defined (SIGILL)
1348 if (hostsig
== SIGILL
) return TARGET_SIGNAL_ILL
;
1350 #if defined (SIGTRAP)
1351 if (hostsig
== SIGTRAP
) return TARGET_SIGNAL_TRAP
;
1353 #if defined (SIGABRT)
1354 if (hostsig
== SIGABRT
) return TARGET_SIGNAL_ABRT
;
1356 #if defined (SIGEMT)
1357 if (hostsig
== SIGEMT
) return TARGET_SIGNAL_EMT
;
1359 #if defined (SIGFPE)
1360 if (hostsig
== SIGFPE
) return TARGET_SIGNAL_FPE
;
1362 #if defined (SIGKILL)
1363 if (hostsig
== SIGKILL
) return TARGET_SIGNAL_KILL
;
1365 #if defined (SIGBUS)
1366 if (hostsig
== SIGBUS
) return TARGET_SIGNAL_BUS
;
1368 #if defined (SIGSEGV)
1369 if (hostsig
== SIGSEGV
) return TARGET_SIGNAL_SEGV
;
1371 #if defined (SIGSYS)
1372 if (hostsig
== SIGSYS
) return TARGET_SIGNAL_SYS
;
1374 #if defined (SIGPIPE)
1375 if (hostsig
== SIGPIPE
) return TARGET_SIGNAL_PIPE
;
1377 #if defined (SIGALRM)
1378 if (hostsig
== SIGALRM
) return TARGET_SIGNAL_ALRM
;
1380 #if defined (SIGTERM)
1381 if (hostsig
== SIGTERM
) return TARGET_SIGNAL_TERM
;
1383 #if defined (SIGUSR1)
1384 if (hostsig
== SIGUSR1
) return TARGET_SIGNAL_USR1
;
1386 #if defined (SIGUSR2)
1387 if (hostsig
== SIGUSR2
) return TARGET_SIGNAL_USR2
;
1389 #if defined (SIGCLD)
1390 if (hostsig
== SIGCLD
) return TARGET_SIGNAL_CHLD
;
1392 #if defined (SIGCHLD)
1393 if (hostsig
== SIGCHLD
) return TARGET_SIGNAL_CHLD
;
1395 #if defined (SIGPWR)
1396 if (hostsig
== SIGPWR
) return TARGET_SIGNAL_PWR
;
1398 #if defined (SIGWINCH)
1399 if (hostsig
== SIGWINCH
) return TARGET_SIGNAL_WINCH
;
1401 #if defined (SIGURG)
1402 if (hostsig
== SIGURG
) return TARGET_SIGNAL_URG
;
1405 if (hostsig
== SIGIO
) return TARGET_SIGNAL_IO
;
1407 #if defined (SIGPOLL)
1408 if (hostsig
== SIGPOLL
) return TARGET_SIGNAL_POLL
;
1410 #if defined (SIGSTOP)
1411 if (hostsig
== SIGSTOP
) return TARGET_SIGNAL_STOP
;
1413 #if defined (SIGTSTP)
1414 if (hostsig
== SIGTSTP
) return TARGET_SIGNAL_TSTP
;
1416 #if defined (SIGCONT)
1417 if (hostsig
== SIGCONT
) return TARGET_SIGNAL_CONT
;
1419 #if defined (SIGTTIN)
1420 if (hostsig
== SIGTTIN
) return TARGET_SIGNAL_TTIN
;
1422 #if defined (SIGTTOU)
1423 if (hostsig
== SIGTTOU
) return TARGET_SIGNAL_TTOU
;
1425 #if defined (SIGVTALRM)
1426 if (hostsig
== SIGVTALRM
) return TARGET_SIGNAL_VTALRM
;
1428 #if defined (SIGPROF)
1429 if (hostsig
== SIGPROF
) return TARGET_SIGNAL_PROF
;
1431 #if defined (SIGXCPU)
1432 if (hostsig
== SIGXCPU
) return TARGET_SIGNAL_XCPU
;
1434 #if defined (SIGXFSZ)
1435 if (hostsig
== SIGXFSZ
) return TARGET_SIGNAL_XFSZ
;
1437 #if defined (SIGWIND)
1438 if (hostsig
== SIGWIND
) return TARGET_SIGNAL_WIND
;
1440 #if defined (SIGPHONE)
1441 if (hostsig
== SIGPHONE
) return TARGET_SIGNAL_PHONE
;
1443 #if defined (SIGLOST)
1444 if (hostsig
== SIGLOST
) return TARGET_SIGNAL_LOST
;
1446 #if defined (SIGWAITING)
1447 if (hostsig
== SIGWAITING
) return TARGET_SIGNAL_WAITING
;
1449 #if defined (SIGLWP)
1450 if (hostsig
== SIGLWP
) return TARGET_SIGNAL_LWP
;
1452 #if defined (SIGDANGER)
1453 if (hostsig
== SIGDANGER
) return TARGET_SIGNAL_DANGER
;
1455 #if defined (SIGGRANT)
1456 if (hostsig
== SIGGRANT
) return TARGET_SIGNAL_GRANT
;
1458 #if defined (SIGRETRACT)
1459 if (hostsig
== SIGRETRACT
) return TARGET_SIGNAL_RETRACT
;
1461 #if defined (SIGMSG)
1462 if (hostsig
== SIGMSG
) return TARGET_SIGNAL_MSG
;
1464 #if defined (SIGSOUND)
1465 if (hostsig
== SIGSOUND
) return TARGET_SIGNAL_SOUND
;
1467 #if defined (SIGSAK)
1468 if (hostsig
== SIGSAK
) return TARGET_SIGNAL_SAK
;
1470 #if defined (SIGPRIO)
1471 if (hostsig
== SIGPRIO
) return TARGET_SIGNAL_PRIO
;
1474 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1475 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1476 if (hostsig
== _NSIG
+ EXC_BAD_ACCESS
) return TARGET_EXC_BAD_ACCESS
;
1478 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1479 if (hostsig
== _NSIG
+ EXC_BAD_INSTRUCTION
) return TARGET_EXC_BAD_INSTRUCTION
;
1481 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1482 if (hostsig
== _NSIG
+ EXC_ARITHMETIC
) return TARGET_EXC_ARITHMETIC
;
1484 #if defined (EXC_EMULATION) && defined (_NSIG)
1485 if (hostsig
== _NSIG
+ EXC_EMULATION
) return TARGET_EXC_EMULATION
;
1487 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1488 if (hostsig
== _NSIG
+ EXC_SOFTWARE
) return TARGET_EXC_SOFTWARE
;
1490 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1491 if (hostsig
== _NSIG
+ EXC_BREAKPOINT
) return TARGET_EXC_BREAKPOINT
;
1494 #if defined (SIGINFO)
1495 if (hostsig
== SIGINFO
) return TARGET_SIGNAL_INFO
;
1498 #if defined (REALTIME_LO)
1499 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1500 return (enum target_signal
)
1501 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1503 return TARGET_SIGNAL_UNKNOWN
;
1507 target_signal_to_host (oursig
)
1508 enum target_signal oursig
;
1512 case TARGET_SIGNAL_0
: return 0;
1514 #if defined (SIGHUP)
1515 case TARGET_SIGNAL_HUP
: return SIGHUP
;
1517 #if defined (SIGINT)
1518 case TARGET_SIGNAL_INT
: return SIGINT
;
1520 #if defined (SIGQUIT)
1521 case TARGET_SIGNAL_QUIT
: return SIGQUIT
;
1523 #if defined (SIGILL)
1524 case TARGET_SIGNAL_ILL
: return SIGILL
;
1526 #if defined (SIGTRAP)
1527 case TARGET_SIGNAL_TRAP
: return SIGTRAP
;
1529 #if defined (SIGABRT)
1530 case TARGET_SIGNAL_ABRT
: return SIGABRT
;
1532 #if defined (SIGEMT)
1533 case TARGET_SIGNAL_EMT
: return SIGEMT
;
1535 #if defined (SIGFPE)
1536 case TARGET_SIGNAL_FPE
: return SIGFPE
;
1538 #if defined (SIGKILL)
1539 case TARGET_SIGNAL_KILL
: return SIGKILL
;
1541 #if defined (SIGBUS)
1542 case TARGET_SIGNAL_BUS
: return SIGBUS
;
1544 #if defined (SIGSEGV)
1545 case TARGET_SIGNAL_SEGV
: return SIGSEGV
;
1547 #if defined (SIGSYS)
1548 case TARGET_SIGNAL_SYS
: return SIGSYS
;
1550 #if defined (SIGPIPE)
1551 case TARGET_SIGNAL_PIPE
: return SIGPIPE
;
1553 #if defined (SIGALRM)
1554 case TARGET_SIGNAL_ALRM
: return SIGALRM
;
1556 #if defined (SIGTERM)
1557 case TARGET_SIGNAL_TERM
: return SIGTERM
;
1559 #if defined (SIGUSR1)
1560 case TARGET_SIGNAL_USR1
: return SIGUSR1
;
1562 #if defined (SIGUSR2)
1563 case TARGET_SIGNAL_USR2
: return SIGUSR2
;
1565 #if defined (SIGCHLD) || defined (SIGCLD)
1566 case TARGET_SIGNAL_CHLD
:
1567 #if defined (SIGCHLD)
1572 #endif /* SIGCLD or SIGCHLD */
1573 #if defined (SIGPWR)
1574 case TARGET_SIGNAL_PWR
: return SIGPWR
;
1576 #if defined (SIGWINCH)
1577 case TARGET_SIGNAL_WINCH
: return SIGWINCH
;
1579 #if defined (SIGURG)
1580 case TARGET_SIGNAL_URG
: return SIGURG
;
1583 case TARGET_SIGNAL_IO
: return SIGIO
;
1585 #if defined (SIGPOLL)
1586 case TARGET_SIGNAL_POLL
: return SIGPOLL
;
1588 #if defined (SIGSTOP)
1589 case TARGET_SIGNAL_STOP
: return SIGSTOP
;
1591 #if defined (SIGTSTP)
1592 case TARGET_SIGNAL_TSTP
: return SIGTSTP
;
1594 #if defined (SIGCONT)
1595 case TARGET_SIGNAL_CONT
: return SIGCONT
;
1597 #if defined (SIGTTIN)
1598 case TARGET_SIGNAL_TTIN
: return SIGTTIN
;
1600 #if defined (SIGTTOU)
1601 case TARGET_SIGNAL_TTOU
: return SIGTTOU
;
1603 #if defined (SIGVTALRM)
1604 case TARGET_SIGNAL_VTALRM
: return SIGVTALRM
;
1606 #if defined (SIGPROF)
1607 case TARGET_SIGNAL_PROF
: return SIGPROF
;
1609 #if defined (SIGXCPU)
1610 case TARGET_SIGNAL_XCPU
: return SIGXCPU
;
1612 #if defined (SIGXFSZ)
1613 case TARGET_SIGNAL_XFSZ
: return SIGXFSZ
;
1615 #if defined (SIGWIND)
1616 case TARGET_SIGNAL_WIND
: return SIGWIND
;
1618 #if defined (SIGPHONE)
1619 case TARGET_SIGNAL_PHONE
: return SIGPHONE
;
1621 #if defined (SIGLOST)
1622 case TARGET_SIGNAL_LOST
: return SIGLOST
;
1624 #if defined (SIGWAITING)
1625 case TARGET_SIGNAL_WAITING
: return SIGWAITING
;
1627 #if defined (SIGLWP)
1628 case TARGET_SIGNAL_LWP
: return SIGLWP
;
1630 #if defined (SIGDANGER)
1631 case TARGET_SIGNAL_DANGER
: return SIGDANGER
;
1633 #if defined (SIGGRANT)
1634 case TARGET_SIGNAL_GRANT
: return SIGGRANT
;
1636 #if defined (SIGRETRACT)
1637 case TARGET_SIGNAL_RETRACT
: return SIGRETRACT
;
1639 #if defined (SIGMSG)
1640 case TARGET_SIGNAL_MSG
: return SIGMSG
;
1642 #if defined (SIGSOUND)
1643 case TARGET_SIGNAL_SOUND
: return SIGSOUND
;
1645 #if defined (SIGSAK)
1646 case TARGET_SIGNAL_SAK
: return SIGSAK
;
1648 #if defined (SIGPRIO)
1649 case TARGET_SIGNAL_PRIO
: return SIGPRIO
;
1652 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1653 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1654 case TARGET_EXC_BAD_ACCESS
: return _NSIG
+ EXC_BAD_ACCESS
;
1656 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1657 case TARGET_EXC_BAD_INSTRUCTION
: return _NSIG
+ EXC_BAD_INSTRUCTION
;
1659 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1660 case TARGET_EXC_ARITHMETIC
: return _NSIG
+ EXC_ARITHMETIC
;
1662 #if defined (EXC_EMULATION) && defined (_NSIG)
1663 case TARGET_EXC_EMULATION
: return _NSIG
+ EXC_EMULATION
;
1665 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1666 case TARGET_EXC_SOFTWARE
: return _NSIG
+ EXC_SOFTWARE
;
1668 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1669 case TARGET_EXC_BREAKPOINT
: return _NSIG
+ EXC_BREAKPOINT
;
1672 #if defined (SIGINFO)
1673 case TARGET_SIGNAL_INFO
: return SIGINFO
;
1677 #if defined (REALTIME_LO)
1678 if (oursig
>= TARGET_SIGNAL_REALTIME_33
1679 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
1682 (int)oursig
- (int)TARGET_SIGNAL_REALTIME_33
+ REALTIME_LO
;
1683 if (retsig
< REALTIME_HI
)
1687 /* The user might be trying to do "signal SIGSAK" where this system
1688 doesn't have SIGSAK. */
1689 warning ("Signal %s does not exist on this system.\n",
1690 target_signal_to_name (oursig
));
1695 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1696 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1697 translation of that in OURSTATUS. */
1699 store_waitstatus (ourstatus
, hoststatus
)
1700 struct target_waitstatus
*ourstatus
;
1703 #ifdef CHILD_SPECIAL_WAITSTATUS
1704 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1705 if it wants to deal with hoststatus. */
1706 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1710 if (WIFEXITED (hoststatus
))
1712 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1713 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1715 else if (!WIFSTOPPED (hoststatus
))
1717 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1718 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1722 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1723 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1727 /* In some circumstances we allow a command to specify a numeric
1728 signal. The idea is to keep these circumstances limited so that
1729 users (and scripts) develop portable habits. For comparison,
1730 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1731 numeric signal at all is obscelescent. We are slightly more
1732 lenient and allow 1-15 which should match host signal numbers on
1733 most systems. Use of symbolic signal names is strongly encouraged. */
1736 target_signal_from_command (num
)
1739 if (num
>= 1 && num
<= 15)
1740 return (enum target_signal
)num
;
1741 error ("Only signals 1-15 are valid as numeric signals.\n\
1742 Use \"info signals\" for a list of symbolic signals.");
1745 /* Returns zero to leave the inferior alone, one to interrupt it. */
1746 int (*target_activity_function
) PARAMS ((void));
1747 int target_activity_fd
;
1749 /* Convert a normal process ID to a string. Returns the string in a static
1753 normal_pid_to_str (pid
)
1756 static char buf
[30];
1758 if (STREQ (current_target
.to_shortname
, "remote"))
1759 sprintf (buf
, "thread %d\0", pid
);
1761 sprintf (buf
, "process %d\0", pid
);
1766 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1767 notification of inferior events such as fork and vork immediately
1768 after the inferior is created. (This because of how gdb gets an
1769 inferior created via invoking a shell to do it. In such a scenario,
1770 if the shell init file has commands in it, the shell will fork and
1771 exec for each of those commands, and we will see each such fork
1774 This function is used by all targets that allow us to request
1775 notification of forks, etc at inferior creation time; e.g., in
1776 target_acknowledge_forked_child.
1779 normal_target_post_startup_inferior (pid
)
1782 /* This space intentionally left blank. */
1785 /* Set up the handful of non-empty slots needed by the dummy target
1789 init_dummy_target ()
1791 dummy_target
.to_shortname
= "None";
1792 dummy_target
.to_longname
= "None";
1793 dummy_target
.to_doc
= "";
1794 dummy_target
.to_attach
= find_default_attach
;
1795 dummy_target
.to_require_attach
= find_default_require_attach
;
1796 dummy_target
.to_require_detach
= find_default_require_detach
;
1797 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1798 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
1799 dummy_target
.to_stratum
= dummy_stratum
;
1800 dummy_target
.to_magic
= OPS_MAGIC
;
1804 static struct target_ops debug_target
;
1807 debug_to_open (args
, from_tty
)
1811 debug_target
.to_open (args
, from_tty
);
1813 fprintf_unfiltered (gdb_stderr
, "target_open (%s, %d)\n", args
, from_tty
);
1817 debug_to_close (quitting
)
1820 debug_target
.to_close (quitting
);
1822 fprintf_unfiltered (gdb_stderr
, "target_close (%d)\n", quitting
);
1826 debug_to_attach (args
, from_tty
)
1830 debug_target
.to_attach (args
, from_tty
);
1832 fprintf_unfiltered (gdb_stderr
, "target_attach (%s, %d)\n", args
, from_tty
);
1837 debug_to_post_attach (pid
)
1840 debug_target
.to_post_attach (pid
);
1842 fprintf_unfiltered (gdb_stderr
, "target_post_attach (%d)\n", pid
);
1846 debug_to_require_attach (args
, from_tty
)
1850 debug_target
.to_require_attach (args
, from_tty
);
1852 fprintf_unfiltered (gdb_stderr
,
1853 "target_require_attach (%s, %d)\n", args
, from_tty
);
1857 debug_to_detach (args
, from_tty
)
1861 debug_target
.to_detach (args
, from_tty
);
1863 fprintf_unfiltered (gdb_stderr
, "target_detach (%s, %d)\n", args
, from_tty
);
1867 debug_to_require_detach (pid
, args
, from_tty
)
1872 debug_target
.to_require_detach (pid
, args
, from_tty
);
1874 fprintf_unfiltered (gdb_stderr
,
1875 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
1879 debug_to_resume (pid
, step
, siggnal
)
1882 enum target_signal siggnal
;
1884 debug_target
.to_resume (pid
, step
, siggnal
);
1886 fprintf_unfiltered (gdb_stderr
, "target_resume (%d, %s, %s)\n", pid
,
1887 step
? "step" : "continue",
1888 target_signal_to_name (siggnal
));
1892 debug_to_wait (pid
, status
)
1894 struct target_waitstatus
*status
;
1898 retval
= debug_target
.to_wait (pid
, status
);
1900 fprintf_unfiltered (gdb_stderr
,
1901 "target_wait (%d, status) = %d, ", pid
, retval
);
1902 fprintf_unfiltered (gdb_stderr
, "status->kind = ");
1903 switch (status
->kind
)
1905 case TARGET_WAITKIND_EXITED
:
1906 fprintf_unfiltered (gdb_stderr
, "exited, status = %d\n",
1907 status
->value
.integer
);
1909 case TARGET_WAITKIND_STOPPED
:
1910 fprintf_unfiltered (gdb_stderr
, "stopped, signal = %s\n",
1911 target_signal_to_name (status
->value
.sig
));
1913 case TARGET_WAITKIND_SIGNALLED
:
1914 fprintf_unfiltered (gdb_stderr
, "signalled, signal = %s\n",
1915 target_signal_to_name (status
->value
.sig
));
1917 case TARGET_WAITKIND_LOADED
:
1918 fprintf_unfiltered (gdb_stderr
, "loaded\n");
1920 case TARGET_WAITKIND_FORKED
:
1921 fprintf_unfiltered (gdb_stderr
, "forked\n");
1923 case TARGET_WAITKIND_VFORKED
:
1924 fprintf_unfiltered (gdb_stderr
, "vforked\n");
1926 case TARGET_WAITKIND_EXECD
:
1927 fprintf_unfiltered (gdb_stderr
, "execd\n");
1929 case TARGET_WAITKIND_SPURIOUS
:
1930 fprintf_unfiltered (gdb_stderr
, "spurious\n");
1933 fprintf_unfiltered (gdb_stderr
, "unknown???\n");
1941 debug_to_post_wait (pid
, status
)
1945 debug_target
.to_post_wait (pid
, status
);
1947 fprintf_unfiltered (gdb_stderr
, "target_post_wait (%d, %d)\n",
1952 debug_to_fetch_registers (regno
)
1955 debug_target
.to_fetch_registers (regno
);
1957 fprintf_unfiltered (gdb_stderr
, "target_fetch_registers (%s)",
1958 regno
!= -1 ? REGISTER_NAME (regno
) : "-1");
1960 fprintf_unfiltered (gdb_stderr
, " = 0x%x %d",
1961 (unsigned long) read_register (regno
),
1962 read_register (regno
));
1963 fprintf_unfiltered (gdb_stderr
, "\n");
1967 debug_to_store_registers (regno
)
1970 debug_target
.to_store_registers (regno
);
1972 if (regno
>= 0 && regno
< NUM_REGS
)
1973 fprintf_unfiltered (gdb_stderr
, "target_store_registers (%s) = 0x%x %d\n",
1974 REGISTER_NAME (regno
),
1975 (unsigned long) read_register (regno
),
1976 (unsigned long) read_register (regno
));
1978 fprintf_unfiltered (gdb_stderr
, "target_store_registers (%d)\n", regno
);
1982 debug_to_prepare_to_store ()
1984 debug_target
.to_prepare_to_store ();
1986 fprintf_unfiltered (gdb_stderr
, "target_prepare_to_store ()\n");
1990 debug_to_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1995 struct target_ops
*target
;
1999 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
2001 fprintf_unfiltered (gdb_stderr
,
2002 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2003 (unsigned int) memaddr
, /* possable truncate long long */
2004 len
, write
? "write" : "read", retval
);
2012 fputs_unfiltered (", bytes =", gdb_stderr
);
2013 for (i
= 0; i
< retval
; i
++)
2015 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2016 fprintf_unfiltered (gdb_stderr
, "\n");
2017 fprintf_unfiltered (gdb_stderr
, " %02x", myaddr
[i
] & 0xff);
2021 fputc_unfiltered ('\n', gdb_stderr
);
2027 debug_to_files_info (target
)
2028 struct target_ops
*target
;
2030 debug_target
.to_files_info (target
);
2032 fprintf_unfiltered (gdb_stderr
, "target_files_info (xxx)\n");
2036 debug_to_insert_breakpoint (addr
, save
)
2042 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2044 fprintf_unfiltered (gdb_stderr
,
2045 "target_insert_breakpoint (0x%x, xxx) = %d\n",
2046 (unsigned long) addr
, retval
);
2051 debug_to_remove_breakpoint (addr
, save
)
2057 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2059 fprintf_unfiltered (gdb_stderr
,
2060 "target_remove_breakpoint (0x%x, xxx) = %d\n",
2061 (unsigned long)addr
, retval
);
2066 debug_to_terminal_init ()
2068 debug_target
.to_terminal_init ();
2070 fprintf_unfiltered (gdb_stderr
, "target_terminal_init ()\n");
2074 debug_to_terminal_inferior ()
2076 debug_target
.to_terminal_inferior ();
2078 fprintf_unfiltered (gdb_stderr
, "target_terminal_inferior ()\n");
2082 debug_to_terminal_ours_for_output ()
2084 debug_target
.to_terminal_ours_for_output ();
2086 fprintf_unfiltered (gdb_stderr
, "target_terminal_ours_for_output ()\n");
2090 debug_to_terminal_ours ()
2092 debug_target
.to_terminal_ours ();
2094 fprintf_unfiltered (gdb_stderr
, "target_terminal_ours ()\n");
2098 debug_to_terminal_info (arg
, from_tty
)
2102 debug_target
.to_terminal_info (arg
, from_tty
);
2104 fprintf_unfiltered (gdb_stderr
, "target_terminal_info (%s, %d)\n", arg
,
2111 debug_target
.to_kill ();
2113 fprintf_unfiltered (gdb_stderr
, "target_kill ()\n");
2117 debug_to_load (args
, from_tty
)
2121 debug_target
.to_load (args
, from_tty
);
2123 fprintf_unfiltered (gdb_stderr
, "target_load (%s, %d)\n", args
, from_tty
);
2127 debug_to_lookup_symbol (name
, addrp
)
2133 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2135 fprintf_unfiltered (gdb_stderr
, "target_lookup_symbol (%s, xxx)\n", name
);
2141 debug_to_create_inferior (exec_file
, args
, env
)
2146 debug_target
.to_create_inferior (exec_file
, args
, env
);
2148 fprintf_unfiltered (gdb_stderr
, "target_create_inferior (%s, %s, xxx)\n",
2153 debug_to_post_startup_inferior (pid
)
2156 debug_target
.to_post_startup_inferior (pid
);
2158 fprintf_unfiltered (gdb_stderr
, "target_post_startup_inferior (%d)\n",
2163 debug_to_acknowledge_created_inferior (pid
)
2166 debug_target
.to_acknowledge_created_inferior (pid
);
2168 fprintf_unfiltered (gdb_stderr
, "target_acknowledge_created_inferior (%d)\n",
2173 debug_to_clone_and_follow_inferior (child_pid
, followed_child
)
2175 int *followed_child
;
2177 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
2179 fprintf_unfiltered (gdb_stderr
,
2180 "target_clone_and_follow_inferior (%d, %d)\n",
2181 child_pid
, *followed_child
);
2185 debug_to_post_follow_inferior_by_clone ()
2187 debug_target
.to_post_follow_inferior_by_clone ();
2189 fprintf_unfiltered (gdb_stderr
, "target_post_follow_inferior_by_clone ()\n");
2193 debug_to_insert_fork_catchpoint (pid
)
2198 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2200 fprintf_unfiltered (gdb_stderr
, "target_insert_fork_catchpoint (%d) = %d\n",
2207 debug_to_remove_fork_catchpoint (pid
)
2212 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2214 fprintf_unfiltered (gdb_stderr
, "target_remove_fork_catchpoint (%d) = %d\n",
2221 debug_to_insert_vfork_catchpoint (pid
)
2226 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2228 fprintf_unfiltered (gdb_stderr
, "target_insert_vfork_catchpoint (%d)= %d\n",
2235 debug_to_remove_vfork_catchpoint (pid
)
2240 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2242 fprintf_unfiltered (gdb_stderr
, "target_remove_vfork_catchpoint (%d) = %d\n",
2249 debug_to_has_forked (pid
, child_pid
)
2255 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
2257 fprintf_unfiltered (gdb_stderr
, "target_has_forked (%d, %d) = %d\n",
2258 pid
, *child_pid
, has_forked
);
2264 debug_to_has_vforked (pid
, child_pid
)
2270 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
2272 fprintf_unfiltered (gdb_stderr
, "target_has_vforked (%d, %d) = %d\n",
2273 pid
, *child_pid
, has_vforked
);
2279 debug_to_can_follow_vfork_prior_to_exec ()
2281 int can_immediately_follow_vfork
;
2283 can_immediately_follow_vfork
= debug_target
.to_can_follow_vfork_prior_to_exec ();
2285 fprintf_unfiltered (gdb_stderr
, "target_can_follow_vfork_prior_to_exec () = %d\n",
2286 can_immediately_follow_vfork
);
2288 return can_immediately_follow_vfork
;
2292 debug_to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
)
2294 int followed_parent
;
2298 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
2300 fprintf_unfiltered (gdb_stderr
,
2301 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2302 parent_pid
, followed_parent
, child_pid
, followed_child
);
2306 debug_to_insert_exec_catchpoint (pid
)
2311 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2313 fprintf_unfiltered (gdb_stderr
, "target_insert_exec_catchpoint (%d) = %d\n",
2320 debug_to_remove_exec_catchpoint (pid
)
2325 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2327 fprintf_unfiltered (gdb_stderr
, "target_remove_exec_catchpoint (%d) = %d\n",
2334 debug_to_has_execd (pid
, execd_pathname
)
2336 char ** execd_pathname
;
2340 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2342 fprintf_unfiltered (gdb_stderr
, "target_has_execd (%d, %s) = %d\n",
2343 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
2350 debug_to_reported_exec_events_per_exec_call ()
2352 int reported_exec_events
;
2354 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2356 fprintf_unfiltered (gdb_stderr
,
2357 "target_reported_exec_events_per_exec_call () = %d\n",
2358 reported_exec_events
);
2360 return reported_exec_events
;
2364 debug_to_has_syscall_event (pid
, kind
, syscall_id
)
2366 enum target_waitkind
* kind
;
2369 int has_syscall_event
;
2370 char * kind_spelling
= "??";
2372 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2373 if (has_syscall_event
)
2377 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2378 kind_spelling
= "SYSCALL_ENTRY";
2380 case TARGET_WAITKIND_SYSCALL_RETURN
:
2381 kind_spelling
= "SYSCALL_RETURN";
2388 fprintf_unfiltered (gdb_stderr
,
2389 "target_has_syscall_event (%d, %s, %d) = %d\n",
2390 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2392 return has_syscall_event
;
2396 debug_to_has_exited (pid
, wait_status
, exit_status
)
2403 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2405 fprintf_unfiltered (gdb_stderr
, "target_has_exited (%d, %d, %d) = %d\n",
2406 pid
, wait_status
, *exit_status
, has_exited
);
2412 debug_to_mourn_inferior ()
2414 debug_target
.to_mourn_inferior ();
2416 fprintf_unfiltered (gdb_stderr
, "target_mourn_inferior ()\n");
2424 retval
= debug_target
.to_can_run ();
2426 fprintf_unfiltered (gdb_stderr
, "target_can_run () = %d\n", retval
);
2432 debug_to_notice_signals (pid
)
2435 debug_target
.to_notice_signals (pid
);
2437 fprintf_unfiltered (gdb_stderr
, "target_notice_signals (%d)\n", pid
);
2441 debug_to_thread_alive (pid
)
2446 retval
= debug_target
.to_thread_alive (pid
);
2448 fprintf_unfiltered (gdb_stderr
, "target_thread_alive (%d) = %d\n",
2457 debug_target
.to_stop ();
2459 fprintf_unfiltered (gdb_stderr
, "target_stop ()\n");
2463 debug_to_query (type
, req
, resp
, siz
)
2471 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2473 fprintf_unfiltered (gdb_stderr
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2478 static struct symtab_and_line
*
2479 debug_to_enable_exception_callback (kind
, enable
)
2480 enum exception_event_kind kind
;
2483 struct symtab_and_line
*result
;
2484 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2485 fprintf_unfiltered (gdb_stderr
,
2486 "target get_exception_callback_sal (%d, %d)\n",
2491 static struct exception_event_record
*
2492 debug_to_get_current_exception_event ()
2494 struct exception_event_record
*result
;
2495 result
= debug_target
.to_get_current_exception_event();
2496 fprintf_unfiltered (gdb_stderr
, "target get_current_exception_event ()\n");
2501 debug_to_pid_to_exec_file (pid
)
2506 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2508 fprintf_unfiltered (gdb_stderr
, "target_pid_to_exec_file (%d) = %s\n",
2515 debug_to_core_file_to_sym_file (core
)
2520 sym_file
= debug_target
.to_core_file_to_sym_file (core
);
2522 fprintf_unfiltered (gdb_stderr
, "target_core_file_to_sym_file (%s) = %s\n",
2529 setup_target_debug ()
2531 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2533 current_target
.to_open
= debug_to_open
;
2534 current_target
.to_close
= debug_to_close
;
2535 current_target
.to_attach
= debug_to_attach
;
2536 current_target
.to_post_attach
= debug_to_post_attach
;
2537 current_target
.to_require_attach
= debug_to_require_attach
;
2538 current_target
.to_detach
= debug_to_detach
;
2539 current_target
.to_require_detach
= debug_to_require_detach
;
2540 current_target
.to_resume
= debug_to_resume
;
2541 current_target
.to_wait
= debug_to_wait
;
2542 current_target
.to_post_wait
= debug_to_post_wait
;
2543 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2544 current_target
.to_store_registers
= debug_to_store_registers
;
2545 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2546 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2547 current_target
.to_files_info
= debug_to_files_info
;
2548 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2549 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2550 current_target
.to_terminal_init
= debug_to_terminal_init
;
2551 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2552 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2553 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2554 current_target
.to_terminal_info
= debug_to_terminal_info
;
2555 current_target
.to_kill
= debug_to_kill
;
2556 current_target
.to_load
= debug_to_load
;
2557 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2558 current_target
.to_create_inferior
= debug_to_create_inferior
;
2559 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2560 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2561 current_target
.to_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2562 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2563 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2564 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2565 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2566 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2567 current_target
.to_has_forked
= debug_to_has_forked
;
2568 current_target
.to_has_vforked
= debug_to_has_vforked
;
2569 current_target
.to_can_follow_vfork_prior_to_exec
= debug_to_can_follow_vfork_prior_to_exec
;
2570 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2571 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2572 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2573 current_target
.to_has_execd
= debug_to_has_execd
;
2574 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2575 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2576 current_target
.to_has_exited
= debug_to_has_exited
;
2577 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2578 current_target
.to_can_run
= debug_to_can_run
;
2579 current_target
.to_notice_signals
= debug_to_notice_signals
;
2580 current_target
.to_thread_alive
= debug_to_thread_alive
;
2581 current_target
.to_stop
= debug_to_stop
;
2582 current_target
.to_query
= debug_to_query
;
2583 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2584 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2585 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2586 current_target
.to_core_file_to_sym_file
= debug_to_core_file_to_sym_file
;
2591 static char targ_desc
[] =
2592 "Names of targets and files being debugged.\n\
2593 Shows the entire stack of targets currently in use (including the exec-file,\n\
2594 core-file, and process, if any), as well as the symbol file name.";
2597 initialize_targets ()
2599 init_dummy_target ();
2600 push_target (&dummy_target
);
2602 add_info ("target", target_info
, targ_desc
);
2603 add_info ("files", target_info
, targ_desc
);
2606 add_set_cmd ("targetdebug", class_maintenance
, var_zinteger
,
2607 (char *)&targetdebug
,
2608 "Set target debugging.\n\
2609 When non-zero, target debugging is enabled.", &setlist
),
2612 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))