[thirdparty/binutils-gdb.git] / gdb / x86-64-linux-nat.c

/* Native-dependent code for GNU/Linux x86-64.

   Copyright 2001, 2002, 2003 Free Software Foundation, Inc.

   Contributed by Jiri Smid, SuSE Labs.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "regcache.h"
#include "gdb_assert.h"
#include "gdb_string.h"
#include "x86-64-tdep.h"

#include <sys/ptrace.h>
#include <sys/debugreg.h>
#include <sys/syscall.h>
#include <sys/procfs.h>
#include <sys/reg.h>

/* Mapping between the general-purpose registers in `struct user'
   format and GDB's register array layout.  */

static int x86_64_regmap[] = {
  RAX, RBX, RCX, RDX,
  RSI, RDI, RBP, RSP,
  R8, R9, R10, R11,
  R12, R13, R14, R15,
  RIP, EFLAGS, CS, SS, 
  DS, ES, FS, GS
};

static unsigned long
x86_64_linux_dr_get (int regnum)
{
  int tid;
  unsigned long value;

  /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
     multi-threaded processes here.  For now, pretend there is just
     one thread.  */
  tid = PIDGET (inferior_ptid);

  /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
     ptrace call fails breaks debugging remote targets.  The correct
     way to fix this is to add the hardware breakpoint and watchpoint
     stuff to the target vectore.  For now, just return zero if the
     ptrace call fails.  */
  errno = 0;
  value = ptrace (PT_READ_U, tid,
		  offsetof (struct user, u_debugreg[regnum]), 0);
  if (errno != 0)
#if 0
    perror_with_name ("Couldn't read debug register");
#else
    return 0;
#endif

  return value;
}

static void
x86_64_linux_dr_set (int regnum, unsigned long value)
{
  int tid;

  /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
     multi-threaded processes here.  For now, pretend there is just
     one thread.  */
  tid = PIDGET (inferior_ptid);

  errno = 0;
  ptrace (PT_WRITE_U, tid, offsetof (struct user, u_debugreg[regnum]), value);
  if (errno != 0)
    perror_with_name ("Couldn't write debug register");
}

void
x86_64_linux_dr_set_control (unsigned long control)
{
  x86_64_linux_dr_set (DR_CONTROL, control);
}

void
x86_64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
{
  gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);

  x86_64_linux_dr_set (DR_FIRSTADDR + regnum, addr);
}

void
x86_64_linux_dr_reset_addr (int regnum)
{
  gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);

  x86_64_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
}

unsigned long
x86_64_linux_dr_get_status (void)
{
  return x86_64_linux_dr_get (DR_STATUS);
}
\f

/* The register sets used in GNU/Linux ELF core-dumps are identical to
   the register sets used by `ptrace'.  */

#define GETREGS_SUPPLIES(regno) \
  (0 <= (regno) && (regno) < x86_64_num_gregs)
