X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Falpha-mdebug-tdep.c;h=f88ee123851de3f5a59cd8974ed3984ab9664b7c;hb=727fc41e077139570ea8b8ddfd6c546b2a55627c;hp=520656b455b4eda5b6c7623ffd757c54f1ddd82f;hpb=087779b16ba2e92880e361f1a123371de9e517f4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/alpha-mdebug-tdep.c b/gdb/alpha-mdebug-tdep.c index 520656b455..f88ee12385 100644 --- a/gdb/alpha-mdebug-tdep.c +++ b/gdb/alpha-mdebug-tdep.c @@ -1,12 +1,12 @@ /* 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, 2008, 2009 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, @@ -15,9 +15,7 @@ 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 . */ #include "defs.h" #include "frame.h" @@ -27,8 +25,11 @@ #include "gdbcore.h" #include "block.h" #include "gdb_assert.h" +#include "gdb_string.h" +#include "trad-frame.h" #include "alpha-tdep.h" +#include "mdebugread.h" /* FIXME: Some of this code should perhaps be merged with mips. */ @@ -45,7 +46,7 @@ | |localoff | Copies of 1st .. 6th | | | | | | argument if necessary. | | | | v | | - | | | --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS + | | | --- |-------------------------------|<-- LOCALS_ADDRESS | | | | | | | | | Locals and temporaries. | | | | | | @@ -90,17 +91,18 @@ /* 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 @@ -108,12 +110,22 @@ find_proc_desc (CORE_ADDR pc) 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); } 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. */ @@ -128,7 +140,7 @@ find_proc_desc (CORE_ADDR pc) 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) { @@ -146,7 +158,7 @@ alpha_mdebug_after_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc) 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); @@ -157,20 +169,20 @@ alpha_mdebug_in_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc) 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; + struct trad_frame_saved_reg *saved_regs; }; /* Extract all of the information about the frame from PROC_DESC and store the resulting register save locations in the structure. */ static struct alpha_mdebug_unwind_cache * -alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, +alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame, 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; @@ -181,7 +193,7 @@ alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache); *this_prologue_cache = info; - pc = frame_pc_unwind (next_frame); + pc = get_frame_address_in_block (this_frame); /* ??? We don't seem to be able to cache the lookup of the PDR from alpha_mdebug_frame_p. It'd be nice if we could change @@ -190,10 +202,10 @@ alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, info->proc_desc = proc_desc; gdb_assert (proc_desc != NULL); - info->saved_regs = frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS); + info->saved_regs = trad_frame_alloc_saved_regs (this_frame); /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */ - frame_unwind_unsigned_register (next_frame, PROC_FRAME_REG (proc_desc), &vfp); + vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc)); vfp += PROC_FRAME_OFFSET (info->proc_desc); info->vfp = vfp; @@ -210,14 +222,14 @@ alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, /* Clear bit for RA so we don't save it again later. */ mask &= ~(1 << returnreg); - info->saved_regs[returnreg] = reg_position; + info->saved_regs[returnreg].addr = reg_position; reg_position += 8; } for (ireg = 0; ireg <= 31; ++ireg) if (mask & (1 << ireg)) { - info->saved_regs[ireg] = reg_position; + info->saved_regs[ireg].addr = reg_position; reg_position += 8; } @@ -227,10 +239,15 @@ alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, for (ireg = 0; ireg <= 31; ++ireg) if (mask & (1 << ireg)) { - info->saved_regs[ALPHA_FP0_REGNUM + ireg] = reg_position; + info->saved_regs[ALPHA_FP0_REGNUM + ireg].addr = reg_position; reg_position += 8; } + /* The stack pointer of the previous frame is computed by popping + the current stack frame. */ + if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM)) + trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, vfp); + return info; } @@ -238,27 +255,24 @@ alpha_mdebug_frame_unwind_cache (struct frame_info *next_frame, frame. This will be used to create a new GDB frame struct. */ static void -alpha_mdebug_frame_this_id (struct frame_info *next_frame, +alpha_mdebug_frame_this_id (struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id) { struct alpha_mdebug_unwind_cache *info - = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); + = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache); - *this_id = frame_id_build (info->vfp, frame_func_unwind (next_frame)); + *this_id = frame_id_build (info->vfp, get_frame_func (this_frame)); } /* Retrieve the value of REGNUM in FRAME. Don't give up! */ -static void -alpha_mdebug_frame_prev_register (struct frame_info *next_frame, - void **this_prologue_cache, - int regnum, int *optimizedp, - enum lval_type *lvalp, CORE_ADDR *addrp, - int *realnump, void *bufferp) +static struct value * +alpha_mdebug_frame_prev_register (struct frame_info *this_frame, + void **this_prologue_cache, int regnum) { struct alpha_mdebug_unwind_cache *info - = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); + = alpha_mdebug_frame_unwind_cache (this_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 @@ -266,88 +280,65 @@ alpha_mdebug_frame_prev_register (struct frame_info *next_frame, if (regnum == ALPHA_PC_REGNUM) regnum = PROC_PC_REG (info->proc_desc); - /* For all registers known to be saved in the current frame, - do the obvious and pull the value out. */ - if (info->saved_regs[regnum]) - { - *optimizedp = 0; - *lvalp = lval_memory; - *addrp = info->saved_regs[regnum]; - *realnump = -1; - if (bufferp != NULL) - read_memory (*addrp, bufferp, ALPHA_REGISTER_SIZE); - return; - } - - /* The stack pointer of the previous frame is computed by popping - the current stack frame. */ - if (regnum == ALPHA_SP_REGNUM) - { - *optimizedp = 0; - *lvalp = not_lval; - *addrp = 0; - *realnump = -1; - if (bufferp != NULL) - store_unsigned_integer (bufferp, ALPHA_REGISTER_SIZE, info->vfp); - return; - } - - /* Otherwise assume the next frame has the same register value. */ - frame_register (next_frame, regnum, optimizedp, lvalp, addrp, - realnump, bufferp); + return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum); } -static const struct frame_unwind alpha_mdebug_frame_unwind = { - NORMAL_FRAME, - alpha_mdebug_frame_this_id, - alpha_mdebug_frame_prev_register -}; - -const struct frame_unwind * -alpha_mdebug_frame_p (CORE_ADDR pc) +static int +alpha_mdebug_frame_sniffer (const struct frame_unwind *self, + struct frame_info *this_frame, + void **this_cache) { - alpha_extra_func_info_t proc_desc; + CORE_ADDR pc = get_frame_address_in_block (this_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. */ proc_desc = find_proc_desc (pc); if (proc_desc == NULL) - return NULL; + return 0; /* 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 0; - return &alpha_mdebug_frame_unwind; + return 1; } +static const struct frame_unwind alpha_mdebug_frame_unwind = { + NORMAL_FRAME, + alpha_mdebug_frame_this_id, + alpha_mdebug_frame_prev_register, + NULL, + alpha_mdebug_frame_sniffer +}; + static CORE_ADDR -alpha_mdebug_frame_base_address (struct frame_info *next_frame, +alpha_mdebug_frame_base_address (struct frame_info *this_frame, void **this_prologue_cache) { struct alpha_mdebug_unwind_cache *info - = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); + = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache); return info->vfp; } static CORE_ADDR -alpha_mdebug_frame_locals_address (struct frame_info *next_frame, +alpha_mdebug_frame_locals_address (struct frame_info *this_frame, void **this_prologue_cache) { struct alpha_mdebug_unwind_cache *info - = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); + = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache); return info->vfp - PROC_LOCALOFF (info->proc_desc); } static CORE_ADDR -alpha_mdebug_frame_args_address (struct frame_info *next_frame, +alpha_mdebug_frame_args_address (struct frame_info *this_frame, void **this_prologue_cache) { struct alpha_mdebug_unwind_cache *info - = alpha_mdebug_frame_unwind_cache (next_frame, this_prologue_cache); + = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache); return info->vfp - ALPHA_NUM_ARG_REGS * 8; } @@ -360,9 +351,10 @@ 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 *this_frame) { - alpha_extra_func_info_t proc_desc; + CORE_ADDR pc = get_frame_address_in_block (this_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. */ @@ -379,6 +371,6 @@ alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { 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_unwinder (gdbarch, &alpha_mdebug_frame_unwind); + frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer); }