X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsparc64-linux-tdep.c;h=6fb9f96179118e46127fbc9404c10c089ba870ce;hb=d3e5f6c8f1e58e86689909019a3756d4308b66eb;hp=906fd122a5107c8dfeef83ddd40dd00f048d2e64;hpb=5366653e67978dff4051cd8b5326cafd088776f5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/sparc64-linux-tdep.c b/gdb/sparc64-linux-tdep.c index 906fd122a5..6fb9f96179 100644 --- a/gdb/sparc64-linux-tdep.c +++ b/gdb/sparc64-linux-tdep.c @@ -1,6 +1,6 @@ /* Target-dependent code for GNU/Linux UltraSPARC. - Copyright (C) 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc. + Copyright (C) 2003-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -30,6 +30,11 @@ #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" @@ -106,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; @@ -121,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 */ @@ -147,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 @@ -155,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 @@ -163,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 @@ -171,28 +184,132 @@ 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); + 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); @@ -211,6 +328,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); }