GDB (xrefs)
Loading...
Searching...
No Matches
alpha-netbsd-tdep.c
Go to the documentation of this file.
1/* Target-dependent code for NetBSD/alpha.
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 "frame.h"
24#include "gdbcore.h"
25#include "osabi.h"
26#include "regcache.h"
27#include "regset.h"
28#include "value.h"
29
30#include "alpha-tdep.h"
31#include "alpha-bsd-tdep.h"
32#include "netbsd-tdep.h"
33#include "solib-svr4.h"
34#include "target.h"
35
36/* Core file support. */
37
38/* Sizeof `struct reg' in <machine/reg.h>. */
39#define ALPHANBSD_SIZEOF_GREGS (32 * 8)
40
41/* Sizeof `struct fpreg' in <machine/reg.h. */
42#define ALPHANBSD_SIZEOF_FPREGS ((32 * 8) + 8)
43
44/* Supply register REGNUM from the buffer specified by FPREGS and LEN
45 in the floating-point register set REGSET to register cache
46 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
47
48static void
50 struct regcache *regcache,
51 int regnum, const void *fpregs, size_t len)
52{
53 const gdb_byte *regs = (const gdb_byte *) fpregs;
54 int i;
55
56 gdb_assert (len >= ALPHANBSD_SIZEOF_FPREGS);
57
58 for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++)
59 {
60 if (regnum == i || regnum == -1)
61 regcache->raw_supply (i, regs + (i - ALPHA_FP0_REGNUM) * 8);
62 }
63
64 if (regnum == ALPHA_FPCR_REGNUM || regnum == -1)
65 regcache->raw_supply (ALPHA_FPCR_REGNUM, regs + 32 * 8);
66}
67
68/* Supply register REGNUM from the buffer specified by GREGS and LEN
69 in the general-purpose register set REGSET to register cache
70 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
71
72static void
74 struct regcache *regcache,
75 int regnum, const void *gregs, size_t len)
76{
77 const gdb_byte *regs = (const gdb_byte *) gregs;
78 int i;
79
80 /* Table to map a GDB register number to a trapframe register index. */
81 static const int regmap[] =
82 {
83 0, 1, 2, 3,
84 4, 5, 6, 7,
85 8, 9, 10, 11,
86 12, 13, 14, 15,
87 30, 31, 32, 16,
88 17, 18, 19, 20,
89 21, 22, 23, 24,
90 25, 29, 26
91 };
92
93 gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS);
94
95 for (i = 0; i < ARRAY_SIZE(regmap); i++)
96 {
97 if (regnum == i || regnum == -1)
98 regcache->raw_supply (i, regs + regmap[i] * 8);
99 }
100
101 if (regnum == ALPHA_PC_REGNUM || regnum == -1)
102 regcache->raw_supply (ALPHA_PC_REGNUM, regs + 31 * 8);
103
105 {
109 }
110}
111
112/* Supply register REGNUM from the buffer specified by GREGS and LEN
113 in the general-purpose register set REGSET to register cache
114 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
115
116static void
118 struct regcache *regcache,
119 int regnum, const void *gregs, size_t len)
120{
121 const gdb_byte *regs = (const gdb_byte *) gregs;
122 int i;
123
125 {
127 return;
128 }
129
130 for (i = 0; i < ALPHA_ZERO_REGNUM; i++)
131 {
132 if (regnum == i || regnum == -1)
133 regcache->raw_supply (i, regs + i * 8);
134 }
135
136 if (regnum == ALPHA_PC_REGNUM || regnum == -1)
137 regcache->raw_supply (ALPHA_PC_REGNUM, regs + 31 * 8);
138}
139
140/* NetBSD/alpha register sets. */
141
142static const struct regset alphanbsd_gregset =
143{
144 NULL,
146 NULL,
148};
149
150static const struct regset alphanbsd_fpregset =
151{
152 NULL,
154};
155
156/* Iterate over supported core file register note sections. */
157
158void
161 void *cb_data,
162 const struct regcache *regcache)
163{
165 &alphanbsd_gregset, NULL, cb_data);
167 &alphanbsd_fpregset, NULL, cb_data);
168}
169
170
171/* Signal trampolines. */
172
173/* Under NetBSD/alpha, signal handler invocations can be identified by the
174 designated code sequence that is used to return from a signal handler.
175 In particular, the return address of a signal handler points to the
176 following code sequence:
177
178 ldq a0, 0(sp)
179 lda sp, 16(sp)
180 lda v0, 295(zero) # __sigreturn14
181 call_pal callsys
182
183 Each instruction has a unique encoding, so we simply attempt to match
184 the instruction the PC is pointing to with any of the above instructions.
185 If there is a hit, we know the offset to the start of the designated
186 sequence and can then check whether we really are executing in the
187 signal trampoline. If not, -1 is returned, otherwise the offset from the
188 start of the return sequence is returned. */
189static const gdb_byte sigtramp_retcode[] =
190{
191 0x00, 0x00, 0x1e, 0xa6, /* ldq a0, 0(sp) */
192 0x10, 0x00, 0xde, 0x23, /* lda sp, 16(sp) */
193 0x27, 0x01, 0x1f, 0x20, /* lda v0, 295(zero) */
194 0x83, 0x00, 0x00, 0x00, /* call_pal callsys */
195};
196#define RETCODE_NWORDS 4
197#define RETCODE_SIZE (RETCODE_NWORDS * 4)
198
199static LONGEST
201{
202 gdb_byte ret[RETCODE_SIZE], w[4];
203 LONGEST off;
204 int i;
205
206 if (target_read_memory (pc, w, 4) != 0)
207 return -1;
208
209 for (i = 0; i < RETCODE_NWORDS; i++)
210 {
211 if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0)
212 break;
213 }
214 if (i == RETCODE_NWORDS)
215 return (-1);
216
217 off = i * 4;
218 pc -= off;
219
220 if (target_read_memory (pc, ret, sizeof (ret)) != 0)
221 return -1;
222
223 if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0)
224 return off;
225
226 return -1;
227}
228
229static int
231 CORE_ADDR pc, const char *func_name)
232{
233 return (nbsd_pc_in_sigtramp (pc, func_name)
234 || alphanbsd_sigtramp_offset (gdbarch, pc) >= 0);
235}
236
237static CORE_ADDR
239{
240 /* FIXME: This is not correct for all versions of NetBSD/alpha.
241 We will probably need to disassemble the trampoline to figure
242 out which trampoline frame type we have. */
243 if (!get_next_frame (frame))
244 return 0;
245 return get_frame_base (get_next_frame (frame));
246}
247
248
249static void
251 struct gdbarch *gdbarch)
252{
253 alpha_gdbarch_tdep *tdep = gdbarch_tdep<alpha_gdbarch_tdep> (gdbarch);
254
255 /* Hook into the DWARF CFI frame unwinder. */
257
258 /* Hook into the MDEBUG frame unwinder. */
260
261 nbsd_init_abi (info, gdbarch);
262
263 /* NetBSD/alpha does not provide single step support via ptrace(2); we
264 must use software single-stepping. */
266
267 /* NetBSD/alpha has SVR4-style shared libraries. */
270
274
275 tdep->jb_pc = 2;
276 tdep->jb_elt_size = 8;
277
280}
281
282
284void
286{
287 /* Even though NetBSD/alpha used ELF since day one, it used the
288 traditional a.out-style core dump format before NetBSD 1.6, but
289 we don't support those. */
290 gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD,
292}
int regnum
void alpha_mdebug_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static int alphanbsd_pc_in_sigtramp(struct gdbarch *gdbarch, CORE_ADDR pc, const char *func_name)
#define RETCODE_NWORDS
#define RETCODE_SIZE
static void alphanbsd_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static LONGEST alphanbsd_sigtramp_offset(struct gdbarch *gdbarch, CORE_ADDR pc)
static void alphanbsd_aout_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
static const struct regset alphanbsd_gregset
static void alphanbsd_supply_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
static void alphanbsd_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
#define ALPHANBSD_SIZEOF_GREGS
void _initialize_alphanbsd_tdep()
static const gdb_byte sigtramp_retcode[]
static const struct regset alphanbsd_fpregset
void alphanbsd_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
#define ALPHANBSD_SIZEOF_FPREGS
static CORE_ADDR alphanbsd_sigcontext_addr(frame_info_ptr frame)
void alpha_dwarf2_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
std::vector< CORE_ADDR > alpha_software_single_step(struct regcache *regcache)
#define ALPHA_PC_REGNUM
Definition alpha-tdep.h:52
#define ALPHA_FP0_REGNUM
Definition alpha-tdep.h:49
#define ALPHA_FPCR_REGNUM
Definition alpha-tdep.h:51
#define ALPHA_ZERO_REGNUM
Definition alpha-tdep.h:48
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1062
frame_info_ptr get_next_frame(frame_info_ptr this_frame)
Definition frame.c:2068
CORE_ADDR get_frame_base(frame_info_ptr fi)
Definition frame.c:2879
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step)
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 regmap[]
int nbsd_pc_in_sigtramp(CORE_ADDR pc, const char *func_name)
Definition netbsd-tdep.c:48
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))
struct link_map_offsets * svr4_lp64_fetch_link_map_offsets(void)
CORE_ADDR(* sigcontext_addr)(frame_info_ptr)
Definition alpha-tdep.h:84
int(* pc_in_sigtramp)(struct gdbarch *gdbarch, CORE_ADDR pc, const char *name)
Definition alpha-tdep.h:90
LONGEST(* dynamic_sigtramp_offset)(struct gdbarch *, CORE_ADDR)
Definition alpha-tdep.h:80
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785