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