gdb/target.c

   1 /* Select target systems and architectures at runtime for GDB.
   2    Copyright 1990, 1992, 1993, 1994 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include <errno.h>
  23 #include <ctype.h>
  24 #include "target.h"
  25 #include "gdbcmd.h"
  26 #include "symtab.h"
  27 #include "inferior.h"
  28 #include "bfd.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31 #include "wait.h"
  32 #include <signal.h>
  33
  34 extern int errno;
  35
  36 static void
  37 target_info PARAMS ((char *, int));
  38
  39 static void
  40 cleanup_target PARAMS ((struct target_ops *));
  41
  42 static void
  43 maybe_kill_then_create_inferior PARAMS ((char *, char *, char **));
  44
  45 static void
  46 maybe_kill_then_attach PARAMS ((char *, int));
  47
  48 static void
  49 kill_or_be_killed PARAMS ((int));
  50
  51 static void
  52 default_terminal_info PARAMS ((char *, int));
  53
  54 static int
  55 nosymbol PARAMS ((char *, CORE_ADDR *));
  56
  57 static void
  58 tcomplain PARAMS ((void));
  59
  60 static int
  61 nomemory PARAMS ((CORE_ADDR, char *, int, int));
  62
  63 static int
  64 return_zero PARAMS ((void));
  65
  66 static void
  67 ignore PARAMS ((void));
  68
  69 static void
  70 target_command PARAMS ((char *, int));
  71
  72 static struct target_ops *
  73 find_default_run_target PARAMS ((char *));
  74
  75 /* Pointer to array of target architecture structures; the size of the
  76    array; the current index into the array; the allocated size of the
  77    array.  */
  78 struct target_ops **target_structs;
  79 unsigned target_struct_size;
  80 unsigned target_struct_index;
  81 unsigned target_struct_allocsize;
  82 #define DEFAULT_ALLOCSIZE       10
  83
  84 /* The initial current target, so that there is always a semi-valid
  85    current target.  */
  86
  87 struct target_ops dummy_target = {"None", "None", "",
  88     0, 0,               /* open, close */
  89     find_default_attach, 0,  /* attach, detach */
  90     0, 0,               /* resume, wait */
  91     0, 0, 0,            /* registers */
  92     0, 0,               /* memory */
  93     0, 0,               /* bkpts */
  94     0, 0, 0, 0, 0,      /* terminal */
  95     0, 0,               /* kill, load */
  96     0,                  /* lookup_symbol */
  97     find_default_create_inferior, /* create_inferior */
  98     0,                  /* mourn_inferior */
  99     0,                  /* can_run */
 100     0,                  /* notice_signals */
 101     dummy_stratum, 0,   /* stratum, next */
 102     0, 0, 0, 0, 0,      /* all mem, mem, stack, regs, exec */
 103     0, 0,               /* section pointers */
 104     OPS_MAGIC,
 105 };
 106
 107 /* The target structure we are currently using to talk to a process
 108    or file or whatever "inferior" we have.  */
 109
 110 struct target_ops *current_target;
 111
 112 /* The stack of target structures that have been pushed.  */
 113
 114 struct target_ops **current_target_stack;
 115
 116 /* Command list for target.  */
 117
 118 static struct cmd_list_element *targetlist = NULL;
 119
 120 /* The user just typed 'target' without the name of a target.  */
 121
 122 /* ARGSUSED */
 123 static void
 124 target_command (arg, from_tty)
 125      char *arg;
 126      int from_tty;
 127 {
 128   fputs_filtered ("Argument required (target name).  Try `help target'\n",
 129                   gdb_stdout);
 130 }
 131
 132 /* Add a possible target architecture to the list.  */
 133
 134 void
 135 add_target (t)
 136      struct target_ops *t;
 137 {
 138   if (t->to_magic != OPS_MAGIC)
 139     {
 140       fprintf_unfiltered(gdb_stderr, "Magic number of %s target struct wrong\n",
 141         t->to_shortname);
 142       abort();
 143     }
 144
 145   if (!target_structs)
 146     {
 147       target_struct_allocsize = DEFAULT_ALLOCSIZE;
 148       target_structs = (struct target_ops **) xmalloc
 149         (target_struct_allocsize * sizeof (*target_structs));
 150     }
 151   if (target_struct_size >= target_struct_allocsize)
 152     {
 153       target_struct_allocsize *= 2;
 154       target_structs = (struct target_ops **)
 155           xrealloc ((char *) target_structs,
 156                     target_struct_allocsize * sizeof (*target_structs));
 157     }
 158   target_structs[target_struct_size++] = t;
 159   cleanup_target (t);
 160
 161   if (targetlist == NULL)
 162     add_prefix_cmd ("target", class_run, target_command,
 163                     "Connect to a target machine or process.\n\
 164 The first argument is the type or protocol of the target machine.\n\
 165 Remaining arguments are interpreted by the target protocol.  For more\n\
 166 information on the arguments for a particular protocol, type\n\
 167 `help target ' followed by the protocol name.",
 168                     &targetlist, "target ", 0, &cmdlist);
 169   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
 170 }
 171
 172 /* Stub functions */
 173
 174 static void
 175 ignore ()
 176 {
 177 }
 178
 179 /* ARGSUSED */
 180 static int
 181 nomemory (memaddr, myaddr, len, write)
 182      CORE_ADDR memaddr;
 183      char *myaddr;
 184      int len;
 185      int write;
 186 {
 187   errno = EIO;          /* Can't read/write this location */
 188   return 0;             /* No bytes handled */
 189 }
 190
 191 static void
 192 tcomplain ()
 193 {
 194   error ("You can't do that when your target is `%s'",
 195          current_target->to_shortname);
 196 }
 197
 198 void
 199 noprocess ()
 200 {
 201   error ("You can't do that without a process to debug");
 202 }
 203
 204 /* ARGSUSED */
 205 static int
 206 nosymbol (name, addrp)
 207      char *name;
 208      CORE_ADDR *addrp;
 209 {
 210   return 1;             /* Symbol does not exist in target env */
 211 }
 212
 213 /* ARGSUSED */
 214 static void
 215 default_terminal_info (args, from_tty)
 216      char *args;
 217      int from_tty;
 218 {
 219   printf_unfiltered("No saved terminal information.\n");
 220 }
 221
 222 #if 0
 223 /* With strata, this function is no longer needed.  FIXME.  */
 224 /* This is the default target_create_inferior function.  It looks up
 225    the stack for some target that cares to create inferiors, then
 226    calls it -- or complains if not found.  */
 227
 228 static void
 229 upstack_create_inferior (exec, args, env)
 230      char *exec;
 231      char *args;
 232      char **env;
 233 {
 234   struct target_ops *t;
 235
 236   for (t = current_target;
 237        t;
 238        t = t->to_next)
 239     {
 240       if (t->to_create_inferior != upstack_create_inferior)
 241         {
 242           t->to_create_inferior (exec, args, env);
 243           return;
 244         }
 245
 246     }
 247   tcomplain();
 248 }
 249 #endif
 250
 251 /* This is the default target_create_inferior and target_attach function.
 252    If the current target is executing, it asks whether to kill it off.
 253    If this function returns without calling error(), it has killed off
 254    the target, and the operation should be attempted.  */
 255
 256 static void
 257 kill_or_be_killed (from_tty)
 258      int from_tty;
 259 {
 260   if (target_has_execution)
 261     {
 262       printf_unfiltered ("You are already running a program:\n");
 263       target_files_info ();
 264       if (query ("Kill it? ")) {
 265         target_kill ();
 266         if (target_has_execution)
 267           error ("Killing the program did not help.");
 268         return;
 269       } else {
 270         error ("Program not killed.");
 271       }
 272     }
 273   tcomplain();
 274 }
 275
 276 static void
 277 maybe_kill_then_attach (args, from_tty)
 278      char *args;
 279      int from_tty;
 280 {
 281   kill_or_be_killed (from_tty);
 282   target_attach (args, from_tty);
 283 }
 284
 285 static void
 286 maybe_kill_then_create_inferior (exec, args, env)
 287      char *exec;
 288      char *args;
 289      char **env;
 290 {
 291   kill_or_be_killed (0);
 292   target_create_inferior (exec, args, env);
 293 }
 294
 295 /* Clean up a target struct so it no longer has any zero pointers in it.
 296    We default entries, at least to stubs that print error messages.  */
 297
 298 static void
 299 cleanup_target (t)
 300      struct target_ops *t;
 301 {
 302
 303   /* Check magic number.  If wrong, it probably means someone changed
 304      the struct definition, but not all the places that initialize one.  */
 305   if (t->to_magic != OPS_MAGIC)
 306     {
 307       fprintf_unfiltered(gdb_stderr, "Magic number of %s target struct wrong\n",
 308         t->to_shortname);
 309       abort();
 310     }
 311
 312 #define de_fault(field, value) \
 313   if (!t->field)        t->field = value
 314
 315   /*        FIELD                       DEFAULT VALUE        */
 316
 317   de_fault (to_open,                    (void (*)())tcomplain);
 318   de_fault (to_close,                   (void (*)())ignore);
 319   de_fault (to_attach,                  maybe_kill_then_attach);
 320   de_fault (to_detach,                  (void (*)())ignore);
 321   de_fault (to_resume,                  (void (*)())noprocess);
 322   de_fault (to_wait,                    (int (*)())noprocess);
 323   de_fault (to_fetch_registers,         (void (*)())ignore);
 324   de_fault (to_store_registers,         (void (*)())noprocess);
 325   de_fault (to_prepare_to_store,        (void (*)())noprocess);
 326   de_fault (to_xfer_memory,             (int (*)())nomemory);
 327   de_fault (to_files_info,              (void (*)())ignore);
 328   de_fault (to_insert_breakpoint,       memory_insert_breakpoint);
 329   de_fault (to_remove_breakpoint,       memory_remove_breakpoint);
 330   de_fault (to_terminal_init,           ignore);
 331   de_fault (to_terminal_inferior,       ignore);
 332   de_fault (to_terminal_ours_for_output,ignore);
 333   de_fault (to_terminal_ours,           ignore);
 334   de_fault (to_terminal_info,           default_terminal_info);
 335   de_fault (to_kill,                    (void (*)())noprocess);
 336   de_fault (to_load,                    (void (*)())tcomplain);
 337   de_fault (to_lookup_symbol,           nosymbol);
 338   de_fault (to_create_inferior,         maybe_kill_then_create_inferior);
 339   de_fault (to_mourn_inferior,          (void (*)())noprocess);
 340   de_fault (to_can_run,                 return_zero);
 341   de_fault (to_notice_signals,          (void (*)())ignore);
 342   de_fault (to_next,                    0);
 343   de_fault (to_has_all_memory,          0);
 344   de_fault (to_has_memory,              0);
 345   de_fault (to_has_stack,               0);
 346   de_fault (to_has_registers,           0);
 347   de_fault (to_has_execution,           0);
 348
 349 #undef de_fault
 350 }
 351
 352 /* Push a new target type into the stack of the existing target accessors,
 353    possibly superseding some of the existing accessors.
 354
 355    Result is zero if the pushed target ended up on top of the stack,
 356    nonzero if at least one target is on top of it.
 357
 358    Rather than allow an empty stack, we always have the dummy target at
 359    the bottom stratum, so we can call the function vectors without
 360    checking them.  */
 361
 362 int
 363 push_target (t)
 364      struct target_ops *t;
 365 {
 366   struct target_ops *st, *prev;
 367
 368   for (prev = 0, st = current_target;
 369        st;
 370        prev = st, st = st->to_next) {
 371     if ((int)(t->to_stratum) >= (int)(st->to_stratum))
 372       break;
 373   }
 374
 375   while (t->to_stratum == st->to_stratum) {
 376     /* There's already something on this stratum.  Close it off.  */
 377     (st->to_close) (0);
 378     if (prev)
 379       prev->to_next = st->to_next;      /* Unchain old target_ops */
 380     else
 381       current_target = st->to_next;     /* Unchain first on list */
 382     st = st->to_next;
 383   }
 384
 385   /* We have removed all targets in our stratum, now add ourself.  */
 386   t->to_next = st;
 387   if (prev)
 388     prev->to_next = t;
 389   else
 390     current_target = t;
 391
 392   cleanup_target (current_target);
 393   return prev != 0;
 394 }
 395
 396 /* Remove a target_ops vector from the stack, wherever it may be.
 397    Return how many times it was removed (0 or 1 unless bug).  */
 398
 399 int
 400 unpush_target (t)
 401      struct target_ops *t;
 402 {
 403   struct target_ops *u, *v;
 404   int result = 0;
 405
 406   for (u = current_target, v = 0;
 407        u;
 408        v = u, u = u->to_next)
 409     if (u == t)
 410       {
 411         if (v == 0)
 412           pop_target();                 /* unchain top copy */
 413         else {
 414           (t->to_close)(0);             /* Let it clean up */
 415           v->to_next = t->to_next;      /* unchain middle copy */
 416         }
 417         result++;
 418       }
 419   return result;
 420 }
 421
 422 void
 423 pop_target ()
 424 {
 425   (current_target->to_close)(0);        /* Let it clean up */
 426   current_target = current_target->to_next;
 427 #if 0
 428   /* This will dump core if ever called--push_target expects current_target
 429      to be non-NULL.  But I don't think it's needed; I don't see how the
 430      dummy_target could ever be removed from the stack.  */
 431   if (!current_target)          /* At bottom, push dummy.  */
 432     push_target (&dummy_target);
 433 #endif
 434 }
 435
 436 #undef  MIN
 437 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
 438
 439 /* target_read_string -- read a null terminated string, up to LEN bytes,
 440    from MEMADDR in target.  Set *ERRNOP to the errno code, or 0 if successful.
 441    Set *STRING to a pointer to malloc'd memory containing the data; the caller
 442    is responsible for freeing it.  Return the number of bytes successfully
 443    read.  */
 444
 445 int
 446 target_read_string (memaddr, string, len, errnop)
 447      CORE_ADDR memaddr;
 448      char **string;
 449      int len;
 450      int *errnop;
 451 {
 452   int tlen, origlen, offset, i;
 453   char buf[4];
 454   int errcode = 0;
 455   char *buffer;
 456   int buffer_allocated;
 457   char *bufptr;
 458   unsigned int nbytes_read = 0;
 459
 460   /* Small for testing.  */
 461   buffer_allocated = 4;
 462   buffer = xmalloc (buffer_allocated);
 463   bufptr = buffer;
 464
 465   origlen = len;
 466
 467   while (len > 0)
 468     {
 469       tlen = MIN (len, 4 - (memaddr & 3));
 470       offset = memaddr & 3;
 471
 472       errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
 473       if (errcode != 0)
 474         goto done;
 475
 476       if (bufptr - buffer + tlen > buffer_allocated)
 477         {
 478           unsigned int bytes;
 479           bytes = bufptr - buffer;
 480           buffer_allocated *= 2;
 481           buffer = xrealloc (buffer, buffer_allocated);
 482           bufptr = buffer + bytes;
 483         }
 484
 485       for (i = 0; i < tlen; i++)
 486         {
 487           *bufptr++ = buf[i + offset];
 488           if (buf[i + offset] == '\000')
 489             {
 490               nbytes_read += i + 1;
 491               goto done;
 492             }
 493         }
 494
 495       memaddr += tlen;
 496       len -= tlen;
 497       nbytes_read += tlen;
 498     }
 499  done:
 500   if (errnop != NULL)
 501     *errnop = errcode;
 502   if (string != NULL)
 503     *string = buffer;
 504   return nbytes_read;
 505 }
 506
 507 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
 508    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
 509    if any error occurs.
 510
 511    If an error occurs, no guarantee is made about the contents of the data at
 512    MYADDR.  In particular, the caller should not depend upon partial reads
 513    filling the buffer with good data.  There is no way for the caller to know
 514    how much good data might have been transfered anyway.  Callers that can
 515    deal with partial reads should call target_read_memory_partial. */
 516
 517 int
 518 target_read_memory (memaddr, myaddr, len)
 519      CORE_ADDR memaddr;
 520      char *myaddr;
 521      int len;
 522 {
 523   return target_xfer_memory (memaddr, myaddr, len, 0);
 524 }
 525
 526 /* Read LEN bytes of target memory at address MEMADDR, placing the results
 527    in GDB's memory at MYADDR.  Returns a count of the bytes actually read,
 528    and optionally an errno value in the location pointed to by ERRNOPTR
 529    if ERRNOPTR is non-null. */
 530
 531 int
 532 target_read_memory_partial (memaddr, myaddr, len, errnoptr)
 533      CORE_ADDR memaddr;
 534      char *myaddr;
 535      int len;
 536      int *errnoptr;
 537 {
 538   int nread;    /* Number of bytes actually read. */
 539   int errcode;  /* Error from last read. */
 540
 541   /* First try a complete read. */
 542   errcode = target_xfer_memory (memaddr, myaddr, len, 0);
 543   if (errcode == 0)
 544     {
 545       /* Got it all. */
 546       nread = len;
 547     }
 548   else
 549     {
 550       /* Loop, reading one byte at a time until we get as much as we can. */
 551       for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
 552         {
 553           errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0);
 554         }
 555       /* If an error, the last read was unsuccessful, so adjust count. */
 556       if (errcode != 0)
 557         {
 558           nread--;
 559         }
 560     }
 561   if (errnoptr != NULL)
 562     {
 563       *errnoptr = errcode;
 564     }
 565   return (nread);
 566 }
 567
 568 int
 569 target_write_memory (memaddr, myaddr, len)
 570      CORE_ADDR memaddr;
 571      char *myaddr;
 572      int len;
 573 {
 574   return target_xfer_memory (memaddr, myaddr, len, 1);
 575 }
 576
 577 /* Move memory to or from the targets.  Iterate until all of it has
 578    been moved, if necessary.  The top target gets priority; anything
 579    it doesn't want, is offered to the next one down, etc.  Note the
 580    business with curlen:  if an early target says "no, but I have a
 581    boundary overlapping this xfer" then we shorten what we offer to
 582    the subsequent targets so the early guy will get a chance at the
 583    tail before the subsequent ones do.
 584
 585    Result is 0 or errno value.  */
 586
 587 int
 588 target_xfer_memory (memaddr, myaddr, len, write)
 589      CORE_ADDR memaddr;
 590      char *myaddr;
 591      int len;
 592      int write;
 593 {
 594   int curlen;
 595   int res;
 596   struct target_ops *t;
 597
 598   /* to_xfer_memory is not guaranteed to set errno, even when it returns
 599      0.  */
 600   errno = 0;
 601
 602   /* The quick case is that the top target does it all.  */
 603   res = current_target->to_xfer_memory
 604                         (memaddr, myaddr, len, write, current_target);
 605   if (res == len)
 606     return 0;
 607
 608   if (res > 0)
 609     goto bump;
 610   /* If res <= 0 then we call it again in the loop.  Ah well.  */
 611
 612   for (; len > 0;)
 613     {
 614       curlen = len;             /* Want to do it all */
 615       for (t = current_target;
 616            t;
 617            t = t->to_has_all_memory? 0: t->to_next)
 618         {
 619           res = t->to_xfer_memory(memaddr, myaddr, curlen, write, t);
 620           if (res > 0) break;   /* Handled all or part of xfer */
 621           if (res == 0) continue;       /* Handled none */
 622           curlen = -res;        /* Could handle once we get past res bytes */
 623         }
 624       if (res <= 0)
 625         {
 626           /* If this address is for nonexistent memory,
 627              read zeros if reading, or do nothing if writing.  Return error. */
 628           if (!write)
 629             memset (myaddr, 0, len);
 630           if (errno == 0)
 631             return EIO;
 632           else
 633             return errno;
 634         }
 635 bump:
 636       memaddr += res;
 637       myaddr  += res;
 638       len     -= res;
 639     }
 640   return 0;                     /* We managed to cover it all somehow. */
 641 }
 642
 643
 644 /* ARGSUSED */
 645 static void
 646 target_info (args, from_tty)
 647      char *args;
 648      int from_tty;
 649 {
 650   struct target_ops *t;
 651   int has_all_mem = 0;
 652
 653   if (symfile_objfile != NULL)
 654     printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
 655
 656 #ifdef FILES_INFO_HOOK
 657   if (FILES_INFO_HOOK ())
 658     return;
 659 #endif
 660
 661   for (t = current_target;
 662        t;
 663        t = t->to_next)
 664     {
 665       if ((int)(t->to_stratum) <= (int)dummy_stratum)
 666         continue;
 667       if (has_all_mem)
 668         printf_unfiltered("\tWhile running this, gdb does not access memory from...\n");
 669       printf_unfiltered("%s:\n", t->to_longname);
 670       (t->to_files_info)(t);
 671       has_all_mem = t->to_has_all_memory;
 672     }
 673 }
 674
 675 /* This is to be called by the open routine before it does
 676    anything.  */
 677
 678 void
 679 target_preopen (from_tty)
 680      int from_tty;
 681 {
 682   dont_repeat();
 683
 684   if (target_has_execution)
 685     {
 686       if (query ("A program is being debugged already.  Kill it? "))
 687         target_kill ();
 688       else
 689         error ("Program not killed.");
 690     }
 691
 692   /* Calling target_kill may remove the target from the stack.  But if
 693      it doesn't (which seems like a win for UDI), remove it now.  */
 694
 695   if (target_has_execution)
 696     pop_target ();
 697 }
 698
 699 /* Detach a target after doing deferred register stores.  */
 700
 701 void
 702 target_detach (args, from_tty)
 703      char *args;
 704      int from_tty;
 705 {
 706   /* Handle any optimized stores to the inferior.  */
 707 #ifdef DO_DEFERRED_STORES
 708   DO_DEFERRED_STORES;
 709 #endif
 710   (current_target->to_detach) (args, from_tty);
 711 }
 712
 713 void
 714 target_link (modname, t_reloc)
 715      char *modname;
 716      CORE_ADDR *t_reloc;
 717 {
 718   if (STREQ(current_target->to_shortname, "rombug"))
 719     {
 720       (current_target->to_lookup_symbol) (modname, t_reloc);
 721     }
 722   else
 723     *t_reloc = (CORE_ADDR)-1;
 724 }
 725
 726 /* Look through the list of possible targets for a target that can
 727    execute a run or attach command without any other data.  This is
 728    used to locate the default process stratum.
 729
 730    Result is always valid (error() is called for errors).  */
 731
 732 static struct target_ops *
 733 find_default_run_target (do_mesg)
 734      char *do_mesg;
 735 {
 736   struct target_ops **t;
 737   struct target_ops *runable = NULL;
 738   int count;
 739
 740   count = 0;
 741
 742   for (t = target_structs; t < target_structs + target_struct_size;
 743        ++t)
 744     {
 745       if (target_can_run(*t))
 746         {
 747           runable = *t;
 748           ++count;
 749         }
 750     }
 751
 752   if (count != 1)
 753     error ("Don't know how to %s.  Try \"help target\".", do_mesg);
 754
 755   return runable;
 756 }
 757
 758 void
 759 find_default_attach (args, from_tty)
 760      char *args;
 761      int from_tty;
 762 {
 763   struct target_ops *t;
 764
 765   t = find_default_run_target("attach");
 766   (t->to_attach) (args, from_tty);
 767   return;
 768 }
 769
 770 void
 771 find_default_create_inferior (exec_file, allargs, env)
 772      char *exec_file;
 773      char *allargs;
 774      char **env;
 775 {
 776   struct target_ops *t;
 777
 778   t = find_default_run_target("run");
 779   (t->to_create_inferior) (exec_file, allargs, env);
 780   return;
 781 }
 782
 783 static int
 784 return_zero ()
 785 {
 786   return 0;
 787 }
 788
 789 struct target_ops *
 790 find_core_target ()
 791 {
 792   struct target_ops **t;
 793   struct target_ops *runable = NULL;
 794   int count;
 795
 796   count = 0;
 797
 798   for (t = target_structs; t < target_structs + target_struct_size;
 799        ++t)
 800     {
 801       if ((*t)->to_stratum == core_stratum)
 802         {
 803           runable = *t;
 804           ++count;
 805         }
 806     }
 807
 808   return(count == 1 ? runable : NULL);
 809 }
 810 \f
 811 /* This table must match in order and size the signals in enum target_signal
 812    in target.h.  */
 813 static struct {
 814   char *name;
 815   char *string;
 816   } signals [] =
 817 {
 818   {"0", "Signal 0"},
 819   {"SIGHUP", "Hangup"},
 820   {"SIGINT", "Interrupt"},
 821   {"SIGQUIT", "Quit"},
 822   {"SIGILL", "Illegal instruction"},
 823   {"SIGTRAP", "Trace/breakpoint trap"},
 824   {"SIGABRT", "Aborted"},
 825   {"SIGEMT", "Emulation trap"},
 826   {"SIGFPE", "Arithmetic exception"},
 827   {"SIGKILL", "Killed"},
 828   {"SIGBUS", "Bus error"},
 829   {"SIGSEGV", "Segmentation fault"},
 830   {"SIGSYS", "Bad system call"},
 831   {"SIGPIPE", "Broken pipe"},
 832   {"SIGALRM", "Alarm clock"},
 833   {"SIGTERM", "Terminated"},
 834   {"SIGURG", "Urgent I/O condition"},
 835   {"SIGSTOP", "Stopped (signal)"},
 836   {"SIGTSTP", "Stopped (user)"},
 837   {"SIGCONT", "Continued"},
 838   {"SIGCHLD", "Child status changed"},
 839   {"SIGTTIN", "Stopped (tty input)"},
 840   {"SIGTTOU", "Stopped (tty output)"},
 841   {"SIGIO", "I/O possible"},
 842   {"SIGXCPU", "CPU time limit exceeded"},
 843   {"SIGXFSZ", "File size limit exceeded"},
 844   {"SIGVTALRM", "Virtual timer expired"},
 845   {"SIGPROF", "Profiling timer expired"},
 846   {"SIGWINCH", "Window size changed"},
 847   {"SIGLOST", "Resource lost"},
 848   {"SIGUSR1", "User defined signal 1"},
 849   {"SIGUSR2", "User defined signal 2"},
 850   {"SIGPWR", "Power fail/restart"},
 851   {"SIGPOLL", "Pollable event occurred"},
 852   {"SIGWIND", "SIGWIND"},
 853   {"SIGPHONE", "SIGPHONE"},
 854   {"SIGWAITING", "Process's LWPs are blocked"},
 855   {"SIGLWP", "Signal LWP"},
 856   {"SIGDANGER", "Swap space dangerously low"},
 857   {"SIGGRANT", "Monitor mode granted"},
 858   {"SIGRETRACT", "Need to relinguish monitor mode"},
 859   {"SIGMSG", "Monitor mode data available"},
 860   {"SIGSOUND", "Sound completed"},
 861   {"SIGSAK", "Secure attention"},
 862   {NULL, "Unknown signal"},
 863   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
 864
 865   /* Last entry, used to check whether the table is the right size.  */
 866   {NULL, "TARGET_SIGNAL_MAGIC"}
 867 };
 868
 869 /* Return the string for a signal.  */
 870 char *
 871 target_signal_to_string (sig)
 872      enum target_signal sig;
 873 {
 874   return signals[sig].string;
 875 }
 876
 877 /* Return the name for a signal.  */
 878 char *
 879 target_signal_to_name (sig)
 880      enum target_signal sig;
 881 {
 882   if (sig == TARGET_SIGNAL_UNKNOWN)
 883     /* I think the code which prints this will always print it along with
 884        the string, so no need to be verbose.  */
 885     return "?";
 886   return signals[sig].name;
 887 }
 888
 889 /* Given a name, return its signal.  */
 890 enum target_signal
 891 target_signal_from_name (name)
 892      char *name;
 893 {
 894   enum target_signal sig;
 895
 896   /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
 897      for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
 898      questionable; seems like by now people should call it SIGABRT
 899      instead.  */
 900
 901   /* This ugly cast brought to you by the native VAX compiler.  */
 902   for (sig = TARGET_SIGNAL_HUP;
 903        signals[sig].name != NULL;
 904        sig = (enum target_signal)((int)sig + 1))
 905     if (STREQ (name, signals[sig].name))
 906       return sig;
 907   return TARGET_SIGNAL_UNKNOWN;
 908 }
 909 \f
 910 /* The following functions are to help certain targets deal
 911    with the signal/waitstatus stuff.  They could just as well be in
 912    a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */
 913
 914 /* Convert host signal to our signals.  */
 915 enum target_signal
 916 target_signal_from_host (hostsig)
 917      int hostsig;
 918 {
 919   /* A switch statement would make sense but would require special kludges
 920      to deal with the cases where more than one signal has the same number.  */
 921
 922   if (hostsig == 0) return TARGET_SIGNAL_0;
 923
 924 #if defined (SIGHUP)
 925   if (hostsig == SIGHUP) return TARGET_SIGNAL_HUP;
 926 #endif
 927 #if defined (SIGINT)
 928   if (hostsig == SIGINT) return TARGET_SIGNAL_INT;
 929 #endif
 930 #if defined (SIGQUIT)
 931   if (hostsig == SIGQUIT) return TARGET_SIGNAL_QUIT;
 932 #endif
 933 #if defined (SIGILL)
 934   if (hostsig == SIGILL) return TARGET_SIGNAL_ILL;
 935 #endif
 936 #if defined (SIGTRAP)
 937   if (hostsig == SIGTRAP) return TARGET_SIGNAL_TRAP;
 938 #endif
 939 #if defined (SIGABRT)
 940   if (hostsig == SIGABRT) return TARGET_SIGNAL_ABRT;
 941 #endif
 942 #if defined (SIGEMT)
 943   if (hostsig == SIGEMT) return TARGET_SIGNAL_EMT;
 944 #endif
 945 #if defined (SIGFPE)
 946   if (hostsig == SIGFPE) return TARGET_SIGNAL_FPE;
 947 #endif
 948 #if defined (SIGKILL)
 949   if (hostsig == SIGKILL) return TARGET_SIGNAL_KILL;
 950 #endif
 951 #if defined (SIGBUS)
 952   if (hostsig == SIGBUS) return TARGET_SIGNAL_BUS;
 953 #endif
 954 #if defined (SIGSEGV)
 955   if (hostsig == SIGSEGV) return TARGET_SIGNAL_SEGV;
 956 #endif
 957 #if defined (SIGSYS)
 958   if (hostsig == SIGSYS) return TARGET_SIGNAL_SYS;
 959 #endif
 960 #if defined (SIGPIPE)
 961   if (hostsig == SIGPIPE) return TARGET_SIGNAL_PIPE;
 962 #endif
 963 #if defined (SIGALRM)
 964   if (hostsig == SIGALRM) return TARGET_SIGNAL_ALRM;
 965 #endif
 966 #if defined (SIGTERM)
 967   if (hostsig == SIGTERM) return TARGET_SIGNAL_TERM;
 968 #endif
 969 #if defined (SIGUSR1)
 970   if (hostsig == SIGUSR1) return TARGET_SIGNAL_USR1;
 971 #endif
 972 #if defined (SIGUSR2)
 973   if (hostsig == SIGUSR2) return TARGET_SIGNAL_USR2;
 974 #endif
 975 #if defined (SIGCLD)
 976   if (hostsig == SIGCLD) return TARGET_SIGNAL_CHLD;
 977 #endif
 978 #if defined (SIGCHLD)
 979   if (hostsig == SIGCHLD) return TARGET_SIGNAL_CHLD;
 980 #endif
 981 #if defined (SIGPWR)
 982   if (hostsig == SIGPWR) return TARGET_SIGNAL_PWR;
 983 #endif
 984 #if defined (SIGWINCH)
 985   if (hostsig == SIGWINCH) return TARGET_SIGNAL_WINCH;
 986 #endif
 987 #if defined (SIGURG)
 988   if (hostsig == SIGURG) return TARGET_SIGNAL_URG;
 989 #endif
 990 #if defined (SIGIO)
 991   if (hostsig == SIGIO) return TARGET_SIGNAL_IO;
 992 #endif
 993 #if defined (SIGPOLL)
 994   if (hostsig == SIGPOLL) return TARGET_SIGNAL_POLL;
 995 #endif
 996 #if defined (SIGSTOP)
 997   if (hostsig == SIGSTOP) return TARGET_SIGNAL_STOP;
 998 #endif
 999 #if defined (SIGTSTP)
1000   if (hostsig == SIGTSTP) return TARGET_SIGNAL_TSTP;
1001 #endif
1002 #if defined (SIGCONT)
1003   if (hostsig == SIGCONT) return TARGET_SIGNAL_CONT;
1004 #endif
1005 #if defined (SIGTTIN)
1006   if (hostsig == SIGTTIN) return TARGET_SIGNAL_TTIN;
1007 #endif
1008 #if defined (SIGTTOU)
1009   if (hostsig == SIGTTOU) return TARGET_SIGNAL_TTOU;
1010 #endif
1011 #if defined (SIGVTALRM)
1012   if (hostsig == SIGVTALRM) return TARGET_SIGNAL_VTALRM;
1013 #endif
1014 #if defined (SIGPROF)
1015   if (hostsig == SIGPROF) return TARGET_SIGNAL_PROF;
1016 #endif
1017 #if defined (SIGXCPU)
1018   if (hostsig == SIGXCPU) return TARGET_SIGNAL_XCPU;
1019 #endif
1020 #if defined (SIGXFSZ)
1021   if (hostsig == SIGXFSZ) return TARGET_SIGNAL_XFSZ;
1022 #endif
1023 #if defined (SIGWIND)
1024   if (hostsig == SIGWIND) return TARGET_SIGNAL_WIND;
1025 #endif
1026 #if defined (SIGPHONE)
1027   if (hostsig == SIGPHONE) return TARGET_SIGNAL_PHONE;
1028 #endif
1029 #if defined (SIGLOST)
1030   if (hostsig == SIGLOST) return TARGET_SIGNAL_LOST;
1031 #endif
1032 #if defined (SIGWAITING)
1033   if (hostsig == SIGWAITING) return TARGET_SIGNAL_WAITING;
1034 #endif
1035 #if defined (SIGLWP)
1036   if (hostsig == SIGLWP) return TARGET_SIGNAL_LWP;
1037 #endif
1038 #if defined (SIGDANGER)
1039   if (hostsig == SIGDANGER) return TARGET_SIGNAL_DANGER;
1040 #endif
1041 #if defined (SIGGRANT)
1042   if (hostsig == SIGGRANT) return TARGET_SIGNAL_GRANT;
1043 #endif
1044 #if defined (SIGRETRACT)
1045   if (hostsig == SIGRETRACT) return TARGET_SIGNAL_RETRACT;
1046 #endif
1047 #if defined (SIGMSG)
1048   if (hostsig == SIGMSG) return TARGET_SIGNAL_MSG;
1049 #endif
1050 #if defined (SIGSOUND)
1051   if (hostsig == SIGSOUND) return TARGET_SIGNAL_SOUND;
1052 #endif
1053 #if defined (SIGSAK)
1054   if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK;
1055 #endif
1056   return TARGET_SIGNAL_UNKNOWN;
1057 }
1058
1059 int
1060 target_signal_to_host (oursig)
1061      enum target_signal oursig;
1062 {
1063   switch (oursig)
1064     {
1065     case TARGET_SIGNAL_0: return 0;
1066
1067 #if defined (SIGHUP)
1068     case TARGET_SIGNAL_HUP: return SIGHUP;
1069 #endif
1070 #if defined (SIGINT)
1071     case TARGET_SIGNAL_INT: return SIGINT;
1072 #endif
1073 #if defined (SIGQUIT)
1074     case TARGET_SIGNAL_QUIT: return SIGQUIT;
1075 #endif
1076 #if defined (SIGILL)
1077     case TARGET_SIGNAL_ILL: return SIGILL;
1078 #endif
1079 #if defined (SIGTRAP)
1080     case TARGET_SIGNAL_TRAP: return SIGTRAP;
1081 #endif
1082 #if defined (SIGABRT)
1083     case TARGET_SIGNAL_ABRT: return SIGABRT;
1084 #endif
1085 #if defined (SIGEMT)
1086     case TARGET_SIGNAL_EMT: return SIGEMT;
1087 #endif
1088 #if defined (SIGFPE)
1089     case TARGET_SIGNAL_FPE: return SIGFPE;
1090 #endif
1091 #if defined (SIGKILL)
1092     case TARGET_SIGNAL_KILL: return SIGKILL;
1093 #endif
1094 #if defined (SIGBUS)
1095     case TARGET_SIGNAL_BUS: return SIGBUS;
1096 #endif
1097 #if defined (SIGSEGV)
1098     case TARGET_SIGNAL_SEGV: return SIGSEGV;
1099 #endif
1100 #if defined (SIGSYS)
1101     case TARGET_SIGNAL_SYS: return SIGSYS;
1102 #endif
1103 #if defined (SIGPIPE)
1104     case TARGET_SIGNAL_PIPE: return SIGPIPE;
1105 #endif
1106 #if defined (SIGALRM)
1107     case TARGET_SIGNAL_ALRM: return SIGALRM;
1108 #endif
1109 #if defined (SIGTERM)
1110     case TARGET_SIGNAL_TERM: return SIGTERM;
1111 #endif
1112 #if defined (SIGUSR1)
1113     case TARGET_SIGNAL_USR1: return SIGUSR1;
1114 #endif
1115 #if defined (SIGUSR2)
1116     case TARGET_SIGNAL_USR2: return SIGUSR2;
1117 #endif
1118 #if defined (SIGCHLD) || defined (SIGCLD)
1119     case TARGET_SIGNAL_CHLD:
1120 #if defined (SIGCHLD)
1121       return SIGCHLD;
1122 #else
1123       return SIGCLD;
1124 #endif
1125 #endif /* SIGCLD or SIGCHLD */
1126 #if defined (SIGPWR)
1127     case TARGET_SIGNAL_PWR: return SIGPWR;
1128 #endif
1129 #if defined (SIGWINCH)
1130     case TARGET_SIGNAL_WINCH: return SIGWINCH;
1131 #endif
1132 #if defined (SIGURG)
1133     case TARGET_SIGNAL_URG: return SIGURG;
1134 #endif
1135 #if defined (SIGIO)
1136     case TARGET_SIGNAL_IO: return SIGIO;
1137 #endif
1138 #if defined (SIGPOLL)
1139     case TARGET_SIGNAL_POLL: return SIGPOLL;
1140 #endif
1141 #if defined (SIGSTOP)
1142     case TARGET_SIGNAL_STOP: return SIGSTOP;
1143 #endif
1144 #if defined (SIGTSTP)
1145     case TARGET_SIGNAL_TSTP: return SIGTSTP;
1146 #endif
1147 #if defined (SIGCONT)
1148     case TARGET_SIGNAL_CONT: return SIGCONT;
1149 #endif
1150 #if defined (SIGTTIN)
1151     case TARGET_SIGNAL_TTIN: return SIGTTIN;
1152 #endif
1153 #if defined (SIGTTOU)
1154     case TARGET_SIGNAL_TTOU: return SIGTTOU;
1155 #endif
1156 #if defined (SIGVTALRM)
1157     case TARGET_SIGNAL_VTALRM: return SIGVTALRM;
1158 #endif
1159 #if defined (SIGPROF)
1160     case TARGET_SIGNAL_PROF: return SIGPROF;
1161 #endif
1162 #if defined (SIGXCPU)
1163     case TARGET_SIGNAL_XCPU: return SIGXCPU;
1164 #endif
1165 #if defined (SIGXFSZ)
1166     case TARGET_SIGNAL_XFSZ: return SIGXFSZ;
1167 #endif
1168 #if defined (SIGWIND)
1169     case TARGET_SIGNAL_WIND: return SIGWIND;
1170 #endif
1171 #if defined (SIGPHONE)
1172     case TARGET_SIGNAL_PHONE: return SIGPHONE;
1173 #endif
1174 #if defined (SIGLOST)
1175     case TARGET_SIGNAL_LOST: return SIGLOST;
1176 #endif
1177 #if defined (SIGWAITING)
1178     case TARGET_SIGNAL_WAITING: return SIGWAITING;
1179 #endif
1180 #if defined (SIGLWP)
1181     case TARGET_SIGNAL_LWP: return SIGLWP;
1182 #endif
1183 #if defined (SIGDANGER)
1184     case TARGET_SIGNAL_DANGER: return SIGDANGER;
1185 #endif
1186 #if defined (SIGGRANT)
1187     case TARGET_SIGNAL_GRANT: return SIGGRANT;
1188 #endif
1189 #if defined (SIGRETRACT)
1190     case TARGET_SIGNAL_RETRACT: return SIGRETRACT;
1191 #endif
1192 #if defined (SIGMSG)
1193     case TARGET_SIGNAL_MSG: return SIGMSG;
1194 #endif
1195 #if defined (SIGSOUND)
1196     case TARGET_SIGNAL_SOUND: return SIGSOUND;
1197 #endif
1198 #if defined (SIGSAK)
1199     case TARGET_SIGNAL_SAK: return SIGSAK;
1200 #endif
1201     default:
1202       /* The user might be trying to do "signal SIGSAK" where this system
1203          doesn't have SIGSAK.  */
1204       warning ("Signal %s does not exist on this system.\n",
1205                target_signal_to_name (oursig));
1206       return 0;
1207     }
1208 }
1209
1210 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1211    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1212    translation of that in OURSTATUS.  */
1213 void
1214 store_waitstatus (ourstatus, hoststatus)
1215      struct target_waitstatus *ourstatus;
1216      int hoststatus;
1217 {
1218 #ifdef CHILD_SPECIAL_WAITSTATUS
1219   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1220      if it wants to deal with hoststatus.  */
1221   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1222     return;
1223 #endif
1224
1225   if (WIFEXITED (hoststatus))
1226     {
1227       ourstatus->kind = TARGET_WAITKIND_EXITED;
1228       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1229     }
1230   else if (!WIFSTOPPED (hoststatus))
1231     {
1232       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1233       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1234     }
1235   else
1236     {
1237       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1238       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1239     }
1240 }
1241
1242 \f
1243 /* Convert a normal process ID to a string.  Returns the string in a static
1244    buffer.  */
1245
1246 char *
1247 normal_pid_to_str (pid)
1248      int pid;
1249 {
1250   static char buf[30];
1251
1252   sprintf (buf, "process %d", pid);
1253
1254   return buf;
1255 }
1256 \f
1257 static char targ_desc[] =
1258     "Names of targets and files being debugged.\n\
1259 Shows the entire stack of targets currently in use (including the exec-file,\n\
1260 core-file, and process, if any), as well as the symbol file name.";
1261
1262 void
1263 _initialize_targets ()
1264 {
1265   current_target = &dummy_target;
1266   cleanup_target (current_target);
1267
1268   add_info ("target", target_info, targ_desc);
1269   add_info ("files", target_info, targ_desc);
1270
1271   if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
1272     abort ();
1273 }