+2014-01-31 Marek Polacek <polacek@redhat.com>
+
+ PR c/59963
+ * c-common.c (add_atomic_size_parameter): Pass vNULL to
+ build_function_call_vec.
+ (resolve_overloaded_builtin): Likewise.
+ * c-common.h (build_function_call_vec): Adjust declaration.
+
2014-01-30 Marek Polacek <polacek@redhat.com>
PR c/59940
vec_alloc (v, len + 1);
for (z = 0; z < len; z++)
v->quick_push ((*params)[z]);
- f = build_function_call_vec (loc, function, v, NULL);
+ f = build_function_call_vec (loc, vNULL, function, v, NULL);
vec_free (v);
return f;
}
return error_mark_node;
first_param = (*params)[0];
- result = build_function_call_vec (loc, new_function, params, NULL);
+ result = build_function_call_vec (loc, vNULL, new_function, params,
+ NULL);
if (result == error_mark_node)
return result;
if (orig_code != BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N
extern tree build_function_call (location_t, tree, tree);
-extern tree build_function_call_vec (location_t, tree, vec<tree, va_gc> *,
- vec<tree, va_gc> *);
+extern tree build_function_call_vec (location_t, vec<location_t>, tree,
+ vec<tree, va_gc> *, vec<tree, va_gc> *);
extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
+2014-01-31 Marek Polacek <polacek@redhat.com>
+
+ PR c/59963
+ * c-typeck.c (convert_lvalue_to_rvalue): Pass vNULL to
+ build_function_call_vec.
+ (build_function_call): Likewise.
+ (build_atomic_assign): Likewise.
+ (build_function_call_vec): Add arg_loc parameter. Use it.
+ (convert_arguments): Likewise.
+ (convert_for_assignment): Rename rhs_loc to expr_loc.
+ * c-parser.c (c_parser_attributes): Pass NULL to c_parser_expr_list.
+ (c_parser_objc_keywordexpr): Likewise.
+ (c_parser_postfix_expression_after_primary): Call
+ build_function_call_vec with expr_loc rather than op_loc.
+ Call c_parser_expr_list to fill arg_loc. Pass arg_loc to
+ build_function_call_vec.
+ (c_parser_expr_list): Add locations parameter. Fill it with locations
+ of function arguments.
+ * c-decl.c (finish_decl): Pass vNULL to build_function_call_vec.
+
2014-01-30 Marek Polacek <polacek@redhat.com>
PR c/59940
vec_alloc (v, 1);
v->quick_push (cleanup);
cleanup = build_function_call_vec (DECL_SOURCE_LOCATION (decl),
- cleanup_decl, v, NULL);
+ vNULL, cleanup_decl, v, NULL);
vec_free (v);
/* Don't warn about decl unused; the cleanup uses it. */
static struct c_expr c_parser_expression_conv (c_parser *);
static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
vec<tree, va_gc> **, location_t *,
- tree *);
+ tree *, vec<location_t> *);
static void c_parser_omp_construct (c_parser *);
static void c_parser_omp_threadprivate (c_parser *);
static void c_parser_omp_barrier (c_parser *);
tree tree_list;
c_parser_consume_token (parser);
expr_list = c_parser_expr_list (parser, false, true,
- NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
tree_list = build_tree_list_vec (expr_list);
attr_args = tree_cons (NULL_TREE, arg1, tree_list);
release_tree_vector (expr_list);
else
{
expr_list = c_parser_expr_list (parser, false, true,
- NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
attr_args = build_tree_list_vec (expr_list);
release_tree_vector (expr_list);
}
unsigned int i;
vec<tree, va_gc> *exprlist;
vec<tree, va_gc> *origtypes = NULL;
+ vec<location_t> arg_loc = vNULL;
+
while (true)
{
location_t op_loc = c_parser_peek_token (parser)->location;
exprlist = NULL;
else
exprlist = c_parser_expr_list (parser, true, false, &origtypes,
- sizeof_arg_loc, sizeof_arg);
+ sizeof_arg_loc, sizeof_arg,
+ &arg_loc);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
"expected %<)%>");
orig_expr = expr;
expr.value, exprlist,
sizeof_arg,
sizeof_ptr_memacc_comptypes);
- /* FIXME diagnostics: Ideally we want the FUNCNAME, not the
- "(" after the FUNCNAME, which is what we have now. */
- expr.value = build_function_call_vec (op_loc, expr.value, exprlist,
- origtypes);
+ expr.value = build_function_call_vec (expr_loc, arg_loc, expr.value,
+ exprlist, origtypes);
expr.original_code = ERROR_MARK;
if (TREE_CODE (expr.value) == INTEGER_CST
&& TREE_CODE (orig_expr.value) == FUNCTION_DECL
release_tree_vector (exprlist);
release_tree_vector (origtypes);
}
+ arg_loc.release ();
break;
case CPP_DOT:
/* Structure element reference. */
/* Parse a non-empty list of expressions. If CONVERT_P, convert
functions and arrays to pointers and lvalues to rvalues. If
- FOLD_P, fold the expressions.
+ FOLD_P, fold the expressions. If LOCATIONS is non-NULL, save the
+ locations of function arguments into this vector.
nonempty-expr-list:
assignment-expression
static vec<tree, va_gc> *
c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
vec<tree, va_gc> **p_orig_types,
- location_t *sizeof_arg_loc, tree *sizeof_arg)
+ location_t *sizeof_arg_loc, tree *sizeof_arg,
+ vec<location_t> *locations)
{
vec<tree, va_gc> *ret;
vec<tree, va_gc> *orig_types;
ret->quick_push (expr.value);
if (orig_types)
orig_types->quick_push (expr.original_type);
+ if (locations)
+ locations->safe_push (loc);
if (sizeof_arg != NULL
&& cur_sizeof_arg_loc != UNKNOWN_LOCATION
&& expr.original_code == SIZEOF_EXPR)
vec_safe_push (ret, expr.value);
if (orig_types)
vec_safe_push (orig_types, expr.original_type);
+ if (locations)
+ locations->safe_push (loc);
if (++idx < 3
&& sizeof_arg != NULL
&& cur_sizeof_arg_loc != UNKNOWN_LOCATION
{
tree ret;
vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
- NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
if (vec_safe_length (expr_list) == 1)
{
/* Just return the expression, remove a level of
bool *);
static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
static tree lookup_field (tree, tree);
-static int convert_arguments (location_t, tree, vec<tree, va_gc> *,
- vec<tree, va_gc> *, tree, tree);
+static int convert_arguments (location_t, vec<location_t>, tree,
+ vec<tree, va_gc> *, vec<tree, va_gc> *, tree,
+ tree);
static tree pointer_diff (location_t, tree, tree);
static tree convert_for_assignment (location_t, location_t, tree, tree, tree,
enum impl_conv, bool, tree, tree, int);
params->quick_push (expr_addr);
params->quick_push (tmp_addr);
params->quick_push (seq_cst);
- func_call = build_function_call_vec (loc, fndecl, params, NULL);
+ func_call = build_function_call_vec (loc, vNULL, fndecl, params, NULL);
/* Return tmp which contains the value loaded. */
exp.value = build2 (COMPOUND_EXPR, nonatomic_type, func_call, tmp);
vec_alloc (v, list_length (params));
for (; params; params = TREE_CHAIN (params))
v->quick_push (TREE_VALUE (params));
- ret = build_function_call_vec (loc, function, v, NULL);
+ ret = build_function_call_vec (loc, vNULL, function, v, NULL);
vec_free (v);
return ret;
}
PARAMS. */
tree
-build_function_call_vec (location_t loc, tree function,
- vec<tree, va_gc> *params,
+build_function_call_vec (location_t loc, vec<location_t> arg_loc,
+ tree function, vec<tree, va_gc> *params,
vec<tree, va_gc> *origtypes)
{
tree fntype, fundecl = 0;
/* Convert the parameters to the types declared in the
function prototype, or apply default promotions. */
- nargs = convert_arguments (loc, TYPE_ARG_TYPES (fntype), params, origtypes,
- function, fundecl);
+ nargs = convert_arguments (loc, arg_loc, TYPE_ARG_TYPES (fntype), params,
+ origtypes, function, fundecl);
if (nargs < 0)
return error_mark_node;
This is also where warnings about wrong number of args are generated.
+ ARG_LOC are locations of function arguments (if any).
+
Returns the actual number of arguments processed (which may be less
than the length of VALUES in some error situations), or -1 on
failure. */
static int
-convert_arguments (location_t loc, tree typelist, vec<tree, va_gc> *values,
- vec<tree, va_gc> *origtypes, tree function, tree fundecl)
+convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist,
+ vec<tree, va_gc> *values, vec<tree, va_gc> *origtypes,
+ tree function, tree fundecl)
{
tree typetail, val;
unsigned int parmnum;
bool error_args = false;
const bool type_generic = fundecl
- && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
+ && lookup_attribute ("type generic", TYPE_ATTRIBUTES (TREE_TYPE (fundecl)));
bool type_generic_remove_excess_precision = false;
tree selector;
if (excess_precision)
val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
origtype = (!origtypes) ? NULL_TREE : (*origtypes)[parmnum];
- parmval = convert_for_assignment (loc, UNKNOWN_LOCATION, type,
+ bool arg_loc_ok = !arg_loc.is_empty ()
+ /* Some __atomic_* builtins have additional
+ hidden argument at position 0. */
+ && values->length () == arg_loc.length ();
+ parmval = convert_for_assignment (loc,
+ arg_loc_ok ? arg_loc[parmnum]
+ : UNKNOWN_LOCATION, type,
val, origtype, ic_argpass,
npc, fundecl, function,
parmnum + 1);
{
/* Convert `float' to `double'. */
if (warn_double_promotion && !c_inhibit_evaluation_warnings)
- warning (OPT_Wdouble_promotion,
+ warning_at (arg_loc[parmnum], OPT_Wdouble_promotion,
"implicit conversion from %qT to %qT when passing "
"argument to function",
valtype, double_type_node);
params->quick_push (lhs_addr);
params->quick_push (rhs);
params->quick_push (seq_cst);
- func_call = build_function_call_vec (loc, fndecl, params, NULL);
+ func_call = build_function_call_vec (loc, vNULL, fndecl, params, NULL);
add_stmt (func_call);
/* Finish the compound statement. */
params->quick_push (lhs_addr);
params->quick_push (old_addr);
params->quick_push (seq_cst);
- func_call = build_function_call_vec (loc, fndecl, params, NULL);
+ func_call = build_function_call_vec (loc, vNULL, fndecl, params, NULL);
add_stmt (func_call);
params->truncate (0);
params->quick_push (integer_zero_node);
params->quick_push (seq_cst);
params->quick_push (seq_cst);
- func_call = build_function_call_vec (loc, fndecl, params, NULL);
+ func_call = build_function_call_vec (loc, vNULL, fndecl, params, NULL);
goto_stmt = build1 (GOTO_EXPR, void_type_node, done_decl);
SET_EXPR_LOCATION (goto_stmt, loc);
ERRTYPE says whether it is argument passing, assignment,
initialization or return.
- LOCATION is the location of the assignment, RHS_LOC is the location of
- the RHS.
+ LOCATION is the location of the assignment, EXPR_LOC is the location of
+ the RHS or, for a function, location of an argument.
FUNCTION is a tree for the function being called.
PARMNUM is the number of the argument, for printing in error messages. */
static tree
-convert_for_assignment (location_t location, location_t rhs_loc, tree type,
+convert_for_assignment (location_t location, location_t expr_loc, tree type,
tree rhs, tree origtype, enum impl_conv errtype,
bool null_pointer_constant, tree fundecl,
tree function, int parmnum)
rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
SET_EXPR_LOCATION (rhs, location);
- rhs = convert_for_assignment (location, rhs_loc,
+ rhs = convert_for_assignment (location, expr_loc,
build_pointer_type (TREE_TYPE (type)),
rhs, origtype, errtype,
null_pointer_constant, fundecl, function,
bool save = in_late_binary_op;
if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE)
in_late_binary_op = true;
- ret = convert_and_check (rhs_loc != UNKNOWN_LOCATION
- ? rhs_loc : location, type, orig_rhs);
+ ret = convert_and_check (expr_loc != UNKNOWN_LOCATION
+ ? expr_loc : location, type, orig_rhs);
if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE)
in_late_binary_op = save;
return ret;
if ((codel == RECORD_TYPE || codel == UNION_TYPE)
&& codel == coder
&& comptypes (type, rhstype))
- return convert_and_check (rhs_loc != UNKNOWN_LOCATION
- ? rhs_loc : location, type, rhs);
+ return convert_and_check (expr_loc != UNKNOWN_LOCATION
+ ? expr_loc : location, type, rhs);
/* Conversion to a transparent union or record from its member types.
This applies only to function arguments. */
+2014-01-31 Marek Polacek <polacek@redhat.com>
+
+ PR c/59963
+ * typeck.c (build_function_call_vec): Add dummy arg_loc parameter.
+
2014-01-30 Jason Merrill <jason@redhat.com>
PR c++/57899
/* Used by the C-common bits. */
tree
-build_function_call_vec (location_t /*loc*/,
+build_function_call_vec (location_t /*loc*/, vec<location_t> /*arg_loc*/,
tree function, vec<tree, va_gc> *params,
vec<tree, va_gc> * /*origtypes*/)
{
+2014-01-31 Marek Polacek <polacek@redhat.com>
+
+ PR c/59963
+ * objc-next-runtime-abi-02.c (build_throw_stmt): Pass vNULL to
+ build_function_call_vec.
+ (finish_catch): Likewise.
+ (next_runtime_abi_02_get_class_reference): Likewise.
+ * objc-next-runtime-abi-01.c (build_objc_method_call): Pass vNULL to
+ build_function_call_vec.
+ (build_throw_stmt): Likewise.
+ * objc-gnu-runtime-abi-01.c: (build_objc_method_call): Pass vNULL to
+ build_function_call_vec.
+ (build_throw_stmt): Likewise.
+
2014-01-02 Richard Sandiford <rdsandiford@googlemail.com>
Update copyright years
then cast the pointer, then call it with the method arguments. */
tv->quick_push (lookup_object);
tv->quick_push (selector);
- method = build_function_call_vec (loc, sender, tv, NULL);
+ method = build_function_call_vec (loc, vNULL, sender, tv, NULL);
vec_free (tv);
/* Pass the appropriate object to the method. */
/* Build an obj_type_ref, with the correct cast for the method call. */
t = build3 (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node);
- t = build_function_call_vec (loc, t, parms, NULL);
+ t = build_function_call_vec (loc, vNULL, t, parms, NULL);
vec_free (parms);
return t;
}
/* A throw is just a call to the runtime throw function with the
object as a parameter. */
parms->quick_push (throw_expr);
- t = build_function_call_vec (loc, objc_exception_throw_decl, parms, NULL);
+ t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl, parms,
+ NULL);
vec_free (parms);
return add_stmt (t);
}
/* Build an obj_type_ref, with the correct cast for the method call. */
t = build3 (OBJ_TYPE_REF, sender_cast, method,
lookup_object, size_zero_node);
- t = build_function_call_vec (loc, t, parms, NULL);
+ t = build_function_call_vec (loc, vNULL, t, parms, NULL);
vec_free (parms);
return t;
}
/* A throw is just a call to the runtime throw function with the
object as a parameter. */
parms->quick_push (throw_expr);
- t = build_function_call_vec (loc, objc_exception_throw_decl, parms, NULL);
+ t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl, parms,
+ NULL);
vec_free (parms);
return add_stmt (t);
}
t = my_build_string_pointer (IDENTIFIER_LENGTH (ident) + 1,
IDENTIFIER_POINTER (ident));
v->quick_push (t);
- t = build_function_call_vec (input_location, objc_get_class_decl, v, 0);
+ t = build_function_call_vec (input_location, vNULL, objc_get_class_decl,
+ v, 0);
vec_free (v);
return t;
}
tree t;
if (rethrown)
/* We have a separate re-throw entry. */
- t = build_function_call_vec (loc, objc_rethrow_exception_decl, NULL, NULL);
+ t = build_function_call_vec (loc, vNULL, objc_rethrow_exception_decl,
+ NULL, NULL);
else
{
/* Throw like the others... */
vec<tree, va_gc> *parms;
vec_alloc (parms, 1);
parms->quick_push (throw_expr);
- t = build_function_call_vec (loc, objc_exception_throw_decl, parms, 0);
+ t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl,
+ parms, 0);
vec_free (parms);
}
return add_stmt (t);
/* Pick up the new context we made in begin_try above... */
ct = *cur_try_context;
- func = build_function_call_vec (loc, objc2_end_catch_decl, NULL, NULL);
+ func = build_function_call_vec (loc, vNULL, objc2_end_catch_decl, NULL,
+ NULL);
append_to_statement_list (func, &ct->finally_body);
try_exp = build_stmt (loc, TRY_FINALLY_EXPR, ct->try_body, ct->finally_body);
*cur_try_context = ct->outer;
+2014-01-31 Marek Polacek <polacek@redhat.com>
+
+ PR c/59963
+ * gcc.dg/pr59940.c (g): Adjust dg-warning.
+ (y): Adjust dg-error.
+ * gcc.dg/cast-function-1.c (bar): Adjust dg-warnings.
+ * gcc.dg/pr59963-1.c: New test.
+ * gcc.dg/pr59963-2.c: New test.
+ * gcc.dg/pr59963-3.c: New test.
+
2014-01-30 Jakub Jelinek <jakub@redhat.com>
PR target/59923
void bar(double d, int i, str_t s)
{
- d = ((double (*) (int)) foo1) (i); /* { dg-warning "33:non-compatible|abort" } */
- i = ((int (*) (double)) foo1) (d); /* { dg-warning "33:non-compatible|abort" } */
- s = ((str_t (*) (int)) foo1) (i); /* { dg-warning "32:non-compatible|abort" } */
+ d = ((double (*) (int)) foo1) (i); /* { dg-warning "7:non-compatible|abort" } */
+ i = ((int (*) (double)) foo1) (d); /* { dg-warning "7:non-compatible|abort" } */
+ s = ((str_t (*) (int)) foo1) (i); /* { dg-warning "7:non-compatible|abort" } */
((void (*) (int)) foo1) (d); /* { dg-warning "non-compatible|abort" } */
i = ((int (*) (int)) foo1) (i); /* { dg-bogus "non-compatible|abort" } */
(void) foo1 (i); /* { dg-bogus "non-compatible|abort" } */
- d = ((double (*) (int)) foo2) (i); /* { dg-warning "33:non-compatible|abort" } */
+ d = ((double (*) (int)) foo2) (i); /* { dg-warning "7:non-compatible|abort" } */
i = ((int (*) (double)) foo2) (d); /* { dg-bogus "non-compatible|abort" } */
s = ((str_t (*) (int)) foo2) (i); /* { dg-warning "non-compatible|abort" } */
((void (*) (int)) foo2) (d); /* { dg-warning "non-compatible|abort" } */
si = 3.2f; /* { dg-warning "8:conversion" } */
uc = 256; /* { dg-warning "8:large integer implicitly truncated to unsigned type" } */
si = 0x800000000; /* { dg-warning "8:overflow in implicit constant conversion" } */
- return f (si) /* { dg-warning "12:conversion" } */
- + f (si); /* { dg-warning "14:conversion" } */
+ return f (si) /* { dg-warning "13:conversion" } */
+ + f (si); /* { dg-warning "15:conversion" } */
}
int
y (void)
{
- f (); /* { dg-error "5:too few arguments to function" } */
- g (0xa); /* { dg-error "5:too many arguments to function" } */
+ f (); /* { dg-error "3:too few arguments to function" } */
+ g (0xa); /* { dg-error "3:too many arguments to function" } */
}
--- /dev/null
+/* PR c/59963 */
+/* { dg-do compile } */
+/* { dg-options "-Wdouble-promotion" } */
+
+extern void baz ();
+extern void qux (int, ...);
+
+void
+foo (float f)
+{
+ bar (f); /* { dg-warning "8:implicit conversion" } */
+ baz (f); /* { dg-warning "8:implicit conversion" } */
+ qux (42, f); /* { dg-warning "12:implicit conversion" } */
+}
--- /dev/null
+/* PR c/59963 */
+/* { dg-do compile } */
+/* { dg-options "-Woverflow -Wconversion" } */
+
+extern void bar (unsigned char);
+extern void bar8 (unsigned char, unsigned char, unsigned char, unsigned char,
+ unsigned char, unsigned char, unsigned char, unsigned char);
+extern void bazu (unsigned int, ...);
+extern void bazi (char, int);
+extern int f (short a, short b);
+
+int
+g (void)
+{
+ return f (0xffffffffL, /* { dg-warning "13:overflow in implicit constant conversion" } */
+ 0xffffffffL) /* { dg-warning "13:overflow in implicit constant conversion" } */
+ && f (0xffffffffL, /* { dg-warning "9:overflow in implicit constant conversion" } */
+ 0xffffffffL); /* { dg-warning "9:overflow in implicit constant conversion" } */
+}
+
+void
+foo (int i)
+{
+ bar (256); /* { dg-warning "8:large integer implicitly truncated to unsigned type" } */
+ bar (6.66f); /* { dg-warning "8:conversion" } */
+ bar8 (-1, /* { dg-warning "9:negative integer implicitly converted to unsigned type" } */
+ -2, /* { dg-warning "3:negative integer implicitly converted to unsigned type" } */
+ -3, /* { dg-warning "4:negative integer implicitly converted to unsigned type" } */
+ -4, /* { dg-warning "5:negative integer implicitly converted to unsigned type" } */
+ -5, /* { dg-warning "6:negative integer implicitly converted to unsigned type" } */
+ -6, /* { dg-warning "7:negative integer implicitly converted to unsigned type" } */
+ -7, /* { dg-warning "8:negative integer implicitly converted to unsigned type" } */
+ -8); /* { dg-warning "9:negative integer implicitly converted to unsigned type" } */
+ bazu (i, i); /* { dg-warning "9:conversion" } */
+ bazi (0x8, 0x80000000); /* { dg-warning "14:conversion of unsigned constant value to negative integer" } */
+}
--- /dev/null
+/* PR c/59963 */
+/* { dg-do compile } */
+/* { dg-options "-Wconversion" } */
+
+extern void foo (void *p);
+
+void
+bar (void)
+{
+ {
+ /* This must not ICE. */
+ int i __attribute__((cleanup (foo)));
+ }
+}
projects / gcc.git / commitdiff