gdb/amd64-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86-64.
   2
   3    Copyright (C) 2001-2012 Free Software Foundation, Inc.
   4    Contributed by Jiri Smid, SuSE Labs.
   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 "inferior.h"
  23 #include "gdbcore.h"
  24 #include "regcache.h"
  25 #include "regset.h"
  26 #include "linux-nat.h"
  27 #include "amd64-linux-tdep.h"
  28
  29 #include "gdb_assert.h"
  30 #include "gdb_string.h"
  31 #include "elf/common.h"
  32 #include <sys/uio.h>
  33 #include <sys/ptrace.h>
  34 #include <sys/debugreg.h>
  35 #include <sys/syscall.h>
  36 #include <sys/procfs.h>
  37 #include <sys/user.h>
  38 #include <asm/prctl.h>
  39 /* FIXME ezannoni-2003-07-09: we need <sys/reg.h> to be included after
  40    <asm/ptrace.h> because the latter redefines FS and GS for no apparent
  41    reason, and those definitions don't match the ones that libpthread_db
  42    uses, which come from <sys/reg.h>.  */
  43 /* ezannoni-2003-07-09: I think this is fixed.  The extraneous defs have
  44    been removed from ptrace.h in the kernel.  However, better safe than
  45    sorry.  */
  46 #include <asm/ptrace.h>
  47 #include <sys/reg.h>
  48 #include "gdb_proc_service.h"
  49
  50 /* Prototypes for supply_gregset etc.  */
  51 #include "gregset.h"
  52
  53 #include "amd64-tdep.h"
  54 #include "i386-linux-tdep.h"
  55 #include "amd64-nat.h"
  56 #include "i386-nat.h"
  57 #include "i386-xstate.h"
  58
  59 #ifndef PTRACE_GETREGSET
  60 #define PTRACE_GETREGSET        0x4204
  61 #endif
  62
  63 #ifndef PTRACE_SETREGSET
  64 #define PTRACE_SETREGSET        0x4205
  65 #endif
  66
  67 /* Per-thread arch-specific data we want to keep.  */
  68
  69 struct arch_lwp_info
  70 {
  71   /* Non-zero if our copy differs from what's recorded in the thread.  */
  72   int debug_registers_changed;
  73 };
  74
  75 /* Does the current host support PTRACE_GETREGSET?  */
  76 static int have_ptrace_getregset = -1;
  77
  78 /* Mapping between the general-purpose registers in GNU/Linux x86-64
  79    `struct user' format and GDB's register cache layout for GNU/Linux
  80    i386.
  81
  82    Note that most GNU/Linux x86-64 registers are 64-bit, while the
  83    GNU/Linux i386 registers are all 32-bit, but since we're
  84    little-endian we get away with that.  */
  85
  86 /* From <sys/reg.h> on GNU/Linux i386.  */
  87 static int amd64_linux_gregset32_reg_offset[] =
  88 {
  89   RAX * 8, RCX * 8,             /* %eax, %ecx */
  90   RDX * 8, RBX * 8,             /* %edx, %ebx */
  91   RSP * 8, RBP * 8,             /* %esp, %ebp */
  92   RSI * 8, RDI * 8,             /* %esi, %edi */
  93   RIP * 8, EFLAGS * 8,          /* %eip, %eflags */
  94   CS * 8, SS * 8,               /* %cs, %ss */
  95   DS * 8, ES * 8,               /* %ds, %es */
  96   FS * 8, GS * 8,               /* %fs, %gs */
  97   -1, -1, -1, -1, -1, -1, -1, -1,
  98   -1, -1, -1, -1, -1, -1, -1, -1,
  99   -1, -1, -1, -1, -1, -1, -1, -1, -1,
 100   -1, -1, -1, -1, -1, -1, -1, -1,
 101   ORIG_RAX * 8                  /* "orig_eax" */
 102 };
 103 \f
 104
 105 /* Transfering the general-purpose registers between GDB, inferiors
 106    and core files.  */
 107
 108 /* Fill GDB's register cache with the general-purpose register values
 109    in *GREGSETP.  */
 110
 111 void
 112 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 113 {
 114   amd64_supply_native_gregset (regcache, gregsetp, -1);
 115 }
 116
 117 /* Fill register REGNUM (if it is a general-purpose register) in
 118    *GREGSETP with the value in GDB's register cache.  If REGNUM is -1,
 119    do this for all registers.  */
 120
 121 void
 122 fill_gregset (const struct regcache *regcache,
 123               elf_gregset_t *gregsetp, int regnum)
 124 {
 125   amd64_collect_native_gregset (regcache, gregsetp, regnum);
 126 }
 127
 128 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 129
 130 /* Fill GDB's register cache with the floating-point and SSE register
 131    values in *FPREGSETP.  */
 132
 133 void
 134 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 135 {
 136   amd64_supply_fxsave (regcache, -1, fpregsetp);
 137 }
 138
 139 /* Fill register REGNUM (if it is a floating-point or SSE register) in
 140    *FPREGSETP with the value in GDB's register cache.  If REGNUM is
 141    -1, do this for all registers.  */
 142
 143 void
 144 fill_fpregset (const struct regcache *regcache,
 145                elf_fpregset_t *fpregsetp, int regnum)
 146 {
 147   amd64_collect_fxsave (regcache, regnum, fpregsetp);
 148 }
 149 \f
 150
 151 /* Transferring arbitrary registers between GDB and inferior.  */
 152
 153 /* Fetch register REGNUM from the child process.  If REGNUM is -1, do
 154    this for all registers (including the floating point and SSE
 155    registers).  */
 156
 157 static void
 158 amd64_linux_fetch_inferior_registers (struct target_ops *ops,
 159                                       struct regcache *regcache, int regnum)
 160 {
 161   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 162   int tid;
 163
 164   /* GNU/Linux LWP ID's are process ID's.  */
 165   tid = TIDGET (inferior_ptid);
 166   if (tid == 0)
 167     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 168
 169   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
 170     {
 171       elf_gregset_t regs;
 172
 173       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 174         perror_with_name (_("Couldn't get registers"));
 175
 176       amd64_supply_native_gregset (regcache, &regs, -1);
 177       if (regnum != -1)
 178         return;
 179     }
 180
 181   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
 182     {
 183       elf_fpregset_t fpregs;
 184
 185       if (have_ptrace_getregset)
 186         {
 187           char xstateregs[I386_XSTATE_MAX_SIZE];
 188           struct iovec iov;
 189
 190           iov.iov_base = xstateregs;
 191           iov.iov_len = sizeof (xstateregs);
 192           if (ptrace (PTRACE_GETREGSET, tid,
 193                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 194             perror_with_name (_("Couldn't get extended state status"));
 195
 196           amd64_supply_xsave (regcache, -1, xstateregs);
 197         }
 198       else
 199         {
 200           if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 201             perror_with_name (_("Couldn't get floating point status"));
 202
 203           amd64_supply_fxsave (regcache, -1, &fpregs);
 204         }
 205     }
 206 }
 207
 208 /* Store register REGNUM back into the child process.  If REGNUM is
 209    -1, do this for all registers (including the floating-point and SSE
 210    registers).  */
 211
 212 static void
 213 amd64_linux_store_inferior_registers (struct target_ops *ops,
 214                                       struct regcache *regcache, int regnum)
 215 {
 216   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 217   int tid;
 218
 219   /* GNU/Linux LWP ID's are process ID's.  */
 220   tid = TIDGET (inferior_ptid);
 221   if (tid == 0)
 222     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 223
 224   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
 225     {
 226       elf_gregset_t regs;
 227
 228       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 229         perror_with_name (_("Couldn't get registers"));
 230
 231       amd64_collect_native_gregset (regcache, &regs, regnum);
 232
 233       if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
 234         perror_with_name (_("Couldn't write registers"));
 235
 236       if (regnum != -1)
 237         return;
 238     }
 239
 240   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
 241     {
 242       elf_fpregset_t fpregs;
 243
 244       if (have_ptrace_getregset)
 245         {
 246           char xstateregs[I386_XSTATE_MAX_SIZE];
 247           struct iovec iov;
 248
 249           iov.iov_base = xstateregs;
 250           iov.iov_len = sizeof (xstateregs);
 251           if (ptrace (PTRACE_GETREGSET, tid,
 252                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 253             perror_with_name (_("Couldn't get extended state status"));
 254
 255           amd64_collect_xsave (regcache, regnum, xstateregs, 0);
 256
 257           if (ptrace (PTRACE_SETREGSET, tid,
 258                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 259             perror_with_name (_("Couldn't write extended state status"));
 260         }
 261       else
 262         {
 263           if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 264             perror_with_name (_("Couldn't get floating point status"));
 265
 266           amd64_collect_fxsave (regcache, regnum, &fpregs);
 267
 268           if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
 269             perror_with_name (_("Couldn't write floating point status"));
 270         }
 271     }
 272 }
 273 \f
 274 /* Support for debug registers.  */
 275
 276 static unsigned long
 277 amd64_linux_dr_get (ptid_t ptid, int regnum)
 278 {
 279   int tid;
 280   unsigned long value;
 281
 282   tid = TIDGET (ptid);
 283   if (tid == 0)
 284     tid = PIDGET (ptid);
 285
 286   errno = 0;
 287   value = ptrace (PTRACE_PEEKUSER, tid,
 288                   offsetof (struct user, u_debugreg[regnum]), 0);
 289   if (errno != 0)
 290     perror_with_name (_("Couldn't read debug register"));
 291
 292   return value;
 293 }
 294
 295 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
 296
 297 static void
 298 amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 299 {
 300   int tid;
 301
 302   tid = TIDGET (ptid);
 303   if (tid == 0)
 304     tid = PIDGET (ptid);
 305
 306   errno = 0;
 307   ptrace (PTRACE_POKEUSER, tid,
 308           offsetof (struct user, u_debugreg[regnum]), value);
 309   if (errno != 0)
 310     perror_with_name (_("Couldn't write debug register"));
 311 }
 312
 313 /* Return the inferior's debug register REGNUM.  */
 314
 315 static CORE_ADDR
 316 amd64_linux_dr_get_addr (int regnum)
 317 {
 318   /* DR6 and DR7 are retrieved with some other way.  */
 319   gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
 320
 321   return amd64_linux_dr_get (inferior_ptid, regnum);
 322 }
 323
 324 /* Return the inferior's DR7 debug control register.  */
 325
 326 static unsigned long
 327 amd64_linux_dr_get_control (void)
 328 {
 329   return amd64_linux_dr_get (inferior_ptid, DR_CONTROL);
 330 }
 331
 332 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 333
 334 static unsigned long
 335 amd64_linux_dr_get_status (void)
 336 {
 337   return amd64_linux_dr_get (inferior_ptid, DR_STATUS);
 338 }
 339
 340 /* Callback for linux_nat_iterate_watchpoint_lwps.  Update the debug registers
 341    of LWP.  */
 342
 343 static int
 344 update_debug_registers_callback (struct lwp_info *lwp, void *arg)
 345 {
 346   if (lwp->arch_private == NULL)
 347     lwp->arch_private = XCNEW (struct arch_lwp_info);
 348
 349   /* The actual update is done later just before resuming the lwp, we
 350      just mark that the registers need updating.  */
 351   lwp->arch_private->debug_registers_changed = 1;
 352
 353   /* If the lwp isn't stopped, force it to momentarily pause, so we
 354      can update its debug registers.  */
 355   if (!lwp->stopped)
 356     linux_stop_lwp (lwp);
 357
 358   /* Continue the iteration.  */
 359   return 0;
 360 }
 361
 362 /* Set DR_CONTROL to CONTROL in all LWPs of the current inferior.  */
 363
 364 static void
 365 amd64_linux_dr_set_control (unsigned long control)
 366 {
 367   linux_nat_iterate_watchpoint_lwps (update_debug_registers_callback, NULL);
 368 }
 369
 370 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
 371    inferior.  */
 372
 373 static void
 374 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 375 {
 376   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 377
 378   linux_nat_iterate_watchpoint_lwps (update_debug_registers_callback, NULL);
 379 }
 380
 381 /* Called when resuming a thread.
 382    If the debug regs have changed, update the thread's copies.  */
 383
 384 static void
 385 amd64_linux_prepare_to_resume (struct lwp_info *lwp)
 386 {
 387   int clear_status = 0;
 388
 389   /* NULL means this is the main thread still going through the shell,
 390      or, no watchpoint has been set yet.  In that case, there's
 391      nothing to do.  */
 392   if (lwp->arch_private == NULL)
 393     return;
 394
 395   if (lwp->arch_private->debug_registers_changed)
 396     {
 397       struct i386_debug_reg_state *state = i386_debug_reg_state ();
 398       int i;
 399
 400       /* On Linux kernel before 2.6.33 commit
 401          72f674d203cd230426437cdcf7dd6f681dad8b0d
 402          if you enable a breakpoint by the DR_CONTROL bits you need to have
 403          already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
 404
 405          Ensure DR_CONTROL gets written as the very last register here.  */
 406
 407       for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 408         if (state->dr_ref_count[i] > 0)
 409           {
 410             amd64_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
 411
 412             /* If we're setting a watchpoint, any change the inferior
 413                had done itself to the debug registers needs to be
 414                discarded, otherwise, i386_stopped_data_address can get
 415                confused.  */
 416             clear_status = 1;
 417           }
 418
 419       amd64_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
 420
 421       lwp->arch_private->debug_registers_changed = 0;
 422     }
 423
 424   if (clear_status || lwp->stopped_by_watchpoint)
 425     amd64_linux_dr_set (lwp->ptid, DR_STATUS, 0);
 426 }
 427
 428 static void
 429 amd64_linux_new_thread (struct lwp_info *lp)
 430 {
 431   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
 432
 433   info->debug_registers_changed = 1;
 434
 435   lp->arch_private = info;
 436 }
 437 \f
 438
 439 /* This function is called by libthread_db as part of its handling of
 440    a request for a thread's local storage address.  */
 441
 442 ps_err_e
 443 ps_get_thread_area (const struct ps_prochandle *ph,
 444                     lwpid_t lwpid, int idx, void **base)
 445 {
 446   if (gdbarch_bfd_arch_info (target_gdbarch)->bits_per_word == 32)
 447     {
 448       /* The full structure is found in <asm-i386/ldt.h>.  The second
 449          integer is the LDT's base_address and that is used to locate
 450          the thread's local storage.  See i386-linux-nat.c more
 451          info.  */
 452       unsigned int desc[4];
 453
 454       /* This code assumes that "int" is 32 bits and that
 455          GET_THREAD_AREA returns no more than 4 int values.  */
 456       gdb_assert (sizeof (int) == 4);
 457 #ifndef PTRACE_GET_THREAD_AREA
 458 #define PTRACE_GET_THREAD_AREA 25
 459 #endif
 460       if  (ptrace (PTRACE_GET_THREAD_AREA,
 461                    lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
 462         return PS_ERR;
 463
 464       /* Extend the value to 64 bits.  Here it's assumed that a "long"
 465          and a "void *" are the same.  */
 466       (*base) = (void *) (long) desc[1];
 467       return PS_OK;
 468     }
 469   else
 470     {
 471       /* This definition comes from prctl.h, but some kernels may not
 472          have it.  */
 473 #ifndef PTRACE_ARCH_PRCTL
 474 #define PTRACE_ARCH_PRCTL      30
 475 #endif
 476       /* FIXME: ezannoni-2003-07-09 see comment above about include
 477          file order.  We could be getting bogus values for these two.  */
 478       gdb_assert (FS < ELF_NGREG);
 479       gdb_assert (GS < ELF_NGREG);
 480       switch (idx)
 481         {
 482         case FS:
 483 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
 484             {
 485               /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the
 486                  fs_base and gs_base fields of user_regs_struct can be
 487                  used directly.  */
 488               unsigned long fs;
 489               errno = 0;
 490               fs = ptrace (PTRACE_PEEKUSER, lwpid,
 491                            offsetof (struct user_regs_struct, fs_base), 0);
 492               if (errno == 0)
 493                 {
 494                   *base = (void *) fs;
 495                   return PS_OK;
 496                 }
 497             }
 498 #endif
 499           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 500             return PS_OK;
 501           break;
 502         case GS:
 503 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE
 504             {
 505               unsigned long gs;
 506               errno = 0;
 507               gs = ptrace (PTRACE_PEEKUSER, lwpid,
 508                            offsetof (struct user_regs_struct, gs_base), 0);
 509               if (errno == 0)
 510                 {
 511                   *base = (void *) gs;
 512                   return PS_OK;
 513                 }
 514             }
 515 #endif
 516           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 517             return PS_OK;
 518           break;
 519         default:                   /* Should not happen.  */
 520           return PS_BADADDR;
 521         }
 522     }
 523   return PS_ERR;               /* ptrace failed.  */
 524 }
 525 \f
 526
 527 static void (*super_post_startup_inferior) (ptid_t ptid);
 528
 529 static void
 530 amd64_linux_child_post_startup_inferior (ptid_t ptid)
 531 {
 532   i386_cleanup_dregs ();
 533   super_post_startup_inferior (ptid);
 534 }
 535 \f
 536
 537 /* When GDB is built as a 64-bit application on linux, the
 538    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
 539    debugging a 32-bit inferior with a 64-bit GDB should look the same
 540    as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
 541    conversion in-place ourselves.  */
 542
 543 /* These types below (compat_*) define a siginfo type that is layout
 544    compatible with the siginfo type exported by the 32-bit userspace
 545    support.  */
 546
 547 typedef int compat_int_t;
 548 typedef unsigned int compat_uptr_t;
 549
 550 typedef int compat_time_t;
 551 typedef int compat_timer_t;
 552 typedef int compat_clock_t;
 553
 554 struct compat_timeval
 555 {
 556   compat_time_t tv_sec;
 557   int tv_usec;
 558 };
 559
 560 typedef union compat_sigval
 561 {
 562   compat_int_t sival_int;
 563   compat_uptr_t sival_ptr;
 564 } compat_sigval_t;
 565
 566 typedef struct compat_siginfo
 567 {
 568   int si_signo;
 569   int si_errno;
 570   int si_code;
 571
 572   union
 573   {
 574     int _pad[((128 / sizeof (int)) - 3)];
 575
 576     /* kill() */
 577     struct
 578     {
 579       unsigned int _pid;
 580       unsigned int _uid;
 581     } _kill;
 582
 583     /* POSIX.1b timers */
 584     struct
 585     {
 586       compat_timer_t _tid;
 587       int _overrun;
 588       compat_sigval_t _sigval;
 589     } _timer;
 590
 591     /* POSIX.1b signals */
 592     struct
 593     {
 594       unsigned int _pid;
 595       unsigned int _uid;
 596       compat_sigval_t _sigval;
 597     } _rt;
 598
 599     /* SIGCHLD */
 600     struct
 601     {
 602       unsigned int _pid;
 603       unsigned int _uid;
 604       int _status;
 605       compat_clock_t _utime;
 606       compat_clock_t _stime;
 607     } _sigchld;
 608
 609     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 610     struct
 611     {
 612       unsigned int _addr;
 613     } _sigfault;
 614
 615     /* SIGPOLL */
 616     struct
 617     {
 618       int _band;
 619       int _fd;
 620     } _sigpoll;
 621   } _sifields;
 622 } compat_siginfo_t;
 623
 624 /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes.  */
 625 typedef struct compat_x32_clock
 626 {
 627   int lower;
 628   int upper;
 629 } compat_x32_clock_t;
 630
 631 typedef struct compat_x32_siginfo
 632 {
 633   int si_signo;
 634   int si_errno;
 635   int si_code;
 636
 637   union
 638   {
 639     int _pad[((128 / sizeof (int)) - 3)];
 640
 641     /* kill() */
 642     struct
 643     {
 644       unsigned int _pid;
 645       unsigned int _uid;
 646     } _kill;
 647
 648     /* POSIX.1b timers */
 649     struct
 650     {
 651       compat_timer_t _tid;
 652       int _overrun;
 653       compat_sigval_t _sigval;
 654     } _timer;
 655
 656     /* POSIX.1b signals */
 657     struct
 658     {
 659       unsigned int _pid;
 660       unsigned int _uid;
 661       compat_sigval_t _sigval;
 662     } _rt;
 663
 664     /* SIGCHLD */
 665     struct
 666     {
 667       unsigned int _pid;
 668       unsigned int _uid;
 669       int _status;
 670       compat_x32_clock_t _utime;
 671       compat_x32_clock_t _stime;
 672     } _sigchld;
 673
 674     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 675     struct
 676     {
 677       unsigned int _addr;
 678     } _sigfault;
 679
 680     /* SIGPOLL */
 681     struct
 682     {
 683       int _band;
 684       int _fd;
 685     } _sigpoll;
 686   } _sifields;
 687 } compat_x32_siginfo_t;
 688
 689 #define cpt_si_pid _sifields._kill._pid
 690 #define cpt_si_uid _sifields._kill._uid
 691 #define cpt_si_timerid _sifields._timer._tid
 692 #define cpt_si_overrun _sifields._timer._overrun
 693 #define cpt_si_status _sifields._sigchld._status
 694 #define cpt_si_utime _sifields._sigchld._utime
 695 #define cpt_si_stime _sifields._sigchld._stime
 696 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
 697 #define cpt_si_addr _sifields._sigfault._addr
 698 #define cpt_si_band _sifields._sigpoll._band
 699 #define cpt_si_fd _sifields._sigpoll._fd
 700
 701 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
 702    In their place is si_timer1,si_timer2.  */
 703 #ifndef si_timerid
 704 #define si_timerid si_timer1
 705 #endif
 706 #ifndef si_overrun
 707 #define si_overrun si_timer2
 708 #endif
 709
 710 static void
 711 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
 712 {
 713   memset (to, 0, sizeof (*to));
 714
 715   to->si_signo = from->si_signo;
 716   to->si_errno = from->si_errno;
 717   to->si_code = from->si_code;
 718
 719   if (to->si_code == SI_TIMER)
 720     {
 721       to->cpt_si_timerid = from->si_timerid;
 722       to->cpt_si_overrun = from->si_overrun;
 723       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 724     }
 725   else if (to->si_code == SI_USER)
 726     {
 727       to->cpt_si_pid = from->si_pid;
 728       to->cpt_si_uid = from->si_uid;
 729     }
 730   else if (to->si_code < 0)
 731     {
 732       to->cpt_si_pid = from->si_pid;
 733       to->cpt_si_uid = from->si_uid;
 734       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 735     }
 736   else
 737     {
 738       switch (to->si_signo)
 739         {
 740         case SIGCHLD:
 741           to->cpt_si_pid = from->si_pid;
 742           to->cpt_si_uid = from->si_uid;
 743           to->cpt_si_status = from->si_status;
 744           to->cpt_si_utime = from->si_utime;
 745           to->cpt_si_stime = from->si_stime;
 746           break;
 747         case SIGILL:
 748         case SIGFPE:
 749         case SIGSEGV:
 750         case SIGBUS:
 751           to->cpt_si_addr = (intptr_t) from->si_addr;
 752           break;
 753         case SIGPOLL:
 754           to->cpt_si_band = from->si_band;
 755           to->cpt_si_fd = from->si_fd;
 756           break;
 757         default:
 758           to->cpt_si_pid = from->si_pid;
 759           to->cpt_si_uid = from->si_uid;
 760           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 761           break;
 762         }
 763     }
 764 }
 765
 766 static void
 767 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
 768 {
 769   memset (to, 0, sizeof (*to));
 770
 771   to->si_signo = from->si_signo;
 772   to->si_errno = from->si_errno;
 773   to->si_code = from->si_code;
 774
 775   if (to->si_code == SI_TIMER)
 776     {
 777       to->si_timerid = from->cpt_si_timerid;
 778       to->si_overrun = from->cpt_si_overrun;
 779       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 780     }
 781   else if (to->si_code == SI_USER)
 782     {
 783       to->si_pid = from->cpt_si_pid;
 784       to->si_uid = from->cpt_si_uid;
 785     }
 786   if (to->si_code < 0)
 787     {
 788       to->si_pid = from->cpt_si_pid;
 789       to->si_uid = from->cpt_si_uid;
 790       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 791     }
 792   else
 793     {
 794       switch (to->si_signo)
 795         {
 796         case SIGCHLD:
 797           to->si_pid = from->cpt_si_pid;
 798           to->si_uid = from->cpt_si_uid;
 799           to->si_status = from->cpt_si_status;
 800           to->si_utime = from->cpt_si_utime;
 801           to->si_stime = from->cpt_si_stime;
 802           break;
 803         case SIGILL:
 804         case SIGFPE:
 805         case SIGSEGV:
 806         case SIGBUS:
 807           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 808           break;
 809         case SIGPOLL:
 810           to->si_band = from->cpt_si_band;
 811           to->si_fd = from->cpt_si_fd;
 812           break;
 813         default:
 814           to->si_pid = from->cpt_si_pid;
 815           to->si_uid = from->cpt_si_uid;
 816           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 817           break;
 818         }
 819     }
 820 }
 821
 822 static void
 823 compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
 824                                  siginfo_t *from)
 825 {
 826   memset (to, 0, sizeof (*to));
 827
 828   to->si_signo = from->si_signo;
 829   to->si_errno = from->si_errno;
 830   to->si_code = from->si_code;
 831
 832   if (to->si_code == SI_TIMER)
 833     {
 834       to->cpt_si_timerid = from->si_timerid;
 835       to->cpt_si_overrun = from->si_overrun;
 836       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 837     }
 838   else if (to->si_code == SI_USER)
 839     {
 840       to->cpt_si_pid = from->si_pid;
 841       to->cpt_si_uid = from->si_uid;
 842     }
 843   else if (to->si_code < 0)
 844     {
 845       to->cpt_si_pid = from->si_pid;
 846       to->cpt_si_uid = from->si_uid;
 847       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 848     }
 849   else
 850     {
 851       switch (to->si_signo)
 852         {
 853         case SIGCHLD:
 854           to->cpt_si_pid = from->si_pid;
 855           to->cpt_si_uid = from->si_uid;
 856           to->cpt_si_status = from->si_status;
 857           memcpy (&to->cpt_si_utime, &from->si_utime,
 858                   sizeof (to->cpt_si_utime));
 859           memcpy (&to->cpt_si_stime, &from->si_stime,
 860                   sizeof (to->cpt_si_stime));
 861           break;
 862         case SIGILL:
 863         case SIGFPE:
 864         case SIGSEGV:
 865         case SIGBUS:
 866           to->cpt_si_addr = (intptr_t) from->si_addr;
 867           break;
 868         case SIGPOLL:
 869           to->cpt_si_band = from->si_band;
 870           to->cpt_si_fd = from->si_fd;
 871           break;
 872         default:
 873           to->cpt_si_pid = from->si_pid;
 874           to->cpt_si_uid = from->si_uid;
 875           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 876           break;
 877         }
 878     }
 879 }
 880
 881 static void
 882 siginfo_from_compat_x32_siginfo (siginfo_t *to,
 883                                  compat_x32_siginfo_t *from)
 884 {
 885   memset (to, 0, sizeof (*to));
 886
 887   to->si_signo = from->si_signo;
 888   to->si_errno = from->si_errno;
 889   to->si_code = from->si_code;
 890
 891   if (to->si_code == SI_TIMER)
 892     {
 893       to->si_timerid = from->cpt_si_timerid;
 894       to->si_overrun = from->cpt_si_overrun;
 895       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 896     }
 897   else if (to->si_code == SI_USER)
 898     {
 899       to->si_pid = from->cpt_si_pid;
 900       to->si_uid = from->cpt_si_uid;
 901     }
 902   if (to->si_code < 0)
 903     {
 904       to->si_pid = from->cpt_si_pid;
 905       to->si_uid = from->cpt_si_uid;
 906       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 907     }
 908   else
 909     {
 910       switch (to->si_signo)
 911         {
 912         case SIGCHLD:
 913           to->si_pid = from->cpt_si_pid;
 914           to->si_uid = from->cpt_si_uid;
 915           to->si_status = from->cpt_si_status;
 916           memcpy (&to->si_utime, &from->cpt_si_utime,
 917                   sizeof (to->si_utime));
 918           memcpy (&to->si_stime, &from->cpt_si_stime,
 919                   sizeof (to->si_stime));
 920           break;
 921         case SIGILL:
 922         case SIGFPE:
 923         case SIGSEGV:
 924         case SIGBUS:
 925           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 926           break;
 927         case SIGPOLL:
 928           to->si_band = from->cpt_si_band;
 929           to->si_fd = from->cpt_si_fd;
 930           break;
 931         default:
 932           to->si_pid = from->cpt_si_pid;
 933           to->si_uid = from->cpt_si_uid;
 934           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 935           break;
 936         }
 937     }
 938 }
 939
 940 /* Convert a native/host siginfo object, into/from the siginfo in the
 941    layout of the inferiors' architecture.  Returns true if any
 942    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 943    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 944    INF.  */
 945
 946 static int
 947 amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction)
 948 {
 949   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
 950
 951   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
 952      object.  */
 953   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 954     {
 955       gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t));
 956
 957       if (direction == 0)
 958         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
 959       else
 960         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
 961
 962       return 1;
 963     }
 964   /* No fixup for native x32 GDB.  */
 965   else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8)
 966     {
 967       gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t));
 968
 969       if (direction == 0)
 970         compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
 971                                          native);
 972       else
 973         siginfo_from_compat_x32_siginfo (native,
 974                                          (struct compat_x32_siginfo *) inf);
 975
 976       return 1;
 977     }
 978   else
 979     return 0;
 980 }
 981
 982 /* Get Linux/x86 target description from running target.
 983
 984    Value of CS segment register:
 985      1. 64bit process: 0x33.
 986      2. 32bit process: 0x23.
 987
 988    Value of DS segment register:
 989      1. LP64 process: 0x0.
 990      2. X32 process: 0x2b.
 991  */
 992
 993 #define AMD64_LINUX_USER64_CS   0x33
 994 #define AMD64_LINUX_X32_DS      0x2b
 995
 996 static const struct target_desc *
 997 amd64_linux_read_description (struct target_ops *ops)
 998 {
 999   unsigned long cs;
1000   unsigned long ds;
1001   int tid;
1002   int is_64bit;
1003   int is_x32;
1004   static uint64_t xcr0;
1005
1006   /* GNU/Linux LWP ID's are process ID's.  */
1007   tid = TIDGET (inferior_ptid);
1008   if (tid == 0)
1009     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
1010
1011   /* Get CS register.  */
1012   errno = 0;
1013   cs = ptrace (PTRACE_PEEKUSER, tid,
1014                offsetof (struct user_regs_struct, cs), 0);
1015   if (errno != 0)
1016     perror_with_name (_("Couldn't get CS register"));
1017
1018   is_64bit = cs == AMD64_LINUX_USER64_CS;
1019
1020   /* Get DS register.  */
1021   errno = 0;
1022   ds = ptrace (PTRACE_PEEKUSER, tid,
1023                offsetof (struct user_regs_struct, ds), 0);
1024   if (errno != 0)
1025     perror_with_name (_("Couldn't get DS register"));
1026
1027   is_x32 = ds == AMD64_LINUX_X32_DS;
1028
1029   if (sizeof (void *) == 4 && is_64bit && !is_x32)
1030     error (_("Can't debug 64-bit process with 32-bit GDB"));
1031
1032   if (have_ptrace_getregset == -1)
1033     {
1034       uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
1035       struct iovec iov;
1036
1037       iov.iov_base = xstateregs;
1038       iov.iov_len = sizeof (xstateregs);
1039
1040       /* Check if PTRACE_GETREGSET works.  */
1041       if (ptrace (PTRACE_GETREGSET, tid,
1042                   (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
1043         have_ptrace_getregset = 0;
1044       else
1045         {
1046           have_ptrace_getregset = 1;
1047
1048           /* Get XCR0 from XSAVE extended state.  */
1049           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
1050                              / sizeof (uint64_t))];
1051         }
1052     }
1053
1054   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  */
1055   if (have_ptrace_getregset
1056       && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
1057     {
1058       if (is_64bit)
1059         {
1060           if (is_x32)
1061             return tdesc_x32_avx_linux;
1062           else
1063             return tdesc_amd64_avx_linux;
1064         }
1065       else
1066         return tdesc_i386_avx_linux;
1067     }
1068   else
1069     {
1070       if (is_64bit)
1071         {
1072           if (is_x32)
1073             return tdesc_x32_linux;
1074           else
1075             return tdesc_amd64_linux;
1076         }
1077       else
1078         return tdesc_i386_linux;
1079     }
1080 }
1081
1082 /* Provide a prototype to silence -Wmissing-prototypes.  */
1083 void _initialize_amd64_linux_nat (void);
1084
1085 void
1086 _initialize_amd64_linux_nat (void)
1087 {
1088   struct target_ops *t;
1089
1090   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
1091   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
1092   amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
1093   amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
1094
1095   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
1096               == amd64_native_gregset32_num_regs);
1097
1098   /* Fill in the generic GNU/Linux methods.  */
1099   t = linux_target ();
1100
1101   i386_use_watchpoints (t);
1102
1103   i386_dr_low.set_control = amd64_linux_dr_set_control;
1104   i386_dr_low.set_addr = amd64_linux_dr_set_addr;
1105   i386_dr_low.get_addr = amd64_linux_dr_get_addr;
1106   i386_dr_low.get_status = amd64_linux_dr_get_status;
1107   i386_dr_low.get_control = amd64_linux_dr_get_control;
1108   i386_set_debug_register_length (8);
1109
1110   /* Override the GNU/Linux inferior startup hook.  */
1111   super_post_startup_inferior = t->to_post_startup_inferior;
1112   t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
1113
1114   /* Add our register access methods.  */
1115   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
1116   t->to_store_registers = amd64_linux_store_inferior_registers;
1117
1118   t->to_read_description = amd64_linux_read_description;
1119
1120   /* Register the target.  */
1121   linux_nat_add_target (t);
1122   linux_nat_set_new_thread (t, amd64_linux_new_thread);
1123   linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
1124   linux_nat_set_prepare_to_resume (t, amd64_linux_prepare_to_resume);
1125 }