You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* This file is part of the C front end.
static tree qualify_type (tree, tree);
static int tagged_types_tu_compatible_p (tree, tree);
-static int comp_target_types (tree, tree, int);
+static int comp_target_types (tree, tree);
static int function_types_compatible_p (tree, tree);
static int type_lists_compatible_p (tree, tree);
static tree decl_constant_value_for_broken_optimization (tree);
-static tree default_function_array_conversion (tree);
static tree lookup_field (tree, tree);
static tree convert_arguments (tree, tree, tree, tree);
static tree pointer_diff (tree, tree);
tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
int quals;
tree unqual_elt;
+ tree d1 = TYPE_DOMAIN (t1);
+ tree d2 = TYPE_DOMAIN (t2);
+ bool d1_variable, d2_variable;
+ bool d1_zero, d2_zero;
/* We should not have any type quals on arrays at all. */
gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
+ d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1);
+ d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2);
+
+ d1_variable = (!d1_zero
+ && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
+ || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
+ d2_variable = (!d2_zero
+ && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
+ || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
+
/* Save space: see if the result is identical to one of the args. */
- if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
+ if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
+ && (d2_variable || d2_zero || !d1_variable))
return build_type_attribute_variant (t1, attributes);
- if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
+ if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
+ && (d1_variable || d1_zero || !d2_variable))
return build_type_attribute_variant (t2, attributes);
if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
quals = TYPE_QUALS (strip_array_types (elt));
unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
t1 = build_array_type (unqual_elt,
- TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
+ TYPE_DOMAIN ((TYPE_DOMAIN (t1)
+ && (d2_variable
+ || d2_zero
+ || !d1_variable))
+ ? t1
+ : t2));
t1 = c_build_qualified_type (t1, quals);
return build_type_attribute_variant (t1, attributes);
}
return t2;
}
\f
-/* Wrapper around c_common_type that is used by c-common.c. ENUMERAL_TYPEs
- are allowed here and are converted to their compatible integer types. */
+/* Wrapper around c_common_type that is used by c-common.c and other
+ front end optimizations that remove promotions. ENUMERAL_TYPEs
+ are allowed here and are converted to their compatible integer types.
+ BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
+ preferably a non-Boolean type as the common type. */
tree
common_type (tree t1, tree t2)
{
t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
if (TREE_CODE (t2) == ENUMERAL_TYPE)
t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
+
+ /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
+ if (TREE_CODE (t1) == BOOLEAN_TYPE
+ && TREE_CODE (t2) == BOOLEAN_TYPE)
+ return boolean_type_node;
+
+ /* If either type is BOOLEAN_TYPE, then return the other. */
+ if (TREE_CODE (t1) == BOOLEAN_TYPE)
+ return t2;
+ if (TREE_CODE (t2) == BOOLEAN_TYPE)
+ return t1;
+
return c_common_type (t1, t2);
}
\f
switch (TREE_CODE (t1))
{
case POINTER_TYPE:
- /* We must give ObjC the first crack at comparing pointers, since
- protocol qualifiers may be involved. */
- if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
- break;
/* Do not remove mode or aliasing information. */
if (TYPE_MODE (t1) != TYPE_MODE (t2)
|| TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
break;
}
- case RECORD_TYPE:
- /* We are dealing with two distinct structs. In assorted Objective-C
- corner cases, however, these can still be deemed equivalent. */
- if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
- val = 1;
-
case ENUMERAL_TYPE:
+ case RECORD_TYPE:
case UNION_TYPE:
if (val != 1 && !same_translation_unit_p (t1, t2))
val = tagged_types_tu_compatible_p (t1, t2);
}
/* Return 1 if TTL and TTR are pointers to types that are equivalent,
- ignoring their qualifiers. REFLEXIVE is only used by ObjC - set it
- to 1 or 0 depending if the check of the pointer types is meant to
- be reflexive or not (typically, assignments are not reflexive,
- while comparisons are reflexive).
-*/
+ ignoring their qualifiers. */
static int
-comp_target_types (tree ttl, tree ttr, int reflexive)
+comp_target_types (tree ttl, tree ttr)
{
int val;
tree mvl, mvr;
- /* Give objc_comptypes a crack at letting these types through. */
- if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
- return val;
-
/* Do not lose qualifiers on element types of array types that are
pointer targets by taking their TYPE_MAIN_VARIANT. */
mvl = TREE_TYPE (ttl);
return 0;
/* If one of these types comes from a non-prototype fn definition,
compare that with the other type's arglist.
- If they don't match, ask for a warning (0, but no error). */
+ If they don't match, ask for a warning (but no error). */
if (TYPE_ACTUAL_ARG_TYPES (f1)
&& 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
val = 2;
static tree
decl_constant_value_for_broken_optimization (tree decl)
{
+ tree ret;
+
if (pedantic || DECL_MODE (decl) == BLKmode)
return decl;
- else
- return decl_constant_value (decl);
-}
+ ret = decl_constant_value (decl);
+ /* Avoid unwanted tree sharing between the initializer and current
+ function's body where the tree can be modified e.g. by the
+ gimplifier. */
+ if (ret != decl && TREE_STATIC (decl))
+ ret = unshare_expr (ret);
+ return ret;
+}
-/* Perform the default conversion of arrays and functions to pointers.
- Return the result of converting EXP. For any other expression, just
- return EXP. */
-
+/* Convert the array expression EXP to a pointer. */
static tree
-default_function_array_conversion (tree exp)
+array_to_pointer_conversion (tree exp)
{
- tree orig_exp;
+ tree orig_exp = exp;
tree type = TREE_TYPE (exp);
- enum tree_code code = TREE_CODE (type);
- int not_lvalue = 0;
+ tree adr;
+ tree restype = TREE_TYPE (type);
+ tree ptrtype;
- /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
- an lvalue.
+ gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
- Do not use STRIP_NOPS here! It will remove conversions from pointer
- to integer and cause infinite recursion. */
- orig_exp = exp;
- while (TREE_CODE (exp) == NON_LVALUE_EXPR
- || (TREE_CODE (exp) == NOP_EXPR
- && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
- {
- if (TREE_CODE (exp) == NON_LVALUE_EXPR)
- not_lvalue = 1;
- exp = TREE_OPERAND (exp, 0);
- }
+ STRIP_TYPE_NOPS (exp);
if (TREE_NO_WARNING (orig_exp))
TREE_NO_WARNING (exp) = 1;
- if (code == FUNCTION_TYPE)
+ ptrtype = build_pointer_type (restype);
+
+ if (TREE_CODE (exp) == INDIRECT_REF)
+ return convert (ptrtype, TREE_OPERAND (exp, 0));
+
+ if (TREE_CODE (exp) == VAR_DECL)
{
- return build_unary_op (ADDR_EXPR, exp, 0);
+ /* We are making an ADDR_EXPR of ptrtype. This is a valid
+ ADDR_EXPR because it's the best way of representing what
+ happens in C when we take the address of an array and place
+ it in a pointer to the element type. */
+ adr = build1 (ADDR_EXPR, ptrtype, exp);
+ if (!c_mark_addressable (exp))
+ return error_mark_node;
+ TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
+ return adr;
}
- if (code == ARRAY_TYPE)
- {
- tree adr;
- tree restype = TREE_TYPE (type);
- tree ptrtype;
- int constp = 0;
- int volatilep = 0;
- int lvalue_array_p;
- if (REFERENCE_CLASS_P (exp) || DECL_P (exp))
- {
- constp = TREE_READONLY (exp);
- volatilep = TREE_THIS_VOLATILE (exp);
- }
+ /* This way is better for a COMPONENT_REF since it can
+ simplify the offset for a component. */
+ adr = build_unary_op (ADDR_EXPR, exp, 1);
+ return convert (ptrtype, adr);
+}
- if (TYPE_QUALS (type) || constp || volatilep)
- restype
- = c_build_qualified_type (restype,
- TYPE_QUALS (type)
- | (constp * TYPE_QUAL_CONST)
- | (volatilep * TYPE_QUAL_VOLATILE));
+/* Convert the function expression EXP to a pointer. */
+static tree
+function_to_pointer_conversion (tree exp)
+{
+ tree orig_exp = exp;
- if (TREE_CODE (exp) == INDIRECT_REF)
- return convert (build_pointer_type (restype),
- TREE_OPERAND (exp, 0));
+ gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
- if (TREE_CODE (exp) == COMPOUND_EXPR)
- {
- tree op1 = default_conversion (TREE_OPERAND (exp, 1));
- return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
- TREE_OPERAND (exp, 0), op1);
- }
+ STRIP_TYPE_NOPS (exp);
- lvalue_array_p = !not_lvalue && lvalue_p (exp);
- if (!flag_isoc99 && !lvalue_array_p)
- {
- /* Before C99, non-lvalue arrays do not decay to pointers.
- Normally, using such an array would be invalid; but it can
- be used correctly inside sizeof or as a statement expression.
- Thus, do not give an error here; an error will result later. */
- return exp;
- }
+ if (TREE_NO_WARNING (orig_exp))
+ TREE_NO_WARNING (exp) = 1;
- ptrtype = build_pointer_type (restype);
+ return build_unary_op (ADDR_EXPR, exp, 0);
+}
- if (TREE_CODE (exp) == VAR_DECL)
- {
- /* We are making an ADDR_EXPR of ptrtype. This is a valid
- ADDR_EXPR because it's the best way of representing what
- happens in C when we take the address of an array and place
- it in a pointer to the element type. */
- adr = build1 (ADDR_EXPR, ptrtype, exp);
- if (!c_mark_addressable (exp))
- return error_mark_node;
- TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
- return adr;
- }
- /* This way is better for a COMPONENT_REF since it can
- simplify the offset for a component. */
- adr = build_unary_op (ADDR_EXPR, exp, 1);
- return convert (ptrtype, adr);
+/* Perform the default conversion of arrays and functions to pointers.
+ Return the result of converting EXP. For any other expression, just
+ return EXP after removing NOPs. */
+
+struct c_expr
+default_function_array_conversion (struct c_expr exp)
+{
+ tree orig_exp = exp.value;
+ tree type = TREE_TYPE (exp.value);
+ enum tree_code code = TREE_CODE (type);
+
+ switch (code)
+ {
+ case ARRAY_TYPE:
+ {
+ bool not_lvalue = false;
+ bool lvalue_array_p;
+
+ while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
+ || TREE_CODE (exp.value) == NOP_EXPR)
+ && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
+ {
+ if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
+ not_lvalue = true;
+ exp.value = TREE_OPERAND (exp.value, 0);
+ }
+
+ if (TREE_NO_WARNING (orig_exp))
+ TREE_NO_WARNING (exp.value) = 1;
+
+ lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
+ if (!flag_isoc99 && !lvalue_array_p)
+ {
+ /* Before C99, non-lvalue arrays do not decay to pointers.
+ Normally, using such an array would be invalid; but it can
+ be used correctly inside sizeof or as a statement expression.
+ Thus, do not give an error here; an error will result later. */
+ return exp;
+ }
+
+ exp.value = array_to_pointer_conversion (exp.value);
+ }
+ break;
+ case FUNCTION_TYPE:
+ exp.value = function_to_pointer_conversion (exp.value);
+ break;
+ default:
+ STRIP_TYPE_NOPS (exp.value);
+ if (TREE_NO_WARNING (orig_exp))
+ TREE_NO_WARNING (exp.value) = 1;
+ break;
}
+
return exp;
}
/* Perform default promotions for C data used in expressions.
- Arrays and functions are converted to pointers;
- enumeral types or short or char, to int.
+ Enumeral types or short or char are converted to int.
In addition, manifest constants symbols are replaced by their values. */
tree
tree type = TREE_TYPE (exp);
enum tree_code code = TREE_CODE (type);
- if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
- return default_function_array_conversion (exp);
+ /* Functions and arrays have been converted during parsing. */
+ gcc_assert (code != FUNCTION_TYPE);
+ if (code == ARRAY_TYPE)
+ return exp;
/* Constants can be used directly unless they're not loadable. */
if (TREE_CODE (exp) == CONST_DECL)
else
{
tree t = TREE_TYPE (type);
- tree mvt = t;
tree ref;
- if (TREE_CODE (mvt) != ARRAY_TYPE)
- mvt = TYPE_MAIN_VARIANT (mvt);
- ref = build1 (INDIRECT_REF, mvt, pointer);
+ ref = build1 (INDIRECT_REF, t, pointer);
if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
{
deliberately. ??? Existing practice has also been to warn only
when the char index is syntactically the index, not for
char[array]. */
- if (warn_char_subscripts && !swapped
+ if (!swapped
&& TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
- warning (0, "array subscript has type %<char%>");
+ warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
/* Apply default promotions *after* noticing character types. */
index = default_conversion (index);
return tem;
name = DECL_NAME (function);
-
- /* Differs from default_conversion by not setting TREE_ADDRESSABLE
- (because calling an inline function does not mean the function
- needs to be separately compiled). */
- fntype = build_type_variant (TREE_TYPE (function),
- TREE_READONLY (function),
- TREE_THIS_VOLATILE (function));
fundecl = function;
- function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
}
- else
- function = default_conversion (function);
+ if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
+ function = function_to_pointer_conversion (function);
+
+ /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
+ expressions, like those used for ObjC messenger dispatches. */
+ function = objc_rewrite_function_call (function, params);
fntype = TREE_TYPE (function);
If it is not, replace the call by a trap, wrapped up in a compound
expression if necessary. This has the nice side-effect to prevent
the tree-inliner from generating invalid assignment trees which may
- blow up in the RTL expander later.
-
- ??? This doesn't work for Objective-C because objc_comptypes
- refuses to compare function prototypes, yet the compiler appears
- to build calls that are flagged as invalid by C's comptypes. */
- if (!c_dialect_objc ()
- && TREE_CODE (function) == NOP_EXPR
+ blow up in the RTL expander later. */
+ if (TREE_CODE (function) == NOP_EXPR
&& TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
&& TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
&& !comptypes (fntype, TREE_TYPE (tem)))
if (AGGREGATE_TYPE_P (return_type))
rhs = build_compound_literal (return_type,
- build_constructor (return_type,
- NULL_TREE));
+ build_constructor (return_type, 0));
else
- rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
+ rhs = fold_build1 (NOP_EXPR, return_type, integer_zero_node);
return build2 (COMPOUND_EXPR, return_type, trap, rhs);
}
/* Check that the arguments to the function are valid. */
- check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
-
- result = build3 (CALL_EXPR, TREE_TYPE (fntype),
- function, coerced_params, NULL_TREE);
- TREE_SIDE_EFFECTS (result) = 1;
+ check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
+ TYPE_ARG_TYPES (fntype));
if (require_constant_value)
{
- result = fold_initializer (result);
+ result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype),
+ function, coerced_params, NULL_TREE);
if (TREE_CONSTANT (result)
&& (name == NULL_TREE
pedwarn_init ("initializer element is not constant");
}
else
- result = fold (result);
+ result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype),
+ function, coerced_params, NULL_TREE);
if (VOID_TYPE_P (TREE_TYPE (result)))
return result;
STRIP_TYPE_NOPS (val);
- val = default_function_array_conversion (val);
-
val = require_complete_type (val);
if (type != 0)
and the actual arg is that enum type. */
;
else if (formal_prec != TYPE_PRECISION (type1))
- warning (0, "passing argument %d of %qE with different "
- "width due to prototype", argnum, rname);
+ warning (OPT_Wconversion, "passing argument %d of %qE "
+ "with different width due to prototype",
+ argnum, rname);
else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
;
/* Don't complain if the formal parameter type
&& TYPE_UNSIGNED (TREE_TYPE (val)))
;
else if (TYPE_UNSIGNED (type))
- warning (0, "passing argument %d of %qE as unsigned "
- "due to prototype", argnum, rname);
+ warning (OPT_Wconversion, "passing argument %d of %qE "
+ "as unsigned due to prototype",
+ argnum, rname);
else
- warning (0, "passing argument %d of %qE as signed "
- "due to prototype", argnum, rname);
+ warning (OPT_Wconversion, "passing argument %d of %qE "
+ "as signed due to prototype", argnum, rname);
}
}
{
if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
- warning (0, "suggest parentheses around + or - inside shift");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around + or - inside shift");
}
if (code == TRUTH_ORIF_EXPR)
{
if (code1 == TRUTH_ANDIF_EXPR
|| code2 == TRUTH_ANDIF_EXPR)
- warning (0, "suggest parentheses around && within ||");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around && within ||");
}
if (code == BIT_IOR_EXPR)
|| code1 == PLUS_EXPR || code1 == MINUS_EXPR
|| code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
- warning (0, "suggest parentheses around arithmetic in operand of |");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around arithmetic in operand of |");
/* Check cases like x|y==z */
if (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison)
- warning (0, "suggest parentheses around comparison in operand of |");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around comparison in operand of |");
}
if (code == BIT_XOR_EXPR)
|| code1 == PLUS_EXPR || code1 == MINUS_EXPR
|| code2 == BIT_AND_EXPR
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
- warning (0, "suggest parentheses around arithmetic in operand of ^");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around arithmetic in operand of ^");
/* Check cases like x^y==z */
if (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison)
- warning (0, "suggest parentheses around comparison in operand of ^");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around comparison in operand of ^");
}
if (code == BIT_AND_EXPR)
{
if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
|| code2 == PLUS_EXPR || code2 == MINUS_EXPR)
- warning (0, "suggest parentheses around + or - in operand of &");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around + or - in operand of &");
/* Check cases like x&y==z */
if (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison)
- warning (0, "suggest parentheses around comparison in operand of &");
+ warning (OPT_Wparentheses,
+ "suggest parentheses around comparison in operand of &");
}
/* Similarly, check for cases like 1<=i<=10 that are probably errors. */
if (TREE_CODE_CLASS (code) == tcc_comparison
&& (TREE_CODE_CLASS (code1) == tcc_comparison
|| TREE_CODE_CLASS (code2) == tcc_comparison))
- warning (0, "comparisons like X<=Y<=Z do not have their mathematical meaning");
+ warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
+ "have their mathematical meaning");
}
op1 = c_size_in_bytes (target_type);
/* Divide by the size, in easiest possible way. */
- return fold (build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)));
+ return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
}
\f
/* Construct and perhaps optimize a tree representation
enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
tree val;
int noconvert = flag;
+ const char *invalid_op_diag;
if (typecode == ERROR_MARK)
return error_mark_node;
if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
typecode = INTEGER_TYPE;
+ if ((invalid_op_diag
+ = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
+ {
+ error (invalid_op_diag);
+ return error_mark_node;
+ }
+
switch (code)
{
case CONVERT_EXPR:
break;
case TRUTH_NOT_EXPR:
- /* ??? Why do most validation here but that for non-lvalue arrays
- in c_objc_common_truthvalue_conversion? */
if (typecode != INTEGER_TYPE
&& typecode != REAL_TYPE && typecode != POINTER_TYPE
- && typecode != COMPLEX_TYPE
- /* These will convert to a pointer. */
- && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
+ && typecode != COMPLEX_TYPE)
{
error ("wrong type argument to unary exclamation mark");
return error_mark_node;
if (TREE_CODE (arg) == COMPLEX_CST)
return TREE_REALPART (arg);
else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
- return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
+ return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
else
return arg;
if (TREE_CODE (arg) == COMPLEX_CST)
return TREE_IMAGPART (arg);
else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
- return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
+ return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
else
return convert (TREE_TYPE (arg), integer_zero_node);
/* For &x[y], return x+y */
if (TREE_CODE (arg) == ARRAY_REF)
{
- if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
+ tree op0 = TREE_OPERAND (arg, 0);
+ if (!c_mark_addressable (op0))
return error_mark_node;
- return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
+ return build_binary_op (PLUS_EXPR,
+ (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
+ ? array_to_pointer_conversion (op0)
+ : op0),
TREE_OPERAND (arg, 1), 1);
}
val = build1 (ADDR_EXPR, argtype, arg);
- if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
- TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
-
return val;
default:
if (argtype == 0)
argtype = TREE_TYPE (arg);
- val = build1 (code, argtype, arg);
- return require_constant_value ? fold_initializer (val) : fold (val);
+ return require_constant_value ? fold_build1_initializer (code, argtype, arg)
+ : fold_build1 (code, argtype, arg);
}
/* Return nonzero if REF is an lvalue valid for this language.
if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
readonly_error (TREE_OPERAND (arg, 0), use);
else
- error (READONLY_MSG (N_("assignment of read-only member %qD"),
- N_("increment of read-only member %qD"),
- N_("decrement of read-only member %qD")),
+ error (READONLY_MSG (G_("assignment of read-only member %qD"),
+ G_("increment of read-only member %qD"),
+ G_("decrement of read-only member %qD")),
TREE_OPERAND (arg, 1));
}
else if (TREE_CODE (arg) == VAR_DECL)
- error (READONLY_MSG (N_("assignment of read-only variable %qD"),
- N_("increment of read-only variable %qD"),
- N_("decrement of read-only variable %qD")),
+ error (READONLY_MSG (G_("assignment of read-only variable %qD"),
+ G_("increment of read-only variable %qD"),
+ G_("decrement of read-only variable %qD")),
arg);
else
- error (READONLY_MSG (N_("assignment of read-only location"),
- N_("increment of read-only location"),
- N_("decrement of read-only location")));
+ error (READONLY_MSG (G_("assignment of read-only location"),
+ G_("increment of read-only location"),
+ G_("decrement of read-only location")));
}
}
else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
{
- if (comp_target_types (type1, type2, 1))
+ if (comp_target_types (type1, type2))
result_type = common_pointer_type (type1, type2);
else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
&& TREE_CODE (orig_op1) != NOP_EXPR)
tree
build_compound_expr (tree expr1, tree expr2)
{
- /* Convert arrays and functions to pointers. */
- expr2 = default_function_array_conversion (expr2);
-
if (!TREE_SIDE_EFFECTS (expr1))
{
/* The left-hand operand of a comma expression is like an expression
else if (TREE_CODE (type) == UNION_TYPE)
{
tree field;
- value = default_function_array_conversion (value);
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
if (pedantic)
pedwarn ("ISO C forbids casts to union type");
t = digest_init (type,
- build_constructor (type,
- build_tree_list (field, value)),
+ build_constructor_single (type, field, value),
true, 0);
TREE_CONSTANT (t) = TREE_CONSTANT (value);
TREE_INVARIANT (t) = TREE_INVARIANT (value);
{
tree otype, ovalue;
- /* If casting to void, avoid the error that would come
- from default_conversion in the case of a non-lvalue array. */
if (type == void_type_node)
return build1 (CONVERT_EXPR, type, value);
- /* Convert functions and arrays to pointers,
- but don't convert any other types. */
- value = default_function_array_conversion (value);
otype = TREE_TYPE (value);
/* Optionally warn about potentially worrisome casts. */
}
/* Warn about possible alignment problems. */
- if (STRICT_ALIGNMENT && warn_cast_align
+ if (STRICT_ALIGNMENT
&& TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
|| TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
&& TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
&& TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
- warning (0, "cast increases required alignment of target type");
+ warning (OPT_Wcast_align,
+ "cast increases required alignment of target type");
- if (warn_pointer_to_int_cast
- && TREE_CODE (type) == INTEGER_TYPE
+ if (TREE_CODE (type) == INTEGER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
&& !TREE_CONSTANT (value))
- warning (0, "cast from pointer to integer of different size");
+ warning (OPT_Wpointer_to_int_cast,
+ "cast from pointer to integer of different size");
- if (warn_bad_function_cast
- && TREE_CODE (value) == CALL_EXPR
+ if (TREE_CODE (value) == CALL_EXPR
&& TREE_CODE (type) != TREE_CODE (otype))
- warning (0, "cast from function call of type %qT to non-matching "
- "type %qT", otype, type);
+ warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
+ "to non-matching type %qT", otype, type);
- if (warn_int_to_pointer_cast
- && TREE_CODE (type) == POINTER_TYPE
+ if (TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == INTEGER_TYPE
&& TYPE_PRECISION (type) != TYPE_PRECISION (otype)
/* Don't warn about converting any constant. */
&& !TREE_CONSTANT (value))
- warning (0, "cast to pointer from integer of different size");
+ warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
+ "of different size");
- if (TREE_CODE (type) == POINTER_TYPE
+ if (flag_strict_aliasing && warn_strict_aliasing
+ && TREE_CODE (type) == POINTER_TYPE
&& TREE_CODE (otype) == POINTER_TYPE
&& TREE_CODE (expr) == ADDR_EXPR
- && DECL_P (TREE_OPERAND (expr, 0))
- && flag_strict_aliasing && warn_strict_aliasing
+ && (DECL_P (TREE_OPERAND (expr, 0))
+ || TREE_CODE (TREE_OPERAND (expr, 0)) == COMPONENT_REF)
&& !VOID_TYPE_P (TREE_TYPE (type)))
{
- /* Casting the address of a decl to non void pointer. Warn
+ /* Casting the address of an object to non void pointer. Warn
if the cast breaks type based aliasing. */
if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
- warning (0, "type-punning to incomplete type might break strict-aliasing rules");
+ warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
+ "might break strict-aliasing rules");
else
{
HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
if (!alias_sets_conflict_p (set1, set2))
- warning (0, "dereferencing type-punned pointer will break strict-aliasing rules");
+ warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
+ "pointer will break strict-aliasing rules");
else if (warn_strict_aliasing > 1
&& !alias_sets_might_conflict_p (set1, set2))
- warning (0, "dereferencing type-punned pointer might break strict-aliasing rules");
+ warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
+ "pointer might break strict-aliasing rules");
}
}
/* Ignore any integer overflow caused by the cast. */
if (TREE_CODE (value) == INTEGER_CST)
{
- if (EXPR_P (ovalue))
- /* If OVALUE had overflow set, then so will VALUE, so it
- is safe to overwrite. */
- TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
+ /* If OVALUE had overflow set, then so will VALUE, so it
+ is safe to overwrite. */
+ if (CONSTANT_CLASS_P (ovalue))
+ {
+ TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
+ /* Similarly, constant_overflow cannot have become cleared. */
+ TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
+ }
else
TREE_OVERFLOW (value) = 0;
-
- if (CONSTANT_CLASS_P (ovalue))
- /* Similarly, constant_overflow cannot have become
- cleared. */
- TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
}
}
if (TREE_CODE (newrhs) == ERROR_MARK)
return error_mark_node;
+ /* Emit ObjC write barrier, if necessary. */
+ if (c_dialect_objc () && flag_objc_gc)
+ {
+ result = objc_generate_write_barrier (lhs, modifycode, newrhs);
+ if (result)
+ return result;
+ }
+
/* Scan operands. */
result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
tree rhstype;
enum tree_code coder;
tree rname = NULL_TREE;
+ bool objc_ok = false;
if (errtype == ic_argpass || errtype == ic_argpass_nonproto)
{
STRIP_TYPE_NOPS (rhs);
- if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
- || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
- rhs = default_conversion (rhs);
- else if (optimize && TREE_CODE (rhs) == VAR_DECL)
+ if (optimize && TREE_CODE (rhs) == VAR_DECL
+ && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE)
rhs = decl_constant_value_for_broken_optimization (rhs);
rhstype = TREE_TYPE (rhs);
if (coder == ERROR_MARK)
return error_mark_node;
+ if (c_dialect_objc ())
+ {
+ int parmno;
+
+ switch (errtype)
+ {
+ case ic_return:
+ parmno = 0;
+ break;
+
+ case ic_assign:
+ parmno = -1;
+ break;
+
+ case ic_init:
+ parmno = -2;
+ break;
+
+ default:
+ parmno = parmnum;
+ break;
+ }
+
+ objc_ok = objc_compare_types (type, rhstype, parmno, rname);
+ }
+
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
{
overflow_warning (rhs);
- /* Check for Objective-C protocols. This will automatically
- issue a warning if there are protocol violations. No need to
- use the return value. */
- if (c_dialect_objc ())
- objc_comptypes (type, rhstype, 0);
return rhs;
}
Meanwhile, the lhs target must have all the qualifiers of
the rhs. */
if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
- || comp_target_types (memb_type, rhstype, 0))
+ || comp_target_types (memb_type, rhstype))
{
/* If this type won't generate any warnings, use it. */
if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
function where an ordinary one is wanted, but not
vice-versa. */
if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE "
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE "
"makes qualified function "
"pointer from unqualified"),
- N_("assignment makes qualified "
+ G_("assignment makes qualified "
"function pointer from "
"unqualified"),
- N_("initialization makes qualified "
+ G_("initialization makes qualified "
"function pointer from "
"unqualified"),
- N_("return makes qualified function "
+ G_("return makes qualified function "
"pointer from unqualified"));
}
else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
"qualifiers from pointer target type"),
- N_("assignment discards qualifiers "
+ G_("assignment discards qualifiers "
"from pointer target type"),
- N_("initialization discards qualifiers "
+ G_("initialization discards qualifiers "
"from pointer target type"),
- N_("return discards qualifiers from "
+ G_("return discards qualifiers from "
"pointer target type"));
}
- if (pedantic && !DECL_IN_SYSTEM_HEADER (fundecl))
+ if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl)))
pedwarn ("ISO C prohibits argument conversion to union type");
return build1 (NOP_EXPR, type, rhs);
|| targetm.vector_opaque_p (rhstype))
&& TREE_CODE (ttl) == VECTOR_TYPE
&& TREE_CODE (ttr) == VECTOR_TYPE;
-
+
+ /* C++ does not allow the implicit conversion void* -> T*. However,
+ for the purpose of reducing the number of false positives, we
+ tolerate the special case of
+
+ int *p = NULL;
+
+ where NULL is typically defined in C to be '(void *) 0'. */
+ if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
+ warning (OPT_Wc___compat, "request for implicit conversion from "
+ "%qT to %qT not permitted in C++", rhstype, type);
+
+ /* Check if the right-hand side has a format attribute but the
+ left-hand side doesn't. */
+ if (warn_missing_format_attribute
+ && check_missing_format_attribute (type, rhstype))
+ {
+ switch (errtype)
+ {
+ case ic_argpass:
+ case ic_argpass_nonproto:
+ warning (OPT_Wmissing_format_attribute,
+ "argument %d of %qE might be "
+ "a candidate for a format attribute",
+ parmnum, rname);
+ break;
+ case ic_assign:
+ warning (OPT_Wmissing_format_attribute,
+ "assignment left-hand side might be "
+ "a candidate for a format attribute");
+ break;
+ case ic_init:
+ warning (OPT_Wmissing_format_attribute,
+ "initialization left-hand side might be "
+ "a candidate for a format attribute");
+ break;
+ case ic_return:
+ warning (OPT_Wmissing_format_attribute,
+ "return type might be "
+ "a candidate for a format attribute");
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ }
+
/* Any non-function converts to a [const][volatile] void *
and vice versa; otherwise, targets must be the same.
Meanwhile, the lhs target must have all the qualifiers of the rhs. */
if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
- || (target_cmp = comp_target_types (type, rhstype, 0))
+ || (target_cmp = comp_target_types (type, rhstype))
|| is_opaque_pointer
|| (c_common_unsigned_type (mvl)
== c_common_unsigned_type (mvr)))
which are not ANSI null ptr constants. */
&& (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
&& TREE_CODE (ttl) == FUNCTION_TYPE)))
- WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of "
+ WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of "
"%qE between function pointer "
"and %<void *%>"),
- N_("ISO C forbids assignment between "
+ G_("ISO C forbids assignment between "
"function pointer and %<void *%>"),
- N_("ISO C forbids initialization between "
+ G_("ISO C forbids initialization between "
"function pointer and %<void *%>"),
- N_("ISO C forbids return between function "
+ G_("ISO C forbids return between function "
"pointer and %<void *%>"));
/* Const and volatile mean something different for function types,
so the usual warnings are not appropriate. */
&& TREE_CODE (ttl) != FUNCTION_TYPE)
{
if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
- "qualifiers from pointer target type"),
- N_("assignment discards qualifiers "
- "from pointer target type"),
- N_("initialization discards qualifiers "
- "from pointer target type"),
- N_("return discards qualifiers from "
- "pointer target type"));
+ {
+ /* Types differing only by the presence of the 'volatile'
+ qualifier are acceptable if the 'volatile' has been added
+ in by the Objective-C EH machinery. */
+ if (!objc_type_quals_match (ttl, ttr))
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
+ "qualifiers from pointer target type"),
+ G_("assignment discards qualifiers "
+ "from pointer target type"),
+ G_("initialization discards qualifiers "
+ "from pointer target type"),
+ G_("return discards qualifiers from "
+ "pointer target type"));
+ }
/* If this is not a case of ignoring a mismatch in signedness,
no warning. */
else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
;
/* If there is a mismatch, do warn. */
else if (warn_pointer_sign)
- WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument "
+ WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument "
"%d of %qE differ in signedness"),
- N_("pointer targets in assignment "
+ G_("pointer targets in assignment "
"differ in signedness"),
- N_("pointer targets in initialization "
+ G_("pointer targets in initialization "
"differ in signedness"),
- N_("pointer targets in return differ "
+ G_("pointer targets in return differ "
"in signedness"));
}
else if (TREE_CODE (ttl) == FUNCTION_TYPE
it is okay to use a const or volatile function
where an ordinary one is wanted, but not vice-versa. */
if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
"qualified function pointer "
"from unqualified"),
- N_("assignment makes qualified function "
+ G_("assignment makes qualified function "
"pointer from unqualified"),
- N_("initialization makes qualified "
+ G_("initialization makes qualified "
"function pointer from unqualified"),
- N_("return makes qualified function "
+ G_("return makes qualified function "
"pointer from unqualified"));
}
}
else
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from "
- "incompatible pointer type"),
- N_("assignment from incompatible pointer type"),
- N_("initialization from incompatible "
- "pointer type"),
- N_("return from incompatible pointer type"));
+ /* Avoid warning about the volatile ObjC EH puts on decls. */
+ if (!objc_ok)
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from "
+ "incompatible pointer type"),
+ G_("assignment from incompatible pointer type"),
+ G_("initialization from incompatible "
+ "pointer type"),
+ G_("return from incompatible pointer type"));
+
return convert (type, rhs);
}
else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
&& TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
&& integer_zerop (TREE_OPERAND (rhs, 0))))
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
"pointer from integer without a cast"),
- N_("assignment makes pointer from integer "
+ G_("assignment makes pointer from integer "
"without a cast"),
- N_("initialization makes pointer from "
+ G_("initialization makes pointer from "
"integer without a cast"),
- N_("return makes pointer from integer "
+ G_("return makes pointer from integer "
"without a cast"));
return convert (type, rhs);
}
else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
{
- WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer "
+ WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer "
"from pointer without a cast"),
- N_("assignment makes integer from pointer "
+ G_("assignment makes integer from pointer "
"without a cast"),
- N_("initialization makes integer from pointer "
+ G_("initialization makes integer from pointer "
"without a cast"),
- N_("return makes integer from pointer "
+ G_("return makes integer from pointer "
"without a cast"));
return convert (type, rhs);
}
/* Store the expression if valid; else report error. */
- if (warn_traditional && !in_system_header
+ if (!in_system_header
&& AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
- warning (0, "traditional C rejects automatic aggregate initialization");
+ warning (OPT_Wtraditional, "traditional C rejects automatic "
+ "aggregate initialization");
DECL_INITIAL (decl) = value;
if (TREE_CODE (inside_init) == CONSTRUCTOR)
{
- tree link;
+ unsigned HOST_WIDE_INT ix;
+ tree value;
+ bool constant_p = true;
/* Iterate through elements and check if all constructor
elements are *_CSTs. */
- for (link = CONSTRUCTOR_ELTS (inside_init);
- link;
- link = TREE_CHAIN (link))
- if (! CONSTANT_CLASS_P (TREE_VALUE (link)))
- break;
+ FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
+ if (!CONSTANT_CLASS_P (value))
+ {
+ constant_p = false;
+ break;
+ }
- if (link == NULL)
- return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
+ if (constant_p)
+ return build_vector_from_ctor (type,
+ CONSTRUCTOR_ELTS (inside_init));
}
}
|| (code == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
&& comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
- TREE_TYPE (type)))
- || (code == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
- && comptypes (TREE_TYPE (inside_init),
TREE_TYPE (type)))))
{
if (code == POINTER_TYPE)
{
- inside_init = default_function_array_conversion (inside_init);
-
if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
{
- error_init ("invalid use of non-lvalue array");
- return error_mark_node;
+ if (TREE_CODE (inside_init) == STRING_CST
+ || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
+ inside_init = array_to_pointer_conversion (inside_init);
+ else
+ {
+ error_init ("invalid use of non-lvalue array");
+ return error_mark_node;
+ }
}
- }
+ }
if (code == VECTOR_TYPE)
/* Although the types are compatible, we may require a
inside_init = error_mark_node;
}
+ /* Added to enable additional -Wmissing-format-attribute warnings. */
+ if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
+ inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE,
+ NULL_TREE, 0);
return inside_init;
}
|| code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
|| code == VECTOR_TYPE)
{
- /* Note that convert_for_assignment calls default_conversion
- for arrays and functions. We must not call it in the
- case where inside_init is a null pointer constant. */
+ if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
+ && (TREE_CODE (init) == STRING_CST
+ || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
+ init = array_to_pointer_conversion (init);
inside_init
= convert_for_assignment (type, init, ic_init,
NULL_TREE, NULL_TREE, 0);
/* If we are saving up the elements rather than allocating them,
this is the list of elements so far (in reverse order,
most recent first). */
-static tree constructor_elements;
+static VEC(constructor_elt,gc) *constructor_elements;
/* 1 if constructor should be incrementally stored into a constructor chain,
0 if all the elements should be kept in AVL tree. */
static int designator_depth;
/* Nonzero if there were diagnosed errors in this designator list. */
-static int designator_errorneous;
+static int designator_erroneous;
\f
/* This stack has a level for each implicit or explicit level of
tree unfilled_index;
tree unfilled_fields;
tree bit_index;
- tree elements;
+ VEC(constructor_elt,gc) *elements;
struct init_node *pending_elts;
int offset;
int depth;
tree decl;
struct constructor_stack *constructor_stack;
struct constructor_range_stack *constructor_range_stack;
- tree elements;
+ VEC(constructor_elt,gc) *elements;
struct spelling *spelling;
struct spelling *spelling_base;
int spelling_size;
constructor_incremental = 1;
constructor_designated = 0;
designator_depth = 0;
- designator_errorneous = 0;
+ designator_erroneous = 0;
if (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == UNION_TYPE)
tree value = NULL_TREE;
/* If we've exhausted any levels that didn't have braces,
- pop them now. */
- while (constructor_stack->implicit)
+ pop them now. If implicit == 1, this will have been done in
+ process_init_element; do not repeat it here because in the case
+ of excess initializers for an empty aggregate this leads to an
+ infinite cycle of popping a level and immediately recreating
+ it. */
+ if (implicit != 1)
{
- if ((TREE_CODE (constructor_type) == RECORD_TYPE
- || TREE_CODE (constructor_type) == UNION_TYPE)
- && constructor_fields == 0)
- process_init_element (pop_init_level (1));
- else if (TREE_CODE (constructor_type) == ARRAY_TYPE
- && constructor_max_index
- && tree_int_cst_lt (constructor_max_index, constructor_index))
- process_init_element (pop_init_level (1));
- else
- break;
+ while (constructor_stack->implicit)
+ {
+ if ((TREE_CODE (constructor_type) == RECORD_TYPE
+ || TREE_CODE (constructor_type) == UNION_TYPE)
+ && constructor_fields == 0)
+ process_init_element (pop_init_level (1));
+ else if (TREE_CODE (constructor_type) == ARRAY_TYPE
+ && constructor_max_index
+ && tree_int_cst_lt (constructor_max_index,
+ constructor_index))
+ process_init_element (pop_init_level (1));
+ else
+ break;
+ }
}
/* Unless this is an explicit brace, we need to preserve previous
p->range_stack = constructor_range_stack;
constructor_range_stack = 0;
designator_depth = 0;
- designator_errorneous = 0;
+ designator_erroneous = 0;
}
/* Don't die if an entire brace-pair level is superfluous
constructor_constant = TREE_CONSTANT (value);
constructor_simple = TREE_STATIC (value);
constructor_elements = CONSTRUCTOR_ELTS (value);
- if (constructor_elements
+ if (!VEC_empty (constructor_elt, constructor_elements)
&& (TREE_CODE (constructor_type) == RECORD_TYPE
|| TREE_CODE (constructor_type) == ARRAY_TYPE))
set_nonincremental_init ();
{
/* A nonincremental scalar initializer--just return
the element, after verifying there is just one. */
- if (constructor_elements == 0)
+ if (VEC_empty (constructor_elt,constructor_elements))
{
if (!constructor_erroneous)
error_init ("empty scalar initializer");
ret.value = error_mark_node;
}
- else if (TREE_CHAIN (constructor_elements) != 0)
+ else if (VEC_length (constructor_elt,constructor_elements) != 1)
{
error_init ("extra elements in scalar initializer");
- ret.value = TREE_VALUE (constructor_elements);
+ ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
}
else
- ret.value = TREE_VALUE (constructor_elements);
+ ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
}
else
{
else
{
ret.value = build_constructor (constructor_type,
- nreverse (constructor_elements));
+ constructor_elements);
if (constructor_constant)
TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
if (constructor_constant && constructor_simple)
/* If there were errors in this designator list already, bail out
silently. */
- if (designator_errorneous)
+ if (designator_erroneous)
return 1;
if (!designator_depth)
if (set_designator (1))
return;
- designator_errorneous = 1;
+ designator_erroneous = 1;
if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
|| (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
}
designator_depth++;
- designator_errorneous = 0;
+ designator_erroneous = 0;
if (constructor_range_stack || last)
push_range_stack (last);
}
if (set_designator (0))
return;
- designator_errorneous = 1;
+ designator_erroneous = 1;
if (TREE_CODE (constructor_type) != RECORD_TYPE
&& TREE_CODE (constructor_type) != UNION_TYPE)
{
constructor_fields = tail;
designator_depth++;
- designator_errorneous = 0;
+ designator_erroneous = 0;
if (constructor_range_stack)
push_range_stack (NULL_TREE);
}
static void
set_nonincremental_init (void)
{
- tree chain;
+ unsigned HOST_WIDE_INT ix;
+ tree index, value;
if (TREE_CODE (constructor_type) != RECORD_TYPE
&& TREE_CODE (constructor_type) != ARRAY_TYPE)
return;
- for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
- add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
+ FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
+ add_pending_init (index, value);
constructor_elements = 0;
if (TREE_CODE (constructor_type) == RECORD_TYPE)
{
}
else if (TREE_CODE (constructor_type) == UNION_TYPE)
{
- if (constructor_elements
- && TREE_PURPOSE (constructor_elements) == field)
- return TREE_VALUE (constructor_elements);
+ if (!VEC_empty (constructor_elt, constructor_elements)
+ && (VEC_last (constructor_elt, constructor_elements)->index
+ == field))
+ return VEC_last (constructor_elt, constructor_elements)->value;
}
return 0;
}
output_init_element (tree value, bool strict_string, tree type, tree field,
int pending)
{
+ constructor_elt *celt;
+
if (type == error_mark_node || value == error_mark_node)
{
constructor_erroneous = 1;
return;
}
- if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
- || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
- && !(TREE_CODE (value) == STRING_CST
- && TREE_CODE (type) == ARRAY_TYPE
- && INTEGRAL_TYPE_P (TREE_TYPE (type)))
- && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
- TYPE_MAIN_VARIANT (type))))
- value = default_conversion (value);
+ if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
+ && (TREE_CODE (value) == STRING_CST
+ || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
+ && !(TREE_CODE (value) == STRING_CST
+ && TREE_CODE (type) == ARRAY_TYPE
+ && INTEGRAL_TYPE_P (TREE_TYPE (type)))
+ && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
+ TYPE_MAIN_VARIANT (type)))
+ value = array_to_pointer_conversion (value);
if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
&& require_constant_value && !flag_isoc99 && pending)
return;
}
else if (TREE_CODE (constructor_type) == UNION_TYPE
- && constructor_elements)
+ && !VEC_empty (constructor_elt, constructor_elements))
{
- if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
+ if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
+ constructor_elements)->value))
warning_init ("initialized field with side-effects overwritten");
/* We can have just one union field set. */
/* Otherwise, output this element either to
constructor_elements or to the assembler file. */
- if (field && TREE_CODE (field) == INTEGER_CST)
- field = copy_node (field);
- constructor_elements
- = tree_cons (field, value, constructor_elements);
+ celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
+ celt->index = field;
+ celt->value = value;
/* Advance the variable that indicates sequential elements output. */
if (TREE_CODE (constructor_type) == ARRAY_TYPE)
bool strict_string = value.original_code == STRING_CST;
designator_depth = 0;
- designator_errorneous = 0;
+ designator_erroneous = 0;
/* Handle superfluous braces around string cst as in
char x[] = {"foo"}; */
again on the assumption that this must be conditional on
__STDC__ anyway (and we've already complained about the
member-designator already). */
- if (warn_traditional && !in_system_header && !constructor_designated
+ if (!in_system_header && !constructor_designated
&& !(value.value && (integer_zerop (value.value)
|| real_zerop (value.value))))
- warning (0, "traditional C rejects initialization of unions");
+ warning (OPT_Wtraditional, "traditional C rejects initialization "
+ "of unions");
/* Accept a string constant to initialize a subarray. */
if (value.value != 0
TREE_VALUE (tail) = output;
}
- /* Perform default conversions on array and function inputs.
- Don't do this for other types as it would screw up operands
- expected to be in memory. */
for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
{
tree input;
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
input = TREE_VALUE (tail);
- input = default_function_array_conversion (input);
-
if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
oconstraints, &allows_mem, &allows_reg))
{
{
type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
- if (warn_traditional && !in_system_header
+ if (!in_system_header
&& (type == long_integer_type_node
|| type == long_unsigned_type_node))
- warning (0, "%<long%> switch expression not converted to "
- "%<int%> in ISO C");
+ warning (OPT_Wtraditional, "%<long%> switch expression not "
+ "converted to %<int%> in ISO C");
exp = default_conversion (exp);
type = TREE_TYPE (exp);
found:
if (COND_EXPR_ELSE (inner_if))
- warning (0, "%Hsuggest explicit braces to avoid ambiguous %<else%>",
+ warning (OPT_Wparentheses,
+ "%Hsuggest explicit braces to avoid ambiguous %<else%>",
&if_locus);
}
/* Diagnose ";" via the special empty statement node that we create. */
if (extra_warnings)
{
- if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
+ tree *inner_then = &then_block, *inner_else = &else_block;
+
+ if (TREE_CODE (*inner_then) == STATEMENT_LIST
+ && STATEMENT_LIST_TAIL (*inner_then))
+ inner_then = &STATEMENT_LIST_TAIL (*inner_then)->stmt;
+ if (*inner_else && TREE_CODE (*inner_else) == STATEMENT_LIST
+ && STATEMENT_LIST_TAIL (*inner_else))
+ inner_else = &STATEMENT_LIST_TAIL (*inner_else)->stmt;
+
+ if (TREE_CODE (*inner_then) == NOP_EXPR && !TREE_TYPE (*inner_then))
{
- if (!else_block)
+ if (!*inner_else)
warning (0, "%Hempty body in an if-statement",
- EXPR_LOCUS (then_block));
- then_block = alloc_stmt_list ();
+ EXPR_LOCUS (*inner_then));
+
+ *inner_then = alloc_stmt_list ();
}
- if (else_block
- && TREE_CODE (else_block) == NOP_EXPR
- && !TREE_TYPE (else_block))
+ if (*inner_else
+ && TREE_CODE (*inner_else) == NOP_EXPR
+ && !TREE_TYPE (*inner_else))
{
warning (0, "%Hempty body in an else-statement",
- EXPR_LOCUS (else_block));
- else_block = alloc_stmt_list ();
+ EXPR_LOCUS (*inner_else));
+
+ *inner_else = alloc_stmt_list ();
}
}
- stmt = build3 (COND_EXPR, NULL_TREE, cond, then_block, else_block);
+ stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
SET_EXPR_LOCATION (stmt, if_locus);
add_stmt (stmt);
}
}
t = build_and_jump (&blab);
- exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
- exit = fold (exit);
+ exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
if (cond_is_first)
SET_EXPR_LOCATION (exit, start_locus);
else
if (!expr)
return NULL_TREE;
- /* Do default conversion if safe and possibly important,
- in case within ({...}). */
- if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
- && (flag_isoc99 || lvalue_p (expr)))
- || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
- expr = default_conversion (expr);
-
if (warn_sequence_point)
verify_sequence_points (expr);
if (last == error_mark_node
|| (last == BIND_EXPR_BODY (body)
&& BIND_EXPR_VARS (body) == NULL))
- return last;
+ {
+ /* Do not warn if the return value of a statement expression is
+ unused. */
+ if (EXPR_P (last))
+ TREE_NO_WARNING (last) = 1;
+ return last;
+ }
/* Extract the type of said expression. */
type = TREE_TYPE (last);
tree type0, type1;
enum tree_code code0, code1;
tree op0, op1;
+ const char *invalid_op_diag;
/* Expression code to give to the expression when it is built.
Normally this is CODE, which is what the caller asked for,
/* Nonzero means set RESULT_TYPE to the common type of the args. */
int common = 0;
+ /* True means types are compatible as far as ObjC is concerned. */
+ bool objc_ok;
+
if (convert_p)
{
op0 = default_conversion (orig_op0);
if (code0 == ERROR_MARK || code1 == ERROR_MARK)
return error_mark_node;
+ if ((invalid_op_diag
+ = targetm.invalid_binary_op (code, type0, type1)))
+ {
+ error (invalid_op_diag);
+ return error_mark_node;
+ }
+
+ objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
+
switch (code)
{
case PLUS_EXPR:
/* Subtraction of two similar pointers.
We must subtract them as integers, then divide by object size. */
if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
- && comp_target_types (type0, type1, 1))
+ && comp_target_types (type0, type1))
return pointer_diff (op0, op1);
/* Handle pointer minus int. Just like pointer plus int. */
else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
case EXACT_DIV_EXPR:
/* Floating point division by zero is a legitimate way to obtain
infinities and NaNs. */
- if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
- warning (0, "division by zero");
+ if (skip_evaluation == 0 && integer_zerop (op1))
+ warning (OPT_Wdiv_by_zero, "division by zero");
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
|| code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
&& (code1 == INTEGER_TYPE || code1 == REAL_TYPE
|| code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
{
+ enum tree_code tcode0 = code0, tcode1 = code1;
+
if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
- code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
+ tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
- code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
+ tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
- if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
+ if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
resultcode = RDIV_EXPR;
else
/* Although it would be tempting to shorten always here, that
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR:
- if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
- warning (0, "division by zero");
+ if (skip_evaluation == 0 && integer_zerop (op1))
+ warning (OPT_Wdiv_by_zero, "division by zero");
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
{
case EQ_EXPR:
case NE_EXPR:
- if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
- warning (0, "comparing floating point with == or != is unsafe");
+ if (code0 == REAL_TYPE || code1 == REAL_TYPE)
+ warning (OPT_Wfloat_equal,
+ "comparing floating point with == or != is unsafe");
/* Result of comparison is always int,
but don't convert the args to int! */
build_type = integer_type_node;
/* Anything compares with void *. void * compares with anything.
Otherwise, the targets must be compatible
and both must be object or both incomplete. */
- if (comp_target_types (type0, type1, 1))
+ if (comp_target_types (type0, type1))
result_type = common_pointer_type (type0, type1);
else if (VOID_TYPE_P (tt0))
{
" with function pointer");
}
else
- pedwarn ("comparison of distinct pointer types lacks a cast");
+ /* Avoid warning about the volatile ObjC EH puts on decls. */
+ if (!objc_ok)
+ pedwarn ("comparison of distinct pointer types lacks a cast");
if (result_type == NULL_TREE)
result_type = ptr_type_node;
short_compare = 1;
else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
{
- if (comp_target_types (type0, type1, 1))
+ if (comp_target_types (type0, type1))
{
result_type = common_pointer_type (type0, type1);
if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
if (code0 == ERROR_MARK || code1 == ERROR_MARK)
return error_mark_node;
+ if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
+ && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
+ || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
+ TREE_TYPE (type1))))
+ {
+ binary_op_error (code);
+ return error_mark_node;
+ }
+
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
|| code0 == VECTOR_TYPE)
&&
&& (unsigned0 || !uns))
result_type
= c_common_signed_or_unsigned_type
- (unsigned0, c_common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
+ (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
else if (TREE_CODE (arg0) == INTEGER_CST
&& (unsigned1 || !uns)
&& (TYPE_PRECISION (TREE_TYPE (arg1))
build_type = result_type;
{
- tree result = build2 (resultcode, build_type, op0, op1);
-
/* Treat expressions in initializers specially as they can't trap. */
- result = require_constant_value ? fold_initializer (result)
- : fold (result);
+ tree result = require_constant_value ? fold_build2_initializer (resultcode,
+ build_type,
+ op0, op1)
+ : fold_build2 (resultcode, build_type,
+ op0, op1);
if (final_type != 0)
result = convert (final_type, result);
/* Convert EXPR to be a truth-value, validating its type for this
- purpose. Passes EXPR to default_function_array_conversion. */
+ purpose. */
tree
c_objc_common_truthvalue_conversion (tree expr)
{
- expr = default_function_array_conversion (expr);
switch (TREE_CODE (TREE_TYPE (expr)))
{
case ARRAY_TYPE:
error ("used union type value where scalar is required");
return error_mark_node;
+ case FUNCTION_TYPE:
+ gcc_unreachable ();
+
default:
break;
}
leaving those to give errors later? */
return c_common_truthvalue_conversion (expr);
}
+\f
+
+/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
+ required. */
+
+tree
+c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
+ bool *ti ATTRIBUTE_UNUSED, bool *se)
+{
+ if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
+ {
+ tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
+ /* Executing a compound literal inside a function reinitializes
+ it. */
+ if (!TREE_STATIC (decl))
+ *se = true;
+ return decl;
+ }
+ else
+ return expr;
+}
OSDN Git Service
