int stack_extra_size,
int frame_in_fp)
{
+ struct gdbarch *gdbarch;
struct trad_frame_cache *cache;
int offset = 0;
CORE_ADDR base;
cache = mn10300_frame_unwind_cache (fi, this_cache);
if (cache == NULL)
return;
+ gdbarch = get_frame_arch (fi);
if (frame_in_fp)
{
}
else
{
- base = frame_unwind_register_unsigned (fi, E_SP_REGNUM) + stack_extra_size;
+ base = frame_unwind_register_unsigned (fi, E_SP_REGNUM)
+ + stack_extra_size;
}
trad_frame_set_this_base (cache, base);
- if (AM33_MODE == 2)
+ if (AM33_MODE (gdbarch) == 2)
{
/* If bit N is set in fpregmask, fsN is saved on the stack.
The floating point registers are saved in ascending order.
{
if (fpregmask & (1 << i))
{
- trad_frame_set_reg_addr (cache, E_FS0_REGNUM + i, base + offset);
+ trad_frame_set_reg_addr (cache, E_FS0_REGNUM + i,
+ base + offset);
offset += 4;
}
}
trad_frame_set_reg_addr (cache, E_D2_REGNUM, base + offset);
offset += 4;
}
- if (AM33_MODE)
+ if (AM33_MODE (gdbarch))
{
if (movm_args & movm_exother_bit)
{
frame chain to not bother trying to unwind past this frame. */
static CORE_ADDR
-mn10300_analyze_prologue (struct frame_info *fi,
+mn10300_analyze_prologue (struct gdbarch *gdbarch, struct frame_info *fi,
void **this_cache,
CORE_ADDR pc)
{
goto finish_prologue;
}
- if (AM33_MODE == 2)
+ /* Check for "mov pc, a2", an instruction found in optimized, position
+ independent code. Skip it if found. */
+ if (buf[0] == 0xf0 && buf[1] == 0x2e)
+ {
+ addr += 2;
+
+ /* Quit now if we're beyond the stop point. */
+ if (addr >= stop)
+ goto finish_prologue;
+
+ /* Get the next two bytes so the prologue scan can continue. */
+ status = read_memory_nobpt (addr, buf, 2);
+ if (status != 0)
+ goto finish_prologue;
+ }
+
+ if (AM33_MODE (gdbarch) == 2)
{
/* Determine if any floating point registers are to be saved.
Look for one of the following three prologue formats:
was actually encountered. As a consequence, ``addr'' would
sometimes be advanced even when no fmov instructions were found. */
CORE_ADDR restore_addr = addr;
+ int fmov_found = 0;
/* First, look for add -SIZE,sp (i.e. add imm8,sp (0xf8feXX)
or add imm16,sp (0xfafeXXXX)
break;
/* An fmov instruction has just been seen. We can
- now really commit to the pattern match. Set the
- address to restore at the end of this speculative
- bit of code to the actually address that we've
- been incrementing (or not) throughout the
- speculation. */
- restore_addr = addr;
+ now really commit to the pattern match. */
+
+ fmov_found = 1;
/* Get the floating point register number from the
2nd and 3rd bytes of the "fmov" instruction:
imm_size = (buf[0] == 0xf9) ? 3 : 4;
}
}
- else
- {
- /* No "fmov" was found. Reread the two bytes at the original
- "addr" to reset the state. */
- addr = restore_addr;
- if (!safe_frame_unwind_memory (fi, addr, buf, 2))
- goto finish_prologue;
- }
}
- /* else the prologue consists entirely of an "add -SIZE,sp"
- instruction. Handle this below. */
}
- /* else no "add -SIZE,sp" was found indicating no floating point
- registers are saved in this prologue. */
-
- /* In the pattern match code contained within this block, `restore_addr'
- is set to the starting address at the very beginning and then
- iteratively to the next address to start scanning at once the
- pattern match has succeeded. Thus `restore_addr' will contain
- the address to rewind to if the pattern match failed. If the
- match succeeded, `restore_addr' and `addr' will already have the
- same value. */
- addr = restore_addr;
+ /* If no fmov instructions were found by the above sequence, reset
+ the state and pretend that the above bit of code never happened. */
+ if (!fmov_found)
+ {
+ addr = restore_addr;
+ status = read_memory_nobpt (addr, buf, 2);
+ if (status != 0)
+ goto finish_prologue;
+ stack_extra_size = 0;
+ }
}
/* Now see if we set up a frame pointer via "mov sp,a3" */
finish_prologue:
/* Note if/where callee saved registers were saved. */
if (fi)
- set_reg_offsets (fi, this_cache, movm_args, fpregmask, stack_extra_size, frame_in_fp);
+ set_reg_offsets (fi, this_cache, movm_args, fpregmask, stack_extra_size,
+ frame_in_fp);
return addr;
}
static CORE_ADDR
mn10300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
- return mn10300_analyze_prologue (NULL, NULL, pc);
+ return mn10300_analyze_prologue (gdbarch, NULL, NULL, pc);
}
/* Simple frame_unwind_cache.
mn10300_frame_unwind_cache (struct frame_info *next_frame,
void **this_prologue_cache)
{
+ struct gdbarch *gdbarch;
struct trad_frame_cache *cache;
CORE_ADDR pc, start, end;
void *cache_p;
if (*this_prologue_cache)
return (*this_prologue_cache);
+ gdbarch = get_frame_arch (next_frame);
cache_p = trad_frame_cache_zalloc (next_frame);
- pc = gdbarch_unwind_pc (get_frame_arch (next_frame), next_frame);
- mn10300_analyze_prologue (next_frame, &cache_p, pc);
+ pc = gdbarch_unwind_pc (gdbarch, next_frame);
+ mn10300_analyze_prologue (gdbarch, next_frame, &cache_p, pc);
cache = cache_p;
if (find_pc_partial_function (pc, NULL, &start, &end))
to work with the existing GDB, neither of them can change. So we
just have to cope. */
static int
-mn10300_dwarf2_reg_to_regnum (int dwarf2)
+mn10300_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2)
{
/* This table is supposed to be shaped like the gdbarch_register_name
initializer in gcc/config/mn10300/mn10300.h. Registers which
projects / deliverable / binutils-gdb.git / blobdiff