gdb/i386-linux-nat.c

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