gdb/lynx-nat.c

   1 /* Native-dependent code for LynxOS.
   2    Copyright 1993, 1994 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "target.h"
  25 #include "gdbcore.h"
  26
  27 #include <sys/ptrace.h>
  28 #include <sys/wait.h>
  29 #include <sys/fpp.h>
  30
  31 static unsigned long registers_addr PARAMS ((int pid));
  32 static void fetch_core_registers PARAMS ((char *, unsigned, int, CORE_ADDR));
  33
  34 #define X(ENTRY)(offsetof(struct econtext, ENTRY))
  35
  36 #ifdef I386
  37 /* Mappings from tm-i386v.h */
  38
  39 static int regmap[] =
  40 {
  41   X (eax),
  42   X (ecx),
  43   X (edx),
  44   X (ebx),
  45   X (esp),                      /* sp */
  46   X (ebp),                      /* fp */
  47   X (esi),
  48   X (edi),
  49   X (eip),                      /* pc */
  50   X (flags),                    /* ps */
  51   X (cs),
  52   X (ss),
  53   X (ds),
  54   X (es),
  55   X (ecode),                    /* Lynx doesn't give us either fs or gs, so */
  56   X (fault),                    /* we just substitute these two in the hopes
  57                                    that they are useful. */
  58 };
  59 #endif /* I386 */
  60
  61 #ifdef M68K
  62 /* Mappings from tm-m68k.h */
  63
  64 static int regmap[] =
  65 {
  66   X (regs[0]),                  /* d0 */
  67   X (regs[1]),                  /* d1 */
  68   X (regs[2]),                  /* d2 */
  69   X (regs[3]),                  /* d3 */
  70   X (regs[4]),                  /* d4 */
  71   X (regs[5]),                  /* d5 */
  72   X (regs[6]),                  /* d6 */
  73   X (regs[7]),                  /* d7 */
  74   X (regs[8]),                  /* a0 */
  75   X (regs[9]),                  /* a1 */
  76   X (regs[10]),                 /* a2 */
  77   X (regs[11]),                 /* a3 */
  78   X (regs[12]),                 /* a4 */
  79   X (regs[13]),                 /* a5 */
  80   X (regs[14]),                 /* fp */
  81   offsetof (st_t, usp) - offsetof (st_t, ec),   /* sp */
  82   X (status),                   /* ps */
  83   X (pc),
  84
  85   X (fregs[0 * 3]),             /* fp0 */
  86   X (fregs[1 * 3]),             /* fp1 */
  87   X (fregs[2 * 3]),             /* fp2 */
  88   X (fregs[3 * 3]),             /* fp3 */
  89   X (fregs[4 * 3]),             /* fp4 */
  90   X (fregs[5 * 3]),             /* fp5 */
  91   X (fregs[6 * 3]),             /* fp6 */
  92   X (fregs[7 * 3]),             /* fp7 */
  93
  94   X (fcregs[0]),                /* fpcontrol */
  95   X (fcregs[1]),                /* fpstatus */
  96   X (fcregs[2]),                /* fpiaddr */
  97   X (ssw),                      /* fpcode */
  98   X (fault),                    /* fpflags */
  99 };
 100 #endif /* M68K */
 101
 102 #ifdef SPARC
 103 /* Mappings from tm-sparc.h */
 104
 105 #define FX(ENTRY)(offsetof(struct fcontext, ENTRY))
 106
 107 static int regmap[] =
 108 {
 109   -1,                           /* g0 */
 110   X (g1),
 111   X (g2),
 112   X (g3),
 113   X (g4),
 114   -1,                           /* g5->g7 aren't saved by Lynx */
 115   -1,
 116   -1,
 117
 118   X (o[0]),
 119   X (o[1]),
 120   X (o[2]),
 121   X (o[3]),
 122   X (o[4]),
 123   X (o[5]),
 124   X (o[6]),                     /* sp */
 125   X (o[7]),                     /* ra */
 126
 127   -1, -1, -1, -1, -1, -1, -1, -1,       /* l0 -> l7 */
 128
 129   -1, -1, -1, -1, -1, -1, -1, -1,       /* i0 -> i7 */
 130
 131   FX (f.fregs[0]),              /* f0 */
 132   FX (f.fregs[1]),
 133   FX (f.fregs[2]),
 134   FX (f.fregs[3]),
 135   FX (f.fregs[4]),
 136   FX (f.fregs[5]),
 137   FX (f.fregs[6]),
 138   FX (f.fregs[7]),
 139   FX (f.fregs[8]),
 140   FX (f.fregs[9]),
 141   FX (f.fregs[10]),
 142   FX (f.fregs[11]),
 143   FX (f.fregs[12]),
 144   FX (f.fregs[13]),
 145   FX (f.fregs[14]),
 146   FX (f.fregs[15]),
 147   FX (f.fregs[16]),
 148   FX (f.fregs[17]),
 149   FX (f.fregs[18]),
 150   FX (f.fregs[19]),
 151   FX (f.fregs[20]),
 152   FX (f.fregs[21]),
 153   FX (f.fregs[22]),
 154   FX (f.fregs[23]),
 155   FX (f.fregs[24]),
 156   FX (f.fregs[25]),
 157   FX (f.fregs[26]),
 158   FX (f.fregs[27]),
 159   FX (f.fregs[28]),
 160   FX (f.fregs[29]),
 161   FX (f.fregs[30]),
 162   FX (f.fregs[31]),
 163
 164   X (y),
 165   X (psr),
 166   X (wim),
 167   X (tbr),
 168   X (pc),
 169   X (npc),
 170   FX (fsr),                     /* fpsr */
 171   -1,                           /* cpsr */
 172 };
 173 #endif /* SPARC */
 174
 175 #ifdef rs6000
 176
 177 static int regmap[] =
 178 {
 179   X (iregs[0]),                 /* r0 */
 180   X (iregs[1]),
 181   X (iregs[2]),
 182   X (iregs[3]),
 183   X (iregs[4]),
 184   X (iregs[5]),
 185   X (iregs[6]),
 186   X (iregs[7]),
 187   X (iregs[8]),
 188   X (iregs[9]),
 189   X (iregs[10]),
 190   X (iregs[11]),
 191   X (iregs[12]),
 192   X (iregs[13]),
 193   X (iregs[14]),
 194   X (iregs[15]),
 195   X (iregs[16]),
 196   X (iregs[17]),
 197   X (iregs[18]),
 198   X (iregs[19]),
 199   X (iregs[20]),
 200   X (iregs[21]),
 201   X (iregs[22]),
 202   X (iregs[23]),
 203   X (iregs[24]),
 204   X (iregs[25]),
 205   X (iregs[26]),
 206   X (iregs[27]),
 207   X (iregs[28]),
 208   X (iregs[29]),
 209   X (iregs[30]),
 210   X (iregs[31]),
 211
 212   X (fregs[0]),                 /* f0 */
 213   X (fregs[1]),
 214   X (fregs[2]),
 215   X (fregs[3]),
 216   X (fregs[4]),
 217   X (fregs[5]),
 218   X (fregs[6]),
 219   X (fregs[7]),
 220   X (fregs[8]),
 221   X (fregs[9]),
 222   X (fregs[10]),
 223   X (fregs[11]),
 224   X (fregs[12]),
 225   X (fregs[13]),
 226   X (fregs[14]),
 227   X (fregs[15]),
 228   X (fregs[16]),
 229   X (fregs[17]),
 230   X (fregs[18]),
 231   X (fregs[19]),
 232   X (fregs[20]),
 233   X (fregs[21]),
 234   X (fregs[22]),
 235   X (fregs[23]),
 236   X (fregs[24]),
 237   X (fregs[25]),
 238   X (fregs[26]),
 239   X (fregs[27]),
 240   X (fregs[28]),
 241   X (fregs[29]),
 242   X (fregs[30]),
 243   X (fregs[31]),
 244
 245   X (srr0),                     /* IAR (PC) */
 246   X (srr1),                     /* MSR (PS) */
 247   X (cr),                       /* CR */
 248   X (lr),                       /* LR */
 249   X (ctr),                      /* CTR */
 250   X (xer),                      /* XER */
 251   X (mq)                        /* MQ */
 252 };
 253
 254 #endif /* rs6000 */
 255
 256 #ifdef SPARC
 257
 258 /* This routine handles some oddball cases for Sparc registers and LynxOS.
 259    In partucular, it causes refs to G0, g5->7, and all fp regs to return zero.
 260    It also handles knows where to find the I & L regs on the stack.  */
 261
 262 void
 263 fetch_inferior_registers (regno)
 264      int regno;
 265 {
 266   int whatregs = 0;
 267
 268 #define WHATREGS_FLOAT 1
 269 #define WHATREGS_GEN 2
 270 #define WHATREGS_STACK 4
 271
 272   if (regno == -1)
 273     whatregs = WHATREGS_FLOAT | WHATREGS_GEN | WHATREGS_STACK;
 274   else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
 275     whatregs = WHATREGS_STACK;
 276   else if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
 277     whatregs = WHATREGS_FLOAT;
 278   else
 279     whatregs = WHATREGS_GEN;
 280
 281   if (whatregs & WHATREGS_GEN)
 282     {
 283       struct econtext ec;       /* general regs */
 284       char buf[MAX_REGISTER_RAW_SIZE];
 285       int retval;
 286       int i;
 287
 288       errno = 0;
 289       retval = ptrace (PTRACE_GETREGS, inferior_pid, (PTRACE_ARG3_TYPE) & ec,
 290                        0);
 291       if (errno)
 292         perror_with_name ("ptrace(PTRACE_GETREGS)");
 293
 294       memset (buf, 0, REGISTER_RAW_SIZE (G0_REGNUM));
 295       supply_register (G0_REGNUM, buf);
 296       supply_register (TBR_REGNUM, (char *) &ec.tbr);
 297
 298       memcpy (&registers[REGISTER_BYTE (G1_REGNUM)], &ec.g1,
 299               4 * REGISTER_RAW_SIZE (G1_REGNUM));
 300       for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++)
 301         register_valid[i] = 1;
 302
 303       supply_register (PS_REGNUM, (char *) &ec.psr);
 304       supply_register (Y_REGNUM, (char *) &ec.y);
 305       supply_register (PC_REGNUM, (char *) &ec.pc);
 306       supply_register (NPC_REGNUM, (char *) &ec.npc);
 307       supply_register (WIM_REGNUM, (char *) &ec.wim);
 308
 309       memcpy (&registers[REGISTER_BYTE (O0_REGNUM)], ec.o,
 310               8 * REGISTER_RAW_SIZE (O0_REGNUM));
 311       for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++)
 312         register_valid[i] = 1;
 313     }
 314
 315   if (whatregs & WHATREGS_STACK)
 316     {
 317       CORE_ADDR sp;
 318       int i;
 319
 320       sp = read_register (SP_REGNUM);
 321
 322       target_xfer_memory (sp + FRAME_SAVED_I0,
 323                           &registers[REGISTER_BYTE (I0_REGNUM)],
 324                           8 * REGISTER_RAW_SIZE (I0_REGNUM), 0);
 325       for (i = I0_REGNUM; i <= I7_REGNUM; i++)
 326         register_valid[i] = 1;
 327
 328       target_xfer_memory (sp + FRAME_SAVED_L0,
 329                           &registers[REGISTER_BYTE (L0_REGNUM)],
 330                           8 * REGISTER_RAW_SIZE (L0_REGNUM), 0);
 331       for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++)
 332         register_valid[i] = 1;
 333     }
 334
 335   if (whatregs & WHATREGS_FLOAT)
 336     {
 337       struct fcontext fc;       /* fp regs */
 338       int retval;
 339       int i;
 340
 341       errno = 0;
 342       retval = ptrace (PTRACE_GETFPREGS, inferior_pid, (PTRACE_ARG3_TYPE) & fc,
 343                        0);
 344       if (errno)
 345         perror_with_name ("ptrace(PTRACE_GETFPREGS)");
 346
 347       memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs,
 348               32 * REGISTER_RAW_SIZE (FP0_REGNUM));
 349       for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++)
 350         register_valid[i] = 1;
 351
 352       supply_register (FPS_REGNUM, (char *) &fc.fsr);
 353     }
 354 }
 355
 356 /* This routine handles storing of the I & L regs for the Sparc.  The trick
 357    here is that they actually live on the stack.  The really tricky part is
 358    that when changing the stack pointer, the I & L regs must be written to
 359    where the new SP points, otherwise the regs will be incorrect when the
 360    process is started up again.   We assume that the I & L regs are valid at
 361    this point.  */
 362
 363 void
 364 store_inferior_registers (regno)
 365      int regno;
 366 {
 367   int whatregs = 0;
 368
 369   if (regno == -1)
 370     whatregs = WHATREGS_FLOAT | WHATREGS_GEN | WHATREGS_STACK;
 371   else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
 372     whatregs = WHATREGS_STACK;
 373   else if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
 374     whatregs = WHATREGS_FLOAT;
 375   else if (regno == SP_REGNUM)
 376     whatregs = WHATREGS_STACK | WHATREGS_GEN;
 377   else
 378     whatregs = WHATREGS_GEN;
 379
 380   if (whatregs & WHATREGS_GEN)
 381     {
 382       struct econtext ec;       /* general regs */
 383       int retval;
 384
 385       ec.tbr = read_register (TBR_REGNUM);
 386       memcpy (&ec.g1, &registers[REGISTER_BYTE (G1_REGNUM)],
 387               4 * REGISTER_RAW_SIZE (G1_REGNUM));
 388
 389       ec.psr = read_register (PS_REGNUM);
 390       ec.y = read_register (Y_REGNUM);
 391       ec.pc = read_register (PC_REGNUM);
 392       ec.npc = read_register (NPC_REGNUM);
 393       ec.wim = read_register (WIM_REGNUM);
 394
 395       memcpy (ec.o, &registers[REGISTER_BYTE (O0_REGNUM)],
 396               8 * REGISTER_RAW_SIZE (O0_REGNUM));
 397
 398       errno = 0;
 399       retval = ptrace (PTRACE_SETREGS, inferior_pid, (PTRACE_ARG3_TYPE) & ec,
 400                        0);
 401       if (errno)
 402         perror_with_name ("ptrace(PTRACE_SETREGS)");
 403     }
 404
 405   if (whatregs & WHATREGS_STACK)
 406     {
 407       int regoffset;
 408       CORE_ADDR sp;
 409
 410       sp = read_register (SP_REGNUM);
 411
 412       if (regno == -1 || regno == SP_REGNUM)
 413         {
 414           if (!register_valid[L0_REGNUM + 5])
 415             abort ();
 416           target_xfer_memory (sp + FRAME_SAVED_I0,
 417                               &registers[REGISTER_BYTE (I0_REGNUM)],
 418                               8 * REGISTER_RAW_SIZE (I0_REGNUM), 1);
 419
 420           target_xfer_memory (sp + FRAME_SAVED_L0,
 421                               &registers[REGISTER_BYTE (L0_REGNUM)],
 422                               8 * REGISTER_RAW_SIZE (L0_REGNUM), 1);
 423         }
 424       else if (regno >= L0_REGNUM && regno <= I7_REGNUM)
 425         {
 426           if (!register_valid[regno])
 427             abort ();
 428           if (regno >= L0_REGNUM && regno <= L0_REGNUM + 7)
 429             regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM)
 430               + FRAME_SAVED_L0;
 431           else
 432             regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM)
 433               + FRAME_SAVED_I0;
 434           target_xfer_memory (sp + regoffset, &registers[REGISTER_BYTE (regno)],
 435                               REGISTER_RAW_SIZE (regno), 1);
 436         }
 437     }
 438
 439   if (whatregs & WHATREGS_FLOAT)
 440     {
 441       struct fcontext fc;       /* fp regs */
 442       int retval;
 443
 444 /* We read fcontext first so that we can get good values for fq_t... */
 445       errno = 0;
 446       retval = ptrace (PTRACE_GETFPREGS, inferior_pid, (PTRACE_ARG3_TYPE) & fc,
 447                        0);
 448       if (errno)
 449         perror_with_name ("ptrace(PTRACE_GETFPREGS)");
 450
 451       memcpy (fc.f.fregs, &registers[REGISTER_BYTE (FP0_REGNUM)],
 452               32 * REGISTER_RAW_SIZE (FP0_REGNUM));
 453
 454       fc.fsr = read_register (FPS_REGNUM);
 455
 456       errno = 0;
 457       retval = ptrace (PTRACE_SETFPREGS, inferior_pid, (PTRACE_ARG3_TYPE) & fc,
 458                        0);
 459       if (errno)
 460         perror_with_name ("ptrace(PTRACE_SETFPREGS)");
 461     }
 462 }
 463 #endif /* SPARC */
 464
 465 #if defined (I386) || defined (M68K) || defined (rs6000)
 466
 467 /* Return the offset relative to the start of the per-thread data to the
 468    saved context block.  */
 469
 470 static unsigned long
 471 registers_addr (pid)
 472      int pid;
 473 {
 474   CORE_ADDR stblock;
 475   int ecpoff = offsetof (st_t, ecp);
 476   CORE_ADDR ecp;
 477
 478   errno = 0;
 479   stblock = (CORE_ADDR) ptrace (PTRACE_THREADUSER, pid, (PTRACE_ARG3_TYPE) 0,
 480                                 0);
 481   if (errno)
 482     perror_with_name ("ptrace(PTRACE_THREADUSER)");
 483
 484   ecp = (CORE_ADDR) ptrace (PTRACE_PEEKTHREAD, pid, (PTRACE_ARG3_TYPE) ecpoff,
 485                             0);
 486   if (errno)
 487     perror_with_name ("ptrace(PTRACE_PEEKTHREAD)");
 488
 489   return ecp - stblock;
 490 }
 491
 492 /* Fetch one or more registers from the inferior.  REGNO == -1 to get
 493    them all.  We actually fetch more than requested, when convenient,
 494    marking them as valid so we won't fetch them again.  */
 495
 496 void
 497 fetch_inferior_registers (regno)
 498      int regno;
 499 {
 500   int reglo, reghi;
 501   int i;
 502   unsigned long ecp;
 503
 504   if (regno == -1)
 505     {
 506       reglo = 0;
 507       reghi = NUM_REGS - 1;
 508     }
 509   else
 510     reglo = reghi = regno;
 511
 512   ecp = registers_addr (inferior_pid);
 513
 514   for (regno = reglo; regno <= reghi; regno++)
 515     {
 516       char buf[MAX_REGISTER_RAW_SIZE];
 517       int ptrace_fun = PTRACE_PEEKTHREAD;
 518
 519 #ifdef M68K
 520       ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD;
 521 #endif
 522
 523       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 524         {
 525           unsigned int reg;
 526
 527           errno = 0;
 528           reg = ptrace (ptrace_fun, inferior_pid,
 529                         (PTRACE_ARG3_TYPE) (ecp + regmap[regno] + i), 0);
 530           if (errno)
 531             perror_with_name ("ptrace(PTRACE_PEEKUSP)");
 532
 533           *(int *) &buf[i] = reg;
 534         }
 535       supply_register (regno, buf);
 536     }
 537 }
 538
 539 /* Store our register values back into the inferior.
 540    If REGNO is -1, do this for all registers.
 541    Otherwise, REGNO specifies which register (so we can save time).  */
 542
 543 /* Registers we shouldn't try to store.  */
 544 #if !defined (CANNOT_STORE_REGISTER)
 545 #define CANNOT_STORE_REGISTER(regno) 0
 546 #endif
 547
 548 void
 549 store_inferior_registers (regno)
 550      int regno;
 551 {
 552   int reglo, reghi;
 553   int i;
 554   unsigned long ecp;
 555
 556   if (regno == -1)
 557     {
 558       reglo = 0;
 559       reghi = NUM_REGS - 1;
 560     }
 561   else
 562     reglo = reghi = regno;
 563
 564   ecp = registers_addr (inferior_pid);
 565
 566   for (regno = reglo; regno <= reghi; regno++)
 567     {
 568       int ptrace_fun = PTRACE_POKEUSER;
 569
 570       if (CANNOT_STORE_REGISTER (regno))
 571         continue;
 572
 573 #ifdef M68K
 574       ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER;
 575 #endif
 576
 577       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
 578         {
 579           unsigned int reg;
 580
 581           reg = *(unsigned int *) &registers[REGISTER_BYTE (regno) + i];
 582
 583           errno = 0;
 584           ptrace (ptrace_fun, inferior_pid,
 585                   (PTRACE_ARG3_TYPE) (ecp + regmap[regno] + i), reg);
 586           if (errno)
 587             perror_with_name ("ptrace(PTRACE_POKEUSP)");
 588         }
 589     }
 590 }
 591 #endif /* defined (I386) || defined (M68K) || defined (rs6000) */
 592
 593 /* Wait for child to do something.  Return pid of child, or -1 in case
 594    of error; store status through argument pointer OURSTATUS.  */
 595
 596 int
 597 child_wait (pid, ourstatus)
 598      int pid;
 599      struct target_waitstatus *ourstatus;
 600 {
 601   int save_errno;
 602   int thread;
 603   union wait status;
 604
 605   while (1)
 606     {
 607       int sig;
 608
 609       set_sigint_trap ();       /* Causes SIGINT to be passed on to the
 610                                    attached process. */
 611       pid = wait (&status);
 612
 613       save_errno = errno;
 614
 615       clear_sigint_trap ();
 616
 617       if (pid == -1)
 618         {
 619           if (save_errno == EINTR)
 620             continue;
 621           fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing: %s.\n",
 622                               safe_strerror (save_errno));
 623           /* Claim it exited with unknown signal.  */
 624           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 625           ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
 626           return -1;
 627         }
 628
 629       if (pid != PIDGET (inferior_pid))         /* Some other process?!? */
 630         continue;
 631
 632       thread = status.w_tid;    /* Get thread id from status */
 633
 634       /* Initial thread value can only be acquired via wait, so we have to
 635          resort to this hack.  */
 636
 637       if (TIDGET (inferior_pid) == 0 && thread != 0)
 638         {
 639           inferior_pid = BUILDPID (inferior_pid, thread);
 640           add_thread (inferior_pid);
 641         }
 642
 643       pid = BUILDPID (pid, thread);
 644
 645       /* We've become a single threaded process again.  */
 646       if (thread == 0)
 647         inferior_pid = pid;
 648
 649       /* Check for thread creation.  */
 650       if (WIFSTOPPED (status)
 651           && WSTOPSIG (status) == SIGTRAP
 652           && !in_thread_list (pid))
 653         {
 654           int realsig;
 655
 656           realsig = ptrace (PTRACE_GETTRACESIG, pid, (PTRACE_ARG3_TYPE) 0, 0);
 657
 658           if (realsig == SIGNEWTHREAD)
 659             {
 660               /* It's a new thread notification.  We don't want to much with
 661                  realsig -- the code in wait_for_inferior expects SIGTRAP. */
 662               ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 663               ourstatus->value.sig = TARGET_SIGNAL_0;
 664               return pid;
 665             }
 666           else
 667             error ("Signal for unknown thread was not SIGNEWTHREAD");
 668         }
 669
 670       /* Check for thread termination.  */
 671       else if (WIFSTOPPED (status)
 672                && WSTOPSIG (status) == SIGTRAP
 673                && in_thread_list (pid))
 674         {
 675           int realsig;
 676
 677           realsig = ptrace (PTRACE_GETTRACESIG, pid, (PTRACE_ARG3_TYPE) 0, 0);
 678
 679           if (realsig == SIGTHREADEXIT)
 680             {
 681               ptrace (PTRACE_CONT, PIDGET (pid), (PTRACE_ARG3_TYPE) 0, 0);
 682               continue;
 683             }
 684         }
 685
 686 #ifdef SPARC
 687       /* SPARC Lynx uses an byte reversed wait status; we must use the
 688          host macros to access it.  These lines just a copy of
 689          store_waitstatus.  We can't use CHILD_SPECIAL_WAITSTATUS
 690          because target.c can't include the Lynx <sys/wait.h>.  */
 691       if (WIFEXITED (status))
 692         {
 693           ourstatus->kind = TARGET_WAITKIND_EXITED;
 694           ourstatus->value.integer = WEXITSTATUS (status);
 695         }
 696       else if (!WIFSTOPPED (status))
 697         {
 698           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 699           ourstatus->value.sig =
 700             target_signal_from_host (WTERMSIG (status));
 701         }
 702       else
 703         {
 704           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 705           ourstatus->value.sig =
 706             target_signal_from_host (WSTOPSIG (status));
 707         }
 708 #else
 709       store_waitstatus (ourstatus, status.w_status);
 710 #endif
 711
 712       return pid;
 713     }
 714 }
 715
 716 /* Return nonzero if the given thread is still alive.  */
 717 int
 718 child_thread_alive (pid)
 719      int pid;
 720 {
 721   /* Arggh.  Apparently pthread_kill only works for threads within
 722      the process that calls pthread_kill.
 723
 724      We want to avoid the lynx signal extensions as they simply don't
 725      map well to the generic gdb interface we want to keep.
 726
 727      All we want to do is determine if a particular thread is alive;
 728      it appears as if we can just make a harmless thread specific
 729      ptrace call to do that.  */
 730   return (ptrace (PTRACE_THREADUSER, pid, 0, 0) != -1);
 731 }
 732
 733 /* Resume execution of the inferior process.
 734    If STEP is nonzero, single-step it.
 735    If SIGNAL is nonzero, give it that signal.  */
 736
 737 void
 738 child_resume (pid, step, signal)
 739      int pid;
 740      int step;
 741      enum target_signal signal;
 742 {
 743   int func;
 744
 745   errno = 0;
 746
 747   /* If pid == -1, then we want to step/continue all threads, else
 748      we only want to step/continue a single thread.  */
 749   if (pid == -1)
 750     {
 751       pid = inferior_pid;
 752       func = step ? PTRACE_SINGLESTEP : PTRACE_CONT;
 753     }
 754   else
 755     func = step ? PTRACE_SINGLESTEP_ONE : PTRACE_CONT_ONE;
 756
 757
 758   /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
 759      it was.  (If GDB wanted it to start some other way, we have already
 760      written a new PC value to the child.)
 761
 762      If this system does not support PT_STEP, a higher level function will
 763      have called single_step() to transmute the step request into a
 764      continue request (by setting breakpoints on all possible successor
 765      instructions), so we don't have to worry about that here.  */
 766
 767   ptrace (func, pid, (PTRACE_ARG3_TYPE) 1, target_signal_to_host (signal));
 768
 769   if (errno)
 770     perror_with_name ("ptrace");
 771 }
 772
 773 /* Convert a Lynx process ID to a string.  Returns the string in a static
 774    buffer.  */
 775
 776 char *
 777 child_pid_to_str (pid)
 778      int pid;
 779 {
 780   static char buf[40];
 781
 782   sprintf (buf, "process %d thread %d", PIDGET (pid), TIDGET (pid));
 783
 784   return buf;
 785 }
 786
 787 /* Extract the register values out of the core file and store
 788    them where `read_register' will find them.
 789
 790    CORE_REG_SECT points to the register values themselves, read into memory.
 791    CORE_REG_SIZE is the size of that area.
 792    WHICH says which set of registers we are handling (0 = int, 2 = float
 793    on machines where they are discontiguous).
 794    REG_ADDR is the offset from u.u_ar0 to the register values relative to
 795    core_reg_sect.  This is used with old-fashioned core files to
 796    locate the registers in a large upage-plus-stack ".reg" section.
 797    Original upage address X is at location core_reg_sect+x+reg_addr.
 798  */
 799
 800 static void
 801 fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
 802      char *core_reg_sect;
 803      unsigned core_reg_size;
 804      int which;
 805      CORE_ADDR reg_addr;
 806 {
 807   struct st_entry s;
 808   unsigned int regno;
 809
 810   for (regno = 0; regno < NUM_REGS; regno++)
 811     if (regmap[regno] != -1)
 812       supply_register (regno, core_reg_sect + offsetof (st_t, ec)
 813                        + regmap[regno]);
 814
 815 #ifdef SPARC
 816 /* Fetching this register causes all of the I & L regs to be read from the
 817    stack and validated.  */
 818
 819   fetch_inferior_registers (I0_REGNUM);
 820 #endif
 821 }
 822 \f
 823
 824 /* Register that we are able to handle lynx core file formats.
 825    FIXME: is this really bfd_target_unknown_flavour? */
 826
 827 static struct core_fns lynx_core_fns =
 828 {
 829   bfd_target_unknown_flavour,           /* core_flavour */
 830   default_check_format,                 /* check_format */
 831   default_core_sniffer,                 /* core_sniffer */
 832   fetch_core_registers,                 /* core_read_registers */
 833   NULL                                  /* next */
 834 };
 835
 836 void
 837 _initialize_core_lynx ()
 838 {
 839   add_core_fns (&lynx_core_fns);
 840 }