[deliverable/binutils-gdb.git] / gdb / gdbserver / linux-sparc-low.c

/* Low level interface to ptrace, for the remote server for GDB.
   Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.

   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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "server.h"
#include "linux-low.h"

#include <sys/ptrace.h>

#include "gdb_proc_service.h"

/* The stack pointer is offset from the stack frame by a BIAS of 2047
   (0x7ff) for 64-bit code.  BIAS is likely to be defined on SPARC
   hosts, so undefine it first.  */
#undef BIAS
#define BIAS 2047

#ifdef HAVE_SYS_REG_H
#include <sys/reg.h>
#endif

#define INSN_SIZE 4

#define SPARC_R_REGS_NUM 32
#define SPARC_F_REGS_NUM 48
#define SPARC_CONTROL_REGS_NUM 6

#define sparc_num_regs (SPARC_R_REGS_NUM + SPARC_F_REGS_NUM + SPARC_CONTROL_REGS_NUM)

/* Each offset is multiplied by 8, because of the register size.
   These offsets apply to the buffer sent/filled by ptrace.
   Additionally, the array elements order corresponds to the .dat file, and the
   gdb's registers enumeration order.  */

static int sparc_regmap[] = {
  /* These offsets correspond to GET/SETREGSET.  */
	-1,  0*8,  1*8,  2*8,  3*8,  4*8,  5*8,  6*8,	   /* g0 .. g7 */
	7*8,  8*8,  9*8, 10*8, 11*8, 12*8, 13*8, 14*8,	   /* o0 .. o5, sp, o7 */
	-1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,	   /* l0 .. l7 */
	-1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,	   /* i0 .. i5, fp, i7 */

  /* Floating point registers offsets correspond to GET/SETFPREGSET.  */
    0*4,  1*4,  2*4,  3*4,  4*4,  5*4,  6*4,  7*4,	   /*  f0 ..  f7 */
    8*4,  9*4, 10*4, 11*4, 12*4, 13*4, 14*4, 15*4,	   /*  f8 .. f15 */
   16*4, 17*4, 18*4, 19*4, 20*4, 21*4, 22*4, 23*4,	   /* f16 .. f23 */
   24*4, 25*4, 26*4, 27*4, 28*4, 29*4, 30*4, 31*4,	   /* f24 .. f31 */

  /* F32 offset starts next to f31: 31*4+4 = 16 * 8.  */
   16*8, 17*8, 18*8, 19*8, 20*8, 21*8, 22*8, 23*8,	   /* f32 .. f46 */
   24*8, 25*8, 26*8, 27*8, 28*8, 29*8, 30*8, 31*8,	   /* f48 .. f62 */

   17 *8, /*    pc */
   18 *8, /*   npc */
   16 *8, /* state */
  /* FSR offset also corresponds to GET/SETFPREGSET, ans is placed next to f62.  */
   32 *8, /*   fsr */
      -1, /*  fprs */
  /* Y register is 32-bits length, but gdb takes care of that.  */
   19 *8, /*     y */

};


struct regs_range_t
{
  int regno_start;
  int regno_end;
};

static const struct regs_range_t gregs_ranges[] = {
 {  0, 31 }, /*   g0 .. i7  */
 { 80, 82 }, /*   pc .. state */
 { 84, 85 }  /* fprs .. y */
};

#define N_GREGS_RANGES (sizeof (gregs_ranges) / sizeof (struct regs_range_t))

static const struct regs_range_t fpregs_ranges[] = {
 { 32, 79 }, /* f0 .. f62  */
 { 83, 83 }  /* fsr */
};

#define N_FPREGS_RANGES (sizeof (fpregs_ranges) / sizeof (struct regs_range_t))

/* Defined in auto-generated file reg-sparc64.c.  */
void init_registers_sparc64 (void);

static int
sparc_cannot_store_register (int regno)
{
  return (regno >= sparc_num_regs || sparc_regmap[regno] == -1);
}

static int
sparc_cannot_fetch_register (int regno)
{
  return (regno >= sparc_num_regs || sparc_regmap[regno] == -1);
}

