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