static int type_lists_compatible_p (tree, tree);
static tree decl_constant_value_for_broken_optimization (tree);
static tree lookup_field (tree, tree);
-static tree convert_arguments (tree, tree, tree, tree);
+static int convert_arguments (int, tree *, tree, tree, tree, tree);
static tree pointer_diff (tree, tree);
static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree,
int);
build_function_call (tree function, tree params)
{
tree fntype, fundecl = 0;
- tree coerced_params;
tree name = NULL_TREE, result;
tree tem;
+ int nargs;
+ tree *argarray;
+
/* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
STRIP_TYPE_NOPS (function);
/* Convert the parameters to the types declared in the
function prototype, or apply default promotions. */
- coerced_params
- = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl);
-
- if (coerced_params == error_mark_node)
+ nargs = list_length (params);
+ argarray = (tree *) alloca (nargs * sizeof (tree));
+ nargs = convert_arguments (nargs, argarray, TYPE_ARG_TYPES (fntype),
+ params, function, fundecl);
+ if (nargs < 0)
return error_mark_node;
/* Check that the arguments to the function are valid. */
- check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
+ check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
TYPE_ARG_TYPES (fntype));
if (require_constant_value)
{
- result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype),
- function, coerced_params, NULL_TREE);
-
+ result = fold_build_call_array_initializer (TREE_TYPE (fntype),
+ function, nargs, argarray);
if (TREE_CONSTANT (result)
&& (name == NULL_TREE
|| strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
pedwarn_init ("initializer element is not constant");
}
else
- result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype),
- function, coerced_params, NULL_TREE);
+ result = fold_build_call_array (TREE_TYPE (fntype),
+ function, nargs, argarray);
if (VOID_TYPE_P (TREE_TYPE (result)))
return result;
}
\f
/* Convert the argument expressions in the list VALUES
- to the types in the list TYPELIST. The result is a list of converted
- argument expressions, unless there are too few arguments in which
- case it is error_mark_node.
+ to the types in the list TYPELIST. The resulting arguments are
+ stored in the array ARGARRAY which has size NARGS.
If TYPELIST is exhausted, or when an element has NULL as its type,
perform the default conversions.
This is also where warnings about wrong number of args are generated.
- Both VALUES and the returned value are chains of TREE_LIST nodes
- with the elements of the list in the TREE_VALUE slots of those nodes. */
+ VALUES is a chain of TREE_LIST nodes with the elements of the list
+ in the TREE_VALUE slots of those nodes.
-static tree
-convert_arguments (tree typelist, tree values, tree function, tree fundecl)
+ Returns the actual number of arguments processed (which may be less
+ than NARGS in some error situations), or -1 on failure. */
+
+static int
+convert_arguments (int nargs, tree *argarray,
+ tree typelist, tree values, tree function, tree fundecl)
{
tree typetail, valtail;
- tree result = NULL;
int parmnum;
tree selector;
selector = objc_message_selector ();
/* Scan the given expressions and types, producing individual
- converted arguments and pushing them on RESULT in reverse order. */
+ converted arguments and storing them in ARGARRAY. */
for (valtail = values, typetail = typelist, parmnum = 0;
valtail;
if (type == void_type_node)
{
error ("too many arguments to function %qE", function);
- break;
+ return parmnum;
}
if (selector && argnum > 2)
&& (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
parmval = default_conversion (parmval);
}
- result = tree_cons (NULL_TREE, parmval, result);
+ argarray[parmnum] = parmval;
}
else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
&& (TYPE_PRECISION (TREE_TYPE (val))
< TYPE_PRECISION (double_type_node))
&& !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val))))
/* Convert `float' to `double'. */
- result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
+ argarray[parmnum] = convert (double_type_node, val);
else if ((invalid_func_diag =
targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
{
error (invalid_func_diag);
- return error_mark_node;
+ return -1;
}
else
/* Convert `short' and `char' to full-size `int'. */
- result = tree_cons (NULL_TREE, default_conversion (val), result);
+ argarray[parmnum] = default_conversion (val);
if (typetail)
typetail = TREE_CHAIN (typetail);
}
+ gcc_assert (parmnum == nargs);
+
if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
{
error ("too few arguments to function %qE", function);
- return error_mark_node;
+ return -1;
}
- return nreverse (result);
+ return parmnum;
}
\f
/* This is the entry point used by the parser to build unary operators
if (warn_parentheses)
warn_about_parentheses (code, code1, code2);
+ if (code1 != tcc_comparison)
+ warn_logical_operator (code, arg1.value, arg2.value);
+
/* Warn about comparisons against string literals, with the exception
of testing for equality or inequality of a string literal with NULL. */
if (code == EQ_EXPR || code == NE_EXPR)
{
if ((code1 == STRING_CST && !integer_zerop (arg2.value))
|| (code2 == STRING_CST && !integer_zerop (arg1.value)))
- warning (OPT_Wstring_literal_comparison,
- "comparison with string literal");
+ warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
}
else if (TREE_CODE_CLASS (code) == tcc_comparison
&& (code1 == STRING_CST || code2 == STRING_CST))
- warning (OPT_Wstring_literal_comparison,
- "comparison with string literal");
+ warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour");
if (TREE_OVERFLOW_P (result.value)
&& !TREE_OVERFLOW_P (arg1.value)
if (unsigned_op1 ^ unsigned_op2)
{
+ bool ovf;
+
/* Do not warn if the result type is signed, since the
signed type will only be chosen if it can represent
all the values of the unsigned type. */
/* Do not warn if the signed quantity is an unsuffixed
integer literal (or some static constant expression
involving such literals) and it is non-negative. */
- else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
- || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
+ else if ((unsigned_op2
+ && tree_expr_nonnegative_warnv_p (op1, &ovf))
+ || (unsigned_op1
+ && tree_expr_nonnegative_warnv_p (op2, &ovf)))
/* OK */;
else
warning (0, "signed and unsigned type in conditional expression");
|| coder == BOOLEAN_TYPE))
return convert_and_check (type, rhs);
+ /* Aggregates in different TUs might need conversion. */
+ if ((codel == RECORD_TYPE || codel == UNION_TYPE)
+ && codel == coder
+ && comptypes (type, rhstype))
+ return convert_and_check (type, rhs);
+
/* Conversion to a transparent union from its member types.
This applies only to function arguments. */
- else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
- && (errtype == ic_argpass || errtype == ic_argpass_nonproto))
+ if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
+ && (errtype == ic_argpass || errtype == ic_argpass_nonproto))
{
tree memb, marginal_memb = NULL_TREE;
else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
{
current_function_returns_null = 1;
- if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
+ if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
pedwarn ("%<return%> with a value, in function returning void");
+ else if (pedantic)
+ pedwarn ("ISO C forbids %<return%> with expression, in function returning void");
}
else
{
&if_locus);
}
- empty_body_warning (then_block, else_block);
+ empty_if_body_warning (then_block, else_block);
stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
SET_EXPR_LOCATION (stmt, if_locus);
else if (!TREE_SIDE_EFFECTS (expr))
{
if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
- warning (0, "%Hstatement with no effect",
+ warning (OPT_Wunused_value, "%Hstatement with no effect",
EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
}
- else if (warn_unused_value)
+ else
warn_if_unused_value (expr, input_location);
}
Warnings for statement expressions will be emitted later, once we figure
out which is the result. */
if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
- && (extra_warnings || warn_unused_value))
+ && warn_unused_value)
emit_side_effect_warnings (expr);
/* If the expression is not of a type to which we cannot assign a line
/* If we're supposed to generate side effects warnings, process
all of the statements except the last. */
- if (extra_warnings || warn_unused_value)
+ if (warn_unused_value)
{
for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
emit_side_effect_warnings (tsi_stmt (i));
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR:
- /* Floating point division by zero is a legitimate way to obtain
- infinities and NaNs. */
- if (skip_evaluation == 0 && integer_zerop (op1))
- warning (OPT_Wdiv_by_zero, "division by zero");
+ warn_for_div_by_zero (op1);
if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
|| code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
case TRUNC_MOD_EXPR:
case FLOOR_MOD_EXPR:
- if (skip_evaluation == 0 && integer_zerop (op1))
- warning (OPT_Wdiv_by_zero, "division by zero");
+ warn_for_div_by_zero (op1);
if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
{
{
if (TREE_CODE (op0) == ADDR_EXPR
&& decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
- warning (OPT_Walways_true, "the address of %qD will never be NULL",
+ warning (OPT_Waddress, "the address of %qD will never be NULL",
TREE_OPERAND (op0, 0));
result_type = type0;
}
{
if (TREE_CODE (op1) == ADDR_EXPR
&& decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
- warning (OPT_Walways_true, "the address of %qD will never be NULL",
+ warning (OPT_Waddress, "the address of %qD will never be NULL",
TREE_OPERAND (op1, 0));
result_type = type1;
}
else
{
tree sop, uop;
+ bool ovf;
if (op0_signed)
sop = xop0, uop = xop1;
constant expression involving such literals or a
conditional expression involving such literals)
and it is non-negative. */
- if (tree_expr_nonnegative_p (sop))
+ if (tree_expr_nonnegative_warnv_p (sop, &ovf))
/* OK */;
/* Do not warn if the comparison is an equality operation,
the unsigned quantity is an integral constant, and it