static void
sparc_fill_gregset_to_stack (struct regcache *regcache, const void *buf)
{
  int i;
  CORE_ADDR addr = 0;
  unsigned char tmp_reg_buf[8];
  const int l0_regno = find_regno("l0");
  const int i7_regno = l0_regno + 15;

  /* These registers have to be stored in the stack.  */
  memcpy(&addr, ((char *) buf) + sparc_regmap[find_regno("sp")], sizeof(addr));

  addr += BIAS;

  for (i = l0_regno; i <= i7_regno; i++)
    {
      collect_register (regcache, i, tmp_reg_buf);
      (*the_target->write_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
      addr += sizeof(tmp_reg_buf);
    }
}

static void
sparc_fill_gregset (struct regcache *regcache, void *buf)
{
  int i;
  int range;

  for (range = 0; range < N_GREGS_RANGES; range++)
    for (i = gregs_ranges[range].regno_start; i <= gregs_ranges[range].regno_end; i++)
      if (sparc_regmap[i] != -1)
	collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]);

  sparc_fill_gregset_to_stack (regcache, buf);
}

static void
sparc_fill_fpregset (struct regcache *regcache, void *buf)
{
  int i;
  int range;

  for (range = 0; range < N_FPREGS_RANGES; range++)
    for (i = fpregs_ranges[range].regno_start; i <= fpregs_ranges[range].regno_end; i++)
      collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]);

}

