GDB (xrefs)
/tmp/gdb-7.10/gdb/sparc64-linux-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for GNU/Linux UltraSPARC.
2 
3  Copyright (C) 2003-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 #include "defs.h"
21 #include "frame.h"
22 #include "frame-unwind.h"
23 #include "dwarf2-frame.h"
24 #include "regset.h"
25 #include "regcache.h"
26 #include "gdbarch.h"
27 #include "gdbcore.h"
28 #include "osabi.h"
29 #include "solib-svr4.h"
30 #include "symtab.h"
31 #include "trad-frame.h"
32 #include "tramp-frame.h"
33 #include "xml-syscall.h"
34 #include "linux-tdep.h"
35 
36 /* The syscall's XML filename for sparc 64-bit. */
37 #define XML_SYSCALL_FILENAME_SPARC64 "syscalls/sparc64-linux.xml"
38 
39 #include "sparc64-tdep.h"
40 
41 /* Signal trampoline support. */
42 
43 static void sparc64_linux_sigframe_init (const struct tramp_frame *self,
44  struct frame_info *this_frame,
45  struct trad_frame_cache *this_cache,
46  CORE_ADDR func);
47 
48 /* See sparc-linux-tdep.c for details. Note that 64-bit binaries only
49  use RT signals. */
50 
51 static const struct tramp_frame sparc64_linux_rt_sigframe =
52 {
54  4,
55  {
56  { 0x82102065, -1 }, /* mov __NR_rt_sigreturn, %g1 */
57  { 0x91d0206d, -1 }, /* ta 0x6d */
58  { TRAMP_SENTINEL_INSN, -1 }
59  },
61 };
62 
63 static void
65  struct frame_info *this_frame,
66  struct trad_frame_cache *this_cache,
68 {
69  CORE_ADDR base, addr, sp_addr;
70  int regnum;
71 
72  base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
73  base += 128;
74 
75  /* Offsets from <bits/sigcontext.h>. */
76 
77  /* Since %g0 is always zero, keep the identity encoding. */
78  addr = base + 8;
79  sp_addr = base + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 8);
80  for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
81  {
82  trad_frame_set_reg_addr (this_cache, regnum, addr);
83  addr += 8;
84  }
85 
86  trad_frame_set_reg_addr (this_cache, SPARC64_STATE_REGNUM, addr + 0);
87  trad_frame_set_reg_addr (this_cache, SPARC64_PC_REGNUM, addr + 8);
88  trad_frame_set_reg_addr (this_cache, SPARC64_NPC_REGNUM, addr + 16);
89  trad_frame_set_reg_addr (this_cache, SPARC64_Y_REGNUM, addr + 24);
90  trad_frame_set_reg_addr (this_cache, SPARC64_FPRS_REGNUM, addr + 28);
91 
92  base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
93  if (base & 1)
94  base += BIAS;
95 
96  addr = get_frame_memory_unsigned (this_frame, sp_addr, 8);
97  if (addr & 1)
98  addr += BIAS;
99 
100  for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
101  {
102  trad_frame_set_reg_addr (this_cache, regnum, addr);
103  addr += 8;
104  }
105  trad_frame_set_id (this_cache, frame_id_build (base, func));
106 }
107 
108 /* Return the address of a system call's alternative return
109  address. */
110 
111 static CORE_ADDR
112 sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn)
113 {
114  /* __NR_rt_sigreturn is 101 */
115  if ((insn == 0x91d0206d)
116  && (get_frame_register_unsigned (frame, SPARC_G1_REGNUM) == 101))
117  {
118  struct gdbarch *gdbarch = get_frame_arch (frame);
119  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
120 
122  if (sp & 1)
123  sp += BIAS;
124 
125  /* The kernel puts the sigreturn registers on the stack,
126  and this is where the signal unwinding state is take from
127  when returning from a signal.
128 
129  A siginfo_t sits 192 bytes from the base of the stack. This
130  siginfo_t is 128 bytes, and is followed by the sigreturn
131  register save area. The saved PC sits at a 136 byte offset
132  into there. */
133 
134  return read_memory_unsigned_integer (sp + 192 + 128 + 136,
135  8, byte_order);
136  }
137 
138  return 0;
139 }
140 
141 
142 const struct sparc_gregmap sparc64_linux_core_gregmap =
143 {
144  32 * 8, /* %tstate */
145  33 * 8, /* %tpc */
146  34 * 8, /* %tnpc */
147  35 * 8, /* %y */
148  -1, /* %wim */
149  -1, /* %tbr */
150  1 * 8, /* %g1 */
151  16 * 8, /* %l0 */
152  8, /* y size */
153 };
154 
155 
156 static void
158  struct regcache *regcache,
159  int regnum, const void *gregs, size_t len)
160 {
161  sparc64_supply_gregset (&sparc64_linux_core_gregmap,
162  regcache, regnum, gregs);
163 }
164 
165 static void
167  const struct regcache *regcache,
168  int regnum, void *gregs, size_t len)
169 {
170  sparc64_collect_gregset (&sparc64_linux_core_gregmap,
171  regcache, regnum, gregs);
172 }
173 
174 static void
176  struct regcache *regcache,
177  int regnum, const void *fpregs, size_t len)
178 {
179  sparc64_supply_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
180 }
181 
182 static void
184  const struct regcache *regcache,
185  int regnum, void *fpregs, size_t len)
186 {
187  sparc64_collect_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
188 }
189 
190 /* Set the program counter for process PTID to PC. */
191 
192 #define TSTATE_SYSCALL 0x0000000000000020ULL
193 
194 static void
196 {
197  struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
198  ULONGEST state;
199 
200  regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
201  regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
202 
203  /* Clear the "in syscall" bit to prevent the kernel from
204  messing with the PCs we just installed, if we happen to be
205  within an interrupted system call that the kernel wants to
206  restart.
207 
208  Note that after we return from the dummy call, the TSTATE et al.
209  registers will be automatically restored, and the kernel
210  continues to restart the system call at this point. */
212  state &= ~TSTATE_SYSCALL;
214 }
215 
216 static LONGEST
218  ptid_t ptid)
219 {
220  struct regcache *regcache = get_thread_regcache (ptid);
221  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
222  /* The content of a register. */
223  gdb_byte buf[8];
224  /* The result. */
225  LONGEST ret;
226 
227  /* Getting the system call number from the register.
228  When dealing with the sparc architecture, this information
229  is stored at the %g1 register. */
230  regcache_cooked_read (regcache, SPARC_G1_REGNUM, buf);
231 
232  ret = extract_signed_integer (buf, 8, byte_order);
233 
234  return ret;
235 }
236 
237 
238 /* Implement the "get_longjmp_target" gdbarch method. */
239 
240 static int
242 {
243  struct gdbarch *gdbarch = get_frame_arch (frame);
244  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
245  CORE_ADDR jb_addr;
246  gdb_byte buf[8];
247 
248  jb_addr = get_frame_register_unsigned (frame, SPARC_O0_REGNUM);
249 
250  /* setjmp and longjmp in SPARC64 are implemented in glibc using the
251  setcontext and getcontext system calls respectively. These
252  system calls operate on ucontext_t structures, which happen to
253  partially have the same structure than jmp_buf. However the
254  ucontext returned by getcontext, and thus the jmp_buf structure
255  returned by setjmp, contains the context of the trap instruction
256  in the glibc __[sig]setjmp wrapper, not the context of the user
257  code calling setjmp.
258 
259  %o7 in the jmp_buf structure is stored at offset 18*8 in the
260  mc_gregs array, which is itself located at offset 32 into
261  jmp_buf. See bits/setjmp.h. This register contains the address
262  of the 'call setjmp' instruction in user code.
263 
264  In order to determine the longjmp target address in the
265  initiating frame we need to examine the call instruction itself,
266  in particular whether the annul bit is set. If it is not set
267  then we need to jump over the instruction at the delay slot. */
268 
269  if (target_read_memory (jb_addr + 32 + (18 * 8), buf, 8))
270  return 0;
271 
272  *pc = extract_unsigned_integer (buf, 8, gdbarch_byte_order (gdbarch));
273 
275  *pc += 4; /* delay slot insn */
276  *pc += 4; /* call insn */
277 
278  return 1;
279 }
280 
281 
282 
283 static const struct regset sparc64_linux_gregset =
284  {
285  NULL,
288  };
289 
290 static const struct regset sparc64_linux_fpregset =
291  {
292  NULL,
295  };
296 
297 static void
299 {
300  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
301 
302  linux_init_abi (info, gdbarch);
303 
305  tdep->sizeof_gregset = 288;
306 
308  tdep->sizeof_fpregset = 280;
309 
310  tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe);
311 
312  /* Hook in the DWARF CFI frame unwinder. */
313  dwarf2_append_unwinders (gdbarch);
314 
315  sparc64_init_abi (info, gdbarch);
316 
317  /* GNU/Linux has SVR4-style shared libraries... */
321 
322  /* ...which means that we need some special handling when doing
323  prologue analysis. */
324  tdep->plt_entry_size = 16;
325 
326  /* Enable TLS support. */
329 
330  /* Make sure we can single-step over signal return system calls. */
332 
333  /* Make sure we can single-step over longjmp calls. */
335 
337 
338  /* Functions for 'catch syscall'. */
342 }
343 
344 
345 /* Provide a prototype to silence -Wmissing-prototypes. */
346 extern void _initialize_sparc64_linux_tdep (void);
347 
348 void
350 {
351  gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
353 }
void sparc64_collect_fpregset(const struct sparc_fpregmap *fpregmap, const struct regcache *regcache, int regnum, void *fpregs)
void sparc64_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
void trad_frame_set_reg_addr(struct trad_frame_cache *this_trad_cache, int regnum, CORE_ADDR addr)
Definition: trad-frame.c:119
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
void set_gdbarch_get_longjmp_target(struct gdbarch *gdbarch, gdbarch_get_longjmp_target_ftype get_longjmp_target)
Definition: gdbarch.c:2390
bfd_vma CORE_ADDR
Definition: common-types.h:41
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
Definition: gdbarch.c:2822
#define TRAMP_SENTINEL_INSN
Definition: tramp-frame.h:44
struct link_map_offsets * svr4_lp64_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3180
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
void(* func)(char *)
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3084
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype write_pc)
Definition: gdbarch.c:1802
const struct regset * gregset
Definition: sparc-tdep.h:61
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition: trad-frame.c:164
static void sparc64_linux_collect_core_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs, size_t len)
#define BIAS
Definition: sparc-tdep.c:70
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: linux-tdep.c:2427
#define XML_SYSCALL_FILENAME_SPARC64
CORE_ADDR(* step_trap)(struct frame_info *frame, unsigned long insn)
Definition: sparc-tdep.h:74
size_t sizeof_fpregset
Definition: i386-tdep.h:64
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2515
int npc_regnum
Definition: sparc-tdep.h:58
void sparc64_collect_gregset(const struct sparc_gregmap *gregmap, const struct regcache *regcache, int regnum, void *gregs)
void sparc64_supply_gregset(const struct sparc_gregmap *gregmap, struct regcache *regcache, int regnum, const void *gregs)
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
Definition: ptid.h:35
static int sparc64_linux_get_longjmp_target(struct frame_info *frame, CORE_ADDR *pc)
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-svr4.c:1573
static void sparc64_linux_sigframe_init(const struct tramp_frame *self, struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
Definition: regset.h:34
const struct sparc_fpregmap sparc64_bsd_fpregmap
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
Definition: minsyms.c:1394
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
void sparc64_supply_fpregset(const struct sparc_fpregmap *fpregmap, struct regcache *regcache, int regnum, const void *fpregs)
static const struct regset sparc64_linux_fpregset
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3108
static void sparc64_linux_collect_core_fpregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *fpregs, size_t len)
int regnum
Definition: aarch64-tdep.c:69
void set_xml_syscall_file_name(struct gdbarch *gdbarch, const char *name)
Definition: xml-syscall.c:392
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
int sparc_is_annulled_branch_insn(CORE_ADDR pc)
Definition: sparc-tdep.c:128
struct tramp_frame::@170 insn[48]
bfd_byte gdb_byte
Definition: common-types.h:38
static void sparc64_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
void set_gdbarch_get_syscall_number(struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype get_syscall_number)
Definition: gdbarch.c:4025
void tramp_frame_prepend_unwinder(struct gdbarch *gdbarch, const struct tramp_frame *tramp_frame)
Definition: tramp-frame.c:145
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
size_t sizeof_gregset
Definition: i386-tdep.h:61
void _initialize_sparc64_linux_tdep(void)
static LONGEST sparc64_linux_get_syscall_number(struct gdbarch *gdbarch, ptid_t ptid)
const struct regset * fpregset
Definition: i386-tdep.h:242
unsigned long long ULONGEST
Definition: common-types.h:53
static const struct regset sparc64_linux_gregset
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
static void sparc64_linux_supply_core_fpregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *fpregs, size_t len)
LONGEST extract_signed_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:49
size_t plt_entry_size
Definition: sparc-tdep.h:71
#define TSTATE_SYSCALL
enum bfd_endian byte_order
Definition: gdbarch.c:128
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition: osabi.c:148
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
long long LONGEST
Definition: common-types.h:52
static void sparc64_linux_supply_core_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs, size_t len)
static CORE_ADDR sparc64_linux_step_trap(struct frame_info *frame, unsigned long insn)
static void sparc64_linux_write_pc(struct regcache *regcache, CORE_ADDR pc)
const ULONGEST const LONGEST len
Definition: target.h:309