Automatic date update in version.in
[binutils-gdb.git] / gdb / ppc-obsd-tdep.c
blob90fb5e3a3995776a9a1dd443739fe33eb5d567a9
1 /* Target-dependent code for OpenBSD/powerpc.
3 Copyright (C) 2004-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "frame.h"
23 #include "frame-unwind.h"
24 #include "gdbtypes.h"
25 #include "osabi.h"
26 #include "regcache.h"
27 #include "regset.h"
28 #include "symtab.h"
29 #include "trad-frame.h"
31 #include "ppc-tdep.h"
32 #include "ppc-obsd-tdep.h"
33 #include "solib-svr4.h"
35 /* Register offsets from <machine/reg.h>. */
36 struct ppc_reg_offsets ppcobsd_reg_offsets;
37 struct ppc_reg_offsets ppcobsd_fpreg_offsets;
40 /* Core file support. */
42 /* Supply register REGNUM in the general-purpose register set REGSET
43 from the buffer specified by GREGS and LEN to register cache
44 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
46 void
47 ppcobsd_supply_gregset (const struct regset *regset,
48 struct regcache *regcache, int regnum,
49 const void *gregs, size_t len)
51 ppc_supply_gregset (regset, regcache, regnum, gregs, len);
52 ppc_supply_fpregset (regset, regcache, regnum, gregs, len);
55 /* Collect register REGNUM in the general-purpose register set
56 REGSET, from register cache REGCACHE into the buffer specified by
57 GREGS and LEN. If REGNUM is -1, do this for all registers in
58 REGSET. */
60 void
61 ppcobsd_collect_gregset (const struct regset *regset,
62 const struct regcache *regcache, int regnum,
63 void *gregs, size_t len)
65 ppc_collect_gregset (regset, regcache, regnum, gregs, len);
66 ppc_collect_fpregset (regset, regcache, regnum, gregs, len);
69 /* OpenBSD/powerpc register set. */
71 const struct regset ppcobsd_gregset =
73 &ppcobsd_reg_offsets,
74 ppcobsd_supply_gregset
77 const struct regset ppcobsd_fpregset =
79 &ppcobsd_fpreg_offsets,
80 ppc_supply_fpregset
83 /* Iterate over core file register note sections. */
85 static void
86 ppcobsd_iterate_over_regset_sections (struct gdbarch *gdbarch,
87 iterate_over_regset_sections_cb *cb,
88 void *cb_data,
89 const struct regcache *regcache)
91 cb (".reg", 412, 412, &ppcobsd_gregset, NULL, cb_data);
95 /* Signal trampolines. */
97 /* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page
98 in virtual memory. The randomness makes it somewhat tricky to
99 detect it, but fortunately we can rely on the fact that the start
100 of the sigtramp routine is page-aligned. We recognize the
101 trampoline by looking for the code that invokes the sigreturn
102 system call. The offset where we can find that code varies from
103 release to release.
105 By the way, the mapping mentioned above is read-only, so you cannot
106 place a breakpoint in the signal trampoline. */
108 /* Default page size. */
109 static const int ppcobsd_page_size = 4096;
111 /* Offset for sigreturn(2). */
112 static const int ppcobsd_sigreturn_offset[] = {
113 0x98, /* OpenBSD 3.8 */
114 0x0c, /* OpenBSD 3.2 */
118 static int
119 ppcobsd_sigtramp_frame_sniffer (const struct frame_unwind *self,
120 struct frame_info *this_frame,
121 void **this_cache)
123 struct gdbarch *gdbarch = get_frame_arch (this_frame);
124 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
125 CORE_ADDR pc = get_frame_pc (this_frame);
126 CORE_ADDR start_pc = (pc & ~(ppcobsd_page_size - 1));
127 const int *offset;
128 const char *name;
130 find_pc_partial_function (pc, &name, NULL, NULL);
131 if (name)
132 return 0;
134 for (offset = ppcobsd_sigreturn_offset; *offset != -1; offset++)
136 gdb_byte buf[2 * PPC_INSN_SIZE];
137 unsigned long insn;
139 if (!safe_frame_unwind_memory (this_frame, start_pc + *offset,
140 {buf, sizeof buf}))
141 continue;
143 /* Check for "li r0,SYS_sigreturn". */
144 insn = extract_unsigned_integer (buf, PPC_INSN_SIZE, byte_order);
145 if (insn != 0x38000067)
146 continue;
148 /* Check for "sc". */
149 insn = extract_unsigned_integer (buf + PPC_INSN_SIZE,
150 PPC_INSN_SIZE, byte_order);
151 if (insn != 0x44000002)
152 continue;
154 return 1;
157 return 0;
160 static struct trad_frame_cache *
161 ppcobsd_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
163 struct gdbarch *gdbarch = get_frame_arch (this_frame);
164 ppc_gdbarch_tdep *tdep = gdbarch_tdep<ppc_gdbarch_tdep> (gdbarch);
165 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
166 struct trad_frame_cache *cache;
167 CORE_ADDR addr, base, func;
168 gdb_byte buf[PPC_INSN_SIZE];
169 unsigned long insn, sigcontext_offset;
170 int i;
172 if (*this_cache)
173 return (struct trad_frame_cache *) *this_cache;
175 cache = trad_frame_cache_zalloc (this_frame);
176 *this_cache = cache;
178 func = get_frame_pc (this_frame);
179 func &= ~(ppcobsd_page_size - 1);
180 if (!safe_frame_unwind_memory (this_frame, func, {buf, sizeof buf}))
181 return cache;
183 /* Calculate the offset where we can find `struct sigcontext'. We
184 base our calculation on the amount of stack space reserved by the
185 first instruction of the signal trampoline. */
186 insn = extract_unsigned_integer (buf, PPC_INSN_SIZE, byte_order);
187 sigcontext_offset = (0x10000 - (insn & 0x0000ffff)) + 8;
189 base = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
190 addr = base + sigcontext_offset + 2 * tdep->wordsize;
191 for (i = 0; i < ppc_num_gprs; i++, addr += tdep->wordsize)
193 int regnum = i + tdep->ppc_gp0_regnum;
194 trad_frame_set_reg_addr (cache, regnum, addr);
196 trad_frame_set_reg_addr (cache, tdep->ppc_lr_regnum, addr);
197 addr += tdep->wordsize;
198 trad_frame_set_reg_addr (cache, tdep->ppc_cr_regnum, addr);
199 addr += tdep->wordsize;
200 trad_frame_set_reg_addr (cache, tdep->ppc_xer_regnum, addr);
201 addr += tdep->wordsize;
202 trad_frame_set_reg_addr (cache, tdep->ppc_ctr_regnum, addr);
203 addr += tdep->wordsize;
204 trad_frame_set_reg_addr (cache, gdbarch_pc_regnum (gdbarch), addr);
205 /* SRR0? */
206 addr += tdep->wordsize;
208 /* Construct the frame ID using the function start. */
209 trad_frame_set_id (cache, frame_id_build (base, func));
211 return cache;
214 static void
215 ppcobsd_sigtramp_frame_this_id (struct frame_info *this_frame,
216 void **this_cache, struct frame_id *this_id)
218 struct trad_frame_cache *cache =
219 ppcobsd_sigtramp_frame_cache (this_frame, this_cache);
221 trad_frame_get_id (cache, this_id);
224 static struct value *
225 ppcobsd_sigtramp_frame_prev_register (struct frame_info *this_frame,
226 void **this_cache, int regnum)
228 struct trad_frame_cache *cache =
229 ppcobsd_sigtramp_frame_cache (this_frame, this_cache);
231 return trad_frame_get_register (cache, this_frame, regnum);
234 static const struct frame_unwind ppcobsd_sigtramp_frame_unwind = {
235 "ppc openbsd sigtramp",
236 SIGTRAMP_FRAME,
237 default_frame_unwind_stop_reason,
238 ppcobsd_sigtramp_frame_this_id,
239 ppcobsd_sigtramp_frame_prev_register,
240 NULL,
241 ppcobsd_sigtramp_frame_sniffer
245 static void
246 ppcobsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
248 /* OpenBSD doesn't support the 128-bit `long double' from the psABI. */
249 set_gdbarch_long_double_bit (gdbarch, 64);
250 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
252 /* OpenBSD currently uses a broken GCC. */
253 set_gdbarch_return_value (gdbarch, ppc_sysv_abi_broken_return_value);
255 /* OpenBSD uses SVR4-style shared libraries. */
256 set_solib_svr4_fetch_link_map_offsets
257 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
259 set_gdbarch_iterate_over_regset_sections
260 (gdbarch, ppcobsd_iterate_over_regset_sections);
262 frame_unwind_append_unwinder (gdbarch, &ppcobsd_sigtramp_frame_unwind);
265 void _initialize_ppcobsd_tdep ();
266 void
267 _initialize_ppcobsd_tdep ()
269 gdbarch_register_osabi (bfd_arch_rs6000, 0, GDB_OSABI_OPENBSD,
270 ppcobsd_init_abi);
271 gdbarch_register_osabi (bfd_arch_powerpc, 0, GDB_OSABI_OPENBSD,
272 ppcobsd_init_abi);
274 /* Avoid initializing the register offsets again if they were
275 already initialized by ppcobsd-nat.c. */
276 if (ppcobsd_reg_offsets.pc_offset == 0)
278 /* General-purpose registers. */
279 ppcobsd_reg_offsets.r0_offset = 0;
280 ppcobsd_reg_offsets.gpr_size = 4;
281 ppcobsd_reg_offsets.xr_size = 4;
282 ppcobsd_reg_offsets.pc_offset = 384;
283 ppcobsd_reg_offsets.ps_offset = 388;
284 ppcobsd_reg_offsets.cr_offset = 392;
285 ppcobsd_reg_offsets.lr_offset = 396;
286 ppcobsd_reg_offsets.ctr_offset = 400;
287 ppcobsd_reg_offsets.xer_offset = 404;
288 ppcobsd_reg_offsets.mq_offset = 408;
290 /* Floating-point registers. */
291 ppcobsd_reg_offsets.f0_offset = 128;
292 ppcobsd_reg_offsets.fpscr_offset = -1;
296 if (ppcobsd_fpreg_offsets.fpscr_offset == 0)
298 /* Floating-point registers. */
299 ppcobsd_reg_offsets.f0_offset = 0;
300 ppcobsd_reg_offsets.fpscr_offset = 256;
301 ppcobsd_reg_offsets.fpscr_size = 4;