1 /* Select target systems and architectures at runtime for GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 Contributed by Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
39 #include "gdb_assert.h"
42 static void target_info (char *, int);
44 static void maybe_kill_then_create_inferior (char *, char *, char **);
46 static void maybe_kill_then_attach (char *, int);
48 static void kill_or_be_killed (int);
50 static void default_terminal_info (char *, int);
52 static int default_region_size_ok_for_hw_watchpoint (int);
54 static int nosymbol (char *, CORE_ADDR
*);
56 static void tcomplain (void);
58 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
60 static int return_zero (void);
62 static int return_one (void);
64 static int return_minus_one (void);
66 void target_ignore (void);
68 static void target_command (char *, int);
70 static struct target_ops
*find_default_run_target (char *);
72 static void nosupport_runtime (void);
74 static void normal_target_post_startup_inferior (ptid_t ptid
);
76 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
77 enum target_object object
,
78 const char *annex
, const void *writebuf
,
79 void *readbuf
, ULONGEST offset
,
82 /* Transfer LEN bytes between target address MEMADDR and GDB address
83 MYADDR. Returns 0 for success, errno code for failure (which
84 includes partial transfers -- if you want a more useful response to
85 partial transfers, try either target_read_memory_partial or
86 target_write_memory_partial). */
88 static int target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
91 static void init_dummy_target (void);
93 static void debug_to_open (char *, int);
95 static void debug_to_close (int);
97 static void debug_to_attach (char *, int);
99 static void debug_to_detach (char *, int);
101 static void debug_to_disconnect (char *, int);
103 static void debug_to_resume (ptid_t
, int, enum target_signal
);
105 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
107 static void debug_to_fetch_registers (int);
109 static void debug_to_store_registers (int);
111 static void debug_to_prepare_to_store (void);
113 static int debug_to_xfer_memory (CORE_ADDR
, char *, int, int,
114 struct mem_attrib
*, struct target_ops
*);
116 static void debug_to_files_info (struct target_ops
*);
118 static int debug_to_insert_breakpoint (CORE_ADDR
, char *);
120 static int debug_to_remove_breakpoint (CORE_ADDR
, char *);
122 static int debug_to_can_use_hw_breakpoint (int, int, int);
124 static int debug_to_insert_hw_breakpoint (CORE_ADDR
, char *);
126 static int debug_to_remove_hw_breakpoint (CORE_ADDR
, char *);
128 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
130 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
132 static int debug_to_stopped_by_watchpoint (void);
134 static CORE_ADDR
debug_to_stopped_data_address (void);
136 static int debug_to_region_size_ok_for_hw_watchpoint (int);
138 static void debug_to_terminal_init (void);
140 static void debug_to_terminal_inferior (void);
142 static void debug_to_terminal_ours_for_output (void);
144 static void debug_to_terminal_save_ours (void);
146 static void debug_to_terminal_ours (void);
148 static void debug_to_terminal_info (char *, int);
150 static void debug_to_kill (void);
152 static void debug_to_load (char *, int);
154 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
156 static void debug_to_create_inferior (char *, char *, char **);
158 static void debug_to_mourn_inferior (void);
160 static int debug_to_can_run (void);
162 static void debug_to_notice_signals (ptid_t
);
164 static int debug_to_thread_alive (ptid_t
);
166 static void debug_to_stop (void);
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 t
->to_xfer_partial
= default_xfer_partial
;
227 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
228 target_structs
= (struct target_ops
**) xmalloc
229 (target_struct_allocsize
* sizeof (*target_structs
));
231 if (target_struct_size
>= target_struct_allocsize
)
233 target_struct_allocsize
*= 2;
234 target_structs
= (struct target_ops
**)
235 xrealloc ((char *) target_structs
,
236 target_struct_allocsize
* sizeof (*target_structs
));
238 target_structs
[target_struct_size
++] = t
;
240 if (targetlist
== NULL
)
241 add_prefix_cmd ("target", class_run
, target_command
,
242 "Connect to a target machine or process.\n\
243 The first argument is the type or protocol of the target machine.\n\
244 Remaining arguments are interpreted by the target protocol. For more\n\
245 information on the arguments for a particular protocol, type\n\
246 `help target ' followed by the protocol name.",
247 &targetlist
, "target ", 0, &cmdlist
);
248 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
259 target_load (char *arg
, int from_tty
)
261 dcache_invalidate (target_dcache
);
262 (*current_target
.to_load
) (arg
, from_tty
);
266 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
267 struct target_ops
*t
)
269 errno
= EIO
; /* Can't read/write this location */
270 return 0; /* No bytes handled */
276 error ("You can't do that when your target is `%s'",
277 current_target
.to_shortname
);
283 error ("You can't do that without a process to debug.");
287 nosymbol (char *name
, CORE_ADDR
*addrp
)
289 return 1; /* Symbol does not exist in target env */
293 nosupport_runtime (void)
295 if (ptid_equal (inferior_ptid
, null_ptid
))
298 error ("No run-time support for this");
303 default_terminal_info (char *args
, int from_tty
)
305 printf_unfiltered ("No saved terminal information.\n");
308 /* This is the default target_create_inferior and target_attach function.
309 If the current target is executing, it asks whether to kill it off.
310 If this function returns without calling error(), it has killed off
311 the target, and the operation should be attempted. */
314 kill_or_be_killed (int from_tty
)
316 if (target_has_execution
)
318 printf_unfiltered ("You are already running a program:\n");
319 target_files_info ();
320 if (query ("Kill it? "))
323 if (target_has_execution
)
324 error ("Killing the program did not help.");
329 error ("Program not killed.");
336 maybe_kill_then_attach (char *args
, int from_tty
)
338 kill_or_be_killed (from_tty
);
339 target_attach (args
, from_tty
);
343 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
)
345 kill_or_be_killed (0);
346 target_create_inferior (exec
, args
, env
);
349 /* Go through the target stack from top to bottom, copying over zero
350 entries in current_target, then filling in still empty entries. In
351 effect, we are doing class inheritance through the pushed target
354 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
355 is currently implemented, is that it discards any knowledge of
356 which target an inherited method originally belonged to.
357 Consequently, new new target methods should instead explicitly and
358 locally search the target stack for the target that can handle the
362 update_current_target (void)
364 struct target_ops
*t
;
366 /* First, reset curren'ts contents. */
367 memset (¤t_target
, 0, sizeof (current_target
));
369 #define INHERIT(FIELD, TARGET) \
370 if (!current_target.FIELD) \
371 current_target.FIELD = (TARGET)->FIELD
373 for (t
= target_stack
; t
; t
= t
->beneath
)
375 INHERIT (to_shortname
, t
);
376 INHERIT (to_longname
, t
);
378 INHERIT (to_open
, t
);
379 INHERIT (to_close
, t
);
380 INHERIT (to_attach
, t
);
381 INHERIT (to_post_attach
, t
);
382 INHERIT (to_detach
, t
);
383 INHERIT (to_disconnect
, t
);
384 INHERIT (to_resume
, t
);
385 INHERIT (to_wait
, t
);
386 INHERIT (to_post_wait
, t
);
387 INHERIT (to_fetch_registers
, t
);
388 INHERIT (to_store_registers
, t
);
389 INHERIT (to_prepare_to_store
, t
);
390 INHERIT (to_xfer_memory
, t
);
391 INHERIT (to_files_info
, t
);
392 INHERIT (to_insert_breakpoint
, t
);
393 INHERIT (to_remove_breakpoint
, t
);
394 INHERIT (to_can_use_hw_breakpoint
, t
);
395 INHERIT (to_insert_hw_breakpoint
, t
);
396 INHERIT (to_remove_hw_breakpoint
, t
);
397 INHERIT (to_insert_watchpoint
, t
);
398 INHERIT (to_remove_watchpoint
, t
);
399 INHERIT (to_stopped_data_address
, t
);
400 INHERIT (to_stopped_by_watchpoint
, t
);
401 INHERIT (to_have_continuable_watchpoint
, t
);
402 INHERIT (to_region_size_ok_for_hw_watchpoint
, t
);
403 INHERIT (to_terminal_init
, t
);
404 INHERIT (to_terminal_inferior
, t
);
405 INHERIT (to_terminal_ours_for_output
, t
);
406 INHERIT (to_terminal_ours
, t
);
407 INHERIT (to_terminal_save_ours
, t
);
408 INHERIT (to_terminal_info
, t
);
409 INHERIT (to_kill
, t
);
410 INHERIT (to_load
, t
);
411 INHERIT (to_lookup_symbol
, t
);
412 INHERIT (to_create_inferior
, t
);
413 INHERIT (to_post_startup_inferior
, t
);
414 INHERIT (to_acknowledge_created_inferior
, t
);
415 INHERIT (to_insert_fork_catchpoint
, t
);
416 INHERIT (to_remove_fork_catchpoint
, t
);
417 INHERIT (to_insert_vfork_catchpoint
, t
);
418 INHERIT (to_remove_vfork_catchpoint
, t
);
419 INHERIT (to_follow_fork
, t
);
420 INHERIT (to_insert_exec_catchpoint
, t
);
421 INHERIT (to_remove_exec_catchpoint
, t
);
422 INHERIT (to_reported_exec_events_per_exec_call
, t
);
423 INHERIT (to_has_exited
, t
);
424 INHERIT (to_mourn_inferior
, t
);
425 INHERIT (to_can_run
, t
);
426 INHERIT (to_notice_signals
, t
);
427 INHERIT (to_thread_alive
, t
);
428 INHERIT (to_find_new_threads
, t
);
429 INHERIT (to_pid_to_str
, t
);
430 INHERIT (to_extra_thread_info
, t
);
431 INHERIT (to_stop
, t
);
432 /* Do not inherit to_xfer_partial. */
433 INHERIT (to_rcmd
, t
);
434 INHERIT (to_enable_exception_callback
, t
);
435 INHERIT (to_get_current_exception_event
, t
);
436 INHERIT (to_pid_to_exec_file
, t
);
437 INHERIT (to_stratum
, t
);
438 INHERIT (to_has_all_memory
, t
);
439 INHERIT (to_has_memory
, t
);
440 INHERIT (to_has_stack
, t
);
441 INHERIT (to_has_registers
, t
);
442 INHERIT (to_has_execution
, t
);
443 INHERIT (to_has_thread_control
, t
);
444 INHERIT (to_sections
, t
);
445 INHERIT (to_sections_end
, t
);
446 INHERIT (to_can_async_p
, t
);
447 INHERIT (to_is_async_p
, t
);
448 INHERIT (to_async
, t
);
449 INHERIT (to_async_mask_value
, t
);
450 INHERIT (to_find_memory_regions
, t
);
451 INHERIT (to_make_corefile_notes
, t
);
452 INHERIT (to_get_thread_local_address
, t
);
453 INHERIT (to_magic
, t
);
457 /* Clean up a target struct so it no longer has any zero pointers in
458 it. Some entries are defaulted to a method that print an error,
459 others are hard-wired to a standard recursive default. */
461 #define de_fault(field, value) \
462 if (!current_target.field) \
463 current_target.field = value
466 (void (*) (char *, int))
472 maybe_kill_then_attach
);
473 de_fault (to_post_attach
,
477 (void (*) (char *, int))
479 de_fault (to_disconnect
,
480 (void (*) (char *, int))
483 (void (*) (ptid_t
, int, enum target_signal
))
486 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
488 de_fault (to_post_wait
,
489 (void (*) (ptid_t
, int))
491 de_fault (to_fetch_registers
,
494 de_fault (to_store_registers
,
497 de_fault (to_prepare_to_store
,
500 de_fault (to_xfer_memory
,
501 (int (*) (CORE_ADDR
, char *, int, int, struct mem_attrib
*, struct target_ops
*))
503 de_fault (to_files_info
,
504 (void (*) (struct target_ops
*))
506 de_fault (to_insert_breakpoint
,
507 memory_insert_breakpoint
);
508 de_fault (to_remove_breakpoint
,
509 memory_remove_breakpoint
);
510 de_fault (to_can_use_hw_breakpoint
,
511 (int (*) (int, int, int))
513 de_fault (to_insert_hw_breakpoint
,
514 (int (*) (CORE_ADDR
, char *))
516 de_fault (to_remove_hw_breakpoint
,
517 (int (*) (CORE_ADDR
, char *))
519 de_fault (to_insert_watchpoint
,
520 (int (*) (CORE_ADDR
, int, int))
522 de_fault (to_remove_watchpoint
,
523 (int (*) (CORE_ADDR
, int, int))
525 de_fault (to_stopped_by_watchpoint
,
528 de_fault (to_stopped_data_address
,
529 (CORE_ADDR (*) (void))
531 de_fault (to_region_size_ok_for_hw_watchpoint
,
532 default_region_size_ok_for_hw_watchpoint
);
533 de_fault (to_terminal_init
,
536 de_fault (to_terminal_inferior
,
539 de_fault (to_terminal_ours_for_output
,
542 de_fault (to_terminal_ours
,
545 de_fault (to_terminal_save_ours
,
548 de_fault (to_terminal_info
,
549 default_terminal_info
);
554 (void (*) (char *, int))
556 de_fault (to_lookup_symbol
,
557 (int (*) (char *, CORE_ADDR
*))
559 de_fault (to_create_inferior
,
560 maybe_kill_then_create_inferior
);
561 de_fault (to_post_startup_inferior
,
564 de_fault (to_acknowledge_created_inferior
,
567 de_fault (to_insert_fork_catchpoint
,
570 de_fault (to_remove_fork_catchpoint
,
573 de_fault (to_insert_vfork_catchpoint
,
576 de_fault (to_remove_vfork_catchpoint
,
579 de_fault (to_follow_fork
,
582 de_fault (to_insert_exec_catchpoint
,
585 de_fault (to_remove_exec_catchpoint
,
588 de_fault (to_reported_exec_events_per_exec_call
,
591 de_fault (to_has_exited
,
592 (int (*) (int, int, int *))
594 de_fault (to_mourn_inferior
,
597 de_fault (to_can_run
,
599 de_fault (to_notice_signals
,
602 de_fault (to_thread_alive
,
605 de_fault (to_find_new_threads
,
608 de_fault (to_extra_thread_info
,
609 (char *(*) (struct thread_info
*))
614 current_target
.to_xfer_partial
= default_xfer_partial
;
616 (void (*) (char *, struct ui_file
*))
618 de_fault (to_enable_exception_callback
,
619 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
621 de_fault (to_get_current_exception_event
,
622 (struct exception_event_record
* (*) (void))
624 de_fault (to_pid_to_exec_file
,
627 de_fault (to_can_async_p
,
630 de_fault (to_is_async_p
,
634 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
638 /* Finally, position the target-stack beneath the squashed
639 "current_target". That way code looking for a non-inherited
640 target method can quickly and simply find it. */
641 current_target
.beneath
= target_stack
;
644 /* Push a new target type into the stack of the existing target accessors,
645 possibly superseding some of the existing accessors.
647 Result is zero if the pushed target ended up on top of the stack,
648 nonzero if at least one target is on top of it.
650 Rather than allow an empty stack, we always have the dummy target at
651 the bottom stratum, so we can call the function vectors without
655 push_target (struct target_ops
*t
)
657 struct target_ops
**cur
;
659 /* Check magic number. If wrong, it probably means someone changed
660 the struct definition, but not all the places that initialize one. */
661 if (t
->to_magic
!= OPS_MAGIC
)
663 fprintf_unfiltered (gdb_stderr
,
664 "Magic number of %s target struct wrong\n",
666 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
669 /* Find the proper stratum to install this target in. */
670 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
672 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
676 /* If there's already targets at this stratum, remove them. */
677 /* FIXME: cagney/2003-10-15: I think this should be poping all
678 targets to CUR, and not just those at this stratum level. */
679 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
681 /* There's already something at this stratum level. Close it,
682 and un-hook it from the stack. */
683 struct target_ops
*tmp
= (*cur
);
684 (*cur
) = (*cur
)->beneath
;
686 target_close (tmp
, 0);
689 /* We have removed all targets in our stratum, now add the new one. */
693 update_current_target ();
696 setup_target_debug ();
699 return (t
!= target_stack
);
702 /* Remove a target_ops vector from the stack, wherever it may be.
703 Return how many times it was removed (0 or 1). */
706 unpush_target (struct target_ops
*t
)
708 struct target_ops
**cur
;
709 struct target_ops
*tmp
;
713 /* Look for the specified target. Note that we assume that a target
714 can only occur once in the target stack. */
716 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
723 return 0; /* Didn't find target_ops, quit now */
725 /* Unchain the target */
727 (*cur
) = (*cur
)->beneath
;
730 update_current_target ();
738 target_close (¤t_target
, 0); /* Let it clean up */
739 if (unpush_target (target_stack
) == 1)
742 fprintf_unfiltered (gdb_stderr
,
743 "pop_target couldn't find target %s\n",
744 current_target
.to_shortname
);
745 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
749 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
751 /* target_read_string -- read a null terminated string, up to LEN bytes,
752 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
753 Set *STRING to a pointer to malloc'd memory containing the data; the caller
754 is responsible for freeing it. Return the number of bytes successfully
758 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
760 int tlen
, origlen
, offset
, i
;
764 int buffer_allocated
;
766 unsigned int nbytes_read
= 0;
768 /* Small for testing. */
769 buffer_allocated
= 4;
770 buffer
= xmalloc (buffer_allocated
);
777 tlen
= MIN (len
, 4 - (memaddr
& 3));
778 offset
= memaddr
& 3;
780 errcode
= target_xfer_memory (memaddr
& ~3, buf
, 4, 0);
783 /* The transfer request might have crossed the boundary to an
784 unallocated region of memory. Retry the transfer, requesting
788 errcode
= target_xfer_memory (memaddr
, buf
, 1, 0);
793 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
796 bytes
= bufptr
- buffer
;
797 buffer_allocated
*= 2;
798 buffer
= xrealloc (buffer
, buffer_allocated
);
799 bufptr
= buffer
+ bytes
;
802 for (i
= 0; i
< tlen
; i
++)
804 *bufptr
++ = buf
[i
+ offset
];
805 if (buf
[i
+ offset
] == '\000')
807 nbytes_read
+= i
+ 1;
824 /* Find a section containing ADDR. */
825 struct section_table
*
826 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
828 struct section_table
*secp
;
829 for (secp
= target
->to_sections
;
830 secp
< target
->to_sections_end
;
833 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
839 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
840 GDB's memory at MYADDR. Returns either 0 for success or an errno value
843 If an error occurs, no guarantee is made about the contents of the data at
844 MYADDR. In particular, the caller should not depend upon partial reads
845 filling the buffer with good data. There is no way for the caller to know
846 how much good data might have been transfered anyway. Callers that can
847 deal with partial reads should call target_read_memory_partial. */
850 target_read_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
852 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
856 target_write_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
858 return target_xfer_memory (memaddr
, myaddr
, len
, 1);
861 static int trust_readonly
= 0;
863 /* Move memory to or from the targets. The top target gets priority;
864 if it cannot handle it, it is offered to the next one down, etc.
866 Result is -1 on error, or the number of bytes transfered. */
869 do_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
870 struct mem_attrib
*attrib
)
874 struct target_ops
*t
;
876 /* Zero length requests are ok and require no work. */
880 /* to_xfer_memory is not guaranteed to set errno, even when it returns
884 if (!write
&& trust_readonly
)
886 struct section_table
*secp
;
887 /* User-settable option, "trust-readonly-sections". If true,
888 then memory from any SEC_READONLY bfd section may be read
889 directly from the bfd file. */
890 secp
= target_section_by_addr (¤t_target
, memaddr
);
892 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
894 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
897 /* The quick case is that the top target can handle the transfer. */
898 res
= current_target
.to_xfer_memory
899 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
901 /* If res <= 0 then we call it again in the loop. Ah well. */
904 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
906 if (!t
->to_has_memory
)
909 res
= t
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
911 break; /* Handled all or part of xfer */
912 if (t
->to_has_all_memory
)
924 /* Perform a memory transfer. Iterate until the entire region has
927 Result is 0 or errno value. */
930 target_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
)
934 struct mem_region
*region
;
936 /* Zero length requests are ok and require no work. */
944 region
= lookup_mem_region(memaddr
);
945 if (memaddr
+ len
< region
->hi
)
948 reg_len
= region
->hi
- memaddr
;
950 switch (region
->attrib
.mode
)
965 if (region
->attrib
.cache
)
966 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
969 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
974 /* If this address is for nonexistent memory, read zeros
975 if reading, or do nothing if writing. Return
978 memset (myaddr
, 0, len
);
992 return 0; /* We managed to cover it all somehow. */
996 /* Perform a partial memory transfer.
998 Result is -1 on error, or the number of bytes transfered. */
1001 target_xfer_memory_partial (CORE_ADDR memaddr
, char *myaddr
, int len
,
1002 int write_p
, int *err
)
1006 struct mem_region
*region
;
1008 /* Zero length requests are ok and require no work. */
1015 region
= lookup_mem_region(memaddr
);
1016 if (memaddr
+ len
< region
->hi
)
1019 reg_len
= region
->hi
- memaddr
;
1021 switch (region
->attrib
.mode
)
1040 if (region
->attrib
.cache
)
1041 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1044 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1062 target_read_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1064 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1068 target_write_memory_partial (CORE_ADDR memaddr
, char *buf
, int len
, int *err
)
1070 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1073 /* More generic transfers. */
1076 default_xfer_partial (struct target_ops
*ops
,
1077 enum target_object object
,
1078 const char *annex
, const void *writebuf
,
1079 void *readbuf
, ULONGEST offset
, LONGEST len
)
1081 if (object
== TARGET_OBJECT_MEMORY
1082 && ops
->to_xfer_memory
!= NULL
)
1083 /* If available, fall back to the target's "to_xfer_memory"
1088 if (writebuf
!= NULL
)
1090 void *buffer
= xmalloc (len
);
1091 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1092 memcpy (buffer
, writebuf
, len
);
1093 xfered
= ops
->to_xfer_memory (offset
, buffer
, len
, 1/*write*/, NULL
,
1095 do_cleanups (cleanup
);
1097 if (readbuf
!= NULL
)
1098 xfered
= ops
->to_xfer_memory (offset
, readbuf
, len
, 0/*read*/, NULL
,
1102 else if (xfered
== 0 && errno
== 0)
1103 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1104 indication of an error. */
1109 else if (ops
->beneath
!= NULL
)
1110 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1111 writebuf
, readbuf
, offset
, len
);
1116 /* Target vector read/write partial wrapper functions.
1118 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1119 (inbuf, outbuf)", instead of separate read/write methods, make life
1123 target_read_partial (struct target_ops
*ops
,
1124 enum target_object object
,
1125 const char *annex
, void *buf
,
1126 ULONGEST offset
, LONGEST len
)
1128 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1129 return ops
->to_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1133 target_write_partial (struct target_ops
*ops
,
1134 enum target_object object
,
1135 const char *annex
, const void *buf
,
1136 ULONGEST offset
, LONGEST len
)
1138 gdb_assert (ops
->to_xfer_partial
!= NULL
);
1139 return ops
->to_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1142 /* Wrappers to perform the full transfer. */
1144 target_read (struct target_ops
*ops
,
1145 enum target_object object
,
1146 const char *annex
, void *buf
,
1147 ULONGEST offset
, LONGEST len
)
1150 while (xfered
< len
)
1152 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1153 (bfd_byte
*) buf
+ xfered
,
1154 offset
+ xfered
, len
- xfered
);
1155 /* Call an observer, notifying them of the xfer progress? */
1157 /* Call memory_error? */
1166 target_write (struct target_ops
*ops
,
1167 enum target_object object
,
1168 const char *annex
, const void *buf
,
1169 ULONGEST offset
, LONGEST len
)
1172 while (xfered
< len
)
1174 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1175 (bfd_byte
*) buf
+ xfered
,
1176 offset
+ xfered
, len
- xfered
);
1177 /* Call an observer, notifying them of the xfer progress? */
1179 /* Call memory_error? */
1187 /* Memory transfer methods. */
1190 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, void *buf
,
1193 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1195 memory_error (EIO
, addr
);
1199 get_target_memory_unsigned (struct target_ops
*ops
,
1200 CORE_ADDR addr
, int len
)
1202 char buf
[sizeof (ULONGEST
)];
1204 gdb_assert (len
<= sizeof (buf
));
1205 get_target_memory (ops
, addr
, buf
, len
);
1206 return extract_unsigned_integer (buf
, len
);
1210 target_info (char *args
, int from_tty
)
1212 struct target_ops
*t
;
1213 int has_all_mem
= 0;
1215 if (symfile_objfile
!= NULL
)
1216 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile
->name
);
1218 #ifdef FILES_INFO_HOOK
1219 if (FILES_INFO_HOOK ())
1223 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1225 if (!t
->to_has_memory
)
1228 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1231 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1232 printf_unfiltered ("%s:\n", t
->to_longname
);
1233 (t
->to_files_info
) (t
);
1234 has_all_mem
= t
->to_has_all_memory
;
1238 /* This is to be called by the open routine before it does
1242 target_preopen (int from_tty
)
1246 if (target_has_execution
)
1249 || query ("A program is being debugged already. Kill it? "))
1252 error ("Program not killed.");
1255 /* Calling target_kill may remove the target from the stack. But if
1256 it doesn't (which seems like a win for UDI), remove it now. */
1258 if (target_has_execution
)
1262 /* Detach a target after doing deferred register stores. */
1265 target_detach (char *args
, int from_tty
)
1267 /* Handle any optimized stores to the inferior. */
1268 #ifdef DO_DEFERRED_STORES
1271 (current_target
.to_detach
) (args
, from_tty
);
1275 target_disconnect (char *args
, int from_tty
)
1277 /* Handle any optimized stores to the inferior. */
1278 #ifdef DO_DEFERRED_STORES
1281 (current_target
.to_disconnect
) (args
, from_tty
);
1285 target_link (char *modname
, CORE_ADDR
*t_reloc
)
1287 if (STREQ (current_target
.to_shortname
, "rombug"))
1289 (current_target
.to_lookup_symbol
) (modname
, t_reloc
);
1291 error ("Unable to link to %s and get relocation in rombug", modname
);
1294 *t_reloc
= (CORE_ADDR
) -1;
1298 target_async_mask (int mask
)
1300 int saved_async_masked_status
= target_async_mask_value
;
1301 target_async_mask_value
= mask
;
1302 return saved_async_masked_status
;
1305 /* Look through the list of possible targets for a target that can
1306 execute a run or attach command without any other data. This is
1307 used to locate the default process stratum.
1309 Result is always valid (error() is called for errors). */
1311 static struct target_ops
*
1312 find_default_run_target (char *do_mesg
)
1314 struct target_ops
**t
;
1315 struct target_ops
*runable
= NULL
;
1320 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1323 if ((*t
)->to_can_run
&& target_can_run (*t
))
1331 error ("Don't know how to %s. Try \"help target\".", do_mesg
);
1337 find_default_attach (char *args
, int from_tty
)
1339 struct target_ops
*t
;
1341 t
= find_default_run_target ("attach");
1342 (t
->to_attach
) (args
, from_tty
);
1347 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
)
1349 struct target_ops
*t
;
1351 t
= find_default_run_target ("run");
1352 (t
->to_create_inferior
) (exec_file
, allargs
, env
);
1357 default_region_size_ok_for_hw_watchpoint (int byte_count
)
1359 return (byte_count
<= DEPRECATED_REGISTER_SIZE
);
1375 return_minus_one (void)
1381 * Resize the to_sections pointer. Also make sure that anyone that
1382 * was holding on to an old value of it gets updated.
1383 * Returns the old size.
1387 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1389 struct target_ops
**t
;
1390 struct section_table
*old_value
;
1393 old_value
= target
->to_sections
;
1395 if (target
->to_sections
)
1397 old_count
= target
->to_sections_end
- target
->to_sections
;
1398 target
->to_sections
= (struct section_table
*)
1399 xrealloc ((char *) target
->to_sections
,
1400 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1405 target
->to_sections
= (struct section_table
*)
1406 xmalloc ((sizeof (struct section_table
)) * num_added
);
1408 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1410 /* Check to see if anyone else was pointing to this structure.
1411 If old_value was null, then no one was. */
1415 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1418 if ((*t
)->to_sections
== old_value
)
1420 (*t
)->to_sections
= target
->to_sections
;
1421 (*t
)->to_sections_end
= target
->to_sections_end
;
1430 /* Remove all target sections taken from ABFD.
1432 Scan the current target stack for targets whose section tables
1433 refer to sections from BFD, and remove those sections. We use this
1434 when we notice that the inferior has unloaded a shared object, for
1437 remove_target_sections (bfd
*abfd
)
1439 struct target_ops
**t
;
1441 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1443 struct section_table
*src
, *dest
;
1445 dest
= (*t
)->to_sections
;
1446 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1447 if (src
->bfd
!= abfd
)
1449 /* Keep this section. */
1450 if (dest
< src
) *dest
= *src
;
1454 /* If we've dropped any sections, resize the section table. */
1456 target_resize_to_sections (*t
, dest
- src
);
1463 /* Find a single runnable target in the stack and return it. If for
1464 some reason there is more than one, return NULL. */
1467 find_run_target (void)
1469 struct target_ops
**t
;
1470 struct target_ops
*runable
= NULL
;
1475 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1477 if ((*t
)->to_can_run
&& target_can_run (*t
))
1484 return (count
== 1 ? runable
: NULL
);
1487 /* Find a single core_stratum target in the list of targets and return it.
1488 If for some reason there is more than one, return NULL. */
1491 find_core_target (void)
1493 struct target_ops
**t
;
1494 struct target_ops
*runable
= NULL
;
1499 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1502 if ((*t
)->to_stratum
== core_stratum
)
1509 return (count
== 1 ? runable
: NULL
);
1513 * Find the next target down the stack from the specified target.
1517 find_target_beneath (struct target_ops
*t
)
1523 /* The inferior process has died. Long live the inferior! */
1526 generic_mourn_inferior (void)
1528 extern int show_breakpoint_hit_counts
;
1530 inferior_ptid
= null_ptid
;
1532 breakpoint_init_inferior (inf_exited
);
1533 registers_changed ();
1535 #ifdef CLEAR_DEFERRED_STORES
1536 /* Delete any pending stores to the inferior... */
1537 CLEAR_DEFERRED_STORES
;
1540 reopen_exec_file ();
1541 reinit_frame_cache ();
1543 /* It is confusing to the user for ignore counts to stick around
1544 from previous runs of the inferior. So clear them. */
1545 /* However, it is more confusing for the ignore counts to disappear when
1546 using hit counts. So don't clear them if we're counting hits. */
1547 if (!show_breakpoint_hit_counts
)
1548 breakpoint_clear_ignore_counts ();
1554 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1555 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1556 translation of that in OURSTATUS. */
1558 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1560 #ifdef CHILD_SPECIAL_WAITSTATUS
1561 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1562 if it wants to deal with hoststatus. */
1563 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1567 if (WIFEXITED (hoststatus
))
1569 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1570 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1572 else if (!WIFSTOPPED (hoststatus
))
1574 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1575 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1579 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1580 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1584 /* Returns zero to leave the inferior alone, one to interrupt it. */
1585 int (*target_activity_function
) (void);
1586 int target_activity_fd
;
1588 /* Convert a normal process ID to a string. Returns the string in a static
1592 normal_pid_to_str (ptid_t ptid
)
1594 static char buf
[30];
1596 sprintf (buf
, "process %d", PIDGET (ptid
));
1600 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1601 notification of inferior events such as fork and vork immediately
1602 after the inferior is created. (This because of how gdb gets an
1603 inferior created via invoking a shell to do it. In such a scenario,
1604 if the shell init file has commands in it, the shell will fork and
1605 exec for each of those commands, and we will see each such fork
1608 This function is used by all targets that allow us to request
1609 notification of forks, etc at inferior creation time; e.g., in
1610 target_acknowledge_forked_child.
1613 normal_target_post_startup_inferior (ptid_t ptid
)
1615 /* This space intentionally left blank. */
1618 /* Error-catcher for target_find_memory_regions */
1619 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1621 error ("No target.");
1625 /* Error-catcher for target_make_corefile_notes */
1626 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1628 error ("No target.");
1632 /* Set up the handful of non-empty slots needed by the dummy target
1636 init_dummy_target (void)
1638 dummy_target
.to_shortname
= "None";
1639 dummy_target
.to_longname
= "None";
1640 dummy_target
.to_doc
= "";
1641 dummy_target
.to_attach
= find_default_attach
;
1642 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1643 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1644 dummy_target
.to_stratum
= dummy_stratum
;
1645 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1646 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1647 dummy_target
.to_magic
= OPS_MAGIC
;
1651 static struct target_ops debug_target
;
1654 debug_to_open (char *args
, int from_tty
)
1656 debug_target
.to_open (args
, from_tty
);
1658 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1662 debug_to_close (int quitting
)
1664 target_close (&debug_target
, quitting
);
1665 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1669 target_close (struct target_ops
*targ
, int quitting
)
1671 if (targ
->to_xclose
!= NULL
)
1672 targ
->to_xclose (targ
, quitting
);
1673 else if (targ
->to_close
!= NULL
)
1674 targ
->to_close (quitting
);
1678 debug_to_attach (char *args
, int from_tty
)
1680 debug_target
.to_attach (args
, from_tty
);
1682 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1687 debug_to_post_attach (int pid
)
1689 debug_target
.to_post_attach (pid
);
1691 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1695 debug_to_detach (char *args
, int from_tty
)
1697 debug_target
.to_detach (args
, from_tty
);
1699 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1703 debug_to_disconnect (char *args
, int from_tty
)
1705 debug_target
.to_disconnect (args
, from_tty
);
1707 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1712 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1714 debug_target
.to_resume (ptid
, step
, siggnal
);
1716 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1717 step
? "step" : "continue",
1718 target_signal_to_name (siggnal
));
1722 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1726 retval
= debug_target
.to_wait (ptid
, status
);
1728 fprintf_unfiltered (gdb_stdlog
,
1729 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1731 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1732 switch (status
->kind
)
1734 case TARGET_WAITKIND_EXITED
:
1735 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1736 status
->value
.integer
);
1738 case TARGET_WAITKIND_STOPPED
:
1739 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1740 target_signal_to_name (status
->value
.sig
));
1742 case TARGET_WAITKIND_SIGNALLED
:
1743 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1744 target_signal_to_name (status
->value
.sig
));
1746 case TARGET_WAITKIND_LOADED
:
1747 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1749 case TARGET_WAITKIND_FORKED
:
1750 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1752 case TARGET_WAITKIND_VFORKED
:
1753 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1755 case TARGET_WAITKIND_EXECD
:
1756 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1758 case TARGET_WAITKIND_SPURIOUS
:
1759 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1762 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1770 debug_to_post_wait (ptid_t ptid
, int status
)
1772 debug_target
.to_post_wait (ptid
, status
);
1774 fprintf_unfiltered (gdb_stdlog
, "target_post_wait (%d, %d)\n",
1775 PIDGET (ptid
), status
);
1779 debug_print_register (const char * func
, int regno
)
1781 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1782 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1783 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1784 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1786 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1790 unsigned char buf
[MAX_REGISTER_SIZE
];
1791 deprecated_read_register_gen (regno
, buf
);
1792 fprintf_unfiltered (gdb_stdlog
, " = ");
1793 for (i
= 0; i
< DEPRECATED_REGISTER_RAW_SIZE (regno
); i
++)
1795 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1797 if (DEPRECATED_REGISTER_RAW_SIZE (regno
) <= sizeof (LONGEST
))
1799 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
1800 paddr_nz (read_register (regno
)),
1801 paddr_d (read_register (regno
)));
1804 fprintf_unfiltered (gdb_stdlog
, "\n");
1808 debug_to_fetch_registers (int regno
)
1810 debug_target
.to_fetch_registers (regno
);
1811 debug_print_register ("target_fetch_registers", regno
);
1815 debug_to_store_registers (int regno
)
1817 debug_target
.to_store_registers (regno
);
1818 debug_print_register ("target_store_registers", regno
);
1819 fprintf_unfiltered (gdb_stdlog
, "\n");
1823 debug_to_prepare_to_store (void)
1825 debug_target
.to_prepare_to_store ();
1827 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
1831 debug_to_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1832 struct mem_attrib
*attrib
,
1833 struct target_ops
*target
)
1837 retval
= debug_target
.to_xfer_memory (memaddr
, myaddr
, len
, write
,
1840 fprintf_unfiltered (gdb_stdlog
,
1841 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1842 (unsigned int) memaddr
, /* possable truncate long long */
1843 len
, write
? "write" : "read", retval
);
1851 fputs_unfiltered (", bytes =", gdb_stdlog
);
1852 for (i
= 0; i
< retval
; i
++)
1854 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1855 fprintf_unfiltered (gdb_stdlog
, "\n");
1856 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1860 fputc_unfiltered ('\n', gdb_stdlog
);
1866 debug_to_files_info (struct target_ops
*target
)
1868 debug_target
.to_files_info (target
);
1870 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
1874 debug_to_insert_breakpoint (CORE_ADDR addr
, char *save
)
1878 retval
= debug_target
.to_insert_breakpoint (addr
, save
);
1880 fprintf_unfiltered (gdb_stdlog
,
1881 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1882 (unsigned long) addr
,
1883 (unsigned long) retval
);
1888 debug_to_remove_breakpoint (CORE_ADDR addr
, char *save
)
1892 retval
= debug_target
.to_remove_breakpoint (addr
, save
);
1894 fprintf_unfiltered (gdb_stdlog
,
1895 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1896 (unsigned long) addr
,
1897 (unsigned long) retval
);
1902 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
1906 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
1908 fprintf_unfiltered (gdb_stdlog
,
1909 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1910 (unsigned long) type
,
1911 (unsigned long) cnt
,
1912 (unsigned long) from_tty
,
1913 (unsigned long) retval
);
1918 debug_to_region_size_ok_for_hw_watchpoint (int byte_count
)
1922 retval
= debug_target
.to_region_size_ok_for_hw_watchpoint (byte_count
);
1924 fprintf_unfiltered (gdb_stdlog
,
1925 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1926 (unsigned long) byte_count
,
1927 (unsigned long) retval
);
1932 debug_to_stopped_by_watchpoint (void)
1936 retval
= debug_target
.to_stopped_by_watchpoint ();
1938 fprintf_unfiltered (gdb_stdlog
,
1939 "STOPPED_BY_WATCHPOINT () = %ld\n",
1940 (unsigned long) retval
);
1945 debug_to_stopped_data_address (void)
1949 retval
= debug_target
.to_stopped_data_address ();
1951 fprintf_unfiltered (gdb_stdlog
,
1952 "target_stopped_data_address () = 0x%lx\n",
1953 (unsigned long) retval
);
1958 debug_to_insert_hw_breakpoint (CORE_ADDR addr
, char *save
)
1962 retval
= debug_target
.to_insert_hw_breakpoint (addr
, save
);
1964 fprintf_unfiltered (gdb_stdlog
,
1965 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1966 (unsigned long) addr
,
1967 (unsigned long) retval
);
1972 debug_to_remove_hw_breakpoint (CORE_ADDR addr
, char *save
)
1976 retval
= debug_target
.to_remove_hw_breakpoint (addr
, save
);
1978 fprintf_unfiltered (gdb_stdlog
,
1979 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1980 (unsigned long) addr
,
1981 (unsigned long) retval
);
1986 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
1990 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
1992 fprintf_unfiltered (gdb_stdlog
,
1993 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1994 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
1999 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2003 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2005 fprintf_unfiltered (gdb_stdlog
,
2006 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2007 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2012 debug_to_terminal_init (void)
2014 debug_target
.to_terminal_init ();
2016 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2020 debug_to_terminal_inferior (void)
2022 debug_target
.to_terminal_inferior ();
2024 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2028 debug_to_terminal_ours_for_output (void)
2030 debug_target
.to_terminal_ours_for_output ();
2032 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2036 debug_to_terminal_ours (void)
2038 debug_target
.to_terminal_ours ();
2040 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2044 debug_to_terminal_save_ours (void)
2046 debug_target
.to_terminal_save_ours ();
2048 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2052 debug_to_terminal_info (char *arg
, int from_tty
)
2054 debug_target
.to_terminal_info (arg
, from_tty
);
2056 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2061 debug_to_kill (void)
2063 debug_target
.to_kill ();
2065 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2069 debug_to_load (char *args
, int from_tty
)
2071 debug_target
.to_load (args
, from_tty
);
2073 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2077 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2081 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2083 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2089 debug_to_create_inferior (char *exec_file
, char *args
, char **env
)
2091 debug_target
.to_create_inferior (exec_file
, args
, env
);
2093 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx)\n",
2098 debug_to_post_startup_inferior (ptid_t ptid
)
2100 debug_target
.to_post_startup_inferior (ptid
);
2102 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2107 debug_to_acknowledge_created_inferior (int pid
)
2109 debug_target
.to_acknowledge_created_inferior (pid
);
2111 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2116 debug_to_insert_fork_catchpoint (int pid
)
2120 retval
= debug_target
.to_insert_fork_catchpoint (pid
);
2122 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d) = %d\n",
2129 debug_to_remove_fork_catchpoint (int pid
)
2133 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2135 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2142 debug_to_insert_vfork_catchpoint (int pid
)
2146 retval
= debug_target
.to_insert_vfork_catchpoint (pid
);
2148 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)= %d\n",
2155 debug_to_remove_vfork_catchpoint (int pid
)
2159 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2161 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2168 debug_to_follow_fork (int follow_child
)
2170 int retval
= debug_target
.to_follow_fork (follow_child
);
2172 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
2173 follow_child
, retval
);
2179 debug_to_insert_exec_catchpoint (int pid
)
2183 retval
= debug_target
.to_insert_exec_catchpoint (pid
);
2185 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d) = %d\n",
2192 debug_to_remove_exec_catchpoint (int pid
)
2196 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2198 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2205 debug_to_reported_exec_events_per_exec_call (void)
2207 int reported_exec_events
;
2209 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2211 fprintf_unfiltered (gdb_stdlog
,
2212 "target_reported_exec_events_per_exec_call () = %d\n",
2213 reported_exec_events
);
2215 return reported_exec_events
;
2219 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2223 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2225 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2226 pid
, wait_status
, *exit_status
, has_exited
);
2232 debug_to_mourn_inferior (void)
2234 debug_target
.to_mourn_inferior ();
2236 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2240 debug_to_can_run (void)
2244 retval
= debug_target
.to_can_run ();
2246 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2252 debug_to_notice_signals (ptid_t ptid
)
2254 debug_target
.to_notice_signals (ptid
);
2256 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2261 debug_to_thread_alive (ptid_t ptid
)
2265 retval
= debug_target
.to_thread_alive (ptid
);
2267 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2268 PIDGET (ptid
), retval
);
2274 debug_to_find_new_threads (void)
2276 debug_target
.to_find_new_threads ();
2278 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2282 debug_to_stop (void)
2284 debug_target
.to_stop ();
2286 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2290 debug_to_xfer_partial (struct target_ops
*ops
,
2291 enum target_object object
,
2292 const char *annex
, const void *writebuf
,
2293 void *readbuf
, ULONGEST offset
, LONGEST len
)
2297 retval
= debug_target
.to_xfer_partial (&debug_target
, object
, annex
,
2298 writebuf
, readbuf
, offset
, len
);
2300 fprintf_unfiltered (gdb_stdlog
,
2301 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
2302 (int) object
, (annex
? annex
: "(null)"),
2303 (long) writebuf
, (long) readbuf
, paddr_nz (offset
),
2304 paddr_d (len
), paddr_d (retval
));
2310 debug_to_rcmd (char *command
,
2311 struct ui_file
*outbuf
)
2313 debug_target
.to_rcmd (command
, outbuf
);
2314 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2317 static struct symtab_and_line
*
2318 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2320 struct symtab_and_line
*result
;
2321 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2322 fprintf_unfiltered (gdb_stdlog
,
2323 "target get_exception_callback_sal (%d, %d)\n",
2328 static struct exception_event_record
*
2329 debug_to_get_current_exception_event (void)
2331 struct exception_event_record
*result
;
2332 result
= debug_target
.to_get_current_exception_event ();
2333 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2338 debug_to_pid_to_exec_file (int pid
)
2342 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2344 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2351 setup_target_debug (void)
2353 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2355 current_target
.to_open
= debug_to_open
;
2356 current_target
.to_close
= debug_to_close
;
2357 current_target
.to_attach
= debug_to_attach
;
2358 current_target
.to_post_attach
= debug_to_post_attach
;
2359 current_target
.to_detach
= debug_to_detach
;
2360 current_target
.to_disconnect
= debug_to_disconnect
;
2361 current_target
.to_resume
= debug_to_resume
;
2362 current_target
.to_wait
= debug_to_wait
;
2363 current_target
.to_post_wait
= debug_to_post_wait
;
2364 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2365 current_target
.to_store_registers
= debug_to_store_registers
;
2366 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2367 current_target
.to_xfer_memory
= debug_to_xfer_memory
;
2368 current_target
.to_files_info
= debug_to_files_info
;
2369 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2370 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2371 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2372 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2373 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2374 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2375 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2376 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2377 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2378 current_target
.to_region_size_ok_for_hw_watchpoint
= debug_to_region_size_ok_for_hw_watchpoint
;
2379 current_target
.to_terminal_init
= debug_to_terminal_init
;
2380 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2381 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2382 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2383 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2384 current_target
.to_terminal_info
= debug_to_terminal_info
;
2385 current_target
.to_kill
= debug_to_kill
;
2386 current_target
.to_load
= debug_to_load
;
2387 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2388 current_target
.to_create_inferior
= debug_to_create_inferior
;
2389 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2390 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2391 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2392 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2393 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2394 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2395 current_target
.to_follow_fork
= debug_to_follow_fork
;
2396 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2397 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2398 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2399 current_target
.to_has_exited
= debug_to_has_exited
;
2400 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2401 current_target
.to_can_run
= debug_to_can_run
;
2402 current_target
.to_notice_signals
= debug_to_notice_signals
;
2403 current_target
.to_thread_alive
= debug_to_thread_alive
;
2404 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2405 current_target
.to_stop
= debug_to_stop
;
2406 current_target
.to_xfer_partial
= debug_to_xfer_partial
;
2407 current_target
.to_rcmd
= debug_to_rcmd
;
2408 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2409 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2410 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2415 static char targ_desc
[] =
2416 "Names of targets and files being debugged.\n\
2417 Shows the entire stack of targets currently in use (including the exec-file,\n\
2418 core-file, and process, if any), as well as the symbol file name.";
2421 do_monitor_command (char *cmd
,
2424 if ((current_target
.to_rcmd
2425 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2426 || (current_target
.to_rcmd
== debug_to_rcmd
2427 && (debug_target
.to_rcmd
2428 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2430 error ("\"monitor\" command not supported by this target.\n");
2432 target_rcmd (cmd
, gdb_stdtarg
);
2436 initialize_targets (void)
2438 init_dummy_target ();
2439 push_target (&dummy_target
);
2441 add_info ("target", target_info
, targ_desc
);
2442 add_info ("files", target_info
, targ_desc
);
2445 (add_set_cmd ("target", class_maintenance
, var_zinteger
,
2446 (char *) &targetdebug
,
2447 "Set target debugging.\n\
2448 When non-zero, target debugging is enabled.", &setdebuglist
),
2451 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2453 Set mode for reading from readonly sections.\n\
2454 When this mode is on, memory reads from readonly sections (such as .text)\n\
2455 will be read from the object file instead of from the target. This will\n\
2456 result in significant performance improvement for remote targets.", "\
2457 Show mode for reading from readonly sections.\n",
2459 &setlist
, &showlist
);
2461 add_com ("monitor", class_obscure
, do_monitor_command
,
2462 "Send a command to the remote monitor (remote targets only).");
2464 target_dcache
= dcache_init ();