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 /* Transfer LEN bytes between target address MEMADDR and GDB address
80 MYADDR. Returns 0 for success, errno code for failure (which
81 includes partial transfers -- if you want a more useful response to
82 partial transfers, try either target_read_memory_partial or
83 target_write_memory_partial). */
85 static int target_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
88 static void init_dummy_target (void);
90 static struct target_ops debug_target
;
92 static void debug_to_open (char *, int);
94 static void debug_to_close (int);
96 static void debug_to_attach (char *, int);
98 static void debug_to_detach (char *, int);
100 static void debug_to_resume (ptid_t
, int, enum target_signal
);
102 static ptid_t
debug_to_wait (ptid_t
, struct target_waitstatus
*);
104 static void debug_to_fetch_registers (int);
106 static void debug_to_store_registers (int);
108 static void debug_to_prepare_to_store (void);
110 static void debug_to_files_info (struct target_ops
*);
112 static int debug_to_insert_breakpoint (struct bp_target_info
*);
114 static int debug_to_remove_breakpoint (struct bp_target_info
*);
116 static int debug_to_can_use_hw_breakpoint (int, int, int);
118 static int debug_to_insert_hw_breakpoint (struct bp_target_info
*);
120 static int debug_to_remove_hw_breakpoint (struct bp_target_info
*);
122 static int debug_to_insert_watchpoint (CORE_ADDR
, int, int);
124 static int debug_to_remove_watchpoint (CORE_ADDR
, int, int);
126 static int debug_to_stopped_by_watchpoint (void);
128 static int debug_to_stopped_data_address (struct target_ops
*, CORE_ADDR
*);
130 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR
, int);
132 static void debug_to_terminal_init (void);
134 static void debug_to_terminal_inferior (void);
136 static void debug_to_terminal_ours_for_output (void);
138 static void debug_to_terminal_save_ours (void);
140 static void debug_to_terminal_ours (void);
142 static void debug_to_terminal_info (char *, int);
144 static void debug_to_kill (void);
146 static void debug_to_load (char *, int);
148 static int debug_to_lookup_symbol (char *, CORE_ADDR
*);
150 static void debug_to_mourn_inferior (void);
152 static int debug_to_can_run (void);
154 static void debug_to_notice_signals (ptid_t
);
156 static int debug_to_thread_alive (ptid_t
);
158 static void debug_to_stop (void);
160 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
161 wierd and mysterious ways. Putting the variable here lets those
162 wierd and mysterious ways keep building while they are being
163 converted to the inferior inheritance structure. */
164 struct target_ops deprecated_child_ops
;
166 /* Pointer to array of target architecture structures; the size of the
167 array; the current index into the array; the allocated size of the
169 struct target_ops
**target_structs
;
170 unsigned target_struct_size
;
171 unsigned target_struct_index
;
172 unsigned target_struct_allocsize
;
173 #define DEFAULT_ALLOCSIZE 10
175 /* The initial current target, so that there is always a semi-valid
178 static struct target_ops dummy_target
;
180 /* Top of target stack. */
182 static struct target_ops
*target_stack
;
184 /* The target structure we are currently using to talk to a process
185 or file or whatever "inferior" we have. */
187 struct target_ops current_target
;
189 /* Command list for target. */
191 static struct cmd_list_element
*targetlist
= NULL
;
193 /* Nonzero if we are debugging an attached outside process
194 rather than an inferior. */
198 /* Non-zero if we want to see trace of target level stuff. */
200 static int targetdebug
= 0;
202 show_targetdebug (struct ui_file
*file
, int from_tty
,
203 struct cmd_list_element
*c
, const char *value
)
205 fprintf_filtered (file
, _("Target debugging is %s.\n"), value
);
208 static void setup_target_debug (void);
210 DCACHE
*target_dcache
;
212 /* The user just typed 'target' without the name of a target. */
215 target_command (char *arg
, int from_tty
)
217 fputs_filtered ("Argument required (target name). Try `help target'\n",
221 /* Add a possible target architecture to the list. */
224 add_target (struct target_ops
*t
)
226 /* Provide default values for all "must have" methods. */
227 if (t
->to_xfer_partial
== NULL
)
228 t
->to_xfer_partial
= default_xfer_partial
;
232 target_struct_allocsize
= DEFAULT_ALLOCSIZE
;
233 target_structs
= (struct target_ops
**) xmalloc
234 (target_struct_allocsize
* sizeof (*target_structs
));
236 if (target_struct_size
>= target_struct_allocsize
)
238 target_struct_allocsize
*= 2;
239 target_structs
= (struct target_ops
**)
240 xrealloc ((char *) target_structs
,
241 target_struct_allocsize
* sizeof (*target_structs
));
243 target_structs
[target_struct_size
++] = t
;
245 if (targetlist
== NULL
)
246 add_prefix_cmd ("target", class_run
, target_command
, _("\
247 Connect to a target machine or process.\n\
248 The first argument is the type or protocol of the target machine.\n\
249 Remaining arguments are interpreted by the target protocol. For more\n\
250 information on the arguments for a particular protocol, type\n\
251 `help target ' followed by the protocol name."),
252 &targetlist
, "target ", 0, &cmdlist
);
253 add_cmd (t
->to_shortname
, no_class
, t
->to_open
, t
->to_doc
, &targetlist
);
264 target_load (char *arg
, int from_tty
)
266 dcache_invalidate (target_dcache
);
267 (*current_target
.to_load
) (arg
, from_tty
);
271 nomemory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
272 struct target_ops
*t
)
274 errno
= EIO
; /* Can't read/write this location */
275 return 0; /* No bytes handled */
281 error (_("You can't do that when your target is `%s'"),
282 current_target
.to_shortname
);
288 error (_("You can't do that without a process to debug."));
292 nosymbol (char *name
, CORE_ADDR
*addrp
)
294 return 1; /* Symbol does not exist in target env */
298 nosupport_runtime (void)
300 if (ptid_equal (inferior_ptid
, null_ptid
))
303 error (_("No run-time support for this"));
308 default_terminal_info (char *args
, int from_tty
)
310 printf_unfiltered (_("No saved terminal information.\n"));
313 /* This is the default target_create_inferior and target_attach function.
314 If the current target is executing, it asks whether to kill it off.
315 If this function returns without calling error(), it has killed off
316 the target, and the operation should be attempted. */
319 kill_or_be_killed (int from_tty
)
321 if (target_has_execution
)
323 printf_unfiltered (_("You are already running a program:\n"));
324 target_files_info ();
325 if (query ("Kill it? "))
328 if (target_has_execution
)
329 error (_("Killing the program did not help."));
334 error (_("Program not killed."));
341 maybe_kill_then_attach (char *args
, int from_tty
)
343 kill_or_be_killed (from_tty
);
344 target_attach (args
, from_tty
);
348 maybe_kill_then_create_inferior (char *exec
, char *args
, char **env
,
351 kill_or_be_killed (0);
352 target_create_inferior (exec
, args
, env
, from_tty
);
355 /* Go through the target stack from top to bottom, copying over zero
356 entries in current_target, then filling in still empty entries. In
357 effect, we are doing class inheritance through the pushed target
360 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
361 is currently implemented, is that it discards any knowledge of
362 which target an inherited method originally belonged to.
363 Consequently, new new target methods should instead explicitly and
364 locally search the target stack for the target that can handle the
368 update_current_target (void)
370 struct target_ops
*t
;
372 /* First, reset curren'ts contents. */
373 memset (¤t_target
, 0, sizeof (current_target
));
375 #define INHERIT(FIELD, TARGET) \
376 if (!current_target.FIELD) \
377 current_target.FIELD = (TARGET)->FIELD
379 for (t
= target_stack
; t
; t
= t
->beneath
)
381 INHERIT (to_shortname
, t
);
382 INHERIT (to_longname
, t
);
384 INHERIT (to_open
, t
);
385 INHERIT (to_close
, t
);
386 INHERIT (to_attach
, t
);
387 INHERIT (to_post_attach
, t
);
388 INHERIT (to_detach
, t
);
389 /* Do not inherit to_disconnect. */
390 INHERIT (to_resume
, t
);
391 INHERIT (to_wait
, t
);
392 INHERIT (to_fetch_registers
, t
);
393 INHERIT (to_store_registers
, t
);
394 INHERIT (to_prepare_to_store
, t
);
395 INHERIT (deprecated_xfer_memory
, t
);
396 INHERIT (to_files_info
, t
);
397 INHERIT (to_insert_breakpoint
, t
);
398 INHERIT (to_remove_breakpoint
, t
);
399 INHERIT (to_can_use_hw_breakpoint
, t
);
400 INHERIT (to_insert_hw_breakpoint
, t
);
401 INHERIT (to_remove_hw_breakpoint
, t
);
402 INHERIT (to_insert_watchpoint
, t
);
403 INHERIT (to_remove_watchpoint
, t
);
404 INHERIT (to_stopped_data_address
, t
);
405 INHERIT (to_stopped_by_watchpoint
, t
);
406 INHERIT (to_have_continuable_watchpoint
, t
);
407 INHERIT (to_region_ok_for_hw_watchpoint
, t
);
408 INHERIT (to_terminal_init
, t
);
409 INHERIT (to_terminal_inferior
, t
);
410 INHERIT (to_terminal_ours_for_output
, t
);
411 INHERIT (to_terminal_ours
, t
);
412 INHERIT (to_terminal_save_ours
, t
);
413 INHERIT (to_terminal_info
, t
);
414 INHERIT (to_kill
, t
);
415 INHERIT (to_load
, t
);
416 INHERIT (to_lookup_symbol
, t
);
417 INHERIT (to_create_inferior
, t
);
418 INHERIT (to_post_startup_inferior
, t
);
419 INHERIT (to_acknowledge_created_inferior
, t
);
420 INHERIT (to_insert_fork_catchpoint
, t
);
421 INHERIT (to_remove_fork_catchpoint
, t
);
422 INHERIT (to_insert_vfork_catchpoint
, t
);
423 INHERIT (to_remove_vfork_catchpoint
, t
);
424 /* Do not inherit to_follow_fork. */
425 INHERIT (to_insert_exec_catchpoint
, t
);
426 INHERIT (to_remove_exec_catchpoint
, t
);
427 INHERIT (to_reported_exec_events_per_exec_call
, t
);
428 INHERIT (to_has_exited
, t
);
429 INHERIT (to_mourn_inferior
, t
);
430 INHERIT (to_can_run
, t
);
431 INHERIT (to_notice_signals
, t
);
432 INHERIT (to_thread_alive
, t
);
433 INHERIT (to_find_new_threads
, t
);
434 INHERIT (to_pid_to_str
, t
);
435 INHERIT (to_extra_thread_info
, t
);
436 INHERIT (to_stop
, t
);
437 /* Do not inherit to_xfer_partial. */
438 INHERIT (to_rcmd
, t
);
439 INHERIT (to_enable_exception_callback
, t
);
440 INHERIT (to_get_current_exception_event
, t
);
441 INHERIT (to_pid_to_exec_file
, t
);
442 INHERIT (to_stratum
, t
);
443 INHERIT (to_has_all_memory
, t
);
444 INHERIT (to_has_memory
, t
);
445 INHERIT (to_has_stack
, t
);
446 INHERIT (to_has_registers
, t
);
447 INHERIT (to_has_execution
, t
);
448 INHERIT (to_has_thread_control
, t
);
449 INHERIT (to_sections
, t
);
450 INHERIT (to_sections_end
, t
);
451 INHERIT (to_can_async_p
, t
);
452 INHERIT (to_is_async_p
, t
);
453 INHERIT (to_async
, t
);
454 INHERIT (to_async_mask_value
, t
);
455 INHERIT (to_find_memory_regions
, t
);
456 INHERIT (to_make_corefile_notes
, t
);
457 INHERIT (to_get_thread_local_address
, t
);
458 INHERIT (to_magic
, t
);
462 /* Clean up a target struct so it no longer has any zero pointers in
463 it. Some entries are defaulted to a method that print an error,
464 others are hard-wired to a standard recursive default. */
466 #define de_fault(field, value) \
467 if (!current_target.field) \
468 current_target.field = value
471 (void (*) (char *, int))
477 maybe_kill_then_attach
);
478 de_fault (to_post_attach
,
482 (void (*) (char *, int))
485 (void (*) (ptid_t
, int, enum target_signal
))
488 (ptid_t (*) (ptid_t
, struct target_waitstatus
*))
490 de_fault (to_fetch_registers
,
493 de_fault (to_store_registers
,
496 de_fault (to_prepare_to_store
,
499 de_fault (deprecated_xfer_memory
,
500 (int (*) (CORE_ADDR
, gdb_byte
*, int, int, struct mem_attrib
*, struct target_ops
*))
502 de_fault (to_files_info
,
503 (void (*) (struct target_ops
*))
505 de_fault (to_insert_breakpoint
,
506 memory_insert_breakpoint
);
507 de_fault (to_remove_breakpoint
,
508 memory_remove_breakpoint
);
509 de_fault (to_can_use_hw_breakpoint
,
510 (int (*) (int, int, int))
512 de_fault (to_insert_hw_breakpoint
,
513 (int (*) (struct bp_target_info
*))
515 de_fault (to_remove_hw_breakpoint
,
516 (int (*) (struct bp_target_info
*))
518 de_fault (to_insert_watchpoint
,
519 (int (*) (CORE_ADDR
, int, int))
521 de_fault (to_remove_watchpoint
,
522 (int (*) (CORE_ADDR
, int, int))
524 de_fault (to_stopped_by_watchpoint
,
527 de_fault (to_stopped_data_address
,
528 (int (*) (struct target_ops
*, CORE_ADDR
*))
530 de_fault (to_region_ok_for_hw_watchpoint
,
531 default_region_ok_for_hw_watchpoint
);
532 de_fault (to_terminal_init
,
535 de_fault (to_terminal_inferior
,
538 de_fault (to_terminal_ours_for_output
,
541 de_fault (to_terminal_ours
,
544 de_fault (to_terminal_save_ours
,
547 de_fault (to_terminal_info
,
548 default_terminal_info
);
553 (void (*) (char *, int))
555 de_fault (to_lookup_symbol
,
556 (int (*) (char *, CORE_ADDR
*))
558 de_fault (to_create_inferior
,
559 maybe_kill_then_create_inferior
);
560 de_fault (to_post_startup_inferior
,
563 de_fault (to_acknowledge_created_inferior
,
566 de_fault (to_insert_fork_catchpoint
,
569 de_fault (to_remove_fork_catchpoint
,
572 de_fault (to_insert_vfork_catchpoint
,
575 de_fault (to_remove_vfork_catchpoint
,
578 de_fault (to_insert_exec_catchpoint
,
581 de_fault (to_remove_exec_catchpoint
,
584 de_fault (to_reported_exec_events_per_exec_call
,
587 de_fault (to_has_exited
,
588 (int (*) (int, int, int *))
590 de_fault (to_mourn_inferior
,
593 de_fault (to_can_run
,
595 de_fault (to_notice_signals
,
598 de_fault (to_thread_alive
,
601 de_fault (to_find_new_threads
,
604 de_fault (to_extra_thread_info
,
605 (char *(*) (struct thread_info
*))
610 current_target
.to_xfer_partial
= default_xfer_partial
;
612 (void (*) (char *, struct ui_file
*))
614 de_fault (to_enable_exception_callback
,
615 (struct symtab_and_line
* (*) (enum exception_event_kind
, int))
617 de_fault (to_get_current_exception_event
,
618 (struct exception_event_record
* (*) (void))
620 de_fault (to_pid_to_exec_file
,
623 de_fault (to_can_async_p
,
626 de_fault (to_is_async_p
,
630 (void (*) (void (*) (enum inferior_event_type
, void*), void*))
634 /* Finally, position the target-stack beneath the squashed
635 "current_target". That way code looking for a non-inherited
636 target method can quickly and simply find it. */
637 current_target
.beneath
= target_stack
;
640 /* Push a new target type into the stack of the existing target accessors,
641 possibly superseding some of the existing accessors.
643 Result is zero if the pushed target ended up on top of the stack,
644 nonzero if at least one target is on top of it.
646 Rather than allow an empty stack, we always have the dummy target at
647 the bottom stratum, so we can call the function vectors without
651 push_target (struct target_ops
*t
)
653 struct target_ops
**cur
;
655 /* Check magic number. If wrong, it probably means someone changed
656 the struct definition, but not all the places that initialize one. */
657 if (t
->to_magic
!= OPS_MAGIC
)
659 fprintf_unfiltered (gdb_stderr
,
660 "Magic number of %s target struct wrong\n",
662 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
665 /* Find the proper stratum to install this target in. */
666 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
668 if ((int) (t
->to_stratum
) >= (int) (*cur
)->to_stratum
)
672 /* If there's already targets at this stratum, remove them. */
673 /* FIXME: cagney/2003-10-15: I think this should be popping all
674 targets to CUR, and not just those at this stratum level. */
675 while ((*cur
) != NULL
&& t
->to_stratum
== (*cur
)->to_stratum
)
677 /* There's already something at this stratum level. Close it,
678 and un-hook it from the stack. */
679 struct target_ops
*tmp
= (*cur
);
680 (*cur
) = (*cur
)->beneath
;
682 target_close (tmp
, 0);
685 /* We have removed all targets in our stratum, now add the new one. */
689 update_current_target ();
692 setup_target_debug ();
695 return (t
!= target_stack
);
698 /* Remove a target_ops vector from the stack, wherever it may be.
699 Return how many times it was removed (0 or 1). */
702 unpush_target (struct target_ops
*t
)
704 struct target_ops
**cur
;
705 struct target_ops
*tmp
;
707 /* Look for the specified target. Note that we assume that a target
708 can only occur once in the target stack. */
710 for (cur
= &target_stack
; (*cur
) != NULL
; cur
= &(*cur
)->beneath
)
717 return 0; /* Didn't find target_ops, quit now */
719 /* NOTE: cagney/2003-12-06: In '94 the close call was made
720 unconditional by moving it to before the above check that the
721 target was in the target stack (something about "Change the way
722 pushing and popping of targets work to support target overlays
723 and inheritance"). This doesn't make much sense - only open
724 targets should be closed. */
727 /* Unchain the target */
729 (*cur
) = (*cur
)->beneath
;
732 update_current_target ();
740 target_close (¤t_target
, 0); /* Let it clean up */
741 if (unpush_target (target_stack
) == 1)
744 fprintf_unfiltered (gdb_stderr
,
745 "pop_target couldn't find target %s\n",
746 current_target
.to_shortname
);
747 internal_error (__FILE__
, __LINE__
, _("failed internal consistency check"));
751 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
753 /* target_read_string -- read a null terminated string, up to LEN bytes,
754 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
755 Set *STRING to a pointer to malloc'd memory containing the data; the caller
756 is responsible for freeing it. Return the number of bytes successfully
760 target_read_string (CORE_ADDR memaddr
, char **string
, int len
, int *errnop
)
762 int tlen
, origlen
, offset
, i
;
766 int buffer_allocated
;
768 unsigned int nbytes_read
= 0;
770 /* Small for testing. */
771 buffer_allocated
= 4;
772 buffer
= xmalloc (buffer_allocated
);
779 tlen
= MIN (len
, 4 - (memaddr
& 3));
780 offset
= memaddr
& 3;
782 errcode
= target_read_memory (memaddr
& ~3, buf
, sizeof buf
);
785 /* The transfer request might have crossed the boundary to an
786 unallocated region of memory. Retry the transfer, requesting
790 errcode
= target_read_memory (memaddr
, buf
, 1);
795 if (bufptr
- buffer
+ tlen
> buffer_allocated
)
798 bytes
= bufptr
- buffer
;
799 buffer_allocated
*= 2;
800 buffer
= xrealloc (buffer
, buffer_allocated
);
801 bufptr
= buffer
+ bytes
;
804 for (i
= 0; i
< tlen
; i
++)
806 *bufptr
++ = buf
[i
+ offset
];
807 if (buf
[i
+ offset
] == '\000')
809 nbytes_read
+= i
+ 1;
826 /* Find a section containing ADDR. */
827 struct section_table
*
828 target_section_by_addr (struct target_ops
*target
, CORE_ADDR addr
)
830 struct section_table
*secp
;
831 for (secp
= target
->to_sections
;
832 secp
< target
->to_sections_end
;
835 if (addr
>= secp
->addr
&& addr
< secp
->endaddr
)
841 /* Return non-zero when the target vector has supplied an xfer_partial
842 method and it, rather than xfer_memory, should be used. */
844 target_xfer_partial_p (void)
846 return (target_stack
!= NULL
847 && target_stack
->to_xfer_partial
!= default_xfer_partial
);
851 target_xfer_partial (struct target_ops
*ops
,
852 enum target_object object
, const char *annex
,
853 void *readbuf
, const void *writebuf
,
854 ULONGEST offset
, LONGEST len
)
858 gdb_assert (ops
->to_xfer_partial
!= NULL
);
859 retval
= ops
->to_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
863 const unsigned char *myaddr
= NULL
;
865 fprintf_unfiltered (gdb_stdlog
,
866 "%s:target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s",
869 (annex
? annex
: "(null)"),
870 (long) readbuf
, (long) writebuf
,
871 paddr_nz (offset
), paddr_d (len
), paddr_d (retval
));
877 if (retval
> 0 && myaddr
!= NULL
)
881 fputs_unfiltered (", bytes =", gdb_stdlog
);
882 for (i
= 0; i
< retval
; i
++)
884 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
886 if (targetdebug
< 2 && i
> 0)
888 fprintf_unfiltered (gdb_stdlog
, " ...");
891 fprintf_unfiltered (gdb_stdlog
, "\n");
894 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
898 fputc_unfiltered ('\n', gdb_stdlog
);
903 /* Attempt a transfer all LEN bytes starting at OFFSET between the
904 inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer. If
905 the transfer succeeds, return zero, otherwize the host ERRNO is
908 The inferior is formed from several layers. In the case of
909 corefiles, inf-corefile is layered above inf-exec and a request for
910 text (corefiles do not include text pages) will be first sent to
911 the core-stratum, fail, and then sent to the object-file where it
914 NOTE: cagney/2004-09-30:
916 The old code tried to use four separate mechanisms for mapping an
917 object:offset:len tuple onto an inferior and its address space: the
918 target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
923 The code below is instead using a single mechanism (currently
924 strata). If that mechanism proves insufficient then re-factor it
925 implementing another singluar mechanism (for instance, a generic
926 object:annex onto inferior:object:annex say). */
929 xfer_using_stratum (enum target_object object
, const char *annex
,
930 ULONGEST offset
, LONGEST len
, void *readbuf
,
931 const void *writebuf
)
934 struct target_ops
*target
;
936 /* Always successful. */
939 /* Never successful. */
940 if (target_stack
== NULL
)
943 target
= target_stack
;
946 xfered
= target_xfer_partial (target
, object
, annex
,
947 readbuf
, writebuf
, offset
, len
);
950 /* The partial xfer succeeded, update the counts, check that
951 the xfer hasn't finished and if it hasn't set things up
952 for the next round. */
958 readbuf
= (gdb_byte
*) readbuf
+ xfered
;
959 if (writebuf
!= NULL
)
960 writebuf
= (gdb_byte
*) writebuf
+ xfered
;
961 target
= target_stack
;
965 /* Something totally screwed up, abandon the attempt to
974 /* This "stratum" didn't work, try the next one down. */
975 target
= target
->beneath
;
982 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
983 GDB's memory at MYADDR. Returns either 0 for success or an errno value
986 If an error occurs, no guarantee is made about the contents of the data at
987 MYADDR. In particular, the caller should not depend upon partial reads
988 filling the buffer with good data. There is no way for the caller to know
989 how much good data might have been transfered anyway. Callers that can
990 deal with partial reads should call target_read_memory_partial. */
993 target_read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
)
995 if (target_xfer_partial_p ())
996 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
997 memaddr
, len
, myaddr
, NULL
);
999 return target_xfer_memory (memaddr
, myaddr
, len
, 0);
1003 target_write_memory (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, int len
)
1005 gdb_byte
*bytes
= alloca (len
);
1006 memcpy (bytes
, myaddr
, len
);
1007 if (target_xfer_partial_p ())
1008 return xfer_using_stratum (TARGET_OBJECT_MEMORY
, NULL
,
1009 memaddr
, len
, NULL
, bytes
);
1011 return target_xfer_memory (memaddr
, bytes
, len
, 1);
1014 #ifndef target_stopped_data_address_p
1016 target_stopped_data_address_p (struct target_ops
*target
)
1018 if (target
->to_stopped_data_address
1019 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
)
1021 if (target
->to_stopped_data_address
== debug_to_stopped_data_address
1022 && (debug_target
.to_stopped_data_address
1023 == (int (*) (struct target_ops
*, CORE_ADDR
*)) return_zero
))
1029 static int trust_readonly
= 0;
1031 show_trust_readonly (struct ui_file
*file
, int from_tty
,
1032 struct cmd_list_element
*c
, const char *value
)
1034 fprintf_filtered (file
, _("\
1035 Mode for reading from readonly sections is %s.\n"),
1039 /* Move memory to or from the targets. The top target gets priority;
1040 if it cannot handle it, it is offered to the next one down, etc.
1042 Result is -1 on error, or the number of bytes transfered. */
1045 do_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
1046 struct mem_attrib
*attrib
)
1050 struct target_ops
*t
;
1052 /* Zero length requests are ok and require no work. */
1056 /* deprecated_xfer_memory is not guaranteed to set errno, even when
1060 if (!write
&& trust_readonly
)
1062 struct section_table
*secp
;
1063 /* User-settable option, "trust-readonly-sections". If true,
1064 then memory from any SEC_READONLY bfd section may be read
1065 directly from the bfd file. */
1066 secp
= target_section_by_addr (¤t_target
, memaddr
);
1068 && (bfd_get_section_flags (secp
->bfd
, secp
->the_bfd_section
)
1070 return xfer_memory (memaddr
, myaddr
, len
, 0, attrib
, ¤t_target
);
1073 /* The quick case is that the top target can handle the transfer. */
1074 res
= current_target
.deprecated_xfer_memory
1075 (memaddr
, myaddr
, len
, write
, attrib
, ¤t_target
);
1077 /* If res <= 0 then we call it again in the loop. Ah well. */
1080 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1082 if (!t
->to_has_memory
)
1085 res
= t
->deprecated_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, t
);
1087 break; /* Handled all or part of xfer */
1088 if (t
->to_has_all_memory
)
1100 /* Perform a memory transfer. Iterate until the entire region has
1103 Result is 0 or errno value. */
1106 target_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
)
1110 struct mem_region
*region
;
1112 /* Zero length requests are ok and require no work. */
1120 region
= lookup_mem_region(memaddr
);
1121 if (memaddr
+ len
< region
->hi
)
1124 reg_len
= region
->hi
- memaddr
;
1126 switch (region
->attrib
.mode
)
1141 if (region
->attrib
.cache
)
1142 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1145 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write
,
1150 /* If this address is for nonexistent memory, read zeros
1151 if reading, or do nothing if writing. Return
1154 memset (myaddr
, 0, len
);
1168 return 0; /* We managed to cover it all somehow. */
1172 /* Perform a partial memory transfer.
1174 If we succeed, set *ERR to zero and return the number of bytes transferred.
1175 If we fail, set *ERR to a non-zero errno value, and return -1. */
1178 target_xfer_memory_partial (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
,
1179 int write_p
, int *err
)
1183 struct mem_region
*region
;
1185 /* Zero length requests are ok and require no work. */
1192 region
= lookup_mem_region(memaddr
);
1193 if (memaddr
+ len
< region
->hi
)
1196 reg_len
= region
->hi
- memaddr
;
1198 switch (region
->attrib
.mode
)
1217 if (region
->attrib
.cache
)
1218 res
= dcache_xfer_memory (target_dcache
, memaddr
, myaddr
,
1221 res
= do_xfer_memory (memaddr
, myaddr
, reg_len
, write_p
,
1239 target_read_memory_partial (CORE_ADDR memaddr
, gdb_byte
*buf
,
1242 if (target_xfer_partial_p ())
1246 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1247 NULL
, buf
, NULL
, memaddr
, len
);
1264 return target_xfer_memory_partial (memaddr
, buf
, len
, 0, err
);
1268 target_write_memory_partial (CORE_ADDR memaddr
, gdb_byte
*buf
,
1271 if (target_xfer_partial_p ())
1275 retval
= target_xfer_partial (target_stack
, TARGET_OBJECT_MEMORY
,
1276 NULL
, NULL
, buf
, memaddr
, len
);
1293 return target_xfer_memory_partial (memaddr
, buf
, len
, 1, err
);
1296 /* More generic transfers. */
1299 default_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1300 const char *annex
, gdb_byte
*readbuf
,
1301 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
1303 if (object
== TARGET_OBJECT_MEMORY
1304 && ops
->deprecated_xfer_memory
!= NULL
)
1305 /* If available, fall back to the target's
1306 "deprecated_xfer_memory" method. */
1310 if (writebuf
!= NULL
)
1312 void *buffer
= xmalloc (len
);
1313 struct cleanup
*cleanup
= make_cleanup (xfree
, buffer
);
1314 memcpy (buffer
, writebuf
, len
);
1315 xfered
= ops
->deprecated_xfer_memory (offset
, buffer
, len
,
1316 1/*write*/, NULL
, ops
);
1317 do_cleanups (cleanup
);
1319 if (readbuf
!= NULL
)
1320 xfered
= ops
->deprecated_xfer_memory (offset
, readbuf
, len
, 0/*read*/,
1324 else if (xfered
== 0 && errno
== 0)
1325 /* "deprecated_xfer_memory" uses 0, cross checked against
1326 ERRNO as one indication of an error. */
1331 else if (ops
->beneath
!= NULL
)
1332 return target_xfer_partial (ops
->beneath
, object
, annex
,
1333 readbuf
, writebuf
, offset
, len
);
1338 /* Target vector read/write partial wrapper functions.
1340 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1341 (inbuf, outbuf)", instead of separate read/write methods, make life
1345 target_read_partial (struct target_ops
*ops
,
1346 enum target_object object
,
1347 const char *annex
, gdb_byte
*buf
,
1348 ULONGEST offset
, LONGEST len
)
1350 return target_xfer_partial (ops
, object
, annex
, buf
, NULL
, offset
, len
);
1354 target_write_partial (struct target_ops
*ops
,
1355 enum target_object object
,
1356 const char *annex
, const gdb_byte
*buf
,
1357 ULONGEST offset
, LONGEST len
)
1359 return target_xfer_partial (ops
, object
, annex
, NULL
, buf
, offset
, len
);
1362 /* Wrappers to perform the full transfer. */
1364 target_read (struct target_ops
*ops
,
1365 enum target_object object
,
1366 const char *annex
, gdb_byte
*buf
,
1367 ULONGEST offset
, LONGEST len
)
1370 while (xfered
< len
)
1372 LONGEST xfer
= target_read_partial (ops
, object
, annex
,
1373 (gdb_byte
*) buf
+ xfered
,
1374 offset
+ xfered
, len
- xfered
);
1375 /* Call an observer, notifying them of the xfer progress? */
1387 target_write (struct target_ops
*ops
,
1388 enum target_object object
,
1389 const char *annex
, const gdb_byte
*buf
,
1390 ULONGEST offset
, LONGEST len
)
1393 while (xfered
< len
)
1395 LONGEST xfer
= target_write_partial (ops
, object
, annex
,
1396 (gdb_byte
*) buf
+ xfered
,
1397 offset
+ xfered
, len
- xfered
);
1398 /* Call an observer, notifying them of the xfer progress? */
1409 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1410 the size of the transferred data. PADDING additional bytes are
1411 available in *BUF_P. This is a helper function for
1412 target_read_alloc; see the declaration of that function for more
1416 target_read_alloc_1 (struct target_ops
*ops
, enum target_object object
,
1417 const char *annex
, gdb_byte
**buf_p
, int padding
)
1419 size_t buf_alloc
, buf_pos
;
1423 /* This function does not have a length parameter; it reads the
1424 entire OBJECT). Also, it doesn't support objects fetched partly
1425 from one target and partly from another (in a different stratum,
1426 e.g. a core file and an executable). Both reasons make it
1427 unsuitable for reading memory. */
1428 gdb_assert (object
!= TARGET_OBJECT_MEMORY
);
1430 /* Start by reading up to 4K at a time. The target will throttle
1431 this number down if necessary. */
1433 buf
= xmalloc (buf_alloc
);
1437 n
= target_read_partial (ops
, object
, annex
, &buf
[buf_pos
],
1438 buf_pos
, buf_alloc
- buf_pos
- padding
);
1441 /* An error occurred. */
1447 /* Read all there was. */
1457 /* If the buffer is filling up, expand it. */
1458 if (buf_alloc
< buf_pos
* 2)
1461 buf
= xrealloc (buf
, buf_alloc
);
1468 /* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1469 the size of the transferred data. See the declaration in "target.h"
1470 function for more information about the return value. */
1473 target_read_alloc (struct target_ops
*ops
, enum target_object object
,
1474 const char *annex
, gdb_byte
**buf_p
)
1476 return target_read_alloc_1 (ops
, object
, annex
, buf_p
, 0);
1479 /* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1480 returned as a string, allocated using xmalloc. If an error occurs
1481 or the transfer is unsupported, NULL is returned. Empty objects
1482 are returned as allocated but empty strings. A warning is issued
1483 if the result contains any embedded NUL bytes. */
1486 target_read_stralloc (struct target_ops
*ops
, enum target_object object
,
1490 LONGEST transferred
;
1492 transferred
= target_read_alloc_1 (ops
, object
, annex
, &buffer
, 1);
1494 if (transferred
< 0)
1497 if (transferred
== 0)
1498 return xstrdup ("");
1500 buffer
[transferred
] = 0;
1501 if (strlen (buffer
) < transferred
)
1502 warning (_("target object %d, annex %s, "
1503 "contained unexpected null characters"),
1504 (int) object
, annex
? annex
: "(none)");
1506 return (char *) buffer
;
1509 /* Memory transfer methods. */
1512 get_target_memory (struct target_ops
*ops
, CORE_ADDR addr
, gdb_byte
*buf
,
1515 if (target_read (ops
, TARGET_OBJECT_MEMORY
, NULL
, buf
, addr
, len
)
1517 memory_error (EIO
, addr
);
1521 get_target_memory_unsigned (struct target_ops
*ops
,
1522 CORE_ADDR addr
, int len
)
1524 gdb_byte buf
[sizeof (ULONGEST
)];
1526 gdb_assert (len
<= sizeof (buf
));
1527 get_target_memory (ops
, addr
, buf
, len
);
1528 return extract_unsigned_integer (buf
, len
);
1532 target_info (char *args
, int from_tty
)
1534 struct target_ops
*t
;
1535 int has_all_mem
= 0;
1537 if (symfile_objfile
!= NULL
)
1538 printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile
->name
);
1540 for (t
= target_stack
; t
!= NULL
; t
= t
->beneath
)
1542 if (!t
->to_has_memory
)
1545 if ((int) (t
->to_stratum
) <= (int) dummy_stratum
)
1548 printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1549 printf_unfiltered ("%s:\n", t
->to_longname
);
1550 (t
->to_files_info
) (t
);
1551 has_all_mem
= t
->to_has_all_memory
;
1555 /* This is to be called by the open routine before it does
1559 target_preopen (int from_tty
)
1563 if (target_has_execution
)
1566 || query (_("A program is being debugged already. Kill it? ")))
1569 error (_("Program not killed."));
1572 /* Calling target_kill may remove the target from the stack. But if
1573 it doesn't (which seems like a win for UDI), remove it now. */
1575 if (target_has_execution
)
1579 /* Detach a target after doing deferred register stores. */
1582 target_detach (char *args
, int from_tty
)
1584 (current_target
.to_detach
) (args
, from_tty
);
1588 target_disconnect (char *args
, int from_tty
)
1590 struct target_ops
*t
;
1592 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1593 if (t
->to_disconnect
!= NULL
)
1596 fprintf_unfiltered (gdb_stdlog
, "target_disconnect (%s, %d)\n",
1598 t
->to_disconnect (t
, args
, from_tty
);
1606 target_async_mask (int mask
)
1608 int saved_async_masked_status
= target_async_mask_value
;
1609 target_async_mask_value
= mask
;
1610 return saved_async_masked_status
;
1613 /* Look through the list of possible targets for a target that can
1617 target_follow_fork (int follow_child
)
1619 struct target_ops
*t
;
1621 for (t
= current_target
.beneath
; t
!= NULL
; t
= t
->beneath
)
1623 if (t
->to_follow_fork
!= NULL
)
1625 int retval
= t
->to_follow_fork (t
, follow_child
);
1627 fprintf_unfiltered (gdb_stdlog
, "target_follow_fork (%d) = %d\n",
1628 follow_child
, retval
);
1633 /* Some target returned a fork event, but did not know how to follow it. */
1634 internal_error (__FILE__
, __LINE__
,
1635 "could not find a target to follow fork");
1638 /* Look through the list of possible targets for a target that can
1639 execute a run or attach command without any other data. This is
1640 used to locate the default process stratum.
1642 Result is always valid (error() is called for errors). */
1644 static struct target_ops
*
1645 find_default_run_target (char *do_mesg
)
1647 struct target_ops
**t
;
1648 struct target_ops
*runable
= NULL
;
1653 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1656 if ((*t
)->to_can_run
&& target_can_run (*t
))
1664 error (_("Don't know how to %s. Try \"help target\"."), do_mesg
);
1670 find_default_attach (char *args
, int from_tty
)
1672 struct target_ops
*t
;
1674 t
= find_default_run_target ("attach");
1675 (t
->to_attach
) (args
, from_tty
);
1680 find_default_create_inferior (char *exec_file
, char *allargs
, char **env
,
1683 struct target_ops
*t
;
1685 t
= find_default_run_target ("run");
1686 (t
->to_create_inferior
) (exec_file
, allargs
, env
, from_tty
);
1691 default_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
1693 return (len
<= TYPE_LENGTH (builtin_type_void_data_ptr
));
1709 return_minus_one (void)
1715 * Resize the to_sections pointer. Also make sure that anyone that
1716 * was holding on to an old value of it gets updated.
1717 * Returns the old size.
1721 target_resize_to_sections (struct target_ops
*target
, int num_added
)
1723 struct target_ops
**t
;
1724 struct section_table
*old_value
;
1727 old_value
= target
->to_sections
;
1729 if (target
->to_sections
)
1731 old_count
= target
->to_sections_end
- target
->to_sections
;
1732 target
->to_sections
= (struct section_table
*)
1733 xrealloc ((char *) target
->to_sections
,
1734 (sizeof (struct section_table
)) * (num_added
+ old_count
));
1739 target
->to_sections
= (struct section_table
*)
1740 xmalloc ((sizeof (struct section_table
)) * num_added
);
1742 target
->to_sections_end
= target
->to_sections
+ (num_added
+ old_count
);
1744 /* Check to see if anyone else was pointing to this structure.
1745 If old_value was null, then no one was. */
1749 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1752 if ((*t
)->to_sections
== old_value
)
1754 (*t
)->to_sections
= target
->to_sections
;
1755 (*t
)->to_sections_end
= target
->to_sections_end
;
1758 /* There is a flattened view of the target stack in current_target,
1759 so its to_sections pointer might also need updating. */
1760 if (current_target
.to_sections
== old_value
)
1762 current_target
.to_sections
= target
->to_sections
;
1763 current_target
.to_sections_end
= target
->to_sections_end
;
1771 /* Remove all target sections taken from ABFD.
1773 Scan the current target stack for targets whose section tables
1774 refer to sections from BFD, and remove those sections. We use this
1775 when we notice that the inferior has unloaded a shared object, for
1778 remove_target_sections (bfd
*abfd
)
1780 struct target_ops
**t
;
1782 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; t
++)
1784 struct section_table
*src
, *dest
;
1786 dest
= (*t
)->to_sections
;
1787 for (src
= (*t
)->to_sections
; src
< (*t
)->to_sections_end
; src
++)
1788 if (src
->bfd
!= abfd
)
1790 /* Keep this section. */
1791 if (dest
< src
) *dest
= *src
;
1795 /* If we've dropped any sections, resize the section table. */
1797 target_resize_to_sections (*t
, dest
- src
);
1804 /* Find a single runnable target in the stack and return it. If for
1805 some reason there is more than one, return NULL. */
1808 find_run_target (void)
1810 struct target_ops
**t
;
1811 struct target_ops
*runable
= NULL
;
1816 for (t
= target_structs
; t
< target_structs
+ target_struct_size
; ++t
)
1818 if ((*t
)->to_can_run
&& target_can_run (*t
))
1825 return (count
== 1 ? runable
: NULL
);
1828 /* Find a single core_stratum target in the list of targets and return it.
1829 If for some reason there is more than one, return NULL. */
1832 find_core_target (void)
1834 struct target_ops
**t
;
1835 struct target_ops
*runable
= NULL
;
1840 for (t
= target_structs
; t
< target_structs
+ target_struct_size
;
1843 if ((*t
)->to_stratum
== core_stratum
)
1850 return (count
== 1 ? runable
: NULL
);
1854 * Find the next target down the stack from the specified target.
1858 find_target_beneath (struct target_ops
*t
)
1864 /* The inferior process has died. Long live the inferior! */
1867 generic_mourn_inferior (void)
1869 extern int show_breakpoint_hit_counts
;
1871 inferior_ptid
= null_ptid
;
1873 breakpoint_init_inferior (inf_exited
);
1874 registers_changed ();
1876 reopen_exec_file ();
1877 reinit_frame_cache ();
1879 /* It is confusing to the user for ignore counts to stick around
1880 from previous runs of the inferior. So clear them. */
1881 /* However, it is more confusing for the ignore counts to disappear when
1882 using hit counts. So don't clear them if we're counting hits. */
1883 if (!show_breakpoint_hit_counts
)
1884 breakpoint_clear_ignore_counts ();
1886 if (deprecated_detach_hook
)
1887 deprecated_detach_hook ();
1890 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1891 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1892 translation of that in OURSTATUS. */
1894 store_waitstatus (struct target_waitstatus
*ourstatus
, int hoststatus
)
1896 #ifdef CHILD_SPECIAL_WAITSTATUS
1897 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1898 if it wants to deal with hoststatus. */
1899 if (CHILD_SPECIAL_WAITSTATUS (ourstatus
, hoststatus
))
1903 if (WIFEXITED (hoststatus
))
1905 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1906 ourstatus
->value
.integer
= WEXITSTATUS (hoststatus
);
1908 else if (!WIFSTOPPED (hoststatus
))
1910 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1911 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (hoststatus
));
1915 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1916 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (hoststatus
));
1920 /* Returns zero to leave the inferior alone, one to interrupt it. */
1921 int (*target_activity_function
) (void);
1922 int target_activity_fd
;
1924 /* Convert a normal process ID to a string. Returns the string in a
1928 normal_pid_to_str (ptid_t ptid
)
1930 static char buf
[32];
1932 xsnprintf (buf
, sizeof buf
, "process %d", ptid_get_pid (ptid
));
1936 /* Error-catcher for target_find_memory_regions */
1937 static int dummy_find_memory_regions (int (*ignore1
) (), void *ignore2
)
1939 error (_("No target."));
1943 /* Error-catcher for target_make_corefile_notes */
1944 static char * dummy_make_corefile_notes (bfd
*ignore1
, int *ignore2
)
1946 error (_("No target."));
1950 /* Set up the handful of non-empty slots needed by the dummy target
1954 init_dummy_target (void)
1956 dummy_target
.to_shortname
= "None";
1957 dummy_target
.to_longname
= "None";
1958 dummy_target
.to_doc
= "";
1959 dummy_target
.to_attach
= find_default_attach
;
1960 dummy_target
.to_create_inferior
= find_default_create_inferior
;
1961 dummy_target
.to_pid_to_str
= normal_pid_to_str
;
1962 dummy_target
.to_stratum
= dummy_stratum
;
1963 dummy_target
.to_find_memory_regions
= dummy_find_memory_regions
;
1964 dummy_target
.to_make_corefile_notes
= dummy_make_corefile_notes
;
1965 dummy_target
.to_xfer_partial
= default_xfer_partial
;
1966 dummy_target
.to_magic
= OPS_MAGIC
;
1970 debug_to_open (char *args
, int from_tty
)
1972 debug_target
.to_open (args
, from_tty
);
1974 fprintf_unfiltered (gdb_stdlog
, "target_open (%s, %d)\n", args
, from_tty
);
1978 debug_to_close (int quitting
)
1980 target_close (&debug_target
, quitting
);
1981 fprintf_unfiltered (gdb_stdlog
, "target_close (%d)\n", quitting
);
1985 target_close (struct target_ops
*targ
, int quitting
)
1987 if (targ
->to_xclose
!= NULL
)
1988 targ
->to_xclose (targ
, quitting
);
1989 else if (targ
->to_close
!= NULL
)
1990 targ
->to_close (quitting
);
1994 debug_to_attach (char *args
, int from_tty
)
1996 debug_target
.to_attach (args
, from_tty
);
1998 fprintf_unfiltered (gdb_stdlog
, "target_attach (%s, %d)\n", args
, from_tty
);
2003 debug_to_post_attach (int pid
)
2005 debug_target
.to_post_attach (pid
);
2007 fprintf_unfiltered (gdb_stdlog
, "target_post_attach (%d)\n", pid
);
2011 debug_to_detach (char *args
, int from_tty
)
2013 debug_target
.to_detach (args
, from_tty
);
2015 fprintf_unfiltered (gdb_stdlog
, "target_detach (%s, %d)\n", args
, from_tty
);
2019 debug_to_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
2021 debug_target
.to_resume (ptid
, step
, siggnal
);
2023 fprintf_unfiltered (gdb_stdlog
, "target_resume (%d, %s, %s)\n", PIDGET (ptid
),
2024 step
? "step" : "continue",
2025 target_signal_to_name (siggnal
));
2029 debug_to_wait (ptid_t ptid
, struct target_waitstatus
*status
)
2033 retval
= debug_target
.to_wait (ptid
, status
);
2035 fprintf_unfiltered (gdb_stdlog
,
2036 "target_wait (%d, status) = %d, ", PIDGET (ptid
),
2038 fprintf_unfiltered (gdb_stdlog
, "status->kind = ");
2039 switch (status
->kind
)
2041 case TARGET_WAITKIND_EXITED
:
2042 fprintf_unfiltered (gdb_stdlog
, "exited, status = %d\n",
2043 status
->value
.integer
);
2045 case TARGET_WAITKIND_STOPPED
:
2046 fprintf_unfiltered (gdb_stdlog
, "stopped, signal = %s\n",
2047 target_signal_to_name (status
->value
.sig
));
2049 case TARGET_WAITKIND_SIGNALLED
:
2050 fprintf_unfiltered (gdb_stdlog
, "signalled, signal = %s\n",
2051 target_signal_to_name (status
->value
.sig
));
2053 case TARGET_WAITKIND_LOADED
:
2054 fprintf_unfiltered (gdb_stdlog
, "loaded\n");
2056 case TARGET_WAITKIND_FORKED
:
2057 fprintf_unfiltered (gdb_stdlog
, "forked\n");
2059 case TARGET_WAITKIND_VFORKED
:
2060 fprintf_unfiltered (gdb_stdlog
, "vforked\n");
2062 case TARGET_WAITKIND_EXECD
:
2063 fprintf_unfiltered (gdb_stdlog
, "execd\n");
2065 case TARGET_WAITKIND_SPURIOUS
:
2066 fprintf_unfiltered (gdb_stdlog
, "spurious\n");
2069 fprintf_unfiltered (gdb_stdlog
, "unknown???\n");
2077 debug_print_register (const char * func
, int regno
)
2079 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
2080 if (regno
>= 0 && regno
< NUM_REGS
+ NUM_PSEUDO_REGS
2081 && REGISTER_NAME (regno
) != NULL
&& REGISTER_NAME (regno
)[0] != '\0')
2082 fprintf_unfiltered (gdb_stdlog
, "(%s)", REGISTER_NAME (regno
));
2084 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
2088 unsigned char buf
[MAX_REGISTER_SIZE
];
2089 deprecated_read_register_gen (regno
, buf
);
2090 fprintf_unfiltered (gdb_stdlog
, " = ");
2091 for (i
= 0; i
< register_size (current_gdbarch
, regno
); i
++)
2093 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
2095 if (register_size (current_gdbarch
, regno
) <= sizeof (LONGEST
))
2097 fprintf_unfiltered (gdb_stdlog
, " 0x%s %s",
2098 paddr_nz (read_register (regno
)),
2099 paddr_d (read_register (regno
)));
2102 fprintf_unfiltered (gdb_stdlog
, "\n");
2106 debug_to_fetch_registers (int regno
)
2108 debug_target
.to_fetch_registers (regno
);
2109 debug_print_register ("target_fetch_registers", regno
);
2113 debug_to_store_registers (int regno
)
2115 debug_target
.to_store_registers (regno
);
2116 debug_print_register ("target_store_registers", regno
);
2117 fprintf_unfiltered (gdb_stdlog
, "\n");
2121 debug_to_prepare_to_store (void)
2123 debug_target
.to_prepare_to_store ();
2125 fprintf_unfiltered (gdb_stdlog
, "target_prepare_to_store ()\n");
2129 deprecated_debug_xfer_memory (CORE_ADDR memaddr
, bfd_byte
*myaddr
, int len
,
2130 int write
, struct mem_attrib
*attrib
,
2131 struct target_ops
*target
)
2135 retval
= debug_target
.deprecated_xfer_memory (memaddr
, myaddr
, len
, write
,
2138 fprintf_unfiltered (gdb_stdlog
,
2139 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2140 (unsigned int) memaddr
, /* possable truncate long long */
2141 len
, write
? "write" : "read", retval
);
2147 fputs_unfiltered (", bytes =", gdb_stdlog
);
2148 for (i
= 0; i
< retval
; i
++)
2150 if ((((long) &(myaddr
[i
])) & 0xf) == 0)
2152 if (targetdebug
< 2 && i
> 0)
2154 fprintf_unfiltered (gdb_stdlog
, " ...");
2157 fprintf_unfiltered (gdb_stdlog
, "\n");
2160 fprintf_unfiltered (gdb_stdlog
, " %02x", myaddr
[i
] & 0xff);
2164 fputc_unfiltered ('\n', gdb_stdlog
);
2170 debug_to_files_info (struct target_ops
*target
)
2172 debug_target
.to_files_info (target
);
2174 fprintf_unfiltered (gdb_stdlog
, "target_files_info (xxx)\n");
2178 debug_to_insert_breakpoint (struct bp_target_info
*bp_tgt
)
2182 retval
= debug_target
.to_insert_breakpoint (bp_tgt
);
2184 fprintf_unfiltered (gdb_stdlog
,
2185 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2186 (unsigned long) bp_tgt
->placed_address
,
2187 (unsigned long) retval
);
2192 debug_to_remove_breakpoint (struct bp_target_info
*bp_tgt
)
2196 retval
= debug_target
.to_remove_breakpoint (bp_tgt
);
2198 fprintf_unfiltered (gdb_stdlog
,
2199 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2200 (unsigned long) bp_tgt
->placed_address
,
2201 (unsigned long) retval
);
2206 debug_to_can_use_hw_breakpoint (int type
, int cnt
, int from_tty
)
2210 retval
= debug_target
.to_can_use_hw_breakpoint (type
, cnt
, from_tty
);
2212 fprintf_unfiltered (gdb_stdlog
,
2213 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2214 (unsigned long) type
,
2215 (unsigned long) cnt
,
2216 (unsigned long) from_tty
,
2217 (unsigned long) retval
);
2222 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
2226 retval
= debug_target
.to_region_ok_for_hw_watchpoint (addr
, len
);
2228 fprintf_unfiltered (gdb_stdlog
,
2229 "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2230 (unsigned long) addr
,
2231 (unsigned long) len
,
2232 (unsigned long) retval
);
2237 debug_to_stopped_by_watchpoint (void)
2241 retval
= debug_target
.to_stopped_by_watchpoint ();
2243 fprintf_unfiltered (gdb_stdlog
,
2244 "STOPPED_BY_WATCHPOINT () = %ld\n",
2245 (unsigned long) retval
);
2250 debug_to_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr
)
2254 retval
= debug_target
.to_stopped_data_address (target
, addr
);
2256 fprintf_unfiltered (gdb_stdlog
,
2257 "target_stopped_data_address ([0x%lx]) = %ld\n",
2258 (unsigned long)*addr
,
2259 (unsigned long)retval
);
2264 debug_to_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2268 retval
= debug_target
.to_insert_hw_breakpoint (bp_tgt
);
2270 fprintf_unfiltered (gdb_stdlog
,
2271 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2272 (unsigned long) bp_tgt
->placed_address
,
2273 (unsigned long) retval
);
2278 debug_to_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
2282 retval
= debug_target
.to_remove_hw_breakpoint (bp_tgt
);
2284 fprintf_unfiltered (gdb_stdlog
,
2285 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2286 (unsigned long) bp_tgt
->placed_address
,
2287 (unsigned long) retval
);
2292 debug_to_insert_watchpoint (CORE_ADDR addr
, int len
, int type
)
2296 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2298 fprintf_unfiltered (gdb_stdlog
,
2299 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2300 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2305 debug_to_remove_watchpoint (CORE_ADDR addr
, int len
, int type
)
2309 retval
= debug_target
.to_insert_watchpoint (addr
, len
, type
);
2311 fprintf_unfiltered (gdb_stdlog
,
2312 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2313 (unsigned long) addr
, len
, type
, (unsigned long) retval
);
2318 debug_to_terminal_init (void)
2320 debug_target
.to_terminal_init ();
2322 fprintf_unfiltered (gdb_stdlog
, "target_terminal_init ()\n");
2326 debug_to_terminal_inferior (void)
2328 debug_target
.to_terminal_inferior ();
2330 fprintf_unfiltered (gdb_stdlog
, "target_terminal_inferior ()\n");
2334 debug_to_terminal_ours_for_output (void)
2336 debug_target
.to_terminal_ours_for_output ();
2338 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours_for_output ()\n");
2342 debug_to_terminal_ours (void)
2344 debug_target
.to_terminal_ours ();
2346 fprintf_unfiltered (gdb_stdlog
, "target_terminal_ours ()\n");
2350 debug_to_terminal_save_ours (void)
2352 debug_target
.to_terminal_save_ours ();
2354 fprintf_unfiltered (gdb_stdlog
, "target_terminal_save_ours ()\n");
2358 debug_to_terminal_info (char *arg
, int from_tty
)
2360 debug_target
.to_terminal_info (arg
, from_tty
);
2362 fprintf_unfiltered (gdb_stdlog
, "target_terminal_info (%s, %d)\n", arg
,
2367 debug_to_kill (void)
2369 debug_target
.to_kill ();
2371 fprintf_unfiltered (gdb_stdlog
, "target_kill ()\n");
2375 debug_to_load (char *args
, int from_tty
)
2377 debug_target
.to_load (args
, from_tty
);
2379 fprintf_unfiltered (gdb_stdlog
, "target_load (%s, %d)\n", args
, from_tty
);
2383 debug_to_lookup_symbol (char *name
, CORE_ADDR
*addrp
)
2387 retval
= debug_target
.to_lookup_symbol (name
, addrp
);
2389 fprintf_unfiltered (gdb_stdlog
, "target_lookup_symbol (%s, xxx)\n", name
);
2395 debug_to_create_inferior (char *exec_file
, char *args
, char **env
,
2398 debug_target
.to_create_inferior (exec_file
, args
, env
, from_tty
);
2400 fprintf_unfiltered (gdb_stdlog
, "target_create_inferior (%s, %s, xxx, %d)\n",
2401 exec_file
, args
, from_tty
);
2405 debug_to_post_startup_inferior (ptid_t ptid
)
2407 debug_target
.to_post_startup_inferior (ptid
);
2409 fprintf_unfiltered (gdb_stdlog
, "target_post_startup_inferior (%d)\n",
2414 debug_to_acknowledge_created_inferior (int pid
)
2416 debug_target
.to_acknowledge_created_inferior (pid
);
2418 fprintf_unfiltered (gdb_stdlog
, "target_acknowledge_created_inferior (%d)\n",
2423 debug_to_insert_fork_catchpoint (int pid
)
2425 debug_target
.to_insert_fork_catchpoint (pid
);
2427 fprintf_unfiltered (gdb_stdlog
, "target_insert_fork_catchpoint (%d)\n",
2432 debug_to_remove_fork_catchpoint (int pid
)
2436 retval
= debug_target
.to_remove_fork_catchpoint (pid
);
2438 fprintf_unfiltered (gdb_stdlog
, "target_remove_fork_catchpoint (%d) = %d\n",
2445 debug_to_insert_vfork_catchpoint (int pid
)
2447 debug_target
.to_insert_vfork_catchpoint (pid
);
2449 fprintf_unfiltered (gdb_stdlog
, "target_insert_vfork_catchpoint (%d)\n",
2454 debug_to_remove_vfork_catchpoint (int pid
)
2458 retval
= debug_target
.to_remove_vfork_catchpoint (pid
);
2460 fprintf_unfiltered (gdb_stdlog
, "target_remove_vfork_catchpoint (%d) = %d\n",
2467 debug_to_insert_exec_catchpoint (int pid
)
2469 debug_target
.to_insert_exec_catchpoint (pid
);
2471 fprintf_unfiltered (gdb_stdlog
, "target_insert_exec_catchpoint (%d)\n",
2476 debug_to_remove_exec_catchpoint (int pid
)
2480 retval
= debug_target
.to_remove_exec_catchpoint (pid
);
2482 fprintf_unfiltered (gdb_stdlog
, "target_remove_exec_catchpoint (%d) = %d\n",
2489 debug_to_reported_exec_events_per_exec_call (void)
2491 int reported_exec_events
;
2493 reported_exec_events
= debug_target
.to_reported_exec_events_per_exec_call ();
2495 fprintf_unfiltered (gdb_stdlog
,
2496 "target_reported_exec_events_per_exec_call () = %d\n",
2497 reported_exec_events
);
2499 return reported_exec_events
;
2503 debug_to_has_exited (int pid
, int wait_status
, int *exit_status
)
2507 has_exited
= debug_target
.to_has_exited (pid
, wait_status
, exit_status
);
2509 fprintf_unfiltered (gdb_stdlog
, "target_has_exited (%d, %d, %d) = %d\n",
2510 pid
, wait_status
, *exit_status
, has_exited
);
2516 debug_to_mourn_inferior (void)
2518 debug_target
.to_mourn_inferior ();
2520 fprintf_unfiltered (gdb_stdlog
, "target_mourn_inferior ()\n");
2524 debug_to_can_run (void)
2528 retval
= debug_target
.to_can_run ();
2530 fprintf_unfiltered (gdb_stdlog
, "target_can_run () = %d\n", retval
);
2536 debug_to_notice_signals (ptid_t ptid
)
2538 debug_target
.to_notice_signals (ptid
);
2540 fprintf_unfiltered (gdb_stdlog
, "target_notice_signals (%d)\n",
2545 debug_to_thread_alive (ptid_t ptid
)
2549 retval
= debug_target
.to_thread_alive (ptid
);
2551 fprintf_unfiltered (gdb_stdlog
, "target_thread_alive (%d) = %d\n",
2552 PIDGET (ptid
), retval
);
2558 debug_to_find_new_threads (void)
2560 debug_target
.to_find_new_threads ();
2562 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog
);
2566 debug_to_stop (void)
2568 debug_target
.to_stop ();
2570 fprintf_unfiltered (gdb_stdlog
, "target_stop ()\n");
2574 debug_to_rcmd (char *command
,
2575 struct ui_file
*outbuf
)
2577 debug_target
.to_rcmd (command
, outbuf
);
2578 fprintf_unfiltered (gdb_stdlog
, "target_rcmd (%s, ...)\n", command
);
2581 static struct symtab_and_line
*
2582 debug_to_enable_exception_callback (enum exception_event_kind kind
, int enable
)
2584 struct symtab_and_line
*result
;
2585 result
= debug_target
.to_enable_exception_callback (kind
, enable
);
2586 fprintf_unfiltered (gdb_stdlog
,
2587 "target get_exception_callback_sal (%d, %d)\n",
2592 static struct exception_event_record
*
2593 debug_to_get_current_exception_event (void)
2595 struct exception_event_record
*result
;
2596 result
= debug_target
.to_get_current_exception_event ();
2597 fprintf_unfiltered (gdb_stdlog
, "target get_current_exception_event ()\n");
2602 debug_to_pid_to_exec_file (int pid
)
2606 exec_file
= debug_target
.to_pid_to_exec_file (pid
);
2608 fprintf_unfiltered (gdb_stdlog
, "target_pid_to_exec_file (%d) = %s\n",
2615 setup_target_debug (void)
2617 memcpy (&debug_target
, ¤t_target
, sizeof debug_target
);
2619 current_target
.to_open
= debug_to_open
;
2620 current_target
.to_close
= debug_to_close
;
2621 current_target
.to_attach
= debug_to_attach
;
2622 current_target
.to_post_attach
= debug_to_post_attach
;
2623 current_target
.to_detach
= debug_to_detach
;
2624 current_target
.to_resume
= debug_to_resume
;
2625 current_target
.to_wait
= debug_to_wait
;
2626 current_target
.to_fetch_registers
= debug_to_fetch_registers
;
2627 current_target
.to_store_registers
= debug_to_store_registers
;
2628 current_target
.to_prepare_to_store
= debug_to_prepare_to_store
;
2629 current_target
.deprecated_xfer_memory
= deprecated_debug_xfer_memory
;
2630 current_target
.to_files_info
= debug_to_files_info
;
2631 current_target
.to_insert_breakpoint
= debug_to_insert_breakpoint
;
2632 current_target
.to_remove_breakpoint
= debug_to_remove_breakpoint
;
2633 current_target
.to_can_use_hw_breakpoint
= debug_to_can_use_hw_breakpoint
;
2634 current_target
.to_insert_hw_breakpoint
= debug_to_insert_hw_breakpoint
;
2635 current_target
.to_remove_hw_breakpoint
= debug_to_remove_hw_breakpoint
;
2636 current_target
.to_insert_watchpoint
= debug_to_insert_watchpoint
;
2637 current_target
.to_remove_watchpoint
= debug_to_remove_watchpoint
;
2638 current_target
.to_stopped_by_watchpoint
= debug_to_stopped_by_watchpoint
;
2639 current_target
.to_stopped_data_address
= debug_to_stopped_data_address
;
2640 current_target
.to_region_ok_for_hw_watchpoint
= debug_to_region_ok_for_hw_watchpoint
;
2641 current_target
.to_terminal_init
= debug_to_terminal_init
;
2642 current_target
.to_terminal_inferior
= debug_to_terminal_inferior
;
2643 current_target
.to_terminal_ours_for_output
= debug_to_terminal_ours_for_output
;
2644 current_target
.to_terminal_ours
= debug_to_terminal_ours
;
2645 current_target
.to_terminal_save_ours
= debug_to_terminal_save_ours
;
2646 current_target
.to_terminal_info
= debug_to_terminal_info
;
2647 current_target
.to_kill
= debug_to_kill
;
2648 current_target
.to_load
= debug_to_load
;
2649 current_target
.to_lookup_symbol
= debug_to_lookup_symbol
;
2650 current_target
.to_create_inferior
= debug_to_create_inferior
;
2651 current_target
.to_post_startup_inferior
= debug_to_post_startup_inferior
;
2652 current_target
.to_acknowledge_created_inferior
= debug_to_acknowledge_created_inferior
;
2653 current_target
.to_insert_fork_catchpoint
= debug_to_insert_fork_catchpoint
;
2654 current_target
.to_remove_fork_catchpoint
= debug_to_remove_fork_catchpoint
;
2655 current_target
.to_insert_vfork_catchpoint
= debug_to_insert_vfork_catchpoint
;
2656 current_target
.to_remove_vfork_catchpoint
= debug_to_remove_vfork_catchpoint
;
2657 current_target
.to_insert_exec_catchpoint
= debug_to_insert_exec_catchpoint
;
2658 current_target
.to_remove_exec_catchpoint
= debug_to_remove_exec_catchpoint
;
2659 current_target
.to_reported_exec_events_per_exec_call
= debug_to_reported_exec_events_per_exec_call
;
2660 current_target
.to_has_exited
= debug_to_has_exited
;
2661 current_target
.to_mourn_inferior
= debug_to_mourn_inferior
;
2662 current_target
.to_can_run
= debug_to_can_run
;
2663 current_target
.to_notice_signals
= debug_to_notice_signals
;
2664 current_target
.to_thread_alive
= debug_to_thread_alive
;
2665 current_target
.to_find_new_threads
= debug_to_find_new_threads
;
2666 current_target
.to_stop
= debug_to_stop
;
2667 current_target
.to_rcmd
= debug_to_rcmd
;
2668 current_target
.to_enable_exception_callback
= debug_to_enable_exception_callback
;
2669 current_target
.to_get_current_exception_event
= debug_to_get_current_exception_event
;
2670 current_target
.to_pid_to_exec_file
= debug_to_pid_to_exec_file
;
2674 static char targ_desc
[] =
2675 "Names of targets and files being debugged.\n\
2676 Shows the entire stack of targets currently in use (including the exec-file,\n\
2677 core-file, and process, if any), as well as the symbol file name.";
2680 do_monitor_command (char *cmd
,
2683 if ((current_target
.to_rcmd
2684 == (void (*) (char *, struct ui_file
*)) tcomplain
)
2685 || (current_target
.to_rcmd
== debug_to_rcmd
2686 && (debug_target
.to_rcmd
2687 == (void (*) (char *, struct ui_file
*)) tcomplain
)))
2688 error (_("\"monitor\" command not supported by this target."));
2689 target_rcmd (cmd
, gdb_stdtarg
);
2693 initialize_targets (void)
2695 init_dummy_target ();
2696 push_target (&dummy_target
);
2698 add_info ("target", target_info
, targ_desc
);
2699 add_info ("files", target_info
, targ_desc
);
2701 add_setshow_zinteger_cmd ("target", class_maintenance
, &targetdebug
, _("\
2702 Set target debugging."), _("\
2703 Show target debugging."), _("\
2704 When non-zero, target debugging is enabled. Higher numbers are more\n\
2705 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2709 &setdebuglist
, &showdebuglist
);
2711 add_setshow_boolean_cmd ("trust-readonly-sections", class_support
,
2712 &trust_readonly
, _("\
2713 Set mode for reading from readonly sections."), _("\
2714 Show mode for reading from readonly sections."), _("\
2715 When this mode is on, memory reads from readonly sections (such as .text)\n\
2716 will be read from the object file instead of from the target. This will\n\
2717 result in significant performance improvement for remote targets."),
2719 show_trust_readonly
,
2720 &setlist
, &showlist
);
2722 add_com ("monitor", class_obscure
, do_monitor_command
,
2723 _("Send a command to the remote monitor (remote targets only)."));
2725 target_dcache
= dcache_init ();