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_rcmd
, (void (*) (char *, struct gdb_file
*)) tcomplain
);
448 de_fault (to_enable_exception_callback
, (struct symtab_and_line
* (*)PARAMS ((enum exception_event_kind
, int))) nosupport_runtime
);
449 de_fault (to_get_current_exception_event
, (struct exception_event_record
* (*)PARAMS ((void))) nosupport_runtime
);
451 de_fault (to_pid_to_exec_file
, (char *(*)PARAMS ((int))) return_zero
);
452 de_fault (to_core_file_to_sym_file
, (char *(*)PARAMS ((char *))) return_zero
);
456 /* Go through the target stack from top to bottom, copying over zero entries in
457 current_target. In effect, we are doing class inheritance through the
458 pushed target vectors. */
461 update_current_target ()
463 struct target_stack_item
*item
;
464 struct target_ops
*t
;
466 /* First, reset current_target */
467 memset (¤t_target
, 0, sizeof current_target
);
469 for (item
= target_stack
; item
; item
= item
->next
)
471 t
= item
->target_ops
;
473 #define INHERIT(FIELD, TARGET) \
474 if (!current_target.FIELD) \
475 current_target.FIELD = TARGET->FIELD
477 INHERIT (to_shortname
, t
);
478 INHERIT (to_longname
, t
);
480 INHERIT (to_open
, t
);
481 INHERIT (to_close
, t
);
482 INHERIT (to_attach
, t
);
483 INHERIT (to_post_attach
, t
);
484 INHERIT (to_require_attach
, t
);
485 INHERIT (to_detach
, t
);
486 INHERIT (to_require_detach
, t
);
487 INHERIT (to_resume
, t
);
488 INHERIT (to_wait
, t
);
489 INHERIT (to_post_wait
, t
);
490 INHERIT (to_fetch_registers
, t
);
491 INHERIT (to_store_registers
, t
);
492 INHERIT (to_prepare_to_store
, t
);
493 INHERIT (to_xfer_memory
, t
);
494 INHERIT (to_files_info
, t
);
495 INHERIT (to_insert_breakpoint
, t
);
496 INHERIT (to_remove_breakpoint
, t
);
497 INHERIT (to_terminal_init
, t
);
498 INHERIT (to_terminal_inferior
, t
);
499 INHERIT (to_terminal_ours_for_output
, t
);
500 INHERIT (to_terminal_ours
, t
);
501 INHERIT (to_terminal_info
, t
);
502 INHERIT (to_kill
, t
);
503 INHERIT (to_load
, t
);
504 INHERIT (to_lookup_symbol
, t
);
505 INHERIT (to_create_inferior
, t
);
506 INHERIT (to_post_startup_inferior
, t
);
507 INHERIT (to_acknowledge_created_inferior
, t
);
508 INHERIT (to_clone_and_follow_inferior
, t
);
509 INHERIT (to_post_follow_inferior_by_clone
, t
);
510 INHERIT (to_insert_fork_catchpoint
, t
);
511 INHERIT (to_remove_fork_catchpoint
, t
);
512 INHERIT (to_insert_vfork_catchpoint
, t
);
513 INHERIT (to_remove_vfork_catchpoint
, t
);
514 INHERIT (to_has_forked
, t
);
515 INHERIT (to_has_vforked
, t
);
516 INHERIT (to_can_follow_vfork_prior_to_exec
, t
);
517 INHERIT (to_post_follow_vfork
, t
);
518 INHERIT (to_insert_exec_catchpoint
, t
);
519 INHERIT (to_remove_exec_catchpoint
, t
);
520 INHERIT (to_has_execd
, t
);
521 INHERIT (to_reported_exec_events_per_exec_call
, t
);
522 INHERIT (to_has_syscall_event
, t
);
523 INHERIT (to_has_exited
, t
);
524 INHERIT (to_mourn_inferior
, t
);
525 INHERIT (to_can_run
, t
);
526 INHERIT (to_notice_signals
, t
);
527 INHERIT (to_thread_alive
, t
);
528 INHERIT (to_find_new_threads
, t
);
529 INHERIT (to_stop
, t
);
530 INHERIT (to_query
, t
);
531 INHERIT (to_rcmd
, t
);
532 INHERIT (to_enable_exception_callback
, t
);
533 INHERIT (to_get_current_exception_event
, t
);
534 INHERIT (to_pid_to_exec_file
, t
);
535 INHERIT (to_core_file_to_sym_file
, t
);
536 INHERIT (to_stratum
, t
);
537 INHERIT (DONT_USE
, t
);
538 INHERIT (to_has_all_memory
, t
);
539 INHERIT (to_has_memory
, t
);
540 INHERIT (to_has_stack
, t
);
541 INHERIT (to_has_registers
, t
);
542 INHERIT (to_has_execution
, t
);
543 INHERIT (to_has_thread_control
, t
);
544 INHERIT (to_has_async_exec
, t
);
545 INHERIT (to_sections
, t
);
546 INHERIT (to_sections_end
, t
);
547 INHERIT (to_magic
, t
);
553 /* Push a new target type into the stack of the existing target accessors,
554 possibly superseding some of the existing accessors.
556 Result is zero if the pushed target ended up on top of the stack,
557 nonzero if at least one target is on top of it.
559 Rather than allow an empty stack, we always have the dummy target at
560 the bottom stratum, so we can call the function vectors without
565 struct target_ops
*t
;
567 struct target_stack_item
*cur
, *prev
, *tmp
;
569 /* Check magic number. If wrong, it probably means someone changed
570 the struct definition, but not all the places that initialize one. */
571 if (t
->to_magic
!= OPS_MAGIC
)
573 fprintf_unfiltered (gdb_stderr
,
574 "Magic number of %s target struct wrong\n",
579 /* Find the proper stratum to install this target in. */
581 for (prev
= NULL
, cur
= target_stack
; cur
; prev
= cur
, cur
= cur
->next
)
583 if ((int) (t
->to_stratum
) >= (int) (cur
->target_ops
->to_stratum
))
587 /* If there's already targets at this stratum, remove them. */
590 while (t
->to_stratum
== cur
->target_ops
->to_stratum
)
592 /* There's already something on this stratum. Close it off. */
593 if (cur
->target_ops
->to_close
)
594 (cur
->target_ops
->to_close
) (0);
596 prev
->next
= cur
->next
; /* Unchain old target_ops */
598 target_stack
= cur
->next
; /* Unchain first on list */
604 /* We have removed all targets in our stratum, now add the new one. */
606 tmp
= (struct target_stack_item
*)
607 xmalloc (sizeof (struct target_stack_item
));
616 update_current_target ();
618 cleanup_target (¤t_target
); /* Fill in the gaps */
621 setup_target_debug ();
626 /* Remove a target_ops vector from the stack, wherever it may be.
627 Return how many times it was removed (0 or 1). */
631 struct target_ops
*t
;
633 struct target_stack_item
*cur
, *prev
;
636 t
->to_close (0); /* Let it clean up */
638 /* Look for the specified target. Note that we assume that a target
639 can only occur once in the target stack. */
641 for (cur
= target_stack
, prev
= NULL
; cur
; prev
= cur
, cur
= cur
->next
)
642 if (cur
->target_ops
== t
)
646 return 0; /* Didn't find target_ops, quit now */
648 /* Unchain the target */
651 target_stack
= cur
->next
;
653 prev
->next
= cur
->next
;
655 free (cur
); /* Release the target_stack_item */
657 update_current_target ();
658 cleanup_target (¤t_target
);
666 (current_target
.to_close
) (0); /* Let it clean up */
667 if (unpush_target (target_stack
->target_ops
) == 1)
670 fprintf_unfiltered (gdb_stderr
,
671 "pop_target couldn't find target %s\n",
672 current_target
.to_shortname
);
677 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
679 /* target_read_string -- read a null terminated string, up to LEN bytes,
680 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
681 Set *STRING to a pointer to malloc'd memory containing the data; the caller
682 is responsible for freeing it. Return the number of bytes successfully
686 target_read_string (memaddr
, string
, len
, errnop
)
692 int tlen
, origlen
, offset
, i
;
696 int buffer_allocated
;
698 unsigned int nbytes_read
= 0;
700 /* Small for testing. */
701 buffer_allocated
= 4;
702 buffer
= xmalloc (buffer_allocated
);
709 tlen
= MIN (len
, 4 - (memaddr
& 3));
710 offset
= memaddr
& 3;
712 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0, NULL
);
715 /* The transfer request might have crossed the boundary to an
716 unallocated region of memory. Retry the transfer, requesting
720 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0, NULL
);
725 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
728 bytes
= bufptr
- buffer
;
729 buffer_allocated
*= 2;
730 buffer
= xrealloc (buffer
, buffer_allocated
);
731 bufptr
= buffer
+ bytes
;
734 for (i
= 0; i
< tlen
; i
++)
736 *bufptr
++ = buf
[i
+ offset
];
737 if (buf
[i
+ offset
] == '\000')
739 nbytes_read
+= i
+ 1;
756 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
757 GDB's memory at MYADDR. Returns either 0 for success or an errno value
760 If an error occurs, no guarantee is made about the contents of the data at
761 MYADDR. In particular, the caller should not depend upon partial reads
762 filling the buffer with good data. There is no way for the caller to know
763 how much good data might have been transfered anyway. Callers that can
764 deal with partial reads should call target_read_memory_partial. */
767 target_read_memory (memaddr
, myaddr
, len
)
772 return target_xfer_memory (memaddr
, myaddr
, len
, 0, NULL
);
776 target_read_memory_section (memaddr
, myaddr
, len
, bfd_section
)
780 asection
*bfd_section
;
782 return target_xfer_memory (memaddr
, myaddr
, len
, 0, bfd_section
);
785 /* Read LEN bytes of target memory at address MEMADDR, placing the results
786 in GDB's memory at MYADDR. Returns a count of the bytes actually read,
787 and optionally an errno value in the location pointed to by ERRNOPTR
788 if ERRNOPTR is non-null. */
791 target_read_memory_partial (memaddr
, myaddr
, len
, errnoptr
)
797 int nread
; /* Number of bytes actually read. */
798 int errcode
; /* Error from last read. */
800 /* First try a complete read. */
801 errcode
= target_xfer_memory (memaddr
, myaddr
, len
, 0, NULL
);
809 /* Loop, reading one byte at a time until we get as much as we can. */
810 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
812 errcode
= target_xfer_memory (memaddr
++, myaddr
++, 1, 0, NULL
);
814 /* If an error, the last read was unsuccessful, so adjust count. */
820 if (errnoptr
!= NULL
)
828 target_write_memory (memaddr
, myaddr
, len
)
833 return target_xfer_memory (memaddr
, myaddr
, len
, 1, NULL
);
836 /* This variable is used to pass section information down to targets. This
837 *should* be done by adding an argument to the target_xfer_memory function
838 of all the targets, but I didn't feel like changing 50+ files. */
840 asection
*target_memory_bfd_section
= NULL
;
842 /* Move memory to or from the targets. Iterate until all of it has
843 been moved, if necessary. The top target gets priority; anything
844 it doesn't want, is offered to the next one down, etc. Note the
845 business with curlen: if an early target says "no, but I have a
846 boundary overlapping this xfer" then we shorten what we offer to
847 the subsequent targets so the early guy will get a chance at the
848 tail before the subsequent ones do.
850 Result is 0 or errno value. */
853 target_xfer_memory (memaddr
, myaddr
, len
, write
, bfd_section
)
858 asection
*bfd_section
;
862 struct target_ops
*t
;
863 struct target_stack_item
*item
;
865 /* Zero length requests are ok and require no work. */
869 target_memory_bfd_section
= bfd_section
;
871 /* to_xfer_memory is not guaranteed to set errno, even when it returns
875 /* The quick case is that the top target does it all. */
876 res
= current_target
.to_xfer_memory
877 (memaddr
, myaddr
, len
, write
, ¤t_target
);
883 /* If res <= 0 then we call it again in the loop. Ah well. */
887 curlen
= len
; /* Want to do it all */
888 for (item
= target_stack
; item
; item
= item
->next
)
890 t
= item
->target_ops
;
891 if (!t
->to_has_memory
)
894 res
= t
->to_xfer_memory (memaddr
, myaddr
, curlen
, write
, t
);
896 break; /* Handled all or part of xfer */
897 if (t
->to_has_all_memory
)
903 /* If this address is for nonexistent memory,
904 read zeros if reading, or do nothing if writing. Return error. */
906 memset (myaddr
, 0, len
);
917 return 0; /* We managed to cover it all somehow. */
923 target_info (args
, from_tty
)
927 struct target_ops
*t
;
928 struct target_stack_item
*item
;
931 if (symfile_objfile
!= NULL
)
932 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
934 #ifdef FILES_INFO_HOOK
935 if (FILES_INFO_HOOK ())
939 for (item
= target_stack
; item
; item
= item
->next
)
941 t
= item
->target_ops
;
943 if (!t
->to_has_memory
)
946 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
949 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
950 printf_unfiltered ("%s:\n", t
->to_longname
);
951 (t
->to_files_info
) (t
);
952 has_all_mem
= t
->to_has_all_memory
;
956 /* This is to be called by the open routine before it does
960 target_preopen (from_tty
)
965 if (target_has_execution
)
968 || query ("A program is being debugged already. Kill it? "))
971 error ("Program not killed.");
974 /* Calling target_kill may remove the target from the stack. But if
975 it doesn't (which seems like a win for UDI), remove it now. */
977 if (target_has_execution
)
981 /* Detach a target after doing deferred register stores. */
984 target_detach (args
, from_tty
)
988 /* Handle any optimized stores to the inferior. */
989 #ifdef DO_DEFERRED_STORES
992 (current_target
.to_detach
) (args
, from_tty
);
996 target_link (modname
, t_reloc
)
1000 if (STREQ (current_target
.to_shortname
, "rombug"))
1002 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1004 error ("Unable to link to %s and get relocation in rombug", modname
);
1007 *t_reloc
= (CORE_ADDR
) - 1;
1010 /* Look through the list of possible targets for a target that can
1011 execute a run or attach command without any other data. This is
1012 used to locate the default process stratum.
1014 Result is always valid (error() is called for errors). */
1016 static struct target_ops
*
1017 find_default_run_target (do_mesg
)
1020 struct target_ops
**t
;
1021 struct target_ops
*runable
= NULL
;
1026 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1029 if ((*t
)->to_can_run
&& target_can_run (*t
))
1037 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1043 find_default_attach (args
, from_tty
)
1047 struct target_ops
*t
;
1049 t
= find_default_run_target ("attach");
1050 (t
->to_attach
) (args
, from_tty
);
1055 find_default_require_attach (args
, from_tty
)
1059 struct target_ops
*t
;
1061 t
= find_default_run_target ("require_attach");
1062 (t
->to_require_attach
) (args
, from_tty
);
1067 find_default_require_detach (pid
, args
, from_tty
)
1072 struct target_ops
*t
;
1074 t
= find_default_run_target ("require_detach");
1075 (t
->to_require_detach
) (pid
, args
, from_tty
);
1080 find_default_create_inferior (exec_file
, allargs
, env
)
1085 struct target_ops
*t
;
1087 t
= find_default_run_target ("run");
1088 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1093 find_default_clone_and_follow_inferior (child_pid
, followed_child
)
1095 int *followed_child
;
1097 struct target_ops
*t
;
1099 t
= find_default_run_target ("run");
1100 (t
->to_clone_and_follow_inferior
) (child_pid
, followed_child
);
1116 /* Find a single runnable target in the stack and return it. If for
1117 some reason there is more than one, return NULL. */
1122 struct target_ops
**t
;
1123 struct target_ops
*runable
= NULL
;
1128 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1130 if ((*t
)->to_can_run
&& target_can_run (*t
))
1137 return (count
== 1 ? runable
: NULL
);
1143 struct target_ops
**t
;
1144 struct target_ops
*runable
= NULL
;
1149 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1152 if ((*t
)->to_stratum
== core_stratum
)
1159 return (count
== 1 ? runable
: NULL
);
1162 /* The inferior process has died. Long live the inferior! */
1165 generic_mourn_inferior ()
1167 extern int show_breakpoint_hit_counts
;
1171 breakpoint_init_inferior (inf_exited
);
1172 registers_changed ();
1174 #ifdef CLEAR_DEFERRED_STORES
1175 /* Delete any pending stores to the inferior... */
1176 CLEAR_DEFERRED_STORES
;
1179 reopen_exec_file ();
1180 reinit_frame_cache ();
1182 /* It is confusing to the user for ignore counts to stick around
1183 from previous runs of the inferior. So clear them. */
1184 /* However, it is more confusing for the ignore counts to disappear when
1185 using hit counts. So don't clear them if we're counting hits. */
1186 if (!show_breakpoint_hit_counts
)
1187 breakpoint_clear_ignore_counts ();
1190 /* This table must match in order and size the signals in enum target_signal
1199 {"SIGHUP", "Hangup"},
1200 {"SIGINT", "Interrupt"},
1201 {"SIGQUIT", "Quit"},
1202 {"SIGILL", "Illegal instruction"},
1203 {"SIGTRAP", "Trace/breakpoint trap"},
1204 {"SIGABRT", "Aborted"},
1205 {"SIGEMT", "Emulation trap"},
1206 {"SIGFPE", "Arithmetic exception"},
1207 {"SIGKILL", "Killed"},
1208 {"SIGBUS", "Bus error"},
1209 {"SIGSEGV", "Segmentation fault"},
1210 {"SIGSYS", "Bad system call"},
1211 {"SIGPIPE", "Broken pipe"},
1212 {"SIGALRM", "Alarm clock"},
1213 {"SIGTERM", "Terminated"},
1214 {"SIGURG", "Urgent I/O condition"},
1215 {"SIGSTOP", "Stopped (signal)"},
1216 {"SIGTSTP", "Stopped (user)"},
1217 {"SIGCONT", "Continued"},
1218 {"SIGCHLD", "Child status changed"},
1219 {"SIGTTIN", "Stopped (tty input)"},
1220 {"SIGTTOU", "Stopped (tty output)"},
1221 {"SIGIO", "I/O possible"},
1222 {"SIGXCPU", "CPU time limit exceeded"},
1223 {"SIGXFSZ", "File size limit exceeded"},
1224 {"SIGVTALRM", "Virtual timer expired"},
1225 {"SIGPROF", "Profiling timer expired"},
1226 {"SIGWINCH", "Window size changed"},
1227 {"SIGLOST", "Resource lost"},
1228 {"SIGUSR1", "User defined signal 1"},
1229 {"SIGUSR2", "User defined signal 2"},
1230 {"SIGPWR", "Power fail/restart"},
1231 {"SIGPOLL", "Pollable event occurred"},
1232 {"SIGWIND", "SIGWIND"},
1233 {"SIGPHONE", "SIGPHONE"},
1234 {"SIGWAITING", "Process's LWPs are blocked"},
1235 {"SIGLWP", "Signal LWP"},
1236 {"SIGDANGER", "Swap space dangerously low"},
1237 {"SIGGRANT", "Monitor mode granted"},
1238 {"SIGRETRACT", "Need to relinquish monitor mode"},
1239 {"SIGMSG", "Monitor mode data available"},
1240 {"SIGSOUND", "Sound completed"},
1241 {"SIGSAK", "Secure attention"},
1242 {"SIGPRIO", "SIGPRIO"},
1243 {"SIG33", "Real-time event 33"},
1244 {"SIG34", "Real-time event 34"},
1245 {"SIG35", "Real-time event 35"},
1246 {"SIG36", "Real-time event 36"},
1247 {"SIG37", "Real-time event 37"},
1248 {"SIG38", "Real-time event 38"},
1249 {"SIG39", "Real-time event 39"},
1250 {"SIG40", "Real-time event 40"},
1251 {"SIG41", "Real-time event 41"},
1252 {"SIG42", "Real-time event 42"},
1253 {"SIG43", "Real-time event 43"},
1254 {"SIG44", "Real-time event 44"},
1255 {"SIG45", "Real-time event 45"},
1256 {"SIG46", "Real-time event 46"},
1257 {"SIG47", "Real-time event 47"},
1258 {"SIG48", "Real-time event 48"},
1259 {"SIG49", "Real-time event 49"},
1260 {"SIG50", "Real-time event 50"},
1261 {"SIG51", "Real-time event 51"},
1262 {"SIG52", "Real-time event 52"},
1263 {"SIG53", "Real-time event 53"},
1264 {"SIG54", "Real-time event 54"},
1265 {"SIG55", "Real-time event 55"},
1266 {"SIG56", "Real-time event 56"},
1267 {"SIG57", "Real-time event 57"},
1268 {"SIG58", "Real-time event 58"},
1269 {"SIG59", "Real-time event 59"},
1270 {"SIG60", "Real-time event 60"},
1271 {"SIG61", "Real-time event 61"},
1272 {"SIG62", "Real-time event 62"},
1273 {"SIG63", "Real-time event 63"},
1274 {"SIGCANCEL", "LWP internal signal"},
1275 {"SIG32", "Real-time event 32"},
1277 #if defined(MACH) || defined(__MACH__)
1278 /* Mach exceptions */
1279 {"EXC_BAD_ACCESS", "Could not access memory"},
1280 {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1281 {"EXC_ARITHMETIC", "Arithmetic exception"},
1282 {"EXC_EMULATION", "Emulation instruction"},
1283 {"EXC_SOFTWARE", "Software generated exception"},
1284 {"EXC_BREAKPOINT", "Breakpoint"},
1286 {"SIGINFO", "Information request"},
1288 {NULL
, "Unknown signal"},
1289 {NULL
, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1291 /* Last entry, used to check whether the table is the right size. */
1292 {NULL
, "TARGET_SIGNAL_MAGIC"}
1298 /* Return the string for a signal. */
1300 target_signal_to_string (sig
)
1301 enum target_signal sig
;
1303 if ((sig
>= TARGET_SIGNAL_FIRST
) && (sig
<= TARGET_SIGNAL_LAST
))
1304 return signals
[sig
].string
;
1306 return signals
[TARGET_SIGNAL_UNKNOWN
].string
;
1309 /* Return the name for a signal. */
1311 target_signal_to_name (sig
)
1312 enum target_signal sig
;
1314 if (sig
== TARGET_SIGNAL_UNKNOWN
)
1315 /* I think the code which prints this will always print it along with
1316 the string, so no need to be verbose. */
1318 return signals
[sig
].name
;
1321 /* Given a name, return its signal. */
1323 target_signal_from_name (name
)
1326 enum target_signal sig
;
1328 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1329 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
1330 questionable; seems like by now people should call it SIGABRT
1333 /* This ugly cast brought to you by the native VAX compiler. */
1334 for (sig
= TARGET_SIGNAL_HUP
;
1335 signals
[sig
].name
!= NULL
;
1336 sig
= (enum target_signal
) ((int) sig
+ 1))
1337 if (STREQ (name
, signals
[sig
].name
))
1339 return TARGET_SIGNAL_UNKNOWN
;
1342 /* The following functions are to help certain targets deal
1343 with the signal/waitstatus stuff. They could just as well be in
1344 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
1346 /* Convert host signal to our signals. */
1348 target_signal_from_host (hostsig
)
1351 /* A switch statement would make sense but would require special kludges
1352 to deal with the cases where more than one signal has the same number. */
1355 return TARGET_SIGNAL_0
;
1357 #if defined (SIGHUP)
1358 if (hostsig
== SIGHUP
)
1359 return TARGET_SIGNAL_HUP
;
1361 #if defined (SIGINT)
1362 if (hostsig
== SIGINT
)
1363 return TARGET_SIGNAL_INT
;
1365 #if defined (SIGQUIT)
1366 if (hostsig
== SIGQUIT
)
1367 return TARGET_SIGNAL_QUIT
;
1369 #if defined (SIGILL)
1370 if (hostsig
== SIGILL
)
1371 return TARGET_SIGNAL_ILL
;
1373 #if defined (SIGTRAP)
1374 if (hostsig
== SIGTRAP
)
1375 return TARGET_SIGNAL_TRAP
;
1377 #if defined (SIGABRT)
1378 if (hostsig
== SIGABRT
)
1379 return TARGET_SIGNAL_ABRT
;
1381 #if defined (SIGEMT)
1382 if (hostsig
== SIGEMT
)
1383 return TARGET_SIGNAL_EMT
;
1385 #if defined (SIGFPE)
1386 if (hostsig
== SIGFPE
)
1387 return TARGET_SIGNAL_FPE
;
1389 #if defined (SIGKILL)
1390 if (hostsig
== SIGKILL
)
1391 return TARGET_SIGNAL_KILL
;
1393 #if defined (SIGBUS)
1394 if (hostsig
== SIGBUS
)
1395 return TARGET_SIGNAL_BUS
;
1397 #if defined (SIGSEGV)
1398 if (hostsig
== SIGSEGV
)
1399 return TARGET_SIGNAL_SEGV
;
1401 #if defined (SIGSYS)
1402 if (hostsig
== SIGSYS
)
1403 return TARGET_SIGNAL_SYS
;
1405 #if defined (SIGPIPE)
1406 if (hostsig
== SIGPIPE
)
1407 return TARGET_SIGNAL_PIPE
;
1409 #if defined (SIGALRM)
1410 if (hostsig
== SIGALRM
)
1411 return TARGET_SIGNAL_ALRM
;
1413 #if defined (SIGTERM)
1414 if (hostsig
== SIGTERM
)
1415 return TARGET_SIGNAL_TERM
;
1417 #if defined (SIGUSR1)
1418 if (hostsig
== SIGUSR1
)
1419 return TARGET_SIGNAL_USR1
;
1421 #if defined (SIGUSR2)
1422 if (hostsig
== SIGUSR2
)
1423 return TARGET_SIGNAL_USR2
;
1425 #if defined (SIGCLD)
1426 if (hostsig
== SIGCLD
)
1427 return TARGET_SIGNAL_CHLD
;
1429 #if defined (SIGCHLD)
1430 if (hostsig
== SIGCHLD
)
1431 return TARGET_SIGNAL_CHLD
;
1433 #if defined (SIGPWR)
1434 if (hostsig
== SIGPWR
)
1435 return TARGET_SIGNAL_PWR
;
1437 #if defined (SIGWINCH)
1438 if (hostsig
== SIGWINCH
)
1439 return TARGET_SIGNAL_WINCH
;
1441 #if defined (SIGURG)
1442 if (hostsig
== SIGURG
)
1443 return TARGET_SIGNAL_URG
;
1446 if (hostsig
== SIGIO
)
1447 return TARGET_SIGNAL_IO
;
1449 #if defined (SIGPOLL)
1450 if (hostsig
== SIGPOLL
)
1451 return TARGET_SIGNAL_POLL
;
1453 #if defined (SIGSTOP)
1454 if (hostsig
== SIGSTOP
)
1455 return TARGET_SIGNAL_STOP
;
1457 #if defined (SIGTSTP)
1458 if (hostsig
== SIGTSTP
)
1459 return TARGET_SIGNAL_TSTP
;
1461 #if defined (SIGCONT)
1462 if (hostsig
== SIGCONT
)
1463 return TARGET_SIGNAL_CONT
;
1465 #if defined (SIGTTIN)
1466 if (hostsig
== SIGTTIN
)
1467 return TARGET_SIGNAL_TTIN
;
1469 #if defined (SIGTTOU)
1470 if (hostsig
== SIGTTOU
)
1471 return TARGET_SIGNAL_TTOU
;
1473 #if defined (SIGVTALRM)
1474 if (hostsig
== SIGVTALRM
)
1475 return TARGET_SIGNAL_VTALRM
;
1477 #if defined (SIGPROF)
1478 if (hostsig
== SIGPROF
)
1479 return TARGET_SIGNAL_PROF
;
1481 #if defined (SIGXCPU)
1482 if (hostsig
== SIGXCPU
)
1483 return TARGET_SIGNAL_XCPU
;
1485 #if defined (SIGXFSZ)
1486 if (hostsig
== SIGXFSZ
)
1487 return TARGET_SIGNAL_XFSZ
;
1489 #if defined (SIGWIND)
1490 if (hostsig
== SIGWIND
)
1491 return TARGET_SIGNAL_WIND
;
1493 #if defined (SIGPHONE)
1494 if (hostsig
== SIGPHONE
)
1495 return TARGET_SIGNAL_PHONE
;
1497 #if defined (SIGLOST)
1498 if (hostsig
== SIGLOST
)
1499 return TARGET_SIGNAL_LOST
;
1501 #if defined (SIGWAITING)
1502 if (hostsig
== SIGWAITING
)
1503 return TARGET_SIGNAL_WAITING
;
1505 #if defined (SIGCANCEL)
1506 if (hostsig
== SIGCANCEL
)
1507 return TARGET_SIGNAL_CANCEL
;
1509 #if defined (SIGLWP)
1510 if (hostsig
== SIGLWP
)
1511 return TARGET_SIGNAL_LWP
;
1513 #if defined (SIGDANGER)
1514 if (hostsig
== SIGDANGER
)
1515 return TARGET_SIGNAL_DANGER
;
1517 #if defined (SIGGRANT)
1518 if (hostsig
== SIGGRANT
)
1519 return TARGET_SIGNAL_GRANT
;
1521 #if defined (SIGRETRACT)
1522 if (hostsig
== SIGRETRACT
)
1523 return TARGET_SIGNAL_RETRACT
;
1525 #if defined (SIGMSG)
1526 if (hostsig
== SIGMSG
)
1527 return TARGET_SIGNAL_MSG
;
1529 #if defined (SIGSOUND)
1530 if (hostsig
== SIGSOUND
)
1531 return TARGET_SIGNAL_SOUND
;
1533 #if defined (SIGSAK)
1534 if (hostsig
== SIGSAK
)
1535 return TARGET_SIGNAL_SAK
;
1537 #if defined (SIGPRIO)
1538 if (hostsig
== SIGPRIO
)
1539 return TARGET_SIGNAL_PRIO
;
1542 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1543 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1544 if (hostsig
== _NSIG
+ EXC_BAD_ACCESS
)
1545 return TARGET_EXC_BAD_ACCESS
;
1547 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1548 if (hostsig
== _NSIG
+ EXC_BAD_INSTRUCTION
)
1549 return TARGET_EXC_BAD_INSTRUCTION
;
1551 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1552 if (hostsig
== _NSIG
+ EXC_ARITHMETIC
)
1553 return TARGET_EXC_ARITHMETIC
;
1555 #if defined (EXC_EMULATION) && defined (_NSIG)
1556 if (hostsig
== _NSIG
+ EXC_EMULATION
)
1557 return TARGET_EXC_EMULATION
;
1559 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1560 if (hostsig
== _NSIG
+ EXC_SOFTWARE
)
1561 return TARGET_EXC_SOFTWARE
;
1563 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1564 if (hostsig
== _NSIG
+ EXC_BREAKPOINT
)
1565 return TARGET_EXC_BREAKPOINT
;
1568 #if defined (SIGINFO)
1569 if (hostsig
== SIGINFO
)
1570 return TARGET_SIGNAL_INFO
;
1573 #if defined (REALTIME_LO)
1574 if (hostsig
>= REALTIME_LO
&& hostsig
< REALTIME_HI
)
1576 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
1577 if (33 <= hostsig
&& hostsig
<= 63)
1578 return (enum target_signal
)
1579 (hostsig
- 33 + (int) TARGET_SIGNAL_REALTIME_33
);
1580 else if (hostsig
== 32)
1581 return TARGET_SIGNAL_REALTIME_32
;
1583 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
1586 return TARGET_SIGNAL_UNKNOWN
;
1590 target_signal_to_host (oursig
)
1591 enum target_signal oursig
;
1595 case TARGET_SIGNAL_0
:
1598 #if defined (SIGHUP)
1599 case TARGET_SIGNAL_HUP
:
1602 #if defined (SIGINT)
1603 case TARGET_SIGNAL_INT
:
1606 #if defined (SIGQUIT)
1607 case TARGET_SIGNAL_QUIT
:
1610 #if defined (SIGILL)
1611 case TARGET_SIGNAL_ILL
:
1614 #if defined (SIGTRAP)
1615 case TARGET_SIGNAL_TRAP
:
1618 #if defined (SIGABRT)
1619 case TARGET_SIGNAL_ABRT
:
1622 #if defined (SIGEMT)
1623 case TARGET_SIGNAL_EMT
:
1626 #if defined (SIGFPE)
1627 case TARGET_SIGNAL_FPE
:
1630 #if defined (SIGKILL)
1631 case TARGET_SIGNAL_KILL
:
1634 #if defined (SIGBUS)
1635 case TARGET_SIGNAL_BUS
:
1638 #if defined (SIGSEGV)
1639 case TARGET_SIGNAL_SEGV
:
1642 #if defined (SIGSYS)
1643 case TARGET_SIGNAL_SYS
:
1646 #if defined (SIGPIPE)
1647 case TARGET_SIGNAL_PIPE
:
1650 #if defined (SIGALRM)
1651 case TARGET_SIGNAL_ALRM
:
1654 #if defined (SIGTERM)
1655 case TARGET_SIGNAL_TERM
:
1658 #if defined (SIGUSR1)
1659 case TARGET_SIGNAL_USR1
:
1662 #if defined (SIGUSR2)
1663 case TARGET_SIGNAL_USR2
:
1666 #if defined (SIGCHLD) || defined (SIGCLD)
1667 case TARGET_SIGNAL_CHLD
:
1668 #if defined (SIGCHLD)
1673 #endif /* SIGCLD or SIGCHLD */
1674 #if defined (SIGPWR)
1675 case TARGET_SIGNAL_PWR
:
1678 #if defined (SIGWINCH)
1679 case TARGET_SIGNAL_WINCH
:
1682 #if defined (SIGURG)
1683 case TARGET_SIGNAL_URG
:
1687 case TARGET_SIGNAL_IO
:
1690 #if defined (SIGPOLL)
1691 case TARGET_SIGNAL_POLL
:
1694 #if defined (SIGSTOP)
1695 case TARGET_SIGNAL_STOP
:
1698 #if defined (SIGTSTP)
1699 case TARGET_SIGNAL_TSTP
:
1702 #if defined (SIGCONT)
1703 case TARGET_SIGNAL_CONT
:
1706 #if defined (SIGTTIN)
1707 case TARGET_SIGNAL_TTIN
:
1710 #if defined (SIGTTOU)
1711 case TARGET_SIGNAL_TTOU
:
1714 #if defined (SIGVTALRM)
1715 case TARGET_SIGNAL_VTALRM
:
1718 #if defined (SIGPROF)
1719 case TARGET_SIGNAL_PROF
:
1722 #if defined (SIGXCPU)
1723 case TARGET_SIGNAL_XCPU
:
1726 #if defined (SIGXFSZ)
1727 case TARGET_SIGNAL_XFSZ
:
1730 #if defined (SIGWIND)
1731 case TARGET_SIGNAL_WIND
:
1734 #if defined (SIGPHONE)
1735 case TARGET_SIGNAL_PHONE
:
1738 #if defined (SIGLOST)
1739 case TARGET_SIGNAL_LOST
:
1742 #if defined (SIGWAITING)
1743 case TARGET_SIGNAL_WAITING
:
1746 #if defined (SIGCANCEL)
1747 case TARGET_SIGNAL_CANCEL
:
1750 #if defined (SIGLWP)
1751 case TARGET_SIGNAL_LWP
:
1754 #if defined (SIGDANGER)
1755 case TARGET_SIGNAL_DANGER
:
1758 #if defined (SIGGRANT)
1759 case TARGET_SIGNAL_GRANT
:
1762 #if defined (SIGRETRACT)
1763 case TARGET_SIGNAL_RETRACT
:
1766 #if defined (SIGMSG)
1767 case TARGET_SIGNAL_MSG
:
1770 #if defined (SIGSOUND)
1771 case TARGET_SIGNAL_SOUND
:
1774 #if defined (SIGSAK)
1775 case TARGET_SIGNAL_SAK
:
1778 #if defined (SIGPRIO)
1779 case TARGET_SIGNAL_PRIO
:
1783 case TARGET_SIGNAL_REALTIME_32
: return 32; /* by definition */
1785 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
1786 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1787 case TARGET_EXC_BAD_ACCESS
:
1788 return _NSIG
+ EXC_BAD_ACCESS
;
1790 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1791 case TARGET_EXC_BAD_INSTRUCTION
:
1792 return _NSIG
+ EXC_BAD_INSTRUCTION
;
1794 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1795 case TARGET_EXC_ARITHMETIC
:
1796 return _NSIG
+ EXC_ARITHMETIC
;
1798 #if defined (EXC_EMULATION) && defined (_NSIG)
1799 case TARGET_EXC_EMULATION
:
1800 return _NSIG
+ EXC_EMULATION
;
1802 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1803 case TARGET_EXC_SOFTWARE
:
1804 return _NSIG
+ EXC_SOFTWARE
;
1806 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1807 case TARGET_EXC_BREAKPOINT
:
1808 return _NSIG
+ EXC_BREAKPOINT
;
1811 #if defined (SIGINFO)
1812 case TARGET_SIGNAL_INFO
:
1817 #if defined (REALTIME_LO)
1818 if (oursig
>= TARGET_SIGNAL_REALTIME_33
1819 && oursig
<= TARGET_SIGNAL_REALTIME_63
)
1822 (int) oursig
- (int) TARGET_SIGNAL_REALTIME_33
+ REALTIME_LO
;
1823 if (retsig
< REALTIME_HI
)
1827 /* The user might be trying to do "signal SIGSAK" where this system
1828 doesn't have SIGSAK. */
1829 warning ("Signal %s does not exist on this system.\n",
1830 target_signal_to_name (oursig
));
1835 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1836 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1837 translation of that in OURSTATUS. */
1839 store_waitstatus (ourstatus
, hoststatus
)
1840 struct target_waitstatus
*ourstatus
;
1843 #ifdef CHILD_SPECIAL_WAITSTATUS
1844 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1845 if it wants to deal with hoststatus. */
1846 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1850 if (WIFEXITED (hoststatus
))
1852 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1853 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1855 else if (!WIFSTOPPED (hoststatus
))
1857 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1858 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1862 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1863 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1867 /* In some circumstances we allow a command to specify a numeric
1868 signal. The idea is to keep these circumstances limited so that
1869 users (and scripts) develop portable habits. For comparison,
1870 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1871 numeric signal at all is obscelescent. We are slightly more
1872 lenient and allow 1-15 which should match host signal numbers on
1873 most systems. Use of symbolic signal names is strongly encouraged. */
1876 target_signal_from_command (num
)
1879 if (num
>= 1 && num
<= 15)
1880 return (enum target_signal
) num
;
1881 error ("Only signals 1-15 are valid as numeric signals.\n\
1882 Use \"info signals\" for a list of symbolic signals.");
1885 /* Returns zero to leave the inferior alone, one to interrupt it. */
1886 int (*target_activity_function
) PARAMS ((void));
1887 int target_activity_fd
;
1889 /* Convert a normal process ID to a string. Returns the string in a static
1893 normal_pid_to_str (pid
)
1896 static char buf
[30];
1898 if (STREQ (current_target
.to_shortname
, "remote"))
1899 sprintf (buf
, "thread %d", pid
);
1901 sprintf (buf
, "process %d", pid
);
1906 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1907 notification of inferior events such as fork and vork immediately
1908 after the inferior is created. (This because of how gdb gets an
1909 inferior created via invoking a shell to do it. In such a scenario,
1910 if the shell init file has commands in it, the shell will fork and
1911 exec for each of those commands, and we will see each such fork
1914 This function is used by all targets that allow us to request
1915 notification of forks, etc at inferior creation time; e.g., in
1916 target_acknowledge_forked_child.
1919 normal_target_post_startup_inferior (pid
)
1922 /* This space intentionally left blank. */
1925 /* Set up the handful of non-empty slots needed by the dummy target
1929 init_dummy_target ()
1931 dummy_target
.to_shortname
= "None";
1932 dummy_target
.to_longname
= "None";
1933 dummy_target
.to_doc
= "";
1934 dummy_target
.to_attach
= find_default_attach
;
1935 dummy_target
.to_require_attach
= find_default_require_attach
;
1936 dummy_target
.to_require_detach
= find_default_require_detach
;
1937 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1938 dummy_target
.to_clone_and_follow_inferior
= find_default_clone_and_follow_inferior
;
1939 dummy_target
.to_stratum
= dummy_stratum
;
1940 dummy_target
.to_magic
= OPS_MAGIC
;
1944 static struct target_ops debug_target
;
1947 debug_to_open (args
, from_tty
)
1951 debug_target
.to_open (args
, from_tty
);
1953 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1957 debug_to_close (quitting
)
1960 debug_target
.to_close (quitting
);
1962 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1966 debug_to_attach (args
, from_tty
)
1970 debug_target
.to_attach (args
, from_tty
);
1972 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1977 debug_to_post_attach (pid
)
1980 debug_target
.to_post_attach (pid
);
1982 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1986 debug_to_require_attach (args
, from_tty
)
1990 debug_target
.to_require_attach (args
, from_tty
);
1992 fprintf_unfiltered (gdb_stdlog
,
1993 "target_require_attach (%s, %d)\n", args
, from_tty
);
1997 debug_to_detach (args
, from_tty
)
2001 debug_target
.to_detach (args
, from_tty
);
2003 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2007 debug_to_require_detach (pid
, args
, from_tty
)
2012 debug_target
.to_require_detach (pid
, args
, from_tty
);
2014 fprintf_unfiltered (gdb_stdlog
,
2015 "target_require_detach (%d, %s, %d)\n", pid
, args
, from_tty
);
2019 debug_to_resume (pid
, step
, siggnal
)
2022 enum target_signal siggnal
;
2024 debug_target
.to_resume (pid
, step
, siggnal
);
2026 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", pid
,
2027 step
? "step" : "continue",
2028 target_signal_to_name (siggnal
));
2032 debug_to_wait (pid
, status
)
2034 struct target_waitstatus
*status
;
2038 retval
= debug_target
.to_wait (pid
, status
);
2040 fprintf_unfiltered (gdb_stdlog
,
2041 "target_wait (%d, status) = %d, ", pid
, retval
);
2042 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2043 switch (status
->kind
)
2045 case TARGET_WAITKIND_EXITED
:
2046 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2047 status
->value
.integer
);
2049 case TARGET_WAITKIND_STOPPED
:
2050 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2051 target_signal_to_name (status
->value
.sig
));
2053 case TARGET_WAITKIND_SIGNALLED
:
2054 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2055 target_signal_to_name (status
->value
.sig
));
2057 case TARGET_WAITKIND_LOADED
:
2058 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2060 case TARGET_WAITKIND_FORKED
:
2061 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2063 case TARGET_WAITKIND_VFORKED
:
2064 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2066 case TARGET_WAITKIND_EXECD
:
2067 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2069 case TARGET_WAITKIND_SPURIOUS
:
2070 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2073 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2081 debug_to_post_wait (pid
, status
)
2085 debug_target
.to_post_wait (pid
, status
);
2087 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
2092 debug_to_fetch_registers (regno
)
2095 debug_target
.to_fetch_registers (regno
);
2097 fprintf_unfiltered (gdb_stdlog
, "target_fetch_registers (%s)",
2098 regno
!= -1 ? REGISTER_NAME (regno
) : "-1");
2100 fprintf_unfiltered (gdb_stdlog
, " = 0x%lx %ld",
2101 (unsigned long) read_register (regno
),
2102 (unsigned long) read_register (regno
));
2103 fprintf_unfiltered (gdb_stdlog
, "\n");
2107 debug_to_store_registers (regno
)
2110 debug_target
.to_store_registers (regno
);
2112 if (regno
>= 0 && regno
< NUM_REGS
)
2113 fprintf_unfiltered (gdb_stdlog
, "target_store_registers (%s) = 0x%lx %ld\n",
2114 REGISTER_NAME (regno
),
2115 (unsigned long) read_register (regno
),
2116 (unsigned long) read_register (regno
));
2118 fprintf_unfiltered (gdb_stdlog
, "target_store_registers (%d)\n", regno
);
2122 debug_to_prepare_to_store ()
2124 debug_target
.to_prepare_to_store ();
2126 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2130 debug_to_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
2135 struct target_ops
*target
;
2139 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
, target
);
2141 fprintf_unfiltered (gdb_stdlog
,
2142 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2143 (unsigned int) memaddr
, /* possable truncate long long */
2144 len
, write
? "write" : "read", retval
);
2152 fputs_unfiltered (", bytes =", gdb_stdlog
);
2153 for (i
= 0; i
< retval
; i
++)
2155 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2156 fprintf_unfiltered (gdb_stdlog
, "\n");
2157 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2161 fputc_unfiltered ('\n', gdb_stdlog
);
2167 debug_to_files_info (target
)
2168 struct target_ops
*target
;
2170 debug_target
.to_files_info (target
);
2172 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2176 debug_to_insert_breakpoint (addr
, save
)
2182 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2184 fprintf_unfiltered (gdb_stdlog
,
2185 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2186 (unsigned long) addr
,
2187 (unsigned long) retval
);
2192 debug_to_remove_breakpoint (addr
, save
)
2198 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2200 fprintf_unfiltered (gdb_stdlog
,
2201 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2202 (unsigned long) addr
,
2203 (unsigned long) retval
);
2208 debug_to_terminal_init ()
2210 debug_target
.to_terminal_init ();
2212 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2216 debug_to_terminal_inferior ()
2218 debug_target
.to_terminal_inferior ();
2220 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2224 debug_to_terminal_ours_for_output ()
2226 debug_target
.to_terminal_ours_for_output ();
2228 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2232 debug_to_terminal_ours ()
2234 debug_target
.to_terminal_ours ();
2236 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2240 debug_to_terminal_info (arg
, from_tty
)
2244 debug_target
.to_terminal_info (arg
, from_tty
);
2246 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2253 debug_target
.to_kill ();
2255 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2259 debug_to_load (args
, from_tty
)
2263 debug_target
.to_load (args
, from_tty
);
2265 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2269 debug_to_lookup_symbol (name
, addrp
)
2275 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2277 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2283 debug_to_create_inferior (exec_file
, args
, env
)
2288 debug_target
.to_create_inferior (exec_file
, args
, env
);
2290 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2295 debug_to_post_startup_inferior (pid
)
2298 debug_target
.to_post_startup_inferior (pid
);
2300 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2305 debug_to_acknowledge_created_inferior (pid
)
2308 debug_target
.to_acknowledge_created_inferior (pid
);
2310 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2315 debug_to_clone_and_follow_inferior (child_pid
, followed_child
)
2317 int *followed_child
;
2319 debug_target
.to_clone_and_follow_inferior (child_pid
, followed_child
);
2321 fprintf_unfiltered (gdb_stdlog
,
2322 "target_clone_and_follow_inferior (%d, %d)\n",
2323 child_pid
, *followed_child
);
2327 debug_to_post_follow_inferior_by_clone ()
2329 debug_target
.to_post_follow_inferior_by_clone ();
2331 fprintf_unfiltered (gdb_stdlog
, "target_post_follow_inferior_by_clone ()\n");
2335 debug_to_insert_fork_catchpoint (pid
)
2340 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2342 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2349 debug_to_remove_fork_catchpoint (pid
)
2354 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2356 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2363 debug_to_insert_vfork_catchpoint (pid
)
2368 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2370 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2377 debug_to_remove_vfork_catchpoint (pid
)
2382 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2384 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2391 debug_to_has_forked (pid
, child_pid
)
2397 has_forked
= debug_target
.to_has_forked (pid
, child_pid
);
2399 fprintf_unfiltered (gdb_stdlog
, "target_has_forked (%d, %d) = %d\n",
2400 pid
, *child_pid
, has_forked
);
2406 debug_to_has_vforked (pid
, child_pid
)
2412 has_vforked
= debug_target
.to_has_vforked (pid
, child_pid
);
2414 fprintf_unfiltered (gdb_stdlog
, "target_has_vforked (%d, %d) = %d\n",
2415 pid
, *child_pid
, has_vforked
);
2421 debug_to_can_follow_vfork_prior_to_exec ()
2423 int can_immediately_follow_vfork
;
2425 can_immediately_follow_vfork
= debug_target
.to_can_follow_vfork_prior_to_exec ();
2427 fprintf_unfiltered (gdb_stdlog
, "target_can_follow_vfork_prior_to_exec () = %d\n",
2428 can_immediately_follow_vfork
);
2430 return can_immediately_follow_vfork
;
2434 debug_to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
)
2436 int followed_parent
;
2440 debug_target
.to_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
);
2442 fprintf_unfiltered (gdb_stdlog
,
2443 "target_post_follow_vfork (%d, %d, %d, %d)\n",
2444 parent_pid
, followed_parent
, child_pid
, followed_child
);
2448 debug_to_insert_exec_catchpoint (pid
)
2453 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2455 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2462 debug_to_remove_exec_catchpoint (pid
)
2467 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2469 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2476 debug_to_has_execd (pid
, execd_pathname
)
2478 char **execd_pathname
;
2482 has_execd
= debug_target
.to_has_execd (pid
, execd_pathname
);
2484 fprintf_unfiltered (gdb_stdlog
, "target_has_execd (%d, %s) = %d\n",
2485 pid
, (*execd_pathname
? *execd_pathname
: "<NULL>"),
2492 debug_to_reported_exec_events_per_exec_call ()
2494 int reported_exec_events
;
2496 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2498 fprintf_unfiltered (gdb_stdlog
,
2499 "target_reported_exec_events_per_exec_call () = %d\n",
2500 reported_exec_events
);
2502 return reported_exec_events
;
2506 debug_to_has_syscall_event (pid
, kind
, syscall_id
)
2508 enum target_waitkind
*kind
;
2511 int has_syscall_event
;
2512 char *kind_spelling
= "??";
2514 has_syscall_event
= debug_target
.to_has_syscall_event (pid
, kind
, syscall_id
);
2515 if (has_syscall_event
)
2519 case TARGET_WAITKIND_SYSCALL_ENTRY
:
2520 kind_spelling
= "SYSCALL_ENTRY";
2522 case TARGET_WAITKIND_SYSCALL_RETURN
:
2523 kind_spelling
= "SYSCALL_RETURN";
2530 fprintf_unfiltered (gdb_stdlog
,
2531 "target_has_syscall_event (%d, %s, %d) = %d\n",
2532 pid
, kind_spelling
, *syscall_id
, has_syscall_event
);
2534 return has_syscall_event
;
2538 debug_to_has_exited (pid
, wait_status
, exit_status
)
2545 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2547 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2548 pid
, wait_status
, *exit_status
, has_exited
);
2554 debug_to_mourn_inferior ()
2556 debug_target
.to_mourn_inferior ();
2558 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2566 retval
= debug_target
.to_can_run ();
2568 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2574 debug_to_notice_signals (pid
)
2577 debug_target
.to_notice_signals (pid
);
2579 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n", pid
);
2583 debug_to_thread_alive (pid
)
2588 retval
= debug_target
.to_thread_alive (pid
);
2590 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2599 debug_target
.to_stop ();
2601 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2605 debug_to_query (type
, req
, resp
, siz
)
2613 retval
= debug_target
.to_query (type
, req
, resp
, siz
);
2615 fprintf_unfiltered (gdb_stdlog
, "target_query (%c, %s, %s, %d) = %d\n", type
, req
, resp
, *siz
, retval
);
2621 debug_to_rcmd (char *command
,
2622 struct gdb_file
*outbuf
)
2624 debug_target
.to_rcmd (command
, outbuf
);
2625 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2628 static struct symtab_and_line
*
2629 debug_to_enable_exception_callback (kind
, enable
)
2630 enum exception_event_kind kind
;
2633 struct symtab_and_line
*result
;
2634 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2635 fprintf_unfiltered (gdb_stdlog
,
2636 "target get_exception_callback_sal (%d, %d)\n",
2641 static struct exception_event_record
*
2642 debug_to_get_current_exception_event ()
2644 struct exception_event_record
*result
;
2645 result
= debug_target
.to_get_current_exception_event ();
2646 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2651 debug_to_pid_to_exec_file (pid
)
2656 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2658 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2665 debug_to_core_file_to_sym_file (core
)
2670 sym_file
= debug_target
.to_core_file_to_sym_file (core
);
2672 fprintf_unfiltered (gdb_stdlog
, "target_core_file_to_sym_file (%s) = %s\n",
2679 setup_target_debug ()
2681 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2683 current_target
.to_open
= debug_to_open
;
2684 current_target
.to_close
= debug_to_close
;
2685 current_target
.to_attach
= debug_to_attach
;
2686 current_target
.to_post_attach
= debug_to_post_attach
;
2687 current_target
.to_require_attach
= debug_to_require_attach
;
2688 current_target
.to_detach
= debug_to_detach
;
2689 current_target
.to_require_detach
= debug_to_require_detach
;
2690 current_target
.to_resume
= debug_to_resume
;
2691 current_target
.to_wait
= debug_to_wait
;
2692 current_target
.to_post_wait
= debug_to_post_wait
;
2693 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2694 current_target
.to_store_registers
= debug_to_store_registers
;
2695 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2696 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2697 current_target
.to_files_info
= debug_to_files_info
;
2698 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2699 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2700 current_target
.to_terminal_init
= debug_to_terminal_init
;
2701 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2702 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2703 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2704 current_target
.to_terminal_info
= debug_to_terminal_info
;
2705 current_target
.to_kill
= debug_to_kill
;
2706 current_target
.to_load
= debug_to_load
;
2707 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2708 current_target
.to_create_inferior
= debug_to_create_inferior
;
2709 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2710 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2711 current_target
.to_clone_and_follow_inferior
= debug_to_clone_and_follow_inferior
;
2712 current_target
.to_post_follow_inferior_by_clone
= debug_to_post_follow_inferior_by_clone
;
2713 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2714 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2715 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2716 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2717 current_target
.to_has_forked
= debug_to_has_forked
;
2718 current_target
.to_has_vforked
= debug_to_has_vforked
;
2719 current_target
.to_can_follow_vfork_prior_to_exec
= debug_to_can_follow_vfork_prior_to_exec
;
2720 current_target
.to_post_follow_vfork
= debug_to_post_follow_vfork
;
2721 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2722 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2723 current_target
.to_has_execd
= debug_to_has_execd
;
2724 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2725 current_target
.to_has_syscall_event
= debug_to_has_syscall_event
;
2726 current_target
.to_has_exited
= debug_to_has_exited
;
2727 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2728 current_target
.to_can_run
= debug_to_can_run
;
2729 current_target
.to_notice_signals
= debug_to_notice_signals
;
2730 current_target
.to_thread_alive
= debug_to_thread_alive
;
2731 current_target
.to_stop
= debug_to_stop
;
2732 current_target
.to_query
= debug_to_query
;
2733 current_target
.to_rcmd
= debug_to_rcmd
;
2734 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2735 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2736 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2737 current_target
.to_core_file_to_sym_file
= debug_to_core_file_to_sym_file
;
2742 static char targ_desc
[] =
2743 "Names of targets and files being debugged.\n\
2744 Shows the entire stack of targets currently in use (including the exec-file,\n\
2745 core-file, and process, if any), as well as the symbol file name.";
2748 do_monitor_command (char *cmd
,
2751 if ((current_target
.to_rcmd
== (void*) tcomplain
)
2752 || (current_target
.to_rcmd
== debug_to_rcmd
2753 && (debug_target
.to_rcmd
== (void*) tcomplain
)))
2755 error ("\"monitor\" command not supported by this target.\n");
2757 target_rcmd (cmd
, gdb_stdtarg
);
2761 initialize_targets ()
2763 init_dummy_target ();
2764 push_target (&dummy_target
);
2766 add_info ("target", target_info
, targ_desc
);
2767 add_info ("files", target_info
, targ_desc
);
2770 add_set_cmd ("targetdebug", class_maintenance
, var_zinteger
,
2771 (char *) &targetdebug
,
2772 "Set target debugging.\n\
2773 When non-zero, target debugging is enabled.", &setlist
),
2777 add_com ("monitor", class_obscure
, do_monitor_command
,
2778 "Send a command to the remote monitor (remote targets only).");
2780 if (!STREQ (signals
[TARGET_SIGNAL_LAST
].string
, "TARGET_SIGNAL_MAGIC"))