* blockframe.c (block_innermost_frame): Uncomment.

	Return NULL if passed NULL.
	* frame.h: Declare it.
	* expression.h (union exp_element): Add field block.
	* parse.c (write_exp_elt_block): New function.
	* expression.h (OP_VAR_VALUE): Now takes additional struct block *.
	* *-exp.y: Write block for OP_VAR_VALUE.
	* eval.c, expprint.c, parse.c: Deal with block for OP_VAR_VALUE.
	* valops.c, value.h (value_of_variable), callers:
	Add second argument, for block.

1 files changed, 40 insertions, 15 deletions

diff --git a/gdb/eval.c b/gdb/eval.c
index 98774bf..4aba99f 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -197,7 +197,7 @@ evaluate_subexp (expect_type, exp, pos, noside)
 				exp->elts[pc + 2].doubleconst);
 
     case OP_VAR_VALUE:
-      (*pos) += 2;
+      (*pos) += 3;
       if (noside == EVAL_SKIP)
 	goto nosideret;
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -226,7 +226,8 @@ evaluate_subexp (expect_type, exp, pos, noside)
 	  return value_zero (SYMBOL_TYPE (sym), lv);
 	}
       else
-	return value_of_variable (exp->elts[pc + 1].symbol);
+	return value_of_variable (exp->elts[pc + 2].symbol,
+				  exp->elts[pc + 1].block);
 
     case OP_LAST:
       (*pos) += 2;
@@ -373,6 +374,20 @@ evaluate_subexp (expect_type, exp, pos, noside)
 
 	  if (op == STRUCTOP_STRUCT)
 	    {
+	      /* If v is a variable in a register, and the user types
+		 v.method (), this will produce an error, because v has
+		 no address.
+
+		 A possible way around this would be to allocate a
+		 copy of the variable on the stack, copy in the
+		 contents, call the function, and copy out the
+		 contents.  I.e. convert this from call by reference
+		 to call by copy-return (or whatever it's called).
+		 However, this does not work because it is not the
+		 same: the method being called could stash a copy of
+		 the address, and then future uses through that address
+		 (after the method returns) would be expected to
+		 use the variable itself, not some copy of it.  */
 	      arg2 = evaluate_subexp_for_address (exp, pos, noside);
 	    }
 	  else
@@ -1041,14 +1056,14 @@ evaluate_subexp_for_address (exp, pos, noside)
 			 evaluate_subexp (NULL_TYPE, exp, pos, noside));
 
     case OP_VAR_VALUE:
-      var = exp->elts[pc + 1].symbol;
+      var = exp->elts[pc + 2].symbol;
 
       /* C++: The "address" of a reference should yield the address
        * of the object pointed to. Let value_addr() deal with it. */
       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
         goto default_case;
 
-      (*pos) += 3;
+      (*pos) += 4;
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 	{
 	  struct type *type =
@@ -1065,7 +1080,10 @@ evaluate_subexp_for_address (exp, pos, noside)
 	  value_zero (type, not_lval);
 	}
       else
-	return locate_var_value (var, (FRAME) 0);
+	return
+	  locate_var_value
+	    (var,
+	     block_innermost_frame (exp->elts[pc + 1].block));
 
     default:
     default_case:
@@ -1085,14 +1103,15 @@ evaluate_subexp_for_address (exp, pos, noside)
 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
    When used in contexts where arrays will be coerced anyway, this is
    equivalent to `evaluate_subexp' but much faster because it avoids
-   actually fetching array contents.
+   actually fetching array contents (perhaps obsolete now that we have
+   VALUE_LAZY).
 
    Note that we currently only do the coercion for C expressions, where
    arrays are zero based and the coercion is correct.  For other languages,
    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION
    to decide if coercion is appropriate.
 
-  */
+   */
 
 static value
 evaluate_subexp_with_coercion (exp, pos, noside)
@@ -1111,17 +1130,21 @@ evaluate_subexp_with_coercion (exp, pos, noside)
   switch (op)
     {
     case OP_VAR_VALUE:
-      var = exp->elts[pc + 1].symbol;
+      var = exp->elts[pc + 2].symbol;
       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ARRAY
 	  && CAST_IS_CONVERSION)
 	{
-	  (*pos) += 3;
-	  val = locate_var_value (var, (FRAME) 0);
+	  (*pos) += 4;
+	  val =
+	    locate_var_value
+	      (var, block_innermost_frame (exp->elts[pc + 1].block));
 	  return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (var))),
 			     val);
 	}
-      default:
-	return evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      /* FALLTHROUGH */
+
+    default:
+      return evaluate_subexp (NULL_TYPE, exp, pos, noside);
     }
 }
 
@@ -1159,9 +1182,11 @@ evaluate_subexp_for_sizeof (exp, pos)
 			      (LONGEST) TYPE_LENGTH (exp->elts[pc + 1].type));
 
     case OP_VAR_VALUE:
-      (*pos) += 3;
-      return value_from_longest (builtin_type_int,
-	 (LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
+      (*pos) += 4;
+      return
+	value_from_longest
+	  (builtin_type_int,
+	   (LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 2].symbol)));
 
     default:
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);