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