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 { 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 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 274 if (!sparc_is_annulled_branch_insn (*pc)) 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, 286 sparc64_linux_supply_core_gregset, 287 sparc64_linux_collect_core_gregset 288 }; 289 290 static const struct regset sparc64_linux_fpregset = 291 { 292 NULL, 293 sparc64_linux_supply_core_fpregset, 294 sparc64_linux_collect_core_fpregset 295 }; 296 297 static void 298 sparc64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) 299 { 300 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 301 302 linux_init_abi (info, gdbarch); 303 304 tdep->gregset = &sparc64_linux_gregset; 305 tdep->sizeof_gregset = 288; 306 307 tdep->fpregset = &sparc64_linux_fpregset; 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... */ 318 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); 319 set_solib_svr4_fetch_link_map_offsets 320 (gdbarch, svr4_lp64_fetch_link_map_offsets); 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. */ 327 set_gdbarch_fetch_tls_load_module_address (gdbarch, 328 svr4_fetch_objfile_link_map); 329 330 /* Make sure we can single-step over signal return system calls. */ 331 tdep->step_trap = sparc64_linux_step_trap; 332 333 /* Make sure we can single-step over longjmp calls. */ 334 set_gdbarch_get_longjmp_target (gdbarch, sparc64_linux_get_longjmp_target); 335 336 set_gdbarch_write_pc (gdbarch, sparc64_linux_write_pc); 337 338 /* Functions for 'catch syscall'. */ 339 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC64); 340 set_gdbarch_get_syscall_number (gdbarch, 341 sparc64_linux_get_syscall_number); 342 } 343 344 345 /* Provide a prototype to silence -Wmissing-prototypes. */ 346 extern void _initialize_sparc64_linux_tdep (void); 347 348 void 349 _initialize_sparc64_linux_tdep (void) 350 { 351 gdbarch_register_osabi (bfd_arch_sparc, bfd_mach_sparc_v9, 352 GDB_OSABI_LINUX, sparc64_linux_init_abi); 353 } 354