ChangeLog:
[external/binutils.git] / gdb / target.c
1 /* Select target systems and architectures at runtime for GDB.
2
3    Copyright (C) 1990-2012 Free Software Foundation, Inc.
4
5    Contributed by Cygnus Support.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
22 #include "defs.h"
23 #include <errno.h>
24 #include "gdb_string.h"
25 #include "target.h"
26 #include "gdbcmd.h"
27 #include "symtab.h"
28 #include "inferior.h"
29 #include "bfd.h"
30 #include "symfile.h"
31 #include "objfiles.h"
32 #include "gdb_wait.h"
33 #include "dcache.h"
34 #include <signal.h>
35 #include "regcache.h"
36 #include "gdb_assert.h"
37 #include "gdbcore.h"
38 #include "exceptions.h"
39 #include "target-descriptions.h"
40 #include "gdbthread.h"
41 #include "solib.h"
42 #include "exec.h"
43 #include "inline-frame.h"
44 #include "tracepoint.h"
45 #include "gdb/fileio.h"
46
47 static void target_info (char *, int);
48
49 static void default_terminal_info (char *, int);
50
51 static int default_watchpoint_addr_within_range (struct target_ops *,
52                                                  CORE_ADDR, CORE_ADDR, int);
53
54 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
55
56 static void tcomplain (void) ATTRIBUTE_NORETURN;
57
58 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
59
60 static int return_zero (void);
61
62 static int return_one (void);
63
64 static int return_minus_one (void);
65
66 void target_ignore (void);
67
68 static void target_command (char *, int);
69
70 static struct target_ops *find_default_run_target (char *);
71
72 static LONGEST default_xfer_partial (struct target_ops *ops,
73                                      enum target_object object,
74                                      const char *annex, gdb_byte *readbuf,
75                                      const gdb_byte *writebuf,
76                                      ULONGEST offset, LONGEST len);
77
78 static LONGEST current_xfer_partial (struct target_ops *ops,
79                                      enum target_object object,
80                                      const char *annex, gdb_byte *readbuf,
81                                      const gdb_byte *writebuf,
82                                      ULONGEST offset, LONGEST len);
83
84 static LONGEST target_xfer_partial (struct target_ops *ops,
85                                     enum target_object object,
86                                     const char *annex,
87                                     void *readbuf, const void *writebuf,
88                                     ULONGEST offset, LONGEST len);
89
90 static struct gdbarch *default_thread_architecture (struct target_ops *ops,
91                                                     ptid_t ptid);
92
93 static void init_dummy_target (void);
94
95 static struct target_ops debug_target;
96
97 static void debug_to_open (char *, int);
98
99 static void debug_to_prepare_to_store (struct regcache *);
100
101 static void debug_to_files_info (struct target_ops *);
102
103 static int debug_to_insert_breakpoint (struct gdbarch *,
104                                        struct bp_target_info *);
105
106 static int debug_to_remove_breakpoint (struct gdbarch *,
107                                        struct bp_target_info *);
108
109 static int debug_to_can_use_hw_breakpoint (int, int, int);
110
111 static int debug_to_insert_hw_breakpoint (struct gdbarch *,
112                                           struct bp_target_info *);
113
114 static int debug_to_remove_hw_breakpoint (struct gdbarch *,
115                                           struct bp_target_info *);
116
117 static int debug_to_insert_watchpoint (CORE_ADDR, int, int,
118                                        struct expression *);
119
120 static int debug_to_remove_watchpoint (CORE_ADDR, int, int,
121                                        struct expression *);
122
123 static int debug_to_stopped_by_watchpoint (void);
124
125 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
126
127 static int debug_to_watchpoint_addr_within_range (struct target_ops *,
128                                                   CORE_ADDR, CORE_ADDR, int);
129
130 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
131
132 static int debug_to_can_accel_watchpoint_condition (CORE_ADDR, int, int,
133                                                     struct expression *);
134
135 static void debug_to_terminal_init (void);
136
137 static void debug_to_terminal_inferior (void);
138
139 static void debug_to_terminal_ours_for_output (void);
140
141 static void debug_to_terminal_save_ours (void);
142
143 static void debug_to_terminal_ours (void);
144
145 static void debug_to_terminal_info (char *, int);
146
147 static void debug_to_load (char *, int);
148
149 static int debug_to_can_run (void);
150
151 static void debug_to_stop (ptid_t);
152
153 /* Pointer to array of target architecture structures; the size of the
154    array; the current index into the array; the allocated size of the
155    array.  */
156 struct target_ops **target_structs;
157 unsigned target_struct_size;
158 unsigned target_struct_index;
159 unsigned target_struct_allocsize;
160 #define DEFAULT_ALLOCSIZE       10
161
162 /* The initial current target, so that there is always a semi-valid
163    current target.  */
164
165 static struct target_ops dummy_target;
166
167 /* Top of target stack.  */
168
169 static struct target_ops *target_stack;
170
171 /* The target structure we are currently using to talk to a process
172    or file or whatever "inferior" we have.  */
173
174 struct target_ops current_target;
175
176 /* Command list for target.  */
177
178 static struct cmd_list_element *targetlist = NULL;
179
180 /* Nonzero if we should trust readonly sections from the
181    executable when reading memory.  */
182
183 static int trust_readonly = 0;
184
185 /* Nonzero if we should show true memory content including
186    memory breakpoint inserted by gdb.  */
187
188 static int show_memory_breakpoints = 0;
189
190 /* These globals control whether GDB attempts to perform these
191    operations; they are useful for targets that need to prevent
192    inadvertant disruption, such as in non-stop mode.  */
193
194 int may_write_registers = 1;
195
196 int may_write_memory = 1;
197
198 int may_insert_breakpoints = 1;
199
200 int may_insert_tracepoints = 1;
201
202 int may_insert_fast_tracepoints = 1;
203
204 int may_stop = 1;
205
206 /* Non-zero if we want to see trace of target level stuff.  */
207
208 static int targetdebug = 0;
209 static void
210 show_targetdebug (struct ui_file *file, int from_tty,
211                   struct cmd_list_element *c, const char *value)
212 {
213   fprintf_filtered (file, _("Target debugging is %s.\n"), value);
214 }
215
216 static void setup_target_debug (void);
217
218 /* The option sets this.  */
219 static int stack_cache_enabled_p_1 = 1;
220 /* And set_stack_cache_enabled_p updates this.
221    The reason for the separation is so that we don't flush the cache for
222    on->on transitions.  */
223 static int stack_cache_enabled_p = 1;
224
225 /* This is called *after* the stack-cache has been set.
226    Flush the cache for off->on and on->off transitions.
227    There's no real need to flush the cache for on->off transitions,
228    except cleanliness.  */
229
230 static void
231 set_stack_cache_enabled_p (char *args, int from_tty,
232                            struct cmd_list_element *c)
233 {
234   if (stack_cache_enabled_p != stack_cache_enabled_p_1)
235     target_dcache_invalidate ();
236
237   stack_cache_enabled_p = stack_cache_enabled_p_1;
238 }
239
240 static void
241 show_stack_cache_enabled_p (struct ui_file *file, int from_tty,
242                             struct cmd_list_element *c, const char *value)
243 {
244   fprintf_filtered (file, _("Cache use for stack accesses is %s.\n"), value);
245 }
246
247 /* Cache of memory operations, to speed up remote access.  */
248 static DCACHE *target_dcache;
249
250 /* Invalidate the target dcache.  */
251
252 void
253 target_dcache_invalidate (void)
254 {
255   dcache_invalidate (target_dcache);
256 }
257
258 /* The user just typed 'target' without the name of a target.  */
259
260 static void
261 target_command (char *arg, int from_tty)
262 {
263   fputs_filtered ("Argument required (target name).  Try `help target'\n",
264                   gdb_stdout);
265 }
266
267 /* Default target_has_* methods for process_stratum targets.  */
268
269 int
270 default_child_has_all_memory (struct target_ops *ops)
271 {
272   /* If no inferior selected, then we can't read memory here.  */
273   if (ptid_equal (inferior_ptid, null_ptid))
274     return 0;
275
276   return 1;
277 }
278
279 int
280 default_child_has_memory (struct target_ops *ops)
281 {
282   /* If no inferior selected, then we can't read memory here.  */
283   if (ptid_equal (inferior_ptid, null_ptid))
284     return 0;
285
286   return 1;
287 }
288
289 int
290 default_child_has_stack (struct target_ops *ops)
291 {
292   /* If no inferior selected, there's no stack.  */
293   if (ptid_equal (inferior_ptid, null_ptid))
294     return 0;
295
296   return 1;
297 }
298
299 int
300 default_child_has_registers (struct target_ops *ops)
301 {
302   /* Can't read registers from no inferior.  */
303   if (ptid_equal (inferior_ptid, null_ptid))
304     return 0;
305
306   return 1;
307 }
308
309 int
310 default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
311 {
312   /* If there's no thread selected, then we can't make it run through
313      hoops.  */
314   if (ptid_equal (the_ptid, null_ptid))
315     return 0;
316
317   return 1;
318 }
319
320
321 int
322 target_has_all_memory_1 (void)
323 {
324   struct target_ops *t;
325
326   for (t = current_target.beneath; t != NULL; t = t->beneath)
327     if (t->to_has_all_memory (t))
328       return 1;
329
330   return 0;
331 }
332
333 int
334 target_has_memory_1 (void)
335 {
336   struct target_ops *t;
337
338   for (t = current_target.beneath; t != NULL; t = t->beneath)
339     if (t->to_has_memory (t))
340       return 1;
341
342   return 0;
343 }
344
345 int
346 target_has_stack_1 (void)
347 {
348   struct target_ops *t;
349
350   for (t = current_target.beneath; t != NULL; t = t->beneath)
351     if (t->to_has_stack (t))
352       return 1;
353
354   return 0;
355 }
356
357 int
358 target_has_registers_1 (void)
359 {
360   struct target_ops *t;
361
362   for (t = current_target.beneath; t != NULL; t = t->beneath)
363     if (t->to_has_registers (t))
364       return 1;
365
366   return 0;
367 }
368
369 int
370 target_has_execution_1 (ptid_t the_ptid)
371 {
372   struct target_ops *t;
373
374   for (t = current_target.beneath; t != NULL; t = t->beneath)
375     if (t->to_has_execution (t, the_ptid))
376       return 1;
377
378   return 0;
379 }
380
381 int
382 target_has_execution_current (void)
383 {
384   return target_has_execution_1 (inferior_ptid);
385 }
386
387 /* Add a possible target architecture to the list.  */
388
389 void
390 add_target (struct target_ops *t)
391 {
392   /* Provide default values for all "must have" methods.  */
393   if (t->to_xfer_partial == NULL)
394     t->to_xfer_partial = default_xfer_partial;
395
396   if (t->to_has_all_memory == NULL)
397     t->to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
398
399   if (t->to_has_memory == NULL)
400     t->to_has_memory = (int (*) (struct target_ops *)) return_zero;
401
402   if (t->to_has_stack == NULL)
403     t->to_has_stack = (int (*) (struct target_ops *)) return_zero;
404
405   if (t->to_has_registers == NULL)
406     t->to_has_registers = (int (*) (struct target_ops *)) return_zero;
407
408   if (t->to_has_execution == NULL)
409     t->to_has_execution = (int (*) (struct target_ops *, ptid_t)) return_zero;
410
411   if (!target_structs)
412     {
413       target_struct_allocsize = DEFAULT_ALLOCSIZE;
414       target_structs = (struct target_ops **) xmalloc
415         (target_struct_allocsize * sizeof (*target_structs));
416     }
417   if (target_struct_size >= target_struct_allocsize)
418     {
419       target_struct_allocsize *= 2;
420       target_structs = (struct target_ops **)
421         xrealloc ((char *) target_structs,
422                   target_struct_allocsize * sizeof (*target_structs));
423     }
424   target_structs[target_struct_size++] = t;
425
426   if (targetlist == NULL)
427     add_prefix_cmd ("target", class_run, target_command, _("\
428 Connect to a target machine or process.\n\
429 The first argument is the type or protocol of the target machine.\n\
430 Remaining arguments are interpreted by the target protocol.  For more\n\
431 information on the arguments for a particular protocol, type\n\
432 `help target ' followed by the protocol name."),
433                     &targetlist, "target ", 0, &cmdlist);
434   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
435 }
436
437 /* Stub functions */
438
439 void
440 target_ignore (void)
441 {
442 }
443
444 void
445 target_kill (void)
446 {
447   struct target_ops *t;
448
449   for (t = current_target.beneath; t != NULL; t = t->beneath)
450     if (t->to_kill != NULL)
451       {
452         if (targetdebug)
453           fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
454
455         t->to_kill (t);
456         return;
457       }
458
459   noprocess ();
460 }
461
462 void
463 target_load (char *arg, int from_tty)
464 {
465   target_dcache_invalidate ();
466   (*current_target.to_load) (arg, from_tty);
467 }
468
469 void
470 target_create_inferior (char *exec_file, char *args,
471                         char **env, int from_tty)
472 {
473   struct target_ops *t;
474
475   for (t = current_target.beneath; t != NULL; t = t->beneath)
476     {
477       if (t->to_create_inferior != NULL)        
478         {
479           t->to_create_inferior (t, exec_file, args, env, from_tty);
480           if (targetdebug)
481             fprintf_unfiltered (gdb_stdlog,
482                                 "target_create_inferior (%s, %s, xxx, %d)\n",
483                                 exec_file, args, from_tty);
484           return;
485         }
486     }
487
488   internal_error (__FILE__, __LINE__,
489                   _("could not find a target to create inferior"));
490 }
491
492 void
493 target_terminal_inferior (void)
494 {
495   /* A background resume (``run&'') should leave GDB in control of the
496      terminal.  Use target_can_async_p, not target_is_async_p, since at
497      this point the target is not async yet.  However, if sync_execution
498      is not set, we know it will become async prior to resume.  */
499   if (target_can_async_p () && !sync_execution)
500     return;
501
502   /* If GDB is resuming the inferior in the foreground, install
503      inferior's terminal modes.  */
504   (*current_target.to_terminal_inferior) ();
505 }
506
507 static int
508 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
509           struct target_ops *t)
510 {
511   errno = EIO;                  /* Can't read/write this location.  */
512   return 0;                     /* No bytes handled.  */
513 }
514
515 static void
516 tcomplain (void)
517 {
518   error (_("You can't do that when your target is `%s'"),
519          current_target.to_shortname);
520 }
521
522 void
523 noprocess (void)
524 {
525   error (_("You can't do that without a process to debug."));
526 }
527
528 static void
529 default_terminal_info (char *args, int from_tty)
530 {
531   printf_unfiltered (_("No saved terminal information.\n"));
532 }
533
534 /* A default implementation for the to_get_ada_task_ptid target method.
535
536    This function builds the PTID by using both LWP and TID as part of
537    the PTID lwp and tid elements.  The pid used is the pid of the
538    inferior_ptid.  */
539
540 static ptid_t
541 default_get_ada_task_ptid (long lwp, long tid)
542 {
543   return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
544 }
545
546 static enum exec_direction_kind
547 default_execution_direction (void)
548 {
549   if (!target_can_execute_reverse)
550     return EXEC_FORWARD;
551   else if (!target_can_async_p ())
552     return EXEC_FORWARD;
553   else
554     gdb_assert_not_reached ("\
555 to_execution_direction must be implemented for reverse async");
556 }
557
558 /* Go through the target stack from top to bottom, copying over zero
559    entries in current_target, then filling in still empty entries.  In
560    effect, we are doing class inheritance through the pushed target
561    vectors.
562
563    NOTE: cagney/2003-10-17: The problem with this inheritance, as it
564    is currently implemented, is that it discards any knowledge of
565    which target an inherited method originally belonged to.
566    Consequently, new new target methods should instead explicitly and
567    locally search the target stack for the target that can handle the
568    request.  */
569
570 static void
571 update_current_target (void)
572 {
573   struct target_ops *t;
574
575   /* First, reset current's contents.  */
576   memset (&current_target, 0, sizeof (current_target));
577
578 #define INHERIT(FIELD, TARGET) \
579       if (!current_target.FIELD) \
580         current_target.FIELD = (TARGET)->FIELD
581
582   for (t = target_stack; t; t = t->beneath)
583     {
584       INHERIT (to_shortname, t);
585       INHERIT (to_longname, t);
586       INHERIT (to_doc, t);
587       /* Do not inherit to_open.  */
588       /* Do not inherit to_close.  */
589       /* Do not inherit to_attach.  */
590       INHERIT (to_post_attach, t);
591       INHERIT (to_attach_no_wait, t);
592       /* Do not inherit to_detach.  */
593       /* Do not inherit to_disconnect.  */
594       /* Do not inherit to_resume.  */
595       /* Do not inherit to_wait.  */
596       /* Do not inherit to_fetch_registers.  */
597       /* Do not inherit to_store_registers.  */
598       INHERIT (to_prepare_to_store, t);
599       INHERIT (deprecated_xfer_memory, t);
600       INHERIT (to_files_info, t);
601       INHERIT (to_insert_breakpoint, t);
602       INHERIT (to_remove_breakpoint, t);
603       INHERIT (to_can_use_hw_breakpoint, t);
604       INHERIT (to_insert_hw_breakpoint, t);
605       INHERIT (to_remove_hw_breakpoint, t);
606       /* Do not inherit to_ranged_break_num_registers.  */
607       INHERIT (to_insert_watchpoint, t);
608       INHERIT (to_remove_watchpoint, t);
609       /* Do not inherit to_insert_mask_watchpoint.  */
610       /* Do not inherit to_remove_mask_watchpoint.  */
611       INHERIT (to_stopped_data_address, t);
612       INHERIT (to_have_steppable_watchpoint, t);
613       INHERIT (to_have_continuable_watchpoint, t);
614       INHERIT (to_stopped_by_watchpoint, t);
615       INHERIT (to_watchpoint_addr_within_range, t);
616       INHERIT (to_region_ok_for_hw_watchpoint, t);
617       INHERIT (to_can_accel_watchpoint_condition, t);
618       /* Do not inherit to_masked_watch_num_registers.  */
619       INHERIT (to_terminal_init, t);
620       INHERIT (to_terminal_inferior, t);
621       INHERIT (to_terminal_ours_for_output, t);
622       INHERIT (to_terminal_ours, t);
623       INHERIT (to_terminal_save_ours, t);
624       INHERIT (to_terminal_info, t);
625       /* Do not inherit to_kill.  */
626       INHERIT (to_load, t);
627       /* Do no inherit to_create_inferior.  */
628       INHERIT (to_post_startup_inferior, t);
629       INHERIT (to_insert_fork_catchpoint, t);
630       INHERIT (to_remove_fork_catchpoint, t);
631       INHERIT (to_insert_vfork_catchpoint, t);
632       INHERIT (to_remove_vfork_catchpoint, t);
633       /* Do not inherit to_follow_fork.  */
634       INHERIT (to_insert_exec_catchpoint, t);
635       INHERIT (to_remove_exec_catchpoint, t);
636       INHERIT (to_set_syscall_catchpoint, t);
637       INHERIT (to_has_exited, t);
638       /* Do not inherit to_mourn_inferior.  */
639       INHERIT (to_can_run, t);
640       /* Do not inherit to_pass_signals.  */
641       /* Do not inherit to_thread_alive.  */
642       /* Do not inherit to_find_new_threads.  */
643       /* Do not inherit to_pid_to_str.  */
644       INHERIT (to_extra_thread_info, t);
645       INHERIT (to_thread_name, t);
646       INHERIT (to_stop, t);
647       /* Do not inherit to_xfer_partial.  */
648       INHERIT (to_rcmd, t);
649       INHERIT (to_pid_to_exec_file, t);
650       INHERIT (to_log_command, t);
651       INHERIT (to_stratum, t);
652       /* Do not inherit to_has_all_memory.  */
653       /* Do not inherit to_has_memory.  */
654       /* Do not inherit to_has_stack.  */
655       /* Do not inherit to_has_registers.  */
656       /* Do not inherit to_has_execution.  */
657       INHERIT (to_has_thread_control, t);
658       INHERIT (to_can_async_p, t);
659       INHERIT (to_is_async_p, t);
660       INHERIT (to_async, t);
661       INHERIT (to_find_memory_regions, t);
662       INHERIT (to_make_corefile_notes, t);
663       INHERIT (to_get_bookmark, t);
664       INHERIT (to_goto_bookmark, t);
665       /* Do not inherit to_get_thread_local_address.  */
666       INHERIT (to_can_execute_reverse, t);
667       INHERIT (to_execution_direction, t);
668       INHERIT (to_thread_architecture, t);
669       /* Do not inherit to_read_description.  */
670       INHERIT (to_get_ada_task_ptid, t);
671       /* Do not inherit to_search_memory.  */
672       INHERIT (to_supports_multi_process, t);
673       INHERIT (to_supports_enable_disable_tracepoint, t);
674       INHERIT (to_supports_string_tracing, t);
675       INHERIT (to_trace_init, t);
676       INHERIT (to_download_tracepoint, t);
677       INHERIT (to_can_download_tracepoint, t);
678       INHERIT (to_download_trace_state_variable, t);
679       INHERIT (to_enable_tracepoint, t);
680       INHERIT (to_disable_tracepoint, t);
681       INHERIT (to_trace_set_readonly_regions, t);
682       INHERIT (to_trace_start, t);
683       INHERIT (to_get_trace_status, t);
684       INHERIT (to_get_tracepoint_status, t);
685       INHERIT (to_trace_stop, t);
686       INHERIT (to_trace_find, t);
687       INHERIT (to_get_trace_state_variable_value, t);
688       INHERIT (to_save_trace_data, t);
689       INHERIT (to_upload_tracepoints, t);
690       INHERIT (to_upload_trace_state_variables, t);
691       INHERIT (to_get_raw_trace_data, t);
692       INHERIT (to_get_min_fast_tracepoint_insn_len, t);
693       INHERIT (to_set_disconnected_tracing, t);
694       INHERIT (to_set_circular_trace_buffer, t);
695       INHERIT (to_set_trace_notes, t);
696       INHERIT (to_get_tib_address, t);
697       INHERIT (to_set_permissions, t);
698       INHERIT (to_static_tracepoint_marker_at, t);
699       INHERIT (to_static_tracepoint_markers_by_strid, t);
700       INHERIT (to_traceframe_info, t);
701       INHERIT (to_magic, t);
702       /* Do not inherit to_memory_map.  */
703       /* Do not inherit to_flash_erase.  */
704       /* Do not inherit to_flash_done.  */
705     }
706 #undef INHERIT
707
708   /* Clean up a target struct so it no longer has any zero pointers in
709      it.  Some entries are defaulted to a method that print an error,
710      others are hard-wired to a standard recursive default.  */
711
712 #define de_fault(field, value) \
713   if (!current_target.field)               \
714     current_target.field = value
715
716   de_fault (to_open,
717             (void (*) (char *, int))
718             tcomplain);
719   de_fault (to_close,
720             (void (*) (int))
721             target_ignore);
722   de_fault (to_post_attach,
723             (void (*) (int))
724             target_ignore);
725   de_fault (to_prepare_to_store,
726             (void (*) (struct regcache *))
727             noprocess);
728   de_fault (deprecated_xfer_memory,
729             (int (*) (CORE_ADDR, gdb_byte *, int, int,
730                       struct mem_attrib *, struct target_ops *))
731             nomemory);
732   de_fault (to_files_info,
733             (void (*) (struct target_ops *))
734             target_ignore);
735   de_fault (to_insert_breakpoint,
736             memory_insert_breakpoint);
737   de_fault (to_remove_breakpoint,
738             memory_remove_breakpoint);
739   de_fault (to_can_use_hw_breakpoint,
740             (int (*) (int, int, int))
741             return_zero);
742   de_fault (to_insert_hw_breakpoint,
743             (int (*) (struct gdbarch *, struct bp_target_info *))
744             return_minus_one);
745   de_fault (to_remove_hw_breakpoint,
746             (int (*) (struct gdbarch *, struct bp_target_info *))
747             return_minus_one);
748   de_fault (to_insert_watchpoint,
749             (int (*) (CORE_ADDR, int, int, struct expression *))
750             return_minus_one);
751   de_fault (to_remove_watchpoint,
752             (int (*) (CORE_ADDR, int, int, struct expression *))
753             return_minus_one);
754   de_fault (to_stopped_by_watchpoint,
755             (int (*) (void))
756             return_zero);
757   de_fault (to_stopped_data_address,
758             (int (*) (struct target_ops *, CORE_ADDR *))
759             return_zero);
760   de_fault (to_watchpoint_addr_within_range,
761             default_watchpoint_addr_within_range);
762   de_fault (to_region_ok_for_hw_watchpoint,
763             default_region_ok_for_hw_watchpoint);
764   de_fault (to_can_accel_watchpoint_condition,
765             (int (*) (CORE_ADDR, int, int, struct expression *))
766             return_zero);
767   de_fault (to_terminal_init,
768             (void (*) (void))
769             target_ignore);
770   de_fault (to_terminal_inferior,
771             (void (*) (void))
772             target_ignore);
773   de_fault (to_terminal_ours_for_output,
774             (void (*) (void))
775             target_ignore);
776   de_fault (to_terminal_ours,
777             (void (*) (void))
778             target_ignore);
779   de_fault (to_terminal_save_ours,
780             (void (*) (void))
781             target_ignore);
782   de_fault (to_terminal_info,
783             default_terminal_info);
784   de_fault (to_load,
785             (void (*) (char *, int))
786             tcomplain);
787   de_fault (to_post_startup_inferior,
788             (void (*) (ptid_t))
789             target_ignore);
790   de_fault (to_insert_fork_catchpoint,
791             (int (*) (int))
792             return_one);
793   de_fault (to_remove_fork_catchpoint,
794             (int (*) (int))
795             return_one);
796   de_fault (to_insert_vfork_catchpoint,
797             (int (*) (int))
798             return_one);
799   de_fault (to_remove_vfork_catchpoint,
800             (int (*) (int))
801             return_one);
802   de_fault (to_insert_exec_catchpoint,
803             (int (*) (int))
804             return_one);
805   de_fault (to_remove_exec_catchpoint,
806             (int (*) (int))
807             return_one);
808   de_fault (to_set_syscall_catchpoint,
809             (int (*) (int, int, int, int, int *))
810             return_one);
811   de_fault (to_has_exited,
812             (int (*) (int, int, int *))
813             return_zero);
814   de_fault (to_can_run,
815             return_zero);
816   de_fault (to_extra_thread_info,
817             (char *(*) (struct thread_info *))
818             return_zero);
819   de_fault (to_thread_name,
820             (char *(*) (struct thread_info *))
821             return_zero);
822   de_fault (to_stop,
823             (void (*) (ptid_t))
824             target_ignore);
825   current_target.to_xfer_partial = current_xfer_partial;
826   de_fault (to_rcmd,
827             (void (*) (char *, struct ui_file *))
828             tcomplain);
829   de_fault (to_pid_to_exec_file,
830             (char *(*) (int))
831             return_zero);
832   de_fault (to_async,
833             (void (*) (void (*) (enum inferior_event_type, void*), void*))
834             tcomplain);
835   de_fault (to_thread_architecture,
836             default_thread_architecture);
837   current_target.to_read_description = NULL;
838   de_fault (to_get_ada_task_ptid,
839             (ptid_t (*) (long, long))
840             default_get_ada_task_ptid);
841   de_fault (to_supports_multi_process,
842             (int (*) (void))
843             return_zero);
844   de_fault (to_supports_enable_disable_tracepoint,
845             (int (*) (void))
846             return_zero);
847   de_fault (to_supports_string_tracing,
848             (int (*) (void))
849             return_zero);
850   de_fault (to_trace_init,
851             (void (*) (void))
852             tcomplain);
853   de_fault (to_download_tracepoint,
854             (void (*) (struct bp_location *))
855             tcomplain);
856   de_fault (to_can_download_tracepoint,
857             (int (*) (void))
858             return_zero);
859   de_fault (to_download_trace_state_variable,
860             (void (*) (struct trace_state_variable *))
861             tcomplain);
862   de_fault (to_enable_tracepoint,
863             (void (*) (struct bp_location *))
864             tcomplain);
865   de_fault (to_disable_tracepoint,
866             (void (*) (struct bp_location *))
867             tcomplain);
868   de_fault (to_trace_set_readonly_regions,
869             (void (*) (void))
870             tcomplain);
871   de_fault (to_trace_start,
872             (void (*) (void))
873             tcomplain);
874   de_fault (to_get_trace_status,
875             (int (*) (struct trace_status *))
876             return_minus_one);
877   de_fault (to_get_tracepoint_status,
878             (void (*) (struct breakpoint *, struct uploaded_tp *))
879             tcomplain);
880   de_fault (to_trace_stop,
881             (void (*) (void))
882             tcomplain);
883   de_fault (to_trace_find,
884             (int (*) (enum trace_find_type, int, ULONGEST, ULONGEST, int *))
885             return_minus_one);
886   de_fault (to_get_trace_state_variable_value,
887             (int (*) (int, LONGEST *))
888             return_zero);
889   de_fault (to_save_trace_data,
890             (int (*) (const char *))
891             tcomplain);
892   de_fault (to_upload_tracepoints,
893             (int (*) (struct uploaded_tp **))
894             return_zero);
895   de_fault (to_upload_trace_state_variables,
896             (int (*) (struct uploaded_tsv **))
897             return_zero);
898   de_fault (to_get_raw_trace_data,
899             (LONGEST (*) (gdb_byte *, ULONGEST, LONGEST))
900             tcomplain);
901   de_fault (to_get_min_fast_tracepoint_insn_len,
902             (int (*) (void))
903             return_minus_one);
904   de_fault (to_set_disconnected_tracing,
905             (void (*) (int))
906             target_ignore);
907   de_fault (to_set_circular_trace_buffer,
908             (void (*) (int))
909             target_ignore);
910   de_fault (to_set_trace_notes,
911             (int (*) (char *, char *, char *))
912             return_zero);
913   de_fault (to_get_tib_address,
914             (int (*) (ptid_t, CORE_ADDR *))
915             tcomplain);
916   de_fault (to_set_permissions,
917             (void (*) (void))
918             target_ignore);
919   de_fault (to_static_tracepoint_marker_at,
920             (int (*) (CORE_ADDR, struct static_tracepoint_marker *))
921             return_zero);
922   de_fault (to_static_tracepoint_markers_by_strid,
923             (VEC(static_tracepoint_marker_p) * (*) (const char *))
924             tcomplain);
925   de_fault (to_traceframe_info,
926             (struct traceframe_info * (*) (void))
927             tcomplain);
928   de_fault (to_execution_direction, default_execution_direction);
929
930 #undef de_fault
931
932   /* Finally, position the target-stack beneath the squashed
933      "current_target".  That way code looking for a non-inherited
934      target method can quickly and simply find it.  */
935   current_target.beneath = target_stack;
936
937   if (targetdebug)
938     setup_target_debug ();
939 }
940
941 /* Push a new target type into the stack of the existing target accessors,
942    possibly superseding some of the existing accessors.
943
944    Rather than allow an empty stack, we always have the dummy target at
945    the bottom stratum, so we can call the function vectors without
946    checking them.  */
947
948 void
949 push_target (struct target_ops *t)
950 {
951   struct target_ops **cur;
952
953   /* Check magic number.  If wrong, it probably means someone changed
954      the struct definition, but not all the places that initialize one.  */
955   if (t->to_magic != OPS_MAGIC)
956     {
957       fprintf_unfiltered (gdb_stderr,
958                           "Magic number of %s target struct wrong\n",
959                           t->to_shortname);
960       internal_error (__FILE__, __LINE__,
961                       _("failed internal consistency check"));
962     }
963
964   /* Find the proper stratum to install this target in.  */
965   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
966     {
967       if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
968         break;
969     }
970
971   /* If there's already targets at this stratum, remove them.  */
972   /* FIXME: cagney/2003-10-15: I think this should be popping all
973      targets to CUR, and not just those at this stratum level.  */
974   while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
975     {
976       /* There's already something at this stratum level.  Close it,
977          and un-hook it from the stack.  */
978       struct target_ops *tmp = (*cur);
979
980       (*cur) = (*cur)->beneath;
981       tmp->beneath = NULL;
982       target_close (tmp, 0);
983     }
984
985   /* We have removed all targets in our stratum, now add the new one.  */
986   t->beneath = (*cur);
987   (*cur) = t;
988
989   update_current_target ();
990 }
991
992 /* Remove a target_ops vector from the stack, wherever it may be.
993    Return how many times it was removed (0 or 1).  */
994
995 int
996 unpush_target (struct target_ops *t)
997 {
998   struct target_ops **cur;
999   struct target_ops *tmp;
1000
1001   if (t->to_stratum == dummy_stratum)
1002     internal_error (__FILE__, __LINE__,
1003                     _("Attempt to unpush the dummy target"));
1004
1005   /* Look for the specified target.  Note that we assume that a target
1006      can only occur once in the target stack.  */
1007
1008   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
1009     {
1010       if ((*cur) == t)
1011         break;
1012     }
1013
1014   /* If we don't find target_ops, quit.  Only open targets should be
1015      closed.  */
1016   if ((*cur) == NULL)
1017     return 0;                   
1018
1019   /* Unchain the target.  */
1020   tmp = (*cur);
1021   (*cur) = (*cur)->beneath;
1022   tmp->beneath = NULL;
1023
1024   update_current_target ();
1025
1026   /* Finally close the target.  Note we do this after unchaining, so
1027      any target method calls from within the target_close
1028      implementation don't end up in T anymore.  */
1029   target_close (t, 0);
1030
1031   return 1;
1032 }
1033
1034 void
1035 pop_target (void)
1036 {
1037   target_close (target_stack, 0);       /* Let it clean up.  */
1038   if (unpush_target (target_stack) == 1)
1039     return;
1040
1041   fprintf_unfiltered (gdb_stderr,
1042                       "pop_target couldn't find target %s\n",
1043                       current_target.to_shortname);
1044   internal_error (__FILE__, __LINE__,
1045                   _("failed internal consistency check"));
1046 }
1047
1048 void
1049 pop_all_targets_above (enum strata above_stratum, int quitting)
1050 {
1051   while ((int) (current_target.to_stratum) > (int) above_stratum)
1052     {
1053       target_close (target_stack, quitting);
1054       if (!unpush_target (target_stack))
1055         {
1056           fprintf_unfiltered (gdb_stderr,
1057                               "pop_all_targets couldn't find target %s\n",
1058                               target_stack->to_shortname);
1059           internal_error (__FILE__, __LINE__,
1060                           _("failed internal consistency check"));
1061           break;
1062         }
1063     }
1064 }
1065
1066 void
1067 pop_all_targets (int quitting)
1068 {
1069   pop_all_targets_above (dummy_stratum, quitting);
1070 }
1071
1072 /* Return 1 if T is now pushed in the target stack.  Return 0 otherwise.  */
1073
1074 int
1075 target_is_pushed (struct target_ops *t)
1076 {
1077   struct target_ops **cur;
1078
1079   /* Check magic number.  If wrong, it probably means someone changed
1080      the struct definition, but not all the places that initialize one.  */
1081   if (t->to_magic != OPS_MAGIC)
1082     {
1083       fprintf_unfiltered (gdb_stderr,
1084                           "Magic number of %s target struct wrong\n",
1085                           t->to_shortname);
1086       internal_error (__FILE__, __LINE__,
1087                       _("failed internal consistency check"));
1088     }
1089
1090   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
1091     if (*cur == t)
1092       return 1;
1093
1094   return 0;
1095 }
1096
1097 /* Using the objfile specified in OBJFILE, find the address for the
1098    current thread's thread-local storage with offset OFFSET.  */
1099 CORE_ADDR
1100 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
1101 {
1102   volatile CORE_ADDR addr = 0;
1103   struct target_ops *target;
1104
1105   for (target = current_target.beneath;
1106        target != NULL;
1107        target = target->beneath)
1108     {
1109       if (target->to_get_thread_local_address != NULL)
1110         break;
1111     }
1112
1113   if (target != NULL
1114       && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
1115     {
1116       ptid_t ptid = inferior_ptid;
1117       volatile struct gdb_exception ex;
1118
1119       TRY_CATCH (ex, RETURN_MASK_ALL)
1120         {
1121           CORE_ADDR lm_addr;
1122           
1123           /* Fetch the load module address for this objfile.  */
1124           lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch,
1125                                                            objfile);
1126           /* If it's 0, throw the appropriate exception.  */
1127           if (lm_addr == 0)
1128             throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
1129                          _("TLS load module not found"));
1130
1131           addr = target->to_get_thread_local_address (target, ptid,
1132                                                       lm_addr, offset);
1133         }
1134       /* If an error occurred, print TLS related messages here.  Otherwise,
1135          throw the error to some higher catcher.  */
1136       if (ex.reason < 0)
1137         {
1138           int objfile_is_library = (objfile->flags & OBJF_SHARED);
1139
1140           switch (ex.error)
1141             {
1142             case TLS_NO_LIBRARY_SUPPORT_ERROR:
1143               error (_("Cannot find thread-local variables "
1144                        "in this thread library."));
1145               break;
1146             case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
1147               if (objfile_is_library)
1148                 error (_("Cannot find shared library `%s' in dynamic"
1149                          " linker's load module list"), objfile->name);
1150               else
1151                 error (_("Cannot find executable file `%s' in dynamic"
1152                          " linker's load module list"), objfile->name);
1153               break;
1154             case TLS_NOT_ALLOCATED_YET_ERROR:
1155               if (objfile_is_library)
1156                 error (_("The inferior has not yet allocated storage for"
1157                          " thread-local variables in\n"
1158                          "the shared library `%s'\n"
1159                          "for %s"),
1160                        objfile->name, target_pid_to_str (ptid));
1161               else
1162                 error (_("The inferior has not yet allocated storage for"
1163                          " thread-local variables in\n"
1164                          "the executable `%s'\n"
1165                          "for %s"),
1166                        objfile->name, target_pid_to_str (ptid));
1167               break;
1168             case TLS_GENERIC_ERROR:
1169               if (objfile_is_library)
1170                 error (_("Cannot find thread-local storage for %s, "
1171                          "shared library %s:\n%s"),
1172                        target_pid_to_str (ptid),
1173                        objfile->name, ex.message);
1174               else
1175                 error (_("Cannot find thread-local storage for %s, "
1176                          "executable file %s:\n%s"),
1177                        target_pid_to_str (ptid),
1178                        objfile->name, ex.message);
1179               break;
1180             default:
1181               throw_exception (ex);
1182               break;
1183             }
1184         }
1185     }
1186   /* It wouldn't be wrong here to try a gdbarch method, too; finding
1187      TLS is an ABI-specific thing.  But we don't do that yet.  */
1188   else
1189     error (_("Cannot find thread-local variables on this target"));
1190
1191   return addr;
1192 }
1193
1194 #undef  MIN
1195 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
1196
1197 /* target_read_string -- read a null terminated string, up to LEN bytes,
1198    from MEMADDR in target.  Set *ERRNOP to the errno code, or 0 if successful.
1199    Set *STRING to a pointer to malloc'd memory containing the data; the caller
1200    is responsible for freeing it.  Return the number of bytes successfully
1201    read.  */
1202
1203 int
1204 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
1205 {
1206   int tlen, origlen, offset, i;
1207   gdb_byte buf[4];
1208   int errcode = 0;
1209   char *buffer;
1210   int buffer_allocated;
1211   char *bufptr;
1212   unsigned int nbytes_read = 0;
1213
1214   gdb_assert (string);
1215
1216   /* Small for testing.  */
1217   buffer_allocated = 4;
1218   buffer = xmalloc (buffer_allocated);
1219   bufptr = buffer;
1220
1221   origlen = len;
1222
1223   while (len > 0)
1224     {
1225       tlen = MIN (len, 4 - (memaddr & 3));
1226       offset = memaddr & 3;
1227
1228       errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
1229       if (errcode != 0)
1230         {
1231           /* The transfer request might have crossed the boundary to an
1232              unallocated region of memory.  Retry the transfer, requesting
1233              a single byte.  */
1234           tlen = 1;
1235           offset = 0;
1236           errcode = target_read_memory (memaddr, buf, 1);
1237           if (errcode != 0)
1238             goto done;
1239         }
1240
1241       if (bufptr - buffer + tlen > buffer_allocated)
1242         {
1243           unsigned int bytes;
1244
1245           bytes = bufptr - buffer;
1246           buffer_allocated *= 2;
1247           buffer = xrealloc (buffer, buffer_allocated);
1248           bufptr = buffer + bytes;
1249         }
1250
1251       for (i = 0; i < tlen; i++)
1252         {
1253           *bufptr++ = buf[i + offset];
1254           if (buf[i + offset] == '\000')
1255             {
1256               nbytes_read += i + 1;
1257               goto done;
1258             }
1259         }
1260
1261       memaddr += tlen;
1262       len -= tlen;
1263       nbytes_read += tlen;
1264     }
1265 done:
1266   *string = buffer;
1267   if (errnop != NULL)
1268     *errnop = errcode;
1269   return nbytes_read;
1270 }
1271
1272 struct target_section_table *
1273 target_get_section_table (struct target_ops *target)
1274 {
1275   struct target_ops *t;
1276
1277   if (targetdebug)
1278     fprintf_unfiltered (gdb_stdlog, "target_get_section_table ()\n");
1279
1280   for (t = target; t != NULL; t = t->beneath)
1281     if (t->to_get_section_table != NULL)
1282       return (*t->to_get_section_table) (t);
1283
1284   return NULL;
1285 }
1286
1287 /* Find a section containing ADDR.  */
1288
1289 struct target_section *
1290 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
1291 {
1292   struct target_section_table *table = target_get_section_table (target);
1293   struct target_section *secp;
1294
1295   if (table == NULL)
1296     return NULL;
1297
1298   for (secp = table->sections; secp < table->sections_end; secp++)
1299     {
1300       if (addr >= secp->addr && addr < secp->endaddr)
1301         return secp;
1302     }
1303   return NULL;
1304 }
1305
1306 /* Read memory from the live target, even if currently inspecting a
1307    traceframe.  The return is the same as that of target_read.  */
1308
1309 static LONGEST
1310 target_read_live_memory (enum target_object object,
1311                          ULONGEST memaddr, gdb_byte *myaddr, LONGEST len)
1312 {
1313   int ret;
1314   struct cleanup *cleanup;
1315
1316   /* Switch momentarily out of tfind mode so to access live memory.
1317      Note that this must not clear global state, such as the frame
1318      cache, which must still remain valid for the previous traceframe.
1319      We may be _building_ the frame cache at this point.  */
1320   cleanup = make_cleanup_restore_traceframe_number ();
1321   set_traceframe_number (-1);
1322
1323   ret = target_read (current_target.beneath, object, NULL,
1324                      myaddr, memaddr, len);
1325
1326   do_cleanups (cleanup);
1327   return ret;
1328 }
1329
1330 /* Using the set of read-only target sections of OPS, read live
1331    read-only memory.  Note that the actual reads start from the
1332    top-most target again.
1333
1334    For interface/parameters/return description see target.h,
1335    to_xfer_partial.  */
1336
1337 static LONGEST
1338 memory_xfer_live_readonly_partial (struct target_ops *ops,
1339                                    enum target_object object,
1340                                    gdb_byte *readbuf, ULONGEST memaddr,
1341                                    LONGEST len)
1342 {
1343   struct target_section *secp;
1344   struct target_section_table *table;
1345
1346   secp = target_section_by_addr (ops, memaddr);
1347   if (secp != NULL
1348       && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1349           & SEC_READONLY))
1350     {
1351       struct target_section *p;
1352       ULONGEST memend = memaddr + len;
1353
1354       table = target_get_section_table (ops);
1355
1356       for (p = table->sections; p < table->sections_end; p++)
1357         {
1358           if (memaddr >= p->addr)
1359             {
1360               if (memend <= p->endaddr)
1361                 {
1362                   /* Entire transfer is within this section.  */
1363                   return target_read_live_memory (object, memaddr,
1364                                                   readbuf, len);
1365                 }
1366               else if (memaddr >= p->endaddr)
1367                 {
1368                   /* This section ends before the transfer starts.  */
1369                   continue;
1370                 }
1371               else
1372                 {
1373                   /* This section overlaps the transfer.  Just do half.  */
1374                   len = p->endaddr - memaddr;
1375                   return target_read_live_memory (object, memaddr,
1376                                                   readbuf, len);
1377                 }
1378             }
1379         }
1380     }
1381
1382   return 0;
1383 }
1384
1385 /* Perform a partial memory transfer.
1386    For docs see target.h, to_xfer_partial.  */
1387
1388 static LONGEST
1389 memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
1390                        void *readbuf, const void *writebuf, ULONGEST memaddr,
1391                        LONGEST len)
1392 {
1393   LONGEST res;
1394   int reg_len;
1395   struct mem_region *region;
1396   struct inferior *inf;
1397
1398   /* For accesses to unmapped overlay sections, read directly from
1399      files.  Must do this first, as MEMADDR may need adjustment.  */
1400   if (readbuf != NULL && overlay_debugging)
1401     {
1402       struct obj_section *section = find_pc_overlay (memaddr);
1403
1404       if (pc_in_unmapped_range (memaddr, section))
1405         {
1406           struct target_section_table *table
1407             = target_get_section_table (ops);
1408           const char *section_name = section->the_bfd_section->name;
1409
1410           memaddr = overlay_mapped_address (memaddr, section);
1411           return section_table_xfer_memory_partial (readbuf, writebuf,
1412                                                     memaddr, len,
1413                                                     table->sections,
1414                                                     table->sections_end,
1415                                                     section_name);
1416         }
1417     }
1418
1419   /* Try the executable files, if "trust-readonly-sections" is set.  */
1420   if (readbuf != NULL && trust_readonly)
1421     {
1422       struct target_section *secp;
1423       struct target_section_table *table;
1424
1425       secp = target_section_by_addr (ops, memaddr);
1426       if (secp != NULL
1427           && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1428               & SEC_READONLY))
1429         {
1430           table = target_get_section_table (ops);
1431           return section_table_xfer_memory_partial (readbuf, writebuf,
1432                                                     memaddr, len,
1433                                                     table->sections,
1434                                                     table->sections_end,
1435                                                     NULL);
1436         }
1437     }
1438
1439   /* If reading unavailable memory in the context of traceframes, and
1440      this address falls within a read-only section, fallback to
1441      reading from live memory.  */
1442   if (readbuf != NULL && get_traceframe_number () != -1)
1443     {
1444       VEC(mem_range_s) *available;
1445
1446       /* If we fail to get the set of available memory, then the
1447          target does not support querying traceframe info, and so we
1448          attempt reading from the traceframe anyway (assuming the
1449          target implements the old QTro packet then).  */
1450       if (traceframe_available_memory (&available, memaddr, len))
1451         {
1452           struct cleanup *old_chain;
1453
1454           old_chain = make_cleanup (VEC_cleanup(mem_range_s), &available);
1455
1456           if (VEC_empty (mem_range_s, available)
1457               || VEC_index (mem_range_s, available, 0)->start != memaddr)
1458             {
1459               /* Don't read into the traceframe's available
1460                  memory.  */
1461               if (!VEC_empty (mem_range_s, available))
1462                 {
1463                   LONGEST oldlen = len;
1464
1465                   len = VEC_index (mem_range_s, available, 0)->start - memaddr;
1466                   gdb_assert (len <= oldlen);
1467                 }
1468
1469               do_cleanups (old_chain);
1470
1471               /* This goes through the topmost target again.  */
1472               res = memory_xfer_live_readonly_partial (ops, object,
1473                                                        readbuf, memaddr, len);
1474               if (res > 0)
1475                 return res;
1476
1477               /* No use trying further, we know some memory starting
1478                  at MEMADDR isn't available.  */
1479               return -1;
1480             }
1481
1482           /* Don't try to read more than how much is available, in
1483              case the target implements the deprecated QTro packet to
1484              cater for older GDBs (the target's knowledge of read-only
1485              sections may be outdated by now).  */
1486           len = VEC_index (mem_range_s, available, 0)->length;
1487
1488           do_cleanups (old_chain);
1489         }
1490     }
1491
1492   /* Try GDB's internal data cache.  */
1493   region = lookup_mem_region (memaddr);
1494   /* region->hi == 0 means there's no upper bound.  */
1495   if (memaddr + len < region->hi || region->hi == 0)
1496     reg_len = len;
1497   else
1498     reg_len = region->hi - memaddr;
1499
1500   switch (region->attrib.mode)
1501     {
1502     case MEM_RO:
1503       if (writebuf != NULL)
1504         return -1;
1505       break;
1506
1507     case MEM_WO:
1508       if (readbuf != NULL)
1509         return -1;
1510       break;
1511
1512     case MEM_FLASH:
1513       /* We only support writing to flash during "load" for now.  */
1514       if (writebuf != NULL)
1515         error (_("Writing to flash memory forbidden in this context"));
1516       break;
1517
1518     case MEM_NONE:
1519       return -1;
1520     }
1521
1522   if (!ptid_equal (inferior_ptid, null_ptid))
1523     inf = find_inferior_pid (ptid_get_pid (inferior_ptid));
1524   else
1525     inf = NULL;
1526
1527   if (inf != NULL
1528       /* The dcache reads whole cache lines; that doesn't play well
1529          with reading from a trace buffer, because reading outside of
1530          the collected memory range fails.  */
1531       && get_traceframe_number () == -1
1532       && (region->attrib.cache
1533           || (stack_cache_enabled_p && object == TARGET_OBJECT_STACK_MEMORY)))
1534     {
1535       if (readbuf != NULL)
1536         res = dcache_xfer_memory (ops, target_dcache, memaddr, readbuf,
1537                                   reg_len, 0);
1538       else
1539         /* FIXME drow/2006-08-09: If we're going to preserve const
1540            correctness dcache_xfer_memory should take readbuf and
1541            writebuf.  */
1542         res = dcache_xfer_memory (ops, target_dcache, memaddr,
1543                                   (void *) writebuf,
1544                                   reg_len, 1);
1545       if (res <= 0)
1546         return -1;
1547       else
1548         return res;
1549     }
1550
1551   /* If none of those methods found the memory we wanted, fall back
1552      to a target partial transfer.  Normally a single call to
1553      to_xfer_partial is enough; if it doesn't recognize an object
1554      it will call the to_xfer_partial of the next target down.
1555      But for memory this won't do.  Memory is the only target
1556      object which can be read from more than one valid target.
1557      A core file, for instance, could have some of memory but
1558      delegate other bits to the target below it.  So, we must
1559      manually try all targets.  */
1560
1561   do
1562     {
1563       res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
1564                                   readbuf, writebuf, memaddr, reg_len);
1565       if (res > 0)
1566         break;
1567
1568       /* We want to continue past core files to executables, but not
1569          past a running target's memory.  */
1570       if (ops->to_has_all_memory (ops))
1571         break;
1572
1573       ops = ops->beneath;
1574     }
1575   while (ops != NULL);
1576
1577   /* Make sure the cache gets updated no matter what - if we are writing
1578      to the stack.  Even if this write is not tagged as such, we still need
1579      to update the cache.  */
1580
1581   if (res > 0
1582       && inf != NULL
1583       && writebuf != NULL
1584       && !region->attrib.cache
1585       && stack_cache_enabled_p
1586       && object != TARGET_OBJECT_STACK_MEMORY)
1587     {
1588       dcache_update (target_dcache, memaddr, (void *) writebuf, res);
1589     }
1590
1591   /* If we still haven't got anything, return the last error.  We
1592      give up.  */
1593   return res;
1594 }
1595
1596 /* Perform a partial memory transfer.  For docs see target.h,
1597    to_xfer_partial.  */
1598
1599 static LONGEST
1600 memory_xfer_partial (struct target_ops *ops, enum target_object object,
1601                      void *readbuf, const void *writebuf, ULONGEST memaddr,
1602                      LONGEST len)
1603 {
1604   int res;
1605
1606   /* Zero length requests are ok and require no work.  */
1607   if (len == 0)
1608     return 0;
1609
1610   /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1611      breakpoint insns, thus hiding out from higher layers whether
1612      there are software breakpoints inserted in the code stream.  */
1613   if (readbuf != NULL)
1614     {
1615       res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len);
1616
1617       if (res > 0 && !show_memory_breakpoints)
1618         breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, res);
1619     }
1620   else
1621     {
1622       void *buf;
1623       struct cleanup *old_chain;
1624
1625       buf = xmalloc (len);
1626       old_chain = make_cleanup (xfree, buf);
1627       memcpy (buf, writebuf, len);
1628
1629       breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
1630       res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len);
1631
1632       do_cleanups (old_chain);
1633     }
1634
1635   return res;
1636 }
1637
1638 static void
1639 restore_show_memory_breakpoints (void *arg)
1640 {
1641   show_memory_breakpoints = (uintptr_t) arg;
1642 }
1643
1644 struct cleanup *
1645 make_show_memory_breakpoints_cleanup (int show)
1646 {
1647   int current = show_memory_breakpoints;
1648
1649   show_memory_breakpoints = show;
1650   return make_cleanup (restore_show_memory_breakpoints,
1651                        (void *) (uintptr_t) current);
1652 }
1653
1654 /* For docs see target.h, to_xfer_partial.  */
1655
1656 static LONGEST
1657 target_xfer_partial (struct target_ops *ops,
1658                      enum target_object object, const char *annex,
1659                      void *readbuf, const void *writebuf,
1660                      ULONGEST offset, LONGEST len)
1661 {
1662   LONGEST retval;
1663
1664   gdb_assert (ops->to_xfer_partial != NULL);
1665
1666   if (writebuf && !may_write_memory)
1667     error (_("Writing to memory is not allowed (addr %s, len %s)"),
1668            core_addr_to_string_nz (offset), plongest (len));
1669
1670   /* If this is a memory transfer, let the memory-specific code
1671      have a look at it instead.  Memory transfers are more
1672      complicated.  */
1673   if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY)
1674     retval = memory_xfer_partial (ops, object, readbuf,
1675                                   writebuf, offset, len);
1676   else
1677     {
1678       enum target_object raw_object = object;
1679
1680       /* If this is a raw memory transfer, request the normal
1681          memory object from other layers.  */
1682       if (raw_object == TARGET_OBJECT_RAW_MEMORY)
1683         raw_object = TARGET_OBJECT_MEMORY;
1684
1685       retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
1686                                      writebuf, offset, len);
1687     }
1688
1689   if (targetdebug)
1690     {
1691       const unsigned char *myaddr = NULL;
1692
1693       fprintf_unfiltered (gdb_stdlog,
1694                           "%s:target_xfer_partial "
1695                           "(%d, %s, %s, %s, %s, %s) = %s",
1696                           ops->to_shortname,
1697                           (int) object,
1698                           (annex ? annex : "(null)"),
1699                           host_address_to_string (readbuf),
1700                           host_address_to_string (writebuf),
1701                           core_addr_to_string_nz (offset),
1702                           plongest (len), plongest (retval));
1703
1704       if (readbuf)
1705         myaddr = readbuf;
1706       if (writebuf)
1707         myaddr = writebuf;
1708       if (retval > 0 && myaddr != NULL)
1709         {
1710           int i;
1711
1712           fputs_unfiltered (", bytes =", gdb_stdlog);
1713           for (i = 0; i < retval; i++)
1714             {
1715               if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
1716                 {
1717                   if (targetdebug < 2 && i > 0)
1718                     {
1719                       fprintf_unfiltered (gdb_stdlog, " ...");
1720                       break;
1721                     }
1722                   fprintf_unfiltered (gdb_stdlog, "\n");
1723                 }
1724
1725               fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1726             }
1727         }
1728
1729       fputc_unfiltered ('\n', gdb_stdlog);
1730     }
1731   return retval;
1732 }
1733
1734 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
1735    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
1736    if any error occurs.
1737
1738    If an error occurs, no guarantee is made about the contents of the data at
1739    MYADDR.  In particular, the caller should not depend upon partial reads
1740    filling the buffer with good data.  There is no way for the caller to know
1741    how much good data might have been transfered anyway.  Callers that can
1742    deal with partial reads should call target_read (which will retry until
1743    it makes no progress, and then return how much was transferred).  */
1744
1745 int
1746 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1747 {
1748   /* Dispatch to the topmost target, not the flattened current_target.
1749      Memory accesses check target->to_has_(all_)memory, and the
1750      flattened target doesn't inherit those.  */
1751   if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1752                    myaddr, memaddr, len) == len)
1753     return 0;
1754   else
1755     return EIO;
1756 }
1757
1758 /* Like target_read_memory, but specify explicitly that this is a read from
1759    the target's stack.  This may trigger different cache behavior.  */
1760
1761 int
1762 target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
1763 {
1764   /* Dispatch to the topmost target, not the flattened current_target.
1765      Memory accesses check target->to_has_(all_)memory, and the
1766      flattened target doesn't inherit those.  */
1767
1768   if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1769                    myaddr, memaddr, len) == len)
1770     return 0;
1771   else
1772     return EIO;
1773 }
1774
1775 /* Write LEN bytes from MYADDR to target memory at address MEMADDR.
1776    Returns either 0 for success or an errno value if any error occurs.
1777    If an error occurs, no guarantee is made about how much data got written.
1778    Callers that can deal with partial writes should call target_write.  */
1779
1780 int
1781 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1782 {
1783   /* Dispatch to the topmost target, not the flattened current_target.
1784      Memory accesses check target->to_has_(all_)memory, and the
1785      flattened target doesn't inherit those.  */
1786   if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
1787                     myaddr, memaddr, len) == len)
1788     return 0;
1789   else
1790     return EIO;
1791 }
1792
1793 /* Write LEN bytes from MYADDR to target raw memory at address
1794    MEMADDR.  Returns either 0 for success or an errno value if any
1795    error occurs.  If an error occurs, no guarantee is made about how
1796    much data got written.  Callers that can deal with partial writes
1797    should call target_write.  */
1798
1799 int
1800 target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1801 {
1802   /* Dispatch to the topmost target, not the flattened current_target.
1803      Memory accesses check target->to_has_(all_)memory, and the
1804      flattened target doesn't inherit those.  */
1805   if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1806                     myaddr, memaddr, len) == len)
1807     return 0;
1808   else
1809     return EIO;
1810 }
1811
1812 /* Fetch the target's memory map.  */
1813
1814 VEC(mem_region_s) *
1815 target_memory_map (void)
1816 {
1817   VEC(mem_region_s) *result;
1818   struct mem_region *last_one, *this_one;
1819   int ix;
1820   struct target_ops *t;
1821
1822   if (targetdebug)
1823     fprintf_unfiltered (gdb_stdlog, "target_memory_map ()\n");
1824
1825   for (t = current_target.beneath; t != NULL; t = t->beneath)
1826     if (t->to_memory_map != NULL)
1827       break;
1828
1829   if (t == NULL)
1830     return NULL;
1831
1832   result = t->to_memory_map (t);
1833   if (result == NULL)
1834     return NULL;
1835
1836   qsort (VEC_address (mem_region_s, result),
1837          VEC_length (mem_region_s, result),
1838          sizeof (struct mem_region), mem_region_cmp);
1839
1840   /* Check that regions do not overlap.  Simultaneously assign
1841      a numbering for the "mem" commands to use to refer to
1842      each region.  */
1843   last_one = NULL;
1844   for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1845     {
1846       this_one->number = ix;
1847
1848       if (last_one && last_one->hi > this_one->lo)
1849         {
1850           warning (_("Overlapping regions in memory map: ignoring"));
1851           VEC_free (mem_region_s, result);
1852           return NULL;
1853         }
1854       last_one = this_one;
1855     }
1856
1857   return result;
1858 }
1859
1860 void
1861 target_flash_erase (ULONGEST address, LONGEST length)
1862 {
1863   struct target_ops *t;
1864
1865   for (t = current_target.beneath; t != NULL; t = t->beneath)
1866     if (t->to_flash_erase != NULL)
1867       {
1868         if (targetdebug)
1869           fprintf_unfiltered (gdb_stdlog, "target_flash_erase (%s, %s)\n",
1870                               hex_string (address), phex (length, 0));
1871         t->to_flash_erase (t, address, length);
1872         return;
1873       }
1874
1875   tcomplain ();
1876 }
1877
1878 void
1879 target_flash_done (void)
1880 {
1881   struct target_ops *t;
1882
1883   for (t = current_target.beneath; t != NULL; t = t->beneath)
1884     if (t->to_flash_done != NULL)
1885       {
1886         if (targetdebug)
1887           fprintf_unfiltered (gdb_stdlog, "target_flash_done\n");
1888         t->to_flash_done (t);
1889         return;
1890       }
1891
1892   tcomplain ();
1893 }
1894
1895 static void
1896 show_trust_readonly (struct ui_file *file, int from_tty,
1897                      struct cmd_list_element *c, const char *value)
1898 {
1899   fprintf_filtered (file,
1900                     _("Mode for reading from readonly sections is %s.\n"),
1901                     value);
1902 }
1903
1904 /* More generic transfers.  */
1905
1906 static LONGEST
1907 default_xfer_partial (struct target_ops *ops, enum target_object object,
1908                       const char *annex, gdb_byte *readbuf,
1909                       const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1910 {
1911   if (object == TARGET_OBJECT_MEMORY
1912       && ops->deprecated_xfer_memory != NULL)
1913     /* If available, fall back to the target's
1914        "deprecated_xfer_memory" method.  */
1915     {
1916       int xfered = -1;
1917
1918       errno = 0;
1919       if (writebuf != NULL)
1920         {
1921           void *buffer = xmalloc (len);
1922           struct cleanup *cleanup = make_cleanup (xfree, buffer);
1923
1924           memcpy (buffer, writebuf, len);
1925           xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1926                                                 1/*write*/, NULL, ops);
1927           do_cleanups (cleanup);
1928         }
1929       if (readbuf != NULL)
1930         xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 
1931                                               0/*read*/, NULL, ops);
1932       if (xfered > 0)
1933         return xfered;
1934       else if (xfered == 0 && errno == 0)
1935         /* "deprecated_xfer_memory" uses 0, cross checked against
1936            ERRNO as one indication of an error.  */
1937         return 0;
1938       else
1939         return -1;
1940     }
1941   else if (ops->beneath != NULL)
1942     return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1943                                           readbuf, writebuf, offset, len);
1944   else
1945     return -1;
1946 }
1947
1948 /* The xfer_partial handler for the topmost target.  Unlike the default,
1949    it does not need to handle memory specially; it just passes all
1950    requests down the stack.  */
1951
1952 static LONGEST
1953 current_xfer_partial (struct target_ops *ops, enum target_object object,
1954                       const char *annex, gdb_byte *readbuf,
1955                       const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1956 {
1957   if (ops->beneath != NULL)
1958     return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1959                                           readbuf, writebuf, offset, len);
1960   else
1961     return -1;
1962 }
1963
1964 /* Target vector read/write partial wrapper functions.  */
1965
1966 static LONGEST
1967 target_read_partial (struct target_ops *ops,
1968                      enum target_object object,
1969                      const char *annex, gdb_byte *buf,
1970                      ULONGEST offset, LONGEST len)
1971 {
1972   return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1973 }
1974
1975 static LONGEST
1976 target_write_partial (struct target_ops *ops,
1977                       enum target_object object,
1978                       const char *annex, const gdb_byte *buf,
1979                       ULONGEST offset, LONGEST len)
1980 {
1981   return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1982 }
1983
1984 /* Wrappers to perform the full transfer.  */
1985
1986 /* For docs on target_read see target.h.  */
1987
1988 LONGEST
1989 target_read (struct target_ops *ops,
1990              enum target_object object,
1991              const char *annex, gdb_byte *buf,
1992              ULONGEST offset, LONGEST len)
1993 {
1994   LONGEST xfered = 0;
1995
1996   while (xfered < len)
1997     {
1998       LONGEST xfer = target_read_partial (ops, object, annex,
1999                                           (gdb_byte *) buf + xfered,
2000                                           offset + xfered, len - xfered);
2001
2002       /* Call an observer, notifying them of the xfer progress?  */
2003       if (xfer == 0)
2004         return xfered;
2005       if (xfer < 0)
2006         return -1;
2007       xfered += xfer;
2008       QUIT;
2009     }
2010   return len;
2011 }
2012
2013 /* Assuming that the entire [begin, end) range of memory cannot be
2014    read, try to read whatever subrange is possible to read.
2015
2016    The function returns, in RESULT, either zero or one memory block.
2017    If there's a readable subrange at the beginning, it is completely
2018    read and returned.  Any further readable subrange will not be read.
2019    Otherwise, if there's a readable subrange at the end, it will be
2020    completely read and returned.  Any readable subranges before it
2021    (obviously, not starting at the beginning), will be ignored.  In
2022    other cases -- either no readable subrange, or readable subrange(s)
2023    that is neither at the beginning, or end, nothing is returned.
2024
2025    The purpose of this function is to handle a read across a boundary
2026    of accessible memory in a case when memory map is not available.
2027    The above restrictions are fine for this case, but will give
2028    incorrect results if the memory is 'patchy'.  However, supporting
2029    'patchy' memory would require trying to read every single byte,
2030    and it seems unacceptable solution.  Explicit memory map is
2031    recommended for this case -- and target_read_memory_robust will
2032    take care of reading multiple ranges then.  */
2033
2034 static void
2035 read_whatever_is_readable (struct target_ops *ops,
2036                            ULONGEST begin, ULONGEST end,
2037                            VEC(memory_read_result_s) **result)
2038 {
2039   gdb_byte *buf = xmalloc (end - begin);
2040   ULONGEST current_begin = begin;
2041   ULONGEST current_end = end;
2042   int forward;
2043   memory_read_result_s r;
2044
2045   /* If we previously failed to read 1 byte, nothing can be done here.  */
2046   if (end - begin <= 1)
2047     {
2048       xfree (buf);
2049       return;
2050     }
2051
2052   /* Check that either first or the last byte is readable, and give up
2053      if not.  This heuristic is meant to permit reading accessible memory
2054      at the boundary of accessible region.  */
2055   if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2056                            buf, begin, 1) == 1)
2057     {
2058       forward = 1;
2059       ++current_begin;
2060     }
2061   else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
2062                                 buf + (end-begin) - 1, end - 1, 1) == 1)
2063     {
2064       forward = 0;
2065       --current_end;
2066     }
2067   else
2068     {
2069       xfree (buf);
2070       return;
2071     }
2072
2073   /* Loop invariant is that the [current_begin, current_end) was previously
2074      found to be not readable as a whole.
2075
2076      Note loop condition -- if the range has 1 byte, we can't divide the range
2077      so there's no point trying further.  */
2078   while (current_end - current_begin > 1)
2079     {
2080       ULONGEST first_half_begin, first_half_end;
2081       ULONGEST second_half_begin, second_half_end;
2082       LONGEST xfer;
2083       ULONGEST middle = current_begin + (current_end - current_begin)/2;
2084
2085       if (forward)
2086         {
2087           first_half_begin = current_begin;
2088           first_half_end = middle;
2089           second_half_begin = middle;
2090           second_half_end = current_end;
2091         }
2092       else
2093         {
2094           first_half_begin = middle;
2095           first_half_end = current_end;
2096           second_half_begin = current_begin;
2097           second_half_end = middle;
2098         }
2099
2100       xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2101                           buf + (first_half_begin - begin),
2102                           first_half_begin,
2103                           first_half_end - first_half_begin);
2104
2105       if (xfer == first_half_end - first_half_begin)
2106         {
2107           /* This half reads up fine.  So, the error must be in the
2108              other half.  */
2109           current_begin = second_half_begin;
2110           current_end = second_half_end;
2111         }
2112       else
2113         {
2114           /* This half is not readable.  Because we've tried one byte, we
2115              know some part of this half if actually redable.  Go to the next
2116              iteration to divide again and try to read.
2117
2118              We don't handle the other half, because this function only tries
2119              to read a single readable subrange.  */
2120           current_begin = first_half_begin;
2121           current_end = first_half_end;
2122         }
2123     }
2124
2125   if (forward)
2126     {
2127       /* The [begin, current_begin) range has been read.  */
2128       r.begin = begin;
2129       r.end = current_begin;
2130       r.data = buf;
2131     }
2132   else
2133     {
2134       /* The [current_end, end) range has been read.  */
2135       LONGEST rlen = end - current_end;
2136
2137       r.data = xmalloc (rlen);
2138       memcpy (r.data, buf + current_end - begin, rlen);
2139       r.begin = current_end;
2140       r.end = end;
2141       xfree (buf);
2142     }
2143   VEC_safe_push(memory_read_result_s, (*result), &r);
2144 }
2145
2146 void
2147 free_memory_read_result_vector (void *x)
2148 {
2149   VEC(memory_read_result_s) *v = x;
2150   memory_read_result_s *current;
2151   int ix;
2152
2153   for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
2154     {
2155       xfree (current->data);
2156     }
2157   VEC_free (memory_read_result_s, v);
2158 }
2159
2160 VEC(memory_read_result_s) *
2161 read_memory_robust (struct target_ops *ops, ULONGEST offset, LONGEST len)
2162 {
2163   VEC(memory_read_result_s) *result = 0;
2164
2165   LONGEST xfered = 0;
2166   while (xfered < len)
2167     {
2168       struct mem_region *region = lookup_mem_region (offset + xfered);
2169       LONGEST rlen;
2170
2171       /* If there is no explicit region, a fake one should be created.  */
2172       gdb_assert (region);
2173
2174       if (region->hi == 0)
2175         rlen = len - xfered;
2176       else
2177         rlen = region->hi - offset;
2178
2179       if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
2180         {
2181           /* Cannot read this region.  Note that we can end up here only
2182              if the region is explicitly marked inaccessible, or
2183              'inaccessible-by-default' is in effect.  */
2184           xfered += rlen;
2185         }
2186       else
2187         {
2188           LONGEST to_read = min (len - xfered, rlen);
2189           gdb_byte *buffer = (gdb_byte *)xmalloc (to_read);
2190
2191           LONGEST xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2192                                       (gdb_byte *) buffer,
2193                                       offset + xfered, to_read);
2194           /* Call an observer, notifying them of the xfer progress?  */
2195           if (xfer <= 0)
2196             {
2197               /* Got an error reading full chunk.  See if maybe we can read
2198                  some subrange.  */
2199               xfree (buffer);
2200               read_whatever_is_readable (ops, offset + xfered,
2201                                          offset + xfered + to_read, &result);
2202               xfered += to_read;
2203             }
2204           else
2205             {
2206               struct memory_read_result r;
2207               r.data = buffer;
2208               r.begin = offset + xfered;
2209               r.end = r.begin + xfer;
2210               VEC_safe_push (memory_read_result_s, result, &r);
2211               xfered += xfer;
2212             }
2213           QUIT;
2214         }
2215     }
2216   return result;
2217 }
2218
2219
2220 /* An alternative to target_write with progress callbacks.  */
2221
2222 LONGEST
2223 target_write_with_progress (struct target_ops *ops,
2224                             enum target_object object,
2225                             const char *annex, const gdb_byte *buf,
2226                             ULONGEST offset, LONGEST len,
2227                             void (*progress) (ULONGEST, void *), void *baton)
2228 {
2229   LONGEST xfered = 0;
2230
2231   /* Give the progress callback a chance to set up.  */
2232   if (progress)
2233     (*progress) (0, baton);
2234
2235   while (xfered < len)
2236     {
2237       LONGEST xfer = target_write_partial (ops, object, annex,
2238                                            (gdb_byte *) buf + xfered,
2239                                            offset + xfered, len - xfered);
2240
2241       if (xfer == 0)
2242         return xfered;
2243       if (xfer < 0)
2244         return -1;
2245
2246       if (progress)
2247         (*progress) (xfer, baton);
2248
2249       xfered += xfer;
2250       QUIT;
2251     }
2252   return len;
2253 }
2254
2255 /* For docs on target_write see target.h.  */
2256
2257 LONGEST
2258 target_write (struct target_ops *ops,
2259               enum target_object object,
2260               const char *annex, const gdb_byte *buf,
2261               ULONGEST offset, LONGEST len)
2262 {
2263   return target_write_with_progress (ops, object, annex, buf, offset, len,
2264                                      NULL, NULL);
2265 }
2266
2267 /* Read OBJECT/ANNEX using OPS.  Store the result in *BUF_P and return
2268    the size of the transferred data.  PADDING additional bytes are
2269    available in *BUF_P.  This is a helper function for
2270    target_read_alloc; see the declaration of that function for more
2271    information.  */
2272
2273 static LONGEST
2274 target_read_alloc_1 (struct target_ops *ops, enum target_object object,
2275                      const char *annex, gdb_byte **buf_p, int padding)
2276 {
2277   size_t buf_alloc, buf_pos;
2278   gdb_byte *buf;
2279   LONGEST n;
2280
2281   /* This function does not have a length parameter; it reads the
2282      entire OBJECT).  Also, it doesn't support objects fetched partly
2283      from one target and partly from another (in a different stratum,
2284      e.g. a core file and an executable).  Both reasons make it
2285      unsuitable for reading memory.  */
2286   gdb_assert (object != TARGET_OBJECT_MEMORY);
2287
2288   /* Start by reading up to 4K at a time.  The target will throttle
2289      this number down if necessary.  */
2290   buf_alloc = 4096;
2291   buf = xmalloc (buf_alloc);
2292   buf_pos = 0;
2293   while (1)
2294     {
2295       n = target_read_partial (ops, object, annex, &buf[buf_pos],
2296                                buf_pos, buf_alloc - buf_pos - padding);
2297       if (n < 0)
2298         {
2299           /* An error occurred.  */
2300           xfree (buf);
2301           return -1;
2302         }
2303       else if (n == 0)
2304         {
2305           /* Read all there was.  */
2306           if (buf_pos == 0)
2307             xfree (buf);
2308           else
2309             *buf_p = buf;
2310           return buf_pos;
2311         }
2312
2313       buf_pos += n;
2314
2315       /* If the buffer is filling up, expand it.  */
2316       if (buf_alloc < buf_pos * 2)
2317         {
2318           buf_alloc *= 2;
2319           buf = xrealloc (buf, buf_alloc);
2320         }
2321
2322       QUIT;
2323     }
2324 }
2325
2326 /* Read OBJECT/ANNEX using OPS.  Store the result in *BUF_P and return
2327    the size of the transferred data.  See the declaration in "target.h"
2328    function for more information about the return value.  */
2329
2330 LONGEST
2331 target_read_alloc (struct target_ops *ops, enum target_object object,
2332                    const char *annex, gdb_byte **buf_p)
2333 {
2334   return target_read_alloc_1 (ops, object, annex, buf_p, 0);
2335 }
2336
2337 /* Read OBJECT/ANNEX using OPS.  The result is NUL-terminated and
2338    returned as a string, allocated using xmalloc.  If an error occurs
2339    or the transfer is unsupported, NULL is returned.  Empty objects
2340    are returned as allocated but empty strings.  A warning is issued
2341    if the result contains any embedded NUL bytes.  */
2342
2343 char *
2344 target_read_stralloc (struct target_ops *ops, enum target_object object,
2345                       const char *annex)
2346 {
2347   gdb_byte *buffer;
2348   LONGEST i, transferred;
2349
2350   transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
2351
2352   if (transferred < 0)
2353     return NULL;
2354
2355   if (transferred == 0)
2356     return xstrdup ("");
2357
2358   buffer[transferred] = 0;
2359
2360   /* Check for embedded NUL bytes; but allow trailing NULs.  */
2361   for (i = strlen (buffer); i < transferred; i++)
2362     if (buffer[i] != 0)
2363       {
2364         warning (_("target object %d, annex %s, "
2365                    "contained unexpected null characters"),
2366                  (int) object, annex ? annex : "(none)");
2367         break;
2368       }
2369
2370   return (char *) buffer;
2371 }
2372
2373 /* Memory transfer methods.  */
2374
2375 void
2376 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
2377                    LONGEST len)
2378 {
2379   /* This method is used to read from an alternate, non-current
2380      target.  This read must bypass the overlay support (as symbols
2381      don't match this target), and GDB's internal cache (wrong cache
2382      for this target).  */
2383   if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
2384       != len)
2385     memory_error (EIO, addr);
2386 }
2387
2388 ULONGEST
2389 get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2390                             int len, enum bfd_endian byte_order)
2391 {
2392   gdb_byte buf[sizeof (ULONGEST)];
2393
2394   gdb_assert (len <= sizeof (buf));
2395   get_target_memory (ops, addr, buf, len);
2396   return extract_unsigned_integer (buf, len, byte_order);
2397 }
2398
2399 int
2400 target_insert_breakpoint (struct gdbarch *gdbarch,
2401                           struct bp_target_info *bp_tgt)
2402 {
2403   if (!may_insert_breakpoints)
2404     {
2405       warning (_("May not insert breakpoints"));
2406       return 1;
2407     }
2408
2409   return (*current_target.to_insert_breakpoint) (gdbarch, bp_tgt);
2410 }
2411
2412 int
2413 target_remove_breakpoint (struct gdbarch *gdbarch,
2414                           struct bp_target_info *bp_tgt)
2415 {
2416   /* This is kind of a weird case to handle, but the permission might
2417      have been changed after breakpoints were inserted - in which case
2418      we should just take the user literally and assume that any
2419      breakpoints should be left in place.  */
2420   if (!may_insert_breakpoints)
2421     {
2422       warning (_("May not remove breakpoints"));
2423       return 1;
2424     }
2425
2426   return (*current_target.to_remove_breakpoint) (gdbarch, bp_tgt);
2427 }
2428
2429 static void
2430 target_info (char *args, int from_tty)
2431 {
2432   struct target_ops *t;
2433   int has_all_mem = 0;
2434
2435   if (symfile_objfile != NULL)
2436     printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
2437
2438   for (t = target_stack; t != NULL; t = t->beneath)
2439     {
2440       if (!(*t->to_has_memory) (t))
2441         continue;
2442
2443       if ((int) (t->to_stratum) <= (int) dummy_stratum)
2444         continue;
2445       if (has_all_mem)
2446         printf_unfiltered (_("\tWhile running this, "
2447                              "GDB does not access memory from...\n"));
2448       printf_unfiltered ("%s:\n", t->to_longname);
2449       (t->to_files_info) (t);
2450       has_all_mem = (*t->to_has_all_memory) (t);
2451     }
2452 }
2453
2454 /* This function is called before any new inferior is created, e.g.
2455    by running a program, attaching, or connecting to a target.
2456    It cleans up any state from previous invocations which might
2457    change between runs.  This is a subset of what target_preopen
2458    resets (things which might change between targets).  */
2459
2460 void
2461 target_pre_inferior (int from_tty)
2462 {
2463   /* Clear out solib state.  Otherwise the solib state of the previous
2464      inferior might have survived and is entirely wrong for the new
2465      target.  This has been observed on GNU/Linux using glibc 2.3.  How
2466      to reproduce:
2467
2468      bash$ ./foo&
2469      [1] 4711
2470      bash$ ./foo&
2471      [1] 4712
2472      bash$ gdb ./foo
2473      [...]
2474      (gdb) attach 4711
2475      (gdb) detach
2476      (gdb) attach 4712
2477      Cannot access memory at address 0xdeadbeef
2478   */
2479
2480   /* In some OSs, the shared library list is the same/global/shared
2481      across inferiors.  If code is shared between processes, so are
2482      memory regions and features.  */
2483   if (!gdbarch_has_global_solist (target_gdbarch))
2484     {
2485       no_shared_libraries (NULL, from_tty);
2486
2487       invalidate_target_mem_regions ();
2488
2489       target_clear_description ();
2490     }
2491 }
2492
2493 /* Callback for iterate_over_inferiors.  Gets rid of the given
2494    inferior.  */
2495
2496 static int
2497 dispose_inferior (struct inferior *inf, void *args)
2498 {
2499   struct thread_info *thread;
2500
2501   thread = any_thread_of_process (inf->pid);
2502   if (thread)
2503     {
2504       switch_to_thread (thread->ptid);
2505
2506       /* Core inferiors actually should be detached, not killed.  */
2507       if (target_has_execution)
2508         target_kill ();
2509       else
2510         target_detach (NULL, 0);
2511     }
2512
2513   return 0;
2514 }
2515
2516 /* This is to be called by the open routine before it does
2517    anything.  */
2518
2519 void
2520 target_preopen (int from_tty)
2521 {
2522   dont_repeat ();
2523
2524   if (have_inferiors ())
2525     {
2526       if (!from_tty
2527           || !have_live_inferiors ()
2528           || query (_("A program is being debugged already.  Kill it? ")))
2529         iterate_over_inferiors (dispose_inferior, NULL);
2530       else
2531         error (_("Program not killed."));
2532     }
2533
2534   /* Calling target_kill may remove the target from the stack.  But if
2535      it doesn't (which seems like a win for UDI), remove it now.  */
2536   /* Leave the exec target, though.  The user may be switching from a
2537      live process to a core of the same program.  */
2538   pop_all_targets_above (file_stratum, 0);
2539
2540   target_pre_inferior (from_tty);
2541 }
2542
2543 /* Detach a target after doing deferred register stores.  */
2544
2545 void
2546 target_detach (char *args, int from_tty)
2547 {
2548   struct target_ops* t;
2549   
2550   if (gdbarch_has_global_breakpoints (target_gdbarch))
2551     /* Don't remove global breakpoints here.  They're removed on
2552        disconnection from the target.  */
2553     ;
2554   else
2555     /* If we're in breakpoints-always-inserted mode, have to remove
2556        them before detaching.  */
2557     remove_breakpoints_pid (PIDGET (inferior_ptid));
2558
2559   prepare_for_detach ();
2560
2561   for (t = current_target.beneath; t != NULL; t = t->beneath)
2562     {
2563       if (t->to_detach != NULL)
2564         {
2565           t->to_detach (t, args, from_tty);
2566           if (targetdebug)
2567             fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n",
2568                                 args, from_tty);
2569           return;
2570         }
2571     }
2572
2573   internal_error (__FILE__, __LINE__, _("could not find a target to detach"));
2574 }
2575
2576 void
2577 target_disconnect (char *args, int from_tty)
2578 {
2579   struct target_ops *t;
2580
2581   /* If we're in breakpoints-always-inserted mode or if breakpoints
2582      are global across processes, we have to remove them before
2583      disconnecting.  */
2584   remove_breakpoints ();
2585
2586   for (t = current_target.beneath; t != NULL; t = t->beneath)
2587     if (t->to_disconnect != NULL)
2588         {
2589           if (targetdebug)
2590             fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
2591                                 args, from_tty);
2592           t->to_disconnect (t, args, from_tty);
2593           return;
2594         }
2595
2596   tcomplain ();
2597 }
2598
2599 ptid_t
2600 target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
2601 {
2602   struct target_ops *t;
2603
2604   for (t = current_target.beneath; t != NULL; t = t->beneath)
2605     {
2606       if (t->to_wait != NULL)
2607         {
2608           ptid_t retval = (*t->to_wait) (t, ptid, status, options);
2609
2610           if (targetdebug)
2611             {
2612               char *status_string;
2613
2614               status_string = target_waitstatus_to_string (status);
2615               fprintf_unfiltered (gdb_stdlog,
2616                                   "target_wait (%d, status) = %d,   %s\n",
2617                                   PIDGET (ptid), PIDGET (retval),
2618                                   status_string);
2619               xfree (status_string);
2620             }
2621
2622           return retval;
2623         }
2624     }
2625
2626   noprocess ();
2627 }
2628
2629 char *
2630 target_pid_to_str (ptid_t ptid)
2631 {
2632   struct target_ops *t;
2633
2634   for (t = current_target.beneath; t != NULL; t = t->beneath)
2635     {
2636       if (t->to_pid_to_str != NULL)
2637         return (*t->to_pid_to_str) (t, ptid);
2638     }
2639
2640   return normal_pid_to_str (ptid);
2641 }
2642
2643 char *
2644 target_thread_name (struct thread_info *info)
2645 {
2646   struct target_ops *t;
2647
2648   for (t = current_target.beneath; t != NULL; t = t->beneath)
2649     {
2650       if (t->to_thread_name != NULL)
2651         return (*t->to_thread_name) (info);
2652     }
2653
2654   return NULL;
2655 }
2656
2657 void
2658 target_resume (ptid_t ptid, int step, enum target_signal signal)
2659 {
2660   struct target_ops *t;
2661
2662   target_dcache_invalidate ();
2663
2664   for (t = current_target.beneath; t != NULL; t = t->beneath)
2665     {
2666       if (t->to_resume != NULL)
2667         {
2668           t->to_resume (t, ptid, step, signal);
2669           if (targetdebug)
2670             fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n",
2671                                 PIDGET (ptid),
2672                                 step ? "step" : "continue",
2673                                 target_signal_to_name (signal));
2674
2675           registers_changed_ptid (ptid);
2676           set_executing (ptid, 1);
2677           set_running (ptid, 1);
2678           clear_inline_frame_state (ptid);
2679           return;
2680         }
2681     }
2682
2683   noprocess ();
2684 }
2685
2686 void
2687 target_pass_signals (int numsigs, unsigned char *pass_signals)
2688 {
2689   struct target_ops *t;
2690
2691   for (t = current_target.beneath; t != NULL; t = t->beneath)
2692     {
2693       if (t->to_pass_signals != NULL)
2694         {
2695           if (targetdebug)
2696             {
2697               int i;
2698
2699               fprintf_unfiltered (gdb_stdlog, "target_pass_signals (%d, {",
2700                                   numsigs);
2701
2702               for (i = 0; i < numsigs; i++)
2703                 if (pass_signals[i])
2704                   fprintf_unfiltered (gdb_stdlog, " %s",
2705                                       target_signal_to_name (i));
2706
2707               fprintf_unfiltered (gdb_stdlog, " })\n");
2708             }
2709
2710           (*t->to_pass_signals) (numsigs, pass_signals);
2711           return;
2712         }
2713     }
2714 }
2715
2716 /* Look through the list of possible targets for a target that can
2717    follow forks.  */
2718
2719 int
2720 target_follow_fork (int follow_child)
2721 {
2722   struct target_ops *t;
2723
2724   for (t = current_target.beneath; t != NULL; t = t->beneath)
2725     {
2726       if (t->to_follow_fork != NULL)
2727         {
2728           int retval = t->to_follow_fork (t, follow_child);
2729
2730           if (targetdebug)
2731             fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2732                                 follow_child, retval);
2733           return retval;
2734         }
2735     }
2736
2737   /* Some target returned a fork event, but did not know how to follow it.  */
2738   internal_error (__FILE__, __LINE__,
2739                   _("could not find a target to follow fork"));
2740 }
2741
2742 void
2743 target_mourn_inferior (void)
2744 {
2745   struct target_ops *t;
2746
2747   for (t = current_target.beneath; t != NULL; t = t->beneath)
2748     {
2749       if (t->to_mourn_inferior != NULL) 
2750         {
2751           t->to_mourn_inferior (t);
2752           if (targetdebug)
2753             fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2754
2755           /* We no longer need to keep handles on any of the object files.
2756              Make sure to release them to avoid unnecessarily locking any
2757              of them while we're not actually debugging.  */
2758           bfd_cache_close_all ();
2759
2760           return;
2761         }
2762     }
2763
2764   internal_error (__FILE__, __LINE__,
2765                   _("could not find a target to follow mourn inferior"));
2766 }
2767
2768 /* Look for a target which can describe architectural features, starting
2769    from TARGET.  If we find one, return its description.  */
2770
2771 const struct target_desc *
2772 target_read_description (struct target_ops *target)
2773 {
2774   struct target_ops *t;
2775
2776   for (t = target; t != NULL; t = t->beneath)
2777     if (t->to_read_description != NULL)
2778       {
2779         const struct target_desc *tdesc;
2780
2781         tdesc = t->to_read_description (t);
2782         if (tdesc)
2783           return tdesc;
2784       }
2785
2786   return NULL;
2787 }
2788
2789 /* The default implementation of to_search_memory.
2790    This implements a basic search of memory, reading target memory and
2791    performing the search here (as opposed to performing the search in on the
2792    target side with, for example, gdbserver).  */
2793
2794 int
2795 simple_search_memory (struct target_ops *ops,
2796                       CORE_ADDR start_addr, ULONGEST search_space_len,
2797                       const gdb_byte *pattern, ULONGEST pattern_len,
2798                       CORE_ADDR *found_addrp)
2799 {
2800   /* NOTE: also defined in find.c testcase.  */
2801 #define SEARCH_CHUNK_SIZE 16000
2802   const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2803   /* Buffer to hold memory contents for searching.  */
2804   gdb_byte *search_buf;
2805   unsigned search_buf_size;
2806   struct cleanup *old_cleanups;
2807
2808   search_buf_size = chunk_size + pattern_len - 1;
2809
2810   /* No point in trying to allocate a buffer larger than the search space.  */
2811   if (search_space_len < search_buf_size)
2812     search_buf_size = search_space_len;
2813
2814   search_buf = malloc (search_buf_size);
2815   if (search_buf == NULL)
2816     error (_("Unable to allocate memory to perform the search."));
2817   old_cleanups = make_cleanup (free_current_contents, &search_buf);
2818
2819   /* Prime the search buffer.  */
2820
2821   if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2822                    search_buf, start_addr, search_buf_size) != search_buf_size)
2823     {
2824       warning (_("Unable to access target memory at %s, halting search."),
2825                hex_string (start_addr));
2826       do_cleanups (old_cleanups);
2827       return -1;
2828     }
2829
2830   /* Perform the search.
2831
2832      The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2833      When we've scanned N bytes we copy the trailing bytes to the start and
2834      read in another N bytes.  */
2835
2836   while (search_space_len >= pattern_len)
2837     {
2838       gdb_byte *found_ptr;
2839       unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2840
2841       found_ptr = memmem (search_buf, nr_search_bytes,
2842                           pattern, pattern_len);
2843
2844       if (found_ptr != NULL)
2845         {
2846           CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
2847
2848           *found_addrp = found_addr;
2849           do_cleanups (old_cleanups);
2850           return 1;
2851         }
2852
2853       /* Not found in this chunk, skip to next chunk.  */
2854
2855       /* Don't let search_space_len wrap here, it's unsigned.  */
2856       if (search_space_len >= chunk_size)
2857         search_space_len -= chunk_size;
2858       else
2859         search_space_len = 0;
2860
2861       if (search_space_len >= pattern_len)
2862         {
2863           unsigned keep_len = search_buf_size - chunk_size;
2864           CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
2865           int nr_to_read;
2866
2867           /* Copy the trailing part of the previous iteration to the front
2868              of the buffer for the next iteration.  */
2869           gdb_assert (keep_len == pattern_len - 1);
2870           memcpy (search_buf, search_buf + chunk_size, keep_len);
2871
2872           nr_to_read = min (search_space_len - keep_len, chunk_size);
2873
2874           if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2875                            search_buf + keep_len, read_addr,
2876                            nr_to_read) != nr_to_read)
2877             {
2878               warning (_("Unable to access target "
2879                          "memory at %s, halting search."),
2880                        hex_string (read_addr));
2881               do_cleanups (old_cleanups);
2882               return -1;
2883             }
2884
2885           start_addr += chunk_size;
2886         }
2887     }
2888
2889   /* Not found.  */
2890
2891   do_cleanups (old_cleanups);
2892   return 0;
2893 }
2894
2895 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2896    sequence of bytes in PATTERN with length PATTERN_LEN.
2897
2898    The result is 1 if found, 0 if not found, and -1 if there was an error
2899    requiring halting of the search (e.g. memory read error).
2900    If the pattern is found the address is recorded in FOUND_ADDRP.  */
2901
2902 int
2903 target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2904                       const gdb_byte *pattern, ULONGEST pattern_len,
2905                       CORE_ADDR *found_addrp)
2906 {
2907   struct target_ops *t;
2908   int found;
2909
2910   /* We don't use INHERIT to set current_target.to_search_memory,
2911      so we have to scan the target stack and handle targetdebug
2912      ourselves.  */
2913
2914   if (targetdebug)
2915     fprintf_unfiltered (gdb_stdlog, "target_search_memory (%s, ...)\n",
2916                         hex_string (start_addr));
2917
2918   for (t = current_target.beneath; t != NULL; t = t->beneath)
2919     if (t->to_search_memory != NULL)
2920       break;
2921
2922   if (t != NULL)
2923     {
2924       found = t->to_search_memory (t, start_addr, search_space_len,
2925                                    pattern, pattern_len, found_addrp);
2926     }
2927   else
2928     {
2929       /* If a special version of to_search_memory isn't available, use the
2930          simple version.  */
2931       found = simple_search_memory (current_target.beneath,
2932                                     start_addr, search_space_len,
2933                                     pattern, pattern_len, found_addrp);
2934     }
2935
2936   if (targetdebug)
2937     fprintf_unfiltered (gdb_stdlog, "  = %d\n", found);
2938
2939   return found;
2940 }
2941
2942 /* Look through the currently pushed targets.  If none of them will
2943    be able to restart the currently running process, issue an error
2944    message.  */
2945
2946 void
2947 target_require_runnable (void)
2948 {
2949   struct target_ops *t;
2950
2951   for (t = target_stack; t != NULL; t = t->beneath)
2952     {
2953       /* If this target knows how to create a new program, then
2954          assume we will still be able to after killing the current
2955          one.  Either killing and mourning will not pop T, or else
2956          find_default_run_target will find it again.  */
2957       if (t->to_create_inferior != NULL)
2958         return;
2959
2960       /* Do not worry about thread_stratum targets that can not
2961          create inferiors.  Assume they will be pushed again if
2962          necessary, and continue to the process_stratum.  */
2963       if (t->to_stratum == thread_stratum
2964           || t->to_stratum == arch_stratum)
2965         continue;
2966
2967       error (_("The \"%s\" target does not support \"run\".  "
2968                "Try \"help target\" or \"continue\"."),
2969              t->to_shortname);
2970     }
2971
2972   /* This function is only called if the target is running.  In that
2973      case there should have been a process_stratum target and it
2974      should either know how to create inferiors, or not...  */
2975   internal_error (__FILE__, __LINE__, _("No targets found"));
2976 }
2977
2978 /* Look through the list of possible targets for a target that can
2979    execute a run or attach command without any other data.  This is
2980    used to locate the default process stratum.
2981
2982    If DO_MESG is not NULL, the result is always valid (error() is
2983    called for errors); else, return NULL on error.  */
2984
2985 static struct target_ops *
2986 find_default_run_target (char *do_mesg)
2987 {
2988   struct target_ops **t;
2989   struct target_ops *runable = NULL;
2990   int count;
2991
2992   count = 0;
2993
2994   for (t = target_structs; t < target_structs + target_struct_size;
2995        ++t)
2996     {
2997       if ((*t)->to_can_run && target_can_run (*t))
2998         {
2999           runable = *t;
3000           ++count;
3001         }
3002     }
3003
3004   if (count != 1)
3005     {
3006       if (do_mesg)
3007         error (_("Don't know how to %s.  Try \"help target\"."), do_mesg);
3008       else
3009         return NULL;
3010     }
3011
3012   return runable;
3013 }
3014
3015 void
3016 find_default_attach (struct target_ops *ops, char *args, int from_tty)
3017 {
3018   struct target_ops *t;
3019
3020   t = find_default_run_target ("attach");
3021   (t->to_attach) (t, args, from_tty);
3022   return;
3023 }
3024
3025 void
3026 find_default_create_inferior (struct target_ops *ops,
3027                               char *exec_file, char *allargs, char **env,
3028                               int from_tty)
3029 {
3030   struct target_ops *t;
3031
3032   t = find_default_run_target ("run");
3033   (t->to_create_inferior) (t, exec_file, allargs, env, from_tty);
3034   return;
3035 }
3036
3037 static int
3038 find_default_can_async_p (void)
3039 {
3040   struct target_ops *t;
3041
3042   /* This may be called before the target is pushed on the stack;
3043      look for the default process stratum.  If there's none, gdb isn't
3044      configured with a native debugger, and target remote isn't
3045      connected yet.  */
3046   t = find_default_run_target (NULL);
3047   if (t && t->to_can_async_p)
3048     return (t->to_can_async_p) ();
3049   return 0;
3050 }
3051
3052 static int
3053 find_default_is_async_p (void)
3054 {
3055   struct target_ops *t;
3056
3057   /* This may be called before the target is pushed on the stack;
3058      look for the default process stratum.  If there's none, gdb isn't
3059      configured with a native debugger, and target remote isn't
3060      connected yet.  */
3061   t = find_default_run_target (NULL);
3062   if (t && t->to_is_async_p)
3063     return (t->to_is_async_p) ();
3064   return 0;
3065 }
3066
3067 static int
3068 find_default_supports_non_stop (void)
3069 {
3070   struct target_ops *t;
3071
3072   t = find_default_run_target (NULL);
3073   if (t && t->to_supports_non_stop)
3074     return (t->to_supports_non_stop) ();
3075   return 0;
3076 }
3077
3078 int
3079 target_supports_non_stop (void)
3080 {
3081   struct target_ops *t;
3082
3083   for (t = &current_target; t != NULL; t = t->beneath)
3084     if (t->to_supports_non_stop)
3085       return t->to_supports_non_stop ();
3086
3087   return 0;
3088 }
3089
3090 /* Implement the "info proc" command.  */
3091
3092 void
3093 target_info_proc (char *args, enum info_proc_what what)
3094 {
3095   struct target_ops *t;
3096
3097   /* If we're already connected to something that can get us OS
3098      related data, use it.  Otherwise, try using the native
3099      target.  */
3100   if (current_target.to_stratum >= process_stratum)
3101     t = current_target.beneath;
3102   else
3103     t = find_default_run_target (NULL);
3104
3105   for (; t != NULL; t = t->beneath)
3106     {
3107       if (t->to_info_proc != NULL)
3108         {
3109           t->to_info_proc (t, args, what);
3110
3111           if (targetdebug)
3112             fprintf_unfiltered (gdb_stdlog,
3113                                 "target_info_proc (\"%s\", %d)\n", args, what);
3114
3115           return;
3116         }
3117     }
3118
3119   error (_("Not supported on this target."));
3120 }
3121
3122 static int
3123 find_default_supports_disable_randomization (void)
3124 {
3125   struct target_ops *t;
3126
3127   t = find_default_run_target (NULL);
3128   if (t && t->to_supports_disable_randomization)
3129     return (t->to_supports_disable_randomization) ();
3130   return 0;
3131 }
3132
3133 int
3134 target_supports_disable_randomization (void)
3135 {
3136   struct target_ops *t;
3137
3138   for (t = &current_target; t != NULL; t = t->beneath)
3139     if (t->to_supports_disable_randomization)
3140       return t->to_supports_disable_randomization ();
3141
3142   return 0;
3143 }
3144
3145 char *
3146 target_get_osdata (const char *type)
3147 {
3148   struct target_ops *t;
3149
3150   /* If we're already connected to something that can get us OS
3151      related data, use it.  Otherwise, try using the native
3152      target.  */
3153   if (current_target.to_stratum >= process_stratum)
3154     t = current_target.beneath;
3155   else
3156     t = find_default_run_target ("get OS data");
3157
3158   if (!t)
3159     return NULL;
3160
3161   return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
3162 }
3163
3164 /* Determine the current address space of thread PTID.  */
3165
3166 struct address_space *
3167 target_thread_address_space (ptid_t ptid)
3168 {
3169   struct address_space *aspace;
3170   struct inferior *inf;
3171   struct target_ops *t;
3172
3173   for (t = current_target.beneath; t != NULL; t = t->beneath)
3174     {
3175       if (t->to_thread_address_space != NULL)
3176         {
3177           aspace = t->to_thread_address_space (t, ptid);
3178           gdb_assert (aspace);
3179
3180           if (targetdebug)
3181             fprintf_unfiltered (gdb_stdlog,
3182                                 "target_thread_address_space (%s) = %d\n",
3183                                 target_pid_to_str (ptid),
3184                                 address_space_num (aspace));
3185           return aspace;
3186         }
3187     }
3188
3189   /* Fall-back to the "main" address space of the inferior.  */
3190   inf = find_inferior_pid (ptid_get_pid (ptid));
3191
3192   if (inf == NULL || inf->aspace == NULL)
3193     internal_error (__FILE__, __LINE__,
3194                     _("Can't determine the current "
3195                       "address space of thread %s\n"),
3196                     target_pid_to_str (ptid));
3197
3198   return inf->aspace;
3199 }
3200
3201
3202 /* Target file operations.  */
3203
3204 static struct target_ops *
3205 default_fileio_target (void)
3206 {
3207   /* If we're already connected to something that can perform
3208      file I/O, use it. Otherwise, try using the native target.  */
3209   if (current_target.to_stratum >= process_stratum)
3210     return current_target.beneath;
3211   else
3212     return find_default_run_target ("file I/O");
3213 }
3214
3215 /* Open FILENAME on the target, using FLAGS and MODE.  Return a
3216    target file descriptor, or -1 if an error occurs (and set
3217    *TARGET_ERRNO).  */
3218 int
3219 target_fileio_open (const char *filename, int flags, int mode,
3220                     int *target_errno)
3221 {
3222   struct target_ops *t;
3223
3224   for (t = default_fileio_target (); t != NULL; t = t->beneath)
3225     {
3226       if (t->to_fileio_open != NULL)
3227         {
3228           int fd = t->to_fileio_open (filename, flags, mode, target_errno);
3229
3230           if (targetdebug)
3231             fprintf_unfiltered (gdb_stdlog,
3232                                 "target_fileio_open (%s,0x%x,0%o) = %d (%d)\n",
3233                                 filename, flags, mode,
3234                                 fd, fd != -1 ? 0 : *target_errno);
3235           return fd;
3236         }
3237     }
3238
3239   *target_errno = FILEIO_ENOSYS;
3240   return -1;
3241 }
3242
3243 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
3244    Return the number of bytes written, or -1 if an error occurs
3245    (and set *TARGET_ERRNO).  */
3246 int
3247 target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
3248                       ULONGEST offset, int *target_errno)
3249 {
3250   struct target_ops *t;
3251
3252   for (t = default_fileio_target (); t != NULL; t = t->beneath)
3253     {
3254       if (t->to_fileio_pwrite != NULL)
3255         {
3256           int ret = t->to_fileio_pwrite (fd, write_buf, len, offset,
3257                                          target_errno);
3258
3259           if (targetdebug)
3260             fprintf_unfiltered (gdb_stdlog,
3261                                 "target_fileio_pwrite (%d,%p,%d,%s) "
3262                                 "= %d (%d)\n",
3263                                 fd, write_buf, len, pulongest (offset),
3264                                 ret, ret != -1 ? 0 : *target_errno);
3265           return ret;
3266         }
3267     }
3268
3269   *target_errno = FILEIO_ENOSYS;
3270   return -1;
3271 }
3272
3273 /* Read up to LEN bytes FD on the target into READ_BUF.
3274    Return the number of bytes read, or -1 if an error occurs
3275    (and set *TARGET_ERRNO).  */
3276 int
3277 target_fileio_pread (int fd, gdb_byte *read_buf, int len,
3278                      ULONGEST offset, int *target_errno)
3279 {
3280   struct target_ops *t;
3281
3282   for (t = default_fileio_target (); t != NULL; t = t->beneath)
3283     {
3284       if (t->to_fileio_pread != NULL)
3285         {
3286           int ret = t->to_fileio_pread (fd, read_buf, len, offset,
3287                                         target_errno);
3288
3289           if (targetdebug)
3290             fprintf_unfiltered (gdb_stdlog,
3291                                 "target_fileio_pread (%d,%p,%d,%s) "
3292                                 "= %d (%d)\n",
3293                                 fd, read_buf, len, pulongest (offset),
3294                                 ret, ret != -1 ? 0 : *target_errno);
3295           return ret;
3296         }
3297     }
3298
3299   *target_errno = FILEIO_ENOSYS;
3300   return -1;
3301 }
3302
3303 /* Close FD on the target.  Return 0, or -1 if an error occurs
3304    (and set *TARGET_ERRNO).  */
3305 int
3306 target_fileio_close (int fd, int *target_errno)
3307 {
3308   struct target_ops *t;
3309
3310   for (t = default_fileio_target (); t != NULL; t = t->beneath)
3311     {
3312       if (t->to_fileio_close != NULL)
3313         {
3314           int ret = t->to_fileio_close (fd, target_errno);
3315
3316           if (targetdebug)
3317             fprintf_unfiltered (gdb_stdlog,
3318                                 "target_fileio_close (%d) = %d (%d)\n",
3319                                 fd, ret, ret != -1 ? 0 : *target_errno);
3320           return ret;
3321         }
3322     }
3323
3324   *target_errno = FILEIO_ENOSYS;
3325   return -1;
3326 }
3327
3328 /* Unlink FILENAME on the target.  Return 0, or -1 if an error
3329    occurs (and set *TARGET_ERRNO).  */
3330 int
3331 target_fileio_unlink (const char *filename, int *target_errno)
3332 {
3333   struct target_ops *t;
3334
3335   for (t = default_fileio_target (); t != NULL; t = t->beneath)
3336     {
3337       if (t->to_fileio_unlink != NULL)
3338         {
3339           int ret = t->to_fileio_unlink (filename, target_errno);
3340
3341           if (targetdebug)
3342             fprintf_unfiltered (gdb_stdlog,
3343                                 "target_fileio_unlink (%s) = %d (%d)\n",
3344                                 filename, ret, ret != -1 ? 0 : *target_errno);
3345           return ret;
3346         }
3347     }
3348
3349   *target_errno = FILEIO_ENOSYS;
3350   return -1;
3351 }
3352
3353 /* Read value of symbolic link FILENAME on the target.  Return a
3354    null-terminated string allocated via xmalloc, or NULL if an error
3355    occurs (and set *TARGET_ERRNO).  */
3356 char *
3357 target_fileio_readlink (const char *filename, int *target_errno)
3358 {
3359   struct target_ops *t;
3360
3361   for (t = default_fileio_target (); t != NULL; t = t->beneath)
3362     {
3363       if (t->to_fileio_readlink != NULL)
3364         {
3365           char *ret = t->to_fileio_readlink (filename, target_errno);
3366
3367           if (targetdebug)
3368             fprintf_unfiltered (gdb_stdlog,
3369                                 "target_fileio_readlink (%s) = %s (%d)\n",
3370                                 filename, ret? ret : "(nil)",
3371                                 ret? 0 : *target_errno);
3372           return ret;
3373         }
3374     }
3375
3376   *target_errno = FILEIO_ENOSYS;
3377   return NULL;
3378 }
3379
3380 static void
3381 target_fileio_close_cleanup (void *opaque)
3382 {
3383   int fd = *(int *) opaque;
3384   int target_errno;
3385
3386   target_fileio_close (fd, &target_errno);
3387 }
3388
3389 /* Read target file FILENAME.  Store the result in *BUF_P and
3390    return the size of the transferred data.  PADDING additional bytes are
3391    available in *BUF_P.  This is a helper function for
3392    target_fileio_read_alloc; see the declaration of that function for more
3393    information.  */
3394
3395 static LONGEST
3396 target_fileio_read_alloc_1 (const char *filename,
3397                             gdb_byte **buf_p, int padding)
3398 {
3399   struct cleanup *close_cleanup;
3400   size_t buf_alloc, buf_pos;
3401   gdb_byte *buf;
3402   LONGEST n;
3403   int fd;
3404   int target_errno;
3405
3406   fd = target_fileio_open (filename, FILEIO_O_RDONLY, 0700, &target_errno);
3407   if (fd == -1)
3408     return -1;
3409
3410   close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
3411
3412   /* Start by reading up to 4K at a time.  The target will throttle
3413      this number down if necessary.  */
3414   buf_alloc = 4096;
3415   buf = xmalloc (buf_alloc);
3416   buf_pos = 0;
3417   while (1)
3418     {
3419       n = target_fileio_pread (fd, &buf[buf_pos],
3420                                buf_alloc - buf_pos - padding, buf_pos,
3421                                &target_errno);
3422       if (n < 0)
3423         {
3424           /* An error occurred.  */
3425           do_cleanups (close_cleanup);
3426           xfree (buf);
3427           return -1;
3428         }
3429       else if (n == 0)
3430         {
3431           /* Read all there was.  */
3432           do_cleanups (close_cleanup);
3433           if (buf_pos == 0)
3434             xfree (buf);
3435           else
3436             *buf_p = buf;
3437           return buf_pos;
3438         }
3439
3440       buf_pos += n;
3441
3442       /* If the buffer is filling up, expand it.  */
3443       if (buf_alloc < buf_pos * 2)
3444         {
3445           buf_alloc *= 2;
3446           buf = xrealloc (buf, buf_alloc);
3447         }
3448
3449       QUIT;
3450     }
3451 }
3452
3453 /* Read target file FILENAME.  Store the result in *BUF_P and return
3454    the size of the transferred data.  See the declaration in "target.h"
3455    function for more information about the return value.  */
3456
3457 LONGEST
3458 target_fileio_read_alloc (const char *filename, gdb_byte **buf_p)
3459 {
3460   return target_fileio_read_alloc_1 (filename, buf_p, 0);
3461 }
3462
3463 /* Read target file FILENAME.  The result is NUL-terminated and
3464    returned as a string, allocated using xmalloc.  If an error occurs
3465    or the transfer is unsupported, NULL is returned.  Empty objects
3466    are returned as allocated but empty strings.  A warning is issued
3467    if the result contains any embedded NUL bytes.  */
3468
3469 char *
3470 target_fileio_read_stralloc (const char *filename)
3471 {
3472   gdb_byte *buffer;
3473   LONGEST i, transferred;
3474
3475   transferred = target_fileio_read_alloc_1 (filename, &buffer, 1);
3476
3477   if (transferred < 0)
3478     return NULL;
3479
3480   if (transferred == 0)
3481     return xstrdup ("");
3482
3483   buffer[transferred] = 0;
3484
3485   /* Check for embedded NUL bytes; but allow trailing NULs.  */
3486   for (i = strlen (buffer); i < transferred; i++)
3487     if (buffer[i] != 0)
3488       {
3489         warning (_("target file %s "
3490                    "contained unexpected null characters"),
3491                  filename);
3492         break;
3493       }
3494
3495   return (char *) buffer;
3496 }
3497
3498
3499 static int
3500 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
3501 {
3502   return (len <= gdbarch_ptr_bit (target_gdbarch) / TARGET_CHAR_BIT);
3503 }
3504
3505 static int
3506 default_watchpoint_addr_within_range (struct target_ops *target,
3507                                       CORE_ADDR addr,
3508                                       CORE_ADDR start, int length)
3509 {
3510   return addr >= start && addr < start + length;
3511 }
3512
3513 static struct gdbarch *
3514 default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3515 {
3516   return target_gdbarch;
3517 }
3518
3519 static int
3520 return_zero (void)
3521 {
3522   return 0;
3523 }
3524
3525 static int
3526 return_one (void)
3527 {
3528   return 1;
3529 }
3530
3531 static int
3532 return_minus_one (void)
3533 {
3534   return -1;
3535 }
3536
3537 /* Find a single runnable target in the stack and return it.  If for
3538    some reason there is more than one, return NULL.  */
3539
3540 struct target_ops *
3541 find_run_target (void)
3542 {
3543   struct target_ops **t;
3544   struct target_ops *runable = NULL;
3545   int count;
3546
3547   count = 0;
3548
3549   for (t = target_structs; t < target_structs + target_struct_size; ++t)
3550     {
3551       if ((*t)->to_can_run && target_can_run (*t))
3552         {
3553           runable = *t;
3554           ++count;
3555         }
3556     }
3557
3558   return (count == 1 ? runable : NULL);
3559 }
3560
3561 /*
3562  * Find the next target down the stack from the specified target.
3563  */
3564
3565 struct target_ops *
3566 find_target_beneath (struct target_ops *t)
3567 {
3568   return t->beneath;
3569 }
3570
3571 \f
3572 /* The inferior process has died.  Long live the inferior!  */
3573
3574 void
3575 generic_mourn_inferior (void)
3576 {
3577   ptid_t ptid;
3578
3579   ptid = inferior_ptid;
3580   inferior_ptid = null_ptid;
3581
3582   if (!ptid_equal (ptid, null_ptid))
3583     {
3584       int pid = ptid_get_pid (ptid);
3585       exit_inferior (pid);
3586     }
3587
3588   breakpoint_init_inferior (inf_exited);
3589   registers_changed ();
3590
3591   reopen_exec_file ();
3592   reinit_frame_cache ();
3593
3594   if (deprecated_detach_hook)
3595     deprecated_detach_hook ();
3596 }
3597 \f
3598 /* Helper function for child_wait and the derivatives of child_wait.
3599    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
3600    translation of that in OURSTATUS.  */
3601 void
3602 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
3603 {
3604   if (WIFEXITED (hoststatus))
3605     {
3606       ourstatus->kind = TARGET_WAITKIND_EXITED;
3607       ourstatus->value.integer = WEXITSTATUS (hoststatus);
3608     }
3609   else if (!WIFSTOPPED (hoststatus))
3610     {
3611       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
3612       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
3613     }
3614   else
3615     {
3616       ourstatus->kind = TARGET_WAITKIND_STOPPED;
3617       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
3618     }
3619 }
3620 \f
3621 /* Convert a normal process ID to a string.  Returns the string in a
3622    static buffer.  */
3623
3624 char *
3625 normal_pid_to_str (ptid_t ptid)
3626 {
3627   static char buf[32];
3628
3629   xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
3630   return buf;
3631 }
3632
3633 static char *
3634 dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
3635 {
3636   return normal_pid_to_str (ptid);
3637 }
3638
3639 /* Error-catcher for target_find_memory_regions.  */
3640 static int
3641 dummy_find_memory_regions (find_memory_region_ftype ignore1, void *ignore2)
3642 {
3643   error (_("Command not implemented for this target."));
3644   return 0;
3645 }
3646
3647 /* Error-catcher for target_make_corefile_notes.  */
3648 static char *
3649 dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
3650 {
3651   error (_("Command not implemented for this target."));
3652   return NULL;
3653 }
3654
3655 /* Error-catcher for target_get_bookmark.  */
3656 static gdb_byte *
3657 dummy_get_bookmark (char *ignore1, int ignore2)
3658 {
3659   tcomplain ();
3660   return NULL;
3661 }
3662
3663 /* Error-catcher for target_goto_bookmark.  */
3664 static void
3665 dummy_goto_bookmark (gdb_byte *ignore, int from_tty)
3666 {
3667   tcomplain ();
3668 }
3669
3670 /* Set up the handful of non-empty slots needed by the dummy target
3671    vector.  */
3672
3673 static void
3674 init_dummy_target (void)
3675 {
3676   dummy_target.to_shortname = "None";
3677   dummy_target.to_longname = "None";
3678   dummy_target.to_doc = "";
3679   dummy_target.to_attach = find_default_attach;
3680   dummy_target.to_detach = 
3681     (void (*)(struct target_ops *, char *, int))target_ignore;
3682   dummy_target.to_create_inferior = find_default_create_inferior;
3683   dummy_target.to_can_async_p = find_default_can_async_p;
3684   dummy_target.to_is_async_p = find_default_is_async_p;
3685   dummy_target.to_supports_non_stop = find_default_supports_non_stop;
3686   dummy_target.to_supports_disable_randomization
3687     = find_default_supports_disable_randomization;
3688   dummy_target.to_pid_to_str = dummy_pid_to_str;
3689   dummy_target.to_stratum = dummy_stratum;
3690   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
3691   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
3692   dummy_target.to_get_bookmark = dummy_get_bookmark;
3693   dummy_target.to_goto_bookmark = dummy_goto_bookmark;
3694   dummy_target.to_xfer_partial = default_xfer_partial;
3695   dummy_target.to_has_all_memory = (int (*) (struct target_ops *)) return_zero;
3696   dummy_target.to_has_memory = (int (*) (struct target_ops *)) return_zero;
3697   dummy_target.to_has_stack = (int (*) (struct target_ops *)) return_zero;
3698   dummy_target.to_has_registers = (int (*) (struct target_ops *)) return_zero;
3699   dummy_target.to_has_execution
3700     = (int (*) (struct target_ops *, ptid_t)) return_zero;
3701   dummy_target.to_stopped_by_watchpoint = return_zero;
3702   dummy_target.to_stopped_data_address =
3703     (int (*) (struct target_ops *, CORE_ADDR *)) return_zero;
3704   dummy_target.to_magic = OPS_MAGIC;
3705 }
3706 \f
3707 static void
3708 debug_to_open (char *args, int from_tty)
3709 {
3710   debug_target.to_open (args, from_tty);
3711
3712   fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
3713 }
3714
3715 void
3716 target_close (struct target_ops *targ, int quitting)
3717 {
3718   if (targ->to_xclose != NULL)
3719     targ->to_xclose (targ, quitting);
3720   else if (targ->to_close != NULL)
3721     targ->to_close (quitting);
3722
3723   if (targetdebug)
3724     fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
3725 }
3726
3727 void
3728 target_attach (char *args, int from_tty)
3729 {
3730   struct target_ops *t;
3731
3732   for (t = current_target.beneath; t != NULL; t = t->beneath)
3733     {
3734       if (t->to_attach != NULL) 
3735         {
3736           t->to_attach (t, args, from_tty);
3737           if (targetdebug)
3738             fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n",
3739                                 args, from_tty);
3740           return;
3741         }
3742     }
3743
3744   internal_error (__FILE__, __LINE__,
3745                   _("could not find a target to attach"));
3746 }
3747
3748 int
3749 target_thread_alive (ptid_t ptid)
3750 {
3751   struct target_ops *t;
3752
3753   for (t = current_target.beneath; t != NULL; t = t->beneath)
3754     {
3755       if (t->to_thread_alive != NULL)
3756         {
3757           int retval;
3758
3759           retval = t->to_thread_alive (t, ptid);
3760           if (targetdebug)
3761             fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
3762                                 PIDGET (ptid), retval);
3763
3764           return retval;
3765         }
3766     }
3767
3768   return 0;
3769 }
3770
3771 void
3772 target_find_new_threads (void)
3773 {
3774   struct target_ops *t;
3775
3776   for (t = current_target.beneath; t != NULL; t = t->beneath)
3777     {
3778       if (t->to_find_new_threads != NULL)
3779         {
3780           t->to_find_new_threads (t);
3781           if (targetdebug)
3782             fprintf_unfiltered (gdb_stdlog, "target_find_new_threads ()\n");
3783
3784           return;
3785         }
3786     }
3787 }
3788
3789 void
3790 target_stop (ptid_t ptid)
3791 {
3792   if (!may_stop)
3793     {
3794       warning (_("May not interrupt or stop the target, ignoring attempt"));
3795       return;
3796     }
3797
3798   (*current_target.to_stop) (ptid);
3799 }
3800
3801 static void
3802 debug_to_post_attach (int pid)
3803 {
3804   debug_target.to_post_attach (pid);
3805
3806   fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
3807 }
3808
3809 /* Return a pretty printed form of target_waitstatus.
3810    Space for the result is malloc'd, caller must free.  */
3811
3812 char *
3813 target_waitstatus_to_string (const struct target_waitstatus *ws)
3814 {
3815   const char *kind_str = "status->kind = ";
3816
3817   switch (ws->kind)
3818     {
3819     case TARGET_WAITKIND_EXITED:
3820       return xstrprintf ("%sexited, status = %d",
3821                          kind_str, ws->value.integer);
3822     case TARGET_WAITKIND_STOPPED:
3823       return xstrprintf ("%sstopped, signal = %s",
3824                          kind_str, target_signal_to_name (ws->value.sig));
3825     case TARGET_WAITKIND_SIGNALLED:
3826       return xstrprintf ("%ssignalled, signal = %s",
3827                          kind_str, target_signal_to_name (ws->value.sig));
3828     case TARGET_WAITKIND_LOADED:
3829       return xstrprintf ("%sloaded", kind_str);
3830     case TARGET_WAITKIND_FORKED:
3831       return xstrprintf ("%sforked", kind_str);
3832     case TARGET_WAITKIND_VFORKED:
3833       return xstrprintf ("%svforked", kind_str);
3834     case TARGET_WAITKIND_EXECD:
3835       return xstrprintf ("%sexecd", kind_str);
3836     case TARGET_WAITKIND_SYSCALL_ENTRY:
3837       return xstrprintf ("%sentered syscall", kind_str);
3838     case TARGET_WAITKIND_SYSCALL_RETURN:
3839       return xstrprintf ("%sexited syscall", kind_str);
3840     case TARGET_WAITKIND_SPURIOUS:
3841       return xstrprintf ("%sspurious", kind_str);
3842     case TARGET_WAITKIND_IGNORE:
3843       return xstrprintf ("%signore", kind_str);
3844     case TARGET_WAITKIND_NO_HISTORY:
3845       return xstrprintf ("%sno-history", kind_str);
3846     case TARGET_WAITKIND_NO_RESUMED:
3847       return xstrprintf ("%sno-resumed", kind_str);
3848     default:
3849       return xstrprintf ("%sunknown???", kind_str);
3850     }
3851 }
3852
3853 static void
3854 debug_print_register (const char * func,
3855                       struct regcache *regcache, int regno)
3856 {
3857   struct gdbarch *gdbarch = get_regcache_arch (regcache);
3858
3859   fprintf_unfiltered (gdb_stdlog, "%s ", func);
3860   if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
3861       && gdbarch_register_name (gdbarch, regno) != NULL
3862       && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3863     fprintf_unfiltered (gdb_stdlog, "(%s)",
3864                         gdbarch_register_name (gdbarch, regno));
3865   else
3866     fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
3867   if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
3868     {
3869       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3870       int i, size = register_size (gdbarch, regno);
3871       unsigned char buf[MAX_REGISTER_SIZE];
3872
3873       regcache_raw_collect (regcache, regno, buf);
3874       fprintf_unfiltered (gdb_stdlog, " = ");
3875       for (i = 0; i < size; i++)
3876         {
3877           fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3878         }
3879       if (size <= sizeof (LONGEST))
3880         {
3881           ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
3882
3883           fprintf_unfiltered (gdb_stdlog, " %s %s",
3884                               core_addr_to_string_nz (val), plongest (val));
3885         }
3886     }
3887   fprintf_unfiltered (gdb_stdlog, "\n");
3888 }
3889
3890 void
3891 target_fetch_registers (struct regcache *regcache, int regno)
3892 {
3893   struct target_ops *t;
3894
3895   for (t = current_target.beneath; t != NULL; t = t->beneath)
3896     {
3897       if (t->to_fetch_registers != NULL)
3898         {
3899           t->to_fetch_registers (t, regcache, regno);
3900           if (targetdebug)
3901             debug_print_register ("target_fetch_registers", regcache, regno);
3902           return;
3903         }
3904     }
3905 }
3906
3907 void
3908 target_store_registers (struct regcache *regcache, int regno)
3909 {
3910   struct target_ops *t;
3911
3912   if (!may_write_registers)
3913     error (_("Writing to registers is not allowed (regno %d)"), regno);
3914
3915   for (t = current_target.beneath; t != NULL; t = t->beneath)
3916     {
3917       if (t->to_store_registers != NULL)
3918         {
3919           t->to_store_registers (t, regcache, regno);
3920           if (targetdebug)
3921             {
3922               debug_print_register ("target_store_registers", regcache, regno);
3923             }
3924           return;
3925         }
3926     }
3927
3928   noprocess ();
3929 }
3930
3931 int
3932 target_core_of_thread (ptid_t ptid)
3933 {
3934   struct target_ops *t;
3935
3936   for (t = current_target.beneath; t != NULL; t = t->beneath)
3937     {
3938       if (t->to_core_of_thread != NULL)
3939         {
3940           int retval = t->to_core_of_thread (t, ptid);
3941
3942           if (targetdebug)
3943             fprintf_unfiltered (gdb_stdlog,
3944                                 "target_core_of_thread (%d) = %d\n",
3945                                 PIDGET (ptid), retval);
3946           return retval;
3947         }
3948     }
3949
3950   return -1;
3951 }
3952
3953 int
3954 target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3955 {
3956   struct target_ops *t;
3957
3958   for (t = current_target.beneath; t != NULL; t = t->beneath)
3959     {
3960       if (t->to_verify_memory != NULL)
3961         {
3962           int retval = t->to_verify_memory (t, data, memaddr, size);
3963
3964           if (targetdebug)
3965             fprintf_unfiltered (gdb_stdlog,
3966                                 "target_verify_memory (%s, %s) = %d\n",
3967                                 paddress (target_gdbarch, memaddr),
3968                                 pulongest (size),
3969                                 retval);
3970           return retval;
3971         }
3972     }
3973
3974   tcomplain ();
3975 }
3976
3977 /* The documentation for this function is in its prototype declaration in
3978    target.h.  */
3979
3980 int
3981 target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3982 {
3983   struct target_ops *t;
3984
3985   for (t = current_target.beneath; t != NULL; t = t->beneath)
3986     if (t->to_insert_mask_watchpoint != NULL)
3987       {
3988         int ret;
3989
3990         ret = t->to_insert_mask_watchpoint (t, addr, mask, rw);
3991
3992         if (targetdebug)
3993           fprintf_unfiltered (gdb_stdlog, "\
3994 target_insert_mask_watchpoint (%s, %s, %d) = %d\n",
3995                               core_addr_to_string (addr),
3996                               core_addr_to_string (mask), rw, ret);
3997
3998         return ret;
3999       }
4000
4001   return 1;
4002 }
4003
4004 /* The documentation for this function is in its prototype declaration in
4005    target.h.  */
4006
4007 int
4008 target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
4009 {
4010   struct target_ops *t;
4011
4012   for (t = current_target.beneath; t != NULL; t = t->beneath)
4013     if (t->to_remove_mask_watchpoint != NULL)
4014       {
4015         int ret;
4016
4017         ret = t->to_remove_mask_watchpoint (t, addr, mask, rw);
4018
4019         if (targetdebug)
4020           fprintf_unfiltered (gdb_stdlog, "\
4021 target_remove_mask_watchpoint (%s, %s, %d) = %d\n",
4022                               core_addr_to_string (addr),
4023                               core_addr_to_string (mask), rw, ret);
4024
4025         return ret;
4026       }
4027
4028   return 1;
4029 }
4030
4031 /* The documentation for this function is in its prototype declaration
4032    in target.h.  */
4033
4034 int
4035 target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
4036 {
4037   struct target_ops *t;
4038
4039   for (t = current_target.beneath; t != NULL; t = t->beneath)
4040     if (t->to_masked_watch_num_registers != NULL)
4041       return t->to_masked_watch_num_registers (t, addr, mask);
4042
4043   return -1;
4044 }
4045
4046 /* The documentation for this function is in its prototype declaration
4047    in target.h.  */
4048
4049 int
4050 target_ranged_break_num_registers (void)
4051 {
4052   struct target_ops *t;
4053
4054   for (t = current_target.beneath; t != NULL; t = t->beneath)
4055     if (t->to_ranged_break_num_registers != NULL)
4056       return t->to_ranged_break_num_registers (t);
4057
4058   return -1;
4059 }
4060
4061 static void
4062 debug_to_prepare_to_store (struct regcache *regcache)
4063 {
4064   debug_target.to_prepare_to_store (regcache);
4065
4066   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
4067 }
4068
4069 static int
4070 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
4071                               int write, struct mem_attrib *attrib,
4072                               struct target_ops *target)
4073 {
4074   int retval;
4075
4076   retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
4077                                                 attrib, target);
4078
4079   fprintf_unfiltered (gdb_stdlog,
4080                       "target_xfer_memory (%s, xxx, %d, %s, xxx) = %d",
4081                       paddress (target_gdbarch, memaddr), len,
4082                       write ? "write" : "read", retval);
4083
4084   if (retval > 0)
4085     {
4086       int i;
4087
4088       fputs_unfiltered (", bytes =", gdb_stdlog);
4089       for (i = 0; i < retval; i++)
4090         {
4091           if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
4092             {
4093               if (targetdebug < 2 && i > 0)
4094                 {
4095                   fprintf_unfiltered (gdb_stdlog, " ...");
4096                   break;
4097                 }
4098               fprintf_unfiltered (gdb_stdlog, "\n");
4099             }
4100
4101           fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
4102         }
4103     }
4104
4105   fputc_unfiltered ('\n', gdb_stdlog);
4106
4107   return retval;
4108 }
4109
4110 static void
4111 debug_to_files_info (struct target_ops *target)
4112 {
4113   debug_target.to_files_info (target);
4114
4115   fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
4116 }
4117
4118 static int
4119 debug_to_insert_breakpoint (struct gdbarch *gdbarch,
4120                             struct bp_target_info *bp_tgt)
4121 {
4122   int retval;
4123
4124   retval = debug_target.to_insert_breakpoint (gdbarch, bp_tgt);
4125
4126   fprintf_unfiltered (gdb_stdlog,
4127                       "target_insert_breakpoint (%s, xxx) = %ld\n",
4128                       core_addr_to_string (bp_tgt->placed_address),
4129                       (unsigned long) retval);
4130   return retval;
4131 }
4132
4133 static int
4134 debug_to_remove_breakpoint (struct gdbarch *gdbarch,
4135                             struct bp_target_info *bp_tgt)
4136 {
4137   int retval;
4138
4139   retval = debug_target.to_remove_breakpoint (gdbarch, bp_tgt);
4140
4141   fprintf_unfiltered (gdb_stdlog,
4142                       "target_remove_breakpoint (%s, xxx) = %ld\n",
4143                       core_addr_to_string (bp_tgt->placed_address),
4144                       (unsigned long) retval);
4145   return retval;
4146 }
4147
4148 static int
4149 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
4150 {
4151   int retval;
4152
4153   retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
4154
4155   fprintf_unfiltered (gdb_stdlog,
4156                       "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
4157                       (unsigned long) type,
4158                       (unsigned long) cnt,
4159                       (unsigned long) from_tty,
4160                       (unsigned long) retval);
4161   return retval;
4162 }
4163
4164 static int
4165 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
4166 {
4167   CORE_ADDR retval;
4168
4169   retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
4170
4171   fprintf_unfiltered (gdb_stdlog,
4172                       "target_region_ok_for_hw_watchpoint (%s, %ld) = %s\n",
4173                       core_addr_to_string (addr), (unsigned long) len,
4174                       core_addr_to_string (retval));
4175   return retval;
4176 }
4177
4178 static int
4179 debug_to_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw,
4180                                          struct expression *cond)
4181 {
4182   int retval;
4183
4184   retval = debug_target.to_can_accel_watchpoint_condition (addr, len,
4185                                                            rw, cond);
4186
4187   fprintf_unfiltered (gdb_stdlog,
4188                       "target_can_accel_watchpoint_condition "
4189                       "(%s, %d, %d, %s) = %ld\n",
4190                       core_addr_to_string (addr), len, rw,
4191                       host_address_to_string (cond), (unsigned long) retval);
4192   return retval;
4193 }
4194
4195 static int
4196 debug_to_stopped_by_watchpoint (void)
4197 {
4198   int retval;
4199
4200   retval = debug_target.to_stopped_by_watchpoint ();
4201
4202   fprintf_unfiltered (gdb_stdlog,
4203                       "target_stopped_by_watchpoint () = %ld\n",
4204                       (unsigned long) retval);
4205   return retval;
4206 }
4207
4208 static int
4209 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
4210 {
4211   int retval;
4212
4213   retval = debug_target.to_stopped_data_address (target, addr);
4214
4215   fprintf_unfiltered (gdb_stdlog,
4216                       "target_stopped_data_address ([%s]) = %ld\n",
4217                       core_addr_to_string (*addr),
4218                       (unsigned long)retval);
4219   return retval;
4220 }
4221
4222 static int
4223 debug_to_watchpoint_addr_within_range (struct target_ops *target,
4224                                        CORE_ADDR addr,
4225                                        CORE_ADDR start, int length)
4226 {
4227   int retval;
4228
4229   retval = debug_target.to_watchpoint_addr_within_range (target, addr,
4230                                                          start, length);
4231
4232   fprintf_filtered (gdb_stdlog,
4233                     "target_watchpoint_addr_within_range (%s, %s, %d) = %d\n",
4234                     core_addr_to_string (addr), core_addr_to_string (start),
4235                     length, retval);
4236   return retval;
4237 }
4238
4239 static int
4240 debug_to_insert_hw_breakpoint (struct gdbarch *gdbarch,
4241                                struct bp_target_info *bp_tgt)
4242 {
4243   int retval;
4244
4245   retval = debug_target.to_insert_hw_breakpoint (gdbarch, bp_tgt);
4246
4247   fprintf_unfiltered (gdb_stdlog,
4248                       "target_insert_hw_breakpoint (%s, xxx) = %ld\n",
4249                       core_addr_to_string (bp_tgt->placed_address),
4250                       (unsigned long) retval);
4251   return retval;
4252 }
4253
4254 static int
4255 debug_to_remove_hw_breakpoint (struct gdbarch *gdbarch,
4256                                struct bp_target_info *bp_tgt)
4257 {
4258   int retval;
4259
4260   retval = debug_target.to_remove_hw_breakpoint (gdbarch, bp_tgt);
4261
4262   fprintf_unfiltered (gdb_stdlog,
4263                       "target_remove_hw_breakpoint (%s, xxx) = %ld\n",
4264                       core_addr_to_string (bp_tgt->placed_address),
4265                       (unsigned long) retval);
4266   return retval;
4267 }
4268
4269 static int
4270 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type,
4271                             struct expression *cond)
4272 {
4273   int retval;
4274
4275   retval = debug_target.to_insert_watchpoint (addr, len, type, cond);
4276
4277   fprintf_unfiltered (gdb_stdlog,
4278                       "target_insert_watchpoint (%s, %d, %d, %s) = %ld\n",
4279                       core_addr_to_string (addr), len, type,
4280                       host_address_to_string (cond), (unsigned long) retval);
4281   return retval;
4282 }
4283
4284 static int
4285 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type,
4286                             struct expression *cond)
4287 {
4288   int retval;
4289
4290   retval = debug_target.to_remove_watchpoint (addr, len, type, cond);
4291
4292   fprintf_unfiltered (gdb_stdlog,
4293                       "target_remove_watchpoint (%s, %d, %d, %s) = %ld\n",
4294                       core_addr_to_string (addr), len, type,
4295                       host_address_to_string (cond), (unsigned long) retval);
4296   return retval;
4297 }
4298
4299 static void
4300 debug_to_terminal_init (void)
4301 {
4302   debug_target.to_terminal_init ();
4303
4304   fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
4305 }
4306
4307 static void
4308 debug_to_terminal_inferior (void)
4309 {
4310   debug_target.to_terminal_inferior ();
4311
4312   fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
4313 }
4314
4315 static void
4316 debug_to_terminal_ours_for_output (void)
4317 {
4318   debug_target.to_terminal_ours_for_output ();
4319
4320   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
4321 }
4322
4323 static void
4324 debug_to_terminal_ours (void)
4325 {
4326   debug_target.to_terminal_ours ();
4327
4328   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
4329 }
4330
4331 static void
4332 debug_to_terminal_save_ours (void)
4333 {
4334   debug_target.to_terminal_save_ours ();
4335
4336   fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
4337 }
4338
4339 static void
4340 debug_to_terminal_info (char *arg, int from_tty)
4341 {
4342   debug_target.to_terminal_info (arg, from_tty);
4343
4344   fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
4345                       from_tty);
4346 }
4347
4348 static void
4349 debug_to_load (char *args, int from_tty)
4350 {
4351   debug_target.to_load (args, from_tty);
4352
4353   fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
4354 }
4355
4356 static void
4357 debug_to_post_startup_inferior (ptid_t ptid)
4358 {
4359   debug_target.to_post_startup_inferior (ptid);
4360
4361   fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
4362                       PIDGET (ptid));
4363 }
4364
4365 static int
4366 debug_to_insert_fork_catchpoint (int pid)
4367 {
4368   int retval;
4369
4370   retval = debug_target.to_insert_fork_catchpoint (pid);
4371
4372   fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
4373                       pid, retval);
4374
4375   return retval;
4376 }
4377
4378 static int
4379 debug_to_remove_fork_catchpoint (int pid)
4380 {
4381   int retval;
4382
4383   retval = debug_target.to_remove_fork_catchpoint (pid);
4384
4385   fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
4386                       pid, retval);
4387
4388   return retval;
4389 }
4390
4391 static int
4392 debug_to_insert_vfork_catchpoint (int pid)
4393 {
4394   int retval;
4395
4396   retval = debug_target.to_insert_vfork_catchpoint (pid);
4397
4398   fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d) = %d\n",
4399                       pid, retval);
4400
4401   return retval;
4402 }
4403
4404 static int
4405 debug_to_remove_vfork_catchpoint (int pid)
4406 {
4407   int retval;
4408
4409   retval = debug_target.to_remove_vfork_catchpoint (pid);
4410
4411   fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
4412                       pid, retval);
4413
4414   return retval;
4415 }
4416
4417 static int
4418 debug_to_insert_exec_catchpoint (int pid)
4419 {
4420   int retval;
4421
4422   retval = debug_target.to_insert_exec_catchpoint (pid);
4423
4424   fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
4425                       pid, retval);
4426
4427   return retval;
4428 }
4429
4430 static int
4431 debug_to_remove_exec_catchpoint (int pid)
4432 {
4433   int retval;
4434
4435   retval = debug_target.to_remove_exec_catchpoint (pid);
4436
4437   fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
4438                       pid, retval);
4439
4440   return retval;
4441 }
4442
4443 static int
4444 debug_to_has_exited (int pid, int wait_status, int *exit_status)
4445 {
4446   int has_exited;
4447
4448   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
4449
4450   fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
4451                       pid, wait_status, *exit_status, has_exited);
4452
4453   return has_exited;
4454 }
4455
4456 static int
4457 debug_to_can_run (void)
4458 {
4459   int retval;
4460
4461   retval = debug_target.to_can_run ();
4462
4463   fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
4464
4465   return retval;
4466 }
4467
4468 static struct gdbarch *
4469 debug_to_thread_architecture (struct target_ops *ops, ptid_t ptid)
4470 {
4471   struct gdbarch *retval;
4472
4473   retval = debug_target.to_thread_architecture (ops, ptid);
4474
4475   fprintf_unfiltered (gdb_stdlog, 
4476                       "target_thread_architecture (%s) = %s [%s]\n",
4477                       target_pid_to_str (ptid),
4478                       host_address_to_string (retval),
4479                       gdbarch_bfd_arch_info (retval)->printable_name);
4480   return retval;
4481 }
4482
4483 static void
4484 debug_to_stop (ptid_t ptid)
4485 {
4486   debug_target.to_stop (ptid);
4487
4488   fprintf_unfiltered (gdb_stdlog, "target_stop (%s)\n",
4489                       target_pid_to_str (ptid));
4490 }
4491
4492 static void
4493 debug_to_rcmd (char *command,
4494                struct ui_file *outbuf)
4495 {
4496   debug_target.to_rcmd (command, outbuf);
4497   fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
4498 }
4499
4500 static char *
4501 debug_to_pid_to_exec_file (int pid)
4502 {
4503   char *exec_file;
4504
4505   exec_file = debug_target.to_pid_to_exec_file (pid);
4506
4507   fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
4508                       pid, exec_file);
4509
4510   return exec_file;
4511 }
4512
4513 static void
4514 setup_target_debug (void)
4515 {
4516   memcpy (&debug_target, &current_target, sizeof debug_target);
4517
4518   current_target.to_open = debug_to_open;
4519   current_target.to_post_attach = debug_to_post_attach;
4520   current_target.to_prepare_to_store = debug_to_prepare_to_store;
4521   current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
4522   current_target.to_files_info = debug_to_files_info;
4523   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
4524   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
4525   current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
4526   current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
4527   current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
4528   current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
4529   current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
4530   current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
4531   current_target.to_stopped_data_address = debug_to_stopped_data_address;
4532   current_target.to_watchpoint_addr_within_range
4533     = debug_to_watchpoint_addr_within_range;
4534   current_target.to_region_ok_for_hw_watchpoint
4535     = debug_to_region_ok_for_hw_watchpoint;
4536   current_target.to_can_accel_watchpoint_condition
4537     = debug_to_can_accel_watchpoint_condition;
4538   current_target.to_terminal_init = debug_to_terminal_init;
4539   current_target.to_terminal_inferior = debug_to_terminal_inferior;
4540   current_target.to_terminal_ours_for_output
4541     = debug_to_terminal_ours_for_output;
4542   current_target.to_terminal_ours = debug_to_terminal_ours;
4543   current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
4544   current_target.to_terminal_info = debug_to_terminal_info;
4545   current_target.to_load = debug_to_load;
4546   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
4547   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
4548   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
4549   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
4550   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
4551   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
4552   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
4553   current_target.to_has_exited = debug_to_has_exited;
4554   current_target.to_can_run = debug_to_can_run;
4555   current_target.to_stop = debug_to_stop;
4556   current_target.to_rcmd = debug_to_rcmd;
4557   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
4558   current_target.to_thread_architecture = debug_to_thread_architecture;
4559 }
4560 \f
4561
4562 static char targ_desc[] =
4563 "Names of targets and files being debugged.\nShows the entire \
4564 stack of targets currently in use (including the exec-file,\n\
4565 core-file, and process, if any), as well as the symbol file name.";
4566
4567 static void
4568 do_monitor_command (char *cmd,
4569                  int from_tty)
4570 {
4571   if ((current_target.to_rcmd
4572        == (void (*) (char *, struct ui_file *)) tcomplain)
4573       || (current_target.to_rcmd == debug_to_rcmd
4574           && (debug_target.to_rcmd
4575               == (void (*) (char *, struct ui_file *)) tcomplain)))
4576     error (_("\"monitor\" command not supported by this target."));
4577   target_rcmd (cmd, gdb_stdtarg);
4578 }
4579
4580 /* Print the name of each layers of our target stack.  */
4581
4582 static void
4583 maintenance_print_target_stack (char *cmd, int from_tty)
4584 {
4585   struct target_ops *t;
4586
4587   printf_filtered (_("The current target stack is:\n"));
4588
4589   for (t = target_stack; t != NULL; t = t->beneath)
4590     {
4591       printf_filtered ("  - %s (%s)\n", t->to_shortname, t->to_longname);
4592     }
4593 }
4594
4595 /* Controls if async mode is permitted.  */
4596 int target_async_permitted = 0;
4597
4598 /* The set command writes to this variable.  If the inferior is
4599    executing, linux_nat_async_permitted is *not* updated.  */
4600 static int target_async_permitted_1 = 0;
4601
4602 static void
4603 set_maintenance_target_async_permitted (char *args, int from_tty,
4604                                         struct cmd_list_element *c)
4605 {
4606   if (have_live_inferiors ())
4607     {
4608       target_async_permitted_1 = target_async_permitted;
4609       error (_("Cannot change this setting while the inferior is running."));
4610     }
4611
4612   target_async_permitted = target_async_permitted_1;
4613 }
4614
4615 static void
4616 show_maintenance_target_async_permitted (struct ui_file *file, int from_tty,
4617                                          struct cmd_list_element *c,
4618                                          const char *value)
4619 {
4620   fprintf_filtered (file,
4621                     _("Controlling the inferior in "
4622                       "asynchronous mode is %s.\n"), value);
4623 }
4624
4625 /* Temporary copies of permission settings.  */
4626
4627 static int may_write_registers_1 = 1;
4628 static int may_write_memory_1 = 1;
4629 static int may_insert_breakpoints_1 = 1;
4630 static int may_insert_tracepoints_1 = 1;
4631 static int may_insert_fast_tracepoints_1 = 1;
4632 static int may_stop_1 = 1;
4633
4634 /* Make the user-set values match the real values again.  */
4635
4636 void
4637 update_target_permissions (void)
4638 {
4639   may_write_registers_1 = may_write_registers;
4640   may_write_memory_1 = may_write_memory;
4641   may_insert_breakpoints_1 = may_insert_breakpoints;
4642   may_insert_tracepoints_1 = may_insert_tracepoints;
4643   may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
4644   may_stop_1 = may_stop;
4645 }
4646
4647 /* The one function handles (most of) the permission flags in the same
4648    way.  */
4649
4650 static void
4651 set_target_permissions (char *args, int from_tty,
4652                         struct cmd_list_element *c)
4653 {
4654   if (target_has_execution)
4655     {
4656       update_target_permissions ();
4657       error (_("Cannot change this setting while the inferior is running."));
4658     }
4659
4660   /* Make the real values match the user-changed values.  */
4661   may_write_registers = may_write_registers_1;
4662   may_insert_breakpoints = may_insert_breakpoints_1;
4663   may_insert_tracepoints = may_insert_tracepoints_1;
4664   may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
4665   may_stop = may_stop_1;
4666   update_observer_mode ();
4667 }
4668
4669 /* Set memory write permission independently of observer mode.  */
4670
4671 static void
4672 set_write_memory_permission (char *args, int from_tty,
4673                         struct cmd_list_element *c)
4674 {
4675   /* Make the real values match the user-changed values.  */
4676   may_write_memory = may_write_memory_1;
4677   update_observer_mode ();
4678 }
4679
4680
4681 void
4682 initialize_targets (void)
4683 {
4684   init_dummy_target ();
4685   push_target (&dummy_target);
4686
4687   add_info ("target", target_info, targ_desc);
4688   add_info ("files", target_info, targ_desc);
4689
4690   add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
4691 Set target debugging."), _("\
4692 Show target debugging."), _("\
4693 When non-zero, target debugging is enabled.  Higher numbers are more\n\
4694 verbose.  Changes do not take effect until the next \"run\" or \"target\"\n\
4695 command."),
4696                             NULL,
4697                             show_targetdebug,
4698                             &setdebuglist, &showdebuglist);
4699
4700   add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
4701                            &trust_readonly, _("\
4702 Set mode for reading from readonly sections."), _("\
4703 Show mode for reading from readonly sections."), _("\
4704 When this mode is on, memory reads from readonly sections (such as .text)\n\
4705 will be read from the object file instead of from the target.  This will\n\
4706 result in significant performance improvement for remote targets."),
4707                            NULL,
4708                            show_trust_readonly,
4709                            &setlist, &showlist);
4710
4711   add_com ("monitor", class_obscure, do_monitor_command,
4712            _("Send a command to the remote monitor (remote targets only)."));
4713
4714   add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
4715            _("Print the name of each layer of the internal target stack."),
4716            &maintenanceprintlist);
4717
4718   add_setshow_boolean_cmd ("target-async", no_class,
4719                            &target_async_permitted_1, _("\
4720 Set whether gdb controls the inferior in asynchronous mode."), _("\
4721 Show whether gdb controls the inferior in asynchronous mode."), _("\
4722 Tells gdb whether to control the inferior in asynchronous mode."),
4723                            set_maintenance_target_async_permitted,
4724                            show_maintenance_target_async_permitted,
4725                            &setlist,
4726                            &showlist);
4727
4728   add_setshow_boolean_cmd ("stack-cache", class_support,
4729                            &stack_cache_enabled_p_1, _("\
4730 Set cache use for stack access."), _("\
4731 Show cache use for stack access."), _("\
4732 When on, use the data cache for all stack access, regardless of any\n\
4733 configured memory regions.  This improves remote performance significantly.\n\
4734 By default, caching for stack access is on."),
4735                            set_stack_cache_enabled_p,
4736                            show_stack_cache_enabled_p,
4737                            &setlist, &showlist);
4738
4739   add_setshow_boolean_cmd ("may-write-registers", class_support,
4740                            &may_write_registers_1, _("\
4741 Set permission to write into registers."), _("\
4742 Show permission to write into registers."), _("\
4743 When this permission is on, GDB may write into the target's registers.\n\
4744 Otherwise, any sort of write attempt will result in an error."),
4745                            set_target_permissions, NULL,
4746                            &setlist, &showlist);
4747
4748   add_setshow_boolean_cmd ("may-write-memory", class_support,
4749                            &may_write_memory_1, _("\
4750 Set permission to write into target memory."), _("\
4751 Show permission to write into target memory."), _("\
4752 When this permission is on, GDB may write into the target's memory.\n\
4753 Otherwise, any sort of write attempt will result in an error."),
4754                            set_write_memory_permission, NULL,
4755                            &setlist, &showlist);
4756
4757   add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
4758                            &may_insert_breakpoints_1, _("\
4759 Set permission to insert breakpoints in the target."), _("\
4760 Show permission to insert breakpoints in the target."), _("\
4761 When this permission is on, GDB may insert breakpoints in the program.\n\
4762 Otherwise, any sort of insertion attempt will result in an error."),
4763                            set_target_permissions, NULL,
4764                            &setlist, &showlist);
4765
4766   add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
4767                            &may_insert_tracepoints_1, _("\
4768 Set permission to insert tracepoints in the target."), _("\
4769 Show permission to insert tracepoints in the target."), _("\
4770 When this permission is on, GDB may insert tracepoints in the program.\n\
4771 Otherwise, any sort of insertion attempt will result in an error."),
4772                            set_target_permissions, NULL,
4773                            &setlist, &showlist);
4774
4775   add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
4776                            &may_insert_fast_tracepoints_1, _("\
4777 Set permission to insert fast tracepoints in the target."), _("\
4778 Show permission to insert fast tracepoints in the target."), _("\
4779 When this permission is on, GDB may insert fast tracepoints.\n\
4780 Otherwise, any sort of insertion attempt will result in an error."),
4781                            set_target_permissions, NULL,
4782                            &setlist, &showlist);
4783
4784   add_setshow_boolean_cmd ("may-interrupt", class_support,
4785                            &may_stop_1, _("\
4786 Set permission to interrupt or signal the target."), _("\
4787 Show permission to interrupt or signal the target."), _("\
4788 When this permission is on, GDB may interrupt/stop the target's execution.\n\
4789 Otherwise, any attempt to interrupt or stop will be ignored."),
4790                            set_target_permissions, NULL,
4791                            &setlist, &showlist);
4792
4793
4794   target_dcache = dcache_init ();
4795 }