gdb/target.c

   1 /* Select target systems and architectures at runtime for GDB.
   2    Copyright 1990, 1992, 1993, 1994, 1995 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 maybe_kill_then_attach PARAMS ((char *, int));
  48
  49 static void
  50 kill_or_be_killed PARAMS ((int));
  51
  52 static void
  53 default_terminal_info PARAMS ((char *, int));
  54
  55 static int
  56 nosymbol PARAMS ((char *, CORE_ADDR *));
  57
  58 static void
  59 tcomplain PARAMS ((void));
  60
  61 static int
  62 nomemory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
  63
  64 static int
  65 return_zero PARAMS ((void));
  66
  67 static void
  68 ignore PARAMS ((void));
  69
  70 static void
  71 target_command PARAMS ((char *, int));
  72
  73 static struct target_ops *
  74 find_default_run_target PARAMS ((char *));
  75
  76 /* Pointer to array of target architecture structures; the size of the
  77    array; the current index into the array; the allocated size of the
  78    array.  */
  79 struct target_ops **target_structs;
  80 unsigned target_struct_size;
  81 unsigned target_struct_index;
  82 unsigned target_struct_allocsize;
  83 #define DEFAULT_ALLOCSIZE       10
  84
  85 /* The initial current target, so that there is always a semi-valid
  86    current target.  */
  87
  88 struct target_ops dummy_target = {
  89   "None",                       /* to_shortname */
  90   "None",                       /* to_longname */
  91   "",                           /* to_doc */
  92   0,                            /* to_open */
  93   0,                            /* to_close */
  94   find_default_attach,          /* to_attach */
  95   0,                            /* to_detach */
  96   0,                            /* to_resume */
  97   0,                            /* to_wait */
  98   0,                            /* to_fetch_registers */
  99   0,                            /* to_store_registers */
 100   0,                            /* to_prepare_to_store */
 101   0,                            /* to_xfer_memory */
 102   0,                            /* to_files_info */
 103   0,                            /* to_insert_breakpoint */
 104   0,                            /* to_remove_breakpoint */
 105   0,                            /* to_terminal_init */
 106   0,                            /* to_terminal_inferior */
 107   0,                            /* to_terminal_ours_for_output */
 108   0,                            /* to_terminal_ours */
 109   0,                            /* to_terminal_info */
 110   0,                            /* to_kill */
 111   0,                            /* to_load */
 112   0,                            /* to_lookup_symbol */
 113   find_default_create_inferior, /* to_create_inferior */
 114   0,                            /* to_mourn_inferior */
 115   0,                            /* to_can_run */
 116   0,                            /* to_notice_signals */
 117   0,                            /* to_thread_alive */
 118   0,                            /* to_stop */
 119   dummy_stratum,                /* to_stratum */
 120   0,                            /* to_next */
 121   0,                            /* to_next */
 122   0,                            /* to_has_all_memory */
 123   0,                            /* to_has_memory */
 124   0,                            /* to_has_registers */
 125   0,                            /* to_has_execution */
 126   0,                            /* to_sections */
 127   0,                            /* to_sections_end */
 128   OPS_MAGIC,                    /* to_magic */
 129 };
 130
 131 /* Top of target stack.  */
 132
 133 struct target_stack_item *target_stack;
 134
 135 /* The target structure we are currently using to talk to a process
 136    or file or whatever "inferior" we have.  */
 137
 138 struct target_ops current_target;
 139
 140 /* Command list for target.  */
 141
 142 static struct cmd_list_element *targetlist = NULL;
 143
 144 /* Nonzero if we are debugging an attached outside process
 145    rather than an inferior.  */
 146
 147 int attach_flag;
 148
 149 #ifdef MAINTENANCE_CMDS
 150 /* Non-zero if we want to see trace of target level stuff.  */
 151
 152 static int targetdebug = 0;
 153
 154 static void setup_target_debug PARAMS ((void));
 155
 156 #endif
 157
 158 /* The user just typed 'target' without the name of a target.  */
 159
 160 /* ARGSUSED */
 161 static void
 162 target_command (arg, from_tty)
 163      char *arg;
 164      int from_tty;
 165 {
 166   fputs_filtered ("Argument required (target name).  Try `help target'\n",
 167                   gdb_stdout);
 168 }
 169
 170 /* Add a possible target architecture to the list.  */
 171
 172 void
 173 add_target (t)
 174      struct target_ops *t;
 175 {
 176   if (!target_structs)
 177     {
 178       target_struct_allocsize = DEFAULT_ALLOCSIZE;
 179       target_structs = (struct target_ops **) xmalloc
 180         (target_struct_allocsize * sizeof (*target_structs));
 181     }
 182   if (target_struct_size >= target_struct_allocsize)
 183     {
 184       target_struct_allocsize *= 2;
 185       target_structs = (struct target_ops **)
 186           xrealloc ((char *) target_structs,
 187                     target_struct_allocsize * sizeof (*target_structs));
 188     }
 189   target_structs[target_struct_size++] = t;
 190 /*  cleanup_target (t);*/
 191
 192   if (targetlist == NULL)
 193     add_prefix_cmd ("target", class_run, target_command,
 194                     "Connect to a target machine or process.\n\
 195 The first argument is the type or protocol of the target machine.\n\
 196 Remaining arguments are interpreted by the target protocol.  For more\n\
 197 information on the arguments for a particular protocol, type\n\
 198 `help target ' followed by the protocol name.",
 199                     &targetlist, "target ", 0, &cmdlist);
 200   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
 201 }
 202
 203 /* Stub functions */
 204
 205 static void
 206 ignore ()
 207 {
 208 }
 209
 210 /* ARGSUSED */
 211 static int
 212 nomemory (memaddr, myaddr, len, write, t)
 213      CORE_ADDR memaddr;
 214      char *myaddr;
 215      int len;
 216      int write;
 217      struct target_ops *t;
 218 {
 219   errno = EIO;          /* Can't read/write this location */
 220   return 0;             /* No bytes handled */
 221 }
 222
 223 static void
 224 tcomplain ()
 225 {
 226   error ("You can't do that when your target is `%s'",
 227          current_target.to_shortname);
 228 }
 229
 230 void
 231 noprocess ()
 232 {
 233   error ("You can't do that without a process to debug");
 234 }
 235
 236 /* ARGSUSED */
 237 static int
 238 nosymbol (name, addrp)
 239      char *name;
 240      CORE_ADDR *addrp;
 241 {
 242   return 1;             /* Symbol does not exist in target env */
 243 }
 244
 245 /* ARGSUSED */
 246 static void
 247 default_terminal_info (args, from_tty)
 248      char *args;
 249      int from_tty;
 250 {
 251   printf_unfiltered("No saved terminal information.\n");
 252 }
 253
 254 /* This is the default target_create_inferior and target_attach function.
 255    If the current target is executing, it asks whether to kill it off.
 256    If this function returns without calling error(), it has killed off
 257    the target, and the operation should be attempted.  */
 258
 259 static void
 260 kill_or_be_killed (from_tty)
 261      int from_tty;
 262 {
 263   if (target_has_execution)
 264     {
 265       printf_unfiltered ("You are already running a program:\n");
 266       target_files_info ();
 267       if (query ("Kill it? ")) {
 268         target_kill ();
 269         if (target_has_execution)
 270           error ("Killing the program did not help.");
 271         return;
 272       } else {
 273         error ("Program not killed.");
 274       }
 275     }
 276   tcomplain();
 277 }
 278
 279 static void
 280 maybe_kill_then_attach (args, from_tty)
 281      char *args;
 282      int from_tty;
 283 {
 284   kill_or_be_killed (from_tty);
 285   target_attach (args, from_tty);
 286 }
 287
 288 static void
 289 maybe_kill_then_create_inferior (exec, args, env)
 290      char *exec;
 291      char *args;
 292      char **env;
 293 {
 294   kill_or_be_killed (0);
 295   target_create_inferior (exec, args, env);
 296 }
 297
 298 /* Clean up a target struct so it no longer has any zero pointers in it.
 299    We default entries, at least to stubs that print error messages.  */
 300
 301 static void
 302 cleanup_target (t)
 303      struct target_ops *t;
 304 {
 305
 306 #define de_fault(field, value) \
 307   if (!t->field)        t->field = value
 308
 309   /*        FIELD                       DEFAULT VALUE        */
 310
 311   de_fault (to_open,                    (void (*)())tcomplain);
 312   de_fault (to_close,                   (void (*)())ignore);
 313   de_fault (to_attach,                  maybe_kill_then_attach);
 314   de_fault (to_detach,                  (void (*)())ignore);
 315   de_fault (to_resume,                  (void (*)())noprocess);
 316   de_fault (to_wait,                    (int (*)())noprocess);
 317   de_fault (to_fetch_registers,         (void (*)())ignore);
 318   de_fault (to_store_registers,         (void (*)())noprocess);
 319   de_fault (to_prepare_to_store,        (void (*)())noprocess);
 320   de_fault (to_xfer_memory,             (int (*)())nomemory);
 321   de_fault (to_files_info,              (void (*)())ignore);
 322   de_fault (to_insert_breakpoint,       memory_insert_breakpoint);
 323   de_fault (to_remove_breakpoint,       memory_remove_breakpoint);
 324   de_fault (to_terminal_init,           ignore);
 325   de_fault (to_terminal_inferior,       ignore);
 326   de_fault (to_terminal_ours_for_output,ignore);
 327   de_fault (to_terminal_ours,           ignore);
 328   de_fault (to_terminal_info,           default_terminal_info);
 329   de_fault (to_kill,                    (void (*)())noprocess);
 330   de_fault (to_load,                    (void (*)())tcomplain);
 331   de_fault (to_lookup_symbol,           nosymbol);
 332   de_fault (to_create_inferior,         maybe_kill_then_create_inferior);
 333   de_fault (to_mourn_inferior,          (void (*)())noprocess);
 334   de_fault (to_can_run,                 return_zero);
 335   de_fault (to_notice_signals,          (void (*)())ignore);
 336   de_fault (to_thread_alive,            (int (*)())ignore);
 337   de_fault (to_stop,                    (void (*)())ignore);
 338
 339 #undef de_fault
 340 }
 341
 342 /* Go through the target stack from top to bottom, copying over zero entries in
 343    current_target.  In effect, we are doing class inheritance through the
 344    pushed target vectors.  */
 345
 346 static void
 347 update_current_target ()
 348 {
 349   struct target_stack_item *item;
 350   struct target_ops *t;
 351
 352   /* First, reset current_target */
 353   memset (&current_target, 0, sizeof current_target);
 354
 355   for (item = target_stack; item; item = item->next)
 356     {
 357       t = item->target_ops;
 358
 359 #define INHERIT(FIELD, TARGET) \
 360       if (!current_target.FIELD) \
 361         current_target.FIELD = TARGET->FIELD
 362
 363       INHERIT (to_shortname, t);
 364       INHERIT (to_longname, t);
 365       INHERIT (to_doc, t);
 366       INHERIT (to_open, t);
 367       INHERIT (to_close, t);
 368       INHERIT (to_attach, t);
 369       INHERIT (to_detach, t);
 370       INHERIT (to_resume, t);
 371       INHERIT (to_wait, t);
 372       INHERIT (to_fetch_registers, t);
 373       INHERIT (to_store_registers, t);
 374       INHERIT (to_prepare_to_store, t);
 375       INHERIT (to_xfer_memory, t);
 376       INHERIT (to_files_info, t);
 377       INHERIT (to_insert_breakpoint, t);
 378       INHERIT (to_remove_breakpoint, t);
 379       INHERIT (to_terminal_init, t);
 380       INHERIT (to_terminal_inferior, t);
 381       INHERIT (to_terminal_ours_for_output, t);
 382       INHERIT (to_terminal_ours, t);
 383       INHERIT (to_terminal_info, t);
 384       INHERIT (to_kill, t);
 385       INHERIT (to_load, t);
 386       INHERIT (to_lookup_symbol, t);
 387       INHERIT (to_create_inferior, t);
 388       INHERIT (to_mourn_inferior, t);
 389       INHERIT (to_can_run, t);
 390       INHERIT (to_notice_signals, t);
 391       INHERIT (to_thread_alive, t);
 392       INHERIT (to_stop, t);
 393       INHERIT (to_stratum, t);
 394       INHERIT (DONT_USE, t);
 395       INHERIT (to_has_all_memory, t);
 396       INHERIT (to_has_memory, t);
 397       INHERIT (to_has_stack, t);
 398       INHERIT (to_has_registers, t);
 399       INHERIT (to_has_execution, t);
 400       INHERIT (to_sections, t);
 401       INHERIT (to_sections_end, t);
 402       INHERIT (to_magic, t);
 403
 404 #undef INHERIT
 405     }
 406 }
 407
 408 /* Push a new target type into the stack of the existing target accessors,
 409    possibly superseding some of the existing accessors.
 410
 411    Result is zero if the pushed target ended up on top of the stack,
 412    nonzero if at least one target is on top of it.
 413
 414    Rather than allow an empty stack, we always have the dummy target at
 415    the bottom stratum, so we can call the function vectors without
 416    checking them.  */
 417
 418 int
 419 push_target (t)
 420      struct target_ops *t;
 421 {
 422   struct target_stack_item *cur, *prev, *tmp;
 423
 424   /* Check magic number.  If wrong, it probably means someone changed
 425      the struct definition, but not all the places that initialize one.  */
 426   if (t->to_magic != OPS_MAGIC)
 427     {
 428       fprintf_unfiltered(gdb_stderr,
 429                          "Magic number of %s target struct wrong\n",
 430                          t->to_shortname);
 431       abort();
 432     }
 433
 434   /* Find the proper stratum to install this target in. */
 435
 436   for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
 437     {
 438       if ((int)(t->to_stratum) >= (int)(cur->target_ops->to_stratum))
 439         break;
 440     }
 441
 442   /* If there's already targets at this stratum, remove them. */
 443
 444   if (cur)
 445     while (t->to_stratum == cur->target_ops->to_stratum)
 446       {
 447         /* There's already something on this stratum.  Close it off.  */
 448         if (cur->target_ops->to_close)
 449           (cur->target_ops->to_close) (0);
 450         if (prev)
 451           prev->next = cur->next; /* Unchain old target_ops */
 452         else
 453           target_stack = cur->next; /* Unchain first on list */
 454         tmp = cur->next;
 455         free (cur);
 456         cur = tmp;
 457       }
 458
 459   /* We have removed all targets in our stratum, now add the new one.  */
 460
 461   tmp = (struct target_stack_item *)
 462     xmalloc (sizeof (struct target_stack_item));
 463   tmp->next = cur;
 464   tmp->target_ops = t;
 465
 466   if (prev)
 467     prev->next = tmp;
 468   else
 469     target_stack = tmp;
 470
 471   update_current_target ();
 472
 473   cleanup_target (&current_target); /* Fill in the gaps */
 474
 475 #ifdef MAINTENANCE_CMDS
 476   if (targetdebug)
 477     setup_target_debug ();
 478 #endif
 479
 480   return prev != 0;
 481 }
 482
 483 /* Remove a target_ops vector from the stack, wherever it may be.
 484    Return how many times it was removed (0 or 1).  */
 485
 486 int
 487 unpush_target (t)
 488      struct target_ops *t;
 489 {
 490   struct target_stack_item *cur, *prev;
 491
 492   if (t->to_close)
 493     t->to_close (0);            /* Let it clean up */
 494
 495   /* Look for the specified target.  Note that we assume that a target
 496      can only occur once in the target stack. */
 497
 498   for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
 499     if (cur->target_ops == t)
 500       break;
 501
 502   if (!cur)
 503     return 0;                   /* Didn't find target_ops, quit now */
 504
 505   /* Unchain the target */
 506
 507   if (!prev)
 508     target_stack = cur->next;
 509   else
 510     prev->next = cur->next;
 511
 512   free (cur);                   /* Release the target_stack_item */
 513
 514   update_current_target ();
 515   cleanup_target (&current_target);
 516
 517   return 1;
 518 }
 519
 520 void
 521 pop_target ()
 522 {
 523   (current_target.to_close)(0); /* Let it clean up */
 524   if (unpush_target (target_stack->target_ops) == 1)
 525     return;
 526
 527   fprintf_unfiltered(gdb_stderr,
 528                      "pop_target couldn't find target %s\n",
 529                      current_target.to_shortname);
 530   abort();
 531 }
 532
 533 #undef  MIN
 534 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
 535
 536 /* target_read_string -- read a null terminated string, up to LEN bytes,
 537    from MEMADDR in target.  Set *ERRNOP to the errno code, or 0 if successful.
 538    Set *STRING to a pointer to malloc'd memory containing the data; the caller
 539    is responsible for freeing it.  Return the number of bytes successfully
 540    read.  */
 541
 542 int
 543 target_read_string (memaddr, string, len, errnop)
 544      CORE_ADDR memaddr;
 545      char **string;
 546      int len;
 547      int *errnop;
 548 {
 549   int tlen, origlen, offset, i;
 550   char buf[4];
 551   int errcode = 0;
 552   char *buffer;
 553   int buffer_allocated;
 554   char *bufptr;
 555   unsigned int nbytes_read = 0;
 556
 557   /* Small for testing.  */
 558   buffer_allocated = 4;
 559   buffer = xmalloc (buffer_allocated);
 560   bufptr = buffer;
 561
 562   origlen = len;
 563
 564   while (len > 0)
 565     {
 566       tlen = MIN (len, 4 - (memaddr & 3));
 567       offset = memaddr & 3;
 568
 569       errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
 570       if (errcode != 0)
 571         goto done;
 572
 573       if (bufptr - buffer + tlen > buffer_allocated)
 574         {
 575           unsigned int bytes;
 576           bytes = bufptr - buffer;
 577           buffer_allocated *= 2;
 578           buffer = xrealloc (buffer, buffer_allocated);
 579           bufptr = buffer + bytes;
 580         }
 581
 582       for (i = 0; i < tlen; i++)
 583         {
 584           *bufptr++ = buf[i + offset];
 585           if (buf[i + offset] == '\000')
 586             {
 587               nbytes_read += i + 1;
 588               goto done;
 589             }
 590         }
 591
 592       memaddr += tlen;
 593       len -= tlen;
 594       nbytes_read += tlen;
 595     }
 596  done:
 597   if (errnop != NULL)
 598     *errnop = errcode;
 599   if (string != NULL)
 600     *string = buffer;
 601   return nbytes_read;
 602 }
 603
 604 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
 605    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
 606    if any error occurs.
 607
 608    If an error occurs, no guarantee is made about the contents of the data at
 609    MYADDR.  In particular, the caller should not depend upon partial reads
 610    filling the buffer with good data.  There is no way for the caller to know
 611    how much good data might have been transfered anyway.  Callers that can
 612    deal with partial reads should call target_read_memory_partial. */
 613
 614 int
 615 target_read_memory (memaddr, myaddr, len)
 616      CORE_ADDR memaddr;
 617      char *myaddr;
 618      int len;
 619 {
 620   return target_xfer_memory (memaddr, myaddr, len, 0);
 621 }
 622
 623 /* Read LEN bytes of target memory at address MEMADDR, placing the results
 624    in GDB's memory at MYADDR.  Returns a count of the bytes actually read,
 625    and optionally an errno value in the location pointed to by ERRNOPTR
 626    if ERRNOPTR is non-null. */
 627
 628 int
 629 target_read_memory_partial (memaddr, myaddr, len, errnoptr)
 630      CORE_ADDR memaddr;
 631      char *myaddr;
 632      int len;
 633      int *errnoptr;
 634 {
 635   int nread;    /* Number of bytes actually read. */
 636   int errcode;  /* Error from last read. */
 637
 638   /* First try a complete read. */
 639   errcode = target_xfer_memory (memaddr, myaddr, len, 0);
 640   if (errcode == 0)
 641     {
 642       /* Got it all. */
 643       nread = len;
 644     }
 645   else
 646     {
 647       /* Loop, reading one byte at a time until we get as much as we can. */
 648       for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
 649         {
 650           errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0);
 651         }
 652       /* If an error, the last read was unsuccessful, so adjust count. */
 653       if (errcode != 0)
 654         {
 655           nread--;
 656         }
 657     }
 658   if (errnoptr != NULL)
 659     {
 660       *errnoptr = errcode;
 661     }
 662   return (nread);
 663 }
 664
 665 int
 666 target_write_memory (memaddr, myaddr, len)
 667      CORE_ADDR memaddr;
 668      char *myaddr;
 669      int len;
 670 {
 671   return target_xfer_memory (memaddr, myaddr, len, 1);
 672 }
 673
 674 /* Move memory to or from the targets.  Iterate until all of it has
 675    been moved, if necessary.  The top target gets priority; anything
 676    it doesn't want, is offered to the next one down, etc.  Note the
 677    business with curlen:  if an early target says "no, but I have a
 678    boundary overlapping this xfer" then we shorten what we offer to
 679    the subsequent targets so the early guy will get a chance at the
 680    tail before the subsequent ones do.
 681
 682    Result is 0 or errno value.  */
 683
 684 int
 685 target_xfer_memory (memaddr, myaddr, len, write)
 686      CORE_ADDR memaddr;
 687      char *myaddr;
 688      int len;
 689      int write;
 690 {
 691   int curlen;
 692   int res;
 693   struct target_ops *t;
 694   struct target_stack_item *item;
 695
 696   /* to_xfer_memory is not guaranteed to set errno, even when it returns
 697      0.  */
 698   errno = 0;
 699
 700   /* The quick case is that the top target does it all.  */
 701   res = current_target.to_xfer_memory
 702                         (memaddr, myaddr, len, write, &current_target);
 703   if (res == len)
 704     return 0;
 705
 706   if (res > 0)
 707     goto bump;
 708   /* If res <= 0 then we call it again in the loop.  Ah well.  */
 709
 710   for (; len > 0;)
 711     {
 712       curlen = len;             /* Want to do it all */
 713       for (item = target_stack; item; item = item->next)
 714         {
 715           t = item->target_ops;
 716           if (!t->to_has_memory)
 717             continue;
 718
 719           res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
 720           if (res > 0)
 721             break;              /* Handled all or part of xfer */
 722           if (t->to_has_all_memory)
 723             break;
 724         }
 725
 726       if (res <= 0)
 727         {
 728           /* If this address is for nonexistent memory,
 729              read zeros if reading, or do nothing if writing.  Return error. */
 730           if (!write)
 731             memset (myaddr, 0, len);
 732           if (errno == 0)
 733             return EIO;
 734           else
 735             return errno;
 736         }
 737 bump:
 738       memaddr += res;
 739       myaddr  += res;
 740       len     -= res;
 741     }
 742   return 0;                     /* We managed to cover it all somehow. */
 743 }
 744
 745
 746 /* ARGSUSED */
 747 static void
 748 target_info (args, from_tty)
 749      char *args;
 750      int from_tty;
 751 {
 752   struct target_ops *t;
 753   struct target_stack_item *item;
 754   int has_all_mem = 0;
 755
 756   if (symfile_objfile != NULL)
 757     printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
 758
 759 #ifdef FILES_INFO_HOOK
 760   if (FILES_INFO_HOOK ())
 761     return;
 762 #endif
 763
 764   for (item = target_stack; item; item = item->next)
 765     {
 766       t = item->target_ops;
 767
 768       if (!t->to_has_memory)
 769         continue;
 770
 771       if ((int)(t->to_stratum) <= (int)dummy_stratum)
 772         continue;
 773       if (has_all_mem)
 774         printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
 775       printf_unfiltered("%s:\n", t->to_longname);
 776       (t->to_files_info)(t);
 777       has_all_mem = t->to_has_all_memory;
 778     }
 779 }
 780
 781 /* This is to be called by the open routine before it does
 782    anything.  */
 783
 784 void
 785 target_preopen (from_tty)
 786      int from_tty;
 787 {
 788   dont_repeat();
 789
 790   if (target_has_execution)
 791     {
 792       if (query ("A program is being debugged already.  Kill it? "))
 793         target_kill ();
 794       else
 795         error ("Program not killed.");
 796     }
 797
 798   /* Calling target_kill may remove the target from the stack.  But if
 799      it doesn't (which seems like a win for UDI), remove it now.  */
 800
 801   if (target_has_execution)
 802     pop_target ();
 803 }
 804
 805 /* Detach a target after doing deferred register stores.  */
 806
 807 void
 808 target_detach (args, from_tty)
 809      char *args;
 810      int from_tty;
 811 {
 812   /* Handle any optimized stores to the inferior.  */
 813 #ifdef DO_DEFERRED_STORES
 814   DO_DEFERRED_STORES;
 815 #endif
 816   (current_target.to_detach) (args, from_tty);
 817 }
 818
 819 void
 820 target_link (modname, t_reloc)
 821      char *modname;
 822      CORE_ADDR *t_reloc;
 823 {
 824   if (STREQ(current_target.to_shortname, "rombug"))
 825     {
 826       (current_target.to_lookup_symbol) (modname, t_reloc);
 827       if (*t_reloc == 0)
 828       error("Unable to link to %s and get relocation in rombug", modname);
 829     }
 830   else
 831     *t_reloc = (CORE_ADDR)-1;
 832 }
 833
 834 /* Look through the list of possible targets for a target that can
 835    execute a run or attach command without any other data.  This is
 836    used to locate the default process stratum.
 837
 838    Result is always valid (error() is called for errors).  */
 839
 840 static struct target_ops *
 841 find_default_run_target (do_mesg)
 842      char *do_mesg;
 843 {
 844   struct target_ops **t;
 845   struct target_ops *runable = NULL;
 846   int count;
 847
 848   count = 0;
 849
 850   for (t = target_structs; t < target_structs + target_struct_size;
 851        ++t)
 852     {
 853       if ((*t)->to_can_run && target_can_run(*t))
 854         {
 855           runable = *t;
 856           ++count;
 857         }
 858     }
 859
 860   if (count != 1)
 861     error ("Don't know how to %s.  Try \"help target\".", do_mesg);
 862
 863   return runable;
 864 }
 865
 866 void
 867 find_default_attach (args, from_tty)
 868      char *args;
 869      int from_tty;
 870 {
 871   struct target_ops *t;
 872
 873   t = find_default_run_target("attach");
 874   (t->to_attach) (args, from_tty);
 875   return;
 876 }
 877
 878 void
 879 find_default_create_inferior (exec_file, allargs, env)
 880      char *exec_file;
 881      char *allargs;
 882      char **env;
 883 {
 884   struct target_ops *t;
 885
 886   t = find_default_run_target("run");
 887   (t->to_create_inferior) (exec_file, allargs, env);
 888   return;
 889 }
 890
 891 static int
 892 return_zero ()
 893 {
 894   return 0;
 895 }
 896
 897 struct target_ops *
 898 find_core_target ()
 899 {
 900   struct target_ops **t;
 901   struct target_ops *runable = NULL;
 902   int count;
 903
 904   count = 0;
 905
 906   for (t = target_structs; t < target_structs + target_struct_size;
 907        ++t)
 908     {
 909       if ((*t)->to_stratum == core_stratum)
 910         {
 911           runable = *t;
 912           ++count;
 913         }
 914     }
 915
 916   return(count == 1 ? runable : NULL);
 917 }
 918 \f
 919 /* The inferior process has died.  Long live the inferior!  */
 920
 921 void
 922 generic_mourn_inferior ()
 923 {
 924   extern int show_breakpoint_hit_counts;
 925
 926   inferior_pid = 0;
 927   attach_flag = 0;
 928   breakpoint_init_inferior ();
 929   registers_changed ();
 930
 931 #ifdef CLEAR_DEFERRED_STORES
 932   /* Delete any pending stores to the inferior... */
 933   CLEAR_DEFERRED_STORES;
 934 #endif
 935
 936   reopen_exec_file ();
 937   reinit_frame_cache ();
 938
 939   /* It is confusing to the user for ignore counts to stick around
 940      from previous runs of the inferior.  So clear them.  */
 941   /* However, it is more confusing for the ignore counts to disappear when
 942      using hit counts.  So don't clear them if we're counting hits.  */
 943   if (!show_breakpoint_hit_counts)
 944     breakpoint_clear_ignore_counts ();
 945 }
 946 \f
 947 /* This table must match in order and size the signals in enum target_signal
 948    in target.h.  */
 949 static struct {
 950   char *name;
 951   char *string;
 952   } signals [] =
 953 {
 954   {"0", "Signal 0"},
 955   {"SIGHUP", "Hangup"},
 956   {"SIGINT", "Interrupt"},
 957   {"SIGQUIT", "Quit"},
 958   {"SIGILL", "Illegal instruction"},
 959   {"SIGTRAP", "Trace/breakpoint trap"},
 960   {"SIGABRT", "Aborted"},
 961   {"SIGEMT", "Emulation trap"},
 962   {"SIGFPE", "Arithmetic exception"},
 963   {"SIGKILL", "Killed"},
 964   {"SIGBUS", "Bus error"},
 965   {"SIGSEGV", "Segmentation fault"},
 966   {"SIGSYS", "Bad system call"},
 967   {"SIGPIPE", "Broken pipe"},
 968   {"SIGALRM", "Alarm clock"},
 969   {"SIGTERM", "Terminated"},
 970   {"SIGURG", "Urgent I/O condition"},
 971   {"SIGSTOP", "Stopped (signal)"},
 972   {"SIGTSTP", "Stopped (user)"},
 973   {"SIGCONT", "Continued"},
 974   {"SIGCHLD", "Child status changed"},
 975   {"SIGTTIN", "Stopped (tty input)"},
 976   {"SIGTTOU", "Stopped (tty output)"},
 977   {"SIGIO", "I/O possible"},
 978   {"SIGXCPU", "CPU time limit exceeded"},
 979   {"SIGXFSZ", "File size limit exceeded"},
 980   {"SIGVTALRM", "Virtual timer expired"},
 981   {"SIGPROF", "Profiling timer expired"},
 982   {"SIGWINCH", "Window size changed"},
 983   {"SIGLOST", "Resource lost"},
 984   {"SIGUSR1", "User defined signal 1"},
 985   {"SIGUSR2", "User defined signal 2"},
 986   {"SIGPWR", "Power fail/restart"},
 987   {"SIGPOLL", "Pollable event occurred"},
 988   {"SIGWIND", "SIGWIND"},
 989   {"SIGPHONE", "SIGPHONE"},
 990   {"SIGWAITING", "Process's LWPs are blocked"},
 991   {"SIGLWP", "Signal LWP"},
 992   {"SIGDANGER", "Swap space dangerously low"},
 993   {"SIGGRANT", "Monitor mode granted"},
 994   {"SIGRETRACT", "Need to relinguish monitor mode"},
 995   {"SIGMSG", "Monitor mode data available"},
 996   {"SIGSOUND", "Sound completed"},
 997   {"SIGSAK", "Secure attention"},
 998   {"SIGPRIO", "SIGPRIO"},
 999   {"SIG33", "Real-time event 33"},
1000   {"SIG34", "Real-time event 34"},
1001   {"SIG35", "Real-time event 35"},
1002   {"SIG36", "Real-time event 36"},
1003   {"SIG37", "Real-time event 37"},
1004   {"SIG38", "Real-time event 38"},
1005   {"SIG39", "Real-time event 39"},
1006   {"SIG40", "Real-time event 40"},
1007   {"SIG41", "Real-time event 41"},
1008   {"SIG42", "Real-time event 42"},
1009   {"SIG43", "Real-time event 43"},
1010   {"SIG44", "Real-time event 44"},
1011   {"SIG45", "Real-time event 45"},
1012   {"SIG46", "Real-time event 46"},
1013   {"SIG47", "Real-time event 47"},
1014   {"SIG48", "Real-time event 48"},
1015   {"SIG49", "Real-time event 49"},
1016   {"SIG50", "Real-time event 50"},
1017   {"SIG51", "Real-time event 51"},
1018   {"SIG52", "Real-time event 52"},
1019   {"SIG53", "Real-time event 53"},
1020   {"SIG54", "Real-time event 54"},
1021   {"SIG55", "Real-time event 55"},
1022   {"SIG56", "Real-time event 56"},
1023   {"SIG57", "Real-time event 57"},
1024   {"SIG58", "Real-time event 58"},
1025   {"SIG59", "Real-time event 59"},
1026   {"SIG60", "Real-time event 60"},
1027   {"SIG61", "Real-time event 61"},
1028   {"SIG62", "Real-time event 62"},
1029   {"SIG63", "Real-time event 63"},
1030
1031   /* Mach exceptions */
1032   {"EXC_BAD_ACCESS", "Could not access memory"},
1033   {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1034   {"EXC_ARITHMETIC", "Arithmetic exception"},
1035   {"EXC_EMULATION", "Emulation instruction"},
1036   {"EXC_SOFTWARE", "Software generated exception"},
1037   {"EXC_BREAKPOINT", "Breakpoint"},
1038
1039   {NULL, "Unknown signal"},
1040   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1041
1042   /* Last entry, used to check whether the table is the right size.  */
1043   {NULL, "TARGET_SIGNAL_MAGIC"}
1044 };
1045
1046 /* Return the string for a signal.  */
1047 char *
1048 target_signal_to_string (sig)
1049      enum target_signal sig;
1050 {
1051   return signals[sig].string;
1052 }
1053
1054 /* Return the name for a signal.  */
1055 char *
1056 target_signal_to_name (sig)
1057      enum target_signal sig;
1058 {
1059   if (sig == TARGET_SIGNAL_UNKNOWN)
1060     /* I think the code which prints this will always print it along with
1061        the string, so no need to be verbose.  */
1062     return "?";
1063   return signals[sig].name;
1064 }
1065
1066 /* Given a name, return its signal.  */
1067 enum target_signal
1068 target_signal_from_name (name)
1069      char *name;
1070 {
1071   enum target_signal sig;
1072
1073   /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1074      for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
1075      questionable; seems like by now people should call it SIGABRT
1076      instead.  */
1077
1078   /* This ugly cast brought to you by the native VAX compiler.  */
1079   for (sig = TARGET_SIGNAL_HUP;
1080        signals[sig].name != NULL;
1081        sig = (enum target_signal)((int)sig + 1))
1082     if (STREQ (name, signals[sig].name))
1083       return sig;
1084   return TARGET_SIGNAL_UNKNOWN;
1085 }
1086 \f
1087 /* The following functions are to help certain targets deal
1088    with the signal/waitstatus stuff.  They could just as well be in
1089    a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */
1090
1091 /* Convert host signal to our signals.  */
1092 enum target_signal
1093 target_signal_from_host (hostsig)
1094      int hostsig;
1095 {
1096   /* A switch statement would make sense but would require special kludges
1097      to deal with the cases where more than one signal has the same number.  */
1098
1099   if (hostsig == 0) return TARGET_SIGNAL_0;
1100
1101 #if defined (SIGHUP)
1102   if (hostsig == SIGHUP) return TARGET_SIGNAL_HUP;
1103 #endif
1104 #if defined (SIGINT)
1105   if (hostsig == SIGINT) return TARGET_SIGNAL_INT;
1106 #endif
1107 #if defined (SIGQUIT)
1108   if (hostsig == SIGQUIT) return TARGET_SIGNAL_QUIT;
1109 #endif
1110 #if defined (SIGILL)
1111   if (hostsig == SIGILL) return TARGET_SIGNAL_ILL;
1112 #endif
1113 #if defined (SIGTRAP)
1114   if (hostsig == SIGTRAP) return TARGET_SIGNAL_TRAP;
1115 #endif
1116 #if defined (SIGABRT)
1117   if (hostsig == SIGABRT) return TARGET_SIGNAL_ABRT;
1118 #endif
1119 #if defined (SIGEMT)
1120   if (hostsig == SIGEMT) return TARGET_SIGNAL_EMT;
1121 #endif
1122 #if defined (SIGFPE)
1123   if (hostsig == SIGFPE) return TARGET_SIGNAL_FPE;
1124 #endif
1125 #if defined (SIGKILL)
1126   if (hostsig == SIGKILL) return TARGET_SIGNAL_KILL;
1127 #endif
1128 #if defined (SIGBUS)
1129   if (hostsig == SIGBUS) return TARGET_SIGNAL_BUS;
1130 #endif
1131 #if defined (SIGSEGV)
1132   if (hostsig == SIGSEGV) return TARGET_SIGNAL_SEGV;
1133 #endif
1134 #if defined (SIGSYS)
1135   if (hostsig == SIGSYS) return TARGET_SIGNAL_SYS;
1136 #endif
1137 #if defined (SIGPIPE)
1138   if (hostsig == SIGPIPE) return TARGET_SIGNAL_PIPE;
1139 #endif
1140 #if defined (SIGALRM)
1141   if (hostsig == SIGALRM) return TARGET_SIGNAL_ALRM;
1142 #endif
1143 #if defined (SIGTERM)
1144   if (hostsig == SIGTERM) return TARGET_SIGNAL_TERM;
1145 #endif
1146 #if defined (SIGUSR1)
1147   if (hostsig == SIGUSR1) return TARGET_SIGNAL_USR1;
1148 #endif
1149 #if defined (SIGUSR2)
1150   if (hostsig == SIGUSR2) return TARGET_SIGNAL_USR2;
1151 #endif
1152 #if defined (SIGCLD)
1153   if (hostsig == SIGCLD) return TARGET_SIGNAL_CHLD;
1154 #endif
1155 #if defined (SIGCHLD)
1156   if (hostsig == SIGCHLD) return TARGET_SIGNAL_CHLD;
1157 #endif
1158 #if defined (SIGPWR)
1159   if (hostsig == SIGPWR) return TARGET_SIGNAL_PWR;
1160 #endif
1161 #if defined (SIGWINCH)
1162   if (hostsig == SIGWINCH) return TARGET_SIGNAL_WINCH;
1163 #endif
1164 #if defined (SIGURG)
1165   if (hostsig == SIGURG) return TARGET_SIGNAL_URG;
1166 #endif
1167 #if defined (SIGIO)
1168   if (hostsig == SIGIO) return TARGET_SIGNAL_IO;
1169 #endif
1170 #if defined (SIGPOLL)
1171   if (hostsig == SIGPOLL) return TARGET_SIGNAL_POLL;
1172 #endif
1173 #if defined (SIGSTOP)
1174   if (hostsig == SIGSTOP) return TARGET_SIGNAL_STOP;
1175 #endif
1176 #if defined (SIGTSTP)
1177   if (hostsig == SIGTSTP) return TARGET_SIGNAL_TSTP;
1178 #endif
1179 #if defined (SIGCONT)
1180   if (hostsig == SIGCONT) return TARGET_SIGNAL_CONT;
1181 #endif
1182 #if defined (SIGTTIN)
1183   if (hostsig == SIGTTIN) return TARGET_SIGNAL_TTIN;
1184 #endif
1185 #if defined (SIGTTOU)
1186   if (hostsig == SIGTTOU) return TARGET_SIGNAL_TTOU;
1187 #endif
1188 #if defined (SIGVTALRM)
1189   if (hostsig == SIGVTALRM) return TARGET_SIGNAL_VTALRM;
1190 #endif
1191 #if defined (SIGPROF)
1192   if (hostsig == SIGPROF) return TARGET_SIGNAL_PROF;
1193 #endif
1194 #if defined (SIGXCPU)
1195   if (hostsig == SIGXCPU) return TARGET_SIGNAL_XCPU;
1196 #endif
1197 #if defined (SIGXFSZ)
1198   if (hostsig == SIGXFSZ) return TARGET_SIGNAL_XFSZ;
1199 #endif
1200 #if defined (SIGWIND)
1201   if (hostsig == SIGWIND) return TARGET_SIGNAL_WIND;
1202 #endif
1203 #if defined (SIGPHONE)
1204   if (hostsig == SIGPHONE) return TARGET_SIGNAL_PHONE;
1205 #endif
1206 #if defined (SIGLOST)
1207   if (hostsig == SIGLOST) return TARGET_SIGNAL_LOST;
1208 #endif
1209 #if defined (SIGWAITING)
1210   if (hostsig == SIGWAITING) return TARGET_SIGNAL_WAITING;
1211 #endif
1212 #if defined (SIGLWP)
1213   if (hostsig == SIGLWP) return TARGET_SIGNAL_LWP;
1214 #endif
1215 #if defined (SIGDANGER)
1216   if (hostsig == SIGDANGER) return TARGET_SIGNAL_DANGER;
1217 #endif
1218 #if defined (SIGGRANT)
1219   if (hostsig == SIGGRANT) return TARGET_SIGNAL_GRANT;
1220 #endif
1221 #if defined (SIGRETRACT)
1222   if (hostsig == SIGRETRACT) return TARGET_SIGNAL_RETRACT;
1223 #endif
1224 #if defined (SIGMSG)
1225   if (hostsig == SIGMSG) return TARGET_SIGNAL_MSG;
1226 #endif
1227 #if defined (SIGSOUND)
1228   if (hostsig == SIGSOUND) return TARGET_SIGNAL_SOUND;
1229 #endif
1230 #if defined (SIGSAK)
1231   if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK;
1232 #endif
1233 #if defined (SIGPRIO)
1234   if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO;
1235 #endif
1236
1237   /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
1238 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1239   if (hostsig == _NSIG + EXC_BAD_ACCESS) return TARGET_EXC_BAD_ACCESS;
1240 #endif
1241 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1242   if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) return TARGET_EXC_BAD_INSTRUCTION;
1243 #endif
1244 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1245   if (hostsig == _NSIG + EXC_ARITHMETIC) return TARGET_EXC_ARITHMETIC;
1246 #endif
1247 #if defined (EXC_EMULATION) && defined (_NSIG)
1248   if (hostsig == _NSIG + EXC_EMULATION) return TARGET_EXC_EMULATION;
1249 #endif
1250 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1251   if (hostsig == _NSIG + EXC_SOFTWARE) return TARGET_EXC_SOFTWARE;
1252 #endif
1253 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1254   if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
1255 #endif
1256
1257 #if defined (REALTIME_LO)
1258   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
1259     return (enum target_signal)
1260       (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
1261 #endif
1262   return TARGET_SIGNAL_UNKNOWN;
1263 }
1264
1265 int
1266 target_signal_to_host (oursig)
1267      enum target_signal oursig;
1268 {
1269   switch (oursig)
1270     {
1271     case TARGET_SIGNAL_0: return 0;
1272
1273 #if defined (SIGHUP)
1274     case TARGET_SIGNAL_HUP: return SIGHUP;
1275 #endif
1276 #if defined (SIGINT)
1277     case TARGET_SIGNAL_INT: return SIGINT;
1278 #endif
1279 #if defined (SIGQUIT)
1280     case TARGET_SIGNAL_QUIT: return SIGQUIT;
1281 #endif
1282 #if defined (SIGILL)
1283     case TARGET_SIGNAL_ILL: return SIGILL;
1284 #endif
1285 #if defined (SIGTRAP)
1286     case TARGET_SIGNAL_TRAP: return SIGTRAP;
1287 #endif
1288 #if defined (SIGABRT)
1289     case TARGET_SIGNAL_ABRT: return SIGABRT;
1290 #endif
1291 #if defined (SIGEMT)
1292     case TARGET_SIGNAL_EMT: return SIGEMT;
1293 #endif
1294 #if defined (SIGFPE)
1295     case TARGET_SIGNAL_FPE: return SIGFPE;
1296 #endif
1297 #if defined (SIGKILL)
1298     case TARGET_SIGNAL_KILL: return SIGKILL;
1299 #endif
1300 #if defined (SIGBUS)
1301     case TARGET_SIGNAL_BUS: return SIGBUS;
1302 #endif
1303 #if defined (SIGSEGV)
1304     case TARGET_SIGNAL_SEGV: return SIGSEGV;
1305 #endif
1306 #if defined (SIGSYS)
1307     case TARGET_SIGNAL_SYS: return SIGSYS;
1308 #endif
1309 #if defined (SIGPIPE)
1310     case TARGET_SIGNAL_PIPE: return SIGPIPE;
1311 #endif
1312 #if defined (SIGALRM)
1313     case TARGET_SIGNAL_ALRM: return SIGALRM;
1314 #endif
1315 #if defined (SIGTERM)
1316     case TARGET_SIGNAL_TERM: return SIGTERM;
1317 #endif
1318 #if defined (SIGUSR1)
1319     case TARGET_SIGNAL_USR1: return SIGUSR1;
1320 #endif
1321 #if defined (SIGUSR2)
1322     case TARGET_SIGNAL_USR2: return SIGUSR2;
1323 #endif
1324 #if defined (SIGCHLD) || defined (SIGCLD)
1325     case TARGET_SIGNAL_CHLD:
1326 #if defined (SIGCHLD)
1327       return SIGCHLD;
1328 #else
1329       return SIGCLD;
1330 #endif
1331 #endif /* SIGCLD or SIGCHLD */
1332 #if defined (SIGPWR)
1333     case TARGET_SIGNAL_PWR: return SIGPWR;
1334 #endif
1335 #if defined (SIGWINCH)
1336     case TARGET_SIGNAL_WINCH: return SIGWINCH;
1337 #endif
1338 #if defined (SIGURG)
1339     case TARGET_SIGNAL_URG: return SIGURG;
1340 #endif
1341 #if defined (SIGIO)
1342     case TARGET_SIGNAL_IO: return SIGIO;
1343 #endif
1344 #if defined (SIGPOLL)
1345     case TARGET_SIGNAL_POLL: return SIGPOLL;
1346 #endif
1347 #if defined (SIGSTOP)
1348     case TARGET_SIGNAL_STOP: return SIGSTOP;
1349 #endif
1350 #if defined (SIGTSTP)
1351     case TARGET_SIGNAL_TSTP: return SIGTSTP;
1352 #endif
1353 #if defined (SIGCONT)
1354     case TARGET_SIGNAL_CONT: return SIGCONT;
1355 #endif
1356 #if defined (SIGTTIN)
1357     case TARGET_SIGNAL_TTIN: return SIGTTIN;
1358 #endif
1359 #if defined (SIGTTOU)
1360     case TARGET_SIGNAL_TTOU: return SIGTTOU;
1361 #endif
1362 #if defined (SIGVTALRM)
1363     case TARGET_SIGNAL_VTALRM: return SIGVTALRM;
1364 #endif
1365 #if defined (SIGPROF)
1366     case TARGET_SIGNAL_PROF: return SIGPROF;
1367 #endif
1368 #if defined (SIGXCPU)
1369     case TARGET_SIGNAL_XCPU: return SIGXCPU;
1370 #endif
1371 #if defined (SIGXFSZ)
1372     case TARGET_SIGNAL_XFSZ: return SIGXFSZ;
1373 #endif
1374 #if defined (SIGWIND)
1375     case TARGET_SIGNAL_WIND: return SIGWIND;
1376 #endif
1377 #if defined (SIGPHONE)
1378     case TARGET_SIGNAL_PHONE: return SIGPHONE;
1379 #endif
1380 #if defined (SIGLOST)
1381     case TARGET_SIGNAL_LOST: return SIGLOST;
1382 #endif
1383 #if defined (SIGWAITING)
1384     case TARGET_SIGNAL_WAITING: return SIGWAITING;
1385 #endif
1386 #if defined (SIGLWP)
1387     case TARGET_SIGNAL_LWP: return SIGLWP;
1388 #endif
1389 #if defined (SIGDANGER)
1390     case TARGET_SIGNAL_DANGER: return SIGDANGER;
1391 #endif
1392 #if defined (SIGGRANT)
1393     case TARGET_SIGNAL_GRANT: return SIGGRANT;
1394 #endif
1395 #if defined (SIGRETRACT)
1396     case TARGET_SIGNAL_RETRACT: return SIGRETRACT;
1397 #endif
1398 #if defined (SIGMSG)
1399     case TARGET_SIGNAL_MSG: return SIGMSG;
1400 #endif
1401 #if defined (SIGSOUND)
1402     case TARGET_SIGNAL_SOUND: return SIGSOUND;
1403 #endif
1404 #if defined (SIGSAK)
1405     case TARGET_SIGNAL_SAK: return SIGSAK;
1406 #endif
1407 #if defined (SIGPRIO)
1408     case TARGET_SIGNAL_PRIO: return SIGPRIO;
1409 #endif
1410
1411       /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
1412 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1413     case TARGET_EXC_BAD_ACCESS: return _NSIG + EXC_BAD_ACCESS;
1414 #endif
1415 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1416     case TARGET_EXC_BAD_INSTRUCTION: return _NSIG + EXC_BAD_INSTRUCTION;
1417 #endif
1418 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1419     case TARGET_EXC_ARITHMETIC: return _NSIG + EXC_ARITHMETIC;
1420 #endif
1421 #if defined (EXC_EMULATION) && defined (_NSIG)
1422     case TARGET_EXC_EMULATION: return _NSIG + EXC_EMULATION;
1423 #endif
1424 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1425     case TARGET_EXC_SOFTWARE: return _NSIG + EXC_SOFTWARE;
1426 #endif
1427 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1428     case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
1429 #endif
1430
1431     default:
1432 #if defined (REALTIME_LO)
1433       if (oursig >= TARGET_SIGNAL_REALTIME_33
1434           && oursig <= TARGET_SIGNAL_REALTIME_63)
1435         {
1436           int retsig =
1437             (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + REALTIME_LO;
1438           if (retsig < REALTIME_HI)
1439             return retsig;
1440         }
1441 #endif
1442       /* The user might be trying to do "signal SIGSAK" where this system
1443          doesn't have SIGSAK.  */
1444       warning ("Signal %s does not exist on this system.\n",
1445                target_signal_to_name (oursig));
1446       return 0;
1447     }
1448 }
1449
1450 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1451    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1452    translation of that in OURSTATUS.  */
1453 void
1454 store_waitstatus (ourstatus, hoststatus)
1455      struct target_waitstatus *ourstatus;
1456      int hoststatus;
1457 {
1458 #ifdef CHILD_SPECIAL_WAITSTATUS
1459   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1460      if it wants to deal with hoststatus.  */
1461   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1462     return;
1463 #endif
1464
1465   if (WIFEXITED (hoststatus))
1466     {
1467       ourstatus->kind = TARGET_WAITKIND_EXITED;
1468       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1469     }
1470   else if (!WIFSTOPPED (hoststatus))
1471     {
1472       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1473       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1474     }
1475   else
1476     {
1477       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1478       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1479     }
1480 }
1481 \f
1482 /* In some circumstances we allow a command to specify a numeric
1483    signal.  The idea is to keep these circumstances limited so that
1484    users (and scripts) develop portable habits.  For comparison,
1485    POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1486    numeric signal at all is obscelescent.  We are slightly more
1487    lenient and allow 1-15 which should match host signal numbers on
1488    most systems.  Use of symbolic signal names is strongly encouraged.  */
1489
1490 enum target_signal
1491 target_signal_from_command (num)
1492      int num;
1493 {
1494   if (num >= 1 && num <= 15)
1495     return (enum target_signal)num;
1496   error ("Only signals 1-15 are valid as numeric signals.\n\
1497 Use \"info signals\" for a list of symbolic signals.");
1498 }
1499 \f
1500 /* Returns zero to leave the inferior alone, one to interrupt it.  */
1501 int (*target_activity_function) PARAMS ((void));
1502 int target_activity_fd;
1503 \f
1504 /* Convert a normal process ID to a string.  Returns the string in a static
1505    buffer.  */
1506
1507 char *
1508 normal_pid_to_str (pid)
1509      int pid;
1510 {
1511   static char buf[30];
1512
1513   if (STREQ (current_target.to_shortname, "remote"))
1514     sprintf (buf, "thread %d", pid);
1515   else
1516     sprintf (buf, "process %d", pid);
1517
1518   return buf;
1519 }
1520 \f
1521 #ifdef MAINTENANCE_CMDS
1522 static struct target_ops debug_target;
1523
1524 static void
1525 debug_to_open (args, from_tty)
1526      char *args;
1527      int from_tty;
1528 {
1529   debug_target.to_open (args, from_tty);
1530
1531   fprintf_unfiltered (stderr, "target_open (%s, %d)\n", args, from_tty);
1532 }
1533
1534 static void
1535 debug_to_close (quitting)
1536      int quitting;
1537 {
1538   debug_target.to_close (quitting);
1539
1540   fprintf_unfiltered (stderr, "target_close (%d)\n", quitting);
1541 }
1542
1543 static void
1544 debug_to_attach (args, from_tty)
1545      char *args;
1546      int from_tty;
1547 {
1548   debug_target.to_attach (args, from_tty);
1549
1550   fprintf_unfiltered (stderr, "target_attach (%s, %d)\n", args, from_tty);
1551 }
1552
1553 static void
1554 debug_to_detach (args, from_tty)
1555      char *args;
1556      int from_tty;
1557 {
1558   debug_target.to_detach (args, from_tty);
1559
1560   fprintf_unfiltered (stderr, "target_detach (%s, %d)\n", args, from_tty);
1561 }
1562
1563 static void
1564 debug_to_resume (pid, step, siggnal)
1565      int pid;
1566      int step;
1567      enum target_signal siggnal;
1568 {
1569   debug_target.to_resume (pid, step, siggnal);
1570
1571   fprintf_unfiltered (stderr, "target_resume (%d, %s, %s)\n", pid,
1572                       step ? "step" : "continue",
1573                       target_signal_to_name (siggnal));
1574 }
1575
1576 static int
1577 debug_to_wait (pid, status)
1578      int pid;
1579      struct target_waitstatus *status;
1580 {
1581   int retval;
1582
1583   retval = debug_target.to_wait (pid, status);
1584
1585   fprintf_unfiltered (stderr, "target_wait (%d, status) = %d,   ", pid, retval);
1586   fprintf_unfiltered (stderr, "status->kind = ");
1587   switch (status->kind)
1588     {
1589     case TARGET_WAITKIND_EXITED:
1590       fprintf_unfiltered (stderr, "exited, status = %d\n", status->value.integer);
1591       break;
1592     case TARGET_WAITKIND_STOPPED:
1593       fprintf_unfiltered (stderr, "stopped, signal = %s\n",
1594                           target_signal_to_name (status->value.sig));
1595       break;
1596     case TARGET_WAITKIND_SIGNALLED:
1597       fprintf_unfiltered (stderr, "signalled, signal = %s\n",
1598                           target_signal_to_name (status->value.sig));
1599       break;
1600     case TARGET_WAITKIND_LOADED:
1601       fprintf_unfiltered (stderr, "loaded\n");
1602       break;
1603     case TARGET_WAITKIND_SPURIOUS:
1604       fprintf_unfiltered (stderr, "spurious\n");
1605       break;
1606     default:
1607       fprintf_unfiltered (stderr, "unknown???\n");
1608       break;
1609     }
1610
1611   return retval;
1612 }
1613
1614 static void
1615 debug_to_fetch_registers (regno)
1616      int regno;
1617 {
1618   debug_target.to_fetch_registers (regno);
1619
1620   fprintf_unfiltered (stderr, "target_fetch_registers (%s)",
1621                       regno != -1 ? reg_names[regno] : "-1");
1622   if (regno != -1)
1623     fprintf_unfiltered (stderr, " = 0x%x %d", read_register (regno),
1624                         read_register (regno));
1625   fprintf_unfiltered (stderr, "\n");
1626 }
1627
1628 static void
1629 debug_to_store_registers (regno)
1630      int regno;
1631 {
1632   debug_target.to_store_registers (regno);
1633
1634   if (regno >= 0 && regno < NUM_REGS)
1635     fprintf_unfiltered (stderr, "target_store_registers (%s) = 0x%x %d\n",
1636                         reg_names[regno], read_register (regno),
1637                         read_register (regno));
1638   else
1639     fprintf_unfiltered (stderr, "target_store_registers (%d)\n", regno);
1640 }
1641
1642 static void
1643 debug_to_prepare_to_store ()
1644 {
1645   debug_target.to_prepare_to_store ();
1646
1647   fprintf_unfiltered (stderr, "target_prepare_to_store ()\n");
1648 }
1649
1650 static int
1651 debug_to_xfer_memory (memaddr, myaddr, len, write, target)
1652      CORE_ADDR memaddr;
1653      char *myaddr;
1654      int len;
1655      int write;
1656      struct target_ops *target;
1657 {
1658   int retval;
1659
1660   retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
1661
1662   fprintf_unfiltered (stderr,
1663                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1664                       memaddr, len, write ? "write" : "read", retval);
1665
1666   if (retval > 0)
1667     {
1668       int i;
1669
1670       fputs_unfiltered (", bytes =", gdb_stderr);
1671       for (i = 0; i < retval; i++)
1672         {
1673           if ((((long) &(myaddr[i])) & 0xf) == 0)
1674             fprintf_unfiltered (stderr, "\n");
1675           fprintf_unfiltered (stderr, " %02x", myaddr[i] & 0xff);
1676         }
1677     }
1678
1679   fputc_unfiltered ('\n', gdb_stderr);
1680
1681   return retval;
1682 }
1683
1684 static void
1685 debug_to_files_info (target)
1686      struct target_ops *target;
1687 {
1688   debug_target.to_files_info (target);
1689
1690   fprintf_unfiltered (stderr, "target_files_info (xxx)\n");
1691 }
1692
1693 static int
1694 debug_to_insert_breakpoint (addr, save)
1695      CORE_ADDR addr;
1696      char *save;
1697 {
1698   int retval;
1699
1700   retval = debug_target.to_insert_breakpoint (addr, save);
1701
1702   fprintf_unfiltered (stderr, "target_insert_breakpoint (0x%x, xxx) = %d\n",
1703                       addr, retval);
1704   return retval;
1705 }
1706
1707 static int
1708 debug_to_remove_breakpoint (addr, save)
1709      CORE_ADDR addr;
1710      char *save;
1711 {
1712   int retval;
1713
1714   retval = debug_target.to_remove_breakpoint (addr, save);
1715
1716   fprintf_unfiltered (stderr, "target_remove_breakpoint (0x%x, xxx) = %d\n",
1717                       addr, retval);
1718   return retval;
1719 }
1720
1721 static void
1722 debug_to_terminal_init ()
1723 {
1724   debug_target.to_terminal_init ();
1725
1726   fprintf_unfiltered (stderr, "target_terminal_init ()\n");
1727 }
1728
1729 static void
1730 debug_to_terminal_inferior ()
1731 {
1732   debug_target.to_terminal_inferior ();
1733
1734   fprintf_unfiltered (stderr, "target_terminal_inferior ()\n");
1735 }
1736
1737 static void
1738 debug_to_terminal_ours_for_output ()
1739 {
1740   debug_target.to_terminal_ours_for_output ();
1741
1742   fprintf_unfiltered (stderr, "target_terminal_ours_for_output ()\n");
1743 }
1744
1745 static void
1746 debug_to_terminal_ours ()
1747 {
1748   debug_target.to_terminal_ours ();
1749
1750   fprintf_unfiltered (stderr, "target_terminal_ours ()\n");
1751 }
1752
1753 static void
1754 debug_to_terminal_info (arg, from_tty)
1755      char *arg;
1756      int from_tty;
1757 {
1758   debug_target.to_terminal_info (arg, from_tty);
1759
1760   fprintf_unfiltered (stderr, "target_terminal_info (%s, %d)\n", arg,
1761                       from_tty);
1762 }
1763
1764 static void
1765 debug_to_kill ()
1766 {
1767   debug_target.to_kill ();
1768
1769   fprintf_unfiltered (stderr, "target_kill ()\n");
1770 }
1771
1772 static void
1773 debug_to_load (args, from_tty)
1774      char *args;
1775      int from_tty;
1776 {
1777   debug_target.to_load (args, from_tty);
1778
1779   fprintf_unfiltered (stderr, "target_load (%s, %d)\n", args, from_tty);
1780 }
1781
1782 static int
1783 debug_to_lookup_symbol (name, addrp)
1784      char *name;
1785      CORE_ADDR *addrp;
1786 {
1787   int retval;
1788
1789   retval = debug_target.to_lookup_symbol (name, addrp);
1790
1791   fprintf_unfiltered (stderr, "target_lookup_symbol (%s, xxx)\n", name);
1792
1793   return retval;
1794 }
1795
1796 static void
1797 debug_to_create_inferior (exec_file, args, env)
1798      char *exec_file;
1799      char *args;
1800      char **env;
1801 {
1802   debug_target.to_create_inferior (exec_file, args, env);
1803
1804   fprintf_unfiltered (stderr, "target_create_inferior (%s, %s, xxx)\n",
1805                       exec_file, args);
1806 }
1807
1808 static void
1809 debug_to_mourn_inferior ()
1810 {
1811   debug_target.to_mourn_inferior ();
1812
1813   fprintf_unfiltered (stderr, "target_mourn_inferior ()\n");
1814 }
1815
1816 static int
1817 debug_to_can_run ()
1818 {
1819   int retval;
1820
1821   retval = debug_target.to_can_run ();
1822
1823   fprintf_unfiltered (stderr, "target_can_run () = %d\n", retval);
1824
1825   return retval;
1826 }
1827
1828 static void
1829 debug_to_notice_signals (pid)
1830      int pid;
1831 {
1832   debug_target.to_notice_signals (pid);
1833
1834   fprintf_unfiltered (stderr, "target_notice_signals (%d)\n", pid);
1835 }
1836
1837 static int
1838 debug_to_thread_alive (pid)
1839      int pid;
1840 {
1841   int retval;
1842
1843   retval = debug_target.to_thread_alive (pid);
1844
1845   fprintf_unfiltered (stderr, "target_thread_alive (%d) = %d\n", pid, retval);
1846
1847   return retval;
1848 }
1849
1850 static void
1851 debug_to_stop ()
1852 {
1853   debug_target.to_stop ();
1854
1855   fprintf_unfiltered (stderr, "target_stop ()\n");
1856 }
1857
1858 static void
1859 setup_target_debug ()
1860 {
1861   memcpy (&debug_target, &current_target, sizeof debug_target);
1862
1863   current_target.to_open = debug_to_open;
1864   current_target.to_close = debug_to_close;
1865   current_target.to_attach = debug_to_attach;
1866   current_target.to_detach = debug_to_detach;
1867   current_target.to_resume = debug_to_resume;
1868   current_target.to_wait = debug_to_wait;
1869   current_target.to_fetch_registers = debug_to_fetch_registers;
1870   current_target.to_store_registers = debug_to_store_registers;
1871   current_target.to_prepare_to_store = debug_to_prepare_to_store;
1872   current_target.to_xfer_memory = debug_to_xfer_memory;
1873   current_target.to_files_info = debug_to_files_info;
1874   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
1875   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
1876   current_target.to_terminal_init = debug_to_terminal_init;
1877   current_target.to_terminal_inferior = debug_to_terminal_inferior;
1878   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
1879   current_target.to_terminal_ours = debug_to_terminal_ours;
1880   current_target.to_terminal_info = debug_to_terminal_info;
1881   current_target.to_kill = debug_to_kill;
1882   current_target.to_load = debug_to_load;
1883   current_target.to_lookup_symbol = debug_to_lookup_symbol;
1884   current_target.to_create_inferior = debug_to_create_inferior;
1885   current_target.to_mourn_inferior = debug_to_mourn_inferior;
1886   current_target.to_can_run = debug_to_can_run;
1887   current_target.to_notice_signals = debug_to_notice_signals;
1888   current_target.to_thread_alive = debug_to_thread_alive;
1889   current_target.to_stop = debug_to_stop;
1890 }
1891 #endif /* MAINTENANCE_CMDS */
1892 \f
1893 static char targ_desc[] =
1894     "Names of targets and files being debugged.\n\
1895 Shows the entire stack of targets currently in use (including the exec-file,\n\
1896 core-file, and process, if any), as well as the symbol file name.";
1897
1898 void
1899 initialize_targets ()
1900 {
1901   push_target (&dummy_target);
1902
1903   add_info ("target", target_info, targ_desc);
1904   add_info ("files", target_info, targ_desc);
1905
1906 #ifdef MAINTENANCE_CMDS
1907   add_show_from_set (
1908      add_set_cmd ("targetdebug", class_maintenance, var_zinteger,
1909                   (char *)&targetdebug,
1910                  "Set target debugging.\n\
1911 When non-zero, target debugging is enabled.", &setlist),
1912                      &showlist);
1913 #endif
1914
1915   if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
1916     abort ();
1917 }