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, 2008,
   4    2009, 2010, 2011 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "i386-nat.h"
  23 #include "inferior.h"
  24 #include "gdbcore.h"
  25 #include "regcache.h"
  26 #include "regset.h"
  27 #include "target.h"
  28 #include "linux-nat.h"
  29
  30 #include "gdb_assert.h"
  31 #include "gdb_string.h"
  32 #include "elf/common.h"
  33 #include <sys/uio.h>
  34 #include <sys/ptrace.h>
  35 #include <sys/user.h>
  36 #include <sys/procfs.h>
  37
  38 #ifdef HAVE_SYS_REG_H
  39 #include <sys/reg.h>
  40 #endif
  41
  42 #ifndef ORIG_EAX
  43 #define ORIG_EAX -1
  44 #endif
  45
  46 #ifdef HAVE_SYS_DEBUGREG_H
  47 #include <sys/debugreg.h>
  48 #endif
  49
  50 #ifndef DR_FIRSTADDR
  51 #define DR_FIRSTADDR 0
  52 #endif
  53
  54 #ifndef DR_LASTADDR
  55 #define DR_LASTADDR 3
  56 #endif
  57
  58 #ifndef DR_STATUS
  59 #define DR_STATUS 6
  60 #endif
  61
  62 #ifndef DR_CONTROL
  63 #define DR_CONTROL 7
  64 #endif
  65
  66 /* Prototypes for supply_gregset etc.  */
  67 #include "gregset.h"
  68
  69 #include "i387-tdep.h"
  70 #include "i386-tdep.h"
  71 #include "i386-linux-tdep.h"
  72
  73 /* Defines ps_err_e, struct ps_prochandle.  */
  74 #include "gdb_proc_service.h"
  75
  76 #include "i386-xstate.h"
  77
  78 #ifndef PTRACE_GETREGSET
  79 #define PTRACE_GETREGSET        0x4204
  80 #endif
  81
  82 #ifndef PTRACE_SETREGSET
  83 #define PTRACE_SETREGSET        0x4205
  84 #endif
  85
  86 /* Does the current host support PTRACE_GETREGSET?  */
  87 static int have_ptrace_getregset = -1;
  88 \f
  89
  90 /* The register sets used in GNU/Linux ELF core-dumps are identical to
  91    the register sets in `struct user' that is used for a.out
  92    core-dumps, and is also used by `ptrace'.  The corresponding types
  93    are `elf_gregset_t' for the general-purpose registers (with
  94    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
  95    for the floating-point registers.
  96
  97    Those types used to be available under the names `gregset_t' and
  98    `fpregset_t' too, and this file used those names in the past.  But
  99    those names are now used for the register sets used in the
 100    `mcontext_t' type, and have a different size and layout.  */
 101
 102 /* Which ptrace request retrieves which registers?
 103    These apply to the corresponding SET requests as well.  */
 104
 105 #define GETREGS_SUPPLIES(regno) \
 106   ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
 107
 108 #define GETFPXREGS_SUPPLIES(regno) \
 109   (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
 110
 111 #define GETXSTATEREGS_SUPPLIES(regno) \
 112   (I386_ST0_REGNUM <= (regno) && (regno) < I386_AVX_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 (struct regcache *regcache, int regno)
 146 {
 147   int tid;
 148   int val;
 149
 150   gdb_assert (!have_ptrace_getregs);
 151   if (i386_linux_gregset_reg_offset[regno] == -1)
 152     {
 153       regcache_raw_supply (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,
 164                 i386_linux_gregset_reg_offset[regno], 0);
 165   if (errno != 0)
 166     error (_("Couldn't read register %s (#%d): %s."),
 167            gdbarch_register_name (get_regcache_arch (regcache), regno),
 168            regno, safe_strerror (errno));
 169
 170   regcache_raw_supply (regcache, regno, &val);
 171 }
 172
 173 /* Store one register.  */
 174
 175 static void
 176 store_register (const struct regcache *regcache, int regno)
 177 {
 178   int tid;
 179   int val;
 180
 181   gdb_assert (!have_ptrace_getregs);
 182   if (i386_linux_gregset_reg_offset[regno] == -1)
 183     return;
 184
 185   /* GNU/Linux LWP ID's are process ID's.  */
 186   tid = TIDGET (inferior_ptid);
 187   if (tid == 0)
 188     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 189
 190   errno = 0;
 191   regcache_raw_collect (regcache, regno, &val);
 192   ptrace (PTRACE_POKEUSER, tid,
 193           i386_linux_gregset_reg_offset[regno], val);
 194   if (errno != 0)
 195     error (_("Couldn't write register %s (#%d): %s."),
 196            gdbarch_register_name (get_regcache_arch (regcache), regno),
 197            regno, safe_strerror (errno));
 198 }
 199 \f
 200
 201 /* Transfering the general-purpose registers between GDB, inferiors
 202    and core files.  */
 203
 204 /* Fill GDB's register array with the general-purpose register values
 205    in *GREGSETP.  */
 206
 207 void
 208 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 209 {
 210   const gdb_byte *regp = (const gdb_byte *) gregsetp;
 211   int i;
 212
 213   for (i = 0; i < I386_NUM_GREGS; i++)
 214     regcache_raw_supply (regcache, i,
 215                          regp + i386_linux_gregset_reg_offset[i]);
 216
 217   if (I386_LINUX_ORIG_EAX_REGNUM
 218         < gdbarch_num_regs (get_regcache_arch (regcache)))
 219     regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
 220                          + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
 221 }
 222
 223 /* Fill register REGNO (if it is a general-purpose register) in
 224    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 225    do this for all registers.  */
 226
 227 void
 228 fill_gregset (const struct regcache *regcache,
 229               elf_gregset_t *gregsetp, int regno)
 230 {
 231   gdb_byte *regp = (gdb_byte *) gregsetp;
 232   int i;
 233
 234   for (i = 0; i < I386_NUM_GREGS; i++)
 235     if (regno == -1 || regno == i)
 236       regcache_raw_collect (regcache, i,
 237                             regp + i386_linux_gregset_reg_offset[i]);
 238
 239   if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
 240       && I386_LINUX_ORIG_EAX_REGNUM
 241            < gdbarch_num_regs (get_regcache_arch (regcache)))
 242     regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
 243                           + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
 244 }
 245
 246 #ifdef HAVE_PTRACE_GETREGS
 247
 248 /* Fetch all general-purpose registers from process/thread TID and
 249    store their values in GDB's register array.  */
 250
 251 static void
 252 fetch_regs (struct regcache *regcache, int tid)
 253 {
 254   elf_gregset_t regs;
 255   elf_gregset_t *regs_p = &regs;
 256
 257   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 258     {
 259       if (errno == EIO)
 260         {
 261           /* The kernel we're running on doesn't support the GETREGS
 262              request.  Reset `have_ptrace_getregs'.  */
 263           have_ptrace_getregs = 0;
 264           return;
 265         }
 266
 267       perror_with_name (_("Couldn't get registers"));
 268     }
 269
 270   supply_gregset (regcache, (const elf_gregset_t *) regs_p);
 271 }
 272
 273 /* Store all valid general-purpose registers in GDB's register array
 274    into the process/thread specified by TID.  */
 275
 276 static void
 277 store_regs (const struct regcache *regcache, int tid, int regno)
 278 {
 279   elf_gregset_t regs;
 280
 281   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
 282     perror_with_name (_("Couldn't get registers"));
 283
 284   fill_gregset (regcache, &regs, regno);
 285
 286   if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
 287     perror_with_name (_("Couldn't write registers"));
 288 }
 289
 290 #else
 291
 292 static void fetch_regs (struct regcache *regcache, int tid) {}
 293 static void store_regs (const struct regcache *regcache, int tid, int regno) {}
 294
 295 #endif
 296 \f
 297
 298 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 299
 300 /* Fill GDB's register array with the floating-point register values in
 301    *FPREGSETP.  */
 302
 303 void
 304 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 305 {
 306   i387_supply_fsave (regcache, -1, fpregsetp);
 307 }
 308
 309 /* Fill register REGNO (if it is a floating-point register) in
 310    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 311    do this for all registers.  */
 312
 313 void
 314 fill_fpregset (const struct regcache *regcache,
 315                elf_fpregset_t *fpregsetp, int regno)
 316 {
 317   i387_collect_fsave (regcache, regno, fpregsetp);
 318 }
 319
 320 #ifdef HAVE_PTRACE_GETREGS
 321
 322 /* Fetch all floating-point registers from process/thread TID and store
 323    thier values in GDB's register array.  */
 324
 325 static void
 326 fetch_fpregs (struct regcache *regcache, int tid)
 327 {
 328   elf_fpregset_t fpregs;
 329
 330   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 331     perror_with_name (_("Couldn't get floating point status"));
 332
 333   supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
 334 }
 335
 336 /* Store all valid floating-point registers in GDB's register array
 337    into the process/thread specified by TID.  */
 338
 339 static void
 340 store_fpregs (const struct regcache *regcache, int tid, int regno)
 341 {
 342   elf_fpregset_t fpregs;
 343
 344   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
 345     perror_with_name (_("Couldn't get floating point status"));
 346
 347   fill_fpregset (regcache, &fpregs, regno);
 348
 349   if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
 350     perror_with_name (_("Couldn't write floating point status"));
 351 }
 352
 353 #else
 354
 355 static void
 356 fetch_fpregs (struct regcache *regcache, int tid)
 357 {
 358 }
 359
 360 static void
 361 store_fpregs (const struct regcache *regcache, int tid, int regno)
 362 {
 363 }
 364
 365 #endif
 366 \f
 367
 368 /* Transfering floating-point and SSE registers to and from GDB.  */
 369
 370 /* Fetch all registers covered by the PTRACE_GETREGSET request from
 371    process/thread TID and store their values in GDB's register array.
 372    Return non-zero if successful, zero otherwise.  */
 373
 374 static int
 375 fetch_xstateregs (struct regcache *regcache, int tid)
 376 {
 377   char xstateregs[I386_XSTATE_MAX_SIZE];
 378   struct iovec iov;
 379
 380   if (!have_ptrace_getregset)
 381     return 0;
 382
 383   iov.iov_base = xstateregs;
 384   iov.iov_len = sizeof(xstateregs);
 385   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 386               &iov) < 0)
 387     perror_with_name (_("Couldn't read extended state status"));
 388
 389   i387_supply_xsave (regcache, -1, xstateregs);
 390   return 1;
 391 }
 392
 393 /* Store all valid registers in GDB's register array covered by the
 394    PTRACE_SETREGSET request into the process/thread specified by TID.
 395    Return non-zero if successful, zero otherwise.  */
 396
 397 static int
 398 store_xstateregs (const struct regcache *regcache, int tid, int regno)
 399 {
 400   char xstateregs[I386_XSTATE_MAX_SIZE];
 401   struct iovec iov;
 402
 403   if (!have_ptrace_getregset)
 404     return 0;
 405
 406   iov.iov_base = xstateregs;
 407   iov.iov_len = sizeof(xstateregs);
 408   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 409               &iov) < 0)
 410     perror_with_name (_("Couldn't read extended state status"));
 411
 412   i387_collect_xsave (regcache, regno, xstateregs, 0);
 413
 414   if (ptrace (PTRACE_SETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 415               (int) &iov) < 0)
 416     perror_with_name (_("Couldn't write extended state status"));
 417
 418   return 1;
 419 }
 420
 421 #ifdef HAVE_PTRACE_GETFPXREGS
 422
 423 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
 424    process/thread TID and store their values in GDB's register array.
 425    Return non-zero if successful, zero otherwise.  */
 426
 427 static int
 428 fetch_fpxregs (struct regcache *regcache, int tid)
 429 {
 430   elf_fpxregset_t fpxregs;
 431
 432   if (! have_ptrace_getfpxregs)
 433     return 0;
 434
 435   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 436     {
 437       if (errno == EIO)
 438         {
 439           have_ptrace_getfpxregs = 0;
 440           return 0;
 441         }
 442
 443       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 444     }
 445
 446   i387_supply_fxsave (regcache, -1, (const elf_fpxregset_t *) &fpxregs);
 447   return 1;
 448 }
 449
 450 /* Store all valid registers in GDB's register array covered by the
 451    PTRACE_SETFPXREGS request into the process/thread specified by TID.
 452    Return non-zero if successful, zero otherwise.  */
 453
 454 static int
 455 store_fpxregs (const struct regcache *regcache, int tid, int regno)
 456 {
 457   elf_fpxregset_t fpxregs;
 458
 459   if (! have_ptrace_getfpxregs)
 460     return 0;
 461
 462   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
 463     {
 464       if (errno == EIO)
 465         {
 466           have_ptrace_getfpxregs = 0;
 467           return 0;
 468         }
 469
 470       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 471     }
 472
 473   i387_collect_fxsave (regcache, regno, &fpxregs);
 474
 475   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
 476     perror_with_name (_("Couldn't write floating-point and SSE registers"));
 477
 478   return 1;
 479 }
 480
 481 #else
 482
 483 static int
 484 fetch_fpxregs (struct regcache *regcache, int tid)
 485 {
 486   return 0;
 487 }
 488
 489 static int
 490 store_fpxregs (const struct regcache *regcache, int tid, int regno)
 491 {
 492   return 0;
 493 }
 494
 495 #endif /* HAVE_PTRACE_GETFPXREGS */
 496 \f
 497
 498 /* Transferring arbitrary registers between GDB and inferior.  */
 499
 500 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 501    this for all registers (including the floating point and SSE
 502    registers).  */
 503
 504 static void
 505 i386_linux_fetch_inferior_registers (struct target_ops *ops,
 506                                      struct regcache *regcache, int regno)
 507 {
 508   int tid;
 509
 510   /* Use the old method of peeking around in `struct user' if the
 511      GETREGS request isn't available.  */
 512   if (!have_ptrace_getregs)
 513     {
 514       int i;
 515
 516       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 517         if (regno == -1 || regno == i)
 518           fetch_register (regcache, i);
 519
 520       return;
 521     }
 522
 523   /* GNU/Linux LWP ID's are process ID's.  */
 524   tid = TIDGET (inferior_ptid);
 525   if (tid == 0)
 526     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 527
 528   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
 529      transfers more registers in one system call, and we'll cache the
 530      results.  But remember that fetch_fpxregs can fail, and return
 531      zero.  */
 532   if (regno == -1)
 533     {
 534       fetch_regs (regcache, tid);
 535
 536       /* The call above might reset `have_ptrace_getregs'.  */
 537       if (!have_ptrace_getregs)
 538         {
 539           i386_linux_fetch_inferior_registers (ops, regcache, regno);
 540           return;
 541         }
 542
 543       if (fetch_xstateregs (regcache, tid))
 544         return;
 545       if (fetch_fpxregs (regcache, tid))
 546         return;
 547       fetch_fpregs (regcache, tid);
 548       return;
 549     }
 550
 551   if (GETREGS_SUPPLIES (regno))
 552     {
 553       fetch_regs (regcache, tid);
 554       return;
 555     }
 556
 557   if (GETXSTATEREGS_SUPPLIES (regno))
 558     {
 559       if (fetch_xstateregs (regcache, tid))
 560         return;
 561     }
 562
 563   if (GETFPXREGS_SUPPLIES (regno))
 564     {
 565       if (fetch_fpxregs (regcache, tid))
 566         return;
 567
 568       /* Either our processor or our kernel doesn't support the SSE
 569          registers, so read the FP registers in the traditional way,
 570          and fill the SSE registers with dummy values.  It would be
 571          more graceful to handle differences in the register set using
 572          gdbarch.  Until then, this will at least make things work
 573          plausibly.  */
 574       fetch_fpregs (regcache, tid);
 575       return;
 576     }
 577
 578   internal_error (__FILE__, __LINE__,
 579                   _("Got request for bad register number %d."), regno);
 580 }
 581
 582 /* Store register REGNO back into the child process.  If REGNO is -1,
 583    do this for all registers (including the floating point and SSE
 584    registers).  */
 585 static void
 586 i386_linux_store_inferior_registers (struct target_ops *ops,
 587                                      struct regcache *regcache, int regno)
 588 {
 589   int tid;
 590
 591   /* Use the old method of poking around in `struct user' if the
 592      SETREGS request isn't available.  */
 593   if (!have_ptrace_getregs)
 594     {
 595       int i;
 596
 597       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 598         if (regno == -1 || regno == i)
 599           store_register (regcache, i);
 600
 601       return;
 602     }
 603
 604   /* GNU/Linux LWP ID's are process ID's.  */
 605   tid = TIDGET (inferior_ptid);
 606   if (tid == 0)
 607     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 608
 609   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
 610      transfers more registers in one system call.  But remember that
 611      store_fpxregs can fail, and return zero.  */
 612   if (regno == -1)
 613     {
 614       store_regs (regcache, tid, regno);
 615       if (store_xstateregs (regcache, tid, regno))
 616         return;
 617       if (store_fpxregs (regcache, tid, regno))
 618         return;
 619       store_fpregs (regcache, tid, regno);
 620       return;
 621     }
 622
 623   if (GETREGS_SUPPLIES (regno))
 624     {
 625       store_regs (regcache, tid, regno);
 626       return;
 627     }
 628
 629   if (GETXSTATEREGS_SUPPLIES (regno))
 630     {
 631       if (store_xstateregs (regcache, tid, regno))
 632         return;
 633     }
 634
 635   if (GETFPXREGS_SUPPLIES (regno))
 636     {
 637       if (store_fpxregs (regcache, tid, regno))
 638         return;
 639
 640       /* Either our processor or our kernel doesn't support the SSE
 641          registers, so just write the FP registers in the traditional
 642          way.  */
 643       store_fpregs (regcache, tid, regno);
 644       return;
 645     }
 646
 647   internal_error (__FILE__, __LINE__,
 648                   _("Got request to store bad register number %d."), regno);
 649 }
 650 \f
 651
 652 /* Support for debug registers.  */
 653
 654 static unsigned long i386_linux_dr[DR_CONTROL + 1];
 655
 656 /* Get debug register REGNUM value from only the one LWP of PTID.  */
 657
 658 static unsigned long
 659 i386_linux_dr_get (ptid_t ptid, int regnum)
 660 {
 661   int tid;
 662   unsigned long value;
 663
 664   tid = TIDGET (ptid);
 665   if (tid == 0)
 666     tid = PIDGET (ptid);
 667
 668   errno = 0;
 669   value = ptrace (PTRACE_PEEKUSER, tid,
 670                   offsetof (struct user, u_debugreg[regnum]), 0);
 671   if (errno != 0)
 672     perror_with_name (_("Couldn't read debug register"));
 673
 674   return value;
 675 }
 676
 677 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
 678
 679 static void
 680 i386_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 681 {
 682   int tid;
 683
 684   tid = TIDGET (ptid);
 685   if (tid == 0)
 686     tid = PIDGET (ptid);
 687
 688   errno = 0;
 689   ptrace (PTRACE_POKEUSER, tid,
 690           offsetof (struct user, u_debugreg[regnum]), value);
 691   if (errno != 0)
 692     perror_with_name (_("Couldn't write debug register"));
 693 }
 694
 695 /* Set DR_CONTROL to ADDR in all LWPs of LWP_LIST.  */
 696
 697 static void
 698 i386_linux_dr_set_control (unsigned long control)
 699 {
 700   struct lwp_info *lp;
 701
 702   i386_linux_dr[DR_CONTROL] = control;
 703   ALL_LWPS (lp)
 704     i386_linux_dr_set (lp->ptid, DR_CONTROL, control);
 705 }
 706
 707 /* Set address REGNUM (zero based) to ADDR in all LWPs of LWP_LIST.  */
 708
 709 static void
 710 i386_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 711 {
 712   struct lwp_info *lp;
 713
 714   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 715
 716   i386_linux_dr[DR_FIRSTADDR + regnum] = addr;
 717   ALL_LWPS (lp)
 718     i386_linux_dr_set (lp->ptid, DR_FIRSTADDR + regnum, addr);
 719 }
 720
 721 /* Set address REGNUM (zero based) to zero in all LWPs of LWP_LIST.  */
 722
 723 static void
 724 i386_linux_dr_reset_addr (int regnum)
 725 {
 726   i386_linux_dr_set_addr (regnum, 0);
 727 }
 728
 729 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 730
 731 static unsigned long
 732 i386_linux_dr_get_status (void)
 733 {
 734   return i386_linux_dr_get (inferior_ptid, DR_STATUS);
 735 }
 736
 737 /* Unset MASK bits in DR_STATUS in all LWPs of LWP_LIST.  */
 738
 739 static void
 740 i386_linux_dr_unset_status (unsigned long mask)
 741 {
 742   struct lwp_info *lp;
 743
 744   ALL_LWPS (lp)
 745     {
 746       unsigned long value;
 747
 748       value = i386_linux_dr_get (lp->ptid, DR_STATUS);
 749       value &= ~mask;
 750       i386_linux_dr_set (lp->ptid, DR_STATUS, value);
 751     }
 752 }
 753
 754 static void
 755 i386_linux_new_thread (ptid_t ptid)
 756 {
 757   int i;
 758
 759   for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 760     i386_linux_dr_set (ptid, i, i386_linux_dr[i]);
 761
 762   i386_linux_dr_set (ptid, DR_CONTROL, i386_linux_dr[DR_CONTROL]);
 763 }
 764 \f
 765
 766 /* Called by libthread_db.  Returns a pointer to the thread local
 767    storage (or its descriptor).  */
 768
 769 ps_err_e
 770 ps_get_thread_area (const struct ps_prochandle *ph,
 771                     lwpid_t lwpid, int idx, void **base)
 772 {
 773   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 774      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 775      4 byte integers in size: `entry_number', `base_addr', `limit',
 776      and a bunch of status bits.
 777
 778      The values returned by this ptrace call should be part of the
 779      regcache buffer, and ps_get_thread_area should channel its
 780      request through the regcache.  That way remote targets could
 781      provide the value using the remote protocol and not this direct
 782      call.
 783
 784      Is this function needed?  I'm guessing that the `base' is the
 785      address of a descriptor that libthread_db uses to find the
 786      thread local address base that GDB needs.  Perhaps that
 787      descriptor is defined by the ABI.  Anyway, given that
 788      libthread_db calls this function without prompting (gdb
 789      requesting tls base) I guess it needs info in there anyway.  */
 790   unsigned int desc[4];
 791   gdb_assert (sizeof (int) == 4);
 792
 793 #ifndef PTRACE_GET_THREAD_AREA
 794 #define PTRACE_GET_THREAD_AREA 25
 795 #endif
 796
 797   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid,
 798               (void *) idx, (unsigned long) &desc) < 0)
 799     return PS_ERR;
 800
 801   *(int *)base = desc[1];
 802   return PS_OK;
 803 }
 804 \f
 805
 806 /* The instruction for a GNU/Linux system call is:
 807        int $0x80
 808    or 0xcd 0x80.  */
 809
 810 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
 811
 812 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 813
 814 /* The system call number is stored in the %eax register.  */
 815 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
 816
 817 /* We are specifically interested in the sigreturn and rt_sigreturn
 818    system calls.  */
 819
 820 #ifndef SYS_sigreturn
 821 #define SYS_sigreturn           0x77
 822 #endif
 823 #ifndef SYS_rt_sigreturn
 824 #define SYS_rt_sigreturn        0xad
 825 #endif
 826
 827 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 828 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
 829
 830 /* Resume execution of the inferior process.
 831    If STEP is nonzero, single-step it.
 832    If SIGNAL is nonzero, give it that signal.  */
 833
 834 static void
 835 i386_linux_resume (struct target_ops *ops,
 836                    ptid_t ptid, int step, enum target_signal signal)
 837 {
 838   int pid = PIDGET (ptid);
 839
 840   int request;
 841
 842   if (catch_syscall_enabled () > 0)
 843    request = PTRACE_SYSCALL;
 844   else
 845     request = PTRACE_CONT;
 846
 847   if (step)
 848     {
 849       struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid));
 850       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 851       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 852       ULONGEST pc;
 853       gdb_byte buf[LINUX_SYSCALL_LEN];
 854
 855       request = PTRACE_SINGLESTEP;
 856
 857       regcache_cooked_read_unsigned (regcache,
 858                                      gdbarch_pc_regnum (gdbarch), &pc);
 859
 860       /* Returning from a signal trampoline is done by calling a
 861          special system call (sigreturn or rt_sigreturn, see
 862          i386-linux-tdep.c for more information).  This system call
 863          restores the registers that were saved when the signal was
 864          raised, including %eflags.  That means that single-stepping
 865          won't work.  Instead, we'll have to modify the signal context
 866          that's about to be restored, and set the trace flag there.  */
 867
 868       /* First check if PC is at a system call.  */
 869       if (target_read_memory (pc, buf, LINUX_SYSCALL_LEN) == 0
 870           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 871         {
 872           ULONGEST syscall;
 873           regcache_cooked_read_unsigned (regcache,
 874                                          LINUX_SYSCALL_REGNUM, &syscall);
 875
 876           /* Then check the system call number.  */
 877           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
 878             {
 879               ULONGEST sp, addr;
 880               unsigned long int eflags;
 881
 882               regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp);
 883               if (syscall == SYS_rt_sigreturn)
 884                 addr = read_memory_unsigned_integer (sp + 8, 4, byte_order)
 885                   + 20;
 886               else
 887                 addr = sp;
 888
 889               /* Set the trace flag in the context that's about to be
 890                  restored.  */
 891               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 892               read_memory (addr, (gdb_byte *) &eflags, 4);
 893               eflags |= 0x0100;
 894               write_memory (addr, (gdb_byte *) &eflags, 4);
 895             }
 896         }
 897     }
 898
 899   if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
 900     perror_with_name (("ptrace"));
 901 }
 902
 903 static void (*super_post_startup_inferior) (ptid_t ptid);
 904
 905 static void
 906 i386_linux_child_post_startup_inferior (ptid_t ptid)
 907 {
 908   i386_cleanup_dregs ();
 909   super_post_startup_inferior (ptid);
 910 }
 911
 912 /* Get Linux/x86 target description from running target.  */
 913
 914 static const struct target_desc *
 915 i386_linux_read_description (struct target_ops *ops)
 916 {
 917   int tid;
 918   static uint64_t xcr0;
 919
 920   /* GNU/Linux LWP ID's are process ID's.  */
 921   tid = TIDGET (inferior_ptid);
 922   if (tid == 0)
 923     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 924
 925 #ifdef HAVE_PTRACE_GETFPXREGS
 926   if (have_ptrace_getfpxregs == -1)
 927     {
 928       elf_fpxregset_t fpxregs;
 929
 930       if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 931         {
 932           have_ptrace_getfpxregs = 0;
 933           have_ptrace_getregset = 0;
 934           return tdesc_i386_mmx_linux;
 935         }
 936     }
 937 #endif
 938
 939   if (have_ptrace_getregset == -1)
 940     {
 941       uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 942       struct iovec iov;
 943
 944       iov.iov_base = xstateregs;
 945       iov.iov_len = sizeof (xstateregs);
 946
 947       /* Check if PTRACE_GETREGSET works.  */
 948       if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 949                   &iov) < 0)
 950         have_ptrace_getregset = 0;
 951       else
 952         {
 953           have_ptrace_getregset = 1;
 954
 955           /* Get XCR0 from XSAVE extended state.  */
 956           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 957                              / sizeof (long long))];
 958         }
 959     }
 960
 961   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  */
 962   if (have_ptrace_getregset
 963       && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
 964     return tdesc_i386_avx_linux;
 965   else
 966     return tdesc_i386_linux;
 967 }
 968
 969 void
 970 _initialize_i386_linux_nat (void)
 971 {
 972   struct target_ops *t;
 973
 974   /* Fill in the generic GNU/Linux methods.  */
 975   t = linux_target ();
 976
 977   i386_use_watchpoints (t);
 978
 979   i386_dr_low.set_control = i386_linux_dr_set_control;
 980   i386_dr_low.set_addr = i386_linux_dr_set_addr;
 981   i386_dr_low.reset_addr = i386_linux_dr_reset_addr;
 982   i386_dr_low.get_status = i386_linux_dr_get_status;
 983   i386_dr_low.unset_status = i386_linux_dr_unset_status;
 984   i386_set_debug_register_length (4);
 985
 986   /* Override the default ptrace resume method.  */
 987   t->to_resume = i386_linux_resume;
 988
 989   /* Override the GNU/Linux inferior startup hook.  */
 990   super_post_startup_inferior = t->to_post_startup_inferior;
 991   t->to_post_startup_inferior = i386_linux_child_post_startup_inferior;
 992
 993   /* Add our register access methods.  */
 994   t->to_fetch_registers = i386_linux_fetch_inferior_registers;
 995   t->to_store_registers = i386_linux_store_inferior_registers;
 996
 997   t->to_read_description = i386_linux_read_description;
 998
 999   /* Register the target.  */
1000   linux_nat_add_target (t);
1001   linux_nat_set_new_thread (t, i386_linux_new_thread);
1002 }