gdb/amd64-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86-64.
   2
   3    Copyright (C) 2001-2013 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 iterate_over_lwps.  Update the debug registers of
 341    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   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 368
 369   iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
 370 }
 371
 372 /* Set address REGNUM (zero based) to ADDR in all LWPs of the current
 373    inferior.  */
 374
 375 static void
 376 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 377 {
 378   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 379
 380   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 381
 382   iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
 383 }
 384
 385 /* Called when resuming a thread.
 386    If the debug regs have changed, update the thread's copies.  */
 387
 388 static void
 389 amd64_linux_prepare_to_resume (struct lwp_info *lwp)
 390 {
 391   int clear_status = 0;
 392
 393   /* NULL means this is the main thread still going through the shell,
 394      or, no watchpoint has been set yet.  In that case, there's
 395      nothing to do.  */
 396   if (lwp->arch_private == NULL)
 397     return;
 398
 399   if (lwp->arch_private->debug_registers_changed)
 400     {
 401       struct i386_debug_reg_state *state
 402         = i386_debug_reg_state (ptid_get_pid (lwp->ptid));
 403       int i;
 404
 405       /* On Linux kernel before 2.6.33 commit
 406          72f674d203cd230426437cdcf7dd6f681dad8b0d
 407          if you enable a breakpoint by the DR_CONTROL bits you need to have
 408          already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
 409
 410          Ensure DR_CONTROL gets written as the very last register here.  */
 411
 412       for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 413         if (state->dr_ref_count[i] > 0)
 414           {
 415             amd64_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
 416
 417             /* If we're setting a watchpoint, any change the inferior
 418                had done itself to the debug registers needs to be
 419                discarded, otherwise, i386_stopped_data_address can get
 420                confused.  */
 421             clear_status = 1;
 422           }
 423
 424       amd64_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
 425
 426       lwp->arch_private->debug_registers_changed = 0;
 427     }
 428
 429   if (clear_status || lwp->stopped_by_watchpoint)
 430     amd64_linux_dr_set (lwp->ptid, DR_STATUS, 0);
 431 }
 432
 433 static void
 434 amd64_linux_new_thread (struct lwp_info *lp)
 435 {
 436   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
 437
 438   info->debug_registers_changed = 1;
 439
 440   lp->arch_private = info;
 441 }
 442
 443 /* linux_nat_new_fork hook.   */
 444
 445 static void
 446 amd64_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
 447 {
 448   pid_t parent_pid;
 449   struct i386_debug_reg_state *parent_state;
 450   struct i386_debug_reg_state *child_state;
 451
 452   /* NULL means no watchpoint has ever been set in the parent.  In
 453      that case, there's nothing to do.  */
 454   if (parent->arch_private == NULL)
 455     return;
 456
 457   /* Linux kernel before 2.6.33 commit
 458      72f674d203cd230426437cdcf7dd6f681dad8b0d
 459      will inherit hardware debug registers from parent
 460      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 461      zeroed debug registers.
 462
 463      GDB core assumes the child inherits the watchpoints/hw
 464      breakpoints of the parent, and will remove them all from the
 465      forked off process.  Copy the debug registers mirrors into the
 466      new process so that all breakpoints and watchpoints can be
 467      removed together.  The debug registers mirror will become zeroed
 468      in the end before detaching the forked off process, thus making
 469      this compatible with older Linux kernels too.  */
 470
 471   parent_pid = ptid_get_pid (parent->ptid);
 472   parent_state = i386_debug_reg_state (parent_pid);
 473   child_state = i386_debug_reg_state (child_pid);
 474   *child_state = *parent_state;
 475 }
 476
 477 \f
 478
 479 /* This function is called by libthread_db as part of its handling of
 480    a request for a thread's local storage address.  */
 481
 482 ps_err_e
 483 ps_get_thread_area (const struct ps_prochandle *ph,
 484                     lwpid_t lwpid, int idx, void **base)
 485 {
 486   if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32)
 487     {
 488       /* The full structure is found in <asm-i386/ldt.h>.  The second
 489          integer is the LDT's base_address and that is used to locate
 490          the thread's local storage.  See i386-linux-nat.c more
 491          info.  */
 492       unsigned int desc[4];
 493
 494       /* This code assumes that "int" is 32 bits and that
 495          GET_THREAD_AREA returns no more than 4 int values.  */
 496       gdb_assert (sizeof (int) == 4);
 497 #ifndef PTRACE_GET_THREAD_AREA
 498 #define PTRACE_GET_THREAD_AREA 25
 499 #endif
 500       if  (ptrace (PTRACE_GET_THREAD_AREA,
 501                    lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
 502         return PS_ERR;
 503
 504       /* Extend the value to 64 bits.  Here it's assumed that a "long"
 505          and a "void *" are the same.  */
 506       (*base) = (void *) (long) desc[1];
 507       return PS_OK;
 508     }
 509   else
 510     {
 511       /* This definition comes from prctl.h, but some kernels may not
 512          have it.  */
 513 #ifndef PTRACE_ARCH_PRCTL
 514 #define PTRACE_ARCH_PRCTL      30
 515 #endif
 516       /* FIXME: ezannoni-2003-07-09 see comment above about include
 517          file order.  We could be getting bogus values for these two.  */
 518       gdb_assert (FS < ELF_NGREG);
 519       gdb_assert (GS < ELF_NGREG);
 520       switch (idx)
 521         {
 522         case FS:
 523 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE
 524             {
 525               /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the
 526                  fs_base and gs_base fields of user_regs_struct can be
 527                  used directly.  */
 528               unsigned long fs;
 529               errno = 0;
 530               fs = ptrace (PTRACE_PEEKUSER, lwpid,
 531                            offsetof (struct user_regs_struct, fs_base), 0);
 532               if (errno == 0)
 533                 {
 534                   *base = (void *) fs;
 535                   return PS_OK;
 536                 }
 537             }
 538 #endif
 539           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 540             return PS_OK;
 541           break;
 542         case GS:
 543 #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE
 544             {
 545               unsigned long gs;
 546               errno = 0;
 547               gs = ptrace (PTRACE_PEEKUSER, lwpid,
 548                            offsetof (struct user_regs_struct, gs_base), 0);
 549               if (errno == 0)
 550                 {
 551                   *base = (void *) gs;
 552                   return PS_OK;
 553                 }
 554             }
 555 #endif
 556           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 557             return PS_OK;
 558           break;
 559         default:                   /* Should not happen.  */
 560           return PS_BADADDR;
 561         }
 562     }
 563   return PS_ERR;               /* ptrace failed.  */
 564 }
 565 \f
 566
 567 static void (*super_post_startup_inferior) (ptid_t ptid);
 568
 569 static void
 570 amd64_linux_child_post_startup_inferior (ptid_t ptid)
 571 {
 572   i386_cleanup_dregs ();
 573   super_post_startup_inferior (ptid);
 574 }
 575 \f
 576
 577 /* When GDB is built as a 64-bit application on linux, the
 578    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
 579    debugging a 32-bit inferior with a 64-bit GDB should look the same
 580    as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
 581    conversion in-place ourselves.  */
 582
 583 /* These types below (compat_*) define a siginfo type that is layout
 584    compatible with the siginfo type exported by the 32-bit userspace
 585    support.  */
 586
 587 typedef int compat_int_t;
 588 typedef unsigned int compat_uptr_t;
 589
 590 typedef int compat_time_t;
 591 typedef int compat_timer_t;
 592 typedef int compat_clock_t;
 593
 594 struct compat_timeval
 595 {
 596   compat_time_t tv_sec;
 597   int tv_usec;
 598 };
 599
 600 typedef union compat_sigval
 601 {
 602   compat_int_t sival_int;
 603   compat_uptr_t sival_ptr;
 604 } compat_sigval_t;
 605
 606 typedef struct compat_siginfo
 607 {
 608   int si_signo;
 609   int si_errno;
 610   int si_code;
 611
 612   union
 613   {
 614     int _pad[((128 / sizeof (int)) - 3)];
 615
 616     /* kill() */
 617     struct
 618     {
 619       unsigned int _pid;
 620       unsigned int _uid;
 621     } _kill;
 622
 623     /* POSIX.1b timers */
 624     struct
 625     {
 626       compat_timer_t _tid;
 627       int _overrun;
 628       compat_sigval_t _sigval;
 629     } _timer;
 630
 631     /* POSIX.1b signals */
 632     struct
 633     {
 634       unsigned int _pid;
 635       unsigned int _uid;
 636       compat_sigval_t _sigval;
 637     } _rt;
 638
 639     /* SIGCHLD */
 640     struct
 641     {
 642       unsigned int _pid;
 643       unsigned int _uid;
 644       int _status;
 645       compat_clock_t _utime;
 646       compat_clock_t _stime;
 647     } _sigchld;
 648
 649     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 650     struct
 651     {
 652       unsigned int _addr;
 653     } _sigfault;
 654
 655     /* SIGPOLL */
 656     struct
 657     {
 658       int _band;
 659       int _fd;
 660     } _sigpoll;
 661   } _sifields;
 662 } compat_siginfo_t;
 663
 664 /* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes.  */
 665 typedef struct compat_x32_clock
 666 {
 667   int lower;
 668   int upper;
 669 } compat_x32_clock_t;
 670
 671 typedef struct compat_x32_siginfo
 672 {
 673   int si_signo;
 674   int si_errno;
 675   int si_code;
 676
 677   union
 678   {
 679     int _pad[((128 / sizeof (int)) - 3)];
 680
 681     /* kill() */
 682     struct
 683     {
 684       unsigned int _pid;
 685       unsigned int _uid;
 686     } _kill;
 687
 688     /* POSIX.1b timers */
 689     struct
 690     {
 691       compat_timer_t _tid;
 692       int _overrun;
 693       compat_sigval_t _sigval;
 694     } _timer;
 695
 696     /* POSIX.1b signals */
 697     struct
 698     {
 699       unsigned int _pid;
 700       unsigned int _uid;
 701       compat_sigval_t _sigval;
 702     } _rt;
 703
 704     /* SIGCHLD */
 705     struct
 706     {
 707       unsigned int _pid;
 708       unsigned int _uid;
 709       int _status;
 710       compat_x32_clock_t _utime;
 711       compat_x32_clock_t _stime;
 712     } _sigchld;
 713
 714     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 715     struct
 716     {
 717       unsigned int _addr;
 718     } _sigfault;
 719
 720     /* SIGPOLL */
 721     struct
 722     {
 723       int _band;
 724       int _fd;
 725     } _sigpoll;
 726   } _sifields;
 727 } compat_x32_siginfo_t;
 728
 729 #define cpt_si_pid _sifields._kill._pid
 730 #define cpt_si_uid _sifields._kill._uid
 731 #define cpt_si_timerid _sifields._timer._tid
 732 #define cpt_si_overrun _sifields._timer._overrun
 733 #define cpt_si_status _sifields._sigchld._status
 734 #define cpt_si_utime _sifields._sigchld._utime
 735 #define cpt_si_stime _sifields._sigchld._stime
 736 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
 737 #define cpt_si_addr _sifields._sigfault._addr
 738 #define cpt_si_band _sifields._sigpoll._band
 739 #define cpt_si_fd _sifields._sigpoll._fd
 740
 741 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
 742    In their place is si_timer1,si_timer2.  */
 743 #ifndef si_timerid
 744 #define si_timerid si_timer1
 745 #endif
 746 #ifndef si_overrun
 747 #define si_overrun si_timer2
 748 #endif
 749
 750 static void
 751 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
 752 {
 753   memset (to, 0, sizeof (*to));
 754
 755   to->si_signo = from->si_signo;
 756   to->si_errno = from->si_errno;
 757   to->si_code = from->si_code;
 758
 759   if (to->si_code == SI_TIMER)
 760     {
 761       to->cpt_si_timerid = from->si_timerid;
 762       to->cpt_si_overrun = from->si_overrun;
 763       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 764     }
 765   else if (to->si_code == SI_USER)
 766     {
 767       to->cpt_si_pid = from->si_pid;
 768       to->cpt_si_uid = from->si_uid;
 769     }
 770   else if (to->si_code < 0)
 771     {
 772       to->cpt_si_pid = from->si_pid;
 773       to->cpt_si_uid = from->si_uid;
 774       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 775     }
 776   else
 777     {
 778       switch (to->si_signo)
 779         {
 780         case SIGCHLD:
 781           to->cpt_si_pid = from->si_pid;
 782           to->cpt_si_uid = from->si_uid;
 783           to->cpt_si_status = from->si_status;
 784           to->cpt_si_utime = from->si_utime;
 785           to->cpt_si_stime = from->si_stime;
 786           break;
 787         case SIGILL:
 788         case SIGFPE:
 789         case SIGSEGV:
 790         case SIGBUS:
 791           to->cpt_si_addr = (intptr_t) from->si_addr;
 792           break;
 793         case SIGPOLL:
 794           to->cpt_si_band = from->si_band;
 795           to->cpt_si_fd = from->si_fd;
 796           break;
 797         default:
 798           to->cpt_si_pid = from->si_pid;
 799           to->cpt_si_uid = from->si_uid;
 800           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 801           break;
 802         }
 803     }
 804 }
 805
 806 static void
 807 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
 808 {
 809   memset (to, 0, sizeof (*to));
 810
 811   to->si_signo = from->si_signo;
 812   to->si_errno = from->si_errno;
 813   to->si_code = from->si_code;
 814
 815   if (to->si_code == SI_TIMER)
 816     {
 817       to->si_timerid = from->cpt_si_timerid;
 818       to->si_overrun = from->cpt_si_overrun;
 819       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 820     }
 821   else if (to->si_code == SI_USER)
 822     {
 823       to->si_pid = from->cpt_si_pid;
 824       to->si_uid = from->cpt_si_uid;
 825     }
 826   if (to->si_code < 0)
 827     {
 828       to->si_pid = from->cpt_si_pid;
 829       to->si_uid = from->cpt_si_uid;
 830       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 831     }
 832   else
 833     {
 834       switch (to->si_signo)
 835         {
 836         case SIGCHLD:
 837           to->si_pid = from->cpt_si_pid;
 838           to->si_uid = from->cpt_si_uid;
 839           to->si_status = from->cpt_si_status;
 840           to->si_utime = from->cpt_si_utime;
 841           to->si_stime = from->cpt_si_stime;
 842           break;
 843         case SIGILL:
 844         case SIGFPE:
 845         case SIGSEGV:
 846         case SIGBUS:
 847           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 848           break;
 849         case SIGPOLL:
 850           to->si_band = from->cpt_si_band;
 851           to->si_fd = from->cpt_si_fd;
 852           break;
 853         default:
 854           to->si_pid = from->cpt_si_pid;
 855           to->si_uid = from->cpt_si_uid;
 856           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 857           break;
 858         }
 859     }
 860 }
 861
 862 static void
 863 compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to,
 864                                  siginfo_t *from)
 865 {
 866   memset (to, 0, sizeof (*to));
 867
 868   to->si_signo = from->si_signo;
 869   to->si_errno = from->si_errno;
 870   to->si_code = from->si_code;
 871
 872   if (to->si_code == SI_TIMER)
 873     {
 874       to->cpt_si_timerid = from->si_timerid;
 875       to->cpt_si_overrun = from->si_overrun;
 876       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 877     }
 878   else if (to->si_code == SI_USER)
 879     {
 880       to->cpt_si_pid = from->si_pid;
 881       to->cpt_si_uid = from->si_uid;
 882     }
 883   else if (to->si_code < 0)
 884     {
 885       to->cpt_si_pid = from->si_pid;
 886       to->cpt_si_uid = from->si_uid;
 887       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 888     }
 889   else
 890     {
 891       switch (to->si_signo)
 892         {
 893         case SIGCHLD:
 894           to->cpt_si_pid = from->si_pid;
 895           to->cpt_si_uid = from->si_uid;
 896           to->cpt_si_status = from->si_status;
 897           memcpy (&to->cpt_si_utime, &from->si_utime,
 898                   sizeof (to->cpt_si_utime));
 899           memcpy (&to->cpt_si_stime, &from->si_stime,
 900                   sizeof (to->cpt_si_stime));
 901           break;
 902         case SIGILL:
 903         case SIGFPE:
 904         case SIGSEGV:
 905         case SIGBUS:
 906           to->cpt_si_addr = (intptr_t) from->si_addr;
 907           break;
 908         case SIGPOLL:
 909           to->cpt_si_band = from->si_band;
 910           to->cpt_si_fd = from->si_fd;
 911           break;
 912         default:
 913           to->cpt_si_pid = from->si_pid;
 914           to->cpt_si_uid = from->si_uid;
 915           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 916           break;
 917         }
 918     }
 919 }
 920
 921 static void
 922 siginfo_from_compat_x32_siginfo (siginfo_t *to,
 923                                  compat_x32_siginfo_t *from)
 924 {
 925   memset (to, 0, sizeof (*to));
 926
 927   to->si_signo = from->si_signo;
 928   to->si_errno = from->si_errno;
 929   to->si_code = from->si_code;
 930
 931   if (to->si_code == SI_TIMER)
 932     {
 933       to->si_timerid = from->cpt_si_timerid;
 934       to->si_overrun = from->cpt_si_overrun;
 935       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 936     }
 937   else if (to->si_code == SI_USER)
 938     {
 939       to->si_pid = from->cpt_si_pid;
 940       to->si_uid = from->cpt_si_uid;
 941     }
 942   if (to->si_code < 0)
 943     {
 944       to->si_pid = from->cpt_si_pid;
 945       to->si_uid = from->cpt_si_uid;
 946       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 947     }
 948   else
 949     {
 950       switch (to->si_signo)
 951         {
 952         case SIGCHLD:
 953           to->si_pid = from->cpt_si_pid;
 954           to->si_uid = from->cpt_si_uid;
 955           to->si_status = from->cpt_si_status;
 956           memcpy (&to->si_utime, &from->cpt_si_utime,
 957                   sizeof (to->si_utime));
 958           memcpy (&to->si_stime, &from->cpt_si_stime,
 959                   sizeof (to->si_stime));
 960           break;
 961         case SIGILL:
 962         case SIGFPE:
 963         case SIGSEGV:
 964         case SIGBUS:
 965           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 966           break;
 967         case SIGPOLL:
 968           to->si_band = from->cpt_si_band;
 969           to->si_fd = from->cpt_si_fd;
 970           break;
 971         default:
 972           to->si_pid = from->cpt_si_pid;
 973           to->si_uid = from->cpt_si_uid;
 974           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 975           break;
 976         }
 977     }
 978 }
 979
 980 /* Convert a native/host siginfo object, into/from the siginfo in the
 981    layout of the inferiors' architecture.  Returns true if any
 982    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 983    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 984    INF.  */
 985
 986 static int
 987 amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction)
 988 {
 989   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
 990
 991   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
 992      object.  */
 993   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 994     {
 995       gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t));
 996
 997       if (direction == 0)
 998         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
 999       else
