[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 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 (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 (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 (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 (i, ((char *) buf) + sparc_regmap[i]);
      
  sparc_fill_gregset_to_stack (buf);
}

static void
sparc_fill_fpregset (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 (i, ((char *) buf) + sparc_regmap[i]);
      
}

static void
sparc_store_gregset_from_stack (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 (i, tmp_reg_buf);
      addr += sizeof(tmp_reg_buf);
    }
}

static void
sparc_store_gregset (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 (i, ((char *) buf) + sparc_regmap[i]);
      else
        supply_register (i, zerobuf);
      
  sparc_store_gregset_from_stack (buf);
}

static void
sparc_store_fpregset (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 (i, ((char *) buf) + sparc_regmap[i]);
}

extern int debug_threads;

static CORE_ADDR
sparc_get_pc ()
{
  CORE_ADDR pc;
  collect_register_by_name ("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 ()
{
  CORE_ADDR lr;
  /* O7 is the equivalent to the 'lr' of other archs.  */
  collect_register_by_name ("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.
	2	Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
	3	2006, 2007, 2008 Free Software Foundation, Inc.
	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. */
	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 */
	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. */
	64	168, 178, 188, 198, 208, 218, 228, 238, /* f32 .. f46 */
65	248, 258, 268, 278, 288, 298, 308, 318, /* f48 .. f62 */
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
116	sparc_fill_gregset_to_stack (const void *buf)
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;
128
129	for (i = l0_regno; i <= i7_regno; i++)
130	{
131	collect_register (i, tmp_reg_buf);
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
138	sparc_fill_gregset (void *buf)
139	{
140	int i;
141	int range;
142
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)
146	collect_register (i, ((char *) buf) + sparc_regmap[i]);
147
148	sparc_fill_gregset_to_stack (buf);
149	}
150
151	static void
152	sparc_fill_fpregset (void *buf)
153	{
154	int i;
155	int range;
156
157	for (range = 0; range < N_FPREGS_RANGES; range++)
158	for (i = fpregs_ranges[range].regno_start; i <= fpregs_ranges[range].regno_end; i++)
159	collect_register (i, ((char *) buf) + sparc_regmap[i]);
160
161	}
162
163	static void
164	sparc_store_gregset_from_stack (const void *buf)
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;
176
177	for (i = l0_regno; i <= i7_regno; i++)
178	{
179	(*the_target->read_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
180	supply_register (i, tmp_reg_buf);
181	addr += sizeof(tmp_reg_buf);
182	}
183	}
184
185	static void
186	sparc_store_gregset (const void *buf)
187	{
188	int i;
189	char zerobuf[8];
190	int range;
191
192	memset (zerobuf, 0, sizeof(zerobuf));
193
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)
197	supply_register (i, ((char *) buf) + sparc_regmap[i]);
198	else
199	supply_register (i, zerobuf);
200
201	sparc_store_gregset_from_stack (buf);
202	}
203
204	static void
205	sparc_store_fpregset (const void *buf)
206	{
207	int i;
208	int range;
209
210	for (range = 0; range < N_FPREGS_RANGES; range++)
211	for (i = fpregs_ranges[range].regno_start; i <= fpregs_ranges[range].regno_end; i++)
212	supply_register (i, ((char *) buf) + sparc_regmap[i]);
213	}
214
215	extern int debug_threads;
216
217	static CORE_ADDR
218	sparc_get_pc ()
219	{
220	CORE_ADDR pc;
221	collect_register_by_name ("pc", &pc);
222	if (debug_threads)
223	fprintf (stderr, "stop pc is %08lx\n", pc);
224	return pc;
225	}
226
227	static const unsigned char sparc_breakpoint[INSN_SIZE] = { 0x91, 0xd0, 0x20, 0x01 };
228	#define sparc_breakpoint_len INSN_SIZE
229
230
231	static int
232	sparc_breakpoint_at (CORE_ADDR where)
233	{
234	unsigned char insn[INSN_SIZE];
235
236	(the_target->read_memory) (where, (unsigned char ) insn, sizeof(insn));
237
238	if (memcmp(sparc_breakpoint, insn, sizeof(insn)) == 0)
239	return 1;
240
241	/* If necessary, recognize more trap instructions here. GDB only uses TRAP Always. */
242
243	return 0;
244	}
245
246	/* We only place breakpoints in empty marker functions, and thread locking
247	is outside of the function. So rather than importing software single-step,
248	we can just run until exit. */
249	static CORE_ADDR
250	sparc_reinsert_addr ()
251	{
252	CORE_ADDR lr;
253	/* O7 is the equivalent to the 'lr' of other archs. */
254	collect_register_by_name ("o7", &lr);
255	return lr;
256	}
257
258
259	struct regset_info target_regsets[] = {
260	{ PTRACE_GETREGS, PTRACE_SETREGS, sizeof (elf_gregset_t),
261	GENERAL_REGS,
262	sparc_fill_gregset, sparc_store_gregset },
263	{ PTRACE_GETFPREGS, PTRACE_SETFPREGS, sizeof (fpregset_t),
264	FP_REGS,
265	sparc_fill_fpregset, sparc_store_fpregset },
266	{ 0, 0, -1, -1, NULL, NULL }
267	};
268
269	struct linux_target_ops the_low_target = {
270	init_registers_sparc64,
271	sparc_num_regs,
272	/* No regmap needs to be provided since this impl. doesn't use USRREGS. */
273	NULL,
274	sparc_cannot_fetch_register,
275	sparc_cannot_store_register,
276	sparc_get_pc,
277	/* No sparc_set_pc is needed. */
278	NULL,
279	(const unsigned char *) sparc_breakpoint,
280	sparc_breakpoint_len,
281	sparc_reinsert_addr,
282	0,
283	sparc_breakpoint_at,
284	NULL, NULL, NULL, NULL,
285	NULL, NULL
286	};
287