1 /* Select target systems and architectures at runtime for GDB.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
5 Free Software Foundation, Inc.
7 Contributed by Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA. */
28 #include "gdb_string.h"
40 #include "gdb_assert.h"
43 static void target_info (char *, int);
45 static void maybe_kill_then_attach (char *, int);
47 static void kill_or_be_killed (int);
49 static void default_terminal_info (char *, int);
51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
53 static int nosymbol (char *, CORE_ADDR
*);
55 static void tcomplain (void) ATTR_NORETURN
;
57 static int nomemory (CORE_ADDR
, char *, int, int, struct target_ops
*);
59 static int return_zero (void);
61 static int return_one (void);
63 static int return_minus_one (void);
65 void target_ignore (void);
67 static void target_command (char *, int);
69 static struct target_ops
*find_default_run_target (char *);
71 static void nosupport_runtime (void);
73 static LONGEST
default_xfer_partial (struct target_ops
*ops
,
74 enum target_object object
,
75 const char *annex
, gdb_byte
*readbuf
,
76 const gdb_byte
*writebuf
,
77 ULONGEST offset
, LONGEST len
);
79 static LONGEST
current_xfer_partial (struct target_ops
*ops
,
80 enum target_object object
,
81 const char *annex
, gdb_byte
*readbuf
,
82 const gdb_byte
*writebuf
,
83 ULONGEST offset
, LONGEST len
);
85 static LONGEST
target_xfer_partial (struct target_ops
*ops
,
86 enum target_object object
,
88 void *readbuf
, const void *writebuf
,
89 ULONGEST offset
, LONGEST len
);
91 static void init_dummy_target (void);
93 static struct target_ops debug_target
;
95 static void debug_to_open (char *, int);
97 static void debug_to_close (int);
99 static void debug_to_attach (char *, int);
101 static void debug_to_detach (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 void debug_to_files_info (struct target_ops
*);
115 static int debug_to_insert_breakpoint (struct bp_target_info
*);
117 static int debug_to_remove_breakpoint (struct bp_target_info
*);
119 static int debug_to_can_use_hw_breakpoint (int, int, int);
121 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
123 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
125 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
127 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
129 static int debug_to_stopped_by_watchpoint (void);
131 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
133 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
135 static void debug_to_terminal_init (void);
137 static void debug_to_terminal_inferior (void);
139 static void debug_to_terminal_ours_for_output (void);
141 static void debug_to_terminal_save_ours (void);
143 static void debug_to_terminal_ours (void);
145 static void debug_to_terminal_info (char *, int);
147 static void debug_to_kill (void);
149 static void debug_to_load (char *, int);
151 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
153 static void debug_to_mourn_inferior (void);
155 static int debug_to_can_run (void);
157 static void debug_to_notice_signals (ptid_t
);
159 static int debug_to_thread_alive (ptid_t
);
161 static void debug_to_stop (void);
163 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
164 wierd and mysterious ways. Putting the variable here lets those
165 wierd and mysterious ways keep building while they are being
166 converted to the inferior inheritance structure. */
167 struct target_ops deprecated_child_ops
;
169 /* Pointer to array of target architecture structures; the size of the
170 array; the current index into the array; the allocated size of the
172 struct target_ops
**target_structs
;
173 unsigned target_struct_size
;
174 unsigned target_struct_index
;
175 unsigned target_struct_allocsize
;
176 #define DEFAULT_ALLOCSIZE 10
178 /* The initial current target, so that there is always a semi-valid
181 static struct target_ops dummy_target
;
183 /* Top of target stack. */
185 static struct target_ops
*target_stack
;
187 /* The target structure we are currently using to talk to a process
188 or file or whatever "inferior" we have. */
190 struct target_ops current_target
;
192 /* Command list for target. */
194 static struct cmd_list_element
*targetlist
= NULL
;
196 /* Nonzero if we are debugging an attached outside process
197 rather than an inferior. */
201 /* Nonzero if we should trust readonly sections from the
202 executable when reading memory. */
204 static int trust_readonly
= 0;
206 /* Non-zero if we want to see trace of target level stuff. */
208 static int targetdebug
= 0;
210 show_targetdebug (struct ui_file
*file
, int from_tty
,
211 struct cmd_list_element
*c
, const char *value
)
213 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
216 static void setup_target_debug (void);
218 DCACHE
*target_dcache
;
220 /* The user just typed 'target' without the name of a target. */
223 target_command (char *arg
, int from_tty
)
225 fputs_filtered ("Argument required (target name). Try `help target'\n",
229 /* Add a possible target architecture to the list. */
232 add_target (struct target_ops
*t
)
234 /* Provide default values for all "must have" methods. */
235 if (t
->to_xfer_partial
== NULL
)
236 t
->to_xfer_partial
= default_xfer_partial
;
240 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
241 target_structs
= (struct target_ops
**) xmalloc
242 (target_struct_allocsize
* sizeof (*target_structs
));
244 if (target_struct_size
>= target_struct_allocsize
)
246 target_struct_allocsize
*= 2;
247 target_structs
= (struct target_ops
**)
248 xrealloc ((char *) target_structs
,
249 target_struct_allocsize
* sizeof (*target_structs
));
251 target_structs
[target_struct_size
++] = t
;
253 if (targetlist
== NULL
)
254 add_prefix_cmd ("target", class_run
, target_command
, _("\
255 Connect to a target machine or process.\n\
256 The first argument is the type or protocol of the target machine.\n\
257 Remaining arguments are interpreted by the target protocol. For more\n\
258 information on the arguments for a particular protocol, type\n\
259 `help target ' followed by the protocol name."),
260 &targetlist
, "target ", 0, &cmdlist
);
261 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
272 target_load (char *arg
, int from_tty
)
274 dcache_invalidate (target_dcache
);
275 (*current_target
.to_load
) (arg
, from_tty
);
279 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
280 struct target_ops
*t
)
282 errno
= EIO
; /* Can't read/write this location */
283 return 0; /* No bytes handled */
289 error (_("You can't do that when your target is `%s'"),
290 current_target
.to_shortname
);
296 error (_("You can't do that without a process to debug."));
300 nosymbol (char *name
, CORE_ADDR
*addrp
)
302 return 1; /* Symbol does not exist in target env */
306 nosupport_runtime (void)
308 if (ptid_equal (inferior_ptid
, null_ptid
))
311 error (_("No run-time support for this"));
316 default_terminal_info (char *args
, int from_tty
)
318 printf_unfiltered (_("No saved terminal information.\n"));
321 /* This is the default target_create_inferior and target_attach function.
322 If the current target is executing, it asks whether to kill it off.
323 If this function returns without calling error(), it has killed off
324 the target, and the operation should be attempted. */
327 kill_or_be_killed (int from_tty
)
329 if (target_has_execution
)
331 printf_unfiltered (_("You are already running a program:\n"));
332 target_files_info ();
333 if (query ("Kill it? "))
336 if (target_has_execution
)
337 error (_("Killing the program did not help."));
342 error (_("Program not killed."));
349 maybe_kill_then_attach (char *args
, int from_tty
)
351 kill_or_be_killed (from_tty
);
352 target_attach (args
, from_tty
);
356 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
359 kill_or_be_killed (0);
360 target_create_inferior (exec
, args
, env
, from_tty
);
363 /* Go through the target stack from top to bottom, copying over zero
364 entries in current_target, then filling in still empty entries. In
365 effect, we are doing class inheritance through the pushed target
368 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
369 is currently implemented, is that it discards any knowledge of
370 which target an inherited method originally belonged to.
371 Consequently, new new target methods should instead explicitly and
372 locally search the target stack for the target that can handle the
376 update_current_target (void)
378 struct target_ops
*t
;
380 /* First, reset curren'ts contents. */
381 memset (¤t_target
, 0, sizeof (current_target
));
383 #define INHERIT(FIELD, TARGET) \
384 if (!current_target.FIELD) \
385 current_target.FIELD = (TARGET)->FIELD
387 for (t
= target_stack
; t
; t
= t
->beneath
)
389 INHERIT (to_shortname
, t
);
390 INHERIT (to_longname
, t
);
392 INHERIT (to_open
, t
);
393 INHERIT (to_close
, t
);
394 INHERIT (to_attach
, t
);
395 INHERIT (to_post_attach
, t
);
396 INHERIT (to_detach
, t
);
397 /* Do not inherit to_disconnect. */
398 INHERIT (to_resume
, t
);
399 INHERIT (to_wait
, t
);
400 INHERIT (to_fetch_registers
, t
);
401 INHERIT (to_store_registers
, t
);
402 INHERIT (to_prepare_to_store
, t
);
403 INHERIT (deprecated_xfer_memory
, t
);
404 INHERIT (to_files_info
, t
);
405 INHERIT (to_insert_breakpoint
, t
);
406 INHERIT (to_remove_breakpoint
, t
);
407 INHERIT (to_can_use_hw_breakpoint
, t
);
408 INHERIT (to_insert_hw_breakpoint
, t
);
409 INHERIT (to_remove_hw_breakpoint
, t
);
410 INHERIT (to_insert_watchpoint
, t
);
411 INHERIT (to_remove_watchpoint
, t
);
412 INHERIT (to_stopped_data_address
, t
);
413 INHERIT (to_stopped_by_watchpoint
, t
);
414 INHERIT (to_have_continuable_watchpoint
, t
);
415 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
416 INHERIT (to_terminal_init
, t
);
417 INHERIT (to_terminal_inferior
, t
);
418 INHERIT (to_terminal_ours_for_output
, t
);
419 INHERIT (to_terminal_ours
, t
);
420 INHERIT (to_terminal_save_ours
, t
);
421 INHERIT (to_terminal_info
, t
);
422 INHERIT (to_kill
, t
);
423 INHERIT (to_load
, t
);
424 INHERIT (to_lookup_symbol
, t
);
425 INHERIT (to_create_inferior
, t
);
426 INHERIT (to_post_startup_inferior
, t
);
427 INHERIT (to_acknowledge_created_inferior
, t
);
428 INHERIT (to_insert_fork_catchpoint
, t
);
429 INHERIT (to_remove_fork_catchpoint
, t
);
430 INHERIT (to_insert_vfork_catchpoint
, t
);
431 INHERIT (to_remove_vfork_catchpoint
, t
);
432 /* Do not inherit to_follow_fork. */
433 INHERIT (to_insert_exec_catchpoint
, t
);
434 INHERIT (to_remove_exec_catchpoint
, t
);
435 INHERIT (to_reported_exec_events_per_exec_call
, t
);
436 INHERIT (to_has_exited
, t
);
437 INHERIT (to_mourn_inferior
, t
);
438 INHERIT (to_can_run
, t
);
439 INHERIT (to_notice_signals
, t
);
440 INHERIT (to_thread_alive
, t
);
441 INHERIT (to_find_new_threads
, t
);
442 INHERIT (to_pid_to_str
, t
);
443 INHERIT (to_extra_thread_info
, t
);
444 INHERIT (to_stop
, t
);
445 /* Do not inherit to_xfer_partial. */
446 INHERIT (to_rcmd
, t
);
447 INHERIT (to_enable_exception_callback
, t
);
448 INHERIT (to_get_current_exception_event
, t
);
449 INHERIT (to_pid_to_exec_file
, t
);
450 INHERIT (to_stratum
, t
);
451 INHERIT (to_has_all_memory
, t
);
452 INHERIT (to_has_memory
, t
);
453 INHERIT (to_has_stack
, t
);
454 INHERIT (to_has_registers
, t
);
455 INHERIT (to_has_execution
, t
);
456 INHERIT (to_has_thread_control
, t
);
457 INHERIT (to_sections
, t
);
458 INHERIT (to_sections_end
, t
);
459 INHERIT (to_can_async_p
, t
);
460 INHERIT (to_is_async_p
, t
);
461 INHERIT (to_async
, t
);
462 INHERIT (to_async_mask_value
, t
);
463 INHERIT (to_find_memory_regions
, t
);
464 INHERIT (to_make_corefile_notes
, t
);
465 INHERIT (to_get_thread_local_address
, t
);
466 INHERIT (to_magic
, t
);
467 /* Do not inherit to_memory_map. */
468 /* Do not inherit to_flash_erase. */
469 /* Do not inherit to_flash_done. */
473 /* Clean up a target struct so it no longer has any zero pointers in
474 it. Some entries are defaulted to a method that print an error,
475 others are hard-wired to a standard recursive default. */
477 #define de_fault(field, value) \
478 if (!current_target.field) \
479 current_target.field = value
482 (void (*) (char *, int))
488 maybe_kill_then_attach
);
489 de_fault (to_post_attach
,
493 (void (*) (char *, int))
496 (void (*) (ptid_t
, int, enum target_signal
))
499 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
501 de_fault (to_fetch_registers
,
504 de_fault (to_store_registers
,
507 de_fault (to_prepare_to_store
,
510 de_fault (deprecated_xfer_memory
,
511 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
513 de_fault (to_files_info
,
514 (void (*) (struct target_ops
*))
516 de_fault (to_insert_breakpoint
,
517 memory_insert_breakpoint
);
518 de_fault (to_remove_breakpoint
,
519 memory_remove_breakpoint
);
520 de_fault (to_can_use_hw_breakpoint
,
521 (int (*) (int, int, int))
523 de_fault (to_insert_hw_breakpoint
,
524 (int (*) (struct bp_target_info
*))
526 de_fault (to_remove_hw_breakpoint
,
527 (int (*) (struct bp_target_info
*))
529 de_fault (to_insert_watchpoint
,
530 (int (*) (CORE_ADDR
, int, int))
532 de_fault (to_remove_watchpoint
,
533 (int (*) (CORE_ADDR
, int, int))
535 de_fault (to_stopped_by_watchpoint
,
538 de_fault (to_stopped_data_address
,
539 (int (*) (struct target_ops
*, CORE_ADDR
*))
541 de_fault (to_region_ok_for_hw_watchpoint
,
542 default_region_ok_for_hw_watchpoint
);
543 de_fault (to_terminal_init
,
546 de_fault (to_terminal_inferior
,
549 de_fault (to_terminal_ours_for_output
,
552 de_fault (to_terminal_ours
,
555 de_fault (to_terminal_save_ours
,
558 de_fault (to_terminal_info
,
559 default_terminal_info
);
564 (void (*) (char *, int))
566 de_fault (to_lookup_symbol
,
567 (int (*) (char *, CORE_ADDR
*))
569 de_fault (to_create_inferior
,
570 maybe_kill_then_create_inferior
);
571 de_fault (to_post_startup_inferior
,
574 de_fault (to_acknowledge_created_inferior
,
577 de_fault (to_insert_fork_catchpoint
,
580 de_fault (to_remove_fork_catchpoint
,
583 de_fault (to_insert_vfork_catchpoint
,
586 de_fault (to_remove_vfork_catchpoint
,
589 de_fault (to_insert_exec_catchpoint
,
592 de_fault (to_remove_exec_catchpoint
,
595 de_fault (to_reported_exec_events_per_exec_call
,
598 de_fault (to_has_exited
,
599 (int (*) (int, int, int *))
601 de_fault (to_mourn_inferior
,
604 de_fault (to_can_run
,
606 de_fault (to_notice_signals
,
609 de_fault (to_thread_alive
,
612 de_fault (to_find_new_threads
,
615 de_fault (to_extra_thread_info
,
616 (char *(*) (struct thread_info
*))
621 current_target
.to_xfer_partial
= current_xfer_partial
;
623 (void (*) (char *, struct ui_file
*))
625 de_fault (to_enable_exception_callback
,
626 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
628 de_fault (to_get_current_exception_event
,
629 (struct exception_event_record
* (*) (void))
631 de_fault (to_pid_to_exec_file
,
634 de_fault (to_can_async_p
,
637 de_fault (to_is_async_p
,
641 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
645 /* Finally, position the target-stack beneath the squashed
646 "current_target". That way code looking for a non-inherited
647 target method can quickly and simply find it. */
648 current_target
.beneath
= target_stack
;
651 /* Push a new target type into the stack of the existing target accessors,
652 possibly superseding some of the existing accessors.
654 Result is zero if the pushed target ended up on top of the stack,
655 nonzero if at least one target is on top of it.
657 Rather than allow an empty stack, we always have the dummy target at
658 the bottom stratum, so we can call the function vectors without
662 push_target (struct target_ops
*t
)
664 struct target_ops
**cur
;
666 /* Check magic number. If wrong, it probably means someone changed
667 the struct definition, but not all the places that initialize one. */
668 if (t
->to_magic
!= OPS_MAGIC
)
670 fprintf_unfiltered (gdb_stderr
,
671 "Magic number of %s target struct wrong\n",
673 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
676 /* Find the proper stratum to install this target in. */
677 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
679 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
683 /* If there's already targets at this stratum, remove them. */
684 /* FIXME: cagney/2003-10-15: I think this should be popping all
685 targets to CUR, and not just those at this stratum level. */
686 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
688 /* There's already something at this stratum level. Close it,
689 and un-hook it from the stack. */
690 struct target_ops
*tmp
= (*cur
);
691 (*cur
) = (*cur
)->beneath
;
693 target_close (tmp
, 0);
696 /* We have removed all targets in our stratum, now add the new one. */
700 update_current_target ();
703 setup_target_debug ();
706 return (t
!= target_stack
);
709 /* Remove a target_ops vector from the stack, wherever it may be.
710 Return how many times it was removed (0 or 1). */
713 unpush_target (struct target_ops
*t
)
715 struct target_ops
**cur
;
716 struct target_ops
*tmp
;
718 /* Look for the specified target. Note that we assume that a target
719 can only occur once in the target stack. */
721 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
728 return 0; /* Didn't find target_ops, quit now */
730 /* NOTE: cagney/2003-12-06: In '94 the close call was made
731 unconditional by moving it to before the above check that the
732 target was in the target stack (something about "Change the way
733 pushing and popping of targets work to support target overlays
734 and inheritance"). This doesn't make much sense - only open
735 targets should be closed. */
738 /* Unchain the target */
740 (*cur
) = (*cur
)->beneath
;
743 update_current_target ();
751 target_close (¤t_target
, 0); /* Let it clean up */
752 if (unpush_target (target_stack
) == 1)
755 fprintf_unfiltered (gdb_stderr
,
756 "pop_target couldn't find target %s\n",
757 current_target
.to_shortname
);
758 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
762 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
764 /* target_read_string -- read a null terminated string, up to LEN bytes,
765 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
766 Set *STRING to a pointer to malloc'd memory containing the data; the caller
767 is responsible for freeing it. Return the number of bytes successfully
771 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
773 int tlen
, origlen
, offset
, i
;
777 int buffer_allocated
;
779 unsigned int nbytes_read
= 0;
781 /* Small for testing. */
782 buffer_allocated
= 4;
783 buffer
= xmalloc (buffer_allocated
);
790 tlen
= MIN (len
, 4 - (memaddr
& 3));
791 offset
= memaddr
& 3;
793 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
796 /* The transfer request might have crossed the boundary to an
797 unallocated region of memory. Retry the transfer, requesting
801 errcode
= target_read_memory (memaddr
, buf
, 1);
806 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
809 bytes
= bufptr
- buffer
;
810 buffer_allocated
*= 2;
811 buffer
= xrealloc (buffer
, buffer_allocated
);
812 bufptr
= buffer
+ bytes
;
815 for (i
= 0; i
< tlen
; i
++)
817 *bufptr
++ = buf
[i
+ offset
];
818 if (buf
[i
+ offset
] == '\000')
820 nbytes_read
+= i
+ 1;
837 /* Find a section containing ADDR. */
838 struct section_table
*
839 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
841 struct section_table
*secp
;
842 for (secp
= target
->to_sections
;
843 secp
< target
->to_sections_end
;
846 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
852 /* Perform a partial memory transfer. The arguments and return
853 value are just as for target_xfer_partial. */
856 memory_xfer_partial (struct target_ops
*ops
, void *readbuf
, const void *writebuf
,
857 ULONGEST memaddr
, LONGEST len
)
861 struct mem_region
*region
;
863 /* Zero length requests are ok and require no work. */
867 /* Try the executable file, if "trust-readonly-sections" is set. */
868 if (readbuf
!= NULL
&& trust_readonly
)
870 struct section_table
*secp
;
872 secp
= target_section_by_addr (ops
, memaddr
);
874 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
876 return xfer_memory (memaddr
, readbuf
, len
, 0, NULL
, ops
);
879 /* Try GDB's internal data cache. */
880 region
= lookup_mem_region (memaddr
);
881 if (memaddr
+ len
< region
->hi
)
884 reg_len
= region
->hi
- memaddr
;
886 switch (region
->attrib
.mode
)
889 if (writebuf
!= NULL
)
899 /* We only support writing to flash during "load" for now. */
900 if (writebuf
!= NULL
)
901 error (_("Writing to flash memory forbidden in this context"));
905 if (region
->attrib
.cache
)
907 /* FIXME drow/2006-08-09: This call discards OPS, so the raw
908 memory request will start back at current_target. */
910 res
= dcache_xfer_memory (target_dcache
, memaddr
, readbuf
,
913 /* FIXME drow/2006-08-09: If we're going to preserve const
914 correctness dcache_xfer_memory should take readbuf and
916 res
= dcache_xfer_memory (target_dcache
, memaddr
,
925 /* If none of those methods found the memory we wanted, fall back
926 to a target partial transfer. Normally a single call to
927 to_xfer_partial is enough; if it doesn't recognize an object
928 it will call the to_xfer_partial of the next target down.
929 But for memory this won't do. Memory is the only target
930 object which can be read from more than one valid target.
931 A core file, for instance, could have some of memory but
932 delegate other bits to the target below it. So, we must
933 manually try all targets. */
937 res
= ops
->to_xfer_partial (ops
, TARGET_OBJECT_MEMORY
, NULL
,
938 readbuf
, writebuf
, memaddr
, len
);
946 /* If we still haven't got anything, return the last error. We
952 target_xfer_partial (struct target_ops
*ops
,
953 enum target_object object
, const char *annex
,
954 void *readbuf
, const void *writebuf
,
955 ULONGEST offset
, LONGEST len
)
959 gdb_assert (ops
->to_xfer_partial
!= NULL
);
961 /* If this is a memory transfer, let the memory-specific code
962 have a look at it instead. Memory transfers are more
964 if (object
== TARGET_OBJECT_MEMORY
)
965 retval
= memory_xfer_partial (ops
, readbuf
, writebuf
, offset
, len
);
968 enum target_object raw_object
= object
;
970 /* If this is a raw memory transfer, request the normal
971 memory object from other layers. */
972 if (raw_object
== TARGET_OBJECT_RAW_MEMORY
)
973 raw_object
= TARGET_OBJECT_MEMORY
;
975 retval
= ops
->to_xfer_partial (ops
, raw_object
, annex
, readbuf
,
976 writebuf
, offset
, len
);
981 const unsigned char *myaddr
= NULL
;
983 fprintf_unfiltered (gdb_stdlog
,
984 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
987 (annex
? annex
: "(null)"),
988 (long) readbuf
, (long) writebuf
,
989 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
995 if (retval
> 0 && myaddr
!= NULL
)
999 fputs_unfiltered (", bytes =", gdb_stdlog
);
1000 for (i
= 0; i
< retval
; i
++)
1002 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
1004 if (targetdebug
< 2 && i
> 0)
1006 fprintf_unfiltered (gdb_stdlog
, " ...");
1009 fprintf_unfiltered (gdb_stdlog
, "\n");
1012 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
1016 fputc_unfiltered ('\n', gdb_stdlog
);
1021 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1022 GDB's memory at MYADDR. Returns either 0 for success or an errno value
1023 if any error occurs.
1025 If an error occurs, no guarantee is made about the contents of the data at
1026 MYADDR. In particular, the caller should not depend upon partial reads
1027 filling the buffer with good data. There is no way for the caller to know
1028 how much good data might have been transfered anyway. Callers that can
1029 deal with partial reads should call target_read (which will retry until
1030 it makes no progress, and then return how much was transferred). */
1033 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
1035 if (target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1036 myaddr
, memaddr
, len
) == len
)
1043 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1045 if (target_write (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
1046 myaddr
, memaddr
, len
) == len
)
1052 /* Fetch the target's memory map. */
1055 target_memory_map (void)
1057 VEC(mem_region_s
) *result
;
1058 struct mem_region
*last_one
, *this_one
;
1060 struct target_ops
*t
;
1063 fprintf_unfiltered (gdb_stdlog
, "target_memory_map ()\n");
1065 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1066 if (t
->to_memory_map
!= NULL
)
1072 result
= t
->to_memory_map (t
);
1076 qsort (VEC_address (mem_region_s
, result
),
1077 VEC_length (mem_region_s
, result
),
1078 sizeof (struct mem_region
), mem_region_cmp
);
1080 /* Check that regions do not overlap. Simultaneously assign
1081 a numbering for the "mem" commands to use to refer to
1084 for (ix
= 0; VEC_iterate (mem_region_s
, result
, ix
, this_one
); ix
++)
1086 this_one
->number
= ix
;
1088 if (last_one
&& last_one
->hi
> this_one
->lo
)
1090 warning (_("Overlapping regions in memory map: ignoring"));
1091 VEC_free (mem_region_s
, result
);
1094 last_one
= this_one
;
1101 target_flash_erase (ULONGEST address
, LONGEST length
)
1103 struct target_ops
*t
;
1105 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1106 if (t
->to_flash_erase
!= NULL
)
1109 fprintf_unfiltered (gdb_stdlog
, "target_flash_erase (%s, %s)\n",
1110 paddr (address
), phex (length
, 0));
1111 return t
->to_flash_erase (t
, address
, length
);
1118 target_flash_done (void)
1120 struct target_ops
*t
;
1122 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1123 if (t
->to_flash_done
!= NULL
)
1126 fprintf_unfiltered (gdb_stdlog
, "target_flash_done\n");
1127 return t
->to_flash_done (t
);
1133 #ifndef target_stopped_data_address_p
1135 target_stopped_data_address_p (struct target_ops
*target
)
1137 if (target
->to_stopped_data_address
1138 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1140 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1141 && (debug_target
.to_stopped_data_address
1142 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1149 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1150 struct cmd_list_element
*c
, const char *value
)
1152 fprintf_filtered (file
, _("\
1153 Mode for reading from readonly sections is %s.\n"),
1157 /* More generic transfers. */
1160 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1161 const char *annex
, gdb_byte
*readbuf
,
1162 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1164 if (object
== TARGET_OBJECT_MEMORY
1165 && ops
->deprecated_xfer_memory
!= NULL
)
1166 /* If available, fall back to the target's
1167 "deprecated_xfer_memory" method. */
1171 if (writebuf
!= NULL
)
1173 void *buffer
= xmalloc (len
);
1174 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1175 memcpy (buffer
, writebuf
, len
);
1176 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1177 1/*write*/, NULL
, ops
);
1178 do_cleanups (cleanup
);
1180 if (readbuf
!= NULL
)
1181 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1185 else if (xfered
== 0 && errno
== 0)
1186 /* "deprecated_xfer_memory" uses 0, cross checked against
1187 ERRNO as one indication of an error. */
1192 else if (ops
->beneath
!= NULL
)
1193 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1194 readbuf
, writebuf
, offset
, len
);
1199 /* The xfer_partial handler for the topmost target. Unlike the default,
1200 it does not need to handle memory specially; it just passes all
1201 requests down the stack. */
1204 current_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1205 const char *annex
, gdb_byte
*readbuf
,
1206 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1208 if (ops
->beneath
!= NULL
)
1209 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
1210 readbuf
, writebuf
, offset
, len
);
1215 /* Target vector read/write partial wrapper functions.
1217 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1218 (inbuf, outbuf)", instead of separate read/write methods, make life
1222 target_read_partial (struct target_ops
*ops
,
1223 enum target_object object
,
1224 const char *annex
, gdb_byte
*buf
,
1225 ULONGEST offset
, LONGEST len
)
1227 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1231 target_write_partial (struct target_ops
*ops
,
1232 enum target_object object
,
1233 const char *annex
, const gdb_byte
*buf
,
1234 ULONGEST offset
, LONGEST len
)
1236 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1239 /* Wrappers to perform the full transfer. */
1241 target_read (struct target_ops
*ops
,
1242 enum target_object object
,
1243 const char *annex
, gdb_byte
*buf
,
1244 ULONGEST offset
, LONGEST len
)
1247 while (xfered
< len
)
1249 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1250 (gdb_byte
*) buf
+ xfered
,
1251 offset
+ xfered
, len
- xfered
);
1252 /* Call an observer, notifying them of the xfer progress? */
1263 /* An alternative to target_write with progress callbacks. */
1266 target_write_with_progress (struct target_ops
*ops
,
1267 enum target_object object
,
1268 const char *annex
, const gdb_byte
*buf
,
1269 ULONGEST offset
, LONGEST len
,
1270 void (*progress
) (ULONGEST
, void *), void *baton
)
1274 /* Give the progress callback a chance to set up. */
1276 (*progress
) (0, baton
);
1278 while (xfered
< len
)
1280 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1281 (gdb_byte
*) buf
+ xfered
,
1282 offset
+ xfered
, len
- xfered
);
1290 (*progress
) (xfer
, baton
);
1299 target_write (struct target_ops
*ops
,
1300 enum target_object object
,
1301 const char *annex
, const gdb_byte
*buf
,
1302 ULONGEST offset
, LONGEST len
)
1304 return target_write_with_progress (ops
, object
, annex
, buf
, offset
, len
,
1308 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1309 the size of the transferred data. PADDING additional bytes are
1310 available in *BUF_P. This is a helper function for
1311 target_read_alloc; see the declaration of that function for more
1315 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1316 const char *annex
, gdb_byte
**buf_p
, int padding
)
1318 size_t buf_alloc
, buf_pos
;
1322 /* This function does not have a length parameter; it reads the
1323 entire OBJECT). Also, it doesn't support objects fetched partly
1324 from one target and partly from another (in a different stratum,
1325 e.g. a core file and an executable). Both reasons make it
1326 unsuitable for reading memory. */
1327 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1329 /* Start by reading up to 4K at a time. The target will throttle
1330 this number down if necessary. */
1332 buf
= xmalloc (buf_alloc
);
1336 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1337 buf_pos
, buf_alloc
- buf_pos
- padding
);
1340 /* An error occurred. */
1346 /* Read all there was. */
1356 /* If the buffer is filling up, expand it. */
1357 if (buf_alloc
< buf_pos
* 2)
1360 buf
= xrealloc (buf
, buf_alloc
);
1367 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1368 the size of the transferred data. See the declaration in "target.h"
1369 function for more information about the return value. */
1372 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1373 const char *annex
, gdb_byte
**buf_p
)
1375 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1378 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1379 returned as a string, allocated using xmalloc. If an error occurs
1380 or the transfer is unsupported, NULL is returned. Empty objects
1381 are returned as allocated but empty strings. A warning is issued
1382 if the result contains any embedded NUL bytes. */
1385 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1389 LONGEST transferred
;
1391 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1393 if (transferred
< 0)
1396 if (transferred
== 0)
1397 return xstrdup ("");
1399 buffer
[transferred
] = 0;
1400 if (strlen (buffer
) < transferred
)
1401 warning (_("target object %d, annex %s, "
1402 "contained unexpected null characters"),
1403 (int) object
, annex
? annex
: "(none)");
1405 return (char *) buffer
;
1408 /* Memory transfer methods. */
1411 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1414 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1416 memory_error (EIO
, addr
);
1420 get_target_memory_unsigned (struct target_ops
*ops
,
1421 CORE_ADDR addr
, int len
)
1423 gdb_byte buf
[sizeof (ULONGEST
)];
1425 gdb_assert (len
<= sizeof (buf
));
1426 get_target_memory (ops
, addr
, buf
, len
);
1427 return extract_unsigned_integer (buf
, len
);
1431 target_info (char *args
, int from_tty
)
1433 struct target_ops
*t
;
1434 int has_all_mem
= 0;
1436 if (symfile_objfile
!= NULL
)
1437 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1439 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1441 if (!t
->to_has_memory
)
1444 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1447 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1448 printf_unfiltered ("%s:\n", t
->to_longname
);
1449 (t
->to_files_info
) (t
);
1450 has_all_mem
= t
->to_has_all_memory
;
1454 /* This function is called before any new inferior is created, e.g.
1455 by running a program, attaching, or connecting to a target.
1456 It cleans up any state from previous invocations which might
1457 change between runs. This is a subset of what target_preopen
1458 resets (things which might change between targets). */
1461 target_pre_inferior (int from_tty
)
1463 invalidate_target_mem_regions ();
1466 /* This is to be called by the open routine before it does
1470 target_preopen (int from_tty
)
1474 if (target_has_execution
)
1477 || query (_("A program is being debugged already. Kill it? ")))
1480 error (_("Program not killed."));
1483 /* Calling target_kill may remove the target from the stack. But if
1484 it doesn't (which seems like a win for UDI), remove it now. */
1486 if (target_has_execution
)
1489 target_pre_inferior (from_tty
);
1492 /* Detach a target after doing deferred register stores. */
1495 target_detach (char *args
, int from_tty
)
1497 (current_target
.to_detach
) (args
, from_tty
);
1501 target_disconnect (char *args
, int from_tty
)
1503 struct target_ops
*t
;
1505 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1506 if (t
->to_disconnect
!= NULL
)
1509 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1511 t
->to_disconnect (t
, args
, from_tty
);
1519 target_async_mask (int mask
)
1521 int saved_async_masked_status
= target_async_mask_value
;
1522 target_async_mask_value
= mask
;
1523 return saved_async_masked_status
;
1526 /* Look through the list of possible targets for a target that can
1530 target_follow_fork (int follow_child
)
1532 struct target_ops
*t
;
1534 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1536 if (t
->to_follow_fork
!= NULL
)
1538 int retval
= t
->to_follow_fork (t
, follow_child
);
1540 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1541 follow_child
, retval
);
1546 /* Some target returned a fork event, but did not know how to follow it. */
1547 internal_error (__FILE__
, __LINE__
,
1548 "could not find a target to follow fork");
1551 /* Look through the list of possible targets for a target that can
1552 execute a run or attach command without any other data. This is
1553 used to locate the default process stratum.
1555 Result is always valid (error() is called for errors). */
1557 static struct target_ops
*
1558 find_default_run_target (char *do_mesg
)
1560 struct target_ops
**t
;
1561 struct target_ops
*runable
= NULL
;
1566 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1569 if ((*t
)->to_can_run
&& target_can_run (*t
))
1577 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1583 find_default_attach (char *args
, int from_tty
)
1585 struct target_ops
*t
;
1587 t
= find_default_run_target ("attach");
1588 (t
->to_attach
) (args
, from_tty
);
1593 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1596 struct target_ops
*t
;
1598 t
= find_default_run_target ("run");
1599 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1604 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1606 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1622 return_minus_one (void)
1628 * Resize the to_sections pointer. Also make sure that anyone that
1629 * was holding on to an old value of it gets updated.
1630 * Returns the old size.
1634 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1636 struct target_ops
**t
;
1637 struct section_table
*old_value
;
1640 old_value
= target
->to_sections
;
1642 if (target
->to_sections
)
1644 old_count
= target
->to_sections_end
- target
->to_sections
;
1645 target
->to_sections
= (struct section_table
*)
1646 xrealloc ((char *) target
->to_sections
,
1647 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1652 target
->to_sections
= (struct section_table
*)
1653 xmalloc ((sizeof (struct section_table
)) * num_added
);
1655 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1657 /* Check to see if anyone else was pointing to this structure.
1658 If old_value was null, then no one was. */
1662 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1665 if ((*t
)->to_sections
== old_value
)
1667 (*t
)->to_sections
= target
->to_sections
;
1668 (*t
)->to_sections_end
= target
->to_sections_end
;
1671 /* There is a flattened view of the target stack in current_target,
1672 so its to_sections pointer might also need updating. */
1673 if (current_target
.to_sections
== old_value
)
1675 current_target
.to_sections
= target
->to_sections
;
1676 current_target
.to_sections_end
= target
->to_sections_end
;
1684 /* Remove all target sections taken from ABFD.
1686 Scan the current target stack for targets whose section tables
1687 refer to sections from BFD, and remove those sections. We use this
1688 when we notice that the inferior has unloaded a shared object, for
1691 remove_target_sections (bfd
*abfd
)
1693 struct target_ops
**t
;
1695 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1697 struct section_table
*src
, *dest
;
1699 dest
= (*t
)->to_sections
;
1700 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1701 if (src
->bfd
!= abfd
)
1703 /* Keep this section. */
1704 if (dest
< src
) *dest
= *src
;
1708 /* If we've dropped any sections, resize the section table. */
1710 target_resize_to_sections (*t
, dest
- src
);
1717 /* Find a single runnable target in the stack and return it. If for
1718 some reason there is more than one, return NULL. */
1721 find_run_target (void)
1723 struct target_ops
**t
;
1724 struct target_ops
*runable
= NULL
;
1729 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1731 if ((*t
)->to_can_run
&& target_can_run (*t
))
1738 return (count
== 1 ? runable
: NULL
);
1741 /* Find a single core_stratum target in the list of targets and return it.
1742 If for some reason there is more than one, return NULL. */
1745 find_core_target (void)
1747 struct target_ops
**t
;
1748 struct target_ops
*runable
= NULL
;
1753 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1756 if ((*t
)->to_stratum
== core_stratum
)
1763 return (count
== 1 ? runable
: NULL
);
1767 * Find the next target down the stack from the specified target.
1771 find_target_beneath (struct target_ops
*t
)
1777 /* The inferior process has died. Long live the inferior! */
1780 generic_mourn_inferior (void)
1782 extern int show_breakpoint_hit_counts
;
1784 inferior_ptid
= null_ptid
;
1786 breakpoint_init_inferior (inf_exited
);
1787 registers_changed ();
1789 reopen_exec_file ();
1790 reinit_frame_cache ();
1792 /* It is confusing to the user for ignore counts to stick around
1793 from previous runs of the inferior. So clear them. */
1794 /* However, it is more confusing for the ignore counts to disappear when
1795 using hit counts. So don't clear them if we're counting hits. */
1796 if (!show_breakpoint_hit_counts
)
1797 breakpoint_clear_ignore_counts ();
1799 if (deprecated_detach_hook
)
1800 deprecated_detach_hook ();
1803 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1804 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1805 translation of that in OURSTATUS. */
1807 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1809 #ifdef CHILD_SPECIAL_WAITSTATUS
1810 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1811 if it wants to deal with hoststatus. */
1812 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1816 if (WIFEXITED (hoststatus
))
1818 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1819 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1821 else if (!WIFSTOPPED (hoststatus
))
1823 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1824 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1828 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1829 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1833 /* Returns zero to leave the inferior alone, one to interrupt it. */
1834 int (*target_activity_function
) (void);
1835 int target_activity_fd
;
1837 /* Convert a normal process ID to a string. Returns the string in a
1841 normal_pid_to_str (ptid_t ptid
)
1843 static char buf
[32];
1845 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1849 /* Error-catcher for target_find_memory_regions */
1850 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1852 error (_("No target."));
1856 /* Error-catcher for target_make_corefile_notes */
1857 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1859 error (_("No target."));
1863 /* Set up the handful of non-empty slots needed by the dummy target
1867 init_dummy_target (void)
1869 dummy_target
.to_shortname
= "None";
1870 dummy_target
.to_longname
= "None";
1871 dummy_target
.to_doc
= "";
1872 dummy_target
.to_attach
= find_default_attach
;
1873 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1874 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1875 dummy_target
.to_stratum
= dummy_stratum
;
1876 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1877 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1878 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1879 dummy_target
.to_magic
= OPS_MAGIC
;
1883 debug_to_open (char *args
, int from_tty
)
1885 debug_target
.to_open (args
, from_tty
);
1887 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1891 debug_to_close (int quitting
)
1893 target_close (&debug_target
, quitting
);
1894 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1898 target_close (struct target_ops
*targ
, int quitting
)
1900 if (targ
->to_xclose
!= NULL
)
1901 targ
->to_xclose (targ
, quitting
);
1902 else if (targ
->to_close
!= NULL
)
1903 targ
->to_close (quitting
);
1907 debug_to_attach (char *args
, int from_tty
)
1909 debug_target
.to_attach (args
, from_tty
);
1911 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
1916 debug_to_post_attach (int pid
)
1918 debug_target
.to_post_attach (pid
);
1920 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
1924 debug_to_detach (char *args
, int from_tty
)
1926 debug_target
.to_detach (args
, from_tty
);
1928 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
1932 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
1934 debug_target
.to_resume (ptid
, step
, siggnal
);
1936 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
1937 step
? "step" : "continue",
1938 target_signal_to_name (siggnal
));
1942 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1946 retval
= debug_target
.to_wait (ptid
, status
);
1948 fprintf_unfiltered (gdb_stdlog
,
1949 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
1951 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
1952 switch (status
->kind
)
1954 case TARGET_WAITKIND_EXITED
:
1955 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
1956 status
->value
.integer
);
1958 case TARGET_WAITKIND_STOPPED
:
1959 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
1960 target_signal_to_name (status
->value
.sig
));
1962 case TARGET_WAITKIND_SIGNALLED
:
1963 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
1964 target_signal_to_name (status
->value
.sig
));
1966 case TARGET_WAITKIND_LOADED
:
1967 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
1969 case TARGET_WAITKIND_FORKED
:
1970 fprintf_unfiltered (gdb_stdlog
, "forked\n");
1972 case TARGET_WAITKIND_VFORKED
:
1973 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
1975 case TARGET_WAITKIND_EXECD
:
1976 fprintf_unfiltered (gdb_stdlog
, "execd\n");
1978 case TARGET_WAITKIND_SPURIOUS
:
1979 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
1982 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
1990 debug_print_register (const char * func
, int regno
)
1992 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1993 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
1994 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
1995 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
1997 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2001 unsigned char buf
[MAX_REGISTER_SIZE
];
2002 deprecated_read_register_gen (regno
, buf
);
2003 fprintf_unfiltered (gdb_stdlog
, " = ");
2004 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
2006 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2008 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
2010 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2011 paddr_nz (read_register (regno
)),
2012 paddr_d (read_register (regno
)));
2015 fprintf_unfiltered (gdb_stdlog
, "\n");
2019 debug_to_fetch_registers (int regno
)
2021 debug_target
.to_fetch_registers (regno
);
2022 debug_print_register ("target_fetch_registers", regno
);
2026 debug_to_store_registers (int regno
)
2028 debug_target
.to_store_registers (regno
);
2029 debug_print_register ("target_store_registers", regno
);
2030 fprintf_unfiltered (gdb_stdlog
, "\n");
2034 debug_to_prepare_to_store (void)
2036 debug_target
.to_prepare_to_store ();
2038 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2042 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2043 int write
, struct mem_attrib
*attrib
,
2044 struct target_ops
*target
)
2048 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2051 fprintf_unfiltered (gdb_stdlog
,
2052 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2053 (unsigned int) memaddr
, /* possable truncate long long */
2054 len
, write
? "write" : "read", retval
);
2060 fputs_unfiltered (", bytes =", gdb_stdlog
);
2061 for (i
= 0; i
< retval
; i
++)
2063 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2065 if (targetdebug
< 2 && i
> 0)
2067 fprintf_unfiltered (gdb_stdlog
, " ...");
2070 fprintf_unfiltered (gdb_stdlog
, "\n");
2073 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2077 fputc_unfiltered ('\n', gdb_stdlog
);
2083 debug_to_files_info (struct target_ops
*target
)
2085 debug_target
.to_files_info (target
);
2087 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2091 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2095 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2097 fprintf_unfiltered (gdb_stdlog
,
2098 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2099 (unsigned long) bp_tgt
->placed_address
,
2100 (unsigned long) retval
);
2105 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2109 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2111 fprintf_unfiltered (gdb_stdlog
,
2112 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2113 (unsigned long) bp_tgt
->placed_address
,
2114 (unsigned long) retval
);
2119 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2123 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2125 fprintf_unfiltered (gdb_stdlog
,
2126 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2127 (unsigned long) type
,
2128 (unsigned long) cnt
,
2129 (unsigned long) from_tty
,
2130 (unsigned long) retval
);
2135 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2139 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2141 fprintf_unfiltered (gdb_stdlog
,
2142 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2143 (unsigned long) addr
,
2144 (unsigned long) len
,
2145 (unsigned long) retval
);
2150 debug_to_stopped_by_watchpoint (void)
2154 retval
= debug_target
.to_stopped_by_watchpoint ();
2156 fprintf_unfiltered (gdb_stdlog
,
2157 "STOPPED_BY_WATCHPOINT () = %ld\n",
2158 (unsigned long) retval
);
2163 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2167 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2169 fprintf_unfiltered (gdb_stdlog
,
2170 "target_stopped_data_address ([0x%lx]) = %ld\n",
2171 (unsigned long)*addr
,
2172 (unsigned long)retval
);
2177 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2181 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2183 fprintf_unfiltered (gdb_stdlog
,
2184 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2185 (unsigned long) bp_tgt
->placed_address
,
2186 (unsigned long) retval
);
2191 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2195 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2197 fprintf_unfiltered (gdb_stdlog
,
2198 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2199 (unsigned long) bp_tgt
->placed_address
,
2200 (unsigned long) retval
);
2205 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2209 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2211 fprintf_unfiltered (gdb_stdlog
,
2212 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2213 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2218 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2222 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2224 fprintf_unfiltered (gdb_stdlog
,
2225 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2226 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2231 debug_to_terminal_init (void)
2233 debug_target
.to_terminal_init ();
2235 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2239 debug_to_terminal_inferior (void)
2241 debug_target
.to_terminal_inferior ();
2243 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2247 debug_to_terminal_ours_for_output (void)
2249 debug_target
.to_terminal_ours_for_output ();
2251 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2255 debug_to_terminal_ours (void)
2257 debug_target
.to_terminal_ours ();
2259 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2263 debug_to_terminal_save_ours (void)
2265 debug_target
.to_terminal_save_ours ();
2267 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2271 debug_to_terminal_info (char *arg
, int from_tty
)
2273 debug_target
.to_terminal_info (arg
, from_tty
);
2275 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2280 debug_to_kill (void)
2282 debug_target
.to_kill ();
2284 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2288 debug_to_load (char *args
, int from_tty
)
2290 debug_target
.to_load (args
, from_tty
);
2292 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2296 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2300 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2302 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2308 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2311 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2313 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2314 exec_file
, args
, from_tty
);
2318 debug_to_post_startup_inferior (ptid_t ptid
)
2320 debug_target
.to_post_startup_inferior (ptid
);
2322 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2327 debug_to_acknowledge_created_inferior (int pid
)
2329 debug_target
.to_acknowledge_created_inferior (pid
);
2331 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2336 debug_to_insert_fork_catchpoint (int pid
)
2338 debug_target
.to_insert_fork_catchpoint (pid
);
2340 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2345 debug_to_remove_fork_catchpoint (int pid
)
2349 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2351 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2358 debug_to_insert_vfork_catchpoint (int pid
)
2360 debug_target
.to_insert_vfork_catchpoint (pid
);
2362 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2367 debug_to_remove_vfork_catchpoint (int pid
)
2371 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2373 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2380 debug_to_insert_exec_catchpoint (int pid
)
2382 debug_target
.to_insert_exec_catchpoint (pid
);
2384 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2389 debug_to_remove_exec_catchpoint (int pid
)
2393 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2395 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2402 debug_to_reported_exec_events_per_exec_call (void)
2404 int reported_exec_events
;
2406 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2408 fprintf_unfiltered (gdb_stdlog
,
2409 "target_reported_exec_events_per_exec_call () = %d\n",
2410 reported_exec_events
);
2412 return reported_exec_events
;
2416 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2420 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2422 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2423 pid
, wait_status
, *exit_status
, has_exited
);
2429 debug_to_mourn_inferior (void)
2431 debug_target
.to_mourn_inferior ();
2433 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2437 debug_to_can_run (void)
2441 retval
= debug_target
.to_can_run ();
2443 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2449 debug_to_notice_signals (ptid_t ptid
)
2451 debug_target
.to_notice_signals (ptid
);
2453 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2458 debug_to_thread_alive (ptid_t ptid
)
2462 retval
= debug_target
.to_thread_alive (ptid
);
2464 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2465 PIDGET (ptid
), retval
);
2471 debug_to_find_new_threads (void)
2473 debug_target
.to_find_new_threads ();
2475 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2479 debug_to_stop (void)
2481 debug_target
.to_stop ();
2483 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2487 debug_to_rcmd (char *command
,
2488 struct ui_file
*outbuf
)
2490 debug_target
.to_rcmd (command
, outbuf
);
2491 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2494 static struct symtab_and_line
*
2495 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2497 struct symtab_and_line
*result
;
2498 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2499 fprintf_unfiltered (gdb_stdlog
,
2500 "target get_exception_callback_sal (%d, %d)\n",
2505 static struct exception_event_record
*
2506 debug_to_get_current_exception_event (void)
2508 struct exception_event_record
*result
;
2509 result
= debug_target
.to_get_current_exception_event ();
2510 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2515 debug_to_pid_to_exec_file (int pid
)
2519 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2521 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2528 setup_target_debug (void)
2530 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2532 current_target
.to_open
= debug_to_open
;
2533 current_target
.to_close
= debug_to_close
;
2534 current_target
.to_attach
= debug_to_attach
;
2535 current_target
.to_post_attach
= debug_to_post_attach
;
2536 current_target
.to_detach
= debug_to_detach
;
2537 current_target
.to_resume
= debug_to_resume
;
2538 current_target
.to_wait
= debug_to_wait
;
2539 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2540 current_target
.to_store_registers
= debug_to_store_registers
;
2541 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2542 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2543 current_target
.to_files_info
= debug_to_files_info
;
2544 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2545 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2546 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2547 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2548 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2549 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2550 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2551 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2552 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2553 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2554 current_target
.to_terminal_init
= debug_to_terminal_init
;
2555 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2556 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2557 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2558 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2559 current_target
.to_terminal_info
= debug_to_terminal_info
;
2560 current_target
.to_kill
= debug_to_kill
;
2561 current_target
.to_load
= debug_to_load
;
2562 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2563 current_target
.to_create_inferior
= debug_to_create_inferior
;
2564 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2565 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2566 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2567 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2568 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2569 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2570 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2571 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2572 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2573 current_target
.to_has_exited
= debug_to_has_exited
;
2574 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2575 current_target
.to_can_run
= debug_to_can_run
;
2576 current_target
.to_notice_signals
= debug_to_notice_signals
;
2577 current_target
.to_thread_alive
= debug_to_thread_alive
;
2578 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2579 current_target
.to_stop
= debug_to_stop
;
2580 current_target
.to_rcmd
= debug_to_rcmd
;
2581 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2582 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2583 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2587 static char targ_desc
[] =
2588 "Names of targets and files being debugged.\n\
2589 Shows the entire stack of targets currently in use (including the exec-file,\n\
2590 core-file, and process, if any), as well as the symbol file name.";
2593 do_monitor_command (char *cmd
,
2596 if ((current_target
.to_rcmd
2597 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2598 || (current_target
.to_rcmd
== debug_to_rcmd
2599 && (debug_target
.to_rcmd
2600 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2601 error (_("\"monitor\" command not supported by this target."));
2602 target_rcmd (cmd
, gdb_stdtarg
);
2606 initialize_targets (void)
2608 init_dummy_target ();
2609 push_target (&dummy_target
);
2611 add_info ("target", target_info
, targ_desc
);
2612 add_info ("files", target_info
, targ_desc
);
2614 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2615 Set target debugging."), _("\
2616 Show target debugging."), _("\
2617 When non-zero, target debugging is enabled. Higher numbers are more\n\
2618 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2622 &setdebuglist
, &showdebuglist
);
2624 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2625 &trust_readonly
, _("\
2626 Set mode for reading from readonly sections."), _("\
2627 Show mode for reading from readonly sections."), _("\
2628 When this mode is on, memory reads from readonly sections (such as .text)\n\
2629 will be read from the object file instead of from the target. This will\n\
2630 result in significant performance improvement for remote targets."),
2632 show_trust_readonly
,
2633 &setlist
, &showlist
);
2635 add_com ("monitor", class_obscure
, do_monitor_command
,
2636 _("Send a command to the remote monitor (remote targets only)."));
2638 target_dcache
= dcache_init ();