gnu/dist/gdb6/gdb/amd64-linux-nat.c

   1 /* Native-dependent code for GNU/Linux x86-64.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
   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 2 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, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "gdbcore.h"
  27 #include "regcache.h"
  28 #include "linux-nat.h"
  29
  30 #include "gdb_assert.h"
  31 #include "gdb_string.h"
  32 #include <sys/ptrace.h>
  33 #include <sys/debugreg.h>
  34 #include <sys/syscall.h>
  35 #include <sys/procfs.h>
  36 #include <asm/prctl.h>
  37 /* FIXME ezannoni-2003-07-09: we need <sys/reg.h> to be included after
  38    <asm/ptrace.h> because the latter redefines FS and GS for no apparent
  39    reason, and those definitions don't match the ones that libpthread_db
  40    uses, which come from <sys/reg.h>.  */
  41 /* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have
  42    been removed from ptrace.h in the kernel.  However, better safe than
  43    sorry.  */
  44 #include <asm/ptrace.h>
  45 #include <sys/reg.h>
  46 #include "gdb_proc_service.h"
  47
  48 /* Prototypes for supply_gregset etc.  */
  49 #include "gregset.h"
  50
  51 #include "amd64-tdep.h"
  52 #include "i386-linux-tdep.h"
  53 #include "amd64-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 };
  73 \f
  74
  75 /* Mapping between the general-purpose registers in GNU/Linux x86-64
  76    `struct user' format and GDB's register cache layout for GNU/Linux
  77    i386.
  78
  79    Note that most GNU/Linux x86-64 registers are 64-bit, while the
  80    GNU/Linux i386 registers are all 32-bit, but since we're
  81    little-endian we get away with that.  */
  82
  83 /* From <sys/reg.h> on GNU/Linux i386.  */
  84 static int amd64_linux_gregset32_reg_offset[] =
  85 {
  86   RAX * 8, RCX * 8,             /* %eax, %ecx */
  87   RDX * 8, RBX * 8,             /* %edx, %ebx */
  88   RSP * 8, RBP * 8,             /* %esp, %ebp */
  89   RSI * 8, RDI * 8,             /* %esi, %edi */
  90   RIP * 8, EFLAGS * 8,          /* %eip, %eflags */
  91   CS * 8, SS * 8,               /* %cs, %ss */
  92   DS * 8, ES * 8,               /* %ds, %es */
  93   FS * 8, GS * 8,               /* %fs, %gs */
  94   -1, -1, -1, -1, -1, -1, -1, -1,
  95   -1, -1, -1, -1, -1, -1, -1, -1,
  96   -1, -1, -1, -1, -1, -1, -1, -1, -1,
  97   ORIG_RAX * 8                  /* "orig_eax" */
  98 };
  99 \f
 100
 101 /* Transfering the general-purpose registers between GDB, inferiors
 102    and core files.  */
 103
 104 /* Fill GDB's register cache with the general-purpose register values
 105    in *GREGSETP.  */
 106
 107 void
 108 supply_gregset (elf_gregset_t *gregsetp)
 109 {
 110   amd64_supply_native_gregset (current_regcache, gregsetp, -1);
 111 }
 112
 113 /* Fill register REGNUM (if it is a general-purpose register) in
 114    *GREGSETP with the value in GDB's register cache.  If REGNUM is -1,
 115    do this for all registers.  */
 116
 117 void
 118 fill_gregset (elf_gregset_t *gregsetp, int regnum)
 119 {
 120   amd64_collect_native_gregset (current_regcache, gregsetp, regnum);
 121 }
 122
 123 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 124
 125 /* Fill GDB's register cache with the floating-point and SSE register
 126    values in *FPREGSETP.  */
 127
 128 void
 129 supply_fpregset (elf_fpregset_t *fpregsetp)
 130 {
 131   amd64_supply_fxsave (current_regcache, -1, fpregsetp);
 132 }
 133
 134 /* Fill register REGNUM (if it is a floating-point or SSE register) in
 135    *FPREGSETP with the value in GDB's register cache.  If REGNUM is
 136    -1, do this for all registers.  */
 137
 138 void
 139 fill_fpregset (elf_fpregset_t *fpregsetp, int regnum)
 140 {
 141   amd64_collect_fxsave (current_regcache, regnum, fpregsetp);
 142 }
 143 \f
 144
 145 /* Transferring arbitrary registers between GDB and inferior.  */
 146
 147 /* Fetch register REGNUM from the child process.  If REGNUM is -1, do
 148    this for all registers (including the floating point and SSE
 149    registers).  */
 150
 151 static void
 152 amd64_linux_fetch_inferior_registers (int regnum)
 153 {
 154   int tid;
 155
 156   /* GNU/Linux LWP ID's are process ID's.  */
 157   tid = TIDGET (inferior_ptid);
 158   if (tid == 0)
 159     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 160
 161   if (regnum == -1 || amd64_native_gregset_supplies_p (regnum))
 162     {
 163       elf_gregset_t regs;
 164
 165       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 166         perror_with_name (_("Couldn't get registers"));
 167
 168       amd64_supply_native_gregset (current_regcache, &regs, -1);
 169       if (regnum != -1)
 170         return;
 171     }
 172
 173   if (regnum == -1 || !amd64_native_gregset_supplies_p (regnum))
 174     {
 175       elf_fpregset_t fpregs;
 176
 177       if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 178         perror_with_name (_("Couldn't get floating point status"));
 179
 180       amd64_supply_fxsave (current_regcache, -1, &fpregs);
 181     }
 182 }
 183
 184 /* Store register REGNUM back into the child process.  If REGNUM is
 185    -1, do this for all registers (including the floating-point and SSE
 186    registers).  */
 187
 188 static void
 189 amd64_linux_store_inferior_registers (int regnum)
 190 {
 191   int tid;
 192
 193   /* GNU/Linux LWP ID's are process ID's.  */
 194   tid = TIDGET (inferior_ptid);
 195   if (tid == 0)
 196     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 197
 198   if (regnum == -1 || amd64_native_gregset_supplies_p (regnum))
 199     {
 200       elf_gregset_t regs;
 201
 202       if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 203         perror_with_name (_("Couldn't get registers"));
 204
 205       amd64_collect_native_gregset (current_regcache, &regs, regnum);
 206
 207       if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
 208         perror_with_name (_("Couldn't write registers"));
 209
 210       if (regnum != -1)
 211         return;
 212     }
 213
 214   if (regnum == -1 || !amd64_native_gregset_supplies_p (regnum))
 215     {
 216       elf_fpregset_t fpregs;
 217
 218       if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 219         perror_with_name (_("Couldn't get floating point status"));
 220
 221       amd64_collect_fxsave (current_regcache, regnum, &fpregs);
 222
 223       if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
 224         perror_with_name (_("Couldn't write floating point status"));
 225
 226       return;
 227     }
 228 }
 229 \f
 230
 231 static unsigned long
 232 amd64_linux_dr_get (int regnum)
 233 {
 234   int tid;
 235   unsigned long value;
 236
 237   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
 238      multi-threaded processes here.  For now, pretend there is just
 239      one thread.  */
 240   tid = PIDGET (inferior_ptid);
 241
 242   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
 243      ptrace call fails breaks debugging remote targets.  The correct
 244      way to fix this is to add the hardware breakpoint and watchpoint
 245      stuff to the target vectore.  For now, just return zero if the
 246      ptrace call fails.  */
 247   errno = 0;
 248   value = ptrace (PT_READ_U, tid,
 249                   offsetof (struct user, u_debugreg[regnum]), 0);
 250   if (errno != 0)
 251 #if 0
 252     perror_with_name (_("Couldn't read debug register"));
 253 #else
 254     return 0;
 255 #endif
 256
 257   return value;
 258 }
 259
 260 static void
 261 amd64_linux_dr_set (int regnum, unsigned long value)
 262 {
 263   int tid;
 264
 265   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
 266      multi-threaded processes here.  For now, pretend there is just
 267      one thread.  */
 268   tid = PIDGET (inferior_ptid);
 269
 270   errno = 0;
 271   ptrace (PT_WRITE_U, tid, offsetof (struct user, u_debugreg[regnum]), value);
 272   if (errno != 0)
 273     perror_with_name (_("Couldn't write debug register"));
 274 }
 275
 276 void
 277 amd64_linux_dr_set_control (unsigned long control)
 278 {
 279   amd64_linux_dr_set (DR_CONTROL, control);
 280 }
 281
 282 void
 283 amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
 284 {
 285   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 286
 287   amd64_linux_dr_set (DR_FIRSTADDR + regnum, addr);
 288 }
 289
 290 void
 291 amd64_linux_dr_reset_addr (int regnum)
 292 {
 293   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 294
 295   amd64_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
 296 }
 297
 298 unsigned long
 299 amd64_linux_dr_get_status (void)
 300 {
 301   return amd64_linux_dr_get (DR_STATUS);
 302 }
 303 \f
 304
 305 /* This function is called by libthread_db as part of its handling of
 306    a request for a thread's local storage address.  */
 307
 308 ps_err_e
 309 ps_get_thread_area (const struct ps_prochandle *ph,
 310                     lwpid_t lwpid, int idx, void **base)
 311 {
 312   if (gdbarch_ptr_bit (current_gdbarch) == 32)
 313     {
 314       /* The full structure is found in <asm-i386/ldt.h>.  The second
 315          integer is the LDT's base_address and that is used to locate
 316          the thread's local storage.  See i386-linux-nat.c more
 317          info.  */
 318       unsigned int desc[4];
 319
 320       /* This code assumes that "int" is 32 bits and that
 321          GET_THREAD_AREA returns no more than 4 int values.  */
 322       gdb_assert (sizeof (int) == 4);
 323 #ifndef PTRACE_GET_THREAD_AREA
 324 #define PTRACE_GET_THREAD_AREA 25
 325 #endif
 326       if  (ptrace (PTRACE_GET_THREAD_AREA,
 327                    lwpid, (void *) (long) idx, (unsigned long) &desc) < 0)
 328         return PS_ERR;
 329
 330       /* Extend the value to 64 bits.  Here it's assumed that a "long"
 331          and a "void *" are the same.  */
 332       (*base) = (void *) (long) desc[1];
 333       return PS_OK;
 334     }
 335   else
 336     {
 337       /* This definition comes from prctl.h, but some kernels may not
 338          have it.  */
 339 #ifndef PTRACE_ARCH_PRCTL
 340 #define PTRACE_ARCH_PRCTL      30
 341 #endif
 342       /* FIXME: ezannoni-2003-07-09 see comment above about include
 343          file order.  We could be getting bogus values for these two.  */
 344       gdb_assert (FS < ELF_NGREG);
 345       gdb_assert (GS < ELF_NGREG);
 346       switch (idx)
 347         {
 348         case FS:
 349           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 350             return PS_OK;
 351           break;
 352         case GS:
 353           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 354             return PS_OK;
 355           break;
 356         default:                   /* Should not happen.  */
 357           return PS_BADADDR;
 358         }
 359     }
 360   return PS_ERR;               /* ptrace failed.  */
 361 }
 362 \f
 363
 364 static void (*super_post_startup_inferior) (ptid_t ptid);
 365
 366 static void
 367 amd64_linux_child_post_startup_inferior (ptid_t ptid)
 368 {
 369   i386_cleanup_dregs ();
 370   super_post_startup_inferior (ptid);
 371 }
 372 \f
 373
 374 /* Provide a prototype to silence -Wmissing-prototypes.  */
 375 void _initialize_amd64_linux_nat (void);
 376
 377 void
 378 _initialize_amd64_linux_nat (void)
 379 {
 380   struct target_ops *t;
 381
 382   amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset;
 383   amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS;
 384   amd64_native_gregset64_reg_offset = amd64_linux_gregset64_reg_offset;
 385
 386   gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset)
 387               == amd64_native_gregset32_num_regs);
 388   gdb_assert (ARRAY_SIZE (amd64_linux_gregset64_reg_offset)
 389               == amd64_native_gregset64_num_regs);
 390
 391   /* Fill in the generic GNU/Linux methods.  */
 392   t = linux_target ();
 393
 394   /* Override the GNU/Linux inferior startup hook.  */
 395   super_post_startup_inferior = t->to_post_startup_inferior;
 396   t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior;
 397
 398   /* Add our register access methods.  */
 399   t->to_fetch_registers = amd64_linux_fetch_inferior_registers;
 400   t->to_store_registers = amd64_linux_store_inferior_registers;
 401
 402   /* Register the target.  */
 403   linux_nat_add_target (t);
 404 }