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 ULONGEST offset
, LONGEST 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
, offset
, 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. */
960 readbuf
= (bfd_byte
*) readbuf
+ xfered
;
961 if (writebuf
!= NULL
)
962 writebuf
= (bfd_byte
*) writebuf
+ xfered
;
963 target
= target_stack
;
967 /* Something totally screwed up, abandon the attempt to
976 /* This "stratum" didn't work, try the next one down. */
977 target
= target
->beneath
;
984 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
985 GDB's memory at MYADDR. Returns either 0 for success or an errno value
988 If an error occurs, no guarantee is made about the contents of the data at
989 MYADDR. In particular, the caller should not depend upon partial reads
990 filling the buffer with good data. There is no way for the caller to know
991 how much good data might have been transfered anyway. Callers that can
992 deal with partial reads should call target_read_memory_partial. */
995 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
997 if (target_xfer_partial_p ())
998 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
999 memaddr
, len
, myaddr
, NULL
);
1001 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
1005 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1007 if (target_xfer_partial_p ())
1008 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1009 memaddr
, len
, NULL
, myaddr
);
1011 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
1014 static int trust_readonly
= 0;
1016 /* Move memory to or from the targets. The top target gets priority;
1017 if it cannot handle it, it is offered to the next one down, etc.
1019 Result is -1 on error, or the number of bytes transfered. */
1022 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1023 struct mem_attrib
*attrib
)
1027 struct target_ops
*t
;
1029 /* Zero length requests are ok and require no work. */
1033 /* to_xfer_memory is not guaranteed to set errno, even when it returns
1037 if (!write
&& trust_readonly
)
1039 struct section_table
*secp
;
1040 /* User-settable option, "trust-readonly-sections". If true,
1041 then memory from any SEC_READONLY bfd section may be read
1042 directly from the bfd file. */
1043 secp
= target_section_by_addr (¤t_target
, memaddr
);
1045 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1047 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
1050 /* The quick case is that the top target can handle the transfer. */
1051 res
= current_target
.to_xfer_memory
1052 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
1054 /* If res <= 0 then we call it again in the loop. Ah well. */
1057 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1059 if (!t
->to_has_memory
)
1062 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1064 break; /* Handled all or part of xfer */
1065 if (t
->to_has_all_memory
)
1077 /* Perform a memory transfer. Iterate until the entire region has
1080 Result is 0 or errno value. */
1083 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
1087 struct mem_region
*region
;
1089 /* Zero length requests are ok and require no work. */
1097 region
= lookup_mem_region(memaddr
);
1098 if (memaddr
+ len
< region
->hi
)
1101 reg_len
= region
->hi
- memaddr
;
1103 switch (region
->attrib
.mode
)
1118 if (region
->attrib
.cache
)
1119 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1122 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1127 /* If this address is for nonexistent memory, read zeros
1128 if reading, or do nothing if writing. Return
1131 memset (myaddr
, 0, len
);
1145 return 0; /* We managed to cover it all somehow. */
1149 /* Perform a partial memory transfer.
1151 Result is -1 on error, or the number of bytes transfered. */
1154 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1155 int write_p
, int *err
)
1159 struct mem_region
*region
;
1161 /* Zero length requests are ok and require no work. */
1168 region
= lookup_mem_region(memaddr
);
1169 if (memaddr
+ len
< region
->hi
)
1172 reg_len
= region
->hi
- memaddr
;
1174 switch (region
->attrib
.mode
)
1193 if (region
->attrib
.cache
)
1194 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1197 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1215 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1217 if (target_xfer_partial_p ())
1218 return target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
, NULL
,
1219 buf
, NULL
, memaddr
, len
);
1221 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1225 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1227 if (target_xfer_partial_p ())
1228 return target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
, NULL
,
1229 NULL
, buf
, memaddr
, len
);
1231 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1234 /* More generic transfers. */
1237 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1238 const char *annex
, void *readbuf
,
1239 const void *writebuf
, ULONGEST offset
, LONGEST len
)
1241 if (object
== TARGET_OBJECT_MEMORY
1242 && ops
->to_xfer_memory
!= NULL
)
1243 /* If available, fall back to the target's "to_xfer_memory"
1248 if (writebuf
!= NULL
)
1250 void *buffer
= xmalloc (len
);
1251 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1252 memcpy (buffer
, writebuf
, len
);
1253 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1255 do_cleanups (cleanup
);
1257 if (readbuf
!= NULL
)
1258 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1262 else if (xfered
== 0 && errno
== 0)
1263 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1264 indication of an error. */
1269 else if (ops
->beneath
!= NULL
)
1270 return target_xfer_partial (ops
->beneath
, object
, annex
,
1271 readbuf
, writebuf
, offset
, len
);
1276 /* Target vector read/write partial wrapper functions.
1278 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1279 (inbuf, outbuf)", instead of separate read/write methods, make life
1283 target_read_partial (struct target_ops
*ops
,
1284 enum target_object object
,
1285 const char *annex
, void *buf
,
1286 ULONGEST offset
, LONGEST len
)
1288 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1292 target_write_partial (struct target_ops
*ops
,
1293 enum target_object object
,
1294 const char *annex
, const void *buf
,
1295 ULONGEST offset
, LONGEST len
)
1297 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1300 /* Wrappers to perform the full transfer. */
1302 target_read (struct target_ops
*ops
,
1303 enum target_object object
,
1304 const char *annex
, void *buf
,
1305 ULONGEST offset
, LONGEST len
)
1308 while (xfered
< len
)
1310 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1311 (bfd_byte
*) buf
+ xfered
,
1312 offset
+ xfered
, len
- xfered
);
1313 /* Call an observer, notifying them of the xfer progress? */
1315 /* Call memory_error? */
1324 target_write (struct target_ops
*ops
,
1325 enum target_object object
,
1326 const char *annex
, const void *buf
,
1327 ULONGEST offset
, LONGEST len
)
1330 while (xfered
< len
)
1332 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1333 (bfd_byte
*) buf
+ xfered
,
1334 offset
+ xfered
, len
- xfered
);
1335 /* Call an observer, notifying them of the xfer progress? */
1337 /* Call memory_error? */
1345 /* Memory transfer methods. */
1348 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1351 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1353 memory_error (EIO
, addr
);
1357 get_target_memory_unsigned (struct target_ops
*ops
,
1358 CORE_ADDR addr
, int len
)
1360 char buf
[sizeof (ULONGEST
)];
1362 gdb_assert (len
<= sizeof (buf
));
1363 get_target_memory (ops
, addr
, buf
, len
);
1364 return extract_unsigned_integer (buf
, len
);
1368 target_info (char *args
, int from_tty
)
1370 struct target_ops
*t
;
1371 int has_all_mem
= 0;
1373 if (symfile_objfile
!= NULL
)
1374 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1376 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1378 if (!t
->to_has_memory
)
1381 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1384 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1385 printf_unfiltered ("%s:\n", t
->to_longname
);
1386 (t
->to_files_info
) (t
);
1387 has_all_mem
= t
->to_has_all_memory
;
1391 /* This is to be called by the open routine before it does
1395 target_preopen (int from_tty
)
1399 if (target_has_execution
)
1402 || query ("A program is being debugged already. Kill it? "))
1405 error ("Program not killed.");
1408 /* Calling target_kill may remove the target from the stack. But if
1409 it doesn't (which seems like a win for UDI), remove it now. */
1411 if (target_has_execution
)
1415 /* Detach a target after doing deferred register stores. */
1418 target_detach (char *args
, int from_tty
)
1420 (current_target
.to_detach
) (args
, from_tty
);
1424 target_disconnect (char *args
, int from_tty
)
1426 (current_target
.to_disconnect
) (args
, from_tty
);
1430 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1432 if (DEPRECATED_STREQ (current_target
.to_shortname
, "rombug"))
1434 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1436 error ("Unable to link to %s and get relocation in rombug", modname
);
1439 *t_reloc
= (CORE_ADDR
) -1;
1443 target_async_mask (int mask
)
1445 int saved_async_masked_status
= target_async_mask_value
;
1446 target_async_mask_value
= mask
;
1447 return saved_async_masked_status
;
1450 /* Look through the list of possible targets for a target that can
1451 execute a run or attach command without any other data. This is
1452 used to locate the default process stratum.
1454 Result is always valid (error() is called for errors). */
1456 static struct target_ops
*
1457 find_default_run_target (char *do_mesg
)
1459 struct target_ops
**t
;
1460 struct target_ops
*runable
= NULL
;
1465 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1468 if ((*t
)->to_can_run
&& target_can_run (*t
))
1476 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1482 find_default_attach (char *args
, int from_tty
)
1484 struct target_ops
*t
;
1486 t
= find_default_run_target ("attach");
1487 (t
->to_attach
) (args
, from_tty
);
1492 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1495 struct target_ops
*t
;
1497 t
= find_default_run_target ("run");
1498 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1503 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1505 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1521 return_minus_one (void)
1527 * Resize the to_sections pointer. Also make sure that anyone that
1528 * was holding on to an old value of it gets updated.
1529 * Returns the old size.
1533 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1535 struct target_ops
**t
;
1536 struct section_table
*old_value
;
1539 old_value
= target
->to_sections
;
1541 if (target
->to_sections
)
1543 old_count
= target
->to_sections_end
- target
->to_sections
;
1544 target
->to_sections
= (struct section_table
*)
1545 xrealloc ((char *) target
->to_sections
,
1546 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1551 target
->to_sections
= (struct section_table
*)
1552 xmalloc ((sizeof (struct section_table
)) * num_added
);
1554 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1556 /* Check to see if anyone else was pointing to this structure.
1557 If old_value was null, then no one was. */
1561 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1564 if ((*t
)->to_sections
== old_value
)
1566 (*t
)->to_sections
= target
->to_sections
;
1567 (*t
)->to_sections_end
= target
->to_sections_end
;
1570 /* There is a flattened view of the target stack in current_target,
1571 so its to_sections pointer might also need updating. */
1572 if (current_target
.to_sections
== old_value
)
1574 current_target
.to_sections
= target
->to_sections
;
1575 current_target
.to_sections_end
= target
->to_sections_end
;
1583 /* Remove all target sections taken from ABFD.
1585 Scan the current target stack for targets whose section tables
1586 refer to sections from BFD, and remove those sections. We use this
1587 when we notice that the inferior has unloaded a shared object, for
1590 remove_target_sections (bfd
*abfd
)
1592 struct target_ops
**t
;
1594 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1596 struct section_table
*src
, *dest
;
1598 dest
= (*t
)->to_sections
;
1599 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1600 if (src
->bfd
!= abfd
)
1602 /* Keep this section. */
1603 if (dest
< src
) *dest
= *src
;
1607 /* If we've dropped any sections, resize the section table. */
1609 target_resize_to_sections (*t
, dest
- src
);
1616 /* Find a single runnable target in the stack and return it. If for
1617 some reason there is more than one, return NULL. */
1620 find_run_target (void)
1622 struct target_ops
**t
;
1623 struct target_ops
*runable
= NULL
;
1628 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1630 if ((*t
)->to_can_run
&& target_can_run (*t
))
1637 return (count
== 1 ? runable
: NULL
);
1640 /* Find a single core_stratum target in the list of targets and return it.
1641 If for some reason there is more than one, return NULL. */
1644 find_core_target (void)
1646 struct target_ops
**t
;
1647 struct target_ops
*runable
= NULL
;
1652 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1655 if ((*t
)->to_stratum
== core_stratum
)
1662 return (count
== 1 ? runable
: NULL
);
1666 * Find the next target down the stack from the specified target.
1670 find_target_beneath (struct target_ops
*t
)
1676 /* The inferior process has died. Long live the inferior! */
1679 generic_mourn_inferior (void)
1681 extern int show_breakpoint_hit_counts
;
1683 inferior_ptid
= null_ptid
;
1685 breakpoint_init_inferior (inf_exited
);
1686 registers_changed ();
1688 reopen_exec_file ();
1689 reinit_frame_cache ();
1691 /* It is confusing to the user for ignore counts to stick around
1692 from previous runs of the inferior. So clear them. */
1693 /* However, it is more confusing for the ignore counts to disappear when
1694 using hit counts. So don't clear them if we're counting hits. */
1695 if (!show_breakpoint_hit_counts
)
1696 breakpoint_clear_ignore_counts ();
1698 if (deprecated_detach_hook
)
1699 deprecated_detach_hook ();
1702 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1703 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1704 translation of that in OURSTATUS. */
1706 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1708 #ifdef CHILD_SPECIAL_WAITSTATUS
1709 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1710 if it wants to deal with hoststatus. */
1711 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1715 if (WIFEXITED (hoststatus
))
1717 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1718 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1720 else if (!WIFSTOPPED (hoststatus
))
1722 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1723 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1727 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1728 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1732 /* Returns zero to leave the inferior alone, one to interrupt it. */
1733 int (*target_activity_function
) (void);
1734 int target_activity_fd
;
1736 /* Convert a normal process ID to a string. Returns the string in a static
1740 normal_pid_to_str (ptid_t ptid
)
1742 static char buf
[30];
1744 sprintf (buf
, "process %d", PIDGET (ptid
));
1748 /* Error-catcher for target_find_memory_regions */
1749 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1751 error ("No target.");
1755 /* Error-catcher for target_make_corefile_notes */
1756 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1758 error ("No target.");
1762 /* Set up the handful of non-empty slots needed by the dummy target
1766 init_dummy_target (void)
1768 dummy_target
.to_shortname
= "None";
1769 dummy_target
.to_longname
= "None";
1770 dummy_target
.to_doc
= "";
1771 dummy_target
.to_attach
= find_default_attach
;
1772 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1773 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1774 dummy_target
.to_stratum
= dummy_stratum
;
1775 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1776 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1777 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1778 dummy_target
.to_magic
= OPS_MAGIC
;
1782 static struct target_ops debug_target
;
1785 debug_to_open (char *args
, int from_tty
)
1787 debug_target
.to_open (args
, from_tty
);
1789 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1793 debug_to_close (int quitting
)
1795 target_close (&debug_target
, quitting
);
1796 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1800 target_close (struct target_ops
*targ
, int quitting
)
1802 if (targ
->to_xclose
!= NULL
)
1803 targ
->to_xclose (targ
, quitting
);
1804 else if (targ
->to_close
!= NULL
)
1805 targ
->to_close (quitting
);
1809 debug_to_attach (char *args
, int from_tty
)
1811 debug_target
.to_attach (args
, from_tty
);
1813 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1818 debug_to_post_attach (int pid
)
1820 debug_target
.to_post_attach (pid
);
1822 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1826 debug_to_detach (char *args
, int from_tty
)
1828 debug_target
.to_detach (args
, from_tty
);
1830 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1834 debug_to_disconnect (char *args
, int from_tty
)
1836 debug_target
.to_disconnect (args
, from_tty
);
1838 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1843 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1845 debug_target
.to_resume (ptid
, step
, siggnal
);
1847 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1848 step
? "step" : "continue",
1849 target_signal_to_name (siggnal
));
1853 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1857 retval
= debug_target
.to_wait (ptid
, status
);
1859 fprintf_unfiltered (gdb_stdlog
,
1860 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1862 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1863 switch (status
->kind
)
1865 case TARGET_WAITKIND_EXITED
:
1866 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1867 status
->value
.integer
);
1869 case TARGET_WAITKIND_STOPPED
:
1870 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1871 target_signal_to_name (status
->value
.sig
));
1873 case TARGET_WAITKIND_SIGNALLED
:
1874 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1875 target_signal_to_name (status
->value
.sig
));
1877 case TARGET_WAITKIND_LOADED
:
1878 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1880 case TARGET_WAITKIND_FORKED
:
1881 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1883 case TARGET_WAITKIND_VFORKED
:
1884 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1886 case TARGET_WAITKIND_EXECD
:
1887 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1889 case TARGET_WAITKIND_SPURIOUS
:
1890 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1893 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1901 debug_print_register (const char * func
, int regno
)
1903 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1904 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1905 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1906 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1908 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1912 unsigned char buf
[MAX_REGISTER_SIZE
];
1913 deprecated_read_register_gen (regno
, buf
);
1914 fprintf_unfiltered (gdb_stdlog
, " = ");
1915 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1917 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1919 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1921 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1922 paddr_nz (read_register (regno
)),
1923 paddr_d (read_register (regno
)));
1926 fprintf_unfiltered (gdb_stdlog
, "\n");
1930 debug_to_fetch_registers (int regno
)
1932 debug_target
.to_fetch_registers (regno
);
1933 debug_print_register ("target_fetch_registers", regno
);
1937 debug_to_store_registers (int regno
)
1939 debug_target
.to_store_registers (regno
);
1940 debug_print_register ("target_store_registers", regno
);
1941 fprintf_unfiltered (gdb_stdlog
, "\n");
1945 debug_to_prepare_to_store (void)
1947 debug_target
.to_prepare_to_store ();
1949 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1953 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1954 struct mem_attrib
*attrib
,
1955 struct target_ops
*target
)
1959 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1962 fprintf_unfiltered (gdb_stdlog
,
1963 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1964 (unsigned int) memaddr
, /* possable truncate long long */
1965 len
, write
? "write" : "read", retval
);
1971 fputs_unfiltered (", bytes =", gdb_stdlog
);
1972 for (i
= 0; i
< retval
; i
++)
1974 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1976 if (targetdebug
< 2 && i
> 0)
1978 fprintf_unfiltered (gdb_stdlog
, " ...");
1981 fprintf_unfiltered (gdb_stdlog
, "\n");
1984 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1988 fputc_unfiltered ('\n', gdb_stdlog
);
1994 debug_to_files_info (struct target_ops
*target
)
1996 debug_target
.to_files_info (target
);
1998 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2002 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
2006 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
2008 fprintf_unfiltered (gdb_stdlog
,
2009 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2010 (unsigned long) addr
,
2011 (unsigned long) retval
);
2016 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
2020 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
2022 fprintf_unfiltered (gdb_stdlog
,
2023 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2024 (unsigned long) addr
,
2025 (unsigned long) retval
);
2030 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2034 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2036 fprintf_unfiltered (gdb_stdlog
,
2037 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2038 (unsigned long) type
,
2039 (unsigned long) cnt
,
2040 (unsigned long) from_tty
,
2041 (unsigned long) retval
);
2046 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
2050 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
2052 fprintf_unfiltered (gdb_stdlog
,
2053 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2054 (unsigned long) byte_count
,
2055 (unsigned long) retval
);
2060 debug_to_stopped_by_watchpoint (void)
2064 retval
= debug_target
.to_stopped_by_watchpoint ();
2066 fprintf_unfiltered (gdb_stdlog
,
2067 "STOPPED_BY_WATCHPOINT () = %ld\n",
2068 (unsigned long) retval
);
2073 debug_to_stopped_data_address (void)
2077 retval
= debug_target
.to_stopped_data_address ();
2079 fprintf_unfiltered (gdb_stdlog
,
2080 "target_stopped_data_address () = 0x%lx\n",
2081 (unsigned long) retval
);
2086 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
2090 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2092 fprintf_unfiltered (gdb_stdlog
,
2093 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2094 (unsigned long) addr
,
2095 (unsigned long) retval
);
2100 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
2104 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2106 fprintf_unfiltered (gdb_stdlog
,
2107 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2108 (unsigned long) addr
,
2109 (unsigned long) retval
);
2114 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2118 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2120 fprintf_unfiltered (gdb_stdlog
,
2121 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2122 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2127 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2131 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2133 fprintf_unfiltered (gdb_stdlog
,
2134 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2135 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2140 debug_to_terminal_init (void)
2142 debug_target
.to_terminal_init ();
2144 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2148 debug_to_terminal_inferior (void)
2150 debug_target
.to_terminal_inferior ();
2152 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2156 debug_to_terminal_ours_for_output (void)
2158 debug_target
.to_terminal_ours_for_output ();
2160 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2164 debug_to_terminal_ours (void)
2166 debug_target
.to_terminal_ours ();
2168 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2172 debug_to_terminal_save_ours (void)
2174 debug_target
.to_terminal_save_ours ();
2176 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2180 debug_to_terminal_info (char *arg
, int from_tty
)
2182 debug_target
.to_terminal_info (arg
, from_tty
);
2184 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2189 debug_to_kill (void)
2191 debug_target
.to_kill ();
2193 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2197 debug_to_load (char *args
, int from_tty
)
2199 debug_target
.to_load (args
, from_tty
);
2201 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2205 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2209 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2211 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2217 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2220 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2222 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2223 exec_file
, args
, from_tty
);
2227 debug_to_post_startup_inferior (ptid_t ptid
)
2229 debug_target
.to_post_startup_inferior (ptid
);
2231 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2236 debug_to_acknowledge_created_inferior (int pid
)
2238 debug_target
.to_acknowledge_created_inferior (pid
);
2240 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2245 debug_to_insert_fork_catchpoint (int pid
)
2249 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2251 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2258 debug_to_remove_fork_catchpoint (int pid
)
2262 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2264 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2271 debug_to_insert_vfork_catchpoint (int pid
)
2275 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2277 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2284 debug_to_remove_vfork_catchpoint (int pid
)
2288 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2290 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2297 debug_to_follow_fork (int follow_child
)
2299 int retval
= debug_target
.to_follow_fork (follow_child
);
2301 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2302 follow_child
, retval
);
2308 debug_to_insert_exec_catchpoint (int pid
)
2312 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2314 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2321 debug_to_remove_exec_catchpoint (int pid
)
2325 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2327 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2334 debug_to_reported_exec_events_per_exec_call (void)
2336 int reported_exec_events
;
2338 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2340 fprintf_unfiltered (gdb_stdlog
,
2341 "target_reported_exec_events_per_exec_call () = %d\n",
2342 reported_exec_events
);
2344 return reported_exec_events
;
2348 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2352 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2354 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2355 pid
, wait_status
, *exit_status
, has_exited
);
2361 debug_to_mourn_inferior (void)
2363 debug_target
.to_mourn_inferior ();
2365 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2369 debug_to_can_run (void)
2373 retval
= debug_target
.to_can_run ();
2375 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2381 debug_to_notice_signals (ptid_t ptid
)
2383 debug_target
.to_notice_signals (ptid
);
2385 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2390 debug_to_thread_alive (ptid_t ptid
)
2394 retval
= debug_target
.to_thread_alive (ptid
);
2396 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2397 PIDGET (ptid
), retval
);
2403 debug_to_find_new_threads (void)
2405 debug_target
.to_find_new_threads ();
2407 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2411 debug_to_stop (void)
2413 debug_target
.to_stop ();
2415 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2419 debug_to_rcmd (char *command
,
2420 struct ui_file
*outbuf
)
2422 debug_target
.to_rcmd (command
, outbuf
);
2423 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2426 static struct symtab_and_line
*
2427 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2429 struct symtab_and_line
*result
;
2430 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2431 fprintf_unfiltered (gdb_stdlog
,
2432 "target get_exception_callback_sal (%d, %d)\n",
2437 static struct exception_event_record
*
2438 debug_to_get_current_exception_event (void)
2440 struct exception_event_record
*result
;
2441 result
= debug_target
.to_get_current_exception_event ();
2442 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2447 debug_to_pid_to_exec_file (int pid
)
2451 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2453 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2460 setup_target_debug (void)
2462 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2464 current_target
.to_open
= debug_to_open
;
2465 current_target
.to_close
= debug_to_close
;
2466 current_target
.to_attach
= debug_to_attach
;
2467 current_target
.to_post_attach
= debug_to_post_attach
;
2468 current_target
.to_detach
= debug_to_detach
;
2469 current_target
.to_disconnect
= debug_to_disconnect
;
2470 current_target
.to_resume
= debug_to_resume
;
2471 current_target
.to_wait
= debug_to_wait
;
2472 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2473 current_target
.to_store_registers
= debug_to_store_registers
;
2474 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2475 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2476 current_target
.to_files_info
= debug_to_files_info
;
2477 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2478 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2479 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2480 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2481 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2482 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2483 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2484 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2485 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2486 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2487 current_target
.to_terminal_init
= debug_to_terminal_init
;
2488 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2489 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2490 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2491 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2492 current_target
.to_terminal_info
= debug_to_terminal_info
;
2493 current_target
.to_kill
= debug_to_kill
;
2494 current_target
.to_load
= debug_to_load
;
2495 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2496 current_target
.to_create_inferior
= debug_to_create_inferior
;
2497 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2498 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2499 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2500 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2501 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2502 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2503 current_target
.to_follow_fork
= debug_to_follow_fork
;
2504 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2505 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2506 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2507 current_target
.to_has_exited
= debug_to_has_exited
;
2508 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2509 current_target
.to_can_run
= debug_to_can_run
;
2510 current_target
.to_notice_signals
= debug_to_notice_signals
;
2511 current_target
.to_thread_alive
= debug_to_thread_alive
;
2512 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2513 current_target
.to_stop
= debug_to_stop
;
2514 current_target
.to_rcmd
= debug_to_rcmd
;
2515 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2516 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2517 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2522 static char targ_desc
[] =
2523 "Names of targets and files being debugged.\n\
2524 Shows the entire stack of targets currently in use (including the exec-file,\n\
2525 core-file, and process, if any), as well as the symbol file name.";
2528 do_monitor_command (char *cmd
,
2531 if ((current_target
.to_rcmd
2532 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2533 || (current_target
.to_rcmd
== debug_to_rcmd
2534 && (debug_target
.to_rcmd
2535 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2537 error ("\"monitor\" command not supported by this target.\n");
2539 target_rcmd (cmd
, gdb_stdtarg
);
2543 initialize_targets (void)
2545 init_dummy_target ();
2546 push_target (&dummy_target
);
2548 add_info ("target", target_info
, targ_desc
);
2549 add_info ("files", target_info
, targ_desc
);
2551 deprecated_add_show_from_set
2552 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2553 (char *) &targetdebug
,
2554 "Set target debugging.\n\
2555 When non-zero, target debugging is enabled. Higher numbers are more\n\
2556 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2557 command.", &setdebuglist
),
2560 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2562 Set mode for reading from readonly sections.", "\
2563 Show mode for reading from readonly sections.", "\
2564 When this mode is on, memory reads from readonly sections (such as .text)\n\
2565 will be read from the object file instead of from the target. This will\n\
2566 result in significant performance improvement for remote targets.", "\
2567 Mode for reading from readonly sections is %s.",
2569 &setlist
, &showlist
);
2571 add_com ("monitor", class_obscure
, do_monitor_command
,
2572 "Send a command to the remote monitor (remote targets only).");
2574 target_dcache
= dcache_init ();