Pass architecture from ``set arch MACH'' command into disasembler

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

diff --git a/gdb/eval.c b/gdb/eval.c
index eaf0b29a7f0c5896dcfa09973f7dca5dae92003d..4a7da00e6028e1a11d056103cbb1fb9d20273dce 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1,5 +1,5 @@
 /* Evaluate expressions for GDB.
 /* Evaluate expressions for GDB.

-   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
+   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997

    Free Software Foundation, Inc.
 
 This file is part of GDB.
    Free Software Foundation, Inc.
 
 This file is part of GDB.


@@ -43,6 +43,19 @@ static value_ptr evaluate_subexp_for_sizeof PARAMS ((struct expression *,
 static value_ptr evaluate_subexp_for_address PARAMS ((struct expression *,
                                                      int *, enum noside));
 
 static value_ptr evaluate_subexp_for_address PARAMS ((struct expression *,
                                                      int *, enum noside));
 

+static value_ptr evaluate_subexp PARAMS ((struct type *, struct expression *,
+                                         int *, enum noside));
+
+static char *get_label PARAMS ((struct expression *, int *));
+
+static value_ptr
+evaluate_struct_tuple PARAMS ((value_ptr, struct expression *, int *,
+                              enum noside, int));
+
+static LONGEST
+init_array_element PARAMS ((value_ptr, value_ptr, struct expression *,
+                           int *, enum noside, LONGEST, LONGEST));
+

 #ifdef __GNUC__
 inline
 #endif
 #ifdef __GNUC__
 inline
 #endif


@@ -283,7 +296,7 @@ evaluate_struct_tuple (struct_val, exp, pos, noside, nargs)
 
          field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
          if (val == 0)
 
          field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
          if (val == 0)

-           val = evaluate_subexp (substruct_type, exp, pos, noside);
+           val = evaluate_subexp (field_type, exp, pos, noside);

 
          /* Now actually set the field in struct_val. */
 
 
          /* Now actually set the field in struct_val. */
 


@@ -321,6 +334,7 @@ init_array_element (array, element, exp, pos, noside, low_bound, high_bound)
      register struct expression *exp;
      register int *pos;
      enum noside noside;
      register struct expression *exp;
      register int *pos;
      enum noside noside;

