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