1 /* Target-dependent code for HP-UX on PA-RISC.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "frame-unwind.h"
27 #include "trad-frame.h"
33 #include "hppa-tdep.h"
34 #include "solib-som.h"
35 #include "solib-pa64.h"
38 #include "exceptions.h"
40 #include "gdb_string.h"
42 #define IS_32BIT_TARGET(_gdbarch) \
43 ((gdbarch_tdep (_gdbarch))->bytes_per_address == 4)
45 /* Bit in the `ss_flag' member of `struct save_state' that indicates
46 that the 64-bit register values are live. From
47 <machine/save_state.h>. */
48 #define HPPA_HPUX_SS_WIDEREGS 0x40
50 /* Offsets of various parts of `struct save_state'. From
51 <machine/save_state.h>. */
52 #define HPPA_HPUX_SS_FLAGS_OFFSET 0
53 #define HPPA_HPUX_SS_NARROW_OFFSET 4
54 #define HPPA_HPUX_SS_FPBLOCK_OFFSET 256
55 #define HPPA_HPUX_SS_WIDE_OFFSET 640
57 /* The size of `struct save_state. */
58 #define HPPA_HPUX_SAVE_STATE_SIZE 1152
60 /* The size of `struct pa89_save_state', which corresponds to PA-RISC
61 1.1, the lowest common denominator that we support. */
62 #define HPPA_HPUX_PA89_SAVE_STATE_SIZE 512
65 /* Forward declarations. */
66 extern void _initialize_hppa_hpux_tdep (void);
67 extern initialize_file_ftype _initialize_hppa_hpux_tdep
;
70 in_opd_section (CORE_ADDR pc
)
72 struct obj_section
*s
;
75 s
= find_pc_section (pc
);
78 && s
->the_bfd_section
->name
!= NULL
79 && strcmp (s
->the_bfd_section
->name
, ".opd") == 0);
83 /* Return one if PC is in the call path of a trampoline, else return zero.
85 Note we return one for *any* call trampoline (long-call, arg-reloc), not
86 just shared library trampolines (import, export). */
89 hppa32_hpux_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
91 struct minimal_symbol
*minsym
;
92 struct unwind_table_entry
*u
;
94 /* First see if PC is in one of the two C-library trampolines. */
95 if (pc
== hppa_symbol_address("$$dyncall")
96 || pc
== hppa_symbol_address("_sr4export"))
99 minsym
= lookup_minimal_symbol_by_pc (pc
);
100 if (minsym
&& strcmp (DEPRECATED_SYMBOL_NAME (minsym
), ".stub") == 0)
103 /* Get the unwind descriptor corresponding to PC, return zero
104 if no unwind was found. */
105 u
= find_unwind_entry (pc
);
109 /* If this isn't a linker stub, then return now. */
110 if (u
->stub_unwind
.stub_type
== 0)
113 /* By definition a long-branch stub is a call stub. */
114 if (u
->stub_unwind
.stub_type
== LONG_BRANCH
)
117 /* The call and return path execute the same instructions within
118 an IMPORT stub! So an IMPORT stub is both a call and return
120 if (u
->stub_unwind
.stub_type
== IMPORT
)
123 /* Parameter relocation stubs always have a call path and may have a
125 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
126 || u
->stub_unwind
.stub_type
== EXPORT
)
130 /* Search forward from the current PC until we hit a branch
131 or the end of the stub. */
132 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
136 insn
= read_memory_integer (addr
, 4);
138 /* Does it look like a bl? If so then it's the call path, if
139 we find a bv or be first, then we're on the return path. */
140 if ((insn
& 0xfc00e000) == 0xe8000000)
142 else if ((insn
& 0xfc00e001) == 0xe800c000
143 || (insn
& 0xfc000000) == 0xe0000000)
147 /* Should never happen. */
148 warning (_("Unable to find branch in parameter relocation stub."));
152 /* Unknown stub type. For now, just return zero. */
157 hppa64_hpux_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
159 /* PA64 has a completely different stub/trampoline scheme. Is it
160 better? Maybe. It's certainly harder to determine with any
161 certainty that we are in a stub because we can not refer to the
164 The heuristic is simple. Try to lookup the current PC value in th
165 minimal symbol table. If that fails, then assume we are not in a
168 Then see if the PC value falls within the section bounds for the
169 section containing the minimal symbol we found in the first
170 step. If it does, then assume we are not in a stub and return.
172 Finally peek at the instructions to see if they look like a stub. */
173 struct minimal_symbol
*minsym
;
178 minsym
= lookup_minimal_symbol_by_pc (pc
);
182 sec
= SYMBOL_BFD_SECTION (minsym
);
184 if (bfd_get_section_vma (sec
->owner
, sec
) <= pc
185 && pc
< (bfd_get_section_vma (sec
->owner
, sec
)
186 + bfd_section_size (sec
->owner
, sec
)))
189 /* We might be in a stub. Peek at the instructions. Stubs are 3
190 instructions long. */
191 insn
= read_memory_integer (pc
, 4);
193 /* Find out where we think we are within the stub. */
194 if ((insn
& 0xffffc00e) == 0x53610000)
196 else if ((insn
& 0xffffffff) == 0xe820d000)
198 else if ((insn
& 0xffffc00e) == 0x537b0000)
203 /* Now verify each insn in the range looks like a stub instruction. */
204 insn
= read_memory_integer (addr
, 4);
205 if ((insn
& 0xffffc00e) != 0x53610000)
208 /* Now verify each insn in the range looks like a stub instruction. */
209 insn
= read_memory_integer (addr
+ 4, 4);
210 if ((insn
& 0xffffffff) != 0xe820d000)
213 /* Now verify each insn in the range looks like a stub instruction. */
214 insn
= read_memory_integer (addr
+ 8, 4);
215 if ((insn
& 0xffffc00e) != 0x537b0000)
218 /* Looks like a stub. */
222 /* Return one if PC is in the return path of a trampoline, else return zero.
224 Note we return one for *any* call trampoline (long-call, arg-reloc), not
225 just shared library trampolines (import, export). */
228 hppa_hpux_in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
230 struct unwind_table_entry
*u
;
232 /* Get the unwind descriptor corresponding to PC, return zero
233 if no unwind was found. */
234 u
= find_unwind_entry (pc
);
238 /* If this isn't a linker stub or it's just a long branch stub, then
240 if (u
->stub_unwind
.stub_type
== 0 || u
->stub_unwind
.stub_type
== LONG_BRANCH
)
243 /* The call and return path execute the same instructions within
244 an IMPORT stub! So an IMPORT stub is both a call and return
246 if (u
->stub_unwind
.stub_type
== IMPORT
)
249 /* Parameter relocation stubs always have a call path and may have a
251 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
252 || u
->stub_unwind
.stub_type
== EXPORT
)
256 /* Search forward from the current PC until we hit a branch
257 or the end of the stub. */
258 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
262 insn
= read_memory_integer (addr
, 4);
264 /* Does it look like a bl? If so then it's the call path, if
265 we find a bv or be first, then we're on the return path. */
266 if ((insn
& 0xfc00e000) == 0xe8000000)
268 else if ((insn
& 0xfc00e001) == 0xe800c000
269 || (insn
& 0xfc000000) == 0xe0000000)
273 /* Should never happen. */
274 warning (_("Unable to find branch in parameter relocation stub."));
278 /* Unknown stub type. For now, just return zero. */
283 /* Figure out if PC is in a trampoline, and if so find out where
284 the trampoline will jump to. If not in a trampoline, return zero.
286 Simple code examination probably is not a good idea since the code
287 sequences in trampolines can also appear in user code.
289 We use unwinds and information from the minimal symbol table to
290 determine when we're in a trampoline. This won't work for ELF
291 (yet) since it doesn't create stub unwind entries. Whether or
292 not ELF will create stub unwinds or normal unwinds for linker
293 stubs is still being debated.
295 This should handle simple calls through dyncall or sr4export,
296 long calls, argument relocation stubs, and dyncall/sr4export
297 calling an argument relocation stub. It even handles some stubs
298 used in dynamic executables. */
301 hppa_hpux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
303 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
305 long prev_inst
, curr_inst
, loc
;
306 struct minimal_symbol
*msym
;
307 struct unwind_table_entry
*u
;
309 /* Addresses passed to dyncall may *NOT* be the actual address
310 of the function. So we may have to do something special. */
311 if (pc
== hppa_symbol_address("$$dyncall"))
313 pc
= (CORE_ADDR
) get_frame_register_unsigned (frame
, 22);
315 /* If bit 30 (counting from the left) is on, then pc is the address of
316 the PLT entry for this function, not the address of the function
317 itself. Bit 31 has meaning too, but only for MPE. */
319 pc
= (CORE_ADDR
) read_memory_integer
320 (pc
& ~0x3, gdbarch_ptr_bit (gdbarch
) / 8);
322 if (pc
== hppa_symbol_address("$$dyncall_external"))
324 pc
= (CORE_ADDR
) get_frame_register_unsigned (frame
, 22);
325 pc
= (CORE_ADDR
) read_memory_integer
326 (pc
& ~0x3, gdbarch_ptr_bit (gdbarch
) / 8);
328 else if (pc
== hppa_symbol_address("_sr4export"))
329 pc
= (CORE_ADDR
) get_frame_register_unsigned (frame
, 22);
331 /* Get the unwind descriptor corresponding to PC, return zero
332 if no unwind was found. */
333 u
= find_unwind_entry (pc
);
337 /* If this isn't a linker stub, then return now. */
338 /* elz: attention here! (FIXME) because of a compiler/linker
339 error, some stubs which should have a non zero stub_unwind.stub_type
340 have unfortunately a value of zero. So this function would return here
341 as if we were not in a trampoline. To fix this, we go look at the partial
342 symbol information, which reports this guy as a stub.
343 (FIXME): Unfortunately, we are not that lucky: it turns out that the
344 partial symbol information is also wrong sometimes. This is because
345 when it is entered (somread.c::som_symtab_read()) it can happen that
346 if the type of the symbol (from the som) is Entry, and the symbol is
347 in a shared library, then it can also be a trampoline. This would
348 be OK, except that I believe the way they decide if we are ina shared library
349 does not work. SOOOO..., even if we have a regular function w/o trampolines
350 its minimal symbol can be assigned type mst_solib_trampoline.
351 Also, if we find that the symbol is a real stub, then we fix the unwind
352 descriptor, and define the stub type to be EXPORT.
353 Hopefully this is correct most of the times. */
354 if (u
->stub_unwind
.stub_type
== 0)
357 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
358 we can delete all the code which appears between the lines */
359 /*--------------------------------------------------------------------------*/
360 msym
= lookup_minimal_symbol_by_pc (pc
);
362 if (msym
== NULL
|| MSYMBOL_TYPE (msym
) != mst_solib_trampoline
)
363 return orig_pc
== pc
? 0 : pc
& ~0x3;
365 else if (msym
!= NULL
&& MSYMBOL_TYPE (msym
) == mst_solib_trampoline
)
367 struct objfile
*objfile
;
368 struct minimal_symbol
*msymbol
;
369 int function_found
= 0;
371 /* go look if there is another minimal symbol with the same name as
372 this one, but with type mst_text. This would happen if the msym
373 is an actual trampoline, in which case there would be another
374 symbol with the same name corresponding to the real function */
376 ALL_MSYMBOLS (objfile
, msymbol
)
378 if (MSYMBOL_TYPE (msymbol
) == mst_text
379 && strcmp (DEPRECATED_SYMBOL_NAME (msymbol
),
380 DEPRECATED_SYMBOL_NAME (msym
)) == 0)
388 /* the type of msym is correct (mst_solib_trampoline), but
389 the unwind info is wrong, so set it to the correct value */
390 u
->stub_unwind
.stub_type
= EXPORT
;
392 /* the stub type info in the unwind is correct (this is not a
393 trampoline), but the msym type information is wrong, it
394 should be mst_text. So we need to fix the msym, and also
395 get out of this function */
397 MSYMBOL_TYPE (msym
) = mst_text
;
398 return orig_pc
== pc
? 0 : pc
& ~0x3;
402 /*--------------------------------------------------------------------------*/
405 /* It's a stub. Search for a branch and figure out where it goes.
406 Note we have to handle multi insn branch sequences like ldil;ble.
407 Most (all?) other branches can be determined by examining the contents
408 of certain registers and the stack. */
415 /* Make sure we haven't walked outside the range of this stub. */
416 if (u
!= find_unwind_entry (loc
))
418 warning (_("Unable to find branch in linker stub"));
419 return orig_pc
== pc
? 0 : pc
& ~0x3;
422 prev_inst
= curr_inst
;
423 curr_inst
= read_memory_integer (loc
, 4);
425 /* Does it look like a branch external using %r1? Then it's the
426 branch from the stub to the actual function. */
427 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
429 /* Yup. See if the previous instruction loaded
430 a value into %r1. If so compute and return the jump address. */
431 if ((prev_inst
& 0xffe00000) == 0x20200000)
432 return (hppa_extract_21 (prev_inst
) + hppa_extract_17 (curr_inst
)) & ~0x3;
435 warning (_("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."));
436 return orig_pc
== pc
? 0 : pc
& ~0x3;
440 /* Does it look like a be 0(sr0,%r21)? OR
441 Does it look like a be, n 0(sr0,%r21)? OR
442 Does it look like a bve (r21)? (this is on PA2.0)
443 Does it look like a bve, n(r21)? (this is also on PA2.0)
444 That's the branch from an
445 import stub to an export stub.
447 It is impossible to determine the target of the branch via
448 simple examination of instructions and/or data (consider
449 that the address in the plabel may be the address of the
450 bind-on-reference routine in the dynamic loader).
452 So we have try an alternative approach.
454 Get the name of the symbol at our current location; it should
455 be a stub symbol with the same name as the symbol in the
458 Then lookup a minimal symbol with the same name; we should
459 get the minimal symbol for the target routine in the shared
460 library as those take precedence of import/export stubs. */
461 if ((curr_inst
== 0xe2a00000) ||
462 (curr_inst
== 0xe2a00002) ||
463 (curr_inst
== 0xeaa0d000) ||
464 (curr_inst
== 0xeaa0d002))
466 struct minimal_symbol
*stubsym
, *libsym
;
468 stubsym
= lookup_minimal_symbol_by_pc (loc
);
471 warning (_("Unable to find symbol for 0x%lx"), loc
);
472 return orig_pc
== pc
? 0 : pc
& ~0x3;
475 libsym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym
), NULL
, NULL
);
478 warning (_("Unable to find library symbol for %s."),
479 DEPRECATED_SYMBOL_NAME (stubsym
));
480 return orig_pc
== pc
? 0 : pc
& ~0x3;
483 return SYMBOL_VALUE (libsym
);
486 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
487 branch from the stub to the actual function. */
489 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
490 || (curr_inst
& 0xffe0e000) == 0xe8000000
491 || (curr_inst
& 0xffe0e000) == 0xe800A000)
492 return (loc
+ hppa_extract_17 (curr_inst
) + 8) & ~0x3;
494 /* Does it look like bv (rp)? Note this depends on the
495 current stack pointer being the same as the stack
496 pointer in the stub itself! This is a branch on from the
497 stub back to the original caller. */
498 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
499 else if ((curr_inst
& 0xffe0f000) == 0xe840c000)
501 /* Yup. See if the previous instruction loaded
503 if (prev_inst
== 0x4bc23ff1)
506 sp
= get_frame_register_unsigned (frame
, HPPA_SP_REGNUM
);
507 return read_memory_integer (sp
- 8, 4) & ~0x3;
511 warning (_("Unable to find restore of %%rp before bv (%%rp)."));
512 return orig_pc
== pc
? 0 : pc
& ~0x3;
516 /* elz: added this case to capture the new instruction
517 at the end of the return part of an export stub used by
518 the PA2.0: BVE, n (rp) */
519 else if ((curr_inst
& 0xffe0f000) == 0xe840d000)
521 return (read_memory_integer
522 (get_frame_register_unsigned (frame
, HPPA_SP_REGNUM
) - 24,
523 gdbarch_ptr_bit (gdbarch
) / 8)) & ~0x3;
526 /* What about be,n 0(sr0,%rp)? It's just another way we return to
527 the original caller from the stub. Used in dynamic executables. */
528 else if (curr_inst
== 0xe0400002)
530 /* The value we jump to is sitting in sp - 24. But that's
531 loaded several instructions before the be instruction.
532 I guess we could check for the previous instruction being
533 mtsp %r1,%sr0 if we want to do sanity checking. */
534 return (read_memory_integer
535 (get_frame_register_unsigned (frame
, HPPA_SP_REGNUM
) - 24,
536 gdbarch_ptr_bit (gdbarch
) / 8)) & ~0x3;
539 /* Haven't found the branch yet, but we're still in the stub.
546 hppa_skip_permanent_breakpoint (struct regcache
*regcache
)
548 /* To step over a breakpoint instruction on the PA takes some
549 fiddling with the instruction address queue.
551 When we stop at a breakpoint, the IA queue front (the instruction
552 we're executing now) points at the breakpoint instruction, and
553 the IA queue back (the next instruction to execute) points to
554 whatever instruction we would execute after the breakpoint, if it
555 were an ordinary instruction. This is the case even if the
556 breakpoint is in the delay slot of a branch instruction.
558 Clearly, to step past the breakpoint, we need to set the queue
559 front to the back. But what do we put in the back? What
560 instruction comes after that one? Because of the branch delay
561 slot, the next insn is always at the back + 4. */
563 ULONGEST pcoq_tail
, pcsq_tail
;
564 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, &pcoq_tail
);
565 regcache_cooked_read_unsigned (regcache
, HPPA_PCSQ_TAIL_REGNUM
, &pcsq_tail
);
567 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pcoq_tail
);
568 regcache_cooked_write_unsigned (regcache
, HPPA_PCSQ_HEAD_REGNUM
, pcsq_tail
);
570 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pcoq_tail
+ 4);
571 /* We can leave the tail's space the same, since there's no jump. */
576 struct hppa_hpux_sigtramp_unwind_cache
579 struct trad_frame_saved_reg
*saved_regs
;
582 static int hppa_hpux_tramp_reg
[] = {
584 HPPA_PCOQ_HEAD_REGNUM
,
585 HPPA_PCSQ_HEAD_REGNUM
,
586 HPPA_PCOQ_TAIL_REGNUM
,
587 HPPA_PCSQ_TAIL_REGNUM
,
614 static struct hppa_hpux_sigtramp_unwind_cache
*
615 hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
619 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
620 struct gdbarch_tdep
*tdep
= gdbarch_tdep (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 (next_frame
);
633 sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
635 if (IS_32BIT_TARGET (gdbarch
))
642 /* See /usr/include/machine/save_state.h for the structure of the save_state_t
645 flag
= read_memory_unsigned_integer(scptr
+ HPPA_HPUX_SS_FLAGS_OFFSET
, 4);
647 if (!(flag
& HPPA_HPUX_SS_WIDEREGS
))
649 /* Narrow registers. */
650 off
= scptr
+ HPPA_HPUX_SS_NARROW_OFFSET
;
656 /* Wide registers. */
657 off
= scptr
+ HPPA_HPUX_SS_WIDE_OFFSET
+ 8;
659 szoff
= (tdep
->bytes_per_address
== 4 ? 4 : 0);
662 for (i
= 1; i
< 32; i
++)
664 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= off
+ szoff
;
668 for (i
= 0; i
< ARRAY_SIZE (hppa_hpux_tramp_reg
); i
++)
670 if (hppa_hpux_tramp_reg
[i
] > 0)
671 info
->saved_regs
[hppa_hpux_tramp_reg
[i
]].addr
= off
+ szoff
;
678 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
684 hppa_hpux_sigtramp_frame_this_id (struct frame_info
*next_frame
,
685 void **this_prologue_cache
,
686 struct frame_id
*this_id
)
688 struct hppa_hpux_sigtramp_unwind_cache
*info
689 = hppa_hpux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
690 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
694 hppa_hpux_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
695 void **this_prologue_cache
,
696 int regnum
, int *optimizedp
,
697 enum lval_type
*lvalp
,
699 int *realnump
, gdb_byte
*valuep
)
701 struct hppa_hpux_sigtramp_unwind_cache
*info
702 = hppa_hpux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
703 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
704 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
707 static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind
= {
709 hppa_hpux_sigtramp_frame_this_id
,
710 hppa_hpux_sigtramp_frame_prev_register
713 static const struct frame_unwind
*
714 hppa_hpux_sigtramp_unwind_sniffer (struct frame_info
*next_frame
)
716 struct unwind_table_entry
*u
;
717 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
719 u
= find_unwind_entry (pc
);
721 /* If this is an export stub, try to get the unwind descriptor for
722 the actual function itself. */
723 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
725 gdb_byte buf
[HPPA_INSN_SIZE
];
728 if (!safe_frame_unwind_memory (next_frame
, u
->region_start
,
732 insn
= extract_unsigned_integer (buf
, sizeof buf
);
733 if ((insn
& 0xffe0e000) == 0xe8400000)
734 u
= find_unwind_entry(u
->region_start
+ hppa_extract_17 (insn
) + 8);
737 if (u
&& u
->HP_UX_interrupt_marker
)
738 return &hppa_hpux_sigtramp_frame_unwind
;
744 hppa32_hpux_find_global_pointer (struct value
*function
)
748 faddr
= value_as_address (function
);
750 /* Is this a plabel? If so, dereference it to get the gp value. */
758 status
= target_read_memory (faddr
+ 4, buf
, sizeof (buf
));
760 return extract_unsigned_integer (buf
, sizeof (buf
));
763 return gdbarch_tdep (current_gdbarch
)->solib_get_got_by_pc (faddr
);
767 hppa64_hpux_find_global_pointer (struct value
*function
)
772 faddr
= value_as_address (function
);
774 if (in_opd_section (faddr
))
776 target_read_memory (faddr
, buf
, sizeof (buf
));
777 return extract_unsigned_integer (&buf
[24], 8);
781 return gdbarch_tdep (current_gdbarch
)->solib_get_got_by_pc (faddr
);
785 static unsigned int ldsid_pattern
[] = {
786 0x000010a0, /* ldsid (rX),rY */
787 0x00001820, /* mtsp rY,sr0 */
788 0xe0000000 /* be,n (sr0,rX) */
792 hppa_hpux_search_pattern (CORE_ADDR start
, CORE_ADDR end
,
793 unsigned int *patterns
, int count
)
795 int num_insns
= (end
- start
+ HPPA_INSN_SIZE
) / HPPA_INSN_SIZE
;
800 buf
= alloca (num_insns
* HPPA_INSN_SIZE
);
801 insns
= alloca (num_insns
* sizeof (unsigned int));
803 read_memory (start
, buf
, num_insns
* HPPA_INSN_SIZE
);
804 for (i
= 0; i
< num_insns
; i
++, buf
+= HPPA_INSN_SIZE
)
805 insns
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
);
807 for (offset
= 0; offset
<= num_insns
- count
; offset
++)
809 for (i
= 0; i
< count
; i
++)
811 if ((insns
[offset
+ i
] & patterns
[i
]) != patterns
[i
])
818 if (offset
<= num_insns
- count
)
819 return start
+ offset
* HPPA_INSN_SIZE
;
825 hppa32_hpux_search_dummy_call_sequence (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
829 struct obj_section
*sec
;
830 struct hppa_objfile_private
*priv
;
831 struct frame_info
*frame
;
832 struct unwind_table_entry
*u
;
837 sec
= find_pc_section (pc
);
839 priv
= objfile_data (obj
, hppa_objfile_priv_data
);
842 priv
= hppa_init_objfile_priv_data (obj
);
844 error (_("Internal error creating objfile private data."));
846 /* Use the cached value if we have one. */
847 if (priv
->dummy_call_sequence_addr
!= 0)
849 *argreg
= priv
->dummy_call_sequence_reg
;
850 return priv
->dummy_call_sequence_addr
;
853 /* First try a heuristic; if we are in a shared library call, our return
854 pointer is likely to point at an export stub. */
855 frame
= get_current_frame ();
856 rp
= frame_unwind_register_unsigned (frame
, 2);
857 u
= find_unwind_entry (rp
);
858 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
860 addr
= hppa_hpux_search_pattern (u
->region_start
, u
->region_end
,
862 ARRAY_SIZE (ldsid_pattern
));
867 /* Next thing to try is to look for an export stub. */
868 if (priv
->unwind_info
)
872 for (i
= 0; i
< priv
->unwind_info
->last
; i
++)
874 struct unwind_table_entry
*u
;
875 u
= &priv
->unwind_info
->table
[i
];
876 if (u
->stub_unwind
.stub_type
== EXPORT
)
878 addr
= hppa_hpux_search_pattern (u
->region_start
, u
->region_end
,
880 ARRAY_SIZE (ldsid_pattern
));
889 /* Finally, if this is the main executable, try to locate a sequence
891 addr
= hppa_symbol_address ("noshlibs");
892 sec
= find_pc_section (addr
);
894 if (sec
&& sec
->objfile
== obj
)
896 CORE_ADDR start
, end
;
898 find_pc_partial_function (addr
, NULL
, &start
, &end
);
899 if (start
!= 0 && end
!= 0)
901 addr
= hppa_hpux_search_pattern (start
, end
, ldsid_pattern
,
902 ARRAY_SIZE (ldsid_pattern
));
908 /* Can't find a suitable sequence. */
912 target_read_memory (addr
, buf
, sizeof (buf
));
913 insn
= extract_unsigned_integer (buf
, sizeof (buf
));
914 priv
->dummy_call_sequence_addr
= addr
;
915 priv
->dummy_call_sequence_reg
= (insn
>> 21) & 0x1f;
917 *argreg
= priv
->dummy_call_sequence_reg
;
918 return priv
->dummy_call_sequence_addr
;
922 hppa64_hpux_search_dummy_call_sequence (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
926 struct obj_section
*sec
;
927 struct hppa_objfile_private
*priv
;
929 struct minimal_symbol
*msym
;
932 sec
= find_pc_section (pc
);
934 priv
= objfile_data (obj
, hppa_objfile_priv_data
);
937 priv
= hppa_init_objfile_priv_data (obj
);
939 error (_("Internal error creating objfile private data."));
941 /* Use the cached value if we have one. */
942 if (priv
->dummy_call_sequence_addr
!= 0)
944 *argreg
= priv
->dummy_call_sequence_reg
;
945 return priv
->dummy_call_sequence_addr
;
948 /* FIXME: Without stub unwind information, locating a suitable sequence is
949 fairly difficult. For now, we implement a very naive and inefficient
950 scheme; try to read in blocks of code, and look for a "bve,n (rp)"
951 instruction. These are likely to occur at the end of functions, so
952 we only look at the last two instructions of each function. */
953 for (i
= 0, msym
= obj
->msymbols
; i
< obj
->minimal_symbol_count
; i
++, msym
++)
955 CORE_ADDR begin
, end
;
957 gdb_byte buf
[2 * HPPA_INSN_SIZE
];
960 find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym
), &name
,
963 if (name
== NULL
|| begin
== 0 || end
== 0)
966 if (target_read_memory (end
- sizeof (buf
), buf
, sizeof (buf
)) == 0)
968 for (offset
= 0; offset
< sizeof (buf
); offset
++)
972 insn
= extract_unsigned_integer (buf
+ offset
, HPPA_INSN_SIZE
);
973 if (insn
== 0xe840d002) /* bve,n (rp) */
975 addr
= (end
- sizeof (buf
)) + offset
;
982 /* Can't find a suitable sequence. */
986 priv
->dummy_call_sequence_addr
= addr
;
987 /* Right now we only look for a "bve,l (rp)" sequence, so the register is
988 always HPPA_RP_REGNUM. */
989 priv
->dummy_call_sequence_reg
= HPPA_RP_REGNUM
;
991 *argreg
= priv
->dummy_call_sequence_reg
;
992 return priv
->dummy_call_sequence_addr
;
996 hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr
)
998 struct objfile
*objfile
;
999 struct minimal_symbol
*funsym
, *stubsym
;
1002 funsym
= lookup_minimal_symbol_by_pc (funcaddr
);
1005 ALL_OBJFILES (objfile
)
1007 stubsym
= lookup_minimal_symbol_solib_trampoline
1008 (SYMBOL_LINKAGE_NAME (funsym
), objfile
);
1012 struct unwind_table_entry
*u
;
1014 u
= find_unwind_entry (SYMBOL_VALUE (stubsym
));
1016 || (u
->stub_unwind
.stub_type
!= IMPORT
1017 && u
->stub_unwind
.stub_type
!= IMPORT_SHLIB
))
1020 stubaddr
= SYMBOL_VALUE (stubsym
);
1022 /* If we found an IMPORT stub, then we can stop searching;
1023 if we found an IMPORT_SHLIB, we want to continue the search
1024 in the hopes that we will find an IMPORT stub. */
1025 if (u
->stub_unwind
.stub_type
== IMPORT
)
1034 hppa_hpux_sr_for_addr (CORE_ADDR addr
)
1037 /* The space register to use is encoded in the top 2 bits of the address. */
1038 sr
= addr
>> (gdbarch_tdep (current_gdbarch
)->bytes_per_address
* 8 - 2);
1043 hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr
)
1045 /* In order for us to restore the space register to its starting state,
1046 we need the dummy trampoline to return to the an instruction address in
1047 the same space as where we started the call. We used to place the
1048 breakpoint near the current pc, however, this breaks nested dummy calls
1049 as the nested call will hit the breakpoint address and terminate
1050 prematurely. Instead, we try to look for an address in the same space to
1053 This is similar in spirit to putting the breakpoint at the "entry point"
1054 of an executable. */
1056 struct obj_section
*sec
;
1057 struct unwind_table_entry
*u
;
1058 struct minimal_symbol
*msym
;
1062 sec
= find_pc_section (addr
);
1065 /* First try the lowest address in the section; we can use it as long
1066 as it is "regular" code (i.e. not a stub) */
1067 u
= find_unwind_entry (sec
->addr
);
1068 if (!u
|| u
->stub_unwind
.stub_type
== 0)
1071 /* Otherwise, we need to find a symbol for a regular function. We
1072 do this by walking the list of msymbols in the objfile. The symbol
1073 we find should not be the same as the function that was passed in. */
1075 /* FIXME: this is broken, because we can find a function that will be
1076 called by the dummy call target function, which will still not
1079 find_pc_partial_function (addr
, NULL
, &func
, NULL
);
1080 for (i
= 0, msym
= sec
->objfile
->msymbols
;
1081 i
< sec
->objfile
->minimal_symbol_count
;
1084 u
= find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym
));
1085 if (func
!= SYMBOL_VALUE_ADDRESS (msym
)
1086 && (!u
|| u
->stub_unwind
.stub_type
== 0))
1087 return SYMBOL_VALUE_ADDRESS (msym
);
1091 warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1092 "calls may fail."));
1097 hppa_hpux_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
,
1099 struct value
**args
, int nargs
,
1100 struct type
*value_type
,
1101 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
1102 struct regcache
*regcache
)
1104 CORE_ADDR pc
, stubaddr
;
1109 /* Note: we don't want to pass a function descriptor here; push_dummy_call
1110 fills in the PIC register for us. */
1111 funcaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funcaddr
, NULL
);
1113 /* The simple case is where we call a function in the same space that we are
1114 currently in; in that case we don't really need to do anything. */
1115 if (hppa_hpux_sr_for_addr (pc
) == hppa_hpux_sr_for_addr (funcaddr
))
1117 /* Intraspace call. */
1118 *bp_addr
= hppa_hpux_find_dummy_bpaddr (pc
);
1119 *real_pc
= funcaddr
;
1120 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, *bp_addr
);
1125 /* In order to make an interspace call, we need to go through a stub.
1126 gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1127 an application is compiled with HP compilers then this stub is not
1128 available. We used to fallback to "__d_plt_call", however that stub
1129 is not entirely useful for us because it doesn't do an interspace
1130 return back to the caller. Also, on hppa64-hpux, there is no
1131 __gcc_plt_call available. In order to keep the code uniform, we
1132 instead don't use either of these stubs, but instead write our own
1135 A problem arises since the stack is located in a different space than
1136 code, so in order to branch to a stack stub, we will need to do an
1137 interspace branch. Previous versions of gdb did this by modifying code
1138 at the current pc and doing single-stepping to set the pcsq. Since this
1139 is highly undesirable, we use a different scheme:
1141 All we really need to do the branch to the stub is a short instruction
1152 Instead of writing these sequences ourselves, we can find it in
1153 the instruction stream that belongs to the current space. While this
1154 seems difficult at first, we are actually guaranteed to find the sequences
1158 - in export stubs for shared libraries
1159 - in the "noshlibs" routine in the main module
1162 - at the end of each "regular" function
1164 We cache the address of these sequences in the objfile's private data
1165 since these operations can potentially be quite expensive.
1168 - write a stack trampoline
1169 - look for a suitable instruction sequence in the current space
1170 - point the sequence at the trampoline
1171 - set the return address of the trampoline to the current space
1172 (see hppa_hpux_find_dummy_call_bpaddr)
1173 - set the continuing address of the "dummy code" as the sequence.
1177 if (IS_32BIT_TARGET (gdbarch
))
1179 static unsigned int hppa32_tramp
[] = {
1180 0x0fdf1291, /* stw r31,-8(,sp) */
1181 0x02c010a1, /* ldsid (,r22),r1 */
1182 0x00011820, /* mtsp r1,sr0 */
1183 0xe6c00000, /* be,l 0(sr0,r22),%sr0,%r31 */
1184 0x081f0242, /* copy r31,rp */
1185 0x0fd11082, /* ldw -8(,sp),rp */
1186 0x004010a1, /* ldsid (,rp),r1 */
1187 0x00011820, /* mtsp r1,sr0 */
1188 0xe0400000, /* be 0(sr0,rp) */
1189 0x08000240 /* nop */
1192 /* for hppa32, we must call the function through a stub so that on
1193 return it can return to the space of our trampoline. */
1194 stubaddr
= hppa_hpux_find_import_stub_for_addr (funcaddr
);
1196 error (_("Cannot call external function not referenced by application "
1197 "(no import stub).\n"));
1198 regcache_cooked_write_unsigned (regcache
, 22, stubaddr
);
1200 write_memory (sp
, (char *)&hppa32_tramp
, sizeof (hppa32_tramp
));
1202 *bp_addr
= hppa_hpux_find_dummy_bpaddr (pc
);
1203 regcache_cooked_write_unsigned (regcache
, 31, *bp_addr
);
1205 *real_pc
= hppa32_hpux_search_dummy_call_sequence (gdbarch
, pc
, &argreg
);
1207 error (_("Cannot make interspace call from here."));
1209 regcache_cooked_write_unsigned (regcache
, argreg
, sp
);
1211 sp
+= sizeof (hppa32_tramp
);
1215 static unsigned int hppa64_tramp
[] = {
1216 0xeac0f000, /* bve,l (r22),%r2 */
1217 0x0fdf12d1, /* std r31,-8(,sp) */
1218 0x0fd110c2, /* ldd -8(,sp),rp */
1219 0xe840d002, /* bve,n (rp) */
1220 0x08000240 /* nop */
1223 /* for hppa64, we don't need to call through a stub; all functions
1224 return via a bve. */
1225 regcache_cooked_write_unsigned (regcache
, 22, funcaddr
);
1226 write_memory (sp
, (char *)&hppa64_tramp
, sizeof (hppa64_tramp
));
1229 regcache_cooked_write_unsigned (regcache
, 31, *bp_addr
);
1231 *real_pc
= hppa64_hpux_search_dummy_call_sequence (gdbarch
, pc
, &argreg
);
1233 error (_("Cannot make interspace call from here."));
1235 regcache_cooked_write_unsigned (regcache
, argreg
, sp
);
1237 sp
+= sizeof (hppa64_tramp
);
1240 sp
= gdbarch_frame_align (gdbarch
, sp
);
1248 hppa_hpux_supply_ss_narrow (struct regcache
*regcache
,
1249 int regnum
, const char *save_state
)
1251 const char *ss_narrow
= save_state
+ HPPA_HPUX_SS_NARROW_OFFSET
;
1254 for (i
= HPPA_R1_REGNUM
; i
< HPPA_FP0_REGNUM
; i
++)
1256 if (regnum
== i
|| regnum
== -1)
1257 regcache_raw_supply (regcache
, i
, ss_narrow
+ offset
);
1264 hppa_hpux_supply_ss_fpblock (struct regcache
*regcache
,
1265 int regnum
, const char *save_state
)
1267 const char *ss_fpblock
= save_state
+ HPPA_HPUX_SS_FPBLOCK_OFFSET
;
1270 /* FIXME: We view the floating-point state as 64 single-precision
1271 registers for 32-bit code, and 32 double-precision register for
1272 64-bit code. This distinction is artificial and should be
1273 eliminated. If that ever happens, we should remove the if-clause
1276 if (register_size (get_regcache_arch (regcache
), HPPA_FP0_REGNUM
) == 4)
1278 for (i
= HPPA_FP0_REGNUM
; i
< HPPA_FP0_REGNUM
+ 64; i
++)
1280 if (regnum
== i
|| regnum
== -1)
1281 regcache_raw_supply (regcache
, i
, ss_fpblock
+ offset
);
1288 for (i
= HPPA_FP0_REGNUM
; i
< HPPA_FP0_REGNUM
+ 32; i
++)
1290 if (regnum
== i
|| regnum
== -1)
1291 regcache_raw_supply (regcache
, i
, ss_fpblock
+ offset
);
1299 hppa_hpux_supply_ss_wide (struct regcache
*regcache
,
1300 int regnum
, const char *save_state
)
1302 const char *ss_wide
= save_state
+ HPPA_HPUX_SS_WIDE_OFFSET
;
1305 if (register_size (get_regcache_arch (regcache
), HPPA_R1_REGNUM
) == 4)
1308 for (i
= HPPA_R1_REGNUM
; i
< HPPA_FP0_REGNUM
; i
++)
1310 if (regnum
== i
|| regnum
== -1)
1311 regcache_raw_supply (regcache
, i
, ss_wide
+ offset
);
1318 hppa_hpux_supply_save_state (const struct regset
*regset
,
1319 struct regcache
*regcache
,
1320 int regnum
, const void *regs
, size_t len
)
1322 const char *proc_info
= regs
;
1323 const char *save_state
= proc_info
+ 8;
1326 flags
= extract_unsigned_integer (save_state
+ HPPA_HPUX_SS_FLAGS_OFFSET
, 4);
1327 if (regnum
== -1 || regnum
== HPPA_FLAGS_REGNUM
)
1329 struct gdbarch
*arch
= get_regcache_arch (regcache
);
1330 size_t size
= register_size (arch
, HPPA_FLAGS_REGNUM
);
1333 store_unsigned_integer (buf
, size
, flags
);
1334 regcache_raw_supply (regcache
, HPPA_FLAGS_REGNUM
, buf
);
1337 /* If the SS_WIDEREGS flag is set, we really do need the full
1338 `struct save_state'. */
1339 if (flags
& HPPA_HPUX_SS_WIDEREGS
&& len
< HPPA_HPUX_SAVE_STATE_SIZE
)
1340 error (_("Register set contents too small"));
1342 if (flags
& HPPA_HPUX_SS_WIDEREGS
)
1343 hppa_hpux_supply_ss_wide (regcache
, regnum
, save_state
);
1345 hppa_hpux_supply_ss_narrow (regcache
, regnum
, save_state
);
1347 hppa_hpux_supply_ss_fpblock (regcache
, regnum
, save_state
);
1350 /* HP-UX register set. */
1352 static struct regset hppa_hpux_regset
=
1355 hppa_hpux_supply_save_state
1358 static const struct regset
*
1359 hppa_hpux_regset_from_core_section (struct gdbarch
*gdbarch
,
1360 const char *sect_name
, size_t sect_size
)
1362 if (strcmp (sect_name
, ".reg") == 0
1363 && sect_size
>= HPPA_HPUX_PA89_SAVE_STATE_SIZE
+ 8)
1364 return &hppa_hpux_regset
;
1370 /* Bit in the `ss_flag' member of `struct save_state' that indicates
1371 the state was saved from a system call. From
1372 <machine/save_state.h>. */
1373 #define HPPA_HPUX_SS_INSYSCALL 0x02
1376 hppa_hpux_read_pc (struct regcache
*regcache
)
1380 /* If we're currently in a system call return the contents of %r31. */
1381 regcache_cooked_read_unsigned (regcache
, HPPA_FLAGS_REGNUM
, &flags
);
1382 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1385 regcache_cooked_read_unsigned (regcache
, HPPA_R31_REGNUM
, &pc
);
1389 return hppa_read_pc (regcache
);
1393 hppa_hpux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1397 /* If we're currently in a system call also write PC into %r31. */
1398 regcache_cooked_read_unsigned (regcache
, HPPA_FLAGS_REGNUM
, &flags
);
1399 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1400 regcache_cooked_write_unsigned (regcache
, HPPA_R31_REGNUM
, pc
| 0x3);
1402 return hppa_write_pc (regcache
, pc
);
1406 hppa_hpux_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1410 /* If we're currently in a system call return the contents of %r31. */
1411 flags
= frame_unwind_register_unsigned (next_frame
, HPPA_FLAGS_REGNUM
);
1412 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1413 return frame_unwind_register_unsigned (next_frame
, HPPA_R31_REGNUM
) & ~0x3;
1415 return hppa_unwind_pc (gdbarch
, next_frame
);
1419 /* Given the current value of the pc, check to see if it is inside a stub, and
1420 if so, change the value of the pc to point to the caller of the stub.
1421 NEXT_FRAME is the next frame in the current list of frames.
1422 BASE contains to stack frame base of the current frame.
1423 SAVE_REGS is the register file stored in the frame cache. */
1425 hppa_hpux_unwind_adjust_stub (struct frame_info
*next_frame
, CORE_ADDR base
,
1426 struct trad_frame_saved_reg
*saved_regs
)
1428 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
1429 int optimized
, realreg
;
1430 enum lval_type lval
;
1432 char buffer
[sizeof(ULONGEST
)];
1435 struct unwind_table_entry
*u
;
1437 trad_frame_get_prev_register (next_frame
, saved_regs
,
1438 HPPA_PCOQ_HEAD_REGNUM
,
1439 &optimized
, &lval
, &addr
, &realreg
, buffer
);
1440 val
= extract_unsigned_integer (buffer
,
1441 register_size (get_frame_arch (next_frame
),
1442 HPPA_PCOQ_HEAD_REGNUM
));
1444 u
= find_unwind_entry (val
);
1445 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
1447 stubpc
= read_memory_integer
1448 (base
- 24, gdbarch_ptr_bit (gdbarch
) / 8);
1449 trad_frame_set_value (saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, stubpc
);
1451 else if (hppa_symbol_address ("__gcc_plt_call")
1452 == get_pc_function_start (val
))
1454 stubpc
= read_memory_integer
1455 (base
- 8, gdbarch_ptr_bit (gdbarch
) / 8);
1456 trad_frame_set_value (saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, stubpc
);
1461 hppa_hpux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1463 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1465 if (IS_32BIT_TARGET (gdbarch
))
1466 tdep
->in_solib_call_trampoline
= hppa32_hpux_in_solib_call_trampoline
;
1468 tdep
->in_solib_call_trampoline
= hppa64_hpux_in_solib_call_trampoline
;
1470 tdep
->unwind_adjust_stub
= hppa_hpux_unwind_adjust_stub
;
1472 set_gdbarch_in_solib_return_trampoline
1473 (gdbarch
, hppa_hpux_in_solib_return_trampoline
);
1474 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_hpux_skip_trampoline_code
);
1476 set_gdbarch_push_dummy_code (gdbarch
, hppa_hpux_push_dummy_code
);
1477 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1479 set_gdbarch_read_pc (gdbarch
, hppa_hpux_read_pc
);
1480 set_gdbarch_write_pc (gdbarch
, hppa_hpux_write_pc
);
1481 set_gdbarch_unwind_pc (gdbarch
, hppa_hpux_unwind_pc
);
1482 set_gdbarch_skip_permanent_breakpoint
1483 (gdbarch
, hppa_skip_permanent_breakpoint
);
1485 set_gdbarch_regset_from_core_section
1486 (gdbarch
, hppa_hpux_regset_from_core_section
);
1488 frame_unwind_append_sniffer (gdbarch
, hppa_hpux_sigtramp_unwind_sniffer
);
1492 hppa_hpux_som_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1494 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1498 tdep
->find_global_pointer
= hppa32_hpux_find_global_pointer
;
1500 hppa_hpux_init_abi (info
, gdbarch
);
1501 som_solib_select (gdbarch
);
1505 hppa_hpux_elf_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1507 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1510 tdep
->find_global_pointer
= hppa64_hpux_find_global_pointer
;
1512 hppa_hpux_init_abi (info
, gdbarch
);
1513 pa64_solib_select (gdbarch
);
1516 static enum gdb_osabi
1517 hppa_hpux_core_osabi_sniffer (bfd
*abfd
)
1519 if (strcmp (bfd_get_target (abfd
), "hpux-core") == 0)
1520 return GDB_OSABI_HPUX_SOM
;
1521 else if (strcmp (bfd_get_target (abfd
), "elf64-hppa") == 0)
1525 section
= bfd_get_section_by_name (abfd
, ".kernel");
1531 size
= bfd_section_size (abfd
, section
);
1532 contents
= alloca (size
);
1533 if (bfd_get_section_contents (abfd
, section
, contents
,
1535 && strcmp (contents
, "HP-UX") == 0)
1536 return GDB_OSABI_HPUX_ELF
;
1540 return GDB_OSABI_UNKNOWN
;
1544 _initialize_hppa_hpux_tdep (void)
1546 /* BFD doesn't set a flavour for HP-UX style core files. It doesn't
1547 set the architecture either. */
1548 gdbarch_register_osabi_sniffer (bfd_arch_unknown
,
1549 bfd_target_unknown_flavour
,
1550 hppa_hpux_core_osabi_sniffer
);
1551 gdbarch_register_osabi_sniffer (bfd_arch_hppa
,
1552 bfd_target_elf_flavour
,
1553 hppa_hpux_core_osabi_sniffer
);
1555 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_HPUX_SOM
,
1556 hppa_hpux_som_init_abi
);
1557 gdbarch_register_osabi (bfd_arch_hppa
, bfd_mach_hppa20w
, GDB_OSABI_HPUX_ELF
,
1558 hppa_hpux_elf_init_abi
);