ubsan: nios2: left shift cannot be represented in type 'int'

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

diff --git a/gdb/eval.c b/gdb/eval.c
index aed89e5f85a1a6806ec4b25df6f76d6d38e4336f..8c93c7a0b103af1aacb0950c80cf37b4ede65b0c 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -42,9 +42,6 @@
 #include "typeprint.h"
 #include <ctype.h>
 
-/* This is defined in valops.c */
-extern int overload_resolution;
-
 /* Prototypes for local functions.  */
 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
@@ -345,7 +342,7 @@ evaluate_struct_tuple (struct value *struct_val,
 /* Recursive helper function for setting elements of array tuples.
    The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
    element value is ELEMENT; EXP, POS and NOSIDE are as usual.
-   Evaluates index expresions and sets the specified element(s) of
+   Evaluates index expressions and sets the specified element(s) of
    ARRAY to ELEMENT.  Returns last index value.  */
 
 static LONGEST
@@ -421,7 +418,7 @@ unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
        {
        default:
          /* Perform integral promotion for ANSI C/C++.
-            If not appropropriate for any particular language
+            If not appropriate for any particular language
             it needs to modify this function.  */
          {
            struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
@@ -565,20 +562,20 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
          break;
        case language_opencl:
          if (result_len <= TYPE_LENGTH (lookup_signed_typename
-                                        (language, gdbarch, "int")))
+                                        (language, "int")))
            {
              promoted_type =
                (unsigned_operation
-                ? lookup_unsigned_typename (language, gdbarch, "int")
-                : lookup_signed_typename (language, gdbarch, "int"));
+                ? lookup_unsigned_typename (language, "int")
+                : lookup_signed_typename (language, "int"));
            }
          else if (result_len <= TYPE_LENGTH (lookup_signed_typename
-                                             (language, gdbarch, "long")))
+                                             (language, "long")))
            {
              promoted_type =
                (unsigned_operation
-                ? lookup_unsigned_typename (language, gdbarch, "long")
-                : lookup_signed_typename (language, gdbarch,"long"));
+                ? lookup_unsigned_typename (language, "long")
+                : lookup_signed_typename (language,"long"));
            }
          break;
        default:
@@ -1047,12 +1044,12 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
          if (op == OP_VAR_MSYM_VALUE)
            {
              minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
-             var_func_name = MSYMBOL_PRINT_NAME (msym);
+             var_func_name = msym->print_name ();
            }
          else if (op == OP_VAR_VALUE)
            {
              symbol *sym = exp->elts[*pos + 2].symbol;
-             var_func_name = SYMBOL_PRINT_NAME (sym);
+             var_func_name = sym->print_name ();
            }
 
          argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
@@ -1303,7 +1300,7 @@ evaluate_subexp_standard (struct type *expect_type,
        (*pos) += 3;
        symbol *var = exp->elts[pc + 2].symbol;
        if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
-         error_unknown_type (SYMBOL_PRINT_NAME (var));
+         error_unknown_type (var->print_name ());
        if (noside != EVAL_SKIP)
            return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
        else
@@ -1326,7 +1323,7 @@ evaluate_subexp_standard (struct type *expect_type,
        type = value_type (val);
        if (TYPE_CODE (type) == TYPE_CODE_ERROR
            && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
-         error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
+         error_unknown_type (msymbol->print_name ());
        return val;
       }
 
@@ -1345,7 +1342,7 @@ evaluate_subexp_standard (struct type *expect_type,
        if (SYMBOL_COMPUTED_OPS (sym) == NULL
            || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
          error (_("Symbol \"%s\" does not have any specific entry value"),
-                SYMBOL_PRINT_NAME (sym));
+                sym->print_name ());
 
        frame = get_selected_frame (NULL);
        return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
@@ -1550,7 +1547,7 @@ evaluate_subexp_standard (struct type *expect_type,
                {
                  int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
 
-                 if (gdbarch_bits_big_endian (exp->gdbarch))
+                 if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
                    bit_index = TARGET_CHAR_BIT - 1 - bit_index;
                  valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
                    |= 1 << bit_index;
@@ -2154,7 +2151,14 @@ evaluate_subexp_standard (struct type *expect_type,
 
     case BINOP_ASSIGN:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-      arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+      /* Special-case assignments where the left-hand-side is a
+        convenience variable -- in these, don't bother setting an
+        expected type.  This avoids a weird case where re-assigning a
+        string or array to an internal variable could error with "Too
+        many array elements".  */
+      arg2 = evaluate_subexp (VALUE_LVAL (arg1) == lval_internalvar
+                             ? NULL_TYPE : value_type (arg1),
+                             exp, pos, noside);
 
       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
        return arg1;
@@ -3214,7 +3218,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
 
        type = value_type (mval);
        if (TYPE_CODE (type) == TYPE_CODE_ERROR)
-         error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
+         error_unknown_type (msymbol->print_name ());
 
        return value_from_longest (size_type, TYPE_LENGTH (type));
       }
@@ -3222,7 +3226,7 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
 
       /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
         type of the subscript is a variable length array type. In this case we
-        must re-evaluate the right hand side of the subcription to allow
+        must re-evaluate the right hand side of the subscription to allow
         side-effects. */
     case BINOP_SUBSCRIPT:
       if (noside == EVAL_NORMAL)