gdb/i386-linux-nat.c

   1 /* Native-dependent code for GNU/Linux i386.
   2
   3    Copyright (C) 1999-2015 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "inferior.h"
  22 #include "gdbcore.h"
  23 #include "regcache.h"
  24 #include "elf/common.h"
  25 #include <sys/ptrace.h>
  26 #include <sys/uio.h>
  27 #include "gregset.h"
  28 #include "gdb_proc_service.h"
  29
  30 #include "i386-linux-nat.h"
  31 #include "i387-tdep.h"
  32 #include "i386-tdep.h"
  33 #include "i386-linux-tdep.h"
  34 #include "x86-xstate.h"
  35
  36 #include "x86-linux-nat.h"
  37 #include "nat/linux-ptrace.h"
  38
  39 /* The register sets used in GNU/Linux ELF core-dumps are identical to
  40    the register sets in `struct user' that is used for a.out
  41    core-dumps, and is also used by `ptrace'.  The corresponding types
  42    are `elf_gregset_t' for the general-purpose registers (with
  43    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
  44    for the floating-point registers.
  45
  46    Those types used to be available under the names `gregset_t' and
  47    `fpregset_t' too, and this file used those names in the past.  But
  48    those names are now used for the register sets used in the
  49    `mcontext_t' type, and have a different size and layout.  */
  50
  51 /* Which ptrace request retrieves which registers?
  52    These apply to the corresponding SET requests as well.  */
  53
  54 #define GETREGS_SUPPLIES(regno) \
  55   ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
  56
  57 #define GETFPXREGS_SUPPLIES(regno) \
  58   (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
  59
  60 #define GETXSTATEREGS_SUPPLIES(regno) \
  61   (I386_ST0_REGNUM <= (regno) && (regno) < I386_AVX512_NUM_REGS)
  62
  63 /* Does the current host support the GETREGS request?  */
  64 int have_ptrace_getregs =
  65 #ifdef HAVE_PTRACE_GETREGS
  66   1
  67 #else
  68   0
  69 #endif
  70 ;
  71
  72 /* Does the current host support the GETFPXREGS request?  The header
  73    file may or may not define it, and even if it is defined, the
  74    kernel will return EIO if it's running on a pre-SSE processor.
  75
  76    My instinct is to attach this to some architecture- or
  77    target-specific data structure, but really, a particular GDB
  78    process can only run on top of one kernel at a time.  So it's okay
  79    for this to be a simple variable.  */
  80 int have_ptrace_getfpxregs =
  81 #ifdef HAVE_PTRACE_GETFPXREGS
  82   -1
  83 #else
  84   0
  85 #endif
  86 ;
  87 \f
  88
  89 /* Accessing registers through the U area, one at a time.  */
  90
  91 /* Fetch one register.  */
  92
  93 static void
  94 fetch_register (struct regcache *regcache, int regno)
  95 {
  96   int tid;
  97   int val;
  98
  99   gdb_assert (!have_ptrace_getregs);
 100   if (i386_linux_gregset_reg_offset[regno] == -1)
 101     {
 102       regcache_raw_supply (regcache, regno, NULL);
 103       return;
 104     }
 105
 106   /* GNU/Linux LWP ID's are process ID's.  */
 107   tid = ptid_get_lwp (inferior_ptid);
 108   if (tid == 0)
 109     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 110
 111   errno = 0;
 112   val = ptrace (PTRACE_PEEKUSER, tid,
 113                 i386_linux_gregset_reg_offset[regno], 0);
 114   if (errno != 0)
 115     error (_("Couldn't read register %s (#%d): %s."),
 116            gdbarch_register_name (get_regcache_arch (regcache), regno),
 117            regno, safe_strerror (errno));
 118
 119   regcache_raw_supply (regcache, regno, &val);
 120 }
 121
 122 /* Store one register.  */
 123
 124 static void
 125 store_register (const struct regcache *regcache, int regno)
 126 {
 127   int tid;
 128   int val;
 129
 130   gdb_assert (!have_ptrace_getregs);
 131   if (i386_linux_gregset_reg_offset[regno] == -1)
 132     return;
 133
 134   /* GNU/Linux LWP ID's are process ID's.  */
 135   tid = ptid_get_lwp (inferior_ptid);
 136   if (tid == 0)
 137     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 138
 139   errno = 0;
 140   regcache_raw_collect (regcache, regno, &val);
 141   ptrace (PTRACE_POKEUSER, tid,
 142           i386_linux_gregset_reg_offset[regno], val);
 143   if (errno != 0)
 144     error (_("Couldn't write register %s (#%d): %s."),
 145            gdbarch_register_name (get_regcache_arch (regcache), regno),
 146            regno, safe_strerror (errno));
 147 }
 148 \f
 149
 150 /* Transfering the general-purpose registers between GDB, inferiors
 151    and core files.  */
 152
 153 /* Fill GDB's register array with the general-purpose register values
 154    in *GREGSETP.  */
 155
 156 void
 157 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 158 {
 159   const gdb_byte *regp = (const gdb_byte *) gregsetp;
 160   int i;
 161
 162   for (i = 0; i < I386_NUM_GREGS; i++)
 163     regcache_raw_supply (regcache, i,
 164                          regp + i386_linux_gregset_reg_offset[i]);
 165
 166   if (I386_LINUX_ORIG_EAX_REGNUM
 167         < gdbarch_num_regs (get_regcache_arch (regcache)))
 168     regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
 169                          + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
 170 }
 171
 172 /* Fill register REGNO (if it is a general-purpose register) in
 173    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 174    do this for all registers.  */
 175
 176 void
 177 fill_gregset (const struct regcache *regcache,
 178               elf_gregset_t *gregsetp, int regno)
 179 {
 180   gdb_byte *regp = (gdb_byte *) gregsetp;
 181   int i;
 182
 183   for (i = 0; i < I386_NUM_GREGS; i++)
 184     if (regno == -1 || regno == i)
 185       regcache_raw_collect (regcache, i,
 186                             regp + i386_linux_gregset_reg_offset[i]);
 187
 188   if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
 189       && I386_LINUX_ORIG_EAX_REGNUM
 190            < gdbarch_num_regs (get_regcache_arch (regcache)))
 191     regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
 192                           + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
 193 }
 194
 195 #ifdef HAVE_PTRACE_GETREGS
 196
 197 /* Fetch all general-purpose registers from process/thread TID and
 198    store their values in GDB's register array.  */
 199
 200 static void
 201 fetch_regs (struct regcache *regcache, int tid)
 202 {
 203   elf_gregset_t regs;
 204   elf_gregset_t *regs_p = &regs;
 205
 206   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 207     {
 208       if (errno == EIO)
 209         {
 210           /* The kernel we're running on doesn't support the GETREGS
 211              request.  Reset `have_ptrace_getregs'.  */
 212           have_ptrace_getregs = 0;
 213           return;
 214         }
 215
 216       perror_with_name (_("Couldn't get registers"));
 217     }
 218
 219   supply_gregset (regcache, (const elf_gregset_t *) regs_p);
 220 }
 221
 222 /* Store all valid general-purpose registers in GDB's register array
 223    into the process/thread specified by TID.  */
 224
 225 static void
 226 store_regs (const struct regcache *regcache, int tid, int regno)
 227 {
 228   elf_gregset_t regs;
 229
 230   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 231     perror_with_name (_("Couldn't get registers"));
 232
 233   fill_gregset (regcache, &regs, regno);
 234
 235   if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
 236     perror_with_name (_("Couldn't write registers"));
 237 }
 238
 239 #else
 240
 241 static void fetch_regs (struct regcache *regcache, int tid) {}
 242 static void store_regs (const struct regcache *regcache, int tid, int regno) {}
 243
 244 #endif
 245 \f
 246
 247 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 248
 249 /* Fill GDB's register array with the floating-point register values in
 250    *FPREGSETP.  */
 251
 252 void
 253 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 254 {
 255   i387_supply_fsave (regcache, -1, fpregsetp);
 256 }
 257
 258 /* Fill register REGNO (if it is a floating-point register) in
 259    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 260    do this for all registers.  */
 261
 262 void
 263 fill_fpregset (const struct regcache *regcache,
 264                elf_fpregset_t *fpregsetp, int regno)
 265 {
 266   i387_collect_fsave (regcache, regno, fpregsetp);
 267 }
 268
 269 #ifdef HAVE_PTRACE_GETREGS
 270
 271 /* Fetch all floating-point registers from process/thread TID and store
 272    thier values in GDB's register array.  */
 273
 274 static void
 275 fetch_fpregs (struct regcache *regcache, int tid)
 276 {
 277   elf_fpregset_t fpregs;
 278
 279   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 280     perror_with_name (_("Couldn't get floating point status"));
 281
 282   supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
 283 }
 284
 285 /* Store all valid floating-point registers in GDB's register array
 286    into the process/thread specified by TID.  */
 287
 288 static void
 289 store_fpregs (const struct regcache *regcache, int tid, int regno)
 290 {
 291   elf_fpregset_t fpregs;
 292
 293   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 294     perror_with_name (_("Couldn't get floating point status"));
 295
 296   fill_fpregset (regcache, &fpregs, regno);
 297
 298   if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
 299     perror_with_name (_("Couldn't write floating point status"));
 300 }
 301
 302 #else
 303
 304 static void
 305 fetch_fpregs (struct regcache *regcache, int tid)
 306 {
 307 }
 308
 309 static void
 310 store_fpregs (const struct regcache *regcache, int tid, int regno)
 311 {
 312 }
 313
 314 #endif
 315 \f
 316
 317 /* Transfering floating-point and SSE registers to and from GDB.  */
 318
 319 /* Fetch all registers covered by the PTRACE_GETREGSET request from
 320    process/thread TID and store their values in GDB's register array.
 321    Return non-zero if successful, zero otherwise.  */
 322
 323 static int
 324 fetch_xstateregs (struct regcache *regcache, int tid)
 325 {
 326   char xstateregs[X86_XSTATE_MAX_SIZE];
 327   struct iovec iov;
 328
 329   if (!have_ptrace_getregset)
 330     return 0;
 331
 332   iov.iov_base = xstateregs;
 333   iov.iov_len = sizeof(xstateregs);
 334   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 335               &iov) < 0)
 336     perror_with_name (_("Couldn't read extended state status"));
 337
 338   i387_supply_xsave (regcache, -1, xstateregs);
 339   return 1;
 340 }
 341
 342 /* Store all valid registers in GDB's register array covered by the
 343    PTRACE_SETREGSET request into the process/thread specified by TID.
 344    Return non-zero if successful, zero otherwise.  */
 345
 346 static int
 347 store_xstateregs (const struct regcache *regcache, int tid, int regno)
 348 {
 349   char xstateregs[X86_XSTATE_MAX_SIZE];
 350   struct iovec iov;
 351
 352   if (!have_ptrace_getregset)
 353     return 0;
 354
 355   iov.iov_base = xstateregs;
 356   iov.iov_len = sizeof(xstateregs);
 357   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 358               &iov) < 0)
 359     perror_with_name (_("Couldn't read extended state status"));
 360
 361   i387_collect_xsave (regcache, regno, xstateregs, 0);
 362
 363   if (ptrace (PTRACE_SETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 364               (int) &iov) < 0)
 365     perror_with_name (_("Couldn't write extended state status"));
 366
 367   return 1;
 368 }
 369
 370 #ifdef HAVE_PTRACE_GETFPXREGS
 371
 372 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
 373    process/thread TID and store their values in GDB's register array.
 374    Return non-zero if successful, zero otherwise.  */
 375
 376 static int
 377 fetch_fpxregs (struct regcache *regcache, int tid)
 378 {
 379   elf_fpxregset_t fpxregs;
 380
 381   if (! have_ptrace_getfpxregs)
 382     return 0;
 383
 384   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 385     {
 386       if (errno == EIO)
 387         {
 388           have_ptrace_getfpxregs = 0;
 389           return 0;
 390         }
 391
 392       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 393     }
 394
 395   i387_supply_fxsave (regcache, -1, (const elf_fpxregset_t *) &fpxregs);
 396   return 1;
 397 }
 398
 399 /* Store all valid registers in GDB's register array covered by the
 400    PTRACE_SETFPXREGS request into the process/thread specified by TID.
 401    Return non-zero if successful, zero otherwise.  */
 402
 403 static int
 404 store_fpxregs (const struct regcache *regcache, int tid, int regno)
 405 {
 406   elf_fpxregset_t fpxregs;
 407
 408   if (! have_ptrace_getfpxregs)
 409     return 0;
 410
 411   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
 412     {
 413       if (errno == EIO)
 414         {
 415           have_ptrace_getfpxregs = 0;
 416           return 0;
 417         }
 418
 419       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 420     }
 421
 422   i387_collect_fxsave (regcache, regno, &fpxregs);
 423
 424   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
 425     perror_with_name (_("Couldn't write floating-point and SSE registers"));
 426
 427   return 1;
 428 }
 429
 430 #else
 431
 432 static int
 433 fetch_fpxregs (struct regcache *regcache, int tid)
 434 {
 435   return 0;
 436 }
 437
 438 static int
 439 store_fpxregs (const struct regcache *regcache, int tid, int regno)
 440 {
 441   return 0;
 442 }
 443
 444 #endif /* HAVE_PTRACE_GETFPXREGS */
 445 \f
 446
 447 /* Transferring arbitrary registers between GDB and inferior.  */
 448
 449 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 450    this for all registers (including the floating point and SSE
 451    registers).  */
 452
 453 static void
 454 i386_linux_fetch_inferior_registers (struct target_ops *ops,
 455                                      struct regcache *regcache, int regno)
 456 {
 457   int tid;
 458
 459   /* Use the old method of peeking around in `struct user' if the
 460      GETREGS request isn't available.  */
 461   if (!have_ptrace_getregs)
 462     {
 463       int i;
 464
 465       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 466         if (regno == -1 || regno == i)
 467           fetch_register (regcache, i);
 468
 469       return;
 470     }
 471
 472   /* GNU/Linux LWP ID's are process ID's.  */
 473   tid = ptid_get_lwp (inferior_ptid);
 474   if (tid == 0)
 475     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 476
 477   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
 478      transfers more registers in one system call, and we'll cache the
 479      results.  But remember that fetch_fpxregs can fail, and return
 480      zero.  */
 481   if (regno == -1)
 482     {
 483       fetch_regs (regcache, tid);
 484
 485       /* The call above might reset `have_ptrace_getregs'.  */
 486       if (!have_ptrace_getregs)
 487         {
 488           i386_linux_fetch_inferior_registers (ops, regcache, regno);
 489           return;
 490         }
 491
 492       if (fetch_xstateregs (regcache, tid))
 493         return;
 494       if (fetch_fpxregs (regcache, tid))
 495         return;
 496       fetch_fpregs (regcache, tid);
 497       return;
 498     }
 499
 500   if (GETREGS_SUPPLIES (regno))
 501     {
 502       fetch_regs (regcache, tid);
 503       return;
 504     }
 505
 506   if (GETXSTATEREGS_SUPPLIES (regno))
 507     {
 508       if (fetch_xstateregs (regcache, tid))
 509         return;
 510     }
 511
 512   if (GETFPXREGS_SUPPLIES (regno))
 513     {
 514       if (fetch_fpxregs (regcache, tid))
 515         return;
 516
 517       /* Either our processor or our kernel doesn't support the SSE
 518          registers, so read the FP registers in the traditional way,
 519          and fill the SSE registers with dummy values.  It would be
 520          more graceful to handle differences in the register set using
 521          gdbarch.  Until then, this will at least make things work
 522          plausibly.  */
 523       fetch_fpregs (regcache, tid);
 524       return;
 525     }
 526
 527   internal_error (__FILE__, __LINE__,
 528                   _("Got request for bad register number %d."), regno);
 529 }
 530
 531 /* Store register REGNO back into the child process.  If REGNO is -1,
 532    do this for all registers (including the floating point and SSE
 533    registers).  */
 534 static void
 535 i386_linux_store_inferior_registers (struct target_ops *ops,
 536                                      struct regcache *regcache, int regno)
 537 {
 538   int tid;
 539
 540   /* Use the old method of poking around in `struct user' if the
 541      SETREGS request isn't available.  */
 542   if (!have_ptrace_getregs)
 543     {
 544       int i;
 545
 546       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 547         if (regno == -1 || regno == i)
 548           store_register (regcache, i);
 549
 550       return;
 551     }
 552
 553   /* GNU/Linux LWP ID's are process ID's.  */
 554   tid = ptid_get_lwp (inferior_ptid);
 555   if (tid == 0)
 556     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
 557
 558   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
 559      transfers more registers in one system call.  But remember that
 560      store_fpxregs can fail, and return zero.  */
 561   if (regno == -1)
 562     {
 563       store_regs (regcache, tid, regno);
 564       if (store_xstateregs (regcache, tid, regno))
 565         return;
 566       if (store_fpxregs (regcache, tid, regno))
 567         return;
 568       store_fpregs (regcache, tid, regno);
 569       return;
 570     }
 571
 572   if (GETREGS_SUPPLIES (regno))
 573     {
 574       store_regs (regcache, tid, regno);
 575       return;
 576     }
 577
 578   if (GETXSTATEREGS_SUPPLIES (regno))
 579     {
 580       if (store_xstateregs (regcache, tid, regno))
 581         return;
 582     }
 583
 584   if (GETFPXREGS_SUPPLIES (regno))
 585     {
 586       if (store_fpxregs (regcache, tid, regno))
 587         return;
 588
 589       /* Either our processor or our kernel doesn't support the SSE
 590          registers, so just write the FP registers in the traditional
 591          way.  */
 592       store_fpregs (regcache, tid, regno);
 593       return;
 594     }
 595
 596   internal_error (__FILE__, __LINE__,
 597                   _("Got request to store bad register number %d."), regno);
 598 }
 599 \f
 600
 601 /* Called by libthread_db.  Returns a pointer to the thread local
 602    storage (or its descriptor).  */
 603
 604 ps_err_e
 605 ps_get_thread_area (const struct ps_prochandle *ph,
 606                     lwpid_t lwpid, int idx, void **base)
 607 {
 608   unsigned int base_addr;
 609   ps_err_e result;
 610
 611   result = x86_linux_get_thread_area (lwpid, (void *) idx, &base_addr);
 612
 613   if (result == PS_OK)
 614     *(int *) base = base_addr;
 615
 616   return result;
 617 }
 618 \f
 619
 620 /* The instruction for a GNU/Linux system call is:
 621        int $0x80
 622    or 0xcd 0x80.  */
 623
 624 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
 625
 626 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 627
 628 /* The system call number is stored in the %eax register.  */
 629 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
 630
 631 /* We are specifically interested in the sigreturn and rt_sigreturn
 632    system calls.  */
 633
 634 #ifndef SYS_sigreturn
 635 #define SYS_sigreturn           0x77
 636 #endif
 637 #ifndef SYS_rt_sigreturn
 638 #define SYS_rt_sigreturn        0xad
 639 #endif
 640
 641 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 642 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
 643
 644 /* Resume execution of the inferior process.
 645    If STEP is nonzero, single-step it.
 646    If SIGNAL is nonzero, give it that signal.  */
 647
 648 static void
 649 i386_linux_resume (struct target_ops *ops,
 650                    ptid_t ptid, int step, enum gdb_signal signal)
 651 {
 652   int pid = ptid_get_lwp (ptid);
 653   int request;
 654
 655   if (catch_syscall_enabled () > 0)
 656    request = PTRACE_SYSCALL;
 657   else
 658     request = PTRACE_CONT;
 659
 660   if (step)
 661     {
 662       struct regcache *regcache = get_thread_regcache (ptid);
 663       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 664       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 665       ULONGEST pc;
 666       gdb_byte buf[LINUX_SYSCALL_LEN];
 667
 668       request = PTRACE_SINGLESTEP;
 669
 670       regcache_cooked_read_unsigned (regcache,
 671                                      gdbarch_pc_regnum (gdbarch), &pc);
 672
 673       /* Returning from a signal trampoline is done by calling a
 674          special system call (sigreturn or rt_sigreturn, see
 675          i386-linux-tdep.c for more information).  This system call
 676          restores the registers that were saved when the signal was
 677          raised, including %eflags.  That means that single-stepping
 678          won't work.  Instead, we'll have to modify the signal context
 679          that's about to be restored, and set the trace flag there.  */
 680
 681       /* First check if PC is at a system call.  */
 682       if (target_read_memory (pc, buf, LINUX_SYSCALL_LEN) == 0
 683           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 684         {
 685           ULONGEST syscall;
 686           regcache_cooked_read_unsigned (regcache,
 687                                          LINUX_SYSCALL_REGNUM, &syscall);
 688
 689           /* Then check the system call number.  */
 690           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
 691             {
 692               ULONGEST sp, addr;
 693               unsigned long int eflags;
 694
 695               regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp);
 696               if (syscall == SYS_rt_sigreturn)
 697                 addr = read_memory_unsigned_integer (sp + 8, 4, byte_order)
 698                   + 20;
 699               else
 700                 addr = sp;
 701
 702               /* Set the trace flag in the context that's about to be
 703                  restored.  */
 704               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 705               read_memory (addr, (gdb_byte *) &eflags, 4);
 706               eflags |= 0x0100;
 707               write_memory (addr, (gdb_byte *) &eflags, 4);
 708             }
 709         }
 710     }
 711
 712   if (ptrace (request, pid, 0, gdb_signal_to_host (signal)) == -1)
 713     perror_with_name (("ptrace"));
 714 }
 715 \f
 716
 717 /* -Wmissing-prototypes */
 718 extern initialize_file_ftype _initialize_i386_linux_nat;
 719
 720 void
 721 _initialize_i386_linux_nat (void)
 722 {
 723   /* Create a generic x86 GNU/Linux target.  */
 724   struct target_ops *t = x86_linux_create_target ();
 725
 726   /* Override the default ptrace resume method.  */
 727   t->to_resume = i386_linux_resume;
 728
 729   /* Add our register access methods.  */
 730   t->to_fetch_registers = i386_linux_fetch_inferior_registers;
 731   t->to_store_registers = i386_linux_store_inferior_registers;
 732
 733   /* Add the target.  */
 734   x86_linux_add_target (t);
 735 }