gdb/i386-linux-nat.c

   1 /* Native-dependent code for Linux/x86.
   2    Copyright 1999, 2000, 2001 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 "inferior.h"
  23 #include "gdbcore.h"
  24
  25 #include <sys/ptrace.h>
  26 #include <sys/user.h>
  27 #include <sys/procfs.h>
  28
  29 #ifdef HAVE_SYS_REG_H
  30 #include <sys/reg.h>
  31 #endif
  32
  33 /* Prototypes for supply_gregset etc.  */
  34 #include "gregset.h"
  35
  36 /* Prototypes for i387_supply_fsave etc.  */
  37 #include "i387-nat.h"
  38
  39 /* Prototypes for local functions.  */
  40 static void dummy_sse_values (void);
  41
  42 /* On Linux, threads are implemented as pseudo-processes, in which
  43    case we may be tracing more than one process at a time.  In that
  44    case, inferior_pid will contain the main process ID and the
  45    individual thread (process) ID mashed together.  These macros are
  46    used to separate them out.  These definitions should be overridden
  47    if thread support is included.  */
  48
  49 #if !defined (PIDGET)   /* Default definition for PIDGET/TIDGET.  */
  50 #define PIDGET(PID)     PID
  51 #define TIDGET(PID)     0
  52 #endif
  53 \f
  54
  55 /* The register sets used in Linux ELF core-dumps are identical to the
  56    register sets in `struct user' that is used for a.out core-dumps,
  57    and is also used by `ptrace'.  The corresponding types are
  58    `elf_gregset_t' for the general-purpose registers (with
  59    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
  60    for the floating-point registers.
  61
  62    Those types used to be available under the names `gregset_t' and
  63    `fpregset_t' too, and this file used those names in the past.  But
  64    those names are now used for the register sets used in the
  65    `mcontext_t' type, and have a different size and layout.  */
  66
  67 /* Mapping between the general-purpose registers in `struct user'
  68    format and GDB's register array layout.  */
  69 static int regmap[] =
  70 {
  71   EAX, ECX, EDX, EBX,
  72   UESP, EBP, ESI, EDI,
  73   EIP, EFL, CS, SS,
  74   DS, ES, FS, GS
  75 };
  76
  77 /* Which ptrace request retrieves which registers?
  78    These apply to the corresponding SET requests as well.  */
  79 #define GETREGS_SUPPLIES(regno) \
  80   (0 <= (regno) && (regno) <= 15)
  81 #define GETFPREGS_SUPPLIES(regno) \
  82   (FP0_REGNUM <= (regno) && (regno) <= LAST_FPU_CTRL_REGNUM)
  83 #define GETFPXREGS_SUPPLIES(regno) \
  84   (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
  85
  86 /* Does the current host support the GETREGS request?  */
  87 int have_ptrace_getregs =
  88 #ifdef HAVE_PTRACE_GETREGS
  89   1
  90 #else
  91   0
  92 #endif
  93 ;
  94
  95 /* Does the current host support the GETFPXREGS request?  The header
  96    file may or may not define it, and even if it is defined, the
  97    kernel will return EIO if it's running on a pre-SSE processor.
  98
  99    My instinct is to attach this to some architecture- or
 100    target-specific data structure, but really, a particular GDB
 101    process can only run on top of one kernel at a time.  So it's okay
 102    for this to be a simple variable.  */
 103 int have_ptrace_getfpxregs =
 104 #ifdef HAVE_PTRACE_GETFPXREGS
 105   1
 106 #else
 107   0
 108 #endif
 109 ;
 110 \f
 111
 112 /* Fetching registers directly from the U area, one at a time.  */
 113
 114 /* FIXME: kettenis/2000-03-05: This duplicates code from `inptrace.c'.
 115    The problem is that we define FETCH_INFERIOR_REGISTERS since we
 116    want to use our own versions of {fetch,store}_inferior_registers
 117    that use the GETREGS request.  This means that the code in
 118    `infptrace.c' is #ifdef'd out.  But we need to fall back on that
 119    code when GDB is running on top of a kernel that doesn't support
 120    the GETREGS request.  I want to avoid changing `infptrace.c' right
 121    now.  */
 122
 123 #ifndef PT_READ_U
 124 #define PT_READ_U PTRACE_PEEKUSR
 125 #endif
 126 #ifndef PT_WRITE_U
 127 #define PT_WRITE_U PTRACE_POKEUSR
 128 #endif
 129
 130 /* Default the type of the ptrace transfer to int.  */
 131 #ifndef PTRACE_XFER_TYPE
 132 #define PTRACE_XFER_TYPE int
 133 #endif
 134
 135 /* Registers we shouldn't try to fetch.  */
 136 #define OLD_CANNOT_FETCH_REGISTER(regno) ((regno) >= NUM_GREGS)
 137
 138 /* Fetch one register.  */
 139
 140 static void
 141 fetch_register (int regno)
 142 {
 143   /* This isn't really an address.  But ptrace thinks of it as one.  */
 144   CORE_ADDR regaddr;
 145   char mess[128];               /* For messages */
 146   register int i;
 147   unsigned int offset;          /* Offset of registers within the u area.  */
 148   char buf[MAX_REGISTER_RAW_SIZE];
 149   int tid;
 150
 151   if (OLD_CANNOT_FETCH_REGISTER (regno))
 152     {
 153       memset (buf, '\0', REGISTER_RAW_SIZE (regno));    /* Supply zeroes */
 154       supply_register (regno, buf);
 155       return;
 156     }
 157
 158   /* Overload thread id onto process id */
 159   if ((tid = TIDGET (inferior_pid)) == 0)
 160     tid = inferior_pid;         /* no thread id, just use process id */
 161
 162   offset = U_REGS_OFFSET;
 163
 164   regaddr = register_addr (regno, offset);
 165   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
 166     {
 167       errno = 0;
 168       *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
 169                                                (PTRACE_ARG3_TYPE) regaddr, 0);
 170       regaddr += sizeof (PTRACE_XFER_TYPE);
 171       if (errno != 0)
 172         {
 173           sprintf (mess, "reading register %s (#%d)",
 174                    REGISTER_NAME (regno), regno);
 175           perror_with_name (mess);
 176         }
 177     }
 178   supply_register (regno, buf);
 179 }
 180
 181 /* Fetch register values from the inferior.
 182    If REGNO is negative, do this for all registers.
 183    Otherwise, REGNO specifies which register (so we can save time). */
 184
 185 void
 186 old_fetch_inferior_registers (int regno)
 187 {
 188   if (regno >= 0)
 189     {
 190       fetch_register (regno);
 191     }
 192   else
 193     {
 194       for (regno = 0; regno < ARCH_NUM_REGS; regno++)
 195         {
 196           fetch_register (regno);
 197         }
 198     }
 199 }
 200
 201 /* Registers we shouldn't try to store.  */
 202 #define OLD_CANNOT_STORE_REGISTER(regno) ((regno) >= NUM_GREGS)
 203
 204 /* Store one register. */
 205
 206 static void
 207 store_register (int regno)
 208 {
 209   /* This isn't really an address.  But ptrace thinks of it as one.  */
 210   CORE_ADDR regaddr;
 211   char mess[128];               /* For messages */
 212   register int i;
 213   unsigned int offset;          /* Offset of registers within the u area.  */
 214   int tid;
 215
 216   if (OLD_CANNOT_STORE_REGISTER (regno))
 217     {
 218       return;
 219     }
 220
 221   /* Overload thread id onto process id */
 222   if ((tid = TIDGET (inferior_pid)) == 0)
 223     tid = inferior_pid;         /* no thread id, just use process id */
 224
 225   offset = U_REGS_OFFSET;
 226
 227   regaddr = register_addr (regno, offset);
 228   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
 229     {
 230       errno = 0;
 231       ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
 232               *(PTRACE_XFER_TYPE *) & registers[REGISTER_BYTE (regno) + i]);
 233       regaddr += sizeof (PTRACE_XFER_TYPE);
 234       if (errno != 0)
 235         {
 236           sprintf (mess, "writing register %s (#%d)",
 237                    REGISTER_NAME (regno), regno);
 238           perror_with_name (mess);
 239         }
 240     }
 241 }
 242
 243 /* Store our register values back into the inferior.
 244    If REGNO is negative, do this for all registers.
 245    Otherwise, REGNO specifies which register (so we can save time).  */
 246
 247 void
 248 old_store_inferior_registers (int regno)
 249 {
 250   if (regno >= 0)
 251     {
 252       store_register (regno);
 253     }
 254   else
 255     {
 256       for (regno = 0; regno < ARCH_NUM_REGS; regno++)
 257         {
 258           store_register (regno);
 259         }
 260     }
 261 }
 262 \f
 263
 264 /* Transfering the general-purpose registers between GDB, inferiors
 265    and core files.  */
 266
 267 /* Fill GDB's register array with the general-purpose register values
 268    in *GREGSETP.  */
 269
 270 void
 271 supply_gregset (elf_gregset_t *gregsetp)
 272 {
 273   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 274   int i;
 275
 276   for (i = 0; i < NUM_GREGS; i++)
 277     supply_register (i, (char *) (regp + regmap[i]));
 278 }
 279
 280 /* Fill register REGNO (if it is a general-purpose register) in
 281    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 282    do this for all registers.  */
 283
 284 void
 285 fill_gregset (elf_gregset_t *gregsetp, int regno)
 286 {
 287   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 288   int i;
 289
 290   for (i = 0; i < NUM_GREGS; i++)
 291     if ((regno == -1 || regno == i))
 292       *(regp + regmap[i]) = *(elf_greg_t *) &registers[REGISTER_BYTE (i)];
 293 }
 294
 295 #ifdef HAVE_PTRACE_GETREGS
 296
 297 /* Fetch all general-purpose registers from process/thread TID and
 298    store their values in GDB's register array.  */
 299
 300 static void
 301 fetch_regs (int tid)
 302 {
 303   elf_gregset_t regs;
 304
 305   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 306     {
 307       if (errno == EIO)
 308         {
 309           /* The kernel we're running on doesn't support the GETREGS
 310              request.  Reset `have_ptrace_getregs'.  */
 311           have_ptrace_getregs = 0;
 312           return;
 313         }
 314
 315       perror_with_name ("Couldn't get registers");
 316     }
 317
 318   supply_gregset (&regs);
 319 }
 320
 321 /* Store all valid general-purpose registers in GDB's register array
 322    into the process/thread specified by TID.  */
 323
 324 static void
 325 store_regs (int tid, int regno)
 326 {
 327   elf_gregset_t regs;
 328
 329   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 330     perror_with_name ("Couldn't get registers");
 331
 332   fill_gregset (&regs, regno);
 333
 334   if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
 335     perror_with_name ("Couldn't write registers");
 336 }
 337
 338 #else
 339
 340 static void fetch_regs (int tid) {}
 341 static void store_regs (int tid, int regno) {}
 342
 343 #endif
 344 \f
 345
 346 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 347
 348 /* Fill GDB's register array with the floating-point register values in
 349    *FPREGSETP.  */
 350
 351 void
 352 supply_fpregset (elf_fpregset_t *fpregsetp)
 353 {
 354   i387_supply_fsave ((char *) fpregsetp);
 355   dummy_sse_values ();
 356 }
 357
 358 /* Fill register REGNO (if it is a floating-point register) in
 359    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 360    do this for all registers.  */
 361
 362 void
 363 fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
 364 {
 365   i387_fill_fsave ((char *) fpregsetp, regno);
 366 }
 367
 368 #ifdef HAVE_PTRACE_GETREGS
 369
 370 /* Fetch all floating-point registers from process/thread TID and store
 371    thier values in GDB's register array.  */
 372
 373 static void
 374 fetch_fpregs (int tid)
 375 {
 376   elf_fpregset_t fpregs;
 377
 378   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 379     perror_with_name ("Couldn't get floating point status");
 380
 381   supply_fpregset (&fpregs);
 382 }
 383
 384 /* Store all valid floating-point registers in GDB's register array
 385    into the process/thread specified by TID.  */
 386
 387 static void
 388 store_fpregs (int tid, int regno)
 389 {
 390   elf_fpregset_t fpregs;
 391
 392   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 393     perror_with_name ("Couldn't get floating point status");
 394
 395   fill_fpregset (&fpregs, regno);
 396
 397   if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
 398     perror_with_name ("Couldn't write floating point status");
 399 }
 400
 401 #else
 402
 403 static void fetch_fpregs (int tid) {}
 404 static void store_fpregs (int tid, int regno) {}
 405
 406 #endif
 407 \f
 408
 409 /* Transfering floating-point and SSE registers to and from GDB.  */
 410
 411 #ifdef HAVE_PTRACE_GETFPXREGS
 412
 413 /* Fill GDB's register array with the floating-point and SSE register
 414    values in *FPXREGSETP.  */
 415
 416 static void
 417 supply_fpxregset (elf_fpxregset_t *fpxregsetp)
 418 {
 419   i387_supply_fxsave ((char *) fpxregsetp);
 420 }
 421
 422 /* Fill register REGNO (if it is a floating-point or SSE register) in
 423    *FPXREGSETP with the value in GDB's register array.  If REGNO is
 424    -1, do this for all registers.  */
 425
 426 static void
 427 fill_fpxregset (elf_fpxregset_t *fpxregsetp, int regno)
 428 {
 429   i387_fill_fxsave ((char *) fpxregsetp, regno);
 430 }
 431
 432 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
 433    process/thread TID and store their values in GDB's register array.
 434    Return non-zero if successful, zero otherwise.  */
 435
 436 static int
 437 fetch_fpxregs (int tid)
 438 {
 439   elf_fpxregset_t fpxregs;
 440
 441   if (! have_ptrace_getfpxregs)
 442     return 0;
 443
 444   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 445     {
 446       if (errno == EIO)
 447         {
 448           have_ptrace_getfpxregs = 0;
 449           return 0;
 450         }
 451
 452       perror_with_name ("Couldn't read floating-point and SSE registers");
 453     }
 454
 455   supply_fpxregset (&fpxregs);
 456   return 1;
 457 }
 458
 459 /* Store all valid registers in GDB's register array covered by the
 460    PTRACE_SETFPXREGS request into the process/thread specified by TID.
 461    Return non-zero if successful, zero otherwise.  */
 462
 463 static int
 464 store_fpxregs (int tid, int regno)
 465 {
 466   elf_fpxregset_t fpxregs;
 467
 468   if (! have_ptrace_getfpxregs)
 469     return 0;
 470
 471   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
 472     {
 473       if (errno == EIO)
 474         {
 475           have_ptrace_getfpxregs = 0;
 476           return 0;
 477         }
 478
 479       perror_with_name ("Couldn't read floating-point and SSE registers");
 480     }
 481
 482   fill_fpxregset (&fpxregs, regno);
 483
 484   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
 485     perror_with_name ("Couldn't write floating-point and SSE registers");
 486
 487   return 1;
 488 }
 489
 490 /* Fill the XMM registers in the register array with dummy values.  For
 491    cases where we don't have access to the XMM registers.  I think
 492    this is cleaner than printing a warning.  For a cleaner solution,
 493    we should gdbarchify the i386 family.  */
 494
 495 static void
 496 dummy_sse_values (void)
 497 {
 498   /* C doesn't have a syntax for NaN's, so write it out as an array of
 499      longs.  */
 500   static long dummy[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff };
 501   static long mxcsr = 0x1f80;
 502   int reg;
 503
 504   for (reg = 0; reg < 8; reg++)
 505     supply_register (XMM0_REGNUM + reg, (char *) dummy);
 506   supply_register (MXCSR_REGNUM, (char *) &mxcsr);
 507 }
 508
 509 #else
 510
 511 static int fetch_fpxregs (int tid) { return 0; }
 512 static int store_fpxregs (int tid, int regno) { return 0; }
 513 static void dummy_sse_values (void) {}
 514
 515 #endif /* HAVE_PTRACE_GETFPXREGS */
 516 \f
 517
 518 /* Transferring arbitrary registers between GDB and inferior.  */
 519
 520 /* Check if register REGNO in the child process is accessible.
 521    If we are accessing registers directly via the U area, only the
 522    general-purpose registers are available.
 523    All registers should be accessible if we have GETREGS support.  */
 524
 525 int
 526 cannot_fetch_register (int regno)
 527 {
 528   if (! have_ptrace_getregs)
 529     return OLD_CANNOT_FETCH_REGISTER (regno);
 530   return 0;
 531 }
 532 int
 533 cannot_store_register (int regno)
 534 {
 535   if (! have_ptrace_getregs)
 536     return OLD_CANNOT_STORE_REGISTER (regno);
 537   return 0;
 538 }
 539
 540 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 541    this for all registers (including the floating point and SSE
 542    registers).  */
 543
 544 void
 545 fetch_inferior_registers (int regno)
 546 {
 547   int tid;
 548
 549   /* Use the old method of peeking around in `struct user' if the
 550      GETREGS request isn't available.  */
 551   if (! have_ptrace_getregs)
 552     {
 553       old_fetch_inferior_registers (regno);
 554       return;
 555     }
 556
 557   /* Linux LWP ID's are process ID's.  */
 558   if ((tid = TIDGET (inferior_pid)) == 0)
 559     tid = inferior_pid;         /* Not a threaded program.  */
 560
 561   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
 562      transfers more registers in one system call, and we'll cache the
 563      results.  But remember that fetch_fpxregs can fail, and return
 564      zero.  */
 565   if (regno == -1)
 566     {
 567       fetch_regs (tid);
 568
 569       /* The call above might reset `have_ptrace_getregs'.  */
 570       if (! have_ptrace_getregs)
 571         {
 572           old_fetch_inferior_registers (-1);
 573           return;
 574         }
 575
 576       if (fetch_fpxregs (tid))
 577         return;
 578       fetch_fpregs (tid);
 579       return;
 580     }
 581
 582   if (GETREGS_SUPPLIES (regno))
 583     {
 584       fetch_regs (tid);
 585       return;
 586     }
 587
 588   if (GETFPXREGS_SUPPLIES (regno))
 589     {
 590       if (fetch_fpxregs (tid))
 591         return;
 592
 593       /* Either our processor or our kernel doesn't support the SSE
 594          registers, so read the FP registers in the traditional way,
 595          and fill the SSE registers with dummy values.  It would be
 596          more graceful to handle differences in the register set using
 597          gdbarch.  Until then, this will at least make things work
 598          plausibly.  */
 599       fetch_fpregs (tid);
 600       return;
 601     }
 602
 603   internal_error (__FILE__, __LINE__,
 604                   "Got request for bad register number %d.", regno);
 605 }
 606
 607 /* Store register REGNO back into the child process.  If REGNO is -1,
 608    do this for all registers (including the floating point and SSE
 609    registers).  */
 610 void
 611 store_inferior_registers (int regno)
 612 {
 613   int tid;
 614
 615   /* Use the old method of poking around in `struct user' if the
 616      SETREGS request isn't available.  */
 617   if (! have_ptrace_getregs)
 618     {
 619       old_store_inferior_registers (regno);
 620       return;
 621     }
 622
 623   /* Linux LWP ID's are process ID's.  */
 624   if ((tid = TIDGET (inferior_pid)) == 0)
 625     tid = inferior_pid;         /* Not a threaded program.  */
 626
 627   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
 628      transfers more registers in one system call.  But remember that
 629      store_fpxregs can fail, and return zero.  */
 630   if (regno == -1)
 631     {
 632       store_regs (tid, regno);
 633       if (store_fpxregs (tid, regno))
 634         return;
 635       store_fpregs (tid, regno);
 636       return;
 637     }
 638
 639   if (GETREGS_SUPPLIES (regno))
 640     {
 641       store_regs (tid, regno);
 642       return;
 643     }
 644
 645   if (GETFPXREGS_SUPPLIES (regno))
 646     {
 647       if (store_fpxregs (tid, regno))
 648         return;
 649
 650       /* Either our processor or our kernel doesn't support the SSE
 651          registers, so just write the FP registers in the traditional
 652          way.  */
 653       store_fpregs (tid, regno);
 654       return;
 655     }
 656
 657   internal_error (__FILE__, __LINE__,
 658                   "Got request to store bad register number %d.", regno);
 659 }
 660 \f
 661
 662 /* Interpreting register set info found in core files.  */
 663
 664 /* Provide registers to GDB from a core file.
 665
 666    (We can't use the generic version of this function in
 667    core-regset.c, because Linux has *three* different kinds of
 668    register set notes.  core-regset.c would have to call
 669    supply_fpxregset, which most platforms don't have.)
 670
 671    CORE_REG_SECT points to an array of bytes, which are the contents
 672    of a `note' from a core file which BFD thinks might contain
 673    register contents.  CORE_REG_SIZE is its size.
 674
 675    WHICH says which register set corelow suspects this is:
 676      0 --- the general-purpose register set, in elf_gregset_t format
 677      2 --- the floating-point register set, in elf_fpregset_t format
 678      3 --- the extended floating-point register set, in elf_fpxregset_t format
 679
 680    REG_ADDR isn't used on Linux.  */
 681
 682 static void
 683 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 684                       int which, CORE_ADDR reg_addr)
 685 {
 686   elf_gregset_t gregset;
 687   elf_fpregset_t fpregset;
 688
 689   switch (which)
 690     {
 691     case 0:
 692       if (core_reg_size != sizeof (gregset))
 693         warning ("Wrong size gregset in core file.");
 694       else
 695         {
 696           memcpy (&gregset, core_reg_sect, sizeof (gregset));
 697           supply_gregset (&gregset);
 698         }
 699       break;
 700
 701     case 2:
 702       if (core_reg_size != sizeof (fpregset))
 703         warning ("Wrong size fpregset in core file.");
 704       else
 705         {
 706           memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
 707           supply_fpregset (&fpregset);
 708         }
 709       break;
 710
 711 #ifdef HAVE_PTRACE_GETFPXREGS
 712       {
 713         elf_fpxregset_t fpxregset;
 714
 715       case 3:
 716         if (core_reg_size != sizeof (fpxregset))
 717           warning ("Wrong size fpxregset in core file.");
 718         else
 719           {
 720             memcpy (&fpxregset, core_reg_sect, sizeof (fpxregset));
 721             supply_fpxregset (&fpxregset);
 722           }
 723         break;
 724       }
 725 #endif
 726
 727     default:
 728       /* We've covered all the kinds of registers we know about here,
 729          so this must be something we wouldn't know what to do with
 730          anyway.  Just ignore it.  */
 731       break;
 732     }
 733 }
 734 \f
 735
 736 /* The instruction for a Linux system call is:
 737        int $0x80
 738    or 0xcd 0x80.  */
 739
 740 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
 741
 742 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 743
 744 /* The system call number is stored in the %eax register.  */
 745 #define LINUX_SYSCALL_REGNUM 0  /* %eax */
 746
 747 /* We are specifically interested in the sigreturn and rt_sigreturn
 748    system calls.  */
 749
 750 #ifndef SYS_sigreturn
 751 #define SYS_sigreturn           0x77
 752 #endif
 753 #ifndef SYS_rt_sigreturn
 754 #define SYS_rt_sigreturn        0xad
 755 #endif
 756
 757 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 758 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
 759
 760 /* Resume execution of the inferior process.
 761    If STEP is nonzero, single-step it.
 762    If SIGNAL is nonzero, give it that signal.  */
 763
 764 void
 765 child_resume (int pid, int step, enum target_signal signal)
 766 {
 767   int request = PTRACE_CONT;
 768
 769   if (pid == -1)
 770     /* Resume all threads.  */
 771     /* I think this only gets used in the non-threaded case, where "resume
 772        all threads" and "resume inferior_pid" are the same.  */
 773     pid = inferior_pid;
 774
 775   if (step)
 776     {
 777       CORE_ADDR pc = read_pc_pid (pid);
 778       unsigned char buf[LINUX_SYSCALL_LEN];
 779
 780       request = PTRACE_SINGLESTEP;
 781
 782       /* Returning from a signal trampoline is done by calling a
 783          special system call (sigreturn or rt_sigreturn, see
 784          i386-linux-tdep.c for more information).  This system call
 785          restores the registers that were saved when the signal was
 786          raised, including %eflags.  That means that single-stepping
 787          won't work.  Instead, we'll have to modify the signal context
 788          that's about to be restored, and set the trace flag there.  */
 789
 790       /* First check if PC is at a system call.  */
 791       if (read_memory_nobpt (pc, (char *) buf, LINUX_SYSCALL_LEN) == 0
 792           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 793         {
 794           int syscall = read_register_pid (LINUX_SYSCALL_REGNUM, pid);
 795
 796           /* Then check the system call number.  */
 797           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
 798             {
 799               CORE_ADDR sp = read_register (SP_REGNUM);
 800               CORE_ADDR addr = sp;
 801               unsigned long int eflags;
 802
 803               if (syscall == SYS_rt_sigreturn)
 804                 addr = read_memory_integer (sp + 8, 4) + 20;
 805
 806               /* Set the trace flag in the context that's about to be
 807                  restored.  */
 808               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 809               read_memory (addr, (char *) &eflags, 4);
 810               eflags |= 0x0100;
 811               write_memory (addr, (char *) &eflags, 4);
 812             }
 813         }
 814     }
 815
 816   if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
 817     perror_with_name ("ptrace");
 818 }
 819 \f
 820
 821 /* Register that we are able to handle Linux ELF core file formats.  */
 822
 823 static struct core_fns linux_elf_core_fns =
 824 {
 825   bfd_target_elf_flavour,               /* core_flavour */
 826   default_check_format,                 /* check_format */
 827   default_core_sniffer,                 /* core_sniffer */
 828   fetch_core_registers,                 /* core_read_registers */
 829   NULL                                  /* next */
 830 };
 831
 832 void
 833 _initialize_i386_linux_nat (void)
 834 {
 835   add_core_fns (&linux_elf_core_fns);
 836 }