gdb/i386-linux-nat.c

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