1000         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
1001
1002       return 1;
1003     }
1004   /* No fixup for native x32 GDB.  */
1005   else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8)
1006     {
1007       gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t));
1008
1009       if (direction == 0)
1010         compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf,
1011                                          native);
1012       else
1013         siginfo_from_compat_x32_siginfo (native,
1014                                          (struct compat_x32_siginfo *) inf);
1015
1016       return 1;
1017     }
1018   else
1019     return 0;
1020 }
1021
1022 /* Get Linux/x86 target description from running target.
1023
1024    Value of CS segment register:
1025      1. 64bit process: 0x33.
1026      2. 32bit process: 0x23.
1027
1028    Value of DS segment register:
1029      1. LP64 process: 0x0.
1030      2. X32 process: 0x2b.
1031  */
1032
1033 #define AMD64_LINUX_USER64_CS   0x33
1034 #define AMD64_LINUX_X32_DS      0x2b
1035
1036 static const struct target_desc *
1037 amd64_linux_read_description (struct target_ops *ops)
1038 {
1039   unsigned long cs;
1040   unsigned long ds;
1041   int tid;
1042   int is_64bit;
1043   int is_x32;
1044   static uint64_t xcr0;
1045
1046   /* GNU/Linux LWP ID's are process ID's.  */
1047   tid = TIDGET (inferior_ptid);
1048   if (tid == 0)
1049     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
1050
1051   /* Get CS register.  */
1052   errno = 0;
1053   cs = ptrace (PTRACE_PEEKUSER, tid,
1054                offsetof (struct user_regs_struct, cs), 0);
1055   if (errno != 0)
1056     perror_with_name (_("Couldn't get CS register"));
1057
1058   is_64bit = cs == AMD64_LINUX_USER64_CS;
1059
1060   /* Get DS register.  */
1061   errno = 0;
1062   ds = ptrace (PTRACE_PEEKUSER, tid,
1063                offsetof (struct user_regs_struct, ds), 0);
1064   if (errno != 0)
1065     perror_with_name (_("Couldn't get DS register"));
1066
1067   is_x32 = ds == AMD64_LINUX_X32_DS;
1068
1069   if (sizeof (void *) == 4 && is_64bit && !is_x32)
1070     error (_("Can't debug 64-bit process with 32-bit GDB"));
1071
1072   if (have_ptrace_getregset == -1)
1073     {
1074       uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))];
1075       struct iovec iov;
1076
1077       iov.iov_base = xstateregs;
1078       iov.iov_len = sizeof (xstateregs);
1079
1080       /* Check if PTRACE_GETREGSET works.  */
1081       if (ptrace (PTRACE_GETREGSET, tid,
1082                   (unsigned int) NT_X86_XSTATE, (long) &iov) < 0)
1083         have_ptrace_getregset = 0;
1084       else
1085         {
1086           have_ptrace_getregset = 1;
1087
1088           /* Get XCR0 from XSAVE extended state.  */
1089           xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
1090                              / sizeof (uint64_t))];
1091         }
1092     }
1093
1094   /* Check the native XCR0 only if PTRACE_GETREGSET is available.  */
1095   if (have_ptrace_getregset
1096       && (xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
1097     {
1098       if (is_64bit)
1099         {
1100           if (is_x32)
1101             return tdesc_x32_avx_linux;
1102           else
1103             return tdesc_amd64_avx_linux;
1104         }
1105       else
1106         return tdesc_i386_avx_linux;
1107     }
1108   else
1109     {
1110       if (is_64bit)
1111         {
1112           if (is_x32)
1113             return tdesc_x32_linux;
1114           else
1115             return tdesc_amd64_linux;
1116         }
1117       else
1118         return tdesc_i386_linux;
1119     }
1120 }
1121
1122 /* Provide a prototype to silence -Wmissing-prototypes.  */
1123 void _initialize_amd64_linux_nat (void);
1124
1125 void
1126 _initialize_amd64_linux_nat (void)
1127 {
1128   struct target_ops *t;
1129
1130   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
1131   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
1132   amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset;
1133   amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
1134
1135   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
1136               == amd64_native_gregset32_num_regs);
1137
1138   /* Fill in the generic GNU/Linux methods.  */
1139   t = linux_target ();
1140
1141   i386_use_watchpoints (t);
1142
1143   i386_dr_low.set_control = amd64_linux_dr_set_control;
1144   i386_dr_low.set_addr = amd64_linux_dr_set_addr;
1145   i386_dr_low.get_addr = amd64_linux_dr_get_addr;
1146   i386_dr_low.get_status = amd64_linux_dr_get_status;
1147   i386_dr_low.get_control = amd64_linux_dr_get_control;
1148   i386_set_debug_register_length (8);
1149
1150   /* Override the GNU/Linux inferior startup hook.  */
1151   super_post_startup_inferior = t->to_post_startup_inferior;
1152   t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
1153
1154   /* Add our register access methods.  */
1155   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
1156   t->to_store_registers = amd64_linux_store_inferior_registers;
1157
1158   t->to_read_description = amd64_linux_read_description;
1159
1160   /* Register the target.  */
1161   linux_nat_add_target (t);
1162   linux_nat_set_new_thread (t, amd64_linux_new_thread);
1163   linux_nat_set_new_fork (t, amd64_linux_new_fork);
1164   linux_nat_set_forget_process (t, i386_forget_process);
1165   linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
1166   linux_nat_set_prepare_to_resume (t, amd64_linux_prepare_to_resume);
1167 }