GDB (xrefs)
Loading...
Searching...
No Matches
mips-netbsd-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for NetBSD/mips.
2
3 Copyright (C) 2002-2023 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 "netbsd-tdep.h"
31#include "mips-netbsd-tdep.h"
32#include "mips-tdep.h"
33
34#include "solib-svr4.h"
35
36/* Shorthand for some register numbers used below. */
37#define MIPS_PC_REGNUM MIPS_EMBED_PC_REGNUM
38#define MIPS_FP0_REGNUM MIPS_EMBED_FP0_REGNUM
39#define MIPS_FSR_REGNUM MIPS_EMBED_FP0_REGNUM + 32
40
41/* Core file support. */
42
43/* Number of registers in `struct reg' from <machine/reg.h>. */
44#define MIPSNBSD_NUM_GREGS 38
45
46/* Number of registers in `struct fpreg' from <machine/reg.h>. */
47#define MIPSNBSD_NUM_FPREGS 33
48
49/* Supply register REGNUM from the buffer specified by FPREGS and LEN
50 in the floating-point register set REGSET to register cache
51 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
52
53static void
55 struct regcache *regcache,
56 int regnum, const void *fpregs, size_t len)
57{
58 size_t regsize = mips_isa_regsize (regcache->arch ());
59 const char *regs = (const char *) fpregs;
60 int i;
61
62 gdb_assert (len >= MIPSNBSD_NUM_FPREGS * regsize);
63
64 for (i = MIPS_FP0_REGNUM; i <= MIPS_FSR_REGNUM; i++)
65 {
66 if (regnum == i || regnum == -1)
67 regcache->raw_supply (i, regs + (i - MIPS_FP0_REGNUM) * regsize);
68 }
69}
70
71/* Supply register REGNUM from the buffer specified by GREGS and LEN
72 in the general-purpose register set REGSET to register cache
73 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
74
75static void
77 struct regcache *regcache, int regnum,
78 const void *gregs, size_t len)
79{
80 size_t regsize = mips_isa_regsize (regcache->arch ());
81 const char *regs = (const char *) gregs;
82 int i;
83
84 gdb_assert (len >= MIPSNBSD_NUM_GREGS * regsize);
85
86 for (i = 0; i <= MIPS_PC_REGNUM; i++)
87 {
88 if (regnum == i || regnum == -1)
89 regcache->raw_supply (i, regs + i * regsize);
90 }
91
92 if (len >= (MIPSNBSD_NUM_GREGS + MIPSNBSD_NUM_FPREGS) * regsize)
93 {
94 regs += MIPSNBSD_NUM_GREGS * regsize;
95 len -= MIPSNBSD_NUM_GREGS * regsize;
97 }
98}
99
100/* NetBSD/mips register sets. */
101
102static const struct regset mipsnbsd_gregset =
103{
104 NULL,
106 NULL,
108};
109
110static const struct regset mipsnbsd_fpregset =
111{
112 NULL,
114};
115
116/* Iterate over core file register note sections. */
117
118static void
121 void *cb_data,
122 const struct regcache *regcache)
123{
124 size_t regsize = mips_isa_regsize (gdbarch);
125
126 cb (".reg", MIPSNBSD_NUM_GREGS * regsize, MIPSNBSD_NUM_GREGS * regsize,
127 &mipsnbsd_gregset, NULL, cb_data);
128 cb (".reg2", MIPSNBSD_NUM_FPREGS * regsize, MIPSNBSD_NUM_FPREGS * regsize,
129 &mipsnbsd_fpregset, NULL, cb_data);
130}
131
132
133/* Conveniently, GDB uses the same register numbering as the
134 ptrace register structure used by NetBSD/mips. */
135
136void
137mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
138{
139 struct gdbarch *gdbarch = regcache->arch ();
140 int i;
141
142 for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
143 {
144 if (regno == i || regno == -1)
145 {
147 regcache->raw_supply (i, NULL);
148 else
150 (i, regs + (i * mips_isa_regsize (gdbarch)));
151 }
152 }
153}
154
155void
156mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno)
157{
158 struct gdbarch *gdbarch = regcache->arch ();
159 int i;
160
161 for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
162 if ((regno == i || regno == -1)
164 regcache->raw_collect (i, regs + (i * mips_isa_regsize (gdbarch)));
165}
166
167void
169 const char *fpregs, int regno)
170{
171 struct gdbarch *gdbarch = regcache->arch ();
172 int i;
173
174 for (i = gdbarch_fp0_regnum (gdbarch);
176 i++)
177 {
178 if (regno == i || regno == -1)
179 {
181 regcache->raw_supply (i, NULL);
182 else
184 fpregs
185 + ((i - gdbarch_fp0_regnum (gdbarch))
187 }
188 }
189}
190
191void
192mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno)
193{
194 struct gdbarch *gdbarch = regcache->arch ();
195 int i;
196
197 for (i = gdbarch_fp0_regnum (gdbarch);
199 i++)
200 if ((regno == i || regno == -1)
203 (i, (fpregs + ((i - gdbarch_fp0_regnum (gdbarch))
205}
206
207#if 0
208
209/* Under NetBSD/mips, signal handler invocations can be identified by the
210 designated code sequence that is used to return from a signal handler.
211 In particular, the return address of a signal handler points to the
212 following code sequence:
213
214 addu a0, sp, 16
215 li v0, 295 # __sigreturn14
216 syscall
217
218 Each instruction has a unique encoding, so we simply attempt to match
219 the instruction the PC is pointing to with any of the above instructions.
220 If there is a hit, we know the offset to the start of the designated
221 sequence and can then check whether we really are executing in the
222 signal trampoline. If not, -1 is returned, otherwise the offset from the
223 start of the return sequence is returned. */
224
225#define RETCODE_NWORDS 3
226#define RETCODE_SIZE (RETCODE_NWORDS * 4)
227
228static const unsigned char sigtramp_retcode_mipsel[RETCODE_SIZE] =
229{
230 0x10, 0x00, 0xa4, 0x27, /* addu a0, sp, 16 */
231 0x27, 0x01, 0x02, 0x24, /* li v0, 295 */
232 0x0c, 0x00, 0x00, 0x00, /* syscall */
233};
234
235static const unsigned char sigtramp_retcode_mipseb[RETCODE_SIZE] =
236{
237 0x27, 0xa4, 0x00, 0x10, /* addu a0, sp, 16 */
238 0x24, 0x02, 0x01, 0x27, /* li v0, 295 */
239 0x00, 0x00, 0x00, 0x0c, /* syscall */
240};
241
242#endif
243
244/* Figure out where the longjmp will land. We expect that we have
245 just entered longjmp and haven't yet setup the stack frame, so the
246 args are still in the argument regs. MIPS_A0_REGNUM points at the
247 jmp_buf structure from which we extract the PC that we will land
248 at. The PC is copied into *pc. This routine returns true on
249 success. */
250
251#define NBSD_MIPS_JB_PC (2 * 4)
252#define NBSD_MIPS_JB_ELEMENT_SIZE(gdbarch) mips_isa_regsize (gdbarch)
253#define NBSD_MIPS_JB_OFFSET(gdbarch) (NBSD_MIPS_JB_PC * \
254 NBSD_MIPS_JB_ELEMENT_SIZE (gdbarch))
255
256static int
258{
259 struct gdbarch *gdbarch = get_frame_arch (frame);
260 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
261 CORE_ADDR jb_addr;
262 gdb_byte *buf;
263
264 buf = (gdb_byte *) alloca (NBSD_MIPS_JB_ELEMENT_SIZE (gdbarch));
265
267
268 if (target_read_memory (jb_addr + NBSD_MIPS_JB_OFFSET (gdbarch), buf,
270 return 0;
271
273 byte_order);
274 return 1;
275}
276
277static int
279{
280 return (regno == MIPS_ZERO_REGNUM
281 || regno == mips_regnum (gdbarch)->fp_implementation_revision);
282}
283
284static int
286{
287 return (regno == MIPS_ZERO_REGNUM
288 || regno == mips_regnum (gdbarch)->fp_implementation_revision);
289}
290
291/* Shared library support. */
292
293/* NetBSD/mips uses a slightly different `struct link_map' than the
294 other NetBSD platforms. */
295
296static struct link_map_offsets *
298{
299 static struct link_map_offsets lmo;
300 static struct link_map_offsets *lmp = NULL;
301
302 if (lmp == NULL)
303 {
304 lmp = &lmo;
305
306 lmo.r_version_offset = 0;
307 lmo.r_version_size = 4;
308 lmo.r_map_offset = 4;
309 lmo.r_brk_offset = 8;
310 lmo.r_ldsomap_offset = -1;
311 lmo.r_next_offset = -1;
312
313 /* Everything we need is in the first 24 bytes. */
314 lmo.link_map_size = 24;
315 lmo.l_addr_offset = 4;
316 lmo.l_name_offset = 8;
317 lmo.l_ld_offset = 12;
318 lmo.l_next_offset = 16;
319 lmo.l_prev_offset = 20;
320 }
321
322 return lmp;
323}
324
325static struct link_map_offsets *
327{
328 static struct link_map_offsets lmo;
329 static struct link_map_offsets *lmp = NULL;
330
331 if (lmp == NULL)
332 {
333 lmp = &lmo;
334
335 lmo.r_version_offset = 0;
336 lmo.r_version_size = 4;
337 lmo.r_map_offset = 8;
338 lmo.r_brk_offset = 16;
339 lmo.r_ldsomap_offset = -1;
340 lmo.r_next_offset = -1;
341
342 /* Everything we need is in the first 40 bytes. */
343 lmo.link_map_size = 48;
344 lmo.l_addr_offset = 0;
345 lmo.l_name_offset = 16;
346 lmo.l_ld_offset = 24;
347 lmo.l_next_offset = 32;
348 lmo.l_prev_offset = 40;
349 }
350
351 return lmp;
352}
353
354
355static void
377
379void
int regnum
#define RETCODE_SIZE
gdbarch * arch() const
Definition regcache.c:231
void raw_collect(int regnum, void *buf) const override
Definition regcache.c:1127
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
Definition frame.c:1399
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2054
int gdbarch_cannot_store_register(struct gdbarch *gdbarch, int regnum)
Definition gdbarch.c:2419
int gdbarch_cannot_fetch_register(struct gdbarch *gdbarch, int regnum)
Definition gdbarch.c:2402
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step)
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype *get_longjmp_target)
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
Definition gdbarch.c:2088
void set_gdbarch_cannot_store_register(struct gdbarch *gdbarch, gdbarch_cannot_store_register_ftype *cannot_store_register)
void set_gdbarch_cannot_fetch_register(struct gdbarch *gdbarch, gdbarch_cannot_fetch_register_ftype *cannot_fetch_register)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
Definition gdbarch.h:104
static int mipsnbsd_cannot_store_register(struct gdbarch *gdbarch, int regno)
static int mipsnbsd_cannot_fetch_register(struct gdbarch *gdbarch, int regno)
void mipsnbsd_supply_reg(struct regcache *regcache, const char *regs, int regno)
static void mipsnbsd_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
void mipsnbsd_supply_fpreg(struct regcache *regcache, const char *fpregs, int regno)
#define MIPSNBSD_NUM_GREGS
static struct link_map_offsets * mipsnbsd_ilp32_fetch_link_map_offsets(void)
static const struct regset mipsnbsd_fpregset
#define MIPS_FSR_REGNUM
#define MIPSNBSD_NUM_FPREGS
void mipsnbsd_fill_fpreg(const struct regcache *regcache, char *fpregs, int regno)
#define MIPS_PC_REGNUM
static struct link_map_offsets * mipsnbsd_lp64_fetch_link_map_offsets(void)
static const struct regset mipsnbsd_gregset
#define MIPS_FP0_REGNUM
#define NBSD_MIPS_JB_ELEMENT_SIZE(gdbarch)
void mipsnbsd_fill_reg(const struct regcache *regcache, char *regs, int regno)
#define NBSD_MIPS_JB_OFFSET(gdbarch)
static void mipsnbsd_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static void mipsnbsd_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
void _initialize_mipsnbsd_tdep()
static int mipsnbsd_get_longjmp_target(frame_info_ptr frame, CORE_ADDR *pc)
static void mipsnbsd_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
std::vector< CORE_ADDR > mips_software_single_step(struct regcache *regcache)
Definition mips-tdep.c:4210
const struct mips_regnum * mips_regnum(struct gdbarch *gdbarch)
Definition mips-tdep.c:228
int mips_isa_regsize(struct gdbarch *gdbarch)
Definition mips-tdep.c:290
@ MIPS_ZERO_REGNUM
Definition mips-tdep.h:135
@ MIPS_A0_REGNUM
Definition mips-tdep.h:138
void nbsd_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition osabi.c:146
@ GDB_OSABI_NETBSD
Definition osabi.h:34
#define REGSET_VARIABLE_SIZE
Definition regset.h:52
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
int fp_implementation_revision
Definition mips-tdep.h:74
int fp_control_status
Definition mips-tdep.h:75
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785