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, 2004 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"
42 static void target_info (char *, int);
44 static void maybe_kill_then_attach (char *, int);
46 static void kill_or_be_killed (int);
48 static void default_terminal_info (char *, int);
50 static int default_region_size_ok_for_hw_watchpoint (int);
52 static int nosymbol (char *, CORE_ADDR
*);
54 static void tcomplain (void);
56 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
58 static int return_zero (void);
60 static int return_one (void);
62 static int return_minus_one (void);
64 void target_ignore (void);
66 static void target_command (char *, int);
68 static struct target_ops
*find_default_run_target (char *);
70 static void nosupport_runtime (void);
72 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
73 enum target_object object
,
74 const char *annex
, void *readbuf
,
76 ULONGEST offset
, LONGEST len
);
78 /* Transfer LEN bytes between target address MEMADDR and GDB address
79 MYADDR. Returns 0 for success, errno code for failure (which
80 includes partial transfers -- if you want a more useful response to
81 partial transfers, try either target_read_memory_partial or
82 target_write_memory_partial). */
84 static int target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
87 static void init_dummy_target (void);
89 static void debug_to_open (char *, int);
91 static void debug_to_close (int);
93 static void debug_to_attach (char *, int);
95 static void debug_to_detach (char *, int);
97 static void debug_to_disconnect (char *, int);
99 static void debug_to_resume (ptid_t
, int, enum target_signal
);
101 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
103 static void debug_to_fetch_registers (int);
105 static void debug_to_store_registers (int);
107 static void debug_to_prepare_to_store (void);
109 static int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
110 struct mem_attrib
*, struct target_ops
*);
112 static void debug_to_files_info (struct target_ops
*);
114 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
116 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
118 static int debug_to_can_use_hw_breakpoint (int, int, int);
120 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
122 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
124 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
126 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
128 static int debug_to_stopped_by_watchpoint (void);
130 static CORE_ADDR
debug_to_stopped_data_address (void);
132 static int debug_to_region_size_ok_for_hw_watchpoint (int);
134 static void debug_to_terminal_init (void);
136 static void debug_to_terminal_inferior (void);
138 static void debug_to_terminal_ours_for_output (void);
140 static void debug_to_terminal_save_ours (void);
142 static void debug_to_terminal_ours (void);
144 static void debug_to_terminal_info (char *, int);
146 static void debug_to_kill (void);
148 static void debug_to_load (char *, int);
150 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
152 static void debug_to_mourn_inferior (void);
154 static int debug_to_can_run (void);
156 static void debug_to_notice_signals (ptid_t
);
158 static int debug_to_thread_alive (ptid_t
);
160 static void debug_to_stop (void);
162 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
163 wierd and mysterious ways. Putting the variable here lets those
164 wierd and mysterious ways keep building while they are being
165 converted to the inferior inheritance structure. */
166 struct target_ops child_ops
;
168 /* Pointer to array of target architecture structures; the size of the
169 array; the current index into the array; the allocated size of the
171 struct target_ops
**target_structs
;
172 unsigned target_struct_size
;
173 unsigned target_struct_index
;
174 unsigned target_struct_allocsize
;
175 #define DEFAULT_ALLOCSIZE 10
177 /* The initial current target, so that there is always a semi-valid
180 static struct target_ops dummy_target
;
182 /* Top of target stack. */
184 static struct target_ops
*target_stack
;
186 /* The target structure we are currently using to talk to a process
187 or file or whatever "inferior" we have. */
189 struct target_ops current_target
;
191 /* Command list for target. */
193 static struct cmd_list_element
*targetlist
= NULL
;
195 /* Nonzero if we are debugging an attached outside process
196 rather than an inferior. */
200 /* Non-zero if we want to see trace of target level stuff. */
202 static int targetdebug
= 0;
204 static void setup_target_debug (void);
206 DCACHE
*target_dcache
;
208 /* The user just typed 'target' without the name of a target. */
211 target_command (char *arg
, int from_tty
)
213 fputs_filtered ("Argument required (target name). Try `help target'\n",
217 /* Add a possible target architecture to the list. */
220 add_target (struct target_ops
*t
)
222 /* Provide default values for all "must have" methods. */
223 if (t
->to_xfer_partial
== NULL
)
224 t
->to_xfer_partial
= default_xfer_partial
;
228 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
229 target_structs
= (struct target_ops
**) xmalloc
230 (target_struct_allocsize
* sizeof (*target_structs
));
232 if (target_struct_size
>= target_struct_allocsize
)
234 target_struct_allocsize
*= 2;
235 target_structs
= (struct target_ops
**)
236 xrealloc ((char *) target_structs
,
237 target_struct_allocsize
* sizeof (*target_structs
));
239 target_structs
[target_struct_size
++] = t
;
241 if (targetlist
== NULL
)
242 add_prefix_cmd ("target", class_run
, target_command
,
243 "Connect to a target machine or process.\n\
244 The first argument is the type or protocol of the target machine.\n\
245 Remaining arguments are interpreted by the target protocol. For more\n\
246 information on the arguments for a particular protocol, type\n\
247 `help target ' followed by the protocol name.",
248 &targetlist
, "target ", 0, &cmdlist
);
249 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
260 target_load (char *arg
, int from_tty
)
262 dcache_invalidate (target_dcache
);
263 (*current_target
.to_load
) (arg
, from_tty
);
267 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
268 struct target_ops
*t
)
270 errno
= EIO
; /* Can't read/write this location */
271 return 0; /* No bytes handled */
277 error ("You can't do that when your target is `%s'",
278 current_target
.to_shortname
);
284 error ("You can't do that without a process to debug.");
288 nosymbol (char *name
, CORE_ADDR
*addrp
)
290 return 1; /* Symbol does not exist in target env */
294 nosupport_runtime (void)
296 if (ptid_equal (inferior_ptid
, null_ptid
))
299 error ("No run-time support for this");
304 default_terminal_info (char *args
, int from_tty
)
306 printf_unfiltered ("No saved terminal information.\n");
309 /* This is the default target_create_inferior and target_attach function.
310 If the current target is executing, it asks whether to kill it off.
311 If this function returns without calling error(), it has killed off
312 the target, and the operation should be attempted. */
315 kill_or_be_killed (int from_tty
)
317 if (target_has_execution
)
319 printf_unfiltered ("You are already running a program:\n");
320 target_files_info ();
321 if (query ("Kill it? "))
324 if (target_has_execution
)
325 error ("Killing the program did not help.");
330 error ("Program not killed.");
337 maybe_kill_then_attach (char *args
, int from_tty
)
339 kill_or_be_killed (from_tty
);
340 target_attach (args
, from_tty
);
344 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
347 kill_or_be_killed (0);
348 target_create_inferior (exec
, args
, env
, from_tty
);
351 /* Go through the target stack from top to bottom, copying over zero
352 entries in current_target, then filling in still empty entries. In
353 effect, we are doing class inheritance through the pushed target
356 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
357 is currently implemented, is that it discards any knowledge of
358 which target an inherited method originally belonged to.
359 Consequently, new new target methods should instead explicitly and
360 locally search the target stack for the target that can handle the
364 update_current_target (void)
366 struct target_ops
*t
;
368 /* First, reset curren'ts contents. */
369 memset (¤t_target
, 0, sizeof (current_target
));
371 #define INHERIT(FIELD, TARGET) \
372 if (!current_target.FIELD) \
373 current_target.FIELD = (TARGET)->FIELD
375 for (t
= target_stack
; t
; t
= t
->beneath
)
377 INHERIT (to_shortname
, t
);
378 INHERIT (to_longname
, t
);
380 INHERIT (to_open
, t
);
381 INHERIT (to_close
, t
);
382 INHERIT (to_attach
, t
);
383 INHERIT (to_post_attach
, t
);
384 INHERIT (to_detach
, t
);
385 INHERIT (to_disconnect
, t
);
386 INHERIT (to_resume
, t
);
387 INHERIT (to_wait
, t
);
388 INHERIT (to_fetch_registers
, t
);
389 INHERIT (to_store_registers
, t
);
390 INHERIT (to_prepare_to_store
, t
);
391 INHERIT (to_xfer_memory
, t
);
392 INHERIT (to_files_info
, t
);
393 INHERIT (to_insert_breakpoint
, t
);
394 INHERIT (to_remove_breakpoint
, t
);
395 INHERIT (to_can_use_hw_breakpoint
, t
);
396 INHERIT (to_insert_hw_breakpoint
, t
);
397 INHERIT (to_remove_hw_breakpoint
, t
);
398 INHERIT (to_insert_watchpoint
, t
);
399 INHERIT (to_remove_watchpoint
, t
);
400 INHERIT (to_stopped_data_address
, t
);
401 INHERIT (to_stopped_by_watchpoint
, t
);
402 INHERIT (to_have_continuable_watchpoint
, t
);
403 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
404 INHERIT (to_terminal_init
, t
);
405 INHERIT (to_terminal_inferior
, t
);
406 INHERIT (to_terminal_ours_for_output
, t
);
407 INHERIT (to_terminal_ours
, t
);
408 INHERIT (to_terminal_save_ours
, t
);
409 INHERIT (to_terminal_info
, t
);
410 INHERIT (to_kill
, t
);
411 INHERIT (to_load
, t
);
412 INHERIT (to_lookup_symbol
, t
);
413 INHERIT (to_create_inferior
, t
);
414 INHERIT (to_post_startup_inferior
, t
);
415 INHERIT (to_acknowledge_created_inferior
, t
);
416 INHERIT (to_insert_fork_catchpoint
, t
);
417 INHERIT (to_remove_fork_catchpoint
, t
);
418 INHERIT (to_insert_vfork_catchpoint
, t
);
419 INHERIT (to_remove_vfork_catchpoint
, t
);
420 INHERIT (to_follow_fork
, t
);
421 INHERIT (to_insert_exec_catchpoint
, t
);
422 INHERIT (to_remove_exec_catchpoint
, t
);
423 INHERIT (to_reported_exec_events_per_exec_call
, t
);
424 INHERIT (to_has_exited
, t
);
425 INHERIT (to_mourn_inferior
, t
);
426 INHERIT (to_can_run
, t
);
427 INHERIT (to_notice_signals
, t
);
428 INHERIT (to_thread_alive
, t
);
429 INHERIT (to_find_new_threads
, t
);
430 INHERIT (to_pid_to_str
, t
);
431 INHERIT (to_extra_thread_info
, t
);
432 INHERIT (to_stop
, t
);
433 /* Do not inherit to_xfer_partial. */
434 INHERIT (to_rcmd
, t
);
435 INHERIT (to_enable_exception_callback
, t
);
436 INHERIT (to_get_current_exception_event
, t
);
437 INHERIT (to_pid_to_exec_file
, t
);
438 INHERIT (to_stratum
, t
);
439 INHERIT (to_has_all_memory
, t
);
440 INHERIT (to_has_memory
, t
);
441 INHERIT (to_has_stack
, t
);
442 INHERIT (to_has_registers
, t
);
443 INHERIT (to_has_execution
, t
);
444 INHERIT (to_has_thread_control
, t
);
445 INHERIT (to_sections
, t
);
446 INHERIT (to_sections_end
, t
);
447 INHERIT (to_can_async_p
, t
);
448 INHERIT (to_is_async_p
, t
);
449 INHERIT (to_async
, t
);
450 INHERIT (to_async_mask_value
, t
);
451 INHERIT (to_find_memory_regions
, t
);
452 INHERIT (to_make_corefile_notes
, t
);
453 INHERIT (to_get_thread_local_address
, t
);
454 INHERIT (to_magic
, t
);
458 /* Clean up a target struct so it no longer has any zero pointers in
459 it. Some entries are defaulted to a method that print an error,
460 others are hard-wired to a standard recursive default. */
462 #define de_fault(field, value) \
463 if (!current_target.field) \
464 current_target.field = value
467 (void (*) (char *, int))
473 maybe_kill_then_attach
);
474 de_fault (to_post_attach
,
478 (void (*) (char *, int))
480 de_fault (to_disconnect
,
481 (void (*) (char *, int))
484 (void (*) (ptid_t
, int, enum target_signal
))
487 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
489 de_fault (to_fetch_registers
,
492 de_fault (to_store_registers
,
495 de_fault (to_prepare_to_store
,
498 de_fault (to_xfer_memory
,
499 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
501 de_fault (to_files_info
,
502 (void (*) (struct target_ops
*))
504 de_fault (to_insert_breakpoint
,
505 memory_insert_breakpoint
);
506 de_fault (to_remove_breakpoint
,
507 memory_remove_breakpoint
);
508 de_fault (to_can_use_hw_breakpoint
,
509 (int (*) (int, int, int))
511 de_fault (to_insert_hw_breakpoint
,
512 (int (*) (CORE_ADDR
, char *))
514 de_fault (to_remove_hw_breakpoint
,
515 (int (*) (CORE_ADDR
, char *))
517 de_fault (to_insert_watchpoint
,
518 (int (*) (CORE_ADDR
, int, int))
520 de_fault (to_remove_watchpoint
,
521 (int (*) (CORE_ADDR
, int, int))
523 de_fault (to_stopped_by_watchpoint
,
526 de_fault (to_stopped_data_address
,
527 (CORE_ADDR (*) (void))
529 de_fault (to_region_size_ok_for_hw_watchpoint
,
530 default_region_size_ok_for_hw_watchpoint
);
531 de_fault (to_terminal_init
,
534 de_fault (to_terminal_inferior
,
537 de_fault (to_terminal_ours_for_output
,
540 de_fault (to_terminal_ours
,
543 de_fault (to_terminal_save_ours
,
546 de_fault (to_terminal_info
,
547 default_terminal_info
);
552 (void (*) (char *, int))
554 de_fault (to_lookup_symbol
,
555 (int (*) (char *, CORE_ADDR
*))
557 de_fault (to_create_inferior
,
558 maybe_kill_then_create_inferior
);
559 de_fault (to_post_startup_inferior
,
562 de_fault (to_acknowledge_created_inferior
,
565 de_fault (to_insert_fork_catchpoint
,
568 de_fault (to_remove_fork_catchpoint
,
571 de_fault (to_insert_vfork_catchpoint
,
574 de_fault (to_remove_vfork_catchpoint
,
577 de_fault (to_follow_fork
,
580 de_fault (to_insert_exec_catchpoint
,
583 de_fault (to_remove_exec_catchpoint
,
586 de_fault (to_reported_exec_events_per_exec_call
,
589 de_fault (to_has_exited
,
590 (int (*) (int, int, int *))
592 de_fault (to_mourn_inferior
,
595 de_fault (to_can_run
,
597 de_fault (to_notice_signals
,
600 de_fault (to_thread_alive
,
603 de_fault (to_find_new_threads
,
606 de_fault (to_extra_thread_info
,
607 (char *(*) (struct thread_info
*))
612 current_target
.to_xfer_partial
= default_xfer_partial
;
614 (void (*) (char *, struct ui_file
*))
616 de_fault (to_enable_exception_callback
,
617 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
619 de_fault (to_get_current_exception_event
,
620 (struct exception_event_record
* (*) (void))
622 de_fault (to_pid_to_exec_file
,
625 de_fault (to_can_async_p
,
628 de_fault (to_is_async_p
,
632 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
636 /* Finally, position the target-stack beneath the squashed
637 "current_target". That way code looking for a non-inherited
638 target method can quickly and simply find it. */
639 current_target
.beneath
= target_stack
;
642 /* Push a new target type into the stack of the existing target accessors,
643 possibly superseding some of the existing accessors.
645 Result is zero if the pushed target ended up on top of the stack,
646 nonzero if at least one target is on top of it.
648 Rather than allow an empty stack, we always have the dummy target at
649 the bottom stratum, so we can call the function vectors without
653 push_target (struct target_ops
*t
)
655 struct target_ops
**cur
;
657 /* Check magic number. If wrong, it probably means someone changed
658 the struct definition, but not all the places that initialize one. */
659 if (t
->to_magic
!= OPS_MAGIC
)
661 fprintf_unfiltered (gdb_stderr
,
662 "Magic number of %s target struct wrong\n",
664 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
667 /* Find the proper stratum to install this target in. */
668 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
670 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
674 /* If there's already targets at this stratum, remove them. */
675 /* FIXME: cagney/2003-10-15: I think this should be poping all
676 targets to CUR, and not just those at this stratum level. */
677 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
679 /* There's already something at this stratum level. Close it,
680 and un-hook it from the stack. */
681 struct target_ops
*tmp
= (*cur
);
682 (*cur
) = (*cur
)->beneath
;
684 target_close (tmp
, 0);
687 /* We have removed all targets in our stratum, now add the new one. */
691 update_current_target ();
694 setup_target_debug ();
697 return (t
!= target_stack
);
700 /* Remove a target_ops vector from the stack, wherever it may be.
701 Return how many times it was removed (0 or 1). */
704 unpush_target (struct target_ops
*t
)
706 struct target_ops
**cur
;
707 struct target_ops
*tmp
;
709 /* Look for the specified target. Note that we assume that a target
710 can only occur once in the target stack. */
712 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
719 return 0; /* Didn't find target_ops, quit now */
721 /* NOTE: cagney/2003-12-06: In '94 the close call was made
722 unconditional by moving it to before the above check that the
723 target was in the target stack (something about "Change the way
724 pushing and popping of targets work to support target overlays
725 and inheritance"). This doesn't make much sense - only open
726 targets should be closed. */
729 /* Unchain the target */
731 (*cur
) = (*cur
)->beneath
;
734 update_current_target ();
742 target_close (¤t_target
, 0); /* Let it clean up */
743 if (unpush_target (target_stack
) == 1)
746 fprintf_unfiltered (gdb_stderr
,
747 "pop_target couldn't find target %s\n",
748 current_target
.to_shortname
);
749 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
753 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
755 /* target_read_string -- read a null terminated string, up to LEN bytes,
756 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
757 Set *STRING to a pointer to malloc'd memory containing the data; the caller
758 is responsible for freeing it. Return the number of bytes successfully
762 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
764 int tlen
, origlen
, offset
, i
;
768 int buffer_allocated
;
770 unsigned int nbytes_read
= 0;
772 /* Small for testing. */
773 buffer_allocated
= 4;
774 buffer
= xmalloc (buffer_allocated
);
781 tlen
= MIN (len
, 4 - (memaddr
& 3));
782 offset
= memaddr
& 3;
784 errcode
= target_read_memory (memaddr
& ~3, buf
, 4);
787 /* The transfer request might have crossed the boundary to an
788 unallocated region of memory. Retry the transfer, requesting
792 errcode
= target_read_memory (memaddr
, buf
, 1);
797 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
800 bytes
= bufptr
- buffer
;
801 buffer_allocated
*= 2;
802 buffer
= xrealloc (buffer
, buffer_allocated
);
803 bufptr
= buffer
+ bytes
;
806 for (i
= 0; i
< tlen
; i
++)
808 *bufptr
++ = buf
[i
+ offset
];
809 if (buf
[i
+ offset
] == '\000')
811 nbytes_read
+= i
+ 1;
828 /* Find a section containing ADDR. */
829 struct section_table
*
830 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
832 struct section_table
*secp
;
833 for (secp
= target
->to_sections
;
834 secp
< target
->to_sections_end
;
837 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
843 /* Return non-zero when the target vector has supplied an xfer_partial
844 method and it, rather than xfer_memory, should be used. */
846 target_xfer_partial_p (void)
848 return (target_stack
!= NULL
849 && target_stack
->to_xfer_partial
!= default_xfer_partial
);
853 target_xfer_partial (struct target_ops
*ops
,
854 enum target_object object
, const char *annex
,
855 void *readbuf
, const void *writebuf
,
856 ULONGEST offset
, LONGEST len
)
860 gdb_assert (ops
->to_xfer_partial
!= NULL
);
861 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
865 const unsigned char *myaddr
= NULL
;
867 fprintf_unfiltered (gdb_stdlog
,
868 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
871 (annex
? annex
: "(null)"),
872 (long) readbuf
, (long) writebuf
,
873 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
879 if (retval
> 0 && myaddr
!= NULL
)
883 fputs_unfiltered (", bytes =", gdb_stdlog
);
884 for (i
= 0; i
< retval
; i
++)
886 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
888 if (targetdebug
< 2 && i
> 0)
890 fprintf_unfiltered (gdb_stdlog
, " ...");
893 fprintf_unfiltered (gdb_stdlog
, "\n");
896 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
900 fputc_unfiltered ('\n', gdb_stdlog
);
905 /* Attempt a transfer all LEN bytes starting at OFFSET between the
906 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
907 the transfer succeeds, return zero, otherwize the host ERRNO is
910 The inferior is formed from several layers. In the case of
911 corefiles, inf-corefile is layered above inf-exec and a request for
912 text (corefiles do not include text pages) will be first sent to
913 the core-stratum, fail, and then sent to the object-file where it
916 NOTE: cagney/2004-09-30:
918 The old code tried to use four separate mechanisms for mapping an
919 object:offset:len tuple onto an inferior and its address space: the
920 target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
925 The code below is instead using a single mechanism (currently
926 strata). If that mechanism proves insufficient then re-factor it
927 implementing another singluar mechanism (for instance, a generic
928 object:annex onto inferior:object:annex say). */
931 xfer_using_stratum (enum target_object object
, const char *annex
,
932 CORE_ADDR memaddr
, int len
, void *readbuf
,
933 const void *writebuf
)
936 struct target_ops
*target
;
938 /* Always successful. */
941 /* Never successful. */
942 if (target_stack
== NULL
)
945 target
= target_stack
;
948 xfered
= target_xfer_partial (target
, object
, annex
,
949 readbuf
, writebuf
, memaddr
, len
);
952 /* The partial xfer succeeded, update the counts, check that
953 the xfer hasn't finished and if it hasn't set things up
954 for the next round. */
958 target
= target_stack
;
962 /* Something totally screwed up, abandon the attempt to
971 /* This "stratum" didn't work, try the next one down. */
972 target
= target
->beneath
;
979 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
980 GDB's memory at MYADDR. Returns either 0 for success or an errno value
983 If an error occurs, no guarantee is made about the contents of the data at
984 MYADDR. In particular, the caller should not depend upon partial reads
985 filling the buffer with good data. There is no way for the caller to know
986 how much good data might have been transfered anyway. Callers that can
987 deal with partial reads should call target_read_memory_partial. */
990 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
992 if (target_xfer_partial_p ())
993 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
994 memaddr
, len
, myaddr
, NULL
);
996 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
1000 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1002 if (target_xfer_partial_p ())
1003 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1004 memaddr
, len
, NULL
, myaddr
);
1006 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
1009 static int trust_readonly
= 0;
1011 /* Move memory to or from the targets. The top target gets priority;
1012 if it cannot handle it, it is offered to the next one down, etc.
1014 Result is -1 on error, or the number of bytes transfered. */
1017 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1018 struct mem_attrib
*attrib
)
1022 struct target_ops
*t
;
1024 /* Zero length requests are ok and require no work. */
1028 /* to_xfer_memory is not guaranteed to set errno, even when it returns
1032 if (!write
&& trust_readonly
)
1034 struct section_table
*secp
;
1035 /* User-settable option, "trust-readonly-sections". If true,
1036 then memory from any SEC_READONLY bfd section may be read
1037 directly from the bfd file. */
1038 secp
= target_section_by_addr (¤t_target
, memaddr
);
1040 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1042 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
1045 /* The quick case is that the top target can handle the transfer. */
1046 res
= current_target
.to_xfer_memory
1047 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
1049 /* If res <= 0 then we call it again in the loop. Ah well. */
1052 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1054 if (!t
->to_has_memory
)
1057 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1059 break; /* Handled all or part of xfer */
1060 if (t
->to_has_all_memory
)
1072 /* Perform a memory transfer. Iterate until the entire region has
1075 Result is 0 or errno value. */
1078 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
1082 struct mem_region
*region
;
1084 /* Zero length requests are ok and require no work. */
1092 region
= lookup_mem_region(memaddr
);
1093 if (memaddr
+ len
< region
->hi
)
1096 reg_len
= region
->hi
- memaddr
;
1098 switch (region
->attrib
.mode
)
1113 if (region
->attrib
.cache
)
1114 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1117 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1122 /* If this address is for nonexistent memory, read zeros
1123 if reading, or do nothing if writing. Return
1126 memset (myaddr
, 0, len
);
1140 return 0; /* We managed to cover it all somehow. */
1144 /* Perform a partial memory transfer.
1146 Result is -1 on error, or the number of bytes transfered. */
1149 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1150 int write_p
, int *err
)
1154 struct mem_region
*region
;
1156 /* Zero length requests are ok and require no work. */
1163 region
= lookup_mem_region(memaddr
);
1164 if (memaddr
+ len
< region
->hi
)
1167 reg_len
= region
->hi
- memaddr
;
1169 switch (region
->attrib
.mode
)
1188 if (region
->attrib
.cache
)
1189 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1192 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1210 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1212 if (target_xfer_partial_p ())
1213 return target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
, NULL
,
1214 buf
, NULL
, memaddr
, len
);
1216 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1220 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1222 if (target_xfer_partial_p ())
1223 return target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
, NULL
,
1224 NULL
, buf
, memaddr
, len
);
1226 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1229 /* More generic transfers. */
1232 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1233 const char *annex
, void *readbuf
,
1234 const void *writebuf
, ULONGEST offset
, LONGEST len
)
1236 if (object
== TARGET_OBJECT_MEMORY
1237 && ops
->to_xfer_memory
!= NULL
)
1238 /* If available, fall back to the target's "to_xfer_memory"
1243 if (writebuf
!= NULL
)
1245 void *buffer
= xmalloc (len
);
1246 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1247 memcpy (buffer
, writebuf
, len
);
1248 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1250 do_cleanups (cleanup
);
1252 if (readbuf
!= NULL
)
1253 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1257 else if (xfered
== 0 && errno
== 0)
1258 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1259 indication of an error. */
1264 else if (ops
->beneath
!= NULL
)
1265 return target_xfer_partial (ops
->beneath
, object
, annex
,
1266 readbuf
, writebuf
, offset
, len
);
1271 /* Target vector read/write partial wrapper functions.
1273 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1274 (inbuf, outbuf)", instead of separate read/write methods, make life
1278 target_read_partial (struct target_ops
*ops
,
1279 enum target_object object
,
1280 const char *annex
, void *buf
,
1281 ULONGEST offset
, LONGEST len
)
1283 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1287 target_write_partial (struct target_ops
*ops
,
1288 enum target_object object
,
1289 const char *annex
, const void *buf
,
1290 ULONGEST offset
, LONGEST len
)
1292 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1295 /* Wrappers to perform the full transfer. */
1297 target_read (struct target_ops
*ops
,
1298 enum target_object object
,
1299 const char *annex
, void *buf
,
1300 ULONGEST offset
, LONGEST len
)
1303 while (xfered
< len
)
1305 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1306 (bfd_byte
*) buf
+ xfered
,
1307 offset
+ xfered
, len
- xfered
);
1308 /* Call an observer, notifying them of the xfer progress? */
1310 /* Call memory_error? */
1319 target_write (struct target_ops
*ops
,
1320 enum target_object object
,
1321 const char *annex
, const void *buf
,
1322 ULONGEST offset
, LONGEST len
)
1325 while (xfered
< len
)
1327 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1328 (bfd_byte
*) buf
+ xfered
,
1329 offset
+ xfered
, len
- xfered
);
1330 /* Call an observer, notifying them of the xfer progress? */
1332 /* Call memory_error? */
1340 /* Memory transfer methods. */
1343 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1346 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1348 memory_error (EIO
, addr
);
1352 get_target_memory_unsigned (struct target_ops
*ops
,
1353 CORE_ADDR addr
, int len
)
1355 char buf
[sizeof (ULONGEST
)];
1357 gdb_assert (len
<= sizeof (buf
));
1358 get_target_memory (ops
, addr
, buf
, len
);
1359 return extract_unsigned_integer (buf
, len
);
1363 target_info (char *args
, int from_tty
)
1365 struct target_ops
*t
;
1366 int has_all_mem
= 0;
1368 if (symfile_objfile
!= NULL
)
1369 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1371 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1373 if (!t
->to_has_memory
)
1376 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1379 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1380 printf_unfiltered ("%s:\n", t
->to_longname
);
1381 (t
->to_files_info
) (t
);
1382 has_all_mem
= t
->to_has_all_memory
;
1386 /* This is to be called by the open routine before it does
1390 target_preopen (int from_tty
)
1394 if (target_has_execution
)
1397 || query ("A program is being debugged already. Kill it? "))
1400 error ("Program not killed.");
1403 /* Calling target_kill may remove the target from the stack. But if
1404 it doesn't (which seems like a win for UDI), remove it now. */
1406 if (target_has_execution
)
1410 /* Detach a target after doing deferred register stores. */
1413 target_detach (char *args
, int from_tty
)
1415 (current_target
.to_detach
) (args
, from_tty
);
1419 target_disconnect (char *args
, int from_tty
)
1421 (current_target
.to_disconnect
) (args
, from_tty
);
1425 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1427 if (DEPRECATED_STREQ (current_target
.to_shortname
, "rombug"))
1429 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1431 error ("Unable to link to %s and get relocation in rombug", modname
);
1434 *t_reloc
= (CORE_ADDR
) -1;
1438 target_async_mask (int mask
)
1440 int saved_async_masked_status
= target_async_mask_value
;
1441 target_async_mask_value
= mask
;
1442 return saved_async_masked_status
;
1445 /* Look through the list of possible targets for a target that can
1446 execute a run or attach command without any other data. This is
1447 used to locate the default process stratum.
1449 Result is always valid (error() is called for errors). */
1451 static struct target_ops
*
1452 find_default_run_target (char *do_mesg
)
1454 struct target_ops
**t
;
1455 struct target_ops
*runable
= NULL
;
1460 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1463 if ((*t
)->to_can_run
&& target_can_run (*t
))
1471 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1477 find_default_attach (char *args
, int from_tty
)
1479 struct target_ops
*t
;
1481 t
= find_default_run_target ("attach");
1482 (t
->to_attach
) (args
, from_tty
);
1487 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1490 struct target_ops
*t
;
1492 t
= find_default_run_target ("run");
1493 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1498 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1500 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1516 return_minus_one (void)
1522 * Resize the to_sections pointer. Also make sure that anyone that
1523 * was holding on to an old value of it gets updated.
1524 * Returns the old size.
1528 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1530 struct target_ops
**t
;
1531 struct section_table
*old_value
;
1534 old_value
= target
->to_sections
;
1536 if (target
->to_sections
)
1538 old_count
= target
->to_sections_end
- target
->to_sections
;
1539 target
->to_sections
= (struct section_table
*)
1540 xrealloc ((char *) target
->to_sections
,
1541 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1546 target
->to_sections
= (struct section_table
*)
1547 xmalloc ((sizeof (struct section_table
)) * num_added
);
1549 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1551 /* Check to see if anyone else was pointing to this structure.
1552 If old_value was null, then no one was. */
1556 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1559 if ((*t
)->to_sections
== old_value
)
1561 (*t
)->to_sections
= target
->to_sections
;
1562 (*t
)->to_sections_end
= target
->to_sections_end
;
1565 /* There is a flattened view of the target stack in current_target,
1566 so its to_sections pointer might also need updating. */
1567 if (current_target
.to_sections
== old_value
)
1569 current_target
.to_sections
= target
->to_sections
;
1570 current_target
.to_sections_end
= target
->to_sections_end
;
1578 /* Remove all target sections taken from ABFD.
1580 Scan the current target stack for targets whose section tables
1581 refer to sections from BFD, and remove those sections. We use this
1582 when we notice that the inferior has unloaded a shared object, for
1585 remove_target_sections (bfd
*abfd
)
1587 struct target_ops
**t
;
1589 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1591 struct section_table
*src
, *dest
;
1593 dest
= (*t
)->to_sections
;
1594 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1595 if (src
->bfd
!= abfd
)
1597 /* Keep this section. */
1598 if (dest
< src
) *dest
= *src
;
1602 /* If we've dropped any sections, resize the section table. */
1604 target_resize_to_sections (*t
, dest
- src
);
1611 /* Find a single runnable target in the stack and return it. If for
1612 some reason there is more than one, return NULL. */
1615 find_run_target (void)
1617 struct target_ops
**t
;
1618 struct target_ops
*runable
= NULL
;
1623 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1625 if ((*t
)->to_can_run
&& target_can_run (*t
))
1632 return (count
== 1 ? runable
: NULL
);
1635 /* Find a single core_stratum target in the list of targets and return it.
1636 If for some reason there is more than one, return NULL. */
1639 find_core_target (void)
1641 struct target_ops
**t
;
1642 struct target_ops
*runable
= NULL
;
1647 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1650 if ((*t
)->to_stratum
== core_stratum
)
1657 return (count
== 1 ? runable
: NULL
);
1661 * Find the next target down the stack from the specified target.
1665 find_target_beneath (struct target_ops
*t
)
1671 /* The inferior process has died. Long live the inferior! */
1674 generic_mourn_inferior (void)
1676 extern int show_breakpoint_hit_counts
;
1678 inferior_ptid
= null_ptid
;
1680 breakpoint_init_inferior (inf_exited
);
1681 registers_changed ();
1683 reopen_exec_file ();
1684 reinit_frame_cache ();
1686 /* It is confusing to the user for ignore counts to stick around
1687 from previous runs of the inferior. So clear them. */
1688 /* However, it is more confusing for the ignore counts to disappear when
1689 using hit counts. So don't clear them if we're counting hits. */
1690 if (!show_breakpoint_hit_counts
)
1691 breakpoint_clear_ignore_counts ();
1693 if (deprecated_detach_hook
)
1694 deprecated_detach_hook ();
1697 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1698 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1699 translation of that in OURSTATUS. */
1701 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1703 #ifdef CHILD_SPECIAL_WAITSTATUS
1704 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1705 if it wants to deal with hoststatus. */
1706 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1710 if (WIFEXITED (hoststatus
))
1712 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1713 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1715 else if (!WIFSTOPPED (hoststatus
))
1717 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1718 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1722 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1723 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1727 /* Returns zero to leave the inferior alone, one to interrupt it. */
1728 int (*target_activity_function
) (void);
1729 int target_activity_fd
;
1731 /* Convert a normal process ID to a string. Returns the string in a static
1735 normal_pid_to_str (ptid_t ptid
)
1737 static char buf
[30];
1739 sprintf (buf
, "process %d", PIDGET (ptid
));
1743 /* Error-catcher for target_find_memory_regions */
1744 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1746 error ("No target.");
1750 /* Error-catcher for target_make_corefile_notes */
1751 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1753 error ("No target.");
1757 /* Set up the handful of non-empty slots needed by the dummy target
1761 init_dummy_target (void)
1763 dummy_target
.to_shortname
= "None";
1764 dummy_target
.to_longname
= "None";
1765 dummy_target
.to_doc
= "";
1766 dummy_target
.to_attach
= find_default_attach
;
1767 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1768 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1769 dummy_target
.to_stratum
= dummy_stratum
;
1770 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1771 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1772 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1773 dummy_target
.to_magic
= OPS_MAGIC
;
1777 static struct target_ops debug_target
;
1780 debug_to_open (char *args
, int from_tty
)
1782 debug_target
.to_open (args
, from_tty
);
1784 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1788 debug_to_close (int quitting
)
1790 target_close (&debug_target
, quitting
);
1791 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1795 target_close (struct target_ops
*targ
, int quitting
)
1797 if (targ
->to_xclose
!= NULL
)
1798 targ
->to_xclose (targ
, quitting
);
1799 else if (targ
->to_close
!= NULL
)
1800 targ
->to_close (quitting
);
1804 debug_to_attach (char *args
, int from_tty
)
1806 debug_target
.to_attach (args
, from_tty
);
1808 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1813 debug_to_post_attach (int pid
)
1815 debug_target
.to_post_attach (pid
);
1817 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1821 debug_to_detach (char *args
, int from_tty
)
1823 debug_target
.to_detach (args
, from_tty
);
1825 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1829 debug_to_disconnect (char *args
, int from_tty
)
1831 debug_target
.to_disconnect (args
, from_tty
);
1833 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1838 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1840 debug_target
.to_resume (ptid
, step
, siggnal
);
1842 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1843 step
? "step" : "continue",
1844 target_signal_to_name (siggnal
));
1848 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1852 retval
= debug_target
.to_wait (ptid
, status
);
1854 fprintf_unfiltered (gdb_stdlog
,
1855 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1857 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1858 switch (status
->kind
)
1860 case TARGET_WAITKIND_EXITED
:
1861 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1862 status
->value
.integer
);
1864 case TARGET_WAITKIND_STOPPED
:
1865 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1866 target_signal_to_name (status
->value
.sig
));
1868 case TARGET_WAITKIND_SIGNALLED
:
1869 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1870 target_signal_to_name (status
->value
.sig
));
1872 case TARGET_WAITKIND_LOADED
:
1873 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1875 case TARGET_WAITKIND_FORKED
:
1876 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1878 case TARGET_WAITKIND_VFORKED
:
1879 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1881 case TARGET_WAITKIND_EXECD
:
1882 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1884 case TARGET_WAITKIND_SPURIOUS
:
1885 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1888 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1896 debug_print_register (const char * func
, int regno
)
1898 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1899 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1900 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1901 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1903 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1907 unsigned char buf
[MAX_REGISTER_SIZE
];
1908 deprecated_read_register_gen (regno
, buf
);
1909 fprintf_unfiltered (gdb_stdlog
, " = ");
1910 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1912 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1914 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1916 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1917 paddr_nz (read_register (regno
)),
1918 paddr_d (read_register (regno
)));
1921 fprintf_unfiltered (gdb_stdlog
, "\n");
1925 debug_to_fetch_registers (int regno
)
1927 debug_target
.to_fetch_registers (regno
);
1928 debug_print_register ("target_fetch_registers", regno
);
1932 debug_to_store_registers (int regno
)
1934 debug_target
.to_store_registers (regno
);
1935 debug_print_register ("target_store_registers", regno
);
1936 fprintf_unfiltered (gdb_stdlog
, "\n");
1940 debug_to_prepare_to_store (void)
1942 debug_target
.to_prepare_to_store ();
1944 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1948 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1949 struct mem_attrib
*attrib
,
1950 struct target_ops
*target
)
1954 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1957 fprintf_unfiltered (gdb_stdlog
,
1958 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1959 (unsigned int) memaddr
, /* possable truncate long long */
1960 len
, write
? "write" : "read", retval
);
1966 fputs_unfiltered (", bytes =", gdb_stdlog
);
1967 for (i
= 0; i
< retval
; i
++)
1969 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1971 if (targetdebug
< 2 && i
> 0)
1973 fprintf_unfiltered (gdb_stdlog
, " ...");
1976 fprintf_unfiltered (gdb_stdlog
, "\n");
1979 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1983 fputc_unfiltered ('\n', gdb_stdlog
);
1989 debug_to_files_info (struct target_ops
*target
)
1991 debug_target
.to_files_info (target
);
1993 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1997 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
2001 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2003 fprintf_unfiltered (gdb_stdlog
,
2004 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2005 (unsigned long) addr
,
2006 (unsigned long) retval
);
2011 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
2015 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2017 fprintf_unfiltered (gdb_stdlog
,
2018 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2019 (unsigned long) addr
,
2020 (unsigned long) retval
);
2025 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2029 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2031 fprintf_unfiltered (gdb_stdlog
,
2032 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2033 (unsigned long) type
,
2034 (unsigned long) cnt
,
2035 (unsigned long) from_tty
,
2036 (unsigned long) retval
);
2041 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
2045 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
2047 fprintf_unfiltered (gdb_stdlog
,
2048 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2049 (unsigned long) byte_count
,
2050 (unsigned long) retval
);
2055 debug_to_stopped_by_watchpoint (void)
2059 retval
= debug_target
.to_stopped_by_watchpoint ();
2061 fprintf_unfiltered (gdb_stdlog
,
2062 "STOPPED_BY_WATCHPOINT () = %ld\n",
2063 (unsigned long) retval
);
2068 debug_to_stopped_data_address (void)
2072 retval
= debug_target
.to_stopped_data_address ();
2074 fprintf_unfiltered (gdb_stdlog
,
2075 "target_stopped_data_address () = 0x%lx\n",
2076 (unsigned long) retval
);
2081 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
2085 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2087 fprintf_unfiltered (gdb_stdlog
,
2088 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2089 (unsigned long) addr
,
2090 (unsigned long) retval
);
2095 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
2099 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2101 fprintf_unfiltered (gdb_stdlog
,
2102 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2103 (unsigned long) addr
,
2104 (unsigned long) retval
);
2109 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2113 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2115 fprintf_unfiltered (gdb_stdlog
,
2116 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2117 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2122 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2126 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2128 fprintf_unfiltered (gdb_stdlog
,
2129 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2130 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2135 debug_to_terminal_init (void)
2137 debug_target
.to_terminal_init ();
2139 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2143 debug_to_terminal_inferior (void)
2145 debug_target
.to_terminal_inferior ();
2147 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2151 debug_to_terminal_ours_for_output (void)
2153 debug_target
.to_terminal_ours_for_output ();
2155 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2159 debug_to_terminal_ours (void)
2161 debug_target
.to_terminal_ours ();
2163 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2167 debug_to_terminal_save_ours (void)
2169 debug_target
.to_terminal_save_ours ();
2171 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2175 debug_to_terminal_info (char *arg
, int from_tty
)
2177 debug_target
.to_terminal_info (arg
, from_tty
);
2179 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2184 debug_to_kill (void)
2186 debug_target
.to_kill ();
2188 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2192 debug_to_load (char *args
, int from_tty
)
2194 debug_target
.to_load (args
, from_tty
);
2196 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2200 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2204 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2206 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2212 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2215 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2217 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2218 exec_file
, args
, from_tty
);
2222 debug_to_post_startup_inferior (ptid_t ptid
)
2224 debug_target
.to_post_startup_inferior (ptid
);
2226 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2231 debug_to_acknowledge_created_inferior (int pid
)
2233 debug_target
.to_acknowledge_created_inferior (pid
);
2235 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2240 debug_to_insert_fork_catchpoint (int pid
)
2244 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2246 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2253 debug_to_remove_fork_catchpoint (int pid
)
2257 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2259 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2266 debug_to_insert_vfork_catchpoint (int pid
)
2270 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2272 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2279 debug_to_remove_vfork_catchpoint (int pid
)
2283 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2285 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2292 debug_to_follow_fork (int follow_child
)
2294 int retval
= debug_target
.to_follow_fork (follow_child
);
2296 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2297 follow_child
, retval
);
2303 debug_to_insert_exec_catchpoint (int pid
)
2307 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2309 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2316 debug_to_remove_exec_catchpoint (int pid
)
2320 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2322 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2329 debug_to_reported_exec_events_per_exec_call (void)
2331 int reported_exec_events
;
2333 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2335 fprintf_unfiltered (gdb_stdlog
,
2336 "target_reported_exec_events_per_exec_call () = %d\n",
2337 reported_exec_events
);
2339 return reported_exec_events
;
2343 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2347 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2349 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2350 pid
, wait_status
, *exit_status
, has_exited
);
2356 debug_to_mourn_inferior (void)
2358 debug_target
.to_mourn_inferior ();
2360 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2364 debug_to_can_run (void)
2368 retval
= debug_target
.to_can_run ();
2370 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2376 debug_to_notice_signals (ptid_t ptid
)
2378 debug_target
.to_notice_signals (ptid
);
2380 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2385 debug_to_thread_alive (ptid_t ptid
)
2389 retval
= debug_target
.to_thread_alive (ptid
);
2391 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2392 PIDGET (ptid
), retval
);
2398 debug_to_find_new_threads (void)
2400 debug_target
.to_find_new_threads ();
2402 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2406 debug_to_stop (void)
2408 debug_target
.to_stop ();
2410 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2414 debug_to_rcmd (char *command
,
2415 struct ui_file
*outbuf
)
2417 debug_target
.to_rcmd (command
, outbuf
);
2418 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2421 static struct symtab_and_line
*
2422 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2424 struct symtab_and_line
*result
;
2425 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2426 fprintf_unfiltered (gdb_stdlog
,
2427 "target get_exception_callback_sal (%d, %d)\n",
2432 static struct exception_event_record
*
2433 debug_to_get_current_exception_event (void)
2435 struct exception_event_record
*result
;
2436 result
= debug_target
.to_get_current_exception_event ();
2437 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2442 debug_to_pid_to_exec_file (int pid
)
2446 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2448 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2455 setup_target_debug (void)
2457 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2459 current_target
.to_open
= debug_to_open
;
2460 current_target
.to_close
= debug_to_close
;
2461 current_target
.to_attach
= debug_to_attach
;
2462 current_target
.to_post_attach
= debug_to_post_attach
;
2463 current_target
.to_detach
= debug_to_detach
;
2464 current_target
.to_disconnect
= debug_to_disconnect
;
2465 current_target
.to_resume
= debug_to_resume
;
2466 current_target
.to_wait
= debug_to_wait
;
2467 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2468 current_target
.to_store_registers
= debug_to_store_registers
;
2469 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2470 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2471 current_target
.to_files_info
= debug_to_files_info
;
2472 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2473 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2474 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2475 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2476 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2477 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2478 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2479 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2480 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2481 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2482 current_target
.to_terminal_init
= debug_to_terminal_init
;
2483 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2484 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2485 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2486 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2487 current_target
.to_terminal_info
= debug_to_terminal_info
;
2488 current_target
.to_kill
= debug_to_kill
;
2489 current_target
.to_load
= debug_to_load
;
2490 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2491 current_target
.to_create_inferior
= debug_to_create_inferior
;
2492 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2493 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2494 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2495 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2496 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2497 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2498 current_target
.to_follow_fork
= debug_to_follow_fork
;
2499 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2500 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2501 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2502 current_target
.to_has_exited
= debug_to_has_exited
;
2503 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2504 current_target
.to_can_run
= debug_to_can_run
;
2505 current_target
.to_notice_signals
= debug_to_notice_signals
;
2506 current_target
.to_thread_alive
= debug_to_thread_alive
;
2507 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2508 current_target
.to_stop
= debug_to_stop
;
2509 current_target
.to_rcmd
= debug_to_rcmd
;
2510 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2511 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2512 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2517 static char targ_desc
[] =
2518 "Names of targets and files being debugged.\n\
2519 Shows the entire stack of targets currently in use (including the exec-file,\n\
2520 core-file, and process, if any), as well as the symbol file name.";
2523 do_monitor_command (char *cmd
,
2526 if ((current_target
.to_rcmd
2527 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2528 || (current_target
.to_rcmd
== debug_to_rcmd
2529 && (debug_target
.to_rcmd
2530 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2532 error ("\"monitor\" command not supported by this target.\n");
2534 target_rcmd (cmd
, gdb_stdtarg
);
2538 initialize_targets (void)
2540 init_dummy_target ();
2541 push_target (&dummy_target
);
2543 add_info ("target", target_info
, targ_desc
);
2544 add_info ("files", target_info
, targ_desc
);
2546 deprecated_add_show_from_set
2547 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2548 (char *) &targetdebug
,
2549 "Set target debugging.\n\
2550 When non-zero, target debugging is enabled. Higher numbers are more\n\
2551 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2552 command.", &setdebuglist
),
2555 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2557 Set mode for reading from readonly sections.", "\
2558 Show mode for reading from readonly sections.", "\
2559 When this mode is on, memory reads from readonly sections (such as .text)\n\
2560 will be read from the object file instead of from the target. This will\n\
2561 result in significant performance improvement for remote targets.", "\
2562 Mode for reading from readonly sections is %s.",
2564 &setlist
, &showlist
);
2566 add_com ("monitor", class_obscure
, do_monitor_command
,
2567 "Send a command to the remote monitor (remote targets only).");
2569 target_dcache
= dcache_init ();