1 /* Target-dependent code for GNU/Linux UltraSPARC. 2 3 Copyright (C) 2003-2016 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 { 53 SIGTRAMP_FRAME, 54 4, 55 { 56 { 0x82102065, -1 }, /* mov __NR_rt_sigreturn, %g1 */ 57 { 0x91d0206d, -1 }, /* ta 0x6d */ 58 { TRAMP_SENTINEL_INSN, -1 } 59 }, 60 sparc64_linux_sigframe_init 61 }; 62 63 static void 64 sparc64_linux_sigframe_init (const struct tramp_frame *self, 65 struct frame_info *this_frame, 66 struct trad_frame_cache *this_cache, 67 CORE_ADDR func) 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 121 ULONGEST sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM); 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 157 sparc64_linux_supply_core_gregset (const struct regset *regset, 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 166 sparc64_linux_collect_core_gregset (const struct regset *regset, 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 175 sparc64_linux_supply_core_fpregset (const struct regset *regset, 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 183 sparc64_linux_collect_core_fpregset (const struct regset *regset, 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 195 sparc64_linux_write_pc (struct regcache *regcache, CORE_ADDR pc) 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. */ 211 regcache_cooked_read_unsigned (regcache, SPARC64_STATE_REGNUM, &state); 212 state &= ~TSTATE_SYSCALL; 213 regcache_cooked_write_unsigned (regcache, SPARC64_STATE_REGNUM, state); 214 } 215 216 static LONGEST 217 sparc64_linux_get_syscall_number (struct gdbarch *gdbarch, 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 241 sparc64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) 242 { 243 struct gdbarch *gdbarch = get_frame_arch (frame); 244 CORE_ADDR jb_addr; 245 gdb_byte buf[8]; 246 247 jb_addr = get_frame_register_unsigned (frame, SPARC_O0_REGNUM); 248 249 /* setjmp and longjmp in SPARC64 are implemented in glibc using the 250 setcontext and getcontext system calls respectively. These 251 system calls operate on ucontext_t structures, which happen to 252 partially have the same structure than jmp_buf. However the 253 ucontext returned by getcontext, and thus the jmp_buf structure 254 returned by setjmp, contains the context of the trap instruction 255 in the glibc __[sig]setjmp wrapper, not the context of the user 256 code calling setjmp. 257 258 %o7 in the jmp_buf structure is stored at offset 18*8 in the 259 mc_gregs array, which is itself located at offset 32 into 260 jmp_buf. See bits/setjmp.h. This register contains the address 261 of the 'call setjmp' instruction in user code. 262 263 In order to determine the longjmp target address in the 264 initiating frame we need to examine the call instruction itself, 265 in particular whether the annul bit is set. If it is not set 266 then we need to jump over the instruction at the delay slot. */ 267 268 if (target_read_memory (jb_addr + 32 + (18 * 8), buf, 8)) 269 return 0; 270 271 *pc = extract_unsigned_integer (buf, 8, gdbarch_byte_order (gdbarch)); 272 273 if (!sparc_is_annulled_branch_insn (*pc)) 274 *pc += 4; /* delay slot insn */ 275 *pc += 4; /* call insn */ 276 277 return 1; 278 } 279 280 281 282 static const struct regset sparc64_linux_gregset = 283 { 284 NULL, 285 sparc64_linux_supply_core_gregset, 286 sparc64_linux_collect_core_gregset 287 }; 288 289 static const struct regset sparc64_linux_fpregset = 290 { 291 NULL, 292 sparc64_linux_supply_core_fpregset, 293 sparc64_linux_collect_core_fpregset 294 }; 295 296 static void 297 sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 298 { 299 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 300 301 linux_init_abi (info, gdbarch); 302 303 tdep->gregset = &sparc64_linux_gregset; 304 tdep->sizeof_gregset = 288; 305 306 tdep->fpregset = &sparc64_linux_fpregset; 307 tdep->sizeof_fpregset = 280; 308 309 tramp_frame_prepend_unwinder (gdbarch, &sparc64_linux_rt_sigframe); 310 311 /* Hook in the DWARF CFI frame unwinder. */ 312 dwarf2_append_unwinders (gdbarch); 313 314 sparc64_init_abi (info, gdbarch); 315 316 /* GNU/Linux has SVR4-style shared libraries... */ 317 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 318 set_solib_svr4_fetch_link_map_offsets 319 (gdbarch, svr4_lp64_fetch_link_map_offsets); 320 321 /* ...which means that we need some special handling when doing 322 prologue analysis. */ 323 tdep->plt_entry_size = 16; 324 325 /* Enable TLS support. */ 326 set_gdbarch_fetch_tls_load_module_address (gdbarch, 327 svr4_fetch_objfile_link_map); 328 329 /* Make sure we can single-step over signal return system calls. */ 330 tdep->step_trap = sparc64_linux_step_trap; 331 332 /* Make sure we can single-step over longjmp calls. */ 333 set_gdbarch_get_longjmp_target (gdbarch, sparc64_linux_get_longjmp_target); 334 335 set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc); 336 337 /* Functions for 'catch syscall'. */ 338 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64); 339 set_gdbarch_get_syscall_number (gdbarch, 340 sparc64_linux_get_syscall_number); 341 } 342 343 344 /* Provide a prototype to silence -Wmissing-prototypes. */ 345 extern void _initialize_sparc64_linux_tdep (void); 346 347 void 348 _initialize_sparc64_linux_tdep (void) 349 { 350 gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9, 351 GDB_OSABI_LINUX, sparc64_linux_init_abi); 352 } 353