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,
20 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
39 target_info
PARAMS ((char *, int));
42 cleanup_target
PARAMS ((struct target_ops
*));
45 maybe_kill_then_create_inferior
PARAMS ((char *, char *, char **));
48 default_clone_and_follow_inferior
PARAMS ((int, int *));
51 maybe_kill_then_attach
PARAMS ((char *, int));
54 kill_or_be_killed
PARAMS ((int));
57 default_terminal_info
PARAMS ((char *, int));
60 nosymbol
PARAMS ((char *, CORE_ADDR
*));
63 tcomplain
PARAMS ((void));
66 nomemory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
69 return_zero
PARAMS ((void));
72 return_one
PARAMS ((void));
75 target_ignore
PARAMS ((void));
78 target_command
PARAMS ((char *, int));
80 static struct target_ops
*
81 find_default_run_target
PARAMS ((char *));
84 update_current_target
PARAMS ((void));
86 static void nosupport_runtime
PARAMS ((void));
88 static void normal_target_post_startup_inferior
PARAMS ((int pid
));
90 /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
91 Returns 0 for success, errno code for failure (which includes partial
92 transfers--if you want a more useful response to partial transfers, try
93 target_read_memory_partial). */
96 target_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
,
97 int write
, asection
* bfd_section
));
99 static void init_dummy_target
PARAMS ((void));
102 debug_to_open
PARAMS ((char *, int));
105 debug_to_close
PARAMS ((int));
108 debug_to_attach
PARAMS ((char *, int));
111 debug_to_detach
PARAMS ((char *, int));
114 debug_to_resume
PARAMS ((int, int, enum target_signal
));
117 debug_to_wait
PARAMS ((int, struct target_waitstatus
*));
120 debug_to_fetch_registers
PARAMS ((int));
123 debug_to_store_registers
PARAMS ((int));
126 debug_to_prepare_to_store
PARAMS ((void));
129 debug_to_xfer_memory
PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*));
132 debug_to_files_info
PARAMS ((struct target_ops
*));
135 debug_to_insert_breakpoint
PARAMS ((CORE_ADDR
, char *));
138 debug_to_remove_breakpoint
PARAMS ((CORE_ADDR
, char *));
141 debug_to_terminal_init
PARAMS ((void));
144 debug_to_terminal_inferior
PARAMS ((void));
147 debug_to_terminal_ours_for_output
PARAMS ((void));
150 debug_to_terminal_ours
PARAMS ((void));
153 debug_to_terminal_info
PARAMS ((char *, int));
156 debug_to_kill
PARAMS ((void));
159 debug_to_load
PARAMS ((char *, int));
162 debug_to_lookup_symbol
PARAMS ((char *, CORE_ADDR
*));
165 debug_to_create_inferior
PARAMS ((char *, char *, char **));
168 debug_to_mourn_inferior
PARAMS ((void));
171 debug_to_can_run
PARAMS ((void));
174 debug_to_notice_signals
PARAMS ((int));
177 debug_to_thread_alive
PARAMS ((int));
180 debug_to_stop
PARAMS ((void));
182 static int debug_to_query
PARAMS ((int /*char */ , char *, char *, int *));
184 /* Pointer to array of target architecture structures; the size of the
185 array; the current index into the array; the allocated size of the
187 struct target_ops
**target_structs
;
188 unsigned target_struct_size
;
189 unsigned target_struct_index
;
190 unsigned target_struct_allocsize
;
191 #define DEFAULT_ALLOCSIZE 10
193 /* The initial current target, so that there is always a semi-valid
196 static struct target_ops dummy_target
;
198 /* Top of target stack. */
200 struct target_stack_item
*target_stack
;
202 /* The target structure we are currently using to talk to a process
203 or file or whatever "inferior" we have. */
205 struct target_ops current_target
;
207 /* Command list for target. */
209 static struct cmd_list_element
*targetlist
= NULL
;
211 /* Nonzero if we are debugging an attached outside process
212 rather than an inferior. */
216 /* Non-zero if we want to see trace of target level stuff. */
218 static int targetdebug
= 0;
220 static void setup_target_debug
PARAMS ((void));
222 /* The user just typed 'target' without the name of a target. */
226 target_command (arg
, from_tty
)
230 fputs_filtered ("Argument required (target name). Try `help target'\n",
234 /* Add a possible target architecture to the list. */
238 struct target_ops
*t
;
242 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
243 target_structs
= (struct target_ops
**) xmalloc
244 (target_struct_allocsize
* sizeof (*target_structs
));
246 if (target_struct_size
>= target_struct_allocsize
)
248 target_struct_allocsize
*= 2;
249 target_structs
= (struct target_ops
**)
250 xrealloc ((char *) target_structs
,
251 target_struct_allocsize
* sizeof (*target_structs
));
253 target_structs
[target_struct_size
++] = t
;
254 /* cleanup_target (t); */
256 if (targetlist
== NULL
)
257 add_prefix_cmd ("target", class_run
, target_command
,
258 "Connect to a target machine or process.\n\
259 The first argument is the type or protocol of the target machine.\n\
260 Remaining arguments are interpreted by the target protocol. For more\n\
261 information on the arguments for a particular protocol, type\n\
262 `help target ' followed by the protocol name.",
263 &targetlist
, "target ", 0, &cmdlist
);
264 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
276 nomemory (memaddr
, myaddr
, len
, write
, t
)
281 struct target_ops
*t
;
283 errno
= EIO
; /* Can't read/write this location */
284 return 0; /* No bytes handled */
290 error ("You can't do that when your target is `%s'",
291 current_target
.to_shortname
);
297 error ("You can't do that without a process to debug.");
302 nosymbol (name
, addrp
)
306 return 1; /* Symbol does not exist in target env */
316 error ("No run-time support for this");
322 default_terminal_info (args
, from_tty
)
326 printf_unfiltered ("No saved terminal information.\n");
329 /* This is the default target_create_inferior and target_attach function.
330 If the current target is executing, it asks whether to kill it off.
331 If this function returns without calling error(), it has killed off
332 the target, and the operation should be attempted. */
335 kill_or_be_killed (from_tty
)
338 if (target_has_execution
)
340 printf_unfiltered ("You are already running a program:\n");
341 target_files_info ();
342 if (query ("Kill it? "))
345 if (target_has_execution
)
346 error ("Killing the program did not help.");
351 error ("Program not killed.");
358 maybe_kill_then_attach (args
, from_tty
)
362 kill_or_be_killed (from_tty
);
363 target_attach (args
, from_tty
);
367 maybe_kill_then_create_inferior (exec
, args
, env
)
372 kill_or_be_killed (0);
373 target_create_inferior (exec
, args
, env
);
377 default_clone_and_follow_inferior (child_pid
, followed_child
)
381 target_clone_and_follow_inferior (child_pid
, followed_child
);
384 /* Clean up a target struct so it no longer has any zero pointers in it.
385 We default entries, at least to stubs that print error messages. */
389 struct target_ops
*t
;
392 #define de_fault(field, value) \
393 if (!t->field) t->field = value
395 /* FIELD DEFAULT VALUE */
397 de_fault (to_open
, (void (*)PARAMS ((char *, int))) tcomplain
);
398 de_fault (to_close
, (void (*)PARAMS ((int))) target_ignore
);
399 de_fault (to_attach
, maybe_kill_then_attach
);
400 de_fault (to_post_attach
, (void (*)PARAMS ((int))) target_ignore
);
401 de_fault (to_require_attach
, maybe_kill_then_attach
);
402 de_fault (to_detach
, (void (*)PARAMS ((char *, int))) target_ignore
);
403 de_fault (to_require_detach
, (void (*)PARAMS ((int, char *, int))) target_ignore
);
404 de_fault (to_resume
, (void (*)PARAMS ((int, int, enum target_signal
))) noprocess
);
405 de_fault (to_wait
, (int (*)PARAMS ((int, struct target_waitstatus
*))) noprocess
);
406 de_fault (to_post_wait
, (void (*)PARAMS ((int, int))) target_ignore
);
407 de_fault (to_fetch_registers
, (void (*)PARAMS ((int))) target_ignore
);
408 de_fault (to_store_registers
, (void (*)PARAMS ((int))) noprocess
);
409 de_fault (to_prepare_to_store
, (void (*)PARAMS ((void))) noprocess
);
410 de_fault (to_xfer_memory
, (int (*)PARAMS ((CORE_ADDR
, char *, int, int, struct target_ops
*))) nomemory
);
411 de_fault (to_files_info
, (void (*)PARAMS ((struct target_ops
*))) target_ignore
);
412 de_fault (to_insert_breakpoint
, memory_insert_breakpoint
);
413 de_fault (to_remove_breakpoint
, memory_remove_breakpoint
);
414 de_fault (to_terminal_init
, (void (*)PARAMS ((void))) target_ignore
);
415 de_fault (to_terminal_inferior
, (void (*)PARAMS ((void))) target_ignore
);
416 de_fault (to_terminal_ours_for_output
, (void (*)PARAMS ((void))) target_ignore
);
417 de_fault (to_terminal_ours
, (void (*)PARAMS ((void))) target_ignore
);
418 de_fault (to_terminal_info
, default_terminal_info
);
419 de_fault (to_kill
, (void (*)PARAMS ((void))) noprocess
);
420 de_fault (to_load
, (void (*)PARAMS ((char *, int))) tcomplain
);
421 de_fault (to_lookup_symbol
, (int (*)PARAMS ((char *, CORE_ADDR
*))) nosymbol
);
422 de_fault (to_create_inferior
, maybe_kill_then_create_inferior
);
423 de_fault (to_post_startup_inferior
, (void (*)PARAMS ((int))) target_ignore
);
424 de_fault (to_acknowledge_created_inferior
, (void (*)PARAMS ((int))) target_ignore
);
425 de_fault (to_clone_and_follow_inferior
, default_clone_and_follow_inferior
);
426 de_fault (to_post_follow_inferior_by_clone
, (void (*)PARAMS ((void))) target_ignore
);
427 de_fault (to_insert_fork_catchpoint
, (int (*)PARAMS ((int))) tcomplain
);
428 de_fault (to_remove_fork_catchpoint
, (int (*)PARAMS ((int))) tcomplain
);
429 de_fault (to_insert_vfork_catchpoint
, (int (*)PARAMS ((int))) tcomplain
);
430 de_fault (to_remove_vfork_catchpoint
, (int (*)PARAMS ((int))) tcomplain
);
431 de_fault (to_has_forked
, (int (*)PARAMS ((int, int *))) return_zero
);
432 de_fault (to_has_vforked
, (int (*)PARAMS ((int, int *))) return_zero
);
433 de_fault (to_can_follow_vfork_prior_to_exec
, (int (*)PARAMS ((void))) return_zero
);
434 de_fault (to_post_follow_vfork
, (void (*)PARAMS ((int, int, int, int))) target_ignore
);
435 de_fault (to_insert_exec_catchpoint
, (int (*)PARAMS ((int))) tcomplain
);
436 de_fault (to_remove_exec_catchpoint
, (int (*)PARAMS ((int))) tcomplain
);
437 de_fault (to_has_execd
, (int (*)PARAMS ((int, char **))) return_zero
);
438 de_fault (to_reported_exec_events_per_exec_call
, (int (*)PARAMS ((void))) return_one
);
439 de_fault (to_has_syscall_event
, (int (*)PARAMS ((int, enum target_waitkind
*, int *))) return_zero
);
440 de_fault (to_has_exited
, (int (*)PARAMS ((int, int, int *))) return_zero
);
441 de_fault (to_mourn_inferior
, (void (*)PARAMS ((void))) noprocess
);
442 de_fault (to_can_run
, return_zero
);
443 de_fault (to_notice_signals
, (void (*)PARAMS ((int))) target_ignore
);
444 de_fault (to_thread_alive
, (int (*)PARAMS ((int))) target_ignore
);
445 de_fault (to_stop
, (void (*)PARAMS ((void))) target_ignore
);
446 de_fault (to_query
, (int (*)PARAMS ((int /*char */ , char *, char *, int *))) target_ignore
);
447 de_fault (to_enable_exception_callback
, (struct symtab_and_line
* (*)PARAMS ((enum exception_event_kind
, int))) nosupport_runtime
);
448 de_fault (to_get_current_exception_event
, (struct exception_event_record
* (*)PARAMS ((void))) nosupport_runtime
);
450 de_fault (to_pid_to_exec_file
, (char *(*)PARAMS ((int))) return_zero
);
451 de_fault (to_core_file_to_sym_file
, (char *(*)PARAMS ((char *))) return_zero
);
455 /* Go through the target stack from top to bottom, copying over zero entries in
456 current_target. In effect, we are doing class inheritance through the
457 pushed target vectors. */
460 update_current_target ()
462 struct target_stack_item
*item
;
463 struct target_ops
*t
;
465 /* First, reset current_target */
466 memset (¤t_target
, 0, sizeof current_target
);
468 for (item
= target_stack
; item
; item
= item
->next
)
470 t
= item
->target_ops
;
472 #define INHERIT(FIELD, TARGET) \
473 if (!current_target.FIELD) \
474 current_target.FIELD = TARGET->FIELD
476 INHERIT (to_shortname
, t
);
477 INHERIT (to_longname
, t
);
479 INHERIT (to_open
, t
);
480 INHERIT (to_close
, t
);
481 INHERIT (to_attach
, t
);
482 INHERIT (to_post_attach
, t
);
483 INHERIT (to_require_attach
, t
);
484 INHERIT (to_detach
, t
);
485 INHERIT (to_require_detach
, t
);
486 INHERIT (to_resume
, t
);
487 INHERIT (to_wait
, t
);
488 INHERIT (to_post_wait
, t
);
489 INHERIT (to_fetch_registers
, t
);
490 INHERIT (to_store_registers
, t
);
491 INHERIT (to_prepare_to_store
, t
);
492 INHERIT (to_xfer_memory
, t
);
493 INHERIT (to_files_info
, t
);
494 INHERIT (to_insert_breakpoint
, t
);
495 INHERIT (to_remove_breakpoint
, t
);
496 INHERIT (to_terminal_init
, t
);
497 INHERIT (to_terminal_inferior
, t
);
498 INHERIT (to_terminal_ours_for_output
, t
);
499 INHERIT (to_terminal_ours
, t
);
500 INHERIT (to_terminal_info
, t
);
501 INHERIT (to_kill
, t
);
502 INHERIT (to_load
, t
);
503 INHERIT (to_lookup_symbol
, t
);
504 INHERIT (to_create_inferior
, t
);
505 INHERIT (to_post_startup_inferior
, t
);
506 INHERIT (to_acknowledge_created_inferior
, t
);
507 INHERIT (to_clone_and_follow_inferior
, t
);
508 INHERIT (to_post_follow_inferior_by_clone
, t
);
509 INHERIT (to_insert_fork_catchpoint
, t
);
510 INHERIT (to_remove_fork_catchpoint
, t
);
511 INHERIT (to_insert_vfork_catchpoint
, t
);
512 INHERIT (to_remove_vfork_catchpoint
, t
);
513 INHERIT (to_has_forked
, t
);
514 INHERIT (to_has_vforked
, t
);
515 INHERIT (to_can_follow_vfork_prior_to_exec
, t
);
516 INHERIT (to_post_follow_vfork
, t
);
517 INHERIT (to_insert_exec_catchpoint
, t
);
518 INHERIT (to_remove_exec_catchpoint
, t
);
519 INHERIT (to_has_execd
, t
);
520 INHERIT (to_reported_exec_events_per_exec_call
, t
);
521 INHERIT (to_has_syscall_event
, t
);
522 INHERIT (to_has_exited
, t
);
523 INHERIT (to_mourn_inferior
, t
);
524 INHERIT (to_can_run
, t
);
525 INHERIT (to_notice_signals
, t
);
526 INHERIT (to_thread_alive
, t
);
527 INHERIT (to_find_new_threads
, t
);
528 INHERIT (to_stop
, t
);
529 INHERIT (to_query
, t
);
530 INHERIT (to_enable_exception_callback
, t
);
531 INHERIT (to_get_current_exception_event
, t
);
532 INHERIT (to_pid_to_exec_file
, t
);
533 INHERIT (to_core_file_to_sym_file
, t
);
534 INHERIT (to_stratum
, t
);
535 INHERIT (DONT_USE
, t
);
536 INHERIT (to_has_all_memory
, t
);
537 INHERIT (to_has_memory
, t
);
538 INHERIT (to_has_stack
, t
);
539 INHERIT (to_has_registers
, t
);
540 INHERIT (to_has_execution
, t
);
541 INHERIT (to_has_thread_control
, t
);
542 INHERIT (to_has_async_exec
, t
);
543 INHERIT (to_sections
, t
);
544 INHERIT (to_sections_end
, t
);
545 INHERIT (to_magic
, t
);
551 /* Push a new target type into the stack of the existing target accessors,
552 possibly superseding some of the existing accessors.
554 Result is zero if the pushed target ended up on top of the stack,
555 nonzero if at least one target is on top of it.
557 Rather than allow an empty stack, we always have the dummy target at
558 the bottom stratum, so we can call the function vectors without
563 struct target_ops
*t
;
565 struct target_stack_item
*cur
, *prev
, *tmp
;
567 /* Check magic number. If wrong, it probably means someone changed
568 the struct definition, but not all the places that initialize one. */
569 if (t
->to_magic
!= OPS_MAGIC
)
571 fprintf_unfiltered (gdb_stderr
,
572 "Magic number of %s target struct wrong\n",
577 /* Find the proper stratum to install this target in. */
579 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
581 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
585 /* If there's already targets at this stratum, remove them. */
588 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
590 /* There's already something on this stratum. Close it off. */
591 if (cur
->target_ops
->to_close
)
592 (cur
->target_ops
->to_close
) (0);
594 prev
->next
= cur
->next
; /* Unchain old target_ops */
596 target_stack
= cur
->next
; /* Unchain first on list */
602 /* We have removed all targets in our stratum, now add the new one. */
604 tmp
= (struct target_stack_item
*)
605 xmalloc (sizeof (struct target_stack_item
));
614 update_current_target ();
616 cleanup_target (¤t_target
); /* Fill in the gaps */
619 setup_target_debug ();
624 /* Remove a target_ops vector from the stack, wherever it may be.
625 Return how many times it was removed (0 or 1). */
629 struct target_ops
*t
;
631 struct target_stack_item
*cur
, *prev
;
634 t
->to_close (0); /* Let it clean up */
636 /* Look for the specified target. Note that we assume that a target
637 can only occur once in the target stack. */
639 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
640 if (cur
->target_ops
== t
)
644 return 0; /* Didn't find target_ops, quit now */
646 /* Unchain the target */
649 target_stack
= cur
->next
;
651 prev
->next
= cur
->next
;
653 free (cur
); /* Release the target_stack_item */
655 update_current_target ();
656 cleanup_target (¤t_target
);
664 (current_target
.to_close
) (0); /* Let it clean up */
665 if (unpush_target (target_stack
->target_ops
) == 1)
668 fprintf_unfiltered (gdb_stderr
,
669 "pop_target couldn't find target %s\n",
670 current_target
.to_shortname
);
675 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
677 /* target_read_string -- read a null terminated string, up to LEN bytes,
678 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
679 Set *STRING to a pointer to malloc'd memory containing the data; the caller
680 is responsible for freeing it. Return the number of bytes successfully
684 target_read_string (memaddr
, string
, len
, errnop
)
690 int tlen
, origlen
, offset
, i
;
694 int buffer_allocated
;
696 unsigned int nbytes_read
= 0;
698 /* Small for testing. */
699 buffer_allocated
= 4;
700 buffer
= xmalloc (buffer_allocated
);
707 tlen
= MIN (len
, 4 - (memaddr
& 3));
708 offset
= memaddr
& 3;
710 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0, NULL
);
713 /* The transfer request might have crossed the boundary to an
714 unallocated region of memory. Retry the transfer, requesting
718 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0, NULL
);
723 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
726 bytes
= bufptr
- buffer
;
727 buffer_allocated
*= 2;
728 buffer
= xrealloc (buffer
, buffer_allocated
);
729 bufptr
= buffer
+ bytes
;
732 for (i
= 0; i
< tlen
; i
++)
734 *bufptr
++ = buf
[i
+ offset
];
735 if (buf
[i
+ offset
] == '\000')
737 nbytes_read
+= i
+ 1;
754 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
755 GDB's memory at MYADDR. Returns either 0 for success or an errno value
758 If an error occurs, no guarantee is made about the contents of the data at
759 MYADDR. In particular, the caller should not depend upon partial reads
760 filling the buffer with good data. There is no way for the caller to know
761 how much good data might have been transfered anyway. Callers that can
762 deal with partial reads should call target_read_memory_partial. */
765 target_read_memory (memaddr
, myaddr
, len
)
770 return target_xfer_memory (memaddr
, myaddr
, len
, 0, NULL
);
774 target_read_memory_section (memaddr
, myaddr
, len
, bfd_section
)
778 asection
*bfd_section
;
780 return target_xfer_memory (memaddr
, myaddr
, len
, 0, bfd_section
);
783 /* Read LEN bytes of target memory at address MEMADDR, placing the results
784 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
785 and optionally an errno value in the location pointed to by ERRNOPTR
786 if ERRNOPTR is non-null. */
789 target_read_memory_partial (memaddr
, myaddr
, len
, errnoptr
)
795 int nread
; /* Number of bytes actually read. */
796 int errcode
; /* Error from last read. */
798 /* First try a complete read. */
799 errcode
= target_xfer_memory (memaddr
, myaddr
, len
, 0, NULL
);
807 /* Loop, reading one byte at a time until we get as much as we can. */
808 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
810 errcode
= target_xfer_memory (memaddr
++, myaddr
++, 1, 0, NULL
);
812 /* If an error, the last read was unsuccessful, so adjust count. */
818 if (errnoptr
!= NULL
)
826 target_write_memory (memaddr
, myaddr
, len
)
831 return target_xfer_memory (memaddr
, myaddr
, len
, 1, NULL
);
834 /* This variable is used to pass section information down to targets. This
835 *should* be done by adding an argument to the target_xfer_memory function
836 of all the targets, but I didn't feel like changing 50+ files. */
838 asection
*target_memory_bfd_section
= NULL
;
840 /* Move memory to or from the targets. Iterate until all of it has
841 been moved, if necessary. The top target gets priority; anything
842 it doesn't want, is offered to the next one down, etc. Note the
843 business with curlen: if an early target says "no, but I have a
844 boundary overlapping this xfer" then we shorten what we offer to
845 the subsequent targets so the early guy will get a chance at the
846 tail before the subsequent ones do.
848 Result is 0 or errno value. */
851 target_xfer_memory (memaddr
, myaddr
, len
, write
, bfd_section
)
856 asection
*bfd_section
;
860 struct target_ops
*t
;
861 struct target_stack_item
*item
;
863 /* Zero length requests are ok and require no work. */
867 target_memory_bfd_section
= bfd_section
;
869 /* to_xfer_memory is not guaranteed to set errno, even when it returns
873 /* The quick case is that the top target does it all. */
874 res
= current_target
.to_xfer_memory
875 (memaddr
, myaddr
, len
, write
, ¤t_target
);
881 /* If res <= 0 then we call it again in the loop. Ah well. */
885 curlen
= len
; /* Want to do it all */
886 for (item
= target_stack
; item
; item
= item
->next
)
888 t
= item
->target_ops
;
889 if (!t
->to_has_memory
)
892 res
= t
->to_xfer_memory (memaddr
, myaddr
, curlen
, write
, t
);
894 break; /* Handled all or part of xfer */
895 if (t
->to_has_all_memory
)
901 /* If this address is for nonexistent memory,
902 read zeros if reading, or do nothing if writing. Return error. */
904 memset (myaddr
, 0, len
);
915 return 0; /* We managed to cover it all somehow. */
921 target_info (args
, from_tty
)
925 struct target_ops
*t
;
926 struct target_stack_item
*item
;
929 if (symfile_objfile
!= NULL
)
930 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
932 #ifdef FILES_INFO_HOOK
933 if (FILES_INFO_HOOK ())
937 for (item
= target_stack
; item
; item
= item
->next
)
939 t
= item
->target_ops
;
941 if (!t
->to_has_memory
)
944 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
947 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
948 printf_unfiltered ("%s:\n", t
->to_longname
);
949 (t
->to_files_info
) (t
);
950 has_all_mem
= t
->to_has_all_memory
;
954 /* This is to be called by the open routine before it does
958 target_preopen (from_tty
)
963 if (target_has_execution
)
966 || query ("A program is being debugged already. Kill it? "))
969 error ("Program not killed.");
972 /* Calling target_kill may remove the target from the stack. But if
973 it doesn't (which seems like a win for UDI), remove it now. */
975 if (target_has_execution
)
979 /* Detach a target after doing deferred register stores. */
982 target_detach (args
, from_tty
)
986 /* Handle any optimized stores to the inferior. */
987 #ifdef DO_DEFERRED_STORES
990 (current_target
.to_detach
) (args
, from_tty
);
994 target_link (modname
, t_reloc
)
998 if (STREQ (current_target
.to_shortname
, "rombug"))
1000 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1002 error ("Unable to link to %s and get relocation in rombug", modname
);
1005 *t_reloc
= (CORE_ADDR
) - 1;
1008 /* Look through the list of possible targets for a target that can
1009 execute a run or attach command without any other data. This is
1010 used to locate the default process stratum.
1012 Result is always valid (error() is called for errors). */
1014 static struct target_ops
*
1015 find_default_run_target (do_mesg
)
1018 struct target_ops
**t
;
1019 struct target_ops
*runable
= NULL
;
1024 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1027 if ((*t
)->to_can_run
&& target_can_run (*t
))
1035 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1041 find_default_attach (args
, from_tty
)
1045 struct target_ops
*t
;
1047 t
= find_default_run_target ("attach");
1048 (t
->to_attach
) (args
, from_tty
);
1053 find_default_require_attach (args
, from_tty
)
1057 struct target_ops
*t
;
1059 t
= find_default_run_target ("require_attach");
1060 (t
->to_require_attach
) (args
, from_tty
);
1065 find_default_require_detach (pid
, args
, from_tty
)
1070 struct target_ops
*t
;
1072 t
= find_default_run_target ("require_detach");
1073 (t
->to_require_detach
) (pid
, args
, from_tty
);
1078 find_default_create_inferior (exec_file
, allargs
, env
)
1083 struct target_ops
*t
;
1085 t
= find_default_run_target ("run");
1086 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1091 find_default_clone_and_follow_inferior (child_pid
, followed_child
)
1093 int *followed_child
;
1095 struct target_ops
*t
;
1097 t
= find_default_run_target ("run");
1098 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1114 /* Find a single runnable target in the stack and return it. If for
1115 some reason there is more than one, return NULL. */
1120 struct target_ops
**t
;
1121 struct target_ops
*runable
= NULL
;
1126 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1128 if ((*t
)->to_can_run
&& target_can_run (*t
))
1135 return (count
== 1 ? runable
: NULL
);
1141 struct target_ops
**t
;
1142 struct target_ops
*runable
= NULL
;
1147 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1150 if ((*t
)->to_stratum
== core_stratum
)
1157 return (count
== 1 ? runable
: NULL
);
1160 /* The inferior process has died. Long live the inferior! */
1163 generic_mourn_inferior ()
1165 extern int show_breakpoint_hit_counts
;
1169 breakpoint_init_inferior (inf_exited
);
1170 registers_changed ();
1172 #ifdef CLEAR_DEFERRED_STORES
1173 /* Delete any pending stores to the inferior... */
1174 CLEAR_DEFERRED_STORES
;
1177 reopen_exec_file ();
1178 reinit_frame_cache ();
1180 /* It is confusing to the user for ignore counts to stick around
1181 from previous runs of the inferior. So clear them. */
1182 /* However, it is more confusing for the ignore counts to disappear when
1183 using hit counts. So don't clear them if we're counting hits. */
1184 if (!show_breakpoint_hit_counts
)
1185 breakpoint_clear_ignore_counts ();
1188 /* This table must match in order and size the signals in enum target_signal
1197 {"SIGHUP", "Hangup"},
1198 {"SIGINT", "Interrupt"},
1199 {"SIGQUIT", "Quit"},
1200 {"SIGILL", "Illegal instruction"},
1201 {"SIGTRAP", "Trace/breakpoint trap"},
1202 {"SIGABRT", "Aborted"},
1203 {"SIGEMT", "Emulation trap"},
1204 {"SIGFPE", "Arithmetic exception"},
1205 {"SIGKILL", "Killed"},
1206 {"SIGBUS", "Bus error"},
1207 {"SIGSEGV", "Segmentation fault"},
1208 {"SIGSYS", "Bad system call"},
1209 {"SIGPIPE", "Broken pipe"},
1210 {"SIGALRM", "Alarm clock"},
1211 {"SIGTERM", "Terminated"},
1212 {"SIGURG", "Urgent I/O condition"},
1213 {"SIGSTOP", "Stopped (signal)"},
1214 {"SIGTSTP", "Stopped (user)"},
1215 {"SIGCONT", "Continued"},
1216 {"SIGCHLD", "Child status changed"},
1217 {"SIGTTIN", "Stopped (tty input)"},
1218 {"SIGTTOU", "Stopped (tty output)"},
1219 {"SIGIO", "I/O possible"},
1220 {"SIGXCPU", "CPU time limit exceeded"},
1221 {"SIGXFSZ", "File size limit exceeded"},
1222 {"SIGVTALRM", "Virtual timer expired"},
1223 {"SIGPROF", "Profiling timer expired"},
1224 {"SIGWINCH", "Window size changed"},
1225 {"SIGLOST", "Resource lost"},
1226 {"SIGUSR1", "User defined signal 1"},
1227 {"SIGUSR2", "User defined signal 2"},
1228 {"SIGPWR", "Power fail/restart"},
1229 {"SIGPOLL", "Pollable event occurred"},
1230 {"SIGWIND", "SIGWIND"},
1231 {"SIGPHONE", "SIGPHONE"},
1232 {"SIGWAITING", "Process's LWPs are blocked"},
1233 {"SIGLWP", "Signal LWP"},
1234 {"SIGDANGER", "Swap space dangerously low"},
1235 {"SIGGRANT", "Monitor mode granted"},
1236 {"SIGRETRACT", "Need to relinquish monitor mode"},
1237 {"SIGMSG", "Monitor mode data available"},
1238 {"SIGSOUND", "Sound completed"},
1239 {"SIGSAK", "Secure attention"},
1240 {"SIGPRIO", "SIGPRIO"},
1241 {"SIG33", "Real-time event 33"},
1242 {"SIG34", "Real-time event 34"},
1243 {"SIG35", "Real-time event 35"},
1244 {"SIG36", "Real-time event 36"},
1245 {"SIG37", "Real-time event 37"},
1246 {"SIG38", "Real-time event 38"},
1247 {"SIG39", "Real-time event 39"},
1248 {"SIG40", "Real-time event 40"},
1249 {"SIG41", "Real-time event 41"},
1250 {"SIG42", "Real-time event 42"},
1251 {"SIG43", "Real-time event 43"},
1252 {"SIG44", "Real-time event 44"},
1253 {"SIG45", "Real-time event 45"},
1254 {"SIG46", "Real-time event 46"},
1255 {"SIG47", "Real-time event 47"},
1256 {"SIG48", "Real-time event 48"},
1257 {"SIG49", "Real-time event 49"},
1258 {"SIG50", "Real-time event 50"},
1259 {"SIG51", "Real-time event 51"},
1260 {"SIG52", "Real-time event 52"},
1261 {"SIG53", "Real-time event 53"},
1262 {"SIG54", "Real-time event 54"},
1263 {"SIG55", "Real-time event 55"},
1264 {"SIG56", "Real-time event 56"},
1265 {"SIG57", "Real-time event 57"},
1266 {"SIG58", "Real-time event 58"},
1267 {"SIG59", "Real-time event 59"},
1268 {"SIG60", "Real-time event 60"},
1269 {"SIG61", "Real-time event 61"},
1270 {"SIG62", "Real-time event 62"},
1271 {"SIG63", "Real-time event 63"},
1272 {"SIGCANCEL", "LWP internal signal"},
1274 #if defined(MACH) || defined(__MACH__)
1275 /* Mach exceptions */
1276 {"EXC_BAD_ACCESS", "Could not access memory"},
1277 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1278 {"EXC_ARITHMETIC", "Arithmetic exception"},
1279 {"EXC_EMULATION", "Emulation instruction"},
1280 {"EXC_SOFTWARE", "Software generated exception"},
1281 {"EXC_BREAKPOINT", "Breakpoint"},
1283 {"SIGINFO", "Information request"},
1285 {NULL
, "Unknown signal"},
1286 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1288 /* Last entry, used to check whether the table is the right size. */
1289 {NULL
, "TARGET_SIGNAL_MAGIC"}
1295 /* Return the string for a signal. */
1297 target_signal_to_string (sig
)
1298 enum target_signal sig
;
1300 if ((sig
>= TARGET_SIGNAL_FIRST
) && (sig
<= TARGET_SIGNAL_LAST
))
1301 return signals
[sig
].string
;
1303 return signals
[TARGET_SIGNAL_UNKNOWN
].string
;
1306 /* Return the name for a signal. */
1308 target_signal_to_name (sig
)
1309 enum target_signal sig
;
1311 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1312 /* I think the code which prints this will always print it along with
1313 the string, so no need to be verbose. */
1315 return signals
[sig
].name
;
1318 /* Given a name, return its signal. */
1320 target_signal_from_name (name
)
1323 enum target_signal sig
;
1325 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1326 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1327 questionable; seems like by now people should call it SIGABRT
1330 /* This ugly cast brought to you by the native VAX compiler. */
1331 for (sig
= TARGET_SIGNAL_HUP
;
1332 signals
[sig
].name
!= NULL
;
1333 sig
= (enum target_signal
) ((int) sig
+ 1))
1334 if (STREQ (name
, signals
[sig
].name
))
1336 return TARGET_SIGNAL_UNKNOWN
;
1339 /* The following functions are to help certain targets deal
1340 with the signal/waitstatus stuff. They could just as well be in
1341 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1343 /* Convert host signal to our signals. */
1345 target_signal_from_host (hostsig
)
1348 /* A switch statement would make sense but would require special kludges
1349 to deal with the cases where more than one signal has the same number. */
1352 return TARGET_SIGNAL_0
;
1354 #if defined (SIGHUP)
1355 if (hostsig
== SIGHUP
)
1356 return TARGET_SIGNAL_HUP
;
1358 #if defined (SIGINT)
1359 if (hostsig
== SIGINT
)
1360 return TARGET_SIGNAL_INT
;
1362 #if defined (SIGQUIT)
1363 if (hostsig
== SIGQUIT
)
1364 return TARGET_SIGNAL_QUIT
;
1366 #if defined (SIGILL)
1367 if (hostsig
== SIGILL
)
1368 return TARGET_SIGNAL_ILL
;
1370 #if defined (SIGTRAP)
1371 if (hostsig
== SIGTRAP
)
1372 return TARGET_SIGNAL_TRAP
;
1374 #if defined (SIGABRT)
1375 if (hostsig
== SIGABRT
)
1376 return TARGET_SIGNAL_ABRT
;
1378 #if defined (SIGEMT)
1379 if (hostsig
== SIGEMT
)
1380 return TARGET_SIGNAL_EMT
;
1382 #if defined (SIGFPE)
1383 if (hostsig
== SIGFPE
)
1384 return TARGET_SIGNAL_FPE
;
1386 #if defined (SIGKILL)
1387 if (hostsig
== SIGKILL
)
1388 return TARGET_SIGNAL_KILL
;
1390 #if defined (SIGBUS)
1391 if (hostsig
== SIGBUS
)
1392 return TARGET_SIGNAL_BUS
;
1394 #if defined (SIGSEGV)
1395 if (hostsig
== SIGSEGV
)
1396 return TARGET_SIGNAL_SEGV
;
1398 #if defined (SIGSYS)
1399 if (hostsig
== SIGSYS
)
1400 return TARGET_SIGNAL_SYS
;
1402 #if defined (SIGPIPE)
1403 if (hostsig
== SIGPIPE
)
1404 return TARGET_SIGNAL_PIPE
;
1406 #if defined (SIGALRM)
1407 if (hostsig
== SIGALRM
)
1408 return TARGET_SIGNAL_ALRM
;
1410 #if defined (SIGTERM)
1411 if (hostsig
== SIGTERM
)
1412 return TARGET_SIGNAL_TERM
;
1414 #if defined (SIGUSR1)
1415 if (hostsig
== SIGUSR1
)
1416 return TARGET_SIGNAL_USR1
;
1418 #if defined (SIGUSR2)
1419 if (hostsig
== SIGUSR2
)
1420 return TARGET_SIGNAL_USR2
;
1422 #if defined (SIGCLD)
1423 if (hostsig
== SIGCLD
)
1424 return TARGET_SIGNAL_CHLD
;
1426 #if defined (SIGCHLD)
1427 if (hostsig
== SIGCHLD
)
1428 return TARGET_SIGNAL_CHLD
;
1430 #if defined (SIGPWR)
1431 if (hostsig
== SIGPWR
)
1432 return TARGET_SIGNAL_PWR
;
1434 #if defined (SIGWINCH)
1435 if (hostsig
== SIGWINCH
)
1436 return TARGET_SIGNAL_WINCH
;
1438 #if defined (SIGURG)
1439 if (hostsig
== SIGURG
)
1440 return TARGET_SIGNAL_URG
;
1443 if (hostsig
== SIGIO
)
1444 return TARGET_SIGNAL_IO
;
1446 #if defined (SIGPOLL)
1447 if (hostsig
== SIGPOLL
)
1448 return TARGET_SIGNAL_POLL
;
1450 #if defined (SIGSTOP)
1451 if (hostsig
== SIGSTOP
)
1452 return TARGET_SIGNAL_STOP
;
1454 #if defined (SIGTSTP)
1455 if (hostsig
== SIGTSTP
)
1456 return TARGET_SIGNAL_TSTP
;
1458 #if defined (SIGCONT)
1459 if (hostsig
== SIGCONT
)
1460 return TARGET_SIGNAL_CONT
;
1462 #if defined (SIGTTIN)
1463 if (hostsig
== SIGTTIN
)
1464 return TARGET_SIGNAL_TTIN
;
1466 #if defined (SIGTTOU)
1467 if (hostsig
== SIGTTOU
)
1468 return TARGET_SIGNAL_TTOU
;
1470 #if defined (SIGVTALRM)
1471 if (hostsig
== SIGVTALRM
)
1472 return TARGET_SIGNAL_VTALRM
;
1474 #if defined (SIGPROF)
1475 if (hostsig
== SIGPROF
)
1476 return TARGET_SIGNAL_PROF
;
1478 #if defined (SIGXCPU)
1479 if (hostsig
== SIGXCPU
)
1480 return TARGET_SIGNAL_XCPU
;
1482 #if defined (SIGXFSZ)
1483 if (hostsig
== SIGXFSZ
)
1484 return TARGET_SIGNAL_XFSZ
;
1486 #if defined (SIGWIND)
1487 if (hostsig
== SIGWIND
)
1488 return TARGET_SIGNAL_WIND
;
1490 #if defined (SIGPHONE)
1491 if (hostsig
== SIGPHONE
)
1492 return TARGET_SIGNAL_PHONE
;
1494 #if defined (SIGLOST)
1495 if (hostsig
== SIGLOST
)
1496 return TARGET_SIGNAL_LOST
;
1498 #if defined (SIGWAITING)
1499 if (hostsig
== SIGWAITING
)
1500 return TARGET_SIGNAL_WAITING
;
1502 #if defined (SIGCANCEL)
1503 if (hostsig
== SIGCANCEL
)
1504 return TARGET_SIGNAL_CANCEL
;
1506 #if defined (SIGLWP)
1507 if (hostsig
== SIGLWP
)
1508 return TARGET_SIGNAL_LWP
;
1510 #if defined (SIGDANGER)
1511 if (hostsig
== SIGDANGER
)
1512 return TARGET_SIGNAL_DANGER
;
1514 #if defined (SIGGRANT)
1515 if (hostsig
== SIGGRANT
)
1516 return TARGET_SIGNAL_GRANT
;
1518 #if defined (SIGRETRACT)
1519 if (hostsig
== SIGRETRACT
)
1520 return TARGET_SIGNAL_RETRACT
;
1522 #if defined (SIGMSG)
1523 if (hostsig
== SIGMSG
)
1524 return TARGET_SIGNAL_MSG
;
1526 #if defined (SIGSOUND)
1527 if (hostsig
== SIGSOUND
)
1528 return TARGET_SIGNAL_SOUND
;
1530 #if defined (SIGSAK)
1531 if (hostsig
== SIGSAK
)
1532 return TARGET_SIGNAL_SAK
;
1534 #if defined (SIGPRIO)
1535 if (hostsig
== SIGPRIO
)
1536 return TARGET_SIGNAL_PRIO
;
1539 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1540 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1541 if (hostsig
== _NSIG
+ EXC_BAD_ACCESS
)
1542 return TARGET_EXC_BAD_ACCESS
;
1544 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1545 if (hostsig
== _NSIG
+ EXC_BAD_INSTRUCTION
)
1546 return TARGET_EXC_BAD_INSTRUCTION
;
1548 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1549 if (hostsig
== _NSIG
+ EXC_ARITHMETIC
)
1550 return TARGET_EXC_ARITHMETIC
;
1552 #if defined (EXC_EMULATION) && defined (_NSIG)
1553 if (hostsig
== _NSIG
+ EXC_EMULATION
)
1554 return TARGET_EXC_EMULATION
;
1556 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1557 if (hostsig
== _NSIG
+ EXC_SOFTWARE
)
1558 return TARGET_EXC_SOFTWARE
;
1560 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1561 if (hostsig
== _NSIG
+ EXC_BREAKPOINT
)
1562 return TARGET_EXC_BREAKPOINT
;
1565 #if defined (SIGINFO)
1566 if (hostsig
== SIGINFO
)
1567 return TARGET_SIGNAL_INFO
;
1570 #if defined (REALTIME_LO)
1571 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1572 return (enum target_signal
)
1573 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1575 return TARGET_SIGNAL_UNKNOWN
;
1579 target_signal_to_host (oursig
)
1580 enum target_signal oursig
;
1584 case TARGET_SIGNAL_0
:
1587 #if defined (SIGHUP)
1588 case TARGET_SIGNAL_HUP
:
1591 #if defined (SIGINT)
1592 case TARGET_SIGNAL_INT
:
1595 #if defined (SIGQUIT)
1596 case TARGET_SIGNAL_QUIT
:
1599 #if defined (SIGILL)
1600 case TARGET_SIGNAL_ILL
:
1603 #if defined (SIGTRAP)
1604 case TARGET_SIGNAL_TRAP
:
1607 #if defined (SIGABRT)
1608 case TARGET_SIGNAL_ABRT
:
1611 #if defined (SIGEMT)
1612 case TARGET_SIGNAL_EMT
:
1615 #if defined (SIGFPE)
1616 case TARGET_SIGNAL_FPE
:
1619 #if defined (SIGKILL)
1620 case TARGET_SIGNAL_KILL
:
1623 #if defined (SIGBUS)
1624 case TARGET_SIGNAL_BUS
:
1627 #if defined (SIGSEGV)
1628 case TARGET_SIGNAL_SEGV
:
1631 #if defined (SIGSYS)
1632 case TARGET_SIGNAL_SYS
:
1635 #if defined (SIGPIPE)
1636 case TARGET_SIGNAL_PIPE
:
1639 #if defined (SIGALRM)
1640 case TARGET_SIGNAL_ALRM
:
1643 #if defined (SIGTERM)
1644 case TARGET_SIGNAL_TERM
:
1647 #if defined (SIGUSR1)
1648 case TARGET_SIGNAL_USR1
:
1651 #if defined (SIGUSR2)
1652 case TARGET_SIGNAL_USR2
:
1655 #if defined (SIGCHLD) || defined (SIGCLD)
1656 case TARGET_SIGNAL_CHLD
:
1657 #if defined (SIGCHLD)
1662 #endif /* SIGCLD or SIGCHLD */
1663 #if defined (SIGPWR)
1664 case TARGET_SIGNAL_PWR
:
1667 #if defined (SIGWINCH)
1668 case TARGET_SIGNAL_WINCH
:
1671 #if defined (SIGURG)
1672 case TARGET_SIGNAL_URG
:
1676 case TARGET_SIGNAL_IO
:
1679 #if defined (SIGPOLL)
1680 case TARGET_SIGNAL_POLL
:
1683 #if defined (SIGSTOP)
1684 case TARGET_SIGNAL_STOP
:
1687 #if defined (SIGTSTP)
1688 case TARGET_SIGNAL_TSTP
:
1691 #if defined (SIGCONT)
1692 case TARGET_SIGNAL_CONT
:
1695 #if defined (SIGTTIN)
1696 case TARGET_SIGNAL_TTIN
:
1699 #if defined (SIGTTOU)
1700 case TARGET_SIGNAL_TTOU
:
1703 #if defined (SIGVTALRM)
1704 case TARGET_SIGNAL_VTALRM
:
1707 #if defined (SIGPROF)
1708 case TARGET_SIGNAL_PROF
:
1711 #if defined (SIGXCPU)
1712 case TARGET_SIGNAL_XCPU
:
1715 #if defined (SIGXFSZ)
1716 case TARGET_SIGNAL_XFSZ
:
1719 #if defined (SIGWIND)
1720 case TARGET_SIGNAL_WIND
:
1723 #if defined (SIGPHONE)
1724 case TARGET_SIGNAL_PHONE
:
1727 #if defined (SIGLOST)
1728 case TARGET_SIGNAL_LOST
:
1731 #if defined (SIGWAITING)
1732 case TARGET_SIGNAL_WAITING
:
1735 #if defined (SIGCANCEL)
1736 case TARGET_SIGNAL_CANCEL
:
1739 #if defined (SIGLWP)
1740 case TARGET_SIGNAL_LWP
:
1743 #if defined (SIGDANGER)
1744 case TARGET_SIGNAL_DANGER
:
1747 #if defined (SIGGRANT)
1748 case TARGET_SIGNAL_GRANT
:
1751 #if defined (SIGRETRACT)
1752 case TARGET_SIGNAL_RETRACT
:
1755 #if defined (SIGMSG)
1756 case TARGET_SIGNAL_MSG
:
1759 #if defined (SIGSOUND)
1760 case TARGET_SIGNAL_SOUND
:
1763 #if defined (SIGSAK)
1764 case TARGET_SIGNAL_SAK
:
1767 #if defined (SIGPRIO)
1768 case TARGET_SIGNAL_PRIO
:
1772 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1773 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1774 case TARGET_EXC_BAD_ACCESS
:
1775 return _NSIG
+ EXC_BAD_ACCESS
;
1777 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1778 case TARGET_EXC_BAD_INSTRUCTION
:
1779 return _NSIG
+ EXC_BAD_INSTRUCTION
;
1781 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1782 case TARGET_EXC_ARITHMETIC
:
1783 return _NSIG
+ EXC_ARITHMETIC
;
1785 #if defined (EXC_EMULATION) && defined (_NSIG)
1786 case TARGET_EXC_EMULATION
:
1787 return _NSIG
+ EXC_EMULATION
;
1789 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1790 case TARGET_EXC_SOFTWARE
:
1791 return _NSIG
+ EXC_SOFTWARE
;
1793 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1794 case TARGET_EXC_BREAKPOINT
:
1795 return _NSIG
+ EXC_BREAKPOINT
;
1798 #if defined (SIGINFO)
1799 case TARGET_SIGNAL_INFO
:
1804 #if defined (REALTIME_LO)
1805 if (oursig
>= TARGET_SIGNAL_REALTIME_33
1806 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
1809 (int) oursig
- (int) TARGET_SIGNAL_REALTIME_33
+ REALTIME_LO
;
1810 if (retsig
< REALTIME_HI
)
1814 /* The user might be trying to do "signal SIGSAK" where this system
1815 doesn't have SIGSAK. */
1816 warning ("Signal %s does not exist on this system.\n",
1817 target_signal_to_name (oursig
));
1822 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1823 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1824 translation of that in OURSTATUS. */
1826 store_waitstatus (ourstatus
, hoststatus
)
1827 struct target_waitstatus
*ourstatus
;
1830 #ifdef CHILD_SPECIAL_WAITSTATUS
1831 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1832 if it wants to deal with hoststatus. */
1833 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1837 if (WIFEXITED (hoststatus
))
1839 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1840 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1842 else if (!WIFSTOPPED (hoststatus
))
1844 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1845 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1849 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1850 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1854 /* In some circumstances we allow a command to specify a numeric
1855 signal. The idea is to keep these circumstances limited so that
1856 users (and scripts) develop portable habits. For comparison,
1857 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1858 numeric signal at all is obscelescent. We are slightly more
1859 lenient and allow 1-15 which should match host signal numbers on
1860 most systems. Use of symbolic signal names is strongly encouraged. */
1863 target_signal_from_command (num
)
1866 if (num
>= 1 && num
<= 15)
1867 return (enum target_signal
) num
;
1868 error ("Only signals 1-15 are valid as numeric signals.\n\
1869 Use \"info signals\" for a list of symbolic signals.");
1872 /* Returns zero to leave the inferior alone, one to interrupt it. */
1873 int (*target_activity_function
) PARAMS ((void));
1874 int target_activity_fd
;
1876 /* Convert a normal process ID to a string. Returns the string in a static
1880 normal_pid_to_str (pid
)
1883 static char buf
[30];
1885 if (STREQ (current_target
.to_shortname
, "remote"))
1886 sprintf (buf
, "thread %d\0", pid
);
1888 sprintf (buf
, "process %d\0", pid
);
1893 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1894 notification of inferior events such as fork and vork immediately
1895 after the inferior is created. (This because of how gdb gets an
1896 inferior created via invoking a shell to do it. In such a scenario,
1897 if the shell init file has commands in it, the shell will fork and
1898 exec for each of those commands, and we will see each such fork
1901 This function is used by all targets that allow us to request
1902 notification of forks, etc at inferior creation time; e.g., in
1903 target_acknowledge_forked_child.
1906 normal_target_post_startup_inferior (pid
)
1909 /* This space intentionally left blank. */
1912 /* Set up the handful of non-empty slots needed by the dummy target
1916 init_dummy_target ()
1918 dummy_target
.to_shortname
= "None";
1919 dummy_target
.to_longname
= "None";
1920 dummy_target
.to_doc
= "";
1921 dummy_target
.to_attach
= find_default_attach
;
1922 dummy_target
.to_require_attach
= find_default_require_attach
;
1923 dummy_target
.to_require_detach
= find_default_require_detach
;
1924 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1925 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
1926 dummy_target
.to_stratum
= dummy_stratum
;
1927 dummy_target
.to_magic
= OPS_MAGIC
;
1931 static struct target_ops debug_target
;
1934 debug_to_open (args
, from_tty
)
1938 debug_target
.to_open (args
, from_tty
);
1940 fprintf_unfiltered (gdb_stderr
, "target_open (%s, %d)\n", args
, from_tty
);
1944 debug_to_close (quitting
)
1947 debug_target
.to_close (quitting
);
1949 fprintf_unfiltered (gdb_stderr
, "target_close (%d)\n", quitting
);
1953 debug_to_attach (args
, from_tty
)
1957 debug_target
.to_attach (args
, from_tty
);
1959 fprintf_unfiltered (gdb_stderr
, "target_attach (%s, %d)\n", args
, from_tty
);
1964 debug_to_post_attach (pid
)
1967 debug_target
.to_post_attach (pid
);
1969 fprintf_unfiltered (gdb_stderr
, "target_post_attach (%d)\n", pid
);
1973 debug_to_require_attach (args
, from_tty
)
1977 debug_target
.to_require_attach (args
, from_tty
);
1979 fprintf_unfiltered (gdb_stderr
,
1980 "target_require_attach (%s, %d)\n", args
, from_tty
);
1984 debug_to_detach (args
, from_tty
)
1988 debug_target
.to_detach (args
, from_tty
);
1990 fprintf_unfiltered (gdb_stderr
, "target_detach (%s, %d)\n", args
, from_tty
);
1994 debug_to_require_detach (pid
, args
, from_tty
)
1999 debug_target
.to_require_detach (pid
, args
, from_tty
);
2001 fprintf_unfiltered (gdb_stderr
,
2002 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
2006 debug_to_resume (pid
, step
, siggnal
)
2009 enum target_signal siggnal
;
2011 debug_target
.to_resume (pid
, step
, siggnal
);
2013 fprintf_unfiltered (gdb_stderr
, "target_resume (%d, %s, %s)\n", pid
,
2014 step
? "step" : "continue",
2015 target_signal_to_name (siggnal
));
2019 debug_to_wait (pid
, status
)
2021 struct target_waitstatus
*status
;
2025 retval
= debug_target
.to_wait (pid
, status
);
2027 fprintf_unfiltered (gdb_stderr
,
2028 "target_wait (%d, status) = %d, ", pid
, retval
);
2029 fprintf_unfiltered (gdb_stderr
, "status->kind = ");
2030 switch (status
->kind
)
2032 case TARGET_WAITKIND_EXITED
:
2033 fprintf_unfiltered (gdb_stderr
, "exited, status = %d\n",
2034 status
->value
.integer
);
2036 case TARGET_WAITKIND_STOPPED
:
2037 fprintf_unfiltered (gdb_stderr
, "stopped, signal = %s\n",
2038 target_signal_to_name (status
->value
.sig
));
2040 case TARGET_WAITKIND_SIGNALLED
:
2041 fprintf_unfiltered (gdb_stderr
, "signalled, signal = %s\n",
2042 target_signal_to_name (status
->value
.sig
));
2044 case TARGET_WAITKIND_LOADED
:
2045 fprintf_unfiltered (gdb_stderr
, "loaded\n");
2047 case TARGET_WAITKIND_FORKED
:
2048 fprintf_unfiltered (gdb_stderr
, "forked\n");
2050 case TARGET_WAITKIND_VFORKED
:
2051 fprintf_unfiltered (gdb_stderr
, "vforked\n");
2053 case TARGET_WAITKIND_EXECD
:
2054 fprintf_unfiltered (gdb_stderr
, "execd\n");
2056 case TARGET_WAITKIND_SPURIOUS
:
2057 fprintf_unfiltered (gdb_stderr
, "spurious\n");
2060 fprintf_unfiltered (gdb_stderr
, "unknown???\n");
2068 debug_to_post_wait (pid
, status
)
2072 debug_target
.to_post_wait (pid
, status
);
2074 fprintf_unfiltered (gdb_stderr
, "target_post_wait (%d, %d)\n",
2079 debug_to_fetch_registers (regno
)
2082 debug_target
.to_fetch_registers (regno
);
2084 fprintf_unfiltered (gdb_stderr
, "target_fetch_registers (%s)",
2085 regno
!= -1 ? REGISTER_NAME (regno
) : "-1");
2087 fprintf_unfiltered (gdb_stderr
, " = 0x%x %d",
2088 (unsigned long) read_register (regno
),
2089 read_register (regno
));
2090 fprintf_unfiltered (gdb_stderr
, "\n");
2094 debug_to_store_registers (regno
)
2097 debug_target
.to_store_registers (regno
);
2099 if (regno
>= 0 && regno
< NUM_REGS
)
2100 fprintf_unfiltered (gdb_stderr
, "target_store_registers (%s) = 0x%x %d\n",
2101 REGISTER_NAME (regno
),
2102 (unsigned long) read_register (regno
),
2103 (unsigned long) read_register (regno
));
2105 fprintf_unfiltered (gdb_stderr
, "target_store_registers (%d)\n", regno
);
2109 debug_to_prepare_to_store ()
2111 debug_target
.to_prepare_to_store ();
2113 fprintf_unfiltered (gdb_stderr
, "target_prepare_to_store ()\n");
2117 debug_to_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2122 struct target_ops
*target
;
2126 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
2128 fprintf_unfiltered (gdb_stderr
,
2129 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2130 (unsigned int) memaddr
, /* possable truncate long long */
2131 len
, write
? "write" : "read", retval
);
2139 fputs_unfiltered (", bytes =", gdb_stderr
);
2140 for (i
= 0; i
< retval
; i
++)
2142 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2143 fprintf_unfiltered (gdb_stderr
, "\n");
2144 fprintf_unfiltered (gdb_stderr
, " %02x", myaddr
[i
] & 0xff);
2148 fputc_unfiltered ('\n', gdb_stderr
);
2154 debug_to_files_info (target
)
2155 struct target_ops
*target
;
2157 debug_target
.to_files_info (target
);
2159 fprintf_unfiltered (gdb_stderr
, "target_files_info (xxx)\n");
2163 debug_to_insert_breakpoint (addr
, save
)
2169 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2171 fprintf_unfiltered (gdb_stderr
,
2172 "target_insert_breakpoint (0x%x, xxx) = %d\n",
2173 (unsigned long) addr
, retval
);
2178 debug_to_remove_breakpoint (addr
, save
)
2184 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2186 fprintf_unfiltered (gdb_stderr
,
2187 "target_remove_breakpoint (0x%x, xxx) = %d\n",
2188 (unsigned long) addr
, retval
);
2193 debug_to_terminal_init ()
2195 debug_target
.to_terminal_init ();
2197 fprintf_unfiltered (gdb_stderr
, "target_terminal_init ()\n");
2201 debug_to_terminal_inferior ()
2203 debug_target
.to_terminal_inferior ();
2205 fprintf_unfiltered (gdb_stderr
, "target_terminal_inferior ()\n");
2209 debug_to_terminal_ours_for_output ()
2211 debug_target
.to_terminal_ours_for_output ();
2213 fprintf_unfiltered (gdb_stderr
, "target_terminal_ours_for_output ()\n");
2217 debug_to_terminal_ours ()
2219 debug_target
.to_terminal_ours ();
2221 fprintf_unfiltered (gdb_stderr
, "target_terminal_ours ()\n");
2225 debug_to_terminal_info (arg
, from_tty
)
2229 debug_target
.to_terminal_info (arg
, from_tty
);
2231 fprintf_unfiltered (gdb_stderr
, "target_terminal_info (%s, %d)\n", arg
,
2238 debug_target
.to_kill ();
2240 fprintf_unfiltered (gdb_stderr
, "target_kill ()\n");
2244 debug_to_load (args
, from_tty
)
2248 debug_target
.to_load (args
, from_tty
);
2250 fprintf_unfiltered (gdb_stderr
, "target_load (%s, %d)\n", args
, from_tty
);
2254 debug_to_lookup_symbol (name
, addrp
)
2260 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2262 fprintf_unfiltered (gdb_stderr
, "target_lookup_symbol (%s, xxx)\n", name
);
2268 debug_to_create_inferior (exec_file
, args
, env
)
2273 debug_target
.to_create_inferior (exec_file
, args
, env
);
2275 fprintf_unfiltered (gdb_stderr
, "target_create_inferior (%s, %s, xxx)\n",
2280 debug_to_post_startup_inferior (pid
)
2283 debug_target
.to_post_startup_inferior (pid
);
2285 fprintf_unfiltered (gdb_stderr
, "target_post_startup_inferior (%d)\n",
2290 debug_to_acknowledge_created_inferior (pid
)
2293 debug_target
.to_acknowledge_created_inferior (pid
);
2295 fprintf_unfiltered (gdb_stderr
, "target_acknowledge_created_inferior (%d)\n",
2300 debug_to_clone_and_follow_inferior (child_pid
, followed_child
)
2302 int *followed_child
;
2304 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
2306 fprintf_unfiltered (gdb_stderr
,
2307 "target_clone_and_follow_inferior (%d, %d)\n",
2308 child_pid
, *followed_child
);
2312 debug_to_post_follow_inferior_by_clone ()
2314 debug_target
.to_post_follow_inferior_by_clone ();
2316 fprintf_unfiltered (gdb_stderr
, "target_post_follow_inferior_by_clone ()\n");
2320 debug_to_insert_fork_catchpoint (pid
)
2325 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2327 fprintf_unfiltered (gdb_stderr
, "target_insert_fork_catchpoint (%d) = %d\n",
2334 debug_to_remove_fork_catchpoint (pid
)
2339 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2341 fprintf_unfiltered (gdb_stderr
, "target_remove_fork_catchpoint (%d) = %d\n",
2348 debug_to_insert_vfork_catchpoint (pid
)
2353 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2355 fprintf_unfiltered (gdb_stderr
, "target_insert_vfork_catchpoint (%d)= %d\n",
2362 debug_to_remove_vfork_catchpoint (pid
)
2367 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2369 fprintf_unfiltered (gdb_stderr
, "target_remove_vfork_catchpoint (%d) = %d\n",
2376 debug_to_has_forked (pid
, child_pid
)
2382 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
2384 fprintf_unfiltered (gdb_stderr
, "target_has_forked (%d, %d) = %d\n",
2385 pid
, *child_pid
, has_forked
);
2391 debug_to_has_vforked (pid
, child_pid
)
2397 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
2399 fprintf_unfiltered (gdb_stderr
, "target_has_vforked (%d, %d) = %d\n",
2400 pid
, *child_pid
, has_vforked
);
2406 debug_to_can_follow_vfork_prior_to_exec ()
2408 int can_immediately_follow_vfork
;
2410 can_immediately_follow_vfork
= debug_target
.to_can_follow_vfork_prior_to_exec ();
2412 fprintf_unfiltered (gdb_stderr
, "target_can_follow_vfork_prior_to_exec () = %d\n",
2413 can_immediately_follow_vfork
);
2415 return can_immediately_follow_vfork
;
2419 debug_to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
)
2421 int followed_parent
;
2425 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
2427 fprintf_unfiltered (gdb_stderr
,
2428 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2429 parent_pid
, followed_parent
, child_pid
, followed_child
);
2433 debug_to_insert_exec_catchpoint (pid
)
2438 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2440 fprintf_unfiltered (gdb_stderr
, "target_insert_exec_catchpoint (%d) = %d\n",
2447 debug_to_remove_exec_catchpoint (pid
)
2452 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2454 fprintf_unfiltered (gdb_stderr
, "target_remove_exec_catchpoint (%d) = %d\n",
2461 debug_to_has_execd (pid
, execd_pathname
)
2463 char **execd_pathname
;
2467 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2469 fprintf_unfiltered (gdb_stderr
, "target_has_execd (%d, %s) = %d\n",
2470 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
2477 debug_to_reported_exec_events_per_exec_call ()
2479 int reported_exec_events
;
2481 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2483 fprintf_unfiltered (gdb_stderr
,
2484 "target_reported_exec_events_per_exec_call () = %d\n",
2485 reported_exec_events
);
2487 return reported_exec_events
;
2491 debug_to_has_syscall_event (pid
, kind
, syscall_id
)
2493 enum target_waitkind
*kind
;
2496 int has_syscall_event
;
2497 char *kind_spelling
= "??";
2499 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2500 if (has_syscall_event
)
2504 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2505 kind_spelling
= "SYSCALL_ENTRY";
2507 case TARGET_WAITKIND_SYSCALL_RETURN
:
2508 kind_spelling
= "SYSCALL_RETURN";
2515 fprintf_unfiltered (gdb_stderr
,
2516 "target_has_syscall_event (%d, %s, %d) = %d\n",
2517 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2519 return has_syscall_event
;
2523 debug_to_has_exited (pid
, wait_status
, exit_status
)
2530 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2532 fprintf_unfiltered (gdb_stderr
, "target_has_exited (%d, %d, %d) = %d\n",
2533 pid
, wait_status
, *exit_status
, has_exited
);
2539 debug_to_mourn_inferior ()
2541 debug_target
.to_mourn_inferior ();
2543 fprintf_unfiltered (gdb_stderr
, "target_mourn_inferior ()\n");
2551 retval
= debug_target
.to_can_run ();
2553 fprintf_unfiltered (gdb_stderr
, "target_can_run () = %d\n", retval
);
2559 debug_to_notice_signals (pid
)
2562 debug_target
.to_notice_signals (pid
);
2564 fprintf_unfiltered (gdb_stderr
, "target_notice_signals (%d)\n", pid
);
2568 debug_to_thread_alive (pid
)
2573 retval
= debug_target
.to_thread_alive (pid
);
2575 fprintf_unfiltered (gdb_stderr
, "target_thread_alive (%d) = %d\n",
2584 debug_target
.to_stop ();
2586 fprintf_unfiltered (gdb_stderr
, "target_stop ()\n");
2590 debug_to_query (type
, req
, resp
, siz
)
2598 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2600 fprintf_unfiltered (gdb_stderr
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2605 static struct symtab_and_line
*
2606 debug_to_enable_exception_callback (kind
, enable
)
2607 enum exception_event_kind kind
;
2610 struct symtab_and_line
*result
;
2611 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2612 fprintf_unfiltered (gdb_stderr
,
2613 "target get_exception_callback_sal (%d, %d)\n",
2618 static struct exception_event_record
*
2619 debug_to_get_current_exception_event ()
2621 struct exception_event_record
*result
;
2622 result
= debug_target
.to_get_current_exception_event ();
2623 fprintf_unfiltered (gdb_stderr
, "target get_current_exception_event ()\n");
2628 debug_to_pid_to_exec_file (pid
)
2633 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2635 fprintf_unfiltered (gdb_stderr
, "target_pid_to_exec_file (%d) = %s\n",
2642 debug_to_core_file_to_sym_file (core
)
2647 sym_file
= debug_target
.to_core_file_to_sym_file (core
);
2649 fprintf_unfiltered (gdb_stderr
, "target_core_file_to_sym_file (%s) = %s\n",
2656 setup_target_debug ()
2658 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2660 current_target
.to_open
= debug_to_open
;
2661 current_target
.to_close
= debug_to_close
;
2662 current_target
.to_attach
= debug_to_attach
;
2663 current_target
.to_post_attach
= debug_to_post_attach
;
2664 current_target
.to_require_attach
= debug_to_require_attach
;
2665 current_target
.to_detach
= debug_to_detach
;
2666 current_target
.to_require_detach
= debug_to_require_detach
;
2667 current_target
.to_resume
= debug_to_resume
;
2668 current_target
.to_wait
= debug_to_wait
;
2669 current_target
.to_post_wait
= debug_to_post_wait
;
2670 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2671 current_target
.to_store_registers
= debug_to_store_registers
;
2672 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2673 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2674 current_target
.to_files_info
= debug_to_files_info
;
2675 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2676 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2677 current_target
.to_terminal_init
= debug_to_terminal_init
;
2678 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2679 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2680 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2681 current_target
.to_terminal_info
= debug_to_terminal_info
;
2682 current_target
.to_kill
= debug_to_kill
;
2683 current_target
.to_load
= debug_to_load
;
2684 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2685 current_target
.to_create_inferior
= debug_to_create_inferior
;
2686 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2687 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2688 current_target
.to_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2689 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2690 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2691 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2692 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2693 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2694 current_target
.to_has_forked
= debug_to_has_forked
;
2695 current_target
.to_has_vforked
= debug_to_has_vforked
;
2696 current_target
.to_can_follow_vfork_prior_to_exec
= debug_to_can_follow_vfork_prior_to_exec
;
2697 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2698 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2699 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2700 current_target
.to_has_execd
= debug_to_has_execd
;
2701 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2702 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2703 current_target
.to_has_exited
= debug_to_has_exited
;
2704 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2705 current_target
.to_can_run
= debug_to_can_run
;
2706 current_target
.to_notice_signals
= debug_to_notice_signals
;
2707 current_target
.to_thread_alive
= debug_to_thread_alive
;
2708 current_target
.to_stop
= debug_to_stop
;
2709 current_target
.to_query
= debug_to_query
;
2710 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2711 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2712 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2713 current_target
.to_core_file_to_sym_file
= debug_to_core_file_to_sym_file
;
2718 static char targ_desc
[] =
2719 "Names of targets and files being debugged.\n\
2720 Shows the entire stack of targets currently in use (including the exec-file,\n\
2721 core-file, and process, if any), as well as the symbol file name.";
2724 initialize_targets ()
2726 init_dummy_target ();
2727 push_target (&dummy_target
);
2729 add_info ("target", target_info
, targ_desc
);
2730 add_info ("files", target_info
, targ_desc
);
2733 add_set_cmd ("targetdebug", class_maintenance
, var_zinteger
,
2734 (char *) &targetdebug
,
2735 "Set target debugging.\n\
2736 When non-zero, target debugging is enabled.", &setlist
),
2739 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))