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