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
);
852 /* Attempt a transfer all LEN bytes starting at OFFSET between the
853 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
854 the transfer succeeds, return zero, otherwize the host ERRNO is
857 The inferior is formed from several layers. In the case of
858 corefiles, inf-corefile is layered above inf-exec and a request for
859 text (corefiles do not include text pages) will be first sent to
860 the core-stratum, fail, and then sent to the object-file where it
863 NOTE: cagney/2004-09-30:
865 The old code tried to use four separate mechanisms for mapping an
866 object:offset:len tuple onto an inferior and its address space: the
867 target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
872 The code below is instead using a single mechanism (currently
873 strata). If that mechanism proves insufficient then re-factor it
874 implementing another singluar mechanism (for instance, a generic
875 object:annex onto inferior:object:annex say). */
878 xfer_using_stratum (enum target_object object
, const char *annex
,
879 CORE_ADDR memaddr
, int len
, void *readbuf
,
880 const void *writebuf
)
883 struct target_ops
*target
;
885 /* Always successful. */
888 /* Never successful. */
889 if (target_stack
== NULL
)
892 target
= target_stack
;
895 xfered
= target
->to_xfer_partial (target
, object
, annex
,
896 readbuf
, writebuf
, memaddr
, len
);
899 /* The partial xfer succeeded, update the counts, check that
900 the xfer hasn't finished and if it hasn't set things up
901 for the next round. */
905 target
= target_stack
;
909 /* Something totally screwed up, abandon the attempt to
918 /* This "stratum" didn't work, try the next one down. */
919 target
= target
->beneath
;
926 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
927 GDB's memory at MYADDR. Returns either 0 for success or an errno value
930 If an error occurs, no guarantee is made about the contents of the data at
931 MYADDR. In particular, the caller should not depend upon partial reads
932 filling the buffer with good data. There is no way for the caller to know
933 how much good data might have been transfered anyway. Callers that can
934 deal with partial reads should call target_read_memory_partial. */
937 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
939 if (target_xfer_partial_p ())
940 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
941 memaddr
, len
, myaddr
, NULL
);
943 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
947 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
949 if (target_xfer_partial_p ())
950 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
951 memaddr
, len
, NULL
, myaddr
);
953 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
956 static int trust_readonly
= 0;
958 /* Move memory to or from the targets. The top target gets priority;
959 if it cannot handle it, it is offered to the next one down, etc.
961 Result is -1 on error, or the number of bytes transfered. */
964 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
965 struct mem_attrib
*attrib
)
969 struct target_ops
*t
;
971 /* Zero length requests are ok and require no work. */
975 /* to_xfer_memory is not guaranteed to set errno, even when it returns
979 if (!write
&& trust_readonly
)
981 struct section_table
*secp
;
982 /* User-settable option, "trust-readonly-sections". If true,
983 then memory from any SEC_READONLY bfd section may be read
984 directly from the bfd file. */
985 secp
= target_section_by_addr (¤t_target
, memaddr
);
987 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
989 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
992 /* The quick case is that the top target can handle the transfer. */
993 res
= current_target
.to_xfer_memory
994 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
996 /* If res <= 0 then we call it again in the loop. Ah well. */
999 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1001 if (!t
->to_has_memory
)
1004 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1006 break; /* Handled all or part of xfer */
1007 if (t
->to_has_all_memory
)
1019 /* Perform a memory transfer. Iterate until the entire region has
1022 Result is 0 or errno value. */
1025 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
1029 struct mem_region
*region
;
1031 /* Zero length requests are ok and require no work. */
1039 region
= lookup_mem_region(memaddr
);
1040 if (memaddr
+ len
< region
->hi
)
1043 reg_len
= region
->hi
- memaddr
;
1045 switch (region
->attrib
.mode
)
1060 if (region
->attrib
.cache
)
1061 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1064 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1069 /* If this address is for nonexistent memory, read zeros
1070 if reading, or do nothing if writing. Return
1073 memset (myaddr
, 0, len
);
1087 return 0; /* We managed to cover it all somehow. */
1091 /* Perform a partial memory transfer.
1093 Result is -1 on error, or the number of bytes transfered. */
1096 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1097 int write_p
, int *err
)
1101 struct mem_region
*region
;
1103 /* Zero length requests are ok and require no work. */
1110 region
= lookup_mem_region(memaddr
);
1111 if (memaddr
+ len
< region
->hi
)
1114 reg_len
= region
->hi
- memaddr
;
1116 switch (region
->attrib
.mode
)
1135 if (region
->attrib
.cache
)
1136 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1139 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1157 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1159 if (target_xfer_partial_p ())
1160 return target_stack
->to_xfer_partial (target_stack
,
1161 TARGET_OBJECT_MEMORY
, NULL
,
1162 buf
, NULL
, memaddr
, len
);
1164 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1168 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1170 if (target_xfer_partial_p ())
1171 return target_stack
->to_xfer_partial (target_stack
,
1172 TARGET_OBJECT_MEMORY
, NULL
,
1173 NULL
, buf
, memaddr
, len
);
1175 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1178 /* More generic transfers. */
1181 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1182 const char *annex
, void *readbuf
,
1183 const void *writebuf
, ULONGEST offset
, LONGEST len
)
1185 if (object
== TARGET_OBJECT_MEMORY
1186 && ops
->to_xfer_memory
!= NULL
)
1187 /* If available, fall back to the target's "to_xfer_memory"
1192 if (writebuf
!= NULL
)
1194 void *buffer
= xmalloc (len
);
1195 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1196 memcpy (buffer
, writebuf
, len
);
1197 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1199 do_cleanups (cleanup
);
1201 if (readbuf
!= NULL
)
1202 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1206 else if (xfered
== 0 && errno
== 0)
1207 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1208 indication of an error. */
1213 else if (ops
->beneath
!= NULL
)
1214 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1215 readbuf
, writebuf
, offset
, len
);
1220 /* Target vector read/write partial wrapper functions.
1222 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1223 (inbuf, outbuf)", instead of separate read/write methods, make life
1227 target_read_partial (struct target_ops
*ops
,
1228 enum target_object object
,
1229 const char *annex
, void *buf
,
1230 ULONGEST offset
, LONGEST len
)
1232 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1233 return ops
->to_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1237 target_write_partial (struct target_ops
*ops
,
1238 enum target_object object
,
1239 const char *annex
, const void *buf
,
1240 ULONGEST offset
, LONGEST len
)
1242 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1243 return ops
->to_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1246 /* Wrappers to perform the full transfer. */
1248 target_read (struct target_ops
*ops
,
1249 enum target_object object
,
1250 const char *annex
, void *buf
,
1251 ULONGEST offset
, LONGEST len
)
1254 while (xfered
< len
)
1256 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1257 (bfd_byte
*) buf
+ xfered
,
1258 offset
+ xfered
, len
- xfered
);
1259 /* Call an observer, notifying them of the xfer progress? */
1261 /* Call memory_error? */
1270 target_write (struct target_ops
*ops
,
1271 enum target_object object
,
1272 const char *annex
, const void *buf
,
1273 ULONGEST offset
, LONGEST len
)
1276 while (xfered
< len
)
1278 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1279 (bfd_byte
*) buf
+ xfered
,
1280 offset
+ xfered
, len
- xfered
);
1281 /* Call an observer, notifying them of the xfer progress? */
1283 /* Call memory_error? */
1291 /* Memory transfer methods. */
1294 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1297 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1299 memory_error (EIO
, addr
);
1303 get_target_memory_unsigned (struct target_ops
*ops
,
1304 CORE_ADDR addr
, int len
)
1306 char buf
[sizeof (ULONGEST
)];
1308 gdb_assert (len
<= sizeof (buf
));
1309 get_target_memory (ops
, addr
, buf
, len
);
1310 return extract_unsigned_integer (buf
, len
);
1314 target_info (char *args
, int from_tty
)
1316 struct target_ops
*t
;
1317 int has_all_mem
= 0;
1319 if (symfile_objfile
!= NULL
)
1320 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1322 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1324 if (!t
->to_has_memory
)
1327 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1330 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1331 printf_unfiltered ("%s:\n", t
->to_longname
);
1332 (t
->to_files_info
) (t
);
1333 has_all_mem
= t
->to_has_all_memory
;
1337 /* This is to be called by the open routine before it does
1341 target_preopen (int from_tty
)
1345 if (target_has_execution
)
1348 || query ("A program is being debugged already. Kill it? "))
1351 error ("Program not killed.");
1354 /* Calling target_kill may remove the target from the stack. But if
1355 it doesn't (which seems like a win for UDI), remove it now. */
1357 if (target_has_execution
)
1361 /* Detach a target after doing deferred register stores. */
1364 target_detach (char *args
, int from_tty
)
1366 (current_target
.to_detach
) (args
, from_tty
);
1370 target_disconnect (char *args
, int from_tty
)
1372 (current_target
.to_disconnect
) (args
, from_tty
);
1376 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1378 if (DEPRECATED_STREQ (current_target
.to_shortname
, "rombug"))
1380 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1382 error ("Unable to link to %s and get relocation in rombug", modname
);
1385 *t_reloc
= (CORE_ADDR
) -1;
1389 target_async_mask (int mask
)
1391 int saved_async_masked_status
= target_async_mask_value
;
1392 target_async_mask_value
= mask
;
1393 return saved_async_masked_status
;
1396 /* Look through the list of possible targets for a target that can
1397 execute a run or attach command without any other data. This is
1398 used to locate the default process stratum.
1400 Result is always valid (error() is called for errors). */
1402 static struct target_ops
*
1403 find_default_run_target (char *do_mesg
)
1405 struct target_ops
**t
;
1406 struct target_ops
*runable
= NULL
;
1411 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1414 if ((*t
)->to_can_run
&& target_can_run (*t
))
1422 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1428 find_default_attach (char *args
, int from_tty
)
1430 struct target_ops
*t
;
1432 t
= find_default_run_target ("attach");
1433 (t
->to_attach
) (args
, from_tty
);
1438 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1441 struct target_ops
*t
;
1443 t
= find_default_run_target ("run");
1444 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1449 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1451 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1467 return_minus_one (void)
1473 * Resize the to_sections pointer. Also make sure that anyone that
1474 * was holding on to an old value of it gets updated.
1475 * Returns the old size.
1479 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1481 struct target_ops
**t
;
1482 struct section_table
*old_value
;
1485 old_value
= target
->to_sections
;
1487 if (target
->to_sections
)
1489 old_count
= target
->to_sections_end
- target
->to_sections
;
1490 target
->to_sections
= (struct section_table
*)
1491 xrealloc ((char *) target
->to_sections
,
1492 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1497 target
->to_sections
= (struct section_table
*)
1498 xmalloc ((sizeof (struct section_table
)) * num_added
);
1500 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1502 /* Check to see if anyone else was pointing to this structure.
1503 If old_value was null, then no one was. */
1507 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1510 if ((*t
)->to_sections
== old_value
)
1512 (*t
)->to_sections
= target
->to_sections
;
1513 (*t
)->to_sections_end
= target
->to_sections_end
;
1516 /* There is a flattened view of the target stack in current_target,
1517 so its to_sections pointer might also need updating. */
1518 if (current_target
.to_sections
== old_value
)
1520 current_target
.to_sections
= target
->to_sections
;
1521 current_target
.to_sections_end
= target
->to_sections_end
;
1529 /* Remove all target sections taken from ABFD.
1531 Scan the current target stack for targets whose section tables
1532 refer to sections from BFD, and remove those sections. We use this
1533 when we notice that the inferior has unloaded a shared object, for
1536 remove_target_sections (bfd
*abfd
)
1538 struct target_ops
**t
;
1540 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1542 struct section_table
*src
, *dest
;
1544 dest
= (*t
)->to_sections
;
1545 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1546 if (src
->bfd
!= abfd
)
1548 /* Keep this section. */
1549 if (dest
< src
) *dest
= *src
;
1553 /* If we've dropped any sections, resize the section table. */
1555 target_resize_to_sections (*t
, dest
- src
);
1562 /* Find a single runnable target in the stack and return it. If for
1563 some reason there is more than one, return NULL. */
1566 find_run_target (void)
1568 struct target_ops
**t
;
1569 struct target_ops
*runable
= NULL
;
1574 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1576 if ((*t
)->to_can_run
&& target_can_run (*t
))
1583 return (count
== 1 ? runable
: NULL
);
1586 /* Find a single core_stratum target in the list of targets and return it.
1587 If for some reason there is more than one, return NULL. */
1590 find_core_target (void)
1592 struct target_ops
**t
;
1593 struct target_ops
*runable
= NULL
;
1598 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1601 if ((*t
)->to_stratum
== core_stratum
)
1608 return (count
== 1 ? runable
: NULL
);
1612 * Find the next target down the stack from the specified target.
1616 find_target_beneath (struct target_ops
*t
)
1622 /* The inferior process has died. Long live the inferior! */
1625 generic_mourn_inferior (void)
1627 extern int show_breakpoint_hit_counts
;
1629 inferior_ptid
= null_ptid
;
1631 breakpoint_init_inferior (inf_exited
);
1632 registers_changed ();
1634 reopen_exec_file ();
1635 reinit_frame_cache ();
1637 /* It is confusing to the user for ignore counts to stick around
1638 from previous runs of the inferior. So clear them. */
1639 /* However, it is more confusing for the ignore counts to disappear when
1640 using hit counts. So don't clear them if we're counting hits. */
1641 if (!show_breakpoint_hit_counts
)
1642 breakpoint_clear_ignore_counts ();
1644 if (deprecated_detach_hook
)
1645 deprecated_detach_hook ();
1648 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1649 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1650 translation of that in OURSTATUS. */
1652 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1654 #ifdef CHILD_SPECIAL_WAITSTATUS
1655 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1656 if it wants to deal with hoststatus. */
1657 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1661 if (WIFEXITED (hoststatus
))
1663 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1664 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1666 else if (!WIFSTOPPED (hoststatus
))
1668 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1669 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1673 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1674 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1678 /* Returns zero to leave the inferior alone, one to interrupt it. */
1679 int (*target_activity_function
) (void);
1680 int target_activity_fd
;
1682 /* Convert a normal process ID to a string. Returns the string in a static
1686 normal_pid_to_str (ptid_t ptid
)
1688 static char buf
[30];
1690 sprintf (buf
, "process %d", PIDGET (ptid
));
1694 /* Error-catcher for target_find_memory_regions */
1695 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1697 error ("No target.");
1701 /* Error-catcher for target_make_corefile_notes */
1702 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1704 error ("No target.");
1708 /* Set up the handful of non-empty slots needed by the dummy target
1712 init_dummy_target (void)
1714 dummy_target
.to_shortname
= "None";
1715 dummy_target
.to_longname
= "None";
1716 dummy_target
.to_doc
= "";
1717 dummy_target
.to_attach
= find_default_attach
;
1718 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1719 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1720 dummy_target
.to_stratum
= dummy_stratum
;
1721 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1722 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1723 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1724 dummy_target
.to_magic
= OPS_MAGIC
;
1728 static struct target_ops debug_target
;
1731 debug_to_open (char *args
, int from_tty
)
1733 debug_target
.to_open (args
, from_tty
);
1735 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1739 debug_to_close (int quitting
)
1741 target_close (&debug_target
, quitting
);
1742 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1746 target_close (struct target_ops
*targ
, int quitting
)
1748 if (targ
->to_xclose
!= NULL
)
1749 targ
->to_xclose (targ
, quitting
);
1750 else if (targ
->to_close
!= NULL
)
1751 targ
->to_close (quitting
);
1755 debug_to_attach (char *args
, int from_tty
)
1757 debug_target
.to_attach (args
, from_tty
);
1759 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1764 debug_to_post_attach (int pid
)
1766 debug_target
.to_post_attach (pid
);
1768 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1772 debug_to_detach (char *args
, int from_tty
)
1774 debug_target
.to_detach (args
, from_tty
);
1776 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1780 debug_to_disconnect (char *args
, int from_tty
)
1782 debug_target
.to_disconnect (args
, from_tty
);
1784 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1789 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1791 debug_target
.to_resume (ptid
, step
, siggnal
);
1793 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1794 step
? "step" : "continue",
1795 target_signal_to_name (siggnal
));
1799 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1803 retval
= debug_target
.to_wait (ptid
, status
);
1805 fprintf_unfiltered (gdb_stdlog
,
1806 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1808 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1809 switch (status
->kind
)
1811 case TARGET_WAITKIND_EXITED
:
1812 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1813 status
->value
.integer
);
1815 case TARGET_WAITKIND_STOPPED
:
1816 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1817 target_signal_to_name (status
->value
.sig
));
1819 case TARGET_WAITKIND_SIGNALLED
:
1820 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1821 target_signal_to_name (status
->value
.sig
));
1823 case TARGET_WAITKIND_LOADED
:
1824 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1826 case TARGET_WAITKIND_FORKED
:
1827 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1829 case TARGET_WAITKIND_VFORKED
:
1830 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1832 case TARGET_WAITKIND_EXECD
:
1833 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1835 case TARGET_WAITKIND_SPURIOUS
:
1836 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1839 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1847 debug_print_register (const char * func
, int regno
)
1849 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1850 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1851 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1852 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1854 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1858 unsigned char buf
[MAX_REGISTER_SIZE
];
1859 deprecated_read_register_gen (regno
, buf
);
1860 fprintf_unfiltered (gdb_stdlog
, " = ");
1861 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1863 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1865 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1867 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1868 paddr_nz (read_register (regno
)),
1869 paddr_d (read_register (regno
)));
1872 fprintf_unfiltered (gdb_stdlog
, "\n");
1876 debug_to_fetch_registers (int regno
)
1878 debug_target
.to_fetch_registers (regno
);
1879 debug_print_register ("target_fetch_registers", regno
);
1883 debug_to_store_registers (int regno
)
1885 debug_target
.to_store_registers (regno
);
1886 debug_print_register ("target_store_registers", regno
);
1887 fprintf_unfiltered (gdb_stdlog
, "\n");
1891 debug_to_prepare_to_store (void)
1893 debug_target
.to_prepare_to_store ();
1895 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1899 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1900 struct mem_attrib
*attrib
,
1901 struct target_ops
*target
)
1905 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1908 fprintf_unfiltered (gdb_stdlog
,
1909 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1910 (unsigned int) memaddr
, /* possable truncate long long */
1911 len
, write
? "write" : "read", retval
);
1917 fputs_unfiltered (", bytes =", gdb_stdlog
);
1918 for (i
= 0; i
< retval
; i
++)
1920 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1922 if (targetdebug
< 2 && i
> 0)
1924 fprintf_unfiltered (gdb_stdlog
, " ...");
1927 fprintf_unfiltered (gdb_stdlog
, "\n");
1930 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1934 fputc_unfiltered ('\n', gdb_stdlog
);
1940 debug_to_files_info (struct target_ops
*target
)
1942 debug_target
.to_files_info (target
);
1944 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1948 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1952 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1954 fprintf_unfiltered (gdb_stdlog
,
1955 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1956 (unsigned long) addr
,
1957 (unsigned long) retval
);
1962 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1966 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1968 fprintf_unfiltered (gdb_stdlog
,
1969 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1970 (unsigned long) addr
,
1971 (unsigned long) retval
);
1976 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1980 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1982 fprintf_unfiltered (gdb_stdlog
,
1983 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1984 (unsigned long) type
,
1985 (unsigned long) cnt
,
1986 (unsigned long) from_tty
,
1987 (unsigned long) retval
);
1992 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1996 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1998 fprintf_unfiltered (gdb_stdlog
,
1999 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2000 (unsigned long) byte_count
,
2001 (unsigned long) retval
);
2006 debug_to_stopped_by_watchpoint (void)
2010 retval
= debug_target
.to_stopped_by_watchpoint ();
2012 fprintf_unfiltered (gdb_stdlog
,
2013 "STOPPED_BY_WATCHPOINT () = %ld\n",
2014 (unsigned long) retval
);
2019 debug_to_stopped_data_address (void)
2023 retval
= debug_target
.to_stopped_data_address ();
2025 fprintf_unfiltered (gdb_stdlog
,
2026 "target_stopped_data_address () = 0x%lx\n",
2027 (unsigned long) retval
);
2032 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
2036 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
2038 fprintf_unfiltered (gdb_stdlog
,
2039 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2040 (unsigned long) addr
,
2041 (unsigned long) retval
);
2046 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
2050 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
2052 fprintf_unfiltered (gdb_stdlog
,
2053 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2054 (unsigned long) addr
,
2055 (unsigned long) retval
);
2060 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2064 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2066 fprintf_unfiltered (gdb_stdlog
,
2067 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2068 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2073 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2077 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2079 fprintf_unfiltered (gdb_stdlog
,
2080 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2081 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2086 debug_to_terminal_init (void)
2088 debug_target
.to_terminal_init ();
2090 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2094 debug_to_terminal_inferior (void)
2096 debug_target
.to_terminal_inferior ();
2098 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2102 debug_to_terminal_ours_for_output (void)
2104 debug_target
.to_terminal_ours_for_output ();
2106 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2110 debug_to_terminal_ours (void)
2112 debug_target
.to_terminal_ours ();
2114 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2118 debug_to_terminal_save_ours (void)
2120 debug_target
.to_terminal_save_ours ();
2122 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2126 debug_to_terminal_info (char *arg
, int from_tty
)
2128 debug_target
.to_terminal_info (arg
, from_tty
);
2130 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2135 debug_to_kill (void)
2137 debug_target
.to_kill ();
2139 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2143 debug_to_load (char *args
, int from_tty
)
2145 debug_target
.to_load (args
, from_tty
);
2147 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2151 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2155 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2157 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2163 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2166 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2168 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2169 exec_file
, args
, from_tty
);
2173 debug_to_post_startup_inferior (ptid_t ptid
)
2175 debug_target
.to_post_startup_inferior (ptid
);
2177 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2182 debug_to_acknowledge_created_inferior (int pid
)
2184 debug_target
.to_acknowledge_created_inferior (pid
);
2186 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2191 debug_to_insert_fork_catchpoint (int pid
)
2195 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2197 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2204 debug_to_remove_fork_catchpoint (int pid
)
2208 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2210 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2217 debug_to_insert_vfork_catchpoint (int pid
)
2221 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2223 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2230 debug_to_remove_vfork_catchpoint (int pid
)
2234 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2236 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2243 debug_to_follow_fork (int follow_child
)
2245 int retval
= debug_target
.to_follow_fork (follow_child
);
2247 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2248 follow_child
, retval
);
2254 debug_to_insert_exec_catchpoint (int pid
)
2258 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2260 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2267 debug_to_remove_exec_catchpoint (int pid
)
2271 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2273 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2280 debug_to_reported_exec_events_per_exec_call (void)
2282 int reported_exec_events
;
2284 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2286 fprintf_unfiltered (gdb_stdlog
,
2287 "target_reported_exec_events_per_exec_call () = %d\n",
2288 reported_exec_events
);
2290 return reported_exec_events
;
2294 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2298 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2300 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2301 pid
, wait_status
, *exit_status
, has_exited
);
2307 debug_to_mourn_inferior (void)
2309 debug_target
.to_mourn_inferior ();
2311 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2315 debug_to_can_run (void)
2319 retval
= debug_target
.to_can_run ();
2321 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2327 debug_to_notice_signals (ptid_t ptid
)
2329 debug_target
.to_notice_signals (ptid
);
2331 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2336 debug_to_thread_alive (ptid_t ptid
)
2340 retval
= debug_target
.to_thread_alive (ptid
);
2342 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2343 PIDGET (ptid
), retval
);
2349 debug_to_find_new_threads (void)
2351 debug_target
.to_find_new_threads ();
2353 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2357 debug_to_stop (void)
2359 debug_target
.to_stop ();
2361 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2365 debug_to_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2366 const char *annex
, void *readbuf
, const void *writebuf
,
2367 ULONGEST offset
, LONGEST len
)
2371 retval
= debug_target
.to_xfer_partial (&debug_target
, object
, annex
,
2372 readbuf
, writebuf
, offset
, len
);
2374 fprintf_unfiltered (gdb_stdlog
,
2375 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
2376 (int) object
, (annex
? annex
: "(null)"),
2377 (long) readbuf
, (long) writebuf
, paddr_nz (offset
),
2378 paddr_d (len
), paddr_d (retval
));
2384 debug_to_rcmd (char *command
,
2385 struct ui_file
*outbuf
)
2387 debug_target
.to_rcmd (command
, outbuf
);
2388 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2391 static struct symtab_and_line
*
2392 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2394 struct symtab_and_line
*result
;
2395 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2396 fprintf_unfiltered (gdb_stdlog
,
2397 "target get_exception_callback_sal (%d, %d)\n",
2402 static struct exception_event_record
*
2403 debug_to_get_current_exception_event (void)
2405 struct exception_event_record
*result
;
2406 result
= debug_target
.to_get_current_exception_event ();
2407 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2412 debug_to_pid_to_exec_file (int pid
)
2416 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2418 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2425 setup_target_debug (void)
2427 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2429 current_target
.to_open
= debug_to_open
;
2430 current_target
.to_close
= debug_to_close
;
2431 current_target
.to_attach
= debug_to_attach
;
2432 current_target
.to_post_attach
= debug_to_post_attach
;
2433 current_target
.to_detach
= debug_to_detach
;
2434 current_target
.to_disconnect
= debug_to_disconnect
;
2435 current_target
.to_resume
= debug_to_resume
;
2436 current_target
.to_wait
= debug_to_wait
;
2437 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2438 current_target
.to_store_registers
= debug_to_store_registers
;
2439 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2440 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2441 current_target
.to_files_info
= debug_to_files_info
;
2442 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2443 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2444 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2445 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2446 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2447 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2448 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2449 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2450 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2451 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2452 current_target
.to_terminal_init
= debug_to_terminal_init
;
2453 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2454 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2455 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2456 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2457 current_target
.to_terminal_info
= debug_to_terminal_info
;
2458 current_target
.to_kill
= debug_to_kill
;
2459 current_target
.to_load
= debug_to_load
;
2460 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2461 current_target
.to_create_inferior
= debug_to_create_inferior
;
2462 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2463 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2464 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2465 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2466 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2467 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2468 current_target
.to_follow_fork
= debug_to_follow_fork
;
2469 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2470 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2471 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2472 current_target
.to_has_exited
= debug_to_has_exited
;
2473 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2474 current_target
.to_can_run
= debug_to_can_run
;
2475 current_target
.to_notice_signals
= debug_to_notice_signals
;
2476 current_target
.to_thread_alive
= debug_to_thread_alive
;
2477 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2478 current_target
.to_stop
= debug_to_stop
;
2479 current_target
.to_xfer_partial
= debug_to_xfer_partial
;
2480 current_target
.to_rcmd
= debug_to_rcmd
;
2481 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2482 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2483 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2488 static char targ_desc
[] =
2489 "Names of targets and files being debugged.\n\
2490 Shows the entire stack of targets currently in use (including the exec-file,\n\
2491 core-file, and process, if any), as well as the symbol file name.";
2494 do_monitor_command (char *cmd
,
2497 if ((current_target
.to_rcmd
2498 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2499 || (current_target
.to_rcmd
== debug_to_rcmd
2500 && (debug_target
.to_rcmd
2501 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2503 error ("\"monitor\" command not supported by this target.\n");
2505 target_rcmd (cmd
, gdb_stdtarg
);
2509 initialize_targets (void)
2511 init_dummy_target ();
2512 push_target (&dummy_target
);
2514 add_info ("target", target_info
, targ_desc
);
2515 add_info ("files", target_info
, targ_desc
);
2517 deprecated_add_show_from_set
2518 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2519 (char *) &targetdebug
,
2520 "Set target debugging.\n\
2521 When non-zero, target debugging is enabled. Higher numbers are more\n\
2522 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2523 command.", &setdebuglist
),
2526 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2528 Set mode for reading from readonly sections.", "\
2529 Show mode for reading from readonly sections.", "\
2530 When this mode is on, memory reads from readonly sections (such as .text)\n\
2531 will be read from the object file instead of from the target. This will\n\
2532 result in significant performance improvement for remote targets.", "\
2533 Mode for reading from readonly sections is %s.",
2535 &setlist
, &showlist
);
2537 add_com ("monitor", class_obscure
, do_monitor_command
,
2538 "Send a command to the remote monitor (remote targets only).");
2540 target_dcache
= dcache_init ();