X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsparc64-linux-tdep.c;h=5a9fa9db3624be295e3476999fba20b7680a29bb;hb=b08b78e7d4bb56f395d3212eed6184ede236c760;hp=cbeeb218b9e44925c1e569f9b3ad0a20e15b0a1e;hpb=0b1b3e423ad28731135cdd275522bdf3d2d17570;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sparc64-linux-tdep.c b/gdb/sparc64-linux-tdep.c index cbeeb218b9..5a9fa9db36 100644 --- a/gdb/sparc64-linux-tdep.c +++ b/gdb/sparc64-linux-tdep.c @@ -1,12 +1,12 @@ /* Target-dependent code for GNU/Linux UltraSPARC. - Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc. + Copyright (C) 2003-2015 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,9 +15,7 @@ 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "frame.h" @@ -32,13 +30,18 @@ #include "symtab.h" #include "trad-frame.h" #include "tramp-frame.h" +#include "xml-syscall.h" +#include "linux-tdep.h" + +/* The syscall's XML filename for sparc 64-bit. */ +#define XML_SYSCALL_FILENAME_SPARC64 "syscalls/sparc64-linux.xml" #include "sparc64-tdep.h" /* Signal trampoline support. */ static void sparc64_linux_sigframe_init (const struct tramp_frame *self, - struct frame_info *next_frame, + struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func); @@ -59,14 +62,14 @@ static const struct tramp_frame sparc64_linux_rt_sigframe = static void sparc64_linux_sigframe_init (const struct tramp_frame *self, - struct frame_info *next_frame, + struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func) { CORE_ADDR base, addr, sp_addr; int regnum; - base = frame_unwind_register_unsigned (next_frame, SPARC_O1_REGNUM); + base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM); base += 128; /* Offsets from . */ @@ -86,11 +89,11 @@ sparc64_linux_sigframe_init (const struct tramp_frame *self, trad_frame_set_reg_addr (this_cache, SPARC64_Y_REGNUM, addr + 24); trad_frame_set_reg_addr (this_cache, SPARC64_FPRS_REGNUM, addr + 28); - base = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM); + base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM); if (base & 1) base += BIAS; - addr = get_frame_memory_unsigned (next_frame, sp_addr, 8); + addr = get_frame_memory_unsigned (this_frame, sp_addr, 8); if (addr & 1) addr += BIAS; @@ -108,8 +111,13 @@ sparc64_linux_sigframe_init (const struct tramp_frame *self, static CORE_ADDR sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn) { - if (insn == 0x91d0206d) + /* __NR_rt_sigreturn is 101 */ + if ((insn == 0x91d0206d) + && (get_frame_register_unsigned (frame, SPARC_G1_REGNUM) == 101)) { + struct gdbarch *gdbarch = get_frame_arch (frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + ULONGEST sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM); if (sp & 1) sp += BIAS; @@ -123,14 +131,15 @@ sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn) register save area. The saved PC sits at a 136 byte offset into there. */ - return read_memory_unsigned_integer (sp + 192 + 128 + 136, 8); + return read_memory_unsigned_integer (sp + 192 + 128 + 136, + 8, byte_order); } return 0; } -const struct sparc_gregset sparc64_linux_core_gregset = +const struct sparc_gregmap sparc64_linux_core_gregmap = { 32 * 8, /* %tstate */ 33 * 8, /* %tpc */ @@ -149,7 +158,8 @@ sparc64_linux_supply_core_gregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len) { - sparc64_supply_gregset (&sparc64_linux_core_gregset, regcache, regnum, gregs); + sparc64_supply_gregset (&sparc64_linux_core_gregmap, + regcache, regnum, gregs); } static void @@ -157,7 +167,8 @@ sparc64_linux_collect_core_gregset (const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len) { - sparc64_collect_gregset (&sparc64_linux_core_gregset, regcache, regnum, gregs); + sparc64_collect_gregset (&sparc64_linux_core_gregmap, + regcache, regnum, gregs); } static void @@ -165,7 +176,7 @@ sparc64_linux_supply_core_fpregset (const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len) { - sparc64_supply_fpregset (regcache, regnum, fpregs); + sparc64_supply_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs); } static void @@ -173,28 +184,133 @@ sparc64_linux_collect_core_fpregset (const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len) { - sparc64_collect_fpregset (regcache, regnum, fpregs); + sparc64_collect_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs); +} + +/* Set the program counter for process PTID to PC. */ + +#define TSTATE_SYSCALL 0x0000000000000020ULL + +static void +sparc64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); + ULONGEST state; + + regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc); + regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4); + + /* Clear the "in syscall" bit to prevent the kernel from + messing with the PCs we just installed, if we happen to be + within an interrupted system call that the kernel wants to + restart. + + Note that after we return from the dummy call, the TSTATE et al. + registers will be automatically restored, and the kernel + continues to restart the system call at this point. */ + regcache_cooked_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state); + state &= ~TSTATE_SYSCALL; + regcache_cooked_write_unsigned (regcache, SPARC64_STATE_REGNUM, state); +} + +static LONGEST +sparc64_linux_get_syscall_number (struct gdbarch *gdbarch, + ptid_t ptid) +{ + struct regcache *regcache = get_thread_regcache (ptid); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + /* The content of a register. */ + gdb_byte buf[8]; + /* The result. */ + LONGEST ret; + + /* Getting the system call number from the register. + When dealing with the sparc architecture, this information + is stored at the %g1 register. */ + regcache_cooked_read (regcache, SPARC_G1_REGNUM, buf); + + ret = extract_signed_integer (buf, 8, byte_order); + + return ret; +} + + +/* Implement the "get_longjmp_target" gdbarch method. */ + +static int +sparc64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + CORE_ADDR jb_addr; + gdb_byte buf[8]; + + jb_addr = get_frame_register_unsigned (frame, SPARC_O0_REGNUM); + + /* setjmp and longjmp in SPARC64 are implemented in glibc using the + setcontext and getcontext system calls respectively. These + system calls operate on ucontext_t structures, which happen to + partially have the same structure than jmp_buf. However the + ucontext returned by getcontext, and thus the jmp_buf structure + returned by setjmp, contains the context of the trap instruction + in the glibc __[sig]setjmp wrapper, not the context of the user + code calling setjmp. + + %o7 in the jmp_buf structure is stored at offset 18*8 in the + mc_gregs array, which is itself located at offset 32 into + jmp_buf. See bits/setjmp.h. This register contains the address + of the 'call setjmp' instruction in user code. + + In order to determine the longjmp target address in the + initiating frame we need to examine the call instruction itself, + in particular whether the annul bit is set. If it is not set + then we need to jump over the instruction at the delay slot. */ + + if (target_read_memory (jb_addr + 32 + (18 * 8), buf, 8)) + return 0; + + *pc = extract_unsigned_integer (buf, 8, gdbarch_byte_order (gdbarch)); + + if (!sparc_is_annulled_branch_insn (*pc)) + *pc += 4; /* delay slot insn */ + *pc += 4; /* call insn */ + + return 1; } +static const struct regset sparc64_linux_gregset = + { + NULL, + sparc64_linux_supply_core_gregset, + sparc64_linux_collect_core_gregset + }; + +static const struct regset sparc64_linux_fpregset = + { + NULL, + sparc64_linux_supply_core_fpregset, + sparc64_linux_collect_core_fpregset + }; + static void sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - tdep->gregset = regset_alloc (gdbarch, sparc64_linux_supply_core_gregset, - sparc64_linux_collect_core_gregset); + linux_init_abi (info, gdbarch); + + tdep->gregset = &sparc64_linux_gregset; tdep->sizeof_gregset = 288; - tdep->fpregset = regset_alloc (gdbarch, sparc64_linux_supply_core_fpregset, - sparc64_linux_collect_core_fpregset); + tdep->fpregset = &sparc64_linux_fpregset; tdep->sizeof_fpregset = 280; tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe); /* Hook in the DWARF CFI frame unwinder. */ - frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); + dwarf2_append_unwinders (gdbarch); sparc64_init_abi (info, gdbarch); @@ -213,6 +329,16 @@ sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) /* Make sure we can single-step over signal return system calls. */ tdep->step_trap = sparc64_linux_step_trap; + + /* Make sure we can single-step over longjmp calls. */ + set_gdbarch_get_longjmp_target (gdbarch, sparc64_linux_get_longjmp_target); + + set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc); + + /* Functions for 'catch syscall'. */ + set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64); + set_gdbarch_get_syscall_number (gdbarch, + sparc64_linux_get_syscall_number); }