static void
sparc_store_gregset_from_stack (struct regcache *regcache, const void *buf)
{
  int i;
  CORE_ADDR addr = 0;
  unsigned char tmp_reg_buf[8];
  const int l0_regno = find_regno("l0");
  const int i7_regno = l0_regno + 15;

  /* These registers have to be obtained from the stack.  */
  memcpy(&addr, ((char *) buf) + sparc_regmap[find_regno("sp")], sizeof(addr));

  addr += BIAS;

  for (i = l0_regno; i <= i7_regno; i++)
    {
      (*the_target->read_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
      supply_register (regcache, i, tmp_reg_buf);
      addr += sizeof(tmp_reg_buf);
    }
}

static void
sparc_store_gregset (struct regcache *regcache, const void *buf)
{
  int i;
  char zerobuf[8];
  int range;

  memset (zerobuf, 0, sizeof(zerobuf));

  for (range = 0; range < N_GREGS_RANGES; range++)
    for (i = gregs_ranges[range].regno_start; i <= gregs_ranges[range].regno_end; i++)
      if (sparc_regmap[i] != -1)
	supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
      else
	supply_register (regcache, i, zerobuf);

  sparc_store_gregset_from_stack (regcache, buf);
}

static void
sparc_store_fpregset (struct regcache *regcache, const void *buf)
{
  int i;
  int range;

  for (range = 0; range < N_FPREGS_RANGES; range++)
    for (i = fpregs_ranges[range].regno_start;
	 i <= fpregs_ranges[range].regno_end;
	 i++)
      supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
}

extern int debug_threads;

static CORE_ADDR
sparc_get_pc (struct regcache *regcache)
{
  unsigned long pc;
  collect_register_by_name (regcache, "pc", &pc);
  if (debug_threads)
    fprintf (stderr, "stop pc is %08lx\n", pc);
  return pc;
}

static const unsigned char sparc_breakpoint[INSN_SIZE] = { 0x91, 0xd0, 0x20, 0x01 };
#define sparc_breakpoint_len INSN_SIZE


static int
sparc_breakpoint_at (CORE_ADDR where)
{
  unsigned char insn[INSN_SIZE];

  (*the_target->read_memory) (where, (unsigned char *) insn, sizeof(insn));

  if (memcmp(sparc_breakpoint, insn, sizeof(insn)) == 0)
    return 1;

  /* If necessary, recognize more trap instructions here.  GDB only uses TRAP Always.  */

  return 0;
}

/* We only place breakpoints in empty marker functions, and thread locking
   is outside of the function.  So rather than importing software single-step,
   we can just run until exit.  */
static CORE_ADDR
sparc_reinsert_addr (void)
{
  struct regcache *regcache = get_thread_regcache (current_inferior, 1);
  CORE_ADDR lr;
  /* O7 is the equivalent to the 'lr' of other archs.  */
  collect_register_by_name (regcache, "o7", &lr);
  return lr;
}


struct regset_info target_regsets[] = {
  { PTRACE_GETREGS, PTRACE_SETREGS, sizeof (elf_gregset_t),
    GENERAL_REGS,
    sparc_fill_gregset, sparc_store_gregset },
  { PTRACE_GETFPREGS, PTRACE_SETFPREGS, sizeof (fpregset_t),
    FP_REGS,
    sparc_fill_fpregset, sparc_store_fpregset },
  { 0, 0, -1, -1, NULL, NULL }
};

struct linux_target_ops the_low_target = {
  init_registers_sparc64,
  sparc_num_regs,
  /* No regmap needs to be provided since this impl. doesn't use USRREGS.  */
  NULL,
  sparc_cannot_fetch_register,
  sparc_cannot_store_register,
  sparc_get_pc,
  /* No sparc_set_pc is needed.  */
  NULL,
  (const unsigned char *) sparc_breakpoint,
  sparc_breakpoint_len,
  sparc_reinsert_addr,
  0,
  sparc_breakpoint_at,
  NULL, NULL, NULL, NULL,
  NULL, NULL
};
Commit	Line	Data
dfb64f85 DJ	1	/* Low level interface to ptrace, for the remote server for GDB.
dfb64f85 DJ	2	Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4c38e0a4	3	2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
dfb64f85 DJ	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "server.h"
	21	#include "linux-low.h"
	22
	23	#include <sys/ptrace.h>
	24
	25	#include "gdb_proc_service.h"
	26
	27	/* The stack pointer is offset from the stack frame by a BIAS of 2047
	28	(0x7ff) for 64-bit code. BIAS is likely to be defined on SPARC
	29	hosts, so undefine it first. */
	30	#undef BIAS
	31	#define BIAS 2047
	32
	33	#ifdef HAVE_SYS_REG_H
	34	#include <sys/reg.h>
	35	#endif
	36
	37	#define INSN_SIZE 4
	38
	39	#define SPARC_R_REGS_NUM 32
	40	#define SPARC_F_REGS_NUM 48
	41	#define SPARC_CONTROL_REGS_NUM 6
	42
	43	#define sparc_num_regs (SPARC_R_REGS_NUM + SPARC_F_REGS_NUM + SPARC_CONTROL_REGS_NUM)
	44
	45	/* Each offset is multiplied by 8, because of the register size.
	46	These offsets apply to the buffer sent/filled by ptrace.
	47	Additionally, the array elements order corresponds to the .dat file, and the
	48	gdb's registers enumeration order. */
	49
	50	static int sparc_regmap[] = {
	51	/* These offsets correspond to GET/SETREGSET. */
1b3f6016 PA	52	-1, 08, 18, 28, 38, 48, 58, 68, / g0 .. g7 */
	53	78, 88, 98, 108, 118, 128, 138, 148, /* o0 .. o5, sp, o7 */
	54	-1, -1, -1, -1, -1, -1, -1, -1, /* l0 .. l7 */
	55	-1, -1, -1, -1, -1, -1, -1, -1, /* i0 .. i5, fp, i7 */
dfb64f85 DJ	56
	57	/* Floating point registers offsets correspond to GET/SETFPREGSET. */
	58	04, 14, 24, 34, 44, 54, 64, 74, /* f0 .. f7 */
	59	84, 94, 104, 114, 124, 134, 144, 154, /* f8 .. f15 */
	60	164, 174, 184, 194, 204, 214, 224, 234, /* f16 .. f23 */
	61	244, 254, 264, 274, 284, 294, 304, 314, /* f24 .. f31 */
	62
	63	/* F32 offset starts next to f31: 314+4 = 16 8. */
1b3f6016 PA	64	168, 178, 188, 198, 208, 218, 228, 238, /* f32 .. f46 */
1b3f6016 PA	65	248, 258, 268, 278, 288, 298, 308, 318, /* f48 .. f62 */
dfb64f85 DJ	66
	67	17 8, / pc */
	68	18 8, / npc */
	69	16 8, / state */
	70	/* FSR offset also corresponds to GET/SETFPREGSET, ans is placed next to f62. */
	71	32 8, / fsr */
	72	-1, /* fprs */
	73	/* Y register is 32-bits length, but gdb takes care of that. */
	74	19 8, / y */
	75
	76	};
	77
	78
	79	struct regs_range_t
	80	{
	81	int regno_start;
	82	int regno_end;
	83	};
	84
	85	static const struct regs_range_t gregs_ranges[] = {
	86	{ 0, 31 }, /* g0 .. i7 */
	87	{ 80, 82 }, /* pc .. state */
	88	{ 84, 85 } /* fprs .. y */
	89	};
	90
	91	#define N_GREGS_RANGES (sizeof (gregs_ranges) / sizeof (struct regs_range_t))
	92
	93	static const struct regs_range_t fpregs_ranges[] = {
	94	{ 32, 79 }, /* f0 .. f62 */
	95	{ 83, 83 } /* fsr */
	96	};
	97
	98	#define N_FPREGS_RANGES (sizeof (fpregs_ranges) / sizeof (struct regs_range_t))
	99
	100	/* Defined in auto-generated file reg-sparc64.c. */
	101	void init_registers_sparc64 (void);
	102
	103	static int
	104	sparc_cannot_store_register (int regno)
	105	{
	106	return (regno >= sparc_num_regs \|\| sparc_regmap[regno] == -1);
	107	}
	108
	109	static int
	110	sparc_cannot_fetch_register (int regno)
	111	{
	112	return (regno >= sparc_num_regs \|\| sparc_regmap[regno] == -1);
	113	}
	114
	115	static void
442ea881	116	sparc_fill_gregset_to_stack (struct regcache regcache, const void buf)
dfb64f85 DJ	117	{
	118	int i;
	119	CORE_ADDR addr = 0;
	120	unsigned char tmp_reg_buf[8];
	121	const int l0_regno = find_regno("l0");
	122	const int i7_regno = l0_regno + 15;
	123
	124	/* These registers have to be stored in the stack. */
	125	memcpy(&addr, ((char *) buf) + sparc_regmap[find_regno("sp")], sizeof(addr));
	126
	127	addr += BIAS;
1b3f6016	128
dfb64f85 DJ	129	for (i = l0_regno; i <= i7_regno; i++)
dfb64f85 DJ	130	{
442ea881	131	collect_register (regcache, i, tmp_reg_buf);
dfb64f85 DJ	132	(*the_target->write_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
	133	addr += sizeof(tmp_reg_buf);
	134	}
	135	}
	136
	137	static void
442ea881	138	sparc_fill_gregset (struct regcache regcache, void buf)
dfb64f85 DJ	139	{
	140	int i;
	141	int range;
1b3f6016	142
dfb64f85 DJ	143	for (range = 0; range < N_GREGS_RANGES; range++)
	144	for (i = gregs_ranges[range].regno_start; i <= gregs_ranges[range].regno_end; i++)
	145	if (sparc_regmap[i] != -1)
442ea881	146	collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
1b3f6016	147
442ea881	148	sparc_fill_gregset_to_stack (regcache, buf);
dfb64f85 DJ	149	}
	150
	151	static void
442ea881	152	sparc_fill_fpregset (struct regcache regcache, void buf)
dfb64f85 DJ	153	{
	154	int i;
	155	int range;
1b3f6016	156
dfb64f85 DJ	157	for (range = 0; range < N_FPREGS_RANGES; range++)
dfb64f85 DJ	158	for (i = fpregs_ranges[range].regno_start; i <= fpregs_ranges[range].regno_end; i++)
442ea881	159	collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
1b3f6016	160
dfb64f85 DJ	161	}
	162
	163	static void
442ea881	164	sparc_store_gregset_from_stack (struct regcache regcache, const void buf)
dfb64f85 DJ	165	{
	166	int i;
	167	CORE_ADDR addr = 0;
	168	unsigned char tmp_reg_buf[8];
	169	const int l0_regno = find_regno("l0");
	170	const int i7_regno = l0_regno + 15;
	171
	172	/* These registers have to be obtained from the stack. */
	173	memcpy(&addr, ((char *) buf) + sparc_regmap[find_regno("sp")], sizeof(addr));
	174
	175	addr += BIAS;
1b3f6016	176
dfb64f85 DJ	177	for (i = l0_regno; i <= i7_regno; i++)
	178	{
	179	(*the_target->read_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
442ea881	180	supply_register (regcache, i, tmp_reg_buf);
dfb64f85 DJ	181	addr += sizeof(tmp_reg_buf);
	182	}
	183	}
	184
	185	static void
442ea881	186	sparc_store_gregset (struct regcache regcache, const void buf)
dfb64f85 DJ	187	{
	188	int i;
	189	char zerobuf[8];
	190	int range;
	191
	192	memset (zerobuf, 0, sizeof(zerobuf));
1b3f6016	193
dfb64f85 DJ	194	for (range = 0; range < N_GREGS_RANGES; range++)
	195	for (i = gregs_ranges[range].regno_start; i <= gregs_ranges[range].regno_end; i++)
	196	if (sparc_regmap[i] != -1)
442ea881	197	supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
dfb64f85	198	else
442ea881	199	supply_register (regcache, i, zerobuf);
1b3f6016	200
442ea881	201	sparc_store_gregset_from_stack (regcache, buf);
dfb64f85 DJ	202	}
	203
	204	static void
442ea881	205	sparc_store_fpregset (struct regcache regcache, const void buf)
dfb64f85 DJ	206	{
	207	int i;
	208	int range;
1b3f6016	209
dfb64f85	210	for (range = 0; range < N_FPREGS_RANGES; range++)
442ea881 PA	211	for (i = fpregs_ranges[range].regno_start;
	212	i <= fpregs_ranges[range].regno_end;
	213	i++)
	214	supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
dfb64f85 DJ	215	}
	216
	217	extern int debug_threads;
	218
	219	static CORE_ADDR
442ea881	220	sparc_get_pc (struct regcache *regcache)
dfb64f85	221	{
442ea881 PA	222	unsigned long pc;
442ea881 PA	223	collect_register_by_name (regcache, "pc", &pc);
dfb64f85 DJ	224	if (debug_threads)
	225	fprintf (stderr, "stop pc is %08lx\n", pc);
	226	return pc;
	227	}
	228
	229	static const unsigned char sparc_breakpoint[INSN_SIZE] = { 0x91, 0xd0, 0x20, 0x01 };
	230	#define sparc_breakpoint_len INSN_SIZE
	231
	232
	233	static int
	234	sparc_breakpoint_at (CORE_ADDR where)
	235	{
	236	unsigned char insn[INSN_SIZE];
	237
	238	(the_target->read_memory) (where, (unsigned char ) insn, sizeof(insn));
1b3f6016	239
dfb64f85 DJ	240	if (memcmp(sparc_breakpoint, insn, sizeof(insn)) == 0)
	241	return 1;
	242
	243	/* If necessary, recognize more trap instructions here. GDB only uses TRAP Always. */
	244
	245	return 0;
	246	}
	247
	248	/* We only place breakpoints in empty marker functions, and thread locking
	249	is outside of the function. So rather than importing software single-step,
	250	we can just run until exit. */
	251	static CORE_ADDR
442ea881	252	sparc_reinsert_addr (void)
dfb64f85	253	{
442ea881	254	struct regcache *regcache = get_thread_regcache (current_inferior, 1);
dfb64f85 DJ	255	CORE_ADDR lr;
dfb64f85 DJ	256	/* O7 is the equivalent to the 'lr' of other archs. */
442ea881	257	collect_register_by_name (regcache, "o7", &lr);
dfb64f85 DJ	258	return lr;
	259	}
	260
	261
	262	struct regset_info target_regsets[] = {
	263	{ PTRACE_GETREGS, PTRACE_SETREGS, sizeof (elf_gregset_t),
	264	GENERAL_REGS,
	265	sparc_fill_gregset, sparc_store_gregset },
	266	{ PTRACE_GETFPREGS, PTRACE_SETFPREGS, sizeof (fpregset_t),
	267	FP_REGS,
	268	sparc_fill_fpregset, sparc_store_fpregset },
	269	{ 0, 0, -1, -1, NULL, NULL }
	270	};
	271
	272	struct linux_target_ops the_low_target = {
	273	init_registers_sparc64,
	274	sparc_num_regs,
	275	/* No regmap needs to be provided since this impl. doesn't use USRREGS. */
	276	NULL,
	277	sparc_cannot_fetch_register,
	278	sparc_cannot_store_register,
	279	sparc_get_pc,
	280	/* No sparc_set_pc is needed. */
	281	NULL,
	282	(const unsigned char *) sparc_breakpoint,
	283	sparc_breakpoint_len,
	284	sparc_reinsert_addr,
	285	0,
	286	sparc_breakpoint_at,
	287	NULL, NULL, NULL, NULL,
	288	NULL, NULL
	289	};