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