1 /* Target-dependent code for HP-UX on PA-RISC.
3 Copyright (C) 2002-2013 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"
39 #include "gdb_string.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
;
69 in_opd_section (CORE_ADDR pc
)
71 struct obj_section
*s
;
74 s
= find_pc_section (pc
);
77 && s
->the_bfd_section
->name
!= NULL
78 && strcmp (s
->the_bfd_section
->name
, ".opd") == 0);
82 /* Return one if PC is in the call path of a trampoline, else return zero.
84 Note we return one for *any* call trampoline (long-call, arg-reloc), not
85 just shared library trampolines (import, export). */
88 hppa32_hpux_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
89 CORE_ADDR pc
, char *name
)
91 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
92 struct bound_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
);
102 && strcmp (SYMBOL_LINKAGE_NAME (minsym
.minsym
), ".stub") == 0)
105 /* Get the unwind descriptor corresponding to PC, return zero
106 if no unwind was found. */
107 u
= find_unwind_entry (pc
);
111 /* If this isn't a linker stub, then return now. */
112 if (u
->stub_unwind
.stub_type
== 0)
115 /* By definition a long-branch stub is a call stub. */
116 if (u
->stub_unwind
.stub_type
== LONG_BRANCH
)
119 /* The call and return path execute the same instructions within
120 an IMPORT stub! So an IMPORT stub is both a call and return
122 if (u
->stub_unwind
.stub_type
== IMPORT
)
125 /* Parameter relocation stubs always have a call path and may have a
127 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
128 || u
->stub_unwind
.stub_type
== EXPORT
)
132 /* Search forward from the current PC until we hit a branch
133 or the end of the stub. */
134 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
138 insn
= read_memory_integer (addr
, 4, byte_order
);
140 /* Does it look like a bl? If so then it's the call path, if
141 we find a bv or be first, then we're on the return path. */
142 if ((insn
& 0xfc00e000) == 0xe8000000)
144 else if ((insn
& 0xfc00e001) == 0xe800c000
145 || (insn
& 0xfc000000) == 0xe0000000)
149 /* Should never happen. */
150 warning (_("Unable to find branch in parameter relocation stub."));
154 /* Unknown stub type. For now, just return zero. */
159 hppa64_hpux_in_solib_call_trampoline (struct gdbarch
*gdbarch
,
160 CORE_ADDR pc
, char *name
)
162 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
164 /* PA64 has a completely different stub/trampoline scheme. Is it
165 better? Maybe. It's certainly harder to determine with any
166 certainty that we are in a stub because we can not refer to the
169 The heuristic is simple. Try to lookup the current PC value in th
170 minimal symbol table. If that fails, then assume we are not in a
173 Then see if the PC value falls within the section bounds for the
174 section containing the minimal symbol we found in the first
175 step. If it does, then assume we are not in a stub and return.
177 Finally peek at the instructions to see if they look like a stub. */
178 struct bound_minimal_symbol minsym
;
183 minsym
= lookup_minimal_symbol_by_pc (pc
);
187 sec
= SYMBOL_OBJ_SECTION (minsym
.objfile
, minsym
.minsym
)->the_bfd_section
;
189 if (bfd_get_section_vma (sec
->owner
, sec
) <= pc
190 && pc
< (bfd_get_section_vma (sec
->owner
, sec
)
191 + bfd_section_size (sec
->owner
, sec
)))
194 /* We might be in a stub. Peek at the instructions. Stubs are 3
195 instructions long. */
196 insn
= read_memory_integer (pc
, 4, byte_order
);
198 /* Find out where we think we are within the stub. */
199 if ((insn
& 0xffffc00e) == 0x53610000)
201 else if ((insn
& 0xffffffff) == 0xe820d000)
203 else if ((insn
& 0xffffc00e) == 0x537b0000)
208 /* Now verify each insn in the range looks like a stub instruction. */
209 insn
= read_memory_integer (addr
, 4, byte_order
);
210 if ((insn
& 0xffffc00e) != 0x53610000)
213 /* Now verify each insn in the range looks like a stub instruction. */
214 insn
= read_memory_integer (addr
+ 4, 4, byte_order
);
215 if ((insn
& 0xffffffff) != 0xe820d000)
218 /* Now verify each insn in the range looks like a stub instruction. */
219 insn
= read_memory_integer (addr
+ 8, 4, byte_order
);
220 if ((insn
& 0xffffc00e) != 0x537b0000)
223 /* Looks like a stub. */
227 /* Return one if PC is in the return path of a trampoline, else return zero.
229 Note we return one for *any* call trampoline (long-call, arg-reloc), not
230 just shared library trampolines (import, export). */
233 hppa_hpux_in_solib_return_trampoline (struct gdbarch
*gdbarch
,
234 CORE_ADDR pc
, const char *name
)
236 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
237 struct unwind_table_entry
*u
;
239 /* Get the unwind descriptor corresponding to PC, return zero
240 if no unwind was found. */
241 u
= find_unwind_entry (pc
);
245 /* If this isn't a linker stub or it's just a long branch stub, then
247 if (u
->stub_unwind
.stub_type
== 0 || u
->stub_unwind
.stub_type
== LONG_BRANCH
)
250 /* The call and return path execute the same instructions within
251 an IMPORT stub! So an IMPORT stub is both a call and return
253 if (u
->stub_unwind
.stub_type
== IMPORT
)
256 /* Parameter relocation stubs always have a call path and may have a
258 if (u
->stub_unwind
.stub_type
== PARAMETER_RELOCATION
259 || u
->stub_unwind
.stub_type
== EXPORT
)
263 /* Search forward from the current PC until we hit a branch
264 or the end of the stub. */
265 for (addr
= pc
; addr
<= u
->region_end
; addr
+= 4)
269 insn
= read_memory_integer (addr
, 4, byte_order
);
271 /* Does it look like a bl? If so then it's the call path, if
272 we find a bv or be first, then we're on the return path. */
273 if ((insn
& 0xfc00e000) == 0xe8000000)
275 else if ((insn
& 0xfc00e001) == 0xe800c000
276 || (insn
& 0xfc000000) == 0xe0000000)
280 /* Should never happen. */
281 warning (_("Unable to find branch in parameter relocation stub."));
285 /* Unknown stub type. For now, just return zero. */
290 /* Figure out if PC is in a trampoline, and if so find out where
291 the trampoline will jump to. If not in a trampoline, return zero.
293 Simple code examination probably is not a good idea since the code
294 sequences in trampolines can also appear in user code.
296 We use unwinds and information from the minimal symbol table to
297 determine when we're in a trampoline. This won't work for ELF
298 (yet) since it doesn't create stub unwind entries. Whether or
299 not ELF will create stub unwinds or normal unwinds for linker
300 stubs is still being debated.
302 This should handle simple calls through dyncall or sr4export,
303 long calls, argument relocation stubs, and dyncall/sr4export
304 calling an argument relocation stub. It even handles some stubs
305 used in dynamic executables. */
308 hppa_hpux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
310 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
311 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
312 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
314 long prev_inst
, curr_inst
, loc
;
315 struct bound_minimal_symbol msym
;
316 struct unwind_table_entry
*u
;
318 /* Addresses passed to dyncall may *NOT* be the actual address
319 of the function. So we may have to do something special. */
320 if (pc
== hppa_symbol_address("$$dyncall"))
322 pc
= (CORE_ADDR
) get_frame_register_unsigned (frame
, 22);
324 /* If bit 30 (counting from the left) is on, then pc is the address of
325 the PLT entry for this function, not the address of the function
326 itself. Bit 31 has meaning too, but only for MPE. */
328 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, word_size
,
331 if (pc
== hppa_symbol_address("$$dyncall_external"))
333 pc
= (CORE_ADDR
) get_frame_register_unsigned (frame
, 22);
334 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, word_size
, byte_order
);
336 else if (pc
== hppa_symbol_address("_sr4export"))
337 pc
= (CORE_ADDR
) get_frame_register_unsigned (frame
, 22);
339 /* Get the unwind descriptor corresponding to PC, return zero
340 if no unwind was found. */
341 u
= find_unwind_entry (pc
);
345 /* If this isn't a linker stub, then return now. */
346 /* elz: attention here! (FIXME) because of a compiler/linker
347 error, some stubs which should have a non zero stub_unwind.stub_type
348 have unfortunately a value of zero. So this function would return here
349 as if we were not in a trampoline. To fix this, we go look at the partial
350 symbol information, which reports this guy as a stub.
351 (FIXME): Unfortunately, we are not that lucky: it turns out that the
352 partial symbol information is also wrong sometimes. This is because
353 when it is entered (somread.c::som_symtab_read()) it can happen that
354 if the type of the symbol (from the som) is Entry, and the symbol is
355 in a shared library, then it can also be a trampoline. This would be OK,
356 except that I believe the way they decide if we are ina shared library
357 does not work. SOOOO..., even if we have a regular function w/o
358 trampolines its minimal symbol can be assigned type mst_solib_trampoline.
359 Also, if we find that the symbol is a real stub, then we fix the unwind
360 descriptor, and define the stub type to be EXPORT.
361 Hopefully this is correct most of the times. */
362 if (u
->stub_unwind
.stub_type
== 0)
365 /* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
366 we can delete all the code which appears between the lines. */
367 /*--------------------------------------------------------------------------*/
368 msym
= lookup_minimal_symbol_by_pc (pc
);
370 if (msym
.minsym
== NULL
371 || MSYMBOL_TYPE (msym
.minsym
) != mst_solib_trampoline
)
372 return orig_pc
== pc
? 0 : pc
& ~0x3;
374 else if (msym
.minsym
!= NULL
375 && MSYMBOL_TYPE (msym
.minsym
) == mst_solib_trampoline
)
377 struct objfile
*objfile
;
378 struct minimal_symbol
*msymbol
;
379 int function_found
= 0;
381 /* Go look if there is another minimal symbol with the same name as
382 this one, but with type mst_text. This would happen if the msym
383 is an actual trampoline, in which case there would be another
384 symbol with the same name corresponding to the real function. */
386 ALL_MSYMBOLS (objfile
, msymbol
)
388 if (MSYMBOL_TYPE (msymbol
) == mst_text
389 && strcmp (SYMBOL_LINKAGE_NAME (msymbol
),
390 SYMBOL_LINKAGE_NAME (msym
.minsym
)) == 0)
398 /* The type of msym is correct (mst_solib_trampoline), but
399 the unwind info is wrong, so set it to the correct value. */
400 u
->stub_unwind
.stub_type
= EXPORT
;
402 /* The stub type info in the unwind is correct (this is not a
403 trampoline), but the msym type information is wrong, it
404 should be mst_text. So we need to fix the msym, and also
405 get out of this function. */
407 MSYMBOL_TYPE (msym
.minsym
) = mst_text
;
408 return orig_pc
== pc
? 0 : pc
& ~0x3;
412 /*--------------------------------------------------------------------------*/
415 /* It's a stub. Search for a branch and figure out where it goes.
416 Note we have to handle multi insn branch sequences like ldil;ble.
417 Most (all?) other branches can be determined by examining the contents
418 of certain registers and the stack. */
425 /* Make sure we haven't walked outside the range of this stub. */
426 if (u
!= find_unwind_entry (loc
))
428 warning (_("Unable to find branch in linker stub"));
429 return orig_pc
== pc
? 0 : pc
& ~0x3;
432 prev_inst
= curr_inst
;
433 curr_inst
= read_memory_integer (loc
, 4, byte_order
);
435 /* Does it look like a branch external using %r1? Then it's the
436 branch from the stub to the actual function. */
437 if ((curr_inst
& 0xffe0e000) == 0xe0202000)
439 /* Yup. See if the previous instruction loaded
440 a value into %r1. If so compute and return the jump address. */
441 if ((prev_inst
& 0xffe00000) == 0x20200000)
442 return (hppa_extract_21 (prev_inst
)
443 + hppa_extract_17 (curr_inst
)) & ~0x3;
446 warning (_("Unable to find ldil X,%%r1 "
447 "before ble Y(%%sr4,%%r1)."));
448 return orig_pc
== pc
? 0 : pc
& ~0x3;
452 /* Does it look like a be 0(sr0,%r21)? OR
453 Does it look like a be, n 0(sr0,%r21)? OR
454 Does it look like a bve (r21)? (this is on PA2.0)
455 Does it look like a bve, n(r21)? (this is also on PA2.0)
456 That's the branch from an
457 import stub to an export stub.
459 It is impossible to determine the target of the branch via
460 simple examination of instructions and/or data (consider
461 that the address in the plabel may be the address of the
462 bind-on-reference routine in the dynamic loader).
464 So we have try an alternative approach.
466 Get the name of the symbol at our current location; it should
467 be a stub symbol with the same name as the symbol in the
470 Then lookup a minimal symbol with the same name; we should
471 get the minimal symbol for the target routine in the shared
472 library as those take precedence of import/export stubs. */
473 if ((curr_inst
== 0xe2a00000) ||
474 (curr_inst
== 0xe2a00002) ||
475 (curr_inst
== 0xeaa0d000) ||
476 (curr_inst
== 0xeaa0d002))
478 struct bound_minimal_symbol stubsym
;
479 struct minimal_symbol
*libsym
;
481 stubsym
= lookup_minimal_symbol_by_pc (loc
);
482 if (stubsym
.minsym
== NULL
)
484 warning (_("Unable to find symbol for 0x%lx"), loc
);
485 return orig_pc
== pc
? 0 : pc
& ~0x3;
488 libsym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym
.minsym
),
492 warning (_("Unable to find library symbol for %s."),
493 SYMBOL_PRINT_NAME (stubsym
.minsym
));
494 return orig_pc
== pc
? 0 : pc
& ~0x3;
497 return SYMBOL_VALUE (libsym
);
500 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
501 branch from the stub to the actual function. */
503 else if ((curr_inst
& 0xffe0e000) == 0xe8400000
504 || (curr_inst
& 0xffe0e000) == 0xe8000000
505 || (curr_inst
& 0xffe0e000) == 0xe800A000)
506 return (loc
+ hppa_extract_17 (curr_inst
) + 8) & ~0x3;
508 /* Does it look like bv (rp)? Note this depends on the
509 current stack pointer being the same as the stack
510 pointer in the stub itself! This is a branch on from the
511 stub back to the original caller. */
512 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
513 else if ((curr_inst
& 0xffe0f000) == 0xe840c000)
515 /* Yup. See if the previous instruction loaded
517 if (prev_inst
== 0x4bc23ff1)
520 sp
= get_frame_register_unsigned (frame
, HPPA_SP_REGNUM
);
521 return read_memory_integer (sp
- 8, 4, byte_order
) & ~0x3;
525 warning (_("Unable to find restore of %%rp before bv (%%rp)."));
526 return orig_pc
== pc
? 0 : pc
& ~0x3;
530 /* elz: added this case to capture the new instruction
531 at the end of the return part of an export stub used by
532 the PA2.0: BVE, n (rp) */
533 else if ((curr_inst
& 0xffe0f000) == 0xe840d000)
535 return (read_memory_integer
536 (get_frame_register_unsigned (frame
, HPPA_SP_REGNUM
) - 24,
537 word_size
, byte_order
)) & ~0x3;
540 /* What about be,n 0(sr0,%rp)? It's just another way we return to
541 the original caller from the stub. Used in dynamic executables. */
542 else if (curr_inst
== 0xe0400002)
544 /* The value we jump to is sitting in sp - 24. But that's
545 loaded several instructions before the be instruction.
546 I guess we could check for the previous instruction being
547 mtsp %r1,%sr0 if we want to do sanity checking. */
548 return (read_memory_integer
549 (get_frame_register_unsigned (frame
, HPPA_SP_REGNUM
) - 24,
550 word_size
, byte_order
)) & ~0x3;
553 /* Haven't found the branch yet, but we're still in the stub.
560 hppa_skip_permanent_breakpoint (struct regcache
*regcache
)
562 /* To step over a breakpoint instruction on the PA takes some
563 fiddling with the instruction address queue.
565 When we stop at a breakpoint, the IA queue front (the instruction
566 we're executing now) points at the breakpoint instruction, and
567 the IA queue back (the next instruction to execute) points to
568 whatever instruction we would execute after the breakpoint, if it
569 were an ordinary instruction. This is the case even if the
570 breakpoint is in the delay slot of a branch instruction.
572 Clearly, to step past the breakpoint, we need to set the queue
573 front to the back. But what do we put in the back? What
574 instruction comes after that one? Because of the branch delay
575 slot, the next insn is always at the back + 4. */
577 ULONGEST pcoq_tail
, pcsq_tail
;
578 regcache_cooked_read_unsigned (regcache
, HPPA_PCOQ_TAIL_REGNUM
, &pcoq_tail
);
579 regcache_cooked_read_unsigned (regcache
, HPPA_PCSQ_TAIL_REGNUM
, &pcsq_tail
);
581 regcache_cooked_write_unsigned (regcache
, HPPA_PCOQ_HEAD_REGNUM
, pcoq_tail
);
582 regcache_cooked_write_unsigned (regcache
, HPPA_PCSQ_HEAD_REGNUM
, pcsq_tail
);
584 regcache_cooked_write_unsigned (regcache
,
585 HPPA_PCOQ_TAIL_REGNUM
, pcoq_tail
+ 4);
586 /* We can leave the tail's space the same, since there's no jump. */
591 struct hppa_hpux_sigtramp_unwind_cache
594 struct trad_frame_saved_reg
*saved_regs
;
597 static int hppa_hpux_tramp_reg
[] = {
599 HPPA_PCOQ_HEAD_REGNUM
,
600 HPPA_PCSQ_HEAD_REGNUM
,
601 HPPA_PCOQ_TAIL_REGNUM
,
602 HPPA_PCSQ_TAIL_REGNUM
,
629 static struct hppa_hpux_sigtramp_unwind_cache
*
630 hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info
*this_frame
,
634 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
635 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
636 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
637 struct hppa_hpux_sigtramp_unwind_cache
*info
;
639 CORE_ADDR sp
, scptr
, off
;
645 info
= FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache
);
647 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
649 sp
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
651 if (IS_32BIT_TARGET (gdbarch
))
658 /* See /usr/include/machine/save_state.h for the structure of the
659 save_state_t structure. */
661 flag
= read_memory_unsigned_integer (scptr
+ HPPA_HPUX_SS_FLAGS_OFFSET
,
664 if (!(flag
& HPPA_HPUX_SS_WIDEREGS
))
666 /* Narrow registers. */
667 off
= scptr
+ HPPA_HPUX_SS_NARROW_OFFSET
;
673 /* Wide registers. */
674 off
= scptr
+ HPPA_HPUX_SS_WIDE_OFFSET
+ 8;
676 szoff
= (tdep
->bytes_per_address
== 4 ? 4 : 0);
679 for (i
= 1; i
< 32; i
++)
681 info
->saved_regs
[HPPA_R0_REGNUM
+ i
].addr
= off
+ szoff
;
685 for (i
= 0; i
< ARRAY_SIZE (hppa_hpux_tramp_reg
); i
++)
687 if (hppa_hpux_tramp_reg
[i
] > 0)
688 info
->saved_regs
[hppa_hpux_tramp_reg
[i
]].addr
= off
+ szoff
;
695 info
->base
= get_frame_register_unsigned (this_frame
, HPPA_SP_REGNUM
);
701 hppa_hpux_sigtramp_frame_this_id (struct frame_info
*this_frame
,
702 void **this_prologue_cache
,
703 struct frame_id
*this_id
)
705 struct hppa_hpux_sigtramp_unwind_cache
*info
706 = hppa_hpux_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
708 *this_id
= frame_id_build (info
->base
, get_frame_pc (this_frame
));
711 static struct value
*
712 hppa_hpux_sigtramp_frame_prev_register (struct frame_info
*this_frame
,
713 void **this_prologue_cache
,
716 struct hppa_hpux_sigtramp_unwind_cache
*info
717 = hppa_hpux_sigtramp_frame_unwind_cache (this_frame
, this_prologue_cache
);
719 return hppa_frame_prev_register_helper (this_frame
,
720 info
->saved_regs
, regnum
);
724 hppa_hpux_sigtramp_unwind_sniffer (const struct frame_unwind
*self
,
725 struct frame_info
*this_frame
,
728 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
729 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
730 struct unwind_table_entry
*u
;
731 CORE_ADDR pc
= get_frame_pc (this_frame
);
733 u
= find_unwind_entry (pc
);
735 /* If this is an export stub, try to get the unwind descriptor for
736 the actual function itself. */
737 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
739 gdb_byte buf
[HPPA_INSN_SIZE
];
742 if (!safe_frame_unwind_memory (this_frame
, u
->region_start
,
746 insn
= extract_unsigned_integer (buf
, sizeof buf
, byte_order
);
747 if ((insn
& 0xffe0e000) == 0xe8400000)
748 u
= find_unwind_entry(u
->region_start
+ hppa_extract_17 (insn
) + 8);
751 if (u
&& u
->HP_UX_interrupt_marker
)
757 static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind
= {
759 default_frame_unwind_stop_reason
,
760 hppa_hpux_sigtramp_frame_this_id
,
761 hppa_hpux_sigtramp_frame_prev_register
,
763 hppa_hpux_sigtramp_unwind_sniffer
767 hppa32_hpux_find_global_pointer (struct gdbarch
*gdbarch
,
768 struct value
*function
)
770 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
773 faddr
= value_as_address (function
);
775 /* Is this a plabel? If so, dereference it to get the gp value. */
783 status
= target_read_memory (faddr
+ 4, buf
, sizeof (buf
));
785 return extract_unsigned_integer (buf
, sizeof (buf
), byte_order
);
788 return gdbarch_tdep (gdbarch
)->solib_get_got_by_pc (faddr
);
792 hppa64_hpux_find_global_pointer (struct gdbarch
*gdbarch
,
793 struct value
*function
)
795 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
799 faddr
= value_as_address (function
);
801 if (in_opd_section (faddr
))
803 target_read_memory (faddr
, buf
, sizeof (buf
));
804 return extract_unsigned_integer (&buf
[24], 8, byte_order
);
808 return gdbarch_tdep (gdbarch
)->solib_get_got_by_pc (faddr
);
812 static unsigned int ldsid_pattern
[] = {
813 0x000010a0, /* ldsid (rX),rY */
814 0x00001820, /* mtsp rY,sr0 */
815 0xe0000000 /* be,n (sr0,rX) */
819 hppa_hpux_search_pattern (struct gdbarch
*gdbarch
,
820 CORE_ADDR start
, CORE_ADDR end
,
821 unsigned int *patterns
, int count
)
823 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
824 int num_insns
= (end
- start
+ HPPA_INSN_SIZE
) / HPPA_INSN_SIZE
;
829 buf
= alloca (num_insns
* HPPA_INSN_SIZE
);
830 insns
= alloca (num_insns
* sizeof (unsigned int));
832 read_memory (start
, buf
, num_insns
* HPPA_INSN_SIZE
);
833 for (i
= 0; i
< num_insns
; i
++, buf
+= HPPA_INSN_SIZE
)
834 insns
[i
] = extract_unsigned_integer (buf
, HPPA_INSN_SIZE
, byte_order
);
836 for (offset
= 0; offset
<= num_insns
- count
; offset
++)
838 for (i
= 0; i
< count
; i
++)
840 if ((insns
[offset
+ i
] & patterns
[i
]) != patterns
[i
])
847 if (offset
<= num_insns
- count
)
848 return start
+ offset
* HPPA_INSN_SIZE
;
854 hppa32_hpux_search_dummy_call_sequence (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
857 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
859 struct obj_section
*sec
;
860 struct hppa_objfile_private
*priv
;
861 struct frame_info
*frame
;
862 struct unwind_table_entry
*u
;
867 sec
= find_pc_section (pc
);
869 priv
= objfile_data (obj
, hppa_objfile_priv_data
);
872 priv
= hppa_init_objfile_priv_data (obj
);
874 error (_("Internal error creating objfile private data."));
876 /* Use the cached value if we have one. */
877 if (priv
->dummy_call_sequence_addr
!= 0)
879 *argreg
= priv
->dummy_call_sequence_reg
;
880 return priv
->dummy_call_sequence_addr
;
883 /* First try a heuristic; if we are in a shared library call, our return
884 pointer is likely to point at an export stub. */
885 frame
= get_current_frame ();
886 rp
= frame_unwind_register_unsigned (frame
, 2);
887 u
= find_unwind_entry (rp
);
888 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
890 addr
= hppa_hpux_search_pattern (gdbarch
,
891 u
->region_start
, u
->region_end
,
893 ARRAY_SIZE (ldsid_pattern
));
898 /* Next thing to try is to look for an export stub. */
899 if (priv
->unwind_info
)
903 for (i
= 0; i
< priv
->unwind_info
->last
; i
++)
905 struct unwind_table_entry
*u
;
906 u
= &priv
->unwind_info
->table
[i
];
907 if (u
->stub_unwind
.stub_type
== EXPORT
)
909 addr
= hppa_hpux_search_pattern (gdbarch
,
910 u
->region_start
, u
->region_end
,
912 ARRAY_SIZE (ldsid_pattern
));
921 /* Finally, if this is the main executable, try to locate a sequence
923 addr
= hppa_symbol_address ("noshlibs");
924 sec
= find_pc_section (addr
);
926 if (sec
&& sec
->objfile
== obj
)
928 CORE_ADDR start
, end
;
930 find_pc_partial_function (addr
, NULL
, &start
, &end
);
931 if (start
!= 0 && end
!= 0)
933 addr
= hppa_hpux_search_pattern (gdbarch
, start
, end
, ldsid_pattern
,
934 ARRAY_SIZE (ldsid_pattern
));
940 /* Can't find a suitable sequence. */
944 target_read_memory (addr
, buf
, sizeof (buf
));
945 insn
= extract_unsigned_integer (buf
, sizeof (buf
), byte_order
);
946 priv
->dummy_call_sequence_addr
= addr
;
947 priv
->dummy_call_sequence_reg
= (insn
>> 21) & 0x1f;
949 *argreg
= priv
->dummy_call_sequence_reg
;
950 return priv
->dummy_call_sequence_addr
;
954 hppa64_hpux_search_dummy_call_sequence (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
957 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
959 struct obj_section
*sec
;
960 struct hppa_objfile_private
*priv
;
962 struct minimal_symbol
*msym
;
964 sec
= find_pc_section (pc
);
966 priv
= objfile_data (obj
, hppa_objfile_priv_data
);
969 priv
= hppa_init_objfile_priv_data (obj
);
971 error (_("Internal error creating objfile private data."));
973 /* Use the cached value if we have one. */
974 if (priv
->dummy_call_sequence_addr
!= 0)
976 *argreg
= priv
->dummy_call_sequence_reg
;
977 return priv
->dummy_call_sequence_addr
;
980 /* FIXME: Without stub unwind information, locating a suitable sequence is
981 fairly difficult. For now, we implement a very naive and inefficient
982 scheme; try to read in blocks of code, and look for a "bve,n (rp)"
983 instruction. These are likely to occur at the end of functions, so
984 we only look at the last two instructions of each function. */
985 ALL_OBJFILE_MSYMBOLS (obj
, msym
)
987 CORE_ADDR begin
, end
;
989 gdb_byte buf
[2 * HPPA_INSN_SIZE
];
992 find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym
), &name
,
995 if (name
== NULL
|| begin
== 0 || end
== 0)
998 if (target_read_memory (end
- sizeof (buf
), buf
, sizeof (buf
)) == 0)
1000 for (offset
= 0; offset
< sizeof (buf
); offset
++)
1004 insn
= extract_unsigned_integer (buf
+ offset
,
1005 HPPA_INSN_SIZE
, byte_order
);
1006 if (insn
== 0xe840d002) /* bve,n (rp) */
1008 addr
= (end
- sizeof (buf
)) + offset
;
1015 /* Can't find a suitable sequence. */
1019 priv
->dummy_call_sequence_addr
= addr
;
1020 /* Right now we only look for a "bve,l (rp)" sequence, so the register is
1021 always HPPA_RP_REGNUM. */
1022 priv
->dummy_call_sequence_reg
= HPPA_RP_REGNUM
;
1024 *argreg
= priv
->dummy_call_sequence_reg
;
1025 return priv
->dummy_call_sequence_addr
;
1029 hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr
)
1031 struct objfile
*objfile
;
1032 struct bound_minimal_symbol funsym
;
1033 struct minimal_symbol
*stubsym
;
1036 funsym
= lookup_minimal_symbol_by_pc (funcaddr
);
1039 ALL_OBJFILES (objfile
)
1041 stubsym
= lookup_minimal_symbol_solib_trampoline
1042 (SYMBOL_LINKAGE_NAME (funsym
.minsym
), objfile
);
1046 struct unwind_table_entry
*u
;
1048 u
= find_unwind_entry (SYMBOL_VALUE (stubsym
));
1050 || (u
->stub_unwind
.stub_type
!= IMPORT
1051 && u
->stub_unwind
.stub_type
!= IMPORT_SHLIB
))
1054 stubaddr
= SYMBOL_VALUE (stubsym
);
1056 /* If we found an IMPORT stub, then we can stop searching;
1057 if we found an IMPORT_SHLIB, we want to continue the search
1058 in the hopes that we will find an IMPORT stub. */
1059 if (u
->stub_unwind
.stub_type
== IMPORT
)
1068 hppa_hpux_sr_for_addr (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1071 /* The space register to use is encoded in the top 2 bits of the address. */
1072 sr
= addr
>> (gdbarch_tdep (gdbarch
)->bytes_per_address
* 8 - 2);
1077 hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr
)
1079 /* In order for us to restore the space register to its starting state,
1080 we need the dummy trampoline to return to an instruction address in
1081 the same space as where we started the call. We used to place the
1082 breakpoint near the current pc, however, this breaks nested dummy calls
1083 as the nested call will hit the breakpoint address and terminate
1084 prematurely. Instead, we try to look for an address in the same space to
1087 This is similar in spirit to putting the breakpoint at the "entry point"
1088 of an executable. */
1090 struct obj_section
*sec
;
1091 struct unwind_table_entry
*u
;
1092 struct minimal_symbol
*msym
;
1095 sec
= find_pc_section (addr
);
1098 /* First try the lowest address in the section; we can use it as long
1099 as it is "regular" code (i.e. not a stub). */
1100 u
= find_unwind_entry (obj_section_addr (sec
));
1101 if (!u
|| u
->stub_unwind
.stub_type
== 0)
1102 return obj_section_addr (sec
);
1104 /* Otherwise, we need to find a symbol for a regular function. We
1105 do this by walking the list of msymbols in the objfile. The symbol
1106 we find should not be the same as the function that was passed in. */
1108 /* FIXME: this is broken, because we can find a function that will be
1109 called by the dummy call target function, which will still not
1112 find_pc_partial_function (addr
, NULL
, &func
, NULL
);
1113 ALL_OBJFILE_MSYMBOLS (sec
->objfile
, msym
)
1115 u
= find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym
));
1116 if (func
!= SYMBOL_VALUE_ADDRESS (msym
)
1117 && (!u
|| u
->stub_unwind
.stub_type
== 0))
1118 return SYMBOL_VALUE_ADDRESS (msym
);
1122 warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1123 "calls may fail."));
1128 hppa_hpux_push_dummy_code (struct gdbarch
*gdbarch
, CORE_ADDR sp
,
1130 struct value
**args
, int nargs
,
1131 struct type
*value_type
,
1132 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
1133 struct regcache
*regcache
)
1135 CORE_ADDR pc
, stubaddr
;
1138 pc
= regcache_read_pc (regcache
);
1140 /* Note: we don't want to pass a function descriptor here; push_dummy_call
1141 fills in the PIC register for us. */
1142 funcaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funcaddr
, NULL
);
1144 /* The simple case is where we call a function in the same space that we are
1145 currently in; in that case we don't really need to do anything. */
1146 if (hppa_hpux_sr_for_addr (gdbarch
, pc
)
1147 == hppa_hpux_sr_for_addr (gdbarch
, funcaddr
))
1149 /* Intraspace call. */
1150 *bp_addr
= hppa_hpux_find_dummy_bpaddr (pc
);
1151 *real_pc
= funcaddr
;
1152 regcache_cooked_write_unsigned (regcache
, HPPA_RP_REGNUM
, *bp_addr
);
1157 /* In order to make an interspace call, we need to go through a stub.
1158 gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1159 an application is compiled with HP compilers then this stub is not
1160 available. We used to fallback to "__d_plt_call", however that stub
1161 is not entirely useful for us because it doesn't do an interspace
1162 return back to the caller. Also, on hppa64-hpux, there is no
1163 __gcc_plt_call available. In order to keep the code uniform, we
1164 instead don't use either of these stubs, but instead write our own
1167 A problem arises since the stack is located in a different space than
1168 code, so in order to branch to a stack stub, we will need to do an
1169 interspace branch. Previous versions of gdb did this by modifying code
1170 at the current pc and doing single-stepping to set the pcsq. Since this
1171 is highly undesirable, we use a different scheme:
1173 All we really need to do the branch to the stub is a short instruction
1184 Instead of writing these sequences ourselves, we can find it in
1185 the instruction stream that belongs to the current space. While this
1186 seems difficult at first, we are actually guaranteed to find the sequences
1190 - in export stubs for shared libraries
1191 - in the "noshlibs" routine in the main module
1194 - at the end of each "regular" function
1196 We cache the address of these sequences in the objfile's private data
1197 since these operations can potentially be quite expensive.
1200 - write a stack trampoline
1201 - look for a suitable instruction sequence in the current space
1202 - point the sequence at the trampoline
1203 - set the return address of the trampoline to the current space
1204 (see hppa_hpux_find_dummy_call_bpaddr)
1205 - set the continuing address of the "dummy code" as the sequence. */
1207 if (IS_32BIT_TARGET (gdbarch
))
1209 #define INSN(I1, I2, I3, I4) 0x ## I1, 0x ## I2, 0x ## I3, 0x ## I4
1210 static const gdb_byte hppa32_tramp
[] = {
1211 INSN(0f
,df
,12,91), /* stw r31,-8(,sp) */
1212 INSN(02,c0
,10,a1
), /* ldsid (,r22),r1 */
1213 INSN(00,01,18,20), /* mtsp r1,sr0 */
1214 INSN(e6
,c0
,00,00), /* be,l 0(sr0,r22),%sr0,%r31 */
1215 INSN(08,1f
,02,42), /* copy r31,rp */
1216 INSN(0f
,d1
,10,82), /* ldw -8(,sp),rp */
1217 INSN(00,40,10,a1
), /* ldsid (,rp),r1 */
1218 INSN(00,01,18,20), /* mtsp r1,sr0 */
1219 INSN(e0
,40,00,00), /* be 0(sr0,rp) */
1220 INSN(08,00,02,40) /* nop */
1223 /* for hppa32, we must call the function through a stub so that on
1224 return it can return to the space of our trampoline. */
1225 stubaddr
= hppa_hpux_find_import_stub_for_addr (funcaddr
);
1227 error (_("Cannot call external function not referenced by application "
1228 "(no import stub).\n"));
1229 regcache_cooked_write_unsigned (regcache
, 22, stubaddr
);
1231 write_memory (sp
, hppa32_tramp
, sizeof (hppa32_tramp
));
1233 *bp_addr
= hppa_hpux_find_dummy_bpaddr (pc
);
1234 regcache_cooked_write_unsigned (regcache
, 31, *bp_addr
);
1236 *real_pc
= hppa32_hpux_search_dummy_call_sequence (gdbarch
, pc
, &argreg
);
1238 error (_("Cannot make interspace call from here."));
1240 regcache_cooked_write_unsigned (regcache
, argreg
, sp
);
1242 sp
+= sizeof (hppa32_tramp
);
1246 static const gdb_byte hppa64_tramp
[] = {
1247 INSN(ea
,c0
,f0
,00), /* bve,l (r22),%r2 */
1248 INSN(0f
,df
,12,d1
), /* std r31,-8(,sp) */
1249 INSN(0f
,d1
,10,c2
), /* ldd -8(,sp),rp */
1250 INSN(e8
,40,d0
,02), /* bve,n (rp) */
1251 INSN(08,00,02,40) /* nop */
1255 /* for hppa64, we don't need to call through a stub; all functions
1256 return via a bve. */
1257 regcache_cooked_write_unsigned (regcache
, 22, funcaddr
);
1258 write_memory (sp
, hppa64_tramp
, sizeof (hppa64_tramp
));
1261 regcache_cooked_write_unsigned (regcache
, 31, *bp_addr
);
1263 *real_pc
= hppa64_hpux_search_dummy_call_sequence (gdbarch
, pc
, &argreg
);
1265 error (_("Cannot make interspace call from here."));
1267 regcache_cooked_write_unsigned (regcache
, argreg
, sp
);
1269 sp
+= sizeof (hppa64_tramp
);
1272 sp
= gdbarch_frame_align (gdbarch
, sp
);
1280 hppa_hpux_supply_ss_narrow (struct regcache
*regcache
,
1281 int regnum
, const gdb_byte
*save_state
)
1283 const gdb_byte
*ss_narrow
= save_state
+ HPPA_HPUX_SS_NARROW_OFFSET
;
1286 for (i
= HPPA_R1_REGNUM
; i
< HPPA_FP0_REGNUM
; i
++)
1288 if (regnum
== i
|| regnum
== -1)
1289 regcache_raw_supply (regcache
, i
, ss_narrow
+ offset
);
1296 hppa_hpux_supply_ss_fpblock (struct regcache
*regcache
,
1297 int regnum
, const gdb_byte
*save_state
)
1299 const gdb_byte
*ss_fpblock
= save_state
+ HPPA_HPUX_SS_FPBLOCK_OFFSET
;
1302 /* FIXME: We view the floating-point state as 64 single-precision
1303 registers for 32-bit code, and 32 double-precision register for
1304 64-bit code. This distinction is artificial and should be
1305 eliminated. If that ever happens, we should remove the if-clause
1308 if (register_size (get_regcache_arch (regcache
), HPPA_FP0_REGNUM
) == 4)
1310 for (i
= HPPA_FP0_REGNUM
; i
< HPPA_FP0_REGNUM
+ 64; i
++)
1312 if (regnum
== i
|| regnum
== -1)
1313 regcache_raw_supply (regcache
, i
, ss_fpblock
+ offset
);
1320 for (i
= HPPA_FP0_REGNUM
; i
< HPPA_FP0_REGNUM
+ 32; i
++)
1322 if (regnum
== i
|| regnum
== -1)
1323 regcache_raw_supply (regcache
, i
, ss_fpblock
+ offset
);
1331 hppa_hpux_supply_ss_wide (struct regcache
*regcache
,
1332 int regnum
, const gdb_byte
*save_state
)
1334 const gdb_byte
*ss_wide
= save_state
+ HPPA_HPUX_SS_WIDE_OFFSET
;
1337 if (register_size (get_regcache_arch (regcache
), HPPA_R1_REGNUM
) == 4)
1340 for (i
= HPPA_R1_REGNUM
; i
< HPPA_FP0_REGNUM
; i
++)
1342 if (regnum
== i
|| regnum
== -1)
1343 regcache_raw_supply (regcache
, i
, ss_wide
+ offset
);
1350 hppa_hpux_supply_save_state (const struct regset
*regset
,
1351 struct regcache
*regcache
,
1352 int regnum
, const void *regs
, size_t len
)
1354 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1355 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1356 const gdb_byte
*proc_info
= regs
;
1357 const gdb_byte
*save_state
= proc_info
+ 8;
1360 flags
= extract_unsigned_integer (save_state
+ HPPA_HPUX_SS_FLAGS_OFFSET
,
1362 if (regnum
== -1 || regnum
== HPPA_FLAGS_REGNUM
)
1364 size_t size
= register_size (gdbarch
, HPPA_FLAGS_REGNUM
);
1367 store_unsigned_integer (buf
, size
, byte_order
, flags
);
1368 regcache_raw_supply (regcache
, HPPA_FLAGS_REGNUM
, buf
);
1371 /* If the SS_WIDEREGS flag is set, we really do need the full
1372 `struct save_state'. */
1373 if (flags
& HPPA_HPUX_SS_WIDEREGS
&& len
< HPPA_HPUX_SAVE_STATE_SIZE
)
1374 error (_("Register set contents too small"));
1376 if (flags
& HPPA_HPUX_SS_WIDEREGS
)
1377 hppa_hpux_supply_ss_wide (regcache
, regnum
, save_state
);
1379 hppa_hpux_supply_ss_narrow (regcache
, regnum
, save_state
);
1381 hppa_hpux_supply_ss_fpblock (regcache
, regnum
, save_state
);
1384 /* HP-UX register set. */
1386 static struct regset hppa_hpux_regset
=
1389 hppa_hpux_supply_save_state
1392 static const struct regset
*
1393 hppa_hpux_regset_from_core_section (struct gdbarch
*gdbarch
,
1394 const char *sect_name
, size_t sect_size
)
1396 if (strcmp (sect_name
, ".reg") == 0
1397 && sect_size
>= HPPA_HPUX_PA89_SAVE_STATE_SIZE
+ 8)
1398 return &hppa_hpux_regset
;
1404 /* Bit in the `ss_flag' member of `struct save_state' that indicates
1405 the state was saved from a system call. From
1406 <machine/save_state.h>. */
1407 #define HPPA_HPUX_SS_INSYSCALL 0x02
1410 hppa_hpux_read_pc (struct regcache
*regcache
)
1414 /* If we're currently in a system call return the contents of %r31. */
1415 regcache_cooked_read_unsigned (regcache
, HPPA_FLAGS_REGNUM
, &flags
);
1416 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1419 regcache_cooked_read_unsigned (regcache
, HPPA_R31_REGNUM
, &pc
);
1423 return hppa_read_pc (regcache
);
1427 hppa_hpux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1431 /* If we're currently in a system call also write PC into %r31. */
1432 regcache_cooked_read_unsigned (regcache
, HPPA_FLAGS_REGNUM
, &flags
);
1433 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1434 regcache_cooked_write_unsigned (regcache
, HPPA_R31_REGNUM
, pc
| 0x3);
1436 hppa_write_pc (regcache
, pc
);
1440 hppa_hpux_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1444 /* If we're currently in a system call return the contents of %r31. */
1445 flags
= frame_unwind_register_unsigned (next_frame
, HPPA_FLAGS_REGNUM
);
1446 if (flags
& HPPA_HPUX_SS_INSYSCALL
)
1447 return frame_unwind_register_unsigned (next_frame
, HPPA_R31_REGNUM
) & ~0x3;
1449 return hppa_unwind_pc (gdbarch
, next_frame
);
1453 /* Given the current value of the pc, check to see if it is inside a stub, and
1454 if so, change the value of the pc to point to the caller of the stub.
1455 THIS_FRAME is the current frame in the current list of frames.
1456 BASE contains to stack frame base of the current frame.
1457 SAVE_REGS is the register file stored in the frame cache. */
1459 hppa_hpux_unwind_adjust_stub (struct frame_info
*this_frame
, CORE_ADDR base
,
1460 struct trad_frame_saved_reg
*saved_regs
)
1462 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1463 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1464 int word_size
= gdbarch_ptr_bit (gdbarch
) / 8;
1465 struct value
*pcoq_head_val
;
1468 struct unwind_table_entry
*u
;
1470 pcoq_head_val
= trad_frame_get_prev_register (this_frame
, saved_regs
,
1471 HPPA_PCOQ_HEAD_REGNUM
);
1473 extract_unsigned_integer (value_contents_all (pcoq_head_val
),
1474 register_size (gdbarch
, HPPA_PCOQ_HEAD_REGNUM
),
1477 u
= find_unwind_entry (pcoq_head
);
1478 if (u
&& u
->stub_unwind
.stub_type
== EXPORT
)
1480 stubpc
= read_memory_integer (base
- 24, word_size
, byte_order
);
1481 trad_frame_set_value (saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, stubpc
);
1483 else if (hppa_symbol_address ("__gcc_plt_call")
1484 == get_pc_function_start (pcoq_head
))
1486 stubpc
= read_memory_integer (base
- 8, word_size
, byte_order
);
1487 trad_frame_set_value (saved_regs
, HPPA_PCOQ_HEAD_REGNUM
, stubpc
);
1492 hppa_hpux_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1494 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1496 if (IS_32BIT_TARGET (gdbarch
))
1497 tdep
->in_solib_call_trampoline
= hppa32_hpux_in_solib_call_trampoline
;
1499 tdep
->in_solib_call_trampoline
= hppa64_hpux_in_solib_call_trampoline
;
1501 tdep
->unwind_adjust_stub
= hppa_hpux_unwind_adjust_stub
;
1503 set_gdbarch_in_solib_return_trampoline
1504 (gdbarch
, hppa_hpux_in_solib_return_trampoline
);
1505 set_gdbarch_skip_trampoline_code (gdbarch
, hppa_hpux_skip_trampoline_code
);
1507 set_gdbarch_push_dummy_code (gdbarch
, hppa_hpux_push_dummy_code
);
1508 set_gdbarch_call_dummy_location (gdbarch
, ON_STACK
);
1510 set_gdbarch_read_pc (gdbarch
, hppa_hpux_read_pc
);
1511 set_gdbarch_write_pc (gdbarch
, hppa_hpux_write_pc
);
1512 set_gdbarch_unwind_pc (gdbarch
, hppa_hpux_unwind_pc
);
1513 set_gdbarch_skip_permanent_breakpoint
1514 (gdbarch
, hppa_skip_permanent_breakpoint
);
1516 set_gdbarch_regset_from_core_section
1517 (gdbarch
, hppa_hpux_regset_from_core_section
);
1519 frame_unwind_append_unwinder (gdbarch
, &hppa_hpux_sigtramp_frame_unwind
);
1523 hppa_hpux_som_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1525 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1529 tdep
->find_global_pointer
= hppa32_hpux_find_global_pointer
;
1531 hppa_hpux_init_abi (info
, gdbarch
);
1532 som_solib_select (gdbarch
);
1536 hppa_hpux_elf_init_abi (struct gdbarch_info info
, struct gdbarch
*gdbarch
)
1538 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1541 tdep
->find_global_pointer
= hppa64_hpux_find_global_pointer
;
1543 hppa_hpux_init_abi (info
, gdbarch
);
1544 pa64_solib_select (gdbarch
);
1547 static enum gdb_osabi
1548 hppa_hpux_core_osabi_sniffer (bfd
*abfd
)
1550 if (strcmp (bfd_get_target (abfd
), "hpux-core") == 0)
1551 return GDB_OSABI_HPUX_SOM
;
1552 else if (strcmp (bfd_get_target (abfd
), "elf64-hppa") == 0)
1556 section
= bfd_get_section_by_name (abfd
, ".kernel");
1562 size
= bfd_section_size (abfd
, section
);
1563 contents
= alloca (size
);
1564 if (bfd_get_section_contents (abfd
, section
, contents
,
1566 && strcmp (contents
, "HP-UX") == 0)
1567 return GDB_OSABI_HPUX_ELF
;
1571 return GDB_OSABI_UNKNOWN
;
1575 _initialize_hppa_hpux_tdep (void)
1577 /* BFD doesn't set a flavour for HP-UX style core files. It doesn't
1578 set the architecture either. */
1579 gdbarch_register_osabi_sniffer (bfd_arch_unknown
,
1580 bfd_target_unknown_flavour
,
1581 hppa_hpux_core_osabi_sniffer
);
1582 gdbarch_register_osabi_sniffer (bfd_arch_hppa
,
1583 bfd_target_elf_flavour
,
1584 hppa_hpux_core_osabi_sniffer
);
1586 gdbarch_register_osabi (bfd_arch_hppa
, 0, GDB_OSABI_HPUX_SOM
,
1587 hppa_hpux_som_init_abi
);
1588 gdbarch_register_osabi (bfd_arch_hppa
, bfd_mach_hppa20w
, GDB_OSABI_HPUX_ELF
,
1589 hppa_hpux_elf_init_abi
);