/* Target-dependent code for NetBSD/alpha. Copyright (C) 2002-2021 Free Software Foundation, Inc. Contributed by Wasabi Systems, 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 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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, see <http://www.gnu.org/licenses/>. */ #include "defs.h" #include "frame.h" #include "gdbcore.h" #include "osabi.h" #include "regcache.h" #include "regset.h" #include "value.h" #include "alpha-tdep.h" #include "alpha-bsd-tdep.h" #include "netbsd-tdep.h" #include "solib-svr4.h" #include "target.h" /* Core file support. */ /* Sizeof `struct reg' in <machine/reg.h>. */ #define ALPHANBSD_SIZEOF_GREGS (32 * 8) /* Sizeof `struct fpreg' in <machine/reg.h. */ #define ALPHANBSD_SIZEOF_FPREGS ((32 * 8) + 8) /* Supply register REGNUM from the buffer specified by FPREGS and LEN in the floating-point register set REGSET to register cache REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ static void alphanbsd_supply_fpregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len) { const gdb_byte *regs = (const gdb_byte *) fpregs; int i; gdb_assert (len >= ALPHANBSD_SIZEOF_FPREGS); for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++) { if (regnum == i || regnum == -1) regcache->raw_supply (i, regs + (i - ALPHA_FP0_REGNUM) * 8); } if (regnum == ALPHA_FPCR_REGNUM || regnum == -1) regcache->raw_supply (ALPHA_FPCR_REGNUM, regs + 32 * 8); } /* Supply register REGNUM from the buffer specified by GREGS and LEN in the general-purpose register set REGSET to register cache REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ static void alphanbsd_aout_supply_gregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len) { const gdb_byte *regs = (const gdb_byte *) gregs; int i; /* Table to map a GDB register number to a trapframe register index. */ static const int regmap[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 30, 31, 32, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 29, 26 }; gdb_assert (len >= ALPHANBSD_SIZEOF_GREGS); for (i = 0; i < ARRAY_SIZE(regmap); i++) { if (regnum == i || regnum == -1) regcache->raw_supply (i, regs + regmap[i] * 8); } if (regnum == ALPHA_PC_REGNUM || regnum == -1) regcache->raw_supply (ALPHA_PC_REGNUM, regs + 31 * 8); if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS) { regs += ALPHANBSD_SIZEOF_GREGS; len -= ALPHANBSD_SIZEOF_GREGS; alphanbsd_supply_fpregset (regset, regcache, regnum, regs, len); } } /* Supply register REGNUM from the buffer specified by GREGS and LEN in the general-purpose register set REGSET to register cache REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ static void alphanbsd_supply_gregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len) { const gdb_byte *regs = (const gdb_byte *) gregs; int i; if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS) { alphanbsd_aout_supply_gregset (regset, regcache, regnum, gregs, len); return; } for (i = 0; i < ALPHA_ZERO_REGNUM; i++) { if (regnum == i || regnum == -1) regcache->raw_supply (i, regs + i * 8); } if (regnum == ALPHA_PC_REGNUM || regnum == -1) regcache->raw_supply (ALPHA_PC_REGNUM, regs + 31 * 8); } /* NetBSD/alpha register sets. */ static const struct regset alphanbsd_gregset = { NULL, alphanbsd_supply_gregset, NULL, REGSET_VARIABLE_SIZE }; static const struct regset alphanbsd_fpregset = { NULL, alphanbsd_supply_fpregset }; /* Iterate over supported core file register note sections. */ void alphanbsd_iterate_over_regset_sections (struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache) { cb (".reg", ALPHANBSD_SIZEOF_GREGS, ALPHANBSD_SIZEOF_GREGS, &alphanbsd_gregset, NULL, cb_data); cb (".reg2", ALPHANBSD_SIZEOF_FPREGS, ALPHANBSD_SIZEOF_FPREGS, &alphanbsd_fpregset, NULL, cb_data); } /* Signal trampolines. */ /* Under NetBSD/alpha, signal handler invocations can be identified by the designated code sequence that is used to return from a signal handler. In particular, the return address of a signal handler points to the following code sequence: ldq a0, 0(sp) lda sp, 16(sp) lda v0, 295(zero) # __sigreturn14 call_pal callsys Each instruction has a unique encoding, so we simply attempt to match the instruction the PC is pointing to with any of the above instructions. If there is a hit, we know the offset to the start of the designated sequence and can then check whether we really are executing in the signal trampoline. If not, -1 is returned, otherwise the offset from the start of the return sequence is returned. */ static const gdb_byte sigtramp_retcode[] = { 0x00, 0x00, 0x1e, 0xa6, /* ldq a0, 0(sp) */ 0x10, 0x00, 0xde, 0x23, /* lda sp, 16(sp) */ 0x27, 0x01, 0x1f, 0x20, /* lda v0, 295(zero) */ 0x83, 0x00, 0x00, 0x00, /* call_pal callsys */ }; #define RETCODE_NWORDS 4 #define RETCODE_SIZE (RETCODE_NWORDS * 4) static LONGEST alphanbsd_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc) { gdb_byte ret[RETCODE_SIZE], w[4]; LONGEST off; int i; if (target_read_memory (pc, w, 4) != 0) return -1; for (i = 0; i < RETCODE_NWORDS; i++) { if (memcmp (w, sigtramp_retcode + (i * 4), 4) == 0) break; } if (i == RETCODE_NWORDS) return (-1); off = i * 4; pc -= off; if (target_read_memory (pc, ret, sizeof (ret)) != 0) return -1; if (memcmp (ret, sigtramp_retcode, RETCODE_SIZE) == 0) return off; return -1; } static int alphanbsd_pc_in_sigtramp (struct gdbarch *gdbarch, CORE_ADDR pc, const char *func_name) { return (nbsd_pc_in_sigtramp (pc, func_name) || alphanbsd_sigtramp_offset (gdbarch, pc) >= 0); } static CORE_ADDR alphanbsd_sigcontext_addr (struct frame_info *frame) { /* FIXME: This is not correct for all versions of NetBSD/alpha. We will probably need to disassemble the trampoline to figure out which trampoline frame type we have. */ if (!get_next_frame (frame)) return 0; return get_frame_base (get_next_frame (frame)); } static void alphanbsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); /* Hook into the DWARF CFI frame unwinder. */ alpha_dwarf2_init_abi (info, gdbarch); /* Hook into the MDEBUG frame unwinder. */ alpha_mdebug_init_abi (info, gdbarch); nbsd_init_abi (info, gdbarch); /* NetBSD/alpha does not provide single step support via ptrace(2); we must use software single-stepping. */ set_gdbarch_software_single_step (gdbarch, alpha_software_single_step); /* NetBSD/alpha has SVR4-style shared libraries. */ set_solib_svr4_fetch_link_map_offsets (gdbarch, svr4_lp64_fetch_link_map_offsets); tdep->dynamic_sigtramp_offset = alphanbsd_sigtramp_offset; tdep->pc_in_sigtramp = alphanbsd_pc_in_sigtramp; tdep->sigcontext_addr = alphanbsd_sigcontext_addr; tdep->jb_pc = 2; tdep->jb_elt_size = 8; set_gdbarch_iterate_over_regset_sections (gdbarch, alphanbsd_iterate_over_regset_sections); } void _initialize_alphanbsd_tdep (); void _initialize_alphanbsd_tdep () { /* Even though NetBSD/alpha used ELF since day one, it used the traditional a.out-style core dump format before NetBSD 1.6, but we don't support those. */ gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_NETBSD, alphanbsd_init_abi); }