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 (struct frame_info *frame, 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) 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 (current_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 (current_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 && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_SYMBOL_NAME (msym)))
387 /* the type of msym is correct (mst_solib_trampoline), but
388 the unwind info is wrong, so set it to the correct value */
389 u->stub_unwind.stub_type = EXPORT;
391 /* the stub type info in the unwind is correct (this is not a
392 trampoline), but the msym type information is wrong, it
393 should be mst_text. So we need to fix the msym, and also
394 get out of this function */
396 MSYMBOL_TYPE (msym) = mst_text;
397 return orig_pc == pc ? 0 : pc & ~0x3;
401 /*--------------------------------------------------------------------------*/
404 /* It's a stub. Search for a branch and figure out where it goes.
405 Note we have to handle multi insn branch sequences like ldil;ble.
406 Most (all?) other branches can be determined by examining the contents
407 of certain registers and the stack. */
414 /* Make sure we haven't walked outside the range of this stub. */
415 if (u != find_unwind_entry (loc))
417 warning (_("Unable to find branch in linker stub"));
418 return orig_pc == pc ? 0 : pc & ~0x3;
421 prev_inst = curr_inst;
422 curr_inst = read_memory_integer (loc, 4);
424 /* Does it look like a branch external using %r1? Then it's the
425 branch from the stub to the actual function. */
426 if ((curr_inst & 0xffe0e000) == 0xe0202000)
428 /* Yup. See if the previous instruction loaded
429 a value into %r1. If so compute and return the jump address. */
430 if ((prev_inst & 0xffe00000) == 0x20200000)
431 return (hppa_extract_21 (prev_inst) + hppa_extract_17 (curr_inst)) & ~0x3;
434 warning (_("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."));
435 return orig_pc == pc ? 0 : pc & ~0x3;
439 /* Does it look like a be 0(sr0,%r21)? OR
440 Does it look like a be, n 0(sr0,%r21)? OR
441 Does it look like a bve (r21)? (this is on PA2.0)
442 Does it look like a bve, n(r21)? (this is also on PA2.0)
443 That's the branch from an
444 import stub to an export stub.
446 It is impossible to determine the target of the branch via
447 simple examination of instructions and/or data (consider
448 that the address in the plabel may be the address of the
449 bind-on-reference routine in the dynamic loader).
451 So we have try an alternative approach.
453 Get the name of the symbol at our current location; it should
454 be a stub symbol with the same name as the symbol in the
457 Then lookup a minimal symbol with the same name; we should
458 get the minimal symbol for the target routine in the shared
459 library as those take precedence of import/export stubs. */
460 if ((curr_inst == 0xe2a00000) ||
461 (curr_inst == 0xe2a00002) ||
462 (curr_inst == 0xeaa0d000) ||
463 (curr_inst == 0xeaa0d002))
465 struct minimal_symbol *stubsym, *libsym;
467 stubsym = lookup_minimal_symbol_by_pc (loc);
470 warning (_("Unable to find symbol for 0x%lx"), loc);
471 return orig_pc == pc ? 0 : pc & ~0x3;
474 libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
477 warning (_("Unable to find library symbol for %s."),
478 DEPRECATED_SYMBOL_NAME (stubsym));
479 return orig_pc == pc ? 0 : pc & ~0x3;
482 return SYMBOL_VALUE (libsym);
485 /* Does it look like bl X,%rp or bl X,%r0? Another way to do a
486 branch from the stub to the actual function. */
488 else if ((curr_inst & 0xffe0e000) == 0xe8400000
489 || (curr_inst & 0xffe0e000) == 0xe8000000
490 || (curr_inst & 0xffe0e000) == 0xe800A000)
491 return (loc + hppa_extract_17 (curr_inst) + 8) & ~0x3;
493 /* Does it look like bv (rp)? Note this depends on the
494 current stack pointer being the same as the stack
495 pointer in the stub itself! This is a branch on from the
496 stub back to the original caller. */
497 /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
498 else if ((curr_inst & 0xffe0f000) == 0xe840c000)
500 /* Yup. See if the previous instruction loaded
502 if (prev_inst == 0x4bc23ff1)
505 sp = get_frame_register_unsigned (frame, HPPA_SP_REGNUM);
506 return read_memory_integer (sp - 8, 4) & ~0x3;
510 warning (_("Unable to find restore of %%rp before bv (%%rp)."));
511 return orig_pc == pc ? 0 : pc & ~0x3;
515 /* elz: added this case to capture the new instruction
516 at the end of the return part of an export stub used by
517 the PA2.0: BVE, n (rp) */
518 else if ((curr_inst & 0xffe0f000) == 0xe840d000)
520 return (read_memory_integer
521 (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
522 gdbarch_ptr_bit (current_gdbarch) / 8)) & ~0x3;
525 /* What about be,n 0(sr0,%rp)? It's just another way we return to
526 the original caller from the stub. Used in dynamic executables. */
527 else if (curr_inst == 0xe0400002)
529 /* The value we jump to is sitting in sp - 24. But that's
530 loaded several instructions before the be instruction.
531 I guess we could check for the previous instruction being
532 mtsp %r1,%sr0 if we want to do sanity checking. */
533 return (read_memory_integer
534 (get_frame_register_unsigned (frame, HPPA_SP_REGNUM) - 24,
535 gdbarch_ptr_bit (current_gdbarch) / 8)) & ~0x3;
538 /* Haven't found the branch yet, but we're still in the stub.
545 hppa_skip_permanent_breakpoint (struct regcache *regcache)
547 /* To step over a breakpoint instruction on the PA takes some
548 fiddling with the instruction address queue.
550 When we stop at a breakpoint, the IA queue front (the instruction
551 we're executing now) points at the breakpoint instruction, and
552 the IA queue back (the next instruction to execute) points to
553 whatever instruction we would execute after the breakpoint, if it
554 were an ordinary instruction. This is the case even if the
555 breakpoint is in the delay slot of a branch instruction.
557 Clearly, to step past the breakpoint, we need to set the queue
558 front to the back. But what do we put in the back? What
559 instruction comes after that one? Because of the branch delay
560 slot, the next insn is always at the back + 4. */
562 ULONGEST pcoq_tail, pcsq_tail;
563 regcache_cooked_read_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, &pcoq_tail);
564 regcache_cooked_read_unsigned (regcache, HPPA_PCSQ_TAIL_REGNUM, &pcsq_tail);
566 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_HEAD_REGNUM, pcoq_tail);
567 regcache_cooked_write_unsigned (regcache, HPPA_PCSQ_HEAD_REGNUM, pcsq_tail);
569 regcache_cooked_write_unsigned (regcache, HPPA_PCOQ_TAIL_REGNUM, pcoq_tail + 4);
570 /* We can leave the tail's space the same, since there's no jump. */
575 struct hppa_hpux_sigtramp_unwind_cache
578 struct trad_frame_saved_reg *saved_regs;
581 static int hppa_hpux_tramp_reg[] = {
583 HPPA_PCOQ_HEAD_REGNUM,
584 HPPA_PCSQ_HEAD_REGNUM,
585 HPPA_PCOQ_TAIL_REGNUM,
586 HPPA_PCSQ_TAIL_REGNUM,
613 static struct hppa_hpux_sigtramp_unwind_cache *
614 hppa_hpux_sigtramp_frame_unwind_cache (struct frame_info *next_frame,
618 struct gdbarch *gdbarch = get_frame_arch (next_frame);
619 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
620 struct hppa_hpux_sigtramp_unwind_cache *info;
622 CORE_ADDR sp, scptr, off;
628 info = FRAME_OBSTACK_ZALLOC (struct hppa_hpux_sigtramp_unwind_cache);
630 info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
632 sp = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
634 if (IS_32BIT_TARGET (gdbarch))
641 /* See /usr/include/machine/save_state.h for the structure of the save_state_t
644 flag = read_memory_unsigned_integer(scptr + HPPA_HPUX_SS_FLAGS_OFFSET, 4);
646 if (!(flag & HPPA_HPUX_SS_WIDEREGS))
648 /* Narrow registers. */
649 off = scptr + HPPA_HPUX_SS_NARROW_OFFSET;
655 /* Wide registers. */
656 off = scptr + HPPA_HPUX_SS_WIDE_OFFSET + 8;
658 szoff = (tdep->bytes_per_address == 4 ? 4 : 0);
661 for (i = 1; i < 32; i++)
663 info->saved_regs[HPPA_R0_REGNUM + i].addr = off + szoff;
667 for (i = 0; i < ARRAY_SIZE (hppa_hpux_tramp_reg); i++)
669 if (hppa_hpux_tramp_reg[i] > 0)
670 info->saved_regs[hppa_hpux_tramp_reg[i]].addr = off + szoff;
677 info->base = frame_unwind_register_unsigned (next_frame, HPPA_SP_REGNUM);
683 hppa_hpux_sigtramp_frame_this_id (struct frame_info *next_frame,
684 void **this_prologue_cache,
685 struct frame_id *this_id)
687 struct hppa_hpux_sigtramp_unwind_cache *info
688 = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
689 *this_id = frame_id_build (info->base, frame_pc_unwind (next_frame));
693 hppa_hpux_sigtramp_frame_prev_register (struct frame_info *next_frame,
694 void **this_prologue_cache,
695 int regnum, int *optimizedp,
696 enum lval_type *lvalp,
698 int *realnump, gdb_byte *valuep)
700 struct hppa_hpux_sigtramp_unwind_cache *info
701 = hppa_hpux_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
702 hppa_frame_prev_register_helper (next_frame, info->saved_regs, regnum,
703 optimizedp, lvalp, addrp, realnump, valuep);
706 static const struct frame_unwind hppa_hpux_sigtramp_frame_unwind = {
708 hppa_hpux_sigtramp_frame_this_id,
709 hppa_hpux_sigtramp_frame_prev_register
712 static const struct frame_unwind *
713 hppa_hpux_sigtramp_unwind_sniffer (struct frame_info *next_frame)
715 struct unwind_table_entry *u;
716 CORE_ADDR pc = frame_pc_unwind (next_frame);
718 u = find_unwind_entry (pc);
720 /* If this is an export stub, try to get the unwind descriptor for
721 the actual function itself. */
722 if (u && u->stub_unwind.stub_type == EXPORT)
724 gdb_byte buf[HPPA_INSN_SIZE];
727 if (!safe_frame_unwind_memory (next_frame, u->region_start,
731 insn = extract_unsigned_integer (buf, sizeof buf);
732 if ((insn & 0xffe0e000) == 0xe8400000)
733 u = find_unwind_entry(u->region_start + hppa_extract_17 (insn) + 8);
736 if (u && u->HP_UX_interrupt_marker)
737 return &hppa_hpux_sigtramp_frame_unwind;
743 hppa32_hpux_find_global_pointer (struct value *function)
747 faddr = value_as_address (function);
749 /* Is this a plabel? If so, dereference it to get the gp value. */
757 status = target_read_memory (faddr + 4, buf, sizeof (buf));
759 return extract_unsigned_integer (buf, sizeof (buf));
762 return gdbarch_tdep (current_gdbarch)->solib_get_got_by_pc (faddr);
766 hppa64_hpux_find_global_pointer (struct value *function)
771 faddr = value_as_address (function);
773 if (in_opd_section (faddr))
775 target_read_memory (faddr, buf, sizeof (buf));
776 return extract_unsigned_integer (&buf[24], 8);
780 return gdbarch_tdep (current_gdbarch)->solib_get_got_by_pc (faddr);
784 static unsigned int ldsid_pattern[] = {
785 0x000010a0, /* ldsid (rX),rY */
786 0x00001820, /* mtsp rY,sr0 */
787 0xe0000000 /* be,n (sr0,rX) */
791 hppa_hpux_search_pattern (CORE_ADDR start, CORE_ADDR end,
792 unsigned int *patterns, int count)
794 int num_insns = (end - start + HPPA_INSN_SIZE) / HPPA_INSN_SIZE;
799 buf = alloca (num_insns * HPPA_INSN_SIZE);
800 insns = alloca (num_insns * sizeof (unsigned int));
802 read_memory (start, buf, num_insns * HPPA_INSN_SIZE);
803 for (i = 0; i < num_insns; i++, buf += HPPA_INSN_SIZE)
804 insns[i] = extract_unsigned_integer (buf, HPPA_INSN_SIZE);
806 for (offset = 0; offset <= num_insns - count; offset++)
808 for (i = 0; i < count; i++)
810 if ((insns[offset + i] & patterns[i]) != patterns[i])
817 if (offset <= num_insns - count)
818 return start + offset * HPPA_INSN_SIZE;
824 hppa32_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
828 struct obj_section *sec;
829 struct hppa_objfile_private *priv;
830 struct frame_info *frame;
831 struct unwind_table_entry *u;
836 sec = find_pc_section (pc);
838 priv = objfile_data (obj, hppa_objfile_priv_data);
841 priv = hppa_init_objfile_priv_data (obj);
843 error (_("Internal error creating objfile private data."));
845 /* Use the cached value if we have one. */
846 if (priv->dummy_call_sequence_addr != 0)
848 *argreg = priv->dummy_call_sequence_reg;
849 return priv->dummy_call_sequence_addr;
852 /* First try a heuristic; if we are in a shared library call, our return
853 pointer is likely to point at an export stub. */
854 frame = get_current_frame ();
855 rp = frame_unwind_register_unsigned (frame, 2);
856 u = find_unwind_entry (rp);
857 if (u && u->stub_unwind.stub_type == EXPORT)
859 addr = hppa_hpux_search_pattern (u->region_start, u->region_end,
861 ARRAY_SIZE (ldsid_pattern));
866 /* Next thing to try is to look for an export stub. */
867 if (priv->unwind_info)
871 for (i = 0; i < priv->unwind_info->last; i++)
873 struct unwind_table_entry *u;
874 u = &priv->unwind_info->table[i];
875 if (u->stub_unwind.stub_type == EXPORT)
877 addr = hppa_hpux_search_pattern (u->region_start, u->region_end,
879 ARRAY_SIZE (ldsid_pattern));
888 /* Finally, if this is the main executable, try to locate a sequence
890 addr = hppa_symbol_address ("noshlibs");
891 sec = find_pc_section (addr);
893 if (sec && sec->objfile == obj)
895 CORE_ADDR start, end;
897 find_pc_partial_function (addr, NULL, &start, &end);
898 if (start != 0 && end != 0)
900 addr = hppa_hpux_search_pattern (start, end, ldsid_pattern,
901 ARRAY_SIZE (ldsid_pattern));
907 /* Can't find a suitable sequence. */
911 target_read_memory (addr, buf, sizeof (buf));
912 insn = extract_unsigned_integer (buf, sizeof (buf));
913 priv->dummy_call_sequence_addr = addr;
914 priv->dummy_call_sequence_reg = (insn >> 21) & 0x1f;
916 *argreg = priv->dummy_call_sequence_reg;
917 return priv->dummy_call_sequence_addr;
921 hppa64_hpux_search_dummy_call_sequence (struct gdbarch *gdbarch, CORE_ADDR pc,
925 struct obj_section *sec;
926 struct hppa_objfile_private *priv;
928 struct minimal_symbol *msym;
931 sec = find_pc_section (pc);
933 priv = objfile_data (obj, hppa_objfile_priv_data);
936 priv = hppa_init_objfile_priv_data (obj);
938 error (_("Internal error creating objfile private data."));
940 /* Use the cached value if we have one. */
941 if (priv->dummy_call_sequence_addr != 0)
943 *argreg = priv->dummy_call_sequence_reg;
944 return priv->dummy_call_sequence_addr;
947 /* FIXME: Without stub unwind information, locating a suitable sequence is
948 fairly difficult. For now, we implement a very naive and inefficient
949 scheme; try to read in blocks of code, and look for a "bve,n (rp)"
950 instruction. These are likely to occur at the end of functions, so
951 we only look at the last two instructions of each function. */
952 for (i = 0, msym = obj->msymbols; i < obj->minimal_symbol_count; i++, msym++)
954 CORE_ADDR begin, end;
956 gdb_byte buf[2 * HPPA_INSN_SIZE];
959 find_pc_partial_function (SYMBOL_VALUE_ADDRESS (msym), &name,
962 if (name == NULL || begin == 0 || end == 0)
965 if (target_read_memory (end - sizeof (buf), buf, sizeof (buf)) == 0)
967 for (offset = 0; offset < sizeof (buf); offset++)
971 insn = extract_unsigned_integer (buf + offset, HPPA_INSN_SIZE);
972 if (insn == 0xe840d002) /* bve,n (rp) */
974 addr = (end - sizeof (buf)) + offset;
981 /* Can't find a suitable sequence. */
985 priv->dummy_call_sequence_addr = addr;
986 /* Right now we only look for a "bve,l (rp)" sequence, so the register is
987 always HPPA_RP_REGNUM. */
988 priv->dummy_call_sequence_reg = HPPA_RP_REGNUM;
990 *argreg = priv->dummy_call_sequence_reg;
991 return priv->dummy_call_sequence_addr;
995 hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
997 struct objfile *objfile;
998 struct minimal_symbol *funsym, *stubsym;
1001 funsym = lookup_minimal_symbol_by_pc (funcaddr);
1004 ALL_OBJFILES (objfile)
1006 stubsym = lookup_minimal_symbol_solib_trampoline
1007 (SYMBOL_LINKAGE_NAME (funsym), objfile);
1011 struct unwind_table_entry *u;
1013 u = find_unwind_entry (SYMBOL_VALUE (stubsym));
1015 || (u->stub_unwind.stub_type != IMPORT
1016 && u->stub_unwind.stub_type != IMPORT_SHLIB))
1019 stubaddr = SYMBOL_VALUE (stubsym);
1021 /* If we found an IMPORT stub, then we can stop searching;
1022 if we found an IMPORT_SHLIB, we want to continue the search
1023 in the hopes that we will find an IMPORT stub. */
1024 if (u->stub_unwind.stub_type == IMPORT)
1033 hppa_hpux_sr_for_addr (CORE_ADDR addr)
1036 /* The space register to use is encoded in the top 2 bits of the address. */
1037 sr = addr >> (gdbarch_tdep (current_gdbarch)->bytes_per_address * 8 - 2);
1042 hppa_hpux_find_dummy_bpaddr (CORE_ADDR addr)
1044 /* In order for us to restore the space register to its starting state,
1045 we need the dummy trampoline to return to the an instruction address in
1046 the same space as where we started the call. We used to place the
1047 breakpoint near the current pc, however, this breaks nested dummy calls
1048 as the nested call will hit the breakpoint address and terminate
1049 prematurely. Instead, we try to look for an address in the same space to
1052 This is similar in spirit to putting the breakpoint at the "entry point"
1053 of an executable. */
1055 struct obj_section *sec;
1056 struct unwind_table_entry *u;
1057 struct minimal_symbol *msym;
1061 sec = find_pc_section (addr);
1064 /* First try the lowest address in the section; we can use it as long
1065 as it is "regular" code (i.e. not a stub) */
1066 u = find_unwind_entry (sec->addr);
1067 if (!u || u->stub_unwind.stub_type == 0)
1070 /* Otherwise, we need to find a symbol for a regular function. We
1071 do this by walking the list of msymbols in the objfile. The symbol
1072 we find should not be the same as the function that was passed in. */
1074 /* FIXME: this is broken, because we can find a function that will be
1075 called by the dummy call target function, which will still not
1078 find_pc_partial_function (addr, NULL, &func, NULL);
1079 for (i = 0, msym = sec->objfile->msymbols;
1080 i < sec->objfile->minimal_symbol_count;
1083 u = find_unwind_entry (SYMBOL_VALUE_ADDRESS (msym));
1084 if (func != SYMBOL_VALUE_ADDRESS (msym)
1085 && (!u || u->stub_unwind.stub_type == 0))
1086 return SYMBOL_VALUE_ADDRESS (msym);
1090 warning (_("Cannot find suitable address to place dummy breakpoint; nested "
1091 "calls may fail."));
1096 hppa_hpux_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp,
1097 CORE_ADDR funcaddr, int using_gcc,
1098 struct value **args, int nargs,
1099 struct type *value_type,
1100 CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
1102 CORE_ADDR pc, stubaddr;
1107 /* Note: we don't want to pass a function descriptor here; push_dummy_call
1108 fills in the PIC register for us. */
1109 funcaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funcaddr, NULL);
1111 /* The simple case is where we call a function in the same space that we are
1112 currently in; in that case we don't really need to do anything. */
1113 if (hppa_hpux_sr_for_addr (pc) == hppa_hpux_sr_for_addr (funcaddr))
1115 /* Intraspace call. */
1116 *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1117 *real_pc = funcaddr;
1118 regcache_cooked_write_unsigned (current_regcache, HPPA_RP_REGNUM, *bp_addr);
1123 /* In order to make an interspace call, we need to go through a stub.
1124 gcc supplies an appropriate stub called "__gcc_plt_call", however, if
1125 an application is compiled with HP compilers then this stub is not
1126 available. We used to fallback to "__d_plt_call", however that stub
1127 is not entirely useful for us because it doesn't do an interspace
1128 return back to the caller. Also, on hppa64-hpux, there is no
1129 __gcc_plt_call available. In order to keep the code uniform, we
1130 instead don't use either of these stubs, but instead write our own
1133 A problem arises since the stack is located in a different space than
1134 code, so in order to branch to a stack stub, we will need to do an
1135 interspace branch. Previous versions of gdb did this by modifying code
1136 at the current pc and doing single-stepping to set the pcsq. Since this
1137 is highly undesirable, we use a different scheme:
1139 All we really need to do the branch to the stub is a short instruction
1150 Instead of writing these sequences ourselves, we can find it in
1151 the instruction stream that belongs to the current space. While this
1152 seems difficult at first, we are actually guaranteed to find the sequences
1156 - in export stubs for shared libraries
1157 - in the "noshlibs" routine in the main module
1160 - at the end of each "regular" function
1162 We cache the address of these sequences in the objfile's private data
1163 since these operations can potentially be quite expensive.
1166 - write a stack trampoline
1167 - look for a suitable instruction sequence in the current space
1168 - point the sequence at the trampoline
1169 - set the return address of the trampoline to the current space
1170 (see hppa_hpux_find_dummy_call_bpaddr)
1171 - set the continuing address of the "dummy code" as the sequence.
1175 if (IS_32BIT_TARGET (gdbarch))
1177 static unsigned int hppa32_tramp[] = {
1178 0x0fdf1291, /* stw r31,-8(,sp) */
1179 0x02c010a1, /* ldsid (,r22),r1 */
1180 0x00011820, /* mtsp r1,sr0 */
1181 0xe6c00000, /* be,l 0(sr0,r22),%sr0,%r31 */
1182 0x081f0242, /* copy r31,rp */
1183 0x0fd11082, /* ldw -8(,sp),rp */
1184 0x004010a1, /* ldsid (,rp),r1 */
1185 0x00011820, /* mtsp r1,sr0 */
1186 0xe0400000, /* be 0(sr0,rp) */
1187 0x08000240 /* nop */
1190 /* for hppa32, we must call the function through a stub so that on
1191 return it can return to the space of our trampoline. */
1192 stubaddr = hppa_hpux_find_import_stub_for_addr (funcaddr);
1194 error (_("Cannot call external function not referenced by application "
1195 "(no import stub).\n"));
1196 regcache_cooked_write_unsigned (current_regcache, 22, stubaddr);
1198 write_memory (sp, (char *)&hppa32_tramp, sizeof (hppa32_tramp));
1200 *bp_addr = hppa_hpux_find_dummy_bpaddr (pc);
1201 regcache_cooked_write_unsigned (current_regcache, 31, *bp_addr);
1203 *real_pc = hppa32_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1205 error (_("Cannot make interspace call from here."));
1207 regcache_cooked_write_unsigned (current_regcache, argreg, sp);
1209 sp += sizeof (hppa32_tramp);
1213 static unsigned int hppa64_tramp[] = {
1214 0xeac0f000, /* bve,l (r22),%r2 */
1215 0x0fdf12d1, /* std r31,-8(,sp) */
1216 0x0fd110c2, /* ldd -8(,sp),rp */
1217 0xe840d002, /* bve,n (rp) */
1218 0x08000240 /* nop */
1221 /* for hppa64, we don't need to call through a stub; all functions
1222 return via a bve. */
1223 regcache_cooked_write_unsigned (current_regcache, 22, funcaddr);
1224 write_memory (sp, (char *)&hppa64_tramp, sizeof (hppa64_tramp));
1227 regcache_cooked_write_unsigned (current_regcache, 31, *bp_addr);
1229 *real_pc = hppa64_hpux_search_dummy_call_sequence (gdbarch, pc, &argreg);
1231 error (_("Cannot make interspace call from here."));
1233 regcache_cooked_write_unsigned (current_regcache, argreg, sp);
1235 sp += sizeof (hppa64_tramp);
1238 sp = gdbarch_frame_align (gdbarch, sp);
1246 hppa_hpux_supply_ss_narrow (struct regcache *regcache,
1247 int regnum, const char *save_state)
1249 const char *ss_narrow = save_state + HPPA_HPUX_SS_NARROW_OFFSET;
1252 for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1254 if (regnum == i || regnum == -1)
1255 regcache_raw_supply (regcache, i, ss_narrow + offset);
1262 hppa_hpux_supply_ss_fpblock (struct regcache *regcache,
1263 int regnum, const char *save_state)
1265 const char *ss_fpblock = save_state + HPPA_HPUX_SS_FPBLOCK_OFFSET;
1268 /* FIXME: We view the floating-point state as 64 single-precision
1269 registers for 32-bit code, and 32 double-precision register for
1270 64-bit code. This distinction is artificial and should be
1271 eliminated. If that ever happens, we should remove the if-clause
1274 if (register_size (get_regcache_arch (regcache), HPPA_FP0_REGNUM) == 4)
1276 for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 64; i++)
1278 if (regnum == i || regnum == -1)
1279 regcache_raw_supply (regcache, i, ss_fpblock + offset);
1286 for (i = HPPA_FP0_REGNUM; i < HPPA_FP0_REGNUM + 32; i++)
1288 if (regnum == i || regnum == -1)
1289 regcache_raw_supply (regcache, i, ss_fpblock + offset);
1297 hppa_hpux_supply_ss_wide (struct regcache *regcache,
1298 int regnum, const char *save_state)
1300 const char *ss_wide = save_state + HPPA_HPUX_SS_WIDE_OFFSET;
1303 if (register_size (get_regcache_arch (regcache), HPPA_R1_REGNUM) == 4)
1306 for (i = HPPA_R1_REGNUM; i < HPPA_FP0_REGNUM; i++)
1308 if (regnum == i || regnum == -1)
1309 regcache_raw_supply (regcache, i, ss_wide + offset);
1316 hppa_hpux_supply_save_state (const struct regset *regset,
1317 struct regcache *regcache,
1318 int regnum, const void *regs, size_t len)
1320 const char *proc_info = regs;
1321 const char *save_state = proc_info + 8;
1324 flags = extract_unsigned_integer (save_state + HPPA_HPUX_SS_FLAGS_OFFSET, 4);
1325 if (regnum == -1 || regnum == HPPA_FLAGS_REGNUM)
1327 struct gdbarch *arch = get_regcache_arch (regcache);
1328 size_t size = register_size (arch, HPPA_FLAGS_REGNUM);
1331 store_unsigned_integer (buf, size, flags);
1332 regcache_raw_supply (regcache, HPPA_FLAGS_REGNUM, buf);
1335 /* If the SS_WIDEREGS flag is set, we really do need the full
1336 `struct save_state'. */
1337 if (flags & HPPA_HPUX_SS_WIDEREGS && len < HPPA_HPUX_SAVE_STATE_SIZE)
1338 error (_("Register set contents too small"));
1340 if (flags & HPPA_HPUX_SS_WIDEREGS)
1341 hppa_hpux_supply_ss_wide (regcache, regnum, save_state);
1343 hppa_hpux_supply_ss_narrow (regcache, regnum, save_state);
1345 hppa_hpux_supply_ss_fpblock (regcache, regnum, save_state);
1348 /* HP-UX register set. */
1350 static struct regset hppa_hpux_regset =
1353 hppa_hpux_supply_save_state
1356 static const struct regset *
1357 hppa_hpux_regset_from_core_section (struct gdbarch *gdbarch,
1358 const char *sect_name, size_t sect_size)
1360 if (strcmp (sect_name, ".reg") == 0
1361 && sect_size >= HPPA_HPUX_PA89_SAVE_STATE_SIZE + 8)
1362 return &hppa_hpux_regset;
1368 /* Bit in the `ss_flag' member of `struct save_state' that indicates
1369 the state was saved from a system call. From
1370 <machine/save_state.h>. */
1371 #define HPPA_HPUX_SS_INSYSCALL 0x02
1374 hppa_hpux_read_pc (ptid_t ptid)
1378 /* If we're currently in a system call return the contents of %r31. */
1379 flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
1380 if (flags & HPPA_HPUX_SS_INSYSCALL)
1381 return read_register_pid (HPPA_R31_REGNUM, ptid) & ~0x3;
1383 return hppa_read_pc (ptid);
1387 hppa_hpux_write_pc (CORE_ADDR pc, ptid_t ptid)
1391 /* If we're currently in a system call also write PC into %r31. */
1392 flags = read_register_pid (HPPA_FLAGS_REGNUM, ptid);
1393 if (flags & HPPA_HPUX_SS_INSYSCALL)
1394 write_register_pid (HPPA_R31_REGNUM, pc | 0x3, ptid);
1396 return hppa_write_pc (pc, ptid);
1400 hppa_hpux_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1404 /* If we're currently in a system call return the contents of %r31. */
1405 flags = frame_unwind_register_unsigned (next_frame, HPPA_FLAGS_REGNUM);
1406 if (flags & HPPA_HPUX_SS_INSYSCALL)
1407 return frame_unwind_register_unsigned (next_frame, HPPA_R31_REGNUM) & ~0x3;
1409 return hppa_unwind_pc (gdbarch, next_frame);
1413 /* Given the current value of the pc, check to see if it is inside a stub, and
1414 if so, change the value of the pc to point to the caller of the stub.
1415 NEXT_FRAME is the next frame in the current list of frames.
1416 BASE contains to stack frame base of the current frame.
1417 SAVE_REGS is the register file stored in the frame cache. */
1419 hppa_hpux_unwind_adjust_stub (struct frame_info *next_frame, CORE_ADDR base,
1420 struct trad_frame_saved_reg *saved_regs)
1422 int optimized, realreg;
1423 enum lval_type lval;
1425 char buffer[sizeof(ULONGEST)];
1428 struct unwind_table_entry *u;
1430 trad_frame_get_prev_register (next_frame, saved_regs,
1431 HPPA_PCOQ_HEAD_REGNUM,
1432 &optimized, &lval, &addr, &realreg, buffer);
1433 val = extract_unsigned_integer (buffer,
1434 register_size (get_frame_arch (next_frame),
1435 HPPA_PCOQ_HEAD_REGNUM));
1437 u = find_unwind_entry (val);
1438 if (u && u->stub_unwind.stub_type == EXPORT)
1440 stubpc = read_memory_integer
1441 (base - 24, gdbarch_ptr_bit (current_gdbarch) / 8);
1442 trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1444 else if (hppa_symbol_address ("__gcc_plt_call")
1445 == get_pc_function_start (val))
1447 stubpc = read_memory_integer
1448 (base - 8, gdbarch_ptr_bit (current_gdbarch) / 8);
1449 trad_frame_set_value (saved_regs, HPPA_PCOQ_HEAD_REGNUM, stubpc);
1454 hppa_hpux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1456 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1458 if (IS_32BIT_TARGET (gdbarch))
1459 tdep->in_solib_call_trampoline = hppa32_hpux_in_solib_call_trampoline;
1461 tdep->in_solib_call_trampoline = hppa64_hpux_in_solib_call_trampoline;
1463 tdep->unwind_adjust_stub = hppa_hpux_unwind_adjust_stub;
1465 set_gdbarch_in_solib_return_trampoline
1466 (gdbarch, hppa_hpux_in_solib_return_trampoline);
1467 set_gdbarch_skip_trampoline_code (gdbarch, hppa_hpux_skip_trampoline_code);
1469 set_gdbarch_push_dummy_code (gdbarch, hppa_hpux_push_dummy_code);
1470 set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
1472 set_gdbarch_read_pc (gdbarch, hppa_hpux_read_pc);
1473 set_gdbarch_write_pc (gdbarch, hppa_hpux_write_pc);
1474 set_gdbarch_unwind_pc (gdbarch, hppa_hpux_unwind_pc);
1475 set_gdbarch_skip_permanent_breakpoint
1476 (gdbarch, hppa_skip_permanent_breakpoint);
1478 set_gdbarch_regset_from_core_section
1479 (gdbarch, hppa_hpux_regset_from_core_section);
1481 frame_unwind_append_sniffer (gdbarch, hppa_hpux_sigtramp_unwind_sniffer);
1485 hppa_hpux_som_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1487 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1491 tdep->find_global_pointer = hppa32_hpux_find_global_pointer;
1493 hppa_hpux_init_abi (info, gdbarch);
1494 som_solib_select (tdep);
1498 hppa_hpux_elf_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
1500 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1503 tdep->find_global_pointer = hppa64_hpux_find_global_pointer;
1505 hppa_hpux_init_abi (info, gdbarch);
1506 pa64_solib_select (tdep);
1509 static enum gdb_osabi
1510 hppa_hpux_core_osabi_sniffer (bfd *abfd)
1512 if (strcmp (bfd_get_target (abfd), "hpux-core") == 0)
1513 return GDB_OSABI_HPUX_SOM;
1514 else if (strcmp (bfd_get_target (abfd), "elf64-hppa") == 0)
1518 section = bfd_get_section_by_name (abfd, ".kernel");
1524 size = bfd_section_size (abfd, section);
1525 contents = alloca (size);
1526 if (bfd_get_section_contents (abfd, section, contents,
1528 && strcmp (contents, "HP-UX") == 0)
1529 return GDB_OSABI_HPUX_ELF;
1533 return GDB_OSABI_UNKNOWN;
1537 _initialize_hppa_hpux_tdep (void)
1539 /* BFD doesn't set a flavour for HP-UX style core files. It doesn't
1540 set the architecture either. */
1541 gdbarch_register_osabi_sniffer (bfd_arch_unknown,
1542 bfd_target_unknown_flavour,
1543 hppa_hpux_core_osabi_sniffer);
1544 gdbarch_register_osabi_sniffer (bfd_arch_hppa,
1545 bfd_target_elf_flavour,
1546 hppa_hpux_core_osabi_sniffer);
1548 gdbarch_register_osabi (bfd_arch_hppa, 0, GDB_OSABI_HPUX_SOM,
1549 hppa_hpux_som_init_abi);
1550 gdbarch_register_osabi (bfd_arch_hppa, bfd_mach_hppa20w, GDB_OSABI_HPUX_ELF,
1551 hppa_hpux_elf_init_abi);