gdb/target.c

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