gdb/i386-linux-nat.c

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