#define GETFPREGS_SUPPLIES(regno) \
  (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
\f

/* Transfering the general-purpose registers between GDB, inferiors
   and core files.  */

/* Fill GDB's register array with the general-purpose register values
   in *GREGSETP.  */

void
supply_gregset (elf_gregset_t * gregsetp)
{
  elf_greg_t *regp = (elf_greg_t *) gregsetp;
  int i;

  for (i = 0; i < x86_64_num_gregs; i++)
    supply_register (i, (char *) (regp + x86_64_regmap[i]));
}

/* Fill register REGNO (if it is a general-purpose register) in
   *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
   do this for all registers.  */

void
fill_gregset (elf_gregset_t * gregsetp, int regno)
{
  elf_greg_t *regp = (elf_greg_t *) gregsetp;
  int i;

  for (i = 0; i < x86_64_num_gregs; i++)
    if ((regno == -1 || regno == i))
      regcache_collect (i, (char *) (regp + x86_64_regmap[i]));
}

/* Fetch all general-purpose registers from process/thread TID and
   store their values in GDB's register array.  */

static void
fetch_regs (int tid)
{
  elf_gregset_t regs;

  if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
    perror_with_name ("Couldn't get registers");

  supply_gregset (&regs);
}

/* Store all valid general-purpose registers in GDB's register array
   into the process/thread specified by TID.  */

static void
store_regs (int tid, int regno)
{
  elf_gregset_t regs;

  if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
    perror_with_name ("Couldn't get registers");

  fill_gregset (&regs, regno);

  if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
    perror_with_name ("Couldn't write registers");
}
\f

/* Transfering floating-point registers between GDB, inferiors and cores.  */

static void *
x86_64_fxsave_offset (elf_fpregset_t * fxsave, int regnum)
{
  const char *reg_name;
  int reg_index;

  gdb_assert (x86_64_num_gregs - 1 < regnum && regnum < x86_64_num_regs);

  reg_name = x86_64_register_name (regnum);

  if (reg_name[0] == 's' && reg_name[1] == 't')
    {
      reg_index = reg_name[2] - '0';
      return &fxsave->st_space[reg_index * 2];
    }

  if (reg_name[0] == 'x' && reg_name[1] == 'm' && reg_name[2] == 'm')
    {
      reg_index = reg_name[3] - '0';
      return &fxsave->xmm_space[reg_index * 4];
    }

  if (strcmp (reg_name, "mxcsr") == 0)
    return &fxsave->mxcsr;

  return NULL;
}

/* Fill GDB's register array with the floating-point and SSE register
   values in *FXSAVE.  This function masks off any of the reserved
   bits in *FXSAVE.  */

void
supply_fpregset (elf_fpregset_t * fxsave)
{
  int i, reg_st0, reg_mxcsr;

  reg_st0 = x86_64_register_number ("st0");
  reg_mxcsr = x86_64_register_number ("mxcsr");

  gdb_assert (reg_st0 > 0 && reg_mxcsr > reg_st0);

  for (i = reg_st0; i <= reg_mxcsr; i++)
    supply_register (i, x86_64_fxsave_offset (fxsave, i));
}

/* Fill register REGNUM (if it is a floating-point or SSE register) in
   *FXSAVE with the value in GDB's register array.  If REGNUM is -1, do
   this for all registers.  This function doesn't touch any of the
   reserved bits in *FXSAVE.  */

void
fill_fpregset (elf_fpregset_t * fxsave, int regnum)
{
  int i, last_regnum = MXCSR_REGNUM;
  void *ptr;

  if (gdbarch_tdep (current_gdbarch)->num_xmm_regs == 0)
    last_regnum = FOP_REGNUM;

  for (i = FP0_REGNUM; i <= last_regnum; i++)
    if (regnum == -1 || regnum == i)
      {
	ptr = x86_64_fxsave_offset (fxsave, i);
	if (ptr)
	  regcache_collect (i, ptr);
      }
}

/* Fetch all floating-point registers from process/thread TID and store
   thier values in GDB's register array.  */

static void
fetch_fpregs (int tid)
{
  elf_fpregset_t fpregs;

  if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
    perror_with_name ("Couldn't get floating point status");

  supply_fpregset (&fpregs);
}

/* Store all valid floating-point registers in GDB's register array
   into the process/thread specified by TID.  */

static void
store_fpregs (int tid, int regno)
{
  elf_fpregset_t fpregs;

  if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
    perror_with_name ("Couldn't get floating point status");

  fill_fpregset (&fpregs, regno);

  if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
    perror_with_name ("Couldn't write floating point status");
}
\f

/* Transferring arbitrary registers between GDB and inferior.  */

/* Fetch register REGNO from the child process.  If REGNO is -1, do
   this for all registers (including the floating point and SSE
   registers).  */

void
fetch_inferior_registers (int regno)
{
  int tid;

  /* GNU/Linux LWP ID's are process ID's.  */
  if ((tid = TIDGET (inferior_ptid)) == 0)
    tid = PIDGET (inferior_ptid);	/* Not a threaded program.  */

  if (regno == -1)
    {
      fetch_regs (tid);
      fetch_fpregs (tid);
      return;
    }

  if (GETREGS_SUPPLIES (regno))
    {
      fetch_regs (tid);
      return;
    }

  if (GETFPREGS_SUPPLIES (regno))
    {
      fetch_fpregs (tid);
      return;
    }

  internal_error (__FILE__, __LINE__,
		  "Got request for bad register number %d.", regno);
}

/* Store register REGNO back into the child process.  If REGNO is -1,
   do this for all registers (including the floating point and SSE
   registers).  */
void
store_inferior_registers (int regno)
{
  int tid;

  /* GNU/Linux LWP ID's are process ID's.  */
  if ((tid = TIDGET (inferior_ptid)) == 0)
    tid = PIDGET (inferior_ptid);	/* Not a threaded program.  */

  if (regno == -1)
    {
      store_regs (tid, regno);
      store_fpregs (tid, regno);
      return;
    }

  if (GETREGS_SUPPLIES (regno))
    {
      store_regs (tid, regno);
      return;
    }

  if (GETFPREGS_SUPPLIES (regno))
    {
      store_fpregs (tid, regno);
      return;
    }

  internal_error (__FILE__, __LINE__,
		  "Got request to store bad register number %d.", regno);
}
\f

static const unsigned char linux_syscall[] = { 0x0f, 0x05 };

#define LINUX_SYSCALL_LEN (sizeof linux_syscall)

/* The system call number is stored in the %rax register.  */
#define LINUX_SYSCALL_REGNUM 0	/* %rax */

/* We are specifically interested in the sigreturn and rt_sigreturn
   system calls.  */

#ifndef SYS_sigreturn
#define SYS_sigreturn		__NR_sigreturn
#endif
#ifndef SYS_rt_sigreturn
#define SYS_rt_sigreturn	__NR_rt_sigreturn
#endif

/* Offset to saved processor flags, from <asm/sigcontext.h>.  */
#define LINUX_SIGCONTEXT_EFLAGS_OFFSET (152)
/* Offset to saved processor registers from <asm/ucontext.h> */
#define LINUX_UCONTEXT_SIGCONTEXT_OFFSET (36)

/* Interpreting register set info found in core files.  */
/* Provide registers to GDB from a core file.

   CORE_REG_SECT points to an array of bytes, which are the contents
   of a `note' from a core file which BFD thinks might contain
   register contents.  CORE_REG_SIZE is its size.

   WHICH says which register set corelow suspects this is:
     0 --- the general-purpose register set, in elf_gregset_t format
     2 --- the floating-point register set, in elf_fpregset_t format

   REG_ADDR isn't used on GNU/Linux.  */

static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
		      int which, CORE_ADDR reg_addr)
{
  elf_gregset_t gregset;
  elf_fpregset_t fpregset;
  switch (which)
    {
    case 0:
      if (core_reg_size != sizeof (gregset))
	warning ("Wrong size gregset in core file.");
      else
	{
	  memcpy (&gregset, core_reg_sect, sizeof (gregset));
	  supply_gregset (&gregset);
	}
      break;

    case 2:
      if (core_reg_size != sizeof (fpregset))
	warning ("Wrong size fpregset in core file.");
      else
	{
	  memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
	  supply_fpregset (&fpregset);
	}
      break;

    default:
      /* We've covered all the kinds of registers we know about here,
         so this must be something we wouldn't know what to do with
         anyway.  Just ignore it.  */
      break;
    }
}

