1 /* Target-dependent code for GNU/Linux UltraSPARC.
3 Copyright (C) 2003-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "frame-unwind.h"
23 #include "dwarf2-frame.h"
29 #include "solib-svr4.h"
31 #include "trad-frame.h"
32 #include "tramp-frame.h"
33 #include "xml-syscall.h"
34 #include "linux-tdep.h"
36 /* ADI specific si_code */
41 #define SEGV_ADIDERR 4
44 #define SEGV_ADIPERR 5
47 /* The syscall's XML filename for sparc 64-bit. */
48 #define XML_SYSCALL_FILENAME_SPARC64 "syscalls/sparc64-linux.xml"
50 #include "sparc64-tdep.h"
52 /* Signal trampoline support. */
54 static void sparc64_linux_sigframe_init (const struct tramp_frame *self,
55 struct frame_info *this_frame,
56 struct trad_frame_cache *this_cache,
59 /* See sparc-linux-tdep.c for details. Note that 64-bit binaries only
62 static const struct tramp_frame sparc64_linux_rt_sigframe =
67 { 0x82102065, -1 }, /* mov __NR_rt_sigreturn, %g1 */
68 { 0x91d0206d, -1 }, /* ta 0x6d */
69 { TRAMP_SENTINEL_INSN, -1 }
71 sparc64_linux_sigframe_init
75 sparc64_linux_sigframe_init (const struct tramp_frame *self,
76 struct frame_info *this_frame,
77 struct trad_frame_cache *this_cache,
80 CORE_ADDR base, addr, sp_addr;
83 base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
86 /* Offsets from <bits/sigcontext.h>. */
88 /* Since %g0 is always zero, keep the identity encoding. */
90 sp_addr = base + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 8);
91 for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
93 trad_frame_set_reg_addr (this_cache, regnum, addr);
97 trad_frame_set_reg_addr (this_cache, SPARC64_STATE_REGNUM, addr + 0);
98 trad_frame_set_reg_addr (this_cache, SPARC64_PC_REGNUM, addr + 8);
99 trad_frame_set_reg_addr (this_cache, SPARC64_NPC_REGNUM, addr + 16);
100 trad_frame_set_reg_addr (this_cache, SPARC64_Y_REGNUM, addr + 24);
101 trad_frame_set_reg_addr (this_cache, SPARC64_FPRS_REGNUM, addr + 28);
103 base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
107 addr = get_frame_memory_unsigned (this_frame, sp_addr, 8);
111 for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
113 trad_frame_set_reg_addr (this_cache, regnum, addr);
116 trad_frame_set_id (this_cache, frame_id_build (base, func));
119 /* sparc64 GNU/Linux implementation of the handle_segmentation_fault
121 Displays information related to ADI memory corruptions. */
124 sparc64_linux_handle_segmentation_fault (struct gdbarch *gdbarch,
125 struct ui_out *uiout)
127 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 64)
135 /* Evaluate si_code to see if the segfault is ADI related. */
136 si_code = parse_and_eval_long ("$_siginfo.si_code\n");
138 if (si_code >= SEGV_ACCADI && si_code <= SEGV_ADIPERR)
139 addr = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
141 CATCH (exception, RETURN_MASK_ALL)
147 /* Print out ADI event based on sig_code value */
150 case SEGV_ACCADI: /* adi not enabled */
152 uiout->field_string ("sigcode-meaning", _("ADI disabled"));
153 uiout->text (_(" while accessing address "));
154 uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr));
156 case SEGV_ADIDERR: /* disrupting mismatch */
158 uiout->field_string ("sigcode-meaning", _("ADI deferred mismatch"));
159 uiout->text (_(" while accessing address "));
160 uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr));
162 case SEGV_ADIPERR: /* precise mismatch */
164 uiout->field_string ("sigcode-meaning", _("ADI precise mismatch"));
165 uiout->text (_(" while accessing address "));
166 uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr));
175 /* Return the address of a system call's alternative return
179 sparc64_linux_step_trap (struct frame_info *frame, unsigned long insn)
181 /* __NR_rt_sigreturn is 101 */
182 if ((insn == 0x91d0206d)
183 && (get_frame_register_unsigned (frame, SPARC_G1_REGNUM) == 101))
185 struct gdbarch *gdbarch = get_frame_arch (frame);
186 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
188 ULONGEST sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
192 /* The kernel puts the sigreturn registers on the stack,
193 and this is where the signal unwinding state is take from
194 when returning from a signal.
196 A siginfo_t sits 192 bytes from the base of the stack. This
197 siginfo_t is 128 bytes, and is followed by the sigreturn
198 register save area. The saved PC sits at a 136 byte offset
201 return read_memory_unsigned_integer (sp + 192 + 128 + 136,
209 const struct sparc_gregmap sparc64_linux_core_gregmap =
211 32 * 8, /* %tstate */
224 sparc64_linux_supply_core_gregset (const struct regset *regset,
225 struct regcache *regcache,
226 int regnum, const void *gregs, size_t len)
228 sparc64_supply_gregset (&sparc64_linux_core_gregmap,
229 regcache, regnum, gregs);
233 sparc64_linux_collect_core_gregset (const struct regset *regset,
234 const struct regcache *regcache,
235 int regnum, void *gregs, size_t len)
237 sparc64_collect_gregset (&sparc64_linux_core_gregmap,
238 regcache, regnum, gregs);
242 sparc64_linux_supply_core_fpregset (const struct regset *regset,
243 struct regcache *regcache,
244 int regnum, const void *fpregs, size_t len)
246 sparc64_supply_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
250 sparc64_linux_collect_core_fpregset (const struct regset *regset,
251 const struct regcache *regcache,
252 int regnum, void *fpregs, size_t len)
254 sparc64_collect_fpregset (&sparc64_bsd_fpregmap, regcache, regnum, fpregs);
257 /* Set the program counter for process PTID to PC. */
259 #define TSTATE_SYSCALL 0x0000000000000020ULL
262 sparc64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
264 struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
267 regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
268 regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
270 /* Clear the "in syscall" bit to prevent the kernel from
271 messing with the PCs we just installed, if we happen to be
272 within an interrupted system call that the kernel wants to
275 Note that after we return from the dummy call, the TSTATE et al.
276 registers will be automatically restored, and the kernel
277 continues to restart the system call at this point. */
278 regcache_cooked_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state);
279 state &= ~TSTATE_SYSCALL;
280 regcache_cooked_write_unsigned (regcache, SPARC64_STATE_REGNUM, state);
284 sparc64_linux_get_syscall_number (struct gdbarch *gdbarch,
287 struct regcache *regcache = get_thread_regcache (thread);
288 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
289 /* The content of a register. */
294 /* Getting the system call number from the register.
295 When dealing with the sparc architecture, this information
296 is stored at the %g1 register. */
297 regcache->cooked_read (SPARC_G1_REGNUM, buf);
299 ret = extract_signed_integer (buf, 8, byte_order);
305 /* Implement the "get_longjmp_target" gdbarch method. */
308 sparc64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
310 struct gdbarch *gdbarch = get_frame_arch (frame);
314 jb_addr = get_frame_register_unsigned (frame, SPARC_O0_REGNUM);
316 /* setjmp and longjmp in SPARC64 are implemented in glibc using the
317 setcontext and getcontext system calls respectively. These
318 system calls operate on ucontext_t structures, which happen to
319 partially have the same structure than jmp_buf. However the
320 ucontext returned by getcontext, and thus the jmp_buf structure
321 returned by setjmp, contains the context of the trap instruction
322 in the glibc __[sig]setjmp wrapper, not the context of the user
325 %o7 in the jmp_buf structure is stored at offset 18*8 in the
326 mc_gregs array, which is itself located at offset 32 into
327 jmp_buf. See bits/setjmp.h. This register contains the address
328 of the 'call setjmp' instruction in user code.
330 In order to determine the longjmp target address in the
331 initiating frame we need to examine the call instruction itself,
332 in particular whether the annul bit is set. If it is not set
333 then we need to jump over the instruction at the delay slot. */
335 if (target_read_memory (jb_addr + 32 + (18 * 8), buf, 8))
338 *pc = extract_unsigned_integer (buf, 8, gdbarch_byte_order (gdbarch));
340 if (!sparc_is_annulled_branch_insn (*pc))
341 *pc += 4; /* delay slot insn */
342 *pc += 4; /* call insn */
349 static const struct regset sparc64_linux_gregset =
352 sparc64_linux_supply_core_gregset,
353 sparc64_linux_collect_core_gregset
356 static const struct regset sparc64_linux_fpregset =
359 sparc64_linux_supply_core_fpregset,
360 sparc64_linux_collect_core_fpregset
364 sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
366 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
368 linux_init_abi (info, gdbarch);
370 tdep->gregset = &sparc64_linux_gregset;
371 tdep->sizeof_gregset = 288;
373 tdep->fpregset = &sparc64_linux_fpregset;
374 tdep->sizeof_fpregset = 280;
376 tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe);
378 /* Hook in the DWARF CFI frame unwinder. */
379 dwarf2_append_unwinders (gdbarch);
381 sparc64_init_abi (info, gdbarch);
383 /* GNU/Linux has SVR4-style shared libraries... */
384 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
385 set_solib_svr4_fetch_link_map_offsets
386 (gdbarch, svr4_lp64_fetch_link_map_offsets);
388 /* ...which means that we need some special handling when doing
389 prologue analysis. */
390 tdep->plt_entry_size = 16;
392 /* Enable TLS support. */
393 set_gdbarch_fetch_tls_load_module_address (gdbarch,
394 svr4_fetch_objfile_link_map);
396 /* Make sure we can single-step over signal return system calls. */
397 tdep->step_trap = sparc64_linux_step_trap;
399 /* Make sure we can single-step over longjmp calls. */
400 set_gdbarch_get_longjmp_target (gdbarch, sparc64_linux_get_longjmp_target);
402 set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc);
404 /* Functions for 'catch syscall'. */
405 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64);
406 set_gdbarch_get_syscall_number (gdbarch,
407 sparc64_linux_get_syscall_number);
408 set_gdbarch_handle_segmentation_fault (gdbarch,
409 sparc64_linux_handle_segmentation_fault);
413 _initialize_sparc64_linux_tdep (void)
415 gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9,
416 GDB_OSABI_LINUX, sparc64_linux_init_abi);