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