gdb/x86-64-linux-nat.c

   1 /* Native-dependent code for Linux/x86-64.
   2
   3    Copyright 2001, 2002 Free Software Foundation, Inc.
   4
   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., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "inferior.h"
  26 #include "gdbcore.h"
  27 #include "regcache.h"
  28 #include "i387-nat.h"
  29 #include "gdb_assert.h"
  30 #include "x86-64-tdep.h"
  31
  32 #include <sys/ptrace.h>
  33 #include <sys/debugreg.h>
  34 #include <sys/syscall.h>
  35 #include <sys/procfs.h>
  36
  37 static unsigned long
  38 x86_64_linux_dr_get (int regnum)
  39 {
  40   int tid;
  41   unsigned long value;
  42
  43   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
  44      multi-threaded processes here.  For now, pretend there is just
  45      one thread.  */
  46   tid = PIDGET (inferior_ptid);
  47
  48   /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
  49      ptrace call fails breaks debugging remote targets.  The correct
  50      way to fix this is to add the hardware breakpoint and watchpoint
  51      stuff to the target vectore.  For now, just return zero if the
  52      ptrace call fails.  */
  53   errno = 0;
  54   value = ptrace (PT_READ_U, tid,
  55                   offsetof (struct user, u_debugreg[regnum]), 0);
  56   if (errno != 0)
  57 #if 0
  58     perror_with_name ("Couldn't read debug register");
  59 #else
  60     return 0;
  61 #endif
  62
  63   return value;
  64 }
  65
  66 static void
  67 x86_64_linux_dr_set (int regnum, unsigned long value)
  68 {
  69   int tid;
  70
  71   /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
  72      multi-threaded processes here.  For now, pretend there is just
  73      one thread.  */
  74   tid = PIDGET (inferior_ptid);
  75
  76   errno = 0;
  77   ptrace (PT_WRITE_U, tid,
  78           offsetof (struct user, u_debugreg[regnum]), value);
  79   if (errno != 0)
  80     perror_with_name ("Couldn't write debug register");
  81 }
  82
  83 void
  84 x86_64_linux_dr_set_control (unsigned long control)
  85 {
  86   x86_64_linux_dr_set (DR_CONTROL, control);
  87 }
  88
  89 void
  90 x86_64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
  91 {
  92   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
  93
  94   x86_64_linux_dr_set (DR_FIRSTADDR + regnum, addr);
  95 }
  96
  97 void
  98 x86_64_linux_dr_reset_addr (int regnum)
  99 {
 100   gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
 101
 102   x86_64_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
 103 }
 104
 105 unsigned long
 106 x86_64_linux_dr_get_status (void)
 107 {
 108   return x86_64_linux_dr_get (DR_STATUS);
 109 }
 110 \f
 111
 112 /* The register sets used in Linux ELF core-dumps are identical to the
 113    register sets used by `ptrace'.  */
 114
 115 #define GETREGS_SUPPLIES(regno) \
 116   (0 <= (regno) && (regno) <= 17)
 117 #define GETFPREGS_SUPPLIES(regno) \
 118   (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
 119
 120 #define PTRACE_XFER_TYPE unsigned long
 121 \f
 122
 123 /* Transfering the general-purpose registers between GDB, inferiors
 124    and core files.  */
 125
 126 /* Fill GDB's register array with the general-purpose register values
 127    in *GREGSETP.  */
 128
 129 void
 130 supply_gregset (elf_gregset_t * gregsetp)
 131 {
 132   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 133   int i;
 134
 135   for (i = 0; i < X86_64_NUM_GREGS; i++)
 136     supply_register (i, (char *) (regp + x86_64_regmap[i]));
 137 }
 138
 139 /* Fill register REGNO (if it is a general-purpose register) in
 140    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 141    do this for all registers.  */
 142
 143 void
 144 fill_gregset (elf_gregset_t * gregsetp, int regno)
 145 {
 146   elf_greg_t *regp = (elf_greg_t *) gregsetp;
 147   int i;
 148
 149   for (i = 0; i < X86_64_NUM_GREGS; i++)
 150     if ((regno == -1 || regno == i))
 151       read_register_gen (i, regp + x86_64_regmap[i]);
 152 }
 153
 154 /* Fetch all general-purpose registers from process/thread TID and
 155    store their values in GDB's register array.  */
 156
 157 static void
 158 fetch_regs (int tid)
 159 {
 160   elf_gregset_t regs;
 161
 162   if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 163       perror_with_name ("Couldn't get registers");
 164
 165   supply_gregset (&regs);
 166 }
 167
 168 /* Store all valid general-purpose registers in GDB's register array
 169    into the process/thread specified by TID.  */
 170
 171 static void
 172 store_regs (int tid, int regno)
 173 {
 174   elf_gregset_t regs;
 175
 176   if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
 177     perror_with_name ("Couldn't get registers");
 178
 179   fill_gregset (&regs, regno);
 180
 181   if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
 182     perror_with_name ("Couldn't write registers");
 183 }
 184 \f
 185
 186 /* Transfering floating-point registers between GDB, inferiors and cores.  */
 187
 188 /* Fill GDB's register array with the floating-point register values in
 189    *FPREGSETP.  */
 190
 191 void
 192 supply_fpregset (elf_fpregset_t * fpregsetp)
 193 {
 194   i387_supply_fxsave ((char *) fpregsetp);
 195 }
 196
 197 /* Fill register REGNO (if it is a floating-point register) in
 198    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 199    do this for all registers.  */
 200
 201 void
 202 fill_fpregset (elf_fpregset_t * fpregsetp, int regno)
 203 {
 204   i387_fill_fxsave ((char *) fpregsetp, regno);
 205 }
 206
 207 /* Fetch all floating-point registers from process/thread TID and store
 208    thier values in GDB's register array.  */
 209
 210 static void
 211 fetch_fpregs (int tid)
 212 {
 213   elf_fpregset_t fpregs;
 214
 215   if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
 216     perror_with_name ("Couldn't get floating point status");
 217
 218   supply_fpregset (&fpregs);
 219 }
 220
 221 /* Store all valid floating-point registers in GDB's register array
 222    into the process/thread specified by TID.  */
 223
 224 static void
 225 store_fpregs (int tid, int regno)
 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   fill_fpregset (&fpregs, regno);
 233
 234   if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
 235     perror_with_name ("Couldn't write floating point status");
 236 }
 237 \f
 238
 239 /* Transferring arbitrary registers between GDB and inferior.  */
 240
 241 /* Fetch register REGNO from the child process.  If REGNO is -1, do
 242    this for all registers (including the floating point and SSE
 243    registers).  */
 244
 245 void
 246 fetch_inferior_registers (int regno)
 247 {
 248   int tid;
 249
 250   /* Linux LWP ID's are process ID's.  */
 251   if ((tid = TIDGET (inferior_ptid)) == 0)
 252     tid = PIDGET (inferior_ptid);       /* Not a threaded program.  */
 253
 254   if (regno == -1)
 255     {
 256       fetch_regs (tid);
 257       fetch_fpregs (tid);
 258       return;
 259     }
 260
 261   if (GETREGS_SUPPLIES (regno))
 262     {
 263       fetch_regs (tid);
 264       return;
 265     }
 266
 267   if (GETFPREGS_SUPPLIES (regno))
 268     {
 269       fetch_fpregs (tid);
 270       return;
 271     }
 272
 273   internal_error (__FILE__, __LINE__,
 274                   "Got request for bad register number %d.", regno);
 275 }
 276
 277 /* Store register REGNO back into the child process.  If REGNO is -1,
 278    do this for all registers (including the floating point and SSE
 279    registers).  */
 280 void
 281 store_inferior_registers (int regno)
 282 {
 283   int tid;
 284
 285   /* Linux LWP ID's are process ID's.  */
 286   if ((tid = TIDGET (inferior_ptid)) == 0)
 287     tid = PIDGET (inferior_ptid);       /* Not a threaded program.  */
 288
 289   if (regno == -1)
 290     {
 291       store_regs (tid, regno);
 292       store_fpregs (tid, regno);
 293       return;
 294     }
 295
 296   if (GETREGS_SUPPLIES (regno))
 297     {
 298       store_regs (tid, regno);
 299       return;
 300     }
 301
 302   if (GETFPREGS_SUPPLIES (regno))
 303     {
 304       store_fpregs (tid, regno);
 305       return;
 306     }
 307
 308   internal_error (__FILE__, __LINE__,
 309                   "Got request to store bad register number %d.", regno);
 310 }
 311 \f
 312
 313 static const unsigned char linux_syscall[] = { 0x0f, 0x05 };
 314
 315 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
 316
 317 /* The system call number is stored in the %rax register.  */
 318 #define LINUX_SYSCALL_REGNUM 0  /* %rax */
 319
 320 /* We are specifically interested in the sigreturn and rt_sigreturn
 321    system calls.  */
 322
 323 #ifndef SYS_sigreturn
 324 #define SYS_sigreturn           __NR_sigreturn
 325 #endif
 326 #ifndef SYS_rt_sigreturn
 327 #define SYS_rt_sigreturn        __NR_rt_sigreturn
 328 #endif
 329
 330 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
 331 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (152)
 332 /* Offset to saved processor registers from <asm/ucontext.h> */
 333 #define LINUX_UCONTEXT_SIGCONTEXT_OFFSET (36)
 334
 335 /* Resume execution of the inferior process.
 336    If STEP is nonzero, single-step it.
 337    If SIGNAL is nonzero, give it that signal.  */
 338
 339 void
 340 child_resume (ptid_t ptid, int step, enum target_signal signal)
 341 {
 342   int pid = PIDGET (ptid);
 343   int request = PTRACE_CONT;
 344
 345   if (pid == -1)
 346     /* Resume all threads.  */
 347     /* I think this only gets used in the non-threaded case, where "resume
 348        all threads" and "resume inferior_ptid" are the same.  */
 349     pid = PIDGET (inferior_ptid);
 350
 351   if (step)
 352     {
 353       CORE_ADDR pc = read_pc_pid (pid_to_ptid (pid));
 354       unsigned char buf[LINUX_SYSCALL_LEN];
 355
 356       request = PTRACE_SINGLESTEP;
 357
 358       /* Returning from a signal trampoline is done by calling a
 359          special system call (sigreturn or rt_sigreturn, see
 360          i386-linux-tdep.c for more information).  This system call
 361          restores the registers that were saved when the signal was
 362          raised, including %eflags.  That means that single-stepping
 363          won't work.  Instead, we'll have to modify the signal context
 364          that's about to be restored, and set the trace flag there.  */
 365
 366       /* First check if PC is at a system call.  */
 367       if (read_memory_nobpt (pc, (char *) buf, LINUX_SYSCALL_LEN) == 0
 368           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
 369         {
 370           int syscall =
 371             read_register_pid (LINUX_SYSCALL_REGNUM, pid_to_ptid (pid));
 372
 373           /* Then check the system call number.  */
 374           if (syscall == SYS_rt_sigreturn)
 375             {
 376               CORE_ADDR sp = read_register (SP_REGNUM);
 377               CORE_ADDR addr = sp;
 378               unsigned long int eflags;
 379
 380               addr +=
 381                 sizeof (struct siginfo) + LINUX_UCONTEXT_SIGCONTEXT_OFFSET;
 382
 383               /* Set the trace flag in the context that's about to be
 384                  restored.  */
 385               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
 386               read_memory (addr, (char *) &eflags, 8);
 387               eflags |= 0x0100;
 388               write_memory (addr, (char *) &eflags, 8);
 389             }
 390         }
 391     }
 392
 393   if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
 394     perror_with_name ("ptrace");
 395 }
 396 \f
 397
 398 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 399    to debugger memory starting at MYADDR.   Copy to inferior if
 400    WRITE is nonzero.  TARGET is ignored.
 401
 402    Returns the length copied, which is either the LEN argument or zero.
 403    This xfer function does not do partial moves, since child_ops
 404    doesn't allow memory operations to cross below us in the target stack
 405    anyway.  */
 406
 407 int
 408 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 409                    struct mem_attrib *attrib, struct target_ops *target)
 410 {
 411   register int i;
 412   /* Round starting address down to longword boundary.  */
 413   register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);
 414   /* Round ending address up; get number of longwords that makes.  */
 415   register int count
 416     = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
 417     / sizeof (PTRACE_XFER_TYPE);
 418   /* Allocate buffer of that many longwords.  */
 419   /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
 420      because it uses alloca to allocate a buffer of arbitrary size.
 421      For very large xfers, this could crash GDB's stack.  */
 422   register PTRACE_XFER_TYPE *buffer
 423     = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
 424
 425   if (write)
 426     {
 427       /* Fill start and end extra bytes of buffer with existing memory data.  */
 428       if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE))
 429         {
 430           /* Need part of initial word -- fetch it.  */
 431           ptrace (PT_READ_I, PIDGET (inferior_ptid),
 432                   (PTRACE_ARG3_TYPE) addr, buffer);
 433         }
 434
 435       if (count > 1)            /* FIXME, avoid if even boundary */
 436         {
 437           ptrace (PT_READ_I, PIDGET (inferior_ptid),
 438                   ((PTRACE_ARG3_TYPE)
 439                    (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
 440                   buffer + count - 1);
 441         }
 442
 443       /* Copy data to be written over corresponding part of buffer */
 444
 445       memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
 446               myaddr, len);
 447
 448       /* Write the entire buffer.  */
 449
 450       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
 451         {
 452           errno = 0;
 453           ptrace (PT_WRITE_D, PIDGET (inferior_ptid),
 454                   (PTRACE_ARG3_TYPE) addr, buffer[i]);
 455           if (errno)
 456             {
 457               /* Using the appropriate one (I or D) is necessary for
 458                  Gould NP1, at least.  */
 459               errno = 0;
 460               ptrace (PT_WRITE_I, PIDGET (inferior_ptid),
 461                       (PTRACE_ARG3_TYPE) addr, buffer[i]);
 462             }
 463           if (errno)
 464             return 0;
 465         }
 466 #ifdef CLEAR_INSN_CACHE
 467       CLEAR_INSN_CACHE ();
 468 #endif
 469     }
 470   else
 471     {
 472       /* Read all the longwords */
 473       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
 474         {
 475           errno = 0;
 476           ptrace (PT_READ_I, PIDGET (inferior_ptid),
 477                   (PTRACE_ARG3_TYPE) addr, buffer + i);
 478           if (errno)
 479             return 0;
 480         }
 481
 482       /* Copy appropriate bytes out of the buffer.  */
 483       memcpy (myaddr,
 484               (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
 485               len);
 486     }
 487   return len;
 488 }
 489
 490 /* Interpreting register set info found in core files.  */
 491
 492 /* Provide registers to GDB from a core file.
 493
 494    CORE_REG_SECT points to an array of bytes, which are the contents
 495    of a `note' from a core file which BFD thinks might contain
 496    register contents.  CORE_REG_SIZE is its size.
 497
 498    WHICH says which register set corelow suspects this is:
 499      0 --- the general-purpose register set, in elf_gregset_t format
 500      2 --- the floating-point register set, in elf_fpregset_t format
 501
 502    REG_ADDR isn't used on Linux.  */
 503
 504 static void
 505 fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
 506                       int which, CORE_ADDR reg_addr)
 507 {
 508   elf_gregset_t gregset;
 509   elf_fpregset_t fpregset;
 510   switch (which)
 511     {
 512     case 0:
 513       if (core_reg_size != sizeof (gregset))
 514         warning ("Wrong size gregset in core file.");
 515       else
 516         {
 517           memcpy (&gregset, core_reg_sect, sizeof (gregset));
 518           supply_gregset (&gregset);
 519         }
 520       break;
 521
 522     case 2:
 523       if (core_reg_size != sizeof (fpregset))
 524         warning ("Wrong size fpregset in core file.");
 525       else
 526         {
 527           memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
 528           supply_fpregset (&fpregset);
 529         }
 530       break;
 531
 532     default:
 533       /* We've covered all the kinds of registers we know about here,
 534          so this must be something we wouldn't know what to do with
 535          anyway.  Just ignore it.  */
 536       break;
 537     }
 538 }
 539
 540 /* Register that we are able to handle Linux ELF core file formats.  */
 541
 542 static struct core_fns linux_elf_core_fns = {
 543   bfd_target_elf_flavour,       /* core_flavour */
 544   default_check_format,         /* check_format */
 545   default_core_sniffer,         /* core_sniffer */
 546   fetch_core_registers,         /* core_read_registers */
 547   NULL                          /* next */
 548 };
 549 \f
 550
 551 #if !defined (offsetof)
 552 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 553 #endif
 554
 555 /* Record the value of the debug control register.  */
 556 static long debug_control_mirror;
 557
 558 /* Record which address associates with which register.  */
 559 static CORE_ADDR address_lookup[DR_LASTADDR - DR_FIRSTADDR + 1];
 560
 561 /* Return the address of register REGNUM.  BLOCKEND is the value of
 562    u.u_ar0, which should point to the registers.  */
 563 CORE_ADDR
 564 x86_64_register_u_addr (CORE_ADDR blockend, int regnum)
 565 {
 566   struct user u;
 567   CORE_ADDR fpstate;
 568   CORE_ADDR ubase;
 569   ubase = blockend;
 570   if (IS_FP_REGNUM(regnum))
 571     {
 572       fpstate = ubase + ((char *) &u.i387.st_space - (char *) &u);
 573       return (fpstate + 16 * (regnum - FP0_REGNUM));
 574     }
 575   else if (IS_SSE_REGNUM(regnum))
 576     {
 577       fpstate = ubase + ((char *) &u.i387.xmm_space - (char *) &u);
 578       return (fpstate + 16 * (regnum - XMM0_REGNUM));
 579     }
 580   else
 581     return (ubase + 8 * x86_64_regmap[regnum]);
 582 }
 583
 584 void
 585 _initialize_x86_64_linux_nat (void)
 586 {
 587   add_core_fns (&linux_elf_core_fns);
 588 }