+     LONGEST low_bound, high_bound;

 {
   LONGEST index;
   int element_size = TYPE_LENGTH (VALUE_TYPE (element));
 {
   LONGEST index;
   int element_size = TYPE_LENGTH (VALUE_TYPE (element));


@@ -335,7 +349,6 @@ init_array_element (array, element, exp, pos, noside, low_bound, high_bound)
   else if (exp->elts[*pos].opcode == BINOP_RANGE)
     {
       LONGEST low, high;
   else if (exp->elts[*pos].opcode == BINOP_RANGE)
     {
       LONGEST low, high;

-      value_ptr val;

       (*pos)++;
       low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
       high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
       (*pos)++;
       low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
       high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));


@@ -460,11 +473,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
 
     case OP_BOOL:
       (*pos) += 2;
 
     case OP_BOOL:
       (*pos) += 2;

-      if (current_language->la_language == language_fortran)
-       return value_from_longest (builtin_type_f_logical_s2,
-                                  exp->elts[pc + 1].longconst);
-      else
-       return value_from_longest (builtin_type_chill_bool,
+      return value_from_longest (LA_BOOL_TYPE,

                                   exp->elts[pc + 1].longconst);
 
     case OP_INTERNALVAR:
                                   exp->elts[pc + 1].longconst);
 
     case OP_INTERNALVAR:


@@ -539,6 +548,9 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
                }
              else
                {
                }
              else
                {

+                 if (index > high_bound)
+                   /* to avoid memory corruption */
+                   error ("Too many array elements");

                  memcpy (VALUE_CONTENTS_RAW (array)
                          + (index - low_bound) * element_size,
                          VALUE_CONTENTS (element),
                  memcpy (VALUE_CONTENTS_RAW (array)
                          + (index - low_bound) * element_size,
                          VALUE_CONTENTS (element),


@@ -555,27 +567,54 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
          value_ptr set = allocate_value (expect_type);
          char *valaddr = VALUE_CONTENTS_RAW (set);
          struct type *element_type = TYPE_INDEX_TYPE (type);
          value_ptr set = allocate_value (expect_type);
          char *valaddr = VALUE_CONTENTS_RAW (set);
          struct type *element_type = TYPE_INDEX_TYPE (type);

+         struct type *check_type = element_type;

          LONGEST low_bound, high_bound;
          LONGEST low_bound, high_bound;

+
+         /* get targettype of elementtype */
+         while (TYPE_CODE (check_type) == TYPE_CODE_RANGE ||
+                TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
+           check_type = TYPE_TARGET_TYPE (check_type);
+

          if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
            error ("(power)set type with unknown size");
          memset (valaddr, '\0', TYPE_LENGTH (type));
          for (tem = 0; tem < nargs; tem++)
            {
              LONGEST range_low, range_high;
          if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
            error ("(power)set type with unknown size");
          memset (valaddr, '\0', TYPE_LENGTH (type));
          for (tem = 0; tem < nargs; tem++)
            {
              LONGEST range_low, range_high;

+             struct type *range_low_type, *range_high_type;

              value_ptr elem_val;
              if (exp->elts[*pos].opcode == BINOP_RANGE)
                {
                  (*pos)++;
                  elem_val = evaluate_subexp (element_type, exp, pos, noside);
              value_ptr elem_val;
              if (exp->elts[*pos].opcode == BINOP_RANGE)
                {
                  (*pos)++;
                  elem_val = evaluate_subexp (element_type, exp, pos, noside);

+                 range_low_type = VALUE_TYPE (elem_val);

                  range_low = value_as_long (elem_val);
                  elem_val = evaluate_subexp (element_type, exp, pos, noside);
                  range_low = value_as_long (elem_val);
                  elem_val = evaluate_subexp (element_type, exp, pos, noside);

+                 range_high_type = VALUE_TYPE (elem_val);

                  range_high = value_as_long (elem_val);
                }
              else
                {
                  elem_val = evaluate_subexp (element_type, exp, pos, noside);
                  range_high = value_as_long (elem_val);
                }
              else
                {
                  elem_val = evaluate_subexp (element_type, exp, pos, noside);

+                 range_low_type = range_high_type = VALUE_TYPE (elem_val);

                  range_low = range_high = value_as_long (elem_val);
                }
                  range_low = range_high = value_as_long (elem_val);
                }

+             /* check types of elements to avoid mixture of elements from
+                different types. Also check if type of element is "compatible"
+                with element type of powerset */
+             if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
+               range_low_type = TYPE_TARGET_TYPE (range_low_type);
+             if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
+               range_high_type = TYPE_TARGET_TYPE (range_high_type);
+             if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) ||
+                 (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM &&
+                  (range_low_type != range_high_type)))
+               /* different element modes */
+               error ("POWERSET tuple elements of different mode");
+             if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) ||
+                 (TYPE_CODE (check_type) == TYPE_CODE_ENUM &&
+                  range_low_type != check_type))
+               error ("incompatible POWERSET tuple elements");

              if (range_low > range_high)
                {
                  warning ("empty POWERSET tuple range");
              if (range_low > range_high)
                {
                  warning ("empty POWERSET tuple range");


@@ -647,11 +686,15 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
     case OP_FUNCALL:
       (*pos) += 2;
       op = exp->elts[*pos].opcode;
     case OP_FUNCALL:
       (*pos) += 2;
       op = exp->elts[*pos].opcode;

+      nargs = longest_to_int (exp->elts[pc + 1].longconst);
+      /* Allocate arg vector, including space for the function to be
+        called in argvec[0] and a terminating NULL */
+      argvec = (value_ptr *) alloca (sizeof (value_ptr) * (nargs + 3));

       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
        {
          LONGEST fnptr;
 
       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
        {
          LONGEST fnptr;
 

-         nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
+         nargs++;

          /* First, evaluate the structure into arg2 */
          pc2 = (*pos)++;
 
          /* First, evaluate the structure into arg2 */
          pc2 = (*pos)++;
 


@@ -694,7 +737,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
                  /* If one is virtual, then all are virtual.  */
                  if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
                    for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)
                  /* If one is virtual, then all are virtual.  */
                  if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
                    for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)

-                     if (TYPE_FN_FIELD_VOFFSET (f, j) == fnoffset)
+                     if ((int) TYPE_FN_FIELD_VOFFSET (f, j) == fnoffset)

                        {
                          value_ptr temp = value_ind (arg2);
                          arg1 = value_virtual_fn_field (&temp, f, j, domain_type, 0);
                        {
                          value_ptr temp = value_ind (arg2);
                          arg1 = value_virtual_fn_field (&temp, f, j, domain_type, 0);


@@ -719,7 +762,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
          /* Hair for method invocations */
          int tem2;
 
          /* Hair for method invocations */
          int tem2;
 

-         nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
+         nargs++;

          /* First, evaluate the structure into arg2 */
          pc2 = (*pos)++;
          tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
          /* First, evaluate the structure into arg2 */
          pc2 = (*pos)++;
          tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);


@@ -754,15 +797,27 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        }
       else
        {
        }
       else
        {

-         nargs = longest_to_int (exp->elts[pc + 1].longconst);
-         tem = 0;
+         argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
+         tem = 1;
+         type = VALUE_TYPE (argvec[0]);
+         if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
+           type = TYPE_TARGET_TYPE (type);
+         if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
+           {
+             for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
+               {
+                 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, tem-1),
+                                                exp, pos, noside);
+               }
+           }

        }
        }

-      /* Allocate arg vector, including space for the function to be
-        called in argvec[0] and a terminating NULL */
-      argvec = (value_ptr *) alloca (sizeof (value_ptr) * (nargs + 2));
+

       for (; tem <= nargs; tem++)
       for (; tem <= nargs; tem++)

-       /* Ensure that array expressions are coerced into pointer objects. */
-       argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+       {
+         /* Ensure that array expressions are coerced into pointer objects. */
+         
+         argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+       }

 
       /* signal end of arglist */
       argvec[tem] = 0;
 
       /* signal end of arglist */
       argvec[tem] = 0;


@@ -994,7 +1049,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, op, OP_NULL);
+       return value_x_binop (arg1, arg2, op, OP_NULL, noside);

       else
        return value_concat (arg1, arg2);
 
       else
        return value_concat (arg1, arg2);
 


@@ -1004,7 +1059,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
        return arg1;
       if (binop_user_defined_p (op, arg1, arg2))
       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
        return arg1;
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, op, OP_NULL);
+       return value_x_binop (arg1, arg2, op, OP_NULL, noside);

       else
        return value_assign (arg1, arg2);
 
       else
        return value_assign (arg1, arg2);
 


