gdb/target.c

   1 /* Select target systems and architectures at runtime for GDB.
   2
   3    Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   5    Free Software Foundation, Inc.
   6
   7    Contributed by Cygnus Support.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  24    Boston, MA 02110-1301, USA.  */
  25
  26 #include "defs.h"
  27 #include <errno.h>
  28 #include "gdb_string.h"
  29 #include "target.h"
  30 #include "gdbcmd.h"
  31 #include "symtab.h"
  32 #include "inferior.h"
  33 #include "bfd.h"
  34 #include "symfile.h"
  35 #include "objfiles.h"
  36 #include "gdb_wait.h"
  37 #include "dcache.h"
  38 #include <signal.h>
  39 #include "regcache.h"
  40 #include "gdb_assert.h"
  41 #include "gdbcore.h"
  42
  43 static void target_info (char *, int);
  44
  45 static void maybe_kill_then_attach (char *, int);
  46
  47 static void kill_or_be_killed (int);
  48
  49 static void default_terminal_info (char *, int);
  50
  51 static int default_region_ok_for_hw_watchpoint (CORE_ADDR, int);
  52
  53 static int nosymbol (char *, CORE_ADDR *);
  54
  55 static void tcomplain (void);
  56
  57 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
  58
  59 static int return_zero (void);
  60
  61 static int return_one (void);
  62
  63 static int return_minus_one (void);
  64
  65 void target_ignore (void);
  66
  67 static void target_command (char *, int);
  68
  69 static struct target_ops *find_default_run_target (char *);
  70
  71 static void nosupport_runtime (void);
  72
  73 static LONGEST default_xfer_partial (struct target_ops *ops,
  74                                      enum target_object object,
  75                                      const char *annex, gdb_byte *readbuf,
  76                                      const gdb_byte *writebuf,
  77                                      ULONGEST offset, LONGEST len);
  78
  79 /* Transfer LEN bytes between target address MEMADDR and GDB address
  80    MYADDR.  Returns 0 for success, errno code for failure (which
  81    includes partial transfers -- if you want a more useful response to
  82    partial transfers, try either target_read_memory_partial or
  83    target_write_memory_partial).  */
  84
  85 static int target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
  86                                int write);
  87
  88 static void init_dummy_target (void);
  89
  90 static struct target_ops debug_target;
  91
  92 static void debug_to_open (char *, int);
  93
  94 static void debug_to_close (int);
  95
  96 static void debug_to_attach (char *, int);
  97
  98 static void debug_to_detach (char *, int);
  99
 100 static void debug_to_resume (ptid_t, int, enum target_signal);
 101
 102 static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
 103
 104 static void debug_to_fetch_registers (int);
 105
 106 static void debug_to_store_registers (int);
 107
 108 static void debug_to_prepare_to_store (void);
 109
 110 static void debug_to_files_info (struct target_ops *);
 111
 112 static int debug_to_insert_breakpoint (struct bp_target_info *);
 113
 114 static int debug_to_remove_breakpoint (struct bp_target_info *);
 115
 116 static int debug_to_can_use_hw_breakpoint (int, int, int);
 117
 118 static int debug_to_insert_hw_breakpoint (struct bp_target_info *);
 119
 120 static int debug_to_remove_hw_breakpoint (struct bp_target_info *);
 121
 122 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
 123
 124 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
 125
 126 static int debug_to_stopped_by_watchpoint (void);
 127
 128 static int debug_to_stopped_data_address (struct target_ops *, CORE_ADDR *);
 129
 130 static int debug_to_region_ok_for_hw_watchpoint (CORE_ADDR, int);
 131
 132 static void debug_to_terminal_init (void);
 133
 134 static void debug_to_terminal_inferior (void);
 135
 136 static void debug_to_terminal_ours_for_output (void);
 137
 138 static void debug_to_terminal_save_ours (void);
 139
 140 static void debug_to_terminal_ours (void);
 141
 142 static void debug_to_terminal_info (char *, int);
 143
 144 static void debug_to_kill (void);
 145
 146 static void debug_to_load (char *, int);
 147
 148 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
 149
 150 static void debug_to_mourn_inferior (void);
 151
 152 static int debug_to_can_run (void);
 153
 154 static void debug_to_notice_signals (ptid_t);
 155
 156 static int debug_to_thread_alive (ptid_t);
 157
 158 static void debug_to_stop (void);
 159
 160 /* NOTE: cagney/2004-09-29: Many targets reference this variable in
 161    wierd and mysterious ways.  Putting the variable here lets those
 162    wierd and mysterious ways keep building while they are being
 163    converted to the inferior inheritance structure.  */
 164 struct target_ops deprecated_child_ops;
 165
 166 /* Pointer to array of target architecture structures; the size of the
 167    array; the current index into the array; the allocated size of the
 168    array.  */
 169 struct target_ops **target_structs;
 170 unsigned target_struct_size;
 171 unsigned target_struct_index;
 172 unsigned target_struct_allocsize;
 173 #define DEFAULT_ALLOCSIZE       10
 174
 175 /* The initial current target, so that there is always a semi-valid
 176    current target.  */
 177
 178 static struct target_ops dummy_target;
 179
 180 /* Top of target stack.  */
 181
 182 static struct target_ops *target_stack;
 183
 184 /* The target structure we are currently using to talk to a process
 185    or file or whatever "inferior" we have.  */
 186
 187 struct target_ops current_target;
 188
 189 /* Command list for target.  */
 190
 191 static struct cmd_list_element *targetlist = NULL;
 192
 193 /* Nonzero if we are debugging an attached outside process
 194    rather than an inferior.  */
 195
 196 int attach_flag;
 197
 198 /* Non-zero if we want to see trace of target level stuff.  */
 199
 200 static int targetdebug = 0;
 201 static void
 202 show_targetdebug (struct ui_file *file, int from_tty,
 203                   struct cmd_list_element *c, const char *value)
 204 {
 205   fprintf_filtered (file, _("Target debugging is %s.\n"), value);
 206 }
 207
 208 static void setup_target_debug (void);
 209
 210 DCACHE *target_dcache;
 211
 212 /* The user just typed 'target' without the name of a target.  */
 213
 214 static void
 215 target_command (char *arg, int from_tty)
 216 {
 217   fputs_filtered ("Argument required (target name).  Try `help target'\n",
 218                   gdb_stdout);
 219 }
 220
 221 /* Add a possible target architecture to the list.  */
 222
 223 void
 224 add_target (struct target_ops *t)
 225 {
 226   /* Provide default values for all "must have" methods.  */
 227   if (t->to_xfer_partial == NULL)
 228     t->to_xfer_partial = default_xfer_partial;
 229
 230   if (!target_structs)
 231     {
 232       target_struct_allocsize = DEFAULT_ALLOCSIZE;
 233       target_structs = (struct target_ops **) xmalloc
 234         (target_struct_allocsize * sizeof (*target_structs));
 235     }
 236   if (target_struct_size >= target_struct_allocsize)
 237     {
 238       target_struct_allocsize *= 2;
 239       target_structs = (struct target_ops **)
 240         xrealloc ((char *) target_structs,
 241                   target_struct_allocsize * sizeof (*target_structs));
 242     }
 243   target_structs[target_struct_size++] = t;
 244
 245   if (targetlist == NULL)
 246     add_prefix_cmd ("target", class_run, target_command, _("\
 247 Connect to a target machine or process.\n\
 248 The first argument is the type or protocol of the target machine.\n\
 249 Remaining arguments are interpreted by the target protocol.  For more\n\
 250 information on the arguments for a particular protocol, type\n\
 251 `help target ' followed by the protocol name."),
 252                     &targetlist, "target ", 0, &cmdlist);
 253   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
 254 }
 255
 256 /* Stub functions */
 257
 258 void
 259 target_ignore (void)
 260 {
 261 }
 262
 263 void
 264 target_load (char *arg, int from_tty)
 265 {
 266   dcache_invalidate (target_dcache);
 267   (*current_target.to_load) (arg, from_tty);
 268 }
 269
 270 static int
 271 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 272           struct target_ops *t)
 273 {
 274   errno = EIO;                  /* Can't read/write this location */
 275   return 0;                     /* No bytes handled */
 276 }
 277
 278 static void
 279 tcomplain (void)
 280 {
 281   error (_("You can't do that when your target is `%s'"),
 282          current_target.to_shortname);
 283 }
 284
 285 void
 286 noprocess (void)
 287 {
 288   error (_("You can't do that without a process to debug."));
 289 }
 290
 291 static int
 292 nosymbol (char *name, CORE_ADDR *addrp)
 293 {
 294   return 1;                     /* Symbol does not exist in target env */
 295 }
 296
 297 static void
 298 nosupport_runtime (void)
 299 {
 300   if (ptid_equal (inferior_ptid, null_ptid))
 301     noprocess ();
 302   else
 303     error (_("No run-time support for this"));
 304 }
 305
 306
 307 static void
 308 default_terminal_info (char *args, int from_tty)
 309 {
 310   printf_unfiltered (_("No saved terminal information.\n"));
 311 }
 312
 313 /* This is the default target_create_inferior and target_attach function.
 314    If the current target is executing, it asks whether to kill it off.
 315    If this function returns without calling error(), it has killed off
 316    the target, and the operation should be attempted.  */
 317
 318 static void
 319 kill_or_be_killed (int from_tty)
 320 {
 321   if (target_has_execution)
 322     {
 323       printf_unfiltered (_("You are already running a program:\n"));
 324       target_files_info ();
 325       if (query ("Kill it? "))
 326         {
 327           target_kill ();
 328           if (target_has_execution)
 329             error (_("Killing the program did not help."));
 330           return;
 331         }
 332       else
 333         {
 334           error (_("Program not killed."));
 335         }
 336     }
 337   tcomplain ();
 338 }
 339
 340 static void
 341 maybe_kill_then_attach (char *args, int from_tty)
 342 {
 343   kill_or_be_killed (from_tty);
 344   target_attach (args, from_tty);
 345 }
 346
 347 static void
 348 maybe_kill_then_create_inferior (char *exec, char *args, char **env,
 349                                  int from_tty)
 350 {
 351   kill_or_be_killed (0);
 352   target_create_inferior (exec, args, env, from_tty);
 353 }
 354
 355 /* Go through the target stack from top to bottom, copying over zero
 356    entries in current_target, then filling in still empty entries.  In
 357    effect, we are doing class inheritance through the pushed target
 358    vectors.
 359
 360    NOTE: cagney/2003-10-17: The problem with this inheritance, as it
 361    is currently implemented, is that it discards any knowledge of
 362    which target an inherited method originally belonged to.
 363    Consequently, new new target methods should instead explicitly and
 364    locally search the target stack for the target that can handle the
 365    request.  */
 366
 367 static void
 368 update_current_target (void)
 369 {
 370   struct target_ops *t;
 371
 372   /* First, reset curren'ts contents.  */
 373   memset (&current_target, 0, sizeof (current_target));
 374
 375 #define INHERIT(FIELD, TARGET) \
 376       if (!current_target.FIELD) \
 377         current_target.FIELD = (TARGET)->FIELD
 378
 379   for (t = target_stack; t; t = t->beneath)
 380     {
 381       INHERIT (to_shortname, t);
 382       INHERIT (to_longname, t);
 383       INHERIT (to_doc, t);
 384       INHERIT (to_open, t);
 385       INHERIT (to_close, t);
 386       INHERIT (to_attach, t);
 387       INHERIT (to_post_attach, t);
 388       INHERIT (to_detach, t);
 389       /* Do not inherit to_disconnect.  */
 390       INHERIT (to_resume, t);
 391       INHERIT (to_wait, t);
 392       INHERIT (to_fetch_registers, t);
 393       INHERIT (to_store_registers, t);
 394       INHERIT (to_prepare_to_store, t);
 395       INHERIT (deprecated_xfer_memory, t);
 396       INHERIT (to_files_info, t);
 397       INHERIT (to_insert_breakpoint, t);
 398       INHERIT (to_remove_breakpoint, t);
 399       INHERIT (to_can_use_hw_breakpoint, t);
 400       INHERIT (to_insert_hw_breakpoint, t);
 401       INHERIT (to_remove_hw_breakpoint, t);
 402       INHERIT (to_insert_watchpoint, t);
 403       INHERIT (to_remove_watchpoint, t);
 404       INHERIT (to_stopped_data_address, t);
 405       INHERIT (to_stopped_by_watchpoint, t);
 406       INHERIT (to_have_continuable_watchpoint, t);
 407       INHERIT (to_region_ok_for_hw_watchpoint, t);
 408       INHERIT (to_terminal_init, t);
 409       INHERIT (to_terminal_inferior, t);
 410       INHERIT (to_terminal_ours_for_output, t);
 411       INHERIT (to_terminal_ours, t);
 412       INHERIT (to_terminal_save_ours, t);
 413       INHERIT (to_terminal_info, t);
 414       INHERIT (to_kill, t);
 415       INHERIT (to_load, t);
 416       INHERIT (to_lookup_symbol, t);
 417       INHERIT (to_create_inferior, t);
 418       INHERIT (to_post_startup_inferior, t);
 419       INHERIT (to_acknowledge_created_inferior, t);
 420       INHERIT (to_insert_fork_catchpoint, t);
 421       INHERIT (to_remove_fork_catchpoint, t);
 422       INHERIT (to_insert_vfork_catchpoint, t);
 423       INHERIT (to_remove_vfork_catchpoint, t);
 424       /* Do not inherit to_follow_fork.  */
 425       INHERIT (to_insert_exec_catchpoint, t);
 426       INHERIT (to_remove_exec_catchpoint, t);
 427       INHERIT (to_reported_exec_events_per_exec_call, t);
 428       INHERIT (to_has_exited, t);
 429       INHERIT (to_mourn_inferior, t);
 430       INHERIT (to_can_run, t);
 431       INHERIT (to_notice_signals, t);
 432       INHERIT (to_thread_alive, t);
 433       INHERIT (to_find_new_threads, t);
 434       INHERIT (to_pid_to_str, t);
 435       INHERIT (to_extra_thread_info, t);
 436       INHERIT (to_stop, t);
 437       /* Do not inherit to_xfer_partial.  */
 438       INHERIT (to_rcmd, t);
 439       INHERIT (to_enable_exception_callback, t);
 440       INHERIT (to_get_current_exception_event, t);
 441       INHERIT (to_pid_to_exec_file, t);
 442       INHERIT (to_stratum, t);
 443       INHERIT (to_has_all_memory, t);
 444       INHERIT (to_has_memory, t);
 445       INHERIT (to_has_stack, t);
 446       INHERIT (to_has_registers, t);
 447       INHERIT (to_has_execution, t);
 448       INHERIT (to_has_thread_control, t);
 449       INHERIT (to_sections, t);
 450       INHERIT (to_sections_end, t);
 451       INHERIT (to_can_async_p, t);
 452       INHERIT (to_is_async_p, t);
 453       INHERIT (to_async, t);
 454       INHERIT (to_async_mask_value, t);
 455       INHERIT (to_find_memory_regions, t);
 456       INHERIT (to_make_corefile_notes, t);
 457       INHERIT (to_get_thread_local_address, t);
 458       INHERIT (to_magic, t);
 459     }
 460 #undef INHERIT
 461
 462   /* Clean up a target struct so it no longer has any zero pointers in
 463      it.  Some entries are defaulted to a method that print an error,
 464      others are hard-wired to a standard recursive default.  */
 465
 466 #define de_fault(field, value) \
 467   if (!current_target.field)               \
 468     current_target.field = value
 469
 470   de_fault (to_open,
 471             (void (*) (char *, int))
 472             tcomplain);
 473   de_fault (to_close,
 474             (void (*) (int))
 475             target_ignore);
 476   de_fault (to_attach,
 477             maybe_kill_then_attach);
 478   de_fault (to_post_attach,
 479             (void (*) (int))
 480             target_ignore);
 481   de_fault (to_detach,
 482             (void (*) (char *, int))
 483             target_ignore);
 484   de_fault (to_resume,
 485             (void (*) (ptid_t, int, enum target_signal))
 486             noprocess);
 487   de_fault (to_wait,
 488             (ptid_t (*) (ptid_t, struct target_waitstatus *))
 489             noprocess);
 490   de_fault (to_fetch_registers,
 491             (void (*) (int))
 492             target_ignore);
 493   de_fault (to_store_registers,
 494             (void (*) (int))
 495             noprocess);
 496   de_fault (to_prepare_to_store,
 497             (void (*) (void))
 498             noprocess);
 499   de_fault (deprecated_xfer_memory,
 500             (int (*) (CORE_ADDR, gdb_byte *, int, int, struct mem_attrib *, struct target_ops *))
 501             nomemory);
 502   de_fault (to_files_info,
 503             (void (*) (struct target_ops *))
 504             target_ignore);
 505   de_fault (to_insert_breakpoint,
 506             memory_insert_breakpoint);
 507   de_fault (to_remove_breakpoint,
 508             memory_remove_breakpoint);
 509   de_fault (to_can_use_hw_breakpoint,
 510             (int (*) (int, int, int))
 511             return_zero);
 512   de_fault (to_insert_hw_breakpoint,
 513             (int (*) (struct bp_target_info *))
 514             return_minus_one);
 515   de_fault (to_remove_hw_breakpoint,
 516             (int (*) (struct bp_target_info *))
 517             return_minus_one);
 518   de_fault (to_insert_watchpoint,
 519             (int (*) (CORE_ADDR, int, int))
 520             return_minus_one);
 521   de_fault (to_remove_watchpoint,
 522             (int (*) (CORE_ADDR, int, int))
 523             return_minus_one);
 524   de_fault (to_stopped_by_watchpoint,
 525             (int (*) (void))
 526             return_zero);
 527   de_fault (to_stopped_data_address,
 528             (int (*) (struct target_ops *, CORE_ADDR *))
 529             return_zero);
 530   de_fault (to_region_ok_for_hw_watchpoint,
 531             default_region_ok_for_hw_watchpoint);
 532   de_fault (to_terminal_init,
 533             (void (*) (void))
 534             target_ignore);
 535   de_fault (to_terminal_inferior,
 536             (void (*) (void))
 537             target_ignore);
 538   de_fault (to_terminal_ours_for_output,
 539             (void (*) (void))
 540             target_ignore);
 541   de_fault (to_terminal_ours,
 542             (void (*) (void))
 543             target_ignore);
 544   de_fault (to_terminal_save_ours,
 545             (void (*) (void))
 546             target_ignore);
 547   de_fault (to_terminal_info,
 548             default_terminal_info);
 549   de_fault (to_kill,
 550             (void (*) (void))
 551             noprocess);
 552   de_fault (to_load,
 553             (void (*) (char *, int))
 554             tcomplain);
 555   de_fault (to_lookup_symbol,
 556             (int (*) (char *, CORE_ADDR *))
 557             nosymbol);
 558   de_fault (to_create_inferior,
 559             maybe_kill_then_create_inferior);
 560   de_fault (to_post_startup_inferior,
 561             (void (*) (ptid_t))
 562             target_ignore);
 563   de_fault (to_acknowledge_created_inferior,
 564             (void (*) (int))
 565             target_ignore);
 566   de_fault (to_insert_fork_catchpoint,
 567             (void (*) (int))
 568             tcomplain);
 569   de_fault (to_remove_fork_catchpoint,
 570             (int (*) (int))
 571             tcomplain);
 572   de_fault (to_insert_vfork_catchpoint,
 573             (void (*) (int))
 574             tcomplain);
 575   de_fault (to_remove_vfork_catchpoint,
 576             (int (*) (int))
 577             tcomplain);
 578   de_fault (to_insert_exec_catchpoint,
 579             (void (*) (int))
 580             tcomplain);
 581   de_fault (to_remove_exec_catchpoint,
 582             (int (*) (int))
 583             tcomplain);
 584   de_fault (to_reported_exec_events_per_exec_call,
 585             (int (*) (void))
 586             return_one);
 587   de_fault (to_has_exited,
 588             (int (*) (int, int, int *))
 589             return_zero);
 590   de_fault (to_mourn_inferior,
 591             (void (*) (void))
 592             noprocess);
 593   de_fault (to_can_run,
 594             return_zero);
 595   de_fault (to_notice_signals,
 596             (void (*) (ptid_t))
 597             target_ignore);
 598   de_fault (to_thread_alive,
 599             (int (*) (ptid_t))
 600             return_zero);
 601   de_fault (to_find_new_threads,
 602             (void (*) (void))
 603             target_ignore);
 604   de_fault (to_extra_thread_info,
 605             (char *(*) (struct thread_info *))
 606             return_zero);
 607   de_fault (to_stop,
 608             (void (*) (void))
 609             target_ignore);
 610   current_target.to_xfer_partial = default_xfer_partial;
 611   de_fault (to_rcmd,
 612             (void (*) (char *, struct ui_file *))
 613             tcomplain);
 614   de_fault (to_enable_exception_callback,
 615             (struct symtab_and_line * (*) (enum exception_event_kind, int))
 616             nosupport_runtime);
 617   de_fault (to_get_current_exception_event,
 618             (struct exception_event_record * (*) (void))
 619             nosupport_runtime);
 620   de_fault (to_pid_to_exec_file,
 621             (char *(*) (int))
 622             return_zero);
 623   de_fault (to_can_async_p,
 624             (int (*) (void))
 625             return_zero);
 626   de_fault (to_is_async_p,
 627             (int (*) (void))
 628             return_zero);
 629   de_fault (to_async,
 630             (void (*) (void (*) (enum inferior_event_type, void*), void*))
 631             tcomplain);
 632 #undef de_fault
 633
 634   /* Finally, position the target-stack beneath the squashed
 635      "current_target".  That way code looking for a non-inherited
 636      target method can quickly and simply find it.  */
 637   current_target.beneath = target_stack;
 638 }
 639
 640 /* Push a new target type into the stack of the existing target accessors,
 641    possibly superseding some of the existing accessors.
 642
 643    Result is zero if the pushed target ended up on top of the stack,
 644    nonzero if at least one target is on top of it.
 645
 646    Rather than allow an empty stack, we always have the dummy target at
 647    the bottom stratum, so we can call the function vectors without
 648    checking them.  */
 649
 650 int
 651 push_target (struct target_ops *t)
 652 {
 653   struct target_ops **cur;
 654
 655   /* Check magic number.  If wrong, it probably means someone changed
 656      the struct definition, but not all the places that initialize one.  */
 657   if (t->to_magic != OPS_MAGIC)
 658     {
 659       fprintf_unfiltered (gdb_stderr,
 660                           "Magic number of %s target struct wrong\n",
 661                           t->to_shortname);
 662       internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 663     }
 664
 665   /* Find the proper stratum to install this target in.  */
 666   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
 667     {
 668       if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
 669         break;
 670     }
 671
 672   /* If there's already targets at this stratum, remove them.  */
 673   /* FIXME: cagney/2003-10-15: I think this should be popping all
 674      targets to CUR, and not just those at this stratum level.  */
 675   while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
 676     {
 677       /* There's already something at this stratum level.  Close it,
 678          and un-hook it from the stack.  */
 679       struct target_ops *tmp = (*cur);
 680       (*cur) = (*cur)->beneath;
 681       tmp->beneath = NULL;
 682       target_close (tmp, 0);
 683     }
 684
 685   /* We have removed all targets in our stratum, now add the new one.  */
 686   t->beneath = (*cur);
 687   (*cur) = t;
 688
 689   update_current_target ();
 690
 691   if (targetdebug)
 692     setup_target_debug ();
 693
 694   /* Not on top?  */
 695   return (t != target_stack);
 696 }
 697
 698 /* Remove a target_ops vector from the stack, wherever it may be.
 699    Return how many times it was removed (0 or 1).  */
 700
 701 int
 702 unpush_target (struct target_ops *t)
 703 {
 704   struct target_ops **cur;
 705   struct target_ops *tmp;
 706
 707   /* Look for the specified target.  Note that we assume that a target
 708      can only occur once in the target stack. */
 709
 710   for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
 711     {
 712       if ((*cur) == t)
 713         break;
 714     }
 715
 716   if ((*cur) == NULL)
 717     return 0;                   /* Didn't find target_ops, quit now */
 718
 719   /* NOTE: cagney/2003-12-06: In '94 the close call was made
 720      unconditional by moving it to before the above check that the
 721      target was in the target stack (something about "Change the way
 722      pushing and popping of targets work to support target overlays
 723      and inheritance").  This doesn't make much sense - only open
 724      targets should be closed.  */
 725   target_close (t, 0);
 726
 727   /* Unchain the target */
 728   tmp = (*cur);
 729   (*cur) = (*cur)->beneath;
 730   tmp->beneath = NULL;
 731
 732   update_current_target ();
 733
 734   return 1;
 735 }
 736
 737 void
 738 pop_target (void)
 739 {
 740   target_close (&current_target, 0);    /* Let it clean up */
 741   if (unpush_target (target_stack) == 1)
 742     return;
 743
 744   fprintf_unfiltered (gdb_stderr,
 745                       "pop_target couldn't find target %s\n",
 746                       current_target.to_shortname);
 747   internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 748 }
 749
 750 #undef  MIN
 751 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
 752
 753 /* target_read_string -- read a null terminated string, up to LEN bytes,
 754    from MEMADDR in target.  Set *ERRNOP to the errno code, or 0 if successful.
 755    Set *STRING to a pointer to malloc'd memory containing the data; the caller
 756    is responsible for freeing it.  Return the number of bytes successfully
 757    read.  */
 758
 759 int
 760 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
 761 {
 762   int tlen, origlen, offset, i;
 763   gdb_byte buf[4];
 764   int errcode = 0;
 765   char *buffer;
 766   int buffer_allocated;
 767   char *bufptr;
 768   unsigned int nbytes_read = 0;
 769
 770   /* Small for testing.  */
 771   buffer_allocated = 4;
 772   buffer = xmalloc (buffer_allocated);
 773   bufptr = buffer;
 774
 775   origlen = len;
 776
 777   while (len > 0)
 778     {
 779       tlen = MIN (len, 4 - (memaddr & 3));
 780       offset = memaddr & 3;
 781
 782       errcode = target_read_memory (memaddr & ~3, buf, sizeof buf);
 783       if (errcode != 0)
 784         {
 785           /* The transfer request might have crossed the boundary to an
 786              unallocated region of memory. Retry the transfer, requesting
 787              a single byte.  */
 788           tlen = 1;
 789           offset = 0;
 790           errcode = target_read_memory (memaddr, buf, 1);
 791           if (errcode != 0)
 792             goto done;
 793         }
 794
 795       if (bufptr - buffer + tlen > buffer_allocated)
 796         {
 797           unsigned int bytes;
 798           bytes = bufptr - buffer;
 799           buffer_allocated *= 2;
 800           buffer = xrealloc (buffer, buffer_allocated);
 801           bufptr = buffer + bytes;
 802         }
 803
 804       for (i = 0; i < tlen; i++)
 805         {
 806           *bufptr++ = buf[i + offset];
 807           if (buf[i + offset] == '\000')
 808             {
 809               nbytes_read += i + 1;
 810               goto done;
 811             }
 812         }
 813
 814       memaddr += tlen;
 815       len -= tlen;
 816       nbytes_read += tlen;
 817     }
 818 done:
 819   if (errnop != NULL)
 820     *errnop = errcode;
 821   if (string != NULL)
 822     *string = buffer;
 823   return nbytes_read;
 824 }
 825
 826 /* Find a section containing ADDR.  */
 827 struct section_table *
 828 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
 829 {
 830   struct section_table *secp;
 831   for (secp = target->to_sections;
 832        secp < target->to_sections_end;
 833        secp++)
 834     {
 835       if (addr >= secp->addr && addr < secp->endaddr)
 836         return secp;
 837     }
 838   return NULL;
 839 }
 840
 841 /* Return non-zero when the target vector has supplied an xfer_partial
 842    method and it, rather than xfer_memory, should be used.  */
 843 static int
 844 target_xfer_partial_p (void)
 845 {
 846   return (target_stack != NULL
 847           && target_stack->to_xfer_partial != default_xfer_partial);
 848 }
 849
 850 static LONGEST
 851 target_xfer_partial (struct target_ops *ops,
 852                      enum target_object object, const char *annex,
 853                      void *readbuf, const void *writebuf,
 854                      ULONGEST offset, LONGEST len)
 855 {
 856   LONGEST retval;
 857
 858   gdb_assert (ops->to_xfer_partial != NULL);
 859   retval = ops->to_xfer_partial (ops, object, annex, readbuf, writebuf,
 860                                  offset, len);
 861   if (targetdebug)
 862     {
 863       const unsigned char *myaddr = NULL;
 864
 865       fprintf_unfiltered (gdb_stdlog,
 866                           "%s:target_xfer_partial (%d, %s, 0x%lx,  0x%lx,  0x%s, %s) = %s",
 867                           ops->to_shortname,
 868                           (int) object,
 869                           (annex ? annex : "(null)"),
 870                           (long) readbuf, (long) writebuf,
 871                           paddr_nz (offset), paddr_d (len), paddr_d (retval));
 872
 873       if (readbuf)
 874         myaddr = readbuf;
 875       if (writebuf)
 876         myaddr = writebuf;
 877       if (retval > 0 && myaddr != NULL)
 878         {
 879           int i;
 880
 881           fputs_unfiltered (", bytes =", gdb_stdlog);
 882           for (i = 0; i < retval; i++)
 883             {
 884               if ((((long) &(myaddr[i])) & 0xf) == 0)
 885                 {
 886                   if (targetdebug < 2 && i > 0)
 887                     {
 888                       fprintf_unfiltered (gdb_stdlog, " ...");
 889                       break;
 890                     }
 891                   fprintf_unfiltered (gdb_stdlog, "\n");
 892                 }
 893
 894               fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
 895             }
 896         }
 897
 898       fputc_unfiltered ('\n', gdb_stdlog);
 899     }
 900   return retval;
 901 }
 902
 903 /* Attempt a transfer all LEN bytes starting at OFFSET between the
 904    inferior's KIND:ANNEX space and GDB's READBUF/WRITEBUF buffer.  If
 905    the transfer succeeds, return zero, otherwize the host ERRNO is
 906    returned.
 907
 908    The inferior is formed from several layers.  In the case of
 909    corefiles, inf-corefile is layered above inf-exec and a request for
 910    text (corefiles do not include text pages) will be first sent to
 911    the core-stratum, fail, and then sent to the object-file where it
 912    will succeed.
 913
 914    NOTE: cagney/2004-09-30:
 915
 916    The old code tried to use four separate mechanisms for mapping an
 917    object:offset:len tuple onto an inferior and its address space: the
 918    target stack; the inferior's TO_SECTIONS; solib's SO_LIST;
 919    overlays.
 920
 921    This is stupid.
 922
 923    The code below is instead using a single mechanism (currently
 924    strata).  If that mechanism proves insufficient then re-factor it
 925    implementing another singluar mechanism (for instance, a generic
 926    object:annex onto inferior:object:annex say).  */
 927
 928 static LONGEST
 929 xfer_using_stratum (enum target_object object, const char *annex,
 930                     ULONGEST offset, LONGEST len, void *readbuf,
 931                     const void *writebuf)
 932 {
 933   LONGEST xfered;
 934   struct target_ops *target;
 935
 936   /* Always successful.  */
 937   if (len == 0)
 938     return 0;
 939   /* Never successful.  */
 940   if (target_stack == NULL)
 941     return EIO;
 942
 943   target = target_stack;
 944   while (1)
 945     {
 946       xfered = target_xfer_partial (target, object, annex,
 947                                     readbuf, writebuf, offset, len);
 948       if (xfered > 0)
 949         {
 950           /* The partial xfer succeeded, update the counts, check that
 951              the xfer hasn't finished and if it hasn't set things up
 952              for the next round.  */
 953           len -= xfered;
 954           if (len <= 0)
 955             return 0;
 956           offset += xfered;
 957           if (readbuf != NULL)
 958             readbuf = (gdb_byte *) readbuf + xfered;
 959           if (writebuf != NULL)
 960             writebuf = (gdb_byte *) writebuf + xfered;
 961           target = target_stack;
 962         }
 963       else if (xfered < 0)
 964         {
 965           /* Something totally screwed up, abandon the attempt to
 966              xfer.  */
 967           if (errno)
 968             return errno;
 969           else
 970             return EIO;
 971         }
 972       else
 973         {
 974           /* This "stratum" didn't work, try the next one down.  */
 975           target = target->beneath;
 976           if (target == NULL)
 977             return EIO;
 978         }
 979     }
 980 }
 981
 982 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
 983    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
 984    if any error occurs.
 985
 986    If an error occurs, no guarantee is made about the contents of the data at
 987    MYADDR.  In particular, the caller should not depend upon partial reads
 988    filling the buffer with good data.  There is no way for the caller to know
 989    how much good data might have been transfered anyway.  Callers that can
 990    deal with partial reads should call target_read_memory_partial. */
 991
 992 int
 993 target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 994 {
 995   if (target_xfer_partial_p ())
 996     return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
 997                                memaddr, len, myaddr, NULL);
 998   else
 999     return target_xfer_memory (memaddr, myaddr, len, 0);
