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