* target.c (target_resize_to_sections): Check
[external/binutils.git] / gdb / target.c
1 /* Select target systems and architectures at runtime for GDB.
2
3    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6    Contributed by Cygnus Support.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place - Suite 330,
23    Boston, MA 02111-1307, USA.  */
24
25 #include "defs.h"
26 #include <errno.h>
27 #include "gdb_string.h"
28 #include "target.h"
29 #include "gdbcmd.h"
30 #include "symtab.h"
31 #include "inferior.h"
32 #include "bfd.h"
33 #include "symfile.h"
34 #include "objfiles.h"
35 #include "gdb_wait.h"
36 #include "dcache.h"
37 #include <signal.h>
38 #include "regcache.h"
39 #include "gdb_assert.h"
40 #include "gdbcore.h"
41
42 static void target_info (char *, int);
43
44 static void maybe_kill_then_attach (char *, int);
45
46 static void kill_or_be_killed (int);
47
48 static void default_terminal_info (char *, int);
49
50 static int default_region_size_ok_for_hw_watchpoint (int);
51
52 static int nosymbol (char *, CORE_ADDR *);
53
54 static void tcomplain (void);
55
56 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
57
58 static int return_zero (void);
59
60 static int return_one (void);
61
62 static int return_minus_one (void);
63
64 void target_ignore (void);
65
66 static void target_command (char *, int);
67
68 static struct target_ops *find_default_run_target (char *);
69
70 static void nosupport_runtime (void);
71
72 static LONGEST default_xfer_partial (struct target_ops *ops,
73                                      enum target_object object,
74                                      const char *annex, void *readbuf,
75                                      const void *writebuf,
76                                      ULONGEST offset, LONGEST len);
77
78 /* Transfer LEN bytes between target address MEMADDR and GDB address
79    MYADDR.  Returns 0 for success, errno code for failure (which
80    includes partial transfers -- if you want a more useful response to
81    partial transfers, try either target_read_memory_partial or
82    target_write_memory_partial).  */
83
84 static int target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
85                                int write);
86
87 static void init_dummy_target (void);
88
89 static void debug_to_open (char *, int);
90
91 static void debug_to_close (int);
92
93 static void debug_to_attach (char *, int);
94
95 static void debug_to_detach (char *, int);
96
97 static void debug_to_disconnect (char *, int);
98
99 static void debug_to_resume (ptid_t, int, enum target_signal);
100
101 static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
102
103 static void debug_to_fetch_registers (int);
104
105 static void debug_to_store_registers (int);
106
107 static void debug_to_prepare_to_store (void);
108
109 static int debug_to_xfer_memory (CORE_ADDR, char *, int, int,
110                                  struct mem_attrib *, struct target_ops *);
111
112 static void debug_to_files_info (struct target_ops *);
113
114 static int debug_to_insert_breakpoint (CORE_ADDR, char *);
115
116 static int debug_to_remove_breakpoint (CORE_ADDR, char *);
117
118 static int debug_to_can_use_hw_breakpoint (int, int, int);
119
120 static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *);
121
122 static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *);
123
124 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
125
126 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
127
128 static int debug_to_stopped_by_watchpoint (void);
129
130 static CORE_ADDR debug_to_stopped_data_address (void);
131
132 static int debug_to_region_size_ok_for_hw_watchpoint (int);
133
134 static void debug_to_terminal_init (void);
135
136 static void debug_to_terminal_inferior (void);
137
138 static void debug_to_terminal_ours_for_output (void);
139
140 static void debug_to_terminal_save_ours (void);
141
142 static void debug_to_terminal_ours (void);
143
144 static void debug_to_terminal_info (char *, int);
145
146 static void debug_to_kill (void);
147
148 static void debug_to_load (char *, int);
149
150 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
151
152 static void debug_to_mourn_inferior (void);
153
154 static int debug_to_can_run (void);
155
156 static void debug_to_notice_signals (ptid_t);
157
158 static int debug_to_thread_alive (ptid_t);
159
160 static void debug_to_stop (void);
161
162 /* Pointer to array of target architecture structures; the size of the
163    array; the current index into the array; the allocated size of the 
164    array.  */
165 struct target_ops **target_structs;
166 unsigned target_struct_size;
167 unsigned target_struct_index;
168 unsigned target_struct_allocsize;
169 #define DEFAULT_ALLOCSIZE       10
170
171 /* The initial current target, so that there is always a semi-valid
172    current target.  */
173
174 static struct target_ops dummy_target;
175
176 /* Top of target stack.  */
177
178 static struct target_ops *target_stack;
179
180 /* The target structure we are currently using to talk to a process
181    or file or whatever "inferior" we have.  */
182
183 struct target_ops current_target;
184
185 /* Command list for target.  */
186
187 static struct cmd_list_element *targetlist = NULL;
188
189 /* Nonzero if we are debugging an attached outside process
190    rather than an inferior.  */
191
192 int attach_flag;
193
194 /* Non-zero if we want to see trace of target level stuff.  */
195
196 static int targetdebug = 0;
197
198 static void setup_target_debug (void);
199
200 DCACHE *target_dcache;
201
202 /* The user just typed 'target' without the name of a target.  */
203
204 static void
205 target_command (char *arg, int from_tty)
206 {
207   fputs_filtered ("Argument required (target name).  Try `help target'\n",
208                   gdb_stdout);
209 }
210
211 /* Add a possible target architecture to the list.  */
212
213 void
214 add_target (struct target_ops *t)
215 {
216   /* Provide default values for all "must have" methods.  */
217   if (t->to_xfer_partial == NULL)
218     t->to_xfer_partial = default_xfer_partial;
219
220   if (!target_structs)
221     {
222       target_struct_allocsize = DEFAULT_ALLOCSIZE;
223       target_structs = (struct target_ops **) xmalloc
224         (target_struct_allocsize * sizeof (*target_structs));
225     }
226   if (target_struct_size >= target_struct_allocsize)
227     {
228       target_struct_allocsize *= 2;
229       target_structs = (struct target_ops **)
230         xrealloc ((char *) target_structs,
231                   target_struct_allocsize * sizeof (*target_structs));
232     }
233   target_structs[target_struct_size++] = t;
234
235   if (targetlist == NULL)
236     add_prefix_cmd ("target", class_run, target_command,
237                     "Connect to a target machine or process.\n\
238 The first argument is the type or protocol of the target machine.\n\
239 Remaining arguments are interpreted by the target protocol.  For more\n\
240 information on the arguments for a particular protocol, type\n\
241 `help target ' followed by the protocol name.",
242                     &targetlist, "target ", 0, &cmdlist);
243   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
244 }
245
246 /* Stub functions */
247
248 void
249 target_ignore (void)
250 {
251 }
252
253 void
254 target_load (char *arg, int from_tty)
255 {
256   dcache_invalidate (target_dcache);
257   (*current_target.to_load) (arg, from_tty);
258 }
259
260 static int
261 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
262           struct target_ops *t)
263 {
264   errno = EIO;                  /* Can't read/write this location */
265   return 0;                     /* No bytes handled */
266 }
267
268 static void
269 tcomplain (void)
270 {
271   error ("You can't do that when your target is `%s'",
272          current_target.to_shortname);
273 }
274
275 void
276 noprocess (void)
277 {
278   error ("You can't do that without a process to debug.");
279 }
280
281 static int
282 nosymbol (char *name, CORE_ADDR *addrp)
283 {
284   return 1;                     /* Symbol does not exist in target env */
285 }
286
287 static void
288 nosupport_runtime (void)
289 {
290   if (ptid_equal (inferior_ptid, null_ptid))
291     noprocess ();
292   else
293     error ("No run-time support for this");
294 }
295
296
297 static void
298 default_terminal_info (char *args, int from_tty)
299 {
300   printf_unfiltered ("No saved terminal information.\n");
301 }
302
303 /* This is the default target_create_inferior and target_attach function.
304    If the current target is executing, it asks whether to kill it off.
305    If this function returns without calling error(), it has killed off
306    the target, and the operation should be attempted.  */
307
308 static void
309 kill_or_be_killed (int from_tty)
310 {
311   if (target_has_execution)
312     {
313       printf_unfiltered ("You are already running a program:\n");
314       target_files_info ();
315       if (query ("Kill it? "))
316         {
317           target_kill ();
318           if (target_has_execution)
319             error ("Killing the program did not help.");
320           return;
321         }
322       else
323         {
324           error ("Program not killed.");
325         }
326     }
327   tcomplain ();
328 }
329
330 static void
331 maybe_kill_then_attach (char *args, int from_tty)
332 {
333   kill_or_be_killed (from_tty);
334   target_attach (args, from_tty);
335 }
336
337 static void
338 maybe_kill_then_create_inferior (char *exec, char *args, char **env,
339                                  int from_tty)
340 {
341   kill_or_be_killed (0);
342   target_create_inferior (exec, args, env, from_tty);
343 }
344
345 /* Go through the target stack from top to bottom, copying over zero
346    entries in current_target, then filling in still empty entries.  In
347    effect, we are doing class inheritance through the pushed target
348    vectors.
349
350    NOTE: cagney/2003-10-17: The problem with this inheritance, as it
351    is currently implemented, is that it discards any knowledge of
352    which target an inherited method originally belonged to.
353    Consequently, new new target methods should instead explicitly and
354    locally search the target stack for the target that can handle the
355    request.  */
356
357 static void
358 update_current_target (void)
359 {
360   struct target_ops *t;
361
362   /* First, reset curren'ts contents.  */
363   memset (&current_target, 0, sizeof (current_target));
364
365 #define INHERIT(FIELD, TARGET) \
366       if (!current_target.FIELD) \
367         current_target.FIELD = (TARGET)->FIELD
368
369   for (t = target_stack; t; t = t->beneath)
370     {
371       INHERIT (to_shortname, t);
372       INHERIT (to_longname, t);
373       INHERIT (to_doc, t);
374       INHERIT (to_open, t);
375       INHERIT (to_close, t);
376       INHERIT (to_attach, t);
377       INHERIT (to_post_attach, t);
378       INHERIT (to_detach, t);
379       INHERIT (to_disconnect, t);
380       INHERIT (to_resume, t);
381       INHERIT (to_wait, t);
382       INHERIT (to_post_wait, t);
383       INHERIT (to_fetch_registers, t);
384       INHERIT (to_store_registers, t);
385       INHERIT (to_prepare_to_store, t);
386       INHERIT (to_xfer_memory, t);
387       INHERIT (to_files_info, t);
388       INHERIT (to_insert_breakpoint, t);
389       INHERIT (to_remove_breakpoint, t);
390       INHERIT (to_can_use_hw_breakpoint, t);
391       INHERIT (to_insert_hw_breakpoint, t);
392       INHERIT (to_remove_hw_breakpoint, t);
393       INHERIT (to_insert_watchpoint, t);
394       INHERIT (to_remove_watchpoint, t);
395       INHERIT (to_stopped_data_address, t);
396       INHERIT (to_stopped_by_watchpoint, t);
397       INHERIT (to_have_continuable_watchpoint, t);
398       INHERIT (to_region_size_ok_for_hw_watchpoint, t);
399       INHERIT (to_terminal_init, t);
400       INHERIT (to_terminal_inferior, t);
401       INHERIT (to_terminal_ours_for_output, t);
402       INHERIT (to_terminal_ours, t);
403       INHERIT (to_terminal_save_ours, t);
404       INHERIT (to_terminal_info, t);
405       INHERIT (to_kill, t);
406       INHERIT (to_load, t);
407       INHERIT (to_lookup_symbol, t);
408       INHERIT (to_create_inferior, t);
409       INHERIT (to_post_startup_inferior, t);
410       INHERIT (to_acknowledge_created_inferior, t);
411       INHERIT (to_insert_fork_catchpoint, t);
412       INHERIT (to_remove_fork_catchpoint, t);
413       INHERIT (to_insert_vfork_catchpoint, t);
414       INHERIT (to_remove_vfork_catchpoint, t);
415       INHERIT (to_follow_fork, t);
416       INHERIT (to_insert_exec_catchpoint, t);
417       INHERIT (to_remove_exec_catchpoint, t);
418       INHERIT (to_reported_exec_events_per_exec_call, t);
419       INHERIT (to_has_exited, t);
420       INHERIT (to_mourn_inferior, t);
421       INHERIT (to_can_run, t);
422       INHERIT (to_notice_signals, t);
423       INHERIT (to_thread_alive, t);
424       INHERIT (to_find_new_threads, t);
425       INHERIT (to_pid_to_str, t);
426       INHERIT (to_extra_thread_info, t);
427       INHERIT (to_stop, t);
428       /* Do not inherit to_xfer_partial.  */
429       INHERIT (to_rcmd, t);
430       INHERIT (to_enable_exception_callback, t);
431       INHERIT (to_get_current_exception_event, t);
432       INHERIT (to_pid_to_exec_file, t);
433       INHERIT (to_stratum, t);
434       INHERIT (to_has_all_memory, t);
435       INHERIT (to_has_memory, t);
436       INHERIT (to_has_stack, t);
437       INHERIT (to_has_registers, t);
438       INHERIT (to_has_execution, t);
439       INHERIT (to_has_thread_control, t);
440       INHERIT (to_sections, t);
441       INHERIT (to_sections_end, t);
442       INHERIT (to_can_async_p, t);
443       INHERIT (to_is_async_p, t);
444       INHERIT (to_async, t);
445       INHERIT (to_async_mask_value, t);
446       INHERIT (to_find_memory_regions, t);
447       INHERIT (to_make_corefile_notes, t);
448       INHERIT (to_get_thread_local_address, t);
449       INHERIT (to_magic, t);
450     }
451 #undef INHERIT
452
453   /* Clean up a target struct so it no longer has any zero pointers in
454      it.  Some entries are defaulted to a method that print an error,
455      others are hard-wired to a standard recursive default.  */
456
457 #define de_fault(field, value) \
458   if (!current_target.field)               \
459     current_target.field = value
460
461   de_fault (to_open, 
462             (void (*) (char *, int)) 
463             tcomplain);
464   de_fault (to_close, 
465             (void (*) (int)) 
466             target_ignore);
467   de_fault (to_attach, 
468             maybe_kill_then_attach);
469   de_fault (to_post_attach, 
470             (void (*) (int)) 
471             target_ignore);
472   de_fault (to_detach, 
473             (void (*) (char *, int)) 
474             target_ignore);
475   de_fault (to_disconnect, 
476             (void (*) (char *, int)) 
477             tcomplain);
478   de_fault (to_resume, 
479             (void (*) (ptid_t, int, enum target_signal)) 
480             noprocess);
481   de_fault (to_wait, 
482             (ptid_t (*) (ptid_t, struct target_waitstatus *)) 
483             noprocess);
484   de_fault (to_post_wait, 
485             (void (*) (ptid_t, int)) 
486             target_ignore);
487   de_fault (to_fetch_registers, 
488             (void (*) (int)) 
489             target_ignore);
490   de_fault (to_store_registers, 
491             (void (*) (int)) 
492             noprocess);
493   de_fault (to_prepare_to_store, 
494             (void (*) (void)) 
495             noprocess);
496   de_fault (to_xfer_memory, 
497             (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *)) 
498             nomemory);
499   de_fault (to_files_info, 
500             (void (*) (struct target_ops *)) 
501             target_ignore);
502   de_fault (to_insert_breakpoint, 
503             memory_insert_breakpoint);
504   de_fault (to_remove_breakpoint, 
505             memory_remove_breakpoint);
506   de_fault (to_can_use_hw_breakpoint,
507             (int (*) (int, int, int))
508             return_zero);
509   de_fault (to_insert_hw_breakpoint,
510             (int (*) (CORE_ADDR, char *))
511             return_minus_one);
512   de_fault (to_remove_hw_breakpoint,
513             (int (*) (CORE_ADDR, char *))
514             return_minus_one);
515   de_fault (to_insert_watchpoint,
516             (int (*) (CORE_ADDR, int, int))
517             return_minus_one);
518   de_fault (to_remove_watchpoint,
519             (int (*) (CORE_ADDR, int, int))
520             return_minus_one);
521   de_fault (to_stopped_by_watchpoint,
522             (int (*) (void))
523             return_zero);
524   de_fault (to_stopped_data_address,
525             (CORE_ADDR (*) (void))
526             return_zero);
527   de_fault (to_region_size_ok_for_hw_watchpoint,
528             default_region_size_ok_for_hw_watchpoint);
529   de_fault (to_terminal_init, 
530             (void (*) (void)) 
531             target_ignore);
532   de_fault (to_terminal_inferior, 
533             (void (*) (void)) 
534             target_ignore);
535   de_fault (to_terminal_ours_for_output, 
536             (void (*) (void)) 
537             target_ignore);
538   de_fault (to_terminal_ours, 
539             (void (*) (void)) 
540             target_ignore);
541   de_fault (to_terminal_save_ours, 
542             (void (*) (void)) 
543             target_ignore);
544   de_fault (to_terminal_info, 
545             default_terminal_info);
546   de_fault (to_kill, 
547             (void (*) (void)) 
548             noprocess);
549   de_fault (to_load, 
550             (void (*) (char *, int)) 
551             tcomplain);
552   de_fault (to_lookup_symbol, 
553             (int (*) (char *, CORE_ADDR *)) 
554             nosymbol);
555   de_fault (to_create_inferior, 
556             maybe_kill_then_create_inferior);
557   de_fault (to_post_startup_inferior, 
558             (void (*) (ptid_t)) 
559             target_ignore);
560   de_fault (to_acknowledge_created_inferior, 
561             (void (*) (int)) 
562             target_ignore);
563   de_fault (to_insert_fork_catchpoint, 
564             (int (*) (int)) 
565             tcomplain);
566   de_fault (to_remove_fork_catchpoint, 
567             (int (*) (int)) 
568             tcomplain);
569   de_fault (to_insert_vfork_catchpoint, 
570             (int (*) (int)) 
571             tcomplain);
572   de_fault (to_remove_vfork_catchpoint, 
573             (int (*) (int)) 
574             tcomplain);
575   de_fault (to_follow_fork,
576             (int (*) (int)) 
577             target_ignore);
578   de_fault (to_insert_exec_catchpoint, 
579             (int (*) (int)) 
580             tcomplain);
581   de_fault (to_remove_exec_catchpoint, 
582             (int (*) (int)) 
583             tcomplain);
584   de_fault (to_reported_exec_events_per_exec_call, 
585             (int (*) (void)) 
586             return_one);
587   de_fault (to_has_exited, 
588             (int (*) (int, int, int *)) 
589             return_zero);
590   de_fault (to_mourn_inferior, 
591             (void (*) (void)) 
592             noprocess);
593   de_fault (to_can_run, 
594             return_zero);
595   de_fault (to_notice_signals, 
596             (void (*) (ptid_t)) 
597             target_ignore);
598   de_fault (to_thread_alive, 
599             (int (*) (ptid_t)) 
600             return_zero);
601   de_fault (to_find_new_threads, 
602             (void (*) (void)) 
603             target_ignore);
604   de_fault (to_extra_thread_info, 
605             (char *(*) (struct thread_info *)) 
606             return_zero);
607   de_fault (to_stop, 
608             (void (*) (void)) 
609             target_ignore);
610   current_target.to_xfer_partial = default_xfer_partial;
611   de_fault (to_rcmd, 
612             (void (*) (char *, struct ui_file *)) 
613             tcomplain);
614   de_fault (to_enable_exception_callback, 
615             (struct symtab_and_line * (*) (enum exception_event_kind, int)) 
616             nosupport_runtime);
617   de_fault (to_get_current_exception_event, 
618             (struct exception_event_record * (*) (void)) 
619             nosupport_runtime);
620   de_fault (to_pid_to_exec_file, 
621             (char *(*) (int)) 
622             return_zero);
623   de_fault (to_can_async_p, 
624             (int (*) (void)) 
625             return_zero);
626   de_fault (to_is_async_p, 
627             (int (*) (void)) 
628             return_zero);
629   de_fault (to_async, 
630             (void (*) (void (*) (enum inferior_event_type, void*), void*)) 
631             tcomplain);
632 #undef de_fault
633
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;
638 }
639
640 /* Push a new target type into the stack of the existing target accessors,
641    possibly superseding some of the existing accessors.
642
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.
645
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
648    checking them.  */
649
650 int
651 push_target (struct target_ops *t)
652 {
653   struct target_ops **cur;
654
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)
658     {
659       fprintf_unfiltered (gdb_stderr,
660                           "Magic number of %s target struct wrong\n",
661                           t->to_shortname);
662       internal_error (__FILE__, __LINE__, "failed internal consistency check");
663     }
664
665   /* Find the proper stratum to install this target in.  */
666   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
667     {
668       if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
669         break;
670     }
671
672   /* If there's already targets at this stratum, remove them.  */
673   /* FIXME: cagney/2003-10-15: I think this should be poping all
674      targets to CUR, and not just those at this stratum level.  */
675   while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
676     {
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;
681       tmp->beneath = NULL;
682       target_close (tmp, 0);
683     }
684
685   /* We have removed all targets in our stratum, now add the new one.  */
686   t->beneath = (*cur);
687   (*cur) = t;
688
689   update_current_target ();
690
691   if (targetdebug)
692     setup_target_debug ();
693
694   /* Not on top?  */
695   return (t != target_stack);
696 }
697
698 /* Remove a target_ops vector from the stack, wherever it may be. 
699    Return how many times it was removed (0 or 1).  */
700
701 int
702 unpush_target (struct target_ops *t)
703 {
704   struct target_ops **cur;
705   struct target_ops *tmp;
706
707   /* Look for the specified target.  Note that we assume that a target
708      can only occur once in the target stack. */
709
710   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
711     {
712       if ((*cur) == t)
713         break;
714     }
715
716   if ((*cur) == NULL)
717     return 0;                   /* Didn't find target_ops, quit now */
718
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.  */
725   target_close (t, 0);
726
727   /* Unchain the target */
728   tmp = (*cur);
729   (*cur) = (*cur)->beneath;
730   tmp->beneath = NULL;
731
732   update_current_target ();
733
734   return 1;
735 }
736
737 void
738 pop_target (void)
739 {
740   target_close (&current_target, 0);    /* Let it clean up */
741   if (unpush_target (target_stack) == 1)
742     return;
743
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");
748 }
749
750 #undef  MIN
751 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
752
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
757    read.  */
758
759 int
760 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
761 {
762   int tlen, origlen, offset, i;
763   char buf[4];
764   int errcode = 0;
765   char *buffer;
766   int buffer_allocated;
767   char *bufptr;
768   unsigned int nbytes_read = 0;
769
770   /* Small for testing.  */
771   buffer_allocated = 4;
772   buffer = xmalloc (buffer_allocated);
773   bufptr = buffer;
774
775   origlen = len;
776
777   while (len > 0)
778     {
779       tlen = MIN (len, 4 - (memaddr & 3));
780       offset = memaddr & 3;
781
782       errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
783       if (errcode != 0)
784         {
785           /* The transfer request might have crossed the boundary to an
786              unallocated region of memory. Retry the transfer, requesting
787              a single byte.  */
788           tlen = 1;
789           offset = 0;
790           errcode = target_xfer_memory (memaddr, buf, 1, 0);
791           if (errcode != 0)
792             goto done;
793         }
794
795       if (bufptr - buffer + tlen > buffer_allocated)
796         {
797           unsigned int bytes;
798           bytes = bufptr - buffer;
799           buffer_allocated *= 2;
800           buffer = xrealloc (buffer, buffer_allocated);
801           bufptr = buffer + bytes;
802         }
803
804       for (i = 0; i < tlen; i++)
805         {
806           *bufptr++ = buf[i + offset];
807           if (buf[i + offset] == '\000')
808             {
809               nbytes_read += i + 1;
810               goto done;
811             }
812         }
813
814       memaddr += tlen;
815       len -= tlen;
816       nbytes_read += tlen;
817     }
818 done:
819   if (errnop != NULL)
820     *errnop = errcode;
821   if (string != NULL)
822     *string = buffer;
823   return nbytes_read;
824 }
825
826 /* Find a section containing ADDR.  */
827 struct section_table *
828 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
829 {
830   struct section_table *secp;
831   for (secp = target->to_sections;
832        secp < target->to_sections_end;
833        secp++)
834     {
835       if (addr >= secp->addr && addr < secp->endaddr)
836         return secp;
837     }
838   return NULL;
839 }
840
841 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
842    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
843    if any error occurs.
844
845    If an error occurs, no guarantee is made about the contents of the data at
846    MYADDR.  In particular, the caller should not depend upon partial reads
847    filling the buffer with good data.  There is no way for the caller to know
848    how much good data might have been transfered anyway.  Callers that can
849    deal with partial reads should call target_read_memory_partial. */
850
851 int
852 target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
853 {
854   return target_xfer_memory (memaddr, myaddr, len, 0);
855 }
856
857 int
858 target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
859 {
860   return target_xfer_memory (memaddr, myaddr, len, 1);
861 }
862
863 static int trust_readonly = 0;
864
865 /* Move memory to or from the targets.  The top target gets priority;
866    if it cannot handle it, it is offered to the next one down, etc.
867
868    Result is -1 on error, or the number of bytes transfered.  */
869
870 int
871 do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
872                 struct mem_attrib *attrib)
873 {
874   int res;
875   int done = 0;
876   struct target_ops *t;
877
878   /* Zero length requests are ok and require no work.  */
879   if (len == 0)
880     return 0;
881
882   /* to_xfer_memory is not guaranteed to set errno, even when it returns
883      0.  */
884   errno = 0;
885
886   if (!write && trust_readonly)
887     {
888       struct section_table *secp;
889       /* User-settable option, "trust-readonly-sections".  If true,
890          then memory from any SEC_READONLY bfd section may be read
891          directly from the bfd file.  */
892       secp = target_section_by_addr (&current_target, memaddr);
893       if (secp != NULL
894           && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
895               & SEC_READONLY))
896         return xfer_memory (memaddr, myaddr, len, 0, attrib, &current_target);
897     }
898
899   /* The quick case is that the top target can handle the transfer.  */
900   res = current_target.to_xfer_memory
901     (memaddr, myaddr, len, write, attrib, &current_target);
902
903   /* If res <= 0 then we call it again in the loop.  Ah well. */
904   if (res <= 0)
905     {
906       for (t = target_stack; t != NULL; t = t->beneath)
907         {
908           if (!t->to_has_memory)
909             continue;
910
911           res = t->to_xfer_memory (memaddr, myaddr, len, write, attrib, t);
912           if (res > 0)
913             break;              /* Handled all or part of xfer */
914           if (t->to_has_all_memory)
915             break;
916         }
917
918       if (res <= 0)
919         return -1;
920     }
921
922   return res;
923 }
924
925
926 /* Perform a memory transfer.  Iterate until the entire region has
927    been transfered.
928
929    Result is 0 or errno value.  */
930
931 static int
932 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
933 {
934   int res;
935   int reg_len;
936   struct mem_region *region;
937
938   /* Zero length requests are ok and require no work.  */
939   if (len == 0)
940     {
941       return 0;
942     }
943
944   while (len > 0)
945     {
946       region = lookup_mem_region(memaddr);
947       if (memaddr + len < region->hi)
948         reg_len = len;
949       else
950         reg_len = region->hi - memaddr;
951
952       switch (region->attrib.mode)
953         {
954         case MEM_RO:
955           if (write)
956             return EIO;
957           break;
958           
959         case MEM_WO:
960           if (!write)
961             return EIO;
962           break;
963         }
964
965       while (reg_len > 0)
966         {
967           if (region->attrib.cache)
968             res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
969                                      reg_len, write);
970           else
971             res = do_xfer_memory (memaddr, myaddr, reg_len, write,
972                                  &region->attrib);
973               
974           if (res <= 0)
975             {
976               /* If this address is for nonexistent memory, read zeros
977                  if reading, or do nothing if writing.  Return
978                  error. */
979               if (!write)
980                 memset (myaddr, 0, len);
981               if (errno == 0)
982                 return EIO;
983               else
984                 return errno;
985             }
986
987           memaddr += res;
988           myaddr  += res;
989           len     -= res;
990           reg_len -= res;
991         }
992     }
993   
994   return 0;                     /* We managed to cover it all somehow. */
995 }
996
997
998 /* Perform a partial memory transfer.
999
1000    Result is -1 on error, or the number of bytes transfered.  */
1001
1002 static int
1003 target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
1004                             int write_p, int *err)
1005 {
1006   int res;
1007   int reg_len;
1008   struct mem_region *region;
1009
1010   /* Zero length requests are ok and require no work.  */
1011   if (len == 0)
1012     {
1013       *err = 0;
1014       return 0;
1015     }
1016
1017   region = lookup_mem_region(memaddr);
1018   if (memaddr + len < region->hi)
1019     reg_len = len;
1020   else
1021     reg_len = region->hi - memaddr;
1022
1023   switch (region->attrib.mode)
1024     {
1025     case MEM_RO:
1026       if (write_p)
1027         {
1028           *err = EIO;
1029           return -1;
1030         }
1031       break;
1032
1033     case MEM_WO:
1034       if (write_p)
1035         {
1036           *err = EIO;
1037           return -1;
1038         }
1039       break;
1040     }
1041
1042   if (region->attrib.cache)
1043     res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1044                               reg_len, write_p);
1045   else
1046     res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
1047                           &region->attrib);
1048       
1049   if (res <= 0)
1050     {
1051       if (errno != 0)
1052         *err = errno;
1053       else
1054         *err = EIO;
1055
1056         return -1;
1057     }
1058
1059   *err = 0;
1060   return res;
1061 }
1062
1063 int
1064 target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
1065 {
1066   return target_xfer_memory_partial (memaddr, buf, len, 0, err);
1067 }
1068
1069 int
1070 target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
1071 {
1072   return target_xfer_memory_partial (memaddr, buf, len, 1, err);
1073 }
1074
1075 /* More generic transfers.  */
1076
1077 static LONGEST
1078 default_xfer_partial (struct target_ops *ops, enum target_object object,
1079                       const char *annex, void *readbuf, 
1080                       const void *writebuf, ULONGEST offset, LONGEST len)
1081 {
1082   if (object == TARGET_OBJECT_MEMORY
1083       && ops->to_xfer_memory != NULL)
1084     /* If available, fall back to the target's "to_xfer_memory"
1085        method.  */
1086     {
1087       int xfered = -1;
1088       errno = 0;
1089       if (writebuf != NULL)
1090         {
1091           void *buffer = xmalloc (len);
1092           struct cleanup *cleanup = make_cleanup (xfree, buffer);
1093           memcpy (buffer, writebuf, len);
1094           xfered = ops->to_xfer_memory (offset, buffer, len, 1/*write*/, NULL,
1095                                         ops);
1096           do_cleanups (cleanup);
1097         }
1098       if (readbuf != NULL)
1099         xfered = ops->to_xfer_memory (offset, readbuf, len, 0/*read*/, NULL,
1100                                       ops);
1101       if (xfered > 0)
1102         return xfered;
1103       else if (xfered == 0 && errno == 0)
1104         /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1105            indication of an error.  */
1106         return 0;
1107       else
1108         return -1;
1109     }
1110   else if (ops->beneath != NULL)
1111     return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1112                                           readbuf, writebuf, offset, len);
1113   else
1114     return -1;
1115 }
1116
1117 /* Target vector read/write partial wrapper functions.
1118
1119    NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1120    (inbuf, outbuf)", instead of separate read/write methods, make life
1121    easier.  */
1122
1123 LONGEST
1124 target_read_partial (struct target_ops *ops,
1125                      enum target_object object,
1126                      const char *annex, void *buf,
1127                      ULONGEST offset, LONGEST len)
1128 {
1129   gdb_assert (ops->to_xfer_partial != NULL);
1130   return ops->to_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1131 }
1132
1133 LONGEST
1134 target_write_partial (struct target_ops *ops,
1135                       enum target_object object,
1136                       const char *annex, const void *buf,
1137                       ULONGEST offset, LONGEST len)
1138 {
1139   gdb_assert (ops->to_xfer_partial != NULL);
1140   return ops->to_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1141 }
1142
1143 /* Wrappers to perform the full transfer.  */
1144 LONGEST
1145 target_read (struct target_ops *ops,
1146              enum target_object object,
1147              const char *annex, void *buf,
1148              ULONGEST offset, LONGEST len)
1149 {
1150   LONGEST xfered = 0;
1151   while (xfered < len)
1152     {
1153       LONGEST xfer = target_read_partial (ops, object, annex,
1154                                           (bfd_byte *) buf + xfered,
1155                                           offset + xfered, len - xfered);
1156       /* Call an observer, notifying them of the xfer progress?  */
1157       if (xfer <= 0)
1158         /* Call memory_error?  */
1159         return -1;
1160       xfered += xfer;
1161       QUIT;
1162     }
1163   return len;
1164 }
1165
1166 LONGEST
1167 target_write (struct target_ops *ops,
1168               enum target_object object,
1169               const char *annex, const void *buf,
1170               ULONGEST offset, LONGEST len)
1171 {
1172   LONGEST xfered = 0;
1173   while (xfered < len)
1174     {
1175       LONGEST xfer = target_write_partial (ops, object, annex,
1176                                            (bfd_byte *) buf + xfered,
1177                                            offset + xfered, len - xfered);
1178       /* Call an observer, notifying them of the xfer progress?  */
1179       if (xfer <= 0)
1180         /* Call memory_error?  */
1181         return -1;
1182       xfered += xfer;
1183       QUIT;
1184     }
1185   return len;
1186 }
1187
1188 /* Memory transfer methods.  */
1189
1190 void
1191 get_target_memory (struct target_ops *ops, CORE_ADDR addr, void *buf,
1192                    LONGEST len)
1193 {
1194   if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1195       != len)
1196     memory_error (EIO, addr);
1197 }
1198
1199 ULONGEST
1200 get_target_memory_unsigned (struct target_ops *ops,
1201                             CORE_ADDR addr, int len)
1202 {
1203   char buf[sizeof (ULONGEST)];
1204
1205   gdb_assert (len <= sizeof (buf));
1206   get_target_memory (ops, addr, buf, len);
1207   return extract_unsigned_integer (buf, len);
1208 }
1209
1210 static void
1211 target_info (char *args, int from_tty)
1212 {
1213   struct target_ops *t;
1214   int has_all_mem = 0;
1215
1216   if (symfile_objfile != NULL)
1217     printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
1218
1219 #ifdef FILES_INFO_HOOK
1220   if (FILES_INFO_HOOK ())
1221     return;
1222 #endif
1223
1224   for (t = target_stack; t != NULL; t = t->beneath)
1225     {
1226       if (!t->to_has_memory)
1227         continue;
1228
1229       if ((int) (t->to_stratum) <= (int) dummy_stratum)
1230         continue;
1231       if (has_all_mem)
1232         printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1233       printf_unfiltered ("%s:\n", t->to_longname);
1234       (t->to_files_info) (t);
1235       has_all_mem = t->to_has_all_memory;
1236     }
1237 }
1238
1239 /* This is to be called by the open routine before it does
1240    anything.  */
1241
1242 void
1243 target_preopen (int from_tty)
1244 {
1245   dont_repeat ();
1246
1247   if (target_has_execution)
1248     {
1249       if (!from_tty
1250           || query ("A program is being debugged already.  Kill it? "))
1251         target_kill ();
1252       else
1253         error ("Program not killed.");
1254     }
1255
1256   /* Calling target_kill may remove the target from the stack.  But if
1257      it doesn't (which seems like a win for UDI), remove it now.  */
1258
1259   if (target_has_execution)
1260     pop_target ();
1261 }
1262
1263 /* Detach a target after doing deferred register stores.  */
1264
1265 void
1266 target_detach (char *args, int from_tty)
1267 {
1268   (current_target.to_detach) (args, from_tty);
1269 }
1270
1271 void
1272 target_disconnect (char *args, int from_tty)
1273 {
1274   (current_target.to_disconnect) (args, from_tty);
1275 }
1276
1277 void
1278 target_link (char *modname, CORE_ADDR *t_reloc)
1279 {
1280   if (DEPRECATED_STREQ (current_target.to_shortname, "rombug"))
1281     {
1282       (current_target.to_lookup_symbol) (modname, t_reloc);
1283       if (*t_reloc == 0)
1284         error ("Unable to link to %s and get relocation in rombug", modname);
1285     }
1286   else
1287     *t_reloc = (CORE_ADDR) -1;
1288 }
1289
1290 int
1291 target_async_mask (int mask)
1292 {
1293   int saved_async_masked_status = target_async_mask_value;
1294   target_async_mask_value = mask;
1295   return saved_async_masked_status;
1296 }
1297
1298 /* Look through the list of possible targets for a target that can
1299    execute a run or attach command without any other data.  This is
1300    used to locate the default process stratum.
1301
1302    Result is always valid (error() is called for errors).  */
1303
1304 static struct target_ops *
1305 find_default_run_target (char *do_mesg)
1306 {
1307   struct target_ops **t;
1308   struct target_ops *runable = NULL;
1309   int count;
1310
1311   count = 0;
1312
1313   for (t = target_structs; t < target_structs + target_struct_size;
1314        ++t)
1315     {
1316       if ((*t)->to_can_run && target_can_run (*t))
1317         {
1318           runable = *t;
1319           ++count;
1320         }
1321     }
1322
1323   if (count != 1)
1324     error ("Don't know how to %s.  Try \"help target\".", do_mesg);
1325
1326   return runable;
1327 }
1328
1329 void
1330 find_default_attach (char *args, int from_tty)
1331 {
1332   struct target_ops *t;
1333
1334   t = find_default_run_target ("attach");
1335   (t->to_attach) (args, from_tty);
1336   return;
1337 }
1338
1339 void
1340 find_default_create_inferior (char *exec_file, char *allargs, char **env,
1341                               int from_tty)
1342 {
1343   struct target_ops *t;
1344
1345   t = find_default_run_target ("run");
1346   (t->to_create_inferior) (exec_file, allargs, env, from_tty);
1347   return;
1348 }
1349
1350 static int
1351 default_region_size_ok_for_hw_watchpoint (int byte_count)
1352 {
1353   return (byte_count <= TYPE_LENGTH (builtin_type_void_data_ptr));
1354 }
1355
1356 static int
1357 return_zero (void)
1358 {
1359   return 0;
1360 }
1361
1362 static int
1363 return_one (void)
1364 {
1365   return 1;
1366 }
1367
1368 static int
1369 return_minus_one (void)
1370 {
1371   return -1;
1372 }
1373
1374 /*
1375  * Resize the to_sections pointer.  Also make sure that anyone that
1376  * was holding on to an old value of it gets updated.
1377  * Returns the old size.
1378  */
1379
1380 int
1381 target_resize_to_sections (struct target_ops *target, int num_added)
1382 {
1383   struct target_ops **t;
1384   struct section_table *old_value;
1385   int old_count;
1386
1387   old_value = target->to_sections;
1388
1389   if (target->to_sections)
1390     {
1391       old_count = target->to_sections_end - target->to_sections;
1392       target->to_sections = (struct section_table *)
1393         xrealloc ((char *) target->to_sections,
1394                   (sizeof (struct section_table)) * (num_added + old_count));
1395     }
1396   else
1397     {
1398       old_count = 0;
1399       target->to_sections = (struct section_table *)
1400         xmalloc ((sizeof (struct section_table)) * num_added);
1401     }
1402   target->to_sections_end = target->to_sections + (num_added + old_count);
1403
1404   /* Check to see if anyone else was pointing to this structure.
1405      If old_value was null, then no one was. */
1406      
1407   if (old_value)
1408     {
1409       for (t = target_structs; t < target_structs + target_struct_size;
1410            ++t)
1411         {
1412           if ((*t)->to_sections == old_value)
1413             {
1414               (*t)->to_sections = target->to_sections;
1415               (*t)->to_sections_end = target->to_sections_end;
1416             }
1417         }
1418       /* There is a flattened view of the target stack in current_target,
1419          so its to_sections pointer might also need updating. */
1420       if (current_target.to_sections == old_value)
1421         {
1422           current_target.to_sections = target->to_sections;
1423           current_target.to_sections_end = target->to_sections_end;
1424         }
1425     }
1426   
1427   return old_count;
1428
1429 }
1430
1431 /* Remove all target sections taken from ABFD.
1432
1433    Scan the current target stack for targets whose section tables
1434    refer to sections from BFD, and remove those sections.  We use this
1435    when we notice that the inferior has unloaded a shared object, for
1436    example.  */
1437 void
1438 remove_target_sections (bfd *abfd)
1439 {
1440   struct target_ops **t;
1441
1442   for (t = target_structs; t < target_structs + target_struct_size; t++)
1443     {
1444       struct section_table *src, *dest;
1445
1446       dest = (*t)->to_sections;
1447       for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1448         if (src->bfd != abfd)
1449           {
1450             /* Keep this section.  */
1451             if (dest < src) *dest = *src;
1452             dest++;
1453           }
1454
1455       /* If we've dropped any sections, resize the section table.  */
1456       if (dest < src)
1457         target_resize_to_sections (*t, dest - src);
1458     }
1459 }
1460
1461
1462
1463
1464 /* Find a single runnable target in the stack and return it.  If for
1465    some reason there is more than one, return NULL.  */
1466
1467 struct target_ops *
1468 find_run_target (void)
1469 {
1470   struct target_ops **t;
1471   struct target_ops *runable = NULL;
1472   int count;
1473
1474   count = 0;
1475
1476   for (t = target_structs; t < target_structs + target_struct_size; ++t)
1477     {
1478       if ((*t)->to_can_run && target_can_run (*t))
1479         {
1480           runable = *t;
1481           ++count;
1482         }
1483     }
1484
1485   return (count == 1 ? runable : NULL);
1486 }
1487
1488 /* Find a single core_stratum target in the list of targets and return it.
1489    If for some reason there is more than one, return NULL.  */
1490
1491 struct target_ops *
1492 find_core_target (void)
1493 {
1494   struct target_ops **t;
1495   struct target_ops *runable = NULL;
1496   int count;
1497
1498   count = 0;
1499
1500   for (t = target_structs; t < target_structs + target_struct_size;
1501        ++t)
1502     {
1503       if ((*t)->to_stratum == core_stratum)
1504         {
1505           runable = *t;
1506           ++count;
1507         }
1508     }
1509
1510   return (count == 1 ? runable : NULL);
1511 }
1512
1513 /*
1514  * Find the next target down the stack from the specified target.
1515  */
1516
1517 struct target_ops *
1518 find_target_beneath (struct target_ops *t)
1519 {
1520   return t->beneath;
1521 }
1522
1523 \f
1524 /* The inferior process has died.  Long live the inferior!  */
1525
1526 void
1527 generic_mourn_inferior (void)
1528 {
1529   extern int show_breakpoint_hit_counts;
1530
1531   inferior_ptid = null_ptid;
1532   attach_flag = 0;
1533   breakpoint_init_inferior (inf_exited);
1534   registers_changed ();
1535
1536   reopen_exec_file ();
1537   reinit_frame_cache ();
1538
1539   /* It is confusing to the user for ignore counts to stick around
1540      from previous runs of the inferior.  So clear them.  */
1541   /* However, it is more confusing for the ignore counts to disappear when
1542      using hit counts.  So don't clear them if we're counting hits.  */
1543   if (!show_breakpoint_hit_counts)
1544     breakpoint_clear_ignore_counts ();
1545
1546   if (deprecated_detach_hook)
1547     deprecated_detach_hook ();
1548 }
1549 \f
1550 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1551    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1552    translation of that in OURSTATUS.  */
1553 void
1554 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
1555 {
1556 #ifdef CHILD_SPECIAL_WAITSTATUS
1557   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1558      if it wants to deal with hoststatus.  */
1559   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1560     return;
1561 #endif
1562
1563   if (WIFEXITED (hoststatus))
1564     {
1565       ourstatus->kind = TARGET_WAITKIND_EXITED;
1566       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1567     }
1568   else if (!WIFSTOPPED (hoststatus))
1569     {
1570       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1571       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1572     }
1573   else
1574     {
1575       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1576       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1577     }
1578 }
1579 \f
1580 /* Returns zero to leave the inferior alone, one to interrupt it.  */
1581 int (*target_activity_function) (void);
1582 int target_activity_fd;
1583 \f
1584 /* Convert a normal process ID to a string.  Returns the string in a static
1585    buffer.  */
1586
1587 char *
1588 normal_pid_to_str (ptid_t ptid)
1589 {
1590   static char buf[30];
1591
1592   sprintf (buf, "process %d", PIDGET (ptid));
1593   return buf;
1594 }
1595
1596 /* Error-catcher for target_find_memory_regions */
1597 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
1598 {
1599   error ("No target.");
1600   return 0;
1601 }
1602
1603 /* Error-catcher for target_make_corefile_notes */
1604 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
1605 {
1606   error ("No target.");
1607   return NULL;
1608 }
1609
1610 /* Set up the handful of non-empty slots needed by the dummy target
1611    vector.  */
1612
1613 static void
1614 init_dummy_target (void)
1615 {
1616   dummy_target.to_shortname = "None";
1617   dummy_target.to_longname = "None";
1618   dummy_target.to_doc = "";
1619   dummy_target.to_attach = find_default_attach;
1620   dummy_target.to_create_inferior = find_default_create_inferior;
1621   dummy_target.to_pid_to_str = normal_pid_to_str;
1622   dummy_target.to_stratum = dummy_stratum;
1623   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1624   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1625   dummy_target.to_xfer_partial = default_xfer_partial;
1626   dummy_target.to_magic = OPS_MAGIC;
1627 }
1628 \f
1629
1630 static struct target_ops debug_target;
1631
1632 static void
1633 debug_to_open (char *args, int from_tty)
1634 {
1635   debug_target.to_open (args, from_tty);
1636
1637   fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1638 }
1639
1640 static void
1641 debug_to_close (int quitting)
1642 {
1643   target_close (&debug_target, quitting);
1644   fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1645 }
1646
1647 void
1648 target_close (struct target_ops *targ, int quitting)
1649 {
1650   if (targ->to_xclose != NULL)
1651     targ->to_xclose (targ, quitting);
1652   else if (targ->to_close != NULL)
1653     targ->to_close (quitting);
1654 }
1655
1656 static void
1657 debug_to_attach (char *args, int from_tty)
1658 {
1659   debug_target.to_attach (args, from_tty);
1660
1661   fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1662 }
1663
1664
1665 static void
1666 debug_to_post_attach (int pid)
1667 {
1668   debug_target.to_post_attach (pid);
1669
1670   fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1671 }
1672
1673 static void
1674 debug_to_detach (char *args, int from_tty)
1675 {
1676   debug_target.to_detach (args, from_tty);
1677
1678   fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1679 }
1680
1681 static void
1682 debug_to_disconnect (char *args, int from_tty)
1683 {
1684   debug_target.to_disconnect (args, from_tty);
1685
1686   fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1687                       args, from_tty);
1688 }
1689
1690 static void
1691 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1692 {
1693   debug_target.to_resume (ptid, step, siggnal);
1694
1695   fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
1696                       step ? "step" : "continue",
1697                       target_signal_to_name (siggnal));
1698 }
1699
1700 static ptid_t
1701 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1702 {
1703   ptid_t retval;
1704
1705   retval = debug_target.to_wait (ptid, status);
1706
1707   fprintf_unfiltered (gdb_stdlog,
1708                       "target_wait (%d, status) = %d,   ", PIDGET (ptid),
1709                       PIDGET (retval));
1710   fprintf_unfiltered (gdb_stdlog, "status->kind = ");
1711   switch (status->kind)
1712     {
1713     case TARGET_WAITKIND_EXITED:
1714       fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
1715                           status->value.integer);
1716       break;
1717     case TARGET_WAITKIND_STOPPED:
1718       fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
1719                           target_signal_to_name (status->value.sig));
1720       break;
1721     case TARGET_WAITKIND_SIGNALLED:
1722       fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
1723                           target_signal_to_name (status->value.sig));
1724       break;
1725     case TARGET_WAITKIND_LOADED:
1726       fprintf_unfiltered (gdb_stdlog, "loaded\n");
1727       break;
1728     case TARGET_WAITKIND_FORKED:
1729       fprintf_unfiltered (gdb_stdlog, "forked\n");
1730       break;
1731     case TARGET_WAITKIND_VFORKED:
1732       fprintf_unfiltered (gdb_stdlog, "vforked\n");
1733       break;
1734     case TARGET_WAITKIND_EXECD:
1735       fprintf_unfiltered (gdb_stdlog, "execd\n");
1736       break;
1737     case TARGET_WAITKIND_SPURIOUS:
1738       fprintf_unfiltered (gdb_stdlog, "spurious\n");
1739       break;
1740     default:
1741       fprintf_unfiltered (gdb_stdlog, "unknown???\n");
1742       break;
1743     }
1744
1745   return retval;
1746 }
1747
1748 static void
1749 debug_to_post_wait (ptid_t ptid, int status)
1750 {
1751   debug_target.to_post_wait (ptid, status);
1752
1753   fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
1754                       PIDGET (ptid), status);
1755 }
1756
1757 static void
1758 debug_print_register (const char * func, int regno)
1759 {
1760   fprintf_unfiltered (gdb_stdlog, "%s ", func);
1761   if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS
1762       && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0')
1763     fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno));
1764   else
1765     fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1766   if (regno >= 0)
1767     {
1768       int i;
1769       unsigned char buf[MAX_REGISTER_SIZE];
1770       deprecated_read_register_gen (regno, buf);
1771       fprintf_unfiltered (gdb_stdlog, " = ");
1772       for (i = 0; i < register_size (current_gdbarch, regno); i++)
1773         {
1774           fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1775         }
1776       if (register_size (current_gdbarch, regno) <= sizeof (LONGEST))
1777         {
1778           fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
1779                               paddr_nz (read_register (regno)),
1780                               paddr_d (read_register (regno)));
1781         }
1782     }
1783   fprintf_unfiltered (gdb_stdlog, "\n");
1784 }
1785
1786 static void
1787 debug_to_fetch_registers (int regno)
1788 {
1789   debug_target.to_fetch_registers (regno);
1790   debug_print_register ("target_fetch_registers", regno);
1791 }
1792
1793 static void
1794 debug_to_store_registers (int regno)
1795 {
1796   debug_target.to_store_registers (regno);
1797   debug_print_register ("target_store_registers", regno);
1798   fprintf_unfiltered (gdb_stdlog, "\n");
1799 }
1800
1801 static void
1802 debug_to_prepare_to_store (void)
1803 {
1804   debug_target.to_prepare_to_store ();
1805
1806   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
1807 }
1808
1809 static int
1810 debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1811                       struct mem_attrib *attrib,
1812                       struct target_ops *target)
1813 {
1814   int retval;
1815
1816   retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write,
1817                                         attrib, target);
1818
1819   fprintf_unfiltered (gdb_stdlog,
1820                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1821                       (unsigned int) memaddr,   /* possable truncate long long */
1822                       len, write ? "write" : "read", retval);
1823
1824   if (retval > 0)
1825     {
1826       int i;
1827
1828       fputs_unfiltered (", bytes =", gdb_stdlog);
1829       for (i = 0; i < retval; i++)
1830         {
1831           if ((((long) &(myaddr[i])) & 0xf) == 0)
1832             {
1833               if (targetdebug < 2 && i > 0)
1834                 {
1835                   fprintf_unfiltered (gdb_stdlog, " ...");
1836                   break;
1837                 }
1838               fprintf_unfiltered (gdb_stdlog, "\n");
1839             }
1840           
1841           fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1842         }
1843     }
1844
1845   fputc_unfiltered ('\n', gdb_stdlog);
1846
1847   return retval;
1848 }
1849
1850 static void
1851 debug_to_files_info (struct target_ops *target)
1852 {
1853   debug_target.to_files_info (target);
1854
1855   fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
1856 }
1857
1858 static int
1859 debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
1860 {
1861   int retval;
1862
1863   retval = debug_target.to_insert_breakpoint (addr, save);
1864
1865   fprintf_unfiltered (gdb_stdlog,
1866                       "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1867                       (unsigned long) addr,
1868                       (unsigned long) retval);
1869   return retval;
1870 }
1871
1872 static int
1873 debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
1874 {
1875   int retval;
1876
1877   retval = debug_target.to_remove_breakpoint (addr, save);
1878
1879   fprintf_unfiltered (gdb_stdlog,
1880                       "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1881                       (unsigned long) addr,
1882                       (unsigned long) retval);
1883   return retval;
1884 }
1885
1886 static int
1887 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
1888 {
1889   int retval;
1890
1891   retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
1892
1893   fprintf_unfiltered (gdb_stdlog,
1894                       "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1895                       (unsigned long) type,
1896                       (unsigned long) cnt,
1897                       (unsigned long) from_tty,
1898                       (unsigned long) retval);
1899   return retval;
1900 }
1901
1902 static int
1903 debug_to_region_size_ok_for_hw_watchpoint (int byte_count)
1904 {
1905   CORE_ADDR retval;
1906
1907   retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count);
1908
1909   fprintf_unfiltered (gdb_stdlog,
1910                       "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1911                       (unsigned long) byte_count,
1912                       (unsigned long) retval);
1913   return retval;
1914 }
1915
1916 static int
1917 debug_to_stopped_by_watchpoint (void)
1918 {
1919   int retval;
1920
1921   retval = debug_target.to_stopped_by_watchpoint ();
1922
1923   fprintf_unfiltered (gdb_stdlog,
1924                       "STOPPED_BY_WATCHPOINT () = %ld\n",
1925                       (unsigned long) retval);
1926   return retval;
1927 }
1928
1929 static CORE_ADDR
1930 debug_to_stopped_data_address (void)
1931 {
1932   CORE_ADDR retval;
1933
1934   retval = debug_target.to_stopped_data_address ();
1935
1936   fprintf_unfiltered (gdb_stdlog,
1937                       "target_stopped_data_address () = 0x%lx\n",
1938                       (unsigned long) retval);
1939   return retval;
1940 }
1941
1942 static int
1943 debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save)
1944 {
1945   int retval;
1946
1947   retval = debug_target.to_insert_hw_breakpoint (addr, save);
1948
1949   fprintf_unfiltered (gdb_stdlog,
1950                       "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1951                       (unsigned long) addr,
1952                       (unsigned long) retval);
1953   return retval;
1954 }
1955
1956 static int
1957 debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save)
1958 {
1959   int retval;
1960
1961   retval = debug_target.to_remove_hw_breakpoint (addr, save);
1962
1963   fprintf_unfiltered (gdb_stdlog,
1964                       "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1965                       (unsigned long) addr,
1966                       (unsigned long) retval);
1967   return retval;
1968 }
1969
1970 static int
1971 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
1972 {
1973   int retval;
1974
1975   retval = debug_target.to_insert_watchpoint (addr, len, type);
1976
1977   fprintf_unfiltered (gdb_stdlog,
1978                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1979                       (unsigned long) addr, len, type, (unsigned long) retval);
1980   return retval;
1981 }
1982
1983 static int
1984 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
1985 {
1986   int retval;
1987
1988   retval = debug_target.to_insert_watchpoint (addr, len, type);
1989
1990   fprintf_unfiltered (gdb_stdlog,
1991                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1992                       (unsigned long) addr, len, type, (unsigned long) retval);
1993   return retval;
1994 }
1995
1996 static void
1997 debug_to_terminal_init (void)
1998 {
1999   debug_target.to_terminal_init ();
2000
2001   fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2002 }
2003
2004 static void
2005 debug_to_terminal_inferior (void)
2006 {
2007   debug_target.to_terminal_inferior ();
2008
2009   fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2010 }
2011
2012 static void
2013 debug_to_terminal_ours_for_output (void)
2014 {
2015   debug_target.to_terminal_ours_for_output ();
2016
2017   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2018 }
2019
2020 static void
2021 debug_to_terminal_ours (void)
2022 {
2023   debug_target.to_terminal_ours ();
2024
2025   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2026 }
2027
2028 static void
2029 debug_to_terminal_save_ours (void)
2030 {
2031   debug_target.to_terminal_save_ours ();
2032
2033   fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2034 }
2035
2036 static void
2037 debug_to_terminal_info (char *arg, int from_tty)
2038 {
2039   debug_target.to_terminal_info (arg, from_tty);
2040
2041   fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2042                       from_tty);
2043 }
2044
2045 static void
2046 debug_to_kill (void)
2047 {
2048   debug_target.to_kill ();
2049
2050   fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2051 }
2052
2053 static void
2054 debug_to_load (char *args, int from_tty)
2055 {
2056   debug_target.to_load (args, from_tty);
2057
2058   fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2059 }
2060
2061 static int
2062 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2063 {
2064   int retval;
2065
2066   retval = debug_target.to_lookup_symbol (name, addrp);
2067
2068   fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2069
2070   return retval;
2071 }
2072
2073 static void
2074 debug_to_create_inferior (char *exec_file, char *args, char **env,
2075                           int from_tty)
2076 {
2077   debug_target.to_create_inferior (exec_file, args, env, from_tty);
2078
2079   fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2080                       exec_file, args, from_tty);
2081 }
2082
2083 static void
2084 debug_to_post_startup_inferior (ptid_t ptid)
2085 {
2086   debug_target.to_post_startup_inferior (ptid);
2087
2088   fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2089                       PIDGET (ptid));
2090 }
2091
2092 static void
2093 debug_to_acknowledge_created_inferior (int pid)
2094 {
2095   debug_target.to_acknowledge_created_inferior (pid);
2096
2097   fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2098                       pid);
2099 }
2100
2101 static int
2102 debug_to_insert_fork_catchpoint (int pid)
2103 {
2104   int retval;
2105
2106   retval = debug_target.to_insert_fork_catchpoint (pid);
2107
2108   fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
2109                       pid, retval);
2110
2111   return retval;
2112 }
2113
2114 static int
2115 debug_to_remove_fork_catchpoint (int pid)
2116 {
2117   int retval;
2118
2119   retval = debug_target.to_remove_fork_catchpoint (pid);
2120
2121   fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2122                       pid, retval);
2123
2124   return retval;
2125 }
2126
2127 static int
2128 debug_to_insert_vfork_catchpoint (int pid)
2129 {
2130   int retval;
2131
2132   retval = debug_target.to_insert_vfork_catchpoint (pid);
2133
2134   fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
2135                       pid, retval);
2136
2137   return retval;
2138 }
2139
2140 static int
2141 debug_to_remove_vfork_catchpoint (int pid)
2142 {
2143   int retval;
2144
2145   retval = debug_target.to_remove_vfork_catchpoint (pid);
2146
2147   fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2148                       pid, retval);
2149
2150   return retval;
2151 }
2152
2153 static int
2154 debug_to_follow_fork (int follow_child)
2155 {
2156   int retval =  debug_target.to_follow_fork (follow_child);
2157
2158   fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2159                       follow_child, retval);
2160
2161   return retval;
2162 }
2163
2164 static int
2165 debug_to_insert_exec_catchpoint (int pid)
2166 {
2167   int retval;
2168
2169   retval = debug_target.to_insert_exec_catchpoint (pid);
2170
2171   fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
2172                       pid, retval);
2173
2174   return retval;
2175 }
2176
2177 static int
2178 debug_to_remove_exec_catchpoint (int pid)
2179 {
2180   int retval;
2181
2182   retval = debug_target.to_remove_exec_catchpoint (pid);
2183
2184   fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2185                       pid, retval);
2186
2187   return retval;
2188 }
2189
2190 static int
2191 debug_to_reported_exec_events_per_exec_call (void)
2192 {
2193   int reported_exec_events;
2194
2195   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2196
2197   fprintf_unfiltered (gdb_stdlog,
2198                       "target_reported_exec_events_per_exec_call () = %d\n",
2199                       reported_exec_events);
2200
2201   return reported_exec_events;
2202 }
2203
2204 static int
2205 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2206 {
2207   int has_exited;
2208
2209   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2210
2211   fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2212                       pid, wait_status, *exit_status, has_exited);
2213
2214   return has_exited;
2215 }
2216
2217 static void
2218 debug_to_mourn_inferior (void)
2219 {
2220   debug_target.to_mourn_inferior ();
2221
2222   fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2223 }
2224
2225 static int
2226 debug_to_can_run (void)
2227 {
2228   int retval;
2229
2230   retval = debug_target.to_can_run ();
2231
2232   fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2233
2234   return retval;
2235 }
2236
2237 static void
2238 debug_to_notice_signals (ptid_t ptid)
2239 {
2240   debug_target.to_notice_signals (ptid);
2241
2242   fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2243                       PIDGET (ptid));
2244 }
2245
2246 static int
2247 debug_to_thread_alive (ptid_t ptid)
2248 {
2249   int retval;
2250
2251   retval = debug_target.to_thread_alive (ptid);
2252
2253   fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2254                       PIDGET (ptid), retval);
2255
2256   return retval;
2257 }
2258
2259 static void
2260 debug_to_find_new_threads (void)
2261 {
2262   debug_target.to_find_new_threads ();
2263
2264   fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2265 }
2266
2267 static void
2268 debug_to_stop (void)
2269 {
2270   debug_target.to_stop ();
2271
2272   fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2273 }
2274
2275 static LONGEST
2276 debug_to_xfer_partial (struct target_ops *ops, enum target_object object,
2277                        const char *annex, void *readbuf, const void *writebuf,
2278                        ULONGEST offset, LONGEST len)
2279 {
2280   LONGEST retval;
2281
2282   retval = debug_target.to_xfer_partial (&debug_target, object, annex,
2283                                          readbuf, writebuf, offset, len);
2284
2285   fprintf_unfiltered (gdb_stdlog,
2286                       "target_xfer_partial (%d, %s, 0x%lx,  0x%lx,  0x%s, %s) = %s\n",
2287                       (int) object, (annex ? annex : "(null)"),
2288                       (long) readbuf, (long) writebuf, paddr_nz (offset),
2289                       paddr_d (len), paddr_d (retval));
2290
2291   return retval;
2292 }
2293
2294 static void
2295 debug_to_rcmd (char *command,
2296                struct ui_file *outbuf)
2297 {
2298   debug_target.to_rcmd (command, outbuf);
2299   fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2300 }
2301
2302 static struct symtab_and_line *
2303 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2304 {
2305   struct symtab_and_line *result;
2306   result = debug_target.to_enable_exception_callback (kind, enable);
2307   fprintf_unfiltered (gdb_stdlog,
2308                       "target get_exception_callback_sal (%d, %d)\n",
2309                       kind, enable);
2310   return result;
2311 }
2312
2313 static struct exception_event_record *
2314 debug_to_get_current_exception_event (void)
2315 {
2316   struct exception_event_record *result;
2317   result = debug_target.to_get_current_exception_event ();
2318   fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2319   return result;
2320 }
2321
2322 static char *
2323 debug_to_pid_to_exec_file (int pid)
2324 {
2325   char *exec_file;
2326
2327   exec_file = debug_target.to_pid_to_exec_file (pid);
2328
2329   fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2330                       pid, exec_file);
2331
2332   return exec_file;
2333 }
2334
2335 static void
2336 setup_target_debug (void)
2337 {
2338   memcpy (&debug_target, &current_target, sizeof debug_target);
2339
2340   current_target.to_open = debug_to_open;
2341   current_target.to_close = debug_to_close;
2342   current_target.to_attach = debug_to_attach;
2343   current_target.to_post_attach = debug_to_post_attach;
2344   current_target.to_detach = debug_to_detach;
2345   current_target.to_disconnect = debug_to_disconnect;
2346   current_target.to_resume = debug_to_resume;
2347   current_target.to_wait = debug_to_wait;
2348   current_target.to_post_wait = debug_to_post_wait;
2349   current_target.to_fetch_registers = debug_to_fetch_registers;
2350   current_target.to_store_registers = debug_to_store_registers;
2351   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2352   current_target.to_xfer_memory = debug_to_xfer_memory;
2353   current_target.to_files_info = debug_to_files_info;
2354   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2355   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2356   current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2357   current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2358   current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2359   current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2360   current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2361   current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2362   current_target.to_stopped_data_address = debug_to_stopped_data_address;
2363   current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint;
2364   current_target.to_terminal_init = debug_to_terminal_init;
2365   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2366   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2367   current_target.to_terminal_ours = debug_to_terminal_ours;
2368   current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2369   current_target.to_terminal_info = debug_to_terminal_info;
2370   current_target.to_kill = debug_to_kill;
2371   current_target.to_load = debug_to_load;
2372   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2373   current_target.to_create_inferior = debug_to_create_inferior;
2374   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2375   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2376   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2377   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2378   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2379   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2380   current_target.to_follow_fork = debug_to_follow_fork;
2381   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2382   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2383   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2384   current_target.to_has_exited = debug_to_has_exited;
2385   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2386   current_target.to_can_run = debug_to_can_run;
2387   current_target.to_notice_signals = debug_to_notice_signals;
2388   current_target.to_thread_alive = debug_to_thread_alive;
2389   current_target.to_find_new_threads = debug_to_find_new_threads;
2390   current_target.to_stop = debug_to_stop;
2391   current_target.to_xfer_partial = debug_to_xfer_partial;
2392   current_target.to_rcmd = debug_to_rcmd;
2393   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2394   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2395   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2396
2397 }
2398 \f
2399
2400 static char targ_desc[] =
2401 "Names of targets and files being debugged.\n\
2402 Shows the entire stack of targets currently in use (including the exec-file,\n\
2403 core-file, and process, if any), as well as the symbol file name.";
2404
2405 static void
2406 do_monitor_command (char *cmd,
2407                  int from_tty)
2408 {
2409   if ((current_target.to_rcmd
2410        == (void (*) (char *, struct ui_file *)) tcomplain)
2411       || (current_target.to_rcmd == debug_to_rcmd
2412           && (debug_target.to_rcmd
2413               == (void (*) (char *, struct ui_file *)) tcomplain)))
2414     {
2415       error ("\"monitor\" command not supported by this target.\n");
2416     }
2417   target_rcmd (cmd, gdb_stdtarg);
2418 }
2419
2420 void
2421 initialize_targets (void)
2422 {
2423   init_dummy_target ();
2424   push_target (&dummy_target);
2425
2426   add_info ("target", target_info, targ_desc);
2427   add_info ("files", target_info, targ_desc);
2428
2429   deprecated_add_show_from_set 
2430     (add_set_cmd ("target", class_maintenance, var_zinteger,
2431                   (char *) &targetdebug,
2432                   "Set target debugging.\n\
2433 When non-zero, target debugging is enabled.  Higher numbers are more\n\
2434 verbose.  Changes do not take effect until the next \"run\" or \"target\"\n\
2435 command.", &setdebuglist),
2436      &showdebuglist);
2437
2438   add_setshow_boolean_cmd ("trust-readonly-sections", class_support, 
2439                            &trust_readonly, "\
2440 Set mode for reading from readonly sections.", "\
2441 Show mode for reading from readonly sections.", "\
2442 When this mode is on, memory reads from readonly sections (such as .text)\n\
2443 will be read from the object file instead of from the target.  This will\n\
2444 result in significant performance improvement for remote targets.", "\
2445 Mode for reading from readonly sections is %s.",
2446                            NULL, NULL,
2447                            &setlist, &showlist);
2448
2449   add_com ("monitor", class_obscure, do_monitor_command,
2450            "Send a command to the remote monitor (remote targets only).");
2451
2452   target_dcache = dcache_init ();
2453 }