static struct moxie_frame_cache *
moxie_frame_cache (struct frame_info *this_frame, void **this_cache)
{
struct moxie_frame_cache *cache;
CORE_ADDR current_pc;
int i;
if (*this_cache)
return *this_cache;
cache = moxie_alloc_frame_cache ();
*this_cache = cache;
cache->base = get_frame_register_unsigned (this_frame, MOXIE_FP_REGNUM);
if (cache->base == 0)
return cache;
cache->pc = get_frame_func (this_frame);
current_pc = get_frame_pc (this_frame);
if (cache->pc)
moxie_analyze_prologue (cache->pc, current_pc, cache, this_frame);
cache->saved_sp = cache->base - cache->framesize;
for (i = 0; i < MOXIE_NUM_REGS; ++i)
if (cache->saved_regs[i] != REG_UNAVAIL)
cache->saved_regs[i] = cache->base - cache->saved_regs[i];
return cache;
}
int
legacy_frameless_look_for_prologue (struct frame_info *frame)
{
CORE_ADDR func_start;
func_start = get_frame_func (frame);
if (func_start)
{
func_start += FUNCTION_START_OFFSET;
/* NOTE: cagney/2004-02-09: Eliminated per-architecture
PROLOGUE_FRAMELESS_P call as architectures with custom
implementations had all been deleted. Eventually even this
function can go - GDB no longer tries to differentiate
between framed, frameless and stackless functions. They are
all now considered equally evil :-^. */
/* If skipping the prologue ends up skips nothing, there must be
no prologue and hence no code creating a frame. There for
the function is "frameless" :-/. */
return func_start == SKIP_PROLOGUE (func_start);
}
else if (get_frame_pc (frame) == 0)
/* A frame with a zero PC is usually created by dereferencing a
NULL function pointer, normally causing an immediate core dump
of the inferior. Mark function as frameless, as the inferior
has no chance of setting up a stack frame. */
return 1;
else
/* If we can't find the start of the function, we don't really
know whether the function is frameless, but we should be able
to get a reasonable (i.e. best we can do under the
circumstances) backtrace by saying that it isn't. */
return 0;
}
static struct tilegx_frame_cache *
tilegx_frame_cache (struct frame_info *this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct tilegx_frame_cache *cache;
CORE_ADDR current_pc;
if (*this_cache)
return (struct tilegx_frame_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct tilegx_frame_cache);
*this_cache = cache;
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
cache->base = 0;
cache->start_pc = get_frame_func (this_frame);
current_pc = get_frame_pc (this_frame);
cache->base = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
trad_frame_set_value (cache->saved_regs, TILEGX_SP_REGNUM, cache->base);
if (cache->start_pc)
tilegx_analyze_prologue (gdbarch, cache->start_pc, current_pc,
cache, this_frame);
cache->saved_regs[TILEGX_PC_REGNUM] = cache->saved_regs[TILEGX_LR_REGNUM];
return cache;
}
static void
record_btrace_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id)
{
const struct btrace_frame_cache *cache;
const struct btrace_function *bfun;
CORE_ADDR code, special;
cache = *this_cache;
bfun = cache->bfun;
gdb_assert (bfun != NULL);
while (bfun->segment.prev != NULL)
bfun = bfun->segment.prev;
code = get_frame_func (this_frame);
special = bfun->number;
*this_id = frame_id_build_unavailable_stack_special (code, special);
DEBUG ("[frame] %s id: (!stack, pc=%s, special=%s)",
btrace_get_bfun_name (cache->bfun),
core_addr_to_string_nz (this_id->code_addr),
core_addr_to_string_nz (this_id->special_addr));
}
static struct m88k_frame_cache *
m88k_frame_cache (struct frame_info *this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct m88k_frame_cache *cache;
CORE_ADDR frame_sp;
if (*this_cache)
return *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct m88k_frame_cache);
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
cache->fp_offset = -1;
cache->pc = get_frame_func (this_frame);
if (cache->pc != 0)
m88k_analyze_prologue (gdbarch, cache->pc, get_frame_pc (this_frame),
cache);
/* Calculate the stack pointer used in the prologue. */
if (cache->fp_offset != -1)
{
CORE_ADDR fp;
fp = get_frame_register_unsigned (this_frame, M88K_R30_REGNUM);
frame_sp = fp - cache->fp_offset;
}
else
{
/* If we know where the return address is saved, we can take a
solid guess at what the frame pointer should be. */
if (cache->saved_regs[M88K_R1_REGNUM].addr != -1)
cache->fp_offset = cache->saved_regs[M88K_R1_REGNUM].addr - 4;
frame_sp = get_frame_register_unsigned (this_frame, M88K_R31_REGNUM);
}
/* Now that we know the stack pointer, adjust the location of the
saved registers. */
{
int regnum;
for (regnum = M88K_R0_REGNUM; regnum < M88K_R31_REGNUM; regnum ++)
if (cache->saved_regs[regnum].addr != -1)
cache->saved_regs[regnum].addr += frame_sp;
}
/* Calculate the frame's base. */
cache->base = frame_sp - cache->sp_offset;
trad_frame_set_value (cache->saved_regs, M88K_R31_REGNUM, cache->base);
/* Identify SXIP with the return address in R1. */
cache->saved_regs[M88K_SXIP_REGNUM] = cache->saved_regs[M88K_R1_REGNUM];
*this_cache = cache;
return cache;
}
static int
amd64fbsd_trapframe_sniffer (const struct frame_unwind *self,
struct frame_info *this_frame,
void **this_prologue_cache)
{
const char *name;
find_pc_partial_function (get_frame_func (this_frame), &name, NULL, NULL);
return (name && ((strcmp (name, "calltrap") == 0)
|| (strcmp (name, "fork_trampoline") == 0)
|| (strcmp (name, "nmi_calltrap") == 0)
|| (name[0] == 'X' && name[1] != '_')));
}
static struct lm32_frame_cache *
lm32_frame_cache (struct frame_info *this_frame, void **this_prologue_cache)
{
CORE_ADDR prologue_pc;
CORE_ADDR current_pc;
ULONGEST prev_sp;
ULONGEST this_base;
struct lm32_frame_cache *info;
int prefixed;
unsigned long instruction;
int op;
int offsets[32];
int i;
long immediate;
if ((*this_prologue_cache))
return (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct lm32_frame_cache);
(*this_prologue_cache) = info;
info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
info->pc = get_frame_func (this_frame);
current_pc = get_frame_pc (this_frame);
lm32_analyze_prologue (get_frame_arch (this_frame),
info->pc, current_pc, info);
/* Compute the frame's base, and the previous frame's SP. */
this_base = get_frame_register_unsigned (this_frame, SIM_LM32_SP_REGNUM);
prev_sp = this_base + info->size;
info->base = this_base;
/* Convert callee save offsets into addresses. */
for (i = 0; i < gdbarch_num_regs (get_frame_arch (this_frame)) - 1; i++)
{
if (trad_frame_addr_p (info->saved_regs, i))
info->saved_regs[i].addr = this_base + info->saved_regs[i].addr;
}
/* The call instruction moves the caller's PC in the callee's RA register.
Since this is an unwind, do the reverse. Copy the location of RA register
into PC (the address / regnum) so that a request for PC will be
converted into a request for the RA register. */
info->saved_regs[SIM_LM32_PC_REGNUM] = info->saved_regs[SIM_LM32_RA_REGNUM];
/* The previous frame's SP needed to be computed. Save the computed
value. */
trad_frame_set_value (info->saved_regs, SIM_LM32_SP_REGNUM, prev_sp);
return info;
}
static struct trad_frame_cache *
amd64fbsd_trapframe_cache (struct frame_info *this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct trad_frame_cache *cache;
CORE_ADDR addr, func, pc, sp;
const char *name;
int i;
if (*this_cache != NULL)
return (*this_cache);
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
func = get_frame_func (this_frame);
sp = get_frame_register_unsigned (this_frame, AMD64_RSP_REGNUM);
find_pc_partial_function (func, &name, NULL, NULL);
if (strcmp(name, "fork_trampoline") == 0 && get_frame_pc (this_frame) == func)
{
/* fork_exit hasn't been called (kthread has never run), so %rsp
in the pcb points to the trapframe. GDB has auto-adjusted
%rsp for this frame to account for the "call" into
fork_trampoline, so "undo" the adjustment. */
sp += 8;
}
for (i = 0; i < ARRAY_SIZE (amd64fbsd_trapframe_offset); i++)
if (amd64fbsd_trapframe_offset[i] != -1)
trad_frame_set_reg_addr (cache, i, sp + amd64fbsd_trapframe_offset[i]);
/* Read %rip from trap frame. */
addr = sp + amd64fbsd_trapframe_offset[AMD64_RIP_REGNUM];
pc = read_memory_unsigned_integer (addr, 8, byte_order);
if (pc == 0 && strcmp(name, "fork_trampoline") == 0)
{
/* Initial frame of a kthread; terminate backtrace. */
trad_frame_set_id (cache, outer_frame_id);
}
else
{
/* Construct the frame ID using the function start. */
trad_frame_set_id (cache, frame_id_build (sp + TRAPFRAME_SIZE, func));
}
return cache;
}
static int
ppcfbsd_trapframe_sniffer (const struct frame_unwind *self,
struct frame_info *this_frame,
void **this_cache)
{
CORE_ADDR pc;
const char *name;
pc = get_frame_func (this_frame);
find_pc_partial_function (pc, &name, NULL, NULL);
if (name && (strcmp(name, "asttrapexit") == 0
|| strcmp(name, "trapexit") == 0))
return 1;
return 0;
}
static struct trad_frame_cache *
amd64obsd_trapframe_cache (struct frame_info *this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct trad_frame_cache *cache;
CORE_ADDR func, sp, addr;
ULONGEST cs;
const char *name;
int i;
if (*this_cache)
return (struct trad_frame_cache *) *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
func = get_frame_func (this_frame);
sp = get_frame_register_unsigned (this_frame, AMD64_RSP_REGNUM);
find_pc_partial_function (func, &name, NULL, NULL);
if (name && startswith (name, "Xintr"))
addr = sp + 8; /* It's an interrupt frame. */
else
addr = sp;
for (i = 0; i < ARRAY_SIZE (amd64obsd_tf_reg_offset); i++)
if (amd64obsd_tf_reg_offset[i] != -1)
trad_frame_set_reg_addr (cache, i, addr + amd64obsd_tf_reg_offset[i]);
/* Read %cs from trap frame. */
addr += amd64obsd_tf_reg_offset[AMD64_CS_REGNUM];
cs = read_memory_unsigned_integer (addr, 8, byte_order);
if ((cs & I386_SEL_RPL) == I386_SEL_UPL)
{
/* Trap from user space; terminate backtrace. */
trad_frame_set_id (cache, outer_frame_id);
}
else
{
/* Construct the frame ID using the function start. */
trad_frame_set_id (cache, frame_id_build (sp + 16, func));
}
return cache;
}
static struct trad_frame_cache *
ppcfbsd_trapframe_cache (struct frame_info *this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct trad_frame_cache *cache;
CORE_ADDR base;
int i, regnum;
if (*this_cache)
return *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
base = get_frame_register_unsigned (this_frame, gdbarch_sp_regnum (gdbarch));
if (tdep->wordsize == 8)
base += 48;
else
base += 8;
for (i = 0; i < ppc_num_gprs; i++)
trad_frame_set_reg_addr (cache, tdep->ppc_gp0_regnum + i, base
+ (OFF_FIXREG + i) * tdep->wordsize);
trad_frame_set_reg_addr (cache, tdep->ppc_lr_regnum, base
+ OFF_LR * tdep->wordsize);
trad_frame_set_reg_addr (cache, tdep->ppc_cr_regnum, base
+ OFF_CR * tdep->wordsize);
trad_frame_set_reg_addr (cache, tdep->ppc_xer_regnum, base
+ OFF_XER * tdep->wordsize);
trad_frame_set_reg_addr (cache, tdep->ppc_ctr_regnum, base
+ OFF_CTR * tdep->wordsize);
/* SRR0? */
trad_frame_set_reg_addr (cache, gdbarch_pc_regnum (gdbarch), base
+ OFF_SRR0 * tdep->wordsize);
/* Construct the frame ID using the function start. */
trad_frame_set_id (cache, frame_id_build (base, get_frame_func (this_frame)));
return cache;
}
/* Given a frame described by THIS_FRAME, decode the prologue of its
associated function if there is not cache entry as specified by
THIS_PROLOGUE_CACHE. Save the decoded prologue in the cache and
return that struct as the value of this function. */
static struct rx_prologue *
rx_analyze_frame_prologue (struct frame_info *this_frame,
void **this_prologue_cache)
{
if (!*this_prologue_cache)
{
CORE_ADDR func_start, stop_addr;
*this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rx_prologue);
func_start = get_frame_func (this_frame);
stop_addr = get_frame_pc (this_frame);
/* If we couldn't find any function containing the PC, then
just initialize the prologue cache, but don't do anything. */
if (!func_start)
stop_addr = func_start;
rx_analyze_prologue (func_start, stop_addr, *this_prologue_cache);
}
static struct ft32_frame_cache *
ft32_frame_cache (struct frame_info *this_frame, void **this_cache)
{
struct ft32_frame_cache *cache;
CORE_ADDR current_pc;
int i;
if (*this_cache)
return (struct ft32_frame_cache *) *this_cache;
cache = ft32_alloc_frame_cache ();
*this_cache = cache;
cache->base = get_frame_register_unsigned (this_frame, FT32_FP_REGNUM);
if (cache->base == 0)
return cache;
cache->pc = get_frame_func (this_frame);
current_pc = get_frame_pc (this_frame);
if (cache->pc)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
ft32_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
if (!cache->established)
cache->base = get_frame_register_unsigned (this_frame, FT32_SP_REGNUM);
}
cache->saved_sp = cache->base - 4;
for (i = 0; i < FT32_NUM_REGS; ++i)
if (cache->saved_regs[i] != REG_UNAVAIL)
cache->saved_regs[i] = cache->base + cache->saved_regs[i];
return cache;
}
static struct libunwind_frame_cache *
libunwind_frame_cache (struct frame_info *this_frame, void **this_cache)
{
unw_accessors_t *acc;
unw_addr_space_t as;
unw_word_t fp;
unw_regnum_t uw_sp_regnum;
struct libunwind_frame_cache *cache;
struct libunwind_descr *descr;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
int i, ret;
if (*this_cache)
return (struct libunwind_frame_cache *) *this_cache;
/* Allocate a new cache. */
cache = FRAME_OBSTACK_ZALLOC (struct libunwind_frame_cache);
cache->func_addr = get_frame_func (this_frame);
if (cache->func_addr == 0)
/* This can happen when the frame corresponds to a function for which
there is no debugging information nor any entry in the symbol table.
This is probably a static function for which an entry in the symbol
table was not created when the objfile got linked (observed in
libpthread.so on ia64-hpux).
The best we can do, in that case, is use the frame PC as the function
address. We don't need to give up since we still have the unwind
record to help us perform the unwinding. There is also another
compelling to continue, because abandonning now means stopping
the backtrace, which can never be helpful for the user. */
cache->func_addr = get_frame_pc (this_frame);
/* Get a libunwind cursor to the previous frame.
We do this by initializing a cursor. Libunwind treats a new cursor
as the top of stack and will get the current register set via the
libunwind register accessor. Now, we provide the platform-specific
accessors and we set up the register accessor to use the frame
register unwinding interfaces so that we properly get the registers
for the current frame rather than the top. We then use the unw_step
function to move the libunwind cursor back one frame. We can later
use this cursor to find previous registers via the unw_get_reg
interface which will invoke libunwind's special logic. */
descr = libunwind_descr (gdbarch);
acc = (unw_accessors_t *) descr->accessors;
as = unw_create_addr_space_p (acc,
gdbarch_byte_order (gdbarch)
== BFD_ENDIAN_BIG
? __BIG_ENDIAN
: __LITTLE_ENDIAN);
unw_init_remote_p (&cache->cursor, as, this_frame);
if (unw_step_p (&cache->cursor) < 0)
{
unw_destroy_addr_space_p (as);
return NULL;
}
/* To get base address, get sp from previous frame. */
uw_sp_regnum = descr->gdb2uw (gdbarch_sp_regnum (gdbarch));
ret = unw_get_reg_p (&cache->cursor, uw_sp_regnum, &fp);
if (ret < 0)
{
unw_destroy_addr_space_p (as);
error (_("Can't get libunwind sp register."));
}
cache->base = (CORE_ADDR)fp;
cache->as = as;
*this_cache = cache;
return cache;
}
static struct trad_frame_cache *
i386nbsd_trapframe_cache(struct frame_info *this_frame, void **this_cache)
{
struct trad_frame_cache *cache;
CORE_ADDR func, sp, addr, tmp;
ULONGEST cs;
const char *name;
int i;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
if (*this_cache)
return (struct trad_frame_cache *)*this_cache;
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
func = get_frame_func (this_frame);
sp = get_frame_register_unsigned (this_frame, I386_ESP_REGNUM);
find_pc_partial_function (func, &name, NULL, NULL);
if (name && strncmp (name, "Xintr", 5) == 0)
{
/* It's an interrupt frame. */
tmp = read_memory_unsigned_integer (sp + 4, 4, byte_order);
if (tmp < 15)
{
/* Reasonable value for 'ppl': already on interrupt stack. */
addr = sp + 8;
}
else
{
/* Switch to previous stack. */
addr = tmp + 4;
}
}
else
{
/* It's a trap frame. */
addr = sp + 4;
}
for (i = 0; i < ARRAY_SIZE (i386nbsd_tf_reg_offset); i++)
if (i386nbsd_tf_reg_offset[i] != -1)
trad_frame_set_reg_addr (cache, i, addr + i386nbsd_tf_reg_offset[i]);
/* Read %cs from trap frame. */
addr += i386nbsd_tf_reg_offset[I386_CS_REGNUM];
cs = read_memory_unsigned_integer (addr, 4, byte_order);
if ((cs & I386_SEL_RPL) == I386_SEL_UPL)
{
/* Trap from user space; terminate backtrace. */
trad_frame_set_id (cache, outer_frame_id);
}
else
{
/* Construct the frame ID using the function start. */
trad_frame_set_id (cache, frame_id_build (sp + 8, func));
}
return cache;
}
static struct trad_frame_cache *
amd64nbsd_trapframe_cache(struct frame_info *this_frame, void **this_cache)
{
struct trad_frame_cache *cache;
CORE_ADDR func, sp, addr;
ULONGEST cs = 0, rip = 0;
const char *name;
int i;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
if (*this_cache)
return *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
func = get_frame_func (this_frame);
sp = get_frame_register_unsigned (this_frame, AMD64_RSP_REGNUM);
find_pc_partial_function (func, &name, NULL, NULL);
/* There is an extra 'call' in the interrupt sequence - ignore the extra
* return address */
if (name && strncmp (name, "Xintr", 5) == 0)
addr = sp + 8; /* It's an interrupt frame. */
else
addr = sp;
for (i = 0; i < ARRAY_SIZE (amd64nbsd_tf_reg_offset); i++)
if (amd64nbsd_tf_reg_offset[i] != -1)
trad_frame_set_reg_addr (cache, i, addr + amd64nbsd_tf_reg_offset[i]);
/* Read %cs and %rip when we have the addresses to hand */
cs = read_memory_unsigned_integer (addr
+ amd64nbsd_tf_reg_offset[AMD64_CS_REGNUM], 8, byte_order);
rip = read_memory_unsigned_integer (addr
+ amd64nbsd_tf_reg_offset[AMD64_RIP_REGNUM], 8, byte_order);
/* The trap frame layout was changed lf the %rip value is less than 2^16 it
* is almost certainly the %ss of the old format. */
if (rip < (1 << 16))
{
for (i = 0; i < ARRAY_SIZE (amd64nbsd_tf_reg_offset); i++)
{
if (amd64nbsd_tf_reg_offset[i] == -1)
continue;
trad_frame_set_reg_addr (cache, i, addr + amd64nbsd_r_reg_offset[i]);
/* Read %cs when we have the address to hand */
if (i == AMD64_CS_REGNUM)
cs = read_memory_unsigned_integer (addr + amd64nbsd_r_reg_offset[i],
8, byte_order);
}
}
if ((cs & I386_SEL_RPL) == I386_SEL_UPL ||
(name && strncmp(name, "Xsoft", 5) == 0))
{
/* Trap from user space or soft interrupt; terminate backtrace. */
trad_frame_set_id (cache, outer_frame_id);
}
else
{
/* Construct the frame ID using the function start. */
trad_frame_set_id (cache, frame_id_build (sp + 16, func));
}
return cache;
}
int
inside_entry_func (struct frame_info *this_frame)
{
return (get_frame_func (this_frame) == entry_point_address ());
}
