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