/* Register that we are able to handle GNU/Linux ELF core file formats.  */

static struct core_fns linux_elf_core_fns = {
  bfd_target_elf_flavour,	/* core_flavour */
  default_check_format,		/* check_format */
  default_core_sniffer,		/* core_sniffer */
  fetch_core_registers,		/* core_read_registers */
  NULL				/* next */
};
\f

#if !defined (offsetof)
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#endif

/* Return the address of register REGNUM.  BLOCKEND is the value of
   u.u_ar0, which should point to the registers.  */
CORE_ADDR
x86_64_register_u_addr (CORE_ADDR blockend, int regnum)
{
  struct user u;
  CORE_ADDR fpstate;
  CORE_ADDR ubase;
  ubase = blockend;
  if (IS_FP_REGNUM (regnum))
    {
      fpstate = ubase + ((char *) &u.i387.st_space - (char *) &u);
      return (fpstate + 16 * (regnum - FP0_REGNUM));
    }
  else if (IS_SSE_REGNUM (regnum))
    {
      fpstate = ubase + ((char *) &u.i387.xmm_space - (char *) &u);
      return (fpstate + 16 * (regnum - XMM0_REGNUM));
    }
  else
    return (ubase + 8 * x86_64_regmap[regnum]);
}

void
_initialize_x86_64_linux_nat (void)
{
  add_core_fns (&linux_elf_core_fns);
}

