Commit | Line | Data |
---|---|---|
50306a9d RC |
1 | /* Target-dependent code for Linux running on PA-RISC, for GDB. |
2 | ||
3 | Copyright 2004 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
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 | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
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. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
19 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | #include "defs.h" | |
22 | #include "gdbcore.h" | |
23 | #include "osabi.h" | |
24 | #include "target.h" | |
25 | #include "objfiles.h" | |
26 | #include "solib-svr4.h" | |
27 | #include "glibc-tdep.h" | |
28 | #include "frame-unwind.h" | |
29 | #include "trad-frame.h" | |
30 | #include "dwarf2-frame.h" | |
31 | #include "hppa-tdep.h" | |
32 | ||
33 | #if 0 | |
34 | /* Convert DWARF register number REG to the appropriate register | |
35 | number used by GDB. */ | |
36 | static int | |
37 | hppa_dwarf_reg_to_regnum (int reg) | |
38 | { | |
39 | /* registers 0 - 31 are the same in both sets */ | |
40 | if (reg < 32) | |
41 | return reg; | |
42 | ||
43 | /* dwarf regs 32 to 85 are fpregs 4 - 31 */ | |
44 | if (reg >= 32 && reg <= 85) | |
34f75cc1 | 45 | return HPPA_FP4_REGNUM + (reg - 32); |
50306a9d RC |
46 | |
47 | warning ("Unmapped DWARF Register #%d encountered\n", reg); | |
48 | return -1; | |
49 | } | |
50 | #endif | |
51 | ||
52 | static void | |
53 | hppa_linux_target_write_pc (CORE_ADDR v, ptid_t ptid) | |
54 | { | |
55 | /* Probably this should be done by the kernel, but it isn't. */ | |
34f75cc1 RC |
56 | write_register_pid (HPPA_PCOQ_HEAD_REGNUM, v | 0x3, ptid); |
57 | write_register_pid (HPPA_PCOQ_TAIL_REGNUM, (v + 4) | 0x3, ptid); | |
50306a9d RC |
58 | } |
59 | ||
60 | /* An instruction to match. */ | |
61 | struct insn_pattern | |
62 | { | |
63 | unsigned int data; /* See if it matches this.... */ | |
64 | unsigned int mask; /* ... with this mask. */ | |
65 | }; | |
66 | ||
67 | /* See bfd/elf32-hppa.c */ | |
68 | static struct insn_pattern hppa_long_branch_stub[] = { | |
69 | /* ldil LR'xxx,%r1 */ | |
70 | { 0x20200000, 0xffe00000 }, | |
71 | /* be,n RR'xxx(%sr4,%r1) */ | |
72 | { 0xe0202002, 0xffe02002 }, | |
73 | { 0, 0 } | |
74 | }; | |
75 | ||
76 | static struct insn_pattern hppa_long_branch_pic_stub[] = { | |
77 | /* b,l .+8, %r1 */ | |
78 | { 0xe8200000, 0xffe00000 }, | |
79 | /* addil LR'xxx - ($PIC_pcrel$0 - 4), %r1 */ | |
80 | { 0x28200000, 0xffe00000 }, | |
81 | /* be,n RR'xxxx - ($PIC_pcrel$0 - 8)(%sr4, %r1) */ | |
82 | { 0xe0202002, 0xffe02002 }, | |
83 | { 0, 0 } | |
84 | }; | |
85 | ||
86 | static struct insn_pattern hppa_import_stub[] = { | |
87 | /* addil LR'xxx, %dp */ | |
88 | { 0x2b600000, 0xffe00000 }, | |
89 | /* ldw RR'xxx(%r1), %r21 */ | |
90 | { 0x48350000, 0xffffb000 }, | |
91 | /* bv %r0(%r21) */ | |
92 | { 0xeaa0c000, 0xffffffff }, | |
93 | /* ldw RR'xxx+4(%r1), %r19 */ | |
94 | { 0x48330000, 0xffffb000 }, | |
95 | { 0, 0 } | |
96 | }; | |
97 | ||
98 | static struct insn_pattern hppa_import_pic_stub[] = { | |
99 | /* addil LR'xxx,%r19 */ | |
100 | { 0x2a600000, 0xffe00000 }, | |
101 | /* ldw RR'xxx(%r1),%r21 */ | |
102 | { 0x48350000, 0xffffb000 }, | |
103 | /* bv %r0(%r21) */ | |
104 | { 0xeaa0c000, 0xffffffff }, | |
105 | /* ldw RR'xxx+4(%r1),%r19 */ | |
106 | { 0x48330000, 0xffffb000 }, | |
107 | { 0, 0 }, | |
108 | }; | |
109 | ||
110 | static struct insn_pattern hppa_plt_stub[] = { | |
111 | /* b,l 1b, %r20 - 1b is 3 insns before here */ | |
112 | { 0xea9f1fdd, 0xffffffff }, | |
113 | /* depi 0,31,2,%r20 */ | |
114 | { 0xd6801c1e, 0xffffffff }, | |
115 | { 0, 0 } | |
116 | }; | |
117 | ||
118 | static struct insn_pattern hppa_sigtramp[] = { | |
119 | /* ldi 0, %r25 or ldi 1, %r25 */ | |
120 | { 0x34190000, 0xfffffffd }, | |
121 | /* ldi __NR_rt_sigreturn, %r20 */ | |
122 | { 0x3414015a, 0xffffffff }, | |
123 | /* be,l 0x100(%sr2, %r0), %sr0, %r31 */ | |
124 | { 0xe4008200, 0xffffffff }, | |
125 | /* nop */ | |
126 | { 0x08000240, 0xffffffff }, | |
127 | { 0, 0 } | |
128 | }; | |
129 | ||
130 | #define HPPA_MAX_INSN_PATTERN_LEN (4) | |
131 | ||
132 | /* Return non-zero if the instructions at PC match the series | |
133 | described in PATTERN, or zero otherwise. PATTERN is an array of | |
134 | 'struct insn_pattern' objects, terminated by an entry whose mask is | |
135 | zero. | |
136 | ||
137 | When the match is successful, fill INSN[i] with what PATTERN[i] | |
138 | matched. */ | |
139 | static int | |
140 | insns_match_pattern (CORE_ADDR pc, | |
141 | struct insn_pattern *pattern, | |
142 | unsigned int *insn) | |
143 | { | |
144 | int i; | |
145 | CORE_ADDR npc = pc; | |
146 | ||
147 | for (i = 0; pattern[i].mask; i++) | |
148 | { | |
f4ca1d1f RC |
149 | char buf[4]; |
150 | ||
151 | read_memory_nobpt (npc, buf, 4); | |
152 | insn[i] = extract_unsigned_integer (buf, 4); | |
50306a9d RC |
153 | if ((insn[i] & pattern[i].mask) == pattern[i].data) |
154 | npc += 4; | |
155 | else | |
156 | return 0; | |
157 | } | |
158 | return 1; | |
159 | } | |
160 | ||
161 | static int | |
162 | hppa_linux_in_dyncall (CORE_ADDR pc) | |
163 | { | |
164 | static CORE_ADDR dyncall = 0; | |
165 | ||
166 | /* FIXME: if we switch exec files, dyncall should be reinitialized */ | |
167 | if (!dyncall) | |
168 | { | |
169 | struct minimal_symbol *minsym; | |
170 | ||
171 | minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); | |
172 | if (minsym) | |
173 | dyncall = SYMBOL_VALUE_ADDRESS (minsym); | |
174 | else | |
175 | dyncall = -1; | |
176 | } | |
177 | ||
178 | return pc == dyncall; | |
179 | } | |
180 | ||
181 | /* There are several kinds of "trampolines" that we need to deal with: | |
182 | - long branch stubs: these are inserted by the linker when a branch | |
183 | target is too far away for a branch insn to reach | |
184 | - plt stubs: these should go into the .plt section, so are easy to find | |
185 | - import stubs: used to call from object to shared lib or shared lib to | |
186 | shared lib; these go in regular text sections. In fact the linker tries | |
187 | to put them throughout the code because branches have limited reachability. | |
188 | We use the same mechanism as ppc64 to recognize the stub insn patterns. | |
189 | - $$dyncall: similar to hpux, hppa-linux uses $$dyncall for indirect function | |
190 | calls. $$dyncall is exported by libgcc.a */ | |
191 | static int | |
192 | hppa_linux_in_solib_call_trampoline (CORE_ADDR pc, char *name) | |
193 | { | |
194 | unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN]; | |
195 | int r; | |
196 | ||
197 | r = in_plt_section (pc, name) | |
198 | || hppa_linux_in_dyncall (pc) | |
199 | || insns_match_pattern (pc, hppa_import_stub, insn) | |
200 | || insns_match_pattern (pc, hppa_import_pic_stub, insn) | |
201 | || insns_match_pattern (pc, hppa_long_branch_stub, insn) | |
202 | || insns_match_pattern (pc, hppa_long_branch_pic_stub, insn); | |
203 | ||
204 | return r; | |
205 | } | |
206 | ||
207 | static CORE_ADDR | |
208 | hppa_linux_skip_trampoline_code (CORE_ADDR pc) | |
209 | { | |
210 | unsigned int insn[HPPA_MAX_INSN_PATTERN_LEN]; | |
211 | int dp_rel, pic_rel; | |
212 | ||
213 | /* dyncall handles both PLABELs and direct addresses */ | |
214 | if (hppa_linux_in_dyncall (pc)) | |
215 | { | |
216 | pc = (CORE_ADDR) read_register (22); | |
217 | ||
218 | /* PLABELs have bit 30 set; if it's a PLABEL, then dereference it */ | |
219 | if (pc & 0x2) | |
220 | pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); | |
221 | ||
222 | return pc; | |
223 | } | |
224 | ||
225 | dp_rel = pic_rel = 0; | |
226 | if ((dp_rel = insns_match_pattern (pc, hppa_import_stub, insn)) | |
227 | || (pic_rel = insns_match_pattern (pc, hppa_import_pic_stub, insn))) | |
228 | { | |
229 | /* Extract the target address from the addil/ldw sequence. */ | |
230 | pc = hppa_extract_21 (insn[0]) + hppa_extract_14 (insn[1]); | |
231 | ||
232 | if (dp_rel) | |
233 | pc += (CORE_ADDR) read_register (27); | |
234 | else | |
235 | pc += (CORE_ADDR) read_register (19); | |
236 | ||
237 | /* fallthrough */ | |
238 | } | |
239 | ||
240 | if (in_plt_section (pc, NULL)) | |
241 | { | |
242 | pc = (CORE_ADDR) read_memory_integer (pc, TARGET_PTR_BIT / 8); | |
243 | ||
244 | /* if the plt slot has not yet been resolved, the target will | |
245 | be the plt stub */ | |
246 | if (in_plt_section (pc, NULL)) | |
247 | { | |
248 | /* Sanity check: are we pointing to the plt stub? */ | |
249 | if (insns_match_pattern (pc, hppa_plt_stub, insn)) | |
250 | { | |
251 | /* this should point to the fixup routine */ | |
252 | pc = (CORE_ADDR) read_memory_integer (pc + 8, TARGET_PTR_BIT / 8); | |
253 | } | |
254 | else | |
255 | { | |
256 | error ("Cannot resolve plt stub at 0x%s\n", | |
257 | paddr_nz (pc)); | |
258 | pc = 0; | |
259 | } | |
260 | } | |
261 | } | |
262 | ||
263 | return pc; | |
264 | } | |
265 | ||
266 | /* Signal frames. */ | |
267 | ||
268 | /* (This is derived from MD_FALLBACK_FRAME_STATE_FOR in gcc.) | |
269 | ||
270 | Unfortunately, because of various bugs and changes to the kernel, | |
271 | we have several cases to deal with. | |
272 | ||
273 | In 2.4, the signal trampoline is 4 bytes, and pc should point directly at | |
274 | the beginning of the trampoline and struct rt_sigframe. | |
275 | ||
276 | In <= 2.6.5-rc2-pa3, the signal trampoline is 9 bytes, and pc points at | |
277 | the 4th word in the trampoline structure. This is wrong, it should point | |
278 | at the 5th word. This is fixed in 2.6.5-rc2-pa4. | |
279 | ||
280 | To detect these cases, we first take pc, align it to 64-bytes | |
281 | to get the beginning of the signal frame, and then check offsets 0, 4 | |
282 | and 5 to see if we found the beginning of the trampoline. This will | |
283 | tell us how to locate the sigcontext structure. | |
284 | ||
285 | Note that with a 2.4 64-bit kernel, the signal context is not properly | |
286 | passed back to userspace so the unwind will not work correctly. */ | |
287 | static CORE_ADDR | |
2f0e8c7a | 288 | hppa_linux_sigtramp_find_sigcontext (CORE_ADDR pc) |
50306a9d RC |
289 | { |
290 | unsigned int dummy[HPPA_MAX_INSN_PATTERN_LEN]; | |
291 | int offs = 0; | |
292 | int try; | |
293 | /* offsets to try to find the trampoline */ | |
294 | static int pcoffs[] = { 0, 4*4, 5*4 }; | |
295 | /* offsets to the rt_sigframe structure */ | |
296 | static int sfoffs[] = { 4*4, 10*4, 10*4 }; | |
2f0e8c7a RC |
297 | CORE_ADDR sp; |
298 | ||
299 | /* Most of the time, this will be correct. The one case when this will | |
300 | fail is if the user defined an alternate stack, in which case the | |
301 | beginning of the stack will not be align_down (pc, 64). */ | |
302 | sp = align_down (pc, 64); | |
50306a9d RC |
303 | |
304 | /* rt_sigreturn trampoline: | |
305 | 3419000x ldi 0, %r25 or ldi 1, %r25 (x = 0 or 2) | |
306 | 3414015a ldi __NR_rt_sigreturn, %r20 | |
307 | e4008200 be,l 0x100(%sr2, %r0), %sr0, %r31 | |
308 | 08000240 nop */ | |
309 | ||
310 | for (try = 0; try < ARRAY_SIZE (pcoffs); try++) | |
311 | { | |
312 | if (insns_match_pattern (sp + pcoffs[try], hppa_sigtramp, dummy)) | |
313 | { | |
314 | offs = sfoffs[try]; | |
315 | break; | |
316 | } | |
317 | } | |
318 | ||
319 | if (offs == 0) | |
2f0e8c7a RC |
320 | { |
321 | if (insns_match_pattern (pc, hppa_sigtramp, dummy)) | |
322 | { | |
323 | /* sigaltstack case: we have no way of knowing which offset to | |
324 | use in this case; default to new kernel handling. If this is | |
325 | wrong the unwinding will fail. */ | |
326 | try = 2; | |
327 | sp = pc - pcoffs[try]; | |
328 | } | |
329 | else | |
330 | { | |
331 | return 0; | |
332 | } | |
333 | } | |
50306a9d RC |
334 | |
335 | /* sp + sfoffs[try] points to a struct rt_sigframe, which contains | |
336 | a struct siginfo and a struct ucontext. struct ucontext contains | |
337 | a struct sigcontext. Return an offset to this sigcontext here. Too | |
338 | bad we cannot include system specific headers :-(. | |
339 | sizeof(struct siginfo) == 128 | |
340 | offsetof(struct ucontext, uc_mcontext) == 24. */ | |
341 | return sp + sfoffs[try] + 128 + 24; | |
342 | } | |
343 | ||
344 | struct hppa_linux_sigtramp_unwind_cache | |
345 | { | |
346 | CORE_ADDR base; | |
347 | struct trad_frame_saved_reg *saved_regs; | |
348 | }; | |
349 | ||
350 | static struct hppa_linux_sigtramp_unwind_cache * | |
351 | hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *next_frame, | |
352 | void **this_cache) | |
353 | { | |
354 | struct gdbarch *gdbarch = get_frame_arch (next_frame); | |
355 | struct hppa_linux_sigtramp_unwind_cache *info; | |
2f0e8c7a | 356 | CORE_ADDR pc, scptr; |
50306a9d RC |
357 | int i; |
358 | ||
359 | if (*this_cache) | |
360 | return *this_cache; | |
361 | ||
362 | info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache); | |
363 | *this_cache = info; | |
364 | info->saved_regs = trad_frame_alloc_saved_regs (next_frame); | |
365 | ||
366 | pc = frame_pc_unwind (next_frame); | |
2f0e8c7a | 367 | scptr = hppa_linux_sigtramp_find_sigcontext (pc); |
50306a9d RC |
368 | |
369 | /* structure of struct sigcontext: | |
370 | ||
371 | struct sigcontext { | |
372 | unsigned long sc_flags; | |
373 | unsigned long sc_gr[32]; | |
374 | unsigned long long sc_fr[32]; | |
375 | unsigned long sc_iasq[2]; | |
376 | unsigned long sc_iaoq[2]; | |
377 | unsigned long sc_sar; */ | |
378 | ||
379 | /* Skip sc_flags. */ | |
380 | scptr += 4; | |
381 | ||
382 | /* GR[0] is the psw, we don't restore that. */ | |
383 | scptr += 4; | |
384 | ||
385 | /* General registers. */ | |
386 | for (i = 1; i < 32; i++) | |
387 | { | |
34f75cc1 | 388 | info->saved_regs[HPPA_R0_REGNUM + i].addr = scptr; |
50306a9d RC |
389 | scptr += 4; |
390 | } | |
391 | ||
392 | /* Pad. */ | |
393 | scptr += 4; | |
394 | ||
395 | /* FP regs; FP0-3 are not restored. */ | |
396 | scptr += (8 * 4); | |
397 | ||
398 | for (i = 4; i < 32; i++) | |
399 | { | |
400 | info->saved_regs[HPPA_FP0_REGNUM + (i * 2)].addr = scptr; | |
401 | scptr += 4; | |
402 | info->saved_regs[HPPA_FP0_REGNUM + (i * 2) + 1].addr = scptr; | |
403 | scptr += 4; | |
404 | } | |
405 | ||
406 | /* IASQ/IAOQ. */ | |
34f75cc1 | 407 | info->saved_regs[HPPA_PCSQ_HEAD_REGNUM].addr = scptr; |
50306a9d | 408 | scptr += 4; |
34f75cc1 | 409 | info->saved_regs[HPPA_PCSQ_TAIL_REGNUM].addr = scptr; |
50306a9d RC |
410 | scptr += 4; |
411 | ||
34f75cc1 | 412 | info->saved_regs[HPPA_PCOQ_HEAD_REGNUM].addr = scptr; |
50306a9d | 413 | scptr += 4; |
34f75cc1 | 414 | info->saved_regs[HPPA_PCOQ_TAIL_REGNUM].addr = scptr; |
50306a9d RC |
415 | scptr += 4; |
416 | ||
2f0e8c7a | 417 | info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM); |
50306a9d RC |
418 | |
419 | return info; | |
420 | } | |
421 | ||
422 | static void | |
423 | hppa_linux_sigtramp_frame_this_id (struct frame_info *next_frame, | |
424 | void **this_prologue_cache, | |
425 | struct frame_id *this_id) | |
426 | { | |
427 | struct hppa_linux_sigtramp_unwind_cache *info | |
428 | = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); | |
429 | *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame)); | |
430 | } | |
431 | ||
432 | static void | |
433 | hppa_linux_sigtramp_frame_prev_register (struct frame_info *next_frame, | |
434 | void **this_prologue_cache, | |
435 | int regnum, int *optimizedp, | |
436 | enum lval_type *lvalp, | |
437 | CORE_ADDR *addrp, | |
0da28f8a | 438 | int *realnump, void *valuep) |
50306a9d RC |
439 | { |
440 | struct hppa_linux_sigtramp_unwind_cache *info | |
441 | = hppa_linux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache); | |
0da28f8a RC |
442 | hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum, |
443 | optimizedp, lvalp, addrp, realnump, valuep); | |
50306a9d RC |
444 | } |
445 | ||
446 | static const struct frame_unwind hppa_linux_sigtramp_frame_unwind = { | |
447 | SIGTRAMP_FRAME, | |
448 | hppa_linux_sigtramp_frame_this_id, | |
449 | hppa_linux_sigtramp_frame_prev_register | |
450 | }; | |
451 | ||
452 | /* hppa-linux always uses "new-style" rt-signals. The signal handler's return | |
453 | address should point to a signal trampoline on the stack. The signal | |
454 | trampoline is embedded in a rt_sigframe structure that is aligned on | |
455 | the stack. We take advantage of the fact that sp must be 64-byte aligned, | |
456 | and the trampoline is small, so by rounding down the trampoline address | |
457 | we can find the beginning of the struct rt_sigframe. */ | |
458 | static const struct frame_unwind * | |
459 | hppa_linux_sigtramp_unwind_sniffer (struct frame_info *next_frame) | |
460 | { | |
461 | CORE_ADDR pc = frame_pc_unwind (next_frame); | |
50306a9d | 462 | |
2f0e8c7a | 463 | if (hppa_linux_sigtramp_find_sigcontext (pc)) |
50306a9d RC |
464 | return &hppa_linux_sigtramp_frame_unwind; |
465 | ||
466 | return NULL; | |
467 | } | |
468 | ||
469 | /* Forward declarations. */ | |
470 | extern initialize_file_ftype _initialize_hppa_linux_tdep; | |
471 | ||
472 | static void | |
473 | hppa_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
474 | { | |
475 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
476 | ||
477 | /* Linux is always ELF. */ | |
478 | tdep->is_elf = 1; | |
479 | ||
480 | set_gdbarch_write_pc (gdbarch, hppa_linux_target_write_pc); | |
481 | ||
482 | frame_unwind_append_sniffer (gdbarch, hppa_linux_sigtramp_unwind_sniffer); | |
483 | ||
484 | /* GNU/Linux uses SVR4-style shared libraries. */ | |
485 | set_solib_svr4_fetch_link_map_offsets | |
486 | (gdbarch, svr4_ilp32_fetch_link_map_offsets); | |
487 | ||
488 | set_gdbarch_in_solib_call_trampoline | |
489 | (gdbarch, hppa_linux_in_solib_call_trampoline); | |
490 | set_gdbarch_skip_trampoline_code | |
491 | (gdbarch, hppa_linux_skip_trampoline_code); | |
492 | ||
493 | /* GNU/Linux uses the dynamic linker included in the GNU C Library. */ | |
494 | set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver); | |
495 | ||
3a7d1c27 RC |
496 | /* On hppa-linux, currently, sizeof(long double) == 8. There has been |
497 | some discussions to support 128-bit long double, but it requires some | |
498 | more work in gcc and glibc first. */ | |
499 | set_gdbarch_long_double_bit (gdbarch, 64); | |
500 | ||
50306a9d RC |
501 | #if 0 |
502 | /* Dwarf-2 unwinding support. Not yet working. */ | |
503 | set_gdbarch_dwarf_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); | |
504 | set_gdbarch_dwarf2_reg_to_regnum (gdbarch, hppa_dwarf_reg_to_regnum); | |
505 | frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer); | |
506 | frame_base_append_sniffer (gdbarch, dwarf2_frame_base_sniffer); | |
507 | #endif | |
508 | } | |
509 | ||
510 | void | |
511 | _initialize_hppa_linux_tdep (void) | |
512 | { | |
513 | gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_LINUX, hppa_linux_init_abi); | |
514 | } |