1 /* Target-dependent code for GNU/Linux on Alpha.
2 Copyright (C) 2002-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
22 #include "solib-svr4.h"
26 #include "linux-tdep.h"
27 #include "alpha-tdep.h"
29 /* This enum represents the signals' numbers on the Alpha
30 architecture. It just contains the signal definitions which are
31 different from the generic implementation.
33 It is derived from the file <arch/alpha/include/uapi/asm/signal.h>,
34 from the Linux kernel tree. */
38 /* SIGABRT is the same as in the generic implementation, but is
39 defined here because SIGIOT depends on it. */
40 ALPHA_LINUX_SIGABRT = 6,
41 ALPHA_LINUX_SIGEMT = 7,
42 ALPHA_LINUX_SIGBUS = 10,
43 ALPHA_LINUX_SIGSYS = 12,
44 ALPHA_LINUX_SIGURG = 16,
45 ALPHA_LINUX_SIGSTOP = 17,
46 ALPHA_LINUX_SIGTSTP = 18,
47 ALPHA_LINUX_SIGCONT = 19,
48 ALPHA_LINUX_SIGCHLD = 20,
49 ALPHA_LINUX_SIGIO = 23,
50 ALPHA_LINUX_SIGINFO = 29,
51 ALPHA_LINUX_SIGUSR1 = 30,
52 ALPHA_LINUX_SIGUSR2 = 31,
53 ALPHA_LINUX_SIGPOLL = ALPHA_LINUX_SIGIO,
54 ALPHA_LINUX_SIGPWR = ALPHA_LINUX_SIGINFO,
55 ALPHA_LINUX_SIGIOT = ALPHA_LINUX_SIGABRT,
58 /* Under GNU/Linux, signal handler invocations can be identified by
59 the designated code sequence that is used to return from a signal
60 handler. In particular, the return address of a signal handler
61 points to a sequence that copies $sp to $16, loads $0 with the
62 appropriate syscall number, and finally enters the kernel.
64 This is somewhat complicated in that:
65 (1) the expansion of the "mov" assembler macro has changed over
66 time, from "bis src,src,dst" to "bis zero,src,dst",
67 (2) the kernel has changed from using "addq" to "lda" to load the
69 (3) there is a "normal" sigreturn and an "rt" sigreturn which
70 has a different stack layout. */
73 alpha_linux_sigtramp_offset_1 (struct gdbarch *gdbarch, CORE_ADDR pc)
75 switch (alpha_read_insn (gdbarch, pc))
77 case 0x47de0410: /* bis $30,$30,$16 */
78 case 0x47fe0410: /* bis $31,$30,$16 */
81 case 0x43ecf400: /* addq $31,103,$0 */
82 case 0x201f0067: /* lda $0,103($31) */
83 case 0x201f015f: /* lda $0,351($31) */
86 case 0x00000083: /* call_pal callsys */
95 alpha_linux_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc)
102 /* Guess where we might be in the sequence. */
103 off = alpha_linux_sigtramp_offset_1 (gdbarch, pc);
107 /* Verify that the other two insns of the sequence are as we expect. */
109 for (i = 0; i < 12; i += 4)
113 if (alpha_linux_sigtramp_offset_1 (gdbarch, pc + i) != i)
121 alpha_linux_pc_in_sigtramp (struct gdbarch *gdbarch,
122 CORE_ADDR pc, const char *func_name)
124 return alpha_linux_sigtramp_offset (gdbarch, pc) >= 0;
128 alpha_linux_sigcontext_addr (struct frame_info *this_frame)
130 struct gdbarch *gdbarch = get_frame_arch (this_frame);
135 pc = get_frame_pc (this_frame);
136 sp = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM);
138 off = alpha_linux_sigtramp_offset (gdbarch, pc);
139 gdb_assert (off >= 0);
141 /* __NR_rt_sigreturn has a couple of structures on the stack. This is:
148 offsetof (struct rt_sigframe, uc.uc_mcontext); */
150 if (alpha_read_insn (gdbarch, pc - off + 4) == 0x201f015f)
153 /* __NR_sigreturn has the sigcontext structure at the top of the stack. */
157 /* Supply register REGNUM from the buffer specified by GREGS and LEN
158 in the general-purpose register set REGSET to register cache
159 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
162 alpha_linux_supply_gregset (const struct regset *regset,
163 struct regcache *regcache,
164 int regnum, const void *gregs, size_t len)
166 const gdb_byte *regs = gregs;
168 gdb_assert (len >= 32 * 8);
169 alpha_supply_int_regs (regcache, regnum, regs, regs + 31 * 8,
170 len >= 33 * 8 ? regs + 32 * 8 : NULL);
173 /* Collect register REGNUM from the register cache REGCACHE and store
174 it in the buffer specified by GREGS and LEN as described by the
175 general-purpose register set REGSET. If REGNUM is -1, do this for
176 all registers in REGSET. */
179 alpha_linux_collect_gregset (const struct regset *regset,
180 const struct regcache *regcache,
181 int regnum, void *gregs, size_t len)
183 gdb_byte *regs = gregs;
185 gdb_assert (len >= 32 * 8);
186 alpha_fill_int_regs (regcache, regnum, regs, regs + 31 * 8,
187 len >= 33 * 8 ? regs + 32 * 8 : NULL);
190 /* Supply register REGNUM from the buffer specified by FPREGS and LEN
191 in the floating-point register set REGSET to register cache
192 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */
195 alpha_linux_supply_fpregset (const struct regset *regset,
196 struct regcache *regcache,
197 int regnum, const void *fpregs, size_t len)
199 const gdb_byte *regs = fpregs;
201 gdb_assert (len >= 32 * 8);
202 alpha_supply_fp_regs (regcache, regnum, regs, regs + 31 * 8);
205 /* Collect register REGNUM from the register cache REGCACHE and store
206 it in the buffer specified by FPREGS and LEN as described by the
207 general-purpose register set REGSET. If REGNUM is -1, do this for
208 all registers in REGSET. */
211 alpha_linux_collect_fpregset (const struct regset *regset,
212 const struct regcache *regcache,
213 int regnum, void *fpregs, size_t len)
215 gdb_byte *regs = fpregs;
217 gdb_assert (len >= 32 * 8);
218 alpha_fill_fp_regs (regcache, regnum, regs, regs + 31 * 8);
221 static const struct regset alpha_linux_gregset =
224 alpha_linux_supply_gregset, alpha_linux_collect_gregset
227 static const struct regset alpha_linux_fpregset =
230 alpha_linux_supply_fpregset, alpha_linux_collect_fpregset
233 /* Return the appropriate register set for the core section identified
234 by SECT_NAME and SECT_SIZE. */
236 static const struct regset *
237 alpha_linux_regset_from_core_section (struct gdbarch *gdbarch,
238 const char *sect_name, size_t sect_size)
240 if (strcmp (sect_name, ".reg") == 0 && sect_size >= 32 * 8)
241 return &alpha_linux_gregset;
243 if (strcmp (sect_name, ".reg2") == 0 && sect_size >= 32 * 8)
244 return &alpha_linux_fpregset;
249 /* Implementation of `gdbarch_gdb_signal_from_target', as defined in
252 static enum gdb_signal
253 alpha_linux_gdb_signal_from_target (struct gdbarch *gdbarch,
258 case ALPHA_LINUX_SIGEMT:
259 return GDB_SIGNAL_EMT;
261 case ALPHA_LINUX_SIGBUS:
262 return GDB_SIGNAL_BUS;
264 case ALPHA_LINUX_SIGSYS:
265 return GDB_SIGNAL_SYS;
267 case ALPHA_LINUX_SIGURG:
268 return GDB_SIGNAL_URG;
270 case ALPHA_LINUX_SIGSTOP:
271 return GDB_SIGNAL_STOP;
273 case ALPHA_LINUX_SIGTSTP:
274 return GDB_SIGNAL_TSTP;
276 case ALPHA_LINUX_SIGCONT:
277 return GDB_SIGNAL_CONT;
279 case ALPHA_LINUX_SIGCHLD:
280 return GDB_SIGNAL_CHLD;
282 /* No way to differentiate between SIGIO and SIGPOLL.
283 Therefore, we just handle the first one. */
284 case ALPHA_LINUX_SIGIO:
285 return GDB_SIGNAL_IO;
287 /* No way to differentiate between SIGINFO and SIGPWR.
288 Therefore, we just handle the first one. */
289 case ALPHA_LINUX_SIGINFO:
290 return GDB_SIGNAL_INFO;
292 case ALPHA_LINUX_SIGUSR1:
293 return GDB_SIGNAL_USR1;
295 case ALPHA_LINUX_SIGUSR2:
296 return GDB_SIGNAL_USR2;
299 return linux_gdb_signal_from_target (gdbarch, signal);
302 /* Implementation of `gdbarch_gdb_signal_to_target', as defined in
306 alpha_linux_gdb_signal_to_target (struct gdbarch *gdbarch,
307 enum gdb_signal signal)
312 return ALPHA_LINUX_SIGEMT;
315 return ALPHA_LINUX_SIGBUS;
318 return ALPHA_LINUX_SIGSYS;
321 return ALPHA_LINUX_SIGURG;
323 case GDB_SIGNAL_STOP:
324 return ALPHA_LINUX_SIGSTOP;
326 case GDB_SIGNAL_TSTP:
327 return ALPHA_LINUX_SIGTSTP;
329 case GDB_SIGNAL_CONT:
330 return ALPHA_LINUX_SIGCONT;
332 case GDB_SIGNAL_CHLD:
333 return ALPHA_LINUX_SIGCHLD;
336 return ALPHA_LINUX_SIGIO;
338 case GDB_SIGNAL_INFO:
339 return ALPHA_LINUX_SIGINFO;
341 case GDB_SIGNAL_USR1:
342 return ALPHA_LINUX_SIGUSR1;
344 case GDB_SIGNAL_USR2:
345 return ALPHA_LINUX_SIGUSR2;
347 case GDB_SIGNAL_POLL:
348 return ALPHA_LINUX_SIGPOLL;
351 return ALPHA_LINUX_SIGPWR;
354 return linux_gdb_signal_to_target (gdbarch, signal);
358 alpha_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
360 struct gdbarch_tdep *tdep;
362 linux_init_abi (info, gdbarch);
364 /* Hook into the DWARF CFI frame unwinder. */
365 alpha_dwarf2_init_abi (info, gdbarch);
367 /* Hook into the MDEBUG frame unwinder. */
368 alpha_mdebug_init_abi (info, gdbarch);
370 tdep = gdbarch_tdep (gdbarch);
371 tdep->dynamic_sigtramp_offset = alpha_linux_sigtramp_offset;
372 tdep->sigcontext_addr = alpha_linux_sigcontext_addr;
373 tdep->pc_in_sigtramp = alpha_linux_pc_in_sigtramp;
375 tdep->jb_elt_size = 8;
377 set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
379 set_solib_svr4_fetch_link_map_offsets
380 (gdbarch, svr4_lp64_fetch_link_map_offsets);
382 /* Enable TLS support. */
383 set_gdbarch_fetch_tls_load_module_address (gdbarch,
384 svr4_fetch_objfile_link_map);
386 set_gdbarch_regset_from_core_section
387 (gdbarch, alpha_linux_regset_from_core_section);
389 set_gdbarch_gdb_signal_from_target (gdbarch,
390 alpha_linux_gdb_signal_from_target);
391 set_gdbarch_gdb_signal_to_target (gdbarch,
392 alpha_linux_gdb_signal_to_target);
395 /* Provide a prototype to silence -Wmissing-prototypes. */
396 extern initialize_file_ftype _initialize_alpha_linux_tdep;
399 _initialize_alpha_linux_tdep (void)
401 gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_LINUX,
402 alpha_linux_init_abi);