int
kernel_u_size (void)
{
  return (sizeof (struct user));
}
Commit	Line	Data
a4b6fc86	1	/* Native-dependent code for GNU/Linux x86-64.
0a65a603	2
1bac305b	3	Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
0a65a603	4
53e95fcf JS	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"
53e95fcf	28	#include "gdb_assert.h"
30d52491	29	#include "gdb_string.h"
53e95fcf JS	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>
33a0a2ac ML	36	#include <sys/reg.h>
	37
	38	/* Mapping between the general-purpose registers in `struct user'
	39	format and GDB's register array layout. */
	40
	41	static int x86_64_regmap[] = {
de220d0f	42	RAX, RBX, RCX, RDX,
33a0a2ac ML	43	RSI, RDI, RBP, RSP,
	44	R8, R9, R10, R11,
	45	R12, R13, R14, R15,
cb7e422f	46	RIP, EFLAGS, CS, SS,
de220d0f	47	DS, ES, FS, GS
33a0a2ac	48	};
53e95fcf JS	49
	50	static unsigned long
	51	x86_64_linux_dr_get (int regnum)
	52	{
	53	int tid;
	54	unsigned long value;
	55
	56	/* FIXME: kettenis/2001-01-29: It's not clear what we should do with
	57	multi-threaded processes here. For now, pretend there is just
	58	one thread. */
	59	tid = PIDGET (inferior_ptid);
	60
	61	/* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
	62	ptrace call fails breaks debugging remote targets. The correct
	63	way to fix this is to add the hardware breakpoint and watchpoint
	64	stuff to the target vectore. For now, just return zero if the
	65	ptrace call fails. */
	66	errno = 0;
	67	value = ptrace (PT_READ_U, tid,
	68	offsetof (struct user, u_debugreg[regnum]), 0);
	69	if (errno != 0)
	70	#if 0
	71	perror_with_name ("Couldn't read debug register");
	72	#else
	73	return 0;
	74	#endif
	75
	76	return value;
	77	}
	78
	79	static void
	80	x86_64_linux_dr_set (int regnum, unsigned long value)
	81	{
	82	int tid;
	83
	84	/* FIXME: kettenis/2001-01-29: It's not clear what we should do with
	85	multi-threaded processes here. For now, pretend there is just
	86	one thread. */
	87	tid = PIDGET (inferior_ptid);
	88
	89	errno = 0;
7b3fabf0	90	ptrace (PT_WRITE_U, tid, offsetof (struct user, u_debugreg[regnum]), value);
53e95fcf JS	91	if (errno != 0)
	92	perror_with_name ("Couldn't write debug register");
	93	}
	94
	95	void
	96	x86_64_linux_dr_set_control (unsigned long control)
	97	{
	98	x86_64_linux_dr_set (DR_CONTROL, control);
	99	}
	100
	101	void
	102	x86_64_linux_dr_set_addr (int regnum, CORE_ADDR addr)
	103	{
	104	gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
	105
	106	x86_64_linux_dr_set (DR_FIRSTADDR + regnum, addr);
	107	}
	108
	109	void
	110	x86_64_linux_dr_reset_addr (int regnum)
	111	{
	112	gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
	113
	114	x86_64_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
	115	}
	116
	117	unsigned long
	118	x86_64_linux_dr_get_status (void)
	119	{
	120	return x86_64_linux_dr_get (DR_STATUS);
	121	}
	122	\f
	123
