* gdbarch.sh (fetch_tls_load_module_address): New architecture method.
[external/binutils.git] / gdb / sparc-linux-tdep.c
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
85 CORE_ADDR
86 sparc_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
124 static CORE_ADDR
125 sparc32_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
131 static CORE_ADDR
132 sparc32_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
138 static int
139 sparc32_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
159 static struct sparc_frame_cache *
160 sparc32_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
212 static void
213 sparc32_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
223 static void
224 sparc32_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
238 static 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
245 static const struct frame_unwind *
246 sparc32_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 \f
254
255 static void
256 sparc32_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   /* Enable TLS support.  */
271   set_gdbarch_fetch_tls_load_module_address (gdbarch,
272                                              svr4_fetch_objfile_link_map);
273 }
274
275 /* Provide a prototype to silence -Wmissing-prototypes.  */
276 extern void _initialize_sparc_linux_tdep (void);
277
278 void
279 _initialize_sparc_linux_tdep (void)
280 {
281   gdbarch_register_osabi (bfd_arch_sparc, 0, GDB_OSABI_LINUX,
282                           sparc32_linux_init_abi);
283 }