2008-03-25 Pedro Alves <pedro@codesourcery.com>

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

diff --git a/gdb/eval.c b/gdb/eval.c
index 188cca0e0b09b39abfc6e9ed696a48e4c3b0a118..79defebe84eac914c4b89593446cdf60b16cd1f2 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -512,7 +512,15 @@ evaluate_subexp_standard (struct type *expect_type,
                                          name, strlen (name));
        if (regno == -1)
          error (_("Register $%s not available."), name);
-       if (noside == EVAL_AVOID_SIDE_EFFECTS)
+
+        /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
+           a value with the appropriate register type.  Unfortunately,
+           we don't have easy access to the type of user registers.
+           So for these registers, we fetch the register value regardless
+           of the evaluation mode.  */
+       if (noside == EVAL_AVOID_SIDE_EFFECTS
+           && regno < gdbarch_num_regs (current_gdbarch)
+              + gdbarch_num_pseudo_regs (current_gdbarch))
          val = value_zero (register_type (current_gdbarch, regno), not_lval);
        else
          val = value_of_register (regno, get_selected_frame (NULL));
@@ -686,7 +694,7 @@ evaluate_subexp_standard (struct type *expect_type,
              for (; range_low <= range_high; range_low++)
                {
                  int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
-                 if (BITS_BIG_ENDIAN)
+                 if (gdbarch_bits_big_endian (current_gdbarch))
                    bit_index = TARGET_CHAR_BIT - 1 - bit_index;
                  valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
                    |= 1 << bit_index;
@@ -1496,6 +1504,7 @@ evaluate_subexp_standard (struct type *expect_type,
     case BINOP_EXP:
     case BINOP_MUL:
     case BINOP_DIV:
+    case BINOP_INTDIV:
     case BINOP_REM:
     case BINOP_MOD:
     case BINOP_LSH:
@@ -1509,11 +1518,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))
-       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);
@@ -2176,14 +2204,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);
     }