@@ -1016,7 +1071,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        return arg1;
       op = exp->elts[pc + 1].opcode;
       if (binop_user_defined_p (op, arg1, arg2))
        return arg1;
       op = exp->elts[pc + 1].opcode;
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op);
+       return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);

       else if (op == BINOP_ADD)
        arg2 = value_add (arg1, arg2);
       else if (op == BINOP_SUB)
       else if (op == BINOP_ADD)
        arg2 = value_add (arg1, arg2);
       else if (op == BINOP_SUB)


@@ -1031,7 +1086,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, op, OP_NULL);
+       return value_x_binop (arg1, arg2, op, OP_NULL, noside);

       else
        return value_add (arg1, arg2);
 
       else
        return value_add (arg1, arg2);
 


@@ -1041,7 +1096,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, op, OP_NULL);
+       return value_x_binop (arg1, arg2, op, OP_NULL, noside);

       else
        return value_sub (arg1, arg2);
 
       else
        return value_sub (arg1, arg2);
 


@@ -1059,7 +1114,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, op, OP_NULL);
+       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))
       else
        if (noside == EVAL_AVOID_SIDE_EFFECTS
            && (op == BINOP_DIV || op == BINOP_REM || op == BINOP_MOD))


@@ -1079,24 +1134,31 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
       if (noside == EVAL_SKIP)
        goto nosideret;
       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
       if (noside == EVAL_SKIP)
        goto nosideret;

-      if (noside == EVAL_AVOID_SIDE_EFFECTS)
-       {
-         /* If the user attempts to subscript something that has no target
-            type (like a plain int variable for example), then report this
-            as an error. */
-
-         type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
-         if (type)
-           return value_zero (type, VALUE_LVAL (arg1));
-         else
-           error ("cannot subscript something of type `%s'",
-                  TYPE_NAME (VALUE_TYPE (arg1)));
-       }
-                          

       if (binop_user_defined_p (op, arg1, arg2))
       if (binop_user_defined_p (op, arg1, arg2))

-       return value_x_binop (arg1, arg2, op, OP_NULL);
+       return value_x_binop (arg1, arg2, op, OP_NULL, noside);

       else
       else

-       return value_subscript (arg1, arg2);
+        {
+         /* If the user attempts to subscript something that is not an
+            array or pointer type (like a plain int variable for example),
+            then report this as an error. */
+
+         COERCE_REF (arg1);
+         type = check_typedef (VALUE_TYPE (arg1));
+         if (TYPE_CODE (type) != TYPE_CODE_ARRAY
+             && TYPE_CODE (type) != TYPE_CODE_PTR)
+           {
+             if (TYPE_NAME (type))
+               error ("cannot subscript something of type `%s'",
+                      TYPE_NAME (type));
+             else
+               error ("cannot subscript requested type");
+           }
+
+         if (noside == EVAL_AVOID_SIDE_EFFECTS)
+           return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
+         else
+           return value_subscript (arg1, arg2);
+        }

 
     case BINOP_IN:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
 
     case BINOP_IN:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);


