X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ffindvar.c;h=a39d89788e8c16dd128887913c3ac8d8d998cb95;hb=45e3745ed0e034fdec5beee0738f383bd6e2e045;hp=0cda35e75ad982fd8e3983c3c2d8ece5b519339c;hpb=4e38b3864ce96e88108671bd271c71ee461e9404;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/findvar.c b/gdb/findvar.c
index 0cda35e75a..a39d89788e 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -1,14 +1,12 @@
 /* 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 Free
-   Software Foundation, Inc.
+   Copyright (C) 1986-2016 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 +15,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., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "symtab.h"
@@ -29,16 +25,18 @@
 #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.  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
@@ -49,7 +47,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;
@@ -63,7 +62,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (byte_order == BFD_ENDIAN_BIG)
     {
       p = startaddr;
       /* Do the sign extension once at the start.  */
@@ -83,7 +82,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;
@@ -98,7 +98,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (byte_order == BFD_ENDIAN_BIG)
     {
       for (p = startaddr; p < endaddr; ++p)
 	retval = (retval << 8) | *p;
@@ -118,14 +118,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (byte_order == BFD_ENDIAN_BIG)
     {
       for (p = addr;
 	   len > (int) sizeof (LONGEST) && p < addr + orig_len;
@@ -155,7 +155,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;
     }
 
@@ -174,12 +175,15 @@ extract_typed_address (const gdb_byte *buf, struct type *type)
 		    _("extract_typed_address: "
 		    "type is not a pointer or reference"));
 
-  return POINTER_TO_ADDRESS (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;
@@ -187,7 +191,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (byte_order == BFD_ENDIAN_BIG)
     {
       for (p = endaddr - 1; p >= startaddr; --p)
 	{
@@ -206,7 +210,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;
@@ -214,7 +219,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (byte_order == BFD_ENDIAN_BIG)
     {
       for (p = endaddr - 1; p >= startaddr; --p)
 	{
@@ -243,53 +248,51 @@ store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
 		    _("store_typed_address: "
 		    "type is not a pointer or reference"));
 
-  ADDRESS_TO_POINTER (type, buf, addr);
+  gdbarch_address_to_pointer (get_type_arch (type), 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)
 {
-  CORE_ADDR addr;
-  int optim;
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   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.  */
-  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);
+  reg_val = value_of_register_lazy (frame, regnum);
+  value_fetch_lazy (reg_val);
+  return reg_val;
+}
 
-  /* FIXME: cagney/2002-05-15: This test is just bogus.
+/* 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.  */
 
-     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.  */
+struct value *
+value_of_register_lazy (struct frame_info *frame, int regnum)
+{
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  struct value *reg_val;
 
-  if (register_cached (regnum) < 0)
-    return NULL;		/* register value not available */
+  gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
+			+ gdbarch_num_pseudo_regs (gdbarch)));
 
-  reg_val = allocate_value (register_type (current_gdbarch, regnum));
+  /* We should have a valid (i.e. non-sentinel) frame.  */
+  gdb_assert (frame_id_p (get_frame_id (frame)));
 
-  memcpy (value_contents_raw (reg_val), raw_buffer,
-	  register_size (current_gdbarch, regnum));
-  VALUE_LVAL (reg_val) = lval;
-  VALUE_ADDRESS (reg_val) = addr;
+  reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
+  VALUE_LVAL (reg_val) = lval_register;
   VALUE_REGNUM (reg_val) = regnum;
-  set_value_optimized_out (reg_val, optim);
   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
   return reg_val;
 }
@@ -297,30 +300,41 @@ value_of_register (int regnum, struct frame_info *frame)
 /* 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
@@ -329,35 +343,26 @@ 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:
-    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.  */
-      return SYMBOL_OPS (sym)->read_needs_frame (sym);
+      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 
     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:
@@ -374,55 +379,244 @@ 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.
-   If FRAME is NULL, use the deprecated_selected_frame.  */
+/* 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 <optimized out> instead of <frame required> 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;
 
-  if (SYMBOL_CLASS (var) == LOC_COMPUTED
-      || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
-      || SYMBOL_CLASS (var) == LOC_REGISTER
-      || SYMBOL_CLASS (var) == LOC_REGPARM)
-    /* These cases do not use V.  */
-    v = NULL;
-  else
-    {
-      v = allocate_value (type);
-      VALUE_LVAL (v) = lval_memory;	/* The most likely possibility.  */
-    }
+  /* 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);
 
-  len = TYPE_LENGTH (type);
+  if (symbol_read_needs_frame (var))
+    gdb_assert (frame != NULL);
 
-  /* 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 (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.  */
-      store_signed_integer (value_contents_raw (v), len,
+      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), 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_BFD_SECTION (var));
+					SYMBOL_OBJ_SECTION (symbol_objfile (var),
+							    var));
+
 	  store_typed_address (value_contents_raw (v), type, addr);
 	}
       else
