X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsparc64obsd-tdep.c;h=55f0d4982efb3913c564b96078e3e30e8e218b3b;hb=ebd3bcc1327e6a7de6daf6536134cb20be9c2cfd;hp=18e0416c94bad18c29eeb5511820fe04618dc221;hpb=af380d6174d81b323d02d6b0acf02828d360b816;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sparc64obsd-tdep.c b/gdb/sparc64obsd-tdep.c index 18e0416c94..55f0d4982e 100644 --- a/gdb/sparc64obsd-tdep.c +++ b/gdb/sparc64obsd-tdep.c @@ -1,12 +1,12 @@ /* Target-dependent code for OpenBSD/sparc64. - Copyright 2004 Free Software Foundation, Inc. + Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -15,23 +15,25 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "frame.h" #include "frame-unwind.h" +#include "gdbcore.h" #include "osabi.h" +#include "regcache.h" #include "regset.h" #include "symtab.h" #include "objfiles.h" -#include "solib-svr4.h" #include "trad-frame.h" #include "gdb_assert.h" +#include "obsd-tdep.h" #include "sparc64-tdep.h" +#include "solib-svr4.h" +#include "bsd-uthread.h" /* OpenBSD uses the traditional NetBSD core file format, even for ports that use ELF. The core files don't use multiple register @@ -68,19 +70,27 @@ sparc64obsd_supply_gregset (const struct regset *regset, /* Signal trampolines. */ -/* The OpenBSD kernel maps the signal trampoline at some random - location in user space, which means that the traditional BSD way of - detecting it won't work. +/* Since OpenBSD 3.2, the sigtramp routine is mapped at a random page + in virtual memory. The randomness makes it somewhat tricky to + detect it, but fortunately we can rely on the fact that the start + of the sigtramp routine is page-aligned. We recognize the + trampoline by looking for the code that invokes the sigreturn + system call. The offset where we can find that code varies from + release to release. - The signal trampoline will be mapped at an address that is page - aligned. We recognize the signal trampoline by the looking for the - sigreturn system call. The offset where we can find the code that - makes this system call varies from release to release. For OpenBSD - 3.6 and later releases we can find the code at offset 0xec. For - OpenBSD 3.5 and earlier releases, we find it at offset 0xe8. */ + By the way, the mapping mentioned above is read-only, so you cannot + place a breakpoint in the signal trampoline. */ +/* Default page size. */ static const int sparc64obsd_page_size = 8192; -static const int sparc64obsd_sigreturn_offset[] = { 0xec, 0xe8, -1 }; + +/* Offset for sigreturn(2). */ +static const int sparc64obsd_sigreturn_offset[] = { + 0xf0, /* OpenBSD 3.8 */ + 0xec, /* OpenBSD 3.6 */ + 0xe8, /* OpenBSD 3.2 */ + -1 +}; static int sparc64obsd_pc_in_sigtramp (CORE_ADDR pc, char *name) @@ -133,12 +143,14 @@ sparc64obsd_frame_cache (struct frame_info *next_frame, void **this_cache) initialized under the assumption that we're frameless. */ cache->frameless_p = 0; addr = frame_unwind_register_unsigned (next_frame, SPARC_FP_REGNUM); + if (addr & 1) + addr += BIAS; cache->base = addr; } /* We find the appropriate instance of `struct sigcontext' at a fixed offset in the signal frame. */ - addr = cache->base + BIAS + 128 + 16; + addr = cache->base + 128 + 16; cache->saved_regs = sparc64nbsd_sigcontext_saved_regs (addr, next_frame); return cache; @@ -159,7 +171,7 @@ sparc64obsd_frame_prev_register (struct frame_info *next_frame, void **this_cache, int regnum, int *optimizedp, enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, void *valuep) + int *realnump, gdb_byte *valuep) { struct sparc_frame_cache *cache = sparc64obsd_frame_cache (next_frame, this_cache); @@ -188,6 +200,172 @@ sparc64obsd_sigtramp_frame_sniffer (struct frame_info *next_frame) return NULL; } +/* Kernel debugging support. */ + +static struct sparc_frame_cache * +sparc64obsd_trapframe_cache (struct frame_info *next_frame, void **this_cache) +{ + struct sparc_frame_cache *cache; + CORE_ADDR sp, trapframe_addr; + int regnum; + + if (*this_cache) + return *this_cache; + + cache = sparc_frame_cache (next_frame, this_cache); + gdb_assert (cache == *this_cache); + + sp = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM); + trapframe_addr = sp + BIAS + 176; + + cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); + + cache->saved_regs[SPARC64_STATE_REGNUM].addr = trapframe_addr; + cache->saved_regs[SPARC64_PC_REGNUM].addr = trapframe_addr + 8; + cache->saved_regs[SPARC64_NPC_REGNUM].addr = trapframe_addr + 16; + + for (regnum = SPARC_G0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++) + cache->saved_regs[regnum].addr = + trapframe_addr + 48 + (regnum - SPARC_G0_REGNUM) * 8; + + return cache; +} + +static void +sparc64obsd_trapframe_this_id (struct frame_info *next_frame, + void **this_cache, struct frame_id *this_id) +{ + struct sparc_frame_cache *cache = + sparc64obsd_trapframe_cache (next_frame, this_cache); + + (*this_id) = frame_id_build (cache->base, cache->pc); +} + +static void +sparc64obsd_trapframe_prev_register (struct frame_info *next_frame, + void **this_cache, + int regnum, int *optimizedp, + enum lval_type *lvalp, CORE_ADDR *addrp, + int *realnump, gdb_byte *valuep) +{ + struct sparc_frame_cache *cache = + sparc64obsd_trapframe_cache (next_frame, this_cache); + + trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum, + optimizedp, lvalp, addrp, realnump, valuep); +} + +static const struct frame_unwind sparc64obsd_trapframe_unwind = +{ + NORMAL_FRAME, + sparc64obsd_trapframe_this_id, + sparc64obsd_trapframe_prev_register +}; + +static const struct frame_unwind * +sparc64obsd_trapframe_sniffer (struct frame_info *next_frame) +{ + CORE_ADDR pc; + ULONGEST pstate; + char *name; + + /* Check whether we are in privileged mode, and bail out if we're not. */ + pstate = frame_unwind_register_unsigned (next_frame, SPARC64_PSTATE_REGNUM); + if ((pstate & SPARC64_PSTATE_PRIV) == 0) + return NULL; + + pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME); + find_pc_partial_function (pc, &name, NULL, NULL); + if (name && strcmp (name, "Lslowtrap_reenter") == 0) + return &sparc64obsd_trapframe_unwind; + + return NULL; +} + + +/* Threads support. */ + +/* Offset wthin the thread structure where we can find %fp and %i7. */ +#define SPARC64OBSD_UTHREAD_FP_OFFSET 232 +#define SPARC64OBSD_UTHREAD_PC_OFFSET 240 + +static void +sparc64obsd_supply_uthread (struct regcache *regcache, + int regnum, CORE_ADDR addr) +{ + CORE_ADDR fp, fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET; + gdb_byte buf[8]; + + gdb_assert (regnum >= -1); + + fp = read_memory_unsigned_integer (fp_addr, 8); + if (regnum == SPARC_SP_REGNUM || regnum == -1) + { + store_unsigned_integer (buf, 8, fp); + regcache_raw_supply (regcache, SPARC_SP_REGNUM, buf); + + if (regnum == SPARC_SP_REGNUM) + return; + } + + if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM + || regnum == -1) + { + CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET; + + i7 = read_memory_unsigned_integer (i7_addr, 8); + if (regnum == SPARC64_PC_REGNUM || regnum == -1) + { + store_unsigned_integer (buf, 8, i7 + 8); + regcache_raw_supply (regcache, SPARC64_PC_REGNUM, buf); + } + if (regnum == SPARC64_NPC_REGNUM || regnum == -1) + { + store_unsigned_integer (buf, 8, i7 + 12); + regcache_raw_supply (regcache, SPARC64_NPC_REGNUM, buf); + } + + if (regnum == SPARC64_PC_REGNUM || regnum == SPARC64_NPC_REGNUM) + return; + } + + sparc_supply_rwindow (regcache, fp, regnum); +} + +static void +sparc64obsd_collect_uthread(const struct regcache *regcache, + int regnum, CORE_ADDR addr) +{ + CORE_ADDR sp; + gdb_byte buf[8]; + + gdb_assert (regnum >= -1); + + if (regnum == SPARC_SP_REGNUM || regnum == -1) + { + CORE_ADDR fp_addr = addr + SPARC64OBSD_UTHREAD_FP_OFFSET; + + regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf); + write_memory (fp_addr,buf, 8); + } + + if (regnum == SPARC64_PC_REGNUM || regnum == -1) + { + CORE_ADDR i7, i7_addr = addr + SPARC64OBSD_UTHREAD_PC_OFFSET; + + regcache_raw_collect (regcache, SPARC64_PC_REGNUM, buf); + i7 = extract_unsigned_integer (buf, 8) - 8; + write_memory_unsigned_integer (i7_addr, 8, i7); + + if (regnum == SPARC64_PC_REGNUM) + return; + } + + regcache_raw_collect (regcache, SPARC_SP_REGNUM, buf); + sp = extract_unsigned_integer (buf, 8); + sparc_collect_rwindow (regcache, sp, regnum); +} + static void sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) @@ -197,17 +375,25 @@ sparc64obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) tdep->gregset = regset_alloc (gdbarch, sparc64obsd_supply_gregset, NULL); tdep->sizeof_gregset = 832; + /* Make sure we can single-step "new" syscalls. */ + tdep->step_trap = sparcnbsd_step_trap; + frame_unwind_append_sniffer (gdbarch, sparc64obsd_sigtramp_frame_sniffer); + frame_unwind_append_sniffer (gdbarch, sparc64obsd_trapframe_sniffer); sparc64_init_abi (info, gdbarch); - /* OpenBSD/sparc64 has SVR4-style shared libraries... */ - set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); + /* OpenBSD/sparc64 has SVR4-style shared libraries. */ set_solib_svr4_fetch_link_map_offsets (gdbarch, svr4_lp64_fetch_link_map_offsets); -} + set_gdbarch_skip_solib_resolver (gdbarch, obsd_skip_solib_resolver); + /* OpenBSD provides a user-level threads implementation. */ + bsd_uthread_set_supply_uthread (gdbarch, sparc64obsd_supply_uthread); + bsd_uthread_set_collect_uthread (gdbarch, sparc64obsd_collect_uthread); +} + /* Provide a prototype to silence -Wmissing-prototypes. */ void _initialize_sparc64obsd_tdep (void);