Commit | Line | Data |
---|---|---|
9cbc6ef0 | 1 | /* Target-dependent code for GNU/Linux running on PA-RISC, for GDB. |
50306a9d | 2 | |
0fb0cc75 | 3 | Copyright (C) 2004, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. |
50306a9d | 4 | |
c0f96416 | 5 | This file is part of GDB. |
50306a9d | 6 | |
c0f96416 MK |
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 | |
a9762ec7 | 9 | the Free Software Foundation; either version 3 of the License, or |
c0f96416 | 10 | (at your option) any later version. |
50306a9d | 11 | |
c0f96416 MK |
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. | |
50306a9d | 16 | |
c0f96416 | 17 | You should have received a copy of the GNU General Public License |
a9762ec7 | 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
50306a9d RC |
19 | |
20 | #include "defs.h" | |
21 | #include "gdbcore.h" | |
22 | #include "osabi.h" | |
23 | #include "target.h" | |
24 | #include "objfiles.h" | |
25 | #include "solib-svr4.h" | |
26 | #include "glibc-tdep.h" | |
27 | #include "frame-unwind.h" | |
28 | #include "trad-frame.h" | |
29 | #include "dwarf2-frame.h" | |
d49771ef | 30 | #include "value.h" |
3d8dcac6 | 31 | #include "regset.h" |
e7b17823 | 32 | #include "regcache.h" |
50306a9d RC |
33 | #include "hppa-tdep.h" |
34 | ||
d49771ef RC |
35 | #include "elf/common.h" |
36 | ||
85c83e99 | 37 | /* Map DWARF DBX register numbers to GDB register numbers. */ |
50306a9d | 38 | static int |
85c83e99 | 39 | hppa_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg) |
50306a9d | 40 | { |
85c83e99 DA |
41 | /* The general registers and the sar are the same in both sets. */ |
42 | if (reg <= 32) | |
50306a9d RC |
43 | return reg; |
44 | ||
85c83e99 DA |
45 | /* fr4-fr31 (left and right halves) are mapped from 72. */ |
46 | if (reg >= 72 && reg <= 72 + 28 * 2) | |
47 | return HPPA_FP4_REGNUM + (reg - 72); | |
50306a9d | 48 | |
85c83e99 | 49 | warning (_("Unmapped DWARF DBX Register #%d encountered."), reg); |
50306a9d RC |
50 | return -1; |
51 | } | |
50306a9d RC |
52 | |
53 | static void | |
61a1198a | 54 | hppa_linux_target_write_pc (struct regcache *regcache, CORE_ADDR v) |
50306a9d RC |
55 | { |
56 | /* Probably this should be done by the kernel, but it isn't. */ | |
61a1198a UW |
57 | regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, v | 0x3); |
58 | regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3); | |
50306a9d RC |
59 | } |
60 | ||
61 | /* An instruction to match. */ | |
62 | struct insn_pattern | |
63 | { | |
64 | unsigned int data; /* See if it matches this.... */ | |
65 | unsigned int mask; /* ... with this mask. */ | |
66 | }; | |
67 | ||
50306a9d RC |
68 | static struct insn_pattern hppa_sigtramp[] = { |
69 | /* ldi 0, %r25 or ldi 1, %r25 */ | |
70 | { 0x34190000, 0xfffffffd }, | |
71 | /* ldi __NR_rt_sigreturn, %r20 */ | |
72 | { 0x3414015a, 0xffffffff }, | |
73 | /* be,l 0x100(%sr2, %r0), %sr0, %r31 */ | |
74 | { 0xe4008200, 0xffffffff }, | |
75 | /* nop */ | |
76 | { 0x08000240, 0xffffffff }, | |
77 | { 0, 0 } | |
78 | }; | |
79 | ||
80 | #define HPPA_MAX_INSN_PATTERN_LEN (4) | |
81 | ||
82 | /* Return non-zero if the instructions at PC match the series | |
83 | described in PATTERN, or zero otherwise. PATTERN is an array of | |
84 | 'struct insn_pattern' objects, terminated by an entry whose mask is | |
85 | zero. | |
86 | ||
87 | When the match is successful, fill INSN[i] with what PATTERN[i] | |
88 | matched. */ | |
89 | static int | |
e17a4113 | 90 | insns_match_pattern (struct gdbarch *gdbarch, CORE_ADDR pc, |
50306a9d RC |
91 | struct insn_pattern *pattern, |
92 | unsigned int *insn) | |
93 | { | |
e17a4113 | 94 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); |
50306a9d RC |
95 | int i; |
96 | CORE_ADDR npc = pc; | |
97 | ||
98 | for (i = 0; pattern[i].mask; i++) | |
99 | { | |
f4ca1d1f RC |
100 | char buf[4]; |
101 | ||
8defab1a | 102 | target_read_memory (npc, buf, 4); |
e17a4113 | 103 | insn[i] = extract_unsigned_integer (buf, 4, byte_order); |
50306a9d RC |
104 | if ((insn[i] & pattern[i].mask) == pattern[i].data) |
105 | npc += 4; | |
106 | else | |
107 | return 0; | |
108 | } | |
109 | return 1; | |
110 | } | |
111 | ||
50306a9d RC |
112 | /* Signal frames. */ |
113 | ||
114 | /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.) | |
115 | ||
116 | Unfortunately, because of various bugs and changes to the kernel, | |
117 | we have several cases to deal with. | |
118 | ||
119 | In 2.4, the signal trampoline is 4 bytes, and pc should point directly at | |
120 | the beginning of the trampoline and struct rt_sigframe. | |
121 | ||
122 | In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at | |
123 | the 4th word in the trampoline structure. This is wrong, it should point | |
124 | at the 5th word. This is fixed in 2.6.5-rc2-pa4. | |
125 | ||
126 | To detect these cases, we first take pc, align it to 64-bytes | |
127 | to get the beginning of the signal frame, and then check offsets 0, 4 | |
128 | and 5 to see if we found the beginning of the trampoline. This will | |
129 | tell us how to locate the sigcontext structure. | |
130 | ||
131 | Note that with a 2.4 64-bit kernel, the signal context is not properly | |
132 | passed back to userspace so the unwind will not work correctly. */ | |
133 | static CORE_ADDR | |
e17a4113 | 134 | hppa_linux_sigtramp_find_sigcontext (struct gdbarch *gdbarch, CORE_ADDR pc) |
50306a9d RC |
135 | { |
136 | unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN]; | |
137 | int offs = 0; | |
138 | int try; | |
139 | /* offsets to try to find the trampoline */ | |
140 | static int pcoffs[] = { 0, 4*4, 5*4 }; | |
141 | /* offsets to the rt_sigframe structure */ | |
142 | static int sfoffs[] = { 4*4, 10*4, 10*4 }; | |
2f0e8c7a RC |
143 | CORE_ADDR sp; |
144 | ||
145 | /* Most of the time, this will be correct. The one case when this will | |
146 | fail is if the user defined an alternate stack, in which case the | |
147 | beginning of the stack will not be align_down (pc, 64). */ | |
148 | sp = align_down (pc, 64); | |
50306a9d RC |
149 | |
150 | /* rt_sigreturn trampoline: | |
151 | 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2) | |
152 | 3414015a ldi __NR_rt_sigreturn, %r20 | |
153 | e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31 | |
154 | 08000240 nop */ | |
155 | ||
156 | for (try = 0; try < ARRAY_SIZE (pcoffs); try++) | |
157 | { | |
e17a4113 UW |
158 | if (insns_match_pattern (gdbarch, sp + pcoffs[try], |
159 | hppa_sigtramp, dummy)) | |
50306a9d RC |
160 | { |
161 | offs = sfoffs[try]; | |
162 | break; | |
163 | } | |
164 | } | |
165 | ||
166 | if (offs == 0) | |
2f0e8c7a | 167 | { |
e17a4113 | 168 | if (insns_match_pattern (gdbarch, pc, hppa_sigtramp, dummy)) |
2f0e8c7a RC |
169 | { |
170 | /* sigaltstack case: we have no way of knowing which offset to | |
171 | use in this case; default to new kernel handling. If this is | |
172 | wrong the unwinding will fail. */ | |
173 | try = 2; | |
174 | sp = pc - pcoffs[try]; | |
175 | } | |
176 | else | |
177 | { | |
178 | return 0; | |
179 | } | |
180 | } | |
50306a9d RC |
181 | |
182 | /* sp + sfoffs[try] points to a struct rt_sigframe, which contains | |
183 | a struct siginfo and a struct ucontext. struct ucontext contains | |
184 | a struct sigcontext. Return an offset to this sigcontext here. Too | |
185 | bad we cannot include system specific headers :-(. | |
186 | sizeof(struct siginfo) == 128 | |
187 | offsetof(struct ucontext, uc_mcontext) == 24. */ | |
188 | return sp + sfoffs[try] + 128 + 24; | |
189 | } | |
190 | ||
191 | struct hppa_linux_sigtramp_unwind_cache | |
192 | { | |
193 | CORE_ADDR base; | |
194 | struct trad_frame_saved_reg *saved_regs; | |
195 | }; | |
196 | ||
197 | static struct hppa_linux_sigtramp_unwind_cache * | |
94afd7a6 | 198 | hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *this_frame, |
50306a9d RC |
199 | void **this_cache) |
200 | { | |
94afd7a6 | 201 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
50306a9d | 202 | struct hppa_linux_sigtramp_unwind_cache *info; |
2f0e8c7a | 203 | CORE_ADDR pc, scptr; |
50306a9d RC |
204 | int i; |
205 | ||
206 | if (*this_cache) | |
207 | return *this_cache; | |
208 | ||
209 | info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache); | |
210 | *this_cache = info; | |
94afd7a6 | 211 | info->saved_regs = trad_frame_alloc_saved_regs (this_frame); |
50306a9d | 212 | |
94afd7a6 | 213 | pc = get_frame_pc (this_frame); |
e17a4113 | 214 | scptr = hppa_linux_sigtramp_find_sigcontext (gdbarch, pc); |
50306a9d RC |
215 | |
216 | /* structure of struct sigcontext: | |
217 | ||
218 | struct sigcontext { | |
219 | unsigned long sc_flags; | |
220 | unsigned long sc_gr[32]; | |
221 | unsigned long long sc_fr[32]; | |
222 | unsigned long sc_iasq[2]; | |
223 | unsigned long sc_iaoq[2]; | |
224 | unsigned long sc_sar; */ | |
225 | ||
226 | /* Skip sc_flags. */ | |
227 | scptr += 4; | |
228 | ||
326e541f DA |
229 | /* GR[0] is the psw. */ |
230 | info->saved_regs[HPPA_IPSW_REGNUM].addr = scptr; | |
50306a9d RC |
231 | scptr += 4; |
232 | ||
233 | /* General registers. */ | |
234 | for (i = 1; i < 32; i++) | |
235 | { | |
34f75cc1 | 236 | info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr; |
50306a9d RC |
237 | scptr += 4; |
238 | } | |
239 | ||
326e541f | 240 | /* Pad to long long boundary. */ |
50306a9d RC |
241 | scptr += 4; |
242 | ||
243 | /* FP regs; FP0-3 are not restored. */ | |
244 | scptr += (8 * 4); | |
245 | ||
246 | for (i = 4; i < 32; i++) | |
247 | { | |
248 | info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr; | |
249 | scptr += 4; | |
250 | info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr; | |
251 | scptr += 4; | |
252 | } | |
253 | ||
254 | /* IASQ/IAOQ. */ | |
34f75cc1 | 255 | info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr; |
50306a9d | 256 | scptr += 4; |
34f75cc1 | 257 | info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr; |
50306a9d RC |
258 | scptr += 4; |
259 | ||
34f75cc1 | 260 | info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr; |
50306a9d | 261 | scptr += 4; |
34f75cc1 | 262 | info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr; |
50306a9d RC |
263 | scptr += 4; |
264 | ||
326e541f DA |
265 | info->saved_regs[HPPA_SAR_REGNUM].addr = scptr; |
266 | ||
94afd7a6 | 267 | info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM); |
50306a9d RC |
268 | |
269 | return info; | |
270 | } | |
271 | ||
272 | static void | |
94afd7a6 | 273 | hppa_linux_sigtramp_frame_this_id (struct frame_info *this_frame, |
50306a9d RC |
274 | void **this_prologue_cache, |
275 | struct frame_id *this_id) | |
276 | { | |
277 | struct hppa_linux_sigtramp_unwind_cache *info | |
94afd7a6 UW |
278 | = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache); |
279 | *this_id = frame_id_build (info->base, get_frame_pc (this_frame)); | |
50306a9d RC |
280 | } |
281 | ||
94afd7a6 UW |
282 | static struct value * |
283 | hppa_linux_sigtramp_frame_prev_register (struct frame_info *this_frame, | |
50306a9d | 284 | void **this_prologue_cache, |
94afd7a6 | 285 | int regnum) |
50306a9d RC |
286 | { |
287 | struct hppa_linux_sigtramp_unwind_cache *info | |
94afd7a6 UW |
288 | = hppa_linux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache); |
289 | return hppa_frame_prev_register_helper (this_frame, | |
290 | info->saved_regs, regnum); | |
50306a9d RC |
291 | } |
292 | ||
50306a9d RC |
293 | /* hppa-linux always uses "new-style" rt-signals. The signal handler's return |
294 | address should point to a signal trampoline on the stack. The signal | |
295 | trampoline is embedded in a rt_sigframe structure that is aligned on | |
296 | the stack. We take advantage of the fact that sp must be 64-byte aligned, | |
297 | and the trampoline is small, so by rounding down the trampoline address | |
298 | we can find the beginning of the struct rt_sigframe. */ | |
94afd7a6 UW |
299 | static int |
300 | hppa_linux_sigtramp_frame_sniffer (const struct frame_unwind *self, | |
301 | struct frame_info *this_frame, | |
302 | void **this_prologue_cache) | |
50306a9d | 303 | { |
e17a4113 | 304 | struct gdbarch *gdbarch = get_frame_arch (this_frame); |
94afd7a6 | 305 | CORE_ADDR pc = get_frame_pc (this_frame); |
50306a9d | 306 | |
e17a4113 | 307 | if (hppa_linux_sigtramp_find_sigcontext (gdbarch, pc)) |
94afd7a6 | 308 | return 1; |
50306a9d | 309 | |
94afd7a6 | 310 | return 0; |
50306a9d RC |
311 | } |
312 | ||
94afd7a6 UW |
313 | static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = { |
314 | SIGTRAMP_FRAME, | |
315 | hppa_linux_sigtramp_frame_this_id, | |
316 | hppa_linux_sigtramp_frame_prev_register, | |
317 | NULL, | |
318 | hppa_linux_sigtramp_frame_sniffer | |
319 | }; | |
320 | ||
d49771ef RC |
321 | /* Attempt to find (and return) the global pointer for the given |
322 | function. | |
323 | ||
324 | This is a rather nasty bit of code searchs for the .dynamic section | |
325 | in the objfile corresponding to the pc of the function we're trying | |
326 | to call. Once it finds the addresses at which the .dynamic section | |
327 | lives in the child process, it scans the Elf32_Dyn entries for a | |
328 | DT_PLTGOT tag. If it finds one of these, the corresponding | |
329 | d_un.d_ptr value is the global pointer. */ | |
330 | ||
331 | static CORE_ADDR | |
e38c262f | 332 | hppa_linux_find_global_pointer (struct gdbarch *gdbarch, struct value *function) |
d49771ef | 333 | { |
e17a4113 | 334 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); |
d49771ef RC |
335 | struct obj_section *faddr_sect; |
336 | CORE_ADDR faddr; | |
337 | ||
338 | faddr = value_as_address (function); | |
339 | ||
340 | /* Is this a plabel? If so, dereference it to get the gp value. */ | |
341 | if (faddr & 2) | |
342 | { | |
343 | int status; | |
344 | char buf[4]; | |
345 | ||
346 | faddr &= ~3; | |
347 | ||
348 | status = target_read_memory (faddr + 4, buf, sizeof (buf)); | |
349 | if (status == 0) | |
e17a4113 | 350 | return extract_unsigned_integer (buf, sizeof (buf), byte_order); |
d49771ef RC |
351 | } |
352 | ||
353 | /* If the address is in the plt section, then the real function hasn't | |
354 | yet been fixed up by the linker so we cannot determine the gp of | |
355 | that function. */ | |
356 | if (in_plt_section (faddr, NULL)) | |
357 | return 0; | |
358 | ||
359 | faddr_sect = find_pc_section (faddr); | |
360 | if (faddr_sect != NULL) | |
361 | { | |
362 | struct obj_section *osect; | |
363 | ||
364 | ALL_OBJFILE_OSECTIONS (faddr_sect->objfile, osect) | |
365 | { | |
366 | if (strcmp (osect->the_bfd_section->name, ".dynamic") == 0) | |
367 | break; | |
368 | } | |
369 | ||
370 | if (osect < faddr_sect->objfile->sections_end) | |
371 | { | |
aded6f54 | 372 | CORE_ADDR addr, endaddr; |
d49771ef | 373 | |
aded6f54 PA |
374 | addr = obj_section_addr (osect); |
375 | endaddr = obj_section_endaddr (osect); | |
376 | ||
377 | while (addr < endaddr) | |
d49771ef RC |
378 | { |
379 | int status; | |
380 | LONGEST tag; | |
381 | char buf[4]; | |
382 | ||
383 | status = target_read_memory (addr, buf, sizeof (buf)); | |
384 | if (status != 0) | |
385 | break; | |
e17a4113 | 386 | tag = extract_signed_integer (buf, sizeof (buf), byte_order); |
d49771ef RC |
387 | |
388 | if (tag == DT_PLTGOT) | |
389 | { | |
390 | CORE_ADDR global_pointer; | |
391 | ||
392 | status = target_read_memory (addr + 4, buf, sizeof (buf)); | |
393 | if (status != 0) | |
394 | break; | |
e17a4113 UW |
395 | global_pointer = extract_unsigned_integer (buf, sizeof (buf), |
396 | byte_order); | |
d49771ef RC |
397 | /* The payoff... */ |
398 | return global_pointer; | |
399 | } | |
400 | ||
401 | if (tag == DT_NULL) | |
402 | break; | |
403 | ||
404 | addr += 8; | |
405 | } | |
406 | } | |
407 | } | |
408 | return 0; | |
409 | } | |
3d8dcac6 RC |
410 | \f |
411 | /* | |
412 | * Registers saved in a coredump: | |
413 | * gr0..gr31 | |
414 | * sr0..sr7 | |
415 | * iaoq0..iaoq1 | |
416 | * iasq0..iasq1 | |
417 | * sar, iir, isr, ior, ipsw | |
418 | * cr0, cr24..cr31 | |
419 | * cr8,9,12,13 | |
420 | * cr10, cr15 | |
421 | */ | |
422 | ||
423 | #define GR_REGNUM(_n) (HPPA_R0_REGNUM+_n) | |
424 | #define TR_REGNUM(_n) (HPPA_TR0_REGNUM+_n) | |
425 | static const int greg_map[] = | |
426 | { | |
427 | GR_REGNUM(0), GR_REGNUM(1), GR_REGNUM(2), GR_REGNUM(3), | |
428 | GR_REGNUM(4), GR_REGNUM(5), GR_REGNUM(6), GR_REGNUM(7), | |
429 | GR_REGNUM(8), GR_REGNUM(9), GR_REGNUM(10), GR_REGNUM(11), | |
430 | GR_REGNUM(12), GR_REGNUM(13), GR_REGNUM(14), GR_REGNUM(15), | |
431 | GR_REGNUM(16), GR_REGNUM(17), GR_REGNUM(18), GR_REGNUM(19), | |
432 | GR_REGNUM(20), GR_REGNUM(21), GR_REGNUM(22), GR_REGNUM(23), | |
433 | GR_REGNUM(24), GR_REGNUM(25), GR_REGNUM(26), GR_REGNUM(27), | |
434 | GR_REGNUM(28), GR_REGNUM(29), GR_REGNUM(30), GR_REGNUM(31), | |
435 | ||
436 | HPPA_SR4_REGNUM+1, HPPA_SR4_REGNUM+2, HPPA_SR4_REGNUM+3, HPPA_SR4_REGNUM+4, | |
437 | HPPA_SR4_REGNUM, HPPA_SR4_REGNUM+5, HPPA_SR4_REGNUM+6, HPPA_SR4_REGNUM+7, | |
438 | ||
439 | HPPA_PCOQ_HEAD_REGNUM, HPPA_PCOQ_TAIL_REGNUM, | |
440 | HPPA_PCSQ_HEAD_REGNUM, HPPA_PCSQ_TAIL_REGNUM, | |
441 | ||
442 | HPPA_SAR_REGNUM, HPPA_IIR_REGNUM, HPPA_ISR_REGNUM, HPPA_IOR_REGNUM, | |
443 | HPPA_IPSW_REGNUM, HPPA_RCR_REGNUM, | |
444 | ||
445 | TR_REGNUM(0), TR_REGNUM(1), TR_REGNUM(2), TR_REGNUM(3), | |
446 | TR_REGNUM(4), TR_REGNUM(5), TR_REGNUM(6), TR_REGNUM(7), | |
447 | ||
448 | HPPA_PID0_REGNUM, HPPA_PID1_REGNUM, HPPA_PID2_REGNUM, HPPA_PID3_REGNUM, | |
449 | HPPA_CCR_REGNUM, HPPA_EIEM_REGNUM, | |
450 | }; | |
451 | ||
452 | static void | |
453 | hppa_linux_supply_regset (const struct regset *regset, | |
454 | struct regcache *regcache, | |
455 | int regnum, const void *regs, size_t len) | |
456 | { | |
457 | struct gdbarch *arch = get_regcache_arch (regcache); | |
458 | struct gdbarch_tdep *tdep = gdbarch_tdep (arch); | |
459 | const char *buf = regs; | |
460 | int i, offset; | |
461 | ||
462 | offset = 0; | |
463 | for (i = 0; i < ARRAY_SIZE (greg_map); i++) | |
464 | { | |
465 | if (regnum == greg_map[i] || regnum == -1) | |
466 | regcache_raw_supply (regcache, greg_map[i], buf + offset); | |
467 | ||
468 | offset += tdep->bytes_per_address; | |
469 | } | |
470 | } | |
471 | ||
472 | static void | |
473 | hppa_linux_supply_fpregset (const struct regset *regset, | |
474 | struct regcache *regcache, | |
475 | int regnum, const void *regs, size_t len) | |
476 | { | |
477 | const char *buf = regs; | |
478 | int i, offset; | |
479 | ||
480 | offset = 0; | |
51e753cf | 481 | for (i = 0; i < 64; i++) |
3d8dcac6 RC |
482 | { |
483 | if (regnum == HPPA_FP0_REGNUM + i || regnum == -1) | |
484 | regcache_raw_supply (regcache, HPPA_FP0_REGNUM + i, | |
485 | buf + offset); | |
51e753cf | 486 | offset += 4; |
3d8dcac6 RC |
487 | } |
488 | } | |
489 | ||
155bd5d1 | 490 | /* HPPA Linux kernel register set. */ |
3d8dcac6 RC |
491 | static struct regset hppa_linux_regset = |
492 | { | |
493 | NULL, | |
494 | hppa_linux_supply_regset | |
495 | }; | |
496 | ||
497 | static struct regset hppa_linux_fpregset = | |
498 | { | |
499 | NULL, | |
500 | hppa_linux_supply_fpregset | |
501 | }; | |
502 | ||
503 | static const struct regset * | |
504 | hppa_linux_regset_from_core_section (struct gdbarch *gdbarch, | |
505 | const char *sect_name, | |
506 | size_t sect_size) | |
507 | { | |
508 | if (strcmp (sect_name, ".reg") == 0) | |
509 | return &hppa_linux_regset; | |
510 | else if (strcmp (sect_name, ".reg2") == 0) | |
511 | return &hppa_linux_fpregset; | |
512 | ||
513 | return NULL; | |
514 | } | |
515 | \f | |
d49771ef | 516 | |
50306a9d RC |
517 | /* Forward declarations. */ |
518 | extern initialize_file_ftype _initialize_hppa_linux_tdep; | |
519 | ||
520 | static void | |
521 | hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
522 | { | |
523 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
524 | ||
9cbc6ef0 | 525 | /* GNU/Linux is always ELF. */ |
50306a9d RC |
526 | tdep->is_elf = 1; |
527 | ||
d49771ef RC |
528 | tdep->find_global_pointer = hppa_linux_find_global_pointer; |
529 | ||
50306a9d RC |
530 | set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); |
531 | ||
94afd7a6 | 532 | frame_unwind_append_unwinder (gdbarch, &hppa_linux_sigtramp_frame_unwind); |
50306a9d RC |
533 | |
534 | /* GNU/Linux uses SVR4-style shared libraries. */ | |
535 | set_solib_svr4_fetch_link_map_offsets | |
536 | (gdbarch, svr4_ilp32_fetch_link_map_offsets); | |
537 | ||
34f55018 MK |
538 | tdep->in_solib_call_trampoline = hppa_in_solib_call_trampoline; |
539 | set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code); | |
50306a9d RC |
540 | |
541 | /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ | |
542 | set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); | |
543 | ||
3a7d1c27 RC |
544 | /* On hppa-linux, currently, sizeof(long double) == 8. There has been |
545 | some discussions to support 128-bit long double, but it requires some | |
546 | more work in gcc and glibc first. */ | |
547 | set_gdbarch_long_double_bit (gdbarch, 64); | |
548 | ||
3d8dcac6 RC |
549 | set_gdbarch_regset_from_core_section |
550 | (gdbarch, hppa_linux_regset_from_core_section); | |
551 | ||
50306a9d | 552 | set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); |
b2756930 KB |
553 | |
554 | /* Enable TLS support. */ | |
555 | set_gdbarch_fetch_tls_load_module_address (gdbarch, | |
556 | svr4_fetch_objfile_link_map); | |
50306a9d RC |
557 | } |
558 | ||
559 | void | |
560 | _initialize_hppa_linux_tdep (void) | |
561 | { | |
562 | gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi); | |
3d8dcac6 | 563 | gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_LINUX, hppa_linux_init_abi); |
50306a9d | 564 | } |