1 /* Target-dependent code for GNU/Linux SPARC.
3 Copyright (C) 2003-2017 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/>. */
21 #include "dwarf2-frame.h"
23 #include "frame-unwind.h"
30 #include "solib-svr4.h"
32 #include "trad-frame.h"
33 #include "tramp-frame.h"
34 #include "xml-syscall.h"
35 #include "linux-tdep.h"
37 /* The syscall's XML filename for sparc 32-bit. */
38 #define XML_SYSCALL_FILENAME_SPARC32 "syscalls/sparc-linux.xml"
40 #include "sparc-tdep.h"
42 /* Signal trampoline support. */
44 static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
45 struct frame_info *this_frame,
46 struct trad_frame_cache *this_cache,
49 /* GNU/Linux has two flavors of signals. Normal signal handlers, and
50 "realtime" (RT) signals. The RT signals can provide additional
51 information to the signal handler if the SA_SIGINFO flag is set
52 when establishing a signal handler using `sigaction'. It is not
53 unlikely that future versions of GNU/Linux will support SA_SIGINFO
54 for normal signals too. */
56 /* When the sparc Linux kernel calls a signal handler and the
57 SA_RESTORER flag isn't set, the return address points to a bit of
58 code on the stack. This code checks whether the PC appears to be
59 within this bit of code.
61 The instruction sequence for normal signals is encoded below.
62 Checking for the code sequence should be somewhat reliable, because
63 the effect is to call the system call sigreturn. This is unlikely
64 to occur anywhere other than a signal trampoline. */
66 static const struct tramp_frame sparc32_linux_sigframe =
71 { 0x821020d8, -1 }, /* mov __NR_sugreturn, %g1 */
72 { 0x91d02010, -1 }, /* ta 0x10 */
73 { TRAMP_SENTINEL_INSN, -1 }
75 sparc32_linux_sigframe_init
78 /* The instruction sequence for RT signals is slightly different. The
79 effect is to call the system call rt_sigreturn. */
81 static const struct tramp_frame sparc32_linux_rt_sigframe =
86 { 0x82102065, -1 }, /* mov __NR_rt_sigreturn, %g1 */
87 { 0x91d02010, -1 }, /* ta 0x10 */
88 { TRAMP_SENTINEL_INSN, -1 }
90 sparc32_linux_sigframe_init
93 /* This enum represents the signals' numbers on the SPARC
94 architecture. It just contains the signal definitions which are
95 different from the generic implementation.
97 It is derived from the file <arch/sparc/include/uapi/asm/signal.h>,
98 from the Linux kernel tree. */
102 SPARC_LINUX_SIGEMT = 7,
103 SPARC_LINUX_SIGBUS = 10,
104 SPARC_LINUX_SIGSYS = 12,
105 SPARC_LINUX_SIGURG = 16,
106 SPARC_LINUX_SIGSTOP = 17,
107 SPARC_LINUX_SIGTSTP = 18,
108 SPARC_LINUX_SIGCONT = 19,
109 SPARC_LINUX_SIGCHLD = 20,
110 SPARC_LINUX_SIGIO = 23,
111 SPARC_LINUX_SIGPOLL = SPARC_LINUX_SIGIO,
112 SPARC_LINUX_SIGLOST = 29,
113 SPARC_LINUX_SIGPWR = SPARC_LINUX_SIGLOST,
114 SPARC_LINUX_SIGUSR1 = 30,
115 SPARC_LINUX_SIGUSR2 = 31,
119 sparc32_linux_sigframe_init (const struct tramp_frame *self,
120 struct frame_info *this_frame,
121 struct trad_frame_cache *this_cache,
124 CORE_ADDR base, addr, sp_addr;
127 base = get_frame_register_unsigned (this_frame, SPARC_O1_REGNUM);
128 if (self == &sparc32_linux_rt_sigframe)
131 /* Offsets from <bits/sigcontext.h>. */
133 trad_frame_set_reg_addr (this_cache, SPARC32_PSR_REGNUM, base + 0);
134 trad_frame_set_reg_addr (this_cache, SPARC32_PC_REGNUM, base + 4);
135 trad_frame_set_reg_addr (this_cache, SPARC32_NPC_REGNUM, base + 8);
136 trad_frame_set_reg_addr (this_cache, SPARC32_Y_REGNUM, base + 12);
138 /* Since %g0 is always zero, keep the identity encoding. */
140 sp_addr = base + 16 + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 4);
141 for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
143 trad_frame_set_reg_addr (this_cache, regnum, addr);
147 base = get_frame_register_unsigned (this_frame, SPARC_SP_REGNUM);
148 addr = get_frame_memory_unsigned (this_frame, sp_addr, 4);
150 for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
152 trad_frame_set_reg_addr (this_cache, regnum, addr);
155 trad_frame_set_id (this_cache, frame_id_build (base, func));
158 /* Return the address of a system call's alternative return
162 sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
164 if (insn == 0x91d02010)
166 ULONGEST sc_num = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
168 /* __NR_rt_sigreturn is 101 and __NR_sigreturn is 216. */
169 if (sc_num == 101 || sc_num == 216)
171 struct gdbarch *gdbarch = get_frame_arch (frame);
172 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
174 ULONGEST sp, pc_offset;
176 sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
178 /* The kernel puts the sigreturn registers on the stack,
179 and this is where the signal unwinding state is take from
180 when returning from a signal.
182 For __NR_sigreturn, this register area sits 96 bytes from
183 the base of the stack. The saved PC sits 4 bytes into the
184 sigreturn register save area.
186 For __NR_rt_sigreturn a siginfo_t, which is 128 bytes, sits
187 right before the sigreturn register save area. */
193 return read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
201 const struct sparc_gregmap sparc32_linux_core_gregmap =
216 sparc32_linux_supply_core_gregset (const struct regset *regset,
217 struct regcache *regcache,
218 int regnum, const void *gregs, size_t len)
220 sparc32_supply_gregset (&sparc32_linux_core_gregmap,
221 regcache, regnum, gregs);
225 sparc32_linux_collect_core_gregset (const struct regset *regset,
226 const struct regcache *regcache,
227 int regnum, void *gregs, size_t len)
229 sparc32_collect_gregset (&sparc32_linux_core_gregmap,
230 regcache, regnum, gregs);
234 sparc32_linux_supply_core_fpregset (const struct regset *regset,
235 struct regcache *regcache,
236 int regnum, const void *fpregs, size_t len)
238 sparc32_supply_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
242 sparc32_linux_collect_core_fpregset (const struct regset *regset,
243 const struct regcache *regcache,
244 int regnum, void *fpregs, size_t len)
246 sparc32_collect_fpregset (&sparc32_bsd_fpregmap, regcache, regnum, fpregs);
249 /* Set the program counter for process PTID to PC. */
251 #define PSR_SYSCALL 0x00004000
254 sparc_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
256 struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
259 regcache_cooked_write_unsigned (regcache, tdep->pc_regnum, pc);
260 regcache_cooked_write_unsigned (regcache, tdep->npc_regnum, pc + 4);
262 /* Clear the "in syscall" bit to prevent the kernel from
263 messing with the PCs we just installed, if we happen to be
264 within an interrupted system call that the kernel wants to
267 Note that after we return from the dummy call, the PSR et al.
268 registers will be automatically restored, and the kernel
269 continues to restart the system call at this point. */
270 regcache_cooked_read_unsigned (regcache, SPARC32_PSR_REGNUM, &psr);
272 regcache_cooked_write_unsigned (regcache, SPARC32_PSR_REGNUM, psr);
276 sparc32_linux_get_syscall_number (struct gdbarch *gdbarch,
279 struct regcache *regcache = get_thread_regcache (ptid);
280 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
281 /* The content of a register. */
286 /* Getting the system call number from the register.
287 When dealing with the sparc architecture, this information
288 is stored at the %g1 register. */
289 regcache_cooked_read (regcache, SPARC_G1_REGNUM, buf);
291 ret = extract_signed_integer (buf, 4, byte_order);
296 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
299 static enum gdb_signal
300 sparc32_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
305 case SPARC_LINUX_SIGEMT:
306 return GDB_SIGNAL_EMT;
308 case SPARC_LINUX_SIGBUS:
309 return GDB_SIGNAL_BUS;
311 case SPARC_LINUX_SIGSYS:
312 return GDB_SIGNAL_SYS;
314 case SPARC_LINUX_SIGURG:
315 return GDB_SIGNAL_URG;
317 case SPARC_LINUX_SIGSTOP:
318 return GDB_SIGNAL_STOP;
320 case SPARC_LINUX_SIGTSTP:
321 return GDB_SIGNAL_TSTP;
323 case SPARC_LINUX_SIGCONT:
324 return GDB_SIGNAL_CONT;
326 case SPARC_LINUX_SIGCHLD:
327 return GDB_SIGNAL_CHLD;
329 /* No way to differentiate between SIGIO and SIGPOLL.
330 Therefore, we just handle the first one. */
331 case SPARC_LINUX_SIGIO:
332 return GDB_SIGNAL_IO;
334 /* No way to differentiate between SIGLOST and SIGPWR.
335 Therefore, we just handle the first one. */
336 case SPARC_LINUX_SIGLOST:
337 return GDB_SIGNAL_LOST;
339 case SPARC_LINUX_SIGUSR1:
340 return GDB_SIGNAL_USR1;
342 case SPARC_LINUX_SIGUSR2:
343 return GDB_SIGNAL_USR2;
346 return linux_gdb_signal_from_target (gdbarch, signal);
349 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
353 sparc32_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
354 enum gdb_signal signal)
359 return SPARC_LINUX_SIGEMT;
362 return SPARC_LINUX_SIGBUS;
365 return SPARC_LINUX_SIGSYS;
368 return SPARC_LINUX_SIGURG;
370 case GDB_SIGNAL_STOP:
371 return SPARC_LINUX_SIGSTOP;
373 case GDB_SIGNAL_TSTP:
374 return SPARC_LINUX_SIGTSTP;
376 case GDB_SIGNAL_CONT:
377 return SPARC_LINUX_SIGCONT;
379 case GDB_SIGNAL_CHLD:
380 return SPARC_LINUX_SIGCHLD;
383 return SPARC_LINUX_SIGIO;
385 case GDB_SIGNAL_POLL:
386 return SPARC_LINUX_SIGPOLL;
388 case GDB_SIGNAL_LOST:
389 return SPARC_LINUX_SIGLOST;
392 return SPARC_LINUX_SIGPWR;
394 case GDB_SIGNAL_USR1:
395 return SPARC_LINUX_SIGUSR1;
397 case GDB_SIGNAL_USR2:
398 return SPARC_LINUX_SIGUSR2;
401 return linux_gdb_signal_to_target (gdbarch, signal);
406 static const struct regset sparc32_linux_gregset =
409 sparc32_linux_supply_core_gregset,
410 sparc32_linux_collect_core_gregset
413 static const struct regset sparc32_linux_fpregset =
416 sparc32_linux_supply_core_fpregset,
417 sparc32_linux_collect_core_fpregset
421 sparc32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
423 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
425 linux_init_abi (info, gdbarch);
427 tdep->gregset = &sparc32_linux_gregset;
428 tdep->sizeof_gregset = 152;
430 tdep->fpregset = &sparc32_linux_fpregset;
431 tdep->sizeof_fpregset = 396;
433 tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_sigframe);
434 tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_rt_sigframe);
436 /* GNU/Linux has SVR4-style shared libraries... */
437 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
438 set_solib_svr4_fetch_link_map_offsets
439 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
441 /* ...which means that we need some special handling when doing
442 prologue analysis. */
443 tdep->plt_entry_size = 12;
445 /* Enable TLS support. */
446 set_gdbarch_fetch_tls_load_module_address (gdbarch,
447 svr4_fetch_objfile_link_map);
449 /* Make sure we can single-step over signal return system calls. */
450 tdep->step_trap = sparc32_linux_step_trap;
452 /* Hook in the DWARF CFI frame unwinder. */
453 dwarf2_append_unwinders (gdbarch);
455 set_gdbarch_write_pc (gdbarch, sparc_linux_write_pc);
457 /* Functions for 'catch syscall'. */
458 set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_SPARC32);
459 set_gdbarch_get_syscall_number (gdbarch,
460 sparc32_linux_get_syscall_number);
462 set_gdbarch_gdb_signal_from_target (gdbarch,
463 sparc32_linux_gdb_signal_from_target);
464 set_gdbarch_gdb_signal_to_target (gdbarch,
465 sparc32_linux_gdb_signal_to_target);
468 /* Provide a prototype to silence -Wmissing-prototypes. */
469 extern void _initialize_sparc_linux_tdep (void);
472 _initialize_sparc_linux_tdep (void)
474 gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
475 sparc32_linux_init_abi);