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