+2015-08-25 Pierre-Marie de Rodat <derodat@adacore.com>
+
+ * ada-lang.c (ada_read_var_value): Add a var_block argument
+ and pass it to default_read_var_value.
+ * block.c (block_static_link): New accessor.
+ * block.h (block_static_link): Declare it.
+ * buildsym.c (finish_block_internal): Add a static_link
+ argument. If there is a static link, associate it to the new
+ block.
+ (finish_block): Add a static link argument and pass it to
+ finish_block_internal.
+ (end_symtab_get_static_block): Update calls to finish_block and
+ to finish_block_internal.
+ (end_symtab_with_blockvector): Update call to
+ finish_block_internal.
+ * buildsym.h: Forward-declare struct dynamic_prop.
+ (struct context_stack): Add a static_link field.
+ (finish_block): Add a static link argument.
+ * c-exp.y: Remove an obsolete comment (evaluation of variables
+ already start from the selected frame, and now they climb *up*
+ the call stack) and propagate the block information to the
+ produced expression.
+ * d-exp.y: Likewise.
+ * f-exp.y: Likewise.
+ * go-exp.y: Likewise.
+ * jv-exp.y: Likewise.
+ * m2-exp.y: Likewise.
+ * p-exp.y: Likewise.
+ * coffread.c (coff_symtab_read): Update calls to finish_block.
+ * dbxread.c (process_one_symbol): Likewise.
+ * xcoffread.c (read_xcoff_symtab): Likewise.
+ * compile/compile-c-symbols.c (convert_one_symbol): Promote the
+ "sym" parameter to struct block_symbol, update its uses and pass
+ its block to calls to read_var_value.
+ (convert_symbol_sym): Update the calls to convert_one_symbol.
+ * compile/compile-loc2c.c (do_compile_dwarf_expr_to_c): Update
+ call to read_var_value.
+ * dwarf2loc.c (block_op_get_frame_base): New.
+ (dwarf2_block_frame_base_locexpr_funcs): Implement the
+ get_frame_base method.
+ (dwarf2_block_frame_base_loclist_funcs): Likewise.
+ (dwarf2locexpr_baton_eval): Add a frame argument and use it
+ instead of the selected frame in order to evaluate the
+ expression.
+ (dwarf2_evaluate_property): Add a frame argument. Update call
+ to dwarf2_locexpr_baton_eval to provide a frame in available and
+ to handle the absence of address stack.
+ * dwarf2loc.h (dwarf2_evaluate_property): Add a frame argument.
+ * dwarf2read.c (attr_to_dynamic_prop): Add a forward
+ declaration.
+ (read_func_scope): Record any available static link description.
+ Update call to finish_block.
+ (read_lexical_block_scope): Update call to finish_block.
+ * findvar.c (follow_static_link): New.
+ (get_hosting_frame): New.
+ (default_read_var_value): Add a var_block argument. Use
+ get_hosting_frame to handle non-local references.
+ (read_var_value): Add a var_block argument and pass it to the
+ LA_READ_VAR_VALUE method.
+ * gdbtypes.c (resolve_dynamic_range): Update calls to
+ dwarf2_evaluate_property.
+ (resolve_dynamic_type_internal): Likewise.
+ * guile/scm-frame.c (gdbscm_frame_read_var): Update call to
+ read_var_value, passing it the block coming from symbol lookup.
+ * guile/scm-symbol.c (gdbscm_symbol_value): Update call to
+ read_var_value (TODO).
+ * infcmd.c (finish_command_continuation): Update call to
+ read_var_value, passing it the block coming from symbol lookup.
+ * infrun.c (insert_exception_resume_breakpoint): Likewise.
+ * language.h (struct language_defn): Add a var_block argument to
+ the LA_READ_VAR_VALUE method.
+ * objfiles.c (struct static_link_htab_entry): New.
+ (static_link_htab_entry_hash): New.
+ (static_link_htab_entry_eq): New.
+ (objfile_register_static_link): New.
+ (objfile_lookup_static_link): New.
+ (free_objfile): Free the STATIC_LINKS hashed map if needed.
+ * objfiles.h: Include hashtab.h.
+ (struct objfile): Add a static_links field.
+ (objfile_register_static_link): New.
+ (objfile_lookup_static_link): New.
+ * printcmd.c (print_variable_and_value): Update call to
+ read_var_value.
+ * python/py-finishbreakpoint.c (bpfinishpy_init): Likewise.
+ * python/py-frame.c (frapy_read_var): Update call to
+ read_var_value, passing it the block coming from symbol lookup.
+ * python/py-framefilter.c (extract_sym): Add a sym_block
+ parameter and set the pointed value to NULL (TODO).
+ (enumerate_args): Update call to extract_sym.
+ (enumerate_locals): Update calls to extract_sym and to
+ read_var_value.
+ * python/py-symbol.c (sympy_value): Update call to
+ read_var_value (TODO).
+ * stack.c (read_frame_local): Update call to read_var_value.
+ (read_frame_arg): Likewise.
+ (return_command): Likewise.
+ * symtab.h (struct symbol_block_ops): Add a get_frame_base
+ method.
+ (struct symbol): Add a block field.
+ (SYMBOL_BLOCK): New accessor.
+ * valops.c (value_of_variable): Remove frame/block handling and
+ pass the block argument to read_var_value, which does this job
+ now.
+ (value_struct_elt_for_reference): Update calls to
+ read_var_value.
+ (value_of_this): Pass the block found to read_var_value.
+ * value.h (read_var_value): Add a var_block argument.
+ (default_read_var_value): Likewise.
+
2015-08-25 Yao Qi <yao.qi@linaro.org>
* aarch64-linux-nat.c (aarch64_linux_new_thread): Move it to ...
/* Implement the "la_read_var_value" language_defn method for Ada. */
static struct value *
-ada_read_var_value (struct symbol *var, struct frame_info *frame)
+ada_read_var_value (struct symbol *var, const struct block *var_block,
+ struct frame_info *frame)
{
const struct block *frame_block = NULL;
struct symbol *renaming_sym = NULL;
/* This is a typical case where we expect the default_read_var_value
function to work. */
- return default_read_var_value (var, frame);
+ return default_read_var_value (var, var_block, frame);
}
const struct language_defn ada_language_defn = {
gb->compunit_symtab = cu;
}
+/* See block.h. */
+
+struct dynamic_prop *
+block_static_link (const struct block *block)
+{
+ struct objfile *objfile = block_objfile (block);
+
+ /* Only objfile-owned blocks that materialize top function scopes can have
+ static links. */
+ if (objfile == NULL || BLOCK_FUNCTION (block) == NULL)
+ return NULL;
+
+ return (struct dynamic_prop *) objfile_lookup_static_link (objfile, block);
+}
+
/* Return the compunit of the global block. */
static struct compunit_symtab *
extern void set_block_compunit_symtab (struct block *,
struct compunit_symtab *);
+/* Return a property to evaluate the static link associated to BLOCK.
+
+ In the context of nested functions (available in Pascal, Ada and GNU C, for
+ instance), a static link (as in DWARF's DW_AT_static_link attribute) for a
+ function is a way to get the frame corresponding to the enclosing function.
+
+ Note that only objfile-owned and function-level blocks can have a static
+ link. Return NULL if there is no such property. */
+
+extern struct dynamic_prop *block_static_link (const struct block *block);
+
/* A block iterator. This structure should be treated as though it
were opaque; it is only defined here because we want to support
stack allocation of iterators. */
file). Put the block on the list of pending blocks. */
static struct block *
-finish_block_internal (struct symbol *symbol, struct pending **listhead,
+finish_block_internal (struct symbol *symbol,
+ struct pending **listhead,
struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
CORE_ADDR start, CORE_ADDR end,
int is_global, int expandable)
{
BLOCK_FUNCTION (block) = NULL;
}
+ if (static_link != NULL)
+ objfile_register_static_link (objfile, block, static_link);
+
/* Now "free" the links of the list, and empty the list. */
for (next = *listhead; next; next = next1)
}
struct block *
-finish_block (struct symbol *symbol, struct pending **listhead,
+finish_block (struct symbol *symbol,
+ struct pending **listhead,
struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
CORE_ADDR start, CORE_ADDR end)
{
- return finish_block_internal (symbol, listhead, old_blocks,
+ return finish_block_internal (symbol, listhead, old_blocks, static_link,
start, end, 0, 0);
}
struct context_stack *cstk = pop_context ();
/* Make a block for the local symbols within. */
- finish_block (cstk->name, &local_symbols, cstk->old_blocks,
+ finish_block (cstk->name, &local_symbols, cstk->old_blocks, NULL,
cstk->start_addr, end_addr);
if (context_stack_depth > 0)
else
{
/* Define the STATIC_BLOCK. */
- return finish_block_internal (NULL, &file_symbols, NULL,
+ return finish_block_internal (NULL, &file_symbols, NULL, NULL,
last_source_start_addr, end_addr,
0, expandable);
}
end_addr = BLOCK_END (static_block);
/* Create the GLOBAL_BLOCK and build the blockvector. */
- finish_block_internal (NULL, &global_symbols, NULL,
+ finish_block_internal (NULL, &global_symbols, NULL, NULL,
last_source_start_addr, end_addr,
1, expandable);
blockvector = make_blockvector ();
struct block;
struct pending_block;
+struct dynamic_prop;
+
#ifndef EXTERN
#define EXTERN extern
#endif
struct symbol *name;
+ /* Expression that computes the frame base of the lexically enclosing
+ function, if any. NULL otherwise. */
+
+ struct dynamic_prop *static_link;
+
/* PC where this context starts */
CORE_ADDR start_addr;
char *name, int length);
extern struct block *finish_block (struct symbol *symbol,
- struct pending **listhead,
- struct pending_block *old_blocks,
- CORE_ADDR start, CORE_ADDR end);
+ struct pending **listhead,
+ struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
+ CORE_ADDR start,
+ CORE_ADDR end);
extern void record_block_range (struct block *,
CORE_ADDR start, CORE_ADDR end_inclusive);
}
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* We want to use the selected frame, not
- another more inner frame which happens to
- be in the same block. */
- write_exp_elt_block (pstate, NULL);
+ write_exp_elt_block (pstate, sym.block);
write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
enter_linenos (fcn_line_ptr, fcn_first_line,
fcn_last_line, objfile);
- finish_block (newobj->name, &local_symbols,
- newobj->old_blocks, newobj->start_addr,
+ finish_block (newobj->name, &local_symbols, newobj->old_blocks,
+ NULL, newobj->start_addr,
fcn_cs_saved.c_value
+ fcn_aux_saved.x_sym.x_misc.x_fsize
+ ANOFFSET (objfile->section_offsets,
cs->c_value + ANOFFSET (objfile->section_offsets,
SECT_OFF_TEXT (objfile));
/* Make a block for the local symbols within. */
- finish_block (0, &local_symbols, newobj->old_blocks,
+ finish_block (0, &local_symbols, newobj->old_blocks, NULL,
newobj->start_addr, tmpaddr);
}
/* Now pop locals of block just finished. */
static void
convert_one_symbol (struct compile_c_instance *context,
- struct symbol *sym,
+ struct block_symbol sym,
int is_global,
int is_local)
{
gcc_type sym_type;
- const char *filename = symbol_symtab (sym)->filename;
- unsigned short line = SYMBOL_LINE (sym);
+ const char *filename = symbol_symtab (sym.symbol)->filename;
+ unsigned short line = SYMBOL_LINE (sym.symbol);
- error_symbol_once (context, sym);
+ error_symbol_once (context, sym.symbol);
- if (SYMBOL_CLASS (sym) == LOC_LABEL)
+ if (SYMBOL_CLASS (sym.symbol) == LOC_LABEL)
sym_type = 0;
else
- sym_type = convert_type (context, SYMBOL_TYPE (sym));
+ sym_type = convert_type (context, SYMBOL_TYPE (sym.symbol));
- if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN)
+ if (SYMBOL_DOMAIN (sym.symbol) == STRUCT_DOMAIN)
{
/* Binding a tag, so we don't need to build a decl. */
C_CTX (context)->c_ops->tagbind (C_CTX (context),
- SYMBOL_NATURAL_NAME (sym),
+ SYMBOL_NATURAL_NAME (sym.symbol),
sym_type, filename, line);
}
else
CORE_ADDR addr = 0;
char *symbol_name = NULL;
- switch (SYMBOL_CLASS (sym))
+ switch (SYMBOL_CLASS (sym.symbol))
{
case LOC_TYPEDEF:
kind = GCC_C_SYMBOL_TYPEDEF;
case LOC_LABEL:
kind = GCC_C_SYMBOL_LABEL;
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = SYMBOL_VALUE_ADDRESS (sym.symbol);
break;
case LOC_BLOCK:
kind = GCC_C_SYMBOL_FUNCTION;
- addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
+ addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
+ if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym.symbol)))
addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
break;
case LOC_CONST:
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM)
+ if (TYPE_CODE (SYMBOL_TYPE (sym.symbol)) == TYPE_CODE_ENUM)
{
/* Already handled by convert_enum. */
return;
}
- C_CTX (context)->c_ops->build_constant (C_CTX (context), sym_type,
- SYMBOL_NATURAL_NAME (sym),
- SYMBOL_VALUE (sym),
- filename, line);
+ C_CTX (context)->c_ops->build_constant
+ (C_CTX (context),
+ sym_type, SYMBOL_NATURAL_NAME (sym.symbol),
+ SYMBOL_VALUE (sym.symbol),
+ filename, line);
return;
case LOC_CONST_BYTES:
error (_("Unsupported LOC_CONST_BYTES for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_UNDEF:
internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_COMMON_BLOCK:
error (_("Fortran common block is unsupported for compilation "
"evaluaton of symbol \"%s\"."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_OPTIMIZED_OUT:
error (_("Symbol \"%s\" cannot be used for compilation evaluation "
"as it is optimized out."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_COMPUTED:
if (is_local)
warning (_("Symbol \"%s\" is thread-local and currently can only "
"be referenced from the current thread in "
"compiled code."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
/* FALLTHROUGH */
case LOC_UNRESOLVED:
/* 'symbol_name' cannot be used here as that one is used only for
struct value *val;
struct frame_info *frame = NULL;
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
frame = get_selected_frame (NULL);
if (frame == NULL)
error (_("Symbol \"%s\" cannot be used because "
"there is no selected frame"),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
}
- val = read_var_value (sym, frame);
+ val = read_var_value (sym.symbol, sym.block, frame);
if (VALUE_LVAL (val) != lval_memory)
error (_("Symbol \"%s\" cannot be used for compilation "
"evaluation as its address has not been found."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
kind = GCC_C_SYMBOL_VARIABLE;
addr = value_address (val);
case LOC_LOCAL:
substitution:
kind = GCC_C_SYMBOL_VARIABLE;
- symbol_name = symbol_substitution_name (sym);
+ symbol_name = symbol_substitution_name (sym.symbol);
break;
case LOC_STATIC:
kind = GCC_C_SYMBOL_VARIABLE;
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = SYMBOL_VALUE_ADDRESS (sym.symbol);
break;
case LOC_FINAL_VALUE:
if (context->base.scope != COMPILE_I_RAW_SCOPE
|| symbol_name == NULL)
{
- decl = C_CTX (context)->c_ops->build_decl (C_CTX (context),
- SYMBOL_NATURAL_NAME (sym),
- kind,
- sym_type,
- symbol_name, addr,
- filename, line);
+ decl = C_CTX (context)->c_ops->build_decl
+ (C_CTX (context),
+ SYMBOL_NATURAL_NAME (sym.symbol),
+ kind,
+ sym_type,
+ symbol_name, addr,
+ filename, line);
C_CTX (context)->c_ops->bind (C_CTX (context), decl, is_global);
}
fprintf_unfiltered (gdb_stdlog,
"gcc_convert_symbol \"%s\": global symbol\n",
identifier);
- convert_one_symbol (context, global_sym.symbol, 1, 0);
+ convert_one_symbol (context, global_sym, 1, 0);
}
}
fprintf_unfiltered (gdb_stdlog,
"gcc_convert_symbol \"%s\": local symbol\n",
identifier);
- convert_one_symbol (context, sym.symbol, 0, is_local_symbol);
+ convert_one_symbol (context, sym, 0, is_local_symbol);
}
/* Convert a minimal symbol to its gcc form. CONTEXT is the compiler
"there is no selected frame"),
SYMBOL_PRINT_NAME (sym));
- val = read_var_value (sym, frame);
+ val = read_var_value (sym, NULL, frame);
if (VALUE_LVAL (val) != lval_memory)
error (_("Symbol \"%s\" cannot be used for compilation evaluation "
"as its address has not been found."),
/* Make a block for the local symbols within. */
block = finish_block (newobj->name, &local_symbols,
- newobj->old_blocks,
+ newobj->old_blocks, NULL,
newobj->start_addr, newobj->start_addr + valu);
/* For C++, set the block's scope. */
newobj->start_addr = valu;
}
/* Make a block for the local symbols within. */
- finish_block (0, &local_symbols, newobj->old_blocks,
+ finish_block (0, &local_symbols, newobj->old_blocks, NULL,
newobj->start_addr, valu);
}
}
newobj = pop_context ();
/* Make a block for the local symbols within. */
block = finish_block (newobj->name, &local_symbols,
- newobj->old_blocks, newobj->start_addr,
- valu);
+ newobj->old_blocks, NULL,
+ newobj->start_addr, valu);
/* For C++, set the block's scope. */
if (SYMBOL_LANGUAGE (newobj->name) == language_cplus)
*start = symbaton->data;
}
+/* Implement the struct symbol_block_ops::get_frame_base method. */
+
+static CORE_ADDR
+block_op_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
+{
+ struct gdbarch *gdbarch;
+ struct type *type;
+ struct dwarf2_locexpr_baton *dlbaton;
+ const gdb_byte *start;
+ size_t length;
+ struct value *result;
+
+ /* If this method is called, then FRAMEFUNC is supposed to be a DWARF block.
+ Thus, it's supposed to provide the find_frame_base_location method as
+ well. */
+ gdb_assert (SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location != NULL);
+
+ gdbarch = get_frame_arch (frame);
+ type = builtin_type (gdbarch)->builtin_data_ptr;
+ dlbaton = SYMBOL_LOCATION_BATON (framefunc);
+
+ SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location
+ (framefunc, get_frame_pc (frame), &start, &length);
+ result = dwarf2_evaluate_loc_desc (type, frame, start, length,
+ dlbaton->per_cu);
+
+ /* The DW_AT_frame_base attribute contains a location description which
+ computes the base address itself. However, the call to
+ dwarf2_evaluate_loc_desc returns a value representing a variable at
+ that address. The frame base address is thus this variable's
+ address. */
+ return value_address (result);
+}
+
/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
function uses DWARF expression for its DW_AT_frame_base. */
const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
{
- locexpr_find_frame_base_location
+ locexpr_find_frame_base_location,
+ block_op_get_frame_base
};
/* Implement find_frame_base_location method for LOC_BLOCK functions using
const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
{
- loclist_find_frame_base_location
+ loclist_find_frame_base_location,
+ block_op_get_frame_base
};
/* See dwarf2loc.h. */
}
/* Evaluates a dwarf expression and stores the result in VAL, expecting
- that the dwarf expression only produces a single CORE_ADDR. ADDR is a
- context (location of a variable) and might be needed to evaluate the
- location expression.
+ that the dwarf expression only produces a single CORE_ADDR. FRAME is the
+ frame in which the expression is evaluated. ADDR is a context (location of
+ a variable) and might be needed to evaluate the location expression.
Returns 1 on success, 0 otherwise. */
static int
dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
+ struct frame_info *frame,
CORE_ADDR addr,
CORE_ADDR *valp)
{
ctx = new_dwarf_expr_context ();
cleanup = make_cleanup_free_dwarf_expr_context (ctx);
- baton.frame = get_selected_frame (NULL);
+ baton.frame = frame;
baton.per_cu = dlbaton->per_cu;
baton.obj_address = addr;
int
dwarf2_evaluate_property (const struct dynamic_prop *prop,
+ struct frame_info *frame,
struct property_addr_info *addr_stack,
CORE_ADDR *value)
{
if (prop == NULL)
return 0;
+ if (frame == NULL && has_stack_frames ())
+ frame = get_selected_frame (NULL);
+
switch (prop->kind)
{
case PROP_LOCEXPR:
{
const struct dwarf2_property_baton *baton = prop->data.baton;
- if (dwarf2_locexpr_baton_eval (&baton->locexpr, addr_stack->addr,
+ if (dwarf2_locexpr_baton_eval (&baton->locexpr, frame,
+ addr_stack ? addr_stack->addr : 0,
value))
{
if (baton->referenced_type)
case PROP_LOCLIST:
{
struct dwarf2_property_baton *baton = prop->data.baton;
- struct frame_info *frame = get_selected_frame (NULL);
CORE_ADDR pc = get_frame_address_in_block (frame);
const gdb_byte *data;
struct value *val;
struct property_addr_info *next;
};
-/* Converts a dynamic property into a static one. ADDR_STACK is the stack
- of addresses that might be needed to evaluate the property.
+/* Converts a dynamic property into a static one. FRAME is the frame in which
+ the property is evaluated; if NULL, the selected frame (if any) is used
+ instead.
+
+ ADDR_STACK is the stack of addresses that might be needed to evaluate the
+ property. When evaluating a property that is not related to a type, it can
+ be NULL.
+
Returns 1 if PROP could be converted and the static value is passed back
into VALUE, otherwise returns 0. */
int dwarf2_evaluate_property (const struct dynamic_prop *prop,
+ struct frame_info *frame,
struct property_addr_info *addr_stack,
CORE_ADDR *value);
static void read_signatured_type (struct signatured_type *);
+static int attr_to_dynamic_prop (const struct attribute *attr,
+ struct die_info *die, struct dwarf2_cu *cu,
+ struct dynamic_prop *prop);
+
/* memory allocation interface */
static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
if (attr)
dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
+ /* If there is a location for the static link, record it. */
+ newobj->static_link = NULL;
+ attr = dwarf2_attr (die, DW_AT_static_link, cu);
+ if (attr)
+ {
+ newobj->static_link = obstack_alloc (&objfile->objfile_obstack,
+ sizeof (*newobj->static_link));
+ attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
+ }
+
cu->list_in_scope = &local_symbols;
if (die->child != NULL)
newobj = pop_context ();
/* Make a block for the local symbols within. */
block = finish_block (newobj->name, &local_symbols, newobj->old_blocks,
- lowpc, highpc);
+ newobj->static_link, lowpc, highpc);
/* For C++, set the block's scope. */
if ((cu->language == language_cplus
if (local_symbols != NULL || local_using_directives != NULL)
{
struct block *block
- = finish_block (0, &local_symbols, newobj->old_blocks,
+ = finish_block (0, &local_symbols, newobj->old_blocks, NULL,
newobj->start_addr, highpc);
/* Note that recording ranges after traversing children, as we
innermost_block = sym.block;
}
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* We want to use the selected frame, not
- another more inner frame which happens to
- be in the same block. */
- write_exp_elt_block (pstate, NULL);
+ write_exp_elt_block (pstate, sym.block);
write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
break;
#include "block.h"
#include "objfiles.h"
#include "language.h"
+#include "dwarf2loc.h"
/* Basic byte-swapping routines. All 'extract' functions return a
host-format integer from a target-format integer at ADDR which is
return (data->result.minsym != NULL);
}
+/* Given static link expression and the frame it lives in, look for the frame
+ the static links points to and return it. Return NULL if we could not find
+ such a frame. */
+
+static struct frame_info *
+follow_static_link (struct frame_info *frame,
+ const struct dynamic_prop *static_link)
+{
+ CORE_ADDR upper_frame_base;
+
+ if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
+ return NULL;
+
+ /* Now climb up the stack frame until we reach the frame we are interested
+ in. */
+ for (; frame != NULL; frame = get_prev_frame (frame))
+ {
+ struct symbol *framefunc = get_frame_function (frame);
+
+ /* Stacks can be quite deep: give the user a chance to stop this. */
+ QUIT;
+
+ /* If we don't know how to compute FRAME's base address, don't give up:
+ maybe the frame we are looking for is upper in the stace frame. */
+ if (framefunc != NULL
+ && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
+ && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
+ == upper_frame_base))
+ break;
+ }
+
+ return frame;
+}
+
+/* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
+ rules, look for the frame that is actually hosting VAR and return it. If,
+ for some reason, we found no such frame, return NULL.
+
+ This kind of computation is necessary to correctly handle lexically nested
+ functions.
+
+ Note that in some cases, we know what scope VAR comes from but we cannot
+ reach the specific frame that hosts the instance of VAR we are looking for.
+ For backward compatibility purposes (with old compilers), we then look for
+ the first frame that can host it. */
+
+static struct frame_info *
+get_hosting_frame (struct symbol *var, const struct block *var_block,
+ struct frame_info *frame)
+{
+ const struct block *frame_block = NULL;
+
+ if (!symbol_read_needs_frame (var))
+ return NULL;
+
+ /* Some symbols for local variables have no block: this happens when they are
+ not produced by a debug information reader, for instance when GDB creates
+ synthetic symbols. Without block information, we must assume they are
+ local to FRAME. In this case, there is nothing to do. */
+ else if (var_block == NULL)
+ return frame;
+
+ /* We currently assume that all symbols with a location list need a frame.
+ This is true in practice because selecting the location description
+ requires to compute the CFA, hence requires a frame. However we have
+ tests that embed global/static symbols with null location lists.
+ We want to get <optimized out> instead of <frame required> when evaluating
+ them so return a frame instead of raising an error. */
+ else if (var_block == block_global_block (var_block)
+ || var_block == block_static_block (var_block))
+ return frame;
+
+ /* We have to handle the "my_func::my_local_var" notation. This requires us
+ to look for upper frames when we find no block for the current frame: here
+ and below, handle when frame_block == NULL. */
+ if (frame != NULL)
+ frame_block = get_frame_block (frame, NULL);
+
+ /* Climb up the call stack until reaching the frame we are looking for. */
+ while (frame != NULL && frame_block != var_block)
+ {
+ /* Stacks can be quite deep: give the user a chance to stop this. */
+ QUIT;
+
+ if (frame_block == NULL)
+ {
+ frame = get_prev_frame (frame);
+ if (frame == NULL)
+ break;
+ frame_block = get_frame_block (frame, NULL);
+ }
+
+ /* If we failed to find the proper frame, fallback to the heuristic
+ method below. */
+ else if (frame_block == block_global_block (frame_block))
+ {
+ frame = NULL;
+ break;
+ }
+
+ /* Assuming we have a block for this frame: if we are at the function
+ level, the immediate upper lexical block is in an outer function:
+ follow the static link. */
+ else if (BLOCK_FUNCTION (frame_block))
+ {
+ const struct dynamic_prop *static_link
+ = block_static_link (frame_block);
+ int could_climb_up = 0;
+
+ if (static_link != NULL)
+ {
+ frame = follow_static_link (frame, static_link);
+ if (frame != NULL)
+ {
+ frame_block = get_frame_block (frame, NULL);
+ could_climb_up = frame_block != NULL;
+ }
+ }
+ if (!could_climb_up)
+ {
+ frame = NULL;
+ break;
+ }
+ }
+
+ else
+ /* We must be in some function nested lexical block. Just get the
+ outer block: both must share the same frame. */
+ frame_block = BLOCK_SUPERBLOCK (frame_block);
+ }
+
+ /* Old compilers may not provide a static link, or they may provide an
+ invalid one. For such cases, fallback on the old way to evaluate
+ non-local references: just climb up the call stack and pick the first
+ frame that contains the variable we are looking for. */
+ if (frame == NULL)
+ {
+ frame = block_innermost_frame (var_block);
+ if (frame == NULL)
+ {
+ if (BLOCK_FUNCTION (var_block)
+ && !block_inlined_p (var_block)
+ && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
+ error (_("No frame is currently executing in block %s."),
+ SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
+ else
+ error (_("No frame is currently executing in specified"
+ " block"));
+ }
+ }
+
+ return frame;
+}
+
/* A default implementation for the "la_read_var_value" hook in
the language vector which should work in most situations. */
struct value *
-default_read_var_value (struct symbol *var, struct frame_info *frame)
+default_read_var_value (struct symbol *var, const struct block *var_block,
+ struct frame_info *frame)
{
struct value *v;
struct type *type = SYMBOL_TYPE (var);
check_typedef (type);
if (symbol_read_needs_frame (var))
- gdb_assert (frame);
+ gdb_assert (frame != NULL);
+
+ if (frame != NULL)
+ frame = get_hosting_frame (var, var_block, frame);
if (SYMBOL_COMPUTED_OPS (var) != NULL)
return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
/* Calls VAR's language la_read_var_value hook with the given arguments. */
struct value *
-read_var_value (struct symbol *var, struct frame_info *frame)
+read_var_value (struct symbol *var, const struct block *var_block,
+ struct frame_info *frame)
{
const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
gdb_assert (lang != NULL);
gdb_assert (lang->la_read_var_value != NULL);
- return lang->la_read_var_value (var, frame);
+ return lang->la_read_var_value (var, var_block, frame);
}
/* Install default attributes for register values. */
gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
prop = &TYPE_RANGE_DATA (dyn_range_type)->low;
- if (dwarf2_evaluate_property (prop, addr_stack, &value))
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
low_bound.kind = PROP_CONST;
low_bound.data.const_val = value;
}
prop = &TYPE_RANGE_DATA (dyn_range_type)->high;
- if (dwarf2_evaluate_property (prop, addr_stack, &value))
+ if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
high_bound.kind = PROP_CONST;
high_bound.data.const_val = value;
/* Resolve data_location attribute. */
prop = TYPE_DATA_LOCATION (resolved_type);
- if (prop != NULL && dwarf2_evaluate_property (prop, addr_stack, &value))
+ if (prop != NULL
+ && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
{
TYPE_DYN_PROP_ADDR (prop) = value;
TYPE_DYN_PROP_KIND (prop) = PROP_CONST;
}
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* We want to use the selected frame, not
- another more inner frame which happens to
- be in the same block. */
- write_exp_elt_block (pstate, NULL);
+ write_exp_elt_block (pstate, sym.block);
write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
SCM block_scm = SCM_UNDEFINED;
struct frame_info *frame = NULL;
struct symbol *var = NULL;
+ const struct block *block = NULL;
struct value *value = NULL;
f_smob = frscm_get_frame_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
TRY
{
+ struct block_symbol lookup_sym;
+
if (block == NULL)
block = get_frame_block (frame, NULL);
- var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL).symbol;
+ lookup_sym = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
+ var = lookup_sym.symbol;
+ block = lookup_sym.block;
}
CATCH (ex, RETURN_MASK_ALL)
{
TRY
{
- value = read_var_value (var, frame);
+ value = read_var_value (var, block, frame);
}
CATCH (except, RETURN_MASK_ALL)
{
if (symbol_read_needs_frame (symbol) && frame_info == NULL)
error (_("Symbol requires a frame to compute its value"));
- value = read_var_value (symbol, frame_info);
+ /* TODO: currently, we have no way to recover the block in which SYMBOL
+ was found, so we have no block to pass to read_var_value. This will
+ yield an incorrect value when symbol is not local to FRAME_INFO (this
+ can happen with nested functions). */
+ value = read_var_value (symbol, NULL, frame_info);
}
CATCH (except, RETURN_MASK_ALL)
{
{
struct value *func;
- func = read_var_value (a->function, get_current_frame ());
+ func = read_var_value (a->function, NULL, get_current_frame ());
TRY
{
/* print_return_value can throw an exception in some
{
TRY
{
- struct symbol *vsym;
+ struct block_symbol vsym;
struct value *value;
CORE_ADDR handler;
struct breakpoint *bp;
- vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN,
- NULL).symbol;
- value = read_var_value (vsym, frame);
+ vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL);
+ value = read_var_value (vsym.symbol, vsym.block, frame);
/* If the value was optimized out, revert to the old behavior. */
if (! value_optimized_out (value))
{
}
write_exp_elt_opcode (par_state, OP_VAR_VALUE);
- /* We want to use the selected frame, not another more inner frame
- which happens to be in the same block. */
- write_exp_elt_block (par_state, NULL);
+ write_exp_elt_block (par_state, sym.block);
write_exp_elt_sym (par_state, sym.symbol);
write_exp_elt_opcode (par_state, OP_VAR_VALUE);
return 1;
void (*la_value_print) (struct value *, struct ui_file *,
const struct value_print_options *);
- /* Given a symbol VAR, and a stack frame id FRAME, read the value
- of the variable an return (pointer to a) struct value containing
- the value.
+ /* Given a symbol VAR, the corresponding block VAR_BLOCK (if any) and a
+ stack frame id FRAME, read the value of the variable and return (pointer
+ to a) struct value containing the value.
+
+ VAR_BLOCK is needed if there's a possibility for VAR to be outside
+ FRAME. This is what happens if FRAME correspond to a nested function
+ and VAR is defined in the outer function. If callers know that VAR is
+ located in FRAME or is global/static, NULL can be passed as VAR_BLOCK.
Throw an error if the variable cannot be found. */
struct value *(*la_read_var_value) (struct symbol *var,
+ const struct block *var_block,
struct frame_info *frame);
/* PC is possibly an unknown languages trampoline.
}
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* We want to use the selected frame, not
- another more inner frame which happens to
- be in the same block. */
- write_exp_elt_block (pstate, NULL);
+ write_exp_elt_block (pstate, sym.block);
write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
}
objfile->per_bfd->language_of_main = lang;
}
+/* Helper structure to map blocks to static link properties in hash tables. */
+
+struct static_link_htab_entry
+{
+ const struct block *block;
+ const struct dynamic_prop *static_link;
+};
+
+/* Return a hash code for struct static_link_htab_entry *P. */
+
+static hashval_t
+static_link_htab_entry_hash (const void *p)
+{
+ const struct static_link_htab_entry *e
+ = (const struct static_link_htab_entry *) p;
+
+ return htab_hash_pointer (e->block);
+}
+
+/* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
+ mappings for the same block. */
+
+static int
+static_link_htab_entry_eq (const void *p1, const void *p2)
+{
+ const struct static_link_htab_entry *e1
+ = (const struct static_link_htab_entry *) p1;
+ const struct static_link_htab_entry *e2
+ = (const struct static_link_htab_entry *) p2;
+
+ return e1->block == e2->block;
+}
+
+/* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
+ Must not be called more than once for each BLOCK. */
+
+void
+objfile_register_static_link (struct objfile *objfile,
+ const struct block *block,
+ const struct dynamic_prop *static_link)
+{
+ void **slot;
+ struct static_link_htab_entry lookup_entry;
+ struct static_link_htab_entry *entry;
+
+ if (objfile->static_links == NULL)
+ objfile->static_links = htab_create_alloc
+ (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
+ xcalloc, xfree);
+
+ /* Create a slot for the mapping, make sure it's the first mapping for this
+ block and then create the mapping itself. */
+ lookup_entry.block = block;
+ slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT);
+ gdb_assert (*slot == NULL);
+
+ entry = (struct static_link_htab_entry *) obstack_alloc
+ (&objfile->objfile_obstack, sizeof (*entry));
+ entry->block = block;
+ entry->static_link = static_link;
+ *slot = (void *) entry;
+}
+
+/* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
+ none was found. */
+
+const struct dynamic_prop *
+objfile_lookup_static_link (struct objfile *objfile,
+ const struct block *block)
+{
+ struct static_link_htab_entry *entry;
+ struct static_link_htab_entry lookup_entry;
+
+ if (objfile->static_links == NULL)
+ return NULL;
+ lookup_entry.block = block;
+ entry
+ = (struct static_link_htab_entry *) htab_find (objfile->static_links,
+ &lookup_entry);
+ if (entry == NULL)
+ return NULL;
+
+ gdb_assert (entry->block == block);
+ return entry->static_link;
+}
+
\f
/* Called via bfd_map_over_sections to build up the section table that
/* Rebuild section map next time we need it. */
get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
+ /* Free the map for static links. There's no need to free static link
+ themselves since they were allocated on the objstack. */
+ if (objfile->static_links != NULL)
+ htab_delete (objfile->static_links);
+
/* The last thing we do is free the objfile struct itself. */
xfree (objfile);
}
#if !defined (OBJFILES_H)
#define OBJFILES_H
+#include "hashtab.h"
#include "gdb_obstack.h" /* For obstack internals. */
#include "symfile.h" /* For struct psymbol_allocation_list. */
#include "progspace.h"
properly. */
struct symbol *template_symbols;
+
+ /* Associate a static link (struct dynamic_prop *) to all blocks (struct
+ block *) that have one.
+
+ In the context of nested functions (available in Pascal, Ada and GNU C,
+ for instance), a static link (as in DWARF's DW_AT_static_link attribute)
+ for a function is a way to get the frame corresponding to the enclosing
+ function.
+
+ Very few blocks have a static link, so it's more memory efficient to
+ store these here rather than in struct block. Static links must be
+ allocated on the objfile's obstack. */
+ htab_t static_links;
};
/* Defines for the objfile flag word. */
extern void set_objfile_main_name (struct objfile *objfile,
const char *name, enum language lang);
+extern void objfile_register_static_link
+ (struct objfile *objfile,
+ const struct block *block,
+ const struct dynamic_prop *static_link);
+
+extern const struct dynamic_prop *objfile_lookup_static_link
+ (struct objfile *objfile, const struct block *block);
+
#endif /* !defined (OBJFILES_H) */
}
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- /* We want to use the selected frame, not
- another more inner frame which happens to
- be in the same block. */
- write_exp_elt_block (pstate, NULL);
+ write_exp_elt_block (pstate, sym.block);
write_exp_elt_sym (pstate, sym.symbol);
write_exp_elt_opcode (pstate, OP_VAR_VALUE);
current_type = sym.symbol->type; }
struct value *val;
struct value_print_options opts;
- val = read_var_value (var, frame);
+ /* READ_VAR_VALUE needs a block in order to deal with non-local
+ references (i.e. to handle nested functions). In this context, we
+ print variables that are local to this frame, so we can avoid passing
+ a block to it. */
+ val = read_var_value (var, NULL, frame);
get_user_print_options (&opts);
opts.deref_ref = 1;
common_val_print (val, stream, indent, &opts, current_language);
/* Ignore Python errors at this stage. */
self_bpfinish->return_type = type_to_type_object (ret_type);
PyErr_Clear ();
- func_value = read_var_value (function, frame);
+ func_value = read_var_value (function, NULL, frame);
self_bpfinish->function_value =
value_to_value_object (func_value);
PyErr_Clear ();
struct frame_info *frame;
PyObject *sym_obj, *block_obj = NULL;
struct symbol *var = NULL; /* gcc-4.3.2 false warning. */
+ const struct block *block = NULL;
struct value *val = NULL;
if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj))
else if (gdbpy_is_string (sym_obj))
{
char *var_name;
- const struct block *block = NULL;
struct cleanup *cleanup;
var_name = python_string_to_target_string (sym_obj);
TRY
{
+ struct block_symbol lookup_sym;
FRAPY_REQUIRE_VALID (self, frame);
if (!block)
block = get_frame_block (frame, NULL);
- var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL).symbol;
+ lookup_sym = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
+ var = lookup_sym.symbol;
+ block = lookup_sym.block;
}
CATCH (except, RETURN_MASK_ALL)
{
{
FRAPY_REQUIRE_VALID (self, frame);
- val = read_var_value (var, frame);
+ val = read_var_value (var, block, frame);
}
CATCH (except, RETURN_MASK_ALL)
{
NAME is a pass-through argument where the name of the symbol will
be written. NAME is allocated in this function, but the caller is
responsible for clean up. SYM is a pass-through argument where the
- symbol will be written. In the case of the API returning a string,
- this will be set to NULL. LANGUAGE is also a pass-through argument
- denoting the language attributed to the Symbol. In the case of SYM
- being NULL, this will be set to the current language. Returns
- EXT_LANG_BT_ERROR on error with the appropriate Python exception set, and
- EXT_LANG_BT_OK on success. */
+ symbol will be written and SYM_BLOCK is a pass-through argument to
+ write the block where the symbol lies in. In the case of the API
+ returning a string, this will be set to NULL. LANGUAGE is also a
+ pass-through argument denoting the language attributed to the
+ Symbol. In the case of SYM being NULL, this will be set to the
+ current language. Returns EXT_LANG_BT_ERROR on error with the
+ appropriate Python exception set, and EXT_LANG_BT_OK on success. */
static enum ext_lang_bt_status
extract_sym (PyObject *obj, char **name, struct symbol **sym,
- const struct language_defn **language)
+ struct block **sym_block, const struct language_defn **language)
{
PyObject *result = PyObject_CallMethod (obj, "symbol", NULL);
python_language. */
*language = python_language;
*sym = NULL;
+ *sym_block = NULL;
}
else
{
/* This type checks 'result' during the conversion so we
just call it unconditionally and check the return. */
*sym = symbol_object_to_symbol (result);
+ /* TODO: currently, we have no way to recover the block in which SYMBOL
+ was found, so we have no block to return. Trying to evaluate SYMBOL
+ will yield an incorrect value when it's located in a FRAME and
+ evaluated from another frame (as permitted in nested functions). */
+ *sym_block = NULL;
Py_DECREF (result);
const struct language_defn *language;
char *sym_name;
struct symbol *sym;
+ struct block *sym_block;
struct value *val;
enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
- success = extract_sym (item, &sym_name, &sym, &language);
+ success = extract_sym (item, &sym_name, &sym, &sym_block, &language);
if (success == EXT_LANG_BT_ERROR)
{
Py_DECREF (item);
struct value *val;
enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
struct symbol *sym;
+ struct block *sym_block;
int local_indent = 8 + (8 * indent);
struct cleanup *locals_cleanups;
locals_cleanups = make_cleanup_py_decref (item);
- success = extract_sym (item, &sym_name, &sym, &language);
+ success = extract_sym (item, &sym_name, &sym, &sym_block, &language);
if (success == EXT_LANG_BT_ERROR)
{
do_cleanups (locals_cleanups);
{
TRY
{
- val = read_var_value (sym, frame);
+ val = read_var_value (sym, sym_block, frame);
}
CATCH (except, RETURN_MASK_ERROR)
{
if (symbol_read_needs_frame (symbol) && frame_info == NULL)
error (_("symbol requires a frame to compute its value"));
- value = read_var_value (symbol, frame_info);
+ /* TODO: currently, we have no way to recover the block in which SYMBOL
+ was found, so we have no block to pass to read_var_value. This will
+ yield an incorrect value when symbol is not local to FRAME_INFO (this
+ can happen with nested functions). */
+ value = read_var_value (symbol, NULL, frame_info);
}
CATCH (except, RETURN_MASK_ALL)
{
TRY
{
- argp->val = read_var_value (sym, frame);
+ argp->val = read_var_value (sym, NULL, frame);
}
CATCH (except, RETURN_MASK_ERROR)
{
{
TRY
{
- val = read_var_value (sym, frame);
+ val = read_var_value (sym, NULL, frame);
}
CATCH (except, RETURN_MASK_ERROR)
{
TRY
{
- val = read_var_value (sym, frame);
+ val = read_var_value (sym, NULL, frame);
}
CATCH (except, RETURN_MASK_ERROR)
{
value_fetch_lazy (return_value);
if (thisfun != NULL)
- function = read_var_value (thisfun, thisframe);
+ function = read_var_value (thisfun, NULL, thisframe);
rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
uninitialized in such case. */
void (*find_frame_base_location) (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length);
+
+ /* Return the frame base address. FRAME is the frame for which we want to
+ compute the base address while FRAMEFUNC is the symbol for the
+ corresponding function. Return 0 on failure (FRAMEFUNC may not hold the
+ information we need).
+
+ This method is designed to work with static links (nested functions
+ handling). Static links are function properties whose evaluation returns
+ the frame base address for the enclosing frame. However, there are
+ multiple definitions for "frame base": the content of the frame base
+ register, the CFA as defined by DWARF unwinding information, ...
+
+ So this specific method is supposed to compute the frame base address such
+ as for nested fuctions, the static link computes the same address. For
+ instance, considering DWARF debugging information, the static link is
+ computed with DW_AT_static_link and this method must be used to compute
+ the corresponding DW_AT_frame_base attribute. */
+ CORE_ADDR (*get_frame_base) (struct symbol *framefunc,
+ struct frame_info *frame);
};
/* Functions used with LOC_REGISTER and LOC_REGPARM_ADDR. */
+2015-08-25 Pierre-Marie de Rodat <derodat@adacore.com>
+
+ * gdb.base/nested-subp1.exp: New file.
+ * gdb.base/nested-subp1.c: New file.
+ * gdb.base/nested-subp2.exp: New file.
+ * gdb.base/nested-subp2.c: New file.
+ * gdb.base/nested-subp3.exp: New file.
+ * gdb.base/nested-subp3.c: New file.
+
2015-08-24 Pedro Alves <palves@redhat.com>
* gdb.server/connect-without-multi-process.c: New file.
--- /dev/null
+/* This test program is part of GDB, the GNU debugger.
+
+ Copyright 2015 Free Software Foundation, Inc.
+
+ 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 3 of the License, or
+ (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
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+int
+foo (int i1)
+{
+ int
+ nested (int i2)
+ {
+ /* Here with i1 and i2, we can test that GDB can fetch both a local and a
+ non-local variable in the most simple nested function situation: the
+ parent block instance is accessible as the directly upper frame. */
+ return i1 * i2; /* STOP */
+ }
+
+ return nested (i1 + 1);
+}
+
+int
+main ()
+{
+ return !foo (1);
+}
--- /dev/null
+# Copyright 2015 Free Software Foundation, Inc.
+
+# 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 3 of the License, or
+# (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
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# This file is part of the gdb testsuite.
+
+#
+# Test nested functions related functionality.
+#
+
+standard_testfile
+
+
+set testcase "nested-subp1"
+
+if { [gdb_compile "${srcdir}/${subdir}/${testcase}.c" \
+ [standard_output_file "${testcase}"] \
+ "${testcase}" \
+ [list debug "additional_flags=-std=gnu99"]] != "" } {
+ return -1
+}
+
+
+# Run until the variables we are interested in are visible.
+
+clean_restart "${testcase}"
+if ![runto_main] {
+ perror "could not run to main"
+ continue
+}
+
+set bp_location [gdb_get_line_number "STOP" "${testcase}.c"]
+gdb_test "break ${testcase}.c:${bp_location}" \
+ "Breakpoint \[0-9\]+ at 0x\[0-9a-fA-F\]+: .*" \
+ "breakpoint to the STOP marker"
+gdb_test "continue" \
+ "Breakpoint \[0-9\]+, nested .*" \
+ "continue to the STOP marker"
+
+
+# Check we get correct values for both local and non-local variable references.
+
+gdb_test "print i1" "1"
+gdb_test "print i2" "2"
--- /dev/null
+/* This test program is part of GDB, the GNU debugger.
+
+ Copyright 2015 Free Software Foundation, Inc.
+
+ 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 3 of the License, or
+ (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
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+void
+iter_str (const char *str, void (*callback) (char c))
+{
+ for (; *str != '\0'; ++str)
+ callback (*str);
+}
+
+int
+length_str (const char *str)
+{
+ int count = 0;
+
+ void
+ increment (char c)
+ {
+ /* Here with COUNT, we can test that GDB can read a non-local variable even
+ though it's not directly in the upper stack frame. */
+ count += 1; /* STOP */
+ }
+
+ iter_str (str, &increment);
+ return count;
+}
+
+int
+main ()
+{
+ if (length_str ("foo") == 3)
+ return 0;
+ return 1;
+}
--- /dev/null
+# Copyright 2015 Free Software Foundation, Inc.
+
+# 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 3 of the License, or
+# (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
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# This file is part of the gdb testsuite.
+
+#
+# Test nested functions related functionality.
+#
+
+standard_testfile
+
+
+set testcase "nested-subp2"
+
+if { [gdb_compile "${srcdir}/${subdir}/${testcase}.c" \
+ [standard_output_file "${testcase}"] \
+ "${testcase}" \
+ [list debug "additional_flags=-std=gnu99"]] != "" } {
+ return -1
+}
+
+
+# Run until the variables we are interested in are visible.
+
+clean_restart "${testcase}"
+if ![runto_main] {
+ perror "could not run to main"
+ continue
+}
+
+set bp_location [gdb_get_line_number "STOP" "${testcase}.c"]
+gdb_test "break ${testcase}.c:${bp_location}" \
+ "Breakpoint \[0-9\]+ at 0x\[0-9a-fA-F\]+: .*" \
+ "breakpoint to the STOP marker"
+gdb_test "continue" \
+ "Breakpoint \[0-9\]+, increment .*" \
+ "continue to the STOP marker"
+
+
+# Check we get correct values for both local and non-local variable references.
+
+gdb_test "print c" "102 'f'"
+gdb_test "print count" "0"
+
+
+# Same but a little later: make sure we were looking at the proper places.
+
+gdb_test "continue" \
+ "Breakpoint \[0-9\]+, increment .*" \
+ "continue to the STOP marker"
+gdb_test "print c" "111 'o'"
+gdb_test "print count" "1"
--- /dev/null
+/* This test program is part of GDB, the GNU debugger.
+
+ Copyright 2015 Free Software Foundation, Inc.
+
+ 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 3 of the License, or
+ (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
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <stdlib.h>
+
+typedef void (*callback_t) (void);
+
+extern void process (callback_t cb);
+extern void parent (int first, callback_t cb);
+
+void
+ignore (int unused)
+{
+ (void) unused;
+}
+
+void
+process (callback_t cb)
+{
+ parent (0, cb);
+}
+
+void
+parent (int first, callback_t cb)
+{
+ void child (void)
+ {
+ /* When reaching this, there are two block instances for PARENT on the
+ stack: the one that is right in the upper frame is not the one actually
+ used for non-local references, so GDB has to follow the static link in
+ order to get the correct instance, and thus in order to read the proper
+ variables.
+
+ As a simple check, we can verify that under GDB, the following is true:
+ parent_first == first (which should be one: see the IF block below). */
+ const int parent_first = first;
+ ignore (parent_first); /* STOP */
+ ignore (first);
+ }
+
+ if (first)
+ process (&child);
+ else
+ cb ();
+}
+
+int
+main ()
+{
+ parent (1, NULL);
+ return 0;
+}
--- /dev/null
+# Copyright 2015 Free Software Foundation, Inc.
+
+# 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 3 of the License, or
+# (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
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# This file is part of the gdb testsuite.
+
+#
+# Test nested functions related functionality.
+#
+
+standard_testfile
+
+
+set testcase "nested-subp3"
+
+if { [gdb_compile "${srcdir}/${subdir}/${testcase}.c" \
+ [standard_output_file "${testcase}"] \
+ "${testcase}" \
+ [list debug "additional_flags=-std=gnu99"]] != "" } {
+ return -1
+}
+
+
+# Run until the variables we are interested in are visible.
+
+clean_restart "${testcase}"
+if ![runto_main] {
+ perror "could not run to main"
+ continue
+}
+
+set bp_location [gdb_get_line_number "STOP" "${testcase}.c"]
+gdb_test "break ${testcase}.c:${bp_location}" \
+ "Breakpoint \[0-9\]+ at 0x\[0-9a-fA-F\]+: .*" \
+ "breakpoint to the STOP marker"
+gdb_test "continue" \
+ "Breakpoint \[0-9\]+, child .*" \
+ "continue to the STOP marker"
+
+
+# Check we get correct values for both local and non-local variable references.
+
+gdb_test "print first" "1"
+gdb_test "print parent_first" "1"
struct value *
value_of_variable (struct symbol *var, const struct block *b)
{
- struct frame_info *frame;
+ struct frame_info *frame = NULL;
- if (!symbol_read_needs_frame (var))
- frame = NULL;
- else if (!b)
+ if (symbol_read_needs_frame (var))
frame = get_selected_frame (_("No frame selected."));
- else
- {
- frame = block_innermost_frame (b);
- if (!frame)
- {
- if (BLOCK_FUNCTION (b) && !block_inlined_p (b)
- && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
- error (_("No frame is currently executing in block %s."),
- SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
- else
- error (_("No frame is currently executing in specified block"));
- }
- }
- return read_var_value (var, frame);
+ return read_var_value (var, b, frame);
}
struct value *
return NULL;
if (want_address)
- return value_addr (read_var_value (s, 0));
+ return value_addr (read_var_value (s, 0, 0));
else
- return read_var_value (s, 0);
+ return read_var_value (s, 0, 0);
}
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
if (s == NULL)
return NULL;
- v = read_var_value (s, 0);
+ v = read_var_value (s, 0, 0);
if (!want_address)
result = v;
else
struct value *
value_of_this (const struct language_defn *lang)
{
- struct symbol *sym;
+ struct block_symbol sym;
const struct block *b;
struct frame_info *frame;
b = get_frame_block (frame, NULL);
- sym = lookup_language_this (lang, b).symbol;
- if (sym == NULL)
+ sym = lookup_language_this (lang, b);
+ if (sym.symbol == NULL)
error (_("current stack frame does not contain a variable named `%s'"),
lang->la_name_of_this);
- return read_var_value (sym, frame);
+ return read_var_value (sym.symbol, sym.block, frame);
}
/* Return the value of the local variable, if one exists. Return NULL
extern int symbol_read_needs_frame (struct symbol *);
extern struct value *read_var_value (struct symbol *var,
+ const struct block *var_block,
struct frame_info *frame);
extern struct value *default_read_var_value (struct symbol *var,
+ const struct block *var_block,
struct frame_info *frame);
extern struct value *allocate_value (struct type *type);
}
finish_block (newobj->name, &local_symbols, newobj->old_blocks,
- newobj->start_addr,
+ NULL, newobj->start_addr,
(fcn_cs_saved.c_value
+ fcn_aux_saved.x_sym.x_misc.x_fsize
+ ANOFFSET (objfile->section_offsets,
if (local_symbols && context_stack_depth > 0)
{
/* Make a block for the local symbols within. */
- finish_block (newobj->name, &local_symbols, newobj->old_blocks,
+ finish_block (newobj->name, &local_symbols,
+ newobj->old_blocks, NULL,
newobj->start_addr,
(cs->c_value
+ ANOFFSET (objfile->section_offsets,
projects / binutils-gdb.git / commitdiff