1 /* Target-dependent code for HP-UX on PA-RISC.
3 Copyright (C) 2002-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "frame-unwind.h"
26 #include "trad-frame.h"
32 #include "hppa-tdep.h"
33 #include "solib-som.h"
34 #include "solib-pa64.h"
37 #include "exceptions.h"
41 #define IS_32BIT_TARGET(_gdbarch) \
42 ((gdbarch_tdep (_gdbarch))->bytes_per_address == 4)
44 /* Bit in the `ss_flag' member of `struct save_state' that indicates
45 that the 64-bit register values are live. From
46 <machine/save_state.h>. */
47 #define HPPA_HPUX_SS_WIDEREGS 0x40
49 /* Offsets of various parts of `struct save_state'. From
50 <machine/save_state.h>. */
51 #define HPPA_HPUX_SS_FLAGS_OFFSET 0
52 #define HPPA_HPUX_SS_NARROW_OFFSET 4
53 #define HPPA_HPUX_SS_FPBLOCK_OFFSET 256
54 #define HPPA_HPUX_SS_WIDE_OFFSET 640
56 /* The size of `struct save_state. */
57 #define HPPA_HPUX_SAVE_STATE_SIZE 1152
59 /* The size of `struct pa89_save_state', which corresponds to PA-RISC
60 1.1, the lowest common denominator that we support. */
61 #define HPPA_HPUX_PA89_SAVE_STATE_SIZE 512
64 /* Forward declarations. */
65 extern void _initialize_hppa_hpux_tdep (void);
66 extern initialize_file_ftype _initialize_hppa_hpux_tdep;
68 /* Return one if PC is in the call path of a trampoline, else return zero.
70 Note we return one for *any* call trampoline (long-call, arg-reloc), not
71 just shared library trampolines (import, export). */
74 hppa32_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
76 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
77 struct bound_minimal_symbol minsym;
78 struct unwind_table_entry *u;
80 /* First see if PC is in one of the two C-library trampolines. */
81 if (pc == hppa_symbol_address("$$dyncall")
82 || pc == hppa_symbol_address("_sr4export"))
85 minsym = lookup_minimal_symbol_by_pc (pc);
87 && strcmp (SYMBOL_LINKAGE_NAME (minsym.minsym), ".stub") == 0)
90 /* Get the unwind descriptor corresponding to PC, return zero
91 if no unwind was found. */
92 u = find_unwind_entry (pc);
96 /* If this isn't a linker stub, then return now. */
97 if (u->stub_unwind.stub_type == 0)
100 /* By definition a long-branch stub is a call stub. */
101 if (u->stub_unwind.stub_type == LONG_BRANCH)
104 /* The call and return path execute the same instructions within
105 an IMPORT stub! So an IMPORT stub is both a call and return
107 if (u->stub_unwind.stub_type == IMPORT)
110 /* Parameter relocation stubs always have a call path and may have a
112 if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
113 || u->stub_unwind.stub_type == EXPORT)
117 /* Search forward from the current PC until we hit a branch
118 or the end of the stub. */
119 for (addr = pc; addr <= u->region_end; addr += 4)
123 insn = read_memory_integer (addr, 4, byte_order);
125 /* Does it look like a bl? If so then it's the call path, if
126 we find a bv or be first, then we're on the return path. */
127 if ((insn & 0xfc00e000) == 0xe8000000)
129 else if ((insn & 0xfc00e001) == 0xe800c000
130 || (insn & 0xfc000000) == 0xe0000000)
134 /* Should never happen. */
135 warning (_("Unable to find branch in parameter relocation stub."));
139 /* Unknown stub type. For now, just return zero. */
144 hppa64_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch, CORE_ADDR pc)
146 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
148 /* PA64 has a completely different stub/trampoline scheme. Is it
149 better? Maybe. It's certainly harder to determine with any
150 certainty that we are in a stub because we can not refer to the
153 The heuristic is simple. Try to lookup the current PC value in th
154 minimal symbol table. If that fails, then assume we are not in a
157 Then see if the PC value falls within the section bounds for the
158 section containing the minimal symbol we found in the first
159 step. If it does, then assume we are not in a stub and return.
161 Finally peek at the instructions to see if they look like a stub. */
162 struct bound_minimal_symbol minsym;
167 minsym = lookup_minimal_symbol_by_pc (pc);
171 sec = SYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym)->the_bfd_section;
173 if (bfd_get_section_vma (sec->owner, sec) <= pc
174 && pc < (bfd_get_section_vma (sec->owner, sec)
175 + bfd_section_size (sec->owner, sec)))
178 /* We might be in a stub. Peek at the instructions. Stubs are 3
179 instructions long. */
180 insn = read_memory_integer (pc, 4, byte_order);
182 /* Find out where we think we are within the stub. */
183 if ((insn & 0xffffc00e) == 0x53610000)
185 else if ((insn & 0xffffffff) == 0xe820d000)
187 else if ((insn & 0xffffc00e) == 0x537b0000)
192 /* Now verify each insn in the range looks like a stub instruction. */
193 insn = read_memory_integer (addr, 4, byte_order);
194 if ((insn & 0xffffc00e) != 0x53610000)
197 /* Now verify each insn in the range looks like a stub instruction. */
198 insn = read_memory_integer (addr + 4, 4, byte_order);
199 if ((insn & 0xffffffff) != 0xe820d000)
202 /* Now verify each insn in the range looks like a stub instruction. */
203 insn = read_memory_integer (addr + 8, 4, byte_order);
204 if ((insn & 0xffffc00e) != 0x537b0000)
207 /* Looks like a stub. */
211 /* Return one if PC is in the return path of a trampoline, else return zero.
213 Note we return one for *any* call trampoline (long-call, arg-reloc), not
214 just shared library trampolines (import, export). */
217 hppa_hpux_in_solib_return_trampoline (struct gdbarch *gdbarch,
218 CORE_ADDR pc, const char *name)
220 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
221 struct unwind_table_entry *u;
223 /* Get the unwind descriptor corresponding to PC, return zero
224 if no unwind was found. */
225 u = find_unwind_entry (pc);
229 /* If this isn't a linker stub or it's just a long branch stub, then
231 if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH)
234 /* The call and return path execute the same instructions within
235 an IMPORT stub! So an IMPORT stub is both a call and return
237 if (u->stub_unwind.stub_type == IMPORT)
240 /* Parameter relocation stubs always have a call path and may have a
242 if (u->stub_unwind.stub_type == PARAMETER_RELOCATION
243 || u->stub_unwind.stub_type == EXPORT)
247 /* Search forward from the current PC until we hit a branch
248 or the end of the stub. */
249 for (addr = pc; addr <= u->region_end; addr += 4)
253 insn = read_memory_integer (addr, 4, byte_order);
255 /* Does it look like a bl? If so then it's the call path, if
256 we find a bv or be first, then we're on the return path. */
257 if ((insn & 0xfc00e000) == 0xe8000000)
259 else if ((insn & 0xfc00e001) == 0xe800c000
260 || (insn & 0xfc000000) == 0xe0000000)
264 /* Should never happen. */
265 warning (_("Unable to find branch in parameter relocation stub."));
269 /* Unknown stub type. For now, just return zero. */
274 /* Figure out if PC is in a trampoline, and if so find out where
275 the trampoline will jump to. If not in a trampoline, return zero.
277 Simple code examination probably is not a good idea since the code
278 sequences in trampolines can also appear in user code.
280 We use unwinds and information from the minimal symbol table to
281 determine when we're in a trampoline. This won't work for ELF
282 (yet) since it doesn't create stub unwind entries. Whether or
283 not ELF will create stub unwinds or normal unwinds for linker
284 stubs is still being debated.
286 This should handle simple calls through dyncall or sr4export,
287 long calls, argument relocation stubs, and dyncall/sr4export
288 calling an argument relocation stub. It even handles some stubs
289 used in dynamic executables. */
292 hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
294 struct gdbarch *gdbarch = get_frame_arch (frame);
295 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
296 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
298 long prev_inst, curr_inst, loc;
299 struct bound_minimal_symbol msym;
300 struct unwind_table_entry *u;
302 /* Addresses passed to dyncall may *NOT* be the actual address
303 of the function. So we may have to do something special. */
304 if (pc == hppa_symbol_address("$$dyncall"))
306 pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
308 /* If bit 30 (counting from the left) is on, then pc is the address of
309 the PLT entry for this function, not the address of the function
310 itself. Bit 31 has meaning too, but only for MPE. */
312 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, word_size,
315 if (pc == hppa_symbol_address("$$dyncall_external"))
317 pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
318 pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, word_size, byte_order);
320 else if (pc == hppa_symbol_address("_sr4export"))
321 pc = (CORE_ADDR) get_frame_register_unsigned (frame, 22);
323 /* Get the unwind descriptor corresponding to PC, return zero
324 if no unwind was found. */
325 u = find_unwind_entry (pc);
329 /* If this isn't a linker stub, then return now. */
330 /* elz: attention here! (FIXME) because of a compiler/linker
331 error, some stubs which should have a non zero stub_unwind.stub_type
332 have unfortunately a value of zero. So this function would return here
333 as if we were not in a trampoline. To fix this, we go look at the partial
334 symbol information, which reports this guy as a stub.
335 (FIXME): Unfortunately, we are not that lucky: it turns out that the
336 partial symbol information is also wrong sometimes. This is because
337 when it is entered (somread.c::som_symtab_read()) it can happen that
338 if the type of the symbol (from the som) is Entry, and the symbol is
339 in a shared library, then it can also be a trampoline. This would be OK,
340 except that I believe the way they decide if we are ina shared library
341 does not work. SOOOO..., even if we have a regular function w/o
342 trampolines its minimal symbol can be assigned type mst_solib_trampoline.
343 Also, if we find that the symbol is a real stub, then we fix the unwind
344 descriptor, and define the stub type to be EXPORT.
345 Hopefully this is correct most of the times. */
346 if (u->stub_unwind.stub_type == 0)
349 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
350 we can delete all the code which appears between the lines. */
351 /*--------------------------------------------------------------------------*/
352 msym = lookup_minimal_symbol_by_pc (pc);
354 if (msym.minsym == NULL
355 || MSYMBOL_TYPE (msym.minsym) != mst_solib_trampoline)
356 return orig_pc == pc ? 0 : pc & ~0x3;
358 else if (msym.minsym != NULL
359 && MSYMBOL_TYPE (msym.minsym) == mst_solib_trampoline)
361 struct objfile *objfile;
362 struct minimal_symbol *msymbol;
363 int function_found = 0;
365 /* Go look if there is another minimal symbol with the same name as
366 this one, but with type mst_text. This would happen if the msym
367 is an actual trampoline, in which case there would be another
368 symbol with the same name corresponding to the real function. */
370 ALL_MSYMBOLS (objfile, msymbol)
372 if (MSYMBOL_TYPE (msymbol) == mst_text
373 && strcmp (SYMBOL_LINKAGE_NAME (msymbol),
374 SYMBOL_LINKAGE_NAME (msym.minsym)) == 0)
382 /* The type of msym is correct (mst_solib_trampoline), but
383 the unwind info is wrong, so set it to the correct value. */
384 u->stub_unwind.stub_type = EXPORT;
386 /* The stub type info in the unwind is correct (this is not a
387 trampoline), but the msym type information is wrong, it
388 should be mst_text. So we need to fix the msym, and also
389 get out of this function. */
391 MSYMBOL_TYPE (msym.minsym) = mst_text;
392 return orig_pc == pc ? 0 : pc & ~0x3;
396 /*--------------------------------------------------------------------------*/
399 /* It's a stub. Search for a branch and figure out where it goes.
400 Note we have to handle multi insn branch sequences like ldil;ble.
401 Most (all?) other branches can be determined by examining the contents
402 of certain registers and the stack. */
409 /* Make sure we haven't walked outside the range of this stub. */
410 if (u != find_unwind_entry (loc))
412 warning (_("Unable to find branch in linker stub"));
413 return orig_pc == pc ? 0 : pc & ~0x3;
416 prev_inst = curr_inst;
417 curr_inst = read_memory_integer (loc, 4, byte_order);
419 /* Does it look like a branch external using %r1? Then it's the
420 branch from the stub to the actual function. */
421 if ((curr_inst & 0xffe0e000) == 0xe0202000)
423 /* Yup. See if the previous instruction loaded
424 a value into %r1. If so compute and return the jump address. */
425 if ((prev_inst & 0xffe00000) == 0x20200000)
426 return (hppa_extract_21 (prev_inst)
427 + hppa_extract_17 (curr_inst)) & ~0x3;
430 warning (_("Unable to find ldil X,%%r1 "
431 "before ble Y(%%sr4,%%r1)."));
432 return orig_pc == pc ? 0 : pc & ~0x3;
436 /* Does it look like a be 0(sr0,%r21)? OR
437 Does it look like a be, n 0(sr0,%r21)? OR
438 Does it look like a bve (r21)? (this is on PA2.0)
439 Does it look like a bve, n(r21)? (this is also on PA2.0)
440 That's the branch from an
441 import stub to an export stub.
443 It is impossible to determine the target of the branch via
444 simple examination of instructions and/or data (consider
445 that the address in the plabel may be the address of the
446 bind-on-reference routine in the dynamic loader).
448 So we have try an alternative approach.
450 Get the name of the symbol at our current location; it should
451 be a stub symbol with the same name as the symbol in the
454 Then lookup a minimal symbol with the same name; we should
455 get the minimal symbol for the target routine in the shared
456 library as those take precedence of import/export stubs. */
457 if ((curr_inst == 0xe2a00000) ||
458 (curr_inst == 0xe2a00002) ||
459 (curr_inst == 0xeaa0d000) ||
460 (curr_inst == 0xeaa0d002))
462 struct bound_minimal_symbol stubsym;
463 struct minimal_symbol *libsym;
465 stubsym = lookup_minimal_symbol_by_pc (loc);
466 if (stubsym.minsym == NULL)
468 warning (_("Unable to find symbol for 0x%lx"), loc);
469 return orig_pc == pc ? 0 : pc & ~0x3;
472 libsym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym.minsym),
476 warning (_("Unable to find library symbol for %s."),
477 SYMBOL_PRINT_NAME (stubsym.minsym));
478 return orig_pc == pc ? 0 : pc & ~0x3;
481 return SYMBOL_VALUE (libsym);
484 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
485 branch from the stub to the actual function. */
487 else if ((curr_inst & 0xffe0e000) == 0xe8400000
488 || (curr_inst & 0xffe0e000) == 0xe8000000
489 || (curr_inst & 0xffe0e000) == 0xe800A000)
490 return (loc + hppa_extract_17 (curr_inst) + 8) & ~0x3;
492 /* Does it look like bv (rp)? Note this depends on the
493 current stack pointer being the same as the stack
494 pointer in the stub itself! This is a branch on from the
495 stub back to the original caller. */
496 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
497 else if ((curr_inst & 0xffe0f000) == 0xe840c000)
499 /* Yup. See if the previous instruction loaded
501 if (prev_inst == 0x4bc23ff1)
504 sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM);
505 return read_memory_integer (sp - 8, 4, byte_order) & ~0x3;
509 warning (_("Unable to find restore of %%rp before bv (%%rp)."));
510 return orig_pc == pc ? 0 : pc & ~0x3;
514 /* elz: added this case to capture the new instruction
515 at the end of the return part of an export stub used by
516 the PA2.0: BVE, n (rp) */
517 else if ((curr_inst & 0xffe0f000) == 0xe840d000)
519 return (read_memory_integer
520 (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
521 word_size, byte_order)) & ~0x3;
524 /* What about be,n 0(sr0,%rp)? It's just another way we return to
525 the original caller from the stub. Used in dynamic executables. */
526 else if (curr_inst == 0xe0400002)
528 /* The value we jump to is sitting in sp - 24. But that's
529 loaded several instructions before the be instruction.
530 I guess we could check for the previous instruction being
531 mtsp %r1,%sr0 if we want to do sanity checking. */
532 return (read_memory_integer
533 (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
534 word_size, byte_order)) & ~0x3;
537 /* Haven't found the branch yet, but we're still in the stub.
544 hppa_skip_permanent_breakpoint (struct regcache *regcache)
546 /* To step over a breakpoint instruction on the PA takes some
547 fiddling with the instruction address queue.
549 When we stop at a breakpoint, the IA queue front (the instruction
550 we're executing now) points at the breakpoint instruction, and
551 the IA queue back (the next instruction to execute) points to
552 whatever instruction we would execute after the breakpoint, if it
553 were an ordinary instruction. This is the case even if the
554 breakpoint is in the delay slot of a branch instruction.
556 Clearly, to step past the breakpoint, we need to set the queue
557 front to the back. But what do we put in the back? What
558 instruction comes after that one? Because of the branch delay
559 slot, the next insn is always at the back + 4. */
561 ULONGEST pcoq_tail, pcsq_tail;
562 regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, &pcoq_tail);
563 regcache_cooked_read_unsigned (regcache, HPPA_PCSQ_TAIL_REGNUM, &pcsq_tail);
565 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pcoq_tail);
566 regcache_cooked_write_unsigned (regcache, HPPA_PCSQ_HEAD_REGNUM, pcsq_tail);
568 regcache_cooked_write_unsigned (regcache,
569 HPPA_PCOQ_TAIL_REGNUM, pcoq_tail + 4);
570 /* We can leave the tail's space the same, since there's no jump. */
575 struct hppa_hpux_sigtramp_unwind_cache
578 struct trad_frame_saved_reg *saved_regs;
581 static int hppa_hpux_tramp_reg[] = {
583 HPPA_PCOQ_HEAD_REGNUM,
584 HPPA_PCSQ_HEAD_REGNUM,
585 HPPA_PCOQ_TAIL_REGNUM,
586 HPPA_PCSQ_TAIL_REGNUM,
613 static struct hppa_hpux_sigtramp_unwind_cache *
614 hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
618 struct gdbarch *gdbarch = get_frame_arch (this_frame);
619 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
620 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
621 struct hppa_hpux_sigtramp_unwind_cache *info;
623 CORE_ADDR sp, scptr, off;
629 info = FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache);
631 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
633 sp = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
635 if (IS_32BIT_TARGET (gdbarch))
642 /* See /usr/include/machine/save_state.h for the structure of the
643 save_state_t structure. */
645 flag = read_memory_unsigned_integer (scptr + HPPA_HPUX_SS_FLAGS_OFFSET,
648 if (!(flag & HPPA_HPUX_SS_WIDEREGS))
650 /* Narrow registers. */
651 off = scptr + HPPA_HPUX_SS_NARROW_OFFSET;
657 /* Wide registers. */
658 off = scptr + HPPA_HPUX_SS_WIDE_OFFSET + 8;
660 szoff = (tdep->bytes_per_address == 4 ? 4 : 0);
663 for (i = 1; i < 32; i++)
665 info->saved_regs[HPPA_R0_REGNUM + i].addr = off + szoff;
669 for (i = 0; i < ARRAY_SIZE (hppa_hpux_tramp_reg); i++)
671 if (hppa_hpux_tramp_reg[i] > 0)
672 info->saved_regs[hppa_hpux_tramp_reg[i]].addr = off + szoff;
679 info->base = get_frame_register_unsigned (this_frame, HPPA_SP_REGNUM);
685 hppa_hpux_sigtramp_frame_this_id (struct frame_info *this_frame,
686 void **this_prologue_cache,
687 struct frame_id *this_id)
689 struct hppa_hpux_sigtramp_unwind_cache *info
690 = hppa_hpux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
692 *this_id = frame_id_build (info->base, get_frame_pc (this_frame));
695 static struct value *
696 hppa_hpux_sigtramp_frame_prev_register (struct frame_info *this_frame,
697 void **this_prologue_cache,
700 struct hppa_hpux_sigtramp_unwind_cache *info
701 = hppa_hpux_sigtramp_frame_unwind_cache (this_frame, this_prologue_cache);
703 return hppa_frame_prev_register_helper (this_frame,
704 info->saved_regs, regnum);
708 hppa_hpux_sigtramp_unwind_sniffer (const struct frame_unwind *self,
709 struct frame_info *this_frame,
712 struct gdbarch *gdbarch = get_frame_arch (this_frame);
713 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
714 struct unwind_table_entry *u;
715 CORE_ADDR pc = get_frame_pc (this_frame);
717 u = find_unwind_entry (pc);
719 /* If this is an export stub, try to get the unwind descriptor for
720 the actual function itself. */
721 if (u && u->stub_unwind.stub_type == EXPORT)
723 gdb_byte buf[HPPA_INSN_SIZE];
726 if (!safe_frame_unwind_memory (this_frame, u->region_start,
730 insn = extract_unsigned_integer (buf, sizeof buf, byte_order);
731 if ((insn & 0xffe0e000) == 0xe8400000)
732 u = find_unwind_entry(u->region_start + hppa_extract_17 (insn) + 8);
735 if (u && u->HP_UX_interrupt_marker)
741 static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
743 default_frame_unwind_stop_reason,
744 hppa_hpux_sigtramp_frame_this_id,
745 hppa_hpux_sigtramp_frame_prev_register,
747 hppa_hpux_sigtramp_unwind_sniffer
751 hppa32_hpux_find_global_pointer (struct gdbarch *gdbarch,
752 struct value *function)
754 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
757 faddr = value_as_address (function);
759 /* Is this a plabel? If so, dereference it to get the gp value. */
767 status = target_read_memory (faddr + 4, buf, sizeof (buf));
769 return extract_unsigned_integer (buf, sizeof (buf), byte_order);
772 return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
776 hppa64_hpux_find_global_pointer (struct gdbarch *gdbarch,
777 struct value *function)
779 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
783 faddr = value_as_address (function);
785 if (pc_in_section (faddr, ".opd"))
787 target_read_memory (faddr, buf, sizeof (buf));
788 return extract_unsigned_integer (&buf[24], 8, byte_order);
792 return gdbarch_tdep (gdbarch)->solib_get_got_by_pc (faddr);
796 static unsigned int ldsid_pattern[] = {
797 0x000010a0, /* ldsid (rX),rY */
798 0x00001820, /* mtsp rY,sr0 */
799 0xe0000000 /* be,n (sr0,rX) */
803 hppa_hpux_search_pattern (struct gdbarch *gdbarch,
804 CORE_ADDR start, CORE_ADDR end,
805 unsigned int *patterns, int count)
807 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
808 int num_insns = (end - start + HPPA_INSN_SIZE) / HPPA_INSN_SIZE;
813 buf = alloca (num_insns * HPPA_INSN_SIZE);
814 insns = alloca (num_insns * sizeof (unsigned int));
816 read_memory (start, buf, num_insns * HPPA_INSN_SIZE);
817 for (i = 0; i < num_insns; i++, buf += HPPA_INSN_SIZE)
818 insns[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE, byte_order);
820 for (offset = 0; offset <= num_insns - count; offset++)
822 for (i = 0; i < count; i++)
824 if ((insns[offset + i] & patterns[i]) != patterns[i])
831 if (offset <= num_insns - count)
832 return start + offset * HPPA_INSN_SIZE;
838 hppa32_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
841 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
843 struct obj_section *sec;
844 struct hppa_objfile_private *priv;
845 struct frame_info *frame;
846 struct unwind_table_entry *u;
851 sec = find_pc_section (pc);
853 priv = objfile_data (obj, hppa_objfile_priv_data);
856 priv = hppa_init_objfile_priv_data (obj);
858 error (_("Internal error creating objfile private data."));
860 /* Use the cached value if we have one. */
861 if (priv->dummy_call_sequence_addr != 0)
863 *argreg = priv->dummy_call_sequence_reg;
864 return priv->dummy_call_sequence_addr;
867 /* First try a heuristic; if we are in a shared library call, our return
868 pointer is likely to point at an export stub. */
869 frame = get_current_frame ();
870 rp = frame_unwind_register_unsigned (frame, 2);
871 u = find_unwind_entry (rp);
872 if (u && u->stub_unwind.stub_type == EXPORT)
874 addr = hppa_hpux_search_pattern (gdbarch,
875 u->region_start, u->region_end,
877 ARRAY_SIZE (ldsid_pattern));
882 /* Next thing to try is to look for an export stub. */
883 if (priv->unwind_info)
887 for (i = 0; i < priv->unwind_info->last; i++)
889 struct unwind_table_entry *u;
890 u = &priv->unwind_info->table[i];
891 if (u->stub_unwind.stub_type == EXPORT)
893 addr = hppa_hpux_search_pattern (gdbarch,
894 u->region_start, u->region_end,
896 ARRAY_SIZE (ldsid_pattern));
905 /* Finally, if this is the main executable, try to locate a sequence
907 addr = hppa_symbol_address ("noshlibs");
908 sec = find_pc_section (addr);
910 if (sec && sec->objfile == obj)
912 CORE_ADDR start, end;
914 find_pc_partial_function (addr, NULL, &start, &end);
915 if (start != 0 && end != 0)
917 addr = hppa_hpux_search_pattern (gdbarch, start, end, ldsid_pattern,
918 ARRAY_SIZE (ldsid_pattern));
924 /* Can't find a suitable sequence. */
928 target_read_memory (addr, buf, sizeof (buf));
929 insn = extract_unsigned_integer (buf, sizeof (buf), byte_order);
930 priv->dummy_call_sequence_addr = addr;
931 priv->dummy_call_sequence_reg = (insn >> 21) & 0x1f;
933 *argreg = priv->dummy_call_sequence_reg;
934 return priv->dummy_call_sequence_addr;
938 hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
941 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
943 struct obj_section *sec;
944 struct hppa_objfile_private *priv;
946 struct minimal_symbol *msym;
948 sec = find_pc_section (pc);
950 priv = objfile_data (obj, hppa_objfile_priv_data);
953 priv = hppa_init_objfile_priv_data (obj);
955 error (_("Internal error creating objfile private data."));
957 /* Use the cached value if we have one. */
958 if (priv->dummy_call_sequence_addr != 0)
960 *argreg = priv->dummy_call_sequence_reg;
961 return priv->dummy_call_sequence_addr;
964 /* FIXME: Without stub unwind information, locating a suitable sequence is
965 fairly difficult. For now, we implement a very naive and inefficient
966 scheme; try to read in blocks of code, and look for a "bve,n (rp)"
967 instruction. These are likely to occur at the end of functions, so
968 we only look at the last two instructions of each function. */
969 ALL_OBJFILE_MSYMBOLS (obj, msym)
971 CORE_ADDR begin, end;
973 gdb_byte buf[2 * HPPA_INSN_SIZE];
976 find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
979 if (name == NULL || begin == 0 || end == 0)
982 if (target_read_memory (end - sizeof (buf), buf, sizeof (buf)) == 0)
984 for (offset = 0; offset < sizeof (buf); offset++)
988 insn = extract_unsigned_integer (buf + offset,
989 HPPA_INSN_SIZE, byte_order);
990 if (insn == 0xe840d002) /* bve,n (rp) */
992 addr = (end - sizeof (buf)) + offset;
999 /* Can't find a suitable sequence. */
1003 priv->dummy_call_sequence_addr = addr;
1004 /* Right now we only look for a "bve,l (rp)" sequence, so the register is
1005 always HPPA_RP_REGNUM. */
1006 priv->dummy_call_sequence_reg = HPPA_RP_REGNUM;
1008 *argreg = priv->dummy_call_sequence_reg;
1009 return priv->dummy_call_sequence_addr;
1013 hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
1015 struct objfile *objfile;
1016 struct bound_minimal_symbol funsym;
1017 struct minimal_symbol *stubsym;
1020 funsym = lookup_minimal_symbol_by_pc (funcaddr);
1023 ALL_OBJFILES (objfile)
1025 stubsym = lookup_minimal_symbol_solib_trampoline
1026 (SYMBOL_LINKAGE_NAME (funsym.minsym), objfile);
1030 struct unwind_table_entry *u;
1032 u = find_unwind_entry (SYMBOL_VALUE (stubsym));
1034 || (u->stub_unwind.stub_type != IMPORT
1035 && u->stub_unwind.stub_type != IMPORT_SHLIB))
1038 stubaddr = SYMBOL_VALUE (stubsym);
1040 /* If we found an IMPORT stub, then we can stop searching;
1041 if we found an IMPORT_SHLIB, we want to continue the search
1042 in the hopes that we will find an IMPORT stub. */
1043 if (u->stub_unwind.stub_type == IMPORT)
1052 hppa_hpux_sr_for_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
1055 /* The space register to use is encoded in the top 2 bits of the address. */
1056 sr = addr >> (gdbarch_tdep (gdbarch)->bytes_per_address * 8 - 2);
1061 hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr)
1063 /* In order for us to restore the space register to its starting state,
1064 we need the dummy trampoline to return to an instruction address in
1065 the same space as where we started the call. We used to place the
1066 breakpoint near the current pc, however, this breaks nested dummy calls
1067 as the nested call will hit the breakpoint address and terminate
1068 prematurely. Instead, we try to look for an address in the same space to
1071 This is similar in spirit to putting the breakpoint at the "entry point"
1072 of an executable. */
1074 struct obj_section *sec;
1075 struct unwind_table_entry *u;
1076 struct minimal_symbol *msym;
1079 sec = find_pc_section (addr);
1082 /* First try the lowest address in the section; we can use it as long
1083 as it is "regular" code (i.e. not a stub). */
1084 u = find_unwind_entry (obj_section_addr (sec));
1085 if (!u || u->stub_unwind.stub_type == 0)
1086 return obj_section_addr (sec);
1088 /* Otherwise, we need to find a symbol for a regular function. We
1089 do this by walking the list of msymbols in the objfile. The symbol
1090 we find should not be the same as the function that was passed in. */
1092 /* FIXME: this is broken, because we can find a function that will be
1093 called by the dummy call target function, which will still not
1096 find_pc_partial_function (addr, NULL, &func, NULL);
1097 ALL_OBJFILE_MSYMBOLS (sec->objfile, msym)
1099 u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
1100 if (func != SYMBOL_VALUE_ADDRESS (msym)
1101 && (!u || u->stub_unwind.stub_type == 0))
1102 return SYMBOL_VALUE_ADDRESS (msym);
1106 warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1107 "calls may fail."));
1112 hppa_hpux_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
1114 struct value **args, int nargs,
1115 struct type *value_type,
1116 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
1117 struct regcache *regcache)
1119 CORE_ADDR pc, stubaddr;
1122 pc = regcache_read_pc (regcache);
1124 /* Note: we don't want to pass a function descriptor here; push_dummy_call
1125 fills in the PIC register for us. */
1126 funcaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funcaddr, NULL);
1128 /* The simple case is where we call a function in the same space that we are
1129 currently in; in that case we don't really need to do anything. */
1130 if (hppa_hpux_sr_for_addr (gdbarch, pc)
1131 == hppa_hpux_sr_for_addr (gdbarch, funcaddr))
1133 /* Intraspace call. */
1134 *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1135 *real_pc = funcaddr;
1136 regcache_cooked_write_unsigned (regcache, HPPA_RP_REGNUM, *bp_addr);
1141 /* In order to make an interspace call, we need to go through a stub.
1142 gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1143 an application is compiled with HP compilers then this stub is not
1144 available. We used to fallback to "__d_plt_call", however that stub
1145 is not entirely useful for us because it doesn't do an interspace
1146 return back to the caller. Also, on hppa64-hpux, there is no
1147 __gcc_plt_call available. In order to keep the code uniform, we
1148 instead don't use either of these stubs, but instead write our own
1151 A problem arises since the stack is located in a different space than
1152 code, so in order to branch to a stack stub, we will need to do an
1153 interspace branch. Previous versions of gdb did this by modifying code
1154 at the current pc and doing single-stepping to set the pcsq. Since this
1155 is highly undesirable, we use a different scheme:
1157 All we really need to do the branch to the stub is a short instruction
1168 Instead of writing these sequences ourselves, we can find it in
1169 the instruction stream that belongs to the current space. While this
1170 seems difficult at first, we are actually guaranteed to find the sequences
1174 - in export stubs for shared libraries
1175 - in the "noshlibs" routine in the main module
1178 - at the end of each "regular" function
1180 We cache the address of these sequences in the objfile's private data
1181 since these operations can potentially be quite expensive.
1184 - write a stack trampoline
1185 - look for a suitable instruction sequence in the current space
1186 - point the sequence at the trampoline
1187 - set the return address of the trampoline to the current space
1188 (see hppa_hpux_find_dummy_call_bpaddr)
1189 - set the continuing address of the "dummy code" as the sequence. */
1191 if (IS_32BIT_TARGET (gdbarch))
1193 #define INSN(I1, I2, I3, I4) 0x ## I1, 0x ## I2, 0x ## I3, 0x ## I4
1194 static const gdb_byte hppa32_tramp[] = {
1195 INSN(0f,df,12,91), /* stw r31,-8(,sp) */
1196 INSN(02,c0,10,a1), /* ldsid (,r22),r1 */
1197 INSN(00,01,18,20), /* mtsp r1,sr0 */
1198 INSN(e6,c0,00,00), /* be,l 0(sr0,r22),%sr0,%r31 */
1199 INSN(08,1f,02,42), /* copy r31,rp */
1200 INSN(0f,d1,10,82), /* ldw -8(,sp),rp */
1201 INSN(00,40,10,a1), /* ldsid (,rp),r1 */
1202 INSN(00,01,18,20), /* mtsp r1,sr0 */
1203 INSN(e0,40,00,00), /* be 0(sr0,rp) */
1204 INSN(08,00,02,40) /* nop */
1207 /* for hppa32, we must call the function through a stub so that on
1208 return it can return to the space of our trampoline. */
1209 stubaddr = hppa_hpux_find_import_stub_for_addr (funcaddr);
1211 error (_("Cannot call external function not referenced by application "
1212 "(no import stub).\n"));
1213 regcache_cooked_write_unsigned (regcache, 22, stubaddr);
1215 write_memory (sp, hppa32_tramp, sizeof (hppa32_tramp));
1217 *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1218 regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
1220 *real_pc = hppa32_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1222 error (_("Cannot make interspace call from here."));
1224 regcache_cooked_write_unsigned (regcache, argreg, sp);
1226 sp += sizeof (hppa32_tramp);
1230 static const gdb_byte hppa64_tramp[] = {
1231 INSN(ea,c0,f0,00), /* bve,l (r22),%r2 */
1232 INSN(0f,df,12,d1), /* std r31,-8(,sp) */
1233 INSN(0f,d1,10,c2), /* ldd -8(,sp),rp */
1234 INSN(e8,40,d0,02), /* bve,n (rp) */
1235 INSN(08,00,02,40) /* nop */
1239 /* for hppa64, we don't need to call through a stub; all functions
1240 return via a bve. */
1241 regcache_cooked_write_unsigned (regcache, 22, funcaddr);
1242 write_memory (sp, hppa64_tramp, sizeof (hppa64_tramp));
1245 regcache_cooked_write_unsigned (regcache, 31, *bp_addr);
1247 *real_pc = hppa64_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1249 error (_("Cannot make interspace call from here."));
1251 regcache_cooked_write_unsigned (regcache, argreg, sp);
1253 sp += sizeof (hppa64_tramp);
1256 sp = gdbarch_frame_align (gdbarch, sp);
1264 hppa_hpux_supply_ss_narrow (struct regcache *regcache,
1265 int regnum, const gdb_byte *save_state)
1267 const gdb_byte *ss_narrow = save_state + HPPA_HPUX_SS_NARROW_OFFSET;
1270 for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1272 if (regnum == i || regnum == -1)
1273 regcache_raw_supply (regcache, i, ss_narrow + offset);
1280 hppa_hpux_supply_ss_fpblock (struct regcache *regcache,
1281 int regnum, const gdb_byte *save_state)
1283 const gdb_byte *ss_fpblock = save_state + HPPA_HPUX_SS_FPBLOCK_OFFSET;
1286 /* FIXME: We view the floating-point state as 64 single-precision
1287 registers for 32-bit code, and 32 double-precision register for
1288 64-bit code. This distinction is artificial and should be
1289 eliminated. If that ever happens, we should remove the if-clause
1292 if (register_size (get_regcache_arch (regcache), HPPA_FP0_REGNUM) == 4)
1294 for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 64; i++)
1296 if (regnum == i || regnum == -1)
1297 regcache_raw_supply (regcache, i, ss_fpblock + offset);
1304 for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32; i++)
1306 if (regnum == i || regnum == -1)
1307 regcache_raw_supply (regcache, i, ss_fpblock + offset);
1315 hppa_hpux_supply_ss_wide (struct regcache *regcache,
1316 int regnum, const gdb_byte *save_state)
1318 const gdb_byte *ss_wide = save_state + HPPA_HPUX_SS_WIDE_OFFSET;
1321 if (register_size (get_regcache_arch (regcache), HPPA_R1_REGNUM) == 4)
1324 for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1326 if (regnum == i || regnum == -1)
1327 regcache_raw_supply (regcache, i, ss_wide + offset);
1334 hppa_hpux_supply_save_state (const struct regset *regset,
1335 struct regcache *regcache,
1336 int regnum, const void *regs, size_t len)
1338 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1339 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1340 const gdb_byte *proc_info = regs;
1341 const gdb_byte *save_state = proc_info + 8;
1344 flags = extract_unsigned_integer (save_state + HPPA_HPUX_SS_FLAGS_OFFSET,
1346 if (regnum == -1 || regnum == HPPA_FLAGS_REGNUM)
1348 size_t size = register_size (gdbarch, HPPA_FLAGS_REGNUM);
1351 store_unsigned_integer (buf, size, byte_order, flags);
1352 regcache_raw_supply (regcache, HPPA_FLAGS_REGNUM, buf);
1355 /* If the SS_WIDEREGS flag is set, we really do need the full
1356 `struct save_state'. */
1357 if (flags & HPPA_HPUX_SS_WIDEREGS && len < HPPA_HPUX_SAVE_STATE_SIZE)
1358 error (_("Register set contents too small"));
1360 if (flags & HPPA_HPUX_SS_WIDEREGS)
1361 hppa_hpux_supply_ss_wide (regcache, regnum, save_state);
1363 hppa_hpux_supply_ss_narrow (regcache, regnum, save_state);
1365 hppa_hpux_supply_ss_fpblock (regcache, regnum, save_state);
1368 /* HP-UX register set. */
1370 static struct regset hppa_hpux_regset =
1373 hppa_hpux_supply_save_state
1376 static const struct regset *
1377 hppa_hpux_regset_from_core_section (struct gdbarch *gdbarch,
1378 const char *sect_name, size_t sect_size)
1380 if (strcmp (sect_name, ".reg") == 0
1381 && sect_size >= HPPA_HPUX_PA89_SAVE_STATE_SIZE + 8)
1382 return &hppa_hpux_regset;
1388 /* Bit in the `ss_flag' member of `struct save_state' that indicates
1389 the state was saved from a system call. From
1390 <machine/save_state.h>. */
1391 #define HPPA_HPUX_SS_INSYSCALL 0x02
1394 hppa_hpux_read_pc (struct regcache *regcache)
1398 /* If we're currently in a system call return the contents of %r31. */
1399 regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
1400 if (flags & HPPA_HPUX_SS_INSYSCALL)
1403 regcache_cooked_read_unsigned (regcache, HPPA_R31_REGNUM, &pc);
1407 return hppa_read_pc (regcache);
1411 hppa_hpux_write_pc (struct regcache *regcache, CORE_ADDR pc)
1415 /* If we're currently in a system call also write PC into %r31. */
1416 regcache_cooked_read_unsigned (regcache, HPPA_FLAGS_REGNUM, &flags);
1417 if (flags & HPPA_HPUX_SS_INSYSCALL)
1418 regcache_cooked_write_unsigned (regcache, HPPA_R31_REGNUM, pc | 0x3);
1420 hppa_write_pc (regcache, pc);
1424 hppa_hpux_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1428 /* If we're currently in a system call return the contents of %r31. */
1429 flags = frame_unwind_register_unsigned (next_frame, HPPA_FLAGS_REGNUM);
1430 if (flags & HPPA_HPUX_SS_INSYSCALL)
1431 return frame_unwind_register_unsigned (next_frame, HPPA_R31_REGNUM) & ~0x3;
1433 return hppa_unwind_pc (gdbarch, next_frame);
1437 /* Given the current value of the pc, check to see if it is inside a stub, and
1438 if so, change the value of the pc to point to the caller of the stub.
1439 THIS_FRAME is the current frame in the current list of frames.
1440 BASE contains to stack frame base of the current frame.
1441 SAVE_REGS is the register file stored in the frame cache. */
1443 hppa_hpux_unwind_adjust_stub (struct frame_info *this_frame, CORE_ADDR base,
1444 struct trad_frame_saved_reg *saved_regs)
1446 struct gdbarch *gdbarch = get_frame_arch (this_frame);
1447 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1448 int word_size = gdbarch_ptr_bit (gdbarch) / 8;
1449 struct value *pcoq_head_val;
1452 struct unwind_table_entry *u;
1454 pcoq_head_val = trad_frame_get_prev_register (this_frame, saved_regs,
1455 HPPA_PCOQ_HEAD_REGNUM);
1457 extract_unsigned_integer (value_contents_all (pcoq_head_val),
1458 register_size (gdbarch, HPPA_PCOQ_HEAD_REGNUM),
1461 u = find_unwind_entry (pcoq_head);
1462 if (u && u->stub_unwind.stub_type == EXPORT)
1464 stubpc = read_memory_integer (base - 24, word_size, byte_order);
1465 trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1467 else if (hppa_symbol_address ("__gcc_plt_call")
1468 == get_pc_function_start (pcoq_head))
1470 stubpc = read_memory_integer (base - 8, word_size, byte_order);
1471 trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1476 hppa_hpux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1478 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1480 if (IS_32BIT_TARGET (gdbarch))
1481 tdep->in_solib_call_trampoline = hppa32_hpux_in_solib_call_trampoline;
1483 tdep->in_solib_call_trampoline = hppa64_hpux_in_solib_call_trampoline;
1485 tdep->unwind_adjust_stub = hppa_hpux_unwind_adjust_stub;
1487 set_gdbarch_in_solib_return_trampoline
1488 (gdbarch, hppa_hpux_in_solib_return_trampoline);
1489 set_gdbarch_skip_trampoline_code (gdbarch, hppa_hpux_skip_trampoline_code);
1491 set_gdbarch_push_dummy_code (gdbarch, hppa_hpux_push_dummy_code);
1492 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1494 set_gdbarch_read_pc (gdbarch, hppa_hpux_read_pc);
1495 set_gdbarch_write_pc (gdbarch, hppa_hpux_write_pc);
1496 set_gdbarch_unwind_pc (gdbarch, hppa_hpux_unwind_pc);
1497 set_gdbarch_skip_permanent_breakpoint
1498 (gdbarch, hppa_skip_permanent_breakpoint);
1500 set_gdbarch_regset_from_core_section
1501 (gdbarch, hppa_hpux_regset_from_core_section);
1503 frame_unwind_append_unwinder (gdbarch, &hppa_hpux_sigtramp_frame_unwind);
1507 hppa_hpux_som_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1509 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1513 tdep->find_global_pointer = hppa32_hpux_find_global_pointer;
1515 hppa_hpux_init_abi (info, gdbarch);
1516 som_solib_select (gdbarch);
1520 hppa_hpux_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1522 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1525 tdep->find_global_pointer = hppa64_hpux_find_global_pointer;
1527 hppa_hpux_init_abi (info, gdbarch);
1528 pa64_solib_select (gdbarch);
1531 static enum gdb_osabi
1532 hppa_hpux_core_osabi_sniffer (bfd *abfd)
1534 if (strcmp (bfd_get_target (abfd), "hpux-core") == 0)
1535 return GDB_OSABI_HPUX_SOM;
1536 else if (strcmp (bfd_get_target (abfd), "elf64-hppa") == 0)
1540 section = bfd_get_section_by_name (abfd, ".kernel");
1546 size = bfd_section_size (abfd, section);
1547 contents = alloca (size);
1548 if (bfd_get_section_contents (abfd, section, contents,
1550 && strcmp (contents, "HP-UX") == 0)
1551 return GDB_OSABI_HPUX_ELF;
1555 return GDB_OSABI_UNKNOWN;
1559 _initialize_hppa_hpux_tdep (void)
1561 /* BFD doesn't set a flavour for HP-UX style core files. It doesn't
1562 set the architecture either. */
1563 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
1564 bfd_target_unknown_flavour,
1565 hppa_hpux_core_osabi_sniffer);
1566 gdbarch_register_osabi_sniffer (bfd_arch_hppa,
1567 bfd_target_elf_flavour,
1568 hppa_hpux_core_osabi_sniffer);
1570 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_HPUX_SOM,
1571 hppa_hpux_som_init_abi);
1572 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_HPUX_ELF,
1573 hppa_hpux_elf_init_abi);