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