1000 }
1001
1002 int
1003 target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1004 {
1005   gdb_byte *bytes = alloca (len);
1006   memcpy (bytes, myaddr, len);
1007   if (target_xfer_partial_p ())
1008     return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
1009                                memaddr, len, NULL, bytes);
1010   else
1011     return target_xfer_memory (memaddr, bytes, len, 1);
1012 }
1013
1014 #ifndef target_stopped_data_address_p
1015 int
1016 target_stopped_data_address_p (struct target_ops *target)
1017 {
1018   if (target->to_stopped_data_address
1019       == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
1020     return 0;
1021   if (target->to_stopped_data_address == debug_to_stopped_data_address
1022       && (debug_target.to_stopped_data_address
1023           == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1024     return 0;
1025   return 1;
1026 }
1027 #endif
1028
1029 static int trust_readonly = 0;
1030 static void
1031 show_trust_readonly (struct ui_file *file, int from_tty,
1032                      struct cmd_list_element *c, const char *value)
1033 {
1034   fprintf_filtered (file, _("\
1035 Mode for reading from readonly sections is %s.\n"),
1036                     value);
1037 }
1038
1039 /* Move memory to or from the targets.  The top target gets priority;
1040    if it cannot handle it, it is offered to the next one down, etc.
1041
1042    Result is -1 on error, or the number of bytes transfered.  */
1043
1044 int
1045 do_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
1046                 struct mem_attrib *attrib)
1047 {
1048   int res;
1049   int done = 0;
1050   struct target_ops *t;
1051
1052   /* Zero length requests are ok and require no work.  */
1053   if (len == 0)
1054     return 0;
1055
1056   /* deprecated_xfer_memory is not guaranteed to set errno, even when
1057      it returns 0.  */
1058   errno = 0;
1059
1060   if (!write && trust_readonly)
1061     {
1062       struct section_table *secp;
1063       /* User-settable option, "trust-readonly-sections".  If true,
1064          then memory from any SEC_READONLY bfd section may be read
1065          directly from the bfd file.  */
1066       secp = target_section_by_addr (&current_target, memaddr);
1067       if (secp != NULL
1068           && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1069               & SEC_READONLY))
1070         return xfer_memory (memaddr, myaddr, len, 0, attrib, &current_target);
1071     }
1072
1073   /* The quick case is that the top target can handle the transfer.  */
1074   res = current_target.deprecated_xfer_memory
1075     (memaddr, myaddr, len, write, attrib, &current_target);
1076
1077   /* If res <= 0 then we call it again in the loop.  Ah well. */
1078   if (res <= 0)
1079     {
1080       for (t = target_stack; t != NULL; t = t->beneath)
1081         {
1082           if (!t->to_has_memory)
1083             continue;
1084
1085           res = t->deprecated_xfer_memory (memaddr, myaddr, len, write, attrib, t);
1086           if (res > 0)
1087             break;              /* Handled all or part of xfer */
1088           if (t->to_has_all_memory)
1089             break;
1090         }
1091
1092       if (res <= 0)
1093         return -1;
1094     }
1095
1096   return res;
1097 }
1098
1099
1100 /* Perform a memory transfer.  Iterate until the entire region has
1101    been transfered.
1102
1103    Result is 0 or errno value.  */
1104
1105 static int
1106 target_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write)
1107 {
1108   int res;
1109   int reg_len;
1110   struct mem_region *region;
1111
1112   /* Zero length requests are ok and require no work.  */
1113   if (len == 0)
1114     {
1115       return 0;
1116     }
1117
1118   while (len > 0)
1119     {
1120       region = lookup_mem_region(memaddr);
1121       if (memaddr + len < region->hi)
1122         reg_len = len;
1123       else
1124         reg_len = region->hi - memaddr;
1125
1126       switch (region->attrib.mode)
1127         {
1128         case MEM_RO:
1129           if (write)
1130             return EIO;
1131           break;
1132
1133         case MEM_WO:
1134           if (!write)
1135             return EIO;
1136           break;
1137         }
1138
1139       while (reg_len > 0)
1140         {
1141           if (region->attrib.cache)
1142             res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1143                                       reg_len, write);
1144           else
1145             res = do_xfer_memory (memaddr, myaddr, reg_len, write,
1146                                  &region->attrib);
1147
1148           if (res <= 0)
1149             {
1150               /* If this address is for nonexistent memory, read zeros
1151                  if reading, or do nothing if writing.  Return
1152                  error. */
1153               if (!write)
1154                 memset (myaddr, 0, len);
1155               if (errno == 0)
1156                 return EIO;
1157               else
1158                 return errno;
1159             }
1160
1161           memaddr += res;
1162           myaddr  += res;
1163           len     -= res;
1164           reg_len -= res;
1165         }
1166     }
1167
1168   return 0;                     /* We managed to cover it all somehow. */
1169 }
1170
1171
1172 /* Perform a partial memory transfer.
1173
1174    If we succeed, set *ERR to zero and return the number of bytes transferred.
1175    If we fail, set *ERR to a non-zero errno value, and return -1.  */
1176
1177 static int
1178 target_xfer_memory_partial (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1179                             int write_p, int *err)
1180 {
1181   int res;
1182   int reg_len;
1183   struct mem_region *region;
1184
1185   /* Zero length requests are ok and require no work.  */
1186   if (len == 0)
1187     {
1188       *err = 0;
1189       return 0;
1190     }
1191
1192   region = lookup_mem_region(memaddr);
1193   if (memaddr + len < region->hi)
1194     reg_len = len;
1195   else
1196     reg_len = region->hi - memaddr;
1197
1198   switch (region->attrib.mode)
1199     {
1200     case MEM_RO:
1201       if (write_p)
1202         {
1203           *err = EIO;
1204           return -1;
1205         }
1206       break;
1207
1208     case MEM_WO:
1209       if (write_p)
1210         {
1211           *err = EIO;
1212           return -1;
1213         }
1214       break;
1215     }
1216
1217   if (region->attrib.cache)
1218     res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1219                               reg_len, write_p);
1220   else
1221     res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
1222                           &region->attrib);
1223
1224   if (res <= 0)
1225     {
1226       if (errno != 0)
1227         *err = errno;
1228       else
1229         *err = EIO;
1230
1231         return -1;
1232     }
1233
1234   *err = 0;
1235   return res;
1236 }
1237
1238 int
1239 target_read_memory_partial (CORE_ADDR memaddr, gdb_byte *buf,
1240                             int len, int *err)
1241 {
1242   if (target_xfer_partial_p ())
1243     {
1244       int retval;
1245
1246       retval = target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY,
1247                                     NULL, buf, NULL, memaddr, len);
1248
1249       if (retval <= 0)
1250         {
1251           if (errno)
1252             *err = errno;
1253           else
1254             *err = EIO;
1255           return -1;
1256         }
1257       else
1258         {
1259           *err = 0;
1260           return retval;
1261         }
1262     }
1263   else
1264     return target_xfer_memory_partial (memaddr, buf, len, 0, err);
1265 }
1266
1267 int
1268 target_write_memory_partial (CORE_ADDR memaddr, gdb_byte *buf,
1269                              int len, int *err)
1270 {
1271   if (target_xfer_partial_p ())
1272     {
1273       int retval;
1274
1275       retval = target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY,
1276                                     NULL, NULL, buf, memaddr, len);
1277
1278       if (retval <= 0)
1279         {
1280           if (errno)
1281             *err = errno;
1282           else
1283             *err = EIO;
1284           return -1;
1285         }
1286       else
1287         {
1288           *err = 0;
1289           return retval;
1290         }
1291     }
1292   else
1293     return target_xfer_memory_partial (memaddr, buf, len, 1, err);
1294 }
1295
1296 /* More generic transfers.  */
1297
1298 static LONGEST
1299 default_xfer_partial (struct target_ops *ops, enum target_object object,
1300                       const char *annex, gdb_byte *readbuf,
1301                       const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1302 {
1303   if (object == TARGET_OBJECT_MEMORY
1304       && ops->deprecated_xfer_memory != NULL)
1305     /* If available, fall back to the target's
1306        "deprecated_xfer_memory" method.  */
1307     {
1308       int xfered = -1;
1309       errno = 0;
1310       if (writebuf != NULL)
1311         {
1312           void *buffer = xmalloc (len);
1313           struct cleanup *cleanup = make_cleanup (xfree, buffer);
1314           memcpy (buffer, writebuf, len);
1315           xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1316                                                 1/*write*/, NULL, ops);
1317           do_cleanups (cleanup);
1318         }
1319       if (readbuf != NULL)
1320         xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/*read*/,
1321                                               NULL, ops);
1322       if (xfered > 0)
1323         return xfered;
1324       else if (xfered == 0 && errno == 0)
1325         /* "deprecated_xfer_memory" uses 0, cross checked against
1326            ERRNO as one indication of an error.  */
1327         return 0;
1328       else
1329         return -1;
1330     }
1331   else if (ops->beneath != NULL)
1332     return target_xfer_partial (ops->beneath, object, annex,
1333                                 readbuf, writebuf, offset, len);
1334   else
1335     return -1;
1336 }
1337
1338 /* Target vector read/write partial wrapper functions.
1339
1340    NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1341    (inbuf, outbuf)", instead of separate read/write methods, make life
1342    easier.  */
1343
1344 static LONGEST
1345 target_read_partial (struct target_ops *ops,
1346                      enum target_object object,
1347                      const char *annex, gdb_byte *buf,
1348                      ULONGEST offset, LONGEST len)
1349 {
1350   return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1351 }
1352
1353 static LONGEST
1354 target_write_partial (struct target_ops *ops,
1355                       enum target_object object,
1356                       const char *annex, const gdb_byte *buf,
1357                       ULONGEST offset, LONGEST len)
1358 {
1359   return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1360 }
1361
1362 /* Wrappers to perform the full transfer.  */
1363 LONGEST
1364 target_read (struct target_ops *ops,
1365              enum target_object object,
1366              const char *annex, gdb_byte *buf,
1367              ULONGEST offset, LONGEST len)
1368 {
1369   LONGEST xfered = 0;
1370   while (xfered < len)
1371     {
1372       LONGEST xfer = target_read_partial (ops, object, annex,
1373                                           (gdb_byte *) buf + xfered,
1374                                           offset + xfered, len - xfered);
1375       /* Call an observer, notifying them of the xfer progress?  */
1376       if (xfer == 0)
1377         return xfered;
1378       if (xfer < 0)
1379         return -1;
1380       xfered += xfer;
1381       QUIT;
1382     }
1383   return len;
1384 }
1385
1386 LONGEST
1387 target_write (struct target_ops *ops,
1388               enum target_object object,
1389               const char *annex, const gdb_byte *buf,
1390               ULONGEST offset, LONGEST len)
1391 {
1392   LONGEST xfered = 0;
1393   while (xfered < len)
1394     {
1395       LONGEST xfer = target_write_partial (ops, object, annex,
1396                                            (gdb_byte *) buf + xfered,
1397                                            offset + xfered, len - xfered);
1398       /* Call an observer, notifying them of the xfer progress?  */
1399       if (xfer == 0)
1400         return xfered;
1401       if (xfer < 0)
1402         return -1;
1403       xfered += xfer;
1404       QUIT;
1405     }
1406   return len;
1407 }
1408
1409 /* Wrapper to perform a full read of unknown size.  OBJECT/ANNEX will
1410    be read using OPS.  The return value will be -1 if the transfer
1411    fails or is not supported; 0 if the object is empty; or the length
1412    of the object otherwise.  If a positive value is returned, a
1413    sufficiently large buffer will be allocated using xmalloc and
1414    returned in *BUF_P containing the contents of the object.
1415
1416    This method should be used for objects sufficiently small to store
1417    in a single xmalloc'd buffer, when no fixed bound on the object's
1418    size is known in advance.  Don't try to read TARGET_OBJECT_MEMORY
1419    through this function.  */
1420
1421 LONGEST
1422 target_read_alloc (struct target_ops *ops,
1423                    enum target_object object,
1424                    const char *annex, gdb_byte **buf_p)
1425 {
1426   size_t buf_alloc, buf_pos;
1427   gdb_byte *buf;
1428   LONGEST n;
1429
1430   /* This function does not have a length parameter; it reads the
1431      entire OBJECT).  Also, it doesn't support objects fetched partly
1432      from one target and partly from another (in a different stratum,
1433      e.g. a core file and an executable).  Both reasons make it
1434      unsuitable for reading memory.  */
1435   gdb_assert (object != TARGET_OBJECT_MEMORY);
1436
1437   /* Start by reading up to 4K at a time.  The target will throttle
1438      this number down if necessary.  */
1439   buf_alloc = 4096;
1440   buf = xmalloc (buf_alloc);
1441   buf_pos = 0;
1442   while (1)
1443     {
1444       n = target_read_partial (ops, object, annex, &buf[buf_pos],
1445                                buf_pos, buf_alloc - buf_pos);
1446       if (n < 0)
1447         {
1448           /* An error occurred.  */
1449           xfree (buf);
1450           return -1;
1451         }
1452       else if (n == 0)
1453         {
1454           /* Read all there was.  */
1455           if (buf_pos == 0)
1456             xfree (buf);
1457           else
1458             *buf_p = buf;
1459           return buf_pos;
1460         }
1461
1462       buf_pos += n;
1463
1464       /* If the buffer is filling up, expand it.  */
1465       if (buf_alloc < buf_pos * 2)
1466         {
1467           buf_alloc *= 2;
1468           buf = xrealloc (buf, buf_alloc);
1469         }
1470
1471       QUIT;
1472     }
1473 }
1474
1475 /* Memory transfer methods.  */
1476
1477 void
1478 get_target_memory (struct target_ops *ops, CORE_ADDR addr, gdb_byte *buf,
1479                    LONGEST len)
1480 {
1481   if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1482       != len)
1483     memory_error (EIO, addr);
1484 }
1485
1486 ULONGEST
1487 get_target_memory_unsigned (struct target_ops *ops,
1488                             CORE_ADDR addr, int len)
1489 {
1490   gdb_byte buf[sizeof (ULONGEST)];
1491
1492   gdb_assert (len <= sizeof (buf));
1493   get_target_memory (ops, addr, buf, len);
1494   return extract_unsigned_integer (buf, len);
1495 }
1496
1497 static void
1498 target_info (char *args, int from_tty)
1499 {
1500   struct target_ops *t;
1501   int has_all_mem = 0;
1502
1503   if (symfile_objfile != NULL)
1504     printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1505
1506   for (t = target_stack; t != NULL; t = t->beneath)
1507     {
1508       if (!t->to_has_memory)
1509         continue;
1510
1511       if ((int) (t->to_stratum) <= (int) dummy_stratum)
1512         continue;
1513       if (has_all_mem)
1514         printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1515       printf_unfiltered ("%s:\n", t->to_longname);
1516       (t->to_files_info) (t);
1517       has_all_mem = t->to_has_all_memory;
1518     }
1519 }
1520
1521 /* This is to be called by the open routine before it does
1522    anything.  */
1523
1524 void
1525 target_preopen (int from_tty)
1526 {
1527   dont_repeat ();
1528
1529   if (target_has_execution)
1530     {
1531       if (!from_tty
1532           || query (_("A program is being debugged already.  Kill it? ")))
1533         target_kill ();
1534       else
1535         error (_("Program not killed."));
1536     }
1537
1538   /* Calling target_kill may remove the target from the stack.  But if
1539      it doesn't (which seems like a win for UDI), remove it now.  */
1540
1541   if (target_has_execution)
1542     pop_target ();
1543 }
1544
1545 /* Detach a target after doing deferred register stores.  */
1546
1547 void
1548 target_detach (char *args, int from_tty)
1549 {
1550   (current_target.to_detach) (args, from_tty);
1551 }
1552
1553 void
1554 target_disconnect (char *args, int from_tty)
1555 {
1556   struct target_ops *t;
1557
1558   for (t = current_target.beneath; t != NULL; t = t->beneath)
1559     if (t->to_disconnect != NULL)
1560         {
1561           if (targetdebug)
1562             fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1563                                 args, from_tty);
1564           t->to_disconnect (t, args, from_tty);
1565           return;
1566         }
1567
1568   tcomplain ();
1569 }
1570
1571 int
1572 target_async_mask (int mask)
1573 {
1574   int saved_async_masked_status = target_async_mask_value;
1575   target_async_mask_value = mask;
1576   return saved_async_masked_status;
1577 }
1578
1579 /* Look through the list of possible targets for a target that can
1580    follow forks.  */
1581
1582 int
1583 target_follow_fork (int follow_child)
1584 {
1585   struct target_ops *t;
1586
1587   for (t = current_target.beneath; t != NULL; t = t->beneath)
1588     {
1589       if (t->to_follow_fork != NULL)
1590         {
1591           int retval = t->to_follow_fork (t, follow_child);
1592           if (targetdebug)
1593             fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
1594                                 follow_child, retval);
1595           return retval;
1596         }
1597     }
1598
1599   /* Some target returned a fork event, but did not know how to follow it.  */
1600   internal_error (__FILE__, __LINE__,
1601                   "could not find a target to follow fork");
1602 }
1603
1604 /* Look through the list of possible targets for a target that can
1605    execute a run or attach command without any other data.  This is
1606    used to locate the default process stratum.
1607
1608    Result is always valid (error() is called for errors).  */
1609
1610 static struct target_ops *
1611 find_default_run_target (char *do_mesg)
1612 {
1613   struct target_ops **t;
1614   struct target_ops *runable = NULL;
1615   int count;
1616
1617   count = 0;
1618
1619   for (t = target_structs; t < target_structs + target_struct_size;
1620        ++t)
1621     {
1622       if ((*t)->to_can_run && target_can_run (*t))
1623         {
1624           runable = *t;
1625           ++count;
1626         }
1627     }
1628
1629   if (count != 1)
1630     error (_("Don't know how to %s.  Try \"help target\"."), do_mesg);
1631
1632   return runable;
1633 }
1634
1635 void
1636 find_default_attach (char *args, int from_tty)
1637 {
1638   struct target_ops *t;
1639
1640   t = find_default_run_target ("attach");
1641   (t->to_attach) (args, from_tty);
1642   return;
1643 }
1644
1645 void
1646 find_default_create_inferior (char *exec_file, char *allargs, char **env,
1647                               int from_tty)
1648 {
1649   struct target_ops *t;
1650
1651   t = find_default_run_target ("run");
1652   (t->to_create_inferior) (exec_file, allargs, env, from_tty);
1653   return;
1654 }
1655
1656 static int
1657 default_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
1658 {
1659   return (len <= TYPE_LENGTH (builtin_type_void_data_ptr));
1660 }
1661
1662 static int
1663 return_zero (void)
1664 {
1665   return 0;
1666 }
1667
1668 static int
1669 return_one (void)
1670 {
1671   return 1;
1672 }
1673
1674 static int
1675 return_minus_one (void)
1676 {
1677   return -1;
1678 }
1679
1680 /*
1681  * Resize the to_sections pointer.  Also make sure that anyone that
1682  * was holding on to an old value of it gets updated.
1683  * Returns the old size.
1684  */
1685
1686 int
1687 target_resize_to_sections (struct target_ops *target, int num_added)
1688 {
1689   struct target_ops **t;
1690   struct section_table *old_value;
1691   int old_count;
1692
1693   old_value = target->to_sections;
1694
1695   if (target->to_sections)
1696     {
1697       old_count = target->to_sections_end - target->to_sections;
1698       target->to_sections = (struct section_table *)
1699         xrealloc ((char *) target->to_sections,
1700                   (sizeof (struct section_table)) * (num_added + old_count));
1701     }
1702   else
1703     {
1704       old_count = 0;
1705       target->to_sections = (struct section_table *)
1706         xmalloc ((sizeof (struct section_table)) * num_added);
1707     }
1708   target->to_sections_end = target->to_sections + (num_added + old_count);
1709
1710   /* Check to see if anyone else was pointing to this structure.
1711      If old_value was null, then no one was. */
1712
1713   if (old_value)
1714     {
1715       for (t = target_structs; t < target_structs + target_struct_size;
1716            ++t)
1717         {
1718           if ((*t)->to_sections == old_value)
1719             {
1720               (*t)->to_sections = target->to_sections;
1721               (*t)->to_sections_end = target->to_sections_end;
1722             }
1723         }
1724       /* There is a flattened view of the target stack in current_target,
1725          so its to_sections pointer might also need updating. */
1726       if (current_target.to_sections == old_value)
1727         {
1728           current_target.to_sections = target->to_sections;
1729           current_target.to_sections_end = target->to_sections_end;
1730         }
1731     }
1732
1733   return old_count;
1734
1735 }
1736
1737 /* Remove all target sections taken from ABFD.
1738
1739    Scan the current target stack for targets whose section tables
1740    refer to sections from BFD, and remove those sections.  We use this
1741    when we notice that the inferior has unloaded a shared object, for
1742    example.  */
1743 void
1744 remove_target_sections (bfd *abfd)
1745 {
1746   struct target_ops **t;
1747
1748   for (t = target_structs; t < target_structs + target_struct_size; t++)
1749     {
1750       struct section_table *src, *dest;
1751
1752       dest = (*t)->to_sections;
1753       for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1754         if (src->bfd != abfd)
1755           {
1756             /* Keep this section.  */
1757             if (dest < src) *dest = *src;
1758             dest++;
1759           }
1760
1761       /* If we've dropped any sections, resize the section table.  */
1762       if (dest < src)
1763         target_resize_to_sections (*t, dest - src);
1764     }
1765 }
1766
1767
1768
1769
1770 /* Find a single runnable target in the stack and return it.  If for
1771    some reason there is more than one, return NULL.  */
1772
1773 struct target_ops *
1774 find_run_target (void)
1775 {
1776   struct target_ops **t;
1777   struct target_ops *runable = NULL;
1778   int count;
1779
1780   count = 0;
1781
1782   for (t = target_structs; t < target_structs + target_struct_size; ++t)
1783     {
1784       if ((*t)->to_can_run && target_can_run (*t))
1785         {
1786           runable = *t;
1787           ++count;
1788         }
1789     }
1790
1791   return (count == 1 ? runable : NULL);
1792 }
1793
1794 /* Find a single core_stratum target in the list of targets and return it.
1795    If for some reason there is more than one, return NULL.  */
1796
1797 struct target_ops *
1798 find_core_target (void)
1799 {
1800   struct target_ops **t;
1801   struct target_ops *runable = NULL;
1802   int count;
1803
1804   count = 0;
1805
1806   for (t = target_structs; t < target_structs + target_struct_size;
1807        ++t)
1808     {
1809       if ((*t)->to_stratum == core_stratum)
1810         {
1811           runable = *t;
1812           ++count;
1813         }
1814     }
1815
1816   return (count == 1 ? runable : NULL);
1817 }
1818
1819 /*
1820  * Find the next target down the stack from the specified target.
1821  */
1822
1823 struct target_ops *
1824 find_target_beneath (struct target_ops *t)
1825 {
1826   return t->beneath;
1827 }
1828
1829 \f
1830 /* The inferior process has died.  Long live the inferior!  */
1831
1832 void
1833 generic_mourn_inferior (void)
1834 {
1835   extern int show_breakpoint_hit_counts;
1836
1837   inferior_ptid = null_ptid;
1838   attach_flag = 0;
1839   breakpoint_init_inferior (inf_exited);
1840   registers_changed ();
1841
1842   reopen_exec_file ();
1843   reinit_frame_cache ();
1844
1845   /* It is confusing to the user for ignore counts to stick around
1846      from previous runs of the inferior.  So clear them.  */
1847   /* However, it is more confusing for the ignore counts to disappear when
1848      using hit counts.  So don't clear them if we're counting hits.  */
1849   if (!show_breakpoint_hit_counts)
1850     breakpoint_clear_ignore_counts ();
1851
1852   if (deprecated_detach_hook)
1853     deprecated_detach_hook ();
1854 }
1855 \f
1856 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1857    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1858    translation of that in OURSTATUS.  */
1859 void
1860 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
1861 {
1862 #ifdef CHILD_SPECIAL_WAITSTATUS
1863   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1864      if it wants to deal with hoststatus.  */
1865   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1866     return;
1867 #endif
1868
1869   if (WIFEXITED (hoststatus))
1870     {
1871       ourstatus->kind = TARGET_WAITKIND_EXITED;
1872       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1873     }
1874   else if (!WIFSTOPPED (hoststatus))
1875     {
1876       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1877       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1878     }
1879   else
1880     {
1881       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1882       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1883     }
1884 }
1885 \f
1886 /* Returns zero to leave the inferior alone, one to interrupt it.  */
1887 int (*target_activity_function) (void);
1888 int target_activity_fd;
1889 \f
1890 /* Convert a normal process ID to a string.  Returns the string in a
1891    static buffer.  */
1892
1893 char *
1894 normal_pid_to_str (ptid_t ptid)
1895 {
1896   static char buf[32];
1897
1898   xsnprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
1899   return buf;
1900 }
1901
1902 /* Error-catcher for target_find_memory_regions */
1903 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
1904 {
1905   error (_("No target."));
1906   return 0;
1907 }
1908
1909 /* Error-catcher for target_make_corefile_notes */
1910 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
1911 {
1912   error (_("No target."));
1913   return NULL;
1914 }
1915
1916 /* Set up the handful of non-empty slots needed by the dummy target
1917    vector.  */
1918
1919 static void
1920 init_dummy_target (void)
1921 {
1922   dummy_target.to_shortname = "None";
1923   dummy_target.to_longname = "None";
1924   dummy_target.to_doc = "";
1925   dummy_target.to_attach = find_default_attach;
1926   dummy_target.to_create_inferior = find_default_create_inferior;
1927   dummy_target.to_pid_to_str = normal_pid_to_str;
1928   dummy_target.to_stratum = dummy_stratum;
1929   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1930   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1931   dummy_target.to_xfer_partial = default_xfer_partial;
1932   dummy_target.to_magic = OPS_MAGIC;
1933 }
1934 \f
1935 static void
1936 debug_to_open (char *args, int from_tty)
1937 {
1938   debug_target.to_open (args, from_tty);
1939
1940   fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1941 }
1942
1943 static void
1944 debug_to_close (int quitting)
1945 {
1946   target_close (&debug_target, quitting);
1947   fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1948 }
1949
1950 void
1951 target_close (struct target_ops *targ, int quitting)
1952 {
1953   if (targ->to_xclose != NULL)
1954     targ->to_xclose (targ, quitting);
1955   else if (targ->to_close != NULL)
1956     targ->to_close (quitting);
1957 }
1958
1959 static void
1960 debug_to_attach (char *args, int from_tty)
1961 {
1962   debug_target.to_attach (args, from_tty);
1963
1964   fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1965 }
1966
1967
1968 static void
1969 debug_to_post_attach (int pid)
1970 {
1971   debug_target.to_post_attach (pid);
1972
1973   fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1974 }
1975
1976 static void
1977 debug_to_detach (char *args, int from_tty)
1978 {
1979   debug_target.to_detach (args, from_tty);
1980
1981   fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1982 }
1983
1984 static void
1985 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1986 {
1987   debug_target.to_resume (ptid, step, siggnal);
1988
1989   fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
1990                       step ? "step" : "continue",
1991                       target_signal_to_name (siggnal));
1992 }
1993
1994 static ptid_t
1995 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1996 {
1997   ptid_t retval;
1998
1999   retval = debug_target.to_wait (ptid, status);
2000
2001   fprintf_unfiltered (gdb_stdlog,
2002                       "target_wait (%d, status) = %d,   ", PIDGET (ptid),
2003                       PIDGET (retval));
2004   fprintf_unfiltered (gdb_stdlog, "status->kind = ");
2005   switch (status->kind)
2006     {
2007     case TARGET_WAITKIND_EXITED:
2008       fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
2009                           status->value.integer);
2010       break;
2011     case TARGET_WAITKIND_STOPPED:
2012       fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
2013                           target_signal_to_name (status->value.sig));
2014       break;
2015     case TARGET_WAITKIND_SIGNALLED:
2016       fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
2017                           target_signal_to_name (status->value.sig));
2018       break;
2019     case TARGET_WAITKIND_LOADED:
2020       fprintf_unfiltered (gdb_stdlog, "loaded\n");
2021       break;
2022     case TARGET_WAITKIND_FORKED:
2023       fprintf_unfiltered (gdb_stdlog, "forked\n");
2024       break;
2025     case TARGET_WAITKIND_VFORKED:
2026       fprintf_unfiltered (gdb_stdlog, "vforked\n");
2027       break;
2028     case TARGET_WAITKIND_EXECD:
2029       fprintf_unfiltered (gdb_stdlog, "execd\n");
2030       break;
2031     case TARGET_WAITKIND_SPURIOUS:
2032       fprintf_unfiltered (gdb_stdlog, "spurious\n");
2033       break;
2034     default:
2035       fprintf_unfiltered (gdb_stdlog, "unknown???\n");
2036       break;
2037     }
2038
2039   return retval;
2040 }
2041
2042 static void
2043 debug_print_register (const char * func, int regno)
2044 {
2045   fprintf_unfiltered (gdb_stdlog, "%s ", func);
2046   if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS
2047       && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0')
2048     fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno));
2049   else
2050     fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
2051   if (regno >= 0)
2052     {
2053       int i;
2054       unsigned char buf[MAX_REGISTER_SIZE];
2055       deprecated_read_register_gen (regno, buf);
2056       fprintf_unfiltered (gdb_stdlog, " = ");
2057       for (i = 0; i < register_size (current_gdbarch, regno); i++)
2058         {
2059           fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
2060         }
2061       if (register_size (current_gdbarch, regno) <= sizeof (LONGEST))
2062         {
2063           fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
2064                               paddr_nz (read_register (regno)),
2065                               paddr_d (read_register (regno)));
2066         }
2067     }
2068   fprintf_unfiltered (gdb_stdlog, "\n");
2069 }
2070
2071 static void
2072 debug_to_fetch_registers (int regno)
2073 {
2074   debug_target.to_fetch_registers (regno);
2075   debug_print_register ("target_fetch_registers", regno);
2076 }
2077
2078 static void
2079 debug_to_store_registers (int regno)
2080 {
2081   debug_target.to_store_registers (regno);
2082   debug_print_register ("target_store_registers", regno);
2083   fprintf_unfiltered (gdb_stdlog, "\n");
2084 }
2085
2086 static void
2087 debug_to_prepare_to_store (void)
2088 {
2089   debug_target.to_prepare_to_store ();
2090
2091   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2092 }
2093
2094 static int
2095 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2096                               int write, struct mem_attrib *attrib,
2097                               struct target_ops *target)
2098 {
2099   int retval;
2100
2101   retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2102                                                 attrib, target);
2103
2104   fprintf_unfiltered (gdb_stdlog,
2105                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2106                       (unsigned int) memaddr,   /* possable truncate long long */
2107                       len, write ? "write" : "read", retval);
2108
2109   if (retval > 0)
2110     {
2111       int i;
2112
2113       fputs_unfiltered (", bytes =", gdb_stdlog);
2114       for (i = 0; i < retval; i++)
2115         {
2116           if ((((long) &(myaddr[i])) & 0xf) == 0)
2117             {
2118               if (targetdebug < 2 && i > 0)
2119                 {
2120                   fprintf_unfiltered (gdb_stdlog, " ...");
2121                   break;
2122                 }
2123               fprintf_unfiltered (gdb_stdlog, "\n");
2124             }
2125
2126           fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2127         }
2128     }
2129
2130   fputc_unfiltered ('\n', gdb_stdlog);
2131
2132   return retval;
2133 }
2134
2135 static void
2136 debug_to_files_info (struct target_ops *target)
2137 {
2138   debug_target.to_files_info (target);
2139
2140   fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2141 }
2142
2143 static int
2144 debug_to_insert_breakpoint (struct bp_target_info *bp_tgt)
2145 {
2146   int retval;
2147
2148   retval = debug_target.to_insert_breakpoint (bp_tgt);
2149
2150   fprintf_unfiltered (gdb_stdlog,
2151                       "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2152                       (unsigned long) bp_tgt->placed_address,
2153                       (unsigned long) retval);
2154   return retval;
2155 }
2156
2157 static int
2158 debug_to_remove_breakpoint (struct bp_target_info *bp_tgt)
2159 {
2160   int retval;
2161
2162   retval = debug_target.to_remove_breakpoint (bp_tgt);
2163
2164   fprintf_unfiltered (gdb_stdlog,
2165                       "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2166                       (unsigned long) bp_tgt->placed_address,
2167                       (unsigned long) retval);
2168   return retval;
2169 }
2170
2171 static int
2172 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2173 {
2174   int retval;
2175
2176   retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2177
2178   fprintf_unfiltered (gdb_stdlog,
2179                       "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2180                       (unsigned long) type,
2181                       (unsigned long) cnt,
2182                       (unsigned long) from_tty,
2183                       (unsigned long) retval);
2184   return retval;
2185 }
2186
2187 static int
2188 debug_to_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
2189 {
2190   CORE_ADDR retval;
2191
2192   retval = debug_target.to_region_ok_for_hw_watchpoint (addr, len);
2193
2194   fprintf_unfiltered (gdb_stdlog,
2195                       "TARGET_REGION_OK_FOR_HW_WATCHPOINT (%ld, %ld) = 0x%lx\n",
2196                       (unsigned long) addr,
2197                       (unsigned long) len,
2198                       (unsigned long) retval);
2199   return retval;
2200 }
2201
2202 static int
2203 debug_to_stopped_by_watchpoint (void)
2204 {
2205   int retval;
2206
2207   retval = debug_target.to_stopped_by_watchpoint ();
2208
2209   fprintf_unfiltered (gdb_stdlog,
2210                       "STOPPED_BY_WATCHPOINT () = %ld\n",
2211                       (unsigned long) retval);
2212   return retval;
2213 }
2214
2215 static int
2216 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2217 {
2218   int retval;
2219
2220   retval = debug_target.to_stopped_data_address (target, addr);
2221
2222   fprintf_unfiltered (gdb_stdlog,
2223                       "target_stopped_data_address ([0x%lx]) = %ld\n",
2224                       (unsigned long)*addr,
2225                       (unsigned long)retval);
2226   return retval;
2227 }
2228
2229 static int
2230 debug_to_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
2231 {
2232   int retval;
2233
2234   retval = debug_target.to_insert_hw_breakpoint (bp_tgt);
2235
2236   fprintf_unfiltered (gdb_stdlog,
2237                       "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2238                       (unsigned long) bp_tgt->placed_address,
2239                       (unsigned long) retval);
2240   return retval;
2241 }
2242
2243 static int
2244 debug_to_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
2245 {
2246   int retval;
2247
2248   retval = debug_target.to_remove_hw_breakpoint (bp_tgt);
2249
2250   fprintf_unfiltered (gdb_stdlog,
2251                       "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2252                       (unsigned long) bp_tgt->placed_address,
2253                       (unsigned long) retval);
2254   return retval;
2255 }
2256
2257 static int
2258 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2259 {
2260   int retval;
2261
2262   retval = debug_target.to_insert_watchpoint (addr, len, type);
2263
2264   fprintf_unfiltered (gdb_stdlog,
2265                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2266                       (unsigned long) addr, len, type, (unsigned long) retval);
2267   return retval;
2268 }
2269
2270 static int
2271 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2272 {
2273   int retval;
2274
2275   retval = debug_target.to_insert_watchpoint (addr, len, type);
2276
2277   fprintf_unfiltered (gdb_stdlog,
2278                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2279                       (unsigned long) addr, len, type, (unsigned long) retval);
2280   return retval;
2281 }
2282
2283 static void
2284 debug_to_terminal_init (void)
2285 {
2286   debug_target.to_terminal_init ();
2287
2288   fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2289 }
2290
2291 static void
2292 debug_to_terminal_inferior (void)
2293 {
2294   debug_target.to_terminal_inferior ();
2295
2296   fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2297 }
2298
2299 static void
2300 debug_to_terminal_ours_for_output (void)
2301 {
2302   debug_target.to_terminal_ours_for_output ();
2303
2304   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2305 }
2306
2307 static void
2308 debug_to_terminal_ours (void)
2309 {
2310   debug_target.to_terminal_ours ();
2311
2312   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2313 }
2314
2315 static void
2316 debug_to_terminal_save_ours (void)
2317 {
2318   debug_target.to_terminal_save_ours ();
2319
2320   fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2321 }
2322
2323 static void
2324 debug_to_terminal_info (char *arg, int from_tty)
2325 {
2326   debug_target.to_terminal_info (arg, from_tty);
2327
2328   fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2329                       from_tty);
2330 }
2331
2332 static void
2333 debug_to_kill (void)
2334 {
2335   debug_target.to_kill ();
2336
2337   fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2338 }
2339
2340 static void
2341 debug_to_load (char *args, int from_tty)
2342 {
2343   debug_target.to_load (args, from_tty);
2344
2345   fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2346 }
2347
2348 static int
2349 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2350 {
2351   int retval;
2352
2353   retval = debug_target.to_lookup_symbol (name, addrp);
2354
2355   fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2356
2357   return retval;
2358 }
2359
2360 static void
2361 debug_to_create_inferior (char *exec_file, char *args, char **env,
2362                           int from_tty)
2363 {
2364   debug_target.to_create_inferior (exec_file, args, env, from_tty);
2365
2366   fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2367                       exec_file, args, from_tty);
2368 }
2369
2370 static void
2371 debug_to_post_startup_inferior (ptid_t ptid)
2372 {
2373   debug_target.to_post_startup_inferior (ptid);
2374
2375   fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2376                       PIDGET (ptid));
2377 }
2378
2379 static void
2380 debug_to_acknowledge_created_inferior (int pid)
2381 {
2382   debug_target.to_acknowledge_created_inferior (pid);
2383
2384   fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2385                       pid);
2386 }
2387
2388 static void
2389 debug_to_insert_fork_catchpoint (int pid)
2390 {
2391   debug_target.to_insert_fork_catchpoint (pid);
2392
2393   fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
2394                       pid);
2395 }
2396
2397 static int
2398 debug_to_remove_fork_catchpoint (int pid)
2399 {
2400   int retval;
2401
2402   retval = debug_target.to_remove_fork_catchpoint (pid);
2403
2404   fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2405                       pid, retval);
2406
2407   return retval;
2408 }
2409
2410 static void
2411 debug_to_insert_vfork_catchpoint (int pid)
2412 {
2413   debug_target.to_insert_vfork_catchpoint (pid);
2414
2415   fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
2416                       pid);
2417 }
2418
2419 static int
2420 debug_to_remove_vfork_catchpoint (int pid)
2421 {
2422   int retval;
2423
2424   retval = debug_target.to_remove_vfork_catchpoint (pid);
2425
2426   fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2427                       pid, retval);
2428
2429   return retval;
2430 }
2431
2432 static void
2433 debug_to_insert_exec_catchpoint (int pid)
2434 {
2435   debug_target.to_insert_exec_catchpoint (pid);
2436
2437   fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
2438                       pid);
2439 }
2440
2441 static int
2442 debug_to_remove_exec_catchpoint (int pid)
2443 {
2444   int retval;
2445
2446   retval = debug_target.to_remove_exec_catchpoint (pid);
2447
2448   fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2449                       pid, retval);
2450
2451   return retval;
2452 }
2453
2454 static int
2455 debug_to_reported_exec_events_per_exec_call (void)
2456 {
2457   int reported_exec_events;
2458
2459   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2460
2461   fprintf_unfiltered (gdb_stdlog,
2462                       "target_reported_exec_events_per_exec_call () = %d\n",
2463                       reported_exec_events);
2464
2465   return reported_exec_events;
2466 }
2467
2468 static int
2469 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2470 {
2471   int has_exited;
2472
2473   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2474
2475   fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2476                       pid, wait_status, *exit_status, has_exited);
2477
2478   return has_exited;
2479 }
2480
2481 static void
2482 debug_to_mourn_inferior (void)
2483 {
2484   debug_target.to_mourn_inferior ();
2485
2486   fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2487 }
2488
2489 static int
2490 debug_to_can_run (void)
2491 {
2492   int retval;
2493
2494   retval = debug_target.to_can_run ();
2495
2496   fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2497
2498   return retval;
2499 }
2500
2501 static void
2502 debug_to_notice_signals (ptid_t ptid)
2503 {
2504   debug_target.to_notice_signals (ptid);
2505
2506   fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2507                       PIDGET (ptid));
2508 }
2509
2510 static int
2511 debug_to_thread_alive (ptid_t ptid)
2512 {
2513   int retval;
2514
2515   retval = debug_target.to_thread_alive (ptid);
2516
2517   fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2518                       PIDGET (ptid), retval);
2519
2520   return retval;
2521 }
2522
2523 static void
2524 debug_to_find_new_threads (void)
2525 {
2526   debug_target.to_find_new_threads ();
2527
2528   fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2529 }
2530
2531 static void
2532 debug_to_stop (void)
2533 {
2534   debug_target.to_stop ();
2535
2536   fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2537 }
2538
2539 static void
2540 debug_to_rcmd (char *command,
2541                struct ui_file *outbuf)
2542 {
2543   debug_target.to_rcmd (command, outbuf);
2544   fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2545 }
2546
2547 static struct symtab_and_line *
2548 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2549 {
2550   struct symtab_and_line *result;
2551   result = debug_target.to_enable_exception_callback (kind, enable);
2552   fprintf_unfiltered (gdb_stdlog,
2553                       "target get_exception_callback_sal (%d, %d)\n",
2554                       kind, enable);
2555   return result;
2556 }
2557
2558 static struct exception_event_record *
2559 debug_to_get_current_exception_event (void)
2560 {
2561   struct exception_event_record *result;
2562   result = debug_target.to_get_current_exception_event ();
2563   fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2564   return result;
2565 }
2566
2567 static char *
2568 debug_to_pid_to_exec_file (int pid)
2569 {
2570   char *exec_file;
2571
2572   exec_file = debug_target.to_pid_to_exec_file (pid);
2573
2574   fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2575                       pid, exec_file);
2576
2577   return exec_file;
2578 }
2579
2580 static void
2581 setup_target_debug (void)
2582 {
2583   memcpy (&debug_target, &current_target, sizeof debug_target);
2584
2585   current_target.to_open = debug_to_open;
2586   current_target.to_close = debug_to_close;
2587   current_target.to_attach = debug_to_attach;
2588   current_target.to_post_attach = debug_to_post_attach;
2589   current_target.to_detach = debug_to_detach;
2590   current_target.to_resume = debug_to_resume;
2591   current_target.to_wait = debug_to_wait;
2592   current_target.to_fetch_registers = debug_to_fetch_registers;
2593   current_target.to_store_registers = debug_to_store_registers;
2594   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2595   current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
2596   current_target.to_files_info = debug_to_files_info;
2597   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2598   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2599   current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2600   current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2601   current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2602   current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2603   current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2604   current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2605   current_target.to_stopped_data_address = debug_to_stopped_data_address;
2606   current_target.to_region_ok_for_hw_watchpoint = debug_to_region_ok_for_hw_watchpoint;
2607   current_target.to_terminal_init = debug_to_terminal_init;
2608   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2609   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2610   current_target.to_terminal_ours = debug_to_terminal_ours;
2611   current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2612   current_target.to_terminal_info = debug_to_terminal_info;
2613   current_target.to_kill = debug_to_kill;
2614   current_target.to_load = debug_to_load;
2615   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2616   current_target.to_create_inferior = debug_to_create_inferior;
2617   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2618   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2619   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2620   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2621   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2622   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2623   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2624   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2625   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2626   current_target.to_has_exited = debug_to_has_exited;
2627   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2628   current_target.to_can_run = debug_to_can_run;
2629   current_target.to_notice_signals = debug_to_notice_signals;
2630   current_target.to_thread_alive = debug_to_thread_alive;
2631   current_target.to_find_new_threads = debug_to_find_new_threads;
2632   current_target.to_stop = debug_to_stop;
2633   current_target.to_rcmd = debug_to_rcmd;
2634   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2635   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2636   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2637 }
2638 \f
2639
2640 static char targ_desc[] =
2641 "Names of targets and files being debugged.\n\
2642 Shows the entire stack of targets currently in use (including the exec-file,\n\
2643 core-file, and process, if any), as well as the symbol file name.";
2644
2645 static void
2646 do_monitor_command (char *cmd,
2647                  int from_tty)
2648 {
2649   if ((current_target.to_rcmd
2650        == (void (*) (char *, struct ui_file *)) tcomplain)
2651       || (current_target.to_rcmd == debug_to_rcmd
2652           && (debug_target.to_rcmd
2653               == (void (*) (char *, struct ui_file *)) tcomplain)))
2654     error (_("\"monitor\" command not supported by this target."));
2655   target_rcmd (cmd, gdb_stdtarg);
2656 }
2657
2658 void
2659 initialize_targets (void)
2660 {
2661   init_dummy_target ();
2662   push_target (&dummy_target);
2663
2664   add_info ("target", target_info, targ_desc);
2665   add_info ("files", target_info, targ_desc);
2666
2667   add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
2668 Set target debugging."), _("\
2669 Show target debugging."), _("\
2670 When non-zero, target debugging is enabled.  Higher numbers are more\n\
2671 verbose.  Changes do not take effect until the next \"run\" or \"target\"\n\
2672 command."),
2673                             NULL,
2674                             show_targetdebug,
2675                             &setdebuglist, &showdebuglist);
2676
2677   add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
2678                            &trust_readonly, _("\
2679 Set mode for reading from readonly sections."), _("\
2680 Show mode for reading from readonly sections."), _("\
2681 When this mode is on, memory reads from readonly sections (such as .text)\n\
2682 will be read from the object file instead of from the target.  This will\n\
2683 result in significant performance improvement for remote targets."),
2684                            NULL,
2685                            show_trust_readonly,
2686                            &setlist, &showlist);
2687
2688   add_com ("monitor", class_obscure, do_monitor_command,
2689            _("Send a command to the remote monitor (remote targets only)."));
2690
2691   target_dcache = dcache_init ();
2692 }