From ba47d38d4c5d229c686e479fceb9ee9eb23442ff Mon Sep 17 00:00:00 2001 From: Aldy Hernandez Date: Tue, 23 Sep 2008 14:55:14 +0000 Subject: [PATCH] c-tree.h: Add argument to c_objc_common_truthvalue_conversion, parser_build_binary_op. * c-tree.h: Add argument to c_objc_common_truthvalue_conversion, parser_build_binary_op. * c-decl.c (build_enumerator): Pass location to build_binary_op. * c-typeck.c (build_array_ref): Same. (parser_build_unary_op): New location argument. (pointer_diff): Pass location to build_binary_op, c_objc_common_truthvalue_conversion. (build_modify_expr): Same. (build_unary_op): New location argument. (build_binary_op): New location argument. (c_objc_common_truthvalue_conversion): Pass location to c_*common_truthvalue_conversion. * c-convert.c (convert): Same. * c-common.c (binary_op_error): New location argument. (pointer_int_sum): Pass location to build_binary_op. (c_common_truthvalue_conversion): New location argument. (warn_for_sign_compare): Same. * c-common.h: Add location argument to c_common_truthvalue_conversion, binary_op_error, build_binary_op, warn_for_sign_compare. * c-parser.c (c_parser_condition): Pass location to c_*common_truthvalue_conversion. (c_parser_conditional_expression): Save condition's location and pass it on down. (c_parser_binary_expression): Same, but for the binary operator's location. (c_parser_omp_for_loop): Pass location to c_objc_common_truthvalue_conversion. objc/ * objc-act.c (next_sjlj_build_enter_and_setjmp): Call c_common_truthvalue_conversion with location. (next_sjlj_build_catch_list): Same. (next_sjlj_build_try_catch_finally): Same. testsuite/ * gcc.dg/Walways-true-1.c: Test column numbers. * gcc.dg/c90-const-expr-5.c: Same. * gcc.dg/compare4.c: Same. * gcc.dg/Werror-1.c: Same. cp/ * typeck.c (build_array_ref): Pass location to cp_build_binary_op. (get_member_function_from_ptrfunc): Same. (build_x_binary_op): Same. (build_binary_op): Same. (cp_build_binary_op): New location argument. (pointer_diff): Pass location to cp_build_binary_op. (cp_truthvalue_conversion): Pass location to build_binary_op. (convert_ptrmem): Pass location to cp_build_binary_op. (cp_build_modify_expr): Same. (build_ptrmemfunc): Same. * init.c (expand_cleanup_for_base): Pass location to c_common_truthvalue_conversion. (build_new_1): Pass location to cp_build_binary_op. (build_vec_delete_1): Pass location to *build_binary_op, c_common_truthvalue_conversion. (build_vec_init): Same. (build_delete): Same. * decl.c (compute_array_index_type): Same. * call.c (build_new_op): Same. * rtti.c (build_dynamic_cast_1): Same. * cp-tree.h: Add argument to cp_build_binary_op. * semantics.c (handle_omp_for_class_iterator): Pass location to *build_binary_op, c_common_truthvalue_conversion. * decl2.c (get_guard_cond): Same. From-SVN: r140598 --- gcc/ChangeLog | 30 +++++++ gcc/c-common.c | 101 +++++++++++++++-------- gcc/c-common.h | 9 +- gcc/c-convert.c | 3 +- gcc/c-decl.c | 6 +- gcc/c-parser.c | 23 ++++-- gcc/c-tree.h | 5 +- gcc/c-typeck.c | 102 +++++++++++++---------- gcc/cp/ChangeLog | 27 ++++++ gcc/cp/call.c | 2 +- gcc/cp/cp-tree.h | 3 +- gcc/cp/decl.c | 3 +- gcc/cp/decl2.c | 30 ++++--- gcc/cp/init.c | 23 ++++-- gcc/cp/rtti.c | 2 +- gcc/cp/semantics.c | 3 +- gcc/cp/typeck.c | 105 +++++++++++++++--------- gcc/objc/ChangeLog | 7 ++ gcc/objc/objc-act.c | 10 ++- gcc/testsuite/ChangeLog | 8 ++ gcc/testsuite/gcc.dg/Walways-true-1.c | 26 +++--- gcc/testsuite/gcc.dg/Werror-1.c | 4 +- gcc/testsuite/gcc.dg/c90-const-expr-5.c | 16 ++-- gcc/testsuite/gcc.dg/compare4.c | 6 +- gcc/testsuite/gcc.dg/misc-column.c | 29 +++++++ 25 files changed, 395 insertions(+), 188 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/misc-column.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0f04eb4022a..45c2c3c11dc 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,33 @@ +2008-09-23 Aldy Hernandez + + * c-tree.h: Add argument to c_objc_common_truthvalue_conversion, + parser_build_binary_op. + * c-decl.c (build_enumerator): Pass location to build_binary_op. + * c-typeck.c (build_array_ref): Same. + (parser_build_unary_op): New location argument. + (pointer_diff): Pass location to build_binary_op, + c_objc_common_truthvalue_conversion. + (build_modify_expr): Same. + (build_unary_op): New location argument. + (build_binary_op): New location argument. + (c_objc_common_truthvalue_conversion): Pass location to + c_*common_truthvalue_conversion. + * c-convert.c (convert): Same. + * c-common.c (binary_op_error): New location argument. + (pointer_int_sum): Pass location to build_binary_op. + (c_common_truthvalue_conversion): New location argument. + (warn_for_sign_compare): Same. + * c-common.h: Add location argument to c_common_truthvalue_conversion, + binary_op_error, build_binary_op, warn_for_sign_compare. + * c-parser.c (c_parser_condition): Pass location to + c_*common_truthvalue_conversion. + (c_parser_conditional_expression): Save condition's location and pass + it on down. + (c_parser_binary_expression): Same, but for the binary operator's + location. + (c_parser_omp_for_loop): Pass location to + c_objc_common_truthvalue_conversion. + 2008-09-23 Martin Jambor * cgraph.c (cgraph_free_edge): Use sizeof(*e). diff --git a/gcc/c-common.c b/gcc/c-common.c index a810bead87c..09027bab795 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -2849,10 +2849,12 @@ min_precision (tree value, int unsignedp) } /* Print an error message for invalid operands to arith operation - CODE with TYPE0 for operand 0, and TYPE1 for operand 1. */ + CODE with TYPE0 for operand 0, and TYPE1 for operand 1. + LOCATION is the location of the message. */ void -binary_op_error (enum tree_code code, tree type0, tree type1) +binary_op_error (location_t location, enum tree_code code, + tree type0, tree type1) { const char *opname; @@ -2903,8 +2905,9 @@ binary_op_error (enum tree_code code, tree type0, tree type1) default: gcc_unreachable (); } - error ("invalid operands to binary %s (have %qT and %qT)", opname, - type0, type1); + error_at (location, + "invalid operands to binary %s (have %qT and %qT)", opname, + type0, type1); } /* Subroutine of build_binary_op, used for comparison operations. @@ -3320,7 +3323,8 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop) /* Convert both subexpression types to the type of intop, because weird cases involving pointer arithmetic can result in a sum or difference with different type args. */ - ptrop = build_binary_op (subcode, ptrop, + ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)), + subcode, ptrop, convert (int_type, TREE_OPERAND (intop, 1)), 1); intop = convert (int_type, TREE_OPERAND (intop, 0)); } @@ -3336,7 +3340,8 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop) Do this multiplication as signed, then convert to the appropriate type for the pointer operation. */ intop = convert (sizetype, - build_binary_op (MULT_EXPR, intop, + build_binary_op (EXPR_LOCATION (intop), + MULT_EXPR, intop, convert (TREE_TYPE (intop), size_exp), 1)); /* Create the sum or difference. */ @@ -3367,6 +3372,8 @@ decl_with_nonnull_addr_p (const_tree expr) have been validated to be of suitable type; otherwise, a bad diagnostic may result. + The EXPR is located at LOCATION. + This preparation consists of taking the ordinary representation of an expression expr and producing a valid tree boolean expression describing whether expr is nonzero. We could @@ -3376,7 +3383,7 @@ decl_with_nonnull_addr_p (const_tree expr) The resulting type should always be `truthvalue_type_node'. */ tree -c_common_truthvalue_conversion (tree expr) +c_common_truthvalue_conversion (location_t location, tree expr) { switch (TREE_CODE (expr)) { @@ -3397,14 +3404,17 @@ c_common_truthvalue_conversion (tree expr) if (TREE_TYPE (expr) == truthvalue_type_node) return expr; return build2 (TREE_CODE (expr), truthvalue_type_node, - c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)), - c_common_truthvalue_conversion (TREE_OPERAND (expr, 1))); + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 0)), + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 1))); case TRUTH_NOT_EXPR: if (TREE_TYPE (expr) == truthvalue_type_node) return expr; return build1 (TREE_CODE (expr), truthvalue_type_node, - c_common_truthvalue_conversion (TREE_OPERAND (expr, 0))); + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 0))); case ERROR_MARK: return expr; @@ -3434,9 +3444,10 @@ c_common_truthvalue_conversion (tree expr) if (decl_with_nonnull_addr_p (inner)) { /* Common Ada/Pascal programmer's mistake. */ - warning (OPT_Waddress, - "the address of %qD will always evaluate as %", - inner); + warning_at (location, + OPT_Waddress, + "the address of %qD will always evaluate as %", + inner); return truthvalue_true_node; } @@ -3456,17 +3467,20 @@ c_common_truthvalue_conversion (tree expr) } case COMPLEX_EXPR: - return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) + return build_binary_op (EXPR_LOCATION (expr), + (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), - c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)), - c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)), + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 0)), + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 1)), 0); case NEGATE_EXPR: case ABS_EXPR: case FLOAT_EXPR: /* These don't change whether an object is nonzero or zero. */ - return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)); + return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0)); case LROTATE_EXPR: case RROTATE_EXPR: @@ -3475,16 +3489,20 @@ c_common_truthvalue_conversion (tree expr) if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) return build2 (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1), - c_common_truthvalue_conversion (TREE_OPERAND (expr, 0))); + c_common_truthvalue_conversion + (location, TREE_OPERAND (expr, 0))); else - return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)); + return c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 0)); case COND_EXPR: /* Distribute the conversion into the arms of a COND_EXPR. */ return fold_build3 (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0), - c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)), - c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))); + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 1)), + c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 2))); CASE_CONVERT: /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, @@ -3495,7 +3513,8 @@ c_common_truthvalue_conversion (tree expr) /* If this is widening the argument, we can ignore it. */ if (TYPE_PRECISION (TREE_TYPE (expr)) >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) - return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)); + return c_common_truthvalue_conversion (location, + TREE_OPERAND (expr, 0)); break; case MODIFY_EXPR: @@ -3516,10 +3535,13 @@ c_common_truthvalue_conversion (tree expr) { tree t = save_expr (expr); return (build_binary_op - ((TREE_SIDE_EFFECTS (expr) + (EXPR_LOCATION (expr), + (TREE_SIDE_EFFECTS (expr) ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), - c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)), - c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)), + c_common_truthvalue_conversion (location, + build_unary_op (REALPART_EXPR, t, 0)), + c_common_truthvalue_conversion (location, + build_unary_op (IMAGPART_EXPR, t, 0)), 0)); } @@ -3528,10 +3550,12 @@ c_common_truthvalue_conversion (tree expr) tree fixed_zero_node = build_fixed (TREE_TYPE (expr), FCONST0 (TYPE_MODE (TREE_TYPE (expr)))); - return build_binary_op (NE_EXPR, expr, fixed_zero_node, 1); + return build_binary_op (EXPR_LOCATION (expr), + NE_EXPR, expr, fixed_zero_node, 1); } - return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); + return build_binary_op (EXPR_LOCATION (expr), + NE_EXPR, expr, integer_zero_node, 1); } static void def_builtin_1 (enum built_in_function fncode, @@ -8198,13 +8222,16 @@ warn_for_div_by_zero (tree divisor) between signed and unsigned quantities that may fail. Do the checking based on the original operand trees ORIG_OP0 and ORIG_OP1, so that casts will be considered, but default promotions won't - be. + be. + + LOCATION is the location of the comparison operator. The arguments of this function map directly to local variables of build_binary_op. */ void -warn_for_sign_compare (tree orig_op0, tree orig_op1, +warn_for_sign_compare (location_t location, + tree orig_op0, tree orig_op1, tree op0, tree op1, tree result_type, enum tree_code resultcode) { @@ -8219,8 +8246,9 @@ warn_for_sign_compare (tree orig_op0, tree orig_op1, && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))) { - warning (OPT_Wsign_compare, "comparison between types %qT and %qT", - TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); + warning_at (location, + OPT_Wsign_compare, "comparison between types %qT and %qT", + TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); } /* Do not warn if the comparison is being done in a signed type, @@ -8266,8 +8294,9 @@ warn_for_sign_compare (tree orig_op0, tree orig_op1, c_common_signed_type (result_type))) /* OK */; else - warning (OPT_Wsign_compare, - "comparison between signed and unsigned integer expressions"); + warning_at (location, + OPT_Wsign_compare, + "comparison between signed and unsigned integer expressions"); } /* Warn if two unsigned values are being compared in a size larger @@ -8320,8 +8349,8 @@ warn_for_sign_compare (tree orig_op0, tree orig_op1, warning (OPT_Wsign_compare, "promoted ~unsigned is always non-zero"); else - warning (OPT_Wsign_compare, - "comparison of promoted ~unsigned with constant"); + warning_at (location, OPT_Wsign_compare, + "comparison of promoted ~unsigned with constant"); } } } @@ -8330,7 +8359,7 @@ warn_for_sign_compare (tree orig_op0, tree orig_op1, < TYPE_PRECISION (result_type)) && (TYPE_PRECISION (TREE_TYPE (op1)) < TYPE_PRECISION (result_type))) - warning (OPT_Wsign_compare, + warning_at (location, OPT_Wsign_compare, "comparison of promoted ~unsigned with unsigned"); } } diff --git a/gcc/c-common.h b/gcc/c-common.h index 96c5fa071cb..9621b05ba46 100644 --- a/gcc/c-common.h +++ b/gcc/c-common.h @@ -714,13 +714,13 @@ extern tree c_common_signed_type (tree); extern tree c_common_signed_or_unsigned_type (int, tree); extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int); extern bool decl_with_nonnull_addr_p (const_tree); -extern tree c_common_truthvalue_conversion (tree); +extern tree c_common_truthvalue_conversion (location_t, tree); extern void c_apply_type_quals_to_decl (int, tree); extern tree c_sizeof_or_alignof_type (tree, bool, int); extern tree c_alignof_expr (tree); /* Print an error message for invalid operands to arith operation CODE. NOP_EXPR is used as a special case (see truthvalue_conversion). */ -extern void binary_op_error (enum tree_code, tree, tree); +extern void binary_op_error (location_t, enum tree_code, tree, tree); extern tree fix_string_type (tree); struct varray_head_tag; extern void constant_expression_warning (tree); @@ -817,7 +817,7 @@ extern tree build_case_label (tree, tree, tree); a variant of the C language. They are used in c-common.c. */ extern tree build_unary_op (enum tree_code, tree, int); -extern tree build_binary_op (enum tree_code, tree, tree, int); +extern tree build_binary_op (location_t, enum tree_code, tree, tree, int); extern tree perform_integral_promotions (tree); /* These functions must be defined by each front-end which implements @@ -917,7 +917,8 @@ extern void warn_about_parentheses (enum tree_code, enum tree_code, enum tree_code); extern void warn_for_unused_label (tree label); extern void warn_for_div_by_zero (tree divisor); -extern void warn_for_sign_compare (tree orig_op0, tree orig_op1, +extern void warn_for_sign_compare (location_t, + tree orig_op0, tree orig_op1, tree op0, tree op1, tree result_type, enum tree_code resultcode); diff --git a/gcc/c-convert.c b/gcc/c-convert.c index 8fa68a190b6..a5dc1fb39ff 100644 --- a/gcc/c-convert.c +++ b/gcc/c-convert.c @@ -100,7 +100,8 @@ convert (tree type, tree expr) if (code == INTEGER_TYPE || code == ENUMERAL_TYPE) return fold (convert_to_integer (type, e)); if (code == BOOLEAN_TYPE) - return fold_convert (type, c_objc_common_truthvalue_conversion (expr)); + return fold_convert + (type, c_objc_common_truthvalue_conversion (input_location, expr)); if (code == POINTER_TYPE || code == REFERENCE_TYPE) return fold (convert_to_pointer (type, e)); if (code == REAL_TYPE) diff --git a/gcc/c-decl.c b/gcc/c-decl.c index ae8861e2b85..70265557269 100644 --- a/gcc/c-decl.c +++ b/gcc/c-decl.c @@ -6027,8 +6027,10 @@ build_enumerator (struct c_enum_contents *the_enum, tree name, tree value, "ISO C restricts enumerator values to range of %"); /* Set basis for default for next value. */ - the_enum->enum_next_value = build_binary_op (PLUS_EXPR, value, - integer_one_node, 0); + the_enum->enum_next_value + = build_binary_op + (EXPR_HAS_LOCATION (value) ? EXPR_LOCATION (value) : input_location, + PLUS_EXPR, value, integer_one_node, 0); the_enum->enum_overflow = tree_int_cst_lt (the_enum->enum_next_value, value); /* Now create a declaration for the enum value name. */ diff --git a/gcc/c-parser.c b/gcc/c-parser.c index 43ef655495e..4222f41e19f 100644 --- a/gcc/c-parser.c +++ b/gcc/c-parser.c @@ -3805,7 +3805,7 @@ c_parser_condition (c_parser *parser) tree cond; loc = c_parser_peek_token (parser)->location; cond = c_objc_common_truthvalue_conversion - (c_parser_expression_conv (parser).value); + (loc, c_parser_expression_conv (parser).value); if (CAN_HAVE_LOCATION_P (cond)) SET_EXPR_LOCATION (cond, loc); if (warn_sequence_point) @@ -4426,8 +4426,13 @@ static struct c_expr c_parser_conditional_expression (c_parser *parser, struct c_expr *after) { struct c_expr cond, exp1, exp2, ret; + location_t cond_loc; + gcc_assert (!after || c_dialect_objc ()); + + cond_loc = c_parser_peek_token (parser)->location; cond = c_parser_binary_expression (parser, after); + if (c_parser_next_token_is_not (parser, CPP_QUERY)) return cond; cond = default_function_array_conversion (cond); @@ -4438,14 +4443,14 @@ c_parser_conditional_expression (c_parser *parser, struct c_expr *after) "ISO C forbids omitting the middle term of a ?: expression"); /* Make sure first operand is calculated only once. */ exp1.value = save_expr (default_conversion (cond.value)); - cond.value = c_objc_common_truthvalue_conversion (exp1.value); + cond.value = c_objc_common_truthvalue_conversion (cond_loc, exp1.value); skip_evaluation += cond.value == truthvalue_true_node; } else { cond.value = c_objc_common_truthvalue_conversion - (default_conversion (cond.value)); + (cond_loc, default_conversion (cond.value)); skip_evaluation += cond.value == truthvalue_false_node; exp1 = c_parser_expression_conv (parser); skip_evaluation += ((cond.value == truthvalue_true_node) @@ -4570,6 +4575,8 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after) enum tree_code op; } stack[NUM_PRECS]; int sp; + /* Location of the binary operator. */ + location_t binary_loc; #define POP \ do { \ switch (stack[sp].op) \ @@ -4587,7 +4594,8 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after) = default_function_array_conversion (stack[sp - 1].expr); \ stack[sp].expr \ = default_function_array_conversion (stack[sp].expr); \ - stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \ + stack[sp - 1].expr = parser_build_binary_op (binary_loc, \ + stack[sp].op, \ stack[sp - 1].expr, \ stack[sp].expr); \ sp--; \ @@ -4681,6 +4689,7 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after) expression. */ goto out; } + binary_loc = c_parser_peek_token (parser)->location; c_parser_consume_token (parser); while (oprec <= stack[sp].prec) POP; @@ -4690,14 +4699,14 @@ c_parser_binary_expression (c_parser *parser, struct c_expr *after) stack[sp].expr = default_function_array_conversion (stack[sp].expr); stack[sp].expr.value = c_objc_common_truthvalue_conversion - (default_conversion (stack[sp].expr.value)); + (binary_loc, default_conversion (stack[sp].expr.value)); skip_evaluation += stack[sp].expr.value == truthvalue_false_node; break; case TRUTH_ORIF_EXPR: stack[sp].expr = default_function_array_conversion (stack[sp].expr); stack[sp].expr.value = c_objc_common_truthvalue_conversion - (default_conversion (stack[sp].expr.value)); + (binary_loc, default_conversion (stack[sp].expr.value)); skip_evaluation += stack[sp].expr.value == truthvalue_true_node; break; default: @@ -7602,7 +7611,7 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses) if (c_parser_next_token_is_not (parser, CPP_SEMICOLON)) { cond = c_parser_expression_conv (parser).value; - cond = c_objc_common_truthvalue_conversion (cond); + cond = c_objc_common_truthvalue_conversion (input_location, cond); if (CAN_HAVE_LOCATION_P (cond)) SET_EXPR_LOCATION (cond, input_location); } diff --git a/gcc/c-tree.h b/gcc/c-tree.h index 1329ce32282..26ef664092a 100644 --- a/gcc/c-tree.h +++ b/gcc/c-tree.h @@ -521,7 +521,6 @@ extern struct c_declspecs *finish_declspecs (struct c_declspecs *); /* in c-objc-common.c */ extern bool c_objc_common_init (void); extern bool c_missing_noreturn_ok_p (tree); -extern tree c_objc_common_truthvalue_conversion (tree expr); extern bool c_warn_unused_global_decl (const_tree); extern void c_initialize_diagnostics (diagnostic_context *); extern bool c_vla_unspec_p (tree x, tree fn); @@ -540,6 +539,7 @@ extern struct c_switch *c_switch_stack; extern struct c_label_context_se *label_context_stack_se; extern struct c_label_context_vm *label_context_stack_vm; +extern tree c_objc_common_truthvalue_conversion (location_t, tree); extern tree require_complete_type (tree); extern int same_translation_unit_p (const_tree, const_tree); extern int comptypes (tree, tree); @@ -557,7 +557,8 @@ extern struct c_expr c_expr_sizeof_expr (struct c_expr); extern struct c_expr c_expr_sizeof_type (struct c_type_name *); extern struct c_expr parser_build_unary_op (enum tree_code, struct c_expr, location_t); -extern struct c_expr parser_build_binary_op (enum tree_code, struct c_expr, +extern struct c_expr parser_build_binary_op (location_t, + enum tree_code, struct c_expr, struct c_expr); extern tree build_conditional_expr (tree, tree, tree); extern tree build_compound_expr (tree, tree); diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index e9f3fc75b5d..14244051f17 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -2163,8 +2163,9 @@ build_array_ref (tree array, tree index, location_t loc) gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); - return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), - "array indexing", loc); + return build_indirect_ref + (build_binary_op (loc, PLUS_EXPR, ar, index, 0), + "array indexing", loc); } } @@ -2760,23 +2761,29 @@ parser_build_unary_op (enum tree_code code, struct c_expr arg, location_t loc) in the input. CODE, a tree_code, specifies the binary operator, and ARG1 and ARG2 are the operands. In addition to constructing the expression, we check for operands that were written with other binary - operators in a way that is likely to confuse the user. */ + operators in a way that is likely to confuse the user. + + LOCATION is the location of the binary operator. */ struct c_expr -parser_build_binary_op (enum tree_code code, struct c_expr arg1, - struct c_expr arg2) +parser_build_binary_op (location_t location, enum tree_code code, + struct c_expr arg1, struct c_expr arg2) { struct c_expr result; enum tree_code code1 = arg1.original_code; enum tree_code code2 = arg2.original_code; - result.value = build_binary_op (code, arg1.value, arg2.value, 1); + result.value = build_binary_op (location, code, + arg1.value, arg2.value, 1); result.original_code = code; if (TREE_CODE (result.value) == ERROR_MARK) return result; + if (location != UNKNOWN_LOCATION) + protected_set_expr_location (result.value, location); + /* Check for cases such as x+y< with function pointer"); } else if (VOID_TYPE_P (tt1)) { if (pedantic && !null_pointer_constant_p (orig_op1) && TREE_CODE (tt0) == FUNCTION_TYPE) - pedwarn (input_location, OPT_pedantic, "ISO C forbids " + pedwarn (location, OPT_pedantic, "ISO C forbids " "comparison of % with function pointer"); } else /* Avoid warning about the volatile ObjC EH puts on decls. */ if (!objc_ok) - pedwarn (input_location, 0, + pedwarn (location, 0, "comparison of distinct pointer types lacks a cast"); if (result_type == NULL_TREE) @@ -8245,27 +8259,29 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, { if (TREE_CODE (op0) == ADDR_EXPR && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0))) - warning (OPT_Waddress, "the address of %qD will never be NULL", - TREE_OPERAND (op0, 0)); + warning_at (location, + OPT_Waddress, "the address of %qD will never be NULL", + TREE_OPERAND (op0, 0)); result_type = type0; } else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) { if (TREE_CODE (op1) == ADDR_EXPR && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0))) - warning (OPT_Waddress, "the address of %qD will never be NULL", - TREE_OPERAND (op1, 0)); + warning_at (location, + OPT_Waddress, "the address of %qD will never be NULL", + TREE_OPERAND (op1, 0)); result_type = type1; } else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) { result_type = type0; - pedwarn (input_location, 0, "comparison between pointer and integer"); + pedwarn (location, 0, "comparison between pointer and integer"); } else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) { result_type = type1; - pedwarn (input_location, 0, "comparison between pointer and integer"); + pedwarn (location, 0, "comparison between pointer and integer"); } break; @@ -8286,16 +8302,16 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, result_type = common_pointer_type (type0, type1); if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) != !COMPLETE_TYPE_P (TREE_TYPE (type1))) - pedwarn (input_location, 0, + pedwarn (location, 0, "comparison of complete and incomplete pointers"); else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) - pedwarn (input_location, OPT_pedantic, "ISO C forbids " + pedwarn (location, OPT_pedantic, "ISO C forbids " "ordered comparisons of pointers to functions"); } else { result_type = ptr_type_node; - pedwarn (input_location, 0, + pedwarn (location, 0, "comparison of distinct pointer types lacks a cast"); } } @@ -8303,27 +8319,27 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, { result_type = type0; if (pedantic) - pedwarn (input_location, OPT_pedantic, + pedwarn (location, OPT_pedantic, "ordered comparison of pointer with integer zero"); else if (extra_warnings) - warning (OPT_Wextra, + warning_at (location, OPT_Wextra, "ordered comparison of pointer with integer zero"); } else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) { result_type = type1; - pedwarn (input_location, OPT_pedantic, + pedwarn (location, OPT_pedantic, "ordered comparison of pointer with integer zero"); } else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) { result_type = type0; - pedwarn (input_location, 0, "comparison between pointer and integer"); + pedwarn (location, 0, "comparison between pointer and integer"); } else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) { result_type = type1; - pedwarn (input_location, 0, "comparison between pointer and integer"); + pedwarn (location, 0, "comparison between pointer and integer"); } break; @@ -8339,7 +8355,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), TREE_TYPE (type1)))) { - binary_op_error (code, type0, type1); + binary_op_error (location, code, type0, type1); return error_mark_node; } @@ -8429,7 +8445,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, if (warn_sign_compare && !skip_evaluation) { - warn_for_sign_compare (orig_op0, orig_op1, op0, op1, + warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1, result_type, resultcode); } } @@ -8443,7 +8459,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, if (!result_type) { - binary_op_error (code, TREE_TYPE (op0), TREE_TYPE (op1)); + binary_op_error (location, code, TREE_TYPE (op0), TREE_TYPE (op1)); return error_mark_node; } @@ -8479,23 +8495,23 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, /* Convert EXPR to be a truth-value, validating its type for this - purpose. */ + purpose. LOCATION is the source location for the expression. */ tree -c_objc_common_truthvalue_conversion (tree expr) +c_objc_common_truthvalue_conversion (location_t location, tree expr) { switch (TREE_CODE (TREE_TYPE (expr))) { case ARRAY_TYPE: - error ("used array that cannot be converted to pointer where scalar is required"); + error_at (location, "used array that cannot be converted to pointer where scalar is required"); return error_mark_node; case RECORD_TYPE: - error ("used struct type value where scalar is required"); + error_at (location, "used struct type value where scalar is required"); return error_mark_node; case UNION_TYPE: - error ("used union type value where scalar is required"); + error_at (location, "used union type value where scalar is required"); return error_mark_node; case FUNCTION_TYPE: @@ -8507,7 +8523,7 @@ c_objc_common_truthvalue_conversion (tree expr) /* ??? Should we also give an error for void and vectors rather than leaving those to give errors later? */ - return c_common_truthvalue_conversion (expr); + return c_common_truthvalue_conversion (location, expr); } diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ebab140a9f5..4b5105e04e8 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,30 @@ +2008-09-23 Aldy Hernandez + + * typeck.c (build_array_ref): Pass location to cp_build_binary_op. + (get_member_function_from_ptrfunc): Same. + (build_x_binary_op): Same. + (build_binary_op): Same. + (cp_build_binary_op): New location argument. + (pointer_diff): Pass location to cp_build_binary_op. + (cp_truthvalue_conversion): Pass location to build_binary_op. + (convert_ptrmem): Pass location to cp_build_binary_op. + (cp_build_modify_expr): Same. + (build_ptrmemfunc): Same. + * init.c (expand_cleanup_for_base): Pass location to + c_common_truthvalue_conversion. + (build_new_1): Pass location to cp_build_binary_op. + (build_vec_delete_1): Pass location to *build_binary_op, + c_common_truthvalue_conversion. + (build_vec_init): Same. + (build_delete): Same. + * decl.c (compute_array_index_type): Same. + * call.c (build_new_op): Same. + * rtti.c (build_dynamic_cast_1): Same. + * cp-tree.h: Add argument to cp_build_binary_op. + * semantics.c (handle_omp_for_class_iterator): Pass location to + *build_binary_op, c_common_truthvalue_conversion. + * decl2.c (get_guard_cond): Same. + 2008-09-17 Richard Guenther PR c++/22374 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 653e06e3833..bdaf7fdcc92 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -4199,7 +4199,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, case BIT_AND_EXPR: case BIT_IOR_EXPR: case BIT_XOR_EXPR: - return cp_build_binary_op (code, arg1, arg2, complain); + return cp_build_binary_op (input_location, code, arg1, arg2, complain); case UNARY_PLUS_EXPR: case NEGATE_EXPR: diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 065e47de147..c32fff6b7b4 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4963,7 +4963,8 @@ extern tree composite_pointer_type (tree, tree, tree, tree, const char*, tsubst_flags_t); extern tree merge_types (tree, tree); extern tree check_return_expr (tree, bool *); -extern tree cp_build_binary_op (enum tree_code, tree, tree, +extern tree cp_build_binary_op (location_t, + enum tree_code, tree, tree, tsubst_flags_t); #define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) extern tree build_ptrmemfunc_access_expr (tree, tree); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index f57ca871254..82e0bba649f 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -7223,7 +7223,8 @@ compute_array_index_type (tree name, tree size) cp_build_binary_op will be appropriately folded. */ saved_processing_template_decl = processing_template_decl; processing_template_decl = 0; - itype = cp_build_binary_op (MINUS_EXPR, + itype = cp_build_binary_op (input_location, + MINUS_EXPR, cp_convert (ssizetype, size), cp_convert (ssizetype, integer_one_node), tf_warning_or_error); diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 5aecf3c114c..b326752746f 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -2530,14 +2530,16 @@ get_guard_cond (tree guard) guard_value = integer_one_node; if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) guard_value = convert (TREE_TYPE (guard), guard_value); - guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value, + guard = cp_build_binary_op (input_location, + BIT_AND_EXPR, guard, guard_value, tf_warning_or_error); } guard_value = integer_zero_node; if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) guard_value = convert (TREE_TYPE (guard), guard_value); - return cp_build_binary_op (EQ_EXPR, guard, guard_value, + return cp_build_binary_op (input_location, + EQ_EXPR, guard, guard_value, tf_warning_or_error); } @@ -2927,20 +2929,22 @@ one_static_initialization_or_destruction (tree decl, tree init, bool initp) last to destroy the variable. */ else if (initp) guard_cond - = cp_build_binary_op (EQ_EXPR, + = cp_build_binary_op (input_location, + EQ_EXPR, cp_build_unary_op (PREINCREMENT_EXPR, - guard, - /*noconvert=*/1, - tf_warning_or_error), + guard, + /*noconvert=*/1, + tf_warning_or_error), integer_one_node, tf_warning_or_error); else guard_cond - = cp_build_binary_op (EQ_EXPR, + = cp_build_binary_op (input_location, + EQ_EXPR, cp_build_unary_op (PREDECREMENT_EXPR, - guard, - /*noconvert=*/1, - tf_warning_or_error), + guard, + /*noconvert=*/1, + tf_warning_or_error), integer_zero_node, tf_warning_or_error); @@ -2993,7 +2997,8 @@ do_static_initialization_or_destruction (tree vars, bool initp) /* Build the outer if-stmt to check for initialization or destruction. */ init_if_stmt = begin_if_stmt (); cond = initp ? integer_one_node : integer_zero_node; - cond = cp_build_binary_op (EQ_EXPR, + cond = cp_build_binary_op (input_location, + EQ_EXPR, initialize_p_decl, cond, tf_warning_or_error); @@ -3026,7 +3031,8 @@ do_static_initialization_or_destruction (tree vars, bool initp) /* Conditionalize this initialization on being in the right priority and being initializing/finalizing appropriately. */ priority_if_stmt = begin_if_stmt (); - cond = cp_build_binary_op (EQ_EXPR, + cond = cp_build_binary_op (input_location, + EQ_EXPR, priority_decl, build_int_cst (NULL_TREE, priority), tf_warning_or_error); diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 1c722f52322..d68dd2d5362 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -1001,7 +1001,7 @@ expand_cleanup_for_base (tree binfo, tree flag) tf_warning_or_error); if (flag) expr = fold_build3 (COND_EXPR, void_type_node, - c_common_truthvalue_conversion (flag), + c_common_truthvalue_conversion (input_location, flag), expr, integer_zero_node); finish_eh_cleanup (expr); @@ -1877,7 +1877,8 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, for (elt_type = type; TREE_CODE (elt_type) == ARRAY_TYPE; elt_type = TREE_TYPE (elt_type)) - nelts = cp_build_binary_op (MULT_EXPR, nelts, + nelts = cp_build_binary_op (input_location, + MULT_EXPR, nelts, array_type_nelts_top (elt_type), complain); @@ -2177,7 +2178,8 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, } init_expr = build_vec_init (init_expr, - cp_build_binary_op (MINUS_EXPR, outer_nelts, + cp_build_binary_op (input_location, + MINUS_EXPR, outer_nelts, integer_one_node, complain), init, @@ -2312,7 +2314,8 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, { if (check_new) { - tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node, + tree ifexp = cp_build_binary_op (input_location, + NE_EXPR, alloc_node, integer_zero_node, complain); rval = build_conditional_expr (ifexp, rval, alloc_node, @@ -2579,7 +2582,8 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, cookie_size = targetm.cxx.get_cookie_size (type); base_tbd = cp_convert (ptype, - cp_build_binary_op (MINUS_EXPR, + cp_build_binary_op (input_location, + MINUS_EXPR, cp_convert (string_type_node, base), cookie_size, @@ -2933,13 +2937,15 @@ build_vec_init (tree base, tree maxindex, tree init, && from_array != 2) { tree e; - tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator, + tree m = cp_build_binary_op (input_location, + MINUS_EXPR, maxindex, iterator, complain); /* Flatten multi-dimensional array since build_vec_delete only expects one-dimensional array. */ if (TREE_CODE (type) == ARRAY_TYPE) - m = cp_build_binary_op (MULT_EXPR, m, + m = cp_build_binary_op (input_location, + MULT_EXPR, m, array_type_nelts_total (type), complain); @@ -3167,7 +3173,8 @@ build_delete (tree type, tree addr, special_function_kind auto_delete, ifexp = integer_one_node; else /* Handle deleting a null pointer. */ - ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node, + ifexp = fold (cp_build_binary_op (input_location, + NE_EXPR, addr, integer_zero_node, tf_warning_or_error)); if (ifexp != integer_one_node) diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c index 1c67832a7fd..1d5da671437 100644 --- a/gcc/cp/rtti.c +++ b/gcc/cp/rtti.c @@ -721,7 +721,7 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain) tree neq; result = save_expr (result); - neq = c_common_truthvalue_conversion (result); + neq = c_common_truthvalue_conversion (input_location, result); return cp_convert (type, build3 (COND_EXPR, TREE_TYPE (result), neq, result, bad)); diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index c6f921a968d..82a0495ef43 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -4107,7 +4107,8 @@ handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv, tf_warning_or_error)); *pre_body = pop_stmt_list (*pre_body); - cond = cp_build_binary_op (TREE_CODE (cond), decl, diff, + cond = cp_build_binary_op (elocus, + TREE_CODE (cond), decl, diff, tf_warning_or_error); incr = build_modify_expr (decl, PLUS_EXPR, incr); diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index cfa33ae691f..75bcf9c6913 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -2655,7 +2655,8 @@ build_array_ref (tree array, tree idx, location_t loc) warn_array_subscript_with_type_char (idx); - ret = cp_build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind, + ret = cp_build_indirect_ref (cp_build_binary_op (input_location, + PLUS_EXPR, ar, ind, tf_warning_or_error), "array indexing", tf_warning_or_error); @@ -2718,16 +2719,20 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) switch (TARGET_PTRMEMFUNC_VBIT_LOCATION) { case ptrmemfunc_vbit_in_pfn: - e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node, + e1 = cp_build_binary_op (input_location, + BIT_AND_EXPR, idx, integer_one_node, tf_warning_or_error); - idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node, + idx = cp_build_binary_op (input_location, + MINUS_EXPR, idx, integer_one_node, tf_warning_or_error); break; case ptrmemfunc_vbit_in_delta: - e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node, + e1 = cp_build_binary_op (input_location, + BIT_AND_EXPR, delta, integer_one_node, tf_warning_or_error); - delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node, + delta = cp_build_binary_op (input_location, + RSHIFT_EXPR, delta, integer_one_node, tf_warning_or_error); break; @@ -3141,15 +3146,16 @@ build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code, /* For the c-common bits. */ tree -build_binary_op (enum tree_code code, tree op0, tree op1, +build_binary_op (location_t location, enum tree_code code, tree op0, tree op1, int convert_p ATTRIBUTE_UNUSED) { - return cp_build_binary_op(code, op0, op1, tf_warning_or_error); + return cp_build_binary_op (location, code, op0, op1, tf_warning_or_error); } /* Build a binary-operation expression without default conversions. CODE is the kind of expression to build. + LOCATION is the location_t of the operator in the source code. This function differs from `build' in several ways: the data type of the result is computed and recorded in it, warnings are generated if arg data types are invalid, @@ -3167,7 +3173,8 @@ build_binary_op (enum tree_code code, tree op0, tree op1, multiple inheritance, and deal with pointer to member functions. */ tree -cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, +cp_build_binary_op (location_t location, + enum tree_code code, tree orig_op0, tree orig_op1, tsubst_flags_t complain) { tree op0, op1; @@ -3555,18 +3562,22 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, { tree pfn0 = pfn_from_ptrmemfunc (op0); tree delta0 = delta_from_ptrmemfunc (op0); - tree e1 = cp_build_binary_op (EQ_EXPR, + tree e1 = cp_build_binary_op (location, + EQ_EXPR, pfn0, fold_convert (TREE_TYPE (pfn0), integer_zero_node), complain); - tree e2 = cp_build_binary_op (BIT_AND_EXPR, + tree e2 = cp_build_binary_op (location, + BIT_AND_EXPR, delta0, integer_one_node, complain); - e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node, + e2 = cp_build_binary_op (location, + EQ_EXPR, e2, integer_zero_node, complain); - op0 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, + op0 = cp_build_binary_op (location, + TRUTH_ANDIF_EXPR, e1, e2, complain); op1 = cp_convert (TREE_TYPE (op0), integer_one_node); } @@ -3578,7 +3589,7 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, result_type = TREE_TYPE (op0); } else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0)) - return cp_build_binary_op (code, op1, op0, complain); + return cp_build_binary_op (location, code, op1, op0, complain); else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)) { tree type; @@ -3626,28 +3637,34 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, pointer-to-member is any member with a zero PFN and LSB of the DELTA field is 0. */ - e1 = cp_build_binary_op (BIT_AND_EXPR, + e1 = cp_build_binary_op (location, BIT_AND_EXPR, delta0, integer_one_node, complain); - e1 = cp_build_binary_op (EQ_EXPR, e1, integer_zero_node, + e1 = cp_build_binary_op (location, + EQ_EXPR, e1, integer_zero_node, complain); - e2 = cp_build_binary_op (BIT_AND_EXPR, + e2 = cp_build_binary_op (location, BIT_AND_EXPR, delta1, integer_one_node, complain); - e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node, + e2 = cp_build_binary_op (location, + EQ_EXPR, e2, integer_zero_node, complain); - e1 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, + e1 = cp_build_binary_op (location, + TRUTH_ANDIF_EXPR, e2, e1, complain); - e2 = cp_build_binary_op (EQ_EXPR, + e2 = cp_build_binary_op (location, EQ_EXPR, pfn0, fold_convert (TREE_TYPE (pfn0), integer_zero_node), complain); - e2 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, complain); - e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1, complain); - e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2, complain); + e2 = cp_build_binary_op (location, + TRUTH_ANDIF_EXPR, e2, e1, complain); + e1 = cp_build_binary_op (location, + EQ_EXPR, delta0, delta1, complain); + e1 = cp_build_binary_op (location, + TRUTH_ORIF_EXPR, e1, e2, complain); } else { @@ -3660,19 +3677,24 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, pointer-to-member is any member with a zero PFN; the DELTA field is unspecified. */ - e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1, complain); - e2 = cp_build_binary_op (EQ_EXPR, + e1 = cp_build_binary_op (location, + EQ_EXPR, delta0, delta1, complain); + e2 = cp_build_binary_op (location, + EQ_EXPR, pfn0, fold_convert (TREE_TYPE (pfn0), integer_zero_node), complain); - e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2, complain); + e1 = cp_build_binary_op (location, + TRUTH_ORIF_EXPR, e1, e2, complain); } e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1); - e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, complain); + e = cp_build_binary_op (location, + TRUTH_ANDIF_EXPR, e2, e1, complain); if (code == EQ_EXPR) return e; - return cp_build_binary_op (EQ_EXPR, e, integer_zero_node, complain); + return cp_build_binary_op (location, + EQ_EXPR, e, integer_zero_node, complain); } else { @@ -3773,7 +3795,7 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), TREE_TYPE (type1))) { - binary_op_error (code, type0, type1); + binary_op_error (location, code, type0, type1); return error_mark_node; } arithmetic_types_p = 1; @@ -3857,8 +3879,8 @@ cp_build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, && !processing_template_decl && (complain & tf_warning)) { - warn_for_sign_compare (orig_op0, orig_op1, op0, op1, - result_type, resultcode); + warn_for_sign_compare (location, orig_op0, orig_op1, op0, op1, + result_type, resultcode); } } @@ -3954,7 +3976,8 @@ pointer_diff (tree op0, tree op1, tree ptrtype) /* First do the subtraction as integers; then drop through to build the divide operator. */ - op0 = cp_build_binary_op (MINUS_EXPR, + op0 = cp_build_binary_op (input_location, + MINUS_EXPR, cp_convert (restype, op0), cp_convert (restype, op1), tf_warning_or_error); @@ -4073,9 +4096,10 @@ cp_truthvalue_conversion (tree expr) { tree type = TREE_TYPE (expr); if (TYPE_PTRMEM_P (type)) - return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); + return build_binary_op (EXPR_LOCATION (expr), + NE_EXPR, expr, integer_zero_node, 1); else - return c_common_truthvalue_conversion (expr); + return c_common_truthvalue_conversion (input_location, expr); } /* Just like cp_truthvalue_conversion, but we want a CLEANUP_POINT_EXPR. */ @@ -4968,12 +4992,14 @@ convert_ptrmem (tree type, tree expr, bool allow_inverse_p, { tree cond, op1, op2; - cond = cp_build_binary_op (EQ_EXPR, + cond = cp_build_binary_op (input_location, + EQ_EXPR, expr, build_int_cst (TREE_TYPE (expr), -1), tf_warning_or_error); op1 = build_nop (ptrdiff_type_node, expr); - op2 = cp_build_binary_op (PLUS_EXPR, op1, delta, + op2 = cp_build_binary_op (input_location, + PLUS_EXPR, op1, delta, tf_warning_or_error); expr = fold_build3 (COND_EXPR, ptrdiff_type_node, cond, op1, op2); @@ -5914,7 +5940,8 @@ cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs, || MAYBE_CLASS_TYPE_P (lhstype))); lhs = stabilize_reference (lhs); - newrhs = cp_build_binary_op (modifycode, lhs, rhs, + newrhs = cp_build_binary_op (EXPR_LOCATION (lhs), + modifycode, lhs, rhs, complain); if (newrhs == error_mark_node) { @@ -6303,9 +6330,11 @@ build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p) gcc_assert (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (delta), ptrdiff_type_node)); if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta) - n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node, + n = cp_build_binary_op (input_location, + LSHIFT_EXPR, n, integer_one_node, tf_warning_or_error); - delta = cp_build_binary_op (PLUS_EXPR, delta, n, tf_warning_or_error); + delta = cp_build_binary_op (input_location, + PLUS_EXPR, delta, n, tf_warning_or_error); return build_ptrmemfunc1 (to_type, delta, npfn); } diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog index 039ad3b1bf0..fb9b664d2b8 100644 --- a/gcc/objc/ChangeLog +++ b/gcc/objc/ChangeLog @@ -1,3 +1,10 @@ +2008-09-23 Aldy Hernandez + + * objc-act.c (next_sjlj_build_enter_and_setjmp): Call + c_common_truthvalue_conversion with location. + (next_sjlj_build_catch_list): Same. + (next_sjlj_build_try_catch_finally): Same. + 2008-09-17 Andrew Pinski PR objc/37460 diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c index 837f3cf5c0b..9ea40eafbec 100644 --- a/gcc/objc/objc-act.c +++ b/gcc/objc/objc-act.c @@ -3538,7 +3538,7 @@ next_sjlj_build_enter_and_setjmp (void) sj = build_function_call (objc_setjmp_decl, t); cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj); - cond = c_common_truthvalue_conversion (cond); + cond = c_common_truthvalue_conversion (input_location, cond); return build3 (COND_EXPR, void_type_node, cond, NULL, NULL); } @@ -3605,7 +3605,7 @@ next_sjlj_build_catch_list (void) t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type))); args = tree_cons (NULL, t, args); t = build_function_call (objc_exception_match_decl, args); - cond = c_common_truthvalue_conversion (t); + cond = c_common_truthvalue_conversion (input_location, t); } t = build3 (COND_EXPR, void_type_node, cond, body, NULL); SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt)); @@ -3727,7 +3727,8 @@ next_sjlj_build_try_catch_finally (void) /* Build the complete FINALLY statement list. */ t = next_sjlj_build_try_exit (); t = build_stmt (COND_EXPR, - c_common_truthvalue_conversion (rethrow_decl), + c_common_truthvalue_conversion + (input_location, rethrow_decl), NULL, t); SET_EXPR_LOCATION (t, cur_try_context->finally_locus); append_to_statement_list (t, &TREE_OPERAND (try_fin, 1)); @@ -3738,7 +3739,8 @@ next_sjlj_build_try_catch_finally (void) t = tree_cons (NULL, rethrow_decl, NULL); t = build_function_call (objc_exception_throw_decl, t); t = build_stmt (COND_EXPR, - c_common_truthvalue_conversion (rethrow_decl), + c_common_truthvalue_conversion (input_location, + rethrow_decl), t, NULL); SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus); append_to_statement_list (t, &TREE_OPERAND (try_fin, 1)); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index e3215bdf053..4ec69d5889c 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,10 @@ +2008-09-23 Aldy Hernandez + + * gcc.dg/Walways-true-1.c: Test column numbers. + * gcc.dg/c90-const-expr-5.c: Same. + * gcc.dg/compare4.c: Same. + * gcc.dg/Werror-1.c: Same. + 2008-09-23 Daniel Kraft PR fortran/37588 @@ -619,6 +626,7 @@ PR tree-optimization/37508 * gcc.dg/tree-ssa/pr37508.c: New testcase. +>>>>>>> .r140590 2008-09-15 Aldy Hernandez * g++.old-deja/g++.brendan/crash16.C: Function name is the correct diff --git a/gcc/testsuite/gcc.dg/Walways-true-1.c b/gcc/testsuite/gcc.dg/Walways-true-1.c index 299932fcf55..32b921c3fa7 100644 --- a/gcc/testsuite/gcc.dg/Walways-true-1.c +++ b/gcc/testsuite/gcc.dg/Walways-true-1.c @@ -2,7 +2,7 @@ Origin: Ian Lance Taylor . */ /* { dg-do compile} */ -/* { dg-options "-Waddress" } */ +/* { dg-options "-Waddress -fshow-column" } */ extern int foo (int); @@ -12,46 +12,46 @@ void bar (int a) { lab: - if (foo) /* { dg-warning "always evaluate as" "correct warning" } */ + if (foo) /* { dg-warning "7:always evaluate as" "correct warning" } */ foo (0); if (foo (1)) ; - if (&i) /* { dg-warning "always evaluate as" "correct warning" } */ + if (&i) /* { dg-warning "7:always evaluate as" "correct warning" } */ foo (2); if (i) foo (3); - if (&a) /* { dg-warning "always evaluate as" "correct warning" } */ + if (&a) /* { dg-warning "7:always evaluate as" "correct warning" } */ foo (4); if (a) foo (5); - if (&&lab) /* { dg-warning "always evaluate as" "correct warning" } */ + if (&&lab) /* { dg-warning "7:always evaluate as" "correct warning" } */ foo (6); - if (foo == 0) /* { dg-warning "never be NULL" "correct warning" } */ + if (foo == 0) /* { dg-warning "11:never be NULL" "correct warning" } */ foo (7); if (foo (1) == 0) foo (8); - if (&i == 0) /* { dg-warning "never be NULL" "correct warning" } */ + if (&i == 0) /* { dg-warning "10:never be NULL" "correct warning" } */ foo (9); if (i == 0) foo (10); - if (&a == 0) /* { dg-warning "never be NULL" "correct warning" } */ + if (&a == 0) /* { dg-warning "10:never be NULL" "correct warning" } */ foo (11); if (a == 0) foo (12); - if (&&lab == 0) /* { dg-warning "never be NULL" "correct warning" } */ + if (&&lab == 0) /* { dg-warning "13:never be NULL" "correct warning" } */ foo (13); - if (0 == foo) /* { dg-warning "never be NULL" "correct warning" } */ + if (0 == foo) /* { dg-warning "9:never be NULL" "correct warning" } */ foo (14); if (0 == foo (1)) foo (15); - if (0 == &i) /* { dg-warning "never be NULL" "correct warning" } */ + if (0 == &i) /* { dg-warning "9:never be NULL" "correct warning" } */ foo (16); if (0 == i) foo (17); - if (0 == &a) /* { dg-warning "never be NULL" "correct warning" } */ + if (0 == &a) /* { dg-warning "9:never be NULL" "correct warning" } */ foo (18); if (0 == a) foo (19); - if (0 == &&lab) /* { dg-warning "never be NULL" "correct warning" } */ + if (0 == &&lab) /* { dg-warning "9:never be NULL" "correct warning" } */ foo (20); } diff --git a/gcc/testsuite/gcc.dg/Werror-1.c b/gcc/testsuite/gcc.dg/Werror-1.c index 815a561f2e8..001af24525c 100644 --- a/gcc/testsuite/gcc.dg/Werror-1.c +++ b/gcc/testsuite/gcc.dg/Werror-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-Waddress -Wattributes -Werror" } */ +/* { dg-options "-Waddress -Wattributes -Werror -fshow-column" } */ /* { dg-message "warnings being treated as errors" "" {target "*-*-*"} 0 } */ /* This is the first in a series of test cases that test the @@ -16,6 +16,6 @@ int i; void foo () { - if (&i) /* { dg-error ".* will always evaluate as 'true'" } */ + if (&i) /* { dg-error "7:.* will always evaluate as 'true'" } */ grill (); } diff --git a/gcc/testsuite/gcc.dg/c90-const-expr-5.c b/gcc/testsuite/gcc.dg/c90-const-expr-5.c index ca725085441..0a5af8124cd 100644 --- a/gcc/testsuite/gcc.dg/c90-const-expr-5.c +++ b/gcc/testsuite/gcc.dg/c90-const-expr-5.c @@ -2,7 +2,7 @@ qualified void. */ /* Origin: Joseph Myers */ /* { dg-do compile } */ -/* { dg-options "-std=iso9899:1990 -pedantic-errors" } */ +/* { dg-options "-std=iso9899:1990 -pedantic-errors -fshow-column" } */ typedef void V; int *p; @@ -15,14 +15,14 @@ f (void) { /* (V *)0 is a null pointer constant, so the assignment should be diagnosed. */ - q = (j ? p : (V *)0); /* { dg-error "assignment from incompatible pointer type" } */ - q = (j ? p : (void *)0); /* { dg-error "assignment from incompatible pointer type" } */ + q = (j ? p : (V *)0); /* { dg-error "3:assignment from incompatible pointer type" } */ + q = (j ? p : (void *)0); /* { dg-error "3:assignment from incompatible pointer type" } */ /* And this conversion should be valid. */ (void (*)(void))(V *)0; (void (*)(void))(void *)0; /* Pointers to qualified void are not valid null pointer constants. */ - fp = (const void *)0; /* { dg-error "ISO C forbids assignment between function pointer and 'void \\*'" } */ + fp = (const void *)0; /* { dg-error "3:ISO C forbids assignment between function pointer and 'void \\*'" } */ fp = (void *)0; fp = (V *)0; fp = 0; @@ -32,8 +32,8 @@ f (void) (void *)0 == fp; fp == (V *)0; (V *)0 == fp; - fp == (V *)1; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */ - (V *)1 == fp; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */ - fp == (const void *)0; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */ - (const void *)0 == fp; /* { dg-error "ISO C forbids comparison of 'void \\*' with function pointer" } */ + fp == (V *)1; /* { dg-error "6:ISO C forbids comparison of 'void \\*' with function pointer" } */ + (V *)1 == fp; /* { dg-error "10:ISO C forbids comparison of 'void \\*' with function pointer" } */ + fp == (const void *)0; /* { dg-error "6:ISO C forbids comparison of 'void \\*' with function pointer" } */ + (const void *)0 == fp; /* { dg-error "19:ISO C forbids comparison of 'void \\*' with function pointer" } */ } diff --git a/gcc/testsuite/gcc.dg/compare4.c b/gcc/testsuite/gcc.dg/compare4.c index aae7cbee32d..e5dad4d1e45 100644 --- a/gcc/testsuite/gcc.dg/compare4.c +++ b/gcc/testsuite/gcc.dg/compare4.c @@ -2,7 +2,7 @@ Origin: Kaveh R. Ghazi 5/13/2001. */ /* { dg-do compile } */ -/* { dg-options "-Wsign-compare -fstrict-overflow" } */ +/* { dg-options "-fshow-column -Wsign-compare -fstrict-overflow" } */ extern void bar(void); @@ -10,7 +10,7 @@ int foo(int x, int y, unsigned u) { /* A COMPOUND_EXPR is non-negative if the last element is known to be non-negative. */ - if (u < (bar(), -1)) /*{ dg-warning "signed and unsigned" "COMPOUND_EXPR" }*/ + if (u < (bar(), -1)) /*{ dg-warning "9:signed and unsigned" "COMPOUND_EXPR" }*/ return x; if (u < (bar(), 10)) return x; @@ -34,7 +34,7 @@ int foo(int x, int y, unsigned u) /* A MODIFY_EXPR is non-negative if the new value is known to be non-negative. */ - if (u < (x = -1)) /* { dg-warning "signed and unsigned" "MODIFY_EXPR" } */ + if (u < (x = -1)) /* { dg-warning "9:signed and unsigned" "MODIFY_EXPR" } */ return x; if (u < (x = 10)) return x; diff --git a/gcc/testsuite/gcc.dg/misc-column.c b/gcc/testsuite/gcc.dg/misc-column.c new file mode 100644 index 00000000000..f84a553959d --- /dev/null +++ b/gcc/testsuite/gcc.dg/misc-column.c @@ -0,0 +1,29 @@ +/* { dg-options "-fshow-column -Wall -Wfloat-equal -pedantic" } */ + +float a, b; + +int *p; +struct { + int a; + char b; +} *q; + +extern void bar(); + +void foo (void) +{ + if (a == b) /* { dg-warning "9:comparing floating point with" } */ + bar (); + + if (p < q) /* { dg-warning "9:comparison of distinct pointer types" } */ + bar (); + + if (&p == 0) /* { dg-warning "10:will never be NULL" } */ + bar(); + + if (p == 4) /* { dg-warning "9:comparison between pointer and integer" } */ + bar(); + + if (p < 0) /* { dg-warning "9:ordered comparison of pointer with" } */ + bar(); +}