]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/target.c
Add "ld -r" tests for PR ld/15323
[thirdparty/binutils-gdb.git] / gdb / target.c
CommitLineData
c906108c 1/* Select target systems and architectures at runtime for GDB.
7998dfc3 2
32d0add0 3 Copyright (C) 1990-2015 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"
c906108c 23#include "target.h"
68c765e2 24#include "target-dcache.h"
c906108c
SS
25#include "gdbcmd.h"
26#include "symtab.h"
27#include "inferior.h"
45741a9c 28#include "infrun.h"
c906108c
SS
29#include "bfd.h"
30#include "symfile.h"
31#include "objfiles.h"
4930751a 32#include "dcache.h"
c906108c 33#include <signal.h>
4e052eda 34#include "regcache.h"
b6591e8b 35#include "gdbcore.h"
424163ea 36#include "target-descriptions.h"
e1ac3328 37#include "gdbthread.h"
b9db4ced 38#include "solib.h"
07b82ea5 39#include "exec.h"
edb3359d 40#include "inline-frame.h"
2f4d8875 41#include "tracepoint.h"
7313baad 42#include "gdb/fileio.h"
8ffcbaaf 43#include "agent.h"
8de71aab 44#include "auxv.h"
a7068b60 45#include "target-debug.h"
c906108c 46
a14ed312 47static void target_info (char *, int);
c906108c 48
f0f9ff95
TT
49static void generic_tls_error (void) ATTRIBUTE_NORETURN;
50
0a4f40a2 51static void default_terminal_info (struct target_ops *, const char *, int);
c906108c 52
5009afc5
AS
53static int default_watchpoint_addr_within_range (struct target_ops *,
54 CORE_ADDR, CORE_ADDR, int);
55
31568a15
TT
56static int default_region_ok_for_hw_watchpoint (struct target_ops *,
57 CORE_ADDR, int);
e0d24f8d 58
a30bf1f1 59static void default_rcmd (struct target_ops *, const char *, struct ui_file *);
a53f3625 60
4229b31d
TT
61static ptid_t default_get_ada_task_ptid (struct target_ops *self,
62 long lwp, long tid);
63
098dba18
TT
64static int default_follow_fork (struct target_ops *self, int follow_child,
65 int detach_fork);
66
8d657035
TT
67static void default_mourn_inferior (struct target_ops *self);
68
58a5184e
TT
69static int default_search_memory (struct target_ops *ops,
70 CORE_ADDR start_addr,
71 ULONGEST search_space_len,
72 const gdb_byte *pattern,
73 ULONGEST pattern_len,
74 CORE_ADDR *found_addrp);
75
936d2992
PA
76static int default_verify_memory (struct target_ops *self,
77 const gdb_byte *data,
78 CORE_ADDR memaddr, ULONGEST size);
79
8eaff7cd
TT
80static struct address_space *default_thread_address_space
81 (struct target_ops *self, ptid_t ptid);
82
c25c4a8b 83static void tcomplain (void) ATTRIBUTE_NORETURN;
c906108c 84
555bbdeb
TT
85static int return_zero (struct target_ops *);
86
87static int return_zero_has_execution (struct target_ops *, ptid_t);
c906108c 88
a14ed312 89static void target_command (char *, int);
c906108c 90
a14ed312 91static struct target_ops *find_default_run_target (char *);
c906108c 92
c2250ad1
UW
93static struct gdbarch *default_thread_architecture (struct target_ops *ops,
94 ptid_t ptid);
95
0b5a2719
TT
96static int dummy_find_memory_regions (struct target_ops *self,
97 find_memory_region_ftype ignore1,
98 void *ignore2);
99
16f796b1
TT
100static char *dummy_make_corefile_notes (struct target_ops *self,
101 bfd *ignore1, int *ignore2);
102
770234d3
TT
103static char *default_pid_to_str (struct target_ops *ops, ptid_t ptid);
104
fe31bf5b
TT
105static enum exec_direction_kind default_execution_direction
106 (struct target_ops *self);
107
a7068b60
TT
108static struct target_ops debug_target;
109
1101cb7b
TT
110#include "target-delegates.c"
111
a14ed312 112static void init_dummy_target (void);
c906108c 113
3cecbbbe
TT
114static void update_current_target (void);
115
89a1c21a
SM
116/* Vector of existing target structures. */
117typedef struct target_ops *target_ops_p;
118DEF_VEC_P (target_ops_p);
119static VEC (target_ops_p) *target_structs;
c906108c
SS
120
121/* The initial current target, so that there is always a semi-valid
122 current target. */
123
124static struct target_ops dummy_target;
125
126/* Top of target stack. */
127
258b763a 128static struct target_ops *target_stack;
c906108c
SS
129
130/* The target structure we are currently using to talk to a process
131 or file or whatever "inferior" we have. */
132
133struct target_ops current_target;
134
135/* Command list for target. */
136
137static struct cmd_list_element *targetlist = NULL;
138
cf7a04e8
DJ
139/* Nonzero if we should trust readonly sections from the
140 executable when reading memory. */
141
142static int trust_readonly = 0;
143
8defab1a
DJ
144/* Nonzero if we should show true memory content including
145 memory breakpoint inserted by gdb. */
146
147static int show_memory_breakpoints = 0;
148
d914c394
SS
149/* These globals control whether GDB attempts to perform these
150 operations; they are useful for targets that need to prevent
151 inadvertant disruption, such as in non-stop mode. */
152
153int may_write_registers = 1;
154
155int may_write_memory = 1;
156
157int may_insert_breakpoints = 1;
158
159int may_insert_tracepoints = 1;
160
161int may_insert_fast_tracepoints = 1;
162
163int may_stop = 1;
164
c906108c
SS
165/* Non-zero if we want to see trace of target level stuff. */
166
ccce17b0 167static unsigned int targetdebug = 0;
3cecbbbe
TT
168
169static void
170set_targetdebug (char *args, int from_tty, struct cmd_list_element *c)
171{
172 update_current_target ();
173}
174
920d2a44
AC
175static void
176show_targetdebug (struct ui_file *file, int from_tty,
177 struct cmd_list_element *c, const char *value)
178{
179 fprintf_filtered (file, _("Target debugging is %s.\n"), value);
180}
c906108c 181
a14ed312 182static void setup_target_debug (void);
c906108c 183
c906108c
SS
184/* The user just typed 'target' without the name of a target. */
185
c906108c 186static void
fba45db2 187target_command (char *arg, int from_tty)
c906108c
SS
188{
189 fputs_filtered ("Argument required (target name). Try `help target'\n",
190 gdb_stdout);
191}
192
c35b1492
PA
193/* Default target_has_* methods for process_stratum targets. */
194
195int
196default_child_has_all_memory (struct target_ops *ops)
197{
198 /* If no inferior selected, then we can't read memory here. */
199 if (ptid_equal (inferior_ptid, null_ptid))
200 return 0;
201
202 return 1;
203}
204
205int
206default_child_has_memory (struct target_ops *ops)
207{
208 /* If no inferior selected, then we can't read memory here. */
209 if (ptid_equal (inferior_ptid, null_ptid))
210 return 0;
211
212 return 1;
213}
214
215int
216default_child_has_stack (struct target_ops *ops)
217{
218 /* If no inferior selected, there's no stack. */
219 if (ptid_equal (inferior_ptid, null_ptid))
220 return 0;
221
222 return 1;
223}
224
225int
226default_child_has_registers (struct target_ops *ops)
227{
228 /* Can't read registers from no inferior. */
229 if (ptid_equal (inferior_ptid, null_ptid))
230 return 0;
231
232 return 1;
233}
234
235int
aeaec162 236default_child_has_execution (struct target_ops *ops, ptid_t the_ptid)
c35b1492
PA
237{
238 /* If there's no thread selected, then we can't make it run through
239 hoops. */
aeaec162 240 if (ptid_equal (the_ptid, null_ptid))
c35b1492
PA
241 return 0;
242
243 return 1;
244}
245
246
247int
248target_has_all_memory_1 (void)
249{
250 struct target_ops *t;
251
252 for (t = current_target.beneath; t != NULL; t = t->beneath)
253 if (t->to_has_all_memory (t))
254 return 1;
255
256 return 0;
257}
258
259int
260target_has_memory_1 (void)
261{
262 struct target_ops *t;
263
264 for (t = current_target.beneath; t != NULL; t = t->beneath)
265 if (t->to_has_memory (t))
266 return 1;
267
268 return 0;
269}
270
271int
272target_has_stack_1 (void)
273{
274 struct target_ops *t;
275
276 for (t = current_target.beneath; t != NULL; t = t->beneath)
277 if (t->to_has_stack (t))
278 return 1;
279
280 return 0;
281}
282
283int
284target_has_registers_1 (void)
285{
286 struct target_ops *t;
287
288 for (t = current_target.beneath; t != NULL; t = t->beneath)
289 if (t->to_has_registers (t))
290 return 1;
291
292 return 0;
293}
294
295int
aeaec162 296target_has_execution_1 (ptid_t the_ptid)
c35b1492
PA
297{
298 struct target_ops *t;
299
300 for (t = current_target.beneath; t != NULL; t = t->beneath)
aeaec162 301 if (t->to_has_execution (t, the_ptid))
c35b1492
PA
302 return 1;
303
304 return 0;
305}
306
aeaec162
TT
307int
308target_has_execution_current (void)
309{
310 return target_has_execution_1 (inferior_ptid);
311}
312
c22a2b88
TT
313/* Complete initialization of T. This ensures that various fields in
314 T are set, if needed by the target implementation. */
c906108c
SS
315
316void
c22a2b88 317complete_target_initialization (struct target_ops *t)
c906108c 318{
0088c768 319 /* Provide default values for all "must have" methods. */
0088c768 320
c35b1492 321 if (t->to_has_all_memory == NULL)
555bbdeb 322 t->to_has_all_memory = return_zero;
c35b1492
PA
323
324 if (t->to_has_memory == NULL)
555bbdeb 325 t->to_has_memory = return_zero;
c35b1492
PA
326
327 if (t->to_has_stack == NULL)
555bbdeb 328 t->to_has_stack = return_zero;
c35b1492
PA
329
330 if (t->to_has_registers == NULL)
555bbdeb 331 t->to_has_registers = return_zero;
c35b1492
PA
332
333 if (t->to_has_execution == NULL)
555bbdeb 334 t->to_has_execution = return_zero_has_execution;
1101cb7b 335
b3ccfe11
TT
336 /* These methods can be called on an unpushed target and so require
337 a default implementation if the target might plausibly be the
338 default run target. */
339 gdb_assert (t->to_can_run == NULL || (t->to_can_async_p != NULL
340 && t->to_supports_non_stop != NULL));
341
1101cb7b 342 install_delegators (t);
c22a2b88
TT
343}
344
8981c758
TT
345/* This is used to implement the various target commands. */
346
347static void
348open_target (char *args, int from_tty, struct cmd_list_element *command)
349{
350 struct target_ops *ops = get_cmd_context (command);
351
352 if (targetdebug)
353 fprintf_unfiltered (gdb_stdlog, "-> %s->to_open (...)\n",
354 ops->to_shortname);
355
356 ops->to_open (args, from_tty);
357
358 if (targetdebug)
359 fprintf_unfiltered (gdb_stdlog, "<- %s->to_open (%s, %d)\n",
360 ops->to_shortname, args, from_tty);
361}
362
c22a2b88
TT
363/* Add possible target architecture T to the list and add a new
364 command 'target T->to_shortname'. Set COMPLETER as the command's
365 completer if not NULL. */
366
367void
368add_target_with_completer (struct target_ops *t,
369 completer_ftype *completer)
370{
371 struct cmd_list_element *c;
372
373 complete_target_initialization (t);
c35b1492 374
89a1c21a 375 VEC_safe_push (target_ops_p, target_structs, t);
c906108c
SS
376
377 if (targetlist == NULL)
1bedd215
AC
378 add_prefix_cmd ("target", class_run, target_command, _("\
379Connect to a target machine or process.\n\
c906108c
SS
380The first argument is the type or protocol of the target machine.\n\
381Remaining arguments are interpreted by the target protocol. For more\n\
382information on the arguments for a particular protocol, type\n\
1bedd215 383`help target ' followed by the protocol name."),
c906108c 384 &targetlist, "target ", 0, &cmdlist);
8981c758
TT
385 c = add_cmd (t->to_shortname, no_class, NULL, t->to_doc, &targetlist);
386 set_cmd_sfunc (c, open_target);
387 set_cmd_context (c, t);
9852c492
YQ
388 if (completer != NULL)
389 set_cmd_completer (c, completer);
390}
391
392/* Add a possible target architecture to the list. */
393
394void
395add_target (struct target_ops *t)
396{
397 add_target_with_completer (t, NULL);
c906108c
SS
398}
399
b48d48eb
MM
400/* See target.h. */
401
402void
403add_deprecated_target_alias (struct target_ops *t, char *alias)
404{
405 struct cmd_list_element *c;
406 char *alt;
407
408 /* If we use add_alias_cmd, here, we do not get the deprecated warning,
409 see PR cli/15104. */
8981c758
TT
410 c = add_cmd (alias, no_class, NULL, t->to_doc, &targetlist);
411 set_cmd_sfunc (c, open_target);
412 set_cmd_context (c, t);
b48d48eb
MM
413 alt = xstrprintf ("target %s", t->to_shortname);
414 deprecate_cmd (c, alt);
415}
416
c906108c
SS
417/* Stub functions */
418
7d85a9c0
JB
419void
420target_kill (void)
421{
423a4807 422 current_target.to_kill (&current_target);
7d85a9c0
JB
423}
424
11cf8741 425void
9cbe5fff 426target_load (const char *arg, int from_tty)
11cf8741 427{
4e5d721f 428 target_dcache_invalidate ();
71a9f134 429 (*current_target.to_load) (&current_target, arg, from_tty);
11cf8741
JM
430}
431
5842f62a
PA
432/* Possible terminal states. */
433
434enum terminal_state
435 {
436 /* The inferior's terminal settings are in effect. */
437 terminal_is_inferior = 0,
438
439 /* Some of our terminal settings are in effect, enough to get
440 proper output. */
441 terminal_is_ours_for_output = 1,
442
443 /* Our terminal settings are in effect, for output and input. */
444 terminal_is_ours = 2
445 };
446
7afa63c6 447static enum terminal_state terminal_state = terminal_is_ours;
5842f62a
PA
448
449/* See target.h. */
450
451void
452target_terminal_init (void)
453{
454 (*current_target.to_terminal_init) (&current_target);
455
456 terminal_state = terminal_is_ours;
457}
458
459/* See target.h. */
460
6fdebc3d
PA
461int
462target_terminal_is_inferior (void)
463{
464 return (terminal_state == terminal_is_inferior);
465}
466
467/* See target.h. */
468
d9d2d8b6
PA
469void
470target_terminal_inferior (void)
471{
472 /* A background resume (``run&'') should leave GDB in control of the
c378eb4e 473 terminal. Use target_can_async_p, not target_is_async_p, since at
ba7f6c64
VP
474 this point the target is not async yet. However, if sync_execution
475 is not set, we know it will become async prior to resume. */
476 if (target_can_async_p () && !sync_execution)
d9d2d8b6
PA
477 return;
478
5842f62a
PA
479 if (terminal_state == terminal_is_inferior)
480 return;
481
d9d2d8b6
PA
482 /* If GDB is resuming the inferior in the foreground, install
483 inferior's terminal modes. */
d2f640d4 484 (*current_target.to_terminal_inferior) (&current_target);
5842f62a
PA
485 terminal_state = terminal_is_inferior;
486}
487
488/* See target.h. */
489
490void
491target_terminal_ours (void)
492{
493 if (terminal_state == terminal_is_ours)
494 return;
495
496 (*current_target.to_terminal_ours) (&current_target);
497 terminal_state = terminal_is_ours;
498}
499
500/* See target.h. */
501
502void
503target_terminal_ours_for_output (void)
504{
505 if (terminal_state != terminal_is_inferior)
506 return;
507 (*current_target.to_terminal_ours_for_output) (&current_target);
508 terminal_state = terminal_is_ours_for_output;
d9d2d8b6 509}
136d6dae 510
b0ed115f
TT
511/* See target.h. */
512
513int
514target_supports_terminal_ours (void)
515{
516 struct target_ops *t;
517
518 for (t = current_target.beneath; t != NULL; t = t->beneath)
519 {
520 if (t->to_terminal_ours != delegate_terminal_ours
521 && t->to_terminal_ours != tdefault_terminal_ours)
522 return 1;
523 }
524
525 return 0;
526}
527
1abf3a14
SM
528/* Restore the terminal to its previous state (helper for
529 make_cleanup_restore_target_terminal). */
530
531static void
532cleanup_restore_target_terminal (void *arg)
533{
534 enum terminal_state *previous_state = arg;
535
536 switch (*previous_state)
537 {
538 case terminal_is_ours:
539 target_terminal_ours ();
540 break;
541 case terminal_is_ours_for_output:
542 target_terminal_ours_for_output ();
543 break;
544 case terminal_is_inferior:
545 target_terminal_inferior ();
546 break;
547 }
548}
549
550/* See target.h. */
551
552struct cleanup *
553make_cleanup_restore_target_terminal (void)
554{
8d749320 555 enum terminal_state *ts = XNEW (enum terminal_state);
1abf3a14
SM
556
557 *ts = terminal_state;
558
559 return make_cleanup_dtor (cleanup_restore_target_terminal, ts, xfree);
560}
561
c906108c 562static void
fba45db2 563tcomplain (void)
c906108c 564{
8a3fe4f8 565 error (_("You can't do that when your target is `%s'"),
c906108c
SS
566 current_target.to_shortname);
567}
568
569void
fba45db2 570noprocess (void)
c906108c 571{
8a3fe4f8 572 error (_("You can't do that without a process to debug."));
c906108c
SS
573}
574
c906108c 575static void
0a4f40a2 576default_terminal_info (struct target_ops *self, const char *args, int from_tty)
c906108c 577{
a3f17187 578 printf_unfiltered (_("No saved terminal information.\n"));
c906108c
SS
579}
580
0ef643c8
JB
581/* A default implementation for the to_get_ada_task_ptid target method.
582
583 This function builds the PTID by using both LWP and TID as part of
584 the PTID lwp and tid elements. The pid used is the pid of the
585 inferior_ptid. */
586
2c0b251b 587static ptid_t
1e6b91a4 588default_get_ada_task_ptid (struct target_ops *self, long lwp, long tid)
0ef643c8
JB
589{
590 return ptid_build (ptid_get_pid (inferior_ptid), lwp, tid);
591}
592
32231432 593static enum exec_direction_kind
4c612759 594default_execution_direction (struct target_ops *self)
32231432
PA
595{
596 if (!target_can_execute_reverse)
597 return EXEC_FORWARD;
598 else if (!target_can_async_p ())
599 return EXEC_FORWARD;
600 else
601 gdb_assert_not_reached ("\
602to_execution_direction must be implemented for reverse async");
603}
604
7998dfc3
AC
605/* Go through the target stack from top to bottom, copying over zero
606 entries in current_target, then filling in still empty entries. In
607 effect, we are doing class inheritance through the pushed target
608 vectors.
609
610 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
611 is currently implemented, is that it discards any knowledge of
612 which target an inherited method originally belonged to.
613 Consequently, new new target methods should instead explicitly and
614 locally search the target stack for the target that can handle the
615 request. */
c906108c
SS
616
617static void
7998dfc3 618update_current_target (void)
c906108c 619{
7998dfc3
AC
620 struct target_ops *t;
621
08d8bcd7 622 /* First, reset current's contents. */
7998dfc3
AC
623 memset (&current_target, 0, sizeof (current_target));
624
1101cb7b
TT
625 /* Install the delegators. */
626 install_delegators (&current_target);
627
be4ddd36
TT
628 current_target.to_stratum = target_stack->to_stratum;
629
7998dfc3
AC
630#define INHERIT(FIELD, TARGET) \
631 if (!current_target.FIELD) \
632 current_target.FIELD = (TARGET)->FIELD
633
be4ddd36
TT
634 /* Do not add any new INHERITs here. Instead, use the delegation
635 mechanism provided by make-target-delegates. */
7998dfc3
AC
636 for (t = target_stack; t; t = t->beneath)
637 {
638 INHERIT (to_shortname, t);
639 INHERIT (to_longname, t);
dc177b7a 640 INHERIT (to_attach_no_wait, t);
74174d2e 641 INHERIT (to_have_steppable_watchpoint, t);
7998dfc3 642 INHERIT (to_have_continuable_watchpoint, t);
7998dfc3 643 INHERIT (to_has_thread_control, t);
7998dfc3
AC
644 }
645#undef INHERIT
646
7998dfc3
AC
647 /* Finally, position the target-stack beneath the squashed
648 "current_target". That way code looking for a non-inherited
649 target method can quickly and simply find it. */
650 current_target.beneath = target_stack;
b4b61fdb
DJ
651
652 if (targetdebug)
653 setup_target_debug ();
c906108c
SS
654}
655
656/* Push a new target type into the stack of the existing target accessors,
657 possibly superseding some of the existing accessors.
658
c906108c
SS
659 Rather than allow an empty stack, we always have the dummy target at
660 the bottom stratum, so we can call the function vectors without
661 checking them. */
662
b26a4dcb 663void
fba45db2 664push_target (struct target_ops *t)
c906108c 665{
258b763a 666 struct target_ops **cur;
c906108c
SS
667
668 /* Check magic number. If wrong, it probably means someone changed
669 the struct definition, but not all the places that initialize one. */
670 if (t->to_magic != OPS_MAGIC)
671 {
c5aa993b
JM
672 fprintf_unfiltered (gdb_stderr,
673 "Magic number of %s target struct wrong\n",
674 t->to_shortname);
3e43a32a
MS
675 internal_error (__FILE__, __LINE__,
676 _("failed internal consistency check"));
c906108c
SS
677 }
678
258b763a
AC
679 /* Find the proper stratum to install this target in. */
680 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
c906108c 681 {
258b763a 682 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
c906108c
SS
683 break;
684 }
685
258b763a 686 /* If there's already targets at this stratum, remove them. */
88c231eb 687 /* FIXME: cagney/2003-10-15: I think this should be popping all
258b763a
AC
688 targets to CUR, and not just those at this stratum level. */
689 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
690 {
691 /* There's already something at this stratum level. Close it,
692 and un-hook it from the stack. */
693 struct target_ops *tmp = (*cur);
5d502164 694
258b763a
AC
695 (*cur) = (*cur)->beneath;
696 tmp->beneath = NULL;
460014f5 697 target_close (tmp);
258b763a 698 }
c906108c
SS
699
700 /* We have removed all targets in our stratum, now add the new one. */
258b763a
AC
701 t->beneath = (*cur);
702 (*cur) = t;
c906108c
SS
703
704 update_current_target ();
c906108c
SS
705}
706
2bc416ba 707/* Remove a target_ops vector from the stack, wherever it may be.
c906108c
SS
708 Return how many times it was removed (0 or 1). */
709
710int
fba45db2 711unpush_target (struct target_ops *t)
c906108c 712{
258b763a
AC
713 struct target_ops **cur;
714 struct target_ops *tmp;
c906108c 715
c8d104ad
PA
716 if (t->to_stratum == dummy_stratum)
717 internal_error (__FILE__, __LINE__,
9b20d036 718 _("Attempt to unpush the dummy target"));
c8d104ad 719
c906108c 720 /* Look for the specified target. Note that we assume that a target
c378eb4e 721 can only occur once in the target stack. */
c906108c 722
258b763a
AC
723 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
724 {
725 if ((*cur) == t)
726 break;
727 }
c906108c 728
305436e0
PA
729 /* If we don't find target_ops, quit. Only open targets should be
730 closed. */
258b763a 731 if ((*cur) == NULL)
305436e0 732 return 0;
5269965e 733
c378eb4e 734 /* Unchain the target. */
258b763a
AC
735 tmp = (*cur);
736 (*cur) = (*cur)->beneath;
737 tmp->beneath = NULL;
c906108c
SS
738
739 update_current_target ();
c906108c 740
305436e0
PA
741 /* Finally close the target. Note we do this after unchaining, so
742 any target method calls from within the target_close
743 implementation don't end up in T anymore. */
460014f5 744 target_close (t);
305436e0 745
c906108c
SS
746 return 1;
747}
748
aa76d38d 749void
460014f5 750pop_all_targets_above (enum strata above_stratum)
aa76d38d 751{
87ab71f0 752 while ((int) (current_target.to_stratum) > (int) above_stratum)
aa76d38d 753 {
aa76d38d
PA
754 if (!unpush_target (target_stack))
755 {
756 fprintf_unfiltered (gdb_stderr,
757 "pop_all_targets couldn't find target %s\n",
b52323fa 758 target_stack->to_shortname);
aa76d38d
PA
759 internal_error (__FILE__, __LINE__,
760 _("failed internal consistency check"));
761 break;
762 }
763 }
764}
765
87ab71f0 766void
460014f5 767pop_all_targets (void)
87ab71f0 768{
460014f5 769 pop_all_targets_above (dummy_stratum);
87ab71f0
PA
770}
771
c0edd9ed
JK
772/* Return 1 if T is now pushed in the target stack. Return 0 otherwise. */
773
774int
775target_is_pushed (struct target_ops *t)
776{
84202f9c 777 struct target_ops *cur;
c0edd9ed
JK
778
779 /* Check magic number. If wrong, it probably means someone changed
780 the struct definition, but not all the places that initialize one. */
781 if (t->to_magic != OPS_MAGIC)
782 {
783 fprintf_unfiltered (gdb_stderr,
784 "Magic number of %s target struct wrong\n",
785 t->to_shortname);
3e43a32a
MS
786 internal_error (__FILE__, __LINE__,
787 _("failed internal consistency check"));
c0edd9ed
JK
788 }
789
84202f9c
TT
790 for (cur = target_stack; cur != NULL; cur = cur->beneath)
791 if (cur == t)
c0edd9ed
JK
792 return 1;
793
794 return 0;
795}
796
f0f9ff95
TT
797/* Default implementation of to_get_thread_local_address. */
798
799static void
800generic_tls_error (void)
801{
802 throw_error (TLS_GENERIC_ERROR,
803 _("Cannot find thread-local variables on this target"));
804}
805
72f5cf0e 806/* Using the objfile specified in OBJFILE, find the address for the
9e35dae4
DJ
807 current thread's thread-local storage with offset OFFSET. */
808CORE_ADDR
809target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
810{
811 volatile CORE_ADDR addr = 0;
f0f9ff95 812 struct target_ops *target = &current_target;
9e35dae4 813
f0f9ff95 814 if (gdbarch_fetch_tls_load_module_address_p (target_gdbarch ()))
9e35dae4
DJ
815 {
816 ptid_t ptid = inferior_ptid;
9e35dae4 817
492d29ea 818 TRY
9e35dae4
DJ
819 {
820 CORE_ADDR lm_addr;
821
822 /* Fetch the load module address for this objfile. */
f5656ead 823 lm_addr = gdbarch_fetch_tls_load_module_address (target_gdbarch (),
9e35dae4 824 objfile);
9e35dae4 825
3e43a32a
MS
826 addr = target->to_get_thread_local_address (target, ptid,
827 lm_addr, offset);
9e35dae4
DJ
828 }
829 /* If an error occurred, print TLS related messages here. Otherwise,
830 throw the error to some higher catcher. */
492d29ea 831 CATCH (ex, RETURN_MASK_ALL)
9e35dae4
DJ
832 {
833 int objfile_is_library = (objfile->flags & OBJF_SHARED);
834
835 switch (ex.error)
836 {
837 case TLS_NO_LIBRARY_SUPPORT_ERROR:
3e43a32a
MS
838 error (_("Cannot find thread-local variables "
839 "in this thread library."));
9e35dae4
DJ
840 break;
841 case TLS_LOAD_MODULE_NOT_FOUND_ERROR:
842 if (objfile_is_library)
843 error (_("Cannot find shared library `%s' in dynamic"
4262abfb 844 " linker's load module list"), objfile_name (objfile));
9e35dae4
DJ
845 else
846 error (_("Cannot find executable file `%s' in dynamic"
4262abfb 847 " linker's load module list"), objfile_name (objfile));
9e35dae4
DJ
848 break;
849 case TLS_NOT_ALLOCATED_YET_ERROR:
850 if (objfile_is_library)
851 error (_("The inferior has not yet allocated storage for"
852 " thread-local variables in\n"
853 "the shared library `%s'\n"
854 "for %s"),
4262abfb 855 objfile_name (objfile), target_pid_to_str (ptid));
9e35dae4
DJ
856 else
857 error (_("The inferior has not yet allocated storage for"
858 " thread-local variables in\n"
859 "the executable `%s'\n"
860 "for %s"),
4262abfb 861 objfile_name (objfile), target_pid_to_str (ptid));
9e35dae4
DJ
862 break;
863 case TLS_GENERIC_ERROR:
864 if (objfile_is_library)
865 error (_("Cannot find thread-local storage for %s, "
866 "shared library %s:\n%s"),
867 target_pid_to_str (ptid),
4262abfb 868 objfile_name (objfile), ex.message);
9e35dae4
DJ
869 else
870 error (_("Cannot find thread-local storage for %s, "
871 "executable file %s:\n%s"),
872 target_pid_to_str (ptid),
4262abfb 873 objfile_name (objfile), ex.message);
9e35dae4
DJ
874 break;
875 default:
876 throw_exception (ex);
877 break;
878 }
879 }
492d29ea 880 END_CATCH
9e35dae4
DJ
881 }
882 /* It wouldn't be wrong here to try a gdbarch method, too; finding
883 TLS is an ABI-specific thing. But we don't do that yet. */
884 else
885 error (_("Cannot find thread-local variables on this target"));
886
887 return addr;
888}
889
6be7b56e 890const char *
01cb8804 891target_xfer_status_to_string (enum target_xfer_status status)
6be7b56e
PA
892{
893#define CASE(X) case X: return #X
01cb8804 894 switch (status)
6be7b56e
PA
895 {
896 CASE(TARGET_XFER_E_IO);
bc113b4e 897 CASE(TARGET_XFER_UNAVAILABLE);
6be7b56e
PA
898 default:
899 return "<unknown>";
900 }
901#undef CASE
902};
903
904
c906108c
SS
905#undef MIN
906#define MIN(A, B) (((A) <= (B)) ? (A) : (B))
907
908/* target_read_string -- read a null terminated string, up to LEN bytes,
909 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
910 Set *STRING to a pointer to malloc'd memory containing the data; the caller
911 is responsible for freeing it. Return the number of bytes successfully
912 read. */
913
914int
fba45db2 915target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
c906108c 916{
c2e8b827 917 int tlen, offset, i;
1b0ba102 918 gdb_byte buf[4];
c906108c
SS
919 int errcode = 0;
920 char *buffer;
921 int buffer_allocated;
922 char *bufptr;
923 unsigned int nbytes_read = 0;
924
6217bf3e
MS
925 gdb_assert (string);
926
c906108c
SS
927 /* Small for testing. */
928 buffer_allocated = 4;
929 buffer = xmalloc (buffer_allocated);
930 bufptr = buffer;
931
c906108c
SS
932 while (len > 0)
933 {
934 tlen = MIN (len, 4 - (memaddr & 3));
935 offset = memaddr & 3;
936
1b0ba102 937 errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
c906108c
SS
938 if (errcode != 0)
939 {
940 /* The transfer request might have crossed the boundary to an
c378eb4e 941 unallocated region of memory. Retry the transfer, requesting
c906108c
SS
942 a single byte. */
943 tlen = 1;
944 offset = 0;
b8eb5af0 945 errcode = target_read_memory (memaddr, buf, 1);
c906108c
SS
946 if (errcode != 0)
947 goto done;
948 }
949
950 if (bufptr - buffer + tlen > buffer_allocated)
951 {
952 unsigned int bytes;
5d502164 953
c906108c
SS
954 bytes = bufptr - buffer;
955 buffer_allocated *= 2;
956 buffer = xrealloc (buffer, buffer_allocated);
957 bufptr = buffer + bytes;
958 }
959
960 for (i = 0; i < tlen; i++)
961 {
962 *bufptr++ = buf[i + offset];
963 if (buf[i + offset] == '\000')
964 {
965 nbytes_read += i + 1;
966 goto done;
967 }
968 }
969
970 memaddr += tlen;
971 len -= tlen;
972 nbytes_read += tlen;
973 }
c5aa993b 974done:
6217bf3e 975 *string = buffer;
c906108c
SS
976 if (errnop != NULL)
977 *errnop = errcode;
c906108c
SS
978 return nbytes_read;
979}
980
07b82ea5
PA
981struct target_section_table *
982target_get_section_table (struct target_ops *target)
983{
7e35c012 984 return (*target->to_get_section_table) (target);
07b82ea5
PA
985}
986
8db32d44 987/* Find a section containing ADDR. */
07b82ea5 988
0542c86d 989struct target_section *
8db32d44
AC
990target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
991{
07b82ea5 992 struct target_section_table *table = target_get_section_table (target);
0542c86d 993 struct target_section *secp;
07b82ea5
PA
994
995 if (table == NULL)
996 return NULL;
997
998 for (secp = table->sections; secp < table->sections_end; secp++)
8db32d44
AC
999 {
1000 if (addr >= secp->addr && addr < secp->endaddr)
1001 return secp;
1002 }
1003 return NULL;
1004}
1005
0fec99e8
PA
1006
1007/* Helper for the memory xfer routines. Checks the attributes of the
1008 memory region of MEMADDR against the read or write being attempted.
1009 If the access is permitted returns true, otherwise returns false.
1010 REGION_P is an optional output parameter. If not-NULL, it is
1011 filled with a pointer to the memory region of MEMADDR. REG_LEN
1012 returns LEN trimmed to the end of the region. This is how much the
1013 caller can continue requesting, if the access is permitted. A
1014 single xfer request must not straddle memory region boundaries. */
1015
1016static int
1017memory_xfer_check_region (gdb_byte *readbuf, const gdb_byte *writebuf,
1018 ULONGEST memaddr, ULONGEST len, ULONGEST *reg_len,
1019 struct mem_region **region_p)
1020{
1021 struct mem_region *region;
1022
1023 region = lookup_mem_region (memaddr);
1024
1025 if (region_p != NULL)
1026 *region_p = region;
1027
1028 switch (region->attrib.mode)
1029 {
1030 case MEM_RO:
1031 if (writebuf != NULL)
1032 return 0;
1033 break;
1034
1035 case MEM_WO:
1036 if (readbuf != NULL)
1037 return 0;
1038 break;
1039
1040 case MEM_FLASH:
1041 /* We only support writing to flash during "load" for now. */
1042 if (writebuf != NULL)
1043 error (_("Writing to flash memory forbidden in this context"));
1044 break;
1045
1046 case MEM_NONE:
1047 return 0;
1048 }
1049
1050 /* region->hi == 0 means there's no upper bound. */
1051 if (memaddr + len < region->hi || region->hi == 0)
1052 *reg_len = len;
1053 else
1054 *reg_len = region->hi - memaddr;
1055
1056 return 1;
1057}
1058
9f713294
YQ
1059/* Read memory from more than one valid target. A core file, for
1060 instance, could have some of memory but delegate other bits to
1061 the target below it. So, we must manually try all targets. */
1062
cc9f16aa 1063enum target_xfer_status
17fde6d0 1064raw_memory_xfer_partial (struct target_ops *ops, gdb_byte *readbuf,
9b409511
YQ
1065 const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len,
1066 ULONGEST *xfered_len)
9f713294 1067{
9b409511 1068 enum target_xfer_status res;
9f713294
YQ
1069
1070 do
1071 {
1072 res = ops->to_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
9b409511
YQ
1073 readbuf, writebuf, memaddr, len,
1074 xfered_len);
1075 if (res == TARGET_XFER_OK)
9f713294
YQ
1076 break;
1077
633785ff 1078 /* Stop if the target reports that the memory is not available. */
bc113b4e 1079 if (res == TARGET_XFER_UNAVAILABLE)
633785ff
MM
1080 break;
1081
9f713294
YQ
1082 /* We want to continue past core files to executables, but not
1083 past a running target's memory. */
1084 if (ops->to_has_all_memory (ops))
1085 break;
1086
1087 ops = ops->beneath;
1088 }
1089 while (ops != NULL);
1090
0f26cec1
PA
1091 /* The cache works at the raw memory level. Make sure the cache
1092 gets updated with raw contents no matter what kind of memory
1093 object was originally being written. Note we do write-through
1094 first, so that if it fails, we don't write to the cache contents
1095 that never made it to the target. */
1096 if (writebuf != NULL
1097 && !ptid_equal (inferior_ptid, null_ptid)
1098 && target_dcache_init_p ()
1099 && (stack_cache_enabled_p () || code_cache_enabled_p ()))
1100 {
1101 DCACHE *dcache = target_dcache_get ();
1102
1103 /* Note that writing to an area of memory which wasn't present
1104 in the cache doesn't cause it to be loaded in. */
1105 dcache_update (dcache, res, memaddr, writebuf, *xfered_len);
1106 }
1107
9f713294
YQ
1108 return res;
1109}
1110
7f79c47e
DE
1111/* Perform a partial memory transfer.
1112 For docs see target.h, to_xfer_partial. */
cf7a04e8 1113
9b409511 1114static enum target_xfer_status
f0ba3972 1115memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
17fde6d0 1116 gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr,
9b409511 1117 ULONGEST len, ULONGEST *xfered_len)
0779438d 1118{
9b409511 1119 enum target_xfer_status res;
0fec99e8 1120 ULONGEST reg_len;
cf7a04e8 1121 struct mem_region *region;
4e5d721f 1122 struct inferior *inf;
cf7a04e8 1123
07b82ea5
PA
1124 /* For accesses to unmapped overlay sections, read directly from
1125 files. Must do this first, as MEMADDR may need adjustment. */
1126 if (readbuf != NULL && overlay_debugging)
1127 {
1128 struct obj_section *section = find_pc_overlay (memaddr);
5d502164 1129
07b82ea5
PA
1130 if (pc_in_unmapped_range (memaddr, section))
1131 {
1132 struct target_section_table *table
1133 = target_get_section_table (ops);
1134 const char *section_name = section->the_bfd_section->name;
5d502164 1135
07b82ea5
PA
1136 memaddr = overlay_mapped_address (memaddr, section);
1137 return section_table_xfer_memory_partial (readbuf, writebuf,
9b409511 1138 memaddr, len, xfered_len,
07b82ea5
PA
1139 table->sections,
1140 table->sections_end,
1141 section_name);
1142 }
1143 }
1144
1145 /* Try the executable files, if "trust-readonly-sections" is set. */
cf7a04e8
DJ
1146 if (readbuf != NULL && trust_readonly)
1147 {
0542c86d 1148 struct target_section *secp;
07b82ea5 1149 struct target_section_table *table;
cf7a04e8
DJ
1150
1151 secp = target_section_by_addr (ops, memaddr);
1152 if (secp != NULL
2b2848e2
DE
1153 && (bfd_get_section_flags (secp->the_bfd_section->owner,
1154 secp->the_bfd_section)
cf7a04e8 1155 & SEC_READONLY))
07b82ea5
PA
1156 {
1157 table = target_get_section_table (ops);
1158 return section_table_xfer_memory_partial (readbuf, writebuf,
9b409511 1159 memaddr, len, xfered_len,
07b82ea5
PA
1160 table->sections,
1161 table->sections_end,
1162 NULL);
1163 }
98646950
UW
1164 }
1165
cf7a04e8 1166 /* Try GDB's internal data cache. */
cf7a04e8 1167
0fec99e8
PA
1168 if (!memory_xfer_check_region (readbuf, writebuf, memaddr, len, &reg_len,
1169 &region))
1170 return TARGET_XFER_E_IO;
cf7a04e8 1171
6c95b8df 1172 if (!ptid_equal (inferior_ptid, null_ptid))
c9657e70 1173 inf = find_inferior_ptid (inferior_ptid);
6c95b8df
PA
1174 else
1175 inf = NULL;
4e5d721f
DE
1176
1177 if (inf != NULL
0f26cec1 1178 && readbuf != NULL
2f4d8875
PA
1179 /* The dcache reads whole cache lines; that doesn't play well
1180 with reading from a trace buffer, because reading outside of
1181 the collected memory range fails. */
1182 && get_traceframe_number () == -1
4e5d721f 1183 && (region->attrib.cache
29453a14
YQ
1184 || (stack_cache_enabled_p () && object == TARGET_OBJECT_STACK_MEMORY)
1185 || (code_cache_enabled_p () && object == TARGET_OBJECT_CODE_MEMORY)))
cf7a04e8 1186 {
2a2f9fe4
YQ
1187 DCACHE *dcache = target_dcache_get_or_init ();
1188
0f26cec1
PA
1189 return dcache_read_memory_partial (ops, dcache, memaddr, readbuf,
1190 reg_len, xfered_len);
cf7a04e8
DJ
1191 }
1192
1193 /* If none of those methods found the memory we wanted, fall back
1194 to a target partial transfer. Normally a single call to
1195 to_xfer_partial is enough; if it doesn't recognize an object
1196 it will call the to_xfer_partial of the next target down.
1197 But for memory this won't do. Memory is the only target
9b409511
YQ
1198 object which can be read from more than one valid target.
1199 A core file, for instance, could have some of memory but
1200 delegate other bits to the target below it. So, we must
1201 manually try all targets. */
1202
1203 res = raw_memory_xfer_partial (ops, readbuf, writebuf, memaddr, reg_len,
1204 xfered_len);
cf7a04e8
DJ
1205
1206 /* If we still haven't got anything, return the last error. We
1207 give up. */
1208 return res;
0779438d
AC
1209}
1210
f0ba3972
PA
1211/* Perform a partial memory transfer. For docs see target.h,
1212 to_xfer_partial. */
1213
9b409511 1214static enum target_xfer_status
f0ba3972 1215memory_xfer_partial (struct target_ops *ops, enum target_object object,
9b409511
YQ
1216 gdb_byte *readbuf, const gdb_byte *writebuf,
1217 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
f0ba3972 1218{
9b409511 1219 enum target_xfer_status res;
f0ba3972
PA
1220
1221 /* Zero length requests are ok and require no work. */
1222 if (len == 0)
9b409511 1223 return TARGET_XFER_EOF;
f0ba3972
PA
1224
1225 /* Fill in READBUF with breakpoint shadows, or WRITEBUF with
1226 breakpoint insns, thus hiding out from higher layers whether
1227 there are software breakpoints inserted in the code stream. */
1228 if (readbuf != NULL)
1229 {
9b409511
YQ
1230 res = memory_xfer_partial_1 (ops, object, readbuf, NULL, memaddr, len,
1231 xfered_len);
f0ba3972 1232
9b409511 1233 if (res == TARGET_XFER_OK && !show_memory_breakpoints)
c63528fc 1234 breakpoint_xfer_memory (readbuf, NULL, NULL, memaddr, *xfered_len);
f0ba3972
PA
1235 }
1236 else
1237 {
1238 void *buf;
1239 struct cleanup *old_chain;
1240
67c059c2
AB
1241 /* A large write request is likely to be partially satisfied
1242 by memory_xfer_partial_1. We will continually malloc
1243 and free a copy of the entire write request for breakpoint
1244 shadow handling even though we only end up writing a small
1245 subset of it. Cap writes to 4KB to mitigate this. */
1246 len = min (4096, len);
1247
f0ba3972
PA
1248 buf = xmalloc (len);
1249 old_chain = make_cleanup (xfree, buf);
1250 memcpy (buf, writebuf, len);
1251
1252 breakpoint_xfer_memory (NULL, buf, writebuf, memaddr, len);
9b409511
YQ
1253 res = memory_xfer_partial_1 (ops, object, NULL, buf, memaddr, len,
1254 xfered_len);
f0ba3972
PA
1255
1256 do_cleanups (old_chain);
1257 }
1258
1259 return res;
1260}
1261
8defab1a
DJ
1262static void
1263restore_show_memory_breakpoints (void *arg)
1264{
1265 show_memory_breakpoints = (uintptr_t) arg;
1266}
1267
1268struct cleanup *
1269make_show_memory_breakpoints_cleanup (int show)
1270{
1271 int current = show_memory_breakpoints;
8defab1a 1272
5d502164 1273 show_memory_breakpoints = show;
8defab1a
DJ
1274 return make_cleanup (restore_show_memory_breakpoints,
1275 (void *) (uintptr_t) current);
1276}
1277
7f79c47e
DE
1278/* For docs see target.h, to_xfer_partial. */
1279
9b409511 1280enum target_xfer_status
27394598
AC
1281target_xfer_partial (struct target_ops *ops,
1282 enum target_object object, const char *annex,
4ac248ca 1283 gdb_byte *readbuf, const gdb_byte *writebuf,
9b409511
YQ
1284 ULONGEST offset, ULONGEST len,
1285 ULONGEST *xfered_len)
27394598 1286{
9b409511 1287 enum target_xfer_status retval;
27394598
AC
1288
1289 gdb_assert (ops->to_xfer_partial != NULL);
cf7a04e8 1290
ce6d0892
YQ
1291 /* Transfer is done when LEN is zero. */
1292 if (len == 0)
9b409511 1293 return TARGET_XFER_EOF;
ce6d0892 1294
d914c394
SS
1295 if (writebuf && !may_write_memory)
1296 error (_("Writing to memory is not allowed (addr %s, len %s)"),
1297 core_addr_to_string_nz (offset), plongest (len));
1298
9b409511
YQ
1299 *xfered_len = 0;
1300
cf7a04e8
DJ
1301 /* If this is a memory transfer, let the memory-specific code
1302 have a look at it instead. Memory transfers are more
1303 complicated. */
29453a14
YQ
1304 if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
1305 || object == TARGET_OBJECT_CODE_MEMORY)
4e5d721f 1306 retval = memory_xfer_partial (ops, object, readbuf,
9b409511 1307 writebuf, offset, len, xfered_len);
9f713294 1308 else if (object == TARGET_OBJECT_RAW_MEMORY)
cf7a04e8 1309 {
0fec99e8
PA
1310 /* Skip/avoid accessing the target if the memory region
1311 attributes block the access. Check this here instead of in
1312 raw_memory_xfer_partial as otherwise we'd end up checking
1313 this twice in the case of the memory_xfer_partial path is
1314 taken; once before checking the dcache, and another in the
1315 tail call to raw_memory_xfer_partial. */
1316 if (!memory_xfer_check_region (readbuf, writebuf, offset, len, &len,
1317 NULL))
1318 return TARGET_XFER_E_IO;
1319
9f713294 1320 /* Request the normal memory object from other layers. */
9b409511
YQ
1321 retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len,
1322 xfered_len);
cf7a04e8 1323 }
9f713294
YQ
1324 else
1325 retval = ops->to_xfer_partial (ops, object, annex, readbuf,
9b409511 1326 writebuf, offset, len, xfered_len);
cf7a04e8 1327
27394598
AC
1328 if (targetdebug)
1329 {
1330 const unsigned char *myaddr = NULL;
1331
1332 fprintf_unfiltered (gdb_stdlog,
3e43a32a 1333 "%s:target_xfer_partial "
9b409511 1334 "(%d, %s, %s, %s, %s, %s) = %d, %s",
27394598
AC
1335 ops->to_shortname,
1336 (int) object,
1337 (annex ? annex : "(null)"),
53b71562
JB
1338 host_address_to_string (readbuf),
1339 host_address_to_string (writebuf),
0b1553bc 1340 core_addr_to_string_nz (offset),
9b409511
YQ
1341 pulongest (len), retval,
1342 pulongest (*xfered_len));
27394598
AC
1343
1344 if (readbuf)
1345 myaddr = readbuf;
1346 if (writebuf)
1347 myaddr = writebuf;
9b409511 1348 if (retval == TARGET_XFER_OK && myaddr != NULL)
27394598
AC
1349 {
1350 int i;
2bc416ba 1351
27394598 1352 fputs_unfiltered (", bytes =", gdb_stdlog);
9b409511 1353 for (i = 0; i < *xfered_len; i++)
27394598 1354 {
53b71562 1355 if ((((intptr_t) &(myaddr[i])) & 0xf) == 0)
27394598
AC
1356 {
1357 if (targetdebug < 2 && i > 0)
1358 {
1359 fprintf_unfiltered (gdb_stdlog, " ...");
1360 break;
1361 }
1362 fprintf_unfiltered (gdb_stdlog, "\n");
1363 }
2bc416ba 1364
27394598
AC
1365 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1366 }
1367 }
2bc416ba 1368
27394598
AC
1369 fputc_unfiltered ('\n', gdb_stdlog);
1370 }
9b409511
YQ
1371
1372 /* Check implementations of to_xfer_partial update *XFERED_LEN
1373 properly. Do assertion after printing debug messages, so that we
1374 can find more clues on assertion failure from debugging messages. */
bc113b4e 1375 if (retval == TARGET_XFER_OK || retval == TARGET_XFER_UNAVAILABLE)
9b409511
YQ
1376 gdb_assert (*xfered_len > 0);
1377
27394598
AC
1378 return retval;
1379}
1380
578d3588
PA
1381/* Read LEN bytes of target memory at address MEMADDR, placing the
1382 results in GDB's memory at MYADDR. Returns either 0 for success or
9b409511 1383 TARGET_XFER_E_IO if any error occurs.
c906108c
SS
1384
1385 If an error occurs, no guarantee is made about the contents of the data at
1386 MYADDR. In particular, the caller should not depend upon partial reads
1387 filling the buffer with good data. There is no way for the caller to know
1388 how much good data might have been transfered anyway. Callers that can
cf7a04e8 1389 deal with partial reads should call target_read (which will retry until
c378eb4e 1390 it makes no progress, and then return how much was transferred). */
c906108c
SS
1391
1392int
1b162304 1393target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
c906108c 1394{
c35b1492
PA
1395 /* Dispatch to the topmost target, not the flattened current_target.
1396 Memory accesses check target->to_has_(all_)memory, and the
1397 flattened target doesn't inherit those. */
1398 if (target_read (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
cf7a04e8
DJ
1399 myaddr, memaddr, len) == len)
1400 return 0;
0779438d 1401 else
578d3588 1402 return TARGET_XFER_E_IO;
c906108c
SS
1403}
1404
721ec300
GB
1405/* See target/target.h. */
1406
1407int
1408target_read_uint32 (CORE_ADDR memaddr, uint32_t *result)
1409{
1410 gdb_byte buf[4];
1411 int r;
1412
1413 r = target_read_memory (memaddr, buf, sizeof buf);
1414 if (r != 0)
1415 return r;
1416 *result = extract_unsigned_integer (buf, sizeof buf,
1417 gdbarch_byte_order (target_gdbarch ()));
1418 return 0;
1419}
1420
aee4bf85
PA
1421/* Like target_read_memory, but specify explicitly that this is a read
1422 from the target's raw memory. That is, this read bypasses the
1423 dcache, breakpoint shadowing, etc. */
1424
1425int
1426target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1427{
1428 /* See comment in target_read_memory about why the request starts at
1429 current_target.beneath. */
1430 if (target_read (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1431 myaddr, memaddr, len) == len)
1432 return 0;
1433 else
1434 return TARGET_XFER_E_IO;
1435}
1436
4e5d721f
DE
1437/* Like target_read_memory, but specify explicitly that this is a read from
1438 the target's stack. This may trigger different cache behavior. */
1439
1440int
45aa4659 1441target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
4e5d721f 1442{
aee4bf85
PA
1443 /* See comment in target_read_memory about why the request starts at
1444 current_target.beneath. */
4e5d721f
DE
1445 if (target_read (current_target.beneath, TARGET_OBJECT_STACK_MEMORY, NULL,
1446 myaddr, memaddr, len) == len)
1447 return 0;
1448 else
578d3588 1449 return TARGET_XFER_E_IO;
4e5d721f
DE
1450}
1451
29453a14
YQ
1452/* Like target_read_memory, but specify explicitly that this is a read from
1453 the target's code. This may trigger different cache behavior. */
1454
1455int
1456target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
1457{
aee4bf85
PA
1458 /* See comment in target_read_memory about why the request starts at
1459 current_target.beneath. */
29453a14
YQ
1460 if (target_read (current_target.beneath, TARGET_OBJECT_CODE_MEMORY, NULL,
1461 myaddr, memaddr, len) == len)
1462 return 0;
1463 else
1464 return TARGET_XFER_E_IO;
1465}
1466
7f79c47e 1467/* Write LEN bytes from MYADDR to target memory at address MEMADDR.
9b409511 1468 Returns either 0 for success or TARGET_XFER_E_IO if any
578d3588
PA
1469 error occurs. If an error occurs, no guarantee is made about how
1470 much data got written. Callers that can deal with partial writes
1471 should call target_write. */
7f79c47e 1472
c906108c 1473int
45aa4659 1474target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
c906108c 1475{
aee4bf85
PA
1476 /* See comment in target_read_memory about why the request starts at
1477 current_target.beneath. */
c35b1492 1478 if (target_write (current_target.beneath, TARGET_OBJECT_MEMORY, NULL,
cf7a04e8
DJ
1479 myaddr, memaddr, len) == len)
1480 return 0;
0779438d 1481 else
578d3588 1482 return TARGET_XFER_E_IO;
c906108c 1483}
c5aa993b 1484
f0ba3972 1485/* Write LEN bytes from MYADDR to target raw memory at address
9b409511 1486 MEMADDR. Returns either 0 for success or TARGET_XFER_E_IO
578d3588
PA
1487 if any error occurs. If an error occurs, no guarantee is made
1488 about how much data got written. Callers that can deal with
1489 partial writes should call target_write. */
f0ba3972
PA
1490
1491int
45aa4659 1492target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
f0ba3972 1493{
aee4bf85
PA
1494 /* See comment in target_read_memory about why the request starts at
1495 current_target.beneath. */
f0ba3972
PA
1496 if (target_write (current_target.beneath, TARGET_OBJECT_RAW_MEMORY, NULL,
1497 myaddr, memaddr, len) == len)
1498 return 0;
1499 else
578d3588 1500 return TARGET_XFER_E_IO;
f0ba3972
PA
1501}
1502
fd79ecee
DJ
1503/* Fetch the target's memory map. */
1504
1505VEC(mem_region_s) *
1506target_memory_map (void)
1507{
1508 VEC(mem_region_s) *result;
1509 struct mem_region *last_one, *this_one;
1510 int ix;
1511 struct target_ops *t;
1512
6b2c5a57 1513 result = current_target.to_memory_map (&current_target);
fd79ecee
DJ
1514 if (result == NULL)
1515 return NULL;
1516
1517 qsort (VEC_address (mem_region_s, result),
1518 VEC_length (mem_region_s, result),
1519 sizeof (struct mem_region), mem_region_cmp);
1520
1521 /* Check that regions do not overlap. Simultaneously assign
1522 a numbering for the "mem" commands to use to refer to
1523 each region. */
1524 last_one = NULL;
1525 for (ix = 0; VEC_iterate (mem_region_s, result, ix, this_one); ix++)
1526 {
1527 this_one->number = ix;
1528
1529 if (last_one && last_one->hi > this_one->lo)
1530 {
1531 warning (_("Overlapping regions in memory map: ignoring"));
1532 VEC_free (mem_region_s, result);
1533 return NULL;
1534 }
1535 last_one = this_one;
1536 }
1537
1538 return result;
1539}
1540
a76d924d
DJ
1541void
1542target_flash_erase (ULONGEST address, LONGEST length)
1543{
e8a6c6ac 1544 current_target.to_flash_erase (&current_target, address, length);
a76d924d
DJ
1545}
1546
1547void
1548target_flash_done (void)
1549{
f6fb2925 1550 current_target.to_flash_done (&current_target);
a76d924d
DJ
1551}
1552
920d2a44
AC
1553static void
1554show_trust_readonly (struct ui_file *file, int from_tty,
1555 struct cmd_list_element *c, const char *value)
1556{
3e43a32a
MS
1557 fprintf_filtered (file,
1558 _("Mode for reading from readonly sections is %s.\n"),
920d2a44
AC
1559 value);
1560}
3a11626d 1561
7f79c47e 1562/* Target vector read/write partial wrapper functions. */
0088c768 1563
9b409511 1564static enum target_xfer_status
1e3ff5ad
AC
1565target_read_partial (struct target_ops *ops,
1566 enum target_object object,
1b0ba102 1567 const char *annex, gdb_byte *buf,
9b409511
YQ
1568 ULONGEST offset, ULONGEST len,
1569 ULONGEST *xfered_len)
1e3ff5ad 1570{
9b409511
YQ
1571 return target_xfer_partial (ops, object, annex, buf, NULL, offset, len,
1572 xfered_len);
1e3ff5ad
AC
1573}
1574
8a55ffb0 1575static enum target_xfer_status
1e3ff5ad
AC
1576target_write_partial (struct target_ops *ops,
1577 enum target_object object,
1b0ba102 1578 const char *annex, const gdb_byte *buf,
9b409511 1579 ULONGEST offset, LONGEST len, ULONGEST *xfered_len)
1e3ff5ad 1580{
9b409511
YQ
1581 return target_xfer_partial (ops, object, annex, NULL, buf, offset, len,
1582 xfered_len);
1e3ff5ad
AC
1583}
1584
1585/* Wrappers to perform the full transfer. */
7f79c47e
DE
1586
1587/* For docs on target_read see target.h. */
1588
1e3ff5ad
AC
1589LONGEST
1590target_read (struct target_ops *ops,
1591 enum target_object object,
1b0ba102 1592 const char *annex, gdb_byte *buf,
1e3ff5ad
AC
1593 ULONGEST offset, LONGEST len)
1594{
279a6fed 1595 LONGEST xfered_total = 0;
d309493c
SM
1596 int unit_size = 1;
1597
1598 /* If we are reading from a memory object, find the length of an addressable
1599 unit for that architecture. */
1600 if (object == TARGET_OBJECT_MEMORY
1601 || object == TARGET_OBJECT_STACK_MEMORY
1602 || object == TARGET_OBJECT_CODE_MEMORY
1603 || object == TARGET_OBJECT_RAW_MEMORY)
1604 unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
5d502164 1605
279a6fed 1606 while (xfered_total < len)
1e3ff5ad 1607 {
279a6fed 1608 ULONGEST xfered_partial;
9b409511
YQ
1609 enum target_xfer_status status;
1610
1611 status = target_read_partial (ops, object, annex,
d309493c 1612 buf + xfered_total * unit_size,
279a6fed
SM
1613 offset + xfered_total, len - xfered_total,
1614 &xfered_partial);
5d502164 1615
1e3ff5ad 1616 /* Call an observer, notifying them of the xfer progress? */
9b409511 1617 if (status == TARGET_XFER_EOF)
279a6fed 1618 return xfered_total;
9b409511
YQ
1619 else if (status == TARGET_XFER_OK)
1620 {
279a6fed 1621 xfered_total += xfered_partial;
9b409511
YQ
1622 QUIT;
1623 }
1624 else
279a6fed 1625 return TARGET_XFER_E_IO;
9b409511 1626
1e3ff5ad
AC
1627 }
1628 return len;
1629}
1630
f1a507a1
JB
1631/* Assuming that the entire [begin, end) range of memory cannot be
1632 read, try to read whatever subrange is possible to read.
1633
1634 The function returns, in RESULT, either zero or one memory block.
1635 If there's a readable subrange at the beginning, it is completely
1636 read and returned. Any further readable subrange will not be read.
1637 Otherwise, if there's a readable subrange at the end, it will be
1638 completely read and returned. Any readable subranges before it
1639 (obviously, not starting at the beginning), will be ignored. In
1640 other cases -- either no readable subrange, or readable subrange(s)
1641 that is neither at the beginning, or end, nothing is returned.
1642
1643 The purpose of this function is to handle a read across a boundary
1644 of accessible memory in a case when memory map is not available.
1645 The above restrictions are fine for this case, but will give
1646 incorrect results if the memory is 'patchy'. However, supporting
1647 'patchy' memory would require trying to read every single byte,
1648 and it seems unacceptable solution. Explicit memory map is
1649 recommended for this case -- and target_read_memory_robust will
1650 take care of reading multiple ranges then. */
8dedea02
VP
1651
1652static void
3e43a32a 1653read_whatever_is_readable (struct target_ops *ops,
279a6fed 1654 const ULONGEST begin, const ULONGEST end,
d309493c 1655 int unit_size,
8dedea02 1656 VEC(memory_read_result_s) **result)
d5086790 1657{
f1a507a1 1658 gdb_byte *buf = xmalloc (end - begin);
8dedea02
VP
1659 ULONGEST current_begin = begin;
1660 ULONGEST current_end = end;
1661 int forward;
1662 memory_read_result_s r;
9b409511 1663 ULONGEST xfered_len;
8dedea02
VP
1664
1665 /* If we previously failed to read 1 byte, nothing can be done here. */
1666 if (end - begin <= 1)
13b3fd9b
MS
1667 {
1668 xfree (buf);
1669 return;
1670 }
8dedea02
VP
1671
1672 /* Check that either first or the last byte is readable, and give up
c378eb4e 1673 if not. This heuristic is meant to permit reading accessible memory
8dedea02
VP
1674 at the boundary of accessible region. */
1675 if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
9b409511 1676 buf, begin, 1, &xfered_len) == TARGET_XFER_OK)
8dedea02
VP
1677 {
1678 forward = 1;
1679 ++current_begin;
1680 }
1681 else if (target_read_partial (ops, TARGET_OBJECT_MEMORY, NULL,
279a6fed 1682 buf + (end - begin) - 1, end - 1, 1,
9b409511 1683 &xfered_len) == TARGET_XFER_OK)
8dedea02
VP
1684 {
1685 forward = 0;
1686 --current_end;
1687 }
1688 else
1689 {
13b3fd9b 1690 xfree (buf);
8dedea02
VP
1691 return;
1692 }
1693
1694 /* Loop invariant is that the [current_begin, current_end) was previously
1695 found to be not readable as a whole.
1696
1697 Note loop condition -- if the range has 1 byte, we can't divide the range
1698 so there's no point trying further. */
1699 while (current_end - current_begin > 1)
1700 {
1701 ULONGEST first_half_begin, first_half_end;
1702 ULONGEST second_half_begin, second_half_end;
1703 LONGEST xfer;
279a6fed 1704 ULONGEST middle = current_begin + (current_end - current_begin) / 2;
f1a507a1 1705
8dedea02
VP
1706 if (forward)
1707 {
1708 first_half_begin = current_begin;
1709 first_half_end = middle;
1710 second_half_begin = middle;
1711 second_half_end = current_end;
1712 }
1713 else
1714 {
1715 first_half_begin = middle;
1716 first_half_end = current_end;
1717 second_half_begin = current_begin;
1718 second_half_end = middle;
1719 }
1720
1721 xfer = target_read (ops, TARGET_OBJECT_MEMORY, NULL,
d309493c 1722 buf + (first_half_begin - begin) * unit_size,
8dedea02
VP
1723 first_half_begin,
1724 first_half_end - first_half_begin);
1725
1726 if (xfer == first_half_end - first_half_begin)
1727 {
c378eb4e 1728 /* This half reads up fine. So, the error must be in the
3e43a32a 1729 other half. */
8dedea02
VP
1730 current_begin = second_half_begin;
1731 current_end = second_half_end;
1732 }
1733 else
1734 {
c378eb4e 1735 /* This half is not readable. Because we've tried one byte, we
279a6fed 1736 know some part of this half if actually readable. Go to the next
8dedea02
VP
1737 iteration to divide again and try to read.
1738
1739 We don't handle the other half, because this function only tries
1740 to read a single readable subrange. */
1741 current_begin = first_half_begin;
1742 current_end = first_half_end;
1743 }
1744 }
1745
1746 if (forward)
1747 {
1748 /* The [begin, current_begin) range has been read. */
1749 r.begin = begin;
1750 r.end = current_begin;
1751 r.data = buf;
1752 }
1753 else
1754 {
1755 /* The [current_end, end) range has been read. */
279a6fed 1756 LONGEST region_len = end - current_end;
f1a507a1 1757
d309493c
SM
1758 r.data = xmalloc (region_len * unit_size);
1759 memcpy (r.data, buf + (current_end - begin) * unit_size,
1760 region_len * unit_size);
8dedea02
VP
1761 r.begin = current_end;
1762 r.end = end;
1763 xfree (buf);
1764 }
1765 VEC_safe_push(memory_read_result_s, (*result), &r);
1766}
1767
1768void
1769free_memory_read_result_vector (void *x)
1770{
1771 VEC(memory_read_result_s) *v = x;
1772 memory_read_result_s *current;
1773 int ix;
1774
1775 for (ix = 0; VEC_iterate (memory_read_result_s, v, ix, current); ++ix)
1776 {
1777 xfree (current->data);
1778 }
1779 VEC_free (memory_read_result_s, v);
1780}
1781
1782VEC(memory_read_result_s) *
279a6fed
SM
1783read_memory_robust (struct target_ops *ops,
1784 const ULONGEST offset, const LONGEST len)
8dedea02
VP
1785{
1786 VEC(memory_read_result_s) *result = 0;
d309493c 1787 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
8dedea02 1788
279a6fed
SM
1789 LONGEST xfered_total = 0;
1790 while (xfered_total < len)
d5086790 1791 {
279a6fed
SM
1792 struct mem_region *region = lookup_mem_region (offset + xfered_total);
1793 LONGEST region_len;
5d502164 1794
8dedea02
VP
1795 /* If there is no explicit region, a fake one should be created. */
1796 gdb_assert (region);
1797
1798 if (region->hi == 0)
279a6fed 1799 region_len = len - xfered_total;
8dedea02 1800 else
279a6fed 1801 region_len = region->hi - offset;
8dedea02
VP
1802
1803 if (region->attrib.mode == MEM_NONE || region->attrib.mode == MEM_WO)
d5086790 1804 {
c378eb4e 1805 /* Cannot read this region. Note that we can end up here only
8dedea02
VP
1806 if the region is explicitly marked inaccessible, or
1807 'inaccessible-by-default' is in effect. */
279a6fed 1808 xfered_total += region_len;
8dedea02
VP
1809 }
1810 else
1811 {
279a6fed 1812 LONGEST to_read = min (len - xfered_total, region_len);
d309493c 1813 gdb_byte *buffer = (gdb_byte *) xmalloc (to_read * unit_size);
8dedea02 1814
279a6fed
SM
1815 LONGEST xfered_partial =
1816 target_read (ops, TARGET_OBJECT_MEMORY, NULL,
1817 (gdb_byte *) buffer,
1818 offset + xfered_total, to_read);
8dedea02 1819 /* Call an observer, notifying them of the xfer progress? */
279a6fed 1820 if (xfered_partial <= 0)
d5086790 1821 {
c378eb4e 1822 /* Got an error reading full chunk. See if maybe we can read
8dedea02
VP
1823 some subrange. */
1824 xfree (buffer);
d309493c 1825 read_whatever_is_readable (ops, offset + xfered_total, unit_size,
279a6fed
SM
1826 offset + xfered_total + to_read, &result);
1827 xfered_total += to_read;
d5086790 1828 }
8dedea02
VP
1829 else
1830 {
1831 struct memory_read_result r;
1832 r.data = buffer;
279a6fed
SM
1833 r.begin = offset + xfered_total;
1834 r.end = r.begin + xfered_partial;
8dedea02 1835 VEC_safe_push (memory_read_result_s, result, &r);
279a6fed 1836 xfered_total += xfered_partial;
8dedea02
VP
1837 }
1838 QUIT;
d5086790 1839 }
d5086790 1840 }
8dedea02 1841 return result;
d5086790
VP
1842}
1843
8dedea02 1844
cf7a04e8
DJ
1845/* An alternative to target_write with progress callbacks. */
1846
1e3ff5ad 1847LONGEST
cf7a04e8
DJ
1848target_write_with_progress (struct target_ops *ops,
1849 enum target_object object,
1850 const char *annex, const gdb_byte *buf,
1851 ULONGEST offset, LONGEST len,
1852 void (*progress) (ULONGEST, void *), void *baton)
1e3ff5ad 1853{
279a6fed 1854 LONGEST xfered_total = 0;
d309493c
SM
1855 int unit_size = 1;
1856
1857 /* If we are writing to a memory object, find the length of an addressable
1858 unit for that architecture. */
1859 if (object == TARGET_OBJECT_MEMORY
1860 || object == TARGET_OBJECT_STACK_MEMORY
1861 || object == TARGET_OBJECT_CODE_MEMORY
1862 || object == TARGET_OBJECT_RAW_MEMORY)
1863 unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
a76d924d
DJ
1864
1865 /* Give the progress callback a chance to set up. */
1866 if (progress)
1867 (*progress) (0, baton);
1868
279a6fed 1869 while (xfered_total < len)
1e3ff5ad 1870 {
279a6fed 1871 ULONGEST xfered_partial;
9b409511
YQ
1872 enum target_xfer_status status;
1873
1874 status = target_write_partial (ops, object, annex,
d309493c 1875 buf + xfered_total * unit_size,
279a6fed
SM
1876 offset + xfered_total, len - xfered_total,
1877 &xfered_partial);
cf7a04e8 1878
5c328c05 1879 if (status != TARGET_XFER_OK)
279a6fed 1880 return status == TARGET_XFER_EOF ? xfered_total : TARGET_XFER_E_IO;
cf7a04e8
DJ
1881
1882 if (progress)
279a6fed 1883 (*progress) (xfered_partial, baton);
cf7a04e8 1884
279a6fed 1885 xfered_total += xfered_partial;
1e3ff5ad
AC
1886 QUIT;
1887 }
1888 return len;
1889}
1890
7f79c47e
DE
1891/* For docs on target_write see target.h. */
1892
cf7a04e8
DJ
1893LONGEST
1894target_write (struct target_ops *ops,
1895 enum target_object object,
1896 const char *annex, const gdb_byte *buf,
1897 ULONGEST offset, LONGEST len)
1898{
1899 return target_write_with_progress (ops, object, annex, buf, offset, len,
1900 NULL, NULL);
1901}
1902
159f81f3
DJ
1903/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1904 the size of the transferred data. PADDING additional bytes are
1905 available in *BUF_P. This is a helper function for
1906 target_read_alloc; see the declaration of that function for more
1907 information. */
13547ab6 1908
159f81f3
DJ
1909static LONGEST
1910target_read_alloc_1 (struct target_ops *ops, enum target_object object,
1911 const char *annex, gdb_byte **buf_p, int padding)
13547ab6
DJ
1912{
1913 size_t buf_alloc, buf_pos;
1914 gdb_byte *buf;
13547ab6
DJ
1915
1916 /* This function does not have a length parameter; it reads the
1917 entire OBJECT). Also, it doesn't support objects fetched partly
1918 from one target and partly from another (in a different stratum,
1919 e.g. a core file and an executable). Both reasons make it
1920 unsuitable for reading memory. */
1921 gdb_assert (object != TARGET_OBJECT_MEMORY);
1922
1923 /* Start by reading up to 4K at a time. The target will throttle
1924 this number down if necessary. */
1925 buf_alloc = 4096;
1926 buf = xmalloc (buf_alloc);
1927 buf_pos = 0;
1928 while (1)
1929 {
9b409511
YQ
1930 ULONGEST xfered_len;
1931 enum target_xfer_status status;
1932
1933 status = target_read_partial (ops, object, annex, &buf[buf_pos],
1934 buf_pos, buf_alloc - buf_pos - padding,
1935 &xfered_len);
1936
1937 if (status == TARGET_XFER_EOF)
13547ab6
DJ
1938 {
1939 /* Read all there was. */
1940 if (buf_pos == 0)
1941 xfree (buf);
1942 else
1943 *buf_p = buf;
1944 return buf_pos;
1945 }
9b409511
YQ
1946 else if (status != TARGET_XFER_OK)
1947 {
1948 /* An error occurred. */
1949 xfree (buf);
1950 return TARGET_XFER_E_IO;
1951 }
13547ab6 1952
9b409511 1953 buf_pos += xfered_len;
13547ab6
DJ
1954
1955 /* If the buffer is filling up, expand it. */
1956 if (buf_alloc < buf_pos * 2)
1957 {
1958 buf_alloc *= 2;
1959 buf = xrealloc (buf, buf_alloc);
1960 }
1961
1962 QUIT;
1963 }
1964}
1965
159f81f3
DJ
1966/* Read OBJECT/ANNEX using OPS. Store the result in *BUF_P and return
1967 the size of the transferred data. See the declaration in "target.h"
1968 function for more information about the return value. */
1969
1970LONGEST
1971target_read_alloc (struct target_ops *ops, enum target_object object,
1972 const char *annex, gdb_byte **buf_p)
1973{
1974 return target_read_alloc_1 (ops, object, annex, buf_p, 0);
1975}
1976
1977/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
1978 returned as a string, allocated using xmalloc. If an error occurs
1979 or the transfer is unsupported, NULL is returned. Empty objects
1980 are returned as allocated but empty strings. A warning is issued
1981 if the result contains any embedded NUL bytes. */
1982
1983char *
1984target_read_stralloc (struct target_ops *ops, enum target_object object,
1985 const char *annex)
1986{
39086a0e
PA
1987 gdb_byte *buffer;
1988 char *bufstr;
7313baad 1989 LONGEST i, transferred;
159f81f3 1990
39086a0e
PA
1991 transferred = target_read_alloc_1 (ops, object, annex, &buffer, 1);
1992 bufstr = (char *) buffer;
159f81f3
DJ
1993
1994 if (transferred < 0)
1995 return NULL;
1996
1997 if (transferred == 0)
1998 return xstrdup ("");
1999
39086a0e 2000 bufstr[transferred] = 0;
7313baad
UW
2001
2002 /* Check for embedded NUL bytes; but allow trailing NULs. */
39086a0e
PA
2003 for (i = strlen (bufstr); i < transferred; i++)
2004 if (bufstr[i] != 0)
7313baad
UW
2005 {
2006 warning (_("target object %d, annex %s, "
2007 "contained unexpected null characters"),
2008 (int) object, annex ? annex : "(none)");
2009 break;
2010 }
159f81f3 2011
39086a0e 2012 return bufstr;
159f81f3
DJ
2013}
2014
b6591e8b
AC
2015/* Memory transfer methods. */
2016
2017void
1b0ba102 2018get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
b6591e8b
AC
2019 LONGEST len)
2020{
07b82ea5
PA
2021 /* This method is used to read from an alternate, non-current
2022 target. This read must bypass the overlay support (as symbols
2023 don't match this target), and GDB's internal cache (wrong cache
2024 for this target). */
2025 if (target_read (ops, TARGET_OBJECT_RAW_MEMORY, NULL, buf, addr, len)
b6591e8b 2026 != len)
578d3588 2027 memory_error (TARGET_XFER_E_IO, addr);
b6591e8b
AC
2028}
2029
2030ULONGEST
5d502164
MS
2031get_target_memory_unsigned (struct target_ops *ops, CORE_ADDR addr,
2032 int len, enum bfd_endian byte_order)
b6591e8b 2033{
f6519ebc 2034 gdb_byte buf[sizeof (ULONGEST)];
b6591e8b
AC
2035
2036 gdb_assert (len <= sizeof (buf));
2037 get_target_memory (ops, addr, buf, len);
e17a4113 2038 return extract_unsigned_integer (buf, len, byte_order);
b6591e8b
AC
2039}
2040
3db08215
MM
2041/* See target.h. */
2042
d914c394
SS
2043int
2044target_insert_breakpoint (struct gdbarch *gdbarch,
2045 struct bp_target_info *bp_tgt)
2046{
2047 if (!may_insert_breakpoints)
2048 {
2049 warning (_("May not insert breakpoints"));
2050 return 1;
2051 }
2052
6b84065d
TT
2053 return current_target.to_insert_breakpoint (&current_target,
2054 gdbarch, bp_tgt);
d914c394
SS
2055}
2056
3db08215
MM
2057/* See target.h. */
2058
d914c394 2059int
6b84065d
TT
2060target_remove_breakpoint (struct gdbarch *gdbarch,
2061 struct bp_target_info *bp_tgt)
d914c394
SS
2062{
2063 /* This is kind of a weird case to handle, but the permission might
2064 have been changed after breakpoints were inserted - in which case
2065 we should just take the user literally and assume that any
2066 breakpoints should be left in place. */
2067 if (!may_insert_breakpoints)
2068 {
2069 warning (_("May not remove breakpoints"));
2070 return 1;
2071 }
2072
6b84065d
TT
2073 return current_target.to_remove_breakpoint (&current_target,
2074 gdbarch, bp_tgt);
d914c394
SS
2075}
2076
c906108c 2077static void
fba45db2 2078target_info (char *args, int from_tty)
c906108c
SS
2079{
2080 struct target_ops *t;
c906108c 2081 int has_all_mem = 0;
c5aa993b 2082
c906108c 2083 if (symfile_objfile != NULL)
4262abfb
JK
2084 printf_unfiltered (_("Symbols from \"%s\".\n"),
2085 objfile_name (symfile_objfile));
c906108c 2086
258b763a 2087 for (t = target_stack; t != NULL; t = t->beneath)
c906108c 2088 {
c35b1492 2089 if (!(*t->to_has_memory) (t))
c906108c
SS
2090 continue;
2091
c5aa993b 2092 if ((int) (t->to_stratum) <= (int) dummy_stratum)
c906108c
SS
2093 continue;
2094 if (has_all_mem)
3e43a32a
MS
2095 printf_unfiltered (_("\tWhile running this, "
2096 "GDB does not access memory from...\n"));
c5aa993b
JM
2097 printf_unfiltered ("%s:\n", t->to_longname);
2098 (t->to_files_info) (t);
c35b1492 2099 has_all_mem = (*t->to_has_all_memory) (t);
c906108c
SS
2100 }
2101}
2102
fd79ecee
DJ
2103/* This function is called before any new inferior is created, e.g.
2104 by running a program, attaching, or connecting to a target.
2105 It cleans up any state from previous invocations which might
2106 change between runs. This is a subset of what target_preopen
2107 resets (things which might change between targets). */
2108
2109void
2110target_pre_inferior (int from_tty)
2111{
c378eb4e 2112 /* Clear out solib state. Otherwise the solib state of the previous
b9db4ced 2113 inferior might have survived and is entirely wrong for the new
c378eb4e 2114 target. This has been observed on GNU/Linux using glibc 2.3. How
b9db4ced
UW
2115 to reproduce:
2116
2117 bash$ ./foo&
2118 [1] 4711
2119 bash$ ./foo&
2120 [1] 4712
2121 bash$ gdb ./foo
2122 [...]
2123 (gdb) attach 4711
2124 (gdb) detach
2125 (gdb) attach 4712
2126 Cannot access memory at address 0xdeadbeef
2127 */
b9db4ced 2128
50c71eaf
PA
2129 /* In some OSs, the shared library list is the same/global/shared
2130 across inferiors. If code is shared between processes, so are
2131 memory regions and features. */
f5656ead 2132 if (!gdbarch_has_global_solist (target_gdbarch ()))
50c71eaf
PA
2133 {
2134 no_shared_libraries (NULL, from_tty);
2135
2136 invalidate_target_mem_regions ();
424163ea 2137
50c71eaf
PA
2138 target_clear_description ();
2139 }
8ffcbaaf 2140
e9756d52
PP
2141 /* attach_flag may be set if the previous process associated with
2142 the inferior was attached to. */
2143 current_inferior ()->attach_flag = 0;
2144
8ffcbaaf 2145 agent_capability_invalidate ();
fd79ecee
DJ
2146}
2147
b8fa0bfa
PA
2148/* Callback for iterate_over_inferiors. Gets rid of the given
2149 inferior. */
2150
2151static int
2152dispose_inferior (struct inferior *inf, void *args)
2153{
2154 struct thread_info *thread;
2155
2156 thread = any_thread_of_process (inf->pid);
2157 if (thread)
2158 {
2159 switch_to_thread (thread->ptid);
2160
2161 /* Core inferiors actually should be detached, not killed. */
2162 if (target_has_execution)
2163 target_kill ();
2164 else
2165 target_detach (NULL, 0);
2166 }
2167
2168 return 0;
2169}
2170
c906108c
SS
2171/* This is to be called by the open routine before it does
2172 anything. */
2173
2174void
fba45db2 2175target_preopen (int from_tty)
c906108c 2176{
c5aa993b 2177 dont_repeat ();
c906108c 2178
b8fa0bfa 2179 if (have_inferiors ())
c5aa993b 2180 {
adf40b2e 2181 if (!from_tty
b8fa0bfa
PA
2182 || !have_live_inferiors ()
2183 || query (_("A program is being debugged already. Kill it? ")))
2184 iterate_over_inferiors (dispose_inferior, NULL);
c906108c 2185 else
8a3fe4f8 2186 error (_("Program not killed."));
c906108c
SS
2187 }
2188
2189 /* Calling target_kill may remove the target from the stack. But if
2190 it doesn't (which seems like a win for UDI), remove it now. */
87ab71f0
PA
2191 /* Leave the exec target, though. The user may be switching from a
2192 live process to a core of the same program. */
460014f5 2193 pop_all_targets_above (file_stratum);
fd79ecee
DJ
2194
2195 target_pre_inferior (from_tty);
c906108c
SS
2196}
2197
2198/* Detach a target after doing deferred register stores. */
2199
2200void
52554a0e 2201target_detach (const char *args, int from_tty)
c906108c 2202{
136d6dae
VP
2203 struct target_ops* t;
2204
f5656ead 2205 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
50c71eaf
PA
2206 /* Don't remove global breakpoints here. They're removed on
2207 disconnection from the target. */
2208 ;
2209 else
2210 /* If we're in breakpoints-always-inserted mode, have to remove
2211 them before detaching. */
dfd4cc63 2212 remove_breakpoints_pid (ptid_get_pid (inferior_ptid));
74960c60 2213
24291992
PA
2214 prepare_for_detach ();
2215
09da0d0a 2216 current_target.to_detach (&current_target, args, from_tty);
c906108c
SS
2217}
2218
6ad8ae5c 2219void
fee354ee 2220target_disconnect (const char *args, int from_tty)
6ad8ae5c 2221{
50c71eaf
PA
2222 /* If we're in breakpoints-always-inserted mode or if breakpoints
2223 are global across processes, we have to remove them before
2224 disconnecting. */
74960c60
VP
2225 remove_breakpoints ();
2226
86a0854a 2227 current_target.to_disconnect (&current_target, args, from_tty);
6ad8ae5c
DJ
2228}
2229
117de6a9 2230ptid_t
47608cb1 2231target_wait (ptid_t ptid, struct target_waitstatus *status, int options)
117de6a9 2232{
a7068b60 2233 return (current_target.to_wait) (&current_target, ptid, status, options);
117de6a9
PA
2234}
2235
0b333c5e
PA
2236/* See target.h. */
2237
2238ptid_t
2239default_target_wait (struct target_ops *ops,
2240 ptid_t ptid, struct target_waitstatus *status,
2241 int options)
2242{
2243 status->kind = TARGET_WAITKIND_IGNORE;
2244 return minus_one_ptid;
2245}
2246
117de6a9
PA
2247char *
2248target_pid_to_str (ptid_t ptid)
2249{
770234d3 2250 return (*current_target.to_pid_to_str) (&current_target, ptid);
117de6a9
PA
2251}
2252
4694da01
TT
2253char *
2254target_thread_name (struct thread_info *info)
2255{
825828fc 2256 return current_target.to_thread_name (&current_target, info);
4694da01
TT
2257}
2258
e1ac3328 2259void
2ea28649 2260target_resume (ptid_t ptid, int step, enum gdb_signal signal)
e1ac3328 2261{
28439f5e
PA
2262 struct target_ops *t;
2263
4e5d721f 2264 target_dcache_invalidate ();
28439f5e 2265
6b84065d 2266 current_target.to_resume (&current_target, ptid, step, signal);
28439f5e 2267
6b84065d 2268 registers_changed_ptid (ptid);
251bde03
PA
2269 /* We only set the internal executing state here. The user/frontend
2270 running state is set at a higher level. */
6b84065d 2271 set_executing (ptid, 1);
6b84065d 2272 clear_inline_frame_state (ptid);
e1ac3328 2273}
2455069d
UW
2274
2275void
2276target_pass_signals (int numsigs, unsigned char *pass_signals)
2277{
035cad7f 2278 (*current_target.to_pass_signals) (&current_target, numsigs, pass_signals);
2455069d
UW
2279}
2280
9b224c5e
PA
2281void
2282target_program_signals (int numsigs, unsigned char *program_signals)
2283{
7d4f8efa
TT
2284 (*current_target.to_program_signals) (&current_target,
2285 numsigs, program_signals);
9b224c5e
PA
2286}
2287
098dba18
TT
2288static int
2289default_follow_fork (struct target_ops *self, int follow_child,
2290 int detach_fork)
2291{
2292 /* Some target returned a fork event, but did not know how to follow it. */
2293 internal_error (__FILE__, __LINE__,
2294 _("could not find a target to follow fork"));
2295}
2296
ee057212
DJ
2297/* Look through the list of possible targets for a target that can
2298 follow forks. */
2299
2300int
07107ca6 2301target_follow_fork (int follow_child, int detach_fork)
ee057212 2302{
a7068b60
TT
2303 return current_target.to_follow_fork (&current_target,
2304 follow_child, detach_fork);
ee057212
DJ
2305}
2306
8d657035
TT
2307static void
2308default_mourn_inferior (struct target_ops *self)
2309{
2310 internal_error (__FILE__, __LINE__,
2311 _("could not find a target to follow mourn inferior"));
2312}
2313
136d6dae
VP
2314void
2315target_mourn_inferior (void)
2316{
8d657035 2317 current_target.to_mourn_inferior (&current_target);
136d6dae 2318
8d657035
TT
2319 /* We no longer need to keep handles on any of the object files.
2320 Make sure to release them to avoid unnecessarily locking any
2321 of them while we're not actually debugging. */
2322 bfd_cache_close_all ();
136d6dae
VP
2323}
2324
424163ea
DJ
2325/* Look for a target which can describe architectural features, starting
2326 from TARGET. If we find one, return its description. */
2327
2328const struct target_desc *
2329target_read_description (struct target_ops *target)
2330{
2117c711 2331 return target->to_read_description (target);
424163ea
DJ
2332}
2333
58a5184e 2334/* This implements a basic search of memory, reading target memory and
08388c79
DE
2335 performing the search here (as opposed to performing the search in on the
2336 target side with, for example, gdbserver). */
2337
2338int
2339simple_search_memory (struct target_ops *ops,
2340 CORE_ADDR start_addr, ULONGEST search_space_len,
2341 const gdb_byte *pattern, ULONGEST pattern_len,
2342 CORE_ADDR *found_addrp)
2343{
2344 /* NOTE: also defined in find.c testcase. */
2345#define SEARCH_CHUNK_SIZE 16000
2346 const unsigned chunk_size = SEARCH_CHUNK_SIZE;
2347 /* Buffer to hold memory contents for searching. */
2348 gdb_byte *search_buf;
2349 unsigned search_buf_size;
2350 struct cleanup *old_cleanups;
2351
2352 search_buf_size = chunk_size + pattern_len - 1;
2353
2354 /* No point in trying to allocate a buffer larger than the search space. */
2355 if (search_space_len < search_buf_size)
2356 search_buf_size = search_space_len;
2357
2358 search_buf = malloc (search_buf_size);
2359 if (search_buf == NULL)
5e1471f5 2360 error (_("Unable to allocate memory to perform the search."));
08388c79
DE
2361 old_cleanups = make_cleanup (free_current_contents, &search_buf);
2362
2363 /* Prime the search buffer. */
2364
2365 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2366 search_buf, start_addr, search_buf_size) != search_buf_size)
2367 {
b3dc46ff
AB
2368 warning (_("Unable to access %s bytes of target "
2369 "memory at %s, halting search."),
2370 pulongest (search_buf_size), hex_string (start_addr));
08388c79
DE
2371 do_cleanups (old_cleanups);
2372 return -1;
2373 }
2374
2375 /* Perform the search.
2376
2377 The loop is kept simple by allocating [N + pattern-length - 1] bytes.
2378 When we've scanned N bytes we copy the trailing bytes to the start and
2379 read in another N bytes. */
2380
2381 while (search_space_len >= pattern_len)
2382 {
2383 gdb_byte *found_ptr;
2384 unsigned nr_search_bytes = min (search_space_len, search_buf_size);
2385
2386 found_ptr = memmem (search_buf, nr_search_bytes,
2387 pattern, pattern_len);
2388
2389 if (found_ptr != NULL)
2390 {
2391 CORE_ADDR found_addr = start_addr + (found_ptr - search_buf);
5d502164 2392
08388c79
DE
2393 *found_addrp = found_addr;
2394 do_cleanups (old_cleanups);
2395 return 1;
2396 }
2397
2398 /* Not found in this chunk, skip to next chunk. */
2399
2400 /* Don't let search_space_len wrap here, it's unsigned. */
2401 if (search_space_len >= chunk_size)
2402 search_space_len -= chunk_size;
2403 else
2404 search_space_len = 0;
2405
2406 if (search_space_len >= pattern_len)
2407 {
2408 unsigned keep_len = search_buf_size - chunk_size;
8a35fb51 2409 CORE_ADDR read_addr = start_addr + chunk_size + keep_len;
08388c79
DE
2410 int nr_to_read;
2411
2412 /* Copy the trailing part of the previous iteration to the front
2413 of the buffer for the next iteration. */
2414 gdb_assert (keep_len == pattern_len - 1);
2415 memcpy (search_buf, search_buf + chunk_size, keep_len);
2416
2417 nr_to_read = min (search_space_len - keep_len, chunk_size);
2418
2419 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL,
2420 search_buf + keep_len, read_addr,
2421 nr_to_read) != nr_to_read)
2422 {
b3dc46ff 2423 warning (_("Unable to access %s bytes of target "
9b20d036 2424 "memory at %s, halting search."),
b3dc46ff 2425 plongest (nr_to_read),
08388c79
DE
2426 hex_string (read_addr));
2427 do_cleanups (old_cleanups);
2428 return -1;
2429 }
2430
2431 start_addr += chunk_size;
2432 }
2433 }
2434
2435 /* Not found. */
2436
2437 do_cleanups (old_cleanups);
2438 return 0;
2439}
2440
58a5184e
TT
2441/* Default implementation of memory-searching. */
2442
2443static int
2444default_search_memory (struct target_ops *self,
2445 CORE_ADDR start_addr, ULONGEST search_space_len,
2446 const gdb_byte *pattern, ULONGEST pattern_len,
2447 CORE_ADDR *found_addrp)
2448{
2449 /* Start over from the top of the target stack. */
2450 return simple_search_memory (current_target.beneath,
2451 start_addr, search_space_len,
2452 pattern, pattern_len, found_addrp);
2453}
2454
08388c79
DE
2455/* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
2456 sequence of bytes in PATTERN with length PATTERN_LEN.
2457
2458 The result is 1 if found, 0 if not found, and -1 if there was an error
2459 requiring halting of the search (e.g. memory read error).
2460 If the pattern is found the address is recorded in FOUND_ADDRP. */
2461
2462int
2463target_search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
2464 const gdb_byte *pattern, ULONGEST pattern_len,
2465 CORE_ADDR *found_addrp)
2466{
a7068b60
TT
2467 return current_target.to_search_memory (&current_target, start_addr,
2468 search_space_len,
2469 pattern, pattern_len, found_addrp);
08388c79
DE
2470}
2471
8edfe269
DJ
2472/* Look through the currently pushed targets. If none of them will
2473 be able to restart the currently running process, issue an error
2474 message. */
2475
2476void
2477target_require_runnable (void)
2478{
2479 struct target_ops *t;
2480
2481 for (t = target_stack; t != NULL; t = t->beneath)
2482 {
2483 /* If this target knows how to create a new program, then
2484 assume we will still be able to after killing the current
2485 one. Either killing and mourning will not pop T, or else
2486 find_default_run_target will find it again. */
2487 if (t->to_create_inferior != NULL)
2488 return;
2489
548740d6 2490 /* Do not worry about targets at certain strata that can not
8edfe269
DJ
2491 create inferiors. Assume they will be pushed again if
2492 necessary, and continue to the process_stratum. */
85e747d2 2493 if (t->to_stratum == thread_stratum
548740d6 2494 || t->to_stratum == record_stratum
85e747d2 2495 || t->to_stratum == arch_stratum)
8edfe269
DJ
2496 continue;
2497
3e43a32a
MS
2498 error (_("The \"%s\" target does not support \"run\". "
2499 "Try \"help target\" or \"continue\"."),
8edfe269
DJ
2500 t->to_shortname);
2501 }
2502
2503 /* This function is only called if the target is running. In that
2504 case there should have been a process_stratum target and it
c378eb4e 2505 should either know how to create inferiors, or not... */
9b20d036 2506 internal_error (__FILE__, __LINE__, _("No targets found"));
8edfe269
DJ
2507}
2508
6a3cb8e8
PA
2509/* Whether GDB is allowed to fall back to the default run target for
2510 "run", "attach", etc. when no target is connected yet. */
2511static int auto_connect_native_target = 1;
2512
2513static void
2514show_auto_connect_native_target (struct ui_file *file, int from_tty,
2515 struct cmd_list_element *c, const char *value)
2516{
2517 fprintf_filtered (file,
2518 _("Whether GDB may automatically connect to the "
2519 "native target is %s.\n"),
2520 value);
2521}
2522
c906108c
SS
2523/* Look through the list of possible targets for a target that can
2524 execute a run or attach command without any other data. This is
2525 used to locate the default process stratum.
2526
5f667f2d
PA
2527 If DO_MESG is not NULL, the result is always valid (error() is
2528 called for errors); else, return NULL on error. */
c906108c
SS
2529
2530static struct target_ops *
fba45db2 2531find_default_run_target (char *do_mesg)
c906108c 2532{
c906108c 2533 struct target_ops *runable = NULL;
c906108c 2534
6a3cb8e8 2535 if (auto_connect_native_target)
c906108c 2536 {
89a1c21a 2537 struct target_ops *t;
6a3cb8e8 2538 int count = 0;
89a1c21a 2539 int i;
6a3cb8e8 2540
89a1c21a 2541 for (i = 0; VEC_iterate (target_ops_p, target_structs, i, t); ++i)
c906108c 2542 {
89a1c21a 2543 if (t->to_can_run != delegate_can_run && target_can_run (t))
6a3cb8e8 2544 {
89a1c21a 2545 runable = t;
6a3cb8e8
PA
2546 ++count;
2547 }
c906108c 2548 }
6a3cb8e8
PA
2549
2550 if (count != 1)
2551 runable = NULL;
c906108c
SS
2552 }
2553
6a3cb8e8 2554 if (runable == NULL)
5f667f2d
PA
2555 {
2556 if (do_mesg)
2557 error (_("Don't know how to %s. Try \"help target\"."), do_mesg);
2558 else
2559 return NULL;
2560 }
c906108c
SS
2561
2562 return runable;
2563}
2564
b3ccfe11 2565/* See target.h. */
c906108c 2566
b3ccfe11
TT
2567struct target_ops *
2568find_attach_target (void)
c906108c
SS
2569{
2570 struct target_ops *t;
2571
b3ccfe11
TT
2572 /* If a target on the current stack can attach, use it. */
2573 for (t = current_target.beneath; t != NULL; t = t->beneath)
2574 {
2575 if (t->to_attach != NULL)
2576 break;
2577 }
c906108c 2578
b3ccfe11
TT
2579 /* Otherwise, use the default run target for attaching. */
2580 if (t == NULL)
2581 t = find_default_run_target ("attach");
b84876c2 2582
b3ccfe11 2583 return t;
b84876c2
PA
2584}
2585
b3ccfe11 2586/* See target.h. */
b84876c2 2587
b3ccfe11
TT
2588struct target_ops *
2589find_run_target (void)
9908b566
VP
2590{
2591 struct target_ops *t;
2592
b3ccfe11
TT
2593 /* If a target on the current stack can attach, use it. */
2594 for (t = current_target.beneath; t != NULL; t = t->beneath)
2595 {
2596 if (t->to_create_inferior != NULL)
2597 break;
2598 }
5d502164 2599
b3ccfe11
TT
2600 /* Otherwise, use the default run target. */
2601 if (t == NULL)
2602 t = find_default_run_target ("run");
9908b566 2603
b3ccfe11 2604 return t;
9908b566
VP
2605}
2606
145b16a9
UW
2607/* Implement the "info proc" command. */
2608
451b7c33 2609int
7bc112c1 2610target_info_proc (const char *args, enum info_proc_what what)
145b16a9
UW
2611{
2612 struct target_ops *t;
2613
2614 /* If we're already connected to something that can get us OS
2615 related data, use it. Otherwise, try using the native
2616 target. */
2617 if (current_target.to_stratum >= process_stratum)
2618 t = current_target.beneath;
2619 else
2620 t = find_default_run_target (NULL);
2621
2622 for (; t != NULL; t = t->beneath)
2623 {
2624 if (t->to_info_proc != NULL)
2625 {
2626 t->to_info_proc (t, args, what);
2627
2628 if (targetdebug)
2629 fprintf_unfiltered (gdb_stdlog,
2630 "target_info_proc (\"%s\", %d)\n", args, what);
2631
451b7c33 2632 return 1;
145b16a9
UW
2633 }
2634 }
2635
451b7c33 2636 return 0;
145b16a9
UW
2637}
2638
03583c20 2639static int
2bfc0540 2640find_default_supports_disable_randomization (struct target_ops *self)
03583c20
UW
2641{
2642 struct target_ops *t;
2643
2644 t = find_default_run_target (NULL);
2645 if (t && t->to_supports_disable_randomization)
2bfc0540 2646 return (t->to_supports_disable_randomization) (t);
03583c20
UW
2647 return 0;
2648}
2649
2650int
2651target_supports_disable_randomization (void)
2652{
2653 struct target_ops *t;
2654
2655 for (t = &current_target; t != NULL; t = t->beneath)
2656 if (t->to_supports_disable_randomization)
2bfc0540 2657 return t->to_supports_disable_randomization (t);
03583c20
UW
2658
2659 return 0;
2660}
9908b566 2661
07e059b5
VP
2662char *
2663target_get_osdata (const char *type)
2664{
07e059b5
VP
2665 struct target_ops *t;
2666
739ef7fb
PA
2667 /* If we're already connected to something that can get us OS
2668 related data, use it. Otherwise, try using the native
2669 target. */
2670 if (current_target.to_stratum >= process_stratum)
6d097e65 2671 t = current_target.beneath;
739ef7fb
PA
2672 else
2673 t = find_default_run_target ("get OS data");
07e059b5
VP
2674
2675 if (!t)
2676 return NULL;
2677
6d097e65 2678 return target_read_stralloc (t, TARGET_OBJECT_OSDATA, type);
07e059b5
VP
2679}
2680
8eaff7cd
TT
2681static struct address_space *
2682default_thread_address_space (struct target_ops *self, ptid_t ptid)
6c95b8df
PA
2683{
2684 struct inferior *inf;
6c95b8df
PA
2685
2686 /* Fall-back to the "main" address space of the inferior. */
c9657e70 2687 inf = find_inferior_ptid (ptid);
6c95b8df
PA
2688
2689 if (inf == NULL || inf->aspace == NULL)
3e43a32a 2690 internal_error (__FILE__, __LINE__,
9b20d036
MS
2691 _("Can't determine the current "
2692 "address space of thread %s\n"),
6c95b8df
PA
2693 target_pid_to_str (ptid));
2694
2695 return inf->aspace;
2696}
2697
8eaff7cd
TT
2698/* Determine the current address space of thread PTID. */
2699
2700struct address_space *
2701target_thread_address_space (ptid_t ptid)
2702{
2703 struct address_space *aspace;
2704
2705 aspace = current_target.to_thread_address_space (&current_target, ptid);
2706 gdb_assert (aspace != NULL);
2707
8eaff7cd
TT
2708 return aspace;
2709}
2710
7313baad
UW
2711
2712/* Target file operations. */
2713
2714static struct target_ops *
2715default_fileio_target (void)
2716{
2717 /* If we're already connected to something that can perform
2718 file I/O, use it. Otherwise, try using the native target. */
2719 if (current_target.to_stratum >= process_stratum)
2720 return current_target.beneath;
2721 else
2722 return find_default_run_target ("file I/O");
2723}
2724
1c4b552b
GB
2725/* File handle for target file operations. */
2726
2727typedef struct
2728{
2729 /* The target on which this file is open. */
2730 struct target_ops *t;
2731
2732 /* The file descriptor on the target. */
2733 int fd;
2734} fileio_fh_t;
2735
2736DEF_VEC_O (fileio_fh_t);
2737
2738/* Vector of currently open file handles. The value returned by
2739 target_fileio_open and passed as the FD argument to other
2740 target_fileio_* functions is an index into this vector. This
2741 vector's entries are never freed; instead, files are marked as
2742 closed, and the handle becomes available for reuse. */
2743static VEC (fileio_fh_t) *fileio_fhandles;
2744
2745/* Macro to check whether a fileio_fh_t represents a closed file. */
2746#define is_closed_fileio_fh(fd) ((fd) < 0)
2747
2748/* Index into fileio_fhandles of the lowest handle that might be
2749 closed. This permits handle reuse without searching the whole
2750 list each time a new file is opened. */
2751static int lowest_closed_fd;
2752
2753/* Acquire a target fileio file descriptor. */
2754
2755static int
2756acquire_fileio_fd (struct target_ops *t, int fd)
2757{
2758 fileio_fh_t *fh, buf;
2759
2760 gdb_assert (!is_closed_fileio_fh (fd));
2761
2762 /* Search for closed handles to reuse. */
2763 for (;
2764 VEC_iterate (fileio_fh_t, fileio_fhandles,
2765 lowest_closed_fd, fh);
2766 lowest_closed_fd++)
2767 if (is_closed_fileio_fh (fh->fd))
2768 break;
2769
2770 /* Push a new handle if no closed handles were found. */
2771 if (lowest_closed_fd == VEC_length (fileio_fh_t, fileio_fhandles))
2772 fh = VEC_safe_push (fileio_fh_t, fileio_fhandles, NULL);
2773
2774 /* Fill in the handle. */
2775 fh->t = t;
2776 fh->fd = fd;
2777
2778 /* Return its index, and start the next lookup at
2779 the next index. */
2780 return lowest_closed_fd++;
2781}
2782
2783/* Release a target fileio file descriptor. */
2784
2785static void
2786release_fileio_fd (int fd, fileio_fh_t *fh)
2787{
2788 fh->fd = -1;
2789 lowest_closed_fd = min (lowest_closed_fd, fd);
2790}
2791
2792/* Return a pointer to the fileio_fhandle_t corresponding to FD. */
2793
2794#define fileio_fd_to_fh(fd) \
2795 VEC_index (fileio_fh_t, fileio_fhandles, (fd))
2796
4313b8c0
GB
2797/* Helper for target_fileio_open and
2798 target_fileio_open_warn_if_slow. */
12e2a5fd 2799
4313b8c0
GB
2800static int
2801target_fileio_open_1 (struct inferior *inf, const char *filename,
2802 int flags, int mode, int warn_if_slow,
2803 int *target_errno)
7313baad
UW
2804{
2805 struct target_ops *t;
2806
2807 for (t = default_fileio_target (); t != NULL; t = t->beneath)
2808 {
2809 if (t->to_fileio_open != NULL)
2810 {
07c138c8 2811 int fd = t->to_fileio_open (t, inf, filename, flags, mode,
4313b8c0 2812 warn_if_slow, target_errno);
7313baad 2813
1c4b552b
GB
2814 if (fd < 0)
2815 fd = -1;
2816 else
2817 fd = acquire_fileio_fd (t, fd);
2818
7313baad
UW
2819 if (targetdebug)
2820 fprintf_unfiltered (gdb_stdlog,
4313b8c0 2821 "target_fileio_open (%d,%s,0x%x,0%o,%d)"
07c138c8
GB
2822 " = %d (%d)\n",
2823 inf == NULL ? 0 : inf->num,
7313baad 2824 filename, flags, mode,
4313b8c0
GB
2825 warn_if_slow, fd,
2826 fd != -1 ? 0 : *target_errno);
7313baad
UW
2827 return fd;
2828 }
2829 }
2830
2831 *target_errno = FILEIO_ENOSYS;
2832 return -1;
2833}
2834
12e2a5fd
GB
2835/* See target.h. */
2836
4313b8c0
GB
2837int
2838target_fileio_open (struct inferior *inf, const char *filename,
2839 int flags, int mode, int *target_errno)
2840{
2841 return target_fileio_open_1 (inf, filename, flags, mode, 0,
2842 target_errno);
2843}
2844
2845/* See target.h. */
2846
2847int
2848target_fileio_open_warn_if_slow (struct inferior *inf,
2849 const char *filename,
2850 int flags, int mode, int *target_errno)
2851{
2852 return target_fileio_open_1 (inf, filename, flags, mode, 1,
2853 target_errno);
2854}
2855
2856/* See target.h. */
2857
7313baad
UW
2858int
2859target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
2860 ULONGEST offset, int *target_errno)
2861{
1c4b552b
GB
2862 fileio_fh_t *fh = fileio_fd_to_fh (fd);
2863 int ret = -1;
7313baad 2864
1c4b552b
GB
2865 if (is_closed_fileio_fh (fh->fd))
2866 *target_errno = EBADF;
2867 else
2868 ret = fh->t->to_fileio_pwrite (fh->t, fh->fd, write_buf,
2869 len, offset, target_errno);
7313baad 2870
1c4b552b
GB
2871 if (targetdebug)
2872 fprintf_unfiltered (gdb_stdlog,
2873 "target_fileio_pwrite (%d,...,%d,%s) "
2874 "= %d (%d)\n",
2875 fd, len, pulongest (offset),
2876 ret, ret != -1 ? 0 : *target_errno);
2877 return ret;
7313baad
UW
2878}
2879
12e2a5fd
GB
2880/* See target.h. */
2881
7313baad
UW
2882int
2883target_fileio_pread (int fd, gdb_byte *read_buf, int len,
2884 ULONGEST offset, int *target_errno)
2885{
1c4b552b
GB
2886 fileio_fh_t *fh = fileio_fd_to_fh (fd);
2887 int ret = -1;
7313baad 2888
1c4b552b
GB
2889 if (is_closed_fileio_fh (fh->fd))
2890 *target_errno = EBADF;
2891 else
2892 ret = fh->t->to_fileio_pread (fh->t, fh->fd, read_buf,
2893 len, offset, target_errno);
7313baad 2894
1c4b552b
GB
2895 if (targetdebug)
2896 fprintf_unfiltered (gdb_stdlog,
2897 "target_fileio_pread (%d,...,%d,%s) "
2898 "= %d (%d)\n",
2899 fd, len, pulongest (offset),
2900 ret, ret != -1 ? 0 : *target_errno);
9b15c1f0
GB
2901 return ret;
2902}
2903
2904/* See target.h. */
12e2a5fd 2905
9b15c1f0
GB
2906int
2907target_fileio_fstat (int fd, struct stat *sb, int *target_errno)
2908{
2909 fileio_fh_t *fh = fileio_fd_to_fh (fd);
2910 int ret = -1;
2911
2912 if (is_closed_fileio_fh (fh->fd))
2913 *target_errno = EBADF;
2914 else
2915 ret = fh->t->to_fileio_fstat (fh->t, fh->fd, sb, target_errno);
2916
2917 if (targetdebug)
2918 fprintf_unfiltered (gdb_stdlog,
2919 "target_fileio_fstat (%d) = %d (%d)\n",
2920 fd, ret, ret != -1 ? 0 : *target_errno);
1c4b552b 2921 return ret;
7313baad
UW
2922}
2923
12e2a5fd
GB
2924/* See target.h. */
2925
7313baad
UW
2926int
2927target_fileio_close (int fd, int *target_errno)
2928{
1c4b552b
GB
2929 fileio_fh_t *fh = fileio_fd_to_fh (fd);
2930 int ret = -1;
7313baad 2931
1c4b552b
GB
2932 if (is_closed_fileio_fh (fh->fd))
2933 *target_errno = EBADF;
2934 else
7313baad 2935 {
1c4b552b
GB
2936 ret = fh->t->to_fileio_close (fh->t, fh->fd, target_errno);
2937 release_fileio_fd (fd, fh);
7313baad
UW
2938 }
2939
1c4b552b
GB
2940 if (targetdebug)
2941 fprintf_unfiltered (gdb_stdlog,
2942 "target_fileio_close (%d) = %d (%d)\n",
2943 fd, ret, ret != -1 ? 0 : *target_errno);
2944 return ret;
7313baad
UW
2945}
2946
12e2a5fd
GB
2947/* See target.h. */
2948
7313baad 2949int
07c138c8
GB
2950target_fileio_unlink (struct inferior *inf, const char *filename,
2951 int *target_errno)
7313baad
UW
2952{
2953 struct target_ops *t;
2954
2955 for (t = default_fileio_target (); t != NULL; t = t->beneath)
2956 {
2957 if (t->to_fileio_unlink != NULL)
2958 {
07c138c8
GB
2959 int ret = t->to_fileio_unlink (t, inf, filename,
2960 target_errno);
7313baad
UW
2961
2962 if (targetdebug)
2963 fprintf_unfiltered (gdb_stdlog,
07c138c8
GB
2964 "target_fileio_unlink (%d,%s)"
2965 " = %d (%d)\n",
2966 inf == NULL ? 0 : inf->num, filename,
2967 ret, ret != -1 ? 0 : *target_errno);
7313baad
UW
2968 return ret;
2969 }
2970 }
2971
2972 *target_errno = FILEIO_ENOSYS;
2973 return -1;
2974}
2975
12e2a5fd
GB
2976/* See target.h. */
2977
b9e7b9c3 2978char *
07c138c8
GB
2979target_fileio_readlink (struct inferior *inf, const char *filename,
2980 int *target_errno)
b9e7b9c3
UW
2981{
2982 struct target_ops *t;
2983
2984 for (t = default_fileio_target (); t != NULL; t = t->beneath)
2985 {
2986 if (t->to_fileio_readlink != NULL)
2987 {
07c138c8
GB
2988 char *ret = t->to_fileio_readlink (t, inf, filename,
2989 target_errno);
b9e7b9c3
UW
2990
2991 if (targetdebug)
2992 fprintf_unfiltered (gdb_stdlog,
07c138c8
GB
2993 "target_fileio_readlink (%d,%s)"
2994 " = %s (%d)\n",
2995 inf == NULL ? 0 : inf->num,
b9e7b9c3
UW
2996 filename, ret? ret : "(nil)",
2997 ret? 0 : *target_errno);
2998 return ret;
2999 }
3000 }
3001
3002 *target_errno = FILEIO_ENOSYS;
3003 return NULL;
3004}
3005
7313baad
UW
3006static void
3007target_fileio_close_cleanup (void *opaque)
3008{
3009 int fd = *(int *) opaque;
3010 int target_errno;
3011
3012 target_fileio_close (fd, &target_errno);
3013}
3014
07c138c8
GB
3015/* Read target file FILENAME, in the filesystem as seen by INF. If
3016 INF is NULL, use the filesystem seen by the debugger (GDB or, for
3017 remote targets, the remote stub). Store the result in *BUF_P and
3018 return the size of the transferred data. PADDING additional bytes
3019 are available in *BUF_P. This is a helper function for
3020 target_fileio_read_alloc; see the declaration of that function for
3021 more information. */
7313baad 3022
f7af1fcd
JK
3023static LONGEST
3024target_fileio_read_alloc_1 (struct inferior *inf, const char *filename,
3025 gdb_byte **buf_p, int padding)
3026{
3027 struct cleanup *close_cleanup;
db1ff28b
JK
3028 size_t buf_alloc, buf_pos;
3029 gdb_byte *buf;
3030 LONGEST n;
3031 int fd;
3032 int target_errno;
f7af1fcd 3033
db1ff28b
JK
3034 fd = target_fileio_open (inf, filename, FILEIO_O_RDONLY, 0700,
3035 &target_errno);
f7af1fcd
JK
3036 if (fd == -1)
3037 return -1;
3038
3039 close_cleanup = make_cleanup (target_fileio_close_cleanup, &fd);
db1ff28b
JK
3040
3041 /* Start by reading up to 4K at a time. The target will throttle
3042 this number down if necessary. */
3043 buf_alloc = 4096;
3044 buf = xmalloc (buf_alloc);
3045 buf_pos = 0;
3046 while (1)
3047 {
3048 n = target_fileio_pread (fd, &buf[buf_pos],
3049 buf_alloc - buf_pos - padding, buf_pos,
3050 &target_errno);
3051 if (n < 0)
3052 {
3053 /* An error occurred. */
3054 do_cleanups (close_cleanup);
3055 xfree (buf);
3056 return -1;
3057 }
3058 else if (n == 0)
3059 {
3060 /* Read all there was. */
3061 do_cleanups (close_cleanup);
3062 if (buf_pos == 0)
3063 xfree (buf);
3064 else
3065 *buf_p = buf;
3066 return buf_pos;
3067 }
3068
3069 buf_pos += n;
3070
3071 /* If the buffer is filling up, expand it. */
3072 if (buf_alloc < buf_pos * 2)
3073 {
3074 buf_alloc *= 2;
3075 buf = xrealloc (buf, buf_alloc);
3076 }
3077
3078 QUIT;
3079 }
f7af1fcd
JK
3080}
3081
12e2a5fd 3082/* See target.h. */
7313baad
UW
3083
3084LONGEST
07c138c8
GB
3085target_fileio_read_alloc (struct inferior *inf, const char *filename,
3086 gdb_byte **buf_p)
7313baad 3087{
07c138c8 3088 return target_fileio_read_alloc_1 (inf, filename, buf_p, 0);
7313baad
UW
3089}
3090
db1ff28b 3091/* See target.h. */
f7af1fcd
JK
3092
3093char *
3094target_fileio_read_stralloc (struct inferior *inf, const char *filename)
3095{
db1ff28b
JK
3096 gdb_byte *buffer;
3097 char *bufstr;
3098 LONGEST i, transferred;
3099
3100 transferred = target_fileio_read_alloc_1 (inf, filename, &buffer, 1);
3101 bufstr = (char *) buffer;
3102
3103 if (transferred < 0)
3104 return NULL;
3105
3106 if (transferred == 0)
3107 return xstrdup ("");
3108
3109 bufstr[transferred] = 0;
3110
3111 /* Check for embedded NUL bytes; but allow trailing NULs. */
3112 for (i = strlen (bufstr); i < transferred; i++)
3113 if (bufstr[i] != 0)
3114 {
3115 warning (_("target file %s "
3116 "contained unexpected null characters"),
3117 filename);
3118 break;
3119 }
3120
3121 return bufstr;
f7af1fcd 3122}
7313baad 3123
db1ff28b 3124
e0d24f8d 3125static int
31568a15
TT
3126default_region_ok_for_hw_watchpoint (struct target_ops *self,
3127 CORE_ADDR addr, int len)
e0d24f8d 3128{
f5656ead 3129 return (len <= gdbarch_ptr_bit (target_gdbarch ()) / TARGET_CHAR_BIT);
ccaa32c7
GS
3130}
3131
5009afc5
AS
3132static int
3133default_watchpoint_addr_within_range (struct target_ops *target,
3134 CORE_ADDR addr,
3135 CORE_ADDR start, int length)
3136{
3137 return addr >= start && addr < start + length;
3138}
3139
c2250ad1
UW
3140static struct gdbarch *
3141default_thread_architecture (struct target_ops *ops, ptid_t ptid)
3142{
f5656ead 3143 return target_gdbarch ();
c2250ad1
UW
3144}
3145
c906108c 3146static int
555bbdeb
TT
3147return_zero (struct target_ops *ignore)
3148{
3149 return 0;
3150}
3151
3152static int
3153return_zero_has_execution (struct target_ops *ignore, ptid_t ignore2)
c906108c
SS
3154{
3155 return 0;
3156}
3157
ed9a39eb
JM
3158/*
3159 * Find the next target down the stack from the specified target.
3160 */
3161
3162struct target_ops *
fba45db2 3163find_target_beneath (struct target_ops *t)
ed9a39eb 3164{
258b763a 3165 return t->beneath;
ed9a39eb
JM
3166}
3167
8b06beed
TT
3168/* See target.h. */
3169
3170struct target_ops *
3171find_target_at (enum strata stratum)
3172{
3173 struct target_ops *t;
3174
3175 for (t = current_target.beneath; t != NULL; t = t->beneath)
3176 if (t->to_stratum == stratum)
3177 return t;
3178
3179 return NULL;
3180}
3181
c906108c
SS
3182\f
3183/* The inferior process has died. Long live the inferior! */
3184
3185void
fba45db2 3186generic_mourn_inferior (void)
c906108c 3187{
7f9f62ba 3188 ptid_t ptid;
c906108c 3189
7f9f62ba 3190 ptid = inferior_ptid;
39f77062 3191 inferior_ptid = null_ptid;
7f9f62ba 3192
f59f708a
PA
3193 /* Mark breakpoints uninserted in case something tries to delete a
3194 breakpoint while we delete the inferior's threads (which would
3195 fail, since the inferior is long gone). */
3196 mark_breakpoints_out ();
3197
7f9f62ba
PA
3198 if (!ptid_equal (ptid, null_ptid))
3199 {
3200 int pid = ptid_get_pid (ptid);
6c95b8df 3201 exit_inferior (pid);
7f9f62ba
PA
3202 }
3203
f59f708a
PA
3204 /* Note this wipes step-resume breakpoints, so needs to be done
3205 after exit_inferior, which ends up referencing the step-resume
3206 breakpoints through clear_thread_inferior_resources. */
c906108c 3207 breakpoint_init_inferior (inf_exited);
f59f708a 3208
c906108c
SS
3209 registers_changed ();
3210
c906108c
SS
3211 reopen_exec_file ();
3212 reinit_frame_cache ();
3213
9a4105ab
AC
3214 if (deprecated_detach_hook)
3215 deprecated_detach_hook ();
c906108c
SS
3216}
3217\f
fd0a2a6f
MK
3218/* Convert a normal process ID to a string. Returns the string in a
3219 static buffer. */
c906108c
SS
3220
3221char *
39f77062 3222normal_pid_to_str (ptid_t ptid)
c906108c 3223{
fd0a2a6f 3224 static char buf[32];
c906108c 3225
5fff8fc0 3226 xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
c906108c
SS
3227 return buf;
3228}
3229
2c0b251b 3230static char *
770234d3 3231default_pid_to_str (struct target_ops *ops, ptid_t ptid)
117de6a9
PA
3232{
3233 return normal_pid_to_str (ptid);
3234}
3235
9b4eba8e
HZ
3236/* Error-catcher for target_find_memory_regions. */
3237static int
2e73927c
TT
3238dummy_find_memory_regions (struct target_ops *self,
3239 find_memory_region_ftype ignore1, void *ignore2)
be4d1333 3240{
9b4eba8e 3241 error (_("Command not implemented for this target."));
be4d1333
MS
3242 return 0;
3243}
3244
9b4eba8e
HZ
3245/* Error-catcher for target_make_corefile_notes. */
3246static char *
fc6691b2
TT
3247dummy_make_corefile_notes (struct target_ops *self,
3248 bfd *ignore1, int *ignore2)
be4d1333 3249{
9b4eba8e 3250 error (_("Command not implemented for this target."));
be4d1333
MS
3251 return NULL;
3252}
3253
c906108c
SS
3254/* Set up the handful of non-empty slots needed by the dummy target
3255 vector. */
3256
3257static void
fba45db2 3258init_dummy_target (void)
c906108c
SS
3259{
3260 dummy_target.to_shortname = "None";
3261 dummy_target.to_longname = "None";
3262 dummy_target.to_doc = "";
03583c20
UW
3263 dummy_target.to_supports_disable_randomization
3264 = find_default_supports_disable_randomization;
c906108c 3265 dummy_target.to_stratum = dummy_stratum;
555bbdeb
TT
3266 dummy_target.to_has_all_memory = return_zero;
3267 dummy_target.to_has_memory = return_zero;
3268 dummy_target.to_has_stack = return_zero;
3269 dummy_target.to_has_registers = return_zero;
3270 dummy_target.to_has_execution = return_zero_has_execution;
c906108c 3271 dummy_target.to_magic = OPS_MAGIC;
1101cb7b
TT
3272
3273 install_dummy_methods (&dummy_target);
c906108c 3274}
c906108c 3275\f
c906108c 3276
f1c07ab0 3277void
460014f5 3278target_close (struct target_ops *targ)
f1c07ab0 3279{
7fdc1521
TT
3280 gdb_assert (!target_is_pushed (targ));
3281
f1c07ab0 3282 if (targ->to_xclose != NULL)
460014f5 3283 targ->to_xclose (targ);
f1c07ab0 3284 else if (targ->to_close != NULL)
de90e03d 3285 targ->to_close (targ);
947b8855
PA
3286
3287 if (targetdebug)
460014f5 3288 fprintf_unfiltered (gdb_stdlog, "target_close ()\n");
f1c07ab0
AC
3289}
3290
28439f5e
PA
3291int
3292target_thread_alive (ptid_t ptid)
c906108c 3293{
a7068b60 3294 return current_target.to_thread_alive (&current_target, ptid);
28439f5e
PA
3295}
3296
3297void
e8032dde 3298target_update_thread_list (void)
28439f5e 3299{
e8032dde 3300 current_target.to_update_thread_list (&current_target);
c906108c
SS
3301}
3302
d914c394
SS
3303void
3304target_stop (ptid_t ptid)
3305{
3306 if (!may_stop)
3307 {
3308 warning (_("May not interrupt or stop the target, ignoring attempt"));
3309 return;
3310 }
3311
1eab8a48 3312 (*current_target.to_stop) (&current_target, ptid);
d914c394
SS
3313}
3314
bfedc46a
PA
3315void
3316target_interrupt (ptid_t ptid)
3317{
3318 if (!may_stop)
3319 {
3320 warning (_("May not interrupt or stop the target, ignoring attempt"));
3321 return;
3322 }
3323
3324 (*current_target.to_interrupt) (&current_target, ptid);
3325}
3326
abc56d60
PA
3327/* See target.h. */
3328
3329void
3330target_check_pending_interrupt (void)
3331{
3332 (*current_target.to_check_pending_interrupt) (&current_target);
3333}
3334
f8c1d06b
GB
3335/* See target/target.h. */
3336
3337void
03f4463b 3338target_stop_and_wait (ptid_t ptid)
f8c1d06b
GB
3339{
3340 struct target_waitstatus status;
3341 int was_non_stop = non_stop;
3342
3343 non_stop = 1;
3344 target_stop (ptid);
3345
3346 memset (&status, 0, sizeof (status));
3347 target_wait (ptid, &status, 0);
3348
3349 non_stop = was_non_stop;
3350}
3351
3352/* See target/target.h. */
3353
3354void
03f4463b 3355target_continue_no_signal (ptid_t ptid)
f8c1d06b
GB
3356{
3357 target_resume (ptid, 0, GDB_SIGNAL_0);
3358}
3359
09826ec5
PA
3360/* Concatenate ELEM to LIST, a comma separate list, and return the
3361 result. The LIST incoming argument is released. */
3362
3363static char *
3364str_comma_list_concat_elem (char *list, const char *elem)
3365{
3366 if (list == NULL)
3367 return xstrdup (elem);
3368 else
3369 return reconcat (list, list, ", ", elem, (char *) NULL);
3370}
3371
3372/* Helper for target_options_to_string. If OPT is present in
3373 TARGET_OPTIONS, append the OPT_STR (string version of OPT) in RET.
3374 Returns the new resulting string. OPT is removed from
3375 TARGET_OPTIONS. */
3376
3377static char *
3378do_option (int *target_options, char *ret,
3379 int opt, char *opt_str)
3380{
3381 if ((*target_options & opt) != 0)
3382 {
3383 ret = str_comma_list_concat_elem (ret, opt_str);
3384 *target_options &= ~opt;
3385 }
3386
3387 return ret;
3388}
3389
3390char *
3391target_options_to_string (int target_options)
3392{
3393 char *ret = NULL;
3394
3395#define DO_TARG_OPTION(OPT) \
3396 ret = do_option (&target_options, ret, OPT, #OPT)
3397
3398 DO_TARG_OPTION (TARGET_WNOHANG);
3399
3400 if (target_options != 0)
3401 ret = str_comma_list_concat_elem (ret, "unknown???");
3402
3403 if (ret == NULL)
3404 ret = xstrdup ("");
3405 return ret;
3406}
3407
bf0c5130 3408static void
56be3814
UW
3409debug_print_register (const char * func,
3410 struct regcache *regcache, int regno)
bf0c5130 3411{
f8d29908 3412 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5d502164 3413
bf0c5130 3414 fprintf_unfiltered (gdb_stdlog, "%s ", func);
f8d29908 3415 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
f8d29908
UW
3416 && gdbarch_register_name (gdbarch, regno) != NULL
3417 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
3418 fprintf_unfiltered (gdb_stdlog, "(%s)",
3419 gdbarch_register_name (gdbarch, regno));
bf0c5130
AC
3420 else
3421 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
0ff58721 3422 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
bf0c5130 3423 {
e17a4113 3424 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
f8d29908 3425 int i, size = register_size (gdbarch, regno);
e362b510 3426 gdb_byte buf[MAX_REGISTER_SIZE];
5d502164 3427
0ff58721 3428 regcache_raw_collect (regcache, regno, buf);
bf0c5130 3429 fprintf_unfiltered (gdb_stdlog, " = ");
81c4a259 3430 for (i = 0; i < size; i++)
bf0c5130
AC
3431 {
3432 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
3433 }
81c4a259 3434 if (size <= sizeof (LONGEST))
bf0c5130 3435 {
e17a4113 3436 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
5d502164 3437
0b1553bc
UW
3438 fprintf_unfiltered (gdb_stdlog, " %s %s",
3439 core_addr_to_string_nz (val), plongest (val));
bf0c5130
AC
3440 }
3441 }
3442 fprintf_unfiltered (gdb_stdlog, "\n");
3443}
3444
28439f5e
PA
3445void
3446target_fetch_registers (struct regcache *regcache, int regno)
c906108c 3447{
ad5989bd
TT
3448 current_target.to_fetch_registers (&current_target, regcache, regno);
3449 if (targetdebug)
3450 debug_print_register ("target_fetch_registers", regcache, regno);
c906108c
SS
3451}
3452
28439f5e
PA
3453void
3454target_store_registers (struct regcache *regcache, int regno)
c906108c 3455{
28439f5e 3456 struct target_ops *t;
5d502164 3457
d914c394
SS
3458 if (!may_write_registers)
3459 error (_("Writing to registers is not allowed (regno %d)"), regno);
3460
6b84065d
TT
3461 current_target.to_store_registers (&current_target, regcache, regno);
3462 if (targetdebug)
28439f5e 3463 {
6b84065d 3464 debug_print_register ("target_store_registers", regcache, regno);
28439f5e 3465 }
c906108c
SS
3466}
3467
dc146f7c
VP
3468int
3469target_core_of_thread (ptid_t ptid)
3470{
a7068b60 3471 return current_target.to_core_of_thread (&current_target, ptid);
dc146f7c
VP
3472}
3473
936d2992
PA
3474int
3475simple_verify_memory (struct target_ops *ops,
3476 const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
3477{
3478 LONGEST total_xfered = 0;
3479
3480 while (total_xfered < size)
3481 {
3482 ULONGEST xfered_len;
3483 enum target_xfer_status status;
3484 gdb_byte buf[1024];
3485 ULONGEST howmuch = min (sizeof (buf), size - total_xfered);
3486
3487 status = target_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
3488 buf, NULL, lma + total_xfered, howmuch,
3489 &xfered_len);
3490 if (status == TARGET_XFER_OK
3491 && memcmp (data + total_xfered, buf, xfered_len) == 0)
3492 {
3493 total_xfered += xfered_len;
3494 QUIT;
3495 }
3496 else
3497 return 0;
3498 }
3499 return 1;
3500}
3501
3502/* Default implementation of memory verification. */
3503
3504static int
3505default_verify_memory (struct target_ops *self,
3506 const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3507{
3508 /* Start over from the top of the target stack. */
3509 return simple_verify_memory (current_target.beneath,
3510 data, memaddr, size);
3511}
3512
4a5e7a5b
PA
3513int
3514target_verify_memory (const gdb_byte *data, CORE_ADDR memaddr, ULONGEST size)
3515{
a7068b60
TT
3516 return current_target.to_verify_memory (&current_target,
3517 data, memaddr, size);
4a5e7a5b
PA
3518}
3519
9c06b0b4
TJB
3520/* The documentation for this function is in its prototype declaration in
3521 target.h. */
3522
3523int
3524target_insert_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3525{
a7068b60
TT
3526 return current_target.to_insert_mask_watchpoint (&current_target,
3527 addr, mask, rw);
9c06b0b4
TJB
3528}
3529
3530/* The documentation for this function is in its prototype declaration in
3531 target.h. */
3532
3533int
3534target_remove_mask_watchpoint (CORE_ADDR addr, CORE_ADDR mask, int rw)
3535{
a7068b60
TT
3536 return current_target.to_remove_mask_watchpoint (&current_target,
3537 addr, mask, rw);
9c06b0b4
TJB
3538}
3539
3540/* The documentation for this function is in its prototype declaration
3541 in target.h. */
3542
3543int
3544target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask)
3545{
6c7e5e5c
TT
3546 return current_target.to_masked_watch_num_registers (&current_target,
3547 addr, mask);
9c06b0b4
TJB
3548}
3549
f1310107
TJB
3550/* The documentation for this function is in its prototype declaration
3551 in target.h. */
3552
3553int
3554target_ranged_break_num_registers (void)
3555{
a134316b 3556 return current_target.to_ranged_break_num_registers (&current_target);
f1310107
TJB
3557}
3558
02d27625
MM
3559/* See target.h. */
3560
043c3577
MM
3561int
3562target_supports_btrace (enum btrace_format format)
3563{
3564 return current_target.to_supports_btrace (&current_target, format);
3565}
3566
3567/* See target.h. */
3568
02d27625 3569struct btrace_target_info *
f4abbc16 3570target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
02d27625 3571{
f4abbc16 3572 return current_target.to_enable_btrace (&current_target, ptid, conf);
02d27625
MM
3573}
3574
3575/* See target.h. */
3576
3577void
3578target_disable_btrace (struct btrace_target_info *btinfo)
3579{
8dc292d3 3580 current_target.to_disable_btrace (&current_target, btinfo);
02d27625
MM
3581}
3582
3583/* See target.h. */
3584
3585void
3586target_teardown_btrace (struct btrace_target_info *btinfo)
3587{
9ace480d 3588 current_target.to_teardown_btrace (&current_target, btinfo);
02d27625
MM
3589}
3590
3591/* See target.h. */
3592
969c39fb 3593enum btrace_error
734b0e4b 3594target_read_btrace (struct btrace_data *btrace,
969c39fb 3595 struct btrace_target_info *btinfo,
02d27625
MM
3596 enum btrace_read_type type)
3597{
eb5b20d4 3598 return current_target.to_read_btrace (&current_target, btrace, btinfo, type);
02d27625
MM
3599}
3600
d02ed0bb
MM
3601/* See target.h. */
3602
f4abbc16
MM
3603const struct btrace_config *
3604target_btrace_conf (const struct btrace_target_info *btinfo)
3605{
3606 return current_target.to_btrace_conf (&current_target, btinfo);
3607}
3608
3609/* See target.h. */
3610
7c1687a9
MM
3611void
3612target_stop_recording (void)
3613{
ee97f592 3614 current_target.to_stop_recording (&current_target);
7c1687a9
MM
3615}
3616
3617/* See target.h. */
3618
d02ed0bb 3619void
85e1311a 3620target_save_record (const char *filename)
d02ed0bb 3621{
f09e2107 3622 current_target.to_save_record (&current_target, filename);
d02ed0bb
MM
3623}
3624
3625/* See target.h. */
3626
3627int
3628target_supports_delete_record (void)
3629{
3630 struct target_ops *t;
3631
3632 for (t = current_target.beneath; t != NULL; t = t->beneath)
b0ed115f
TT
3633 if (t->to_delete_record != delegate_delete_record
3634 && t->to_delete_record != tdefault_delete_record)
d02ed0bb
MM
3635 return 1;
3636
3637 return 0;
3638}
3639
3640/* See target.h. */
3641
3642void
3643target_delete_record (void)
3644{
07366925 3645 current_target.to_delete_record (&current_target);
d02ed0bb
MM
3646}
3647
3648/* See target.h. */
3649
3650int
3651target_record_is_replaying (void)
3652{
dd2e9d25 3653 return current_target.to_record_is_replaying (&current_target);
d02ed0bb
MM
3654}
3655
3656/* See target.h. */
3657
3658void
3659target_goto_record_begin (void)
3660{
671e76cc 3661 current_target.to_goto_record_begin (&current_target);
d02ed0bb
MM
3662}
3663
3664/* See target.h. */
3665
3666void
3667target_goto_record_end (void)
3668{
e9179bb3 3669 current_target.to_goto_record_end (&current_target);
d02ed0bb
MM
3670}
3671
3672/* See target.h. */
3673
3674void
3675target_goto_record (ULONGEST insn)
3676{
05969c84 3677 current_target.to_goto_record (&current_target, insn);
d02ed0bb
MM
3678}
3679
67c86d06
MM
3680/* See target.h. */
3681
3682void
3683target_insn_history (int size, int flags)
3684{
3679abfa 3685 current_target.to_insn_history (&current_target, size, flags);
67c86d06
MM
3686}
3687
3688/* See target.h. */
3689
3690void
3691target_insn_history_from (ULONGEST from, int size, int flags)
3692{
8444ab58 3693 current_target.to_insn_history_from (&current_target, from, size, flags);
67c86d06
MM
3694}
3695
3696/* See target.h. */
3697
3698void
3699target_insn_history_range (ULONGEST begin, ULONGEST end, int flags)
3700{
c29302cc 3701 current_target.to_insn_history_range (&current_target, begin, end, flags);
67c86d06
MM
3702}
3703
15984c13
MM
3704/* See target.h. */
3705
3706void
3707target_call_history (int size, int flags)
3708{
170049d4 3709 current_target.to_call_history (&current_target, size, flags);
15984c13
MM
3710}
3711
3712/* See target.h. */
3713
3714void
3715target_call_history_from (ULONGEST begin, int size, int flags)
3716{
16fc27d6 3717 current_target.to_call_history_from (&current_target, begin, size, flags);
15984c13
MM
3718}
3719
3720/* See target.h. */
3721
3722void
3723target_call_history_range (ULONGEST begin, ULONGEST end, int flags)
3724{
115d9817 3725 current_target.to_call_history_range (&current_target, begin, end, flags);
15984c13
MM
3726}
3727
ea001bdc
MM
3728/* See target.h. */
3729
3730const struct frame_unwind *
3731target_get_unwinder (void)
3732{
ac01945b 3733 return current_target.to_get_unwinder (&current_target);
ea001bdc
MM
3734}
3735
3736/* See target.h. */
3737
3738const struct frame_unwind *
3739target_get_tailcall_unwinder (void)
3740{
ac01945b 3741 return current_target.to_get_tailcall_unwinder (&current_target);
ea001bdc
MM
3742}
3743
5fff78c4
MM
3744/* See target.h. */
3745
3746void
3747target_prepare_to_generate_core (void)
3748{
3749 current_target.to_prepare_to_generate_core (&current_target);
3750}
3751
3752/* See target.h. */
3753
3754void
3755target_done_generating_core (void)
3756{
3757 current_target.to_done_generating_core (&current_target);
3758}
3759
c906108c 3760static void
fba45db2 3761setup_target_debug (void)
c906108c
SS
3762{
3763 memcpy (&debug_target, &current_target, sizeof debug_target);
3764
a7068b60 3765 init_debug_target (&current_target);
c906108c 3766}
c906108c 3767\f
c5aa993b
JM
3768
3769static char targ_desc[] =
3e43a32a
MS
3770"Names of targets and files being debugged.\nShows the entire \
3771stack of targets currently in use (including the exec-file,\n\
c906108c
SS
3772core-file, and process, if any), as well as the symbol file name.";
3773
a53f3625 3774static void
a30bf1f1
TT
3775default_rcmd (struct target_ops *self, const char *command,
3776 struct ui_file *output)
a53f3625
TT
3777{
3778 error (_("\"monitor\" command not supported by this target."));
3779}
3780
96baa820
JM
3781static void
3782do_monitor_command (char *cmd,
3783 int from_tty)
3784{
96baa820
JM
3785 target_rcmd (cmd, gdb_stdtarg);
3786}
3787
87680a14
JB
3788/* Print the name of each layers of our target stack. */
3789
3790static void
3791maintenance_print_target_stack (char *cmd, int from_tty)
3792{
3793 struct target_ops *t;
3794
3795 printf_filtered (_("The current target stack is:\n"));
3796
3797 for (t = target_stack; t != NULL; t = t->beneath)
3798 {
3799 printf_filtered (" - %s (%s)\n", t->to_shortname, t->to_longname);
3800 }
3801}
3802
372316f1
PA
3803/* See target.h. */
3804
3805void
3806target_async (int enable)
3807{
3808 infrun_async (enable);
3809 current_target.to_async (&current_target, enable);
3810}
3811
329ea579
PA
3812/* Controls if targets can report that they can/are async. This is
3813 just for maintainers to use when debugging gdb. */
3814int target_async_permitted = 1;
c6ebd6cf
VP
3815
3816/* The set command writes to this variable. If the inferior is
b5419e49 3817 executing, target_async_permitted is *not* updated. */
329ea579 3818static int target_async_permitted_1 = 1;
c6ebd6cf
VP
3819
3820static void
329ea579
PA
3821maint_set_target_async_command (char *args, int from_tty,
3822 struct cmd_list_element *c)
c6ebd6cf 3823{
c35b1492 3824 if (have_live_inferiors ())
c6ebd6cf
VP
3825 {
3826 target_async_permitted_1 = target_async_permitted;
3827 error (_("Cannot change this setting while the inferior is running."));
3828 }
3829
3830 target_async_permitted = target_async_permitted_1;
3831}
3832
3833static void
329ea579
PA
3834maint_show_target_async_command (struct ui_file *file, int from_tty,
3835 struct cmd_list_element *c,
3836 const char *value)
c6ebd6cf 3837{
3e43a32a
MS
3838 fprintf_filtered (file,
3839 _("Controlling the inferior in "
3840 "asynchronous mode is %s.\n"), value);
c6ebd6cf
VP
3841}
3842
fbea99ea
PA
3843/* Return true if the target operates in non-stop mode even with "set
3844 non-stop off". */
3845
3846static int
3847target_always_non_stop_p (void)
3848{
3849 return current_target.to_always_non_stop_p (&current_target);
3850}
3851
3852/* See target.h. */
3853
3854int
3855target_is_non_stop_p (void)
3856{
3857 return (non_stop
3858 || target_non_stop_enabled == AUTO_BOOLEAN_TRUE
3859 || (target_non_stop_enabled == AUTO_BOOLEAN_AUTO
3860 && target_always_non_stop_p ()));
3861}
3862
3863/* Controls if targets can report that they always run in non-stop
3864 mode. This is just for maintainers to use when debugging gdb. */
3865enum auto_boolean target_non_stop_enabled = AUTO_BOOLEAN_AUTO;
3866
3867/* The set command writes to this variable. If the inferior is
3868 executing, target_non_stop_enabled is *not* updated. */
3869static enum auto_boolean target_non_stop_enabled_1 = AUTO_BOOLEAN_AUTO;
3870
3871/* Implementation of "maint set target-non-stop". */
3872
3873static void
3874maint_set_target_non_stop_command (char *args, int from_tty,
3875 struct cmd_list_element *c)
3876{
3877 if (have_live_inferiors ())
3878 {
3879 target_non_stop_enabled_1 = target_non_stop_enabled;
3880 error (_("Cannot change this setting while the inferior is running."));
3881 }
3882
3883 target_non_stop_enabled = target_non_stop_enabled_1;
3884}
3885
3886/* Implementation of "maint show target-non-stop". */
3887
3888static void
3889maint_show_target_non_stop_command (struct ui_file *file, int from_tty,
3890 struct cmd_list_element *c,
3891 const char *value)
3892{
3893 if (target_non_stop_enabled == AUTO_BOOLEAN_AUTO)
3894 fprintf_filtered (file,
3895 _("Whether the target is always in non-stop mode "
3896 "is %s (currently %s).\n"), value,
3897 target_always_non_stop_p () ? "on" : "off");
3898 else
3899 fprintf_filtered (file,
3900 _("Whether the target is always in non-stop mode "
3901 "is %s.\n"), value);
3902}
3903
d914c394
SS
3904/* Temporary copies of permission settings. */
3905
3906static int may_write_registers_1 = 1;
3907static int may_write_memory_1 = 1;
3908static int may_insert_breakpoints_1 = 1;
3909static int may_insert_tracepoints_1 = 1;
3910static int may_insert_fast_tracepoints_1 = 1;
3911static int may_stop_1 = 1;
3912
3913/* Make the user-set values match the real values again. */
3914
3915void
3916update_target_permissions (void)
3917{
3918 may_write_registers_1 = may_write_registers;
3919 may_write_memory_1 = may_write_memory;
3920 may_insert_breakpoints_1 = may_insert_breakpoints;
3921 may_insert_tracepoints_1 = may_insert_tracepoints;
3922 may_insert_fast_tracepoints_1 = may_insert_fast_tracepoints;
3923 may_stop_1 = may_stop;
3924}
3925
3926/* The one function handles (most of) the permission flags in the same
3927 way. */
3928
3929static void
3930set_target_permissions (char *args, int from_tty,
3931 struct cmd_list_element *c)
3932{
3933 if (target_has_execution)
3934 {
3935 update_target_permissions ();
3936 error (_("Cannot change this setting while the inferior is running."));
3937 }
3938
3939 /* Make the real values match the user-changed values. */
3940 may_write_registers = may_write_registers_1;
3941 may_insert_breakpoints = may_insert_breakpoints_1;
3942 may_insert_tracepoints = may_insert_tracepoints_1;
3943 may_insert_fast_tracepoints = may_insert_fast_tracepoints_1;
3944 may_stop = may_stop_1;
3945 update_observer_mode ();
3946}
3947
3948/* Set memory write permission independently of observer mode. */
3949
3950static void
3951set_write_memory_permission (char *args, int from_tty,
3952 struct cmd_list_element *c)
3953{
3954 /* Make the real values match the user-changed values. */
3955 may_write_memory = may_write_memory_1;
3956 update_observer_mode ();
3957}
3958
3959
c906108c 3960void
fba45db2 3961initialize_targets (void)
c906108c
SS
3962{
3963 init_dummy_target ();
3964 push_target (&dummy_target);
3965
3966 add_info ("target", target_info, targ_desc);
3967 add_info ("files", target_info, targ_desc);
3968
ccce17b0 3969 add_setshow_zuinteger_cmd ("target", class_maintenance, &targetdebug, _("\
85c07804
AC
3970Set target debugging."), _("\
3971Show target debugging."), _("\
333dabeb 3972When non-zero, target debugging is enabled. Higher numbers are more\n\
3cecbbbe
TT
3973verbose."),
3974 set_targetdebug,
ccce17b0
YQ
3975 show_targetdebug,
3976 &setdebuglist, &showdebuglist);
3a11626d 3977
2bc416ba 3978 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
7915a72c
AC
3979 &trust_readonly, _("\
3980Set mode for reading from readonly sections."), _("\
3981Show mode for reading from readonly sections."), _("\
3a11626d
MS
3982When this mode is on, memory reads from readonly sections (such as .text)\n\
3983will be read from the object file instead of from the target. This will\n\
7915a72c 3984result in significant performance improvement for remote targets."),
2c5b56ce 3985 NULL,
920d2a44 3986 show_trust_readonly,
e707bbc2 3987 &setlist, &showlist);
96baa820
JM
3988
3989 add_com ("monitor", class_obscure, do_monitor_command,
1bedd215 3990 _("Send a command to the remote monitor (remote targets only)."));
96baa820 3991
87680a14
JB
3992 add_cmd ("target-stack", class_maintenance, maintenance_print_target_stack,
3993 _("Print the name of each layer of the internal target stack."),
3994 &maintenanceprintlist);
3995
c6ebd6cf
VP
3996 add_setshow_boolean_cmd ("target-async", no_class,
3997 &target_async_permitted_1, _("\
3998Set whether gdb controls the inferior in asynchronous mode."), _("\
3999Show whether gdb controls the inferior in asynchronous mode."), _("\
4000Tells gdb whether to control the inferior in asynchronous mode."),
329ea579
PA
4001 maint_set_target_async_command,
4002 maint_show_target_async_command,
4003 &maintenance_set_cmdlist,
4004 &maintenance_show_cmdlist);
c6ebd6cf 4005
fbea99ea
PA
4006 add_setshow_auto_boolean_cmd ("target-non-stop", no_class,
4007 &target_non_stop_enabled_1, _("\
4008Set whether gdb always controls the inferior in non-stop mode."), _("\
4009Show whether gdb always controls the inferior in non-stop mode."), _("\
4010Tells gdb whether to control the inferior in non-stop mode."),
4011 maint_set_target_non_stop_command,
4012 maint_show_target_non_stop_command,
4013 &maintenance_set_cmdlist,
4014 &maintenance_show_cmdlist);
4015
d914c394
SS
4016 add_setshow_boolean_cmd ("may-write-registers", class_support,
4017 &may_write_registers_1, _("\
4018Set permission to write into registers."), _("\
4019Show permission to write into registers."), _("\
4020When this permission is on, GDB may write into the target's registers.\n\
4021Otherwise, any sort of write attempt will result in an error."),
4022 set_target_permissions, NULL,
4023 &setlist, &showlist);
4024
4025 add_setshow_boolean_cmd ("may-write-memory", class_support,
4026 &may_write_memory_1, _("\
4027Set permission to write into target memory."), _("\
4028Show permission to write into target memory."), _("\
4029When this permission is on, GDB may write into the target's memory.\n\
4030Otherwise, any sort of write attempt will result in an error."),
4031 set_write_memory_permission, NULL,
4032 &setlist, &showlist);
4033
4034 add_setshow_boolean_cmd ("may-insert-breakpoints", class_support,
4035 &may_insert_breakpoints_1, _("\
4036Set permission to insert breakpoints in the target."), _("\
4037Show permission to insert breakpoints in the target."), _("\
4038When this permission is on, GDB may insert breakpoints in the program.\n\
4039Otherwise, any sort of insertion attempt will result in an error."),
4040 set_target_permissions, NULL,
4041 &setlist, &showlist);
4042
4043 add_setshow_boolean_cmd ("may-insert-tracepoints", class_support,
4044 &may_insert_tracepoints_1, _("\
4045Set permission to insert tracepoints in the target."), _("\
4046Show permission to insert tracepoints in the target."), _("\
4047When this permission is on, GDB may insert tracepoints in the program.\n\
4048Otherwise, any sort of insertion attempt will result in an error."),
4049 set_target_permissions, NULL,
4050 &setlist, &showlist);
4051
4052 add_setshow_boolean_cmd ("may-insert-fast-tracepoints", class_support,
4053 &may_insert_fast_tracepoints_1, _("\
4054Set permission to insert fast tracepoints in the target."), _("\
4055Show permission to insert fast tracepoints in the target."), _("\
4056When this permission is on, GDB may insert fast tracepoints.\n\
4057Otherwise, any sort of insertion attempt will result in an error."),
4058 set_target_permissions, NULL,
4059 &setlist, &showlist);
4060
4061 add_setshow_boolean_cmd ("may-interrupt", class_support,
4062 &may_stop_1, _("\
4063Set permission to interrupt or signal the target."), _("\
4064Show permission to interrupt or signal the target."), _("\
4065When this permission is on, GDB may interrupt/stop the target's execution.\n\
4066Otherwise, any attempt to interrupt or stop will be ignored."),
4067 set_target_permissions, NULL,
4068 &setlist, &showlist);
6a3cb8e8
PA
4069
4070 add_setshow_boolean_cmd ("auto-connect-native-target", class_support,
4071 &auto_connect_native_target, _("\
4072Set whether GDB may automatically connect to the native target."), _("\
4073Show whether GDB may automatically connect to the native target."), _("\
4074When on, and GDB is not connected to a target yet, GDB\n\
4075attempts \"run\" and other commands with the native target."),
4076 NULL, show_auto_connect_native_target,
4077 &setlist, &showlist);
c906108c 4078}