X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=4f201390bbca987b86cae983ff5007b1dff5728f;hb=42ae523077b469c09e83845d30ee137a844aacb8;hp=487d25eefa5cc6bb42dd827043c2fcd61902c90c;hpb=25ae5d16b1e30cc2bc1f2eb5b51553ea6413433c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/findvar.c b/gdb/findvar.c index 487d25eefa..4f201390bb 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -1,14 +1,14 @@ /* Find a variable's value in memory, for GDB, the GNU debugger. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software - Foundation, Inc. + 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. This file is part of GDB. 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 2 of the License, or + 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, @@ -17,9 +17,7 @@ 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, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "symtab.h" @@ -36,6 +34,7 @@ #include "regcache.h" #include "user-regs.h" #include "block.h" +#include "objfiles.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. */ @@ -49,7 +48,7 @@ you lose #endif LONGEST -extract_signed_integer (const void *addr, int len) +extract_signed_integer (const gdb_byte *addr, int len) { LONGEST retval; const unsigned char *p; @@ -57,13 +56,13 @@ extract_signed_integer (const void *addr, int len) const unsigned char *endaddr = startaddr + len; if (len > (int) sizeof (LONGEST)) - error ("\ -That operation is not available on integers of more than %d bytes.", + error (_("\ +That operation is not available on integers of more than %d bytes."), (int) sizeof (LONGEST)); /* Start at the most significant end of the integer, and work towards the least significant. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) { p = startaddr; /* Do the sign extension once at the start. */ @@ -83,7 +82,7 @@ That operation is not available on integers of more than %d bytes.", } ULONGEST -extract_unsigned_integer (const void *addr, int len) +extract_unsigned_integer (const gdb_byte *addr, int len) { ULONGEST retval; const unsigned char *p; @@ -91,14 +90,14 @@ extract_unsigned_integer (const void *addr, int len) const unsigned char *endaddr = startaddr + len; if (len > (int) sizeof (ULONGEST)) - error ("\ -That operation is not available on integers of more than %d bytes.", + error (_("\ +That operation is not available on integers of more than %d bytes."), (int) sizeof (ULONGEST)); /* Start at the most significant end of the integer, and work towards the least significant. */ retval = 0; - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) { for (p = startaddr; p < endaddr; ++p) retval = (retval << 8) | *p; @@ -117,16 +116,18 @@ That operation is not available on integers of more than %d bytes.", function returns 1 and sets *PVAL. Otherwise it returns 0. */ int -extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval) +extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, + LONGEST *pval) { - char *p, *first_addr; + const gdb_byte *p; + const gdb_byte *first_addr; int len; len = orig_len; - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) { - for (p = (char *) addr; - len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len; + for (p = addr; + len > (int) sizeof (LONGEST) && p < addr + orig_len; p++) { if (*p == 0) @@ -138,9 +139,9 @@ extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval) } else { - first_addr = (char *) addr; - for (p = (char *) addr + orig_len - 1; - len > (int) sizeof (LONGEST) && p >= (char *) addr; + first_addr = addr; + for (p = addr + orig_len - 1; + len > (int) sizeof (LONGEST) && p >= addr; p--) { if (*p == 0) @@ -164,28 +165,28 @@ extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval) /* Treat the bytes at BUF as a pointer of type TYPE, and return the address it represents. */ CORE_ADDR -extract_typed_address (const void *buf, struct type *type) +extract_typed_address (const gdb_byte *buf, struct type *type) { if (TYPE_CODE (type) != TYPE_CODE_PTR && TYPE_CODE (type) != TYPE_CODE_REF) internal_error (__FILE__, __LINE__, - "extract_typed_address: " - "type is not a pointer or reference"); + _("extract_typed_address: " + "type is not a pointer or reference")); - return POINTER_TO_ADDRESS (type, buf); + return gdbarch_pointer_to_address (current_gdbarch, type, buf); } void -store_signed_integer (void *addr, int len, LONGEST val) +store_signed_integer (gdb_byte *addr, int len, LONGEST val) { - unsigned char *p; - unsigned char *startaddr = (unsigned char *) addr; - unsigned char *endaddr = startaddr + len; + gdb_byte *p; + gdb_byte *startaddr = addr; + gdb_byte *endaddr = startaddr + len; /* Start at the least significant end of the integer, and work towards the most significant. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) { for (p = endaddr - 1; p >= startaddr; --p) { @@ -204,7 +205,7 @@ store_signed_integer (void *addr, int len, LONGEST val) } void -store_unsigned_integer (void *addr, int len, ULONGEST val) +store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val) { unsigned char *p; unsigned char *startaddr = (unsigned char *) addr; @@ -212,7 +213,7 @@ store_unsigned_integer (void *addr, int len, ULONGEST val) /* Start at the least significant end of the integer, and work towards the most significant. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) { for (p = endaddr - 1; p >= startaddr; --p) { @@ -233,74 +234,88 @@ store_unsigned_integer (void *addr, int len, ULONGEST val) /* Store the address ADDR as a pointer of type TYPE at BUF, in target form. */ void -store_typed_address (void *buf, struct type *type, CORE_ADDR addr) +store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) { if (TYPE_CODE (type) != TYPE_CODE_PTR && TYPE_CODE (type) != TYPE_CODE_REF) internal_error (__FILE__, __LINE__, - "store_typed_address: " - "type is not a pointer or reference"); + _("store_typed_address: " + "type is not a pointer or reference")); - ADDRESS_TO_POINTER (type, buf, addr); + gdbarch_address_to_pointer (current_gdbarch, type, buf, addr); } /* Return a `value' with the contents of (virtual or cooked) register REGNUM as found in the specified FRAME. The register's type is - determined by register_type(). - - NOTE: returns NULL if register value is not available. Caller will - check return value or die! */ + determined by register_type(). */ 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; - char raw_buffer[MAX_REGISTER_SIZE]; + 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. */ - if (regnum >= NUM_REGS + NUM_PSEUDO_REGS) + if (regnum >= gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch)) return value_of_user_reg (regnum, frame); frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer); - /* FIXME: cagney/2002-05-15: This test is just bogus. + reg_val = allocate_value (register_type (gdbarch, regnum)); - It indicates that the target failed to supply a value for a - register because it was "not available" at this time. Problem - is, the target still has the register and so get saved_register() - may be returning a value saved on the stack. */ + memcpy (value_contents_raw (reg_val), raw_buffer, + 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); + VALUE_FRAME_ID (reg_val) = get_frame_id (frame); + return reg_val; +} - if (register_cached (regnum) < 0) - return NULL; /* register value not available */ +/* Return a `value' with the contents of (virtual or cooked) register + REGNUM as found in the specified FRAME. The register's type is + determined by register_type(). The value is not fetched. */ - reg_val = allocate_value (register_type (current_gdbarch, regnum)); +struct value * +value_of_register_lazy (struct frame_info *frame, int regnum) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + struct value *reg_val; - memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer, - register_size (current_gdbarch, regnum)); - VALUE_LVAL (reg_val) = lval; - VALUE_ADDRESS (reg_val) = addr; + gdb_assert (regnum < (gdbarch_num_regs (gdbarch) + + gdbarch_num_pseudo_regs (gdbarch))); + + /* 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)); + VALUE_LVAL (reg_val) = lval_register; VALUE_REGNUM (reg_val) = regnum; - VALUE_OPTIMIZED_OUT (reg_val) = optim; + 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 void *buf) +unsigned_pointer_to_address (struct type *type, const gdb_byte *buf) { return extract_unsigned_integer (buf, TYPE_LENGTH (type)); } CORE_ADDR -signed_pointer_to_address (struct type *type, const void *buf) +signed_pointer_to_address (struct type *type, const gdb_byte *buf) { return extract_signed_integer (buf, TYPE_LENGTH (type)); } @@ -308,13 +323,14 @@ signed_pointer_to_address (struct type *type, const void *buf) /* Given an address, store it as a pointer of type TYPE in target format in BUF. */ void -unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) +unsigned_address_to_pointer (struct type *type, gdb_byte *buf, + CORE_ADDR addr) { store_unsigned_integer (buf, TYPE_LENGTH (type), addr); } void -address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr) +address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr) { store_signed_integer (buf, TYPE_LENGTH (type), addr); } @@ -330,7 +346,6 @@ symbol_read_needs_frame (struct symbol *sym) /* All cases listed explicitly so that gcc -Wall will detect it if we failed to consider one. */ case LOC_COMPUTED: - case LOC_COMPUTED_ARG: /* 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 @@ -341,19 +356,13 @@ symbol_read_needs_frame (struct symbol *sym) case LOC_REGISTER: case LOC_ARG: case LOC_REF_ARG: - case LOC_REGPARM: case LOC_REGPARM_ADDR: case LOC_LOCAL: - case LOC_LOCAL_ARG: - case LOC_BASEREG: - case LOC_BASEREG_ARG: - case LOC_HP_THREAD_LOCAL_STATIC: return 1; case LOC_UNDEF: case LOC_CONST: case LOC_STATIC: - case LOC_INDIRECT: case LOC_TYPEDEF: case LOC_LABEL: @@ -373,8 +382,7 @@ symbol_read_needs_frame (struct symbol *sym) /* 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. - If FRAME is NULL, use the deprecated_selected_frame. */ + If the variable cannot be found, return a zero pointer. */ struct value * read_var_value (struct symbol *var, struct frame_info *frame) @@ -384,22 +392,26 @@ read_var_value (struct symbol *var, struct frame_info *frame) CORE_ADDR addr; int len; - v = allocate_value (type); - VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */ + 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); - - /* FIXME drow/2003-09-06: this call to the selected frame should be - pushed upwards to the callers. */ - if (frame == NULL) - frame = deprecated_safe_get_selected_frame (); + if (symbol_read_needs_frame (var)) + gdb_assert (frame); switch (SYMBOL_CLASS (var)) { case LOC_CONST: /* Put the constant back in target format. */ - store_signed_integer (VALUE_CONTENTS_RAW (v), len, + store_signed_integer (value_contents_raw (v), len, (LONGEST) SYMBOL_VALUE (var)); VALUE_LVAL (v) = not_lval; return v; @@ -410,20 +422,18 @@ read_var_value (struct symbol *var, struct frame_info *frame) { CORE_ADDR addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), - SYMBOL_BFD_SECTION (var)); - store_typed_address (VALUE_CONTENTS_RAW (v), type, addr); + SYMBOL_OBJ_SECTION (var)); + store_typed_address (value_contents_raw (v), type, addr); } else - store_typed_address (VALUE_CONTENTS_RAW (v), type, + store_typed_address (value_contents_raw (v), type, SYMBOL_VALUE_ADDRESS (var)); VALUE_LVAL (v) = not_lval; return v; case LOC_CONST_BYTES: { - char *bytes_addr; - bytes_addr = SYMBOL_VALUE_BYTES (var); - memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len); + memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len); VALUE_LVAL (v) = not_lval; return v; } @@ -431,31 +441,12 @@ read_var_value (struct symbol *var, struct frame_info *frame) case LOC_STATIC: if (overlay_debugging) addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), - SYMBOL_BFD_SECTION (var)); + SYMBOL_OBJ_SECTION (var)); else addr = SYMBOL_VALUE_ADDRESS (var); break; - case LOC_INDIRECT: - { - /* The import slot does not have a real address in it from the - dynamic loader (dld.sl on HP-UX), if the target hasn't - begun execution yet, so check for that. */ - CORE_ADDR locaddr; - struct value *loc; - if (!target_has_execution) - error ("\ -Attempt to access variable defined in different shared object or load module when\n\ -addresses have not been bound by the dynamic loader. Try again when executable is running."); - - locaddr = SYMBOL_VALUE_ADDRESS (var); - loc = value_at (lookup_pointer_type (type), locaddr); - addr = value_as_address (loc); - } - case LOC_ARG: - if (frame == NULL) - return 0; addr = get_frame_args_address (frame); if (!addr) return 0; @@ -466,8 +457,6 @@ addresses have not been bound by the dynamic loader. Try again when executable i { struct value *ref; CORE_ADDR argref; - if (frame == NULL) - return 0; argref = get_frame_args_address (frame); if (!argref) return 0; @@ -478,52 +467,28 @@ addresses have not been bound by the dynamic loader. Try again when executable i } case LOC_LOCAL: - case LOC_LOCAL_ARG: - if (frame == NULL) - return 0; addr = get_frame_locals_address (frame); addr += SYMBOL_VALUE (var); break; - case LOC_BASEREG: - case LOC_BASEREG_ARG: - case LOC_HP_THREAD_LOCAL_STATIC: - { - struct value *regval; - - regval = value_from_register (lookup_pointer_type (type), - SYMBOL_BASEREG (var), frame); - if (regval == NULL) - error ("Value of base register not available."); - addr = value_as_address (regval); - addr += SYMBOL_VALUE (var); - break; - } - case LOC_TYPEDEF: - error ("Cannot look up value of a typedef"); + error (_("Cannot look up value of a typedef")); break; case LOC_BLOCK: if (overlay_debugging) - VALUE_ADDRESS (v) = symbol_overlayed_address - (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var)); + set_value_address (v, symbol_overlayed_address + (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var))); else - VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); + set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var))); return v; case LOC_REGISTER: - case LOC_REGPARM: case LOC_REGPARM_ADDR: { - struct block *b; int regno = SYMBOL_VALUE (var); struct value *regval; - if (frame == NULL) - return 0; - b = get_frame_block (frame, 0); - if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) { regval = value_from_register (lookup_pointer_type (type), @@ -531,7 +496,7 @@ addresses have not been bound by the dynamic loader. Try again when executable i frame); if (regval == NULL) - error ("Value of register variable not available."); + error (_("Value of register variable not available.")); addr = value_as_address (regval); VALUE_LVAL (v) = lval_memory; @@ -541,228 +506,140 @@ addresses have not been bound by the dynamic loader. Try again when executable i regval = value_from_register (type, regno, frame); if (regval == NULL) - error ("Value of register variable not available."); + error (_("Value of register variable not available.")); return regval; } } break; case LOC_COMPUTED: - case LOC_COMPUTED_ARG: /* 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. */ - if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var)) - return 0; return SYMBOL_OPS (var)->read_variable (var, frame); case LOC_UNRESOLVED: { struct minimal_symbol *msym; + struct obj_section *obj_section; - msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL); + msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL); if (msym == NULL) return 0; if (overlay_debugging) addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), - SYMBOL_BFD_SECTION (msym)); + SYMBOL_OBJ_SECTION (msym)); else addr = SYMBOL_VALUE_ADDRESS (msym); + + obj_section = SYMBOL_OBJ_SECTION (msym); + if (obj_section + && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) + addr = target_translate_tls_address (obj_section->objfile, addr); } break; case LOC_OPTIMIZED_OUT: VALUE_LVAL (v) = not_lval; - VALUE_OPTIMIZED_OUT (v) = 1; + set_value_optimized_out (v, 1); return v; default: - error ("Cannot look up value of a botched symbol."); + error (_("Cannot look up value of a botched symbol.")); break; } - VALUE_ADDRESS (v) = addr; - VALUE_LAZY (v) = 1; + set_value_address (v, addr); + set_value_lazy (v, 1); return v; } -/* Return a value of type TYPE, stored in register REGNUM, in frame - FRAME. +/* Install default attributes for register values. */ - NOTE: returns NULL if register value is not available. - Caller will check return value or die! */ +struct value * +default_value_from_register (struct type *type, int regnum, + struct frame_info *frame) +{ + 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_REGNUM (value) = regnum; + + /* Any structure stored in more than one register will always be + an integral number of registers. Otherwise, you need to do + some fiddling with the last register copied here for little + endian machines. */ + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG + && len < register_size (gdbarch, regnum)) + /* Big-endian, and we want less than full size. */ + set_value_offset (value, register_size (gdbarch, regnum) - len); + else + set_value_offset (value, 0); + + return value; +} + +/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */ struct value * value_from_register (struct type *type, int regnum, struct frame_info *frame) { struct gdbarch *gdbarch = get_frame_arch (frame); - struct value *v = allocate_value (type); - CHECK_TYPEDEF (type); + struct type *type1 = check_typedef (type); + struct value *v; - if (TYPE_LENGTH (type) == 0) - { - /* It doesn't matter much what we return for this: since the - length is zero, it could be anything. But if allowed to see - a zero-length type, the register-finding loop below will set - neither mem_stor nor reg_stor, and then report an internal - error. - - Zero-length types can legitimately arise from declarations - like 'struct {}' (a GCC extension, not valid ISO C). GDB may - also create them when it finds bogus debugging information; - for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the - STABS BINCL->EXCL compression process can create bad type - numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero - length. (That bug is actually the only known way to get a - zero-length value allocated to a register --- which is what - it takes to make it here.) - - We'll just attribute the value to the original register. */ - VALUE_LVAL (v) = lval_register; - VALUE_ADDRESS (v) = regnum; - VALUE_REGNUM (v) = regnum; - } - else if (CONVERT_REGISTER_P (regnum, type)) + if (gdbarch_convert_register_p (gdbarch, regnum, type1)) { /* 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 i386). It might need to convert the [float] register into the corresponding [integer] type (see Alpha). The assumption - is that REGISTER_TO_VALUE populates the entire value + is that gdbarch_register_to_value populates the entire value including the location. */ - REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v)); + v = allocate_value (type); 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)); } else { - int local_regnum; - int mem_stor = 0, reg_stor = 0; - int mem_tracking = 1; - CORE_ADDR last_addr = 0; - CORE_ADDR first_addr = 0; - int first_realnum = regnum; int len = TYPE_LENGTH (type); - int value_bytes_copied; - int optimized = 0; - char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE); - - /* Copy all of the data out, whereever it may be. */ - for (local_regnum = regnum, value_bytes_copied = 0; - value_bytes_copied < len; - (value_bytes_copied += register_size (current_gdbarch, local_regnum), - ++local_regnum)) - { - int realnum; - int optim; - enum lval_type lval; - CORE_ADDR addr; - frame_register (frame, local_regnum, &optim, &lval, &addr, - &realnum, value_bytes + value_bytes_copied); - optimized += optim; - if (register_cached (local_regnum) == -1) - return NULL; /* register value not available */ - - if (regnum == local_regnum) - { - first_addr = addr; - first_realnum = realnum; - } - if (lval == lval_register) - reg_stor++; - else - { - mem_stor++; - - /* FIXME: cagney/2004-11-12: I think this is trying to - check that the stored registers are adjacent in - memory. It isn't doing a good job? */ - mem_tracking = (mem_tracking - && (regnum == local_regnum - || addr == last_addr)); - } - last_addr = addr; - } - - if (mem_tracking && mem_stor && !reg_stor) - { - VALUE_LVAL (v) = lval_memory; - VALUE_ADDRESS (v) = first_addr; - } - else - { - VALUE_LVAL (v) = lval_register; - VALUE_FRAME_ID (v) = get_frame_id (frame); - VALUE_REGNUM (v) = regnum; - } - - VALUE_OPTIMIZED_OUT (v) = optimized; - - /* Any structure stored in more than one register will always be - an integral number of registers. Otherwise, you need to do - some fiddling with the last register copied here for little - endian machines. */ - if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG - && len < register_size (current_gdbarch, regnum)) - /* Big-endian, and we want less than full size. */ - v->offset = register_size (current_gdbarch, regnum) - len; - else - v->offset = 0; - memcpy (VALUE_CONTENTS_RAW (v), value_bytes + value_offset (v), len); + + /* 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); } return v; } - -/* Given a struct symbol for a variable or function, - and a stack frame id, - return a (pointer to a) struct value containing the properly typed - address. */ +/* Return contents of register REGNUM in frame FRAME as address, + interpreted as value of type TYPE. Will abort if register + value is not available. */ -struct value * -locate_var_value (struct symbol *var, struct frame_info *frame) +CORE_ADDR +address_from_register (struct type *type, int regnum, struct frame_info *frame) { - CORE_ADDR addr = 0; - struct type *type = SYMBOL_TYPE (var); - struct value *lazy_value; - - /* Evaluate it first; if the result is a memory address, we're fine. - Lazy evaluation pays off here. */ + struct value *value; + CORE_ADDR result; - lazy_value = read_var_value (var, frame); - if (lazy_value == 0) - error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var)); + value = value_from_register (type, regnum, frame); + gdb_assert (value); - if (VALUE_LAZY (lazy_value) - || TYPE_CODE (type) == TYPE_CODE_FUNC) - { - struct value *val; - - addr = VALUE_ADDRESS (lazy_value); - val = value_from_pointer (lookup_pointer_type (type), addr); - return val; - } + result = value_as_address (value); + release_value (value); + value_free (value); - /* Not a memory address; check what the problem was. */ - switch (VALUE_LVAL (lazy_value)) - { - case lval_register: - gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL - && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0'); - error("Address requested for identifier " - "\"%s\" which is in register $%s", - SYMBOL_PRINT_NAME (var), - REGISTER_NAME (VALUE_REGNUM (lazy_value))); - break; - - default: - error ("Can't take address of \"%s\" which isn't an lvalue.", - SYMBOL_PRINT_NAME (var)); - break; - } - return 0; /* For lint -- never reached */ + return result; }