1 /* Target-dependent code for HP-UX on PA-RISC.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007 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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
23 #include "arch-utils.h"
27 #include "frame-unwind.h"
28 #include "trad-frame.h"
34 #include "hppa-tdep.h"
35 #include "solib-som.h"
36 #include "solib-pa64.h"
39 #include "exceptions.h"
41 #include "gdb_string.h"
43 #define IS_32BIT_TARGET(_gdbarch) \
44 ((gdbarch_tdep (_gdbarch))->bytes_per_address == 4)
46 /* Bit in the `ss_flag' member of `struct save_state' that indicates
47 that the 64-bit register values are live. From
48 <machine/save_state.h>. */
49 #define HPPA_HPUX_SS_WIDEREGS 0x40
51 /* Offsets of various parts of `struct save_state'. From
52 <machine/save_state.h>. */
53 #define HPPA_HPUX_SS_FLAGS_OFFSET 0
54 #define HPPA_HPUX_SS_NARROW_OFFSET 4
55 #define HPPA_HPUX_SS_FPBLOCK_OFFSET 256
56 #define HPPA_HPUX_SS_WIDE_OFFSET 640
58 /* The size of `struct save_state. */
59 #define HPPA_HPUX_SAVE_STATE_SIZE 1152
61 /* The size of `struct pa89_save_state', which corresponds to PA-RISC
62 1.1, the lowest common denominator that we support. */
63 #define HPPA_HPUX_PA89_SAVE_STATE_SIZE 512
66 /* Forward declarations. */
67 extern void _initialize_hppa_hpux_tdep (void);
68 extern initialize_file_ftype _initialize_hppa_hpux_tdep
;
71 in_opd_section (CORE_ADDR pc
)
73 struct obj_section
*s
;
76 s
= find_pc_section (pc
);
79 && s
->the_bfd_section
->name
!= NULL
80 && strcmp (s
->the_bfd_section
->name
, ".opd") == 0);
84 /* Return one if PC is in the call path of a trampoline, else return zero.
86 Note we return one for *any* call trampoline (long-call, arg-reloc), not
87 just shared library trampolines (import, export). */
90 hppa32_hpux_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
92 struct minimal_symbol
*minsym
;
93 struct unwind_table_entry
*u
;
95 /* First see if PC is in one of the two C-library trampolines. */
96 if (pc
== hppa_symbol_address("$$dyncall")
97 || pc
== hppa_symbol_address("_sr4export"))
100 minsym
= lookup_minimal_symbol_by_pc (pc
);
101 if (minsym
&& strcmp (DEPRECATED_SYMBOL_NAME (minsym
), ".stub") == 0)
104 /* Get the unwind descriptor corresponding to PC, return zero
105 if no unwind was found. */
106 u
= find_unwind_entry (pc
);
110 /* If this isn't a linker stub, then return now. */
111 if (u
->stub_unwind
.stub_type
== 0)
114 /* By definition a long-branch stub is a call stub. */
115 if (u
->stub_unwind
.stub_type
== LONG_BRANCH
)
118 /* The call and return path execute the same instructions within
119 an IMPORT stub! So an IMPORT stub is both a call and return
121 if (u
->stub_unwind
.stub_type
== IMPORT
)
124 /* Parameter relocation stubs always have a call path and may have a
126 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
127 || u
->stub_unwind
.stub_type
== EXPORT
)
131 /* Search forward from the current PC until we hit a branch
132 or the end of the stub. */
133 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
137 insn
= read_memory_integer (addr
, 4);
139 /* Does it look like a bl? If so then it's the call path, if
140 we find a bv or be first, then we're on the return path. */
141 if ((insn
& 0xfc00e000) == 0xe8000000)
143 else if ((insn
& 0xfc00e001) == 0xe800c000
144 || (insn
& 0xfc000000) == 0xe0000000)
148 /* Should never happen. */
149 warning (_("Unable to find branch in parameter relocation stub."));
153 /* Unknown stub type. For now, just return zero. */
158 hppa64_hpux_in_solib_call_trampoline (CORE_ADDR pc
, char *name
)
160 /* PA64 has a completely different stub/trampoline scheme. Is it
161 better? Maybe. It's certainly harder to determine with any
162 certainty that we are in a stub because we can not refer to the
165 The heuristic is simple. Try to lookup the current PC value in th
166 minimal symbol table. If that fails, then assume we are not in a
169 Then see if the PC value falls within the section bounds for the
170 section containing the minimal symbol we found in the first
171 step. If it does, then assume we are not in a stub and return.
173 Finally peek at the instructions to see if they look like a stub. */
174 struct minimal_symbol
*minsym
;
179 minsym
= lookup_minimal_symbol_by_pc (pc
);
183 sec
= SYMBOL_BFD_SECTION (minsym
);
185 if (bfd_get_section_vma (sec
->owner
, sec
) <= pc
186 && pc
< (bfd_get_section_vma (sec
->owner
, sec
)
187 + bfd_section_size (sec
->owner
, sec
)))
190 /* We might be in a stub. Peek at the instructions. Stubs are 3
191 instructions long. */
192 insn
= read_memory_integer (pc
, 4);
194 /* Find out where we think we are within the stub. */
195 if ((insn
& 0xffffc00e) == 0x53610000)
197 else if ((insn
& 0xffffffff) == 0xe820d000)
199 else if ((insn
& 0xffffc00e) == 0x537b0000)
204 /* Now verify each insn in the range looks like a stub instruction. */
205 insn
= read_memory_integer (addr
, 4);
206 if ((insn
& 0xffffc00e) != 0x53610000)
209 /* Now verify each insn in the range looks like a stub instruction. */
210 insn
= read_memory_integer (addr
+ 4, 4);
211 if ((insn
& 0xffffffff) != 0xe820d000)
214 /* Now verify each insn in the range looks like a stub instruction. */
215 insn
= read_memory_integer (addr
+ 8, 4);
216 if ((insn
& 0xffffc00e) != 0x537b0000)
219 /* Looks like a stub. */
223 /* Return one if PC is in the return path of a trampoline, else return zero.
225 Note we return one for *any* call trampoline (long-call, arg-reloc), not
226 just shared library trampolines (import, export). */
229 hppa_hpux_in_solib_return_trampoline (CORE_ADDR pc
, char *name
)
231 struct unwind_table_entry
*u
;
233 /* Get the unwind descriptor corresponding to PC, return zero
234 if no unwind was found. */
235 u
= find_unwind_entry (pc
);
239 /* If this isn't a linker stub or it's just a long branch stub, then
241 if (u
->stub_unwind
.stub_type
== 0 || u
->stub_unwind
.stub_type
== LONG_BRANCH
)
244 /* The call and return path execute the same instructions within
245 an IMPORT stub! So an IMPORT stub is both a call and return
247 if (u
->stub_unwind
.stub_type
== IMPORT
)
250 /* Parameter relocation stubs always have a call path and may have a
252 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
253 || u
->stub_unwind
.stub_type
== EXPORT
)
257 /* Search forward from the current PC until we hit a branch
258 or the end of the stub. */
259 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
263 insn
= read_memory_integer (addr
, 4);
265 /* Does it look like a bl? If so then it's the call path, if
266 we find a bv or be first, then we're on the return path. */
267 if ((insn
& 0xfc00e000) == 0xe8000000)
269 else if ((insn
& 0xfc00e001) == 0xe800c000
270 || (insn
& 0xfc000000) == 0xe0000000)
274 /* Should never happen. */
275 warning (_("Unable to find branch in parameter relocation stub."));
279 /* Unknown stub type. For now, just return zero. */
284 /* Figure out if PC is in a trampoline, and if so find out where
285 the trampoline will jump to. If not in a trampoline, return zero.
287 Simple code examination probably is not a good idea since the code
288 sequences in trampolines can also appear in user code.
290 We use unwinds and information from the minimal symbol table to
291 determine when we're in a trampoline. This won't work for ELF
292 (yet) since it doesn't create stub unwind entries. Whether or
293 not ELF will create stub unwinds or normal unwinds for linker
294 stubs is still being debated.
296 This should handle simple calls through dyncall or sr4export,
297 long calls, argument relocation stubs, and dyncall/sr4export
298 calling an argument relocation stub. It even handles some stubs
299 used in dynamic executables. */
302 hppa_hpux_skip_trampoline_code (CORE_ADDR pc
)
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
) read_register (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 (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
321 if (pc
== hppa_symbol_address("$$dyncall_external"))
323 pc
= (CORE_ADDR
) read_register (22);
324 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, TARGET_PTR_BIT
/ 8);
326 else if (pc
== hppa_symbol_address("_sr4export"))
327 pc
= (CORE_ADDR
) (read_register (22));
329 /* Get the unwind descriptor corresponding to PC, return zero
330 if no unwind was found. */
331 u
= find_unwind_entry (pc
);
335 /* If this isn't a linker stub, then return now. */
336 /* elz: attention here! (FIXME) because of a compiler/linker
337 error, some stubs which should have a non zero stub_unwind.stub_type
338 have unfortunately a value of zero. So this function would return here
339 as if we were not in a trampoline. To fix this, we go look at the partial
340 symbol information, which reports this guy as a stub.
341 (FIXME): Unfortunately, we are not that lucky: it turns out that the
342 partial symbol information is also wrong sometimes. This is because
343 when it is entered (somread.c::som_symtab_read()) it can happen that
344 if the type of the symbol (from the som) is Entry, and the symbol is
345 in a shared library, then it can also be a trampoline. This would
346 be OK, except that I believe the way they decide if we are ina shared library
347 does not work. SOOOO..., even if we have a regular function w/o trampolines
348 its minimal symbol can be assigned type mst_solib_trampoline.
349 Also, if we find that the symbol is a real stub, then we fix the unwind
350 descriptor, and define the stub type to be EXPORT.
351 Hopefully this is correct most of the times. */
352 if (u
->stub_unwind
.stub_type
== 0)
355 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
356 we can delete all the code which appears between the lines */
357 /*--------------------------------------------------------------------------*/
358 msym
= lookup_minimal_symbol_by_pc (pc
);
360 if (msym
== NULL
|| MSYMBOL_TYPE (msym
) != mst_solib_trampoline
)
361 return orig_pc
== pc
? 0 : pc
& ~0x3;
363 else if (msym
!= NULL
&& MSYMBOL_TYPE (msym
) == mst_solib_trampoline
)
365 struct objfile
*objfile
;
366 struct minimal_symbol
*msymbol
;
367 int function_found
= 0;
369 /* go look if there is another minimal symbol with the same name as
370 this one, but with type mst_text. This would happen if the msym
371 is an actual trampoline, in which case there would be another
372 symbol with the same name corresponding to the real function */
374 ALL_MSYMBOLS (objfile
, msymbol
)
376 if (MSYMBOL_TYPE (msymbol
) == mst_text
377 && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol
), DEPRECATED_SYMBOL_NAME (msym
)))
385 /* the type of msym is correct (mst_solib_trampoline), but
386 the unwind info is wrong, so set it to the correct value */
387 u
->stub_unwind
.stub_type
= EXPORT
;
389 /* the stub type info in the unwind is correct (this is not a
390 trampoline), but the msym type information is wrong, it
391 should be mst_text. So we need to fix the msym, and also
392 get out of this function */
394 MSYMBOL_TYPE (msym
) = mst_text
;
395 return orig_pc
== pc
? 0 : pc
& ~0x3;
399 /*--------------------------------------------------------------------------*/
402 /* It's a stub. Search for a branch and figure out where it goes.
403 Note we have to handle multi insn branch sequences like ldil;ble.
404 Most (all?) other branches can be determined by examining the contents
405 of certain registers and the stack. */
412 /* Make sure we haven't walked outside the range of this stub. */
413 if (u
!= find_unwind_entry (loc
))
415 warning (_("Unable to find branch in linker stub"));
416 return orig_pc
== pc
? 0 : pc
& ~0x3;
419 prev_inst
= curr_inst
;
420 curr_inst
= read_memory_integer (loc
, 4);
422 /* Does it look like a branch external using %r1? Then it's the
423 branch from the stub to the actual function. */
424 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
426 /* Yup. See if the previous instruction loaded
427 a value into %r1. If so compute and return the jump address. */
428 if ((prev_inst
& 0xffe00000) == 0x20200000)
429 return (hppa_extract_21 (prev_inst
) + hppa_extract_17 (curr_inst
)) & ~0x3;
432 warning (_("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."));
433 return orig_pc
== pc
? 0 : pc
& ~0x3;
437 /* Does it look like a be 0(sr0,%r21)? OR
438 Does it look like a be, n 0(sr0,%r21)? OR
439 Does it look like a bve (r21)? (this is on PA2.0)
440 Does it look like a bve, n(r21)? (this is also on PA2.0)
441 That's the branch from an
442 import stub to an export stub.
444 It is impossible to determine the target of the branch via
445 simple examination of instructions and/or data (consider
446 that the address in the plabel may be the address of the
447 bind-on-reference routine in the dynamic loader).
449 So we have try an alternative approach.
451 Get the name of the symbol at our current location; it should
452 be a stub symbol with the same name as the symbol in the
455 Then lookup a minimal symbol with the same name; we should
456 get the minimal symbol for the target routine in the shared
457 library as those take precedence of import/export stubs. */
458 if ((curr_inst
== 0xe2a00000) ||
459 (curr_inst
== 0xe2a00002) ||
460 (curr_inst
== 0xeaa0d000) ||
461 (curr_inst
== 0xeaa0d002))
463 struct minimal_symbol
*stubsym
, *libsym
;
465 stubsym
= lookup_minimal_symbol_by_pc (loc
);
468 warning (_("Unable to find symbol for 0x%lx"), loc
);
469 return orig_pc
== pc
? 0 : pc
& ~0x3;
472 libsym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym
), NULL
, NULL
);
475 warning (_("Unable to find library symbol for %s."),
476 DEPRECATED_SYMBOL_NAME (stubsym
));
477 return orig_pc
== pc
? 0 : pc
& ~0x3;
480 return SYMBOL_VALUE (libsym
);
483 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
484 branch from the stub to the actual function. */
486 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
487 || (curr_inst
& 0xffe0e000) == 0xe8000000
488 || (curr_inst
& 0xffe0e000) == 0xe800A000)
489 return (loc
+ hppa_extract_17 (curr_inst
) + 8) & ~0x3;
491 /* Does it look like bv (rp)? Note this depends on the
492 current stack pointer being the same as the stack
493 pointer in the stub itself! This is a branch on from the
494 stub back to the original caller. */
495 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
496 else if ((curr_inst
& 0xffe0f000) == 0xe840c000)
498 /* Yup. See if the previous instruction loaded
500 if (prev_inst
== 0x4bc23ff1)
501 return (read_memory_integer
502 (read_register (HPPA_SP_REGNUM
) - 8, 4)) & ~0x3;
505 warning (_("Unable to find restore of %%rp before bv (%%rp)."));
506 return orig_pc
== pc
? 0 : pc
& ~0x3;
510 /* elz: added this case to capture the new instruction
511 at the end of the return part of an export stub used by
512 the PA2.0: BVE, n (rp) */
513 else if ((curr_inst
& 0xffe0f000) == 0xe840d000)
515 return (read_memory_integer
516 (read_register (HPPA_SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
519 /* What about be,n 0(sr0,%rp)? It's just another way we return to
520 the original caller from the stub. Used in dynamic executables. */
521 else if (curr_inst
== 0xe0400002)
523 /* The value we jump to is sitting in sp - 24. But that's
524 loaded several instructions before the be instruction.
525 I guess we could check for the previous instruction being
526 mtsp %r1,%sr0 if we want to do sanity checking. */
527 return (read_memory_integer
528 (read_register (HPPA_SP_REGNUM
) - 24, TARGET_PTR_BIT
/ 8)) & ~0x3;
531 /* Haven't found the branch yet, but we're still in the stub.
538 hppa_skip_permanent_breakpoint (struct regcache
*regcache
)
540 /* To step over a breakpoint instruction on the PA takes some
541 fiddling with the instruction address queue.
543 When we stop at a breakpoint, the IA queue front (the instruction
544 we're executing now) points at the breakpoint instruction, and
545 the IA queue back (the next instruction to execute) points to
546 whatever instruction we would execute after the breakpoint, if it
547 were an ordinary instruction. This is the case even if the
548 breakpoint is in the delay slot of a branch instruction.
550 Clearly, to step past the breakpoint, we need to set the queue
551 front to the back. But what do we put in the back? What
552 instruction comes after that one? Because of the branch delay
553 slot, the next insn is always at the back + 4. */
555 ULONGEST pcoq_tail
, pcsq_tail
;
556 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, &pcoq_tail
);
557 regcache_cooked_read_unsigned (regcache
, HPPA_PCSQ_TAIL_REGNUM
, &pcsq_tail
);
559 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pcoq_tail
);
560 regcache_cooked_write_unsigned (regcache
, HPPA_PCSQ_HEAD_REGNUM
, pcsq_tail
);
562 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, pcoq_tail
+ 4);
563 /* We can leave the tail's space the same, since there's no jump. */
568 struct hppa_hpux_sigtramp_unwind_cache
571 struct trad_frame_saved_reg
*saved_regs
;
574 static int hppa_hpux_tramp_reg
[] = {
576 HPPA_PCOQ_HEAD_REGNUM
,
577 HPPA_PCSQ_HEAD_REGNUM
,
578 HPPA_PCOQ_TAIL_REGNUM
,
579 HPPA_PCSQ_TAIL_REGNUM
,
606 static struct hppa_hpux_sigtramp_unwind_cache
*
607 hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info
*next_frame
,
611 struct gdbarch
*gdbarch
= get_frame_arch (next_frame
);
612 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
613 struct hppa_hpux_sigtramp_unwind_cache
*info
;
615 CORE_ADDR sp
, scptr
, off
;
621 info
= FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache
);
623 info
->saved_regs
= trad_frame_alloc_saved_regs (next_frame
);
625 sp
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
627 if (IS_32BIT_TARGET (gdbarch
))
634 /* See /usr/include/machine/save_state.h for the structure of the save_state_t
637 flag
= read_memory_unsigned_integer(scptr
+ HPPA_HPUX_SS_FLAGS_OFFSET
, 4);
639 if (!(flag
& HPPA_HPUX_SS_WIDEREGS
))
641 /* Narrow registers. */
642 off
= scptr
+ HPPA_HPUX_SS_NARROW_OFFSET
;
648 /* Wide registers. */
649 off
= scptr
+ HPPA_HPUX_SS_WIDE_OFFSET
+ 8;
651 szoff
= (tdep
->bytes_per_address
== 4 ? 4 : 0);
654 for (i
= 1; i
< 32; i
++)
656 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= off
+ szoff
;
660 for (i
= 0; i
< ARRAY_SIZE (hppa_hpux_tramp_reg
); i
++)
662 if (hppa_hpux_tramp_reg
[i
] > 0)
663 info
->saved_regs
[hppa_hpux_tramp_reg
[i
]].addr
= off
+ szoff
;
670 info
->base
= frame_unwind_register_unsigned (next_frame
, HPPA_SP_REGNUM
);
676 hppa_hpux_sigtramp_frame_this_id (struct frame_info
*next_frame
,
677 void **this_prologue_cache
,
678 struct frame_id
*this_id
)
680 struct hppa_hpux_sigtramp_unwind_cache
*info
681 = hppa_hpux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
682 *this_id
= frame_id_build (info
->base
, frame_pc_unwind (next_frame
));
686 hppa_hpux_sigtramp_frame_prev_register (struct frame_info
*next_frame
,
687 void **this_prologue_cache
,
688 int regnum
, int *optimizedp
,
689 enum lval_type
*lvalp
,
691 int *realnump
, gdb_byte
*valuep
)
693 struct hppa_hpux_sigtramp_unwind_cache
*info
694 = hppa_hpux_sigtramp_frame_unwind_cache (next_frame
, this_prologue_cache
);
695 hppa_frame_prev_register_helper (next_frame
, info
->saved_regs
, regnum
,
696 optimizedp
, lvalp
, addrp
, realnump
, valuep
);
699 static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind
= {
701 hppa_hpux_sigtramp_frame_this_id
,
702 hppa_hpux_sigtramp_frame_prev_register
705 static const struct frame_unwind
*
706 hppa_hpux_sigtramp_unwind_sniffer (struct frame_info
*next_frame
)
708 struct unwind_table_entry
*u
;
709 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
711 u
= find_unwind_entry (pc
);
713 /* If this is an export stub, try to get the unwind descriptor for
714 the actual function itself. */
715 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
717 gdb_byte buf
[HPPA_INSN_SIZE
];
720 if (!safe_frame_unwind_memory (next_frame
, u
->region_start
,
724 insn
= extract_unsigned_integer (buf
, sizeof buf
);
725 if ((insn
& 0xffe0e000) == 0xe8400000)
726 u
= find_unwind_entry(u
->region_start
+ hppa_extract_17 (insn
) + 8);
729 if (u
&& u
->HP_UX_interrupt_marker
)
730 return &hppa_hpux_sigtramp_frame_unwind
;
736 hppa32_hpux_find_global_pointer (struct value
*function
)
740 faddr
= value_as_address (function
);
742 /* Is this a plabel? If so, dereference it to get the gp value. */
750 status
= target_read_memory (faddr
+ 4, buf
, sizeof (buf
));
752 return extract_unsigned_integer (buf
, sizeof (buf
));
755 return gdbarch_tdep (current_gdbarch
)->solib_get_got_by_pc (faddr
);
759 hppa64_hpux_find_global_pointer (struct value
*function
)
764 faddr
= value_as_address (function
);
766 if (in_opd_section (faddr
))
768 target_read_memory (faddr
, buf
, sizeof (buf
));
769 return extract_unsigned_integer (&buf
[24], 8);
773 return gdbarch_tdep (current_gdbarch
)->solib_get_got_by_pc (faddr
);
777 static unsigned int ldsid_pattern
[] = {
778 0x000010a0, /* ldsid (rX),rY */
779 0x00001820, /* mtsp rY,sr0 */
780 0xe0000000 /* be,n (sr0,rX) */
784 hppa_hpux_search_pattern (CORE_ADDR start
, CORE_ADDR end
,
785 unsigned int *patterns
, int count
)
787 int num_insns
= (end
- start
+ HPPA_INSN_SIZE
) / HPPA_INSN_SIZE
;
792 buf
= alloca (num_insns
* HPPA_INSN_SIZE
);
793 insns
= alloca (num_insns
* sizeof (unsigned int));
795 read_memory (start
, buf
, num_insns
* HPPA_INSN_SIZE
);
796 for (i
= 0; i
< num_insns
; i
++, buf
+= HPPA_INSN_SIZE
)
797 insns
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
);
799 for (offset
= 0; offset
<= num_insns
- count
; offset
++)
801 for (i
= 0; i
< count
; i
++)
803 if ((insns
[offset
+ i
] & patterns
[i
]) != patterns
[i
])
810 if (offset
<= num_insns
- count
)
811 return start
+ offset
* HPPA_INSN_SIZE
;
817 hppa32_hpux_search_dummy_call_sequence (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
821 struct obj_section
*sec
;
822 struct hppa_objfile_private
*priv
;
823 struct frame_info
*frame
;
824 struct unwind_table_entry
*u
;
829 sec
= find_pc_section (pc
);
831 priv
= objfile_data (obj
, hppa_objfile_priv_data
);
834 priv
= hppa_init_objfile_priv_data (obj
);
836 error (_("Internal error creating objfile private data."));
838 /* Use the cached value if we have one. */
839 if (priv
->dummy_call_sequence_addr
!= 0)
841 *argreg
= priv
->dummy_call_sequence_reg
;
842 return priv
->dummy_call_sequence_addr
;
845 /* First try a heuristic; if we are in a shared library call, our return
846 pointer is likely to point at an export stub. */
847 frame
= get_current_frame ();
848 rp
= frame_unwind_register_unsigned (frame
, 2);
849 u
= find_unwind_entry (rp
);
850 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
852 addr
= hppa_hpux_search_pattern (u
->region_start
, u
->region_end
,
854 ARRAY_SIZE (ldsid_pattern
));
859 /* Next thing to try is to look for an export stub. */
860 if (priv
->unwind_info
)
864 for (i
= 0; i
< priv
->unwind_info
->last
; i
++)
866 struct unwind_table_entry
*u
;
867 u
= &priv
->unwind_info
->table
[i
];
868 if (u
->stub_unwind
.stub_type
== EXPORT
)
870 addr
= hppa_hpux_search_pattern (u
->region_start
, u
->region_end
,
872 ARRAY_SIZE (ldsid_pattern
));
881 /* Finally, if this is the main executable, try to locate a sequence
883 addr
= hppa_symbol_address ("noshlibs");
884 sec
= find_pc_section (addr
);
886 if (sec
&& sec
->objfile
== obj
)
888 CORE_ADDR start
, end
;
890 find_pc_partial_function (addr
, NULL
, &start
, &end
);
891 if (start
!= 0 && end
!= 0)
893 addr
= hppa_hpux_search_pattern (start
, end
, ldsid_pattern
,
894 ARRAY_SIZE (ldsid_pattern
));
900 /* Can't find a suitable sequence. */
904 target_read_memory (addr
, buf
, sizeof (buf
));
905 insn
= extract_unsigned_integer (buf
, sizeof (buf
));
906 priv
->dummy_call_sequence_addr
= addr
;
907 priv
->dummy_call_sequence_reg
= (insn
>> 21) & 0x1f;
909 *argreg
= priv
->dummy_call_sequence_reg
;
910 return priv
->dummy_call_sequence_addr
;
914 hppa64_hpux_search_dummy_call_sequence (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
918 struct obj_section
*sec
;
919 struct hppa_objfile_private
*priv
;
921 struct minimal_symbol
*msym
;
924 sec
= find_pc_section (pc
);
926 priv
= objfile_data (obj
, hppa_objfile_priv_data
);
929 priv
= hppa_init_objfile_priv_data (obj
);
931 error (_("Internal error creating objfile private data."));
933 /* Use the cached value if we have one. */
934 if (priv
->dummy_call_sequence_addr
!= 0)
936 *argreg
= priv
->dummy_call_sequence_reg
;
937 return priv
->dummy_call_sequence_addr
;
940 /* FIXME: Without stub unwind information, locating a suitable sequence is
941 fairly difficult. For now, we implement a very naive and inefficient
942 scheme; try to read in blocks of code, and look for a "bve,n (rp)"
943 instruction. These are likely to occur at the end of functions, so
944 we only look at the last two instructions of each function. */
945 for (i
= 0, msym
= obj
->msymbols
; i
< obj
->minimal_symbol_count
; i
++, msym
++)
947 CORE_ADDR begin
, end
;
949 gdb_byte buf
[2 * HPPA_INSN_SIZE
];
952 find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym
), &name
,
955 if (name
== NULL
|| begin
== 0 || end
== 0)
958 if (target_read_memory (end
- sizeof (buf
), buf
, sizeof (buf
)) == 0)
960 for (offset
= 0; offset
< sizeof (buf
); offset
++)
964 insn
= extract_unsigned_integer (buf
+ offset
, HPPA_INSN_SIZE
);
965 if (insn
== 0xe840d002) /* bve,n (rp) */
967 addr
= (end
- sizeof (buf
)) + offset
;
974 /* Can't find a suitable sequence. */
978 priv
->dummy_call_sequence_addr
= addr
;
979 /* Right now we only look for a "bve,l (rp)" sequence, so the register is
980 always HPPA_RP_REGNUM. */
981 priv
->dummy_call_sequence_reg
= HPPA_RP_REGNUM
;
983 *argreg
= priv
->dummy_call_sequence_reg
;
984 return priv
->dummy_call_sequence_addr
;
988 hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr
)
990 struct objfile
*objfile
;
991 struct minimal_symbol
*funsym
, *stubsym
;
994 funsym
= lookup_minimal_symbol_by_pc (funcaddr
);
997 ALL_OBJFILES (objfile
)
999 stubsym
= lookup_minimal_symbol_solib_trampoline
1000 (SYMBOL_LINKAGE_NAME (funsym
), objfile
);
1004 struct unwind_table_entry
*u
;
1006 u
= find_unwind_entry (SYMBOL_VALUE (stubsym
));
1008 || (u
->stub_unwind
.stub_type
!= IMPORT
1009 && u
->stub_unwind
.stub_type
!= IMPORT_SHLIB
))
1012 stubaddr
= SYMBOL_VALUE (stubsym
);
1014 /* If we found an IMPORT stub, then we can stop searching;
1015 if we found an IMPORT_SHLIB, we want to continue the search
1016 in the hopes that we will find an IMPORT stub. */
1017 if (u
->stub_unwind
.stub_type
== IMPORT
)
1026 hppa_hpux_sr_for_addr (CORE_ADDR addr
)
1029 /* The space register to use is encoded in the top 2 bits of the address. */
1030 sr
= addr
>> (gdbarch_tdep (current_gdbarch
)->bytes_per_address
* 8 - 2);
1035 hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr
)
1037 /* In order for us to restore the space register to its starting state,
1038 we need the dummy trampoline to return to the an instruction address in
1039 the same space as where we started the call. We used to place the
1040 breakpoint near the current pc, however, this breaks nested dummy calls
1041 as the nested call will hit the breakpoint address and terminate
1042 prematurely. Instead, we try to look for an address in the same space to
1045 This is similar in spirit to putting the breakpoint at the "entry point"
1046 of an executable. */
1048 struct obj_section
*sec
;
1049 struct unwind_table_entry
*u
;
1050 struct minimal_symbol
*msym
;
1054 sec
= find_pc_section (addr
);
1057 /* First try the lowest address in the section; we can use it as long
1058 as it is "regular" code (i.e. not a stub) */
1059 u
= find_unwind_entry (sec
->addr
);
1060 if (!u
|| u
->stub_unwind
.stub_type
== 0)
1063 /* Otherwise, we need to find a symbol for a regular function. We
1064 do this by walking the list of msymbols in the objfile. The symbol
1065 we find should not be the same as the function that was passed in. */
1067 /* FIXME: this is broken, because we can find a function that will be
1068 called by the dummy call target function, which will still not
1071 find_pc_partial_function (addr
, NULL
, &func
, NULL
);
1072 for (i
= 0, msym
= sec
->objfile
->msymbols
;
1073 i
< sec
->objfile
->minimal_symbol_count
;
1076 u
= find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym
));
1077 if (func
!= SYMBOL_VALUE_ADDRESS (msym
)
1078 && (!u
|| u
->stub_unwind
.stub_type
== 0))
1079 return SYMBOL_VALUE_ADDRESS (msym
);
1083 warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1084 "calls may fail."));
1089 hppa_hpux_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
,
1090 CORE_ADDR funcaddr
, int using_gcc
,
1091 struct value
**args
, int nargs
,
1092 struct type
*value_type
,
1093 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
)
1095 CORE_ADDR pc
, stubaddr
;
1100 /* Note: we don't want to pass a function descriptor here; push_dummy_call
1101 fills in the PIC register for us. */
1102 funcaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funcaddr
, NULL
);
1104 /* The simple case is where we call a function in the same space that we are
1105 currently in; in that case we don't really need to do anything. */
1106 if (hppa_hpux_sr_for_addr (pc
) == hppa_hpux_sr_for_addr (funcaddr
))
1108 /* Intraspace call. */
1109 *bp_addr
= hppa_hpux_find_dummy_bpaddr (pc
);
1110 *real_pc
= funcaddr
;
1111 regcache_cooked_write_unsigned (current_regcache
, HPPA_RP_REGNUM
, *bp_addr
);
1116 /* In order to make an interspace call, we need to go through a stub.
1117 gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1118 an application is compiled with HP compilers then this stub is not
1119 available. We used to fallback to "__d_plt_call", however that stub
1120 is not entirely useful for us because it doesn't do an interspace
1121 return back to the caller. Also, on hppa64-hpux, there is no
1122 __gcc_plt_call available. In order to keep the code uniform, we
1123 instead don't use either of these stubs, but instead write our own
1126 A problem arises since the stack is located in a different space than
1127 code, so in order to branch to a stack stub, we will need to do an
1128 interspace branch. Previous versions of gdb did this by modifying code
1129 at the current pc and doing single-stepping to set the pcsq. Since this
1130 is highly undesirable, we use a different scheme:
1132 All we really need to do the branch to the stub is a short instruction
1143 Instead of writing these sequences ourselves, we can find it in
1144 the instruction stream that belongs to the current space. While this
1145 seems difficult at first, we are actually guaranteed to find the sequences
1149 - in export stubs for shared libraries
1150 - in the "noshlibs" routine in the main module
1153 - at the end of each "regular" function
1155 We cache the address of these sequences in the objfile's private data
1156 since these operations can potentially be quite expensive.
1159 - write a stack trampoline
1160 - look for a suitable instruction sequence in the current space
1161 - point the sequence at the trampoline
1162 - set the return address of the trampoline to the current space
1163 (see hppa_hpux_find_dummy_call_bpaddr)
1164 - set the continuing address of the "dummy code" as the sequence.
1168 if (IS_32BIT_TARGET (gdbarch
))
1170 static unsigned int hppa32_tramp
[] = {
1171 0x0fdf1291, /* stw r31,-8(,sp) */
1172 0x02c010a1, /* ldsid (,r22),r1 */
1173 0x00011820, /* mtsp r1,sr0 */
1174 0xe6c00000, /* be,l 0(sr0,r22),%sr0,%r31 */
1175 0x081f0242, /* copy r31,rp */
1176 0x0fd11082, /* ldw -8(,sp),rp */
1177 0x004010a1, /* ldsid (,rp),r1 */
1178 0x00011820, /* mtsp r1,sr0 */
1179 0xe0400000, /* be 0(sr0,rp) */
1180 0x08000240 /* nop */
1183 /* for hppa32, we must call the function through a stub so that on
1184 return it can return to the space of our trampoline. */
1185 stubaddr
= hppa_hpux_find_import_stub_for_addr (funcaddr
);
1187 error (_("Cannot call external function not referenced by application "
1188 "(no import stub).\n"));
1189 regcache_cooked_write_unsigned (current_regcache
, 22, stubaddr
);
1191 write_memory (sp
, (char *)&hppa32_tramp
, sizeof (hppa32_tramp
));
1193 *bp_addr
= hppa_hpux_find_dummy_bpaddr (pc
);
1194 regcache_cooked_write_unsigned (current_regcache
, 31, *bp_addr
);
1196 *real_pc
= hppa32_hpux_search_dummy_call_sequence (gdbarch
, pc
, &argreg
);
1198 error (_("Cannot make interspace call from here."));
1200 regcache_cooked_write_unsigned (current_regcache
, argreg
, sp
);
1202 sp
+= sizeof (hppa32_tramp
);
1206 static unsigned int hppa64_tramp
[] = {
1207 0xeac0f000, /* bve,l (r22),%r2 */
1208 0x0fdf12d1, /* std r31,-8(,sp) */
1209 0x0fd110c2, /* ldd -8(,sp),rp */
1210 0xe840d002, /* bve,n (rp) */
1211 0x08000240 /* nop */
1214 /* for hppa64, we don't need to call through a stub; all functions
1215 return via a bve. */
1216 regcache_cooked_write_unsigned (current_regcache
, 22, funcaddr
);
1217 write_memory (sp
, (char *)&hppa64_tramp
, sizeof (hppa64_tramp
));
1220 regcache_cooked_write_unsigned (current_regcache
, 31, *bp_addr
);
1222 *real_pc
= hppa64_hpux_search_dummy_call_sequence (gdbarch
, pc
, &argreg
);
1224 error (_("Cannot make interspace call from here."));
1226 regcache_cooked_write_unsigned (current_regcache
, argreg
, sp
);
1228 sp
+= sizeof (hppa64_tramp
);
1231 sp
= gdbarch_frame_align (gdbarch
, sp
);
1239 hppa_hpux_supply_ss_narrow (struct regcache
*regcache
,
1240 int regnum
, const char *save_state
)
1242 const char *ss_narrow
= save_state
+ HPPA_HPUX_SS_NARROW_OFFSET
;
1245 for (i
= HPPA_R1_REGNUM
; i
< HPPA_FP0_REGNUM
; i
++)
1247 if (regnum
== i
|| regnum
== -1)
1248 regcache_raw_supply (regcache
, i
, ss_narrow
+ offset
);
1255 hppa_hpux_supply_ss_fpblock (struct regcache
*regcache
,
1256 int regnum
, const char *save_state
)
1258 const char *ss_fpblock
= save_state
+ HPPA_HPUX_SS_FPBLOCK_OFFSET
;
1261 /* FIXME: We view the floating-point state as 64 single-precision
1262 registers for 32-bit code, and 32 double-precision register for
1263 64-bit code. This distinction is artificial and should be
1264 eliminated. If that ever happens, we should remove the if-clause
1267 if (register_size (get_regcache_arch (regcache
), HPPA_FP0_REGNUM
) == 4)
1269 for (i
= HPPA_FP0_REGNUM
; i
< HPPA_FP0_REGNUM
+ 64; i
++)
1271 if (regnum
== i
|| regnum
== -1)
1272 regcache_raw_supply (regcache
, i
, ss_fpblock
+ offset
);
1279 for (i
= HPPA_FP0_REGNUM
; i
< HPPA_FP0_REGNUM
+ 32; i
++)
1281 if (regnum
== i
|| regnum
== -1)
1282 regcache_raw_supply (regcache
, i
, ss_fpblock
+ offset
);
1290 hppa_hpux_supply_ss_wide (struct regcache
*regcache
,
1291 int regnum
, const char *save_state
)
1293 const char *ss_wide
= save_state
+ HPPA_HPUX_SS_WIDE_OFFSET
;
1296 if (register_size (get_regcache_arch (regcache
), HPPA_R1_REGNUM
) == 4)
1299 for (i
= HPPA_R1_REGNUM
; i
< HPPA_FP0_REGNUM
; i
++)
1301 if (regnum
== i
|| regnum
== -1)
1302 regcache_raw_supply (regcache
, i
, ss_wide
+ offset
);
1309 hppa_hpux_supply_save_state (const struct regset
*regset
,
1310 struct regcache
*regcache
,
1311 int regnum
, const void *regs
, size_t len
)
1313 const char *proc_info
= regs
;
1314 const char *save_state
= proc_info
+ 8;
1317 flags
= extract_unsigned_integer (save_state
+ HPPA_HPUX_SS_FLAGS_OFFSET
, 4);
1318 if (regnum
== -1 || regnum
== HPPA_FLAGS_REGNUM
)
1320 struct gdbarch
*arch
= get_regcache_arch (regcache
);
1321 size_t size
= register_size (arch
, HPPA_FLAGS_REGNUM
);
1324 store_unsigned_integer (buf
, size
, flags
);
1325 regcache_raw_supply (regcache
, HPPA_FLAGS_REGNUM
, buf
);
1328 /* If the SS_WIDEREGS flag is set, we really do need the full
1329 `struct save_state'. */
1330 if (flags
& HPPA_HPUX_SS_WIDEREGS
&& len
< HPPA_HPUX_SAVE_STATE_SIZE
)
1331 error (_("Register set contents too small"));
1333 if (flags
& HPPA_HPUX_SS_WIDEREGS
)
1334 hppa_hpux_supply_ss_wide (regcache
, regnum
, save_state
);
1336 hppa_hpux_supply_ss_narrow (regcache
, regnum
, save_state
);
1338 hppa_hpux_supply_ss_fpblock (regcache
, regnum
, save_state
);
1341 /* HP-UX register set. */
1343 static struct regset hppa_hpux_regset
=
1346 hppa_hpux_supply_save_state
1349 static const struct regset
*
1350 hppa_hpux_regset_from_core_section (struct gdbarch
*gdbarch
,
1351 const char *sect_name
, size_t sect_size
)
1353 if (strcmp (sect_name
, ".reg") == 0
1354 && sect_size
>= HPPA_HPUX_PA89_SAVE_STATE_SIZE
+ 8)
1355 return &hppa_hpux_regset
;
1361 /* Bit in the `ss_flag' member of `struct save_state' that indicates
1362 the state was saved from a system call. From
1363 <machine/save_state.h>. */
1364 #define HPPA_HPUX_SS_INSYSCALL 0x02
1367 hppa_hpux_read_pc (ptid_t ptid
)
1371 /* If we're currently in a system call return the contents of %r31. */
1372 flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1373 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1374 return read_register_pid (HPPA_R31_REGNUM
, ptid
) & ~0x3;
1376 return hppa_read_pc (ptid
);
1380 hppa_hpux_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1384 /* If we're currently in a system call also write PC into %r31. */
1385 flags
= read_register_pid (HPPA_FLAGS_REGNUM
, ptid
);
1386 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1387 write_register_pid (HPPA_R31_REGNUM
, pc
| 0x3, ptid
);
1389 return hppa_write_pc (pc
, ptid
);
1393 hppa_hpux_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1397 /* If we're currently in a system call return the contents of %r31. */
1398 flags
= frame_unwind_register_unsigned (next_frame
, HPPA_FLAGS_REGNUM
);
1399 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1400 return frame_unwind_register_unsigned (next_frame
, HPPA_R31_REGNUM
) & ~0x3;
1402 return hppa_unwind_pc (gdbarch
, next_frame
);
1406 /* Given the current value of the pc, check to see if it is inside a stub, and
1407 if so, change the value of the pc to point to the caller of the stub.
1408 NEXT_FRAME is the next frame in the current list of frames.
1409 BASE contains to stack frame base of the current frame.
1410 SAVE_REGS is the register file stored in the frame cache. */
1412 hppa_hpux_unwind_adjust_stub (struct frame_info
*next_frame
, CORE_ADDR base
,
1413 struct trad_frame_saved_reg
*saved_regs
)
1415 int optimized
, realreg
;
1416 enum lval_type lval
;
1418 char buffer
[sizeof(ULONGEST
)];
1421 struct unwind_table_entry
*u
;
1423 trad_frame_get_prev_register (next_frame
, saved_regs
,
1424 HPPA_PCOQ_HEAD_REGNUM
,
1425 &optimized
, &lval
, &addr
, &realreg
, buffer
);
1426 val
= extract_unsigned_integer (buffer
,
1427 register_size (get_frame_arch (next_frame
),
1428 HPPA_PCOQ_HEAD_REGNUM
));
1430 u
= find_unwind_entry (val
);
1431 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
1433 stubpc
= read_memory_integer (base
- 24, TARGET_PTR_BIT
/ 8);
1434 trad_frame_set_value (saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, stubpc
);
1436 else if (hppa_symbol_address ("__gcc_plt_call")
1437 == get_pc_function_start (val
))
1439 stubpc
= read_memory_integer (base
- 8, TARGET_PTR_BIT
/ 8);
1440 trad_frame_set_value (saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, stubpc
);
1445 hppa_hpux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1447 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1449 if (IS_32BIT_TARGET (gdbarch
))
1450 tdep
->in_solib_call_trampoline
= hppa32_hpux_in_solib_call_trampoline
;
1452 tdep
->in_solib_call_trampoline
= hppa64_hpux_in_solib_call_trampoline
;
1454 tdep
->unwind_adjust_stub
= hppa_hpux_unwind_adjust_stub
;
1456 set_gdbarch_in_solib_return_trampoline
1457 (gdbarch
, hppa_hpux_in_solib_return_trampoline
);
1458 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_hpux_skip_trampoline_code
);
1460 set_gdbarch_push_dummy_code (gdbarch
, hppa_hpux_push_dummy_code
);
1461 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1463 set_gdbarch_read_pc (gdbarch
, hppa_hpux_read_pc
);
1464 set_gdbarch_write_pc (gdbarch
, hppa_hpux_write_pc
);
1465 set_gdbarch_unwind_pc (gdbarch
, hppa_hpux_unwind_pc
);
1466 set_gdbarch_skip_permanent_breakpoint
1467 (gdbarch
, hppa_skip_permanent_breakpoint
);
1469 set_gdbarch_regset_from_core_section
1470 (gdbarch
, hppa_hpux_regset_from_core_section
);
1472 frame_unwind_append_sniffer (gdbarch
, hppa_hpux_sigtramp_unwind_sniffer
);
1476 hppa_hpux_som_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1478 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1482 tdep
->find_global_pointer
= hppa32_hpux_find_global_pointer
;
1484 hppa_hpux_init_abi (info
, gdbarch
);
1485 som_solib_select (tdep
);
1489 hppa_hpux_elf_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1491 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1494 tdep
->find_global_pointer
= hppa64_hpux_find_global_pointer
;
1496 hppa_hpux_init_abi (info
, gdbarch
);
1497 pa64_solib_select (tdep
);
1500 static enum gdb_osabi
1501 hppa_hpux_core_osabi_sniffer (bfd
*abfd
)
1503 if (strcmp (bfd_get_target (abfd
), "hpux-core") == 0)
1504 return GDB_OSABI_HPUX_SOM
;
1505 else if (strcmp (bfd_get_target (abfd
), "elf64-hppa") == 0)
1509 section
= bfd_get_section_by_name (abfd
, ".kernel");
1515 size
= bfd_section_size (abfd
, section
);
1516 contents
= alloca (size
);
1517 if (bfd_get_section_contents (abfd
, section
, contents
,
1519 && strcmp (contents
, "HP-UX") == 0)
1520 return GDB_OSABI_HPUX_ELF
;
1524 return GDB_OSABI_UNKNOWN
;
1528 _initialize_hppa_hpux_tdep (void)
1530 /* BFD doesn't set a flavour for HP-UX style core files. It doesn't
1531 set the architecture either. */
1532 gdbarch_register_osabi_sniffer (bfd_arch_unknown
,
1533 bfd_target_unknown_flavour
,
1534 hppa_hpux_core_osabi_sniffer
);
1535 gdbarch_register_osabi_sniffer (bfd_arch_hppa
,
1536 bfd_target_elf_flavour
,
1537 hppa_hpux_core_osabi_sniffer
);
1539 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_HPUX_SOM
,
1540 hppa_hpux_som_init_abi
);
1541 gdbarch_register_osabi (bfd_arch_hppa
, bfd_mach_hppa20w
, GDB_OSABI_HPUX_ELF
,
1542 hppa_hpux_elf_init_abi
);