gdb/target.c

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