2003-05-30 01:02:53 +02:00
|
|
|
|
/* Target-dependent mdebug code for the ALPHA architecture.
|
2015-01-01 10:32:14 +01:00
|
|
|
|
Copyright (C) 1993-2015 Free Software Foundation, Inc.
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
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
|
2007-08-23 20:08:50 +02:00
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
2003-05-30 01:02:53 +02:00
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 20:08:50 +02:00
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "frame-unwind.h"
|
|
|
|
|
#include "frame-base.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
#include "gdbcore.h"
|
|
|
|
|
#include "block.h"
|
2008-05-21 16:47:26 +02:00
|
|
|
|
#include "trad-frame.h"
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
#include "alpha-tdep.h"
|
2004-11-06 18:18:10 +01:00
|
|
|
|
#include "mdebugread.h"
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
/* FIXME: Some of this code should perhaps be merged with mips. */
|
|
|
|
|
|
|
|
|
|
/* *INDENT-OFF* */
|
|
|
|
|
/* Layout of a stack frame on the alpha:
|
|
|
|
|
|
|
|
|
|
| |
|
|
|
|
|
pdr members: | 7th ... nth arg, |
|
|
|
|
|
| `pushed' by caller. |
|
|
|
|
|
| |
|
|
|
|
|
----------------|-------------------------------|<-- old_sp == vfp
|
|
|
|
|
^ ^ ^ ^ | |
|
|
|
|
|
| | | | | |
|
|
|
|
|
| |localoff | Copies of 1st .. 6th |
|
|
|
|
|
| | | | | argument if necessary. |
|
|
|
|
|
| | | v | |
|
2003-06-26 19:18:43 +02:00
|
|
|
|
| | | --- |-------------------------------|<-- LOCALS_ADDRESS
|
2003-05-30 01:02:53 +02:00
|
|
|
|
| | | | |
|
|
|
|
|
| | | | Locals and temporaries. |
|
|
|
|
|
| | | | |
|
|
|
|
|
| | | |-------------------------------|
|
|
|
|
|
| | | | |
|
|
|
|
|
|-fregoffset | Saved float registers. |
|
|
|
|
|
| | | | F9 |
|
|
|
|
|
| | | | . |
|
|
|
|
|
| | | | . |
|
|
|
|
|
| | | | F2 |
|
|
|
|
|
| | v | |
|
|
|
|
|
| | -------|-------------------------------|
|
|
|
|
|
| | | |
|
|
|
|
|
| | | Saved registers. |
|
|
|
|
|
| | | S6 |
|
|
|
|
|
|-regoffset | . |
|
|
|
|
|
| | | . |
|
|
|
|
|
| | | S0 |
|
|
|
|
|
| | | pdr.pcreg |
|
|
|
|
|
| v | |
|
|
|
|
|
| ----------|-------------------------------|
|
|
|
|
|
| | |
|
|
|
|
|
frameoffset | Argument build area, gets |
|
|
|
|
|
| | 7th ... nth arg for any |
|
|
|
|
|
| | called procedure. |
|
|
|
|
|
v | |
|
|
|
|
|
-------------|-------------------------------|<-- sp
|
|
|
|
|
| |
|
|
|
|
|
*/
|
|
|
|
|
/* *INDENT-ON* */
|
|
|
|
|
|
|
|
|
|
#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)
|
|
|
|
|
#define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
|
|
|
|
|
#define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
|
|
|
|
|
#define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
|
|
|
|
|
#define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
|
|
|
|
|
#define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
|
|
|
|
|
#define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
|
|
|
|
|
#define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
|
|
|
|
|
#define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)
|
|
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
|
2004-11-06 18:18:10 +01:00
|
|
|
|
static struct mdebug_extra_func_info *
|
2003-05-30 01:02:53 +02:00
|
|
|
|
find_proc_desc (CORE_ADDR pc)
|
|
|
|
|
{
|
constify struct block in some places
This makes some spots in gdb, particularly general_symbol_info, use a
"const struct block", then fixes the fallout.
The justification is that, ordinarily, blocks ought to be readonly.
Note though that we can't add "const" in the blockvector due to block
relocation. This can be done once blocks are made independent of the
program space.
2014-06-18 Tom Tromey <tromey@redhat.com>
* varobj.c (varobj_create): Update.
* valops.c (value_of_this): Update.
* tracepoint.c (add_local_symbols, scope_info): Update.
* symtab.h (struct general_symbol_info) <block>: Now const.
* symtab.c (skip_prologue_sal)
(default_make_symbol_completion_list_break_on)
(skip_prologue_using_sal): Update.
* stack.h (iterate_over_block_locals)
(iterate_over_block_local_vars): Update.
* stack.c (print_frame_args): Update.
(iterate_over_block_locals, iterate_over_block_local_vars): Make
parameter const.
(get_selected_block): Make return type const.
* python/py-frame.c (frapy_block): Update.
* python/py-block.c (gdbpy_block_for_pc): Update.
* p-exp.y (%union) <bval>: Now const.
* mi/mi-cmd-stack.c (list_args_or_locals): Update.
* mdebugread.c (mylookup_symbol, parse_procedure): Update.
* m2-exp.y (%union) <bval>: Now const.
* linespec.c (get_current_search_block): Make return type const.
(create_sals_line_offset, find_label_symbols): Update.
* inline-frame.c (inline_frame_sniffer, skip_inline_frames):
Update.
(block_starting_point_at): Make "block" const.
* infrun.c (insert_exception_resume_breakpoint): Make "b" const.
(check_exception_resume): Update.
* guile/scm-frame.c (gdbscm_frame_block): Update.
* guile/scm-block.c (gdbscm_lookup_block): Update.
* frame.h (get_frame_block): Update.
(get_selected_block): Make return type const.
* frame.c (frame_id_inner): Update.
* f-valprint.c (info_common_command_for_block)
(info_common_command): Update.
* dwarf2loc.c (dwarf2_find_location_expression)
(dwarf_expr_frame_base, dwarf2_compile_expr_to_ax)
(locexpr_describe_location_piece): Update.
* c-exp.y (%union) <bval>: Now const.
* breakpoint.c (resolve_sal_pc): Update.
* blockframe.c (get_frame_block):Make return type const.
(get_pc_function_start, get_frame_function, find_pc_sect_function)
(block_innermost_frame): Update.
* block.h (blockvector_for_pc, blockvector_for_pc_sect)
(block_for_pc, block_for_pc_sect): Update.
* block.c (blockvector_for_pc_sect, blockvector_for_pc): Make
'pblock' const.
(block_for_pc_sect, block_for_pc): Make return type const.
* ax-gdb.c (gen_expr): Update.
* alpha-mdebug-tdep.c (find_proc_desc): Update.
* ada-lang.c (ada_read_renaming_var_value): Make 'block' const.
(ada_make_symbol_completion_list, ada_add_exceptions_from_frame)
(ada_read_var_value): Update.
* ada-exp.y (struct name_info) <block>: Now const.
(%union): Likewise.
(block_lookup): Constify.
2013-03-12 16:51:37 +01:00
|
|
|
|
const struct block *b = block_for_pc (pc);
|
2004-11-06 18:18:10 +01:00
|
|
|
|
struct mdebug_extra_func_info *proc_desc = NULL;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
struct symbol *sym = NULL;
|
2012-02-02 21:19:17 +01:00
|
|
|
|
const char *sh_name = NULL;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
if (b)
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR startaddr;
|
2007-10-12 18:13:20 +02:00
|
|
|
|
find_pc_partial_function (pc, &sh_name, &startaddr, NULL);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
if (startaddr > BLOCK_START (b))
|
|
|
|
|
/* This is the "pathological" case referred to in a comment in
|
|
|
|
|
print_frame_info. It might be better to move this check into
|
|
|
|
|
symbol reading. */
|
|
|
|
|
sym = NULL;
|
|
|
|
|
else
|
2015-08-01 11:25:44 +02:00
|
|
|
|
sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN,
|
|
|
|
|
0).symbol;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (sym)
|
|
|
|
|
{
|
2010-09-10 18:04:58 +02:00
|
|
|
|
proc_desc = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (sym);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
2007-10-12 18:13:20 +02:00
|
|
|
|
/* 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;
|
|
|
|
|
}
|
|
|
|
|
|
2003-05-30 01:02:53 +02:00
|
|
|
|
/* If we never found a PDR for this function in symbol reading,
|
|
|
|
|
then examine prologues to find the information. */
|
|
|
|
|
if (proc_desc->pdr.framereg == -1)
|
|
|
|
|
proc_desc = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return proc_desc;
|
|
|
|
|
}
|
|
|
|
|
|
* alpha-tdep.c (INSN_OPCODE, MEM_RA, MEM_RB, MEM_DISP, BR_RA)
(OPR_FUNCTION, OPR_HAS_IMMEDIATE, OPR_RA, OPR_RC, OPR_LIT): New macros.
(lda_opcode, stq_opcode, bne_opcode, subq_opcode, subq_function):
New constants.
(alpha_heuristic_analyze_probing_loop): New function.
(alpha_heuristic_frame_unwind_cache): In the prologue analysis, detect
and handle cases when a stack probe loop is generated.
* alpha-mdebug-tdep.c (alpha_mdebug_frameless): New function.
(alpha_mdebug_max_frame_size_exceeded): New function.
(alpha_mdebug_after_prologue): Use alpha_mdebug_frameless.
(alpha_mdebug_frame_sniffer, alpha_mdebug_frame_base_sniffer):
Return 0 when the maximum debuggable frame size has been exceeded.
2010-04-23 17:14:22 +02:00
|
|
|
|
/* Return a non-zero result if the function is frameless; zero otherwise. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
alpha_mdebug_frameless (struct mdebug_extra_func_info *proc_desc)
|
|
|
|
|
{
|
|
|
|
|
return (PROC_FRAME_REG (proc_desc) == ALPHA_SP_REGNUM
|
|
|
|
|
&& PROC_FRAME_OFFSET (proc_desc) == 0);
|
|
|
|
|
}
|
|
|
|
|
|
2003-05-30 01:02:53 +02:00
|
|
|
|
/* This returns the PC of the first inst after the prologue. If we can't
|
|
|
|
|
find the prologue, then return 0. */
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
2011-01-07 20:36:19 +01:00
|
|
|
|
alpha_mdebug_after_prologue (CORE_ADDR pc,
|
|
|
|
|
struct mdebug_extra_func_info *proc_desc)
|
2003-05-30 01:02:53 +02:00
|
|
|
|
{
|
|
|
|
|
if (proc_desc)
|
|
|
|
|
{
|
|
|
|
|
/* If function is frameless, then we need to do it the hard way. I
|
2011-01-07 20:36:19 +01:00
|
|
|
|
strongly suspect that frameless always means prologueless... */
|
* alpha-tdep.c (INSN_OPCODE, MEM_RA, MEM_RB, MEM_DISP, BR_RA)
(OPR_FUNCTION, OPR_HAS_IMMEDIATE, OPR_RA, OPR_RC, OPR_LIT): New macros.
(lda_opcode, stq_opcode, bne_opcode, subq_opcode, subq_function):
New constants.
(alpha_heuristic_analyze_probing_loop): New function.
(alpha_heuristic_frame_unwind_cache): In the prologue analysis, detect
and handle cases when a stack probe loop is generated.
* alpha-mdebug-tdep.c (alpha_mdebug_frameless): New function.
(alpha_mdebug_max_frame_size_exceeded): New function.
(alpha_mdebug_after_prologue): Use alpha_mdebug_frameless.
(alpha_mdebug_frame_sniffer, alpha_mdebug_frame_base_sniffer):
Return 0 when the maximum debuggable frame size has been exceeded.
2010-04-23 17:14:22 +02:00
|
|
|
|
if (alpha_mdebug_frameless (proc_desc))
|
2003-05-30 01:02:53 +02:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return alpha_after_prologue (pc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return non-zero if we *might* be in a function prologue. Return zero
|
|
|
|
|
if we are definitively *not* in a function prologue. */
|
|
|
|
|
|
|
|
|
|
static int
|
2011-01-07 20:36:19 +01:00
|
|
|
|
alpha_mdebug_in_prologue (CORE_ADDR pc,
|
|
|
|
|
struct mdebug_extra_func_info *proc_desc)
|
2003-05-30 01:02:53 +02:00
|
|
|
|
{
|
|
|
|
|
CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc);
|
|
|
|
|
return (after_prologue_pc == 0 || pc < after_prologue_pc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Frame unwinder that reads mdebug PDRs. */
|
|
|
|
|
|
|
|
|
|
struct alpha_mdebug_unwind_cache
|
|
|
|
|
{
|
2004-11-06 18:18:10 +01:00
|
|
|
|
struct mdebug_extra_func_info *proc_desc;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
CORE_ADDR vfp;
|
2008-05-21 16:47:26 +02:00
|
|
|
|
struct trad_frame_saved_reg *saved_regs;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* 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 *
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame,
|
2003-05-30 01:02:53 +02:00
|
|
|
|
void **this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
struct alpha_mdebug_unwind_cache *info;
|
2004-11-06 18:18:10 +01:00
|
|
|
|
struct mdebug_extra_func_info *proc_desc;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
ULONGEST vfp;
|
|
|
|
|
CORE_ADDR pc, reg_position;
|
|
|
|
|
unsigned long mask;
|
|
|
|
|
int ireg, returnreg;
|
|
|
|
|
|
|
|
|
|
if (*this_prologue_cache)
|
|
|
|
|
return *this_prologue_cache;
|
|
|
|
|
|
|
|
|
|
info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
|
|
|
|
|
*this_prologue_cache = info;
|
2008-11-24 14:52:05 +01:00
|
|
|
|
pc = get_frame_address_in_block (this_frame);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
/* ??? 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
|
|
|
|
|
the arguments to that function. Oh well. */
|
|
|
|
|
proc_desc = find_proc_desc (pc);
|
|
|
|
|
info->proc_desc = proc_desc;
|
|
|
|
|
gdb_assert (proc_desc != NULL);
|
|
|
|
|
|
2008-05-21 16:47:26 +02:00
|
|
|
|
info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
/* The VFP of the frame is at FRAME_REG+FRAME_OFFSET. */
|
2008-05-09 05:58:26 +02:00
|
|
|
|
vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc));
|
2003-05-30 01:02:53 +02:00
|
|
|
|
vfp += PROC_FRAME_OFFSET (info->proc_desc);
|
|
|
|
|
info->vfp = vfp;
|
|
|
|
|
|
|
|
|
|
/* Fill in the offsets for the registers which gen_mask says were saved. */
|
|
|
|
|
|
|
|
|
|
reg_position = vfp + PROC_REG_OFFSET (proc_desc);
|
|
|
|
|
mask = PROC_REG_MASK (proc_desc);
|
|
|
|
|
returnreg = PROC_PC_REG (proc_desc);
|
|
|
|
|
|
|
|
|
|
/* Note that RA is always saved first, regardless of its actual
|
|
|
|
|
register number. */
|
|
|
|
|
if (mask & (1 << returnreg))
|
|
|
|
|
{
|
2011-01-07 20:36:19 +01:00
|
|
|
|
/* Clear bit for RA so we don't save it again later. */
|
2003-05-30 01:02:53 +02:00
|
|
|
|
mask &= ~(1 << returnreg);
|
|
|
|
|
|
2008-05-21 16:47:26 +02:00
|
|
|
|
info->saved_regs[returnreg].addr = reg_position;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
reg_position += 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (ireg = 0; ireg <= 31; ++ireg)
|
|
|
|
|
if (mask & (1 << ireg))
|
|
|
|
|
{
|
2008-05-21 16:47:26 +02:00
|
|
|
|
info->saved_regs[ireg].addr = reg_position;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
reg_position += 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
reg_position = vfp + PROC_FREG_OFFSET (proc_desc);
|
|
|
|
|
mask = PROC_FREG_MASK (proc_desc);
|
|
|
|
|
|
|
|
|
|
for (ireg = 0; ireg <= 31; ++ireg)
|
|
|
|
|
if (mask & (1 << ireg))
|
|
|
|
|
{
|
2008-05-21 16:47:26 +02:00
|
|
|
|
info->saved_regs[ALPHA_FP0_REGNUM + ireg].addr = reg_position;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
reg_position += 8;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-21 16:47:26 +02:00
|
|
|
|
/* 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);
|
|
|
|
|
|
2003-05-30 01:02:53 +02:00
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Given a GDB frame, determine the address of the calling function's
|
|
|
|
|
frame. This will be used to create a new GDB frame struct. */
|
|
|
|
|
|
|
|
|
|
static void
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_this_id (struct frame_info *this_frame,
|
2003-05-30 01:02:53 +02:00
|
|
|
|
void **this_prologue_cache,
|
|
|
|
|
struct frame_id *this_id)
|
|
|
|
|
{
|
|
|
|
|
struct alpha_mdebug_unwind_cache *info
|
2008-05-09 05:58:26 +02:00
|
|
|
|
= alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
2008-05-09 05:58:26 +02:00
|
|
|
|
*this_id = frame_id_build (info->vfp, get_frame_func (this_frame));
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Retrieve the value of REGNUM in FRAME. Don't give up! */
|
|
|
|
|
|
2008-05-09 05:58:26 +02:00
|
|
|
|
static struct value *
|
|
|
|
|
alpha_mdebug_frame_prev_register (struct frame_info *this_frame,
|
|
|
|
|
void **this_prologue_cache, int regnum)
|
2003-05-30 01:02:53 +02:00
|
|
|
|
{
|
|
|
|
|
struct alpha_mdebug_unwind_cache *info
|
2008-05-09 05:58:26 +02:00
|
|
|
|
= alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
/* 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. */
|
2003-06-04 18:40:50 +02:00
|
|
|
|
if (regnum == ALPHA_PC_REGNUM)
|
2003-05-30 01:02:53 +02:00
|
|
|
|
regnum = PROC_PC_REG (info->proc_desc);
|
|
|
|
|
|
2008-05-21 16:47:26 +02:00
|
|
|
|
return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
* alpha-tdep.c (INSN_OPCODE, MEM_RA, MEM_RB, MEM_DISP, BR_RA)
(OPR_FUNCTION, OPR_HAS_IMMEDIATE, OPR_RA, OPR_RC, OPR_LIT): New macros.
(lda_opcode, stq_opcode, bne_opcode, subq_opcode, subq_function):
New constants.
(alpha_heuristic_analyze_probing_loop): New function.
(alpha_heuristic_frame_unwind_cache): In the prologue analysis, detect
and handle cases when a stack probe loop is generated.
* alpha-mdebug-tdep.c (alpha_mdebug_frameless): New function.
(alpha_mdebug_max_frame_size_exceeded): New function.
(alpha_mdebug_after_prologue): Use alpha_mdebug_frameless.
(alpha_mdebug_frame_sniffer, alpha_mdebug_frame_base_sniffer):
Return 0 when the maximum debuggable frame size has been exceeded.
2010-04-23 17:14:22 +02:00
|
|
|
|
/* Return a non-zero result if the size of the stack frame exceeds the
|
|
|
|
|
maximum debuggable frame size (512 Kbytes); zero otherwise. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
alpha_mdebug_max_frame_size_exceeded (struct mdebug_extra_func_info *proc_desc)
|
|
|
|
|
{
|
|
|
|
|
/* If frame offset is null, we can be in two cases: either the
|
|
|
|
|
function is frameless (the stack frame is null) or its
|
|
|
|
|
frame exceeds the maximum debuggable frame size (512 Kbytes). */
|
|
|
|
|
|
|
|
|
|
return (PROC_FRAME_OFFSET (proc_desc) == 0
|
|
|
|
|
&& !alpha_mdebug_frameless (proc_desc));
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-09 05:58:26 +02:00
|
|
|
|
static int
|
|
|
|
|
alpha_mdebug_frame_sniffer (const struct frame_unwind *self,
|
|
|
|
|
struct frame_info *this_frame,
|
|
|
|
|
void **this_cache)
|
2003-05-30 01:02:53 +02:00
|
|
|
|
{
|
2008-05-09 05:58:26 +02:00
|
|
|
|
CORE_ADDR pc = get_frame_address_in_block (this_frame);
|
2004-11-06 18:18:10 +01:00
|
|
|
|
struct mdebug_extra_func_info *proc_desc;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
/* 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)
|
2008-05-09 05:58:26 +02:00
|
|
|
|
return 0;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
2003-05-31 02:27:46 +02:00
|
|
|
|
/* 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))
|
2008-05-09 05:58:26 +02:00
|
|
|
|
return 0;
|
2003-05-31 02:27:46 +02:00
|
|
|
|
|
* alpha-tdep.c (INSN_OPCODE, MEM_RA, MEM_RB, MEM_DISP, BR_RA)
(OPR_FUNCTION, OPR_HAS_IMMEDIATE, OPR_RA, OPR_RC, OPR_LIT): New macros.
(lda_opcode, stq_opcode, bne_opcode, subq_opcode, subq_function):
New constants.
(alpha_heuristic_analyze_probing_loop): New function.
(alpha_heuristic_frame_unwind_cache): In the prologue analysis, detect
and handle cases when a stack probe loop is generated.
* alpha-mdebug-tdep.c (alpha_mdebug_frameless): New function.
(alpha_mdebug_max_frame_size_exceeded): New function.
(alpha_mdebug_after_prologue): Use alpha_mdebug_frameless.
(alpha_mdebug_frame_sniffer, alpha_mdebug_frame_base_sniffer):
Return 0 when the maximum debuggable frame size has been exceeded.
2010-04-23 17:14:22 +02:00
|
|
|
|
/* If the maximum debuggable frame size has been exceeded, the
|
|
|
|
|
proc desc is bogus. Fall back on the heuristic unwinder. */
|
|
|
|
|
if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2008-05-09 05:58:26 +02:00
|
|
|
|
return 1;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
2008-05-09 05:58:26 +02:00
|
|
|
|
static const struct frame_unwind alpha_mdebug_frame_unwind = {
|
|
|
|
|
NORMAL_FRAME,
|
gdb/
* frame.c (frame_unwind_register): Throw an error if unwinding the
register failed.
* get_prev_frame_1 (get_prev_frame_1): Ask the unwinder if there's
an unwind stop reason.
(frame_stop_reason_string): Handle UNWIND_UNAVAILABLE.
* frame.h (enum unwind_stop_reason) <UNWIND_OUTERMOST,
UNWIND_UNAVAILABLE>: New.
* inline-frame.c (inline_frame_unwind): Install
default_frame_unwind_stop_reason.
* frame-unwind.c: Include "exceptions.h".
(frame_unwind_find_by_frame): Swallow NOT_AVAILABLE_ERROR errors.
(default_frame_unwind_stop_reason): New.
* frame-unwind.h (frame_unwind_stop_reason_ftype): New typedef.
(default_frame_unwind_stop_reason): Declare.
(struct frame_unwind) <stop_reason>: New function pointer.
* dummy-frame.c: Install default_frame_unwind_stop_reason.
* dwarf2-frame.c: Include exceptions.h.
(struct dwarf2_frame_cache) <unavailable_retaddr>: New field.
(dwarf2_frame_cache): Swallow NOT_AVAILABLE_ERROR errors when
computing the CFA. If such an error was thrown, set
unavailable_retaddr.
(dwarf2_frame_unwind_stop_reason): New.
(dwarf2_frame_this_id): Don't build a frame id if the CFA was
unavailable.
(dwarf2_frame_unwind): Install dwarf2_frame_unwind_stop_reason.
(dwarf2_signal_frame_unwind): Ditto.
* amd64-tdep.c: Include "exceptions.h".
(struct amd64_frame_cache): New field "base_p".
(amd64_init_frame_cache): Clear it.
(amd64_frame_cache_1): New, factored out from amd64_frame_cache.
Avoid reading registers with functions that throw if the register
is not necessary to compute the frame base.
(amd64_frame_cache): Reimplement wrapping amd64_frame_cache_1, and
swallowing NOT_AVAILABLE_ERROR.
(amd64_frame_unwind_stop_reason): New.
(amd64_frame_this_id): Don't build a frame id if the frame base
was unavailable.
(amd64_frame_unwind): Install amd64_frame_unwind_stop_reason.
(amd64_sigtramp_frame_cache): Swallow NOT_AVAILABLE_ERROR, and set
base_p if the frame base was computable.
(amd64_sigtramp_frame_unwind_stop_reason): New.
(amd64_sigtramp_frame_this_id): Don't build a frame id if the
frame base was unavailable.
(amd64_sigtramp_frame_unwind): Install
amd64_sigtramp_frame_unwind_stop_reason.
(amd64_epilogue_frame_cache): Swallow NOT_AVAILABLE_ERROR, and set
base_p if the frame base was computable.
(amd64_epilogue_frame_unwind_stop_reason): New.
(amd64_epilogue_frame_this_id): Don't build a frame id if the
frame base was unavailable.
(amd64_epilogue_frame_unwind): Install
amd64_epilogue_frame_unwind_stop_reason.
* i386-tdep.c: Include "exceptions.h".
(struct i386_frame_cache): New field "base_p".
(i386_init_frame_cache): Clear it.
(i386_frame_cache_1): New, factored out from amd64_frame_cache.
Avoid reading registers with functions that throw if the register
is not necessary to compute the frame base.
(i386_frame_cache): Reimplement wrapping amd64_frame_cache_1, and
swallowing NOT_AVAILABLE_ERROR.
(i386_frame_unwind_stop_reason): New.
(i386_frame_this_id): Don't build a frame id if the frame base was
unavailable.
(i386_frame_prev_register): Handle unavailable SP.
(i386_frame_unwind): Install i386_frame_unwind_stop_reason.
(i386_epilogue_frame_cache): Swallow NOT_AVAILABLE_ERROR, and set
base_p if the frame base was computable.
(i386_epilogue_frame_unwind_stop_reason): New.
(i386_epilogue_frame_this_id): Don't build a frame id if the frame
base was unavailable.
(i386_epilogue_frame_unwind): Install
i386_epilogue_frame_unwind_stop_reason.
(i386_sigtramp_frame_cache): Swallow NOT_AVAILABLE_ERROR, and set
base_p if the frame base was computable.
(i386_sigtramp_frame_unwind_stop_reason): New.
(i386_sigtramp_frame_this_id): Don't build a frame id if the frame
base was unavailable.
(i386_sigtramp_frame_unwind): Install
i386_sigtramp_frame_unwind_stop_reason.
* sentinel-frame.c (sentinel_frame_prev_register): Use the value
type's size, not the register's.
(sentinel_frame_unwind): Install default_frame_unwind_stop_reason.
* alpha-mdebug-tdep.c (alpha_mdebug_frame_unwind): Install
default_frame_unwind_stop_reason.
* alpha-tdep.c (alpha_sigtramp_frame_unwind)
(alpha_heuristic_frame_unwind): Ditto.
* amd64obsd-tdep.c (amd64obsd_trapframe_unwind): Ditto.
* arm-tdep.c (arm_prologue_unwind, arm_stub_unwind): Ditto.
* avr-tdep.c (avr_frame_unwind): Ditto.
* cris-tdep.c (cris_sigtramp_frame_unwind, cris_frame_unwind):
Ditto.
* frv-linux-tdep.c (frv_linux_sigtramp_frame_unwind): Ditto.
* frv-tdep.c (frv_frame_unwind): Ditto.
* h8300-tdep.c (h8300_frame_unwind): Ditto.
* hppa-hpux-tdep.c (hppa_hpux_sigtramp_frame_unwind): Ditto.
* hppa-linux-tdep.c (hppa_linux_sigtramp_frame_unwind): Ditto.
* hppa-tdep.c (hppa_frame_unwind, hppa_fallback_frame_unwind)
(hppa_stub_frame_unwind): Ditto.
* i386obsd-tdep.c (i386obsd_trapframe_unwind): Ditto.
* ia64-tdep.c (ia64_frame_unwind, ia64_sigtramp_frame_unwind)
(ia64_libunwind_frame_unwind)
(ia64_libunwind_sigtramp_frame_unwind): Ditto.
* iq2000-tdep.c (iq2000_frame_unwind): Ditto.
* lm32-tdep.c (lm32_frame_unwind): Ditto.
* m32c-tdep.c (m32c_unwind): Ditto.
* m32r-linux-tdep.c (m32r_linux_sigtramp_frame_unwind): Ditto.
* m32r-tdep.c (m32r_frame_unwind): Ditto.
* m68hc11-tdep.c (m68hc11_frame_unwind): Ditto.
* m68k-tdep.c (m68k_frame_unwind): Ditto.
* m68klinux-tdep.c (m68k_linux_sigtramp_frame_unwind): Ditto.
* m88k-tdep.c (m88k_frame_unwind): Ditto.
* mep-tdep.c (mep_frame_unwind): Ditto.
* microblaze-tdep.c (microblaze_frame_unwind): Ditto.
* mips-tdep.c (mips_insn16_frame_unwind, mips_insn32_frame_unwind)
(mips_stub_frame_unwind): Ditto.
* mn10300-tdep.c (mn10300_frame_unwind): Ditto.
* moxie-tdep.c (moxie_frame_unwind): Ditto.
* mt-tdep.c (mt_frame_unwind): Ditto.
* ppc-linux-tdep.c (ppu2spu_unwind): Ditto.
* ppcobsd-tdep.c (ppcobsd_sigtramp_frame_unwind): Ditto.
* rs6000-tdep.c (rs6000_frame_unwind): Ditto.
* s390-tdep.c (s390_frame_unwind, s390_stub_frame_unwind)
(s390_sigtramp_frame_unwind): Ditto.
* score-tdep.c (score_prologue_unwind): Ditto.
* sh-tdep.c (sh_frame_unwind): Ditto.
* sh64-tdep.c (sh64_frame_unwind): Ditto.
* sparc-sol2-tdep.c (sparc32_sol2_sigtramp_frame_unwind): Ditto.
* sparc-tdep.c (sparc32_frame_unwind): Ditto.
* sparc64-sol2-tdep.c (sparc64_sol2_sigtramp_frame_unwind): Ditto.
* sparc64-tdep.c (sparc64_frame_unwind): Ditto.
* sparc64fbsd-tdep.c (sparc64fbsd_sigtramp_frame_unwind): Ditto.
* sparc64nbsd-tdep.c (sparc64nbsd_sigcontext_frame_unwind): Ditto.
* sparc64obsd-tdep.c (sparc64obsd_frame_unwind)
(sparc64obsd_trapframe_unwind): Ditto.
* sparcnbsd-tdep.c (sparc32nbsd_sigcontext_frame_unwind): Ditto.
* sparcobsd-tdep.c (sparc32obsd_sigtramp_frame_unwind): Ditto.
* spu-tdep.c (spu_frame_unwind, spu2ppu_unwind): Ditto.
* v850-tdep.c (v850_frame_unwind): Ditto.
* vax-tdep.c (vax_frame_unwind): Ditto.
* vaxobsd-tdep.c (vaxobsd_sigtramp_frame_unwind): Ditto.
* xstormy16-tdep.c (frame_unwind xstormy16_frame_unwind): Ditto.
* xtensa-tdep.c (xtensa_unwind): Ditto.
2011-03-18 19:52:32 +01:00
|
|
|
|
default_frame_unwind_stop_reason,
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_this_id,
|
|
|
|
|
alpha_mdebug_frame_prev_register,
|
|
|
|
|
NULL,
|
|
|
|
|
alpha_mdebug_frame_sniffer
|
|
|
|
|
};
|
|
|
|
|
|
2003-05-30 01:02:53 +02:00
|
|
|
|
static CORE_ADDR
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_base_address (struct frame_info *this_frame,
|
2003-05-30 01:02:53 +02:00
|
|
|
|
void **this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
struct alpha_mdebug_unwind_cache *info
|
2008-05-09 05:58:26 +02:00
|
|
|
|
= alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
2003-05-31 02:27:46 +02:00
|
|
|
|
return info->vfp;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_locals_address (struct frame_info *this_frame,
|
2003-05-30 01:02:53 +02:00
|
|
|
|
void **this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
struct alpha_mdebug_unwind_cache *info
|
2008-05-09 05:58:26 +02:00
|
|
|
|
= alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
2003-05-31 02:27:46 +02:00
|
|
|
|
return info->vfp - PROC_LOCALOFF (info->proc_desc);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_args_address (struct frame_info *this_frame,
|
2003-05-30 01:02:53 +02:00
|
|
|
|
void **this_prologue_cache)
|
|
|
|
|
{
|
|
|
|
|
struct alpha_mdebug_unwind_cache *info
|
2008-05-09 05:58:26 +02:00
|
|
|
|
= alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
2003-05-31 02:27:46 +02:00
|
|
|
|
return info->vfp - ALPHA_NUM_ARG_REGS * 8;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct frame_base alpha_mdebug_frame_base = {
|
|
|
|
|
&alpha_mdebug_frame_unwind,
|
|
|
|
|
alpha_mdebug_frame_base_address,
|
|
|
|
|
alpha_mdebug_frame_locals_address,
|
|
|
|
|
alpha_mdebug_frame_args_address
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct frame_base *
|
2008-05-09 05:58:26 +02:00
|
|
|
|
alpha_mdebug_frame_base_sniffer (struct frame_info *this_frame)
|
2003-05-30 01:02:53 +02:00
|
|
|
|
{
|
2008-05-09 05:58:26 +02:00
|
|
|
|
CORE_ADDR pc = get_frame_address_in_block (this_frame);
|
2004-11-06 18:18:10 +01:00
|
|
|
|
struct mdebug_extra_func_info *proc_desc;
|
2003-05-30 01:02:53 +02:00
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
* alpha-tdep.c (INSN_OPCODE, MEM_RA, MEM_RB, MEM_DISP, BR_RA)
(OPR_FUNCTION, OPR_HAS_IMMEDIATE, OPR_RA, OPR_RC, OPR_LIT): New macros.
(lda_opcode, stq_opcode, bne_opcode, subq_opcode, subq_function):
New constants.
(alpha_heuristic_analyze_probing_loop): New function.
(alpha_heuristic_frame_unwind_cache): In the prologue analysis, detect
and handle cases when a stack probe loop is generated.
* alpha-mdebug-tdep.c (alpha_mdebug_frameless): New function.
(alpha_mdebug_max_frame_size_exceeded): New function.
(alpha_mdebug_after_prologue): Use alpha_mdebug_frameless.
(alpha_mdebug_frame_sniffer, alpha_mdebug_frame_base_sniffer):
Return 0 when the maximum debuggable frame size has been exceeded.
2010-04-23 17:14:22 +02:00
|
|
|
|
/* If the maximum debuggable frame size has been exceeded, the
|
|
|
|
|
proc desc is bogus. Fall back on the heuristic unwinder. */
|
|
|
|
|
if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2003-05-30 01:02:53 +02:00
|
|
|
|
return &alpha_mdebug_frame_base;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
|
|
|
|
|
{
|
|
|
|
|
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
|
|
|
|
|
2008-05-09 05:58:26 +02:00
|
|
|
|
frame_unwind_append_unwinder (gdbarch, &alpha_mdebug_frame_unwind);
|
2003-07-17 00:29:13 +02:00
|
|
|
|
frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);
|
2003-05-30 01:02:53 +02:00
|
|
|
|
}
|