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 /* 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 /* Error-catcher for target_find_memory_regions */
1468 /* ARGSUSED */
1469 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
1470 {
1471   error ("No target.");
1472   return 0;
1473 }
1474
1475 /* Error-catcher for target_make_corefile_notes */
1476 /* ARGSUSED */
1477 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
1478 {
1479   error ("No target.");
1480   return NULL;
1481 }
1482
1483 /* Set up the handful of non-empty slots needed by the dummy target
1484    vector.  */
1485
1486 static void
1487 init_dummy_target (void)
1488 {
1489   dummy_target.to_shortname = "None";
1490   dummy_target.to_longname = "None";
1491   dummy_target.to_doc = "";
1492   dummy_target.to_attach = find_default_attach;
1493   dummy_target.to_require_attach = find_default_require_attach;
1494   dummy_target.to_require_detach = find_default_require_detach;
1495   dummy_target.to_create_inferior = find_default_create_inferior;
1496   dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
1497   dummy_target.to_pid_to_str = normal_pid_to_str;
1498   dummy_target.to_stratum = dummy_stratum;
1499   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1500   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1501   dummy_target.to_magic = OPS_MAGIC;
1502 }
1503 \f
1504
1505 static struct target_ops debug_target;
1506
1507 static void
1508 debug_to_open (char *args, int from_tty)
1509 {
1510   debug_target.to_open (args, from_tty);
1511
1512   fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1513 }
1514
1515 static void
1516 debug_to_close (int quitting)
1517 {
1518   debug_target.to_close (quitting);
1519
1520   fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1521 }
1522
1523 static void
1524 debug_to_attach (char *args, int from_tty)
1525 {
1526   debug_target.to_attach (args, from_tty);
1527
1528   fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1529 }
1530
1531
1532 static void
1533 debug_to_post_attach (int pid)
1534 {
1535   debug_target.to_post_attach (pid);
1536
1537   fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1538 }
1539
1540 static void
1541 debug_to_require_attach (char *args, int from_tty)
1542 {
1543   debug_target.to_require_attach (args, from_tty);
1544
1545   fprintf_unfiltered (gdb_stdlog,
1546                       "target_require_attach (%s, %d)\n", args, from_tty);
1547 }
1548
1549 static void
1550 debug_to_detach (char *args, int from_tty)
1551 {
1552   debug_target.to_detach (args, from_tty);
1553
1554   fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1555 }
1556
1557 static void
1558 debug_to_require_detach (int pid, char *args, int from_tty)
1559 {
1560   debug_target.to_require_detach (pid, args, from_tty);
1561
1562   fprintf_unfiltered (gdb_stdlog,
1563                "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
1564 }
1565
1566 static void
1567 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1568 {
1569   debug_target.to_resume (ptid, step, siggnal);
1570
1571   fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
1572                       step ? "step" : "continue",
1573                       target_signal_to_name (siggnal));
1574 }
1575
1576 static ptid_t
1577 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1578 {
1579   ptid_t retval;
1580
1581   retval = debug_target.to_wait (ptid, status);
1582
1583   fprintf_unfiltered (gdb_stdlog,
1584                       "target_wait (%d, status) = %d,   ", PIDGET (ptid),
1585                       PIDGET (retval));
1586   fprintf_unfiltered (gdb_stdlog, "status->kind = ");
1587   switch (status->kind)
1588     {
1589     case TARGET_WAITKIND_EXITED:
1590       fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
1591                           status->value.integer);
1592       break;
1593     case TARGET_WAITKIND_STOPPED:
1594       fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
1595                           target_signal_to_name (status->value.sig));
1596       break;
1597     case TARGET_WAITKIND_SIGNALLED:
1598       fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
1599                           target_signal_to_name (status->value.sig));
1600       break;
1601     case TARGET_WAITKIND_LOADED:
1602       fprintf_unfiltered (gdb_stdlog, "loaded\n");
1603       break;
1604     case TARGET_WAITKIND_FORKED:
1605       fprintf_unfiltered (gdb_stdlog, "forked\n");
1606       break;
1607     case TARGET_WAITKIND_VFORKED:
1608       fprintf_unfiltered (gdb_stdlog, "vforked\n");
1609       break;
1610     case TARGET_WAITKIND_EXECD:
1611       fprintf_unfiltered (gdb_stdlog, "execd\n");
1612       break;
1613     case TARGET_WAITKIND_SPURIOUS:
1614       fprintf_unfiltered (gdb_stdlog, "spurious\n");
1615       break;
1616     default:
1617       fprintf_unfiltered (gdb_stdlog, "unknown???\n");
1618       break;
1619     }
1620
1621   return retval;
1622 }
1623
1624 static void
1625 debug_to_post_wait (ptid_t ptid, int status)
1626 {
1627   debug_target.to_post_wait (ptid, status);
1628
1629   fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
1630                       PIDGET (ptid), status);
1631 }
1632
1633 static void
1634 debug_to_fetch_registers (int regno)
1635 {
1636   debug_target.to_fetch_registers (regno);
1637
1638   fprintf_unfiltered (gdb_stdlog, "target_fetch_registers (%s)",
1639                       regno != -1 ? REGISTER_NAME (regno) : "-1");
1640   if (regno != -1)
1641     fprintf_unfiltered (gdb_stdlog, " = 0x%lx %ld",
1642                         (unsigned long) read_register (regno),
1643                         (unsigned long) read_register (regno));
1644   fprintf_unfiltered (gdb_stdlog, "\n");
1645 }
1646
1647 static void
1648 debug_to_store_registers (int regno)
1649 {
1650   debug_target.to_store_registers (regno);
1651
1652   if (regno >= 0 && regno < NUM_REGS)
1653     fprintf_unfiltered (gdb_stdlog, "target_store_registers (%s) = 0x%lx %ld\n",
1654                         REGISTER_NAME (regno),
1655                         (unsigned long) read_register (regno),
1656                         (unsigned long) read_register (regno));
1657   else
1658     fprintf_unfiltered (gdb_stdlog, "target_store_registers (%d)\n", regno);
1659 }
1660
1661 static void
1662 debug_to_prepare_to_store (void)
1663 {
1664   debug_target.to_prepare_to_store ();
1665
1666   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
1667 }
1668
1669 static int
1670 debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1671                       struct mem_attrib *attrib,
1672                       struct target_ops *target)
1673 {
1674   int retval;
1675
1676   retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write,
1677                                         attrib, target);
1678
1679   fprintf_unfiltered (gdb_stdlog,
1680                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1681                       (unsigned int) memaddr,   /* possable truncate long long */
1682                       len, write ? "write" : "read", retval);
1683
1684
1685
1686   if (retval > 0)
1687     {
1688       int i;
1689
1690       fputs_unfiltered (", bytes =", gdb_stdlog);
1691       for (i = 0; i < retval; i++)
1692         {
1693           if ((((long) &(myaddr[i])) & 0xf) == 0)
1694             fprintf_unfiltered (gdb_stdlog, "\n");
1695           fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1696         }
1697     }
1698
1699   fputc_unfiltered ('\n', gdb_stdlog);
1700
1701   return retval;
1702 }
1703
1704 static void
1705 debug_to_files_info (struct target_ops *target)
1706 {
1707   debug_target.to_files_info (target);
1708
1709   fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
1710 }
1711
1712 static int
1713 debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
1714 {
1715   int retval;
1716
1717   retval = debug_target.to_insert_breakpoint (addr, save);
1718
1719   fprintf_unfiltered (gdb_stdlog,
1720                       "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1721                       (unsigned long) addr,
1722                       (unsigned long) retval);
1723   return retval;
1724 }
1725
1726 static int
1727 debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
1728 {
1729   int retval;
1730
1731   retval = debug_target.to_remove_breakpoint (addr, save);
1732
1733   fprintf_unfiltered (gdb_stdlog,
1734                       "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1735                       (unsigned long) addr,
1736                       (unsigned long) retval);
1737   return retval;
1738 }
1739
1740 static void
1741 debug_to_terminal_init (void)
1742 {
1743   debug_target.to_terminal_init ();
1744
1745   fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
1746 }
1747
1748 static void
1749 debug_to_terminal_inferior (void)
1750 {
1751   debug_target.to_terminal_inferior ();
1752
1753   fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
1754 }
1755
1756 static void
1757 debug_to_terminal_ours_for_output (void)
1758 {
1759   debug_target.to_terminal_ours_for_output ();
1760
1761   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
1762 }
1763
1764 static void
1765 debug_to_terminal_ours (void)
1766 {
1767   debug_target.to_terminal_ours ();
1768
1769   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
1770 }
1771
1772 static void
1773 debug_to_terminal_info (char *arg, int from_tty)
1774 {
1775   debug_target.to_terminal_info (arg, from_tty);
1776
1777   fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
1778                       from_tty);
1779 }
1780
1781 static void
1782 debug_to_kill (void)
1783 {
1784   debug_target.to_kill ();
1785
1786   fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
1787 }
1788
1789 static void
1790 debug_to_load (char *args, int from_tty)
1791 {
1792   debug_target.to_load (args, from_tty);
1793
1794   fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
1795 }
1796
1797 static int
1798 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
1799 {
1800   int retval;
1801
1802   retval = debug_target.to_lookup_symbol (name, addrp);
1803
1804   fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
1805
1806   return retval;
1807 }
1808
1809 static void
1810 debug_to_create_inferior (char *exec_file, char *args, char **env)
1811 {
1812   debug_target.to_create_inferior (exec_file, args, env);
1813
1814   fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx)\n",
1815                       exec_file, args);
1816 }
1817
1818 static void
1819 debug_to_post_startup_inferior (ptid_t ptid)
1820 {
1821   debug_target.to_post_startup_inferior (ptid);
1822
1823   fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
1824                       PIDGET (ptid));
1825 }
1826
1827 static void
1828 debug_to_acknowledge_created_inferior (int pid)
1829 {
1830   debug_target.to_acknowledge_created_inferior (pid);
1831
1832   fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
1833                       pid);
1834 }
1835
1836 static void
1837 debug_to_clone_and_follow_inferior (int child_pid, int *followed_child)
1838 {
1839   debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
1840
1841   fprintf_unfiltered (gdb_stdlog,
1842                       "target_clone_and_follow_inferior (%d, %d)\n",
1843                       child_pid, *followed_child);
1844 }
1845
1846 static void
1847 debug_to_post_follow_inferior_by_clone (void)
1848 {
1849   debug_target.to_post_follow_inferior_by_clone ();
1850
1851   fprintf_unfiltered (gdb_stdlog, "target_post_follow_inferior_by_clone ()\n");
1852 }
1853
1854 static int
1855 debug_to_insert_fork_catchpoint (int pid)
1856 {
1857   int retval;
1858
1859   retval = debug_target.to_insert_fork_catchpoint (pid);
1860
1861   fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
1862                       pid, retval);
1863
1864   return retval;
1865 }
1866
1867 static int
1868 debug_to_remove_fork_catchpoint (int pid)
1869 {
1870   int retval;
1871
1872   retval = debug_target.to_remove_fork_catchpoint (pid);
1873
1874   fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
1875                       pid, retval);
1876
1877   return retval;
1878 }
1879
1880 static int
1881 debug_to_insert_vfork_catchpoint (int pid)
1882 {
1883   int retval;
1884
1885   retval = debug_target.to_insert_vfork_catchpoint (pid);
1886
1887   fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
1888                       pid, retval);
1889
1890   return retval;
1891 }
1892
1893 static int
1894 debug_to_remove_vfork_catchpoint (int pid)
1895 {
1896   int retval;
1897
1898   retval = debug_target.to_remove_vfork_catchpoint (pid);
1899
1900   fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
1901                       pid, retval);
1902
1903   return retval;
1904 }
1905
1906 static int
1907 debug_to_has_forked (int pid, int *child_pid)
1908 {
1909   int has_forked;
1910
1911   has_forked = debug_target.to_has_forked (pid, child_pid);
1912
1913   fprintf_unfiltered (gdb_stdlog, "target_has_forked (%d, %d) = %d\n",
1914                       pid, *child_pid, has_forked);
1915
1916   return has_forked;
1917 }
1918
1919 static int
1920 debug_to_has_vforked (int pid, int *child_pid)
1921 {
1922   int has_vforked;
1923
1924   has_vforked = debug_target.to_has_vforked (pid, child_pid);
1925
1926   fprintf_unfiltered (gdb_stdlog, "target_has_vforked (%d, %d) = %d\n",
1927                       pid, *child_pid, has_vforked);
1928
1929   return has_vforked;
1930 }
1931
1932 static int
1933 debug_to_can_follow_vfork_prior_to_exec (void)
1934 {
1935   int can_immediately_follow_vfork;
1936
1937   can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
1938
1939   fprintf_unfiltered (gdb_stdlog, "target_can_follow_vfork_prior_to_exec () = %d\n",
1940                       can_immediately_follow_vfork);
1941
1942   return can_immediately_follow_vfork;
1943 }
1944
1945 static void
1946 debug_to_post_follow_vfork (int parent_pid, int followed_parent, int child_pid,
1947                             int followed_child)
1948 {
1949   debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
1950
1951   fprintf_unfiltered (gdb_stdlog,
1952                       "target_post_follow_vfork (%d, %d, %d, %d)\n",
1953                     parent_pid, followed_parent, child_pid, followed_child);
1954 }
1955
1956 static int
1957 debug_to_insert_exec_catchpoint (int pid)
1958 {
1959   int retval;
1960
1961   retval = debug_target.to_insert_exec_catchpoint (pid);
1962
1963   fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
1964                       pid, retval);
1965
1966   return retval;
1967 }
1968
1969 static int
1970 debug_to_remove_exec_catchpoint (int pid)
1971 {
1972   int retval;
1973
1974   retval = debug_target.to_remove_exec_catchpoint (pid);
1975
1976   fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
1977                       pid, retval);
1978
1979   return retval;
1980 }
1981
1982 static int
1983 debug_to_has_execd (int pid, char **execd_pathname)
1984 {
1985   int has_execd;
1986
1987   has_execd = debug_target.to_has_execd (pid, execd_pathname);
1988
1989   fprintf_unfiltered (gdb_stdlog, "target_has_execd (%d, %s) = %d\n",
1990                       pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
1991                       has_execd);
1992
1993   return has_execd;
1994 }
1995
1996 static int
1997 debug_to_reported_exec_events_per_exec_call (void)
1998 {
1999   int reported_exec_events;
2000
2001   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2002
2003   fprintf_unfiltered (gdb_stdlog,
2004                       "target_reported_exec_events_per_exec_call () = %d\n",
2005                       reported_exec_events);
2006
2007   return reported_exec_events;
2008 }
2009
2010 static int
2011 debug_to_has_syscall_event (int pid, enum target_waitkind *kind,
2012                             int *syscall_id)
2013 {
2014   int has_syscall_event;
2015   char *kind_spelling = "??";
2016
2017   has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
2018   if (has_syscall_event)
2019     {
2020       switch (*kind)
2021         {
2022         case TARGET_WAITKIND_SYSCALL_ENTRY:
2023           kind_spelling = "SYSCALL_ENTRY";
2024           break;
2025         case TARGET_WAITKIND_SYSCALL_RETURN:
2026           kind_spelling = "SYSCALL_RETURN";
2027           break;
2028         default:
2029           break;
2030         }
2031     }
2032
2033   fprintf_unfiltered (gdb_stdlog,
2034                       "target_has_syscall_event (%d, %s, %d) = %d\n",
2035                       pid, kind_spelling, *syscall_id, has_syscall_event);
2036
2037   return has_syscall_event;
2038 }
2039
2040 static int
2041 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2042 {
2043   int has_exited;
2044
2045   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2046
2047   fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2048                       pid, wait_status, *exit_status, has_exited);
2049
2050   return has_exited;
2051 }
2052
2053 static void
2054 debug_to_mourn_inferior (void)
2055 {
2056   debug_target.to_mourn_inferior ();
2057
2058   fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2059 }
2060
2061 static int
2062 debug_to_can_run (void)
2063 {
2064   int retval;
2065
2066   retval = debug_target.to_can_run ();
2067
2068   fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2069
2070   return retval;
2071 }
2072
2073 static void
2074 debug_to_notice_signals (ptid_t ptid)
2075 {
2076   debug_target.to_notice_signals (ptid);
2077
2078   fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2079                       PIDGET (ptid));
2080 }
2081
2082 static int
2083 debug_to_thread_alive (ptid_t ptid)
2084 {
2085   int retval;
2086
2087   retval = debug_target.to_thread_alive (ptid);
2088
2089   fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2090                       PIDGET (ptid), retval);
2091
2092   return retval;
2093 }
2094
2095 static void
2096 debug_to_find_new_threads (void)
2097 {
2098   debug_target.to_find_new_threads ();
2099
2100   fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2101 }
2102
2103 static void
2104 debug_to_stop (void)
2105 {
2106   debug_target.to_stop ();
2107
2108   fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2109 }
2110
2111 static int
2112 debug_to_query (int type, char *req, char *resp, int *siz)
2113 {
2114   int retval;
2115
2116   retval = debug_target.to_query (type, req, resp, siz);
2117
2118   fprintf_unfiltered (gdb_stdlog, "target_query (%c, %s, %s,  %d) = %d\n", type, req, resp, *siz, retval);
2119
2120   return retval;
2121 }
2122
2123 static void
2124 debug_to_rcmd (char *command,
2125                struct ui_file *outbuf)
2126 {
2127   debug_target.to_rcmd (command, outbuf);
2128   fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2129 }
2130
2131 static struct symtab_and_line *
2132 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2133 {
2134   struct symtab_and_line *result;
2135   result = debug_target.to_enable_exception_callback (kind, enable);
2136   fprintf_unfiltered (gdb_stdlog,
2137                       "target get_exception_callback_sal (%d, %d)\n",
2138                       kind, enable);
2139   return result;
2140 }
2141
2142 static struct exception_event_record *
2143 debug_to_get_current_exception_event (void)
2144 {
2145   struct exception_event_record *result;
2146   result = debug_target.to_get_current_exception_event ();
2147   fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2148   return result;
2149 }
2150
2151 static char *
2152 debug_to_pid_to_exec_file (int pid)
2153 {
2154   char *exec_file;
2155
2156   exec_file = debug_target.to_pid_to_exec_file (pid);
2157
2158   fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2159                       pid, exec_file);
2160
2161   return exec_file;
2162 }
2163
2164 static void
2165 setup_target_debug (void)
2166 {
2167   memcpy (&debug_target, &current_target, sizeof debug_target);
2168
2169   current_target.to_open = debug_to_open;
2170   current_target.to_close = debug_to_close;
2171   current_target.to_attach = debug_to_attach;
2172   current_target.to_post_attach = debug_to_post_attach;
2173   current_target.to_require_attach = debug_to_require_attach;
2174   current_target.to_detach = debug_to_detach;
2175   current_target.to_require_detach = debug_to_require_detach;
2176   current_target.to_resume = debug_to_resume;
2177   current_target.to_wait = debug_to_wait;
2178   current_target.to_post_wait = debug_to_post_wait;
2179   current_target.to_fetch_registers = debug_to_fetch_registers;
2180   current_target.to_store_registers = debug_to_store_registers;
2181   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2182   current_target.to_xfer_memory = debug_to_xfer_memory;
2183   current_target.to_files_info = debug_to_files_info;
2184   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2185   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2186   current_target.to_terminal_init = debug_to_terminal_init;
2187   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2188   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2189   current_target.to_terminal_ours = debug_to_terminal_ours;
2190   current_target.to_terminal_info = debug_to_terminal_info;
2191   current_target.to_kill = debug_to_kill;
2192   current_target.to_load = debug_to_load;
2193   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2194   current_target.to_create_inferior = debug_to_create_inferior;
2195   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2196   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2197   current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior;
2198   current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone;
2199   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2200   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2201   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2202   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2203   current_target.to_has_forked = debug_to_has_forked;
2204   current_target.to_has_vforked = debug_to_has_vforked;
2205   current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec;
2206   current_target.to_post_follow_vfork = debug_to_post_follow_vfork;
2207   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2208   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2209   current_target.to_has_execd = debug_to_has_execd;
2210   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2211   current_target.to_has_syscall_event = debug_to_has_syscall_event;
2212   current_target.to_has_exited = debug_to_has_exited;
2213   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2214   current_target.to_can_run = debug_to_can_run;
2215   current_target.to_notice_signals = debug_to_notice_signals;
2216   current_target.to_thread_alive = debug_to_thread_alive;
2217   current_target.to_find_new_threads = debug_to_find_new_threads;
2218   current_target.to_stop = debug_to_stop;
2219   current_target.to_query = debug_to_query;
2220   current_target.to_rcmd = debug_to_rcmd;
2221   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2222   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2223   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2224
2225 }
2226 \f
2227
2228 static char targ_desc[] =
2229 "Names of targets and files being debugged.\n\
2230 Shows the entire stack of targets currently in use (including the exec-file,\n\
2231 core-file, and process, if any), as well as the symbol file name.";
2232
2233 static void
2234 do_monitor_command (char *cmd,
2235                  int from_tty)
2236 {
2237   if ((current_target.to_rcmd
2238        == (void (*) (char *, struct ui_file *)) tcomplain)
2239       || (current_target.to_rcmd == debug_to_rcmd
2240           && (debug_target.to_rcmd
2241               == (void (*) (char *, struct ui_file *)) tcomplain)))
2242     {
2243       error ("\"monitor\" command not supported by this target.\n");
2244     }
2245   target_rcmd (cmd, gdb_stdtarg);
2246 }
2247
2248 void
2249 initialize_targets (void)
2250 {
2251   init_dummy_target ();
2252   push_target (&dummy_target);
2253
2254   add_info ("target", target_info, targ_desc);
2255   add_info ("files", target_info, targ_desc);
2256
2257   add_show_from_set (
2258                 add_set_cmd ("target", class_maintenance, var_zinteger,
2259                              (char *) &targetdebug,
2260                              "Set target debugging.\n\
2261 When non-zero, target debugging is enabled.", &setdebuglist),
2262                       &showdebuglist);
2263
2264
2265   add_com ("monitor", class_obscure, do_monitor_command,
2266            "Send a command to the remote monitor (remote targets only).");
2267
2268   target_dcache = dcache_init();
2269 }