/* 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 **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->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
/* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */
- frame_unwind_unsigned_register (next_frame, PROC_FRAME_REG (proc_desc), &vfp);
+ vfp = frame_unwind_register_unsigned (next_frame, PROC_FRAME_REG (proc_desc));
vfp += PROC_FRAME_OFFSET (info->proc_desc);
info->vfp = vfp;
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);
- *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);
/* 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. */
};
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