a4b6fc86 AC	124	/* The register sets used in GNU/Linux ELF core-dumps are identical to
a4b6fc86 AC	125	the register sets used by `ptrace'. */
53e95fcf JS	126
53e95fcf JS	127	#define GETREGS_SUPPLIES(regno) \
de220d0f	128	(0 <= (regno) && (regno) < x86_64_num_gregs)
53e95fcf JS	129	#define GETFPREGS_SUPPLIES(regno) \
53e95fcf JS	130	(FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
53e95fcf JS	131	\f
	132
	133	/* Transfering the general-purpose registers between GDB, inferiors
	134	and core files. */
	135
	136	/* Fill GDB's register array with the general-purpose register values
	137	in GREGSETP. /
	138
	139	void
	140	supply_gregset (elf_gregset_t * gregsetp)
	141	{
	142	elf_greg_t regp = (elf_greg_t ) gregsetp;
	143	int i;
	144
de220d0f	145	for (i = 0; i < x86_64_num_gregs; i++)
53e95fcf JS	146	supply_register (i, (char *) (regp + x86_64_regmap[i]));
	147	}
	148
	149	/* Fill register REGNO (if it is a general-purpose register) in
	150	*GREGSETPS with the value in GDB's register array. If REGNO is -1,
	151	do this for all registers. */
	152
	153	void
	154	fill_gregset (elf_gregset_t * gregsetp, int regno)
	155	{
	156	elf_greg_t regp = (elf_greg_t ) gregsetp;
	157	int i;
	158
de220d0f	159	for (i = 0; i < x86_64_num_gregs; i++)
53e95fcf	160	if ((regno == -1 \|\| regno == i))
48037ead	161	regcache_collect (i, (char *) (regp + x86_64_regmap[i]));
53e95fcf JS	162	}
	163
	164	/* Fetch all general-purpose registers from process/thread TID and
	165	store their values in GDB's register array. */
	166
	167	static void
	168	fetch_regs (int tid)
	169	{
	170	elf_gregset_t regs;
	171
	172	if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
7b3fabf0	173	perror_with_name ("Couldn't get registers");
53e95fcf JS	174
	175	supply_gregset (&regs);
	176	}
	177
	178	/* Store all valid general-purpose registers in GDB's register array
	179	into the process/thread specified by TID. */
	180
	181	static void
	182	store_regs (int tid, int regno)
	183	{
	184	elf_gregset_t regs;
	185
	186	if (ptrace (PTRACE_GETREGS, tid, 0, (long) &regs) < 0)
	187	perror_with_name ("Couldn't get registers");
	188
	189	fill_gregset (&regs, regno);
	190
	191	if (ptrace (PTRACE_SETREGS, tid, 0, (long) &regs) < 0)
	192	perror_with_name ("Couldn't write registers");
	193	}
	194	\f
	195
	196	/* Transfering floating-point registers between GDB, inferiors and cores. */
	197
8dda9770 ML	198	static void *
	199	x86_64_fxsave_offset (elf_fpregset_t * fxsave, int regnum)
	200	{
1cf877ad	201	const char *reg_name;
8dda9770 ML	202	int reg_index;
	203
	204	gdb_assert (x86_64_num_gregs - 1 < regnum && regnum < x86_64_num_regs);
	205
1cf877ad	206	reg_name = x86_64_register_name (regnum);
8dda9770 ML	207
	208	if (reg_name[0] == 's' && reg_name[1] == 't')
	209	{
	210	reg_index = reg_name[2] - '0';
	211	return &fxsave->st_space[reg_index * 2];
	212	}
	213
	214	if (reg_name[0] == 'x' && reg_name[1] == 'm' && reg_name[2] == 'm')
	215	{
	216	reg_index = reg_name[3] - '0';
	217	return &fxsave->xmm_space[reg_index * 4];
	218	}
	219
	220	if (strcmp (reg_name, "mxcsr") == 0)
	221	return &fxsave->mxcsr;
	222
	223	return NULL;
	224	}
	225
	226	/* Fill GDB's register array with the floating-point and SSE register
	227	values in *FXSAVE. This function masks off any of the reserved
	228	bits in FXSAVE. /
53e95fcf JS	229
53e95fcf JS	230	void
8dda9770	231	supply_fpregset (elf_fpregset_t * fxsave)
53e95fcf	232	{
8dda9770 ML	233	int i, reg_st0, reg_mxcsr;
8dda9770 ML	234
1cf877ad ML	235	reg_st0 = x86_64_register_number ("st0");
1cf877ad ML	236	reg_mxcsr = x86_64_register_number ("mxcsr");
8dda9770 ML	237
	238	gdb_assert (reg_st0 > 0 && reg_mxcsr > reg_st0);
	239
	240	for (i = reg_st0; i <= reg_mxcsr; i++)
	241	supply_register (i, x86_64_fxsave_offset (fxsave, i));
53e95fcf JS	242	}
53e95fcf JS	243
8dda9770 ML	244	/* Fill register REGNUM (if it is a floating-point or SSE register) in
	245	*FXSAVE with the value in GDB's register array. If REGNUM is -1, do
	246	this for all registers. This function doesn't touch any of the
	247	reserved bits in FXSAVE. /
53e95fcf JS	248
53e95fcf JS	249	void
8dda9770	250	fill_fpregset (elf_fpregset_t * fxsave, int regnum)
53e95fcf	251	{
8dda9770 ML	252	int i, last_regnum = MXCSR_REGNUM;
	253	void *ptr;
	254
	255	if (gdbarch_tdep (current_gdbarch)->num_xmm_regs == 0)
	256	last_regnum = FOP_REGNUM;
	257
	258	for (i = FP0_REGNUM; i <= last_regnum; i++)
	259	if (regnum == -1 \|\| regnum == i)
	260	{
	261	ptr = x86_64_fxsave_offset (fxsave, i);
	262	if (ptr)
	263	regcache_collect (i, ptr);
	264	}
53e95fcf JS	265	}
	266
	267	/* Fetch all floating-point registers from process/thread TID and store
	268	thier values in GDB's register array. */
	269
	270	static void
	271	fetch_fpregs (int tid)
	272	{
	273	elf_fpregset_t fpregs;
	274
	275	if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
	276	perror_with_name ("Couldn't get floating point status");
	277
	278	supply_fpregset (&fpregs);
	279	}
	280
	281	/* Store all valid floating-point registers in GDB's register array
	282	into the process/thread specified by TID. */
	283
	284	static void
	285	store_fpregs (int tid, int regno)
	286	{
	287	elf_fpregset_t fpregs;
	288
	289	if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0)
	290	perror_with_name ("Couldn't get floating point status");
	291
	292	fill_fpregset (&fpregs, regno);
	293
	294	if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0)
	295	perror_with_name ("Couldn't write floating point status");
	296	}
	297	\f
	298
	299	/* Transferring arbitrary registers between GDB and inferior. */
	300
	301	/* Fetch register REGNO from the child process. If REGNO is -1, do
	302	this for all registers (including the floating point and SSE
	303	registers). */
	304
	305	void
	306	fetch_inferior_registers (int regno)
	307	{
	308	int tid;
	309
a4b6fc86	310	/* GNU/Linux LWP ID's are process ID's. */
53e95fcf JS	311	if ((tid = TIDGET (inferior_ptid)) == 0)
	312	tid = PIDGET (inferior_ptid); /* Not a threaded program. */
	313
	314	if (regno == -1)
	315	{
	316	fetch_regs (tid);
	317	fetch_fpregs (tid);
	318	return;
	319	}
	320
	321	if (GETREGS_SUPPLIES (regno))
	322	{
	323	fetch_regs (tid);
	324	return;
	325	}
	326
	327	if (GETFPREGS_SUPPLIES (regno))
	328	{
	329	fetch_fpregs (tid);
	330	return;
	331	}
	332
	333	internal_error (__FILE__, __LINE__,
	334	"Got request for bad register number %d.", regno);
	335	}
	336
	337	/* Store register REGNO back into the child process. If REGNO is -1,
	338	do this for all registers (including the floating point and SSE
	339	registers). */
	340	void
	341	store_inferior_registers (int regno)
	342	{
	343	int tid;
	344
a4b6fc86	345	/* GNU/Linux LWP ID's are process ID's. */
53e95fcf JS	346	if ((tid = TIDGET (inferior_ptid)) == 0)
	347	tid = PIDGET (inferior_ptid); /* Not a threaded program. */
	348
	349	if (regno == -1)
	350	{
	351	store_regs (tid, regno);
	352	store_fpregs (tid, regno);
	353	return;
	354	}
	355
	356	if (GETREGS_SUPPLIES (regno))
	357	{
	358	store_regs (tid, regno);
	359	return;
	360	}
	361
	362	if (GETFPREGS_SUPPLIES (regno))
	363	{
	364	store_fpregs (tid, regno);
	365	return;
	366	}
	367
	368	internal_error (__FILE__, __LINE__,
	369	"Got request to store bad register number %d.", regno);
	370	}
	371	\f
	372
	373	static const unsigned char linux_syscall[] = { 0x0f, 0x05 };
	374
	375	#define LINUX_SYSCALL_LEN (sizeof linux_syscall)
	376
	377	/* The system call number is stored in the %rax register. */
	378	#define LINUX_SYSCALL_REGNUM 0 /* %rax */
	379
	380	/* We are specifically interested in the sigreturn and rt_sigreturn
	381	system calls. */
	382
	383	#ifndef SYS_sigreturn
	384	#define SYS_sigreturn __NR_sigreturn
	385	#endif
	386	#ifndef SYS_rt_sigreturn
	387	#define SYS_rt_sigreturn __NR_rt_sigreturn
	388	#endif
	389
	390	/* Offset to saved processor flags, from <asm/sigcontext.h>. */
	391	#define LINUX_SIGCONTEXT_EFLAGS_OFFSET (152)
	392	/* Offset to saved processor registers from <asm/ucontext.h> */
	393	#define LINUX_UCONTEXT_SIGCONTEXT_OFFSET (36)
	394
