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             (void (*) (int))
 570             tcomplain);
 571   de_fault (to_remove_fork_catchpoint,
 572             (int (*) (int))
 573             tcomplain);
 574   de_fault (to_insert_vfork_catchpoint,
 575             (void (*) (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             (void (*) (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, bfd_byte *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, const bfd_byte *myaddr, int len)
1009 {
1010   bfd_byte *bytes = alloca (len);
1011   memcpy (bytes, myaddr, len);
1012   if (target_xfer_partial_p ())
1013     return xfer_using_stratum (TARGET_OBJECT_MEMORY, NULL,
1014                                memaddr, len, NULL, bytes);
1015   else
1016     return target_xfer_memory (memaddr, bytes, len, 1);
1017 }
1018
1019 #ifndef target_stopped_data_address_p
1020 int
1021 target_stopped_data_address_p (struct target_ops *target)
1022 {
1023   if (target->to_stopped_data_address
1024       == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero)
1025     return 0;
1026   if (target->to_stopped_data_address == debug_to_stopped_data_address
1027       && (debug_target.to_stopped_data_address
1028           == (int (*) (struct target_ops *, CORE_ADDR *)) return_zero))
1029     return 0;
1030   return 1;
1031 }
1032 #endif
1033
1034 static int trust_readonly = 0;
1035
1036 /* Move memory to or from the targets.  The top target gets priority;
1037    if it cannot handle it, it is offered to the next one down, etc.
1038
1039    Result is -1 on error, or the number of bytes transfered.  */
1040
1041 int
1042 do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1043                 struct mem_attrib *attrib)
1044 {
1045   int res;
1046   int done = 0;
1047   struct target_ops *t;
1048
1049   /* Zero length requests are ok and require no work.  */
1050   if (len == 0)
1051     return 0;
1052
1053   /* deprecated_xfer_memory is not guaranteed to set errno, even when
1054      it returns 0.  */
1055   errno = 0;
1056
1057   if (!write && trust_readonly)
1058     {
1059       struct section_table *secp;
1060       /* User-settable option, "trust-readonly-sections".  If true,
1061          then memory from any SEC_READONLY bfd section may be read
1062          directly from the bfd file.  */
1063       secp = target_section_by_addr (&current_target, memaddr);
1064       if (secp != NULL
1065           && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
1066               & SEC_READONLY))
1067         return xfer_memory (memaddr, myaddr, len, 0, attrib, &current_target);
1068     }
1069
1070   /* The quick case is that the top target can handle the transfer.  */
1071   res = current_target.deprecated_xfer_memory
1072     (memaddr, myaddr, len, write, attrib, &current_target);
1073
1074   /* If res <= 0 then we call it again in the loop.  Ah well. */
1075   if (res <= 0)
1076     {
1077       for (t = target_stack; t != NULL; t = t->beneath)
1078         {
1079           if (!t->to_has_memory)
1080             continue;
1081
1082           res = t->deprecated_xfer_memory (memaddr, myaddr, len, write, attrib, t);
1083           if (res > 0)
1084             break;              /* Handled all or part of xfer */
1085           if (t->to_has_all_memory)
1086             break;
1087         }
1088
1089       if (res <= 0)
1090         return -1;
1091     }
1092
1093   return res;
1094 }
1095
1096
1097 /* Perform a memory transfer.  Iterate until the entire region has
1098    been transfered.
1099
1100    Result is 0 or errno value.  */
1101
1102 static int
1103 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
1104 {
1105   int res;
1106   int reg_len;
1107   struct mem_region *region;
1108
1109   /* Zero length requests are ok and require no work.  */
1110   if (len == 0)
1111     {
1112       return 0;
1113     }
1114
1115   while (len > 0)
1116     {
1117       region = lookup_mem_region(memaddr);
1118       if (memaddr + len < region->hi)
1119         reg_len = len;
1120       else
1121         reg_len = region->hi - memaddr;
1122
1123       switch (region->attrib.mode)
1124         {
1125         case MEM_RO:
1126           if (write)
1127             return EIO;
1128           break;
1129
1130         case MEM_WO:
1131           if (!write)
1132             return EIO;
1133           break;
1134         }
1135
1136       while (reg_len > 0)
1137         {
1138           if (region->attrib.cache)
1139             res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1140                                      reg_len, write);
1141           else
1142             res = do_xfer_memory (memaddr, myaddr, reg_len, write,
1143                                  &region->attrib);
1144
1145           if (res <= 0)
1146             {
1147               /* If this address is for nonexistent memory, read zeros
1148                  if reading, or do nothing if writing.  Return
1149                  error. */
1150               if (!write)
1151                 memset (myaddr, 0, len);
1152               if (errno == 0)
1153                 return EIO;
1154               else
1155                 return errno;
1156             }
1157
1158           memaddr += res;
1159           myaddr  += res;
1160           len     -= res;
1161           reg_len -= res;
1162         }
1163     }
1164
1165   return 0;                     /* We managed to cover it all somehow. */
1166 }
1167
1168
1169 /* Perform a partial memory transfer.
1170
1171    Result is -1 on error, or the number of bytes transfered.  */
1172
1173 static int
1174 target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
1175                             int write_p, int *err)
1176 {
1177   int res;
1178   int reg_len;
1179   struct mem_region *region;
1180
1181   /* Zero length requests are ok and require no work.  */
1182   if (len == 0)
1183     {
1184       *err = 0;
1185       return 0;
1186     }
1187
1188   region = lookup_mem_region(memaddr);
1189   if (memaddr + len < region->hi)
1190     reg_len = len;
1191   else
1192     reg_len = region->hi - memaddr;
1193
1194   switch (region->attrib.mode)
1195     {
1196     case MEM_RO:
1197       if (write_p)
1198         {
1199           *err = EIO;
1200           return -1;
1201         }
1202       break;
1203
1204     case MEM_WO:
1205       if (write_p)
1206         {
1207           *err = EIO;
1208           return -1;
1209         }
1210       break;
1211     }
1212
1213   if (region->attrib.cache)
1214     res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1215                               reg_len, write_p);
1216   else
1217     res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
1218                           &region->attrib);
1219
1220   if (res <= 0)
1221     {
1222       if (errno != 0)
1223         *err = errno;
1224       else
1225         *err = EIO;
1226
1227         return -1;
1228     }
1229
1230   *err = 0;
1231   return res;
1232 }
1233
1234 int
1235 target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
1236 {
1237   if (target_xfer_partial_p ())
1238     return target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY, NULL,
1239                                 buf, NULL, memaddr, len);
1240   else
1241     return target_xfer_memory_partial (memaddr, buf, len, 0, err);
1242 }
1243
1244 int
1245 target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
1246 {
1247   if (target_xfer_partial_p ())
1248     return target_xfer_partial (target_stack, TARGET_OBJECT_MEMORY, NULL,
1249                                 NULL, buf, memaddr, len);
1250   else
1251     return target_xfer_memory_partial (memaddr, buf, len, 1, err);
1252 }
1253
1254 /* More generic transfers.  */
1255
1256 static LONGEST
1257 default_xfer_partial (struct target_ops *ops, enum target_object object,
1258                       const char *annex, void *readbuf,
1259                       const void *writebuf, ULONGEST offset, LONGEST len)
1260 {
1261   if (object == TARGET_OBJECT_MEMORY
1262       && ops->deprecated_xfer_memory != NULL)
1263     /* If available, fall back to the target's
1264        "deprecated_xfer_memory" method.  */
1265     {
1266       int xfered = -1;
1267       errno = 0;
1268       if (writebuf != NULL)
1269         {
1270           void *buffer = xmalloc (len);
1271           struct cleanup *cleanup = make_cleanup (xfree, buffer);
1272           memcpy (buffer, writebuf, len);
1273           xfered = ops->deprecated_xfer_memory (offset, buffer, len,
1274                                                 1/*write*/, NULL, ops);
1275           do_cleanups (cleanup);
1276         }
1277       if (readbuf != NULL)
1278         xfered = ops->deprecated_xfer_memory (offset, readbuf, len, 0/*read*/,
1279                                               NULL, ops);
1280       if (xfered > 0)
1281         return xfered;
1282       else if (xfered == 0 && errno == 0)
1283         /* "deprecated_xfer_memory" uses 0, cross checked against
1284            ERRNO as one indication of an error.  */
1285         return 0;
1286       else
1287         return -1;
1288     }
1289   else if (ops->beneath != NULL)
1290     return target_xfer_partial (ops->beneath, object, annex,
1291                                 readbuf, writebuf, offset, len);
1292   else
1293     return -1;
1294 }
1295
1296 /* Target vector read/write partial wrapper functions.
1297
1298    NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1299    (inbuf, outbuf)", instead of separate read/write methods, make life
1300    easier.  */
1301
1302 LONGEST
1303 target_read_partial (struct target_ops *ops,
1304                      enum target_object object,
1305                      const char *annex, void *buf,
1306                      ULONGEST offset, LONGEST len)
1307 {
1308   return target_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1309 }
1310
1311 LONGEST
1312 target_write_partial (struct target_ops *ops,
1313                       enum target_object object,
1314                       const char *annex, const void *buf,
1315                       ULONGEST offset, LONGEST len)
1316 {
1317   return target_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1318 }
1319
1320 /* Wrappers to perform the full transfer.  */
1321 LONGEST
1322 target_read (struct target_ops *ops,
1323              enum target_object object,
1324              const char *annex, void *buf,
1325              ULONGEST offset, LONGEST len)
1326 {
1327   LONGEST xfered = 0;
1328   while (xfered < len)
1329     {
1330       LONGEST xfer = target_read_partial (ops, object, annex,
1331                                           (bfd_byte *) buf + xfered,
1332                                           offset + xfered, len - xfered);
1333       /* Call an observer, notifying them of the xfer progress?  */
1334       if (xfer <= 0)
1335         /* Call memory_error?  */
1336         return -1;
1337       xfered += xfer;
1338       QUIT;
1339     }
1340   return len;
1341 }
1342
1343 LONGEST
1344 target_write (struct target_ops *ops,
1345               enum target_object object,
1346               const char *annex, const void *buf,
1347               ULONGEST offset, LONGEST len)
1348 {
1349   LONGEST xfered = 0;
1350   while (xfered < len)
1351     {
1352       LONGEST xfer = target_write_partial (ops, object, annex,
1353                                            (bfd_byte *) buf + xfered,
1354                                            offset + xfered, len - xfered);
1355       /* Call an observer, notifying them of the xfer progress?  */
1356       if (xfer <= 0)
1357         /* Call memory_error?  */
1358         return -1;
1359       xfered += xfer;
1360       QUIT;
1361     }
1362   return len;
1363 }
1364
1365 /* Memory transfer methods.  */
1366
1367 void
1368 get_target_memory (struct target_ops *ops, CORE_ADDR addr, void *buf,
1369                    LONGEST len)
1370 {
1371   if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1372       != len)
1373     memory_error (EIO, addr);
1374 }
1375
1376 ULONGEST
1377 get_target_memory_unsigned (struct target_ops *ops,
1378                             CORE_ADDR addr, int len)
1379 {
1380   char buf[sizeof (ULONGEST)];
1381
1382   gdb_assert (len <= sizeof (buf));
1383   get_target_memory (ops, addr, buf, len);
1384   return extract_unsigned_integer (buf, len);
1385 }
1386
1387 static void
1388 target_info (char *args, int from_tty)
1389 {
1390   struct target_ops *t;
1391   int has_all_mem = 0;
1392
1393   if (symfile_objfile != NULL)
1394     printf_unfiltered (_("Symbols from \"%s\".\n"), symfile_objfile->name);
1395
1396   for (t = target_stack; t != NULL; t = t->beneath)
1397     {
1398       if (!t->to_has_memory)
1399         continue;
1400
1401       if ((int) (t->to_stratum) <= (int) dummy_stratum)
1402         continue;
1403       if (has_all_mem)
1404         printf_unfiltered (_("\tWhile running this, GDB does not access memory from...\n"));
1405       printf_unfiltered ("%s:\n", t->to_longname);
1406       (t->to_files_info) (t);
1407       has_all_mem = t->to_has_all_memory;
1408     }
1409 }
1410
1411 /* This is to be called by the open routine before it does
1412    anything.  */
1413
1414 void
1415 target_preopen (int from_tty)
1416 {
1417   dont_repeat ();
1418
1419   if (target_has_execution)
1420     {
1421       if (!from_tty
1422           || query (_("A program is being debugged already.  Kill it? ")))
1423         target_kill ();
1424       else
1425         error (_("Program not killed."));
1426     }
1427
1428   /* Calling target_kill may remove the target from the stack.  But if
1429      it doesn't (which seems like a win for UDI), remove it now.  */
1430
1431   if (target_has_execution)
1432     pop_target ();
1433 }
1434
1435 /* Detach a target after doing deferred register stores.  */
1436
1437 void
1438 target_detach (char *args, int from_tty)
1439 {
1440   (current_target.to_detach) (args, from_tty);
1441 }
1442
1443 void
1444 target_disconnect (char *args, int from_tty)
1445 {
1446   (current_target.to_disconnect) (args, from_tty);
1447 }
1448
1449 void
1450 target_link (char *modname, CORE_ADDR *t_reloc)
1451 {
1452   if (DEPRECATED_STREQ (current_target.to_shortname, "rombug"))
1453     {
1454       (current_target.to_lookup_symbol) (modname, t_reloc);
1455       if (*t_reloc == 0)
1456         error (_("Unable to link to %s and get relocation in rombug"), modname);
1457     }
1458   else
1459     *t_reloc = (CORE_ADDR) -1;
1460 }
1461
1462 int
1463 target_async_mask (int mask)
1464 {
1465   int saved_async_masked_status = target_async_mask_value;
1466   target_async_mask_value = mask;
1467   return saved_async_masked_status;
1468 }
1469
1470 /* Look through the list of possible targets for a target that can
1471    execute a run or attach command without any other data.  This is
1472    used to locate the default process stratum.
1473
1474    Result is always valid (error() is called for errors).  */
1475
1476 static struct target_ops *
1477 find_default_run_target (char *do_mesg)
1478 {
1479   struct target_ops **t;
1480   struct target_ops *runable = NULL;
1481   int count;
1482
1483   count = 0;
1484
1485   for (t = target_structs; t < target_structs + target_struct_size;
1486        ++t)
1487     {
1488       if ((*t)->to_can_run && target_can_run (*t))
1489         {
1490           runable = *t;
1491           ++count;
1492         }
1493     }
1494
1495   if (count != 1)
1496     error (_("Don't know how to %s.  Try \"help target\"."), do_mesg);
1497
1498   return runable;
1499 }
1500
1501 void
1502 find_default_attach (char *args, int from_tty)
1503 {
1504   struct target_ops *t;
1505
1506   t = find_default_run_target ("attach");
1507   (t->to_attach) (args, from_tty);
1508   return;
1509 }
1510
1511 void
1512 find_default_create_inferior (char *exec_file, char *allargs, char **env,
1513                               int from_tty)
1514 {
1515   struct target_ops *t;
1516
1517   t = find_default_run_target ("run");
1518   (t->to_create_inferior) (exec_file, allargs, env, from_tty);
1519   return;
1520 }
1521
1522 static int
1523 default_region_size_ok_for_hw_watchpoint (int byte_count)
1524 {
1525   return (byte_count <= TYPE_LENGTH (builtin_type_void_data_ptr));
1526 }
1527
1528 static int
1529 return_zero (void)
1530 {
1531   return 0;
1532 }
1533
1534 static int
1535 return_one (void)
1536 {
1537   return 1;
1538 }
1539
1540 static int
1541 return_minus_one (void)
1542 {
1543   return -1;
1544 }
1545
1546 /*
1547  * Resize the to_sections pointer.  Also make sure that anyone that
1548  * was holding on to an old value of it gets updated.
1549  * Returns the old size.
1550  */
1551
1552 int
1553 target_resize_to_sections (struct target_ops *target, int num_added)
1554 {
1555   struct target_ops **t;
1556   struct section_table *old_value;
1557   int old_count;
1558
1559   old_value = target->to_sections;
1560
1561   if (target->to_sections)
1562     {
1563       old_count = target->to_sections_end - target->to_sections;
1564       target->to_sections = (struct section_table *)
1565         xrealloc ((char *) target->to_sections,
1566                   (sizeof (struct section_table)) * (num_added + old_count));
1567     }
1568   else
1569     {
1570       old_count = 0;
1571       target->to_sections = (struct section_table *)
1572         xmalloc ((sizeof (struct section_table)) * num_added);
1573     }
1574   target->to_sections_end = target->to_sections + (num_added + old_count);
1575
1576   /* Check to see if anyone else was pointing to this structure.
1577      If old_value was null, then no one was. */
1578
1579   if (old_value)
1580     {
1581       for (t = target_structs; t < target_structs + target_struct_size;
1582            ++t)
1583         {
1584           if ((*t)->to_sections == old_value)
1585             {
1586               (*t)->to_sections = target->to_sections;
1587               (*t)->to_sections_end = target->to_sections_end;
1588             }
1589         }
1590       /* There is a flattened view of the target stack in current_target,
1591          so its to_sections pointer might also need updating. */
1592       if (current_target.to_sections == old_value)
1593         {
1594           current_target.to_sections = target->to_sections;
1595           current_target.to_sections_end = target->to_sections_end;
1596         }
1597     }
1598
1599   return old_count;
1600
1601 }
1602
1603 /* Remove all target sections taken from ABFD.
1604
1605    Scan the current target stack for targets whose section tables
1606    refer to sections from BFD, and remove those sections.  We use this
1607    when we notice that the inferior has unloaded a shared object, for
1608    example.  */
1609 void
1610 remove_target_sections (bfd *abfd)
1611 {
1612   struct target_ops **t;
1613
1614   for (t = target_structs; t < target_structs + target_struct_size; t++)
1615     {
1616       struct section_table *src, *dest;
1617
1618       dest = (*t)->to_sections;
1619       for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1620         if (src->bfd != abfd)
1621           {
1622             /* Keep this section.  */
1623             if (dest < src) *dest = *src;
1624             dest++;
1625           }
1626
1627       /* If we've dropped any sections, resize the section table.  */
1628       if (dest < src)
1629         target_resize_to_sections (*t, dest - src);
1630     }
1631 }
1632
1633
1634
1635
1636 /* Find a single runnable target in the stack and return it.  If for
1637    some reason there is more than one, return NULL.  */
1638
1639 struct target_ops *
1640 find_run_target (void)
1641 {
1642   struct target_ops **t;
1643   struct target_ops *runable = NULL;
1644   int count;
1645
1646   count = 0;
1647
1648   for (t = target_structs; t < target_structs + target_struct_size; ++t)
1649     {
1650       if ((*t)->to_can_run && target_can_run (*t))
1651         {
1652           runable = *t;
1653           ++count;
1654         }
1655     }
1656
1657   return (count == 1 ? runable : NULL);
1658 }
1659
1660 /* Find a single core_stratum target in the list of targets and return it.
1661    If for some reason there is more than one, return NULL.  */
1662
1663 struct target_ops *
1664 find_core_target (void)
1665 {
1666   struct target_ops **t;
1667   struct target_ops *runable = NULL;
1668   int count;
1669
1670   count = 0;
1671
1672   for (t = target_structs; t < target_structs + target_struct_size;
1673        ++t)
1674     {
1675       if ((*t)->to_stratum == core_stratum)
1676         {
1677           runable = *t;
1678           ++count;
1679         }
1680     }
1681
1682   return (count == 1 ? runable : NULL);
1683 }
1684
1685 /*
1686  * Find the next target down the stack from the specified target.
1687  */
1688
1689 struct target_ops *
1690 find_target_beneath (struct target_ops *t)
1691 {
1692   return t->beneath;
1693 }
1694
1695 \f
1696 /* The inferior process has died.  Long live the inferior!  */
1697
1698 void
1699 generic_mourn_inferior (void)
1700 {
1701   extern int show_breakpoint_hit_counts;
1702
1703   inferior_ptid = null_ptid;
1704   attach_flag = 0;
1705   breakpoint_init_inferior (inf_exited);
1706   registers_changed ();
1707
1708   reopen_exec_file ();
1709   reinit_frame_cache ();
1710
1711   /* It is confusing to the user for ignore counts to stick around
1712      from previous runs of the inferior.  So clear them.  */
1713   /* However, it is more confusing for the ignore counts to disappear when
1714      using hit counts.  So don't clear them if we're counting hits.  */
1715   if (!show_breakpoint_hit_counts)
1716     breakpoint_clear_ignore_counts ();
1717
1718   if (deprecated_detach_hook)
1719     deprecated_detach_hook ();
1720 }
1721 \f
1722 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1723    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1724    translation of that in OURSTATUS.  */
1725 void
1726 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
1727 {
1728 #ifdef CHILD_SPECIAL_WAITSTATUS
1729   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1730      if it wants to deal with hoststatus.  */
1731   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1732     return;
1733 #endif
1734
1735   if (WIFEXITED (hoststatus))
1736     {
1737       ourstatus->kind = TARGET_WAITKIND_EXITED;
1738       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1739     }
1740   else if (!WIFSTOPPED (hoststatus))
1741     {
1742       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1743       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1744     }
1745   else
1746     {
1747       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1748       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1749     }
1750 }
1751 \f
1752 /* Returns zero to leave the inferior alone, one to interrupt it.  */
1753 int (*target_activity_function) (void);
1754 int target_activity_fd;
1755 \f
1756 /* Convert a normal process ID to a string.  Returns the string in a static
1757    buffer.  */
1758
1759 char *
1760 normal_pid_to_str (ptid_t ptid)
1761 {
1762   static char buf[30];
1763
1764   sprintf (buf, "process %d", PIDGET (ptid));
1765   return buf;
1766 }
1767
1768 /* Error-catcher for target_find_memory_regions */
1769 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
1770 {
1771   error (_("No target."));
1772   return 0;
1773 }
1774
1775 /* Error-catcher for target_make_corefile_notes */
1776 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
1777 {
1778   error (_("No target."));
1779   return NULL;
1780 }
1781
1782 /* Set up the handful of non-empty slots needed by the dummy target
1783    vector.  */
1784
1785 static void
1786 init_dummy_target (void)
1787 {
1788   dummy_target.to_shortname = "None";
1789   dummy_target.to_longname = "None";
1790   dummy_target.to_doc = "";
1791   dummy_target.to_attach = find_default_attach;
1792   dummy_target.to_create_inferior = find_default_create_inferior;
1793   dummy_target.to_pid_to_str = normal_pid_to_str;
1794   dummy_target.to_stratum = dummy_stratum;
1795   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1796   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1797   dummy_target.to_xfer_partial = default_xfer_partial;
1798   dummy_target.to_magic = OPS_MAGIC;
1799 }
1800 \f
1801 static void
1802 debug_to_open (char *args, int from_tty)
1803 {
1804   debug_target.to_open (args, from_tty);
1805
1806   fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1807 }
1808
1809 static void
1810 debug_to_close (int quitting)
1811 {
1812   target_close (&debug_target, quitting);
1813   fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1814 }
1815
1816 void
1817 target_close (struct target_ops *targ, int quitting)
1818 {
1819   if (targ->to_xclose != NULL)
1820     targ->to_xclose (targ, quitting);
1821   else if (targ->to_close != NULL)
1822     targ->to_close (quitting);
1823 }
1824
1825 static void
1826 debug_to_attach (char *args, int from_tty)
1827 {
1828   debug_target.to_attach (args, from_tty);
1829
1830   fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1831 }
1832
1833
1834 static void
1835 debug_to_post_attach (int pid)
1836 {
1837   debug_target.to_post_attach (pid);
1838
1839   fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1840 }
1841
1842 static void
1843 debug_to_detach (char *args, int from_tty)
1844 {
1845   debug_target.to_detach (args, from_tty);
1846
1847   fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1848 }
1849
1850 static void
1851 debug_to_disconnect (char *args, int from_tty)
1852 {
1853   debug_target.to_disconnect (args, from_tty);
1854
1855   fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1856                       args, from_tty);
1857 }
1858
1859 static void
1860 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1861 {
1862   debug_target.to_resume (ptid, step, siggnal);
1863
1864   fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
1865                       step ? "step" : "continue",
1866                       target_signal_to_name (siggnal));
1867 }
1868
1869 static ptid_t
1870 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1871 {
1872   ptid_t retval;
1873
1874   retval = debug_target.to_wait (ptid, status);
1875
1876   fprintf_unfiltered (gdb_stdlog,
1877                       "target_wait (%d, status) = %d,   ", PIDGET (ptid),
1878                       PIDGET (retval));
1879   fprintf_unfiltered (gdb_stdlog, "status->kind = ");
1880   switch (status->kind)
1881     {
1882     case TARGET_WAITKIND_EXITED:
1883       fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
1884                           status->value.integer);
1885       break;
1886     case TARGET_WAITKIND_STOPPED:
1887       fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
1888                           target_signal_to_name (status->value.sig));
1889       break;
1890     case TARGET_WAITKIND_SIGNALLED:
1891       fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
1892                           target_signal_to_name (status->value.sig));
1893       break;
1894     case TARGET_WAITKIND_LOADED:
1895       fprintf_unfiltered (gdb_stdlog, "loaded\n");
1896       break;
1897     case TARGET_WAITKIND_FORKED:
1898       fprintf_unfiltered (gdb_stdlog, "forked\n");
1899       break;
1900     case TARGET_WAITKIND_VFORKED:
1901       fprintf_unfiltered (gdb_stdlog, "vforked\n");
1902       break;
1903     case TARGET_WAITKIND_EXECD:
1904       fprintf_unfiltered (gdb_stdlog, "execd\n");
1905       break;
1906     case TARGET_WAITKIND_SPURIOUS:
1907       fprintf_unfiltered (gdb_stdlog, "spurious\n");
1908       break;
1909     default:
1910       fprintf_unfiltered (gdb_stdlog, "unknown???\n");
1911       break;
1912     }
1913
1914   return retval;
1915 }
1916
1917 static void
1918 debug_print_register (const char * func, int regno)
1919 {
1920   fprintf_unfiltered (gdb_stdlog, "%s ", func);
1921   if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS
1922       && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0')
1923     fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno));
1924   else
1925     fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1926   if (regno >= 0)
1927     {
1928       int i;
1929       unsigned char buf[MAX_REGISTER_SIZE];
1930       deprecated_read_register_gen (regno, buf);
1931       fprintf_unfiltered (gdb_stdlog, " = ");
1932       for (i = 0; i < register_size (current_gdbarch, regno); i++)
1933         {
1934           fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1935         }
1936       if (register_size (current_gdbarch, regno) <= sizeof (LONGEST))
1937         {
1938           fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
1939                               paddr_nz (read_register (regno)),
1940                               paddr_d (read_register (regno)));
1941         }
1942     }
1943   fprintf_unfiltered (gdb_stdlog, "\n");
1944 }
1945
1946 static void
1947 debug_to_fetch_registers (int regno)
1948 {
1949   debug_target.to_fetch_registers (regno);
1950   debug_print_register ("target_fetch_registers", regno);
1951 }
1952
1953 static void
1954 debug_to_store_registers (int regno)
1955 {
1956   debug_target.to_store_registers (regno);
1957   debug_print_register ("target_store_registers", regno);
1958   fprintf_unfiltered (gdb_stdlog, "\n");
1959 }
1960
1961 static void
1962 debug_to_prepare_to_store (void)
1963 {
1964   debug_target.to_prepare_to_store ();
1965
1966   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
1967 }
1968
1969 static int
1970 deprecated_debug_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1971                               int write, struct mem_attrib *attrib,
1972                               struct target_ops *target)
1973 {
1974   int retval;
1975
1976   retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
1977                                                 attrib, target);
1978
1979   fprintf_unfiltered (gdb_stdlog,
1980                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1981                       (unsigned int) memaddr,   /* possable truncate long long */
1982                       len, write ? "write" : "read", retval);
1983
1984   if (retval > 0)
1985     {
1986       int i;
1987
1988       fputs_unfiltered (", bytes =", gdb_stdlog);
1989       for (i = 0; i < retval; i++)
1990         {
1991           if ((((long) &(myaddr[i])) & 0xf) == 0)
1992             {
1993               if (targetdebug < 2 && i > 0)
1994                 {
1995                   fprintf_unfiltered (gdb_stdlog, " ...");
1996                   break;
1997                 }
1998               fprintf_unfiltered (gdb_stdlog, "\n");
1999             }
2000
2001           fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2002         }
2003     }
2004
2005   fputc_unfiltered ('\n', gdb_stdlog);
2006
2007   return retval;
2008 }
2009
2010 static void
2011 debug_to_files_info (struct target_ops *target)
2012 {
2013   debug_target.to_files_info (target);
2014
2015   fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2016 }
2017
2018 static int
2019 debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
2020 {
2021   int retval;
2022
2023   retval = debug_target.to_insert_breakpoint (addr, save);
2024
2025   fprintf_unfiltered (gdb_stdlog,
2026                       "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2027                       (unsigned long) addr,
2028                       (unsigned long) retval);
2029   return retval;
2030 }
2031
2032 static int
2033 debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
2034 {
2035   int retval;
2036
2037   retval = debug_target.to_remove_breakpoint (addr, save);
2038
2039   fprintf_unfiltered (gdb_stdlog,
2040                       "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2041                       (unsigned long) addr,
2042                       (unsigned long) retval);
2043   return retval;
2044 }
2045
2046 static int
2047 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2048 {
2049   int retval;
2050
2051   retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2052
2053   fprintf_unfiltered (gdb_stdlog,
2054                       "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2055                       (unsigned long) type,
2056                       (unsigned long) cnt,
2057                       (unsigned long) from_tty,
2058                       (unsigned long) retval);
2059   return retval;
2060 }
2061
2062 static int
2063 debug_to_region_size_ok_for_hw_watchpoint (int byte_count)
2064 {
2065   CORE_ADDR retval;
2066
2067   retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count);
2068
2069   fprintf_unfiltered (gdb_stdlog,
2070                       "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2071                       (unsigned long) byte_count,
2072                       (unsigned long) retval);
2073   return retval;
2074 }
2075
2076 static int
2077 debug_to_stopped_by_watchpoint (void)
2078 {
2079   int retval;
2080
2081   retval = debug_target.to_stopped_by_watchpoint ();
2082
2083   fprintf_unfiltered (gdb_stdlog,
2084                       "STOPPED_BY_WATCHPOINT () = %ld\n",
2085                       (unsigned long) retval);
2086   return retval;
2087 }
2088
2089 static int
2090 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2091 {
2092   int retval;
2093
2094   retval = debug_target.to_stopped_data_address (target, addr);
2095
2096   fprintf_unfiltered (gdb_stdlog,
2097                       "target_stopped_data_address ([0x%lx]) = %ld\n",
2098                       (unsigned long)*addr,
2099                       (unsigned long)retval);
2100   return retval;
2101 }
2102
2103 static int
2104 debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save)
2105 {
2106   int retval;
2107
2108   retval = debug_target.to_insert_hw_breakpoint (addr, save);
2109
2110   fprintf_unfiltered (gdb_stdlog,
2111                       "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2112                       (unsigned long) addr,
2113                       (unsigned long) retval);
2114   return retval;
2115 }
2116
2117 static int
2118 debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save)
2119 {
2120   int retval;
2121
2122   retval = debug_target.to_remove_hw_breakpoint (addr, save);
2123
2124   fprintf_unfiltered (gdb_stdlog,
2125                       "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2126                       (unsigned long) addr,
2127                       (unsigned long) retval);
2128   return retval;
2129 }
2130
2131 static int
2132 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2133 {
2134   int retval;
2135
2136   retval = debug_target.to_insert_watchpoint (addr, len, type);
2137
2138   fprintf_unfiltered (gdb_stdlog,
2139                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2140                       (unsigned long) addr, len, type, (unsigned long) retval);
2141   return retval;
2142 }
2143
2144 static int
2145 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2146 {
2147   int retval;
2148
2149   retval = debug_target.to_insert_watchpoint (addr, len, type);
2150
2151   fprintf_unfiltered (gdb_stdlog,
2152                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2153                       (unsigned long) addr, len, type, (unsigned long) retval);
2154   return retval;
2155 }
2156
2157 static void
2158 debug_to_terminal_init (void)
2159 {
2160   debug_target.to_terminal_init ();
2161
2162   fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2163 }
2164
2165 static void
2166 debug_to_terminal_inferior (void)
2167 {
2168   debug_target.to_terminal_inferior ();
2169
2170   fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2171 }
2172
2173 static void
2174 debug_to_terminal_ours_for_output (void)
2175 {
2176   debug_target.to_terminal_ours_for_output ();
2177
2178   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2179 }
2180
2181 static void
2182 debug_to_terminal_ours (void)
2183 {
2184   debug_target.to_terminal_ours ();
2185
2186   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2187 }
2188
2189 static void
2190 debug_to_terminal_save_ours (void)
2191 {
2192   debug_target.to_terminal_save_ours ();
2193
2194   fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2195 }
2196
2197 static void
2198 debug_to_terminal_info (char *arg, int from_tty)
2199 {
2200   debug_target.to_terminal_info (arg, from_tty);
2201
2202   fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2203                       from_tty);
2204 }
2205
2206 static void
2207 debug_to_kill (void)
2208 {
2209   debug_target.to_kill ();
2210
2211   fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2212 }
2213
2214 static void
2215 debug_to_load (char *args, int from_tty)
2216 {
2217   debug_target.to_load (args, from_tty);
2218
2219   fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2220 }
2221
2222 static int
2223 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2224 {
2225   int retval;
2226
2227   retval = debug_target.to_lookup_symbol (name, addrp);
2228
2229   fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2230
2231   return retval;
2232 }
2233
2234 static void
2235 debug_to_create_inferior (char *exec_file, char *args, char **env,
2236                           int from_tty)
2237 {
2238   debug_target.to_create_inferior (exec_file, args, env, from_tty);
2239
2240   fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2241                       exec_file, args, from_tty);
2242 }
2243
2244 static void
2245 debug_to_post_startup_inferior (ptid_t ptid)
2246 {
2247   debug_target.to_post_startup_inferior (ptid);
2248
2249   fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2250                       PIDGET (ptid));
2251 }
2252
2253 static void
2254 debug_to_acknowledge_created_inferior (int pid)
2255 {
2256   debug_target.to_acknowledge_created_inferior (pid);
2257
2258   fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2259                       pid);
2260 }
2261
2262 static void
2263 debug_to_insert_fork_catchpoint (int pid)
2264 {
2265   debug_target.to_insert_fork_catchpoint (pid);
2266
2267   fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
2268                       pid);
2269 }
2270
2271 static int
2272 debug_to_remove_fork_catchpoint (int pid)
2273 {
2274   int retval;
2275
2276   retval = debug_target.to_remove_fork_catchpoint (pid);
2277
2278   fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2279                       pid, retval);
2280
2281   return retval;
2282 }
2283
2284 static void
2285 debug_to_insert_vfork_catchpoint (int pid)
2286 {
2287   debug_target.to_insert_vfork_catchpoint (pid);
2288
2289   fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
2290                       pid);
2291 }
2292
2293 static int
2294 debug_to_remove_vfork_catchpoint (int pid)
2295 {
2296   int retval;
2297
2298   retval = debug_target.to_remove_vfork_catchpoint (pid);
2299
2300   fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2301                       pid, retval);
2302
2303   return retval;
2304 }
2305
2306 static int
2307 debug_to_follow_fork (int follow_child)
2308 {
2309   int retval =  debug_target.to_follow_fork (follow_child);
2310
2311   fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2312                       follow_child, retval);
2313
2314   return retval;
2315 }
2316
2317 static void
2318 debug_to_insert_exec_catchpoint (int pid)
2319 {
2320   debug_target.to_insert_exec_catchpoint (pid);
2321
2322   fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
2323                       pid);
2324 }
2325
2326 static int
2327 debug_to_remove_exec_catchpoint (int pid)
2328 {
2329   int retval;
2330
2331   retval = debug_target.to_remove_exec_catchpoint (pid);
2332
2333   fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2334                       pid, retval);
2335
2336   return retval;
2337 }
2338
2339 static int
2340 debug_to_reported_exec_events_per_exec_call (void)
2341 {
2342   int reported_exec_events;
2343
2344   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2345
2346   fprintf_unfiltered (gdb_stdlog,
2347                       "target_reported_exec_events_per_exec_call () = %d\n",
2348                       reported_exec_events);
2349
2350   return reported_exec_events;
2351 }
2352
2353 static int
2354 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2355 {
2356   int has_exited;
2357
2358   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2359
2360   fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2361                       pid, wait_status, *exit_status, has_exited);
2362
2363   return has_exited;
2364 }
2365
2366 static void
2367 debug_to_mourn_inferior (void)
2368 {
2369   debug_target.to_mourn_inferior ();
2370
2371   fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2372 }
2373
2374 static int
2375 debug_to_can_run (void)
2376 {
2377   int retval;
2378
2379   retval = debug_target.to_can_run ();
2380
2381   fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2382
2383   return retval;
2384 }
2385
2386 static void
2387 debug_to_notice_signals (ptid_t ptid)
2388 {
2389   debug_target.to_notice_signals (ptid);
2390
2391   fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2392                       PIDGET (ptid));
2393 }
2394
2395 static int
2396 debug_to_thread_alive (ptid_t ptid)
2397 {
2398   int retval;
2399
2400   retval = debug_target.to_thread_alive (ptid);
2401
2402   fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2403                       PIDGET (ptid), retval);
2404
2405   return retval;
2406 }
2407
2408 static void
2409 debug_to_find_new_threads (void)
2410 {
2411   debug_target.to_find_new_threads ();
2412
2413   fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2414 }
2415
2416 static void
2417 debug_to_stop (void)
2418 {
2419   debug_target.to_stop ();
2420
2421   fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2422 }
2423
2424 static void
2425 debug_to_rcmd (char *command,
2426                struct ui_file *outbuf)
2427 {
2428   debug_target.to_rcmd (command, outbuf);
2429   fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2430 }
2431
2432 static struct symtab_and_line *
2433 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2434 {
2435   struct symtab_and_line *result;
2436   result = debug_target.to_enable_exception_callback (kind, enable);
2437   fprintf_unfiltered (gdb_stdlog,
2438                       "target get_exception_callback_sal (%d, %d)\n",
2439                       kind, enable);
2440   return result;
2441 }
2442
2443 static struct exception_event_record *
2444 debug_to_get_current_exception_event (void)
2445 {
2446   struct exception_event_record *result;
2447   result = debug_target.to_get_current_exception_event ();
2448   fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2449   return result;
2450 }
2451
2452 static char *
2453 debug_to_pid_to_exec_file (int pid)
2454 {
2455   char *exec_file;
2456
2457   exec_file = debug_target.to_pid_to_exec_file (pid);
2458
2459   fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2460                       pid, exec_file);
2461
2462   return exec_file;
2463 }
2464
2465 static void
2466 setup_target_debug (void)
2467 {
2468   memcpy (&debug_target, &current_target, sizeof debug_target);
2469
2470   current_target.to_open = debug_to_open;
2471   current_target.to_close = debug_to_close;
2472   current_target.to_attach = debug_to_attach;
2473   current_target.to_post_attach = debug_to_post_attach;
2474   current_target.to_detach = debug_to_detach;
2475   current_target.to_disconnect = debug_to_disconnect;
2476   current_target.to_resume = debug_to_resume;
2477   current_target.to_wait = debug_to_wait;
2478   current_target.to_fetch_registers = debug_to_fetch_registers;
2479   current_target.to_store_registers = debug_to_store_registers;
2480   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2481   current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
2482   current_target.to_files_info = debug_to_files_info;
2483   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2484   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2485   current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2486   current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2487   current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2488   current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2489   current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2490   current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2491   current_target.to_stopped_data_address = debug_to_stopped_data_address;
2492   current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint;
2493   current_target.to_terminal_init = debug_to_terminal_init;
2494   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2495   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2496   current_target.to_terminal_ours = debug_to_terminal_ours;
2497   current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2498   current_target.to_terminal_info = debug_to_terminal_info;
2499   current_target.to_kill = debug_to_kill;
2500   current_target.to_load = debug_to_load;
2501   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2502   current_target.to_create_inferior = debug_to_create_inferior;
2503   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2504   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2505   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2506   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2507   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2508   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2509   current_target.to_follow_fork = debug_to_follow_fork;
2510   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2511   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2512   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2513   current_target.to_has_exited = debug_to_has_exited;
2514   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2515   current_target.to_can_run = debug_to_can_run;
2516   current_target.to_notice_signals = debug_to_notice_signals;
2517   current_target.to_thread_alive = debug_to_thread_alive;
2518   current_target.to_find_new_threads = debug_to_find_new_threads;
2519   current_target.to_stop = debug_to_stop;
2520   current_target.to_rcmd = debug_to_rcmd;
2521   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2522   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2523   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2524
2525 }
2526 \f
2527
2528 static char targ_desc[] =
2529 "Names of targets and files being debugged.\n\
2530 Shows the entire stack of targets currently in use (including the exec-file,\n\
2531 core-file, and process, if any), as well as the symbol file name.";
2532
2533 static void
2534 do_monitor_command (char *cmd,
2535                  int from_tty)
2536 {
2537   if ((current_target.to_rcmd
2538        == (void (*) (char *, struct ui_file *)) tcomplain)
2539       || (current_target.to_rcmd == debug_to_rcmd
2540           && (debug_target.to_rcmd
2541               == (void (*) (char *, struct ui_file *)) tcomplain)))
2542     error (_("\"monitor\" command not supported by this target."));
2543   target_rcmd (cmd, gdb_stdtarg);
2544 }
2545
2546 void
2547 initialize_targets (void)
2548 {
2549   init_dummy_target ();
2550   push_target (&dummy_target);
2551
2552   add_info ("target", target_info, targ_desc);
2553   add_info ("files", target_info, targ_desc);
2554
2555   deprecated_add_show_from_set
2556     (add_set_cmd ("target", class_maintenance, var_zinteger,
2557                   (char *) &targetdebug,
2558                   "Set target debugging.\n\
2559 When non-zero, target debugging is enabled.  Higher numbers are more\n\
2560 verbose.  Changes do not take effect until the next \"run\" or \"target\"\n\
2561 command.", &setdebuglist),
2562      &showdebuglist);
2563
2564   add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
2565                            &trust_readonly, "\
2566 Set mode for reading from readonly sections.", "\
2567 Show mode for reading from readonly sections.", "\
2568 When this mode is on, memory reads from readonly sections (such as .text)\n\
2569 will be read from the object file instead of from the target.  This will\n\
2570 result in significant performance improvement for remote targets.",
2571                            NULL, /* PRINT: Mode for reading from readonly sections is %s.  */
2572                            NULL, NULL,
2573                            &setlist, &showlist);
2574
2575   add_com ("monitor", class_obscure, do_monitor_command,
2576            "Send a command to the remote monitor (remote targets only).");
2577
2578   target_dcache = dcache_init ();
2579 }