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 (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 (current_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 (current_regcache, regno, &val);
 169 }
 170
 171 /* Store one register. */
 172
 173 static void
 174 store_register (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 (current_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 (elf_gregset_t *gregsetp)
 205 {
 206   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 207   int i;
 208
 209   for (i = 0; i < I386_NUM_GREGS; i++)
 210     regcache_raw_supply (current_regcache, i, regp + regmap[i]);
 211
 212   if (I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
 213     regcache_raw_supply (current_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 (elf_gregset_t *gregsetp, int regno)
 223 {
 224   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 225   int i;
 226
 227   for (i = 0; i < I386_NUM_GREGS; i++)
 228     if (regno == -1 || regno == i)
 229       regcache_raw_collect (current_regcache, i, regp + regmap[i]);
 230
 231   if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
 232       && I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
 233     regcache_raw_collect (current_regcache, I386_LINUX_ORIG_EAX_REGNUM,
 234                           regp + ORIG_EAX);
 235 }
 236
 237 #ifdef HAVE_PTRACE_GETREGS
 238
 239 /* Fetch all general-purpose registers from process/thread TID and
 240    store their values in GDB's register array.  */
 241
 242 static void
 243 fetch_regs (int tid)
 244 {
 245   elf_gregset_t regs;
 246
 247   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 248     {
 249       if (errno == EIO)
 250         {
 251           /* The kernel we're running on doesn't support the GETREGS
 252              request.  Reset `have_ptrace_getregs'.  */
 253           have_ptrace_getregs = 0;
 254           return;
 255         }
 256
 257       perror_with_name (_("Couldn't get registers"));
 258     }
 259
 260   supply_gregset (&regs);
 261 }
 262
 263 /* Store all valid general-purpose registers in GDB's register array
 264    into the process/thread specified by TID.  */
 265
 266 static void
 267 store_regs (int tid, int regno)
 268 {
 269   elf_gregset_t regs;
 270
 271   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 272     perror_with_name (_("Couldn't get registers"));
 273
 274   fill_gregset (&regs, regno);
 275
 276   if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
 277     perror_with_name (_("Couldn't write registers"));
 278 }
 279
 280 #else
 281
 282 static void fetch_regs (int tid) {}
 283 static void store_regs (int tid, int regno) {}
 284
 285 #endif
 286 \f
 287
 288 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 289
 290 /* Fill GDB's register array with the floating-point register values in
 291    *FPREGSETP.  */
 292
 293 void
 294 supply_fpregset (elf_fpregset_t *fpregsetp)
 295 {
 296   i387_supply_fsave (current_regcache, -1, fpregsetp);
 297 }
 298
 299 /* Fill register REGNO (if it is a floating-point register) in
 300    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 301    do this for all registers.  */
 302
 303 void
 304 fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
 305 {
 306   i387_fill_fsave ((char *) fpregsetp, regno);
 307 }
 308
 309 #ifdef HAVE_PTRACE_GETREGS
 310
 311 /* Fetch all floating-point registers from process/thread TID and store
 312    thier values in GDB's register array.  */
 313
 314 static void
 315 fetch_fpregs (int tid)
 316 {
 317   elf_fpregset_t fpregs;
 318
 319   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 320     perror_with_name (_("Couldn't get floating point status"));
 321
 322   supply_fpregset (&fpregs);
 323 }
 324
 325 /* Store all valid floating-point registers in GDB's register array
 326    into the process/thread specified by TID.  */
 327
 328 static void
 329 store_fpregs (int tid, int regno)
 330 {
 331   elf_fpregset_t fpregs;
 332
 333   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 334     perror_with_name (_("Couldn't get floating point status"));
 335
 336   fill_fpregset (&fpregs, regno);
 337
 338   if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
 339     perror_with_name (_("Couldn't write floating point status"));
 340 }
 341
 342 #else
 343
 344 static void fetch_fpregs (int tid) {}
 345 static void store_fpregs (int tid, int regno) {}
 346
 347 #endif
 348 \f
 349
 350 /* Transfering floating-point and SSE registers to and from GDB.  */
 351
 352 #ifdef HAVE_PTRACE_GETFPXREGS
 353
 354 /* Fill GDB's register array with the floating-point and SSE register
 355    values in *FPXREGSETP.  */
 356
 357 void
 358 supply_fpxregset (elf_fpxregset_t *fpxregsetp)
 359 {
 360   i387_supply_fxsave (current_regcache, -1, fpxregsetp);
 361 }
 362
 363 /* Fill register REGNO (if it is a floating-point or SSE register) in
 364    *FPXREGSETP with the value in GDB's register array.  If REGNO is
 365    -1, do this for all registers.  */
 366
 367 void
 368 fill_fpxregset (elf_fpxregset_t *fpxregsetp, int regno)
 369 {
 370   i387_fill_fxsave ((char *) fpxregsetp, regno);
 371 }
 372
 373 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
 374    process/thread TID and store their values in GDB's register array.
 375    Return non-zero if successful, zero otherwise.  */
 376
 377 static int
 378 fetch_fpxregs (int tid)
 379 {
 380   elf_fpxregset_t fpxregs;
 381
 382   if (! have_ptrace_getfpxregs)
 383     return 0;
 384
 385   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 386     {
 387       if (errno == EIO)
 388         {
 389           have_ptrace_getfpxregs = 0;
 390           return 0;
 391         }
 392
 393       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 394     }
 395
 396   supply_fpxregset (&fpxregs);
 397   return 1;
 398 }
 399
 400 /* Store all valid registers in GDB's register array covered by the
 401    PTRACE_SETFPXREGS request into the process/thread specified by TID.
 402    Return non-zero if successful, zero otherwise.  */
 403
 404 static int
 405 store_fpxregs (int tid, int regno)
 406 {
 407   elf_fpxregset_t fpxregs;
 408
 409   if (! have_ptrace_getfpxregs)
 410     return 0;
 411
 412   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
 413     {
 414       if (errno == EIO)
 415         {
 416           have_ptrace_getfpxregs = 0;
 417           return 0;
 418         }
 419
 420       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 421     }
 422
 423   fill_fpxregset (&fpxregs, regno);
 424
 425   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
 426     perror_with_name (_("Couldn't write floating-point and SSE registers"));
 427
 428   return 1;
 429 }
 430
 431 #else
 432
 433 static int fetch_fpxregs (int tid) { return 0; }
 434 static int store_fpxregs (int tid, int regno) { return 0; }
 435
 436 #endif /* HAVE_PTRACE_GETFPXREGS */
 437 \f
 438
 439 /* Transferring arbitrary registers between GDB and inferior.  */
 440
 441 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 442    this for all registers (including the floating point and SSE
 443    registers).  */
 444
 445 static void
 446 i386_linux_fetch_inferior_registers (int regno)
 447 {
 448   int tid;
 449
 450   /* Use the old method of peeking around in `struct user' if the
 451      GETREGS request isn't available.  */
 452   if (!have_ptrace_getregs)
 453     {
 454       int i;
 455
 456       for (i = 0; i < NUM_REGS; i++)
 457         if (regno == -1 || regno == i)
 458           fetch_register (i);
 459
 460       return;
 461     }
 462
 463   /* GNU/Linux LWP ID's are process ID's.  */
 464   tid = TIDGET (inferior_ptid);
 465   if (tid == 0)
 466     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 467
 468   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
 469      transfers more registers in one system call, and we'll cache the
 470      results.  But remember that fetch_fpxregs can fail, and return
 471      zero.  */
 472   if (regno == -1)
 473     {
 474       fetch_regs (tid);
 475
 476       /* The call above might reset `have_ptrace_getregs'.  */
 477       if (!have_ptrace_getregs)
 478         {
 479           i386_linux_fetch_inferior_registers (regno);
 480           return;
 481         }
 482
 483       if (fetch_fpxregs (tid))
 484         return;
 485       fetch_fpregs (tid);
 486       return;
 487     }
 488
 489   if (GETREGS_SUPPLIES (regno))
 490     {
 491       fetch_regs (tid);
 492       return;
 493     }
 494
 495   if (GETFPXREGS_SUPPLIES (regno))
 496     {
 497       if (fetch_fpxregs (tid))
 498         return;
 499
 500       /* Either our processor or our kernel doesn't support the SSE
 501          registers, so read the FP registers in the traditional way,
 502          and fill the SSE registers with dummy values.  It would be
 503          more graceful to handle differences in the register set using
 504          gdbarch.  Until then, this will at least make things work
 505          plausibly.  */
 506       fetch_fpregs (tid);
 507       return;
 508     }
 509
 510   internal_error (__FILE__, __LINE__,
 511                   _("Got request for bad register number %d."), regno);
 512 }
 513
 514 /* Store register REGNO back into the child process.  If REGNO is -1,
 515    do this for all registers (including the floating point and SSE
 516    registers).  */
 517 static void
 518 i386_linux_store_inferior_registers (int regno)
 519 {
 520   int tid;
 521
 522   /* Use the old method of poking around in `struct user' if the
 523      SETREGS request isn't available.  */
 524   if (!have_ptrace_getregs)
 525     {
 526       int i;
 527
 528       for (i = 0; i < NUM_REGS; i++)
 529         if (regno == -1 || regno == i)
 530           store_register (i);
 531
 532       return;
 533     }
 534
 535   /* GNU/Linux LWP ID's are process ID's.  */
 536   tid = TIDGET (inferior_ptid);
 537   if (tid == 0)
 538     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 539
 540   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
 541      transfers more registers in one system call.  But remember that
 542      store_fpxregs can fail, and return zero.  */
 543   if (regno == -1)
 544     {
 545       store_regs (tid, regno);
 546       if (store_fpxregs (tid, regno))
 547         return;
 548       store_fpregs (tid, regno);
 549       return;
 550     }
 551
 552   if (GETREGS_SUPPLIES (regno))
 553     {
 554       store_regs (tid, regno);
 555       return;
 556     }
 557
 558   if (GETFPXREGS_SUPPLIES (regno))
 559     {
 560       if (store_fpxregs (tid, regno))
 561         return;
 562
 563       /* Either our processor or our kernel doesn't support the SSE
 564          registers, so just write the FP registers in the traditional
 565          way.  */
 566       store_fpregs (tid, regno);
 567       return;
 568     }
 569
 570   internal_error (__FILE__, __LINE__,
 571                   _("Got request to store bad register number %d."), regno);
 572 }
 573 \f
 574
 575 /* Support for debug registers.  */
 576
 577 static unsigned long
 578 i386_linux_dr_get (int regnum)
 579 {
 580   int tid;
 581   unsigned long value;
 582
 583   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
 584      multi-threaded processes here.  For now, pretend there is just
 585      one thread.  */
 586   tid = PIDGET (inferior_ptid);
 587
 588   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
 589      ptrace call fails breaks debugging remote targets.  The correct
 590      way to fix this is to add the hardware breakpoint and watchpoint
 591      stuff to the target vector.  For now, just return zero if the
 592      ptrace call fails.  */
 593   errno = 0;
 594   value = ptrace (PTRACE_PEEKUSER, tid,
 595                   offsetof (struct user, u_debugreg[regnum]), 0);
 596   if (errno != 0)
 597 #if 0
 598     perror_with_name (_("Couldn't read debug register"));
 599 #else
 600     return 0;
 601 #endif
 602
 603   return value;
 604 }
 605
 606 static void
 607 i386_linux_dr_set (int regnum, unsigned long value)
 608 {
 609   int tid;
 610
 611   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
 612      multi-threaded processes here.  For now, pretend there is just
 613      one thread.  */
 614   tid = PIDGET (inferior_ptid);
 615
 616   errno = 0;
 617   ptrace (PTRACE_POKEUSER, tid,
 618           offsetof (struct user, u_debugreg[regnum]), value);
 619   if (errno != 0)
 620     perror_with_name (_("Couldn't write debug register"));
 621 }
 622
 623 void
 624 i386_linux_dr_set_control (unsigned long control)
 625 {
 626   i386_linux_dr_set (DR_CONTROL, control);
 627 }
 628
 629 void
 630 i386_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 631 {
 632   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 633
 634   i386_linux_dr_set (DR_FIRSTADDR + regnum, addr);
 635 }
 636
 637 void
 638 i386_linux_dr_reset_addr (int regnum)
 639 {
 640   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 641
 642   i386_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
 643 }
 644
 645 unsigned long
 646 i386_linux_dr_get_status (void)
 647 {
 648   return i386_linux_dr_get (DR_STATUS);
 649 }
 650 \f
 651
 652 /* Called by libthread_db.  Returns a pointer to the thread local
 653    storage (or its descriptor).  */
 654
 655 ps_err_e
 656 ps_get_thread_area (const struct ps_prochandle *ph,
 657                     lwpid_t lwpid, int idx, void **base)
 658 {
 659   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 660      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 661      4 byte integers in size: `entry_number', `base_addr', `limit',
 662      and a bunch of status bits.
 663
 664      The values returned by this ptrace call should be part of the
 665      regcache buffer, and ps_get_thread_area should channel its
 666      request through the regcache.  That way remote targets could
 667      provide the value using the remote protocol and not this direct
 668      call.
 669
 670      Is this function needed?  I'm guessing that the `base' is the
 671      address of a a descriptor that libthread_db uses to find the
 672      thread local address base that GDB needs.  Perhaps that
 673      descriptor is defined by the ABI.  Anyway, given that
 674      libthread_db calls this function without prompting (gdb
 675      requesting tls base) I guess it needs info in there anyway.  */
 676   unsigned int desc[4];
 677   gdb_assert (sizeof (int) == 4);
 678
 679 #ifndef PTRACE_GET_THREAD_AREA
 680 #define PTRACE_GET_THREAD_AREA 25
 681 #endif
 682
 683   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid,
 684               (void *) idx, (unsigned long) &desc) < 0)
 685     return PS_ERR;
 686
 687   *(int *)base = desc[1];
 688   return PS_OK;
 689 }
 690 \f
 691
 692 /* The instruction for a GNU/Linux system call is:
 693        int $0x80
 694    or 0xcd 0x80.  */
 695
 696 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
 697
 698 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 699
 700 /* The system call number is stored in the %eax register.  */
 701 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
 702
 703 /* We are specifically interested in the sigreturn and rt_sigreturn
 704    system calls.  */
 705
 706 #ifndef SYS_sigreturn
 707 #define SYS_sigreturn           0x77
 708 #endif
 709 #ifndef SYS_rt_sigreturn
 710 #define SYS_rt_sigreturn        0xad
 711 #endif
 712
 713 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 714 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
 715
 716 /* Resume execution of the inferior process.
 717    If STEP is nonzero, single-step it.
 718    If SIGNAL is nonzero, give it that signal.  */
 719
 720 static void
 721 i386_linux_resume (ptid_t ptid, int step, enum target_signal signal)
 722 {
 723   int pid = PIDGET (ptid);
 724
 725   int request = PTRACE_CONT;
 726
 727   if (pid == -1)
 728     /* Resume all threads.  */
 729     /* I think this only gets used in the non-threaded case, where "resume
 730        all threads" and "resume inferior_ptid" are the same.  */
 731     pid = PIDGET (inferior_ptid);
 732
 733   if (step)
 734     {
 735       CORE_ADDR pc = read_pc_pid (pid_to_ptid (pid));
 736       gdb_byte buf[LINUX_SYSCALL_LEN];
 737
 738       request = PTRACE_SINGLESTEP;
 739
 740       /* Returning from a signal trampoline is done by calling a
 741          special system call (sigreturn or rt_sigreturn, see
 742          i386-linux-tdep.c for more information).  This system call
 743          restores the registers that were saved when the signal was
 744          raised, including %eflags.  That means that single-stepping
 745          won't work.  Instead, we'll have to modify the signal context
 746          that's about to be restored, and set the trace flag there.  */
 747
 748       /* First check if PC is at a system call.  */
 749       if (read_memory_nobpt (pc, buf, LINUX_SYSCALL_LEN) == 0
 750           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 751         {
 752           int syscall = read_register_pid (LINUX_SYSCALL_REGNUM,
 753                                            pid_to_ptid (pid));
 754
 755           /* Then check the system call number.  */
 756           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
 757             {
 758               CORE_ADDR sp = read_register (I386_ESP_REGNUM);
 759               CORE_ADDR addr = sp;
 760               unsigned long int eflags;
 761
 762               if (syscall == SYS_rt_sigreturn)
 763                 addr = read_memory_integer (sp + 8, 4) + 20;
 764
 765               /* Set the trace flag in the context that's about to be
 766                  restored.  */
 767               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 768               read_memory (addr, (gdb_byte *) &eflags, 4);
 769               eflags |= 0x0100;
 770               write_memory (addr, (gdb_byte *) &eflags, 4);
 771             }
 772         }
 773     }
 774
 775   if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
 776     perror_with_name (("ptrace"));
 777 }
 778
 779 static void (*super_post_startup_inferior) (ptid_t ptid);
 780
 781 static void
 782 i386_linux_child_post_startup_inferior (ptid_t ptid)
 783 {
 784   i386_cleanup_dregs ();
 785   super_post_startup_inferior (ptid);
 786 }
 787
 788 void
 789 _initialize_i386_linux_nat (void)
 790 {
 791   struct target_ops *t;
 792
 793   /* Fill in the generic GNU/Linux methods.  */
 794   t = linux_target ();
 795
 796   /* Override the default ptrace resume method.  */
 797   t->to_resume = i386_linux_resume;
 798
 799   /* Override the GNU/Linux inferior startup hook.  */
 800   super_post_startup_inferior = t->to_post_startup_inferior;
 801   t->to_post_startup_inferior = i386_linux_child_post_startup_inferior;
 802
 803   /* Add our register access methods.  */
 804   t->to_fetch_registers = i386_linux_fetch_inferior_registers;
 805   t->to_store_registers = i386_linux_store_inferior_registers;
 806
 807   /* Register the target.  */
 808   linux_nat_add_target (t);
 809 }