/* Target-dependent mdebug code for the ALPHA architecture.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+ 2003, 2007 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
#include "frame-unwind.h"
#include "frame-base.h"
-#include "inferior.h"
#include "symtab.h"
-#include "value.h"
-#include "gdbcmd.h"
#include "gdbcore.h"
-#include "dis-asm.h"
-#include "symfile.h"
-#include "objfiles.h"
-#include "gdb_string.h"
-#include "linespec.h"
-#include "regcache.h"
-#include "doublest.h"
-#include "arch-utils.h"
-#include "osabi.h"
#include "block.h"
#include "gdb_assert.h"
-
-#include "elf-bfd.h"
+#include "gdb_string.h"
#include "alpha-tdep.h"
+#include "mdebugread.h"
/* FIXME: Some of this code should perhaps be merged with mips. */
| |localoff | Copies of 1st .. 6th |
| | | | | argument if necessary. |
| | | v | |
- | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS
+ | | | --- |-------------------------------|<-- LOCALS_ADDRESS
| | | | |
| | | | Locals and temporaries. |
| | | | |
/* Locate the mdebug PDR for the given PC. Return null if one can't
be found; you'll have to fall back to other methods in that case. */
-static alpha_extra_func_info_t
+static struct mdebug_extra_func_info *
find_proc_desc (CORE_ADDR pc)
{
struct block *b = block_for_pc (pc);
- alpha_extra_func_info_t proc_desc = NULL;
+ struct mdebug_extra_func_info *proc_desc = NULL;
struct symbol *sym = NULL;
+ char *sh_name = NULL;
if (b)
{
CORE_ADDR startaddr;
- find_pc_partial_function (pc, NULL, &startaddr, NULL);
+ find_pc_partial_function (pc, &sh_name, &startaddr, NULL);
if (startaddr > BLOCK_START (b))
/* This is the "pathological" case referred to in a comment in
symbol reading. */
sym = NULL;
else
- sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0, NULL);
+ sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0, NULL);
}
if (sym)
{
- proc_desc = (alpha_extra_func_info_t) SYMBOL_VALUE (sym);
+ proc_desc = (struct mdebug_extra_func_info *) SYMBOL_VALUE (sym);
+
+ /* Correct incorrect setjmp procedure descriptor from the library
+ to make backtrace through setjmp work. */
+ if (proc_desc->pdr.pcreg == 0
+ && strcmp (sh_name, "setjmp") == 0)
+ {
+ proc_desc->pdr.pcreg = ALPHA_RA_REGNUM;
+ proc_desc->pdr.regmask = 0x80000000;
+ proc_desc->pdr.regoffset = -4;
+ }
/* If we never found a PDR for this function in symbol reading,
then examine prologues to find the information. */
find the prologue, then return 0. */
static CORE_ADDR
-alpha_mdebug_after_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc)
+alpha_mdebug_after_prologue (CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
{
if (proc_desc)
{
/* If function is frameless, then we need to do it the hard way. I
strongly suspect that frameless always means prologueless... */
- if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
+ if (PROC_FRAME_REG (proc_desc) == ALPHA_SP_REGNUM
&& PROC_FRAME_OFFSET (proc_desc) == 0)
return 0;
}
if we are definitively *not* in a function prologue. */
static int
-alpha_mdebug_in_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc)
+alpha_mdebug_in_prologue (CORE_ADDR pc, struct mdebug_extra_func_info *proc_desc)
{
CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc);
return (after_prologue_pc == 0 || pc < after_prologue_pc);
struct alpha_mdebug_unwind_cache
{
- alpha_extra_func_info_t proc_desc;
+ struct mdebug_extra_func_info *proc_desc;
CORE_ADDR vfp;
CORE_ADDR *saved_regs;
- void *in_prologue_cache;
};
/* Extract all of the information about the frame from PROC_DESC
void **this_prologue_cache)
{
struct alpha_mdebug_unwind_cache *info;
- alpha_extra_func_info_t proc_desc;
+ struct mdebug_extra_func_info *proc_desc;
ULONGEST vfp;
CORE_ADDR pc, reg_position;
unsigned long mask;
info->proc_desc = proc_desc;
gdb_assert (proc_desc != NULL);
- /* If we're in the prologue, the PDR for this frame is not yet valid. */
- /* ??? We could have said "no" in alpha_mdebug_frame_p, and we'd
- walk down the list of unwinders and try the heuristic unwinder
- and things would have been fine. However, since we have the PDR,
- we know how to skip the search for the start of the procedure,
- and all the uncertainty involved there. So instead, arrange for
- us to defer to the heuristic unwinder directly. */
- if (alpha_mdebug_in_prologue (pc, proc_desc))
- {
- alpha_heuristic_frame_unwind_cache (next_frame,
- &info->in_prologue_cache,
- PROC_LOW_ADDR (proc_desc));
- return info;
- }
-
info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
/* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */
for (ireg = 0; ireg <= 31; ++ireg)
if (mask & (1 << ireg))
{
- info->saved_regs[FP0_REGNUM + ireg] = reg_position;
+ info->saved_regs[ALPHA_FP0_REGNUM + ireg] = reg_position;
reg_position += 8;
}
struct alpha_mdebug_unwind_cache *info
= alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
- /* If we're in the prologue, defer to the heuristic unwinder. */
- if (info->in_prologue_cache)
- alpha_heuristic_frame_this_id (next_frame, &info->in_prologue_cache,
- this_id);
- else
- *this_id = frame_id_build (info->vfp, frame_func_unwind (next_frame));
+ *this_id = frame_id_build (info->vfp,
+ frame_func_unwind (next_frame, NORMAL_FRAME));
}
/* Retrieve the value of REGNUM in FRAME. Don't give up! */
void **this_prologue_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *bufferp)
+ int *realnump, gdb_byte *bufferp)
{
struct alpha_mdebug_unwind_cache *info
= alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
- /* If we're in the prologue, defer to the heuristic unwinder. */
- if (info->in_prologue_cache)
- {
- alpha_heuristic_frame_prev_register (next_frame,
- &info->in_prologue_cache,
- regnum, optimizedp, lvalp,
- addrp, realnump, bufferp);
- return;
- }
-
/* The PC of the previous frame is stored in the link register of
the current frame. Frob regnum so that we pull the value from
the correct place. */
- if (regnum == PC_REGNUM)
+ if (regnum == ALPHA_PC_REGNUM)
regnum = PROC_PC_REG (info->proc_desc);
/* For all registers known to be saved in the current frame,
*addrp = info->saved_regs[regnum];
*realnump = -1;
if (bufferp != NULL)
- read_memory (*addrp, bufferp, ALPHA_REGISTER_SIZE);
+ get_frame_memory (next_frame, *addrp, bufferp, ALPHA_REGISTER_SIZE);
return;
}
/* The stack pointer of the previous frame is computed by popping
the current stack frame. */
- if (regnum == SP_REGNUM)
+ if (regnum == ALPHA_SP_REGNUM)
{
*optimizedp = 0;
*lvalp = not_lval;
}
/* Otherwise assume the next frame has the same register value. */
- frame_register (next_frame, regnum, optimizedp, lvalp, addrp,
- realnump, bufferp);
+ *optimizedp = 0;
+ *lvalp = lval_register;
+ *addrp = 0;
+ *realnump = regnum;
+ if (bufferp)
+ frame_unwind_register (next_frame, *realnump, bufferp);
}
static const struct frame_unwind alpha_mdebug_frame_unwind = {
};
const struct frame_unwind *
-alpha_mdebug_frame_p (CORE_ADDR pc)
+alpha_mdebug_frame_sniffer (struct frame_info *next_frame)
{
- alpha_extra_func_info_t proc_desc;
+ CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+ struct mdebug_extra_func_info *proc_desc;
/* If this PC does not map to a PDR, then clearly this isn't an
mdebug frame. */
if (proc_desc == NULL)
return NULL;
+ /* If we're in the prologue, the PDR for this frame is not yet valid.
+ Say no here and we'll fall back on the heuristic unwinder. */
+ if (alpha_mdebug_in_prologue (pc, proc_desc))
+ return NULL;
+
return &alpha_mdebug_frame_unwind;
}
struct alpha_mdebug_unwind_cache *info
= alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
- if (info->in_prologue_cache)
- return alpha_heuristic_frame_base_address (next_frame,
- &info->in_prologue_cache);
- else
- return info->vfp;
+ return info->vfp;
}
static CORE_ADDR
{
struct alpha_mdebug_unwind_cache *info
= alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
- CORE_ADDR vfp;
-
- if (info->in_prologue_cache)
- vfp = alpha_heuristic_frame_base_address (next_frame,
- &info->in_prologue_cache);
- else
- vfp = info->vfp;
- return vfp - PROC_LOCALOFF (info->proc_desc);
+ return info->vfp - PROC_LOCALOFF (info->proc_desc);
}
static CORE_ADDR
{
struct alpha_mdebug_unwind_cache *info
= alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache);
- CORE_ADDR vfp;
-
- if (info->in_prologue_cache)
- vfp = alpha_heuristic_frame_base_address (next_frame,
- &info->in_prologue_cache);
- else
- vfp = info->vfp;
- return vfp - ALPHA_NUM_ARG_REGS * 8;
+ return info->vfp - ALPHA_NUM_ARG_REGS * 8;
}
static const struct frame_base alpha_mdebug_frame_base = {
};
static const struct frame_base *
-alpha_mdebug_frame_base_p (CORE_ADDR pc)
+alpha_mdebug_frame_base_sniffer (struct frame_info *next_frame)
{
- alpha_extra_func_info_t proc_desc;
+ CORE_ADDR pc = frame_unwind_address_in_block (next_frame, NORMAL_FRAME);
+ struct mdebug_extra_func_info *proc_desc;
/* If this PC does not map to a PDR, then clearly this isn't an
mdebug frame. */
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- frame_unwind_append_predicate (gdbarch, alpha_mdebug_frame_p);
- frame_base_append_predicate (gdbarch, alpha_mdebug_frame_base_p);
+ frame_unwind_append_sniffer (gdbarch, alpha_mdebug_frame_sniffer);
+ frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);
}
projects / deliverable / binutils-gdb.git / blobdiff