1/* Target-dependent code for GNU/Linux SPARC.
2
3   Copyright 2003, 2004 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 2 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, write to the Free Software
19   Foundation, Inc., 59 Temple Place - Suite 330,
20   Boston, MA 02111-1307, USA.  */
21
22#include "defs.h"
23#include "floatformat.h"
24#include "frame.h"
25#include "frame-unwind.h"
26#include "gdbarch.h"
27#include "gdbcore.h"
28#include "osabi.h"
29#include "regcache.h"
30#include "solib-svr4.h"
31#include "symtab.h"
32#include "trad-frame.h"
33
34#include "gdb_assert.h"
35#include "gdb_string.h"
36
37#include "sparc-tdep.h"
38
39/* Recognizing signal handler frames.  */
40
41/* GNU/Linux has two flavors of signals.  Normal signal handlers, and
42   "realtime" (RT) signals.  The RT signals can provide additional
43   information to the signal handler if the SA_SIGINFO flag is set
44   when establishing a signal handler using `sigaction'.  It is not
45   unlikely that future versions of GNU/Linux will support SA_SIGINFO
46   for normal signals too.  */
47
48/* When the sparc Linux kernel calls a signal handler and the
49   SA_RESTORER flag isn't set, the return address points to a bit of
50   code on the stack.  This function returns whether the PC appears to
51   be within this bit of code.
52
53   The instruction sequence for normal signals is
54	mov __NR_sigreturn, %g1		! hex: 0x821020d8
55	ta  0x10			! hex: 0x91d02010
56
57   Checking for the code sequence should be somewhat reliable, because
58   the effect is to call the system call sigreturn.  This is unlikely
59   to occur anywhere other than a signal trampoline.
60
61   It kind of sucks that we have to read memory from the process in
62   order to identify a signal trampoline, but there doesn't seem to be
63   any other way.  However, sparc32_linux_pc_in_sigtramp arranges to
64   only call us if no function name could be identified, which should
65   be the case since the code is on the stack.  */
66
67#define LINUX32_SIGTRAMP_INSN0	0x821020d8	/* mov __NR_sigreturn, %g1 */
68#define LINUX32_SIGTRAMP_INSN1	0x91d02010	/* ta  0x10 */
69
70/* The instruction sequence for RT signals is
71       mov __NR_rt_sigreturn, %g1	! hex: 0x82102065
72       ta  {0x10,0x6d}			! hex: 0x91d02010 or 0x91d0206d
73
74   The effect is to call the system call rt_sigreturn.  The trap number
75   is variable based upon whether this is a 32-bit or 64-bit sparc binary.
76   Note that 64-bit binaries only use this RT signal return method.  */
77
78#define LINUX32_RT_SIGTRAMP_INSN0	0x82102065
79#define LINUX32_RT_SIGTRAMP_INSN1	0x91d02010
80
81/* If PC is in a sigtramp routine consisting of the instructions INSN0
82   and INSN1, return the address of the start of the routine.
83   Otherwise, return 0.  */
84
85CORE_ADDR
86sparc_linux_sigtramp_start (struct frame_info *next_frame,
87			    ULONGEST insn0, ULONGEST insn1)
88{
89  CORE_ADDR pc = frame_pc_unwind (next_frame);
90  ULONGEST word0, word1;
91  unsigned char buf[8];		/* Two instructions.  */
92
93  /* We only recognize a signal trampoline if PC is at the start of
94     one of the instructions.  We optimize for finding the PC at the
95     start of the instruction sequence, as will be the case when the
96     trampoline is not the first frame on the stack.  We assume that
97     in the case where the PC is not at the start of the instruction
98     sequence, there will be a few trailing readable bytes on the
99     stack.  */
100
101  if (!safe_frame_unwind_memory (next_frame, pc, buf, sizeof buf))
102    return 0;
103
104  word0 = extract_unsigned_integer (buf, 4);
105  if (word0 != insn0)
106    {
107      if (word0 != insn1)
108	return 0;
109
110      pc -= 4;
111      if (!safe_frame_unwind_memory (next_frame, pc, buf, sizeof buf))
112	return 0;
113
114      word0 = extract_unsigned_integer (buf, 4);
115    }
116
117  word1 = extract_unsigned_integer (buf + 4, 4);
118  if (word0 != insn0 || word1 != insn1)
119    return 0;
120
121  return pc;
122}
123
124static CORE_ADDR
125sparc32_linux_sigtramp_start (struct frame_info *next_frame)
126{
127  return sparc_linux_sigtramp_start (next_frame, LINUX32_SIGTRAMP_INSN0,
128				     LINUX32_SIGTRAMP_INSN1);
129}
130
131static CORE_ADDR
132sparc32_linux_rt_sigtramp_start (struct frame_info *next_frame)
133{
134  return sparc_linux_sigtramp_start (next_frame, LINUX32_RT_SIGTRAMP_INSN0,
135				     LINUX32_RT_SIGTRAMP_INSN1);
136}
137
138static int
139sparc32_linux_sigtramp_p (struct frame_info *next_frame)
140{
141  CORE_ADDR pc = frame_pc_unwind (next_frame);
142  char *name;
143
144  find_pc_partial_function (pc, &name, NULL, NULL);
145
146  /* If we have NAME, we can optimize the search.  The trampolines are
147     named __restore and __restore_rt.  However, they aren't dynamically
148     exported from the shared C library, so the trampoline may appear to
149     be part of the preceding function.  This should always be sigaction,
150     __sigaction, or __libc_sigaction (all aliases to the same function).  */
151  if (name == NULL || strstr (name, "sigaction") != NULL)
152    return (sparc32_linux_sigtramp_start (next_frame) != 0
153	    || sparc32_linux_rt_sigtramp_start (next_frame) != 0);
154
155  return (strcmp ("__restore", name) == 0
156	  || strcmp ("__restore_rt", name) == 0);
157}
158
159static struct sparc_frame_cache *
160sparc32_linux_sigtramp_frame_cache (struct frame_info *next_frame,
161				    void **this_cache)
162{
163  struct sparc_frame_cache *cache;
164  CORE_ADDR sigcontext_addr, addr;
165  int regnum;
166
167  if (*this_cache)
168    return *this_cache;
169
170  cache = sparc32_frame_cache (next_frame, this_cache);
171  gdb_assert (cache == *this_cache);
172
173  /* ??? What about signal trampolines that aren't frameless?  */
174  regnum = SPARC_SP_REGNUM;
175  cache->base = frame_unwind_register_unsigned (next_frame, regnum);
176
177  regnum = SPARC_O1_REGNUM;
178  sigcontext_addr = frame_unwind_register_unsigned (next_frame, regnum);
179
180  addr = sparc32_linux_sigtramp_start (next_frame);
181  if (addr == 0)
182    {
183      /* If this is a RT signal trampoline, adjust SIGCONTEXT_ADDR
184         accordingly.  */
185      addr = sparc32_linux_rt_sigtramp_start (next_frame);
186      if (addr)
187	sigcontext_addr += 128;
188      else
189	addr = frame_func_unwind (next_frame);
190    }
191  cache->pc = addr;
192
193  cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
194
195  cache->saved_regs[SPARC32_PSR_REGNUM].addr = sigcontext_addr + 0;
196  cache->saved_regs[SPARC32_PC_REGNUM].addr = sigcontext_addr + 4;
197  cache->saved_regs[SPARC32_NPC_REGNUM].addr = sigcontext_addr + 8;
198  cache->saved_regs[SPARC32_Y_REGNUM].addr = sigcontext_addr + 12;
199
200  /* Since %g0 is always zero, keep the identity encoding.  */
201  for (regnum = SPARC_G1_REGNUM, addr = sigcontext_addr + 20;
202       regnum <= SPARC_O7_REGNUM; regnum++, addr += 4)
203    cache->saved_regs[regnum].addr = addr;
204
205  for (regnum = SPARC_L0_REGNUM, addr = cache->base;
206       regnum <= SPARC_I7_REGNUM; regnum++, addr += 4)
207    cache->saved_regs[regnum].addr = addr;
208
209  return cache;
210}
211
212static void
213sparc32_linux_sigtramp_frame_this_id (struct frame_info *next_frame,
214				      void **this_cache,
215				      struct frame_id *this_id)
216{
217  struct sparc_frame_cache *cache =
218    sparc32_linux_sigtramp_frame_cache (next_frame, this_cache);
219
220  (*this_id) = frame_id_build (cache->base, cache->pc);
221}
222
223static void
224sparc32_linux_sigtramp_frame_prev_register (struct frame_info *next_frame,
225					    void **this_cache,
226					    int regnum, int *optimizedp,
227					    enum lval_type *lvalp,
228					    CORE_ADDR *addrp,
229					    int *realnump, void *valuep)
230{
231  struct sparc_frame_cache *cache =
232    sparc32_linux_sigtramp_frame_cache (next_frame, this_cache);
233
234  trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
235				optimizedp, lvalp, addrp, realnump, valuep);
236}
237
238static const struct frame_unwind sparc32_linux_sigtramp_frame_unwind =
239{
240  SIGTRAMP_FRAME,
241  sparc32_linux_sigtramp_frame_this_id,
242  sparc32_linux_sigtramp_frame_prev_register
243};
244
245static const struct frame_unwind *
246sparc32_linux_sigtramp_frame_sniffer (struct frame_info *next_frame)
247{
248  if (sparc32_linux_sigtramp_p (next_frame))
249    return &sparc32_linux_sigtramp_frame_unwind;
250
251  return NULL;
252}
253
254
255static void
256sparc32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
257{
258  /* GNU/Linux is very similar to Solaris ...  */
259  sparc32_sol2_init_abi (info, gdbarch);
260
261  /* ... but doesn't have kernel-assisted single-stepping support.  */
262  set_gdbarch_software_single_step (gdbarch, sparc_software_single_step);
263
264  /* GNU/Linux doesn't support the 128-bit `long double' from the psABI.  */
265  set_gdbarch_long_double_bit (gdbarch, 64);
266  set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
267
268  frame_unwind_append_sniffer (gdbarch, sparc32_linux_sigtramp_frame_sniffer);
269}
270
271/* Provide a prototype to silence -Wmissing-prototypes.  */
272extern void _initialize_sparc_linux_tdep (void);
273
274void
275_initialize_sparc_linux_tdep (void)
276{
277  gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
278			  sparc32_linux_init_abi);
279}
280