arithmetic-combinations of integers. */
static tree
-initializer_constant_valid_p (value)
+initializer_constant_valid_p (value, endtype)
tree value;
+ tree endtype;
{
switch (TREE_CODE (value))
{
return TREE_OPERAND (value, 0);
case NON_LVALUE_EXPR:
- return initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
case CONVERT_EXPR:
case NOP_EXPR:
/* Allow conversions between pointer types. */
if (TREE_CODE (TREE_TYPE (value)) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE)
- return initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
/* Allow conversions between real types. */
if (TREE_CODE (TREE_TYPE (value)) == REAL_TYPE
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == REAL_TYPE)
- return initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
/* Allow length-preserving conversions between integer types. */
if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
&& tree_int_cst_equal (TYPE_SIZE (TREE_TYPE (value)),
TYPE_SIZE (TREE_TYPE (TREE_OPERAND (value, 0)))))
- return initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
/* Allow conversions between integer types only if explicit value. */
if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
{
- tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+ endtype);
if (inner == null_pointer_node)
return null_pointer_node;
return 0;
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == POINTER_TYPE
&& tree_int_cst_equal (TYPE_SIZE (TREE_TYPE (value)),
TYPE_SIZE (TREE_TYPE (TREE_OPERAND (value, 0)))))
- return initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+ endtype);
/* Allow conversions to union types if the value inside is okay. */
if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
- return initializer_constant_valid_p (TREE_OPERAND (value, 0));
+ return initializer_constant_valid_p (TREE_OPERAND (value, 0),
+ endtype);
return 0;
case PLUS_EXPR:
+ if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
+ && TYPE_PRECISION (TREE_TYPE (value)) < POINTER_SIZE)
+ return 0;
{
- tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0));
- tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1));
+ tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+ endtype);
+ tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
+ endtype);
/* If either term is absolute, use the other terms relocation. */
if (valid0 == null_pointer_node)
return valid1;
}
case MINUS_EXPR:
+ if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE
+ && TYPE_PRECISION (TREE_TYPE (value)) < POINTER_SIZE)
+ return 0;
{
- tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0));
- tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1));
+ tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
+ endtype);
+ tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
+ endtype);
/* Win if second argument is absolute. */
if (valid1 == null_pointer_node)
return valid0;
value = error_mark_node;
}
else if (TREE_STATIC (decl)
- && initializer_constant_valid_p (value) == 0)
+ && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
{
error ("initializer for static variable uses complicated arithmetic");
value = error_mark_node;
" for `%s'", ofwhat);
inside_init = error_mark_node;
}
- else if (require_constant && initializer_constant_valid_p (inside_init) == 0)
+ else if (require_constant
+ && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
{
error_init ("initializer element%s is not computable at load time",
" for `%s'", ofwhat);
" for `%s'", ofwhat);
element = error_mark_node;
}
- else if (require_constant && initializer_constant_valid_p (element) == 0)
+ else if (require_constant
+ && initializer_constant_valid_p (element, TREE_TYPE (element)) == 0)
{
error_init ("initializer element%s is not computable at load time",
" for `%s'", ofwhat);
" for `%s'", ofwhat);
inside_init = error_mark_node;
}
- else if (require_constant && initializer_constant_valid_p (inside_init) == 0)
+ else if (require_constant
+ && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
{
error_init ("initializer element%s is not computable at load time",
" for `%s'", ofwhat);
erroneous = 1;
else if (!TREE_CONSTANT (next1))
allconstant = 0;
- else if (initializer_constant_valid_p (next1) == 0)
+ else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
allsimple = 0;
/* Now store NEXT1 in the list, I elements from the *end*.
erroneous = 1;
else if (!TREE_CONSTANT (next1))
allconstant = 0;
- else if (initializer_constant_valid_p (next1) == 0)
+ else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
allsimple = 0;
/* Now store NEXT1 in the list, I elements from the *end*.
erroneous = 1;
else if (!TREE_CONSTANT (next1))
allconstant = 0;
- else if (initializer_constant_valid_p (next1) == 0)
+ else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0)
allsimple = 0;
members = tree_cons (field, next1, members);
}