* configure: Regenerate to track ../common/common.m4 changes.

[deliverable/binutils-gdb.git] / gdb / eval.c

diff --git a/gdb/eval.c b/gdb/eval.c
index 6e5be65921cbbd2aad8f459282e5dff0d5213e91..bbd7539a9fbbe80970685135a798f6f28cb960c8 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -175,6 +175,36 @@ evaluate_type (struct expression *exp)
   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 }
 
+/* Evaluate a subexpression, avoiding all memory references and
+   getting a value whose type alone is correct.  */
+
+struct value *
+evaluate_subexpression_type (struct expression *exp, int subexp)
+{
+  return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
+}
+
+/* Extract a field operation from an expression.  If the subexpression
+   of EXP starting at *SUBEXP is not a structure dereference
+   operation, return NULL.  Otherwise, return the name of the
+   dereferenced field, and advance *SUBEXP to point to the
+   subexpression of the left-hand-side of the dereference.  This is
+   used when completing field names.  */
+
+char *
+extract_field_op (struct expression *exp, int *subexp)
+{
+  int tem;
+  char *result;
+  if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
+      && exp->elts[*subexp].opcode != STRUCTOP_PTR)
+    return NULL;
+  tem = longest_to_int (exp->elts[*subexp + 1].longconst);
+  result = &exp->elts[*subexp + 2].string;
+  (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
+  return result;
+}
+
 /* If the next expression is an OP_LABELED, skips past it,
    returning the label.  Otherwise, does nothing and returns NULL. */
 
@@ -918,26 +948,27 @@ evaluate_subexp_standard (struct type *expect_type,
          {
            struct block *b;
            CORE_ADDR funaddr;
-           struct type *value_type;
+           struct type *val_type;
 
-           funaddr = find_function_addr (method, &value_type);
+           funaddr = find_function_addr (method, &val_type);
 
            b = block_for_pc (funaddr);
 
-           CHECK_TYPEDEF (value_type);
+           CHECK_TYPEDEF (val_type);
          
-           if ((value_type == NULL) 
-               || (TYPE_CODE(value_type) == TYPE_CODE_ERROR))
+           if ((val_type == NULL) 
+               || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
              {
                if (expect_type != NULL)
-                 value_type = expect_type;
+                 val_type = expect_type;
              }
 
-           struct_return = using_struct_return (value_type);
+           struct_return = using_struct_return (value_type (method), val_type);
          }
        else if (expect_type != NULL)
          {
-           struct_return = using_struct_return (check_typedef (expect_type));
+           struct_return = using_struct_return (NULL,
+                                                check_typedef (expect_type));
          }
        
        /* Found a function symbol.  Now we will substitute its
@@ -1518,12 +1549,30 @@ evaluate_subexp_standard (struct type *expect_type,
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, op, OP_NULL, noside);
-      else if (noside == EVAL_AVOID_SIDE_EFFECTS
-              && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD
-                  || op == BINOP_INTDIV))
-       return value_zero (value_type (arg1), not_lval);
       else
-       return value_binop (arg1, arg2, op);
+       {
+         /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
+            fudge arg2 to avoid division-by-zero, the caller is
+            (theoretically) only looking for the type of the result.  */
+         if (noside == EVAL_AVOID_SIDE_EFFECTS
+             /* ??? Do we really want to test for BINOP_MOD here?
+                The implementation of value_binop gives it a well-defined
+                value.  */
+             && (op == BINOP_DIV
+                 || op == BINOP_INTDIV
+                 || op == BINOP_REM
+                 || op == BINOP_MOD)
+             && value_logical_not (arg2))
+           {
+             struct value *v_one, *retval;
+
+             v_one = value_one (value_type (arg2), not_lval);
+             retval = value_binop (arg1, v_one, op);
+             return retval;
+           }
+         else
+           return value_binop (arg1, arg2, op);
+       }
 
     case BINOP_RANGE:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
@@ -1702,7 +1751,7 @@ evaluate_subexp_standard (struct type *expect_type,
           returns the correct type value */
 
        deprecated_set_value_type (arg1, tmp_type);
-       return value_ind (value_add (value_coerce_array (arg1), arg2));
+       return value_subscripted_rvalue (arg1, arg2, 0);
       }
 
     case BINOP_LOGICAL_AND:
@@ -2153,8 +2202,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
 
          if (sym_class == LOC_CONST
              || sym_class == LOC_CONST_BYTES
-             || sym_class == LOC_REGISTER
-             || sym_class == LOC_REGPARM)
+             || sym_class == LOC_REGISTER)
            error (_("Attempt to take address of register or constant."));
 
          return
@@ -2186,14 +2234,14 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
        {
          struct type *type = check_typedef (value_type (x));
 
-         if (VALUE_LVAL (x) == lval_memory)
+         if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
            return value_zero (lookup_pointer_type (value_type (x)),
                               not_lval);
          else if (TYPE_CODE (type) == TYPE_CODE_REF)
            return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
                               not_lval);
          else
-           error (_("Attempt to take address of non-lval"));
+           error (_("Attempt to take address of value not located in memory."));
        }
       return value_addr (x);
     }