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" |
d2427a71 | 21 | #include "gdb_assert.h" |
0e9f083f | 22 | #include <string.h> |
f1a559ae | 23 | #include "osabi.h" |
b2756930 | 24 | #include "solib-svr4.h" |
982e9687 | 25 | #include "symtab.h" |
b02f9d57 UW |
26 | #include "regset.h" |
27 | #include "regcache.h" | |
a5ee0f0c | 28 | #include "linux-tdep.h" |
3379287a JT |
29 | #include "alpha-tdep.h" |
30 | ||
eb14d406 SDJ |
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 | ||
d2427a71 RH |
60 | /* Under GNU/Linux, signal handler invocations can be identified by |
61 | the designated code sequence that is used to return from a signal | |
3379287a | 62 | handler. In particular, the return address of a signal handler |
d2427a71 RH |
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 | |
0963b4bd | 72 | has a different stack layout. */ |
d2427a71 RH |
73 | |
74 | static long | |
e17a4113 | 75 | alpha_linux_sigtramp_offset_1 (struct gdbarch *gdbarch, CORE_ADDR pc) |
3379287a | 76 | { |
e17a4113 | 77 | switch (alpha_read_insn (gdbarch, pc)) |
d2427a71 RH |
78 | { |
79 | case 0x47de0410: /* bis $30,$30,$16 */ | |
80 | case 0x47fe0410: /* bis $31,$30,$16 */ | |
81 | return 0; | |
3379287a | 82 | |
d2427a71 RH |
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; | |
3379287a | 90 | |
3379287a JT |
91 | default: |
92 | return -1; | |
93 | } | |
d2427a71 RH |
94 | } |
95 | ||
96 | static LONGEST | |
e17a4113 | 97 | alpha_linux_sigtramp_offset (struct gdbarch *gdbarch, CORE_ADDR pc) |
d2427a71 RH |
98 | { |
99 | long i, off; | |
100 | ||
101 | if (pc & 3) | |
102 | return -1; | |
103 | ||
104 | /* Guess where we might be in the sequence. */ | |
e17a4113 | 105 | off = alpha_linux_sigtramp_offset_1 (gdbarch, pc); |
d2427a71 RH |
106 | if (off < 0) |
107 | return -1; | |
108 | ||
109 | /* Verify that the other two insns of the sequence are as we expect. */ | |
3379287a | 110 | pc -= off; |
d2427a71 | 111 | for (i = 0; i < 12; i += 4) |
3379287a | 112 | { |
d2427a71 RH |
113 | if (i == off) |
114 | continue; | |
e17a4113 | 115 | if (alpha_linux_sigtramp_offset_1 (gdbarch, pc + i) != i) |
d2427a71 | 116 | return -1; |
3379287a | 117 | } |
3379287a | 118 | |
d2427a71 | 119 | return off; |
3379287a JT |
120 | } |
121 | ||
6c72f9f9 | 122 | static int |
e17a4113 | 123 | alpha_linux_pc_in_sigtramp (struct gdbarch *gdbarch, |
2c02bd72 | 124 | CORE_ADDR pc, const char *func_name) |
6c72f9f9 | 125 | { |
e17a4113 | 126 | return alpha_linux_sigtramp_offset (gdbarch, pc) >= 0; |
6c72f9f9 JT |
127 | } |
128 | ||
5868c862 | 129 | static CORE_ADDR |
94afd7a6 | 130 | alpha_linux_sigcontext_addr (struct frame_info *this_frame) |
5868c862 | 131 | { |
e17a4113 | 132 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
d2427a71 RH |
133 | CORE_ADDR pc; |
134 | ULONGEST sp; | |
135 | long off; | |
136 | ||
94afd7a6 UW |
137 | pc = get_frame_pc (this_frame); |
138 | sp = get_frame_register_unsigned (this_frame, ALPHA_SP_REGNUM); | |
d2427a71 | 139 | |
e17a4113 | 140 | off = alpha_linux_sigtramp_offset (gdbarch, pc); |
d2427a71 RH |
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 | ||
0963b4bd MS |
150 | offsetof (struct rt_sigframe, uc.uc_mcontext); */ |
151 | ||
e17a4113 | 152 | if (alpha_read_insn (gdbarch, pc - off + 4) == 0x201f015f) |
d2427a71 RH |
153 | return sp + 176; |
154 | ||
155 | /* __NR_sigreturn has the sigcontext structure at the top of the stack. */ | |
156 | return sp; | |
5868c862 JT |
157 | } |
158 | ||
b02f9d57 UW |
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) | |
6afb1f32 | 206 | regcache_raw_supply (regcache, ALPHA_FPCR_REGNUM, regs + 31 * 8); |
b02f9d57 UW |
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 | ||
63807e1d | 224 | static const struct regset * |
b02f9d57 UW |
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 | ||
eb14d406 SDJ |
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 | ||
3379287a | 345 | static void |
baa490c4 | 346 | alpha_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) |
3379287a | 347 | { |
d2427a71 RH |
348 | struct gdbarch_tdep *tdep; |
349 | ||
a5ee0f0c PA |
350 | linux_init_abi (info, gdbarch); |
351 | ||
f1a559ae | 352 | /* Hook into the DWARF CFI frame unwinder. */ |
baa490c4 | 353 | alpha_dwarf2_init_abi (info, gdbarch); |
f1a559ae RH |
354 | |
355 | /* Hook into the MDEBUG frame unwinder. */ | |
d2427a71 | 356 | alpha_mdebug_init_abi (info, gdbarch); |
36a6271d | 357 | |
d2427a71 | 358 | tdep = gdbarch_tdep (gdbarch); |
36a6271d | 359 | tdep->dynamic_sigtramp_offset = alpha_linux_sigtramp_offset; |
5868c862 | 360 | tdep->sigcontext_addr = alpha_linux_sigcontext_addr; |
f2524b93 | 361 | tdep->pc_in_sigtramp = alpha_linux_pc_in_sigtramp; |
accc6d1f JT |
362 | tdep->jb_pc = 2; |
363 | tdep->jb_elt_size = 8; | |
b2756930 | 364 | |
982e9687 UW |
365 | set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); |
366 | ||
8d005789 UW |
367 | set_solib_svr4_fetch_link_map_offsets |
368 | (gdbarch, svr4_lp64_fetch_link_map_offsets); | |
369 | ||
b2756930 KB |
370 | /* Enable TLS support. */ |
371 | set_gdbarch_fetch_tls_load_module_address (gdbarch, | |
372 | svr4_fetch_objfile_link_map); | |
b02f9d57 UW |
373 | |
374 | set_gdbarch_regset_from_core_section | |
375 | (gdbarch, alpha_linux_regset_from_core_section); | |
eb14d406 SDJ |
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); | |
3379287a JT |
381 | } |
382 | ||
63807e1d PA |
383 | /* Provide a prototype to silence -Wmissing-prototypes. */ |
384 | extern initialize_file_ftype _initialize_alpha_linux_tdep; | |
385 | ||
3379287a JT |
386 | void |
387 | _initialize_alpha_linux_tdep (void) | |
388 | { | |
05816f70 | 389 | gdbarch_register_osabi (bfd_arch_alpha, 0, GDB_OSABI_LINUX, |
70f80edf | 390 | alpha_linux_init_abi); |
3379287a | 391 | } |