Commit | Line | Data |
---|---|---|
1e067c66 MK |
1 | /* Target-dependent code for OpenBSD/sparc64. |
2 | ||
6aba47ca | 3 | Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc. |
1e067c66 MK |
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 2 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, write to the Free Software | |
197e01b6 EZ |
19 | Foundation, Inc., 51 Franklin Street, Fifth Floor, |
20 | Boston, MA 02110-1301, USA. */ | |
1e067c66 MK |
21 | |
22 | #include "defs.h" | |
23 | #include "frame.h" | |
24 | #include "frame-unwind.h" | |
585e38ed | 25 | #include "gdbcore.h" |
1e067c66 | 26 | #include "osabi.h" |
585e38ed | 27 | #include "regcache.h" |
1e067c66 MK |
28 | #include "regset.h" |
29 | #include "symtab.h" | |
3510d1f2 | 30 | #include "objfiles.h" |
1e067c66 MK |
31 | #include "trad-frame.h" |
32 | ||
33 | #include "gdb_assert.h" | |
34 | ||
4807909c | 35 | #include "obsd-tdep.h" |
1e067c66 | 36 | #include "sparc64-tdep.h" |
585e38ed MK |
37 | #include "solib-svr4.h" |
38 | #include "bsd-uthread.h" | |
1e067c66 MK |
39 | |
40 | /* OpenBSD uses the traditional NetBSD core file format, even for | |
41 | ports that use ELF. The core files don't use multiple register | |
42 | sets. Instead, the general-purpose and floating-point registers | |
43 | are lumped together in a single section. Unlike on NetBSD, OpenBSD | |
44 | uses a different layout for its general-purpose registers than the | |
45 | layout used for ptrace(2). */ | |
46 | ||
47 | /* From <machine/reg.h>. */ | |
48 | const struct sparc_gregset sparc64obsd_core_gregset = | |
49 | { | |
50 | 0 * 8, /* "tstate" */ | |
51 | 1 * 8, /* %pc */ | |
52 | 2 * 8, /* %npc */ | |
53 | 3 * 8, /* %y */ | |
54 | -1, /* %fprs */ | |
55 | -1, | |
56 | 7 * 8, /* %g1 */ | |
57 | 22 * 8, /* %l0 */ | |
58 | 4 /* sizeof (%y) */ | |
59 | }; | |
60 | ||
61 | static void | |
62 | sparc64obsd_supply_gregset (const struct regset *regset, | |
63 | struct regcache *regcache, | |
64 | int regnum, const void *gregs, size_t len) | |
65 | { | |
66 | const char *regs = gregs; | |
67 | ||
9ea75c57 | 68 | sparc64_supply_gregset (&sparc64obsd_core_gregset, regcache, regnum, regs); |
1e067c66 MK |
69 | sparc64_supply_fpregset (regcache, regnum, regs + 288); |
70 | } | |
71 | \f | |
72 | ||
73 | /* Signal trampolines. */ | |
74 | ||
47b4f830 MK |
75 | /* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page |
76 | in virtual memory. The randomness makes it somewhat tricky to | |
77 | detect it, but fortunately we can rely on the fact that the start | |
78 | of the sigtramp routine is page-aligned. We recognize the | |
79 | trampoline by looking for the code that invokes the sigreturn | |
80 | system call. The offset where we can find that code varies from | |
81 | release to release. | |
82 | ||
83 | By the way, the mapping mentioned above is read-only, so you cannot | |
84 | place a breakpoint in the signal trampoline. */ | |
85 | ||
86 | /* Default page size. */ | |
1e067c66 | 87 | static const int sparc64obsd_page_size = 8192; |
47b4f830 MK |
88 | |
89 | /* Offset for sigreturn(2). */ | |
90 | static const int sparc64obsd_sigreturn_offset[] = { | |
91 | 0xf0, /* OpenBSD 3.8 */ | |
92 | 0xec, /* OpenBSD 3.6 */ | |
93 | 0xe8, /* OpenBSD 3.2 */ | |
94 | -1 | |
95 | }; | |
1e067c66 MK |
96 | |
97 | static int | |
98 | sparc64obsd_pc_in_sigtramp (CORE_ADDR pc, char *name) | |
99 | { | |
100 | CORE_ADDR start_pc = (pc & ~(sparc64obsd_page_size - 1)); | |
101 | unsigned long insn; | |
dc856692 | 102 | const int *offset; |
1e067c66 MK |
103 | |
104 | if (name) | |
105 | return 0; | |
106 | ||
dc856692 | 107 | for (offset = sparc64obsd_sigreturn_offset; *offset != -1; offset++) |
24f033e8 | 108 | { |
dc856692 MK |
109 | /* Check for "restore %g0, SYS_sigreturn, %g1". */ |
110 | insn = sparc_fetch_instruction (start_pc + *offset); | |
111 | if (insn != 0x83e82067) | |
112 | continue; | |
1e067c66 | 113 | |
dc856692 MK |
114 | /* Check for "t ST_SYSCALL". */ |
115 | insn = sparc_fetch_instruction (start_pc + *offset + 8); | |
116 | if (insn != 0x91d02000) | |
117 | continue; | |
118 | ||
119 | return 1; | |
5a5effe1 | 120 | } |
1e067c66 | 121 | |
dc856692 | 122 | return 0; |
1e067c66 MK |
123 | } |
124 | ||
125 | static struct sparc_frame_cache * | |
126 | sparc64obsd_frame_cache (struct frame_info *next_frame, void **this_cache) | |
127 | { | |
128 | struct sparc_frame_cache *cache; | |
129 | CORE_ADDR addr; | |
130 | ||
131 | if (*this_cache) | |
132 | return *this_cache; | |
133 | ||
134 | cache = sparc_frame_cache (next_frame, this_cache); | |
135 | gdb_assert (cache == *this_cache); | |
136 | ||
137 | /* If we couldn't find the frame's function, we're probably dealing | |
138 | with an on-stack signal trampoline. */ | |
139 | if (cache->pc == 0) | |
140 | { | |
141 | cache->pc = frame_pc_unwind (next_frame); | |
142 | cache->pc &= ~(sparc64obsd_page_size - 1); | |
143 | ||
144 | /* Since we couldn't find the frame's function, the cache was | |
145 | initialized under the assumption that we're frameless. */ | |
146 | cache->frameless_p = 0; | |
147 | addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM); | |
5b2d44a0 MK |
148 | if (addr & 1) |
149 | addr += BIAS; | |
1e067c66 MK |
150 | cache->base = addr; |
151 | } | |
152 | ||
153 | /* We find the appropriate instance of `struct sigcontext' at a | |
154 | fixed offset in the signal frame. */ | |
5b2d44a0 | 155 | addr = cache->base + 128 + 16; |
1e067c66 MK |
156 | cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, next_frame); |
157 | ||
158 | return cache; | |
159 | } | |
160 | ||
161 | static void | |
162 | sparc64obsd_frame_this_id (struct frame_info *next_frame, void **this_cache, | |
163 | struct frame_id *this_id) | |
164 | { | |
165 | struct sparc_frame_cache *cache = | |
166 | sparc64obsd_frame_cache (next_frame, this_cache); | |
167 | ||
168 | (*this_id) = frame_id_build (cache->base, cache->pc); | |
169 | } | |
170 | ||
171 | static void | |
172 | sparc64obsd_frame_prev_register (struct frame_info *next_frame, | |
173 | void **this_cache, | |
174 | int regnum, int *optimizedp, | |
175 | enum lval_type *lvalp, CORE_ADDR *addrp, | |
47ef841b | 176 | int *realnump, gdb_byte *valuep) |
1e067c66 MK |
177 | { |
178 | struct sparc_frame_cache *cache = | |
179 | sparc64obsd_frame_cache (next_frame, this_cache); | |
180 | ||
1f67027d AC |
181 | trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum, |
182 | optimizedp, lvalp, addrp, realnump, valuep); | |
1e067c66 MK |
183 | } |
184 | ||
185 | static const struct frame_unwind sparc64obsd_frame_unwind = | |
186 | { | |
187 | SIGTRAMP_FRAME, | |
188 | sparc64obsd_frame_this_id, | |
189 | sparc64obsd_frame_prev_register | |
190 | }; | |
191 | ||
192 | static const struct frame_unwind * | |
193 | sparc64obsd_sigtramp_frame_sniffer (struct frame_info *next_frame) | |
194 | { | |
195 | CORE_ADDR pc = frame_pc_unwind (next_frame); | |
196 | char *name; | |
197 | ||
198 | find_pc_partial_function (pc, &name, NULL, NULL); | |
199 | if (sparc64obsd_pc_in_sigtramp (pc, name)) | |
200 | return &sparc64obsd_frame_unwind; | |
201 | ||
202 | return NULL; | |
203 | } | |
204 | \f | |
6df5070e MK |
205 | /* Kernel debugging support. */ |
206 | ||
207 | static struct sparc_frame_cache * | |
93d42b30 | 208 | sparc64obsd_trapframe_cache (struct frame_info *next_frame, void **this_cache) |
6df5070e MK |
209 | { |
210 | struct sparc_frame_cache *cache; | |
211 | CORE_ADDR sp, trapframe_addr; | |
212 | int regnum; | |
213 | ||
214 | if (*this_cache) | |
215 | return *this_cache; | |
216 | ||
217 | cache = sparc_frame_cache (next_frame, this_cache); | |
218 | gdb_assert (cache == *this_cache); | |
219 | ||
220 | sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM); | |
221 | trapframe_addr = sp + BIAS + 176; | |
222 | ||
223 | cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); | |
224 | ||
225 | cache->saved_regs[SPARC64_STATE_REGNUM].addr = trapframe_addr; | |
226 | cache->saved_regs[SPARC64_PC_REGNUM].addr = trapframe_addr + 8; | |
227 | cache->saved_regs[SPARC64_NPC_REGNUM].addr = trapframe_addr + 16; | |
228 | ||
229 | for (regnum = SPARC_G0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++) | |
230 | cache->saved_regs[regnum].addr = | |
231 | trapframe_addr + 48 + (regnum - SPARC_G0_REGNUM) * 8; | |
232 | ||
233 | return cache; | |
234 | } | |
235 | ||
236 | static void | |
237 | sparc64obsd_trapframe_this_id (struct frame_info *next_frame, | |
238 | void **this_cache, struct frame_id *this_id) | |
239 | { | |
240 | struct sparc_frame_cache *cache = | |
241 | sparc64obsd_trapframe_cache (next_frame, this_cache); | |
242 | ||
243 | (*this_id) = frame_id_build (cache->base, cache->pc); | |
244 | } | |
245 | ||
246 | static void | |
247 | sparc64obsd_trapframe_prev_register (struct frame_info *next_frame, | |
248 | void **this_cache, | |
249 | int regnum, int *optimizedp, | |
250 | enum lval_type *lvalp, CORE_ADDR *addrp, | |
251 | int *realnump, gdb_byte *valuep) | |
252 | { | |
253 | struct sparc_frame_cache *cache = | |
254 | sparc64obsd_trapframe_cache (next_frame, this_cache); | |
255 | ||
256 | trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum, | |
257 | optimizedp, lvalp, addrp, realnump, valuep); | |
258 | } | |
259 | ||
260 | static const struct frame_unwind sparc64obsd_trapframe_unwind = | |
261 | { | |
262 | NORMAL_FRAME, | |
263 | sparc64obsd_trapframe_this_id, | |
264 | sparc64obsd_trapframe_prev_register | |
265 | }; | |
266 | ||
267 | static const struct frame_unwind * | |
268 | sparc64obsd_trapframe_sniffer (struct frame_info *next_frame) | |
269 | { | |
93d42b30 | 270 | CORE_ADDR pc; |
6df5070e MK |
271 | ULONGEST pstate; |
272 | char *name; | |
273 | ||
274 | /* Check whether we are in privileged mode, and bail out if we're not. */ | |
93d42b30 | 275 | pstate = frame_unwind_register_unsigned (next_frame, SPARC64_PSTATE_REGNUM); |
6df5070e MK |
276 | if ((pstate & SPARC64_PSTATE_PRIV) == 0) |
277 | return NULL; | |
278 | ||
93d42b30 DJ |
279 | pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); |
280 | find_pc_partial_function (pc, &name, NULL, NULL); | |
6df5070e MK |
281 | if (name && strcmp (name, "Lslowtrap_reenter") == 0) |
282 | return &sparc64obsd_trapframe_unwind; | |
283 | ||
284 | return NULL; | |
285 | } | |
286 | \f | |
1e067c66 | 287 | |
585e38ed MK |
288 | /* Threads support. */ |
289 | ||
290 | /* Offset wthin the thread structure where we can find %fp and %i7. */ | |
291 | #define SPARC64OBSD_UTHREAD_FP_OFFSET 232 | |
292 | #define SPARC64OBSD_UTHREAD_PC_OFFSET 240 | |
293 | ||
294 | static void | |
295 | sparc64obsd_supply_uthread (struct regcache *regcache, | |
296 | int regnum, CORE_ADDR addr) | |
297 | { | |
298 | CORE_ADDR fp, fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET; | |
299 | gdb_byte buf[8]; | |
300 | ||
301 | gdb_assert (regnum >= -1); | |
302 | ||
303 | fp = read_memory_unsigned_integer (fp_addr, 8); | |
304 | if (regnum == SPARC_SP_REGNUM || regnum == -1) | |
305 | { | |
306 | store_unsigned_integer (buf, 8, fp); | |
307 | regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf); | |
308 | ||
309 | if (regnum == SPARC_SP_REGNUM) | |
310 | return; | |
311 | } | |
312 | ||
313 | if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM | |
314 | || regnum == -1) | |
315 | { | |
316 | CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET; | |
317 | ||
318 | i7 = read_memory_unsigned_integer (i7_addr, 8); | |
319 | if (regnum == SPARC64_PC_REGNUM || regnum == -1) | |
320 | { | |
321 | store_unsigned_integer (buf, 8, i7 + 8); | |
322 | regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf); | |
323 | } | |
324 | if (regnum == SPARC64_NPC_REGNUM || regnum == -1) | |
325 | { | |
326 | store_unsigned_integer (buf, 8, i7 + 12); | |
327 | regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf); | |
328 | } | |
329 | ||
330 | if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM) | |
331 | return; | |
332 | } | |
333 | ||
334 | sparc_supply_rwindow (regcache, fp, regnum); | |
335 | } | |
336 | ||
337 | static void | |
338 | sparc64obsd_collect_uthread(const struct regcache *regcache, | |
339 | int regnum, CORE_ADDR addr) | |
340 | { | |
341 | CORE_ADDR sp; | |
342 | gdb_byte buf[8]; | |
343 | ||
344 | gdb_assert (regnum >= -1); | |
345 | ||
346 | if (regnum == SPARC_SP_REGNUM || regnum == -1) | |
347 | { | |
348 | CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET; | |
349 | ||
350 | regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf); | |
351 | write_memory (fp_addr,buf, 8); | |
352 | } | |
353 | ||
354 | if (regnum == SPARC64_PC_REGNUM || regnum == -1) | |
355 | { | |
356 | CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET; | |
357 | ||
358 | regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf); | |
359 | i7 = extract_unsigned_integer (buf, 8) - 8; | |
360 | write_memory_unsigned_integer (i7_addr, 8, i7); | |
361 | ||
362 | if (regnum == SPARC64_PC_REGNUM) | |
363 | return; | |
364 | } | |
365 | ||
366 | regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf); | |
367 | sp = extract_unsigned_integer (buf, 8); | |
368 | sparc_collect_rwindow (regcache, sp, regnum); | |
369 | } | |
370 | \f | |
371 | ||
1e067c66 MK |
372 | static void |
373 | sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
374 | { | |
375 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
376 | ||
9ea75c57 | 377 | tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL); |
1e067c66 MK |
378 | tdep->sizeof_gregset = 832; |
379 | ||
c893be75 MK |
380 | /* Make sure we can single-step "new" syscalls. */ |
381 | tdep->step_trap = sparcnbsd_step_trap; | |
382 | ||
1e067c66 | 383 | frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer); |
6df5070e | 384 | frame_unwind_append_sniffer (gdbarch, sparc64obsd_trapframe_sniffer); |
1e067c66 MK |
385 | |
386 | sparc64_init_abi (info, gdbarch); | |
387 | ||
5b2d44a0 | 388 | /* OpenBSD/sparc64 has SVR4-style shared libraries. */ |
1e067c66 | 389 | set_solib_svr4_fetch_link_map_offsets |
3510d1f2 | 390 | (gdbarch, svr4_lp64_fetch_link_map_offsets); |
4807909c | 391 | set_gdbarch_skip_solib_resolver (gdbarch, obsd_skip_solib_resolver); |
585e38ed MK |
392 | |
393 | /* OpenBSD provides a user-level threads implementation. */ | |
394 | bsd_uthread_set_supply_uthread (gdbarch, sparc64obsd_supply_uthread); | |
395 | bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread); | |
1e067c66 | 396 | } |
1e067c66 | 397 | \f |
5b2d44a0 | 398 | |
1e067c66 MK |
399 | /* Provide a prototype to silence -Wmissing-prototypes. */ |
400 | void _initialize_sparc64obsd_tdep (void); | |
401 | ||
402 | void | |
403 | _initialize_sparc64obsd_tdep (void) | |
404 | { | |
405 | gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9, | |
406 | GDB_OSABI_OPENBSD_ELF, sparc64obsd_init_abi); | |
407 | } |