/* Target-dependent code for GNU/Linux UltraSPARC.
- Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2003-2005, 2007-2012 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,
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 <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
#include "frame-unwind.h"
+#include "dwarf2-frame.h"
#include "regset.h"
#include "regcache.h"
#include "gdbarch.h"
#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);
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 <bits/sigcontext.h>. */
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;
address. */
static CORE_ADDR
-sparc64_linux_step_trap (unsigned long insn)
+sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn)
{
if (insn == 0x91d0206d)
{
- ULONGEST sp;
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- regcache_cooked_read_unsigned (current_regcache,
- SPARC_SP_REGNUM, &sp);
+ ULONGEST sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
if (sp & 1)
sp += BIAS;
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;
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_gregset,
+ regcache, regnum, gregs);
}
static void
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_gregset,
+ regcache, regnum, gregs);
}
static void
sparc64_collect_fpregset (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;
+}
+
\f
static void
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ linux_init_abi (info, gdbarch);
+
tdep->gregset = regset_alloc (gdbarch, sparc64_linux_supply_core_gregset,
sparc64_linux_collect_core_gregset);
tdep->sizeof_gregset = 288;
tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe);
+ /* Hook in the DWARF CFI frame unwinder. */
+ dwarf2_append_unwinders (gdbarch);
+
sparc64_init_abi (info, gdbarch);
/* GNU/Linux has SVR4-style shared libraries... */
/* Make sure we can single-step over signal return system calls. */
tdep->step_trap = sparc64_linux_step_trap;
+
+ set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc);
+
+ /* Functions for 'catch syscall'. */
+ set_xml_syscall_file_name (XML_SYSCALL_FILENAME_SPARC64);
+ set_gdbarch_get_syscall_number (gdbarch,
+ sparc64_linux_get_syscall_number);
}
\f