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