1 /* Select target systems and architectures at runtime for GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 Contributed by Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
39 #include "gdb_assert.h"
41 static void target_info (char *, int);
43 static void maybe_kill_then_create_inferior (char *, char *, char **);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_size_ok_for_hw_watchpoint (int);
53 static int nosymbol (char *, CORE_ADDR
*);
55 static void tcomplain (void);
57 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static void normal_target_post_startup_inferior (ptid_t ptid
);
75 static LONGEST
default_read_partial (struct target_ops
*ops
,
76 enum target_object object
,
77 const char *annex
, void *buf
,
78 ULONGEST offset
, LONGEST len
);
79 static LONGEST
default_write_partial (struct target_ops
*ops
,
80 enum target_object object
,
81 const char *annex
, const void *buf
,
82 ULONGEST offset
, LONGEST len
);
84 /* Transfer LEN bytes between target address MEMADDR and GDB address
85 MYADDR. Returns 0 for success, errno code for failure (which
86 includes partial transfers -- if you want a more useful response to
87 partial transfers, try either target_read_memory_partial or
88 target_write_memory_partial). */
90 static int target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
93 static void init_dummy_target (void);
95 static void debug_to_open (char *, int);
97 static void debug_to_close (int);
99 static void debug_to_attach (char *, int);
101 static void debug_to_detach (char *, int);
103 static void debug_to_disconnect (char *, int);
105 static void debug_to_resume (ptid_t
, int, enum target_signal
);
107 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
109 static void debug_to_fetch_registers (int);
111 static void debug_to_store_registers (int);
113 static void debug_to_prepare_to_store (void);
115 static int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
116 struct mem_attrib
*, struct target_ops
*);
118 static void debug_to_files_info (struct target_ops
*);
120 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
122 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
124 static int debug_to_can_use_hw_breakpoint (int, int, int);
126 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
128 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
130 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
132 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
134 static int debug_to_stopped_by_watchpoint (void);
136 static CORE_ADDR
debug_to_stopped_data_address (void);
138 static int debug_to_region_size_ok_for_hw_watchpoint (int);
140 static void debug_to_terminal_init (void);
142 static void debug_to_terminal_inferior (void);
144 static void debug_to_terminal_ours_for_output (void);
146 static void debug_to_terminal_save_ours (void);
148 static void debug_to_terminal_ours (void);
150 static void debug_to_terminal_info (char *, int);
152 static void debug_to_kill (void);
154 static void debug_to_load (char *, int);
156 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
158 static void debug_to_create_inferior (char *, char *, char **);
160 static void debug_to_mourn_inferior (void);
162 static int debug_to_can_run (void);
164 static void debug_to_notice_signals (ptid_t
);
166 static int debug_to_thread_alive (ptid_t
);
168 static void debug_to_stop (void);
170 /* Pointer to array of target architecture structures; the size of the
171 array; the current index into the array; the allocated size of the
173 struct target_ops
**target_structs
;
174 unsigned target_struct_size
;
175 unsigned target_struct_index
;
176 unsigned target_struct_allocsize
;
177 #define DEFAULT_ALLOCSIZE 10
179 /* The initial current target, so that there is always a semi-valid
182 static struct target_ops dummy_target
;
184 /* Top of target stack. */
186 static struct target_ops
*target_stack
;
188 /* The target structure we are currently using to talk to a process
189 or file or whatever "inferior" we have. */
191 struct target_ops current_target
;
193 /* Command list for target. */
195 static struct cmd_list_element
*targetlist
= NULL
;
197 /* Nonzero if we are debugging an attached outside process
198 rather than an inferior. */
202 /* Non-zero if we want to see trace of target level stuff. */
204 static int targetdebug
= 0;
206 static void setup_target_debug (void);
208 DCACHE
*target_dcache
;
210 /* The user just typed 'target' without the name of a target. */
213 target_command (char *arg
, int from_tty
)
215 fputs_filtered ("Argument required (target name). Try `help target'\n",
219 /* Add a possible target architecture to the list. */
222 add_target (struct target_ops
*t
)
224 /* Provide default values for all "must have" methods. */
225 t
->to_read_partial
= default_read_partial
;
226 t
->to_write_partial
= default_write_partial
;
230 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
231 target_structs
= (struct target_ops
**) xmalloc
232 (target_struct_allocsize
* sizeof (*target_structs
));
234 if (target_struct_size
>= target_struct_allocsize
)
236 target_struct_allocsize
*= 2;
237 target_structs
= (struct target_ops
**)
238 xrealloc ((char *) target_structs
,
239 target_struct_allocsize
* sizeof (*target_structs
));
241 target_structs
[target_struct_size
++] = t
;
243 if (targetlist
== NULL
)
244 add_prefix_cmd ("target", class_run
, target_command
,
245 "Connect to a target machine or process.\n\
246 The first argument is the type or protocol of the target machine.\n\
247 Remaining arguments are interpreted by the target protocol. For more\n\
248 information on the arguments for a particular protocol, type\n\
249 `help target ' followed by the protocol name.",
250 &targetlist
, "target ", 0, &cmdlist
);
251 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
262 target_load (char *arg
, int from_tty
)
264 dcache_invalidate (target_dcache
);
265 (*current_target
.to_load
) (arg
, from_tty
);
269 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
270 struct target_ops
*t
)
272 errno
= EIO
; /* Can't read/write this location */
273 return 0; /* No bytes handled */
279 error ("You can't do that when your target is `%s'",
280 current_target
.to_shortname
);
286 error ("You can't do that without a process to debug.");
290 nosymbol (char *name
, CORE_ADDR
*addrp
)
292 return 1; /* Symbol does not exist in target env */
296 nosupport_runtime (void)
298 if (ptid_equal (inferior_ptid
, null_ptid
))
301 error ("No run-time support for this");
306 default_terminal_info (char *args
, int from_tty
)
308 printf_unfiltered ("No saved terminal information.\n");
311 /* This is the default target_create_inferior and target_attach function.
312 If the current target is executing, it asks whether to kill it off.
313 If this function returns without calling error(), it has killed off
314 the target, and the operation should be attempted. */
317 kill_or_be_killed (int from_tty
)
319 if (target_has_execution
)
321 printf_unfiltered ("You are already running a program:\n");
322 target_files_info ();
323 if (query ("Kill it? "))
326 if (target_has_execution
)
327 error ("Killing the program did not help.");
332 error ("Program not killed.");
339 maybe_kill_then_attach (char *args
, int from_tty
)
341 kill_or_be_killed (from_tty
);
342 target_attach (args
, from_tty
);
346 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
348 kill_or_be_killed (0);
349 target_create_inferior (exec
, args
, env
);
352 /* Go through the target stack from top to bottom, copying over zero
353 entries in current_target, then filling in still empty entries. In
354 effect, we are doing class inheritance through the pushed target
357 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
358 is currently implemented, is that it discards any knowledge of
359 which target an inherited method originally belonged to.
360 Consequently, new new target methods should instead explicitly and
361 locally search the target stack for the target that can handle the
365 update_current_target (void)
367 struct target_ops
*t
;
369 /* First, reset curren'ts contents. */
370 memset (¤t_target
, 0, sizeof (current_target
));
372 #define INHERIT(FIELD, TARGET) \
373 if (!current_target.FIELD) \
374 current_target.FIELD = (TARGET)->FIELD
376 for (t
= target_stack
; t
; t
= t
->beneath
)
378 INHERIT (to_shortname
, t
);
379 INHERIT (to_longname
, t
);
381 INHERIT (to_open
, t
);
382 INHERIT (to_close
, t
);
383 INHERIT (to_attach
, t
);
384 INHERIT (to_post_attach
, t
);
385 INHERIT (to_detach
, t
);
386 INHERIT (to_disconnect
, t
);
387 INHERIT (to_resume
, t
);
388 INHERIT (to_wait
, t
);
389 INHERIT (to_post_wait
, t
);
390 INHERIT (to_fetch_registers
, t
);
391 INHERIT (to_store_registers
, t
);
392 INHERIT (to_prepare_to_store
, t
);
393 INHERIT (to_xfer_memory
, t
);
394 INHERIT (to_files_info
, t
);
395 INHERIT (to_insert_breakpoint
, t
);
396 INHERIT (to_remove_breakpoint
, t
);
397 INHERIT (to_can_use_hw_breakpoint
, t
);
398 INHERIT (to_insert_hw_breakpoint
, t
);
399 INHERIT (to_remove_hw_breakpoint
, t
);
400 INHERIT (to_insert_watchpoint
, t
);
401 INHERIT (to_remove_watchpoint
, t
);
402 INHERIT (to_stopped_data_address
, t
);
403 INHERIT (to_stopped_by_watchpoint
, t
);
404 INHERIT (to_have_continuable_watchpoint
, t
);
405 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
406 INHERIT (to_terminal_init
, t
);
407 INHERIT (to_terminal_inferior
, t
);
408 INHERIT (to_terminal_ours_for_output
, t
);
409 INHERIT (to_terminal_ours
, t
);
410 INHERIT (to_terminal_save_ours
, t
);
411 INHERIT (to_terminal_info
, t
);
412 INHERIT (to_kill
, t
);
413 INHERIT (to_load
, t
);
414 INHERIT (to_lookup_symbol
, t
);
415 INHERIT (to_create_inferior
, t
);
416 INHERIT (to_post_startup_inferior
, t
);
417 INHERIT (to_acknowledge_created_inferior
, t
);
418 INHERIT (to_insert_fork_catchpoint
, t
);
419 INHERIT (to_remove_fork_catchpoint
, t
);
420 INHERIT (to_insert_vfork_catchpoint
, t
);
421 INHERIT (to_remove_vfork_catchpoint
, t
);
422 INHERIT (to_follow_fork
, t
);
423 INHERIT (to_insert_exec_catchpoint
, t
);
424 INHERIT (to_remove_exec_catchpoint
, t
);
425 INHERIT (to_reported_exec_events_per_exec_call
, t
);
426 INHERIT (to_has_exited
, t
);
427 INHERIT (to_mourn_inferior
, t
);
428 INHERIT (to_can_run
, t
);
429 INHERIT (to_notice_signals
, t
);
430 INHERIT (to_thread_alive
, t
);
431 INHERIT (to_find_new_threads
, t
);
432 INHERIT (to_pid_to_str
, t
);
433 INHERIT (to_extra_thread_info
, t
);
434 INHERIT (to_stop
, t
);
435 /* Do not inherit to_read_partial. */
436 /* Do not inherit to_write_partial. */
437 INHERIT (to_rcmd
, t
);
438 INHERIT (to_enable_exception_callback
, t
);
439 INHERIT (to_get_current_exception_event
, t
);
440 INHERIT (to_pid_to_exec_file
, t
);
441 INHERIT (to_stratum
, t
);
442 INHERIT (to_has_all_memory
, t
);
443 INHERIT (to_has_memory
, t
);
444 INHERIT (to_has_stack
, t
);
445 INHERIT (to_has_registers
, t
);
446 INHERIT (to_has_execution
, t
);
447 INHERIT (to_has_thread_control
, t
);
448 INHERIT (to_sections
, t
);
449 INHERIT (to_sections_end
, t
);
450 INHERIT (to_can_async_p
, t
);
451 INHERIT (to_is_async_p
, t
);
452 INHERIT (to_async
, t
);
453 INHERIT (to_async_mask_value
, t
);
454 INHERIT (to_find_memory_regions
, t
);
455 INHERIT (to_make_corefile_notes
, t
);
456 INHERIT (to_get_thread_local_address
, t
);
457 INHERIT (to_magic
, t
);
461 /* Clean up a target struct so it no longer has any zero pointers in
462 it. Some entries are defaulted to a method that print an error,
463 others are hard-wired to a standard recursive default. */
465 #define de_fault(field, value) \
466 if (!current_target.field) \
467 current_target.field = value
470 (void (*) (char *, int))
476 maybe_kill_then_attach
);
477 de_fault (to_post_attach
,
481 (void (*) (char *, int))
483 de_fault (to_disconnect
,
484 (void (*) (char *, int))
487 (void (*) (ptid_t
, int, enum target_signal
))
490 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
492 de_fault (to_post_wait
,
493 (void (*) (ptid_t
, int))
495 de_fault (to_fetch_registers
,
498 de_fault (to_store_registers
,
501 de_fault (to_prepare_to_store
,
504 de_fault (to_xfer_memory
,
505 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
507 de_fault (to_files_info
,
508 (void (*) (struct target_ops
*))
510 de_fault (to_insert_breakpoint
,
511 memory_insert_breakpoint
);
512 de_fault (to_remove_breakpoint
,
513 memory_remove_breakpoint
);
514 de_fault (to_can_use_hw_breakpoint
,
515 (int (*) (int, int, int))
517 de_fault (to_insert_hw_breakpoint
,
518 (int (*) (CORE_ADDR
, char *))
520 de_fault (to_remove_hw_breakpoint
,
521 (int (*) (CORE_ADDR
, char *))
523 de_fault (to_insert_watchpoint
,
524 (int (*) (CORE_ADDR
, int, int))
526 de_fault (to_remove_watchpoint
,
527 (int (*) (CORE_ADDR
, int, int))
529 de_fault (to_stopped_by_watchpoint
,
532 de_fault (to_stopped_data_address
,
533 (CORE_ADDR (*) (void))
535 de_fault (to_region_size_ok_for_hw_watchpoint
,
536 default_region_size_ok_for_hw_watchpoint
);
537 de_fault (to_terminal_init
,
540 de_fault (to_terminal_inferior
,
543 de_fault (to_terminal_ours_for_output
,
546 de_fault (to_terminal_ours
,
549 de_fault (to_terminal_save_ours
,
552 de_fault (to_terminal_info
,
553 default_terminal_info
);
558 (void (*) (char *, int))
560 de_fault (to_lookup_symbol
,
561 (int (*) (char *, CORE_ADDR
*))
563 de_fault (to_create_inferior
,
564 maybe_kill_then_create_inferior
);
565 de_fault (to_post_startup_inferior
,
568 de_fault (to_acknowledge_created_inferior
,
571 de_fault (to_insert_fork_catchpoint
,
574 de_fault (to_remove_fork_catchpoint
,
577 de_fault (to_insert_vfork_catchpoint
,
580 de_fault (to_remove_vfork_catchpoint
,
583 de_fault (to_follow_fork
,
586 de_fault (to_insert_exec_catchpoint
,
589 de_fault (to_remove_exec_catchpoint
,
592 de_fault (to_reported_exec_events_per_exec_call
,
595 de_fault (to_has_exited
,
596 (int (*) (int, int, int *))
598 de_fault (to_mourn_inferior
,
601 de_fault (to_can_run
,
603 de_fault (to_notice_signals
,
606 de_fault (to_thread_alive
,
609 de_fault (to_find_new_threads
,
612 de_fault (to_extra_thread_info
,
613 (char *(*) (struct thread_info
*))
618 current_target
.to_read_partial
= default_read_partial
;
619 current_target
.to_write_partial
= default_write_partial
;
621 (void (*) (char *, struct ui_file
*))
623 de_fault (to_enable_exception_callback
,
624 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
626 de_fault (to_get_current_exception_event
,
627 (struct exception_event_record
* (*) (void))
629 de_fault (to_pid_to_exec_file
,
632 de_fault (to_can_async_p
,
635 de_fault (to_is_async_p
,
639 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
643 /* Finally, position the target-stack beneath the squashed
644 "current_target". That way code looking for a non-inherited
645 target method can quickly and simply find it. */
646 current_target
.beneath
= target_stack
;
649 /* Push a new target type into the stack of the existing target accessors,
650 possibly superseding some of the existing accessors.
652 Result is zero if the pushed target ended up on top of the stack,
653 nonzero if at least one target is on top of it.
655 Rather than allow an empty stack, we always have the dummy target at
656 the bottom stratum, so we can call the function vectors without
660 push_target (struct target_ops
*t
)
662 struct target_ops
**cur
;
664 /* Check magic number. If wrong, it probably means someone changed
665 the struct definition, but not all the places that initialize one. */
666 if (t
->to_magic
!= OPS_MAGIC
)
668 fprintf_unfiltered (gdb_stderr
,
669 "Magic number of %s target struct wrong\n",
671 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
674 /* Find the proper stratum to install this target in. */
675 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
677 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
681 /* If there's already targets at this stratum, remove them. */
682 /* FIXME: cagney/2003-10-15: I think this should be poping all
683 targets to CUR, and not just those at this stratum level. */
684 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
686 /* There's already something at this stratum level. Close it,
687 and un-hook it from the stack. */
688 struct target_ops
*tmp
= (*cur
);
689 (*cur
) = (*cur
)->beneath
;
691 target_close (tmp
, 0);
694 /* We have removed all targets in our stratum, now add the new one. */
698 update_current_target ();
701 setup_target_debug ();
704 return (t
!= target_stack
);
707 /* Remove a target_ops vector from the stack, wherever it may be.
708 Return how many times it was removed (0 or 1). */
711 unpush_target (struct target_ops
*t
)
713 struct target_ops
**cur
;
714 struct target_ops
*tmp
;
718 /* Look for the specified target. Note that we assume that a target
719 can only occur once in the target stack. */
721 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
728 return 0; /* Didn't find target_ops, quit now */
730 /* Unchain the target */
732 (*cur
) = (*cur
)->beneath
;
735 update_current_target ();
743 target_close (¤t_target
, 0); /* Let it clean up */
744 if (unpush_target (target_stack
) == 1)
747 fprintf_unfiltered (gdb_stderr
,
748 "pop_target couldn't find target %s\n",
749 current_target
.to_shortname
);
750 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
754 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
756 /* target_read_string -- read a null terminated string, up to LEN bytes,
757 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
758 Set *STRING to a pointer to malloc'd memory containing the data; the caller
759 is responsible for freeing it. Return the number of bytes successfully
763 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
765 int tlen
, origlen
, offset
, i
;
769 int buffer_allocated
;
771 unsigned int nbytes_read
= 0;
773 /* Small for testing. */
774 buffer_allocated
= 4;
775 buffer
= xmalloc (buffer_allocated
);
782 tlen
= MIN (len
, 4 - (memaddr
& 3));
783 offset
= memaddr
& 3;
785 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
788 /* The transfer request might have crossed the boundary to an
789 unallocated region of memory. Retry the transfer, requesting
793 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
798 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
801 bytes
= bufptr
- buffer
;
802 buffer_allocated
*= 2;
803 buffer
= xrealloc (buffer
, buffer_allocated
);
804 bufptr
= buffer
+ bytes
;
807 for (i
= 0; i
< tlen
; i
++)
809 *bufptr
++ = buf
[i
+ offset
];
810 if (buf
[i
+ offset
] == '\000')
812 nbytes_read
+= i
+ 1;
829 /* Find a section containing ADDR. */
830 struct section_table
*
831 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
833 struct section_table
*secp
;
834 for (secp
= target
->to_sections
;
835 secp
< target
->to_sections_end
;
838 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
844 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
845 GDB's memory at MYADDR. Returns either 0 for success or an errno value
848 If an error occurs, no guarantee is made about the contents of the data at
849 MYADDR. In particular, the caller should not depend upon partial reads
850 filling the buffer with good data. There is no way for the caller to know
851 how much good data might have been transfered anyway. Callers that can
852 deal with partial reads should call target_read_memory_partial. */
855 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
857 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
861 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
863 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
866 static int trust_readonly
= 0;
868 /* Move memory to or from the targets. The top target gets priority;
869 if it cannot handle it, it is offered to the next one down, etc.
871 Result is -1 on error, or the number of bytes transfered. */
874 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
875 struct mem_attrib
*attrib
)
879 struct target_ops
*t
;
881 /* Zero length requests are ok and require no work. */
885 /* to_xfer_memory is not guaranteed to set errno, even when it returns
889 if (!write
&& trust_readonly
)
891 struct section_table
*secp
;
892 /* User-settable option, "trust-readonly-sections". If true,
893 then memory from any SEC_READONLY bfd section may be read
894 directly from the bfd file. */
895 secp
= target_section_by_addr (¤t_target
, memaddr
);
897 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
899 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
902 /* The quick case is that the top target can handle the transfer. */
903 res
= current_target
.to_xfer_memory
904 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
906 /* If res <= 0 then we call it again in the loop. Ah well. */
909 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
911 if (!t
->to_has_memory
)
914 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
916 break; /* Handled all or part of xfer */
917 if (t
->to_has_all_memory
)
929 /* Perform a memory transfer. Iterate until the entire region has
932 Result is 0 or errno value. */
935 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
939 struct mem_region
*region
;
941 /* Zero length requests are ok and require no work. */
949 region
= lookup_mem_region(memaddr
);
950 if (memaddr
+ len
< region
->hi
)
953 reg_len
= region
->hi
- memaddr
;
955 switch (region
->attrib
.mode
)
970 if (region
->attrib
.cache
)
971 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
974 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
979 /* If this address is for nonexistent memory, read zeros
980 if reading, or do nothing if writing. Return
983 memset (myaddr
, 0, len
);
997 return 0; /* We managed to cover it all somehow. */
1001 /* Perform a partial memory transfer.
1003 Result is -1 on error, or the number of bytes transfered. */
1006 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1007 int write_p
, int *err
)
1011 struct mem_region
*region
;
1013 /* Zero length requests are ok and require no work. */
1020 region
= lookup_mem_region(memaddr
);
1021 if (memaddr
+ len
< region
->hi
)
1024 reg_len
= region
->hi
- memaddr
;
1026 switch (region
->attrib
.mode
)
1045 if (region
->attrib
.cache
)
1046 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1049 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1067 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1069 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1073 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1075 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1078 /* More generic transfers. */
1081 default_read_partial (struct target_ops
*ops
,
1082 enum target_object object
,
1083 const char *annex
, void *buf
,
1084 ULONGEST offset
, LONGEST len
)
1086 if (object
== TARGET_OBJECT_MEMORY
1087 && ops
->to_xfer_memory
!= NULL
)
1088 /* If available, fall back to the target's "to_xfer_memory"
1093 xfered
= ops
->to_xfer_memory (offset
, buf
, len
, 0/*read*/, NULL
, ops
);
1096 else if (xfered
== 0 && errno
== 0)
1097 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1098 indication of an error. */
1103 else if (ops
->beneath
!= NULL
)
1104 return target_read_partial (ops
->beneath
, object
, annex
, buf
, offset
, len
);
1110 default_write_partial (struct target_ops
*ops
,
1111 enum target_object object
,
1112 const char *annex
, const void *buf
,
1113 ULONGEST offset
, LONGEST len
)
1115 if (object
== TARGET_OBJECT_MEMORY
1116 && ops
->to_xfer_memory
!= NULL
)
1117 /* If available, fall back to the target's "to_xfer_memory"
1123 void *buffer
= xmalloc (len
);
1124 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1125 memcpy (buffer
, buf
, len
);
1126 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1128 do_cleanups (cleanup
);
1132 else if (xfered
== 0 && errno
== 0)
1133 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1134 indication of an error. */
1139 else if (ops
->beneath
!= NULL
)
1140 return target_write_partial (ops
->beneath
, object
, annex
, buf
, offset
,
1146 /* Target vector read/write partial wrapper functions.
1148 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1149 (inbuf, outbuf)", instead of separate read/write methods, make life
1153 target_read_partial (struct target_ops
*ops
,
1154 enum target_object object
,
1155 const char *annex
, void *buf
,
1156 ULONGEST offset
, LONGEST len
)
1158 gdb_assert (ops
->to_read_partial
!= NULL
);
1159 return ops
->to_read_partial (ops
, object
, annex
, buf
, offset
, len
);
1163 target_write_partial (struct target_ops
*ops
,
1164 enum target_object object
,
1165 const char *annex
, const void *buf
,
1166 ULONGEST offset
, LONGEST len
)
1168 gdb_assert (ops
->to_write_partial
!= NULL
);
1169 return ops
->to_write_partial (ops
, object
, annex
, buf
, offset
, len
);
1172 /* Wrappers to perform the full transfer. */
1174 target_read (struct target_ops
*ops
,
1175 enum target_object object
,
1176 const char *annex
, void *buf
,
1177 ULONGEST offset
, LONGEST len
)
1180 while (xfered
< len
)
1182 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1183 (bfd_byte
*) buf
+ xfered
,
1184 offset
+ xfered
, len
- xfered
);
1185 /* Call an observer, notifying them of the xfer progress? */
1187 /* Call memory_error? */
1196 target_write (struct target_ops
*ops
,
1197 enum target_object object
,
1198 const char *annex
, const void *buf
,
1199 ULONGEST offset
, LONGEST len
)
1202 while (xfered
< len
)
1204 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1205 (bfd_byte
*) buf
+ xfered
,
1206 offset
+ xfered
, len
- xfered
);
1207 /* Call an observer, notifying them of the xfer progress? */
1209 /* Call memory_error? */
1218 target_info (char *args
, int from_tty
)
1220 struct target_ops
*t
;
1221 int has_all_mem
= 0;
1223 if (symfile_objfile
!= NULL
)
1224 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1226 #ifdef FILES_INFO_HOOK
1227 if (FILES_INFO_HOOK ())
1231 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1233 if (!t
->to_has_memory
)
1236 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1239 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1240 printf_unfiltered ("%s:\n", t
->to_longname
);
1241 (t
->to_files_info
) (t
);
1242 has_all_mem
= t
->to_has_all_memory
;
1246 /* This is to be called by the open routine before it does
1250 target_preopen (int from_tty
)
1254 if (target_has_execution
)
1257 || query ("A program is being debugged already. Kill it? "))
1260 error ("Program not killed.");
1263 /* Calling target_kill may remove the target from the stack. But if
1264 it doesn't (which seems like a win for UDI), remove it now. */
1266 if (target_has_execution
)
1270 /* Detach a target after doing deferred register stores. */
1273 target_detach (char *args
, int from_tty
)
1275 /* Handle any optimized stores to the inferior. */
1276 #ifdef DO_DEFERRED_STORES
1279 (current_target
.to_detach
) (args
, from_tty
);
1283 target_disconnect (char *args
, int from_tty
)
1285 /* Handle any optimized stores to the inferior. */
1286 #ifdef DO_DEFERRED_STORES
1289 (current_target
.to_disconnect
) (args
, from_tty
);
1293 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1295 if (STREQ (current_target
.to_shortname
, "rombug"))
1297 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1299 error ("Unable to link to %s and get relocation in rombug", modname
);
1302 *t_reloc
= (CORE_ADDR
) -1;
1306 target_async_mask (int mask
)
1308 int saved_async_masked_status
= target_async_mask_value
;
1309 target_async_mask_value
= mask
;
1310 return saved_async_masked_status
;
1313 /* Look through the list of possible targets for a target that can
1314 execute a run or attach command without any other data. This is
1315 used to locate the default process stratum.
1317 Result is always valid (error() is called for errors). */
1319 static struct target_ops
*
1320 find_default_run_target (char *do_mesg
)
1322 struct target_ops
**t
;
1323 struct target_ops
*runable
= NULL
;
1328 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1331 if ((*t
)->to_can_run
&& target_can_run (*t
))
1339 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1345 find_default_attach (char *args
, int from_tty
)
1347 struct target_ops
*t
;
1349 t
= find_default_run_target ("attach");
1350 (t
->to_attach
) (args
, from_tty
);
1355 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1357 struct target_ops
*t
;
1359 t
= find_default_run_target ("run");
1360 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1365 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1367 return (byte_count
<= DEPRECATED_REGISTER_SIZE
);
1383 return_minus_one (void)
1389 * Resize the to_sections pointer. Also make sure that anyone that
1390 * was holding on to an old value of it gets updated.
1391 * Returns the old size.
1395 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1397 struct target_ops
**t
;
1398 struct section_table
*old_value
;
1401 old_value
= target
->to_sections
;
1403 if (target
->to_sections
)
1405 old_count
= target
->to_sections_end
- target
->to_sections
;
1406 target
->to_sections
= (struct section_table
*)
1407 xrealloc ((char *) target
->to_sections
,
1408 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1413 target
->to_sections
= (struct section_table
*)
1414 xmalloc ((sizeof (struct section_table
)) * num_added
);
1416 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1418 /* Check to see if anyone else was pointing to this structure.
1419 If old_value was null, then no one was. */
1423 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1426 if ((*t
)->to_sections
== old_value
)
1428 (*t
)->to_sections
= target
->to_sections
;
1429 (*t
)->to_sections_end
= target
->to_sections_end
;
1438 /* Remove all target sections taken from ABFD.
1440 Scan the current target stack for targets whose section tables
1441 refer to sections from BFD, and remove those sections. We use this
1442 when we notice that the inferior has unloaded a shared object, for
1445 remove_target_sections (bfd
*abfd
)
1447 struct target_ops
**t
;
1449 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1451 struct section_table
*src
, *dest
;
1453 dest
= (*t
)->to_sections
;
1454 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1455 if (src
->bfd
!= abfd
)
1457 /* Keep this section. */
1458 if (dest
< src
) *dest
= *src
;
1462 /* If we've dropped any sections, resize the section table. */
1464 target_resize_to_sections (*t
, dest
- src
);
1471 /* Find a single runnable target in the stack and return it. If for
1472 some reason there is more than one, return NULL. */
1475 find_run_target (void)
1477 struct target_ops
**t
;
1478 struct target_ops
*runable
= NULL
;
1483 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1485 if ((*t
)->to_can_run
&& target_can_run (*t
))
1492 return (count
== 1 ? runable
: NULL
);
1495 /* Find a single core_stratum target in the list of targets and return it.
1496 If for some reason there is more than one, return NULL. */
1499 find_core_target (void)
1501 struct target_ops
**t
;
1502 struct target_ops
*runable
= NULL
;
1507 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1510 if ((*t
)->to_stratum
== core_stratum
)
1517 return (count
== 1 ? runable
: NULL
);
1521 * Find the next target down the stack from the specified target.
1525 find_target_beneath (struct target_ops
*t
)
1531 /* The inferior process has died. Long live the inferior! */
1534 generic_mourn_inferior (void)
1536 extern int show_breakpoint_hit_counts
;
1538 inferior_ptid
= null_ptid
;
1540 breakpoint_init_inferior (inf_exited
);
1541 registers_changed ();
1543 #ifdef CLEAR_DEFERRED_STORES
1544 /* Delete any pending stores to the inferior... */
1545 CLEAR_DEFERRED_STORES
;
1548 reopen_exec_file ();
1549 reinit_frame_cache ();
1551 /* It is confusing to the user for ignore counts to stick around
1552 from previous runs of the inferior. So clear them. */
1553 /* However, it is more confusing for the ignore counts to disappear when
1554 using hit counts. So don't clear them if we're counting hits. */
1555 if (!show_breakpoint_hit_counts
)
1556 breakpoint_clear_ignore_counts ();
1562 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1563 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1564 translation of that in OURSTATUS. */
1566 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1568 #ifdef CHILD_SPECIAL_WAITSTATUS
1569 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1570 if it wants to deal with hoststatus. */
1571 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1575 if (WIFEXITED (hoststatus
))
1577 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1578 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1580 else if (!WIFSTOPPED (hoststatus
))
1582 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1583 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1587 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1588 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1592 /* Returns zero to leave the inferior alone, one to interrupt it. */
1593 int (*target_activity_function
) (void);
1594 int target_activity_fd
;
1596 /* Convert a normal process ID to a string. Returns the string in a static
1600 normal_pid_to_str (ptid_t ptid
)
1602 static char buf
[30];
1604 sprintf (buf
, "process %d", PIDGET (ptid
));
1608 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1609 notification of inferior events such as fork and vork immediately
1610 after the inferior is created. (This because of how gdb gets an
1611 inferior created via invoking a shell to do it. In such a scenario,
1612 if the shell init file has commands in it, the shell will fork and
1613 exec for each of those commands, and we will see each such fork
1616 This function is used by all targets that allow us to request
1617 notification of forks, etc at inferior creation time; e.g., in
1618 target_acknowledge_forked_child.
1621 normal_target_post_startup_inferior (ptid_t ptid
)
1623 /* This space intentionally left blank. */
1626 /* Error-catcher for target_find_memory_regions */
1627 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1629 error ("No target.");
1633 /* Error-catcher for target_make_corefile_notes */
1634 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1636 error ("No target.");
1640 /* Set up the handful of non-empty slots needed by the dummy target
1644 init_dummy_target (void)
1646 dummy_target
.to_shortname
= "None";
1647 dummy_target
.to_longname
= "None";
1648 dummy_target
.to_doc
= "";
1649 dummy_target
.to_attach
= find_default_attach
;
1650 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1651 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1652 dummy_target
.to_stratum
= dummy_stratum
;
1653 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1654 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1655 dummy_target
.to_magic
= OPS_MAGIC
;
1659 static struct target_ops debug_target
;
1662 debug_to_open (char *args
, int from_tty
)
1664 debug_target
.to_open (args
, from_tty
);
1666 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1670 debug_to_close (int quitting
)
1672 target_close (&debug_target
, quitting
);
1673 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1677 target_close (struct target_ops
*targ
, int quitting
)
1679 if (targ
->to_xclose
!= NULL
)
1680 targ
->to_xclose (targ
, quitting
);
1681 else if (targ
->to_close
!= NULL
)
1682 targ
->to_close (quitting
);
1686 debug_to_attach (char *args
, int from_tty
)
1688 debug_target
.to_attach (args
, from_tty
);
1690 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1695 debug_to_post_attach (int pid
)
1697 debug_target
.to_post_attach (pid
);
1699 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1703 debug_to_detach (char *args
, int from_tty
)
1705 debug_target
.to_detach (args
, from_tty
);
1707 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1711 debug_to_disconnect (char *args
, int from_tty
)
1713 debug_target
.to_disconnect (args
, from_tty
);
1715 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1720 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1722 debug_target
.to_resume (ptid
, step
, siggnal
);
1724 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1725 step
? "step" : "continue",
1726 target_signal_to_name (siggnal
));
1730 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1734 retval
= debug_target
.to_wait (ptid
, status
);
1736 fprintf_unfiltered (gdb_stdlog
,
1737 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1739 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1740 switch (status
->kind
)
1742 case TARGET_WAITKIND_EXITED
:
1743 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1744 status
->value
.integer
);
1746 case TARGET_WAITKIND_STOPPED
:
1747 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1748 target_signal_to_name (status
->value
.sig
));
1750 case TARGET_WAITKIND_SIGNALLED
:
1751 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1752 target_signal_to_name (status
->value
.sig
));
1754 case TARGET_WAITKIND_LOADED
:
1755 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1757 case TARGET_WAITKIND_FORKED
:
1758 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1760 case TARGET_WAITKIND_VFORKED
:
1761 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1763 case TARGET_WAITKIND_EXECD
:
1764 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1766 case TARGET_WAITKIND_SPURIOUS
:
1767 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1770 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1778 debug_to_post_wait (ptid_t ptid
, int status
)
1780 debug_target
.to_post_wait (ptid
, status
);
1782 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1783 PIDGET (ptid
), status
);
1787 debug_print_register (const char * func
, int regno
)
1789 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1790 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1791 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1792 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1794 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1798 unsigned char buf
[MAX_REGISTER_SIZE
];
1799 deprecated_read_register_gen (regno
, buf
);
1800 fprintf_unfiltered (gdb_stdlog
, " = ");
1801 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
++)
1803 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1805 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1807 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1808 paddr_nz (read_register (regno
)),
1809 paddr_d (read_register (regno
)));
1812 fprintf_unfiltered (gdb_stdlog
, "\n");
1816 debug_to_fetch_registers (int regno
)
1818 debug_target
.to_fetch_registers (regno
);
1819 debug_print_register ("target_fetch_registers", regno
);
1823 debug_to_store_registers (int regno
)
1825 debug_target
.to_store_registers (regno
);
1826 debug_print_register ("target_store_registers", regno
);
1827 fprintf_unfiltered (gdb_stdlog
, "\n");
1831 debug_to_prepare_to_store (void)
1833 debug_target
.to_prepare_to_store ();
1835 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1839 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1840 struct mem_attrib
*attrib
,
1841 struct target_ops
*target
)
1845 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1848 fprintf_unfiltered (gdb_stdlog
,
1849 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1850 (unsigned int) memaddr
, /* possable truncate long long */
1851 len
, write
? "write" : "read", retval
);
1859 fputs_unfiltered (", bytes =", gdb_stdlog
);
1860 for (i
= 0; i
< retval
; i
++)
1862 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1863 fprintf_unfiltered (gdb_stdlog
, "\n");
1864 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1868 fputc_unfiltered ('\n', gdb_stdlog
);
1874 debug_to_files_info (struct target_ops
*target
)
1876 debug_target
.to_files_info (target
);
1878 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1882 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1886 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1888 fprintf_unfiltered (gdb_stdlog
,
1889 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1890 (unsigned long) addr
,
1891 (unsigned long) retval
);
1896 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1900 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1902 fprintf_unfiltered (gdb_stdlog
,
1903 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1904 (unsigned long) addr
,
1905 (unsigned long) retval
);
1910 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1914 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1916 fprintf_unfiltered (gdb_stdlog
,
1917 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1918 (unsigned long) type
,
1919 (unsigned long) cnt
,
1920 (unsigned long) from_tty
,
1921 (unsigned long) retval
);
1926 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1930 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1932 fprintf_unfiltered (gdb_stdlog
,
1933 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1934 (unsigned long) byte_count
,
1935 (unsigned long) retval
);
1940 debug_to_stopped_by_watchpoint (void)
1944 retval
= debug_target
.to_stopped_by_watchpoint ();
1946 fprintf_unfiltered (gdb_stdlog
,
1947 "STOPPED_BY_WATCHPOINT () = %ld\n",
1948 (unsigned long) retval
);
1953 debug_to_stopped_data_address (void)
1957 retval
= debug_target
.to_stopped_data_address ();
1959 fprintf_unfiltered (gdb_stdlog
,
1960 "target_stopped_data_address () = 0x%lx\n",
1961 (unsigned long) retval
);
1966 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1970 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1972 fprintf_unfiltered (gdb_stdlog
,
1973 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1974 (unsigned long) addr
,
1975 (unsigned long) retval
);
1980 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1984 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1986 fprintf_unfiltered (gdb_stdlog
,
1987 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1988 (unsigned long) addr
,
1989 (unsigned long) retval
);
1994 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1998 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2000 fprintf_unfiltered (gdb_stdlog
,
2001 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2002 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2007 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2011 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2013 fprintf_unfiltered (gdb_stdlog
,
2014 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2015 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2020 debug_to_terminal_init (void)
2022 debug_target
.to_terminal_init ();
2024 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2028 debug_to_terminal_inferior (void)
2030 debug_target
.to_terminal_inferior ();
2032 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2036 debug_to_terminal_ours_for_output (void)
2038 debug_target
.to_terminal_ours_for_output ();
2040 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2044 debug_to_terminal_ours (void)
2046 debug_target
.to_terminal_ours ();
2048 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2052 debug_to_terminal_save_ours (void)
2054 debug_target
.to_terminal_save_ours ();
2056 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2060 debug_to_terminal_info (char *arg
, int from_tty
)
2062 debug_target
.to_terminal_info (arg
, from_tty
);
2064 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2069 debug_to_kill (void)
2071 debug_target
.to_kill ();
2073 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2077 debug_to_load (char *args
, int from_tty
)
2079 debug_target
.to_load (args
, from_tty
);
2081 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2085 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2089 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2091 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2097 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2099 debug_target
.to_create_inferior (exec_file
, args
, env
);
2101 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2106 debug_to_post_startup_inferior (ptid_t ptid
)
2108 debug_target
.to_post_startup_inferior (ptid
);
2110 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2115 debug_to_acknowledge_created_inferior (int pid
)
2117 debug_target
.to_acknowledge_created_inferior (pid
);
2119 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2124 debug_to_insert_fork_catchpoint (int pid
)
2128 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2130 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2137 debug_to_remove_fork_catchpoint (int pid
)
2141 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2143 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2150 debug_to_insert_vfork_catchpoint (int pid
)
2154 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2156 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2163 debug_to_remove_vfork_catchpoint (int pid
)
2167 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2169 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2176 debug_to_follow_fork (int follow_child
)
2178 int retval
= debug_target
.to_follow_fork (follow_child
);
2180 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2181 follow_child
, retval
);
2187 debug_to_insert_exec_catchpoint (int pid
)
2191 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2193 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2200 debug_to_remove_exec_catchpoint (int pid
)
2204 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2206 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2213 debug_to_reported_exec_events_per_exec_call (void)
2215 int reported_exec_events
;
2217 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2219 fprintf_unfiltered (gdb_stdlog
,
2220 "target_reported_exec_events_per_exec_call () = %d\n",
2221 reported_exec_events
);
2223 return reported_exec_events
;
2227 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2231 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2233 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2234 pid
, wait_status
, *exit_status
, has_exited
);
2240 debug_to_mourn_inferior (void)
2242 debug_target
.to_mourn_inferior ();
2244 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2248 debug_to_can_run (void)
2252 retval
= debug_target
.to_can_run ();
2254 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2260 debug_to_notice_signals (ptid_t ptid
)
2262 debug_target
.to_notice_signals (ptid
);
2264 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2269 debug_to_thread_alive (ptid_t ptid
)
2273 retval
= debug_target
.to_thread_alive (ptid
);
2275 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2276 PIDGET (ptid
), retval
);
2282 debug_to_find_new_threads (void)
2284 debug_target
.to_find_new_threads ();
2286 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2290 debug_to_stop (void)
2292 debug_target
.to_stop ();
2294 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2298 debug_to_read_partial (struct target_ops
*ops
,
2299 enum target_object object
,
2300 const char *annex
, void *buf
,
2301 ULONGEST offset
, LONGEST len
)
2305 retval
= target_read_partial (&debug_target
, object
, annex
, buf
, offset
,
2308 fprintf_unfiltered (gdb_stdlog
,
2309 "target_read_partial (%d, %s, 0x%lx, 0x%s, %s) = %s\n",
2310 (int) object
, (annex
? annex
: "(null)"),
2311 (long) buf
, paddr_nz (offset
),
2312 paddr_d (len
), paddr_d (retval
));
2318 debug_to_write_partial (struct target_ops
*ops
,
2319 enum target_object object
,
2320 const char *annex
, const void *buf
,
2321 ULONGEST offset
, LONGEST len
)
2325 retval
= target_write_partial (&debug_target
, object
, annex
, buf
, offset
,
2328 fprintf_unfiltered (gdb_stdlog
,
2329 "target_write_partial (%d, %s, 0x%lx, 0x%s, %s) = %s\n",
2330 (int) object
, (annex
? annex
: "(null)"),
2331 (long) buf
, paddr_nz (offset
),
2332 paddr_d (len
), paddr_d (retval
));
2338 debug_to_rcmd (char *command
,
2339 struct ui_file
*outbuf
)
2341 debug_target
.to_rcmd (command
, outbuf
);
2342 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2345 static struct symtab_and_line
*
2346 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2348 struct symtab_and_line
*result
;
2349 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2350 fprintf_unfiltered (gdb_stdlog
,
2351 "target get_exception_callback_sal (%d, %d)\n",
2356 static struct exception_event_record
*
2357 debug_to_get_current_exception_event (void)
2359 struct exception_event_record
*result
;
2360 result
= debug_target
.to_get_current_exception_event ();
2361 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2366 debug_to_pid_to_exec_file (int pid
)
2370 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2372 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2379 setup_target_debug (void)
2381 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2383 current_target
.to_open
= debug_to_open
;
2384 current_target
.to_close
= debug_to_close
;
2385 current_target
.to_attach
= debug_to_attach
;
2386 current_target
.to_post_attach
= debug_to_post_attach
;
2387 current_target
.to_detach
= debug_to_detach
;
2388 current_target
.to_disconnect
= debug_to_disconnect
;
2389 current_target
.to_resume
= debug_to_resume
;
2390 current_target
.to_wait
= debug_to_wait
;
2391 current_target
.to_post_wait
= debug_to_post_wait
;
2392 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2393 current_target
.to_store_registers
= debug_to_store_registers
;
2394 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2395 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2396 current_target
.to_files_info
= debug_to_files_info
;
2397 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2398 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2399 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2400 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2401 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2402 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2403 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2404 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2405 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2406 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2407 current_target
.to_terminal_init
= debug_to_terminal_init
;
2408 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2409 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2410 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2411 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2412 current_target
.to_terminal_info
= debug_to_terminal_info
;
2413 current_target
.to_kill
= debug_to_kill
;
2414 current_target
.to_load
= debug_to_load
;
2415 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2416 current_target
.to_create_inferior
= debug_to_create_inferior
;
2417 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2418 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2419 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2420 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2421 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2422 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2423 current_target
.to_follow_fork
= debug_to_follow_fork
;
2424 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2425 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2426 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2427 current_target
.to_has_exited
= debug_to_has_exited
;
2428 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2429 current_target
.to_can_run
= debug_to_can_run
;
2430 current_target
.to_notice_signals
= debug_to_notice_signals
;
2431 current_target
.to_thread_alive
= debug_to_thread_alive
;
2432 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2433 current_target
.to_stop
= debug_to_stop
;
2434 current_target
.to_read_partial
= debug_to_read_partial
;
2435 current_target
.to_write_partial
= debug_to_write_partial
;
2436 current_target
.to_rcmd
= debug_to_rcmd
;
2437 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2438 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2439 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2444 static char targ_desc
[] =
2445 "Names of targets and files being debugged.\n\
2446 Shows the entire stack of targets currently in use (including the exec-file,\n\
2447 core-file, and process, if any), as well as the symbol file name.";
2450 do_monitor_command (char *cmd
,
2453 if ((current_target
.to_rcmd
2454 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2455 || (current_target
.to_rcmd
== debug_to_rcmd
2456 && (debug_target
.to_rcmd
2457 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2459 error ("\"monitor\" command not supported by this target.\n");
2461 target_rcmd (cmd
, gdb_stdtarg
);
2465 initialize_targets (void)
2467 init_dummy_target ();
2468 push_target (&dummy_target
);
2470 add_info ("target", target_info
, targ_desc
);
2471 add_info ("files", target_info
, targ_desc
);
2474 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2475 (char *) &targetdebug
,
2476 "Set target debugging.\n\
2477 When non-zero, target debugging is enabled.", &setdebuglist
),
2480 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2482 Set mode for reading from readonly sections.\n\
2483 When this mode is on, memory reads from readonly sections (such as .text)\n\
2484 will be read from the object file instead of from the target. This will\n\
2485 result in significant performance improvement for remote targets.", "\
2486 Show mode for reading from readonly sections.\n",
2488 &setlist
, &showlist
);
2490 add_com ("monitor", class_obscure
, do_monitor_command
,
2491 "Send a command to the remote monitor (remote targets only).");
2493 target_dcache
= dcache_init ();