1/* Target-dependent code for NetBSD/mips.
2
3   Copyright (C) 2002, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
4
5   Contributed by Wasabi Systems, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.  */
21
22#include "defs.h"
23#include "gdbcore.h"
24#include "regcache.h"
25#include "regset.h"
26#include "target.h"
27#include "value.h"
28#include "osabi.h"
29
30#include "gdb_assert.h"
31#include "gdb_string.h"
32
33#include "nbsd-tdep.h"
34#include "mipsnbsd-tdep.h"
35#include "mips-tdep.h"
36
37#include "solib-svr4.h"
38
39/* Shorthand for some register numbers used below.  */
40#define MIPS_PC_REGNUM  MIPS_EMBED_PC_REGNUM
41#define MIPS_FP0_REGNUM MIPS_EMBED_FP0_REGNUM
42#define MIPS_FSR_REGNUM MIPS_EMBED_FP0_REGNUM + 32
43
44/* Core file support.  */
45
46/* Number of registers in `struct reg' from <machine/reg.h>.  */
47#define MIPSNBSD_NUM_GREGS	38
48
49/* Number of registers in `struct fpreg' from <machine/reg.h>.  */
50#define MIPSNBSD_NUM_FPREGS	33
51
52/* Supply register REGNUM from the buffer specified by FPREGS and LEN
53   in the floating-point register set REGSET to register cache
54   REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
55
56static void
57mipsnbsd_supply_fpregset (const struct regset *regset,
58			  struct regcache *regcache,
59			  int regnum, const void *fpregs, size_t len)
60{
61  size_t regsize = mips_isa_regsize (get_regcache_arch (regcache));
62  const char *regs = fpregs;
63  int i;
64
65  gdb_assert (len >= MIPSNBSD_NUM_FPREGS * regsize);
66
67  for (i = MIPS_FP0_REGNUM; i <= MIPS_FSR_REGNUM; i++)
68    {
69      if (regnum == i || regnum == -1)
70	regcache_raw_supply (regcache, i,
71			     regs + (i - MIPS_FP0_REGNUM) * regsize);
72    }
73}
74
75/* Supply register REGNUM from the buffer specified by GREGS and LEN
76   in the general-purpose register set REGSET to register cache
77   REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
78
79static void
80mipsnbsd_supply_gregset (const struct regset *regset,
81			 struct regcache *regcache, int regnum,
82			 const void *gregs, size_t len)
83{
84  size_t regsize = mips_isa_regsize (get_regcache_arch (regcache));
85  const char *regs = gregs;
86  int i;
87
88  gdb_assert (len >= MIPSNBSD_NUM_GREGS * regsize);
89
90  for (i = 0; i <= MIPS_PC_REGNUM; i++)
91    {
92      if (regnum == i || regnum == -1)
93	regcache_raw_supply (regcache, i, regs + i * regsize);
94    }
95
96  if (len >= (MIPSNBSD_NUM_GREGS + MIPSNBSD_NUM_FPREGS) * regsize)
97    {
98      regs += MIPSNBSD_NUM_GREGS * regsize;
99      len -= MIPSNBSD_NUM_GREGS * regsize;
100      mipsnbsd_supply_fpregset (regset, regcache, regnum, regs, len);
101    }
102}
103
104/* NetBSD/mips register sets.  */
105
106static struct regset mipsnbsd_gregset =
107{
108  NULL,
109  mipsnbsd_supply_gregset
110};
111
112static struct regset mipsnbsd_fpregset =
113{
114  NULL,
115  mipsnbsd_supply_fpregset
116};
117
118/* Return the appropriate register set for the core section identified
119   by SECT_NAME and SECT_SIZE.  */
120
121static const struct regset *
122mipsnbsd_regset_from_core_section (struct gdbarch *gdbarch,
123				   const char *sect_name, size_t sect_size)
124{
125  size_t regsize = mips_isa_regsize (gdbarch);
126
127  if (strcmp (sect_name, ".reg") == 0
128      && sect_size >= MIPSNBSD_NUM_GREGS * regsize)
129    return &mipsnbsd_gregset;
130
131  if (strcmp (sect_name, ".reg2") == 0
132      && sect_size >= MIPSNBSD_NUM_FPREGS * regsize)
133    return &mipsnbsd_fpregset;
134
135  return NULL;
136}
137
138
139/* Conveniently, GDB uses the same register numbering as the
140   ptrace register structure used by NetBSD/mips.  */
141
142void
143mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
144{
145  int i;
146
147  for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
148    {
149      if (regno == i || regno == -1)
150	{
151	  if (gdbarch_cannot_fetch_register (current_gdbarch, i))
152	    regcache_raw_supply (regcache, i, NULL);
153	  else
154            regcache_raw_supply (regcache, i,
155				 regs + (i * mips_isa_regsize (current_gdbarch)));
156        }
157    }
158}
159
160void
161mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno)
162{
163  int i;
164
165  for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
166    if ((regno == i || regno == -1)
167	&& ! gdbarch_cannot_store_register (current_gdbarch, i))
168      regcache_raw_collect (regcache, i,
169			    regs + (i * mips_isa_regsize (current_gdbarch)));
170}
171
172void
173mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
174{
175  int i;
176
177  for (i = gdbarch_fp0_regnum (current_gdbarch);
178       i <= mips_regnum (current_gdbarch)->fp_implementation_revision;
179       i++)
180    {
181      if (regno == i || regno == -1)
182	{
183	  if (gdbarch_cannot_fetch_register (current_gdbarch, i))
184	    regcache_raw_supply (regcache, i, NULL);
185	  else
186            regcache_raw_supply (regcache, i,
187				 fpregs
188				 + ((i - gdbarch_fp0_regnum (current_gdbarch))
189				    * mips_isa_regsize (current_gdbarch)));
190	}
191    }
192}
193
194void
195mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno)
196{
197  int i;
198
199  for (i = gdbarch_fp0_regnum (current_gdbarch);
200       i <= mips_regnum (current_gdbarch)->fp_control_status;
201       i++)
202    if ((regno == i || regno == -1)
203	&& ! gdbarch_cannot_store_register (current_gdbarch, i))
204      regcache_raw_collect (regcache, i,
205			    fpregs + ((i - gdbarch_fp0_regnum
206					     (current_gdbarch))
207			      * mips_isa_regsize (current_gdbarch)));
208}
209
210/* Under NetBSD/mips, signal handler invocations can be identified by the
211   designated code sequence that is used to return from a signal handler.
212   In particular, the return address of a signal handler points to the
213   following code sequence:
214
215	addu	a0, sp, 16
216	li	v0, 295			# __sigreturn14
217	syscall
218
219   Each instruction has a unique encoding, so we simply attempt to match
220   the instruction the PC is pointing to with any of the above instructions.
221   If there is a hit, we know the offset to the start of the designated
222   sequence and can then check whether we really are executing in the
223   signal trampoline.  If not, -1 is returned, otherwise the offset from the
224   start of the return sequence is returned.  */
225
226#define RETCODE_NWORDS	3
227#define RETCODE_SIZE	(RETCODE_NWORDS * 4)
228
229static const unsigned char sigtramp_retcode_mipsel[RETCODE_SIZE] =
230{
231  0x10, 0x00, 0xa4, 0x27,	/* addu a0, sp, 16 */
232  0x27, 0x01, 0x02, 0x24,	/* li v0, 295 */
233  0x0c, 0x00, 0x00, 0x00,	/* syscall */
234};
235
236static const unsigned char sigtramp_retcode_mipseb[RETCODE_SIZE] =
237{
238  0x27, 0xa4, 0x00, 0x10,	/* addu a0, sp, 16 */
239  0x24, 0x02, 0x01, 0x27,	/* li v0, 295 */
240  0x00, 0x00, 0x00, 0x0c,	/* syscall */
241};
242
243static LONGEST
244mipsnbsd_sigtramp_offset (struct frame_info *next_frame)
245{
246  CORE_ADDR pc = frame_pc_unwind (next_frame);
247  const char *retcode = gdbarch_byte_order (current_gdbarch)
248			== BFD_ENDIAN_BIG ? sigtramp_retcode_mipseb :
249			sigtramp_retcode_mipsel;
250  unsigned char ret[RETCODE_SIZE], w[4];
251  LONGEST off;
252  int i;
253
254  if (!safe_frame_unwind_memory (next_frame, pc, w, sizeof (w)))
255    return -1;
256
257  for (i = 0; i < RETCODE_NWORDS; i++)
258    {
259      if (memcmp (w, retcode + (i * 4), 4) == 0)
260	break;
261    }
262  if (i == RETCODE_NWORDS)
263    return -1;
264
265  off = i * 4;
266  pc -= off;
267
268  if (!safe_frame_unwind_memory (next_frame, pc, ret, sizeof (ret)))
269    return -1;
270
271  if (memcmp (ret, retcode, RETCODE_SIZE) == 0)
272    return off;
273
274  return -1;
275}
276
277/* Figure out where the longjmp will land.  We expect that we have
278   just entered longjmp and haven't yet setup the stack frame, so the
279   args are still in the argument regs.  MIPS_A0_REGNUM points at the
280   jmp_buf structure from which we extract the PC that we will land
281   at.  The PC is copied into *pc.  This routine returns true on
282   success.  */
283
284#define NBSD_MIPS_JB_PC			(2 * 4)
285#define NBSD_MIPS_JB_ELEMENT_SIZE	mips_isa_regsize (current_gdbarch)
286#define NBSD_MIPS_JB_OFFSET		(NBSD_MIPS_JB_PC * \
287					 NBSD_MIPS_JB_ELEMENT_SIZE)
288
289static int
290mipsnbsd_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
291{
292  CORE_ADDR jb_addr;
293  char *buf;
294
295  buf = alloca (NBSD_MIPS_JB_ELEMENT_SIZE);
296
297  jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
298
299  if (target_read_memory (jb_addr + NBSD_MIPS_JB_OFFSET, buf,
300  			  NBSD_MIPS_JB_ELEMENT_SIZE))
301    return 0;
302
303  *pc = extract_unsigned_integer (buf, NBSD_MIPS_JB_ELEMENT_SIZE);
304
305  return 1;
306}
307
308static int
309mipsnbsd_cannot_fetch_register (int regno)
310{
311  return (regno == MIPS_ZERO_REGNUM
312	  || regno == mips_regnum (current_gdbarch)->fp_implementation_revision);
313}
314
315static int
316mipsnbsd_cannot_store_register (int regno)
317{
318  return (regno == MIPS_ZERO_REGNUM
319	  || regno == mips_regnum (current_gdbarch)->fp_implementation_revision);
320}
321
322/* Shared library support.  */
323
324/* NetBSD/mips uses a slightly different `struct link_map' than the
325   other NetBSD platforms.  */
326
327static struct link_map_offsets *
328mipsnbsd_ilp32_fetch_link_map_offsets (void)
329{
330  static struct link_map_offsets lmo;
331  static struct link_map_offsets *lmp = NULL;
332
333  if (lmp == NULL)
334    {
335      lmp = &lmo;
336
337      lmo.r_version_offset = 0;
338      lmo.r_version_size = 4;
339      lmo.r_map_offset = 4;
340      lmo.r_ldsomap_offset = -1;
341
342      /* Everything we need is in the first 24 bytes.  */
343      lmo.link_map_size = 24;
344      lmo.l_addr_offset = 4;
345      lmo.l_name_offset = 8;
346      lmo.l_ld_offset = 12;
347      lmo.l_next_offset = 16;
348      lmo.l_prev_offset = 20;
349    }
350
351  return lmp;
352}
353
354static struct link_map_offsets *
355mipsnbsd_lp64_fetch_link_map_offsets (void)
356{
357  static struct link_map_offsets lmo;
358  static struct link_map_offsets *lmp = NULL;
359
360  if (lmp == NULL)
361    {
362      lmp = &lmo;
363
364      lmo.r_version_offset = 0;
365      lmo.r_version_size = 4;
366      lmo.r_map_offset = 8;
367      lmo.r_ldsomap_offset = -1;
368
369      /* Everything we need is in the first 40 bytes.  */
370      lmo.link_map_size = 48;
371      lmo.l_addr_offset = 0;
372      lmo.l_name_offset = 16;
373      lmo.l_ld_offset = 24;
374      lmo.l_next_offset = 32;
375      lmo.l_prev_offset = 40;
376    }
377
378  return lmp;
379}
380
381
382static void
383mipsnbsd_init_abi (struct gdbarch_info info,
384                   struct gdbarch *gdbarch)
385{
386  set_gdbarch_regset_from_core_section
387    (gdbarch, mipsnbsd_regset_from_core_section);
388
389  set_gdbarch_get_longjmp_target (gdbarch, mipsnbsd_get_longjmp_target);
390
391  set_gdbarch_cannot_fetch_register (gdbarch, mipsnbsd_cannot_fetch_register);
392  set_gdbarch_cannot_store_register (gdbarch, mipsnbsd_cannot_store_register);
393
394  set_gdbarch_software_single_step (gdbarch, mips_software_single_step);
395
396  /* NetBSD/mips has SVR4-style shared libraries.  */
397  set_solib_svr4_fetch_link_map_offsets
398    (gdbarch, (gdbarch_ptr_bit (gdbarch) == 32 ?
399	       mipsnbsd_ilp32_fetch_link_map_offsets :
400	       mipsnbsd_lp64_fetch_link_map_offsets));
401}
402
403
404static enum gdb_osabi
405mipsnbsd_core_osabi_sniffer (bfd *abfd)
406{
407  if (strcmp (bfd_get_target (abfd), "netbsd-core") == 0)
408    return GDB_OSABI_NETBSD_ELF;
409
410  return GDB_OSABI_UNKNOWN;
411}
412
413void
414_initialize_mipsnbsd_tdep (void)
415{
416  gdbarch_register_osabi (bfd_arch_mips, 0, GDB_OSABI_NETBSD_ELF,
417			  mipsnbsd_init_abi);
418}
419