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 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,
 220                           regp + 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,
 243                           regp + 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 fetch_fpregs (struct regcache *regcache, int tid) {}
 356 static void store_fpregs (const struct regcache *regcache, int tid, int regno) {}
 357
 358 #endif
 359 \f
 360
 361 /* Transfering floating-point and SSE registers to and from GDB.  */
 362
 363 /* Fetch all registers covered by the PTRACE_GETREGSET request from
 364    process/thread TID and store their values in GDB's register array.
 365    Return non-zero if successful, zero otherwise.  */
 366
 367 static int
 368 fetch_xstateregs (struct regcache *regcache, int tid)
 369 {
 370   char xstateregs[I386_XSTATE_MAX_SIZE];
 371   struct iovec iov;
 372
 373   if (!have_ptrace_getregset)
 374     return 0;
 375
 376   iov.iov_base = xstateregs;
 377   iov.iov_len = sizeof(xstateregs);
 378   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 379               &iov) < 0)
 380     perror_with_name (_("Couldn't read extended state status"));
 381
 382   i387_supply_xsave (regcache, -1, xstateregs);
 383   return 1;
 384 }
 385
 386 /* Store all valid registers in GDB's register array covered by the
 387    PTRACE_SETREGSET request into the process/thread specified by TID.
 388    Return non-zero if successful, zero otherwise.  */
 389
 390 static int
 391 store_xstateregs (const struct regcache *regcache, int tid, int regno)
 392 {
 393   char xstateregs[I386_XSTATE_MAX_SIZE];
 394   struct iovec iov;
 395
 396   if (!have_ptrace_getregset)
 397     return 0;
 398
 399   iov.iov_base = xstateregs;
 400   iov.iov_len = sizeof(xstateregs);
 401   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 402               &iov) < 0)
 403     perror_with_name (_("Couldn't read extended state status"));
 404
 405   i387_collect_xsave (regcache, regno, xstateregs, 0);
 406
 407   if (ptrace (PTRACE_SETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 408               (int) &iov) < 0)
 409     perror_with_name (_("Couldn't write extended state status"));
 410
 411   return 1;
 412 }
 413
 414 #ifdef HAVE_PTRACE_GETFPXREGS
 415
 416 /* Fill GDB's register array with the floating-point and SSE register
 417    values in *FPXREGSETP.  */
 418
 419 void
 420 supply_fpxregset (struct regcache *regcache,
 421                   const elf_fpxregset_t *fpxregsetp)
 422 {
 423   i387_supply_fxsave (regcache, -1, fpxregsetp);
 424 }
 425
 426 /* Fill register REGNO (if it is a floating-point or SSE register) in
 427    *FPXREGSETP with the value in GDB's register array.  If REGNO is
 428    -1, do this for all registers.  */
 429
 430 void
 431 fill_fpxregset (const struct regcache *regcache,
 432                 elf_fpxregset_t *fpxregsetp, int regno)
 433 {
 434   i387_collect_fxsave (regcache, regno, fpxregsetp);
 435 }
 436
 437 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
 438    process/thread TID and store their values in GDB's register array.
 439    Return non-zero if successful, zero otherwise.  */
 440
 441 static int
 442 fetch_fpxregs (struct regcache *regcache, int tid)
 443 {
 444   elf_fpxregset_t fpxregs;
 445
 446   if (! have_ptrace_getfpxregs)
 447     return 0;
 448
 449   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 450     {
 451       if (errno == EIO)
 452         {
 453           have_ptrace_getfpxregs = 0;
 454           return 0;
 455         }
 456
 457       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 458     }
 459
 460   supply_fpxregset (regcache, (const elf_fpxregset_t *) &fpxregs);
 461   return 1;
 462 }
 463
 464 /* Store all valid registers in GDB's register array covered by the
 465    PTRACE_SETFPXREGS request into the process/thread specified by TID.
 466    Return non-zero if successful, zero otherwise.  */
 467
 468 static int
 469 store_fpxregs (const struct regcache *regcache, int tid, int regno)
 470 {
 471   elf_fpxregset_t fpxregs;
 472
 473   if (! have_ptrace_getfpxregs)
 474     return 0;
 475
 476   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
 477     {
 478       if (errno == EIO)
 479         {
 480           have_ptrace_getfpxregs = 0;
 481           return 0;
 482         }
 483
 484       perror_with_name (_("Couldn't read floating-point and SSE registers"));
 485     }
 486
 487   fill_fpxregset (regcache, &fpxregs, regno);
 488
 489   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
 490     perror_with_name (_("Couldn't write floating-point and SSE registers"));
 491
 492   return 1;
 493 }
 494
 495 #else
 496
 497 static int fetch_fpxregs (struct regcache *regcache, int tid) { return 0; }
 498 static int store_fpxregs (const struct regcache *regcache, int tid, int regno) { return 0; }
 499
 500 #endif /* HAVE_PTRACE_GETFPXREGS */
 501 \f
 502
 503 /* Transferring arbitrary registers between GDB and inferior.  */
 504
 505 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 506    this for all registers (including the floating point and SSE
 507    registers).  */
 508
 509 static void
 510 i386_linux_fetch_inferior_registers (struct target_ops *ops,
 511                                      struct regcache *regcache, int regno)
 512 {
 513   int tid;
 514
 515   /* Use the old method of peeking around in `struct user' if the
 516      GETREGS request isn't available.  */
 517   if (!have_ptrace_getregs)
 518     {
 519       int i;
 520
 521       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 522         if (regno == -1 || regno == i)
 523           fetch_register (regcache, i);
 524
 525       return;
 526     }
 527
 528   /* GNU/Linux LWP ID's are process ID's.  */
 529   tid = TIDGET (inferior_ptid);
 530   if (tid == 0)
 531     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 532
 533   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
 534      transfers more registers in one system call, and we'll cache the
 535      results.  But remember that fetch_fpxregs can fail, and return
 536      zero.  */
 537   if (regno == -1)
 538     {
 539       fetch_regs (regcache, tid);
 540
 541       /* The call above might reset `have_ptrace_getregs'.  */
 542       if (!have_ptrace_getregs)
 543         {
 544           i386_linux_fetch_inferior_registers (ops, regcache, regno);
 545           return;
 546         }
 547
 548       if (fetch_xstateregs (regcache, tid))
 549         return;
 550       if (fetch_fpxregs (regcache, tid))
 551         return;
 552       fetch_fpregs (regcache, tid);
 553       return;
 554     }
 555
 556   if (GETREGS_SUPPLIES (regno))
 557     {
 558       fetch_regs (regcache, tid);
 559       return;
 560     }
 561
 562   if (GETXSTATEREGS_SUPPLIES (regno))
 563     {
 564       if (fetch_xstateregs (regcache, tid))
 565         return;
 566     }
 567
 568   if (GETFPXREGS_SUPPLIES (regno))
 569     {
 570       if (fetch_fpxregs (regcache, tid))
 571         return;
 572
 573       /* Either our processor or our kernel doesn't support the SSE
 574          registers, so read the FP registers in the traditional way,
 575          and fill the SSE registers with dummy values.  It would be
 576          more graceful to handle differences in the register set using
 577          gdbarch.  Until then, this will at least make things work
 578          plausibly.  */
 579       fetch_fpregs (regcache, tid);
 580       return;
 581     }
 582
 583   internal_error (__FILE__, __LINE__,
 584                   _("Got request for bad register number %d."), regno);
 585 }
 586
 587 /* Store register REGNO back into the child process.  If REGNO is -1,
 588    do this for all registers (including the floating point and SSE
 589    registers).  */
 590 static void
 591 i386_linux_store_inferior_registers (struct target_ops *ops,
 592                                      struct regcache *regcache, int regno)
 593 {
 594   int tid;
 595
 596   /* Use the old method of poking around in `struct user' if the
 597      SETREGS request isn't available.  */
 598   if (!have_ptrace_getregs)
 599     {
 600       int i;
 601
 602       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
 603         if (regno == -1 || regno == i)
 604           store_register (regcache, i);
 605
 606       return;
 607     }
 608
 609   /* GNU/Linux LWP ID's are process ID's.  */
 610   tid = TIDGET (inferior_ptid);
 611   if (tid == 0)
 612     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 613
 614   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
 615      transfers more registers in one system call.  But remember that
 616      store_fpxregs can fail, and return zero.  */
 617   if (regno == -1)
 618     {
 619       store_regs (regcache, tid, regno);
 620       if (store_xstateregs (regcache, tid, regno))
 621         return;
 622       if (store_fpxregs (regcache, tid, regno))
 623         return;
 624       store_fpregs (regcache, tid, regno);
 625       return;
 626     }
 627
 628   if (GETREGS_SUPPLIES (regno))
 629     {
 630       store_regs (regcache, tid, regno);
 631       return;
 632     }
 633
 634   if (GETXSTATEREGS_SUPPLIES (regno))
 635     {
 636       if (store_xstateregs (regcache, tid, regno))
 637         return;
 638     }
 639
 640   if (GETFPXREGS_SUPPLIES (regno))
 641     {
 642       if (store_fpxregs (regcache, tid, regno))
 643         return;
 644
 645       /* Either our processor or our kernel doesn't support the SSE
 646          registers, so just write the FP registers in the traditional
 647          way.  */
 648       store_fpregs (regcache, tid, regno);
 649       return;
 650     }
 651
 652   internal_error (__FILE__, __LINE__,
 653                   _("Got request to store bad register number %d."), regno);
 654 }
 655 \f
 656
 657 /* Support for debug registers.  */
 658
 659 static unsigned long i386_linux_dr[DR_CONTROL + 1];
 660
 661 /* Get debug register REGNUM value from only the one LWP of PTID.  */
 662
 663 static unsigned long
 664 i386_linux_dr_get (ptid_t ptid, int regnum)
 665 {
 666   int tid;
 667   unsigned long value;
 668
 669   tid = TIDGET (ptid);
 670   if (tid == 0)
 671     tid = PIDGET (ptid);
 672
 673   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
 674      ptrace call fails breaks debugging remote targets.  The correct
 675      way to fix this is to add the hardware breakpoint and watchpoint
 676      stuff to the target vector.  For now, just return zero if the
 677      ptrace call fails.  */
 678   errno = 0;
 679   value = ptrace (PTRACE_PEEKUSER, tid,
 680                   offsetof (struct user, u_debugreg[regnum]), 0);
 681   if (errno != 0)
 682 #if 0
 683     perror_with_name (_("Couldn't read debug register"));
 684 #else
 685     return 0;
 686 #endif
 687
 688   return value;
 689 }
 690
 691 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
 692
 693 static void
 694 i386_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 695 {
 696   int tid;
 697
 698   tid = TIDGET (ptid);
 699   if (tid == 0)
 700     tid = PIDGET (ptid);
 701
 702   errno = 0;
 703   ptrace (PTRACE_POKEUSER, tid,
 704           offsetof (struct user, u_debugreg[regnum]), value);
 705   if (errno != 0)
 706     perror_with_name (_("Couldn't write debug register"));
 707 }
 708
 709 /* Set DR_CONTROL to ADDR in all LWPs of LWP_LIST.  */
 710
 711 static void
 712 i386_linux_dr_set_control (unsigned long control)
 713 {
 714   struct lwp_info *lp;
 715   ptid_t ptid;
 716
 717   i386_linux_dr[DR_CONTROL] = control;
 718   ALL_LWPS (lp, ptid)
 719     i386_linux_dr_set (ptid, DR_CONTROL, control);
 720 }
 721
 722 /* Set address REGNUM (zero based) to ADDR in all LWPs of LWP_LIST.  */
 723
 724 static void
 725 i386_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 726 {
 727   struct lwp_info *lp;
 728   ptid_t ptid;
 729
 730   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 731
 732   i386_linux_dr[DR_FIRSTADDR + regnum] = addr;
 733   ALL_LWPS (lp, ptid)
 734     i386_linux_dr_set (ptid, DR_FIRSTADDR + regnum, addr);
 735 }
 736
 737 /* Set address REGNUM (zero based) to zero in all LWPs of LWP_LIST.  */
 738
 739 static void
 740 i386_linux_dr_reset_addr (int regnum)
 741 {
 742   i386_linux_dr_set_addr (regnum, 0);
 743 }
 744
 745 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 746
 747 static unsigned long
 748 i386_linux_dr_get_status (void)
 749 {
 750   return i386_linux_dr_get (inferior_ptid, DR_STATUS);
 751 }
 752
 753 /* Unset MASK bits in DR_STATUS in all LWPs of LWP_LIST.  */
 754
 755 static void
 756 i386_linux_dr_unset_status (unsigned long mask)
 757 {
 758   struct lwp_info *lp;
 759   ptid_t ptid;
 760
 761   ALL_LWPS (lp, ptid)
 762     {
 763       unsigned long value;
 764
 765       value = i386_linux_dr_get (ptid, DR_STATUS);
 766       value &= ~mask;
 767       i386_linux_dr_set (ptid, DR_STATUS, value);
 768     }
 769 }
 770
 771 static void
 772 i386_linux_new_thread (ptid_t ptid)
 773 {
 774   int i;
 775
 776   for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 777     i386_linux_dr_set (ptid, i, i386_linux_dr[i]);
 778
 779   i386_linux_dr_set (ptid, DR_CONTROL, i386_linux_dr[DR_CONTROL]);
 780 }
 781 \f
 782
 783 /* Called by libthread_db.  Returns a pointer to the thread local
 784    storage (or its descriptor).  */
 785
 786 ps_err_e
 787 ps_get_thread_area (const struct ps_prochandle *ph,
 788                     lwpid_t lwpid, int idx, void **base)
 789 {
 790   /* NOTE: cagney/2003-08-26: The definition of this buffer is found
 791      in the kernel header <asm-i386/ldt.h>.  It, after padding, is 4 x
 792      4 byte integers in size: `entry_number', `base_addr', `limit',
 793      and a bunch of status bits.
 794
 795      The values returned by this ptrace call should be part of the
 796      regcache buffer, and ps_get_thread_area should channel its
 797      request through the regcache.  That way remote targets could
 798      provide the value using the remote protocol and not this direct
 799      call.
 800
 801      Is this function needed?  I'm guessing that the `base' is the
 802      address of a a descriptor that libthread_db uses to find the
 803      thread local address base that GDB needs.  Perhaps that
 804      descriptor is defined by the ABI.  Anyway, given that
 805      libthread_db calls this function without prompting (gdb
 806      requesting tls base) I guess it needs info in there anyway.  */
 807   unsigned int desc[4];
 808   gdb_assert (sizeof (int) == 4);
 809
 810 #ifndef PTRACE_GET_THREAD_AREA
 811 #define PTRACE_GET_THREAD_AREA 25
 812 #endif
 813
 814   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid,
 815               (void *) idx, (unsigned long) &desc) < 0)
 816     return PS_ERR;
 817
 818   *(int *)base = desc[1];
 819   return PS_OK;
 820 }
 821 \f
 822
 823 /* The instruction for a GNU/Linux system call is:
 824        int $0x80
 825    or 0xcd 0x80.  */
 826
 827 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
 828
 829 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 830
 831 /* The system call number is stored in the %eax register.  */
 832 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
 833
 834 /* We are specifically interested in the sigreturn and rt_sigreturn
 835    system calls.  */
 836
 837 #ifndef SYS_sigreturn
 838 #define SYS_sigreturn           0x77
 839 #endif
 840 #ifndef SYS_rt_sigreturn
 841 #define SYS_rt_sigreturn        0xad
 842 #endif
 843
 844 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 845 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
 846
 847 /* Resume execution of the inferior process.
 848    If STEP is nonzero, single-step it.
 849    If SIGNAL is nonzero, give it that signal.  */
 850
 851 static void
 852 i386_linux_resume (struct target_ops *ops,
 853                    ptid_t ptid, int step, enum target_signal signal)
 854 {
 855   int pid = PIDGET (ptid);
 856
 857   int request;
 858
 859   if (catch_syscall_enabled () > 0)
 860    request = PTRACE_SYSCALL;
 861   else
 862     request = PTRACE_CONT;
 863
 864   if (step)
 865     {
 866       struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid));
 867       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 868       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 869       ULONGEST pc;
 870       gdb_byte buf[LINUX_SYSCALL_LEN];
 871
 872       request = PTRACE_SINGLESTEP;
 873
 874       regcache_cooked_read_unsigned (regcache,
 875                                      gdbarch_pc_regnum (gdbarch), &pc);
 876
 877       /* Returning from a signal trampoline is done by calling a
 878          special system call (sigreturn or rt_sigreturn, see
 879          i386-linux-tdep.c for more information).  This system call
 880          restores the registers that were saved when the signal was
 881          raised, including %eflags.  That means that single-stepping
 882          won't work.  Instead, we'll have to modify the signal context
 883          that's about to be restored, and set the trace flag there.  */
 884
 885       /* First check if PC is at a system call.  */
 886       if (target_read_memory (pc, buf, LINUX_SYSCALL_LEN) == 0
 887           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 888         {
 889           ULONGEST syscall;
 890           regcache_cooked_read_unsigned (regcache,
 891                                          LINUX_SYSCALL_REGNUM, &syscall);
 892
 893           /* Then check the system call number.  */
 894           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
 895             {
 896               ULONGEST sp, addr;
 897               unsigned long int eflags;
 898
 899               regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp);
 900               if (syscall == SYS_rt_sigreturn)
 901                 addr = read_memory_integer (sp + 8, 4, byte_order) + 20;
 902               else
 903                 addr = sp;
 904
 905               /* Set the trace flag in the context that's about to be
 906                  restored.  */
 907               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 908               read_memory (addr, (gdb_byte *) &eflags, 4);
 909               eflags |= 0x0100;
 910               write_memory (addr, (gdb_byte *) &eflags, 4);
 911             }
 912         }
 913     }
 914
 915   if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
 916     perror_with_name (("ptrace"));
 917 }
 918
 919 static void (*super_post_startup_inferior) (ptid_t ptid);
 920
 921 static void
 922 i386_linux_child_post_startup_inferior (ptid_t ptid)
 923 {
 924   i386_cleanup_dregs ();
 925   super_post_startup_inferior (ptid);
 926 }
 927
 928 /* Get Linux/x86 target description from running target.  */
 929
 930 static const struct target_desc *
 931 i386_linux_read_description (struct target_ops *ops)
 932 {
 933   int tid;
 934   static uint64_t xcr0;
 935
 936   /* GNU/Linux LWP ID's are process ID's.  */
 937   tid = TIDGET (inferior_ptid);
 938   if (tid == 0)
 939     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 940
 941 #ifdef HAVE_PTRACE_GETFPXREGS
 942   if (have_ptrace_getfpxregs == -1)
 943     {
 944       elf_fpxregset_t fpxregs;
 945
 946       if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
 947         {
 948           have_ptrace_getfpxregs = 0;
 949           have_ptrace_getregset = 0;
 950           return tdesc_i386_mmx_linux;
 951         }
 952     }
 953 #endif
 954
 955   if (have_ptrace_getregset == -1)
 956     {
 957       uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 958       struct iovec iov;
 959
 960       iov.iov_base = xstateregs;
 961       iov.iov_len = sizeof (xstateregs);
 962
 963       /* Check if PTRACE_GETREGSET works.  */
 964       if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
 965                   &iov) < 0)
 966         have_ptrace_getregset = 0;
 967       else
 968         {
 969           have_ptrace_getregset = 1;
 970
 971           /* Get XCR0 from XSAVE extended state.  */
 972           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 973                              / sizeof (long long))];
 974         }
 975     }
 976
 977   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  */
 978   if (have_ptrace_getregset
 979       && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
 980     return tdesc_i386_avx_linux;
 981   else
 982     return tdesc_i386_linux;
 983 }
 984
 985 void
 986 _initialize_i386_linux_nat (void)
 987 {
 988   struct target_ops *t;
 989
 990   /* Fill in the generic GNU/Linux methods.  */
 991   t = linux_target ();
 992
 993   i386_use_watchpoints (t);
 994
 995   i386_dr_low.set_control = i386_linux_dr_set_control;
 996   i386_dr_low.set_addr = i386_linux_dr_set_addr;
 997   i386_dr_low.reset_addr = i386_linux_dr_reset_addr;
 998   i386_dr_low.get_status = i386_linux_dr_get_status;
 999   i386_dr_low.unset_status = i386_linux_dr_unset_status;
1000   i386_set_debug_register_length (4);
1001
1002   /* Override the default ptrace resume method.  */
1003   t->to_resume = i386_linux_resume;
1004
1005   /* Override the GNU/Linux inferior startup hook.  */
1006   super_post_startup_inferior = t->to_post_startup_inferior;
1007   t->to_post_startup_inferior = i386_linux_child_post_startup_inferior;
1008
1009   /* Add our register access methods.  */
1010   t->to_fetch_registers = i386_linux_fetch_inferior_registers;
1011   t->to_store_registers = i386_linux_store_inferior_registers;
1012
1013   t->to_read_description = i386_linux_read_description;
1014
1015   /* Register the target.  */
1016   linux_nat_add_target (t);
1017   linux_nat_set_new_thread (t, i386_linux_new_thread);
1018 }