gdb/i386-linux-nat.c

   1 /* Native-dependent code for GNU/Linux i386.
   2
   3    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24 #include "inferior.h"
  25 #include "gdbcore.h"
  26 #include "regcache.h"
  27 #include "target.h"
  28 #include "linux-nat.h"
  29
  30 #include "gdb_assert.h"
  31 #include "gdb_string.h"
  32 #include <sys/ptrace.h>
  33 #include <sys/user.h>
  34 #include <sys/procfs.h>
  35
  36 #ifdef HAVE_SYS_REG_H
  37 #include <sys/reg.h>
  38 #endif
  39
  40 #ifndef ORIG_EAX
  41 #define ORIG_EAX -1
  42 #endif
  43
  44 #ifdef HAVE_SYS_DEBUGREG_H
  45 #include <sys/debugreg.h>
  46 #endif
  47
  48 #ifndef DR_FIRSTADDR
  49 #define DR_FIRSTADDR 0
  50 #endif
  51
  52 #ifndef DR_LASTADDR
  53 #define DR_LASTADDR 3
  54 #endif
  55
  56 #ifndef DR_STATUS
  57 #define DR_STATUS 6
  58 #endif
  59
  60 #ifndef DR_CONTROL
  61 #define DR_CONTROL 7
  62 #endif
  63
  64 /* Prototypes for supply_gregset etc.  */
  65 #include "gregset.h"
  66
  67 #include "i387-tdep.h"
  68 #include "i386-tdep.h"
  69 #include "i386-linux-tdep.h"
  70
  71 /* Defines ps_err_e, struct ps_prochandle.  */
  72 #include "gdb_proc_service.h"
  73 \f
  74
  75 /* The register sets used in GNU/Linux ELF core-dumps are identical to
  76    the register sets in `struct user' that is used for a.out
  77    core-dumps, and is also used by `ptrace'.  The corresponding types
  78    are `elf_gregset_t' for the general-purpose registers (with
  79    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
  80    for the floating-point registers.
  81
  82    Those types used to be available under the names `gregset_t' and
  83    `fpregset_t' too, and this file used those names in the past.  But
  84    those names are now used for the register sets used in the
  85    `mcontext_t' type, and have a different size and layout.  */
  86
  87 /* Mapping between the general-purpose registers in `struct user'
  88    format and GDB's register array layout.  */
  89 static int regmap[] =
  90 {
  91   EAX, ECX, EDX, EBX,
  92   UESP, EBP, ESI, EDI,
  93   EIP, EFL, CS, SS,
  94   DS, ES, FS, GS,
  95   -1, -1, -1, -1,               /* st0, st1, st2, st3 */
  96   -1, -1, -1, -1,               /* st4, st5, st6, st7 */
  97   -1, -1, -1, -1,               /* fctrl, fstat, ftag, fiseg */
  98   -1, -1, -1, -1,               /* fioff, foseg, fooff, fop */
  99   -1, -1, -1, -1,               /* xmm0, xmm1, xmm2, xmm3 */
 100   -1, -1, -1, -1,               /* xmm4, xmm5, xmm6, xmm6 */
 101   -1,                           /* mxcsr */
 102   ORIG_EAX
 103 };
 104
 105 /* Which ptrace request retrieves which registers?
 106    These apply to the corresponding SET requests as well.  */
 107
 108 #define GETREGS_SUPPLIES(regno) \
 109   ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
 110
 111 #define GETFPXREGS_SUPPLIES(regno) \
 112   (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
 113
 114 /* Does the current host support the GETREGS request?  */
 115 int have_ptrace_getregs =
 116 #ifdef HAVE_PTRACE_GETREGS
 117   1
 118 #else
 119   0
 120 #endif
 121 ;
 122
 123 /* Does the current host support the GETFPXREGS request?  The header
 124    file may or may not define it, and even if it is defined, the
 125    kernel will return EIO if it's running on a pre-SSE processor.
 126
 127    My instinct is to attach this to some architecture- or
 128    target-specific data structure, but really, a particular GDB
 129    process can only run on top of one kernel at a time.  So it's okay
 130    for this to be a simple variable.  */
 131 int have_ptrace_getfpxregs =
 132 #ifdef HAVE_PTRACE_GETFPXREGS
 133   1
 134 #else
 135   0
 136 #endif
 137 ;
 138 \f
 139
 140 /* Accessing registers through the U area, one at a time.  */
 141
 142 /* Fetch one register.  */
 143
 144 static void
 145 fetch_register (struct regcache *regcache, int regno)
 146 {
 147   int tid;
 148   int val;
 149
 150   gdb_assert (!have_ptrace_getregs);
 151   if (regmap[regno] == -1)
 152     {
 153       regcache_raw_supply (regcache, regno, NULL);
 154       return;
 155     }
 156
 157   /* GNU/Linux LWP ID's are process ID's.  */
 158   tid = TIDGET (inferior_ptid);
 159   if (tid == 0)
 160     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 161
 162   errno = 0;
 163   val = ptrace (PTRACE_PEEKUSER, tid, 4 * regmap[regno], 0);
 164   if (errno != 0)
 165     error (_("Couldn't read register %s (#%d): %s."), REGISTER_NAME (regno),
 166            regno, safe_strerror (errno));
 167
 168   regcache_raw_supply (regcache, regno, &val);
 169 }
 170
 171 /* Store one register. */
 172
 173 static void
 174 store_register (const struct regcache *regcache, int regno)
 175 {
 176   int tid;
 177   int val;
 178
 179   gdb_assert (!have_ptrace_getregs);
 180   if (regmap[regno] == -1)
 181     return;
 182
 183   /* GNU/Linux LWP ID's are process ID's.  */
 184   tid = TIDGET (inferior_ptid);
 185   if (tid == 0)
 186     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 187
 188   errno = 0;
 189   regcache_raw_collect (regcache, regno, &val);
 190   ptrace (PTRACE_POKEUSER, tid, 4 * regmap[regno], val);
 191   if (errno != 0)
 192     error (_("Couldn't write register %s (#%d): %s."), REGISTER_NAME (regno),
 193            regno, safe_strerror (errno));
 194 }
 195 \f
 196
 197 /* Transfering the general-purpose registers between GDB, inferiors
 198    and core files.  */
 199
 200 /* Fill GDB's register array with the general-purpose register values
 201    in *GREGSETP.  */
 202
 203 void
 204 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 205 {
 206   const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
 207   int i;
 208
 209   for (i = 0; i < I386_NUM_GREGS; i++)
 210     regcache_raw_supply (regcache, i, regp + regmap[i]);
 211
 212   if (I386_LINUX_ORIG_EAX_REGNUM < gdbarch_num_regs (current_gdbarch))
 213     regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM,
 214                          regp + ORIG_EAX);
 215 }
 216
 217 /* Fill register REGNO (if it is a general-purpose register) in
 218    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 219    do this for all registers.  */
 220
 221 void
 222 fill_gregset (const struct regcache *regcache,
 223               elf_gregset_t *gregsetp, int regno)
 224 {
 225   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 226   int i;
 227
 228   for (i = 0; i < I386_NUM_GREGS; i++)
 229     if (regno == -1 || regno == i)
 230       regcache_raw_collect (regcache, i, regp + regmap[i]);
 231
 232   if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
 233       && I386_LINUX_ORIG_EAX_REGNUM < gdbarch_num_regs (current_gdbarch))
 234     regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM,
 235                           regp + ORIG_EAX);
 236 }
 237
 238 #ifdef HAVE_PTRACE_GETREGS
 239
 240 /* Fetch all general-purpose registers from process/thread TID and
 241    store their values in GDB's register array.  */
 242
 243 static void
 244 fetch_regs (struct regcache *regcache, int tid)
 245 {
 246   elf_gregset_t regs;
 247
 248   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 249     {
 250       if (errno == EIO)
 251         {
 252           /* The kernel we're running on doesn't support the GETREGS
 253              request.  Reset `have_ptrace_getregs'.  */
 254           have_ptrace_getregs = 0;
 255           return;
 256         }
 257
 258       perror_with_name (_("Couldn't get registers"));
 259     }
 260
 261   supply_gregset (regcache, (const elf_gregset_t *) &regs);
 262 }
 263
 264 /* Store all valid general-purpose registers in GDB's register array
 265    into the process/thread specified by TID.  */
 266
 267 static void
 268 store_regs (const struct regcache *regcache, int tid, int regno)
 269 {
 270   elf_gregset_t regs;
 271
 272   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 273     perror_with_name (_("Couldn't get registers"));
 274
 275   fill_gregset (regcache, &regs, regno);
 276
 277   if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
 278     perror_with_name (_("Couldn't write registers"));
 279 }
 280
 281 #else
 282
 283 static void fetch_regs (struct regcache *regcache, int tid) {}
 284 static void store_regs (const struct regcache *regcache, int tid, int regno) {}
 285
 286 #endif
 287 \f
 288
 289 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 290
 291 /* Fill GDB's register array with the floating-point register values in
 292    *FPREGSETP.  */
 293
 294 void
 295 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 296 {
 297   i387_supply_fsave (regcache, -1, fpregsetp);
 298 }
 299
 300 /* Fill register REGNO (if it is a floating-point register) in
 301    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 302    do this for all registers.  */
 303
 304 void
 305 fill_fpregset (const struct regcache *regcache,
 306                elf_fpregset_t *fpregsetp, int regno)
 307 {
 308   i387_collect_fsave (regcache, regno, fpregsetp);
 309 }
 310
 311 #ifdef HAVE_PTRACE_GETREGS
 312
 313 /* Fetch all floating-point registers from process/thread TID and store
 314    thier values in GDB's register array.  */
 315
 316 static void
 317 fetch_fpregs (struct regcache *regcache, int tid)
 318 {
 319   elf_fpregset_t fpregs;
 320
 321   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 322     perror_with_name (_("Couldn't get floating point status"));
 323
 324   supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
 325 }
 326
 327 /* Store all valid floating-point registers in GDB's register array
 328    into the process/thread specified by TID.  */
 329
 330 static void
 331 store_fpregs (const struct regcache *regcache, int tid, int regno)
 332 {
 333   elf_fpregset_t fpregs;
 334
 335   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 336     perror_with_name (_("Couldn't get floating point status"));
 337
 338   fill_fpregset (regcache, &fpregs, regno);
 339
 340   if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
 341     perror_with_name (_("Couldn't write floating point status"));
 342 }
 343
 344 #else
 345
 346 static void fetch_fpregs (struct regcache *regcache, int tid) {}
 347 static void store_fpregs (const struct regcache *regcache, int tid, int regno) {}
 348
 349 #endif
 350 \f
 351
 352 /* Transfering floating-point and SSE registers to and from GDB.  */
 353
 354 #ifdef HAVE_PTRACE_GETFPXREGS
 355
 356 /* Fill GDB's register array with the floating-point and SSE register
 357    values in *FPXREGSETP.  */
 358
 359 void
 360 supply_fpxregset (struct regcache *regcache,
 361                   const elf_fpxregset_t *fpxregsetp)
 362 {
 363   i387_supply_fxsave (regcache, -1, fpxregsetp);
 364 }
 365
 366 /* Fill register REGNO (if it is a floating-point or SSE register) in
 367    *FPXREGSETP with the value in GDB's register array.  If REGNO is
 368    -1, do this for all registers.  */
 369
 370 void
 371 fill_fpxregset (const struct regcache *regcache,
 372                 elf_fpxregset_t *fpxregsetp, int regno)
 373 {
 374   i387_collect_fxsave (regcache, regno, fpxregsetp);
 375 }
 376
 377 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
 378    process/thread TID and store their values in GDB's register array.
 379    Return non-zero if successful, zero otherwise.  */
 380
 381 static int
 382 fetch_fpxregs (struct regcache *regcache, int tid)
 383 {
 384   elf_fpxregset_t fpxregs;
 385
 386   if (! have_ptrace_getfpxregs)
 387     return 0;
 388
 389   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 390     {
 391       if (errno == EIO)
 392         {
 393           have_ptrace_getfpxregs = 0;
 394           return 0;
 395         }
 396
 397       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 398     }
 399
 400   supply_fpxregset (regcache, (const elf_fpxregset_t *) &fpxregs);
 401   return 1;
 402 }
 403
 404 /* Store all valid registers in GDB's register array covered by the
 405    PTRACE_SETFPXREGS request into the process/thread specified by TID.
 406    Return non-zero if successful, zero otherwise.  */
 407
 408 static int
 409 store_fpxregs (const struct regcache *regcache, int tid, int regno)
 410 {
 411   elf_fpxregset_t fpxregs;
 412
 413   if (! have_ptrace_getfpxregs)
 414     return 0;
 415
 416   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
 417     {
 418       if (errno == EIO)
 419         {
 420           have_ptrace_getfpxregs = 0;
 421           return 0;
 422         }
 423
 424       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 425     }
 426
 427   fill_fpxregset (regcache, &fpxregs, regno);
 428
 429   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
 430     perror_with_name (_("Couldn't write floating-point and SSE registers"));
 431
 432   return 1;
 433 }
 434
 435 #else
 436
 437 static int fetch_fpxregs (struct regcache *regcache, int tid) { return 0; }
 438 static int store_fpxregs (const struct regcache *regcache, int tid, int regno) { return 0; }
 439
 440 #endif /* HAVE_PTRACE_GETFPXREGS */
 441 \f
 442
 443 /* Transferring arbitrary registers between GDB and inferior.  */
 444
 445 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 446    this for all registers (including the floating point and SSE
 447    registers).  */
 448
 449 static void
 450 i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno)
 451 {
 452   int tid;
 453
 454   /* Use the old method of peeking around in `struct user' if the
 455      GETREGS request isn't available.  */
 456   if (!have_ptrace_getregs)
 457     {
 458       int i;
 459
 460       for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
 461         if (regno == -1 || regno == i)
 462           fetch_register (regcache, i);
 463
 464       return;
 465     }
 466
 467   /* GNU/Linux LWP ID's are process ID's.  */
 468   tid = TIDGET (inferior_ptid);
 469   if (tid == 0)
 470     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 471
 472   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
 473      transfers more registers in one system call, and we'll cache the
 474      results.  But remember that fetch_fpxregs can fail, and return
 475      zero.  */
 476   if (regno == -1)
 477     {
 478       fetch_regs (regcache, tid);
 479
 480       /* The call above might reset `have_ptrace_getregs'.  */
 481       if (!have_ptrace_getregs)
 482         {
 483           i386_linux_fetch_inferior_registers (regcache, regno);
 484           return;
 485         }
 486
 487       if (fetch_fpxregs (regcache, tid))
 488         return;
 489       fetch_fpregs (regcache, tid);
 490       return;
 491     }
 492
 493   if (GETREGS_SUPPLIES (regno))
 494     {
 495       fetch_regs (regcache, tid);
 496       return;
 497     }
 498
 499   if (GETFPXREGS_SUPPLIES (regno))
 500     {
 501       if (fetch_fpxregs (regcache, tid))
 502         return;
 503
 504       /* Either our processor or our kernel doesn't support the SSE
 505          registers, so read the FP registers in the traditional way,
 506          and fill the SSE registers with dummy values.  It would be
 507          more graceful to handle differences in the register set using
 508          gdbarch.  Until then, this will at least make things work
 509          plausibly.  */
 510       fetch_fpregs (regcache, tid);
 511       return;
 512     }
 513
 514   internal_error (__FILE__, __LINE__,
 515                   _("Got request for bad register number %d."), regno);
 516 }
 517
 518 /* Store register REGNO back into the child process.  If REGNO is -1,
 519    do this for all registers (including the floating point and SSE
 520    registers).  */
 521 static void
 522 i386_linux_store_inferior_registers (struct regcache *regcache, int regno)
 523 {
 524   int tid;
 525
 526   /* Use the old method of poking around in `struct user' if the
 527      SETREGS request isn't available.  */
 528   if (!have_ptrace_getregs)
 529     {
 530       int i;
 531
 532       for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++)
 533         if (regno == -1 || regno == i)
 534           store_register (regcache, i);
 535
 536       return;
 537     }
 538
 539   /* GNU/Linux LWP ID's are process ID's.  */
 540   tid = TIDGET (inferior_ptid);
 541   if (tid == 0)
 542     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 543
 544   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
 545      transfers more registers in one system call.  But remember that
 546      store_fpxregs can fail, and return zero.  */
 547   if (regno == -1)
 548     {
 549       store_regs (regcache, tid, regno);
 550       if (store_fpxregs (regcache, tid, regno))
 551         return;
 552       store_fpregs (regcache, tid, regno);
 553       return;
 554     }
 555
 556   if (GETREGS_SUPPLIES (regno))
 557     {
 558       store_regs (regcache, tid, regno);
 559       return;
 560     }
 561
 562   if (GETFPXREGS_SUPPLIES (regno))
 563     {
 564       if (store_fpxregs (regcache, tid, regno))
 565         return;
 566
 567       /* Either our processor or our kernel doesn't support the SSE
 568          registers, so just write the FP registers in the traditional
 569          way.  */
 570       store_fpregs (regcache, tid, regno);
 571       return;
 572     }
 573
 574   internal_error (__FILE__, __LINE__,
 575                   _("Got request to store bad register number %d."), regno);
 576 }
 577 \f
 578
 579 /* Support for debug registers.  */
 580
 581 static unsigned long
 582 i386_linux_dr_get (int regnum)
 583 {
 584   int tid;
 585   unsigned long value;
 586
 587   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
 588      multi-threaded processes here.  For now, pretend there is just
 589      one thread.  */
 590   tid = PIDGET (inferior_ptid);
 591
 592   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
 593      ptrace call fails breaks debugging remote targets.  The correct
 594      way to fix this is to add the hardware breakpoint and watchpoint
 595      stuff to the target vector.  For now, just return zero if the
 596      ptrace call fails.  */
 597   errno = 0;
 598   value = ptrace (PTRACE_PEEKUSER, tid,
 599                   offsetof (struct user, u_debugreg[regnum]), 0);
 600   if (errno != 0)
 601 #if 0
 602     perror_with_name (_("Couldn't read debug register"));
 603 #else
 604     return 0;
 605 #endif
 606
 607   return value;
 608 }
 609
 610 static void
 611 i386_linux_dr_set (int regnum, unsigned long value)
 612 {
 613   int tid;
 614
 615   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
 616      multi-threaded processes here.  For now, pretend there is just
 617      one thread.  */
 618   tid = PIDGET (inferior_ptid);
 619
 620   errno = 0;
 621   ptrace (PTRACE_POKEUSER, tid,
 622           offsetof (struct user, u_debugreg[regnum]), value);
 623   if (errno != 0)
 624     perror_with_name (_("Couldn't write debug register"));
 625 }
 626
 627 void
 628 i386_linux_dr_set_control (unsigned long control)
 629 {
 630   i386_linux_dr_set (DR_CONTROL, control);
 631 }
 632
 633 void
 634 i386_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 635 {
 636   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 637
 638   i386_linux_dr_set (DR_FIRSTADDR + regnum, addr);
 639 }
 640
 641 void
 642 i386_linux_dr_reset_addr (int regnum)
 643 {
 644   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 645
 646   i386_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
 647 }
 648
 649 unsigned long
 650 i386_linux_dr_get_status (void)
 651 {
 652   return i386_linux_dr_get (DR_STATUS);
 653 }
 654 \f
 655
 656 /* Called by libthread_db.  Returns a pointer to the thread local
 657    storage (or its descriptor).  */
 658
 659 ps_err_e
 660 ps_get_thread_area (const struct ps_prochandle *ph,
 661                     lwpid_t lwpid, int idx, void **base)
 662 {
 663   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 664      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 665      4 byte integers in size: `entry_number', `base_addr', `limit',
 666      and a bunch of status bits.
 667
 668      The values returned by this ptrace call should be part of the
 669      regcache buffer, and ps_get_thread_area should channel its
 670      request through the regcache.  That way remote targets could
 671      provide the value using the remote protocol and not this direct
 672      call.
 673
 674      Is this function needed?  I'm guessing that the `base' is the
 675      address of a a descriptor that libthread_db uses to find the
 676      thread local address base that GDB needs.  Perhaps that
 677      descriptor is defined by the ABI.  Anyway, given that
 678      libthread_db calls this function without prompting (gdb
 679      requesting tls base) I guess it needs info in there anyway.  */
 680   unsigned int desc[4];
 681   gdb_assert (sizeof (int) == 4);
 682
 683 #ifndef PTRACE_GET_THREAD_AREA
 684 #define PTRACE_GET_THREAD_AREA 25
 685 #endif
 686
 687   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid,
 688               (void *) idx, (unsigned long) &desc) < 0)
 689     return PS_ERR;
 690
 691   *(int *)base = desc[1];
 692   return PS_OK;
 693 }
 694 \f
 695
 696 /* The instruction for a GNU/Linux system call is:
 697        int $0x80
 698    or 0xcd 0x80.  */
 699
 700 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
 701
 702 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 703
 704 /* The system call number is stored in the %eax register.  */
 705 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
 706
 707 /* We are specifically interested in the sigreturn and rt_sigreturn
 708    system calls.  */
 709
 710 #ifndef SYS_sigreturn
 711 #define SYS_sigreturn           0x77
 712 #endif
 713 #ifndef SYS_rt_sigreturn
 714 #define SYS_rt_sigreturn        0xad
 715 #endif
 716
 717 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 718 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
 719
 720 /* Resume execution of the inferior process.
 721    If STEP is nonzero, single-step it.
 722    If SIGNAL is nonzero, give it that signal.  */
 723
 724 static void
 725 i386_linux_resume (ptid_t ptid, int step, enum target_signal signal)
 726 {
 727   int pid = PIDGET (ptid);
 728
 729   int request = PTRACE_CONT;
 730
 731   if (pid == -1)
 732     /* Resume all threads.  */
 733     /* I think this only gets used in the non-threaded case, where "resume
 734        all threads" and "resume inferior_ptid" are the same.  */
 735     pid = PIDGET (inferior_ptid);
 736
 737   if (step)
 738     {
 739       struct cleanup *old_chain = save_inferior_ptid ();
 740       struct regcache *regcache = current_regcache;
 741       ULONGEST pc;
 742       gdb_byte buf[LINUX_SYSCALL_LEN];
 743
 744       request = PTRACE_SINGLESTEP;
 745
 746       inferior_ptid = pid_to_ptid (pid);
 747       regcache_cooked_read_unsigned (regcache, PC_REGNUM, &pc);
 748
 749       /* Returning from a signal trampoline is done by calling a
 750          special system call (sigreturn or rt_sigreturn, see
 751          i386-linux-tdep.c for more information).  This system call
 752          restores the registers that were saved when the signal was
 753          raised, including %eflags.  That means that single-stepping
 754          won't work.  Instead, we'll have to modify the signal context
 755          that's about to be restored, and set the trace flag there.  */
 756
 757       /* First check if PC is at a system call.  */
 758       if (read_memory_nobpt (pc, buf, LINUX_SYSCALL_LEN) == 0
 759           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 760         {
 761           ULONGEST syscall;
 762           regcache_cooked_read_unsigned (regcache,
 763                                          LINUX_SYSCALL_REGNUM, &syscall);
 764
 765           /* Then check the system call number.  */
 766           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
 767             {
 768               ULONGEST sp, addr;
 769               unsigned long int eflags;
 770
 771               regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp);
 772               if (syscall == SYS_rt_sigreturn)
 773                 addr = read_memory_integer (sp + 8, 4) + 20;
 774               else
 775                 addr = sp;
 776
 777               /* Set the trace flag in the context that's about to be
 778                  restored.  */
 779               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 780               read_memory (addr, (gdb_byte *) &eflags, 4);
 781               eflags |= 0x0100;
 782               write_memory (addr, (gdb_byte *) &eflags, 4);
 783             }
 784         }
 785
 786       do_cleanups (old_chain);
 787     }
 788
 789   if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
 790     perror_with_name (("ptrace"));
 791 }
 792
 793 static void (*super_post_startup_inferior) (ptid_t ptid);
 794
 795 static void
 796 i386_linux_child_post_startup_inferior (ptid_t ptid)
 797 {
 798   i386_cleanup_dregs ();
 799   super_post_startup_inferior (ptid);
 800 }
 801
 802 void
 803 _initialize_i386_linux_nat (void)
 804 {
 805   struct target_ops *t;
 806
 807   /* Fill in the generic GNU/Linux methods.  */
 808   t = linux_target ();
 809
 810   /* Override the default ptrace resume method.  */
 811   t->to_resume = i386_linux_resume;
 812
 813   /* Override the GNU/Linux inferior startup hook.  */
 814   super_post_startup_inferior = t->to_post_startup_inferior;
 815   t->to_post_startup_inferior = i386_linux_child_post_startup_inferior;
 816
 817   /* Add our register access methods.  */
 818   t->to_fetch_registers = i386_linux_fetch_inferior_registers;
 819   t->to_store_registers = i386_linux_store_inferior_registers;
 820
 821   /* Register the target.  */
 822   linux_nat_add_target (t);
 823 }