X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=a39d89788e8c16dd128887913c3ac8d8d998cb95;hb=4e7b8beaa3b7b9ac8577b10afa9d58bb9d453b08;hp=809a99e8a728b0d161bc44b581d8e643f22cae99;hpb=0fdb4f184b39af02d76e21cd25af561b464f15a6;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/findvar.c b/gdb/findvar.c index 809a99e8a7..a39d89788e 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -1,8 +1,6 @@ /* Find a variable's value in memory, for GDB, the GNU debugger. - Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009, - 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -27,14 +25,14 @@ #include "gdbcore.h" #include "inferior.h" #include "target.h" -#include "gdb_string.h" -#include "gdb_assert.h" #include "floatformat.h" #include "symfile.h" /* for overlay functions */ #include "regcache.h" #include "user-regs.h" #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 @@ -263,13 +261,7 @@ struct value * value_of_register (int regnum, struct frame_info *frame) { struct gdbarch *gdbarch = get_frame_arch (frame); - CORE_ADDR addr; - int optim; - int unavail; struct value *reg_val; - int realnum; - gdb_byte raw_buffer[MAX_REGISTER_SIZE]; - enum lval_type lval; /* User registers lie completely outside of the range of normal registers. Catch them early so that the target never sees them. */ @@ -277,25 +269,8 @@ value_of_register (int regnum, struct frame_info *frame) + gdbarch_num_pseudo_regs (gdbarch)) return value_of_user_reg (regnum, frame); - frame_register (frame, regnum, &optim, &unavail, - &lval, &addr, &realnum, raw_buffer); - - reg_val = allocate_value (register_type (gdbarch, regnum)); - - if (!optim && !unavail) - memcpy (value_contents_raw (reg_val), raw_buffer, - register_size (gdbarch, regnum)); - else - memset (value_contents_raw (reg_val), 0, - register_size (gdbarch, regnum)); - - VALUE_LVAL (reg_val) = lval; - set_value_address (reg_val, addr); - VALUE_REGNUM (reg_val) = regnum; - set_value_optimized_out (reg_val, optim); - if (unavail) - mark_value_bytes_unavailable (reg_val, 0, register_size (gdbarch, regnum)); - VALUE_FRAME_ID (reg_val) = get_frame_id (frame); + reg_val = value_of_register_lazy (frame, regnum); + value_fetch_lazy (reg_val); return reg_val; } @@ -368,17 +343,15 @@ address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type, int symbol_read_needs_frame (struct symbol *sym) { + if (SYMBOL_COMPUTED_OPS (sym) != NULL) + return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym); + switch (SYMBOL_CLASS (sym)) { /* All cases listed explicitly so that gcc -Wall will detect it if we failed to consider one. */ case LOC_COMPUTED: - /* FIXME: cagney/2004-01-26: It should be possible to - unconditionally call the SYMBOL_COMPUTED_OPS method when available. - Unfortunately DWARF 2 stores the frame-base (instead of the - function) location in a function's symbol. Oops! For the - moment enable this when/where applicable. */ - return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym); + gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method")); case LOC_REGISTER: case LOC_ARG: @@ -406,18 +379,201 @@ symbol_read_needs_frame (struct symbol *sym) return 1; } -/* Given a struct symbol for a variable, - and a stack frame id, read the value of the variable - and return a (pointer to a) struct value containing the value. - If the variable cannot be found, return a zero pointer. */ +/* Private data to be used with minsym_lookup_iterator_cb. */ + +struct minsym_lookup_data +{ + /* The name of the minimal symbol we are searching for. */ + const char *name; + + /* The field where the callback should store the minimal symbol + if found. It should be initialized to NULL before the search + is started. */ + struct bound_minimal_symbol result; +}; + +/* A callback function for gdbarch_iterate_over_objfiles_in_search_order. + It searches by name for a minimal symbol within the given OBJFILE. + The arguments are passed via CB_DATA, which in reality is a pointer + to struct minsym_lookup_data. */ + +static int +minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data) +{ + struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data; + + gdb_assert (data->result.minsym == NULL); + + data->result = lookup_minimal_symbol (data->name, NULL, objfile); + + /* The iterator should stop iff a match was found. */ + 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 instead of 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 * -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); CORE_ADDR addr; - int len; /* Call check_typedef on our type to make sure that, if TYPE is a TYPE_CODE_TYPEDEF, its length is set to the length of the target type @@ -426,17 +582,26 @@ read_var_value (struct symbol *var, struct frame_info *frame) set the returned value type description correctly. */ check_typedef (type); - len = TYPE_LENGTH (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); switch (SYMBOL_CLASS (var)) { case LOC_CONST: - /* Put the constant back in target format. */ + if (is_dynamic_type (type)) + { + /* Value is a constant byte-sequence and needs no memory access. */ + type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0); + } + /* Put the constant back in target format. */ v = allocate_value (type); - store_signed_integer (value_contents_raw (v), len, + store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type), gdbarch_byte_order (get_type_arch (type)), (LONGEST) SYMBOL_VALUE (var)); VALUE_LVAL (v) = not_lval; @@ -449,7 +614,8 @@ read_var_value (struct symbol *var, struct frame_info *frame) { CORE_ADDR addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), - SYMBOL_OBJ_SECTION (var)); + SYMBOL_OBJ_SECTION (symbol_objfile (var), + var)); store_typed_address (value_contents_raw (v), type, addr); } @@ -460,16 +626,22 @@ read_var_value (struct symbol *var, struct frame_info *frame) return v; case LOC_CONST_BYTES: + if (is_dynamic_type (type)) + { + /* Value is a constant byte-sequence and needs no memory access. */ + type = resolve_dynamic_type (type, NULL, /* Unused address. */ 0); + } v = allocate_value (type); - memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len); + memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), + TYPE_LENGTH (type)); VALUE_LVAL (v) = not_lval; return v; case LOC_STATIC: - v = allocate_value_lazy (type); if (overlay_debugging) addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), - SYMBOL_OBJ_SECTION (var)); + SYMBOL_OBJ_SECTION (symbol_objfile (var), + var)); else addr = SYMBOL_VALUE_ADDRESS (var); break; @@ -477,9 +649,9 @@ read_var_value (struct symbol *var, struct frame_info *frame) case LOC_ARG: addr = get_frame_args_address (frame); if (!addr) - return 0; + error (_("Unknown argument list address for `%s'."), + SYMBOL_PRINT_NAME (var)); addr += SYMBOL_VALUE (var); - v = allocate_value_lazy (type); break; case LOC_REF_ARG: @@ -489,29 +661,29 @@ read_var_value (struct symbol *var, struct frame_info *frame) argref = get_frame_args_address (frame); if (!argref) - return 0; + error (_("Unknown argument list address for `%s'."), + SYMBOL_PRINT_NAME (var)); argref += SYMBOL_VALUE (var); ref = value_at (lookup_pointer_type (type), argref); addr = value_as_address (ref); - v = allocate_value_lazy (type); break; } case LOC_LOCAL: addr = get_frame_locals_address (frame); addr += SYMBOL_VALUE (var); - v = allocate_value_lazy (type); break; case LOC_TYPEDEF: - error (_("Cannot look up value of a typedef")); + error (_("Cannot look up value of a typedef `%s'."), + SYMBOL_PRINT_NAME (var)); break; case LOC_BLOCK: - v = allocate_value_lazy (type); if (overlay_debugging) addr = symbol_overlayed_address - (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)); + (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), + SYMBOL_OBJ_SECTION (symbol_objfile (var), var)); else addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); break; @@ -530,80 +702,110 @@ read_var_value (struct symbol *var, struct frame_info *frame) frame); if (regval == NULL) - error (_("Value of register variable not available.")); + error (_("Value of register variable not available for `%s'."), + SYMBOL_PRINT_NAME (var)); addr = value_as_address (regval); - v = allocate_value_lazy (type); } else { regval = value_from_register (type, regno, frame); if (regval == NULL) - error (_("Value of register variable not available.")); + error (_("Value of register variable not available for `%s'."), + SYMBOL_PRINT_NAME (var)); return regval; } } break; case LOC_COMPUTED: - /* FIXME: cagney/2004-01-26: It should be possible to - unconditionally call the SYMBOL_COMPUTED_OPS method when available. - Unfortunately DWARF 2 stores the frame-base (instead of the - function) location in a function's symbol. Oops! For the - moment enable this when/where applicable. */ - return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame); + gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method")); case LOC_UNRESOLVED: { + struct minsym_lookup_data lookup_data; struct minimal_symbol *msym; struct obj_section *obj_section; - msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL); + memset (&lookup_data, 0, sizeof (lookup_data)); + lookup_data.name = SYMBOL_LINKAGE_NAME (var); + + gdbarch_iterate_over_objfiles_in_search_order + (symbol_arch (var), + minsym_lookup_iterator_cb, &lookup_data, + symbol_objfile (var)); + msym = lookup_data.result.minsym; + + /* If we can't find the minsym there's a problem in the symbol info. + The symbol exists in the debug info, but it's missing in the minsym + table. */ if (msym == NULL) - return 0; - if (overlay_debugging) - addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), - SYMBOL_OBJ_SECTION (msym)); + { + const char *flavour_name + = objfile_flavour_name (symbol_objfile (var)); + + /* We can't get here unless we've opened the file, so flavour_name + can't be NULL. */ + gdb_assert (flavour_name != NULL); + error (_("Missing %s symbol \"%s\"."), + flavour_name, SYMBOL_LINKAGE_NAME (var)); + } + obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym); + /* Relocate address, unless there is no section or the variable is + a TLS variable. */ + if (obj_section == NULL + || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) + addr = MSYMBOL_VALUE_RAW_ADDRESS (msym); else - addr = SYMBOL_VALUE_ADDRESS (msym); - - obj_section = SYMBOL_OBJ_SECTION (msym); + addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result); + if (overlay_debugging) + addr = symbol_overlayed_address (addr, obj_section); + /* Determine address of TLS variable. */ if (obj_section && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) addr = target_translate_tls_address (obj_section->objfile, addr); - v = allocate_value_lazy (type); } break; case LOC_OPTIMIZED_OUT: - v = allocate_value_lazy (type); - VALUE_LVAL (v) = not_lval; - set_value_optimized_out (v, 1); - return v; + return allocate_optimized_out_value (type); default: - error (_("Cannot look up value of a botched symbol.")); + error (_("Cannot look up value of a botched symbol `%s'."), + SYMBOL_PRINT_NAME (var)); break; } - VALUE_LVAL (v) = lval_memory; - set_value_address (v, addr); + v = value_at_lazy (type, addr); return v; } +/* Calls VAR's language la_read_var_value hook with the given arguments. */ + +struct value * +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, var_block, frame); +} + /* Install default attributes for register values. */ struct value * -default_value_from_register (struct type *type, int regnum, - struct frame_info *frame) +default_value_from_register (struct gdbarch *gdbarch, struct type *type, + int regnum, struct frame_id frame_id) { - struct gdbarch *gdbarch = get_frame_arch (frame); int len = TYPE_LENGTH (type); struct value *value = allocate_value (type); VALUE_LVAL (value) = lval_register; - VALUE_FRAME_ID (value) = get_frame_id (frame); + VALUE_FRAME_ID (value) = frame_id; VALUE_REGNUM (value) = regnum; /* Any structure stored in more than one register will always be @@ -620,6 +822,52 @@ default_value_from_register (struct type *type, int regnum, return value; } +/* VALUE must be an lval_register value. If regnum is the value's + associated register number, and len the length of the values type, + read one or more registers in FRAME, starting with register REGNUM, + until we've read LEN bytes. + + If any of the registers we try to read are optimized out, then mark the + complete resulting value as optimized out. */ + +void +read_frame_register_value (struct value *value, struct frame_info *frame) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + int offset = 0; + int reg_offset = value_offset (value); + int regnum = VALUE_REGNUM (value); + int len = type_length_units (check_typedef (value_type (value))); + + gdb_assert (VALUE_LVAL (value) == lval_register); + + /* Skip registers wholly inside of REG_OFFSET. */ + while (reg_offset >= register_size (gdbarch, regnum)) + { + reg_offset -= register_size (gdbarch, regnum); + regnum++; + } + + /* Copy the data. */ + while (len > 0) + { + struct value *regval = get_frame_register_value (frame, regnum); + int reg_len = type_length_units (value_type (regval)) - reg_offset; + + /* If the register length is larger than the number of bytes + remaining to copy, then only copy the appropriate bytes. */ + if (reg_len > len) + reg_len = len; + + value_contents_copy (value, offset, regval, reg_offset, reg_len); + + offset += reg_len; + len -= reg_len; + reg_offset = 0; + regnum++; + } +} + /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */ struct value * @@ -631,6 +879,8 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame) if (gdbarch_convert_register_p (gdbarch, regnum, type1)) { + int optim, unavail, ok; + /* The ISA/ABI need to something weird when obtaining the specified value from this register. It might need to re-order non-adjacent, starting with REGNUM (see MIPS and @@ -642,36 +892,87 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame) VALUE_LVAL (v) = lval_register; VALUE_FRAME_ID (v) = get_frame_id (frame); VALUE_REGNUM (v) = regnum; - gdbarch_register_to_value (gdbarch, - frame, regnum, type1, value_contents_raw (v)); + ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1, + value_contents_raw (v), &optim, + &unavail); + + if (!ok) + { + if (optim) + mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type)); + if (unavail) + mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type)); + } } else { - int len = TYPE_LENGTH (type); - /* Construct the value. */ - v = gdbarch_value_from_register (gdbarch, type, regnum, frame); + v = gdbarch_value_from_register (gdbarch, type, + regnum, get_frame_id (frame)); /* Get the data. */ - if (!get_frame_register_bytes (frame, regnum, value_offset (v), len, - value_contents_raw (v))) - set_value_optimized_out (v, 1); + read_frame_register_value (v, frame); } + return v; } -/* Return contents of register REGNUM in frame FRAME as address, - interpreted as value of type TYPE. Will abort if register - value is not available. */ +/* Return contents of register REGNUM in frame FRAME as address. + Will abort if register value is not available. */ CORE_ADDR -address_from_register (struct type *type, int regnum, struct frame_info *frame) +address_from_register (int regnum, struct frame_info *frame) { + struct gdbarch *gdbarch = get_frame_arch (frame); + struct type *type = builtin_type (gdbarch)->builtin_data_ptr; struct value *value; CORE_ADDR result; + int regnum_max_excl = (gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)); + + if (regnum < 0 || regnum >= regnum_max_excl) + error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum, + regnum_max_excl); + + /* This routine may be called during early unwinding, at a time + where the ID of FRAME is not yet known. Calling value_from_register + would therefore abort in get_frame_id. However, since we only need + a temporary value that is never used as lvalue, we actually do not + really need to set its VALUE_FRAME_ID. Therefore, we re-implement + the core of value_from_register, but use the null_frame_id. */ + + /* Some targets require a special conversion routine even for plain + pointer types. Avoid constructing a value object in those cases. */ + if (gdbarch_convert_register_p (gdbarch, regnum, type)) + { + gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type)); + int optim, unavail, ok; + + ok = gdbarch_register_to_value (gdbarch, frame, regnum, type, + buf, &optim, &unavail); + if (!ok) + { + /* This function is used while computing a location expression. + Complain about the value being optimized out, rather than + letting value_as_address complain about some random register + the expression depends on not being saved. */ + error_value_optimized_out (); + } + + return unpack_long (type, buf); + } - value = value_from_register (type, regnum, frame); - gdb_assert (value); + value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id); + read_frame_register_value (value, frame); + + if (value_optimized_out (value)) + { + /* This function is used while computing a location expression. + Complain about the value being optimized out, rather than + letting value_as_address complain about some random register + the expression depends on not being saved. */ + error_value_optimized_out (); + } result = value_as_address (value); release_value (value); @@ -679,3 +980,4 @@ address_from_register (struct type *type, int regnum, struct frame_info *frame) return result; } +