X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=fdce436baac214f2ed2fddd06cbe3c904e481472;hb=79bb5c2356e7651d0aad0a0c3818f1727bc3cb74;hp=99629eada65da72ce2c47d88fefd8a4eef0ba145;hpb=768a979c31bbe51154e3363c1061c45aa9cd937f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/findvar.c b/gdb/findvar.c index 99629eada6..fdce436baa 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-2013 Free Software Foundation, Inc. This file is part of GDB. @@ -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); } @@ -257,6 +264,7 @@ 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]; @@ -268,16 +276,24 @@ 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); + frame_register (frame, regnum, &optim, &unavail, + &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)); + 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); return reg_val; } @@ -298,41 +314,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 +367,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_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: @@ -379,50 +403,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 +491,18 @@ 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: + 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; @@ -449,39 +510,48 @@ 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: { 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); + 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) - set_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 - set_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: @@ -497,66 +567,86 @@ 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; + 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 + (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); + v = allocate_value_lazy (type); } 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_LVAL (v) = lval_memory; set_value_address (v, addr); - set_value_lazy (v, 1); 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 * @@ -585,6 +675,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 * @@ -596,6 +738,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 @@ -607,21 +751,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; } @@ -644,3 +794,4 @@ address_from_register (struct type *type, int regnum, struct frame_info *frame) return result; } +