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
   4    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 "linux-nat.h"
  27 #include "amd64-linux-tdep.h"
  28
  29 #include "gdb_assert.h"
  30 #include "gdb_string.h"
  31 #include <sys/ptrace.h>
  32 #include <sys/debugreg.h>
  33 #include <sys/syscall.h>
  34 #include <sys/procfs.h>
  35 #include <asm/prctl.h>
  36 /* FIXME ezannoni-2003-07-09: we need <sys/reg.h> to be included after
  37    <asm/ptrace.h> because the latter redefines FS and GS for no apparent
  38    reason, and those definitions don't match the ones that libpthread_db
  39    uses, which come from <sys/reg.h>.  */
  40 /* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have
  41    been removed from ptrace.h in the kernel.  However, better safe than
  42    sorry.  */
  43 #include <asm/ptrace.h>
  44 #include <sys/reg.h>
  45 #include "gdb_proc_service.h"
  46
  47 /* Prototypes for supply_gregset etc.  */
  48 #include "gregset.h"
  49
  50 #include "amd64-tdep.h"
  51 #include "i386-linux-tdep.h"
  52 #include "amd64-nat.h"
  53 #include "i386-nat.h"
  54
  55 /* Mapping between the general-purpose registers in GNU/Linux x86-64
  56    `struct user' format and GDB's register cache layout.  */
  57
  58 static int amd64_linux_gregset64_reg_offset[] =
  59 {
  60   RAX * 8, RBX * 8,             /* %rax, %rbx */
  61   RCX * 8, RDX * 8,             /* %rcx, %rdx */
  62   RSI * 8, RDI * 8,             /* %rsi, %rdi */
  63   RBP * 8, RSP * 8,             /* %rbp, %rsp */
  64   R8 * 8, R9 * 8,               /* %r8 ... */
  65   R10 * 8, R11 * 8,
  66   R12 * 8, R13 * 8,
  67   R14 * 8, R15 * 8,             /* ... %r15 */
  68   RIP * 8, EFLAGS * 8,          /* %rip, %eflags */
  69   CS * 8, SS * 8,               /* %cs, %ss */
  70   DS * 8, ES * 8,               /* %ds, %es */
  71   FS * 8, GS * 8,               /* %fs, %gs */
  72   -1, -1, -1, -1, -1, -1, -1, -1,
  73   -1, -1, -1, -1, -1, -1, -1, -1,
  74   -1, -1, -1, -1, -1, -1, -1, -1,
  75   -1, -1, -1, -1, -1, -1, -1, -1, -1,
  76   ORIG_RAX * 8
  77 };
  78 \f
  79
  80 /* Mapping between the general-purpose registers in GNU/Linux x86-64
  81    `struct user' format and GDB's register cache layout for GNU/Linux
  82    i386.
  83
  84    Note that most GNU/Linux x86-64 registers are 64-bit, while the
  85    GNU/Linux i386 registers are all 32-bit, but since we're
  86    little-endian we get away with that.  */
  87
  88 /* From <sys/reg.h> on GNU/Linux i386.  */
  89 static int amd64_linux_gregset32_reg_offset[] =
  90 {
  91   RAX * 8, RCX * 8,             /* %eax, %ecx */
  92   RDX * 8, RBX * 8,             /* %edx, %ebx */
  93   RSP * 8, RBP * 8,             /* %esp, %ebp */
  94   RSI * 8, RDI * 8,             /* %esi, %edi */
  95   RIP * 8, EFLAGS * 8,          /* %eip, %eflags */
  96   CS * 8, SS * 8,               /* %cs, %ss */
  97   DS * 8, ES * 8,               /* %ds, %es */
  98   FS * 8, GS * 8,               /* %fs, %gs */
  99   -1, -1, -1, -1, -1, -1, -1, -1,
 100   -1, -1, -1, -1, -1, -1, -1, -1,
 101   -1, -1, -1, -1, -1, -1, -1, -1, -1,
 102   ORIG_RAX * 8                  /* "orig_eax" */
 103 };
 104 \f
 105
 106 /* Transfering the general-purpose registers between GDB, inferiors
 107    and core files.  */
 108
 109 /* Fill GDB's register cache with the general-purpose register values
 110    in *GREGSETP.  */
 111
 112 void
 113 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
 114 {
 115   amd64_supply_native_gregset (regcache, gregsetp, -1);
 116 }
 117
 118 /* Fill register REGNUM (if it is a general-purpose register) in
 119    *GREGSETP with the value in GDB's register cache.  If REGNUM is -1,
 120    do this for all registers.  */
 121
 122 void
 123 fill_gregset (const struct regcache *regcache,
 124               elf_gregset_t *gregsetp, int regnum)
 125 {
 126   amd64_collect_native_gregset (regcache, gregsetp, regnum);
 127 }
 128
 129 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 130
 131 /* Fill GDB's register cache with the floating-point and SSE register
 132    values in *FPREGSETP.  */
 133
 134 void
 135 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
 136 {
 137   amd64_supply_fxsave (regcache, -1, fpregsetp);
 138 }
 139
 140 /* Fill register REGNUM (if it is a floating-point or SSE register) in
 141    *FPREGSETP with the value in GDB's register cache.  If REGNUM is
 142    -1, do this for all registers.  */
 143
 144 void
 145 fill_fpregset (const struct regcache *regcache,
 146                elf_fpregset_t *fpregsetp, int regnum)
 147 {
 148   amd64_collect_fxsave (regcache, regnum, fpregsetp);
 149 }
 150 \f
 151
 152 /* Transferring arbitrary registers between GDB and inferior.  */
 153
 154 /* Fetch register REGNUM from the child process.  If REGNUM is -1, do
 155    this for all registers (including the floating point and SSE
 156    registers).  */
 157
 158 static void
 159 amd64_linux_fetch_inferior_registers (struct target_ops *ops,
 160                                       struct regcache *regcache, int regnum)
 161 {
 162   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 163   int tid;
 164
 165   /* GNU/Linux LWP ID's are process ID's.  */
 166   tid = TIDGET (inferior_ptid);
 167   if (tid == 0)
 168     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 169
 170   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
 171     {
 172       elf_gregset_t regs;
 173
 174       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 175         perror_with_name (_("Couldn't get registers"));
 176
 177       amd64_supply_native_gregset (regcache, &regs, -1);
 178       if (regnum != -1)
 179         return;
 180     }
 181
 182   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
 183     {
 184       elf_fpregset_t fpregs;
 185
 186       if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 187         perror_with_name (_("Couldn't get floating point status"));
 188
 189       amd64_supply_fxsave (regcache, -1, &fpregs);
 190     }
 191 }
 192
 193 /* Store register REGNUM back into the child process.  If REGNUM is
 194    -1, do this for all registers (including the floating-point and SSE
 195    registers).  */
 196
 197 static void
 198 amd64_linux_store_inferior_registers (struct target_ops *ops,
 199                                       struct regcache *regcache, int regnum)
 200 {
 201   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 202   int tid;
 203
 204   /* GNU/Linux LWP ID's are process ID's.  */
 205   tid = TIDGET (inferior_ptid);
 206   if (tid == 0)
 207     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 208
 209   if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum))
 210     {
 211       elf_gregset_t regs;
 212
 213       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 214         perror_with_name (_("Couldn't get registers"));
 215
 216       amd64_collect_native_gregset (regcache, &regs, regnum);
 217
 218       if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
 219         perror_with_name (_("Couldn't write registers"));
 220
 221       if (regnum != -1)
 222         return;
 223     }
 224
 225   if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum))
 226     {
 227       elf_fpregset_t fpregs;
 228
 229       if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 230         perror_with_name (_("Couldn't get floating point status"));
 231
 232       amd64_collect_fxsave (regcache, regnum, &fpregs);
 233
 234       if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
 235         perror_with_name (_("Couldn't write floating point status"));
 236
 237       return;
 238     }
 239 }
 240 \f
 241 /* Support for debug registers.  */
 242
 243 static unsigned long amd64_linux_dr[DR_CONTROL + 1];
 244
 245 static unsigned long
 246 amd64_linux_dr_get (ptid_t ptid, int regnum)
 247 {
 248   int tid;
 249   unsigned long value;
 250
 251   tid = TIDGET (ptid);
 252   if (tid == 0)
 253     tid = PIDGET (ptid);
 254
 255   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
 256      ptrace call fails breaks debugging remote targets.  The correct
 257      way to fix this is to add the hardware breakpoint and watchpoint
 258      stuff to the target vector.  For now, just return zero if the
 259      ptrace call fails.  */
 260   errno = 0;
 261   value = ptrace (PTRACE_PEEKUSER, tid,
 262                   offsetof (struct user, u_debugreg[regnum]), 0);
 263   if (errno != 0)
 264 #if 0
 265     perror_with_name (_("Couldn't read debug register"));
 266 #else
 267     return 0;
 268 #endif
 269
 270   return value;
 271 }
 272
 273 static void
 274 amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 275 {
 276   int tid;
 277
 278   tid = TIDGET (ptid);
 279   if (tid == 0)
 280     tid = PIDGET (ptid);
 281
 282   errno = 0;
 283   ptrace (PTRACE_POKEUSER, tid,
 284           offsetof (struct user, u_debugreg[regnum]), value);
 285   if (errno != 0)
 286     perror_with_name (_("Couldn't write debug register"));
 287 }
 288
 289 static void
 290 amd64_linux_dr_set_control (unsigned long control)
 291 {
 292   struct lwp_info *lp;
 293   ptid_t ptid;
 294
 295   amd64_linux_dr[DR_CONTROL] = control;
 296   ALL_LWPS (lp, ptid)
 297     amd64_linux_dr_set (ptid, DR_CONTROL, control);
 298 }
 299
 300 static void
 301 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 302 {
 303   struct lwp_info *lp;
 304   ptid_t ptid;
 305
 306   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 307
 308   amd64_linux_dr[DR_FIRSTADDR + regnum] = addr;
 309   ALL_LWPS (lp, ptid)
 310     amd64_linux_dr_set (ptid, DR_FIRSTADDR + regnum, addr);
 311 }
 312
 313 static void
 314 amd64_linux_dr_reset_addr (int regnum)
 315 {
 316   amd64_linux_dr_set_addr (regnum, 0);
 317 }
 318
 319 static unsigned long
 320 amd64_linux_dr_get_status (void)
 321 {
 322   return amd64_linux_dr_get (inferior_ptid, DR_STATUS);
 323 }
 324
 325 static void
 326 amd64_linux_new_thread (ptid_t ptid)
 327 {
 328   int i;
 329
 330   for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 331     amd64_linux_dr_set (ptid, i, amd64_linux_dr[i]);
 332
 333   amd64_linux_dr_set (ptid, DR_CONTROL, amd64_linux_dr[DR_CONTROL]);
 334 }
 335 \f
 336
 337 /* This function is called by libthread_db as part of its handling of
 338    a request for a thread's local storage address.  */
 339
 340 ps_err_e
 341 ps_get_thread_area (const struct ps_prochandle *ph,
 342                     lwpid_t lwpid, int idx, void **base)
 343 {
 344   if (gdbarch_ptr_bit (target_gdbarch) == 32)
 345     {
 346       /* The full structure is found in <asm-i386/ldt.h>.  The second
 347          integer is the LDT's base_address and that is used to locate
 348          the thread's local storage.  See i386-linux-nat.c more
 349          info.  */
 350       unsigned int desc[4];
 351
 352       /* This code assumes that "int" is 32 bits and that
 353          GET_THREAD_AREA returns no more than 4 int values.  */
 354       gdb_assert (sizeof (int) == 4);
 355 #ifndef PTRACE_GET_THREAD_AREA
 356 #define PTRACE_GET_THREAD_AREA 25
 357 #endif
 358       if  (ptrace (PTRACE_GET_THREAD_AREA,
 359                    lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
 360         return PS_ERR;
 361
 362       /* Extend the value to 64 bits.  Here it's assumed that a "long"
 363          and a "void *" are the same.  */
 364       (*base) = (void *) (long) desc[1];
 365       return PS_OK;
 366     }
 367   else
 368     {
 369       /* This definition comes from prctl.h, but some kernels may not
 370          have it.  */
 371 #ifndef PTRACE_ARCH_PRCTL
 372 #define PTRACE_ARCH_PRCTL      30
 373 #endif
 374       /* FIXME: ezannoni-2003-07-09 see comment above about include
 375          file order.  We could be getting bogus values for these two.  */
 376       gdb_assert (FS < ELF_NGREG);
 377       gdb_assert (GS < ELF_NGREG);
 378       switch (idx)
 379         {
 380         case FS:
 381           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 382             return PS_OK;
 383           break;
 384         case GS:
 385           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 386             return PS_OK;
 387           break;
 388         default:                   /* Should not happen.  */
 389           return PS_BADADDR;
 390         }
 391     }
 392   return PS_ERR;               /* ptrace failed.  */
 393 }
 394 \f
 395
 396 static void (*super_post_startup_inferior) (ptid_t ptid);
 397
 398 static void
 399 amd64_linux_child_post_startup_inferior (ptid_t ptid)
 400 {
 401   i386_cleanup_dregs ();
 402   super_post_startup_inferior (ptid);
 403 }
 404 \f
 405
 406 /* When GDB is built as a 64-bit application on linux, the
 407    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
 408    debugging a 32-bit inferior with a 64-bit GDB should look the same
 409    as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit
 410    conversion in-place ourselves.  */
 411
 412 /* These types below (compat_*) define a siginfo type that is layout
 413    compatible with the siginfo type exported by the 32-bit userspace
 414    support.  */
 415
 416 typedef int compat_int_t;
 417 typedef unsigned int compat_uptr_t;
 418
 419 typedef int compat_time_t;
 420 typedef int compat_timer_t;
 421 typedef int compat_clock_t;
 422
 423 struct compat_timeval
 424 {
 425   compat_time_t tv_sec;
 426   int tv_usec;
 427 };
 428
 429 typedef union compat_sigval
 430 {
 431   compat_int_t sival_int;
 432   compat_uptr_t sival_ptr;
 433 } compat_sigval_t;
 434
 435 typedef struct compat_siginfo
 436 {
 437   int si_signo;
 438   int si_errno;
 439   int si_code;
 440
 441   union
 442   {
 443     int _pad[((128 / sizeof (int)) - 3)];
 444
 445     /* kill() */
 446     struct
 447     {
 448       unsigned int _pid;
 449       unsigned int _uid;
 450     } _kill;
 451
 452     /* POSIX.1b timers */
 453     struct
 454     {
 455       compat_timer_t _tid;
 456       int _overrun;
 457       compat_sigval_t _sigval;
 458     } _timer;
 459
 460     /* POSIX.1b signals */
 461     struct
 462     {
 463       unsigned int _pid;
 464       unsigned int _uid;
 465       compat_sigval_t _sigval;
 466     } _rt;
 467
 468     /* SIGCHLD */
 469     struct
 470     {
 471       unsigned int _pid;
 472       unsigned int _uid;
 473       int _status;
 474       compat_clock_t _utime;
 475       compat_clock_t _stime;
 476     } _sigchld;
 477
 478     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 479     struct
 480     {
 481       unsigned int _addr;
 482     } _sigfault;
 483
 484     /* SIGPOLL */
 485     struct
 486     {
 487       int _band;
 488       int _fd;
 489     } _sigpoll;
 490   } _sifields;
 491 } compat_siginfo_t;
 492
 493 #define cpt_si_pid _sifields._kill._pid
 494 #define cpt_si_uid _sifields._kill._uid
 495 #define cpt_si_timerid _sifields._timer._tid
 496 #define cpt_si_overrun _sifields._timer._overrun
 497 #define cpt_si_status _sifields._sigchld._status
 498 #define cpt_si_utime _sifields._sigchld._utime
 499 #define cpt_si_stime _sifields._sigchld._stime
 500 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
 501 #define cpt_si_addr _sifields._sigfault._addr
 502 #define cpt_si_band _sifields._sigpoll._band
 503 #define cpt_si_fd _sifields._sigpoll._fd
 504
 505 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
 506    In their place is si_timer1,si_timer2.  */
 507 #ifndef si_timerid
 508 #define si_timerid si_timer1
 509 #endif
 510 #ifndef si_overrun
 511 #define si_overrun si_timer2
 512 #endif
 513
 514 static void
 515 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
 516 {
 517   memset (to, 0, sizeof (*to));
 518
 519   to->si_signo = from->si_signo;
 520   to->si_errno = from->si_errno;
 521   to->si_code = from->si_code;
 522
 523   if (to->si_code < 0)
 524     {
 525       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 526     }
 527   else if (to->si_code == SI_USER)
 528     {
 529       to->cpt_si_pid = from->si_pid;
 530       to->cpt_si_uid = from->si_uid;
 531     }
 532   else if (to->si_code == SI_TIMER)
 533     {
 534       to->cpt_si_timerid = from->si_timerid;
 535       to->cpt_si_overrun = from->si_overrun;
 536       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 537     }
 538   else
 539     {
 540       switch (to->si_signo)
 541         {
 542         case SIGCHLD:
 543           to->cpt_si_pid = from->si_pid;
 544           to->cpt_si_uid = from->si_uid;
 545           to->cpt_si_status = from->si_status;
 546           to->cpt_si_utime = from->si_utime;
 547           to->cpt_si_stime = from->si_stime;
 548           break;
 549         case SIGILL:
 550         case SIGFPE:
 551         case SIGSEGV:
 552         case SIGBUS:
 553           to->cpt_si_addr = (intptr_t) from->si_addr;
 554           break;
 555         case SIGPOLL:
 556           to->cpt_si_band = from->si_band;
 557           to->cpt_si_fd = from->si_fd;
 558           break;
 559         default:
 560           to->cpt_si_pid = from->si_pid;
 561           to->cpt_si_uid = from->si_uid;
 562           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 563           break;
 564         }
 565     }
 566 }
 567
 568 static void
 569 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
 570 {
 571   memset (to, 0, sizeof (*to));
 572
 573   to->si_signo = from->si_signo;
 574   to->si_errno = from->si_errno;
 575   to->si_code = from->si_code;
 576
 577   if (to->si_code < 0)
 578     {
 579       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 580     }
 581   else if (to->si_code == SI_USER)
 582     {
 583       to->si_pid = from->cpt_si_pid;
 584       to->si_uid = from->cpt_si_uid;
 585     }
 586   else if (to->si_code == SI_TIMER)
 587     {
 588       to->si_timerid = from->cpt_si_timerid;
 589       to->si_overrun = from->cpt_si_overrun;
 590       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 591     }
 592   else
 593     {
 594       switch (to->si_signo)
 595         {
 596         case SIGCHLD:
 597           to->si_pid = from->cpt_si_pid;
 598           to->si_uid = from->cpt_si_uid;
 599           to->si_status = from->cpt_si_status;
 600           to->si_utime = from->cpt_si_utime;
 601           to->si_stime = from->cpt_si_stime;
 602           break;
 603         case SIGILL:
 604         case SIGFPE:
 605         case SIGSEGV:
 606         case SIGBUS:
 607           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 608           break;
 609         case SIGPOLL:
 610           to->si_band = from->cpt_si_band;
 611           to->si_fd = from->cpt_si_fd;
 612           break;
 613         default:
 614           to->si_pid = from->cpt_si_pid;
 615           to->si_uid = from->cpt_si_uid;
 616           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 617           break;
 618         }
 619     }
 620 }
 621
 622 /* Convert a native/host siginfo object, into/from the siginfo in the
 623    layout of the inferiors' architecture.  Returns true if any
 624    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 625    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 626    INF.  */
 627
 628 static int
 629 amd64_linux_siginfo_fixup (struct siginfo *native, gdb_byte *inf, int direction)
 630 {
 631   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
 632      object.  */
 633   if (gdbarch_addr_bit (get_frame_arch (get_current_frame ())) == 32)
 634     {
 635       gdb_assert (sizeof (struct siginfo) == sizeof (compat_siginfo_t));
 636
 637       if (direction == 0)
 638         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
 639       else
 640         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
 641
 642       return 1;
 643     }
 644   else
 645     return 0;
 646 }
 647
 648 /* Provide a prototype to silence -Wmissing-prototypes.  */
 649 void _initialize_amd64_linux_nat (void);
 650
 651 void
 652 _initialize_amd64_linux_nat (void)
 653 {
 654   struct target_ops *t;
 655
 656   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
 657   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
 658   amd64_native_gregset64_reg_offset = amd64_linux_gregset64_reg_offset;
 659   amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS;
 660
 661   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
 662               == amd64_native_gregset32_num_regs);
 663   gdb_assert (ARRAY_SIZE (amd64_linux_gregset64_reg_offset)
 664               == amd64_native_gregset64_num_regs);
 665
 666   /* Fill in the generic GNU/Linux methods.  */
 667   t = linux_target ();
 668
 669   i386_use_watchpoints (t);
 670
 671   i386_dr_low.set_control = amd64_linux_dr_set_control;
 672   i386_dr_low.set_addr = amd64_linux_dr_set_addr;
 673   i386_dr_low.reset_addr = amd64_linux_dr_reset_addr;
 674   i386_dr_low.get_status = amd64_linux_dr_get_status;
 675   i386_set_debug_register_length (8);
 676
 677   /* Override the GNU/Linux inferior startup hook.  */
 678   super_post_startup_inferior = t->to_post_startup_inferior;
 679   t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
 680
 681   /* Add our register access methods.  */
 682   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
 683   t->to_store_registers = amd64_linux_store_inferior_registers;
 684
 685   /* Register the target.  */
 686   linux_nat_add_target (t);
 687   linux_nat_set_new_thread (t, amd64_linux_new_thread);
 688   linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup);
 689 }