gdb/target.c

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