gdb/amd64-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86-64.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   4    2011 Free Software Foundation, Inc.
   5    Contributed by Jiri Smid, SuSE Labs.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "gdbcore.h"
  25 #include "regcache.h"
  26 #include "regset.h"
  27 #include "linux-nat.h"
  28 #include "amd64-linux-tdep.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/debugreg.h>
  36 #include <sys/syscall.h>
  37 #include <sys/procfs.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 /* Does the current host support PTRACE_GETREGSET?  */
  68 static int have_ptrace_getregset = -1;
  69
  70 /* Mapping between the general-purpose registers in GNU/Linux x86-64
  71    `struct user' format and GDB's register cache layout for GNU/Linux
  72    i386.
  73
  74    Note that most GNU/Linux x86-64 registers are 64-bit, while the
  75    GNU/Linux i386 registers are all 32-bit, but since we're
  76    little-endian we get away with that.  */
  77
  78 /* From <sys/reg.h> on GNU/Linux i386.  */
  79 static int amd64_linux_gregset32_reg_offset[] =
  80 {
  81   RAX * 8, RCX * 8,             /* %eax, %ecx */
  82   RDX * 8, RBX * 8,             /* %edx, %ebx */
  83   RSP * 8, RBP * 8,             /* %esp, %ebp */
  84   RSI * 8, RDI * 8,             /* %esi, %edi */
  85   RIP * 8, EFLAGS * 8,          /* %eip, %eflags */
  86   CS * 8, SS * 8,               /* %cs, %ss */
  87   DS * 8, ES * 8,               /* %ds, %es */
  88   FS * 8, GS * 8,               /* %fs, %gs */
  89   -1, -1, -1, -1, -1, -1, -1, -1,
  90   -1, -1, -1, -1, -1, -1, -1, -1,
  91   -1, -1, -1, -1, -1, -1, -1, -1, -1,
  92   -1, -1, -1, -1, -1, -1, -1, -1,
  93   ORIG_RAX * 8                  /* "orig_eax" */
  94 };
  95 \f
  96
  97 /* Transfering the general-purpose registers between GDB, inferiors
  98    and core files.  */
  99
 100 /* Fill GDB's register cache with the general-purpose register values
 101    in *GREGSETP.  */
 102
 103 void
 104 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 105 {
 106   amd64_supply_native_gregset (regcache, gregsetp, -1);
 107 }
 108
 109 /* Fill register REGNUM (if it is a general-purpose register) in
 110    *GREGSETP with the value in GDB's register cache.  If REGNUM is -1,
 111    do this for all registers.  */
 112
 113 void
 114 fill_gregset (const struct regcache *regcache,
 115               elf_gregset_t *gregsetp, int regnum)
 116 {
 117   amd64_collect_native_gregset (regcache, gregsetp, regnum);
 118 }
 119
 120 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 121
 122 /* Fill GDB's register cache with the floating-point and SSE register
 123    values in *FPREGSETP.  */
 124
 125 void
 126 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 127 {
 128   amd64_supply_fxsave (regcache, -1, fpregsetp);
 129 }
 130
 131 /* Fill register REGNUM (if it is a floating-point or SSE register) in
 132    *FPREGSETP with the value in GDB's register cache.  If REGNUM is
 133    -1, do this for all registers.  */
 134
 135 void
 136 fill_fpregset (const struct regcache *regcache,
 137                elf_fpregset_t *fpregsetp, int regnum)
 138 {
 139   amd64_collect_fxsave (regcache, regnum, fpregsetp);
 140 }
 141 \f
 142
 143 /* Transferring arbitrary registers between GDB and inferior.  */
 144
 145 /* Fetch register REGNUM from the child process.  If REGNUM is -1, do
 146    this for all registers (including the floating point and SSE
 147    registers).  */
 148
 149 static void
 150 amd64_linux_fetch_inferior_registers (struct target_ops *ops,
 151                                       struct regcache *regcache, int regnum)
 152 {
 153   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 154   int tid;
 155
 156   /* GNU/Linux LWP ID's are process ID's.  */
 157   tid = TIDGET (inferior_ptid);
 158   if (tid == 0)
 159     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 160
 161   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
 162     {
 163       elf_gregset_t regs;
 164
 165       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 166         perror_with_name (_("Couldn't get registers"));
 167
 168       amd64_supply_native_gregset (regcache, &regs, -1);
 169       if (regnum != -1)
 170         return;
 171     }
 172
 173   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
 174     {
 175       elf_fpregset_t fpregs;
 176
 177       if (have_ptrace_getregset)
 178         {
 179           char xstateregs[I386_XSTATE_MAX_SIZE];
 180           struct iovec iov;
 181
 182           iov.iov_base = xstateregs;
 183           iov.iov_len = sizeof (xstateregs);
 184           if (ptrace (PTRACE_GETREGSET, tid,
 185                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 186             perror_with_name (_("Couldn't get extended state status"));
 187
 188           amd64_supply_xsave (regcache, -1, xstateregs);
 189         }
 190       else
 191         {
 192           if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 193             perror_with_name (_("Couldn't get floating point status"));
 194
 195           amd64_supply_fxsave (regcache, -1, &fpregs);
 196         }
 197     }
 198 }
 199
 200 /* Store register REGNUM back into the child process.  If REGNUM is
 201    -1, do this for all registers (including the floating-point and SSE
 202    registers).  */
 203
 204 static void
 205 amd64_linux_store_inferior_registers (struct target_ops *ops,
 206                                       struct regcache *regcache, int regnum)
 207 {
 208   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 209   int tid;
 210
 211   /* GNU/Linux LWP ID's are process ID's.  */
 212   tid = TIDGET (inferior_ptid);
 213   if (tid == 0)
 214     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 215
 216   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
 217     {
 218       elf_gregset_t regs;
 219
 220       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 221         perror_with_name (_("Couldn't get registers"));
 222
 223       amd64_collect_native_gregset (regcache, &regs, regnum);
 224
 225       if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
 226         perror_with_name (_("Couldn't write registers"));
 227
 228       if (regnum != -1)
 229         return;
 230     }
 231
 232   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
 233     {
 234       elf_fpregset_t fpregs;
 235
 236       if (have_ptrace_getregset)
 237         {
 238           char xstateregs[I386_XSTATE_MAX_SIZE];
 239           struct iovec iov;
 240
 241           iov.iov_base = xstateregs;
 242           iov.iov_len = sizeof (xstateregs);
 243           if (ptrace (PTRACE_GETREGSET, tid,
 244                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 245             perror_with_name (_("Couldn't get extended state status"));
 246
 247           amd64_collect_xsave (regcache, regnum, xstateregs, 0);
 248
 249           if (ptrace (PTRACE_SETREGSET, tid,
 250                       (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 251             perror_with_name (_("Couldn't write extended state status"));
 252         }
 253       else
 254         {
 255           if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 256             perror_with_name (_("Couldn't get floating point status"));
 257
 258           amd64_collect_fxsave (regcache, regnum, &fpregs);
 259
 260           if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
 261             perror_with_name (_("Couldn't write floating point status"));
 262         }
 263     }
 264 }
 265 \f
 266 /* Support for debug registers.  */
 267
 268 static unsigned long amd64_linux_dr[DR_CONTROL + 1];
 269
 270 static unsigned long
 271 amd64_linux_dr_get (ptid_t ptid, int regnum)
 272 {
 273   int tid;
 274   unsigned long value;
 275
 276   tid = TIDGET (ptid);
 277   if (tid == 0)
 278     tid = PIDGET (ptid);
 279
 280   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
 281      ptrace call fails breaks debugging remote targets.  The correct
 282      way to fix this is to add the hardware breakpoint and watchpoint
 283      stuff to the target vector.  For now, just return zero if the
 284      ptrace call fails.  */
 285   errno = 0;
 286   value = ptrace (PTRACE_PEEKUSER, tid,
 287                   offsetof (struct user, u_debugreg[regnum]), 0);
 288   if (errno != 0)
 289 #if 0
 290     perror_with_name (_("Couldn't read debug register"));
 291 #else
 292     return 0;
 293 #endif
 294
 295   return value;
 296 }
 297
 298 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
 299
 300 static void
 301 amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 302 {
 303   int tid;
 304
 305   tid = TIDGET (ptid);
 306   if (tid == 0)
 307     tid = PIDGET (ptid);
 308
 309   errno = 0;
 310   ptrace (PTRACE_POKEUSER, tid,
 311           offsetof (struct user, u_debugreg[regnum]), value);
 312   if (errno != 0)
 313     perror_with_name (_("Couldn't write debug register"));
 314 }
 315
 316 /* Set DR_CONTROL to ADDR in all LWPs of LWP_LIST.  */
 317
 318 static void
 319 amd64_linux_dr_set_control (unsigned long control)
 320 {
 321   struct lwp_info *lp;
 322
 323   amd64_linux_dr[DR_CONTROL] = control;
 324   ALL_LWPS (lp)
 325     amd64_linux_dr_set (lp->ptid, DR_CONTROL, control);
 326 }
 327
 328 /* Set address REGNUM (zero based) to ADDR in all LWPs of LWP_LIST.  */
 329
 330 static void
 331 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 332 {
 333   struct lwp_info *lp;
 334
 335   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 336
 337   amd64_linux_dr[DR_FIRSTADDR + regnum] = addr;
 338   ALL_LWPS (lp)
 339     amd64_linux_dr_set (lp->ptid, DR_FIRSTADDR + regnum, addr);
 340 }
 341
 342 /* Set address REGNUM (zero based) to zero in all LWPs of LWP_LIST.  */
 343
 344 static void
 345 amd64_linux_dr_reset_addr (int regnum)
 346 {
 347   amd64_linux_dr_set_addr (regnum, 0);
 348 }
 349
 350 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 351
 352 static unsigned long
 353 amd64_linux_dr_get_status (void)
 354 {
 355   return amd64_linux_dr_get (inferior_ptid, DR_STATUS);
 356 }
 357
 358 /* Unset MASK bits in DR_STATUS in all LWPs of LWP_LIST.  */
 359
 360 static void
 361 amd64_linux_dr_unset_status (unsigned long mask)
 362 {
 363   struct lwp_info *lp;
 364
 365   ALL_LWPS (lp)
 366     {
 367       unsigned long value;
 368
 369       value = amd64_linux_dr_get (lp->ptid, DR_STATUS);
 370       value &= ~mask;
 371       amd64_linux_dr_set (lp->ptid, DR_STATUS, value);
 372     }
 373 }
 374
 375
 376 static void
 377 amd64_linux_new_thread (ptid_t ptid)
 378 {
 379   int i;
 380
 381   for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 382     amd64_linux_dr_set (ptid, i, amd64_linux_dr[i]);
 383
 384   amd64_linux_dr_set (ptid, DR_CONTROL, amd64_linux_dr[DR_CONTROL]);
 385 }
 386 \f
 387
 388 /* This function is called by libthread_db as part of its handling of
 389    a request for a thread's local storage address.  */
 390
 391 ps_err_e
 392 ps_get_thread_area (const struct ps_prochandle *ph,
 393                     lwpid_t lwpid, int idx, void **base)
 394 {
 395   if (gdbarch_ptr_bit (target_gdbarch) == 32)
 396     {
 397       /* The full structure is found in <asm-i386/ldt.h>.  The second
 398          integer is the LDT's base_address and that is used to locate
 399          the thread's local storage.  See i386-linux-nat.c more
 400          info.  */
 401       unsigned int desc[4];
 402
 403       /* This code assumes that "int" is 32 bits and that
 404          GET_THREAD_AREA returns no more than 4 int values.  */
 405       gdb_assert (sizeof (int) == 4);
 406 #ifndef PTRACE_GET_THREAD_AREA
 407 #define PTRACE_GET_THREAD_AREA 25
 408 #endif
 409       if  (ptrace (PTRACE_GET_THREAD_AREA,
 410                    lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
 411         return PS_ERR;
 412
 413       /* Extend the value to 64 bits.  Here it's assumed that a "long"
 414          and a "void *" are the same.  */
 415       (*base) = (void *) (long) desc[1];
 416       return PS_OK;
 417     }
 418   else
 419     {
 420       /* This definition comes from prctl.h, but some kernels may not
 421          have it.  */
 422 #ifndef PTRACE_ARCH_PRCTL
 423 #define PTRACE_ARCH_PRCTL      30
 424 #endif
 425       /* FIXME: ezannoni-2003-07-09 see comment above about include
 426          file order.  We could be getting bogus values for these two.  */
 427       gdb_assert (FS < ELF_NGREG);
 428       gdb_assert (GS < ELF_NGREG);
 429       switch (idx)
 430         {
 431         case FS:
 432           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 433             return PS_OK;
 434           break;
 435         case GS:
 436           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 437             return PS_OK;
 438           break;
 439         default:                   /* Should not happen.  */
 440           return PS_BADADDR;
 441         }
 442     }
 443   return PS_ERR;               /* ptrace failed.  */
 444 }
 445 \f
 446
 447 static void (*super_post_startup_inferior) (ptid_t ptid);
 448
 449 static void
 450 amd64_linux_child_post_startup_inferior (ptid_t ptid)
 451 {
 452   i386_cleanup_dregs ();
 453   super_post_startup_inferior (ptid);
 454 }
 455 \f
 456
 457 /* When GDB is built as a 64-bit application on linux, the
 458    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
 459    debugging a 32-bit inferior with a 64-bit GDB should look the same
 460    as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
 461    conversion in-place ourselves.  */
 462
 463 /* These types below (compat_*) define a siginfo type that is layout
 464    compatible with the siginfo type exported by the 32-bit userspace
 465    support.  */
 466
 467 typedef int compat_int_t;
 468 typedef unsigned int compat_uptr_t;
 469
 470 typedef int compat_time_t;
 471 typedef int compat_timer_t;
 472 typedef int compat_clock_t;
 473
 474 struct compat_timeval
 475 {
 476   compat_time_t tv_sec;
 477   int tv_usec;
 478 };
 479
 480 typedef union compat_sigval
 481 {
 482   compat_int_t sival_int;
 483   compat_uptr_t sival_ptr;
 484 } compat_sigval_t;
 485
 486 typedef struct compat_siginfo
 487 {
 488   int si_signo;
 489   int si_errno;
 490   int si_code;
 491
 492   union
 493   {
 494     int _pad[((128 / sizeof (int)) - 3)];
 495
 496     /* kill() */
 497     struct
 498     {
 499       unsigned int _pid;
 500       unsigned int _uid;
 501     } _kill;
 502
 503     /* POSIX.1b timers */
 504     struct
 505     {
 506       compat_timer_t _tid;
 507       int _overrun;
 508       compat_sigval_t _sigval;
 509     } _timer;
 510
 511     /* POSIX.1b signals */
 512     struct
 513     {
 514       unsigned int _pid;
 515       unsigned int _uid;
 516       compat_sigval_t _sigval;
 517     } _rt;
 518
 519     /* SIGCHLD */
 520     struct
 521     {
 522       unsigned int _pid;
 523       unsigned int _uid;
 524       int _status;
 525       compat_clock_t _utime;
 526       compat_clock_t _stime;
 527     } _sigchld;
 528
 529     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 530     struct
 531     {
 532       unsigned int _addr;
 533     } _sigfault;
 534
 535     /* SIGPOLL */
 536     struct
 537     {
 538       int _band;
 539       int _fd;
 540     } _sigpoll;
 541   } _sifields;
 542 } compat_siginfo_t;
 543
 544 #define cpt_si_pid _sifields._kill._pid
 545 #define cpt_si_uid _sifields._kill._uid
 546 #define cpt_si_timerid _sifields._timer._tid
 547 #define cpt_si_overrun _sifields._timer._overrun
 548 #define cpt_si_status _sifields._sigchld._status
 549 #define cpt_si_utime _sifields._sigchld._utime
 550 #define cpt_si_stime _sifields._sigchld._stime
 551 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
 552 #define cpt_si_addr _sifields._sigfault._addr
 553 #define cpt_si_band _sifields._sigpoll._band
 554 #define cpt_si_fd _sifields._sigpoll._fd
 555
 556 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
 557    In their place is si_timer1,si_timer2.  */
 558 #ifndef si_timerid
 559 #define si_timerid si_timer1
 560 #endif
 561 #ifndef si_overrun
 562 #define si_overrun si_timer2
 563 #endif
 564
 565 static void
 566 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
 567 {
 568   memset (to, 0, sizeof (*to));
 569
 570   to->si_signo = from->si_signo;
 571   to->si_errno = from->si_errno;
 572   to->si_code = from->si_code;
 573
 574   if (to->si_code == SI_TIMER)
 575     {
 576       to->cpt_si_timerid = from->si_timerid;
 577       to->cpt_si_overrun = from->si_overrun;
 578       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 579     }
 580   else if (to->si_code == SI_USER)
 581     {
 582       to->cpt_si_pid = from->si_pid;
 583       to->cpt_si_uid = from->si_uid;
 584     }
 585   else if (to->si_code < 0)
 586     {
 587       to->cpt_si_pid = from->si_pid;
 588       to->cpt_si_uid = from->si_uid;
 589       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 590     }
 591   else
 592     {
 593       switch (to->si_signo)
 594         {
 595         case SIGCHLD:
 596           to->cpt_si_pid = from->si_pid;
 597           to->cpt_si_uid = from->si_uid;
 598           to->cpt_si_status = from->si_status;
 599           to->cpt_si_utime = from->si_utime;
 600           to->cpt_si_stime = from->si_stime;
 601           break;
 602         case SIGILL:
 603         case SIGFPE:
 604         case SIGSEGV:
 605         case SIGBUS:
 606           to->cpt_si_addr = (intptr_t) from->si_addr;
 607           break;
 608         case SIGPOLL:
 609           to->cpt_si_band = from->si_band;
 610           to->cpt_si_fd = from->si_fd;
 611           break;
 612         default:
 613           to->cpt_si_pid = from->si_pid;
 614           to->cpt_si_uid = from->si_uid;
 615           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 616           break;
 617         }
 618     }
 619 }
 620
 621 static void
 622 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
 623 {
 624   memset (to, 0, sizeof (*to));
 625
 626   to->si_signo = from->si_signo;
 627   to->si_errno = from->si_errno;
 628   to->si_code = from->si_code;
 629
 630   if (to->si_code == SI_TIMER)
 631     {
 632       to->si_timerid = from->cpt_si_timerid;
 633       to->si_overrun = from->cpt_si_overrun;
 634       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 635     }
 636   else if (to->si_code == SI_USER)
 637     {
 638       to->si_pid = from->cpt_si_pid;
 639       to->si_uid = from->cpt_si_uid;
 640     }
 641   if (to->si_code < 0)
 642     {
 643       to->si_pid = from->cpt_si_pid;
 644       to->si_uid = from->cpt_si_uid;
 645       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 646     }
 647   else
 648     {
 649       switch (to->si_signo)
 650         {
 651         case SIGCHLD:
 652           to->si_pid = from->cpt_si_pid;
 653           to->si_uid = from->cpt_si_uid;
 654           to->si_status = from->cpt_si_status;
 655           to->si_utime = from->cpt_si_utime;
 656           to->si_stime = from->cpt_si_stime;
 657           break;
 658         case SIGILL:
 659         case SIGFPE:
 660         case SIGSEGV:
 661         case SIGBUS:
 662           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 663           break;
 664         case SIGPOLL:
 665           to->si_band = from->cpt_si_band;
 666           to->si_fd = from->cpt_si_fd;
 667           break;
 668         default:
 669           to->si_pid = from->cpt_si_pid;
 670           to->si_uid = from->cpt_si_uid;
 671           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 672           break;
 673         }
 674     }
 675 }
 676
 677 /* Convert a native/host siginfo object, into/from the siginfo in the
 678    layout of the inferiors' architecture.  Returns true if any
 679    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 680    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 681    INF.  */
 682
 683 static int
 684 amd64_linux_siginfo_fixup (struct siginfo *native, gdb_byte *inf, int direction)
 685 {
 686   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
 687      object.  */
 688   if (gdbarch_addr_bit (get_frame_arch (get_current_frame ())) == 32)
 689     {
 690       gdb_assert (sizeof (struct siginfo) == sizeof (compat_siginfo_t));
 691
 692       if (direction == 0)
 693         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
 694       else
 695         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
 696
 697       return 1;
 698     }
 699   else
 700     return 0;
 701 }
 702
 703 /* Get Linux/x86 target description from running target.
 704
 705    Value of CS segment register:
 706      1. 64bit process: 0x33.
 707      2. 32bit process: 0x23.
 708  */
 709
 710 #define AMD64_LINUX_USER64_CS   0x33
 711
 712 static const struct target_desc *
 713 amd64_linux_read_description (struct target_ops *ops)
 714 {
 715   unsigned long cs;
 716   int tid;
 717   int is_64bit;
 718   static uint64_t xcr0;
 719
 720   /* GNU/Linux LWP ID's are process ID's.  */
 721   tid = TIDGET (inferior_ptid);
 722   if (tid == 0)
 723     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 724
 725   /* Get CS register.  */
 726   errno = 0;
 727   cs = ptrace (PTRACE_PEEKUSER, tid,
 728                offsetof (struct user_regs_struct, cs), 0);
 729   if (errno != 0)
 730     perror_with_name (_("Couldn't get CS register"));
 731
 732   is_64bit = cs == AMD64_LINUX_USER64_CS;
 733
 734   if (have_ptrace_getregset == -1)
 735     {
 736       uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 737       struct iovec iov;
 738
 739       iov.iov_base = xstateregs;
 740       iov.iov_len = sizeof (xstateregs);
 741
 742       /* Check if PTRACE_GETREGSET works.  */
 743       if (ptrace (PTRACE_GETREGSET, tid,
 744                   (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 745         have_ptrace_getregset = 0;
 746       else
 747         {
 748           have_ptrace_getregset = 1;
 749
 750           /* Get XCR0 from XSAVE extended state.  */
 751           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 752                              / sizeof (uint64_t))];
 753         }
 754     }
 755
 756   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  */
 757   if (have_ptrace_getregset
 758       && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
 759     {
 760       if (is_64bit)
 761         return tdesc_amd64_avx_linux;
 762       else
 763         return tdesc_i386_avx_linux;
 764     }
 765   else
 766     {
 767       if (is_64bit)
 768         return tdesc_amd64_linux;
 769       else
 770         return tdesc_i386_linux;
 771     }
 772 }
 773
 774 /* Provide a prototype to silence -Wmissing-prototypes.  */
 775 void _initialize_amd64_linux_nat (void);
 776
 777 void
 778 _initialize_amd64_linux_nat (void)
 779 {
 780   struct target_ops *t;
 781
 782   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
 783   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
 784   amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
 785   amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
 786
 787   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
 788               == amd64_native_gregset32_num_regs);
 789
 790   /* Fill in the generic GNU/Linux methods.  */
 791   t = linux_target ();
 792
 793   i386_use_watchpoints (t);
 794
 795   i386_dr_low.set_control = amd64_linux_dr_set_control;
 796   i386_dr_low.set_addr = amd64_linux_dr_set_addr;
 797   i386_dr_low.reset_addr = amd64_linux_dr_reset_addr;
 798   i386_dr_low.get_status = amd64_linux_dr_get_status;
 799   i386_dr_low.unset_status = amd64_linux_dr_unset_status;
 800   i386_set_debug_register_length (8);
 801
 802   /* Override the GNU/Linux inferior startup hook.  */
 803   super_post_startup_inferior = t->to_post_startup_inferior;
 804   t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
 805
 806   /* Add our register access methods.  */
 807   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
 808   t->to_store_registers = amd64_linux_store_inferior_registers;
 809
 810   t->to_read_description = amd64_linux_read_description;
 811
 812   /* Register the target.  */
 813   linux_nat_add_target (t);
 814   linux_nat_set_new_thread (t, amd64_linux_new_thread);
 815   linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
 816 }