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   errno = 0;
 281   value = ptrace (PTRACE_PEEKUSER, tid,
 282                   offsetof (struct user, u_debugreg[regnum]), 0);
 283   if (errno != 0)
 284     perror_with_name (_("Couldn't read debug register"));
 285
 286   return value;
 287 }
 288
 289 /* Set debug register REGNUM to VALUE in only the one LWP of PTID.  */
 290
 291 static void
 292 amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 293 {
 294   int tid;
 295
 296   tid = TIDGET (ptid);
 297   if (tid == 0)
 298     tid = PIDGET (ptid);
 299
 300   errno = 0;
 301   ptrace (PTRACE_POKEUSER, tid,
 302           offsetof (struct user, u_debugreg[regnum]), value);
 303   if (errno != 0)
 304     perror_with_name (_("Couldn't write debug register"));
 305 }
 306
 307 /* Set DR_CONTROL to ADDR in all LWPs of LWP_LIST.  */
 308
 309 static void
 310 amd64_linux_dr_set_control (unsigned long control)
 311 {
 312   struct lwp_info *lp;
 313
 314   amd64_linux_dr[DR_CONTROL] = control;
 315   ALL_LWPS (lp)
 316     amd64_linux_dr_set (lp->ptid, DR_CONTROL, control);
 317 }
 318
 319 /* Set address REGNUM (zero based) to ADDR in all LWPs of LWP_LIST.  */
 320
 321 static void
 322 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 323 {
 324   struct lwp_info *lp;
 325
 326   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 327
 328   amd64_linux_dr[DR_FIRSTADDR + regnum] = addr;
 329   ALL_LWPS (lp)
 330     amd64_linux_dr_set (lp->ptid, DR_FIRSTADDR + regnum, addr);
 331 }
 332
 333 /* Set address REGNUM (zero based) to zero in all LWPs of LWP_LIST.  */
 334
 335 static void
 336 amd64_linux_dr_reset_addr (int regnum)
 337 {
 338   amd64_linux_dr_set_addr (regnum, 0);
 339 }
 340
 341 /* Get DR_STATUS from only the one LWP of INFERIOR_PTID.  */
 342
 343 static unsigned long
 344 amd64_linux_dr_get_status (void)
 345 {
 346   return amd64_linux_dr_get (inferior_ptid, DR_STATUS);
 347 }
 348
 349 /* Unset MASK bits in DR_STATUS in all LWPs of LWP_LIST.  */
 350
 351 static void
 352 amd64_linux_dr_unset_status (unsigned long mask)
 353 {
 354   struct lwp_info *lp;
 355
 356   ALL_LWPS (lp)
 357     {
 358       unsigned long value;
 359
 360       value = amd64_linux_dr_get (lp->ptid, DR_STATUS);
 361       value &= ~mask;
 362       amd64_linux_dr_set (lp->ptid, DR_STATUS, value);
 363     }
 364 }
 365
 366
 367 static void
 368 amd64_linux_new_thread (ptid_t ptid)
 369 {
 370   int i;
 371
 372   for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 373     amd64_linux_dr_set (ptid, i, amd64_linux_dr[i]);
 374
 375   amd64_linux_dr_set (ptid, DR_CONTROL, amd64_linux_dr[DR_CONTROL]);
 376 }
 377 \f
 378
 379 /* This function is called by libthread_db as part of its handling of
 380    a request for a thread's local storage address.  */
 381
 382 ps_err_e
 383 ps_get_thread_area (const struct ps_prochandle *ph,
 384                     lwpid_t lwpid, int idx, void **base)
 385 {
 386   if (gdbarch_ptr_bit (target_gdbarch) == 32)
 387     {
 388       /* The full structure is found in <asm-i386/ldt.h>.  The second
 389          integer is the LDT's base_address and that is used to locate
 390          the thread's local storage.  See i386-linux-nat.c more
 391          info.  */
 392       unsigned int desc[4];
 393
 394       /* This code assumes that "int" is 32 bits and that
 395          GET_THREAD_AREA returns no more than 4 int values.  */
 396       gdb_assert (sizeof (int) == 4);
 397 #ifndef PTRACE_GET_THREAD_AREA
 398 #define PTRACE_GET_THREAD_AREA 25
 399 #endif
 400       if  (ptrace (PTRACE_GET_THREAD_AREA,
 401                    lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
 402         return PS_ERR;
 403
 404       /* Extend the value to 64 bits.  Here it's assumed that a "long"
 405          and a "void *" are the same.  */
 406       (*base) = (void *) (long) desc[1];
 407       return PS_OK;
 408     }
 409   else
 410     {
 411       /* This definition comes from prctl.h, but some kernels may not
 412          have it.  */
 413 #ifndef PTRACE_ARCH_PRCTL
 414 #define PTRACE_ARCH_PRCTL      30
 415 #endif
 416       /* FIXME: ezannoni-2003-07-09 see comment above about include
 417          file order.  We could be getting bogus values for these two.  */
 418       gdb_assert (FS < ELF_NGREG);
 419       gdb_assert (GS < ELF_NGREG);
 420       switch (idx)
 421         {
 422         case FS:
 423           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 424             return PS_OK;
 425           break;
 426         case GS:
 427           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 428             return PS_OK;
 429           break;
 430         default:                   /* Should not happen.  */
 431           return PS_BADADDR;
 432         }
 433     }
 434   return PS_ERR;               /* ptrace failed.  */
 435 }
 436 \f
 437
 438 static void (*super_post_startup_inferior) (ptid_t ptid);
 439
 440 static void
 441 amd64_linux_child_post_startup_inferior (ptid_t ptid)
 442 {
 443   i386_cleanup_dregs ();
 444   super_post_startup_inferior (ptid);
 445 }
 446 \f
 447
 448 /* When GDB is built as a 64-bit application on linux, the
 449    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
 450    debugging a 32-bit inferior with a 64-bit GDB should look the same
 451    as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
 452    conversion in-place ourselves.  */
 453
 454 /* These types below (compat_*) define a siginfo type that is layout
 455    compatible with the siginfo type exported by the 32-bit userspace
 456    support.  */
 457
 458 typedef int compat_int_t;
 459 typedef unsigned int compat_uptr_t;
 460
 461 typedef int compat_time_t;
 462 typedef int compat_timer_t;
 463 typedef int compat_clock_t;
 464
 465 struct compat_timeval
 466 {
 467   compat_time_t tv_sec;
 468   int tv_usec;
 469 };
 470
 471 typedef union compat_sigval
 472 {
 473   compat_int_t sival_int;
 474   compat_uptr_t sival_ptr;
 475 } compat_sigval_t;
 476
 477 typedef struct compat_siginfo
 478 {
 479   int si_signo;
 480   int si_errno;
 481   int si_code;
 482
 483   union
 484   {
 485     int _pad[((128 / sizeof (int)) - 3)];
 486
 487     /* kill() */
 488     struct
 489     {
 490       unsigned int _pid;
 491       unsigned int _uid;
 492     } _kill;
 493
 494     /* POSIX.1b timers */
 495     struct
 496     {
 497       compat_timer_t _tid;
 498       int _overrun;
 499       compat_sigval_t _sigval;
 500     } _timer;
 501
 502     /* POSIX.1b signals */
 503     struct
 504     {
 505       unsigned int _pid;
 506       unsigned int _uid;
 507       compat_sigval_t _sigval;
 508     } _rt;
 509
 510     /* SIGCHLD */
 511     struct
 512     {
 513       unsigned int _pid;
 514       unsigned int _uid;
 515       int _status;
 516       compat_clock_t _utime;
 517       compat_clock_t _stime;
 518     } _sigchld;
 519
 520     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 521     struct
 522     {
 523       unsigned int _addr;
 524     } _sigfault;
 525
 526     /* SIGPOLL */
 527     struct
 528     {
 529       int _band;
 530       int _fd;
 531     } _sigpoll;
 532   } _sifields;
 533 } compat_siginfo_t;
 534
 535 #define cpt_si_pid _sifields._kill._pid
 536 #define cpt_si_uid _sifields._kill._uid
 537 #define cpt_si_timerid _sifields._timer._tid
 538 #define cpt_si_overrun _sifields._timer._overrun
 539 #define cpt_si_status _sifields._sigchld._status
 540 #define cpt_si_utime _sifields._sigchld._utime
 541 #define cpt_si_stime _sifields._sigchld._stime
 542 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
 543 #define cpt_si_addr _sifields._sigfault._addr
 544 #define cpt_si_band _sifields._sigpoll._band
 545 #define cpt_si_fd _sifields._sigpoll._fd
 546
 547 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
 548    In their place is si_timer1,si_timer2.  */
 549 #ifndef si_timerid
 550 #define si_timerid si_timer1
 551 #endif
 552 #ifndef si_overrun
 553 #define si_overrun si_timer2
 554 #endif
 555
 556 static void
 557 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
 558 {
 559   memset (to, 0, sizeof (*to));
 560
 561   to->si_signo = from->si_signo;
 562   to->si_errno = from->si_errno;
 563   to->si_code = from->si_code;
 564
 565   if (to->si_code == SI_TIMER)
 566     {
 567       to->cpt_si_timerid = from->si_timerid;
 568       to->cpt_si_overrun = from->si_overrun;
 569       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 570     }
 571   else if (to->si_code == SI_USER)
 572     {
 573       to->cpt_si_pid = from->si_pid;
 574       to->cpt_si_uid = from->si_uid;
 575     }
 576   else if (to->si_code < 0)
 577     {
 578       to->cpt_si_pid = from->si_pid;
 579       to->cpt_si_uid = from->si_uid;
 580       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 581     }
 582   else
 583     {
 584       switch (to->si_signo)
 585         {
 586         case SIGCHLD:
 587           to->cpt_si_pid = from->si_pid;
 588           to->cpt_si_uid = from->si_uid;
 589           to->cpt_si_status = from->si_status;
 590           to->cpt_si_utime = from->si_utime;
 591           to->cpt_si_stime = from->si_stime;
 592           break;
 593         case SIGILL:
 594         case SIGFPE:
 595         case SIGSEGV:
 596         case SIGBUS:
 597           to->cpt_si_addr = (intptr_t) from->si_addr;
 598           break;
 599         case SIGPOLL:
 600           to->cpt_si_band = from->si_band;
 601           to->cpt_si_fd = from->si_fd;
 602           break;
 603         default:
 604           to->cpt_si_pid = from->si_pid;
 605           to->cpt_si_uid = from->si_uid;
 606           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 607           break;
 608         }
 609     }
 610 }
 611
 612 static void
 613 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
 614 {
 615   memset (to, 0, sizeof (*to));
 616
 617   to->si_signo = from->si_signo;
 618   to->si_errno = from->si_errno;
 619   to->si_code = from->si_code;
 620
 621   if (to->si_code == SI_TIMER)
 622     {
 623       to->si_timerid = from->cpt_si_timerid;
 624       to->si_overrun = from->cpt_si_overrun;
 625       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 626     }
 627   else if (to->si_code == SI_USER)
 628     {
 629       to->si_pid = from->cpt_si_pid;
 630       to->si_uid = from->cpt_si_uid;
 631     }
 632   if (to->si_code < 0)
 633     {
 634       to->si_pid = from->cpt_si_pid;
 635       to->si_uid = from->cpt_si_uid;
 636       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 637     }
 638   else
 639     {
 640       switch (to->si_signo)
 641         {
 642         case SIGCHLD:
 643           to->si_pid = from->cpt_si_pid;
 644           to->si_uid = from->cpt_si_uid;
 645           to->si_status = from->cpt_si_status;
 646           to->si_utime = from->cpt_si_utime;
 647           to->si_stime = from->cpt_si_stime;
 648           break;
 649         case SIGILL:
 650         case SIGFPE:
 651         case SIGSEGV:
 652         case SIGBUS:
 653           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 654           break;
 655         case SIGPOLL:
 656           to->si_band = from->cpt_si_band;
 657           to->si_fd = from->cpt_si_fd;
 658           break;
 659         default:
 660           to->si_pid = from->cpt_si_pid;
 661           to->si_uid = from->cpt_si_uid;
 662           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 663           break;
 664         }
 665     }
 666 }
 667
 668 /* Convert a native/host siginfo object, into/from the siginfo in the
 669    layout of the inferiors' architecture.  Returns true if any
 670    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 671    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 672    INF.  */
 673
 674 static int
 675 amd64_linux_siginfo_fixup (struct siginfo *native, gdb_byte *inf, int direction)
 676 {
 677   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
 678      object.  */
 679   if (gdbarch_addr_bit (get_frame_arch (get_current_frame ())) == 32)
 680     {
 681       gdb_assert (sizeof (struct siginfo) == sizeof (compat_siginfo_t));
 682
 683       if (direction == 0)
 684         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
 685       else
 686         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
 687
 688       return 1;
 689     }
 690   else
 691     return 0;
 692 }
 693
 694 /* Get Linux/x86 target description from running target.
 695
 696    Value of CS segment register:
 697      1. 64bit process: 0x33.
 698      2. 32bit process: 0x23.
 699  */
 700
 701 #define AMD64_LINUX_USER64_CS   0x33
 702
 703 static const struct target_desc *
 704 amd64_linux_read_description (struct target_ops *ops)
 705 {
 706   unsigned long cs;
 707   int tid;
 708   int is_64bit;
 709   static uint64_t xcr0;
 710
 711   /* GNU/Linux LWP ID's are process ID's.  */
 712   tid = TIDGET (inferior_ptid);
 713   if (tid == 0)
 714     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 715
 716   /* Get CS register.  */
 717   errno = 0;
 718   cs = ptrace (PTRACE_PEEKUSER, tid,
 719                offsetof (struct user_regs_struct, cs), 0);
 720   if (errno != 0)
 721     perror_with_name (_("Couldn't get CS register"));
 722
 723   is_64bit = cs == AMD64_LINUX_USER64_CS;
 724
 725   if (have_ptrace_getregset == -1)
 726     {
 727       uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
 728       struct iovec iov;
 729
 730       iov.iov_base = xstateregs;
 731       iov.iov_len = sizeof (xstateregs);
 732
 733       /* Check if PTRACE_GETREGSET works.  */
 734       if (ptrace (PTRACE_GETREGSET, tid,
 735                   (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
 736         have_ptrace_getregset = 0;
 737       else
 738         {
 739           have_ptrace_getregset = 1;
 740
 741           /* Get XCR0 from XSAVE extended state.  */
 742           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
 743                              / sizeof (uint64_t))];
 744         }
 745     }
 746
 747   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  */
 748   if (have_ptrace_getregset
 749       && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
 750     {
 751       if (is_64bit)
 752         return tdesc_amd64_avx_linux;
 753       else
 754         return tdesc_i386_avx_linux;
 755     }
 756   else
 757     {
 758       if (is_64bit)
 759         return tdesc_amd64_linux;
 760       else
 761         return tdesc_i386_linux;
 762     }
 763 }
 764
 765 /* Provide a prototype to silence -Wmissing-prototypes.  */
 766 void _initialize_amd64_linux_nat (void);
 767
 768 void
 769 _initialize_amd64_linux_nat (void)
 770 {
 771   struct target_ops *t;
 772
 773   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
 774   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
 775   amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
 776   amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
 777
 778   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
 779               == amd64_native_gregset32_num_regs);
 780
 781   /* Fill in the generic GNU/Linux methods.  */
 782   t = linux_target ();
 783
 784   i386_use_watchpoints (t);
 785
 786   i386_dr_low.set_control = amd64_linux_dr_set_control;
 787   i386_dr_low.set_addr = amd64_linux_dr_set_addr;
 788   i386_dr_low.reset_addr = amd64_linux_dr_reset_addr;
 789   i386_dr_low.get_status = amd64_linux_dr_get_status;
 790   i386_dr_low.unset_status = amd64_linux_dr_unset_status;
 791   i386_set_debug_register_length (8);
 792
 793   /* Override the GNU/Linux inferior startup hook.  */
 794   super_post_startup_inferior = t->to_post_startup_inferior;
 795   t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
 796
 797   /* Add our register access methods.  */
 798   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
 799   t->to_store_registers = amd64_linux_store_inferior_registers;
 800
 801   t->to_read_description = amd64_linux_read_description;
 802
 803   /* Register the target.  */
 804   linux_nat_add_target (t);
 805   linux_nat_set_new_thread (t, amd64_linux_new_thread);
 806   linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
 807 }