@@ -1147,7 +1209,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
          
          if (binop_user_defined_p (op, arg1, arg2))
            {
          
          if (binop_user_defined_p (op, arg1, arg2))
            {

-             arg1 = value_x_binop (arg1, arg2, op, OP_NULL);
+             arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);

            }
          else
            {
            }
          else
            {


@@ -1251,7 +1313,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (binop_user_defined_p (op, arg1, arg2)) 
        {
          arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (binop_user_defined_p (op, arg1, arg2)) 
        {
          arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1277,7 +1339,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (binop_user_defined_p (op, arg1, arg2)) 
        {
          arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (binop_user_defined_p (op, arg1, arg2)) 
        {
          arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1295,7 +1357,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1310,7 +1372,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1325,7 +1387,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1340,7 +1402,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1355,7 +1417,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else
        {
        }
       else
        {


@@ -1370,7 +1432,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        {

-         return value_x_binop (arg1, arg2, op, OP_NULL);
+         return value_x_binop (arg1, arg2, op, OP_NULL, noside);

        }
       else 
        {
        }
       else 
        {


@@ -1383,7 +1445,8 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
        goto nosideret;
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
        goto nosideret;

-      if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT)
+      type = check_typedef (VALUE_TYPE (arg2));
+      if (TYPE_CODE (type) != TYPE_CODE_INT)

        error ("Non-integral right operand for \"@\" operator.");
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
        error ("Non-integral right operand for \"@\" operator.");
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {


@@ -1402,7 +1465,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (op, arg1))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (op, arg1))

-       return value_x_unop (arg1, op);
+       return value_x_unop (arg1, op, noside);

       else
        return value_neg (arg1);
 
       else
        return value_neg (arg1);
 


@@ -1414,7 +1477,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))

-       return value_x_unop (arg1, UNOP_COMPLEMENT);
+       return value_x_unop (arg1, UNOP_COMPLEMENT, noside);

       else
        return value_complement (arg1);
 
       else
        return value_complement (arg1);
 


@@ -1423,7 +1486,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (op, arg1))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (op, arg1))

-       return value_x_unop (arg1, op);
+       return value_x_unop (arg1, op, noside);

       else
        return value_from_longest (builtin_type_int,
                                   (LONGEST) value_logical_not (arg1));
       else
        return value_from_longest (builtin_type_int,
                                   (LONGEST) value_logical_not (arg1));


@@ -1498,7 +1561,8 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        return value_zero (exp->elts[pc + 1].type, lval_memory);
       else
        return value_at_lazy (exp->elts[pc + 1].type,
        return value_zero (exp->elts[pc + 1].type, lval_memory);
       else
        return value_at_lazy (exp->elts[pc + 1].type,

-                             value_as_pointer (arg1));
+                             value_as_pointer (arg1),
+                             NULL);

 
     case UNOP_PREINCREMENT:
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 
     case UNOP_PREINCREMENT:
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);


@@ -1506,7 +1570,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {

-         return value_x_unop (arg1, op);
+         return value_x_unop (arg1, op, noside);

        }
       else
        {
        }
       else
        {


@@ -1521,7 +1585,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {

-         return value_x_unop (arg1, op);
+         return value_x_unop (arg1, op, noside);

        }
       else
        {
        }
       else
        {


@@ -1536,7 +1600,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {

-         return value_x_unop (arg1, op);
+         return value_x_unop (arg1, op, noside);

        }
       else
        {
        }
       else
        {


@@ -1552,7 +1616,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {
        return arg1;
       else if (unop_user_defined_p (op, arg1))
        {

-         return value_x_unop (arg1, op);
+         return value_x_unop (arg1, op, noside);

        }
       else
        {
        }
       else
        {


@@ -1739,6 +1803,10 @@ evaluate_subexp_for_sizeof (exp, pos)
       (*pos)++;
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
       type = check_typedef (VALUE_TYPE (val));
       (*pos)++;
       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
       type = check_typedef (VALUE_TYPE (val));

+      if (TYPE_CODE (type) != TYPE_CODE_PTR
+         && TYPE_CODE (type) != TYPE_CODE_REF
+         && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+       error ("Attempt to take contents of a non-pointer value.");

       type = check_typedef (TYPE_TARGET_TYPE (type));
       return value_from_longest (builtin_type_int, (LONGEST)
                      TYPE_LENGTH (type));
       type = check_typedef (TYPE_TARGET_TYPE (type));
       return value_from_longest (builtin_type_int, (LONGEST)
                      TYPE_LENGTH (type));