53e95fcf	395	/* Interpreting register set info found in core files. */
53e95fcf JS	396	/* Provide registers to GDB from a core file.
	397
	398	CORE_REG_SECT points to an array of bytes, which are the contents
	399	of a `note' from a core file which BFD thinks might contain
	400	register contents. CORE_REG_SIZE is its size.
	401
	402	WHICH says which register set corelow suspects this is:
	403	0 --- the general-purpose register set, in elf_gregset_t format
	404	2 --- the floating-point register set, in elf_fpregset_t format
	405
a4b6fc86	406	REG_ADDR isn't used on GNU/Linux. */
53e95fcf JS	407
	408	static void
	409	fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
	410	int which, CORE_ADDR reg_addr)
	411	{
	412	elf_gregset_t gregset;
	413	elf_fpregset_t fpregset;
	414	switch (which)
	415	{
	416	case 0:
	417	if (core_reg_size != sizeof (gregset))
	418	warning ("Wrong size gregset in core file.");
	419	else
	420	{
	421	memcpy (&gregset, core_reg_sect, sizeof (gregset));
	422	supply_gregset (&gregset);
	423	}
	424	break;
	425
	426	case 2:
	427	if (core_reg_size != sizeof (fpregset))
	428	warning ("Wrong size fpregset in core file.");
	429	else
	430	{
	431	memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
	432	supply_fpregset (&fpregset);
	433	}
	434	break;
	435
	436	default:
	437	/* We've covered all the kinds of registers we know about here,
	438	so this must be something we wouldn't know what to do with
	439	anyway. Just ignore it. */
	440	break;
	441	}
	442	}
	443