@@ -432,44 +626,31 @@ 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;
-      }
+      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),
+	      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_BFD_SECTION (var));
+					 SYMBOL_OBJ_SECTION (symbol_objfile (var),
+							     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);
-	break;
-      }
-
     case LOC_ARG:
-      if (frame == NULL)
-	return 0;
       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;
 
@@ -477,11 +658,11 @@ 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;
+	  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);
@@ -489,52 +670,31 @@ 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 `%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_BFD_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:
     case LOC_REGPARM_ADDR:
       {
-	struct block *b;
-	int regno = SYMBOL_VALUE (var);
+	int regno = SYMBOL_REGISTER_OPS (var)
+		      ->register_number (var, get_frame_arch (frame));
 	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),
@@ -542,238 +702,282 @@ 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 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:
-    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);
+      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;
+
+	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;
 
-	msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
+	/* 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_BFD_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);
+	   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);
       }
       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;
 }
 
-/* Return a value of type TYPE, stored in register REGNUM, in frame
-   FRAME.
+/* Calls VAR's language la_read_var_value hook with the given arguments.  */
 
-   NOTE: returns NULL if register value is not available.
-   Caller will check return value or die!  */
+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 *
-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)
+{
+  int len = TYPE_LENGTH (type);
+  struct value *value = allocate_value (type);
+
+  VALUE_LVAL (value) = lval_register;
+  VALUE_FRAME_ID (value) = frame_id;
+  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;
+}
+
+/* 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);
-  struct value *v = allocate_value (type);
-  CHECK_TYPEDEF (type);
+  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);
 
-  if (TYPE_LENGTH (type) == 0)
+  /* Skip registers wholly inside of REG_OFFSET.  */
+  while (reg_offset >= register_size (gdbarch, regnum))
     {
-      /* 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;
+      reg_offset -= register_size (gdbarch, regnum);
+      regnum++;
     }
-  else if (CONVERT_REGISTER_P (regnum, type))
+
+  /* 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 *
+value_from_register (struct type *type, int regnum, struct frame_info *frame)
+{
+  struct gdbarch *gdbarch = get_frame_arch (frame);
+  struct type *type1 = check_typedef (type);
+  struct value *v;
+
+  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
          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;
+      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 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;
-      gdb_byte *value_bytes = 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;
-	}
-      
-      set_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.  */
-	set_value_offset (v, register_size (current_gdbarch, regnum) - len);
-      else
-	set_value_offset (v, 0);
-      memcpy (value_contents_raw (v), value_bytes + value_offset (v), len);
+      /* Construct the value.  */
+      v = gdbarch_value_from_register (gdbarch, type,
+				       regnum, get_frame_id (frame));
+
+      /* Get the data.  */
+      read_frame_register_value (v, frame);
     }
+
   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.
+   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 (int regnum, struct frame_info *frame)
 {
-  CORE_ADDR addr = 0;
-  struct type *type = SYMBOL_TYPE (var);
-  struct value *lazy_value;
+  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;
 
-  /* Evaluate it first; if the result is a memory address, we're fine.
-     Lazy evaluation pays off here. */
+      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 ();
+	}
 
-  lazy_value = read_var_value (var, frame);
-  if (lazy_value == 0)
-    error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
+      return unpack_long (type, buf);
+    }
 
-  if (value_lazy (lazy_value)
-      || TYPE_CODE (type) == TYPE_CODE_FUNC)
-    {
-      struct value *val;
+  value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
+  read_frame_register_value (value, frame);
 
-      addr = VALUE_ADDRESS (lazy_value);
-      val = value_from_pointer (lookup_pointer_type (type), addr);
-      return val;
+  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 ();
     }
 
-  /* 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;
+  result = value_as_address (value);
+  release_value (value);
+  value_free (value);
 
-    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;
 }
+