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 /* Pointer to array of target architecture structures; the size of the
163 array; the current index into the array; the allocated size of the
165 struct target_ops
**target_structs
;
166 unsigned target_struct_size
;
167 unsigned target_struct_index
;
168 unsigned target_struct_allocsize
;
169 #define DEFAULT_ALLOCSIZE 10
171 /* The initial current target, so that there is always a semi-valid
174 static struct target_ops dummy_target
;
176 /* Top of target stack. */
178 static struct target_ops
*target_stack
;
180 /* The target structure we are currently using to talk to a process
181 or file or whatever "inferior" we have. */
183 struct target_ops current_target
;
185 /* Command list for target. */
187 static struct cmd_list_element
*targetlist
= NULL
;
189 /* Nonzero if we are debugging an attached outside process
190 rather than an inferior. */
194 /* Non-zero if we want to see trace of target level stuff. */
196 static int targetdebug
= 0;
198 static void setup_target_debug (void);
200 DCACHE
*target_dcache
;
202 /* The user just typed 'target' without the name of a target. */
205 target_command (char *arg
, int from_tty
)
207 fputs_filtered ("Argument required (target name). Try `help target'\n",
211 /* Add a possible target architecture to the list. */
214 add_target (struct target_ops
*t
)
216 /* Provide default values for all "must have" methods. */
217 if (t
->to_xfer_partial
== NULL
)
218 t
->to_xfer_partial
= default_xfer_partial
;
222 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
223 target_structs
= (struct target_ops
**) xmalloc
224 (target_struct_allocsize
* sizeof (*target_structs
));
226 if (target_struct_size
>= target_struct_allocsize
)
228 target_struct_allocsize
*= 2;
229 target_structs
= (struct target_ops
**)
230 xrealloc ((char *) target_structs
,
231 target_struct_allocsize
* sizeof (*target_structs
));
233 target_structs
[target_struct_size
++] = t
;
235 if (targetlist
== NULL
)
236 add_prefix_cmd ("target", class_run
, target_command
,
237 "Connect to a target machine or process.\n\
238 The first argument is the type or protocol of the target machine.\n\
239 Remaining arguments are interpreted by the target protocol. For more\n\
240 information on the arguments for a particular protocol, type\n\
241 `help target ' followed by the protocol name.",
242 &targetlist
, "target ", 0, &cmdlist
);
243 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
254 target_load (char *arg
, int from_tty
)
256 dcache_invalidate (target_dcache
);
257 (*current_target
.to_load
) (arg
, from_tty
);
261 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
262 struct target_ops
*t
)
264 errno
= EIO
; /* Can't read/write this location */
265 return 0; /* No bytes handled */
271 error ("You can't do that when your target is `%s'",
272 current_target
.to_shortname
);
278 error ("You can't do that without a process to debug.");
282 nosymbol (char *name
, CORE_ADDR
*addrp
)
284 return 1; /* Symbol does not exist in target env */
288 nosupport_runtime (void)
290 if (ptid_equal (inferior_ptid
, null_ptid
))
293 error ("No run-time support for this");
298 default_terminal_info (char *args
, int from_tty
)
300 printf_unfiltered ("No saved terminal information.\n");
303 /* This is the default target_create_inferior and target_attach function.
304 If the current target is executing, it asks whether to kill it off.
305 If this function returns without calling error(), it has killed off
306 the target, and the operation should be attempted. */
309 kill_or_be_killed (int from_tty
)
311 if (target_has_execution
)
313 printf_unfiltered ("You are already running a program:\n");
314 target_files_info ();
315 if (query ("Kill it? "))
318 if (target_has_execution
)
319 error ("Killing the program did not help.");
324 error ("Program not killed.");
331 maybe_kill_then_attach (char *args
, int from_tty
)
333 kill_or_be_killed (from_tty
);
334 target_attach (args
, from_tty
);
338 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
341 kill_or_be_killed (0);
342 target_create_inferior (exec
, args
, env
, from_tty
);
345 /* Go through the target stack from top to bottom, copying over zero
346 entries in current_target, then filling in still empty entries. In
347 effect, we are doing class inheritance through the pushed target
350 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
351 is currently implemented, is that it discards any knowledge of
352 which target an inherited method originally belonged to.
353 Consequently, new new target methods should instead explicitly and
354 locally search the target stack for the target that can handle the
358 update_current_target (void)
360 struct target_ops
*t
;
362 /* First, reset curren'ts contents. */
363 memset (¤t_target
, 0, sizeof (current_target
));
365 #define INHERIT(FIELD, TARGET) \
366 if (!current_target.FIELD) \
367 current_target.FIELD = (TARGET)->FIELD
369 for (t
= target_stack
; t
; t
= t
->beneath
)
371 INHERIT (to_shortname
, t
);
372 INHERIT (to_longname
, t
);
374 INHERIT (to_open
, t
);
375 INHERIT (to_close
, t
);
376 INHERIT (to_attach
, t
);
377 INHERIT (to_post_attach
, t
);
378 INHERIT (to_detach
, t
);
379 INHERIT (to_disconnect
, t
);
380 INHERIT (to_resume
, t
);
381 INHERIT (to_wait
, t
);
382 INHERIT (to_post_wait
, t
);
383 INHERIT (to_fetch_registers
, t
);
384 INHERIT (to_store_registers
, t
);
385 INHERIT (to_prepare_to_store
, t
);
386 INHERIT (to_xfer_memory
, t
);
387 INHERIT (to_files_info
, t
);
388 INHERIT (to_insert_breakpoint
, t
);
389 INHERIT (to_remove_breakpoint
, t
);
390 INHERIT (to_can_use_hw_breakpoint
, t
);
391 INHERIT (to_insert_hw_breakpoint
, t
);
392 INHERIT (to_remove_hw_breakpoint
, t
);
393 INHERIT (to_insert_watchpoint
, t
);
394 INHERIT (to_remove_watchpoint
, t
);
395 INHERIT (to_stopped_data_address
, t
);
396 INHERIT (to_stopped_by_watchpoint
, t
);
397 INHERIT (to_have_continuable_watchpoint
, t
);
398 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
399 INHERIT (to_terminal_init
, t
);
400 INHERIT (to_terminal_inferior
, t
);
401 INHERIT (to_terminal_ours_for_output
, t
);
402 INHERIT (to_terminal_ours
, t
);
403 INHERIT (to_terminal_save_ours
, t
);
404 INHERIT (to_terminal_info
, t
);
405 INHERIT (to_kill
, t
);
406 INHERIT (to_load
, t
);
407 INHERIT (to_lookup_symbol
, t
);
408 INHERIT (to_create_inferior
, t
);
409 INHERIT (to_post_startup_inferior
, t
);
410 INHERIT (to_acknowledge_created_inferior
, t
);
411 INHERIT (to_insert_fork_catchpoint
, t
);
412 INHERIT (to_remove_fork_catchpoint
, t
);
413 INHERIT (to_insert_vfork_catchpoint
, t
);
414 INHERIT (to_remove_vfork_catchpoint
, t
);
415 INHERIT (to_follow_fork
, t
);
416 INHERIT (to_insert_exec_catchpoint
, t
);
417 INHERIT (to_remove_exec_catchpoint
, t
);
418 INHERIT (to_reported_exec_events_per_exec_call
, t
);
419 INHERIT (to_has_exited
, t
);
420 INHERIT (to_mourn_inferior
, t
);
421 INHERIT (to_can_run
, t
);
422 INHERIT (to_notice_signals
, t
);
423 INHERIT (to_thread_alive
, t
);
424 INHERIT (to_find_new_threads
, t
);
425 INHERIT (to_pid_to_str
, t
);
426 INHERIT (to_extra_thread_info
, t
);
427 INHERIT (to_stop
, t
);
428 /* Do not inherit to_xfer_partial. */
429 INHERIT (to_rcmd
, t
);
430 INHERIT (to_enable_exception_callback
, t
);
431 INHERIT (to_get_current_exception_event
, t
);
432 INHERIT (to_pid_to_exec_file
, t
);
433 INHERIT (to_stratum
, t
);
434 INHERIT (to_has_all_memory
, t
);
435 INHERIT (to_has_memory
, t
);
436 INHERIT (to_has_stack
, t
);
437 INHERIT (to_has_registers
, t
);
438 INHERIT (to_has_execution
, t
);
439 INHERIT (to_has_thread_control
, t
);
440 INHERIT (to_sections
, t
);
441 INHERIT (to_sections_end
, t
);
442 INHERIT (to_can_async_p
, t
);
443 INHERIT (to_is_async_p
, t
);
444 INHERIT (to_async
, t
);
445 INHERIT (to_async_mask_value
, t
);
446 INHERIT (to_find_memory_regions
, t
);
447 INHERIT (to_make_corefile_notes
, t
);
448 INHERIT (to_get_thread_local_address
, t
);
449 INHERIT (to_magic
, t
);
453 /* Clean up a target struct so it no longer has any zero pointers in
454 it. Some entries are defaulted to a method that print an error,
455 others are hard-wired to a standard recursive default. */
457 #define de_fault(field, value) \
458 if (!current_target.field) \
459 current_target.field = value
462 (void (*) (char *, int))
468 maybe_kill_then_attach
);
469 de_fault (to_post_attach
,
473 (void (*) (char *, int))
475 de_fault (to_disconnect
,
476 (void (*) (char *, int))
479 (void (*) (ptid_t
, int, enum target_signal
))
482 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
484 de_fault (to_post_wait
,
485 (void (*) (ptid_t
, int))
487 de_fault (to_fetch_registers
,
490 de_fault (to_store_registers
,
493 de_fault (to_prepare_to_store
,
496 de_fault (to_xfer_memory
,
497 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
499 de_fault (to_files_info
,
500 (void (*) (struct target_ops
*))
502 de_fault (to_insert_breakpoint
,
503 memory_insert_breakpoint
);
504 de_fault (to_remove_breakpoint
,
505 memory_remove_breakpoint
);
506 de_fault (to_can_use_hw_breakpoint
,
507 (int (*) (int, int, int))
509 de_fault (to_insert_hw_breakpoint
,
510 (int (*) (CORE_ADDR
, char *))
512 de_fault (to_remove_hw_breakpoint
,
513 (int (*) (CORE_ADDR
, char *))
515 de_fault (to_insert_watchpoint
,
516 (int (*) (CORE_ADDR
, int, int))
518 de_fault (to_remove_watchpoint
,
519 (int (*) (CORE_ADDR
, int, int))
521 de_fault (to_stopped_by_watchpoint
,
524 de_fault (to_stopped_data_address
,
525 (CORE_ADDR (*) (void))
527 de_fault (to_region_size_ok_for_hw_watchpoint
,
528 default_region_size_ok_for_hw_watchpoint
);
529 de_fault (to_terminal_init
,
532 de_fault (to_terminal_inferior
,
535 de_fault (to_terminal_ours_for_output
,
538 de_fault (to_terminal_ours
,
541 de_fault (to_terminal_save_ours
,
544 de_fault (to_terminal_info
,
545 default_terminal_info
);
550 (void (*) (char *, int))
552 de_fault (to_lookup_symbol
,
553 (int (*) (char *, CORE_ADDR
*))
555 de_fault (to_create_inferior
,
556 maybe_kill_then_create_inferior
);
557 de_fault (to_post_startup_inferior
,
560 de_fault (to_acknowledge_created_inferior
,
563 de_fault (to_insert_fork_catchpoint
,
566 de_fault (to_remove_fork_catchpoint
,
569 de_fault (to_insert_vfork_catchpoint
,
572 de_fault (to_remove_vfork_catchpoint
,
575 de_fault (to_follow_fork
,
578 de_fault (to_insert_exec_catchpoint
,
581 de_fault (to_remove_exec_catchpoint
,
584 de_fault (to_reported_exec_events_per_exec_call
,
587 de_fault (to_has_exited
,
588 (int (*) (int, int, int *))
590 de_fault (to_mourn_inferior
,
593 de_fault (to_can_run
,
595 de_fault (to_notice_signals
,
598 de_fault (to_thread_alive
,
601 de_fault (to_find_new_threads
,
604 de_fault (to_extra_thread_info
,
605 (char *(*) (struct thread_info
*))
610 current_target
.to_xfer_partial
= default_xfer_partial
;
612 (void (*) (char *, struct ui_file
*))
614 de_fault (to_enable_exception_callback
,
615 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
617 de_fault (to_get_current_exception_event
,
618 (struct exception_event_record
* (*) (void))
620 de_fault (to_pid_to_exec_file
,
623 de_fault (to_can_async_p
,
626 de_fault (to_is_async_p
,
630 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
634 /* Finally, position the target-stack beneath the squashed
635 "current_target". That way code looking for a non-inherited
636 target method can quickly and simply find it. */
637 current_target
.beneath
= target_stack
;
640 /* Push a new target type into the stack of the existing target accessors,
641 possibly superseding some of the existing accessors.
643 Result is zero if the pushed target ended up on top of the stack,
644 nonzero if at least one target is on top of it.
646 Rather than allow an empty stack, we always have the dummy target at
647 the bottom stratum, so we can call the function vectors without
651 push_target (struct target_ops
*t
)
653 struct target_ops
**cur
;
655 /* Check magic number. If wrong, it probably means someone changed
656 the struct definition, but not all the places that initialize one. */
657 if (t
->to_magic
!= OPS_MAGIC
)
659 fprintf_unfiltered (gdb_stderr
,
660 "Magic number of %s target struct wrong\n",
662 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
665 /* Find the proper stratum to install this target in. */
666 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
668 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
672 /* If there's already targets at this stratum, remove them. */
673 /* FIXME: cagney/2003-10-15: I think this should be poping all
674 targets to CUR, and not just those at this stratum level. */
675 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
677 /* There's already something at this stratum level. Close it,
678 and un-hook it from the stack. */
679 struct target_ops
*tmp
= (*cur
);
680 (*cur
) = (*cur
)->beneath
;
682 target_close (tmp
, 0);
685 /* We have removed all targets in our stratum, now add the new one. */
689 update_current_target ();
692 setup_target_debug ();
695 return (t
!= target_stack
);
698 /* Remove a target_ops vector from the stack, wherever it may be.
699 Return how many times it was removed (0 or 1). */
702 unpush_target (struct target_ops
*t
)
704 struct target_ops
**cur
;
705 struct target_ops
*tmp
;
707 /* Look for the specified target. Note that we assume that a target
708 can only occur once in the target stack. */
710 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
717 return 0; /* Didn't find target_ops, quit now */
719 /* NOTE: cagney/2003-12-06: In '94 the close call was made
720 unconditional by moving it to before the above check that the
721 target was in the target stack (something about "Change the way
722 pushing and popping of targets work to support target overlays
723 and inheritance"). This doesn't make much sense - only open
724 targets should be closed. */
727 /* Unchain the target */
729 (*cur
) = (*cur
)->beneath
;
732 update_current_target ();
740 target_close (¤t_target
, 0); /* Let it clean up */
741 if (unpush_target (target_stack
) == 1)
744 fprintf_unfiltered (gdb_stderr
,
745 "pop_target couldn't find target %s\n",
746 current_target
.to_shortname
);
747 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
751 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
753 /* target_read_string -- read a null terminated string, up to LEN bytes,
754 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
755 Set *STRING to a pointer to malloc'd memory containing the data; the caller
756 is responsible for freeing it. Return the number of bytes successfully
760 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
762 int tlen
, origlen
, offset
, i
;
766 int buffer_allocated
;
768 unsigned int nbytes_read
= 0;
770 /* Small for testing. */
771 buffer_allocated
= 4;
772 buffer
= xmalloc (buffer_allocated
);
779 tlen
= MIN (len
, 4 - (memaddr
& 3));
780 offset
= memaddr
& 3;
782 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
785 /* The transfer request might have crossed the boundary to an
786 unallocated region of memory. Retry the transfer, requesting
790 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
795 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
798 bytes
= bufptr
- buffer
;
799 buffer_allocated
*= 2;
800 buffer
= xrealloc (buffer
, buffer_allocated
);
801 bufptr
= buffer
+ bytes
;
804 for (i
= 0; i
< tlen
; i
++)
806 *bufptr
++ = buf
[i
+ offset
];
807 if (buf
[i
+ offset
] == '\000')
809 nbytes_read
+= i
+ 1;
826 /* Find a section containing ADDR. */
827 struct section_table
*
828 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
830 struct section_table
*secp
;
831 for (secp
= target
->to_sections
;
832 secp
< target
->to_sections_end
;
835 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
841 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
842 GDB's memory at MYADDR. Returns either 0 for success or an errno value
845 If an error occurs, no guarantee is made about the contents of the data at
846 MYADDR. In particular, the caller should not depend upon partial reads
847 filling the buffer with good data. There is no way for the caller to know
848 how much good data might have been transfered anyway. Callers that can
849 deal with partial reads should call target_read_memory_partial. */
852 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
854 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
858 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
860 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
863 static int trust_readonly
= 0;
865 /* Move memory to or from the targets. The top target gets priority;
866 if it cannot handle it, it is offered to the next one down, etc.
868 Result is -1 on error, or the number of bytes transfered. */
871 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
872 struct mem_attrib
*attrib
)
876 struct target_ops
*t
;
878 /* Zero length requests are ok and require no work. */
882 /* to_xfer_memory is not guaranteed to set errno, even when it returns
886 if (!write
&& trust_readonly
)
888 struct section_table
*secp
;
889 /* User-settable option, "trust-readonly-sections". If true,
890 then memory from any SEC_READONLY bfd section may be read
891 directly from the bfd file. */
892 secp
= target_section_by_addr (¤t_target
, memaddr
);
894 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
896 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
899 /* The quick case is that the top target can handle the transfer. */
900 res
= current_target
.to_xfer_memory
901 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
903 /* If res <= 0 then we call it again in the loop. Ah well. */
906 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
908 if (!t
->to_has_memory
)
911 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
913 break; /* Handled all or part of xfer */
914 if (t
->to_has_all_memory
)
926 /* Perform a memory transfer. Iterate until the entire region has
929 Result is 0 or errno value. */
932 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
936 struct mem_region
*region
;
938 /* Zero length requests are ok and require no work. */
946 region
= lookup_mem_region(memaddr
);
947 if (memaddr
+ len
< region
->hi
)
950 reg_len
= region
->hi
- memaddr
;
952 switch (region
->attrib
.mode
)
967 if (region
->attrib
.cache
)
968 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
971 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
976 /* If this address is for nonexistent memory, read zeros
977 if reading, or do nothing if writing. Return
980 memset (myaddr
, 0, len
);
994 return 0; /* We managed to cover it all somehow. */
998 /* Perform a partial memory transfer.
1000 Result is -1 on error, or the number of bytes transfered. */
1003 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1004 int write_p
, int *err
)
1008 struct mem_region
*region
;
1010 /* Zero length requests are ok and require no work. */
1017 region
= lookup_mem_region(memaddr
);
1018 if (memaddr
+ len
< region
->hi
)
1021 reg_len
= region
->hi
- memaddr
;
1023 switch (region
->attrib
.mode
)
1042 if (region
->attrib
.cache
)
1043 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1046 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1064 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1066 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1070 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1072 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1075 /* More generic transfers. */
1078 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1079 const char *annex
, void *readbuf
,
1080 const void *writebuf
, ULONGEST offset
, LONGEST len
)
1082 if (object
== TARGET_OBJECT_MEMORY
1083 && ops
->to_xfer_memory
!= NULL
)
1084 /* If available, fall back to the target's "to_xfer_memory"
1089 if (writebuf
!= NULL
)
1091 void *buffer
= xmalloc (len
);
1092 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1093 memcpy (buffer
, writebuf
, len
);
1094 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1096 do_cleanups (cleanup
);
1098 if (readbuf
!= NULL
)
1099 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1103 else if (xfered
== 0 && errno
== 0)
1104 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1105 indication of an error. */
1110 else if (ops
->beneath
!= NULL
)
1111 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1112 readbuf
, writebuf
, offset
, len
);
1117 /* Target vector read/write partial wrapper functions.
1119 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1120 (inbuf, outbuf)", instead of separate read/write methods, make life
1124 target_read_partial (struct target_ops
*ops
,
1125 enum target_object object
,
1126 const char *annex
, void *buf
,
1127 ULONGEST offset
, LONGEST len
)
1129 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1130 return ops
->to_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1134 target_write_partial (struct target_ops
*ops
,
1135 enum target_object object
,
1136 const char *annex
, const void *buf
,
1137 ULONGEST offset
, LONGEST len
)
1139 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1140 return ops
->to_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1143 /* Wrappers to perform the full transfer. */
1145 target_read (struct target_ops
*ops
,
1146 enum target_object object
,
1147 const char *annex
, void *buf
,
1148 ULONGEST offset
, LONGEST len
)
1151 while (xfered
< len
)
1153 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1154 (bfd_byte
*) buf
+ xfered
,
1155 offset
+ xfered
, len
- xfered
);
1156 /* Call an observer, notifying them of the xfer progress? */
1158 /* Call memory_error? */
1167 target_write (struct target_ops
*ops
,
1168 enum target_object object
,
1169 const char *annex
, const void *buf
,
1170 ULONGEST offset
, LONGEST len
)
1173 while (xfered
< len
)
1175 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1176 (bfd_byte
*) buf
+ xfered
,
1177 offset
+ xfered
, len
- xfered
);
1178 /* Call an observer, notifying them of the xfer progress? */
1180 /* Call memory_error? */
1188 /* Memory transfer methods. */
1191 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1194 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1196 memory_error (EIO
, addr
);
1200 get_target_memory_unsigned (struct target_ops
*ops
,
1201 CORE_ADDR addr
, int len
)
1203 char buf
[sizeof (ULONGEST
)];
1205 gdb_assert (len
<= sizeof (buf
));
1206 get_target_memory (ops
, addr
, buf
, len
);
1207 return extract_unsigned_integer (buf
, len
);
1211 target_info (char *args
, int from_tty
)
1213 struct target_ops
*t
;
1214 int has_all_mem
= 0;
1216 if (symfile_objfile
!= NULL
)
1217 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1219 #ifdef FILES_INFO_HOOK
1220 if (FILES_INFO_HOOK ())
1224 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1226 if (!t
->to_has_memory
)
1229 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1232 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1233 printf_unfiltered ("%s:\n", t
->to_longname
);
1234 (t
->to_files_info
) (t
);
1235 has_all_mem
= t
->to_has_all_memory
;
1239 /* This is to be called by the open routine before it does
1243 target_preopen (int from_tty
)
1247 if (target_has_execution
)
1250 || query ("A program is being debugged already. Kill it? "))
1253 error ("Program not killed.");
1256 /* Calling target_kill may remove the target from the stack. But if
1257 it doesn't (which seems like a win for UDI), remove it now. */
1259 if (target_has_execution
)
1263 /* Detach a target after doing deferred register stores. */
1266 target_detach (char *args
, int from_tty
)
1268 (current_target
.to_detach
) (args
, from_tty
);
1272 target_disconnect (char *args
, int from_tty
)
1274 (current_target
.to_disconnect
) (args
, from_tty
);
1278 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1280 if (DEPRECATED_STREQ (current_target
.to_shortname
, "rombug"))
1282 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1284 error ("Unable to link to %s and get relocation in rombug", modname
);
1287 *t_reloc
= (CORE_ADDR
) -1;
1291 target_async_mask (int mask
)
1293 int saved_async_masked_status
= target_async_mask_value
;
1294 target_async_mask_value
= mask
;
1295 return saved_async_masked_status
;
1298 /* Look through the list of possible targets for a target that can
1299 execute a run or attach command without any other data. This is
1300 used to locate the default process stratum.
1302 Result is always valid (error() is called for errors). */
1304 static struct target_ops
*
1305 find_default_run_target (char *do_mesg
)
1307 struct target_ops
**t
;
1308 struct target_ops
*runable
= NULL
;
1313 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1316 if ((*t
)->to_can_run
&& target_can_run (*t
))
1324 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1330 find_default_attach (char *args
, int from_tty
)
1332 struct target_ops
*t
;
1334 t
= find_default_run_target ("attach");
1335 (t
->to_attach
) (args
, from_tty
);
1340 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1343 struct target_ops
*t
;
1345 t
= find_default_run_target ("run");
1346 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1351 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1353 return (byte_count
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1369 return_minus_one (void)
1375 * Resize the to_sections pointer. Also make sure that anyone that
1376 * was holding on to an old value of it gets updated.
1377 * Returns the old size.
1381 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1383 struct target_ops
**t
;
1384 struct section_table
*old_value
;
1387 old_value
= target
->to_sections
;
1389 if (target
->to_sections
)
1391 old_count
= target
->to_sections_end
- target
->to_sections
;
1392 target
->to_sections
= (struct section_table
*)
1393 xrealloc ((char *) target
->to_sections
,
1394 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1399 target
->to_sections
= (struct section_table
*)
1400 xmalloc ((sizeof (struct section_table
)) * num_added
);
1402 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1404 /* Check to see if anyone else was pointing to this structure.
1405 If old_value was null, then no one was. */
1409 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1412 if ((*t
)->to_sections
== old_value
)
1414 (*t
)->to_sections
= target
->to_sections
;
1415 (*t
)->to_sections_end
= target
->to_sections_end
;
1418 /* There is a flattened view of the target stack in current_target,
1419 so its to_sections pointer might also need updating. */
1420 if (current_target
.to_sections
== old_value
)
1422 current_target
.to_sections
= target
->to_sections
;
1423 current_target
.to_sections_end
= target
->to_sections_end
;
1431 /* Remove all target sections taken from ABFD.
1433 Scan the current target stack for targets whose section tables
1434 refer to sections from BFD, and remove those sections. We use this
1435 when we notice that the inferior has unloaded a shared object, for
1438 remove_target_sections (bfd
*abfd
)
1440 struct target_ops
**t
;
1442 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1444 struct section_table
*src
, *dest
;
1446 dest
= (*t
)->to_sections
;
1447 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1448 if (src
->bfd
!= abfd
)
1450 /* Keep this section. */
1451 if (dest
< src
) *dest
= *src
;
1455 /* If we've dropped any sections, resize the section table. */
1457 target_resize_to_sections (*t
, dest
- src
);
1464 /* Find a single runnable target in the stack and return it. If for
1465 some reason there is more than one, return NULL. */
1468 find_run_target (void)
1470 struct target_ops
**t
;
1471 struct target_ops
*runable
= NULL
;
1476 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1478 if ((*t
)->to_can_run
&& target_can_run (*t
))
1485 return (count
== 1 ? runable
: NULL
);
1488 /* Find a single core_stratum target in the list of targets and return it.
1489 If for some reason there is more than one, return NULL. */
1492 find_core_target (void)
1494 struct target_ops
**t
;
1495 struct target_ops
*runable
= NULL
;
1500 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1503 if ((*t
)->to_stratum
== core_stratum
)
1510 return (count
== 1 ? runable
: NULL
);
1514 * Find the next target down the stack from the specified target.
1518 find_target_beneath (struct target_ops
*t
)
1524 /* The inferior process has died. Long live the inferior! */
1527 generic_mourn_inferior (void)
1529 extern int show_breakpoint_hit_counts
;
1531 inferior_ptid
= null_ptid
;
1533 breakpoint_init_inferior (inf_exited
);
1534 registers_changed ();
1536 reopen_exec_file ();
1537 reinit_frame_cache ();
1539 /* It is confusing to the user for ignore counts to stick around
1540 from previous runs of the inferior. So clear them. */
1541 /* However, it is more confusing for the ignore counts to disappear when
1542 using hit counts. So don't clear them if we're counting hits. */
1543 if (!show_breakpoint_hit_counts
)
1544 breakpoint_clear_ignore_counts ();
1546 if (deprecated_detach_hook
)
1547 deprecated_detach_hook ();
1550 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1551 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1552 translation of that in OURSTATUS. */
1554 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1556 #ifdef CHILD_SPECIAL_WAITSTATUS
1557 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1558 if it wants to deal with hoststatus. */
1559 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1563 if (WIFEXITED (hoststatus
))
1565 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1566 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1568 else if (!WIFSTOPPED (hoststatus
))
1570 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1571 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1575 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1576 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1580 /* Returns zero to leave the inferior alone, one to interrupt it. */
1581 int (*target_activity_function
) (void);
1582 int target_activity_fd
;
1584 /* Convert a normal process ID to a string. Returns the string in a static
1588 normal_pid_to_str (ptid_t ptid
)
1590 static char buf
[30];
1592 sprintf (buf
, "process %d", PIDGET (ptid
));
1596 /* Error-catcher for target_find_memory_regions */
1597 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1599 error ("No target.");
1603 /* Error-catcher for target_make_corefile_notes */
1604 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1606 error ("No target.");
1610 /* Set up the handful of non-empty slots needed by the dummy target
1614 init_dummy_target (void)
1616 dummy_target
.to_shortname
= "None";
1617 dummy_target
.to_longname
= "None";
1618 dummy_target
.to_doc
= "";
1619 dummy_target
.to_attach
= find_default_attach
;
1620 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1621 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1622 dummy_target
.to_stratum
= dummy_stratum
;
1623 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1624 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1625 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1626 dummy_target
.to_magic
= OPS_MAGIC
;
1630 static struct target_ops debug_target
;
1633 debug_to_open (char *args
, int from_tty
)
1635 debug_target
.to_open (args
, from_tty
);
1637 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1641 debug_to_close (int quitting
)
1643 target_close (&debug_target
, quitting
);
1644 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1648 target_close (struct target_ops
*targ
, int quitting
)
1650 if (targ
->to_xclose
!= NULL
)
1651 targ
->to_xclose (targ
, quitting
);
1652 else if (targ
->to_close
!= NULL
)
1653 targ
->to_close (quitting
);
1657 debug_to_attach (char *args
, int from_tty
)
1659 debug_target
.to_attach (args
, from_tty
);
1661 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1666 debug_to_post_attach (int pid
)
1668 debug_target
.to_post_attach (pid
);
1670 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1674 debug_to_detach (char *args
, int from_tty
)
1676 debug_target
.to_detach (args
, from_tty
);
1678 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1682 debug_to_disconnect (char *args
, int from_tty
)
1684 debug_target
.to_disconnect (args
, from_tty
);
1686 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1691 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1693 debug_target
.to_resume (ptid
, step
, siggnal
);
1695 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1696 step
? "step" : "continue",
1697 target_signal_to_name (siggnal
));
1701 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1705 retval
= debug_target
.to_wait (ptid
, status
);
1707 fprintf_unfiltered (gdb_stdlog
,
1708 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1710 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1711 switch (status
->kind
)
1713 case TARGET_WAITKIND_EXITED
:
1714 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1715 status
->value
.integer
);
1717 case TARGET_WAITKIND_STOPPED
:
1718 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1719 target_signal_to_name (status
->value
.sig
));
1721 case TARGET_WAITKIND_SIGNALLED
:
1722 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1723 target_signal_to_name (status
->value
.sig
));
1725 case TARGET_WAITKIND_LOADED
:
1726 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1728 case TARGET_WAITKIND_FORKED
:
1729 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1731 case TARGET_WAITKIND_VFORKED
:
1732 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1734 case TARGET_WAITKIND_EXECD
:
1735 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1737 case TARGET_WAITKIND_SPURIOUS
:
1738 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1741 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1749 debug_to_post_wait (ptid_t ptid
, int status
)
1751 debug_target
.to_post_wait (ptid
, status
);
1753 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1754 PIDGET (ptid
), status
);
1758 debug_print_register (const char * func
, int regno
)
1760 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1761 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1762 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1763 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1765 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1769 unsigned char buf
[MAX_REGISTER_SIZE
];
1770 deprecated_read_register_gen (regno
, buf
);
1771 fprintf_unfiltered (gdb_stdlog
, " = ");
1772 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
1774 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1776 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
1778 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1779 paddr_nz (read_register (regno
)),
1780 paddr_d (read_register (regno
)));
1783 fprintf_unfiltered (gdb_stdlog
, "\n");
1787 debug_to_fetch_registers (int regno
)
1789 debug_target
.to_fetch_registers (regno
);
1790 debug_print_register ("target_fetch_registers", regno
);
1794 debug_to_store_registers (int regno
)
1796 debug_target
.to_store_registers (regno
);
1797 debug_print_register ("target_store_registers", regno
);
1798 fprintf_unfiltered (gdb_stdlog
, "\n");
1802 debug_to_prepare_to_store (void)
1804 debug_target
.to_prepare_to_store ();
1806 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1810 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1811 struct mem_attrib
*attrib
,
1812 struct target_ops
*target
)
1816 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1819 fprintf_unfiltered (gdb_stdlog
,
1820 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1821 (unsigned int) memaddr
, /* possable truncate long long */
1822 len
, write
? "write" : "read", retval
);
1828 fputs_unfiltered (", bytes =", gdb_stdlog
);
1829 for (i
= 0; i
< retval
; i
++)
1831 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1833 if (targetdebug
< 2 && i
> 0)
1835 fprintf_unfiltered (gdb_stdlog
, " ...");
1838 fprintf_unfiltered (gdb_stdlog
, "\n");
1841 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1845 fputc_unfiltered ('\n', gdb_stdlog
);
1851 debug_to_files_info (struct target_ops
*target
)
1853 debug_target
.to_files_info (target
);
1855 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1859 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1863 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1865 fprintf_unfiltered (gdb_stdlog
,
1866 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1867 (unsigned long) addr
,
1868 (unsigned long) retval
);
1873 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1877 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1879 fprintf_unfiltered (gdb_stdlog
,
1880 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1881 (unsigned long) addr
,
1882 (unsigned long) retval
);
1887 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1891 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1893 fprintf_unfiltered (gdb_stdlog
,
1894 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1895 (unsigned long) type
,
1896 (unsigned long) cnt
,
1897 (unsigned long) from_tty
,
1898 (unsigned long) retval
);
1903 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1907 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1909 fprintf_unfiltered (gdb_stdlog
,
1910 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1911 (unsigned long) byte_count
,
1912 (unsigned long) retval
);
1917 debug_to_stopped_by_watchpoint (void)
1921 retval
= debug_target
.to_stopped_by_watchpoint ();
1923 fprintf_unfiltered (gdb_stdlog
,
1924 "STOPPED_BY_WATCHPOINT () = %ld\n",
1925 (unsigned long) retval
);
1930 debug_to_stopped_data_address (void)
1934 retval
= debug_target
.to_stopped_data_address ();
1936 fprintf_unfiltered (gdb_stdlog
,
1937 "target_stopped_data_address () = 0x%lx\n",
1938 (unsigned long) retval
);
1943 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1947 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1949 fprintf_unfiltered (gdb_stdlog
,
1950 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1951 (unsigned long) addr
,
1952 (unsigned long) retval
);
1957 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1961 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1963 fprintf_unfiltered (gdb_stdlog
,
1964 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1965 (unsigned long) addr
,
1966 (unsigned long) retval
);
1971 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1975 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1977 fprintf_unfiltered (gdb_stdlog
,
1978 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1979 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1984 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
1988 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1990 fprintf_unfiltered (gdb_stdlog
,
1991 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1992 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1997 debug_to_terminal_init (void)
1999 debug_target
.to_terminal_init ();
2001 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2005 debug_to_terminal_inferior (void)
2007 debug_target
.to_terminal_inferior ();
2009 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2013 debug_to_terminal_ours_for_output (void)
2015 debug_target
.to_terminal_ours_for_output ();
2017 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2021 debug_to_terminal_ours (void)
2023 debug_target
.to_terminal_ours ();
2025 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2029 debug_to_terminal_save_ours (void)
2031 debug_target
.to_terminal_save_ours ();
2033 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2037 debug_to_terminal_info (char *arg
, int from_tty
)
2039 debug_target
.to_terminal_info (arg
, from_tty
);
2041 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2046 debug_to_kill (void)
2048 debug_target
.to_kill ();
2050 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2054 debug_to_load (char *args
, int from_tty
)
2056 debug_target
.to_load (args
, from_tty
);
2058 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2062 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2066 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2068 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2074 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2077 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2079 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2080 exec_file
, args
, from_tty
);
2084 debug_to_post_startup_inferior (ptid_t ptid
)
2086 debug_target
.to_post_startup_inferior (ptid
);
2088 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2093 debug_to_acknowledge_created_inferior (int pid
)
2095 debug_target
.to_acknowledge_created_inferior (pid
);
2097 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2102 debug_to_insert_fork_catchpoint (int pid
)
2106 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2108 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2115 debug_to_remove_fork_catchpoint (int pid
)
2119 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2121 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2128 debug_to_insert_vfork_catchpoint (int pid
)
2132 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2134 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2141 debug_to_remove_vfork_catchpoint (int pid
)
2145 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2147 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2154 debug_to_follow_fork (int follow_child
)
2156 int retval
= debug_target
.to_follow_fork (follow_child
);
2158 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2159 follow_child
, retval
);
2165 debug_to_insert_exec_catchpoint (int pid
)
2169 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2171 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2178 debug_to_remove_exec_catchpoint (int pid
)
2182 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2184 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2191 debug_to_reported_exec_events_per_exec_call (void)
2193 int reported_exec_events
;
2195 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2197 fprintf_unfiltered (gdb_stdlog
,
2198 "target_reported_exec_events_per_exec_call () = %d\n",
2199 reported_exec_events
);
2201 return reported_exec_events
;
2205 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2209 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2211 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2212 pid
, wait_status
, *exit_status
, has_exited
);
2218 debug_to_mourn_inferior (void)
2220 debug_target
.to_mourn_inferior ();
2222 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2226 debug_to_can_run (void)
2230 retval
= debug_target
.to_can_run ();
2232 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2238 debug_to_notice_signals (ptid_t ptid
)
2240 debug_target
.to_notice_signals (ptid
);
2242 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2247 debug_to_thread_alive (ptid_t ptid
)
2251 retval
= debug_target
.to_thread_alive (ptid
);
2253 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2254 PIDGET (ptid
), retval
);
2260 debug_to_find_new_threads (void)
2262 debug_target
.to_find_new_threads ();
2264 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2268 debug_to_stop (void)
2270 debug_target
.to_stop ();
2272 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2276 debug_to_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2277 const char *annex
, void *readbuf
, const void *writebuf
,
2278 ULONGEST offset
, LONGEST len
)
2282 retval
= debug_target
.to_xfer_partial (&debug_target
, object
, annex
,
2283 readbuf
, writebuf
, offset
, len
);
2285 fprintf_unfiltered (gdb_stdlog
,
2286 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
2287 (int) object
, (annex
? annex
: "(null)"),
2288 (long) readbuf
, (long) writebuf
, paddr_nz (offset
),
2289 paddr_d (len
), paddr_d (retval
));
2295 debug_to_rcmd (char *command
,
2296 struct ui_file
*outbuf
)
2298 debug_target
.to_rcmd (command
, outbuf
);
2299 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2302 static struct symtab_and_line
*
2303 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2305 struct symtab_and_line
*result
;
2306 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2307 fprintf_unfiltered (gdb_stdlog
,
2308 "target get_exception_callback_sal (%d, %d)\n",
2313 static struct exception_event_record
*
2314 debug_to_get_current_exception_event (void)
2316 struct exception_event_record
*result
;
2317 result
= debug_target
.to_get_current_exception_event ();
2318 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2323 debug_to_pid_to_exec_file (int pid
)
2327 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2329 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2336 setup_target_debug (void)
2338 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2340 current_target
.to_open
= debug_to_open
;
2341 current_target
.to_close
= debug_to_close
;
2342 current_target
.to_attach
= debug_to_attach
;
2343 current_target
.to_post_attach
= debug_to_post_attach
;
2344 current_target
.to_detach
= debug_to_detach
;
2345 current_target
.to_disconnect
= debug_to_disconnect
;
2346 current_target
.to_resume
= debug_to_resume
;
2347 current_target
.to_wait
= debug_to_wait
;
2348 current_target
.to_post_wait
= debug_to_post_wait
;
2349 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2350 current_target
.to_store_registers
= debug_to_store_registers
;
2351 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2352 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2353 current_target
.to_files_info
= debug_to_files_info
;
2354 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2355 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2356 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2357 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2358 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2359 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2360 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2361 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2362 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2363 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2364 current_target
.to_terminal_init
= debug_to_terminal_init
;
2365 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2366 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2367 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2368 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2369 current_target
.to_terminal_info
= debug_to_terminal_info
;
2370 current_target
.to_kill
= debug_to_kill
;
2371 current_target
.to_load
= debug_to_load
;
2372 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2373 current_target
.to_create_inferior
= debug_to_create_inferior
;
2374 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2375 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2376 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2377 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2378 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2379 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2380 current_target
.to_follow_fork
= debug_to_follow_fork
;
2381 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2382 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2383 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2384 current_target
.to_has_exited
= debug_to_has_exited
;
2385 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2386 current_target
.to_can_run
= debug_to_can_run
;
2387 current_target
.to_notice_signals
= debug_to_notice_signals
;
2388 current_target
.to_thread_alive
= debug_to_thread_alive
;
2389 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2390 current_target
.to_stop
= debug_to_stop
;
2391 current_target
.to_xfer_partial
= debug_to_xfer_partial
;
2392 current_target
.to_rcmd
= debug_to_rcmd
;
2393 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2394 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2395 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2400 static char targ_desc
[] =
2401 "Names of targets and files being debugged.\n\
2402 Shows the entire stack of targets currently in use (including the exec-file,\n\
2403 core-file, and process, if any), as well as the symbol file name.";
2406 do_monitor_command (char *cmd
,
2409 if ((current_target
.to_rcmd
2410 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2411 || (current_target
.to_rcmd
== debug_to_rcmd
2412 && (debug_target
.to_rcmd
2413 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2415 error ("\"monitor\" command not supported by this target.\n");
2417 target_rcmd (cmd
, gdb_stdtarg
);
2421 initialize_targets (void)
2423 init_dummy_target ();
2424 push_target (&dummy_target
);
2426 add_info ("target", target_info
, targ_desc
);
2427 add_info ("files", target_info
, targ_desc
);
2429 deprecated_add_show_from_set
2430 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2431 (char *) &targetdebug
,
2432 "Set target debugging.\n\
2433 When non-zero, target debugging is enabled. Higher numbers are more\n\
2434 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2435 command.", &setdebuglist
),
2438 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2440 Set mode for reading from readonly sections.", "\
2441 Show mode for reading from readonly sections.", "\
2442 When this mode is on, memory reads from readonly sections (such as .text)\n\
2443 will be read from the object file instead of from the target. This will\n\
2444 result in significant performance improvement for remote targets.", "\
2445 Mode for reading from readonly sections is %s.",
2447 &setlist
, &showlist
);
2449 add_com ("monitor", class_obscure
, do_monitor_command
,
2450 "Send a command to the remote monitor (remote targets only).");
2452 target_dcache
= dcache_init ();