a4b6fc86	444	/* Register that we are able to handle GNU/Linux ELF core file formats. */
53e95fcf JS	445
	446	static struct core_fns linux_elf_core_fns = {
	447	bfd_target_elf_flavour, /* core_flavour */
	448	default_check_format, /* check_format */
	449	default_core_sniffer, /* core_sniffer */
	450	fetch_core_registers, /* core_read_registers */
	451	NULL /* next */
	452	};
	453	\f
	454
	455	#if !defined (offsetof)
	456	#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
	457	#endif
	458
b7c4cbf8 AJ	459	/* Return the address of register REGNUM. BLOCKEND is the value of
	460	u.u_ar0, which should point to the registers. */
	461	CORE_ADDR
	462	x86_64_register_u_addr (CORE_ADDR blockend, int regnum)
	463	{
	464	struct user u;
	465	CORE_ADDR fpstate;
	466	CORE_ADDR ubase;
	467	ubase = blockend;
7b3fabf0	468	if (IS_FP_REGNUM (regnum))
b7c4cbf8 AJ	469	{
	470	fpstate = ubase + ((char ) &u.i387.st_space - (char ) &u);
	471	return (fpstate + 16 * (regnum - FP0_REGNUM));
	472	}
7b3fabf0	473	else if (IS_SSE_REGNUM (regnum))
b7c4cbf8 AJ	474	{
	475	fpstate = ubase + ((char ) &u.i387.xmm_space - (char ) &u);
	476	return (fpstate + 16 * (regnum - XMM0_REGNUM));
	477	}
	478	else
	479	return (ubase + 8 * x86_64_regmap[regnum]);
	480	}
	481
53e95fcf JS	482	void
	483	_initialize_x86_64_linux_nat (void)
	484	{
	485	add_core_fns (&linux_elf_core_fns);
	486	}
8cfda98c ML	487
	488	int
	489	kernel_u_size (void)
	490	{
	491	return (sizeof (struct user));
	492	}