X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=cb98b869c471976ff834752fec742535d96e7f48;hb=5aa03310cef09e8c41aaa05152d9570dfe62ba81;hp=79c4221f73624b37100743390cdbd1c8aab46ad3;hpb=0b30217134add051e159a192066a1e568ebd837f;p=platform%2Fupstream%2Fbinutils.git diff --git a/gdb/findvar.c b/gdb/findvar.c index 79c4221..cb98b86 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -1,7 +1,6 @@ /* Find a variable's value in memory, for GDB, the GNU debugger. - Copyright (C) 1986-2001, 2003-2005, 2007-2012 Free Software - Foundation, Inc. + Copyright (C) 1986-2014 Free Software Foundation, Inc. This file is part of GDB. @@ -26,14 +25,13 @@ #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" /* Basic byte-swapping routines. All 'extract' functions return a host-format integer from a target-format integer at ADDR which is @@ -262,13 +260,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. */ @@ -276,25 +268,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; } @@ -367,17 +342,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: @@ -405,18 +378,46 @@ 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, throw error. */ +/* 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); +} + +/* 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, 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 @@ -425,17 +426,23 @@ 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); + 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, /* 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; @@ -448,7 +455,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); } @@ -459,16 +467,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, /* 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; @@ -479,7 +493,6 @@ read_var_value (struct symbol *var, struct frame_info *frame) 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: @@ -494,14 +507,12 @@ read_var_value (struct symbol *var, struct frame_info *frame) 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: @@ -510,10 +521,10 @@ read_var_value (struct symbol *var, struct frame_info *frame) 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; @@ -536,7 +547,6 @@ read_var_value (struct symbol *var, struct frame_info *frame) SYMBOL_PRINT_NAME (var)); addr = value_as_address (regval); - v = allocate_value_lazy (type); } else { @@ -551,32 +561,36 @@ read_var_value (struct symbol *var, struct frame_info *frame) 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 + (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile), + minsym_lookup_iterator_cb, &lookup_data, + SYMBOL_SYMTAB (var)->objfile); + msym = lookup_data.result.minsym; + if (msym == NULL) error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var)); if (overlay_debugging) - addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), - SYMBOL_OBJ_SECTION (msym)); + addr = symbol_overlayed_address (BMSYMBOL_VALUE_ADDRESS (lookup_data.result), + MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, + msym)); else - addr = SYMBOL_VALUE_ADDRESS (msym); + addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result); - obj_section = SYMBOL_OBJ_SECTION (msym); + obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym); 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; @@ -589,23 +603,34 @@ read_var_value (struct symbol *var, struct frame_info *frame) 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, 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); +} + /* 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 @@ -625,7 +650,10 @@ default_value_from_register (struct type *type, int regnum, /* 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. */ + 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) @@ -696,7 +724,7 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame) if (!ok) { if (optim) - set_value_optimized_out (v, 1); + mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type)); if (unavail) mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type)); } @@ -704,7 +732,8 @@ value_from_register (struct type *type, int regnum, struct frame_info *frame) else { /* 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. */ read_frame_register_value (v, frame); @@ -713,18 +742,56 @@ value_from_register (struct type *type, int regnum, struct frame_info *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; - value = value_from_register (type, regnum, frame); - gdb_assert (value); + /* 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 = 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 = 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);