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