gdb/target.c

   1 /* Select target systems and architectures at runtime for GDB.
   2    Copyright 1990, 1992-1995, 1998, 1999 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include <errno.h>
  23 #include <ctype.h>
  24 #include "gdb_string.h"
  25 #include "target.h"
  26 #include "gdbcmd.h"
  27 #include "symtab.h"
  28 #include "inferior.h"
  29 #include "bfd.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "wait.h"
  33 #include <signal.h>
  34
  35 extern int errno;
  36
  37 static void
  38 target_info PARAMS ((char *, int));
  39
  40 static void
  41 cleanup_target PARAMS ((struct target_ops *));
  42
  43 static void
  44 maybe_kill_then_create_inferior PARAMS ((char *, char *, char **));
  45
  46 static void
  47 default_clone_and_follow_inferior PARAMS ((int, int *));
  48
  49 static void
  50 maybe_kill_then_attach PARAMS ((char *, int));
  51
  52 static void
  53 kill_or_be_killed PARAMS ((int));
  54
  55 static void
  56 default_terminal_info PARAMS ((char *, int));
  57
  58 static int
  59 nosymbol PARAMS ((char *, CORE_ADDR *));
  60
  61 static void
  62 tcomplain PARAMS ((void));
  63
  64 static int
  65 nomemory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
  66
  67 static int
  68 return_zero PARAMS ((void));
  69
  70 static int
  71 return_one PARAMS ((void));
  72
  73 void
  74 target_ignore PARAMS ((void));
  75
  76 static void
  77 target_command PARAMS ((char *, int));
  78
  79 static struct target_ops *
  80 find_default_run_target PARAMS ((char *));
  81
  82 static void
  83 update_current_target PARAMS ((void));
  84
  85 /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
  86    Returns 0 for success, errno code for failure (which includes partial
  87    transfers--if you want a more useful response to partial transfers, try
  88    target_read_memory_partial).  */
  89
  90 static int
  91 target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
  92                             int write, asection *bfd_section));
  93
  94 static void init_dummy_target PARAMS ((void));
  95
  96 static void
  97 debug_to_open PARAMS ((char *, int));
  98
  99 static void
 100 debug_to_close PARAMS ((int));
 101
 102 static void
 103 debug_to_attach PARAMS ((char *, int));
 104
 105 static void
 106 debug_to_detach PARAMS ((char *, int));
 107
 108 static void
 109 debug_to_resume PARAMS ((int, int, enum target_signal));
 110
 111 static int
 112 debug_to_wait PARAMS ((int, struct target_waitstatus *));
 113
 114 static void
 115 debug_to_fetch_registers PARAMS ((int));
 116
 117 static void
 118 debug_to_store_registers PARAMS ((int));
 119
 120 static void
 121 debug_to_prepare_to_store PARAMS ((void));
 122
 123 static int
 124 debug_to_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 125
 126 static void
 127 debug_to_files_info PARAMS ((struct target_ops *));
 128
 129 static int
 130 debug_to_insert_breakpoint PARAMS ((CORE_ADDR, char *));
 131
 132 static int
 133 debug_to_remove_breakpoint PARAMS ((CORE_ADDR, char *));
 134
 135 static void
 136 debug_to_terminal_init PARAMS ((void));
 137
 138 static void
 139 debug_to_terminal_inferior PARAMS ((void));
 140
 141 static void
 142 debug_to_terminal_ours_for_output PARAMS ((void));
 143
 144 static void
 145 debug_to_terminal_ours PARAMS ((void));
 146
 147 static void
 148 debug_to_terminal_info PARAMS ((char *, int));
 149
 150 static void
 151 debug_to_kill PARAMS ((void));
 152
 153 static void
 154 debug_to_load PARAMS ((char *, int));
 155
 156 static int
 157 debug_to_lookup_symbol PARAMS ((char *, CORE_ADDR *));
 158
 159 static void
 160 debug_to_create_inferior PARAMS ((char *, char *, char **));
 161
 162 static void
 163 debug_to_mourn_inferior PARAMS ((void));
 164
 165 static int
 166 debug_to_can_run PARAMS ((void));
 167
 168 static void
 169 debug_to_notice_signals PARAMS ((int));
 170
 171 static int
 172 debug_to_thread_alive PARAMS ((int));
 173
 174 static void
 175 debug_to_stop PARAMS ((void));
 176
 177 static int debug_to_query PARAMS ((int/*char*/, char *, char *, int *));
 178
 179 /* Pointer to array of target architecture structures; the size of the
 180    array; the current index into the array; the allocated size of the
 181    array.  */
 182 struct target_ops **target_structs;
 183 unsigned target_struct_size;
 184 unsigned target_struct_index;
 185 unsigned target_struct_allocsize;
 186 #define DEFAULT_ALLOCSIZE       10
 187
 188 /* The initial current target, so that there is always a semi-valid
 189    current target.  */
 190
 191 static struct target_ops dummy_target;
 192
 193 /* Top of target stack.  */
 194
 195 struct target_stack_item *target_stack;
 196
 197 /* The target structure we are currently using to talk to a process
 198    or file or whatever "inferior" we have.  */
 199
 200 struct target_ops current_target;
 201
 202 /* Command list for target.  */
 203
 204 static struct cmd_list_element *targetlist = NULL;
 205
 206 /* Nonzero if we are debugging an attached outside process
 207    rather than an inferior.  */
 208
 209 int attach_flag;
 210
 211 /* Non-zero if we want to see trace of target level stuff.  */
 212
 213 static int targetdebug = 0;
 214
 215 static void setup_target_debug PARAMS ((void));
 216
 217 /* The user just typed 'target' without the name of a target.  */
 218
 219 /* ARGSUSED */
 220 static void
 221 target_command (arg, from_tty)
 222      char *arg;
 223      int from_tty;
 224 {
 225   fputs_filtered ("Argument required (target name).  Try `help target'\n",
 226                   gdb_stdout);
 227 }
 228
 229 /* Add a possible target architecture to the list.  */
 230
 231 void
 232 add_target (t)
 233      struct target_ops *t;
 234 {
 235   if (!target_structs)
 236     {
 237       target_struct_allocsize = DEFAULT_ALLOCSIZE;
 238       target_structs = (struct target_ops **) xmalloc
 239         (target_struct_allocsize * sizeof (*target_structs));
 240     }
 241   if (target_struct_size >= target_struct_allocsize)
 242     {
 243       target_struct_allocsize *= 2;
 244       target_structs = (struct target_ops **)
 245           xrealloc ((char *) target_structs,
 246                     target_struct_allocsize * sizeof (*target_structs));
 247     }
 248   target_structs[target_struct_size++] = t;
 249 /*  cleanup_target (t);*/
 250
 251   if (targetlist == NULL)
 252     add_prefix_cmd ("target", class_run, target_command,
 253                     "Connect to a target machine or process.\n\
 254 The first argument is the type or protocol of the target machine.\n\
 255 Remaining arguments are interpreted by the target protocol.  For more\n\
 256 information on the arguments for a particular protocol, type\n\
 257 `help target ' followed by the protocol name.",
 258                     &targetlist, "target ", 0, &cmdlist);
 259   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
 260 }
 261
 262 /* Stub functions */
 263
 264 void
 265 target_ignore ()
 266 {
 267 }
 268
 269 /* ARGSUSED */
 270 static int
 271 nomemory (memaddr, myaddr, len, write, t)
 272      CORE_ADDR memaddr;
 273      char *myaddr;
 274      int len;
 275      int write;
 276      struct target_ops *t;
 277 {
 278   errno = EIO;          /* Can't read/write this location */
 279   return 0;             /* No bytes handled */
 280 }
 281
 282 static void
 283 tcomplain ()
 284 {
 285   error ("You can't do that when your target is `%s'",
 286          current_target.to_shortname);
 287 }
 288
 289 void
 290 noprocess ()
 291 {
 292   error ("You can't do that without a process to debug.");
 293 }
 294
 295 /* ARGSUSED */
 296 static int
 297 nosymbol (name, addrp)
 298      char *name;
 299      CORE_ADDR *addrp;
 300 {
 301   return 1;             /* Symbol does not exist in target env */
 302 }
 303
 304 /* ARGSUSED */
 305 void
 306 nosupport_runtime ()
 307 {
 308   if (!inferior_pid)
 309     noprocess ();
 310   else
 311     error ("No run-time support for this");
 312 }
 313
 314
 315 /* ARGSUSED */
 316 static void
 317 default_terminal_info (args, from_tty)
 318      char *args;
 319      int from_tty;
 320 {
 321   printf_unfiltered("No saved terminal information.\n");
 322 }
 323
 324 /* This is the default target_create_inferior and target_attach function.
 325    If the current target is executing, it asks whether to kill it off.
 326    If this function returns without calling error(), it has killed off
 327    the target, and the operation should be attempted.  */
 328
 329 static void
 330 kill_or_be_killed (from_tty)
 331      int from_tty;
 332 {
 333   if (target_has_execution)
 334     {
 335       printf_unfiltered ("You are already running a program:\n");
 336       target_files_info ();
 337       if (query ("Kill it? ")) {
 338         target_kill ();
 339         if (target_has_execution)
 340           error ("Killing the program did not help.");
 341         return;
 342       } else {
 343         error ("Program not killed.");
 344       }
 345     }
 346   tcomplain();
 347 }
 348
 349 static void
 350 maybe_kill_then_attach (args, from_tty)
 351      char *args;
 352      int from_tty;
 353 {
 354   kill_or_be_killed (from_tty);
 355   target_attach (args, from_tty);
 356 }
 357
 358 static void
 359 maybe_kill_then_create_inferior (exec, args, env)
 360      char *exec;
 361      char *args;
 362      char **env;
 363 {
 364   kill_or_be_killed (0);
 365   target_create_inferior (exec, args, env);
 366 }
 367
 368 static void
 369 default_clone_and_follow_inferior (child_pid, followed_child)
 370   int  child_pid;
 371   int  *followed_child;
 372 {
 373   target_clone_and_follow_inferior (child_pid, followed_child);
 374 }
 375
 376 /* Clean up a target struct so it no longer has any zero pointers in it.
 377    We default entries, at least to stubs that print error messages.  */
 378
 379 static void
 380 cleanup_target (t)
 381      struct target_ops *t;
 382 {
 383
 384 #define de_fault(field, value) \
 385   if (!t->field)        t->field = value
 386
 387   /*        FIELD                       DEFAULT VALUE        */
 388
 389   de_fault (to_open,                    (void (*) PARAMS((char *, int))) tcomplain);
 390   de_fault (to_close,                   (void (*) PARAMS((int))) target_ignore);
 391   de_fault (to_attach,                  maybe_kill_then_attach);
 392   de_fault (to_post_attach,             (void (*) PARAMS ((int))) target_ignore);
 393   de_fault (to_require_attach,          maybe_kill_then_attach);
 394   de_fault (to_detach,                  (void (*) PARAMS((char *, int))) target_ignore);
 395   de_fault (to_require_detach,          (void (*) PARAMS((int, char *, int))) target_ignore);
 396   de_fault (to_resume,                  (void (*) PARAMS((int, int, enum target_signal))) noprocess);
 397   de_fault (to_wait,                    (int (*) PARAMS((int, struct target_waitstatus *))) noprocess);
 398   de_fault (to_post_wait,               (void (*) PARAMS ((int, int))) target_ignore);
 399   de_fault (to_fetch_registers,         (void (*) PARAMS((int))) target_ignore);
 400   de_fault (to_store_registers,         (void (*) PARAMS((int))) noprocess);
 401   de_fault (to_prepare_to_store,        (void (*) PARAMS((void))) noprocess);
 402   de_fault (to_xfer_memory,             (int (*) PARAMS((CORE_ADDR, char *, int, int, struct target_ops *))) nomemory);
 403   de_fault (to_files_info,              (void (*) PARAMS((struct target_ops *))) target_ignore);
 404   de_fault (to_insert_breakpoint,       memory_insert_breakpoint);
 405   de_fault (to_remove_breakpoint,       memory_remove_breakpoint);
 406   de_fault (to_terminal_init,           (void (*) PARAMS((void))) target_ignore);
 407   de_fault (to_terminal_inferior,       (void (*) PARAMS ((void))) target_ignore);
 408   de_fault (to_terminal_ours_for_output,(void (*) PARAMS ((void))) target_ignore);
 409   de_fault (to_terminal_ours,           (void (*) PARAMS ((void))) target_ignore);
 410   de_fault (to_terminal_info,           default_terminal_info);
 411   de_fault (to_kill,                    (void (*) PARAMS((void))) noprocess);
 412   de_fault (to_load,                    (void (*) PARAMS((char *, int))) tcomplain);
 413   de_fault (to_lookup_symbol,           (int (*) PARAMS ((char *, CORE_ADDR *))) nosymbol);
 414   de_fault (to_create_inferior,         maybe_kill_then_create_inferior);
 415   de_fault (to_post_startup_inferior,   (void (*) PARAMS ((int))) target_ignore);
 416   de_fault (to_acknowledge_created_inferior,            (void (*) PARAMS((int))) target_ignore);
 417   de_fault (to_clone_and_follow_inferior,               default_clone_and_follow_inferior);
 418   de_fault (to_post_follow_inferior_by_clone,           (void (*) PARAMS ((void))) target_ignore);
 419   de_fault (to_insert_fork_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 420   de_fault (to_remove_fork_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 421   de_fault (to_insert_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
 422   de_fault (to_remove_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
 423   de_fault (to_has_forked,              (int (*) PARAMS ((int, int *))) return_zero);
 424   de_fault (to_has_vforked,             (int (*) PARAMS ((int, int *))) return_zero);
 425   de_fault (to_can_follow_vfork_prior_to_exec, (int (*) PARAMS ((void ))) return_zero);
 426   de_fault (to_post_follow_vfork,       (void (*) PARAMS ((int, int, int, int))) target_ignore);
 427   de_fault (to_insert_exec_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 428   de_fault (to_remove_exec_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 429   de_fault (to_has_execd,               (int (*) PARAMS ((int, char **))) return_zero);
 430   de_fault (to_reported_exec_events_per_exec_call, (int (*) PARAMS ((void))) return_one);
 431   de_fault (to_has_syscall_event,       (int (*) PARAMS ((int, enum target_waitkind *, int *))) return_zero);
 432   de_fault (to_has_exited,              (int (*) PARAMS ((int, int, int *))) return_zero);
 433   de_fault (to_mourn_inferior,          (void (*) PARAMS ((void))) noprocess);
 434   de_fault (to_can_run,                 return_zero);
 435   de_fault (to_notice_signals,          (void (*) PARAMS((int))) target_ignore);
 436   de_fault (to_thread_alive,            (int (*) PARAMS((int))) target_ignore);
 437   de_fault (to_stop,                    (void (*) PARAMS((void))) target_ignore);
 438   de_fault (to_query,                   (int (*) PARAMS((int/*char*/, char*, char *, int *))) target_ignore);
 439   de_fault (to_enable_exception_callback,       (struct symtab_and_line * (*) PARAMS((enum exception_event_kind, int))) nosupport_runtime);
 440   de_fault (to_get_current_exception_event,     (struct exception_event_record * (*) PARAMS((void))) nosupport_runtime);
 441
 442   de_fault (to_pid_to_exec_file,        (char* (*) PARAMS((int))) return_zero);
 443   de_fault (to_core_file_to_sym_file,   (char* (*) PARAMS ((char *))) return_zero);
 444 #undef de_fault
 445 }
 446
 447 /* Go through the target stack from top to bottom, copying over zero entries in
 448    current_target.  In effect, we are doing class inheritance through the
 449    pushed target vectors.  */
 450
 451 static void
 452 update_current_target ()
 453 {
 454   struct target_stack_item *item;
 455   struct target_ops *t;
 456
 457   /* First, reset current_target */
 458   memset (&current_target, 0, sizeof current_target);
 459
 460   for (item = target_stack; item; item = item->next)
 461     {
 462       t = item->target_ops;
 463
 464 #define INHERIT(FIELD, TARGET) \
 465       if (!current_target.FIELD) \
 466         current_target.FIELD = TARGET->FIELD
 467
 468       INHERIT (to_shortname, t);
 469       INHERIT (to_longname, t);
 470       INHERIT (to_doc, t);
 471       INHERIT (to_open, t);
 472       INHERIT (to_close, t);
 473       INHERIT (to_attach, t);
 474       INHERIT (to_post_attach, t);
 475       INHERIT (to_require_attach, t);
 476       INHERIT (to_detach, t);
 477       INHERIT (to_require_detach, t);
 478       INHERIT (to_resume, t);
 479       INHERIT (to_wait, t);
 480       INHERIT (to_post_wait, t);
 481       INHERIT (to_fetch_registers, t);
 482       INHERIT (to_store_registers, t);
 483       INHERIT (to_prepare_to_store, t);
 484       INHERIT (to_xfer_memory, t);
 485       INHERIT (to_files_info, t);
 486       INHERIT (to_insert_breakpoint, t);
 487       INHERIT (to_remove_breakpoint, t);
 488       INHERIT (to_terminal_init, t);
 489       INHERIT (to_terminal_inferior, t);
 490       INHERIT (to_terminal_ours_for_output, t);
 491       INHERIT (to_terminal_ours, t);
 492       INHERIT (to_terminal_info, t);
 493       INHERIT (to_kill, t);
 494       INHERIT (to_load, t);
 495       INHERIT (to_lookup_symbol, t);
 496       INHERIT (to_create_inferior, t);
 497       INHERIT (to_post_startup_inferior, t);
 498       INHERIT (to_acknowledge_created_inferior, t);
 499       INHERIT (to_clone_and_follow_inferior, t);
 500       INHERIT (to_post_follow_inferior_by_clone, t);
 501       INHERIT (to_insert_fork_catchpoint, t);
 502       INHERIT (to_remove_fork_catchpoint, t);
 503       INHERIT (to_insert_vfork_catchpoint, t);
 504       INHERIT (to_remove_vfork_catchpoint, t);
 505       INHERIT (to_has_forked, t);
 506       INHERIT (to_has_vforked, t);
 507       INHERIT (to_can_follow_vfork_prior_to_exec, t);
 508       INHERIT (to_post_follow_vfork, t);
 509       INHERIT (to_insert_exec_catchpoint, t);
 510       INHERIT (to_remove_exec_catchpoint, t);
 511       INHERIT (to_has_execd, t);
 512       INHERIT (to_reported_exec_events_per_exec_call, t);
 513       INHERIT (to_has_syscall_event, t);
 514       INHERIT (to_has_exited, t);
 515       INHERIT (to_mourn_inferior, t);
 516       INHERIT (to_can_run, t);
 517       INHERIT (to_notice_signals, t);
 518       INHERIT (to_thread_alive, t);
 519       INHERIT (to_find_new_threads, t);
 520       INHERIT (to_stop, t);
 521       INHERIT (to_query, t);
 522       INHERIT (to_enable_exception_callback, t);
 523       INHERIT (to_get_current_exception_event, t);
 524       INHERIT (to_pid_to_exec_file, t);
 525       INHERIT (to_core_file_to_sym_file, t);
 526       INHERIT (to_stratum, t);
 527       INHERIT (DONT_USE, t);
 528       INHERIT (to_has_all_memory, t);
 529       INHERIT (to_has_memory, t);
 530       INHERIT (to_has_stack, t);
 531       INHERIT (to_has_registers, t);
 532       INHERIT (to_has_execution, t);
 533       INHERIT (to_has_thread_control, t);
 534       INHERIT (to_sections, t);
 535       INHERIT (to_sections_end, t);
 536       INHERIT (to_magic, t);
 537
 538 #undef INHERIT
 539     }
 540 }
 541
 542 /* Push a new target type into the stack of the existing target accessors,
 543    possibly superseding some of the existing accessors.
 544
 545    Result is zero if the pushed target ended up on top of the stack,
 546    nonzero if at least one target is on top of it.
 547
 548    Rather than allow an empty stack, we always have the dummy target at
 549    the bottom stratum, so we can call the function vectors without
 550    checking them.  */
 551
 552 int
 553 push_target (t)
 554      struct target_ops *t;
 555 {
 556   struct target_stack_item *cur, *prev, *tmp;
 557
 558   /* Check magic number.  If wrong, it probably means someone changed
 559      the struct definition, but not all the places that initialize one.  */
 560   if (t->to_magic != OPS_MAGIC)
 561     {
 562       fprintf_unfiltered(gdb_stderr,
 563                          "Magic number of %s target struct wrong\n",
 564                          t->to_shortname);
 565       abort();
 566     }
 567
 568   /* Find the proper stratum to install this target in. */
 569
 570   for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
 571     {
 572       if ((int)(t->to_stratum) >= (int)(cur->target_ops->to_stratum))
 573         break;
 574     }
 575
 576   /* If there's already targets at this stratum, remove them. */
 577
 578   if (cur)
 579     while (t->to_stratum == cur->target_ops->to_stratum)
 580       {
 581         /* There's already something on this stratum.  Close it off.  */
 582         if (cur->target_ops->to_close)
 583           (cur->target_ops->to_close) (0);
 584         if (prev)
 585           prev->next = cur->next; /* Unchain old target_ops */
 586         else
 587           target_stack = cur->next; /* Unchain first on list */
 588         tmp = cur->next;
 589         free (cur);
 590         cur = tmp;
 591       }
 592
 593   /* We have removed all targets in our stratum, now add the new one.  */
 594
 595   tmp = (struct target_stack_item *)
 596     xmalloc (sizeof (struct target_stack_item));
 597   tmp->next = cur;
 598   tmp->target_ops = t;
 599
 600   if (prev)
 601     prev->next = tmp;
 602   else
 603     target_stack = tmp;
 604
 605   update_current_target ();
 606
 607   cleanup_target (&current_target); /* Fill in the gaps */
 608
 609   if (targetdebug)
 610     setup_target_debug ();
 611
 612   return prev != 0;
 613 }
 614
 615 /* Remove a target_ops vector from the stack, wherever it may be.
 616    Return how many times it was removed (0 or 1).  */
 617
 618 int
 619 unpush_target (t)
 620      struct target_ops *t;
 621 {
 622   struct target_stack_item *cur, *prev;
 623
 624   if (t->to_close)
 625     t->to_close (0);            /* Let it clean up */
 626
 627   /* Look for the specified target.  Note that we assume that a target
 628      can only occur once in the target stack. */
 629
 630   for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
 631     if (cur->target_ops == t)
 632       break;
 633
 634   if (!cur)
 635     return 0;                   /* Didn't find target_ops, quit now */
 636
 637   /* Unchain the target */
 638
 639   if (!prev)
 640     target_stack = cur->next;
 641   else
 642     prev->next = cur->next;
 643
 644   free (cur);                   /* Release the target_stack_item */
 645
 646   update_current_target ();
 647   cleanup_target (&current_target);
 648
 649   return 1;
 650 }
 651
 652 void
 653 pop_target ()
 654 {
 655   (current_target.to_close)(0); /* Let it clean up */
 656   if (unpush_target (target_stack->target_ops) == 1)
 657     return;
 658
 659   fprintf_unfiltered(gdb_stderr,
 660                      "pop_target couldn't find target %s\n",
 661                      current_target.to_shortname);
 662   abort();
 663 }
 664
 665 #undef  MIN
 666 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
 667
 668 /* target_read_string -- read a null terminated string, up to LEN bytes,
 669    from MEMADDR in target.  Set *ERRNOP to the errno code, or 0 if successful.
 670    Set *STRING to a pointer to malloc'd memory containing the data; the caller
 671    is responsible for freeing it.  Return the number of bytes successfully
 672    read.  */
 673
 674 int
 675 target_read_string (memaddr, string, len, errnop)
 676      CORE_ADDR memaddr;
 677      char **string;
 678      int len;
 679      int *errnop;
 680 {
 681   int tlen, origlen, offset, i;
 682   char buf[4];
 683   int errcode = 0;
 684   char *buffer;
 685   int buffer_allocated;
 686   char *bufptr;
 687   unsigned int nbytes_read = 0;
 688
 689   /* Small for testing.  */
 690   buffer_allocated = 4;
 691   buffer = xmalloc (buffer_allocated);
 692   bufptr = buffer;
 693
 694   origlen = len;
 695
 696   while (len > 0)
 697     {
 698       tlen = MIN (len, 4 - (memaddr & 3));
 699       offset = memaddr & 3;
 700
 701       errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0, NULL);
 702       if (errcode != 0)
 703         {
 704           /* The transfer request might have crossed the boundary to an
 705              unallocated region of memory. Retry the transfer, requesting
 706              a single byte.  */
 707           tlen = 1;
 708           offset = 0;
 709           errcode = target_xfer_memory (memaddr, buf, 1, 0, NULL);
 710           if (errcode != 0)
 711             goto done;
 712         }
 713
 714       if (bufptr - buffer + tlen > buffer_allocated)
 715         {
 716           unsigned int bytes;
 717           bytes = bufptr - buffer;
 718           buffer_allocated *= 2;
 719           buffer = xrealloc (buffer, buffer_allocated);
 720           bufptr = buffer + bytes;
 721         }
 722
 723       for (i = 0; i < tlen; i++)
 724         {
 725           *bufptr++ = buf[i + offset];
 726           if (buf[i + offset] == '\000')
 727             {
 728               nbytes_read += i + 1;
 729               goto done;
 730             }
 731         }
 732
 733       memaddr += tlen;
 734       len -= tlen;
 735       nbytes_read += tlen;
 736     }
 737  done:
 738   if (errnop != NULL)
 739     *errnop = errcode;
 740   if (string != NULL)
 741     *string = buffer;
 742   return nbytes_read;
 743 }
 744
 745 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
 746    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
 747    if any error occurs.
 748
 749    If an error occurs, no guarantee is made about the contents of the data at
 750    MYADDR.  In particular, the caller should not depend upon partial reads
 751    filling the buffer with good data.  There is no way for the caller to know
 752    how much good data might have been transfered anyway.  Callers that can
 753    deal with partial reads should call target_read_memory_partial. */
 754
 755 int
 756 target_read_memory (memaddr, myaddr, len)
 757      CORE_ADDR memaddr;
 758      char *myaddr;
 759      int len;
 760 {
 761   return target_xfer_memory (memaddr, myaddr, len, 0, NULL);
 762 }
 763
 764 int
 765 target_read_memory_section (memaddr, myaddr, len, bfd_section)
 766      CORE_ADDR memaddr;
 767      char *myaddr;
 768      int len;
 769      asection *bfd_section;
 770 {
 771   return target_xfer_memory (memaddr, myaddr, len, 0, bfd_section);
 772 }
 773
 774 /* Read LEN bytes of target memory at address MEMADDR, placing the results
 775    in GDB's memory at MYADDR.  Returns a count of the bytes actually read,
 776    and optionally an errno value in the location pointed to by ERRNOPTR
 777    if ERRNOPTR is non-null. */
 778
 779 int
 780 target_read_memory_partial (memaddr, myaddr, len, errnoptr)
 781      CORE_ADDR memaddr;
 782      char *myaddr;
 783      int len;
 784      int *errnoptr;
 785 {
 786   int nread;    /* Number of bytes actually read. */
 787   int errcode;  /* Error from last read. */
 788
 789   /* First try a complete read. */
 790   errcode = target_xfer_memory (memaddr, myaddr, len, 0, NULL);
 791   if (errcode == 0)
 792     {
 793       /* Got it all. */
 794       nread = len;
 795     }
 796   else
 797     {
 798       /* Loop, reading one byte at a time until we get as much as we can. */
 799       for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
 800         {
 801           errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0, NULL);
 802         }
 803       /* If an error, the last read was unsuccessful, so adjust count. */
 804       if (errcode != 0)
 805         {
 806           nread--;
 807         }
 808     }
 809   if (errnoptr != NULL)
 810     {
 811       *errnoptr = errcode;
 812     }
 813   return (nread);
 814 }
 815
 816 int
 817 target_write_memory (memaddr, myaddr, len)
 818      CORE_ADDR memaddr;
 819      char *myaddr;
 820      int len;
 821 {
 822   return target_xfer_memory (memaddr, myaddr, len, 1, NULL);
 823 }
 824
 825 /* This variable is used to pass section information down to targets.  This
 826    *should* be done by adding an argument to the target_xfer_memory function
 827    of all the targets, but I didn't feel like changing 50+ files.  */
 828
 829 asection *target_memory_bfd_section = NULL;
 830
 831 /* Move memory to or from the targets.  Iterate until all of it has
 832    been moved, if necessary.  The top target gets priority; anything
 833    it doesn't want, is offered to the next one down, etc.  Note the
 834    business with curlen:  if an early target says "no, but I have a
 835    boundary overlapping this xfer" then we shorten what we offer to
 836    the subsequent targets so the early guy will get a chance at the
 837    tail before the subsequent ones do.
 838
 839    Result is 0 or errno value.  */
 840
 841 static int
 842 target_xfer_memory (memaddr, myaddr, len, write, bfd_section)
 843      CORE_ADDR memaddr;
 844      char *myaddr;
 845      int len;
 846      int write;
 847      asection *bfd_section;
 848 {
 849   int curlen;
 850   int res;
 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   target_memory_bfd_section = bfd_section;
 859
 860   /* to_xfer_memory is not guaranteed to set errno, even when it returns
 861      0.  */
 862   errno = 0;
 863
 864   /* The quick case is that the top target does it all.  */
 865   res = current_target.to_xfer_memory
 866                         (memaddr, myaddr, len, write, &current_target);
 867   if (res == len)
 868     return 0;
 869
 870   if (res > 0)
 871     goto bump;
 872   /* If res <= 0 then we call it again in the loop.  Ah well.  */
 873
 874   for (; len > 0;)
 875     {
 876       curlen = len;             /* Want to do it all */
 877       for (item = target_stack; item; item = item->next)
 878         {
 879           t = item->target_ops;
 880           if (!t->to_has_memory)
 881             continue;
 882
 883           res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
 884           if (res > 0)
 885             break;              /* Handled all or part of xfer */
 886           if (t->to_has_all_memory)
 887             break;
 888         }
 889
 890       if (res <= 0)
 891         {
 892           /* If this address is for nonexistent memory,
 893              read zeros if reading, or do nothing if writing.  Return error. */
 894           if (!write)
 895             memset (myaddr, 0, len);
 896           if (errno == 0)
 897             return EIO;
 898           else
 899             return errno;
 900         }
 901 bump:
 902       memaddr += res;
 903       myaddr  += res;
 904       len     -= res;
 905     }
 906   return 0;                     /* We managed to cover it all somehow. */
 907 }
 908
 909
 910 /* ARGSUSED */
 911 static void
 912 target_info (args, from_tty)
 913      char *args;
 914      int from_tty;
 915 {
 916   struct target_ops *t;
 917   struct target_stack_item *item;
 918   int has_all_mem = 0;
 919
 920   if (symfile_objfile != NULL)
 921     printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
 922
 923 #ifdef FILES_INFO_HOOK
 924   if (FILES_INFO_HOOK ())
 925     return;
 926 #endif
 927
 928   for (item = target_stack; item; item = item->next)
 929     {
 930       t = item->target_ops;
 931
 932       if (!t->to_has_memory)
 933         continue;
 934
 935       if ((int)(t->to_stratum) <= (int)dummy_stratum)
 936         continue;
 937       if (has_all_mem)
 938         printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
 939       printf_unfiltered("%s:\n", t->to_longname);
 940       (t->to_files_info)(t);
 941       has_all_mem = t->to_has_all_memory;
 942     }
 943 }
 944
 945 /* This is to be called by the open routine before it does
 946    anything.  */
 947
 948 void
 949 target_preopen (from_tty)
 950      int from_tty;
 951 {
 952   dont_repeat();
 953
 954   if (target_has_execution)
 955     {
 956       if (query ("A program is being debugged already.  Kill it? "))
 957         target_kill ();
 958       else
 959         error ("Program not killed.");
 960     }
 961
 962   /* Calling target_kill may remove the target from the stack.  But if
 963      it doesn't (which seems like a win for UDI), remove it now.  */
 964
 965   if (target_has_execution)
 966     pop_target ();
 967 }
 968
 969 /* Detach a target after doing deferred register stores.  */
 970
 971 void
 972 target_detach (args, from_tty)
 973      char *args;
 974      int from_tty;
 975 {
 976   /* Handle any optimized stores to the inferior.  */
 977 #ifdef DO_DEFERRED_STORES
 978   DO_DEFERRED_STORES;
 979 #endif
 980   (current_target.to_detach) (args, from_tty);
 981 }
 982
 983 void
 984 target_link (modname, t_reloc)
 985      char *modname;
 986      CORE_ADDR *t_reloc;
 987 {
 988   if (STREQ(current_target.to_shortname, "rombug"))
 989     {
 990       (current_target.to_lookup_symbol) (modname, t_reloc);
 991       if (*t_reloc == 0)
 992       error("Unable to link to %s and get relocation in rombug", modname);
 993     }
 994   else
 995     *t_reloc = (CORE_ADDR)-1;
 996 }
 997
 998 /* Look through the list of possible targets for a target that can
 999    execute a run or attach command without any other data.  This is
1000    used to locate the default process stratum.
1001
1002    Result is always valid (error() is called for errors).  */
1003
1004 static struct target_ops *
1005 find_default_run_target (do_mesg)
1006      char *do_mesg;
1007 {
1008   struct target_ops **t;
1009   struct target_ops *runable = NULL;
1010   int count;
1011
1012   count = 0;
1013
1014   for (t = target_structs; t < target_structs + target_struct_size;
1015        ++t)
1016     {
1017       if ((*t)->to_can_run && target_can_run(*t))
1018         {
1019           runable = *t;
1020           ++count;
1021         }
1022     }
1023
1024   if (count != 1)
1025     error ("Don't know how to %s.  Try \"help target\".", do_mesg);
1026
1027   return runable;
1028 }
1029
1030 void
1031 find_default_attach (args, from_tty)
1032      char *args;
1033      int from_tty;
1034 {
1035   struct target_ops *t;
1036
1037   t = find_default_run_target("attach");
1038   (t->to_attach) (args, from_tty);
1039   return;
1040 }
1041
1042 void
1043 find_default_require_attach (args, from_tty)
1044      char *args;
1045      int from_tty;
1046 {
1047   struct target_ops *t;
1048
1049   t = find_default_run_target("require_attach");
1050   (t->to_require_attach) (args, from_tty);
1051   return;
1052 }
1053
1054 void
1055 find_default_require_detach (pid, args, from_tty)
1056   int  pid;
1057   char *  args;
1058   int  from_tty;
1059 {
1060   struct target_ops *t;
1061
1062   t = find_default_run_target("require_detach");
1063   (t->to_require_detach) (pid, args, from_tty);
1064   return;
1065 }
1066
1067 void
1068 find_default_create_inferior (exec_file, allargs, env)
1069      char *exec_file;
1070      char *allargs;
1071      char **env;
1072 {
1073   struct target_ops *t;
1074
1075   t = find_default_run_target("run");
1076   (t->to_create_inferior) (exec_file, allargs, env);
1077   return;
1078 }
1079
1080 void
1081 find_default_clone_and_follow_inferior (child_pid, followed_child)
1082   int  child_pid;
1083   int  *followed_child;
1084 {
1085   struct target_ops *t;
1086
1087   t = find_default_run_target("run");
1088   (t->to_clone_and_follow_inferior) (child_pid, followed_child);
1089   return;
1090 }
1091
1092 static int
1093 return_zero ()
1094 {
1095   return 0;
1096 }
1097
1098 static int
1099 return_one ()
1100 {
1101   return 1;
1102 }
1103
1104 /* Find a single runnable target in the stack and return it.  If for
1105    some reason there is more than one, return NULL.  */
1106
1107 struct target_ops *
1108 find_run_target ()
1109 {
1110   struct target_ops **t;
1111   struct target_ops *runable = NULL;
1112   int count;
1113
1114   count = 0;
1115
1116   for (t = target_structs; t < target_structs + target_struct_size; ++t)
1117     {
1118       if ((*t)->to_can_run && target_can_run(*t))
1119         {
1120           runable = *t;
1121           ++count;
1122         }
1123     }
1124
1125   return (count == 1 ? runable : NULL);
1126 }
1127
1128 struct target_ops *
1129 find_core_target ()
1130 {
1131   struct target_ops **t;
1132   struct target_ops *runable = NULL;
1133   int count;
1134
1135   count = 0;
1136
1137   for (t = target_structs; t < target_structs + target_struct_size;
1138        ++t)
1139     {
1140       if ((*t)->to_stratum == core_stratum)
1141         {
1142           runable = *t;
1143           ++count;
1144         }
1145     }
1146
1147   return(count == 1 ? runable : NULL);
1148 }
1149 \f
1150 /* The inferior process has died.  Long live the inferior!  */
1151
1152 void
1153 generic_mourn_inferior ()
1154 {
1155   extern int show_breakpoint_hit_counts;
1156
1157   inferior_pid = 0;
1158   attach_flag = 0;
1159   breakpoint_init_inferior (inf_exited);
1160   registers_changed ();
1161
1162 #ifdef CLEAR_DEFERRED_STORES
1163   /* Delete any pending stores to the inferior... */
1164   CLEAR_DEFERRED_STORES;
1165 #endif
1166
1167   reopen_exec_file ();
1168   reinit_frame_cache ();
1169
1170   /* It is confusing to the user for ignore counts to stick around
1171      from previous runs of the inferior.  So clear them.  */
1172   /* However, it is more confusing for the ignore counts to disappear when
1173      using hit counts.  So don't clear them if we're counting hits.  */
1174   if (!show_breakpoint_hit_counts)
1175     breakpoint_clear_ignore_counts ();
1176 }
1177 \f
1178 /* This table must match in order and size the signals in enum target_signal
1179    in target.h.  */
1180 static struct {
1181   char *name;
1182   char *string;
1183   } signals [] =
1184 {
1185   {"0", "Signal 0"},
1186   {"SIGHUP", "Hangup"},
1187   {"SIGINT", "Interrupt"},
1188   {"SIGQUIT", "Quit"},
1189   {"SIGILL", "Illegal instruction"},
1190   {"SIGTRAP", "Trace/breakpoint trap"},
1191   {"SIGABRT", "Aborted"},
1192   {"SIGEMT", "Emulation trap"},
1193   {"SIGFPE", "Arithmetic exception"},
1194   {"SIGKILL", "Killed"},
1195   {"SIGBUS", "Bus error"},
1196   {"SIGSEGV", "Segmentation fault"},
1197   {"SIGSYS", "Bad system call"},
1198   {"SIGPIPE", "Broken pipe"},
1199   {"SIGALRM", "Alarm clock"},
1200   {"SIGTERM", "Terminated"},
1201   {"SIGURG", "Urgent I/O condition"},
1202   {"SIGSTOP", "Stopped (signal)"},
1203   {"SIGTSTP", "Stopped (user)"},
1204   {"SIGCONT", "Continued"},
1205   {"SIGCHLD", "Child status changed"},
1206   {"SIGTTIN", "Stopped (tty input)"},
1207   {"SIGTTOU", "Stopped (tty output)"},
1208   {"SIGIO", "I/O possible"},
1209   {"SIGXCPU", "CPU time limit exceeded"},
1210   {"SIGXFSZ", "File size limit exceeded"},
1211   {"SIGVTALRM", "Virtual timer expired"},
1212   {"SIGPROF", "Profiling timer expired"},
1213   {"SIGWINCH", "Window size changed"},
1214   {"SIGLOST", "Resource lost"},
1215   {"SIGUSR1", "User defined signal 1"},
1216   {"SIGUSR2", "User defined signal 2"},
1217   {"SIGPWR", "Power fail/restart"},
1218   {"SIGPOLL", "Pollable event occurred"},
1219   {"SIGWIND", "SIGWIND"},
1220   {"SIGPHONE", "SIGPHONE"},
1221   {"SIGWAITING", "Process's LWPs are blocked"},
1222   {"SIGLWP", "Signal LWP"},
1223   {"SIGDANGER", "Swap space dangerously low"},
1224   {"SIGGRANT", "Monitor mode granted"},
1225   {"SIGRETRACT", "Need to relinquish monitor mode"},
1226   {"SIGMSG", "Monitor mode data available"},
1227   {"SIGSOUND", "Sound completed"},
1228   {"SIGSAK", "Secure attention"},
1229   {"SIGPRIO", "SIGPRIO"},
1230   {"SIG33", "Real-time event 33"},
1231   {"SIG34", "Real-time event 34"},
1232   {"SIG35", "Real-time event 35"},
1233   {"SIG36", "Real-time event 36"},
1234   {"SIG37", "Real-time event 37"},
1235   {"SIG38", "Real-time event 38"},
1236   {"SIG39", "Real-time event 39"},
1237   {"SIG40", "Real-time event 40"},
1238   {"SIG41", "Real-time event 41"},
1239   {"SIG42", "Real-time event 42"},
1240   {"SIG43", "Real-time event 43"},
1241   {"SIG44", "Real-time event 44"},
1242   {"SIG45", "Real-time event 45"},
1243   {"SIG46", "Real-time event 46"},
1244   {"SIG47", "Real-time event 47"},
1245   {"SIG48", "Real-time event 48"},
1246   {"SIG49", "Real-time event 49"},
1247   {"SIG50", "Real-time event 50"},
1248   {"SIG51", "Real-time event 51"},
1249   {"SIG52", "Real-time event 52"},
1250   {"SIG53", "Real-time event 53"},
1251   {"SIG54", "Real-time event 54"},
1252   {"SIG55", "Real-time event 55"},
1253   {"SIG56", "Real-time event 56"},
1254   {"SIG57", "Real-time event 57"},
1255   {"SIG58", "Real-time event 58"},
1256   {"SIG59", "Real-time event 59"},
1257   {"SIG60", "Real-time event 60"},
1258   {"SIG61", "Real-time event 61"},
1259   {"SIG62", "Real-time event 62"},
1260   {"SIG63", "Real-time event 63"},
1261   {"SIGCANCEL", "LWP internal signal"},
1262
1263 #if defined(MACH) || defined(__MACH__)
1264   /* Mach exceptions */
1265   {"EXC_BAD_ACCESS", "Could not access memory"},
1266   {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1267   {"EXC_ARITHMETIC", "Arithmetic exception"},
1268   {"EXC_EMULATION", "Emulation instruction"},
1269   {"EXC_SOFTWARE", "Software generated exception"},
1270   {"EXC_BREAKPOINT", "Breakpoint"},
1271 #endif
1272   {"SIGINFO", "Information request"},
1273
1274   {NULL, "Unknown signal"},
1275   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1276
1277   /* Last entry, used to check whether the table is the right size.  */
1278   {NULL, "TARGET_SIGNAL_MAGIC"}
1279 };
1280
1281 /* Return the string for a signal.  */
1282 char *
1283 target_signal_to_string (sig)
1284      enum target_signal sig;
1285 {
1286   if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
1287     return signals[sig].string;
1288   else
1289     return signals[TARGET_SIGNAL_UNKNOWN].string;
1290 }
1291
1292 /* Return the name for a signal.  */
1293 char *
1294 target_signal_to_name (sig)
1295      enum target_signal sig;
1296 {
1297   if (sig == TARGET_SIGNAL_UNKNOWN)
1298     /* I think the code which prints this will always print it along with
1299        the string, so no need to be verbose.  */
1300     return "?";
1301   return signals[sig].name;
1302 }
1303
1304 /* Given a name, return its signal.  */
1305 enum target_signal
1306 target_signal_from_name (name)
1307      char *name;
1308 {
1309   enum target_signal sig;
1310
1311   /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1312      for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
1313      questionable; seems like by now people should call it SIGABRT
1314      instead.  */
1315
1316   /* This ugly cast brought to you by the native VAX compiler.  */
1317   for (sig = TARGET_SIGNAL_HUP;
1318        signals[sig].name != NULL;
1319        sig = (enum target_signal)((int)sig + 1))
1320     if (STREQ (name, signals[sig].name))
1321       return sig;
1322   return TARGET_SIGNAL_UNKNOWN;
1323 }
1324 \f
1325 /* The following functions are to help certain targets deal
1326    with the signal/waitstatus stuff.  They could just as well be in
1327    a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */
1328
1329 /* Convert host signal to our signals.  */
1330 enum target_signal
1331 target_signal_from_host (hostsig)
1332      int hostsig;
1333 {
1334   /* A switch statement would make sense but would require special kludges
1335      to deal with the cases where more than one signal has the same number.  */
1336
1337   if (hostsig == 0) return TARGET_SIGNAL_0;
1338
1339 #if defined (SIGHUP)
1340   if (hostsig == SIGHUP) return TARGET_SIGNAL_HUP;
1341 #endif
1342 #if defined (SIGINT)
1343   if (hostsig == SIGINT) return TARGET_SIGNAL_INT;
1344 #endif
1345 #if defined (SIGQUIT)
1346   if (hostsig == SIGQUIT) return TARGET_SIGNAL_QUIT;
1347 #endif
1348 #if defined (SIGILL)
1349   if (hostsig == SIGILL) return TARGET_SIGNAL_ILL;
1350 #endif
1351 #if defined (SIGTRAP)
1352   if (hostsig == SIGTRAP) return TARGET_SIGNAL_TRAP;
1353 #endif
1354 #if defined (SIGABRT)
1355   if (hostsig == SIGABRT) return TARGET_SIGNAL_ABRT;
1356 #endif
1357 #if defined (SIGEMT)
1358   if (hostsig == SIGEMT) return TARGET_SIGNAL_EMT;
1359 #endif
1360 #if defined (SIGFPE)
1361   if (hostsig == SIGFPE) return TARGET_SIGNAL_FPE;
1362 #endif
1363 #if defined (SIGKILL)
1364   if (hostsig == SIGKILL) return TARGET_SIGNAL_KILL;
1365 #endif
1366 #if defined (SIGBUS)
1367   if (hostsig == SIGBUS) return TARGET_SIGNAL_BUS;
1368 #endif
1369 #if defined (SIGSEGV)
1370   if (hostsig == SIGSEGV) return TARGET_SIGNAL_SEGV;
1371 #endif
1372 #if defined (SIGSYS)
1373   if (hostsig == SIGSYS) return TARGET_SIGNAL_SYS;
1374 #endif
1375 #if defined (SIGPIPE)
1376   if (hostsig == SIGPIPE) return TARGET_SIGNAL_PIPE;
1377 #endif
1378 #if defined (SIGALRM)
1379   if (hostsig == SIGALRM) return TARGET_SIGNAL_ALRM;
1380 #endif
1381 #if defined (SIGTERM)
1382   if (hostsig == SIGTERM) return TARGET_SIGNAL_TERM;
1383 #endif
1384 #if defined (SIGUSR1)
1385   if (hostsig == SIGUSR1) return TARGET_SIGNAL_USR1;
1386 #endif
1387 #if defined (SIGUSR2)
1388   if (hostsig == SIGUSR2) return TARGET_SIGNAL_USR2;
1389 #endif
1390 #if defined (SIGCLD)
1391   if (hostsig == SIGCLD) return TARGET_SIGNAL_CHLD;
1392 #endif
1393 #if defined (SIGCHLD)
1394   if (hostsig == SIGCHLD) return TARGET_SIGNAL_CHLD;
1395 #endif
1396 #if defined (SIGPWR)
1397   if (hostsig == SIGPWR) return TARGET_SIGNAL_PWR;
1398 #endif
1399 #if defined (SIGWINCH)
1400   if (hostsig == SIGWINCH) return TARGET_SIGNAL_WINCH;
1401 #endif
1402 #if defined (SIGURG)
1403   if (hostsig == SIGURG) return TARGET_SIGNAL_URG;
1404 #endif
1405 #if defined (SIGIO)
1406   if (hostsig == SIGIO) return TARGET_SIGNAL_IO;
1407 #endif
1408 #if defined (SIGPOLL)
1409   if (hostsig == SIGPOLL) return TARGET_SIGNAL_POLL;
1410 #endif
1411 #if defined (SIGSTOP)
1412   if (hostsig == SIGSTOP) return TARGET_SIGNAL_STOP;
1413 #endif
1414 #if defined (SIGTSTP)
1415   if (hostsig == SIGTSTP) return TARGET_SIGNAL_TSTP;
1416 #endif
1417 #if defined (SIGCONT)
1418   if (hostsig == SIGCONT) return TARGET_SIGNAL_CONT;
1419 #endif
1420 #if defined (SIGTTIN)
1421   if (hostsig == SIGTTIN) return TARGET_SIGNAL_TTIN;
1422 #endif
1423 #if defined (SIGTTOU)
1424   if (hostsig == SIGTTOU) return TARGET_SIGNAL_TTOU;
1425 #endif
1426 #if defined (SIGVTALRM)
1427   if (hostsig == SIGVTALRM) return TARGET_SIGNAL_VTALRM;
1428 #endif
1429 #if defined (SIGPROF)
1430   if (hostsig == SIGPROF) return TARGET_SIGNAL_PROF;
1431 #endif
1432 #if defined (SIGXCPU)
1433   if (hostsig == SIGXCPU) return TARGET_SIGNAL_XCPU;
1434 #endif
1435 #if defined (SIGXFSZ)
1436   if (hostsig == SIGXFSZ) return TARGET_SIGNAL_XFSZ;
1437 #endif
1438 #if defined (SIGWIND)
1439   if (hostsig == SIGWIND) return TARGET_SIGNAL_WIND;
1440 #endif
1441 #if defined (SIGPHONE)
1442   if (hostsig == SIGPHONE) return TARGET_SIGNAL_PHONE;
1443 #endif
1444 #if defined (SIGLOST)
1445   if (hostsig == SIGLOST) return TARGET_SIGNAL_LOST;
1446 #endif
1447 #if defined (SIGWAITING)
1448   if (hostsig == SIGWAITING) return TARGET_SIGNAL_WAITING;
1449 #endif
1450 #if defined (SIGCANCEL)
1451   if (hostsig == SIGCANCEL) return TARGET_SIGNAL_CANCEL;
1452 #endif
1453 #if defined (SIGLWP)
1454   if (hostsig == SIGLWP) return TARGET_SIGNAL_LWP;
1455 #endif
1456 #if defined (SIGDANGER)
1457   if (hostsig == SIGDANGER) return TARGET_SIGNAL_DANGER;
1458 #endif
1459 #if defined (SIGGRANT)
1460   if (hostsig == SIGGRANT) return TARGET_SIGNAL_GRANT;
1461 #endif
1462 #if defined (SIGRETRACT)
1463   if (hostsig == SIGRETRACT) return TARGET_SIGNAL_RETRACT;
1464 #endif
1465 #if defined (SIGMSG)
1466   if (hostsig == SIGMSG) return TARGET_SIGNAL_MSG;
1467 #endif
1468 #if defined (SIGSOUND)
1469   if (hostsig == SIGSOUND) return TARGET_SIGNAL_SOUND;
1470 #endif
1471 #if defined (SIGSAK)
1472   if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK;
1473 #endif
1474 #if defined (SIGPRIO)
1475   if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO;
1476 #endif
1477
1478   /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
1479 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1480   if (hostsig == _NSIG + EXC_BAD_ACCESS) return TARGET_EXC_BAD_ACCESS;
1481 #endif
1482 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1483   if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) return TARGET_EXC_BAD_INSTRUCTION;
1484 #endif
1485 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1486   if (hostsig == _NSIG + EXC_ARITHMETIC) return TARGET_EXC_ARITHMETIC;
1487 #endif
1488 #if defined (EXC_EMULATION) && defined (_NSIG)
1489   if (hostsig == _NSIG + EXC_EMULATION) return TARGET_EXC_EMULATION;
1490 #endif
1491 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1492   if (hostsig == _NSIG + EXC_SOFTWARE) return TARGET_EXC_SOFTWARE;
1493 #endif
1494 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1495   if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
1496 #endif
1497
1498 #if defined (SIGINFO)
1499   if (hostsig == SIGINFO) return TARGET_SIGNAL_INFO;
1500 #endif
1501
1502 #if defined (REALTIME_LO)
1503   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
1504     return (enum target_signal)
1505       (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
1506 #endif
1507   return TARGET_SIGNAL_UNKNOWN;
1508 }
1509
1510 int
1511 target_signal_to_host (oursig)
1512      enum target_signal oursig;
1513 {
1514   switch (oursig)
1515     {
1516     case TARGET_SIGNAL_0: return 0;
1517
1518 #if defined (SIGHUP)
1519     case TARGET_SIGNAL_HUP: return SIGHUP;
1520 #endif
1521 #if defined (SIGINT)
1522     case TARGET_SIGNAL_INT: return SIGINT;
1523 #endif
1524 #if defined (SIGQUIT)
1525     case TARGET_SIGNAL_QUIT: return SIGQUIT;
1526 #endif
1527 #if defined (SIGILL)
1528     case TARGET_SIGNAL_ILL: return SIGILL;
1529 #endif
1530 #if defined (SIGTRAP)
1531     case TARGET_SIGNAL_TRAP: return SIGTRAP;
1532 #endif
1533 #if defined (SIGABRT)
1534     case TARGET_SIGNAL_ABRT: return SIGABRT;
1535 #endif
1536 #if defined (SIGEMT)
1537     case TARGET_SIGNAL_EMT: return SIGEMT;
1538 #endif
1539 #if defined (SIGFPE)
1540     case TARGET_SIGNAL_FPE: return SIGFPE;
1541 #endif
1542 #if defined (SIGKILL)
1543     case TARGET_SIGNAL_KILL: return SIGKILL;
1544 #endif
1545 #if defined (SIGBUS)
1546     case TARGET_SIGNAL_BUS: return SIGBUS;
1547 #endif
1548 #if defined (SIGSEGV)
1549     case TARGET_SIGNAL_SEGV: return SIGSEGV;
1550 #endif
1551 #if defined (SIGSYS)
1552     case TARGET_SIGNAL_SYS: return SIGSYS;
1553 #endif
1554 #if defined (SIGPIPE)
1555     case TARGET_SIGNAL_PIPE: return SIGPIPE;
1556 #endif
1557 #if defined (SIGALRM)
1558     case TARGET_SIGNAL_ALRM: return SIGALRM;
1559 #endif
1560 #if defined (SIGTERM)
1561     case TARGET_SIGNAL_TERM: return SIGTERM;
1562 #endif
1563 #if defined (SIGUSR1)
1564     case TARGET_SIGNAL_USR1: return SIGUSR1;
1565 #endif
1566 #if defined (SIGUSR2)
1567     case TARGET_SIGNAL_USR2: return SIGUSR2;
1568 #endif
1569 #if defined (SIGCHLD) || defined (SIGCLD)
1570     case TARGET_SIGNAL_CHLD:
1571 #if defined (SIGCHLD)
1572       return SIGCHLD;
1573 #else
1574       return SIGCLD;
1575 #endif
1576 #endif /* SIGCLD or SIGCHLD */
1577 #if defined (SIGPWR)
1578     case TARGET_SIGNAL_PWR: return SIGPWR;
1579 #endif
1580 #if defined (SIGWINCH)
1581     case TARGET_SIGNAL_WINCH: return SIGWINCH;
1582 #endif
1583 #if defined (SIGURG)
1584     case TARGET_SIGNAL_URG: return SIGURG;
1585 #endif
1586 #if defined (SIGIO)
1587     case TARGET_SIGNAL_IO: return SIGIO;
1588 #endif
1589 #if defined (SIGPOLL)
1590     case TARGET_SIGNAL_POLL: return SIGPOLL;
1591 #endif
1592 #if defined (SIGSTOP)
1593     case TARGET_SIGNAL_STOP: return SIGSTOP;
1594 #endif
1595 #if defined (SIGTSTP)
1596     case TARGET_SIGNAL_TSTP: return SIGTSTP;
1597 #endif
1598 #if defined (SIGCONT)
1599     case TARGET_SIGNAL_CONT: return SIGCONT;
1600 #endif
1601 #if defined (SIGTTIN)
1602     case TARGET_SIGNAL_TTIN: return SIGTTIN;
1603 #endif
1604 #if defined (SIGTTOU)
1605     case TARGET_SIGNAL_TTOU: return SIGTTOU;
1606 #endif
1607 #if defined (SIGVTALRM)
1608     case TARGET_SIGNAL_VTALRM: return SIGVTALRM;
1609 #endif
1610 #if defined (SIGPROF)
1611     case TARGET_SIGNAL_PROF: return SIGPROF;
1612 #endif
1613 #if defined (SIGXCPU)
1614     case TARGET_SIGNAL_XCPU: return SIGXCPU;
1615 #endif
1616 #if defined (SIGXFSZ)
1617     case TARGET_SIGNAL_XFSZ: return SIGXFSZ;
1618 #endif
1619 #if defined (SIGWIND)
1620     case TARGET_SIGNAL_WIND: return SIGWIND;
1621 #endif
1622 #if defined (SIGPHONE)
1623     case TARGET_SIGNAL_PHONE: return SIGPHONE;
1624 #endif
1625 #if defined (SIGLOST)
1626     case TARGET_SIGNAL_LOST: return SIGLOST;
1627 #endif
1628 #if defined (SIGWAITING)
1629     case TARGET_SIGNAL_WAITING: return SIGWAITING;
1630 #endif
1631 #if defined (SIGCANCEL)
1632     case TARGET_SIGNAL_CANCEL: return SIGCANCEL;
1633 #endif
1634 #if defined (SIGLWP)
1635     case TARGET_SIGNAL_LWP: return SIGLWP;
1636 #endif
1637 #if defined (SIGDANGER)
1638     case TARGET_SIGNAL_DANGER: return SIGDANGER;
1639 #endif
1640 #if defined (SIGGRANT)
1641     case TARGET_SIGNAL_GRANT: return SIGGRANT;
1642 #endif
1643 #if defined (SIGRETRACT)
1644     case TARGET_SIGNAL_RETRACT: return SIGRETRACT;
1645 #endif
1646 #if defined (SIGMSG)
1647     case TARGET_SIGNAL_MSG: return SIGMSG;
1648 #endif
1649 #if defined (SIGSOUND)
1650     case TARGET_SIGNAL_SOUND: return SIGSOUND;
1651 #endif
1652 #if defined (SIGSAK)
1653     case TARGET_SIGNAL_SAK: return SIGSAK;
1654 #endif
1655 #if defined (SIGPRIO)
1656     case TARGET_SIGNAL_PRIO: return SIGPRIO;
1657 #endif
1658
1659       /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
1660 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1661     case TARGET_EXC_BAD_ACCESS: return _NSIG + EXC_BAD_ACCESS;
1662 #endif
1663 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1664     case TARGET_EXC_BAD_INSTRUCTION: return _NSIG + EXC_BAD_INSTRUCTION;
1665 #endif
1666 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1667     case TARGET_EXC_ARITHMETIC: return _NSIG + EXC_ARITHMETIC;
1668 #endif
1669 #if defined (EXC_EMULATION) && defined (_NSIG)
1670     case TARGET_EXC_EMULATION: return _NSIG + EXC_EMULATION;
1671 #endif
1672 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1673     case TARGET_EXC_SOFTWARE: return _NSIG + EXC_SOFTWARE;
1674 #endif
1675 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1676     case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
1677 #endif
1678
1679 #if defined (SIGINFO)
1680     case TARGET_SIGNAL_INFO: return SIGINFO;
1681 #endif
1682
1683     default:
1684 #if defined (REALTIME_LO)
1685       if (oursig >= TARGET_SIGNAL_REALTIME_33
1686           && oursig <= TARGET_SIGNAL_REALTIME_63)
1687         {
1688           int retsig =
1689             (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + REALTIME_LO;
1690           if (retsig < REALTIME_HI)
1691             return retsig;
1692         }
1693 #endif
1694       /* The user might be trying to do "signal SIGSAK" where this system
1695          doesn't have SIGSAK.  */
1696       warning ("Signal %s does not exist on this system.\n",
1697                target_signal_to_name (oursig));
1698       return 0;
1699     }
1700 }
1701
1702 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1703    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1704    translation of that in OURSTATUS.  */
1705 void
1706 store_waitstatus (ourstatus, hoststatus)
1707      struct target_waitstatus *ourstatus;
1708      int hoststatus;
1709 {
1710 #ifdef CHILD_SPECIAL_WAITSTATUS
1711   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1712      if it wants to deal with hoststatus.  */
1713   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1714     return;
1715 #endif
1716
1717   if (WIFEXITED (hoststatus))
1718     {
1719       ourstatus->kind = TARGET_WAITKIND_EXITED;
1720       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1721     }
1722   else if (!WIFSTOPPED (hoststatus))
1723     {
1724       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1725       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1726     }
1727   else
1728     {
1729       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1730       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1731     }
1732 }
1733 \f
1734 /* In some circumstances we allow a command to specify a numeric
1735    signal.  The idea is to keep these circumstances limited so that
1736    users (and scripts) develop portable habits.  For comparison,
1737    POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1738    numeric signal at all is obscelescent.  We are slightly more
1739    lenient and allow 1-15 which should match host signal numbers on
1740    most systems.  Use of symbolic signal names is strongly encouraged.  */
1741
1742 enum target_signal
1743 target_signal_from_command (num)
1744      int num;
1745 {
1746   if (num >= 1 && num <= 15)
1747     return (enum target_signal)num;
1748   error ("Only signals 1-15 are valid as numeric signals.\n\
1749 Use \"info signals\" for a list of symbolic signals.");
1750 }
1751 \f
1752 /* Returns zero to leave the inferior alone, one to interrupt it.  */
1753 int (*target_activity_function) PARAMS ((void));
1754 int target_activity_fd;
1755 \f
1756 /* Convert a normal process ID to a string.  Returns the string in a static
1757    buffer.  */
1758
1759 char *
1760 normal_pid_to_str (pid)
1761      int pid;
1762 {
1763   static char buf[30];
1764
1765   if (STREQ (current_target.to_shortname, "remote"))
1766     sprintf (buf, "thread %d\0", pid);
1767   else
1768     sprintf (buf, "process %d\0", pid);
1769
1770   return buf;
1771 }
1772
1773 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1774    notification of inferior events such as fork and vork immediately
1775    after the inferior is created.  (This because of how gdb gets an
1776    inferior created via invoking a shell to do it.  In such a scenario,
1777    if the shell init file has commands in it, the shell will fork and
1778    exec for each of those commands, and we will see each such fork
1779    event.  Very bad.)
1780
1781    This function is used by all targets that allow us to request
1782    notification of forks, etc at inferior creation time; e.g., in
1783    target_acknowledge_forked_child.
1784    */
1785 void
1786 normal_target_post_startup_inferior (pid)
1787   int  pid;
1788 {
1789   /* This space intentionally left blank. */
1790 }
1791
1792 /* Set up the handful of non-empty slots needed by the dummy target
1793    vector.  */
1794
1795 static void
1796 init_dummy_target ()
1797 {
1798   dummy_target.to_shortname = "None";
1799   dummy_target.to_longname = "None";
1800   dummy_target.to_doc = "";
1801   dummy_target.to_attach = find_default_attach;
1802   dummy_target.to_require_attach = find_default_require_attach;
1803   dummy_target.to_require_detach = find_default_require_detach;
1804   dummy_target.to_create_inferior = find_default_create_inferior;
1805   dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
1806   dummy_target.to_stratum = dummy_stratum;
1807   dummy_target.to_magic = OPS_MAGIC;
1808 }
1809
1810 \f
1811 static struct target_ops debug_target;
1812
1813 static void
1814 debug_to_open (args, from_tty)
1815      char *args;
1816      int from_tty;
1817 {
1818   debug_target.to_open (args, from_tty);
1819
1820   fprintf_unfiltered (gdb_stderr, "target_open (%s, %d)\n", args, from_tty);
1821 }
1822
1823 static void
1824 debug_to_close (quitting)
1825      int quitting;
1826 {
1827   debug_target.to_close (quitting);
1828
1829   fprintf_unfiltered (gdb_stderr, "target_close (%d)\n", quitting);
1830 }
1831
1832 static void
1833 debug_to_attach (args, from_tty)
1834      char *args;
1835      int from_tty;
1836 {
1837   debug_target.to_attach (args, from_tty);
1838
1839   fprintf_unfiltered (gdb_stderr, "target_attach (%s, %d)\n", args, from_tty);
1840 }
1841
1842
1843 static void
1844 debug_to_post_attach (pid)
1845   int  pid;
1846 {
1847   debug_target.to_post_attach (pid);
1848
1849   fprintf_unfiltered (gdb_stderr, "target_post_attach (%d)\n", pid);
1850 }
1851
1852 static void
1853 debug_to_require_attach (args, from_tty)
1854      char *args;
1855      int from_tty;
1856 {
1857   debug_target.to_require_attach (args, from_tty);
1858
1859   fprintf_unfiltered (gdb_stderr,
1860                       "target_require_attach (%s, %d)\n", args, from_tty);
1861 }
1862
1863 static void
1864 debug_to_detach (args, from_tty)
1865      char *args;
1866      int from_tty;
1867 {
1868   debug_target.to_detach (args, from_tty);
1869
1870   fprintf_unfiltered (gdb_stderr, "target_detach (%s, %d)\n", args, from_tty);
1871 }
1872
1873 static void
1874 debug_to_require_detach (pid, args, from_tty)
1875   int  pid;
1876   char *  args;
1877   int  from_tty;
1878 {
1879   debug_target.to_require_detach (pid, args, from_tty);
1880
1881   fprintf_unfiltered (gdb_stderr,
1882                       "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
1883 }
1884
1885 static void
1886 debug_to_resume (pid, step, siggnal)
1887      int pid;
1888      int step;
1889      enum target_signal siggnal;
1890 {
1891   debug_target.to_resume (pid, step, siggnal);
1892
1893   fprintf_unfiltered (gdb_stderr, "target_resume (%d, %s, %s)\n", pid,
1894                       step ? "step" : "continue",
1895                       target_signal_to_name (siggnal));
1896 }
1897
1898 static int
1899 debug_to_wait (pid, status)
1900      int pid;
1901      struct target_waitstatus *status;
1902 {
1903   int retval;
1904
1905   retval = debug_target.to_wait (pid, status);
1906
1907   fprintf_unfiltered (gdb_stderr,
1908                       "target_wait (%d, status) = %d,   ", pid, retval);
1909   fprintf_unfiltered (gdb_stderr, "status->kind = ");
1910   switch (status->kind)
1911     {
1912     case TARGET_WAITKIND_EXITED:
1913       fprintf_unfiltered (gdb_stderr, "exited, status = %d\n",
1914                           status->value.integer);
1915       break;
1916     case TARGET_WAITKIND_STOPPED:
1917       fprintf_unfiltered (gdb_stderr, "stopped, signal = %s\n",
1918                           target_signal_to_name (status->value.sig));
1919       break;
1920     case TARGET_WAITKIND_SIGNALLED:
1921       fprintf_unfiltered (gdb_stderr, "signalled, signal = %s\n",
1922                           target_signal_to_name (status->value.sig));
1923       break;
1924     case TARGET_WAITKIND_LOADED:
1925       fprintf_unfiltered (gdb_stderr, "loaded\n");
1926       break;
1927     case TARGET_WAITKIND_FORKED:
1928       fprintf_unfiltered (gdb_stderr, "forked\n");
1929       break;
1930     case TARGET_WAITKIND_VFORKED:
1931       fprintf_unfiltered (gdb_stderr, "vforked\n");
1932       break;
1933     case TARGET_WAITKIND_EXECD:
1934       fprintf_unfiltered (gdb_stderr, "execd\n");
1935       break;
1936     case TARGET_WAITKIND_SPURIOUS:
1937       fprintf_unfiltered (gdb_stderr, "spurious\n");
1938       break;
1939     default:
1940       fprintf_unfiltered (gdb_stderr, "unknown???\n");
1941       break;
1942     }
1943
1944   return retval;
1945 }
1946
1947 static void
1948 debug_to_post_wait (pid, status)
1949   int  pid;
1950   int  status;
1951 {
1952   debug_target.to_post_wait (pid, status);
1953
1954   fprintf_unfiltered (gdb_stderr, "target_post_wait (%d, %d)\n",
1955                       pid, status);
1956 }
1957
1958 static void
1959 debug_to_fetch_registers (regno)
1960      int regno;
1961 {
1962   debug_target.to_fetch_registers (regno);
1963
1964   fprintf_unfiltered (gdb_stderr, "target_fetch_registers (%s)",
1965                       regno != -1 ? REGISTER_NAME (regno) : "-1");
1966   if (regno != -1)
1967     fprintf_unfiltered (gdb_stderr, " = 0x%x %d",
1968                         (unsigned long) read_register (regno),
1969                         read_register (regno));
1970   fprintf_unfiltered (gdb_stderr, "\n");
1971 }
1972
1973 static void
1974 debug_to_store_registers (regno)
1975      int regno;
1976 {
1977   debug_target.to_store_registers (regno);
1978
1979   if (regno >= 0 && regno < NUM_REGS)
1980     fprintf_unfiltered (gdb_stderr, "target_store_registers (%s) = 0x%x %d\n",
1981                         REGISTER_NAME (regno),
1982                         (unsigned long) read_register (regno),
1983                         (unsigned long) read_register (regno));
1984   else
1985     fprintf_unfiltered (gdb_stderr, "target_store_registers (%d)\n", regno);
1986 }
1987
1988 static void
1989 debug_to_prepare_to_store ()
1990 {
1991   debug_target.to_prepare_to_store ();
1992
1993   fprintf_unfiltered (gdb_stderr, "target_prepare_to_store ()\n");
1994 }
1995
1996 static int
1997 debug_to_xfer_memory (memaddr, myaddr, len, write, target)
1998      CORE_ADDR memaddr;
1999      char *myaddr;
2000      int len;
2001      int write;
2002      struct target_ops *target;
2003 {
2004   int retval;
2005
2006   retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
2007
2008   fprintf_unfiltered (gdb_stderr,
2009                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2010                       (unsigned int) memaddr, /* possable truncate long long */
2011                       len, write ? "write" : "read", retval);
2012
2013
2014
2015   if (retval > 0)
2016     {
2017       int i;
2018
2019       fputs_unfiltered (", bytes =", gdb_stderr);
2020       for (i = 0; i < retval; i++)
2021         {
2022           if ((((long) &(myaddr[i])) & 0xf) == 0)
2023             fprintf_unfiltered (gdb_stderr, "\n");
2024           fprintf_unfiltered (gdb_stderr, " %02x", myaddr[i] & 0xff);
2025         }
2026     }
2027
2028   fputc_unfiltered ('\n', gdb_stderr);
2029
2030   return retval;
2031 }
2032
2033 static void
2034 debug_to_files_info (target)
2035      struct target_ops *target;
2036 {
2037   debug_target.to_files_info (target);
2038
2039   fprintf_unfiltered (gdb_stderr, "target_files_info (xxx)\n");
2040 }
2041
2042 static int
2043 debug_to_insert_breakpoint (addr, save)
2044      CORE_ADDR addr;
2045      char *save;
2046 {
2047   int retval;
2048
2049   retval = debug_target.to_insert_breakpoint (addr, save);
2050
2051   fprintf_unfiltered (gdb_stderr,
2052                       "target_insert_breakpoint (0x%x, xxx) = %d\n",
2053                       (unsigned long) addr, retval);
2054   return retval;
2055 }
2056
2057 static int
2058 debug_to_remove_breakpoint (addr, save)
2059      CORE_ADDR addr;
2060      char *save;
2061 {
2062   int retval;
2063
2064   retval = debug_target.to_remove_breakpoint (addr, save);
2065
2066   fprintf_unfiltered (gdb_stderr,
2067                       "target_remove_breakpoint (0x%x, xxx) = %d\n",
2068                       (unsigned long)addr, retval);
2069   return retval;
2070 }
2071
2072 static void
2073 debug_to_terminal_init ()
2074 {
2075   debug_target.to_terminal_init ();
2076
2077   fprintf_unfiltered (gdb_stderr, "target_terminal_init ()\n");
2078 }
2079
2080 static void
2081 debug_to_terminal_inferior ()
2082 {
2083   debug_target.to_terminal_inferior ();
2084
2085   fprintf_unfiltered (gdb_stderr, "target_terminal_inferior ()\n");
2086 }
2087
2088 static void
2089 debug_to_terminal_ours_for_output ()
2090 {
2091   debug_target.to_terminal_ours_for_output ();
2092
2093   fprintf_unfiltered (gdb_stderr, "target_terminal_ours_for_output ()\n");
2094 }
2095
2096 static void
2097 debug_to_terminal_ours ()
2098 {
2099   debug_target.to_terminal_ours ();
2100
2101   fprintf_unfiltered (gdb_stderr, "target_terminal_ours ()\n");
2102 }
2103
2104 static void
2105 debug_to_terminal_info (arg, from_tty)
2106      char *arg;
2107      int from_tty;
2108 {
2109   debug_target.to_terminal_info (arg, from_tty);
2110
2111   fprintf_unfiltered (gdb_stderr, "target_terminal_info (%s, %d)\n", arg,
2112                       from_tty);
2113 }
2114
2115 static void
2116 debug_to_kill ()
2117 {
2118   debug_target.to_kill ();
2119
2120   fprintf_unfiltered (gdb_stderr, "target_kill ()\n");
2121 }
2122
2123 static void
2124 debug_to_load (args, from_tty)
2125      char *args;
2126      int from_tty;
2127 {
2128   debug_target.to_load (args, from_tty);
2129
2130   fprintf_unfiltered (gdb_stderr, "target_load (%s, %d)\n", args, from_tty);
2131 }
2132
2133 static int
2134 debug_to_lookup_symbol (name, addrp)
2135      char *name;
2136      CORE_ADDR *addrp;
2137 {
2138   int retval;
2139
2140   retval = debug_target.to_lookup_symbol (name, addrp);
2141
2142   fprintf_unfiltered (gdb_stderr, "target_lookup_symbol (%s, xxx)\n", name);
2143
2144   return retval;
2145 }
2146
2147 static void
2148 debug_to_create_inferior (exec_file, args, env)
2149      char *exec_file;
2150      char *args;
2151      char **env;
2152 {
2153   debug_target.to_create_inferior (exec_file, args, env);
2154
2155   fprintf_unfiltered (gdb_stderr, "target_create_inferior (%s, %s, xxx)\n",
2156                       exec_file, args);
2157 }
2158
2159 static void
2160 debug_to_post_startup_inferior (pid)
2161   int  pid;
2162 {
2163   debug_target.to_post_startup_inferior (pid);
2164
2165   fprintf_unfiltered (gdb_stderr, "target_post_startup_inferior (%d)\n",
2166                       pid);
2167 }
2168
2169 static void
2170 debug_to_acknowledge_created_inferior (pid)
2171   int  pid;
2172 {
2173   debug_target.to_acknowledge_created_inferior (pid);
2174
2175   fprintf_unfiltered (gdb_stderr, "target_acknowledge_created_inferior (%d)\n",
2176                       pid);
2177 }
2178
2179 static void
2180 debug_to_clone_and_follow_inferior (child_pid, followed_child)
2181   int  child_pid;
2182   int  *followed_child;
2183 {
2184   debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
2185
2186   fprintf_unfiltered (gdb_stderr,
2187                       "target_clone_and_follow_inferior (%d, %d)\n",
2188                       child_pid, *followed_child);
2189 }
2190
2191 static void
2192 debug_to_post_follow_inferior_by_clone ()
2193 {
2194   debug_target.to_post_follow_inferior_by_clone ();
2195
2196   fprintf_unfiltered (gdb_stderr, "target_post_follow_inferior_by_clone ()\n");
2197 }
2198
2199 static int
2200 debug_to_insert_fork_catchpoint (pid)
2201   int  pid;
2202 {
2203   int  retval;
2204
2205   retval = debug_target.to_insert_fork_catchpoint (pid);
2206
2207   fprintf_unfiltered (gdb_stderr, "target_insert_fork_catchpoint (%d) = %d\n",
2208                       pid, retval);
2209
2210   return retval;
2211 }
2212
2213 static int
2214 debug_to_remove_fork_catchpoint (pid)
2215   int  pid;
2216 {
2217   int  retval;
2218
2219   retval = debug_target.to_remove_fork_catchpoint (pid);
2220
2221   fprintf_unfiltered (gdb_stderr, "target_remove_fork_catchpoint (%d) = %d\n",
2222                       pid, retval);
2223
2224   return retval;
2225 }
2226
2227 static int
2228 debug_to_insert_vfork_catchpoint (pid)
2229   int  pid;
2230 {
2231   int  retval;
2232
2233   retval = debug_target.to_insert_vfork_catchpoint (pid);
2234
2235   fprintf_unfiltered (gdb_stderr, "target_insert_vfork_catchpoint (%d)= %d\n",
2236                       pid, retval);
2237
2238   return retval;
2239 }
2240
2241 static int
2242 debug_to_remove_vfork_catchpoint (pid)
2243   int  pid;
2244 {
2245   int  retval;
2246
2247   retval = debug_target.to_remove_vfork_catchpoint (pid);
2248
2249   fprintf_unfiltered (gdb_stderr, "target_remove_vfork_catchpoint (%d) = %d\n",
2250                       pid, retval);
2251
2252   return retval;
2253 }
2254
2255 static int
2256 debug_to_has_forked (pid, child_pid)
2257   int  pid;
2258   int *  child_pid;
2259 {
2260   int  has_forked;
2261
2262   has_forked = debug_target.to_has_forked (pid, child_pid);
2263
2264   fprintf_unfiltered (gdb_stderr, "target_has_forked (%d, %d) = %d\n",
2265                       pid, *child_pid, has_forked);
2266
2267   return has_forked;
2268 }
2269
2270 static int
2271 debug_to_has_vforked (pid, child_pid)
2272   int  pid;
2273   int *  child_pid;
2274 {
2275   int  has_vforked;
2276
2277   has_vforked = debug_target.to_has_vforked (pid, child_pid);
2278
2279   fprintf_unfiltered (gdb_stderr, "target_has_vforked (%d, %d) = %d\n",
2280                       pid, *child_pid, has_vforked);
2281
2282   return has_vforked;
2283 }
2284
2285 static int
2286 debug_to_can_follow_vfork_prior_to_exec ()
2287 {
2288   int  can_immediately_follow_vfork;
2289
2290   can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
2291
2292   fprintf_unfiltered (gdb_stderr, "target_can_follow_vfork_prior_to_exec () = %d\n",
2293                       can_immediately_follow_vfork);
2294
2295   return can_immediately_follow_vfork;
2296 }
2297
2298 static void
2299 debug_to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
2300   int  parent_pid;
2301   int  followed_parent;
2302   int  child_pid;
2303   int  followed_child;
2304 {
2305   debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
2306
2307   fprintf_unfiltered (gdb_stderr,
2308                       "target_post_follow_vfork (%d, %d, %d, %d)\n",
2309                       parent_pid, followed_parent, child_pid, followed_child);
2310 }
2311
2312 static int
2313 debug_to_insert_exec_catchpoint (pid)
2314   int  pid;
2315 {
2316   int  retval;
2317
2318   retval = debug_target.to_insert_exec_catchpoint (pid);
2319
2320   fprintf_unfiltered (gdb_stderr, "target_insert_exec_catchpoint (%d) = %d\n",
2321                       pid, retval);
2322
2323   return retval;
2324 }
2325
2326 static int
2327 debug_to_remove_exec_catchpoint (pid)
2328   int  pid;
2329 {
2330   int  retval;
2331
2332   retval = debug_target.to_remove_exec_catchpoint (pid);
2333
2334   fprintf_unfiltered (gdb_stderr, "target_remove_exec_catchpoint (%d) = %d\n",
2335                       pid, retval);
2336
2337   return retval;
2338 }
2339
2340 static int
2341 debug_to_has_execd (pid, execd_pathname)
2342   int  pid;
2343   char **  execd_pathname;
2344 {
2345   int  has_execd;
2346
2347   has_execd = debug_target.to_has_execd (pid, execd_pathname);
2348
2349   fprintf_unfiltered (gdb_stderr, "target_has_execd (%d, %s) = %d\n",
2350                       pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
2351                       has_execd);
2352
2353   return has_execd;
2354 }
2355
2356 static int
2357 debug_to_reported_exec_events_per_exec_call ()
2358 {
2359   int  reported_exec_events;
2360
2361   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2362
2363   fprintf_unfiltered (gdb_stderr,
2364                       "target_reported_exec_events_per_exec_call () = %d\n",
2365                       reported_exec_events);
2366
2367   return reported_exec_events;
2368 }
2369
2370 static int
2371 debug_to_has_syscall_event (pid, kind, syscall_id)
2372   int  pid;
2373   enum target_waitkind *  kind;
2374   int *  syscall_id;
2375 {
2376   int  has_syscall_event;
2377   char *  kind_spelling = "??";
2378
2379   has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
2380   if (has_syscall_event)
2381     {
2382       switch (*kind)
2383         {
2384           case TARGET_WAITKIND_SYSCALL_ENTRY:
2385             kind_spelling = "SYSCALL_ENTRY";
2386             break;
2387           case TARGET_WAITKIND_SYSCALL_RETURN:
2388             kind_spelling = "SYSCALL_RETURN";
2389             break;
2390           default:
2391             break;
2392         }
2393     }
2394
2395   fprintf_unfiltered (gdb_stderr,
2396                       "target_has_syscall_event (%d, %s, %d) = %d\n",
2397                       pid, kind_spelling, *syscall_id, has_syscall_event);
2398
2399   return has_syscall_event;
2400 }
2401
2402 static int
2403 debug_to_has_exited (pid, wait_status, exit_status)
2404   int  pid;
2405   int  wait_status;
2406   int *  exit_status;
2407 {
2408   int  has_exited;
2409
2410   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2411
2412   fprintf_unfiltered (gdb_stderr, "target_has_exited (%d, %d, %d) = %d\n",
2413                       pid, wait_status, *exit_status, has_exited);
2414
2415   return has_exited;
2416 }
2417
2418 static void
2419 debug_to_mourn_inferior ()
2420 {
2421   debug_target.to_mourn_inferior ();
2422
2423   fprintf_unfiltered (gdb_stderr, "target_mourn_inferior ()\n");
2424 }
2425
2426 static int
2427 debug_to_can_run ()
2428 {
2429   int retval;
2430
2431   retval = debug_target.to_can_run ();
2432
2433   fprintf_unfiltered (gdb_stderr, "target_can_run () = %d\n", retval);
2434
2435   return retval;
2436 }
2437
2438 static void
2439 debug_to_notice_signals (pid)
2440      int pid;
2441 {
2442   debug_target.to_notice_signals (pid);
2443
2444   fprintf_unfiltered (gdb_stderr, "target_notice_signals (%d)\n", pid);
2445 }
2446
2447 static int
2448 debug_to_thread_alive (pid)
2449      int pid;
2450 {
2451   int retval;
2452
2453   retval = debug_target.to_thread_alive (pid);
2454
2455   fprintf_unfiltered (gdb_stderr, "target_thread_alive (%d) = %d\n",
2456                       pid, retval);
2457
2458   return retval;
2459 }
2460
2461 static void
2462 debug_to_stop ()
2463 {
2464   debug_target.to_stop ();
2465
2466   fprintf_unfiltered (gdb_stderr, "target_stop ()\n");
2467 }
2468
2469 static int
2470 debug_to_query (type, req, resp, siz)
2471   int type;
2472   char *req;
2473   char *resp;
2474   int *siz;
2475 {
2476   int retval;
2477
2478   retval = debug_target.to_query (type, req, resp, siz);
2479
2480   fprintf_unfiltered (gdb_stderr, "target_query (%c, %s, %s,  %d) = %d\n", type, req, resp, *siz, retval);
2481
2482   return retval;
2483 }
2484
2485 static struct symtab_and_line *
2486 debug_to_enable_exception_callback (kind, enable)
2487   enum exception_event_kind kind;
2488   int enable;
2489 {
2490   struct symtab_and_line *result;
2491   result = debug_target.to_enable_exception_callback (kind, enable);
2492   fprintf_unfiltered (gdb_stderr,
2493                       "target get_exception_callback_sal (%d, %d)\n",
2494                       kind, enable);
2495   return result;
2496 }
2497
2498 static struct exception_event_record *
2499 debug_to_get_current_exception_event ()
2500 {
2501   struct exception_event_record *result;
2502   result = debug_target.to_get_current_exception_event();
2503   fprintf_unfiltered (gdb_stderr, "target get_current_exception_event ()\n");
2504   return result;
2505 }
2506
2507 static char *
2508 debug_to_pid_to_exec_file (pid)
2509   int  pid;
2510 {
2511   char *  exec_file;
2512
2513   exec_file = debug_target.to_pid_to_exec_file (pid);
2514
2515   fprintf_unfiltered (gdb_stderr, "target_pid_to_exec_file (%d) = %s\n",
2516                       pid, exec_file);
2517
2518   return exec_file;
2519 }
2520
2521 static char *
2522 debug_to_core_file_to_sym_file (core)
2523   char *  core;
2524 {
2525   char *  sym_file;
2526
2527   sym_file = debug_target.to_core_file_to_sym_file (core);
2528
2529   fprintf_unfiltered (gdb_stderr, "target_core_file_to_sym_file (%s) = %s\n",
2530                       core, sym_file);
2531
2532   return sym_file;
2533 }
2534
2535 static void
2536 setup_target_debug ()
2537 {
2538   memcpy (&debug_target, &current_target, sizeof debug_target);
2539
2540   current_target.to_open = debug_to_open;
2541   current_target.to_close = debug_to_close;
2542   current_target.to_attach = debug_to_attach;
2543   current_target.to_post_attach = debug_to_post_attach;
2544   current_target.to_require_attach = debug_to_require_attach;
2545   current_target.to_detach = debug_to_detach;
2546   current_target.to_require_detach = debug_to_require_detach;
2547   current_target.to_resume = debug_to_resume;
2548   current_target.to_wait = debug_to_wait;
2549   current_target.to_post_wait = debug_to_post_wait;
2550   current_target.to_fetch_registers = debug_to_fetch_registers;
2551   current_target.to_store_registers = debug_to_store_registers;
2552   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2553   current_target.to_xfer_memory = debug_to_xfer_memory;
2554   current_target.to_files_info = debug_to_files_info;
2555   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2556   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2557   current_target.to_terminal_init = debug_to_terminal_init;
2558   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2559   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2560   current_target.to_terminal_ours = debug_to_terminal_ours;
2561   current_target.to_terminal_info = debug_to_terminal_info;
2562   current_target.to_kill = debug_to_kill;
2563   current_target.to_load = debug_to_load;
2564   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2565   current_target.to_create_inferior = debug_to_create_inferior;
2566   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2567   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2568   current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior;
2569   current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone;
2570   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2571   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2572   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2573   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2574   current_target.to_has_forked = debug_to_has_forked;
2575   current_target.to_has_vforked = debug_to_has_vforked;
2576   current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec;
2577   current_target.to_post_follow_vfork = debug_to_post_follow_vfork;
2578   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2579   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2580   current_target.to_has_execd = debug_to_has_execd;
2581   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2582   current_target.to_has_syscall_event = debug_to_has_syscall_event;
2583   current_target.to_has_exited = debug_to_has_exited;
2584   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2585   current_target.to_can_run = debug_to_can_run;
2586   current_target.to_notice_signals = debug_to_notice_signals;
2587   current_target.to_thread_alive = debug_to_thread_alive;
2588   current_target.to_stop = debug_to_stop;
2589   current_target.to_query = debug_to_query;
2590   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2591   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2592   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2593   current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
2594
2595 }
2596
2597 \f
2598 static char targ_desc[] =
2599     "Names of targets and files being debugged.\n\
2600 Shows the entire stack of targets currently in use (including the exec-file,\n\
2601 core-file, and process, if any), as well as the symbol file name.";
2602
2603 void
2604 initialize_targets ()
2605 {
2606   init_dummy_target ();
2607   push_target (&dummy_target);
2608
2609   add_info ("target", target_info, targ_desc);
2610   add_info ("files", target_info, targ_desc);
2611
2612   add_show_from_set (
2613      add_set_cmd ("targetdebug", class_maintenance, var_zinteger,
2614                   (char *)&targetdebug,
2615                  "Set target debugging.\n\
2616 When non-zero, target debugging is enabled.", &setlist),
2617                      &showlist);
2618
2619   if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
2620     abort ();
2621 }