u = find_unwind_entry (frame->pc);
if (u == 0)
- return frameless_look_for_prologue (frame);
+ return 0;
return (u->Total_frame_size == 0 && u->stub_type == 0);
}
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
return rp;
}
+restart:
if (frameless_function_invocation (frame))
{
int ret_regnum;
fi = get_frame_info (frame->next);
get_frame_saved_regs (fi, &saved_regs);
if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM] & 0x2, 4))
- return read_memory_integer (saved_regs.regs[31], 4);
+ pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
else
- return read_memory_integer (saved_regs.regs[RP_REGNUM], 4);
+ pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
}
else
- return read_register (ret_regnum) & ~0x3;
+ pc = read_register (ret_regnum) & ~0x3;
}
else
{
fi = get_frame_info (frame->next);
get_frame_saved_regs (fi, &saved_regs);
if (read_memory_integer (saved_regs.regs[FLAGS_REGNUM] & 0x2, 4))
- return read_memory_integer (saved_regs.regs[31], 4);
+ pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
else
- return read_memory_integer (saved_regs.regs[RP_REGNUM], 4);
+ pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
}
else if (rp_offset == 0)
- return read_register (RP_REGNUM) & ~0x3;
+ 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
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
be in the prologue. */
CORE_ADDR
-skip_prologue(pc)
+skip_prologue (pc)
CORE_ADDR pc;
{
char buf[4];
u = find_unwind_entry (pc);
if (!u)
- return 0;
+ return pc;
+
+ /* If we are not at the beginning of a function, then return now. */
+ if ((pc & ~0x3) != u->region_start)
+ return pc;
/* This is how much of a frame adjustment we need to account for. */
stack_remaining = u->Total_frame_size << 3;
projects / binutils.git / blobdiff