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