This patch implements the new gdbarch method gdbarch_gdb_signal_to_target.
[external/binutils.git] / gdb / alpha-linux-tdep.c
1 /* Target-dependent code for GNU/Linux on Alpha.
2    Copyright (C) 2002-2013 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19 #include "defs.h"
20 #include "frame.h"
21 #include "gdb_assert.h"
22 #include "gdb_string.h"
23 #include "osabi.h"
24 #include "solib-svr4.h"
25 #include "symtab.h"
26 #include "regset.h"
27 #include "regcache.h"
28 #include "linux-tdep.h"
29 #include "alpha-tdep.h"
30
31 /* This enum represents the signals' numbers on the Alpha
32    architecture.  It just contains the signal definitions which are
33    different from the generic implementation.
34
35    It is derived from the file <arch/alpha/include/uapi/asm/signal.h>,
36    from the Linux kernel tree.  */
37
38 enum
39   {
40     /* SIGABRT is the same as in the generic implementation, but is
41        defined here because SIGIOT depends on it.  */
42     ALPHA_LINUX_SIGABRT = 6,
43     ALPHA_LINUX_SIGEMT = 7,
44     ALPHA_LINUX_SIGBUS = 10,
45     ALPHA_LINUX_SIGSYS = 12,
46     ALPHA_LINUX_SIGURG = 16,
47     ALPHA_LINUX_SIGSTOP = 17,
48     ALPHA_LINUX_SIGTSTP = 18,
49     ALPHA_LINUX_SIGCONT = 19,
50     ALPHA_LINUX_SIGCHLD = 20,
51     ALPHA_LINUX_SIGIO = 23,
52     ALPHA_LINUX_SIGINFO = 29,
53     ALPHA_LINUX_SIGUSR1 = 30,
54     ALPHA_LINUX_SIGUSR2 = 31,
55     ALPHA_LINUX_SIGPOLL = ALPHA_LINUX_SIGIO,
56     ALPHA_LINUX_SIGPWR = ALPHA_LINUX_SIGINFO,
57     ALPHA_LINUX_SIGIOT = ALPHA_LINUX_SIGABRT,
58   };
59
60 /* Under GNU/Linux, signal handler invocations can be identified by
61    the designated code sequence that is used to return from a signal
62    handler.  In particular, the return address of a signal handler
63    points to a sequence that copies $sp to $16, loads $0 with the
64    appropriate syscall number, and finally enters the kernel.
65
66    This is somewhat complicated in that:
67      (1) the expansion of the "mov" assembler macro has changed over
68          time, from "bis src,src,dst" to "bis zero,src,dst",
69      (2) the kernel has changed from using "addq" to "lda" to load the
70          syscall number,
71      (3) there is a "normal" sigreturn and an "rt" sigreturn which
72          has a different stack layout.  */
73
74 static long
75 alpha_linux_sigtramp_offset_1 (struct gdbarch *gdbarch, CORE_ADDR pc)
76 {
77   switch (alpha_read_insn (gdbarch, pc))
78     {
79     case 0x47de0410:            /* bis $30,$30,$16 */
80     case 0x47fe0410:            /* bis $31,$30,$16 */
81       return 0;
82
83     case 0x43ecf400:            /* addq $31,103,$0 */
84     case 0x201f0067:            /* lda $0,103($31) */
85     case 0x201f015f:            /* lda $0,351($31) */
86       return 4;
87
88     case 0x00000083:            /* call_pal callsys */
89       return 8;
90
91     default:
92       return -1;
93     }
94 }
95
96 static LONGEST
97 alpha_linux_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc)
98 {
99   long i, off;
100
101   if (pc & 3)
102     return -1;
103
104   /* Guess where we might be in the sequence.  */
105   off = alpha_linux_sigtramp_offset_1 (gdbarch, pc);
106   if (off < 0)
107     return -1;
108
109   /* Verify that the other two insns of the sequence are as we expect.  */
110   pc -= off;
111   for (i = 0; i < 12; i += 4)
112     {
113       if (i == off)
114         continue;
115       if (alpha_linux_sigtramp_offset_1 (gdbarch, pc + i) != i)
116         return -1;
117     }
118
119   return off;
120 }
121
122 static int
123 alpha_linux_pc_in_sigtramp (struct gdbarch *gdbarch,
124                             CORE_ADDR pc, const char *func_name)
125 {
126   return alpha_linux_sigtramp_offset (gdbarch, pc) >= 0;
127 }
128
129 static CORE_ADDR
130 alpha_linux_sigcontext_addr (struct frame_info *this_frame)
131 {
132   struct gdbarch *gdbarch = get_frame_arch (this_frame);
133   CORE_ADDR pc;
134   ULONGEST sp;
135   long off;
136
137   pc = get_frame_pc (this_frame);
138   sp = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
139
140   off = alpha_linux_sigtramp_offset (gdbarch, pc);
141   gdb_assert (off >= 0);
142
143   /* __NR_rt_sigreturn has a couple of structures on the stack.  This is:
144
145         struct rt_sigframe {
146           struct siginfo info;
147           struct ucontext uc;
148         };
149
150         offsetof (struct rt_sigframe, uc.uc_mcontext);  */
151
152   if (alpha_read_insn (gdbarch, pc - off + 4) == 0x201f015f)
153     return sp + 176;
154
155   /* __NR_sigreturn has the sigcontext structure at the top of the stack.  */
156   return sp;
157 }
158
159 /* Supply register REGNUM from the buffer specified by GREGS and LEN
160    in the general-purpose register set REGSET to register cache
161    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
162
163 static void
164 alpha_linux_supply_gregset (const struct regset *regset,
165                             struct regcache *regcache,
166                             int regnum, const void *gregs, size_t len)
167 {
168   const gdb_byte *regs = gregs;
169   int i;
170   gdb_assert (len >= 32 * 8);
171
172   for (i = 0; i < ALPHA_ZERO_REGNUM; i++)
173     {
174       if (regnum == i || regnum == -1)
175         regcache_raw_supply (regcache, i, regs + i * 8);
176     }
177
178   if (regnum == ALPHA_PC_REGNUM || regnum == -1)
179     regcache_raw_supply (regcache, ALPHA_PC_REGNUM, regs + 31 * 8);
180
181   if (regnum == ALPHA_UNIQUE_REGNUM || regnum == -1)
182     regcache_raw_supply (regcache, ALPHA_UNIQUE_REGNUM,
183                          len >= 33 * 8 ? regs + 32 * 8 : NULL);
184 }
185
186 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
187    in the floating-point register set REGSET to register cache
188    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
189
190 static void
191 alpha_linux_supply_fpregset (const struct regset *regset,
192                              struct regcache *regcache,
193                              int regnum, const void *fpregs, size_t len)
194 {
195   const gdb_byte *regs = fpregs;
196   int i;
197   gdb_assert (len >= 32 * 8);
198
199   for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; i++)
200     {
201       if (regnum == i || regnum == -1)
202         regcache_raw_supply (regcache, i, regs + (i - ALPHA_FP0_REGNUM) * 8);
203     }
204
205   if (regnum == ALPHA_FPCR_REGNUM || regnum == -1)
206     regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, regs + 31 * 8);
207 }
208
209 static struct regset alpha_linux_gregset =
210 {
211   NULL,
212   alpha_linux_supply_gregset
213 };
214
215 static struct regset alpha_linux_fpregset =
216 {
217   NULL,
218   alpha_linux_supply_fpregset
219 };
220
221 /* Return the appropriate register set for the core section identified
222    by SECT_NAME and SECT_SIZE.  */
223
224 static const struct regset *
225 alpha_linux_regset_from_core_section (struct gdbarch *gdbarch,
226                                       const char *sect_name, size_t sect_size)
227 {
228   if (strcmp (sect_name, ".reg") == 0 && sect_size >= 32 * 8)
229     return &alpha_linux_gregset;
230
231   if (strcmp (sect_name, ".reg2") == 0 && sect_size >= 32 * 8)
232     return &alpha_linux_fpregset;
233
234   return NULL;
235 }
236
237 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
238    gdbarch.h.  */
239
240 static enum gdb_signal
241 alpha_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
242                                     int signal)
243 {
244   switch (signal)
245     {
246     case ALPHA_LINUX_SIGEMT:
247       return GDB_SIGNAL_EMT;
248
249     case ALPHA_LINUX_SIGBUS:
250       return GDB_SIGNAL_BUS;
251
252     case ALPHA_LINUX_SIGSYS:
253       return GDB_SIGNAL_SYS;
254
255     case ALPHA_LINUX_SIGURG:
256       return GDB_SIGNAL_URG;
257
258     case ALPHA_LINUX_SIGSTOP:
259       return GDB_SIGNAL_STOP;
260
261     case ALPHA_LINUX_SIGTSTP:
262       return GDB_SIGNAL_TSTP;
263
264     case ALPHA_LINUX_SIGCONT:
265       return GDB_SIGNAL_CONT;
266
267     case ALPHA_LINUX_SIGCHLD:
268       return GDB_SIGNAL_CHLD;
269
270     /* No way to differentiate between SIGIO and SIGPOLL.
271        Therefore, we just handle the first one.  */
272     case ALPHA_LINUX_SIGIO:
273       return GDB_SIGNAL_IO;
274
275     /* No way to differentiate between SIGINFO and SIGPWR.
276        Therefore, we just handle the first one.  */
277     case ALPHA_LINUX_SIGINFO:
278       return GDB_SIGNAL_INFO;
279
280     case ALPHA_LINUX_SIGUSR1:
281       return GDB_SIGNAL_USR1;
282
283     case ALPHA_LINUX_SIGUSR2:
284       return GDB_SIGNAL_USR2;
285     }
286
287   return linux_gdb_signal_from_target (gdbarch, signal);
288 }
289
290 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
291    gdbarch.h.  */
292
293 static int
294 alpha_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
295                                   enum gdb_signal signal)
296 {
297   switch (signal)
298     {
299     case GDB_SIGNAL_EMT:
300       return ALPHA_LINUX_SIGEMT;
301
302     case GDB_SIGNAL_BUS:
303       return ALPHA_LINUX_SIGBUS;
304
305     case GDB_SIGNAL_SYS:
306       return ALPHA_LINUX_SIGSYS;
307
308     case GDB_SIGNAL_URG:
309       return ALPHA_LINUX_SIGURG;
310
311     case GDB_SIGNAL_STOP:
312       return ALPHA_LINUX_SIGSTOP;
313
314     case GDB_SIGNAL_TSTP:
315       return ALPHA_LINUX_SIGTSTP;
316
317     case GDB_SIGNAL_CONT:
318       return ALPHA_LINUX_SIGCONT;
319
320     case GDB_SIGNAL_CHLD:
321       return ALPHA_LINUX_SIGCHLD;
322
323     case GDB_SIGNAL_IO:
324       return ALPHA_LINUX_SIGIO;
325
326     case GDB_SIGNAL_INFO:
327       return ALPHA_LINUX_SIGINFO;
328
329     case GDB_SIGNAL_USR1:
330       return ALPHA_LINUX_SIGUSR1;
331
332     case GDB_SIGNAL_USR2:
333       return ALPHA_LINUX_SIGUSR2;
334
335     case GDB_SIGNAL_POLL:
336       return ALPHA_LINUX_SIGPOLL;
337
338     case GDB_SIGNAL_PWR:
339       return ALPHA_LINUX_SIGPWR;
340     }
341
342   return linux_gdb_signal_to_target (gdbarch, signal);
343 }
344
345 static void
346 alpha_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
347 {
348   struct gdbarch_tdep *tdep;
349
350   linux_init_abi (info, gdbarch);
351
352   /* Hook into the DWARF CFI frame unwinder.  */
353   alpha_dwarf2_init_abi (info, gdbarch);
354
355   /* Hook into the MDEBUG frame unwinder.  */
356   alpha_mdebug_init_abi (info, gdbarch);
357
358   tdep = gdbarch_tdep (gdbarch);
359   tdep->dynamic_sigtramp_offset = alpha_linux_sigtramp_offset;
360   tdep->sigcontext_addr = alpha_linux_sigcontext_addr;
361   tdep->pc_in_sigtramp = alpha_linux_pc_in_sigtramp;
362   tdep->jb_pc = 2;
363   tdep->jb_elt_size = 8;
364
365   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
366
367   set_solib_svr4_fetch_link_map_offsets
368     (gdbarch, svr4_lp64_fetch_link_map_offsets);
369
370   /* Enable TLS support.  */
371   set_gdbarch_fetch_tls_load_module_address (gdbarch,
372                                              svr4_fetch_objfile_link_map);
373
374   set_gdbarch_regset_from_core_section
375     (gdbarch, alpha_linux_regset_from_core_section);
376
377   set_gdbarch_gdb_signal_from_target (gdbarch,
378                                       alpha_linux_gdb_signal_from_target);
379   set_gdbarch_gdb_signal_to_target (gdbarch,
380                                     alpha_linux_gdb_signal_to_target);
381 }
382
383 /* Provide a prototype to silence -Wmissing-prototypes.  */
384 extern initialize_file_ftype _initialize_alpha_linux_tdep;
385
386 void
387 _initialize_alpha_linux_tdep (void)
388 {
389   gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_LINUX,
390                           alpha_linux_init_abi);
391 }