static int restore_pc_queue PARAMS ((struct frame_saved_regs *fsr));
static int hppa_alignof PARAMS ((struct type *arg));
-static FRAME_ADDR dig_fp_from_stack PARAMS ((FRAME frame,
- struct unwind_table_entry *u));
CORE_ADDR frame_saved_pc PARAMS ((FRAME frame));
+static int prologue_inst_adjust_sp PARAMS ((unsigned long));
+static int is_branch PARAMS ((unsigned long));
+static int inst_saves_gr PARAMS ((unsigned long));
+static int inst_saves_fr PARAMS ((unsigned long));
+static int pc_in_interrupt_handler PARAMS ((CORE_ADDR));
+static int pc_in_linker_stub PARAMS ((CORE_ADDR));
\f
/* Routines to extract various sized constants out of hppa
return NULL;
}
+/* Called to determine if PC is in an interrupt handler of some
+ kind. */
+
+static int
+pc_in_interrupt_handler (pc)
+ CORE_ADDR pc;
+{
+ struct unwind_table_entry *u;
+ struct minimal_symbol *msym_us;
+
+ u = find_unwind_entry (pc);
+ if (!u)
+ return 0;
+
+ /* Oh joys. HPUX sets the interrupt bit for _sigreturn even though
+ its frame isn't a pure interrupt frame. Deal with this. */
+ msym_us = lookup_minimal_symbol_by_pc (pc);
+
+ return u->HP_UX_interrupt_marker && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us));
+}
+
/* Called when no unwind descriptor was found for PC. Returns 1 if it
appears that PC is in a linker stub. */
-static int pc_in_linker_stub PARAMS ((CORE_ADDR));
static int
pc_in_linker_stub (pc)
/* Return size of frame, or -1 if we should use a frame pointer. */
int
-find_proc_framesize(pc)
+find_proc_framesize (pc)
CORE_ADDR pc;
{
struct unwind_table_entry *u;
+ struct minimal_symbol *msym_us;
u = find_unwind_entry (pc);
return -1;
}
- if (u->Save_SP)
- /* If this bit is set, it means there is a frame pointer and we should
- use it. */
+ msym_us = lookup_minimal_symbol_by_pc (pc);
+
+ /* If Save_SP is set, and we're not in an interrupt or signal caller,
+ then we have a frame pointer. Use it. */
+ if (u->Save_SP && !pc_in_interrupt_handler (pc)
+ && !IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)))
return -1;
return u->Total_frame_size << 3;
if (u->Save_RP)
return -20;
+ else if (u->stub_type != 0)
+ {
+ switch (u->stub_type)
+ {
+ case EXPORT:
+ return -24;
+ case PARAMETER_RELOCATION:
+ return -8;
+ default:
+ return 0;
+ }
+ }
else
return 0;
}
u = find_unwind_entry (frame->pc);
if (u == 0)
- return frameless_look_for_prologue (frame);
+ return 0;
- return (u->Total_frame_size == 0);
+ return (u->Total_frame_size == 0 && u->stub_type == 0);
}
CORE_ADDR
FRAME frame;
{
CORE_ADDR pc = get_frame_pc (frame);
+ struct unwind_table_entry *u;
+
+ /* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
+ at the base of the frame in an interrupt handler. Registers within
+ are saved in the exact same order as GDB numbers registers. How
+ convienent. */
+ if (pc_in_interrupt_handler (pc))
+ return read_memory_integer (frame->frame + PC_REGNUM * 4, 4) & ~0x3;
+ /* Deal with signal handler caller frames too. */
+ if (frame->signal_handler_caller)
+ {
+ CORE_ADDR rp;
+ FRAME_SAVED_PC_IN_SIGTRAMP (frame, &rp);
+ return rp;
+ }
+
+restart:
if (frameless_function_invocation (frame))
{
int ret_regnum;
ret_regnum = find_return_regnum (pc);
- return read_register (ret_regnum) & ~0x3;
+ /* If the next frame is an interrupt frame or a signal
+ handler caller, then we need to look in the saved
+ register area to get the return pointer (the values
+ in the registers may not correspond to anything useful). */
+ if (frame->next
+ && (frame->next->signal_handler_caller
+ || pc_in_interrupt_handler (frame->next->pc)))
+ {
+ struct frame_info *fi;
+ struct frame_saved_regs saved_regs;
+
+ fi = get_frame_info (frame->next);
+ get_frame_saved_regs (fi, &saved_regs);
+ if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM] & 0x2, 4))
+ pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
+ else
+ pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
+ }
+ else
+ pc = read_register (ret_regnum) & ~0x3;
}
else
{
int rp_offset = rp_saved (pc);
- if (rp_offset == 0)
- return read_register (RP_REGNUM) & ~0x3;
+ /* Similar to code in frameless function case. If the next
+ frame is a signal or interrupt handler, then dig the right
+ information out of the saved register info. */
+ if (rp_offset == 0
+ && frame->next
+ && (frame->next->signal_handler_caller
+ || pc_in_interrupt_handler (frame->next->pc)))
+ {
+ struct frame_info *fi;
+ struct frame_saved_regs saved_regs;
+
+ fi = get_frame_info (frame->next);
+ get_frame_saved_regs (fi, &saved_regs);
+ if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM] & 0x2, 4))
+ pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
+ else
+ pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
+ }
+ else if (rp_offset == 0)
+ pc = read_register (RP_REGNUM) & ~0x3;
else
- return read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
+ pc = read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
}
+
+ /* If PC is inside a linker stub, then dig out the address the stub
+ will return to. */
+ u = find_unwind_entry (pc);
+ if (u && u->stub_type != 0)
+ goto restart;
+
+ return pc;
}
\f
/* We need to correct the PC and the FP for the outermost frame when we are
{
int my_framesize, caller_framesize;
struct unwind_table_entry *u;
+ CORE_ADDR frame_base;
+
+ /* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
+ are easy; at *sp we have a full save state strucutre which we can
+ pull the old stack pointer from. Also see frame_saved_pc for
+ code to dig a saved PC out of the save state structure. */
+ if (pc_in_interrupt_handler (frame->pc))
+ frame_base = read_memory_integer (frame->frame + SP_REGNUM * 4, 4);
+ else if (frame->signal_handler_caller)
+ {
+ FRAME_BASE_BEFORE_SIGTRAMP (frame, &frame_base);
+ }
+ else
+ frame_base = frame->frame;
/* Get frame sizes for the current frame and the frame of the
caller. */
/* If caller does not have a frame pointer, then its frame
can be found at current_frame - caller_framesize. */
if (caller_framesize != -1)
- return frame->frame - caller_framesize;
+ return frame_base - caller_framesize;
/* Both caller and callee have frame pointers and are GCC compiled
(SAVE_SP bit in unwind descriptor is on for both functions.
The previous frame pointer is found at the top of the current frame. */
if (caller_framesize == -1 && my_framesize == -1)
- return read_memory_integer (frame->frame, 4);
+ return read_memory_integer (frame_base, 4);
/* Caller has a frame pointer, but callee does not. This is a little
more difficult as GCC and HP C lay out locals and callee register save
several areas on the stack.
Walk from the current frame to the innermost frame examining
- unwind descriptors to determine if %r4 ever gets saved into the
+ unwind descriptors to determine if %r3 ever gets saved into the
stack. If so return whatever value got saved into the stack.
- If it was never saved in the stack, then the value in %r4 is still
+ If it was never saved in the stack, then the value in %r3 is still
valid, so use it.
- We use information from unwind descriptors to determine if %r4
+ We use information from unwind descriptors to determine if %r3
is saved into the stack (Entry_GR field has this information). */
while (frame)
}
/* Entry_GR specifies the number of callee-saved general registers
- saved in the stack. It starts at %r3, so %r4 would be 2. */
- if (u->Entry_GR >= 2 || u->Save_SP)
+ saved in the stack. It starts at %r3, so %r3 would be 1. */
+ if (u->Entry_GR >= 1 || u->Save_SP
+ || frame->signal_handler_caller
+ || pc_in_interrupt_handler (frame->pc))
break;
else
frame = frame->next;
{
/* We may have walked down the chain into a function with a frame
pointer. */
- if (u->Save_SP)
+ if (u->Save_SP
+ && !frame->signal_handler_caller
+ && !pc_in_interrupt_handler (frame->pc))
return read_memory_integer (frame->frame, 4);
- /* %r4 was saved somewhere in the stack. Dig it out. */
+ /* %r3 was saved somewhere in the stack. Dig it out. */
else
- return dig_fp_from_stack (frame, u);
+ {
+ struct frame_info *fi;
+ struct frame_saved_regs saved_regs;
+
+ fi = get_frame_info (frame);
+ get_frame_saved_regs (fi, &saved_regs);
+ return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
+ }
}
else
{
- /* The value in %r4 was never saved into the stack (thus %r4 still
+ /* The value in %r3 was never saved into the stack (thus %r3 still
holds the value of the previous frame pointer). */
- return read_register (4);
- }
-}
-
-/* Given a frame and an unwind descriptor return the value for %fr (aka fp)
- which was saved into the stack. FIXME: Why can't we just use the standard
- saved_regs stuff? */
-
-static FRAME_ADDR
-dig_fp_from_stack (frame, u)
- FRAME frame;
- struct unwind_table_entry *u;
-{
- CORE_ADDR pc = u->region_start;
-
- /* Search the function for the save of %r4. */
- while (pc != u->region_end)
- {
- char buf[4];
- unsigned long inst;
- int status;
-
- /* We need only look for the standard stw %r4,X(%sp) instruction,
- the other variants (eg stwm) are only used on the first register
- save (eg %r3). */
- status = target_read_memory (pc, buf, 4);
- inst = extract_unsigned_integer (buf, 4);
-
- if (status != 0)
- memory_error (status, pc);
-
- /* Check for stw %r4,X(%sp). */
- if ((inst & 0xffffc000) == 0x6bc40000)
- {
- /* Found the instruction which saves %r4. The offset (relative
- to this frame) is framesize + immed14 (derived from the
- store instruction). */
- int offset = (u->Total_frame_size << 3) + extract_14 (inst);
-
- return read_memory_integer (frame->frame + offset, 4);
- }
-
- /* Keep looking. */
- pc += 4;
+ return read_register (FP_REGNUM);
}
-
- warning ("Unable to find %%r4 in stack.\n");
- return 0;
}
\f
{
struct minimal_symbol *msym_us;
struct minimal_symbol *msym_start;
- struct unwind_table_entry *u;
+ struct unwind_table_entry *u, *next_u = NULL;
+ FRAME next;
if (!chain)
return 0;
u = find_unwind_entry (thisframe->pc);
+ if (u == NULL)
+ return 1;
+
/* We can't just check that the same of msym_us is "_start", because
someone idiotically decided that they were going to make a Ltext_end
symbol with the same address. This Ltext_end symbol is totally
&& SYMBOL_VALUE_ADDRESS (msym_us) == SYMBOL_VALUE_ADDRESS (msym_start))
return 0;
- if (u == NULL)
- return 1;
+ next = get_next_frame (thisframe);
+ if (next)
+ next_u = find_unwind_entry (next->pc);
- if (u->Save_SP || u->Total_frame_size)
+ /* If this frame does not save SP, has no stack, isn't a stub,
+ and doesn't "call" an interrupt routine or signal handler caller,
+ then its not valid. */
+ if (u->Save_SP || u->Total_frame_size || u->stub_type != 0
+ || (thisframe->next && thisframe->next->signal_handler_caller)
+ || (next_u && next_u->HP_UX_interrupt_marker))
return 1;
if (pc_in_linker_stub (thisframe->pc))
fp = fi->frame;
get_frame_saved_regs (fi, &fsr);
+#ifndef NO_PC_SPACE_QUEUE_RESTORE
if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */
restore_pc_queue (&fsr);
+#endif
for (regnum = 31; regnum > 0; regnum--)
if (fsr.regs[regnum])
CORE_ADDR pc = read_pc ();
CORE_ADDR new_pc = read_memory_integer (fsr->regs[PCOQ_HEAD_REGNUM], 4);
int pid;
- WAITTYPE w;
+ struct target_waitstatus w;
int insn_count;
/* Advance past break instruction in the call dummy. */
any other choice? Is there *any* way to do this stuff with
ptrace() or some equivalent?). */
resume (1, 0);
- target_wait(inferior_pid, &w);
+ target_wait (inferior_pid, &w);
- if (!WIFSTOPPED (w))
+ if (w.kind == TARGET_WAITKIND_SIGNALLED)
{
- stop_signal = WTERMSIG (w);
+ stop_signal = w.value.sig;
terminal_ours_for_output ();
- printf_unfiltered ("\nProgram terminated with signal %d, %s\n",
- stop_signal, safe_strsignal (stop_signal));
+ printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
+ target_signal_to_name (stop_signal),
+ target_signal_to_string (stop_signal));
gdb_flush (gdb_stdout);
return 0;
}
CORE_ADDR
hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
int nargs;
- value *args;
+ value_ptr *args;
CORE_ADDR sp;
int struct_return;
CORE_ADDR struct_addr;
CORE_ADDR pc;
CORE_ADDR fun;
int nargs;
- value *args;
+ value_ptr *args;
struct type *type;
int gcc_p;
{
CORE_ADDR dyncall_addr, sr4export_addr;
struct minimal_symbol *msymbol;
int flags = read_register (FLAGS_REGNUM);
+ struct unwind_table_entry *u;
msymbol = lookup_minimal_symbol ("$$dyncall", (struct objfile *) NULL);
if (msymbol == NULL)
dyncall_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+ /* FUN could be a procedure label, in which case we have to get
+ its real address and the value of its GOT/DP. */
+ if (fun & 0x2)
+ {
+ /* Get the GOT/DP value for the target function. It's
+ at *(fun+4). Note the call dummy is *NOT* allowed to
+ trash %r19 before calling the target function. */
+ write_register (19, read_memory_integer ((fun & ~0x3) + 4, 4));
+
+ /* Now get the real address for the function we are calling, it's
+ at *fun. */
+ fun = (CORE_ADDR) read_memory_integer (fun & ~0x3, 4);
+ }
+
+ /* If we are calling an import stub (eg calling into a dynamic library)
+ then have sr4export call the magic __d_plt_call routine which is linked
+ in from end.o. (You can't use _sr4export to call the import stub as
+ the value in sp-24 will get fried and you end up returning to the
+ wrong location. You can't call the import stub directly as the code
+ to bind the PLT entry to a function can't return to a stack address.) */
+ u = find_unwind_entry (fun);
+ if (u && u->stub_type == IMPORT)
+ {
+ CORE_ADDR new_fun;
+ msymbol = lookup_minimal_symbol ("__d_plt_call", (struct objfile *) NULL);
+ if (msymbol == NULL)
+ error ("Can't find an address for __d_plt_call trampoline");
+
+ /* This is where sr4export will jump to. */
+ new_fun = SYMBOL_VALUE_ADDRESS (msymbol);
+
+ /* We have to store the address of the stub in __shlib_funcptr. */
+ msymbol = lookup_minimal_symbol ("__shlib_funcptr",
+ (struct objfile *)NULL);
+ if (msymbol == NULL)
+ error ("Can't find an address for __shlib_funcptr");
+
+ target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol), (char *)&fun, 4);
+ fun = new_fun;
+
+ }
+
+ /* We still need sr4export's address too. */
msymbol = lookup_minimal_symbol ("_sr4export", (struct objfile *) NULL);
if (msymbol == NULL)
error ("Can't find an address for _sr4export trampoline");
unsigned char raw_buffer[MAX_REGISTER_RAW_SIZE];
unsigned char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
- /* Get the data in raw format. */
+ /* Get 32bits of data. */
read_relative_register_raw_bytes (i, raw_buffer);
- /* Convert raw data to virtual format if necessary. */
-#ifdef REGISTER_CONVERTIBLE
- if (REGISTER_CONVERTIBLE (i))
- {
- REGISTER_CONVERT_TO_VIRTUAL (i, REGISTER_VIRTUAL_TYPE (i),
- raw_buffer, virtual_buffer);
- }
- else
-#endif
- memcpy (virtual_buffer, raw_buffer,
- REGISTER_VIRTUAL_SIZE (i));
+ /* Put it in the buffer. No conversions are ever necessary. */
+ memcpy (virtual_buffer, raw_buffer, REGISTER_RAW_SIZE (i));
fputs_filtered (reg_names[i], gdb_stdout);
- print_spaces_filtered (15 - strlen (reg_names[i]), gdb_stdout);
+ print_spaces_filtered (8 - strlen (reg_names[i]), gdb_stdout);
+ fputs_filtered ("(single precision) ", gdb_stdout);
val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, gdb_stdout, 0,
1, 0, Val_pretty_default);
printf_filtered ("\n");
+
+ /* If "i" is even, then this register can also be a double-precision
+ FP register. Dump it out as such. */
+ if ((i % 2) == 0)
+ {
+ /* Get the data in raw format for the 2nd half. */
+ read_relative_register_raw_bytes (i + 1, raw_buffer);
+
+ /* Copy it into the appropriate part of the virtual buffer. */
+ memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buffer,
+ REGISTER_RAW_SIZE (i));
+
+ /* Dump it as a double. */
+ fputs_filtered (reg_names[i], gdb_stdout);
+ print_spaces_filtered (8 - strlen (reg_names[i]), gdb_stdout);
+ fputs_filtered ("(double precision) ", gdb_stdout);
+
+ val_print (builtin_type_double, virtual_buffer, 0, gdb_stdout, 0,
+ 1, 0, Val_pretty_default);
+ printf_filtered ("\n");
+ }
}
-/* Function calls that pass into a new compilation unit must pass through a
- small piece of code that does long format (`external' in HPPA parlance)
- jumps. We figure out where the trampoline is going to end up, and return
- the PC of the final destination. If we aren't in a trampoline, we just
- return NULL.
+/* Figure out if PC is in a trampoline, and if so find out where
+ the trampoline will jump to. If not in a trampoline, return zero.
+
+ Simple code examination probably is not a good idea since the code
+ sequences in trampolines can also appear in user code.
- For computed calls, we just extract the new PC from r22. */
+ We use unwinds and information from the minimal symbol table to
+ determine when we're in a trampoline. This won't work for ELF
+ (yet) since it doesn't create stub unwind entries. Whether or
+ not ELF will create stub unwinds or normal unwinds for linker
+ stubs is still being debated.
+
+ This should handle simple calls through dyncall or sr4export,
+ long calls, argument relocation stubs, and dyncall/sr4export
+ calling an argument relocation stub. It even handles some stubs
+ used in dynamic executables. */
CORE_ADDR
skip_trampoline_code (pc, name)
CORE_ADDR pc;
char *name;
{
- long inst0, inst1;
+ long orig_pc = pc;
+ long prev_inst, curr_inst, loc;
static CORE_ADDR dyncall = 0;
+ static CORE_ADDR sr4export = 0;
struct minimal_symbol *msym;
+ struct unwind_table_entry *u;
-/* FIXME XXX - dyncall must be initialized whenever we get a new exec file */
+/* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
+ new exec file */
if (!dyncall)
{
dyncall = -1;
}
+ if (!sr4export)
+ {
+ msym = lookup_minimal_symbol ("_sr4export", NULL);
+ if (msym)
+ sr4export = SYMBOL_VALUE_ADDRESS (msym);
+ else
+ sr4export = -1;
+ }
+
+ /* Addresses passed to dyncall may *NOT* be the actual address
+ of the funtion. So we may have to do something special. */
if (pc == dyncall)
- return (CORE_ADDR)(read_register (22) & ~0x3);
+ {
+ pc = (CORE_ADDR) read_register (22);
- inst0 = read_memory_integer (pc, 4);
- inst1 = read_memory_integer (pc+4, 4);
+ /* If bit 30 (counting from the left) is on, then pc is the address of
+ the PLT entry for this function, not the address of the function
+ itself. Bit 31 has meaning too, but only for MPE. */
+ if (pc & 0x2)
+ pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4);
+ }
+ else if (pc == sr4export)
+ pc = (CORE_ADDR) (read_register (22));
- if ( (inst0 & 0xffe00000) == 0x20200000 /* ldil xxx, r1 */
- && (inst1 & 0xffe0e002) == 0xe0202002) /* be,n yyy(sr4, r1) */
- pc = extract_21 (inst0) + extract_17 (inst1);
- else
- pc = (CORE_ADDR)NULL;
+ /* Get the unwind descriptor corresponding to PC, return zero
+ if no unwind was found. */
+ u = find_unwind_entry (pc);
+ if (!u)
+ return 0;
- return pc;
+ /* If this isn't a linker stub, then return now. */
+ if (u->stub_type == 0)
+ return orig_pc == pc ? 0 : pc & ~0x3;
+
+ /* It's a stub. Search for a branch and figure out where it goes.
+ Note we have to handle multi insn branch sequences like ldil;ble.
+ Most (all?) other branches can be determined by examining the contents
+ of certain registers and the stack. */
+ loc = pc;
+ curr_inst = 0;
+ prev_inst = 0;
+ while (1)
+ {
+ /* Make sure we haven't walked outside the range of this stub. */
+ if (u != find_unwind_entry (loc))
+ {
+ warning ("Unable to find branch in linker stub");
+ return orig_pc == pc ? 0 : pc & ~0x3;
+ }
+
+ prev_inst = curr_inst;
+ curr_inst = read_memory_integer (loc, 4);
+
+ /* Does it look like a branch external using %r1? Then it's the
+ branch from the stub to the actual function. */
+ if ((curr_inst & 0xffe0e000) == 0xe0202000)
+ {
+ /* Yup. See if the previous instruction loaded
+ a value into %r1. If so compute and return the jump address. */
+ if ((prev_inst & 0xffe00000) == 0x20202000)
+ return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3;
+ else
+ {
+ warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1).");
+ return orig_pc == pc ? 0 : pc & ~0x3;
+ }
+ }
+
+ /* Does it look like bl X,rp? Another way to do a branch from the
+ stub to the actual function. */
+ else if ((curr_inst & 0xffe0e000) == 0xe8400000)
+ return (loc + extract_17 (curr_inst) + 8) & ~0x3;
+
+ /* Does it look like bv (rp)? Note this depends on the
+ current stack pointer being the same as the stack
+ pointer in the stub itself! This is a branch on from the
+ stub back to the original caller. */
+ else if ((curr_inst & 0xffe0e000) == 0xe840c000)
+ {
+ /* Yup. See if the previous instruction loaded
+ rp from sp - 8. */
+ if (prev_inst == 0x4bc23ff1)
+ return (read_memory_integer
+ (read_register (SP_REGNUM) - 8, 4)) & ~0x3;
+ else
+ {
+ warning ("Unable to find restore of %%rp before bv (%%rp).");
+ return orig_pc == pc ? 0 : pc & ~0x3;
+ }
+ }
+
+ /* What about be,n 0(sr0,%rp)? It's just another way we return to
+ the original caller from the stub. Used in dynamic executables. */
+ else if (curr_inst == 0xe0400002)
+ {
+ /* The value we jump to is sitting in sp - 24. But that's
+ loaded several instructions before the be instruction.
+ I guess we could check for the previous instruction being
+ mtsp %r1,%sr0 if we want to do sanity checking. */
+ return (read_memory_integer
+ (read_register (SP_REGNUM) - 24, 4)) & ~0x3;
+ }
+
+ /* Haven't found the branch yet, but we're still in the stub.
+ Keep looking. */
+ loc += 4;
+ }
+}
+
+/* For the given instruction (INST), return any adjustment it makes
+ to the stack pointer or zero for no adjustment.
+
+ This only handles instructions commonly found in prologues. */
+
+static int
+prologue_inst_adjust_sp (inst)
+ unsigned long inst;
+{
+ /* This must persist across calls. */
+ static int save_high21;
+
+ /* The most common way to perform a stack adjustment ldo X(sp),sp */
+ if ((inst & 0xffffc000) == 0x37de0000)
+ return extract_14 (inst);
+
+ /* stwm X,D(sp) */
+ if ((inst & 0xffe00000) == 0x6fc00000)
+ return extract_14 (inst);
+
+ /* addil high21,%r1; ldo low11,(%r1),%r30)
+ save high bits in save_high21 for later use. */
+ if ((inst & 0xffe00000) == 0x28200000)
+ {
+ save_high21 = extract_21 (inst);
+ return 0;
+ }
+
+ if ((inst & 0xffff0000) == 0x343e0000)
+ return save_high21 + extract_14 (inst);
+
+ /* fstws as used by the HP compilers. */
+ if ((inst & 0xffffffe0) == 0x2fd01220)
+ return extract_5_load (inst);
+
+ /* No adjustment. */
+ return 0;
+}
+
+/* Return nonzero if INST is a branch of some kind, else return zero. */
+
+static int
+is_branch (inst)
+ unsigned long inst;
+{
+ switch (inst >> 26)
+ {
+ case 0x20:
+ case 0x21:
+ case 0x22:
+ case 0x23:
+ case 0x28:
+ case 0x29:
+ case 0x2a:
+ case 0x2b:
+ case 0x30:
+ case 0x31:
+ case 0x32:
+ case 0x33:
+ case 0x38:
+ case 0x39:
+ case 0x3a:
+ return 1;
+
+ default:
+ return 0;
+ }
+}
+
+/* Return the register number for a GR which is saved by INST or
+ zero it INST does not save a GR.
+
+ Note we only care about full 32bit register stores (that's the only
+ kind of stores the prologue will use). */
+
+static int
+inst_saves_gr (inst)
+ unsigned long inst;
+{
+ /* Does it look like a stw? */
+ if ((inst >> 26) == 0x1a)
+ return extract_5R_store (inst);
+
+ /* Does it look like a stwm? */
+ if ((inst >> 26) == 0x1b)
+ return extract_5R_store (inst);
+
+ return 0;
+}
+
+/* Return the register number for a FR which is saved by INST or
+ zero it INST does not save a FR.
+
+ Note we only care about full 64bit register stores (that's the only
+ kind of stores the prologue will use). */
+
+static int
+inst_saves_fr (inst)
+ unsigned long inst;
+{
+ if ((inst & 0xfc1fffe0) == 0x2c101220)
+ return extract_5r_store (inst);
+ return 0;
}
/* Advance PC across any function entry prologue instructions
- to reach some "real" code. */
+ to reach some "real" code.
-/* skip (stw rp, -20(0,sp)); copy 4,1; copy sp, 4; stwm 1,framesize(sp)
- for gcc, or (stw rp, -20(0,sp); stwm 1, framesize(sp) for hcc */
+ Use information in the unwind table to determine what exactly should
+ be in the prologue. */
CORE_ADDR
-skip_prologue(pc)
+skip_prologue (pc)
CORE_ADDR pc;
{
char buf[4];
- unsigned long inst;
- int status;
+ unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
+ int status, i;
+ struct unwind_table_entry *u;
+
+ u = find_unwind_entry (pc);
+ if (!u)
+ return pc;
- status = target_read_memory (pc, buf, 4);
- inst = extract_unsigned_integer (buf, 4);
- if (status != 0)
+ /* If we are not at the beginning of a function, then return now. */
+ if ((pc & ~0x3) != u->region_start)
return pc;
- if (inst == 0x6BC23FD9) /* stw rp,-20(sp) */
+ /* This is how much of a frame adjustment we need to account for. */
+ stack_remaining = u->Total_frame_size << 3;
+
+ /* Magic register saves we want to know about. */
+ save_rp = u->Save_RP;
+ save_sp = u->Save_SP;
+
+ /* Turn the Entry_GR field into a bitmask. */
+ save_gr = 0;
+ for (i = 3; i < u->Entry_GR + 3; i++)
+ {
+ /* Frame pointer gets saved into a special location. */
+ if (u->Save_SP && i == FP_REGNUM)
+ continue;
+
+ save_gr |= (1 << i);
+ }
+
+ /* Turn the Entry_FR field into a bitmask too. */
+ save_fr = 0;
+ for (i = 12; i < u->Entry_FR + 12; i++)
+ save_fr |= (1 << i);
+
+ /* Loop until we find everything of interest or hit a branch.
+
+ For unoptimized GCC code and for any HP CC code this will never ever
+ examine any user instructions.
+
+ For optimzied GCC code we're faced with problems. GCC will schedule
+ its prologue and make prologue instructions available for delay slot
+ filling. The end result is user code gets mixed in with the prologue
+ and a prologue instruction may be in the delay slot of the first branch
+ or call.
+
+ Some unexpected things are expected with debugging optimized code, so
+ we allow this routine to walk past user instructions in optimized
+ GCC code. */
+ while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
{
- if (read_memory_integer (pc + 4, 4) == 0x8040241) /* copy r4,r1 */
- pc += 16;
- else if ((read_memory_integer (pc + 4, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
- pc += 8;
+ status = target_read_memory (pc, buf, 4);
+ inst = extract_unsigned_integer (buf, 4);
+
+ /* Yow! */
+ if (status != 0)
+ return pc;
+
+ /* Note the interesting effects of this instruction. */
+ stack_remaining -= prologue_inst_adjust_sp (inst);
+
+ /* There is only one instruction used for saving RP into the stack. */
+ if (inst == 0x6bc23fd9)
+ save_rp = 0;
+
+ /* This is the only way we save SP into the stack. At this time
+ the HP compilers never bother to save SP into the stack. */
+ if ((inst & 0xffffc000) == 0x6fc10000)
+ save_sp = 0;
+
+ /* Account for general and floating-point register saves. */
+ save_gr &= ~(1 << inst_saves_gr (inst));
+ save_fr &= ~(1 << inst_saves_fr (inst));
+
+ /* Quit if we hit any kind of branch. This can happen if a prologue
+ instruction is in the delay slot of the first call/branch. */
+ if (is_branch (inst))
+ break;
+
+ /* Bump the PC. */
+ pc += 4;
}
- else if (read_memory_integer (pc, 4) == 0x8040241) /* copy r4,r1 */
- pc += 12;
- else if ((read_memory_integer (pc, 4) & ~MASK_14) == 0x68810000) /* stw r1,(r4) */
- pc += 4;
return pc;
}
+/* Put here the code to store, into a struct frame_saved_regs,
+ the addresses of the saved registers of frame described by FRAME_INFO.
+ This includes special registers such as pc and fp saved in special
+ ways in the stack frame. sp is even more special:
+ the address we return for it IS the sp for the next frame. */
+
+void
+hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
+ struct frame_info *frame_info;
+ struct frame_saved_regs *frame_saved_regs;
+{
+ CORE_ADDR pc;
+ struct unwind_table_entry *u;
+ unsigned long inst, stack_remaining, save_gr, save_fr, save_rp, save_sp;
+ int status, i, reg;
+ char buf[4];
+ int fp_loc = -1;
+
+ /* Zero out everything. */
+ memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs));
+
+ /* Call dummy frames always look the same, so there's no need to
+ examine the dummy code to determine locations of saved registers;
+ instead, let find_dummy_frame_regs fill in the correct offsets
+ for the saved registers. */
+ if ((frame_info->pc >= frame_info->frame
+ && frame_info->pc <= (frame_info->frame + CALL_DUMMY_LENGTH
+ + 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8
+ + 6 * 4)))
+ find_dummy_frame_regs (frame_info, frame_saved_regs);
+
+ /* Interrupt handlers are special too. They lay out the register
+ state in the exact same order as the register numbers in GDB. */
+ if (pc_in_interrupt_handler (frame_info->pc))
+ {
+ for (i = 0; i < NUM_REGS; i++)
+ {
+ /* SP is a little special. */
+ if (i == SP_REGNUM)
+ frame_saved_regs->regs[SP_REGNUM]
+ = read_memory_integer (frame_info->frame + SP_REGNUM * 4, 4);
+ else
+ frame_saved_regs->regs[i] = frame_info->frame + i * 4;
+ }
+ return;
+ }
+
+ /* Handle signal handler callers. */
+ if (frame_info->signal_handler_caller)
+ {
+ FRAME_FIND_SAVED_REGS_IN_SIGTRAMP (frame_info, frame_saved_regs);
+ return;
+ }
+
+ /* Get the starting address of the function referred to by the PC
+ saved in frame_info. */
+ pc = get_pc_function_start (frame_info->pc);
+
+ /* Yow! */
+ u = find_unwind_entry (pc);
+ if (!u)
+ return;
+
+ /* This is how much of a frame adjustment we need to account for. */
+ stack_remaining = u->Total_frame_size << 3;
+
+ /* Magic register saves we want to know about. */
+ save_rp = u->Save_RP;
+ save_sp = u->Save_SP;
+
+ /* Turn the Entry_GR field into a bitmask. */
+ save_gr = 0;
+ for (i = 3; i < u->Entry_GR + 3; i++)
+ {
+ /* Frame pointer gets saved into a special location. */
+ if (u->Save_SP && i == FP_REGNUM)
+ continue;
+
+ save_gr |= (1 << i);
+ }
+
+ /* Turn the Entry_FR field into a bitmask too. */
+ save_fr = 0;
+ for (i = 12; i < u->Entry_FR + 12; i++)
+ save_fr |= (1 << i);
+
+ /* The frame always represents the value of %sp at entry to the
+ current function (and is thus equivalent to the "saved" stack
+ pointer. */
+ frame_saved_regs->regs[SP_REGNUM] = frame_info->frame;
+
+ /* Loop until we find everything of interest or hit a branch.
+
+ For unoptimized GCC code and for any HP CC code this will never ever
+ examine any user instructions.
+
+ For optimzied GCC code we're faced with problems. GCC will schedule
+ its prologue and make prologue instructions available for delay slot
+ filling. The end result is user code gets mixed in with the prologue
+ and a prologue instruction may be in the delay slot of the first branch
+ or call.
+
+ Some unexpected things are expected with debugging optimized code, so
+ we allow this routine to walk past user instructions in optimized
+ GCC code. */
+ while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
+ {
+ status = target_read_memory (pc, buf, 4);
+ inst = extract_unsigned_integer (buf, 4);
+
+ /* Yow! */
+ if (status != 0)
+ return;
+
+ /* Note the interesting effects of this instruction. */
+ stack_remaining -= prologue_inst_adjust_sp (inst);
+
+ /* There is only one instruction used for saving RP into the stack. */
+ if (inst == 0x6bc23fd9)
+ {
+ save_rp = 0;
+ frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20;
+ }
+
+ /* Just note that we found the save of SP into the stack. The
+ value for frame_saved_regs was computed above. */
+ if ((inst & 0xffffc000) == 0x6fc10000)
+ save_sp = 0;
+
+ /* Account for general and floating-point register saves. */
+ reg = inst_saves_gr (inst);
+ if (reg >= 3 && reg <= 18
+ && (!u->Save_SP || reg != FP_REGNUM))
+ {
+ save_gr &= ~(1 << reg);
+
+ /* stwm with a positive displacement is a *post modify*. */
+ if ((inst >> 26) == 0x1b
+ && extract_14 (inst) >= 0)
+ frame_saved_regs->regs[reg] = frame_info->frame;
+ else
+ {
+ /* Handle code with and without frame pointers. */
+ if (u->Save_SP)
+ frame_saved_regs->regs[reg]
+ = frame_info->frame + extract_14 (inst);
+ else
+ frame_saved_regs->regs[reg]
+ = frame_info->frame + (u->Total_frame_size << 3)
+ + extract_14 (inst);
+ }
+ }
+
+
+ /* GCC handles callee saved FP regs a little differently.
+
+ It emits an instruction to put the value of the start of
+ the FP store area into %r1. It then uses fstds,ma with
+ a basereg of %r1 for the stores.
+
+ HP CC emits them at the current stack pointer modifying
+ the stack pointer as it stores each register. */
+
+ /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
+ if ((inst & 0xffffc000) == 0x34610000
+ || (inst & 0xffffc000) == 0x37c10000)
+ fp_loc = extract_14 (inst);
+
+ reg = inst_saves_fr (inst);
+ if (reg >= 12 && reg <= 21)
+ {
+ /* Note +4 braindamage below is necessary because the FP status
+ registers are internally 8 registers rather than the expected
+ 4 registers. */
+ save_fr &= ~(1 << reg);
+ if (fp_loc == -1)
+ {
+ /* 1st HP CC FP register store. After this instruction
+ we've set enough state that the GCC and HPCC code are
+ both handled in the same manner. */
+ frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame;
+ fp_loc = 8;
+ }
+ else
+ {
+ frame_saved_regs->regs[reg + FP0_REGNUM + 4]
+ = frame_info->frame + fp_loc;
+ fp_loc += 8;
+ }
+ }
+
+ /* Quit if we hit any kind of branch. This can happen if a prologue
+ instruction is in the delay slot of the first call/branch. */
+ if (is_branch (inst))
+ break;
+
+ /* Bump the PC. */
+ pc += 4;
+ }
+}
+
#ifdef MAINTENANCE_CMDS
static void
projects / binutils.git / blobdiff