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