X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=0647c0f1331306944ca9b650829cd3e5de587f1c;hb=2117c711ae07700adb57ea5b5ca61e4c32d7e3d2;hp=1048887fdc061cba49de10437d100665ded55df7;hpb=61212c0fb13d0a54f12748dcc56a41c15a91d12a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/findvar.c b/gdb/findvar.c index 1048887fdc..0647c0f133 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 - Free Software Foundation, Inc. + Copyright (C) 1986-2014 Free Software Foundation, Inc. This file is part of GDB. @@ -27,7 +25,7 @@ #include "gdbcore.h" #include "inferior.h" #include "target.h" -#include "gdb_string.h" +#include #include "gdb_assert.h" #include "floatformat.h" #include "symfile.h" /* for overlay functions */ @@ -35,9 +33,11 @@ #include "user-regs.h" #include "block.h" #include "objfiles.h" +#include "language.h" -/* Basic byte-swapping routines. GDB has needed these for a long time... - All extract a target-format integer at ADDR which is LEN bytes long. */ +/* Basic byte-swapping routines. All 'extract' functions return a + host-format integer from a target-format integer at ADDR which is + LEN bytes long. */ #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8 /* 8 bit characters are a pretty safe assumption these days, so we @@ -48,7 +48,8 @@ you lose #endif LONGEST -extract_signed_integer (const gdb_byte *addr, int len) +extract_signed_integer (const gdb_byte *addr, int len, + enum bfd_endian byte_order) { LONGEST retval; const unsigned char *p; @@ -62,7 +63,7 @@ That operation is not available on integers of more than %d bytes."), /* Start at the most significant end of the integer, and work towards the least significant. */ - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (byte_order == BFD_ENDIAN_BIG) { p = startaddr; /* Do the sign extension once at the start. */ @@ -82,7 +83,8 @@ That operation is not available on integers of more than %d bytes."), } ULONGEST -extract_unsigned_integer (const gdb_byte *addr, int len) +extract_unsigned_integer (const gdb_byte *addr, int len, + enum bfd_endian byte_order) { ULONGEST retval; const unsigned char *p; @@ -97,7 +99,7 @@ That operation is not available on integers of more than %d bytes."), /* Start at the most significant end of the integer, and work towards the least significant. */ retval = 0; - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (byte_order == BFD_ENDIAN_BIG) { for (p = startaddr; p < endaddr; ++p) retval = (retval << 8) | *p; @@ -117,14 +119,14 @@ That operation is not available on integers of more than %d bytes."), int extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, - LONGEST *pval) + enum bfd_endian byte_order, LONGEST *pval) { const gdb_byte *p; const gdb_byte *first_addr; int len; len = orig_len; - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (byte_order == BFD_ENDIAN_BIG) { for (p = addr; len > (int) sizeof (LONGEST) && p < addr + orig_len; @@ -154,7 +156,8 @@ extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, if (len <= (int) sizeof (LONGEST)) { *pval = (LONGEST) extract_unsigned_integer (first_addr, - sizeof (LONGEST)); + sizeof (LONGEST), + byte_order); return 1; } @@ -173,12 +176,15 @@ extract_typed_address (const gdb_byte *buf, struct type *type) _("extract_typed_address: " "type is not a pointer or reference")); - return gdbarch_pointer_to_address (current_gdbarch, type, buf); + return gdbarch_pointer_to_address (get_type_arch (type), type, buf); } +/* All 'store' functions accept a host-format integer and store a + target-format integer at ADDR which is LEN bytes long. */ void -store_signed_integer (gdb_byte *addr, int len, LONGEST val) +store_signed_integer (gdb_byte *addr, int len, + enum bfd_endian byte_order, LONGEST val) { gdb_byte *p; gdb_byte *startaddr = addr; @@ -186,7 +192,7 @@ store_signed_integer (gdb_byte *addr, int len, LONGEST val) /* Start at the least significant end of the integer, and work towards the most significant. */ - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (byte_order == BFD_ENDIAN_BIG) { for (p = endaddr - 1; p >= startaddr; --p) { @@ -205,7 +211,8 @@ store_signed_integer (gdb_byte *addr, int len, LONGEST val) } void -store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val) +store_unsigned_integer (gdb_byte *addr, int len, + enum bfd_endian byte_order, ULONGEST val) { unsigned char *p; unsigned char *startaddr = (unsigned char *) addr; @@ -213,7 +220,7 @@ store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val) /* Start at the least significant end of the integer, and work towards the most significant. */ - if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) + if (byte_order == BFD_ENDIAN_BIG) { for (p = endaddr - 1; p >= startaddr; --p) { @@ -242,7 +249,7 @@ store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) _("store_typed_address: " "type is not a pointer or reference")); - gdbarch_address_to_pointer (current_gdbarch, type, buf, addr); + gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr); } @@ -255,12 +262,7 @@ struct value * value_of_register (int regnum, struct frame_info *frame) { struct gdbarch *gdbarch = get_frame_arch (frame); - CORE_ADDR addr; - int optim; 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. */ @@ -268,17 +270,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, &lval, &addr, &realnum, raw_buffer); - - reg_val = allocate_value (register_type (gdbarch, regnum)); - - memcpy (value_contents_raw (reg_val), raw_buffer, - register_size (gdbarch, regnum)); - VALUE_LVAL (reg_val) = lval; - VALUE_ADDRESS (reg_val) = addr; - VALUE_REGNUM (reg_val) = regnum; - set_value_optimized_out (reg_val, optim); - 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; } @@ -298,41 +291,51 @@ value_of_register_lazy (struct frame_info *frame, int regnum) /* We should have a valid (i.e. non-sentinel) frame. */ gdb_assert (frame_id_p (get_frame_id (frame))); - reg_val = allocate_value (register_type (gdbarch, regnum)); + reg_val = allocate_value_lazy (register_type (gdbarch, regnum)); VALUE_LVAL (reg_val) = lval_register; VALUE_REGNUM (reg_val) = regnum; VALUE_FRAME_ID (reg_val) = get_frame_id (frame); - set_value_lazy (reg_val, 1); return reg_val; } /* Given a pointer of type TYPE in target form in BUF, return the address it represents. */ CORE_ADDR -unsigned_pointer_to_address (struct type *type, const gdb_byte *buf) +unsigned_pointer_to_address (struct gdbarch *gdbarch, + struct type *type, const gdb_byte *buf) { - return extract_unsigned_integer (buf, TYPE_LENGTH (type)); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); } CORE_ADDR -signed_pointer_to_address (struct type *type, const gdb_byte *buf) +signed_pointer_to_address (struct gdbarch *gdbarch, + struct type *type, const gdb_byte *buf) { - return extract_signed_integer (buf, TYPE_LENGTH (type)); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order); } /* Given an address, store it as a pointer of type TYPE in target format in BUF. */ void -unsigned_address_to_pointer (struct type *type, gdb_byte *buf, - CORE_ADDR addr) +unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type, + gdb_byte *buf, CORE_ADDR addr) { - store_unsigned_integer (buf, TYPE_LENGTH (type), addr); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); } void -address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) +address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type, + gdb_byte *buf, CORE_ADDR addr) { - store_signed_integer (buf, TYPE_LENGTH (type), addr); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + + store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr); } /* Will calling read_var_value or locate_var_value on SYM end @@ -341,17 +344,15 @@ address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) 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_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_OPS (sym)->read_needs_frame (sym); + gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method")); case LOC_REGISTER: case LOC_ARG: @@ -379,50 +380,85 @@ 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 minimal_symbol *result; + + /* The objfile in which the symbol was found. */ + struct objfile *objfile; +}; + +/* 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 == NULL); + + data->result = lookup_minimal_symbol (data->name, NULL, objfile); + data->objfile = objfile; + + /* The iterator should stop iff a match was found. */ + return (data->result != 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; - if (SYMBOL_CLASS (var) == LOC_COMPUTED - || SYMBOL_CLASS (var) == LOC_REGISTER) - /* These cases do not use V. */ - v = NULL; - else - { - v = allocate_value (type); - VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */ - } - - len = TYPE_LENGTH (type); + /* 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 + instead of zero. However, we do not replace the typedef type by the + target type, because we want to keep the typedef in order to be able to + set the returned value type description correctly. */ + check_typedef (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. */ - store_signed_integer (value_contents_raw (v), len, + v = allocate_value (type); + 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; return v; case LOC_LABEL: /* Put the constant back in target format. */ + v = allocate_value (type); if (overlay_debugging) { 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); } else @@ -432,16 +468,17 @@ read_var_value (struct symbol *var, struct frame_info *frame) return v; case LOC_CONST_BYTES: - { - memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len); - VALUE_LVAL (v) = not_lval; - return v; - } + v = allocate_value (type); + memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), + TYPE_LENGTH (type)); + VALUE_LVAL (v) = not_lval; + return v; case LOC_STATIC: 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; @@ -449,7 +486,8 @@ 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); break; @@ -457,9 +495,11 @@ read_var_value (struct symbol *var, struct frame_info *frame) { struct value *ref; CORE_ADDR argref; + 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); @@ -472,21 +512,24 @@ read_var_value (struct symbol *var, struct frame_info *frame) 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: if (overlay_debugging) - VALUE_ADDRESS (v) = symbol_overlayed_address - (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)); + addr = symbol_overlayed_address + (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var), + var)); else - VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); - return v; + addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); + break; case LOC_REGISTER: case LOC_REGPARM_ADDR: { - int regno = SYMBOL_VALUE (var); + int regno = SYMBOL_REGISTER_OPS (var) + ->register_number (var, get_frame_arch (frame)); struct value *regval; if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) @@ -496,45 +539,51 @@ 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); - VALUE_LVAL (v) = lval_memory; } 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_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_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; + if (msym == NULL) - return 0; + error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var)); if (overlay_debugging) addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), - SYMBOL_OBJ_SECTION (msym)); + SYMBOL_OBJ_SECTION (lookup_data.objfile, + msym)); else addr = SYMBOL_VALUE_ADDRESS (msym); - obj_section = SYMBOL_OBJ_SECTION (msym); + obj_section = SYMBOL_OBJ_SECTION (lookup_data.objfile, msym); if (obj_section && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) addr = target_translate_tls_address (obj_section->objfile, addr); @@ -542,20 +591,31 @@ read_var_value (struct symbol *var, struct frame_info *frame) break; case LOC_OPTIMIZED_OUT: - 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_ADDRESS (v) = addr; - set_value_lazy (v, 1); + 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 * @@ -584,6 +644,58 @@ 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 (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 (value_type (regval)) - reg_offset; + + if (value_optimized_out (regval)) + { + set_value_optimized_out (value, 1); + break; + } + + /* 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 * @@ -595,6 +707,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 @@ -606,21 +720,27 @@ 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) + set_value_optimized_out (v, 1); + 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); /* 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; } @@ -637,9 +757,19 @@ address_from_register (struct type *type, int regnum, struct frame_info *frame) value = value_from_register (type, regnum, frame); gdb_assert (value); + 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); value_free (value); return result; } +