1/* Target-dependent code for GNU/Linux SPARC.
2
3   Copyright (C) 2003, 2004, 2005, 2007 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 "dwarf2-frame.h"
22#include "frame.h"
23#include "frame-unwind.h"
24#include "gdbtypes.h"
25#include "regset.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#include "tramp-frame.h"
34
35#include "sparc-tdep.h"
36
37/* Signal trampoline support.  */
38
39static void sparc32_linux_sigframe_init (const struct tramp_frame *self,
40					 struct frame_info *next_frame,
41					 struct trad_frame_cache *this_cache,
42					 CORE_ADDR func);
43
44/* GNU/Linux has two flavors of signals.  Normal signal handlers, and
45   "realtime" (RT) signals.  The RT signals can provide additional
46   information to the signal handler if the SA_SIGINFO flag is set
47   when establishing a signal handler using `sigaction'.  It is not
48   unlikely that future versions of GNU/Linux will support SA_SIGINFO
49   for normal signals too.  */
50
51/* When the sparc Linux kernel calls a signal handler and the
52   SA_RESTORER flag isn't set, the return address points to a bit of
53   code on the stack.  This code checks whether the PC appears to be
54   within this bit of code.
55
56   The instruction sequence for normal signals is encoded below.
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
61static const struct tramp_frame sparc32_linux_sigframe =
62{
63  SIGTRAMP_FRAME,
64  4,
65  {
66    { 0x821020d8, -1 },		/* mov __NR_sugreturn, %g1 */
67    { 0x91d02010, -1 },		/* ta  0x10 */
68    { TRAMP_SENTINEL_INSN, -1 }
69  },
70  sparc32_linux_sigframe_init
71};
72
73/* The instruction sequence for RT signals is slightly different.  The
74   effect is to call the system call rt_sigreturn.  */
75
76static const struct tramp_frame sparc32_linux_rt_sigframe =
77{
78  SIGTRAMP_FRAME,
79  4,
80  {
81    { 0x82102065, -1 },		/* mov __NR_rt_sigreturn, %g1 */
82    { 0x91d02010, -1 },		/* ta  0x10 */
83    { TRAMP_SENTINEL_INSN, -1 }
84  },
85  sparc32_linux_sigframe_init
86};
87
88static void
89sparc32_linux_sigframe_init (const struct tramp_frame *self,
90			     struct frame_info *next_frame,
91			     struct trad_frame_cache *this_cache,
92			     CORE_ADDR func)
93{
94  CORE_ADDR base, addr, sp_addr;
95  int regnum;
96
97  base = frame_unwind_register_unsigned (next_frame, SPARC_O1_REGNUM);
98  if (self == &sparc32_linux_rt_sigframe)
99    base += 128;
100
101  /* Offsets from <bits/sigcontext.h>.  */
102
103  trad_frame_set_reg_addr (this_cache, SPARC32_PSR_REGNUM, base + 0);
104  trad_frame_set_reg_addr (this_cache, SPARC32_PC_REGNUM, base + 4);
105  trad_frame_set_reg_addr (this_cache, SPARC32_NPC_REGNUM, base + 8);
106  trad_frame_set_reg_addr (this_cache, SPARC32_Y_REGNUM, base + 12);
107
108  /* Since %g0 is always zero, keep the identity encoding.  */
109  addr = base + 20;
110  sp_addr = base + 16 + ((SPARC_SP_REGNUM - SPARC_G0_REGNUM) * 4);
111  for (regnum = SPARC_G1_REGNUM; regnum <= SPARC_O7_REGNUM; regnum++)
112    {
113      trad_frame_set_reg_addr (this_cache, regnum, addr);
114      addr += 4;
115    }
116
117  base = frame_unwind_register_unsigned (next_frame, SPARC_SP_REGNUM);
118  addr = get_frame_memory_unsigned (next_frame, sp_addr, 4);
119
120  for (regnum = SPARC_L0_REGNUM; regnum <= SPARC_I7_REGNUM; regnum++)
121    {
122      trad_frame_set_reg_addr (this_cache, regnum, addr);
123      addr += 4;
124    }
125  trad_frame_set_id (this_cache, frame_id_build (base, func));
126}
127
128/* Return the address of a system call's alternative return
129   address.  */
130
131static CORE_ADDR
132sparc32_linux_step_trap (struct frame_info *frame, unsigned long insn)
133{
134  if (insn == 0x91d02010)
135    {
136      ULONGEST sc_num = get_frame_register_unsigned (frame, SPARC_G1_REGNUM);
137
138      /* __NR_rt_sigreturn is 101 and __NR_sigreturn is 216  */
139      if (sc_num == 101 || sc_num == 216)
140	{
141	  ULONGEST sp, pc_offset;
142
143	  sp = get_frame_register_unsigned (frame, SPARC_SP_REGNUM);
144
145	  /* The kernel puts the sigreturn registers on the stack,
146	     and this is where the signal unwinding state is take from
147	     when returning from a signal.
148
149	     For __NR_sigreturn, this register area sits 96 bytes from
150	     the base of the stack.  The saved PC sits 4 bytes into the
151	     sigreturn register save area.
152
153	     For __NR_rt_sigreturn a siginfo_t, which is 128 bytes, sits
154	     right before the sigreturn register save area.  */
155
156	  pc_offset = 96 + 4;
157	  if (sc_num == 101)
158	    pc_offset += 128;
159
160	  return read_memory_unsigned_integer (sp + pc_offset, 4);
161	}
162    }
163
164  return 0;
165}
166
167
168const struct sparc_gregset sparc32_linux_core_gregset =
169{
170  32 * 4,			/* %psr */
171  33 * 4,			/* %pc */
172  34 * 4,			/* %npc */
173  35 * 4,			/* %y */
174  -1,				/* %wim */
175  -1,				/* %tbr */
176  1 * 4,			/* %g1 */
177  16 * 4,			/* %l0 */
178  4,				/* y size */
179};
180
181
182static void
183sparc32_linux_supply_core_gregset (const struct regset *regset,
184				   struct regcache *regcache,
185				   int regnum, const void *gregs, size_t len)
186{
187  sparc32_supply_gregset (&sparc32_linux_core_gregset, regcache, regnum, gregs);
188}
189
190static void
191sparc32_linux_collect_core_gregset (const struct regset *regset,
192				    const struct regcache *regcache,
193				    int regnum, void *gregs, size_t len)
194{
195  sparc32_collect_gregset (&sparc32_linux_core_gregset, regcache, regnum, gregs);
196}
197
198static void
199sparc32_linux_supply_core_fpregset (const struct regset *regset,
200				    struct regcache *regcache,
201				    int regnum, const void *fpregs, size_t len)
202{
203  sparc32_supply_fpregset (regcache, regnum, fpregs);
204}
205
206static void
207sparc32_linux_collect_core_fpregset (const struct regset *regset,
208				     const struct regcache *regcache,
209				     int regnum, void *fpregs, size_t len)
210{
211  sparc32_collect_fpregset (regcache, regnum, fpregs);
212}
213
214
215
216static void
217sparc32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
218{
219  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
220
221  tdep->gregset = regset_alloc (gdbarch, sparc32_linux_supply_core_gregset,
222				sparc32_linux_collect_core_gregset);
223  tdep->sizeof_gregset = 152;
224
225  tdep->fpregset = regset_alloc (gdbarch, sparc32_linux_supply_core_fpregset,
226				 sparc32_linux_collect_core_fpregset);
227  tdep->sizeof_fpregset = 396;
228
229  tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_sigframe);
230  tramp_frame_prepend_unwinder (gdbarch, &sparc32_linux_rt_sigframe);
231
232  /* GNU/Linux has SVR4-style shared libraries...  */
233  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
234  set_solib_svr4_fetch_link_map_offsets
235    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
236
237  /* ...which means that we need some special handling when doing
238     prologue analysis.  */
239  tdep->plt_entry_size = 12;
240
241  /* GNU/Linux doesn't support the 128-bit `long double' from the psABI.  */
242  set_gdbarch_long_double_bit (gdbarch, 64);
243  set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
244
245  /* Enable TLS support.  */
246  set_gdbarch_fetch_tls_load_module_address (gdbarch,
247                                             svr4_fetch_objfile_link_map);
248
249  /* Make sure we can single-step over signal return system calls.  */
250  tdep->step_trap = sparc32_linux_step_trap;
251
252  /* Hook in the DWARF CFI frame unwinder.  */
253  frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
254}
255
256/* Provide a prototype to silence -Wmissing-prototypes.  */
257extern void _initialize_sparc_linux_tdep (void);
258
259void
260_initialize_sparc_linux_tdep (void)
261{
262  gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
263			  sparc32_linux_init_abi);
264}
265