OSDN Git Service

* c-decl.c (finish_decl): Pass input_location to build_unary_op.
authoraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 6 Oct 2008 21:35:02 +0000 (21:35 +0000)
committeraldyh <aldyh@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 6 Oct 2008 21:35:02 +0000 (21:35 +0000)
* c-typeck.c (array_to_pointer_conversion): Pass location to
build_unary_op.
(function_to_pointer_conversion): Use error_at and warning_at.
(build_indirect_ref): Same.
(build_array_ref): Pass location to build_binary_op.
(parser_build_unary_op): Do not set location after calling
build_unary_op.
(build_unary_op): Add location argument.  Use it throughout.  Set
EXPR_LOCATION before returning new tree.
(build_modify_expr): Same.
(build_binary_op): Use location throughout.  Set EXPR_LOCATION before
returning node.
* c-omp.c (c_finish_omp_atomic): Pass location to build_unary_op,
build_indirect_ref, build_modify_expr.
(c_finish_omp_for): Same.  Use error_at instead of error.
* c-common.c (c_common_truthvalue_conversion): Pass location to
build_unary_op.
(warn_for_div_by_zero): Add location argument.
* c-common.h: Add argument to build_modify_expr, build_indirect_ref,
build_unary_op, warn_for_div_by_zero.
* c-parser.c (c_parser_typeof_specifier): Use
protected_set_expr_location.
(c_parser_statement_after_labels): Same.
(c_parser_condition): Same.
(c_parser_expr_no_commas): Pass correct location to build_modify_expr.
(c_parser_conditional_expression): Use protected_set_expr_location.
(c_parser_unary_expression): Pass location to build_indirect_ref.
(c_parser_postfix_expression_after_primary): Pass location to
build_indirect_ref, build_unary_op.
(c_parser_omp_for_loop): Set the increment expression's EXPR_LOCATION.
objc/
* objc-act.c (objc_build_string_object): Pass location to
build_unary_op.
(init_def_list): Same.
(init_objc_symtab): Same.
(init_module_descriptor): Same.
(build_module_initializer_routine): Same.
(generate_static_references): Same.
(build_typed_selector_reference): Same.
(add_objc_string): Same.
(objc_substitute_decl): Same.
(objc_build_ivar_assignment): Same.
(objc_build_global_assignment): Same.
(objc_build_strong_cast_assignment): Same.
(generate_protocols): Same.
(build_protocol_initializer): Same.
(build_dispatch_table_initializer): Same.
(generate_protocol_list): Same.
(build_category_initializer): Same.
(build_shared_structure_initializer): Same.
(generate_shared_structures): Same.
(objc_build_protocol_expr): Same.
(build_ivar_reference): Same.
(get_super_receiver): Same.
build_modify_expr.
testsuite/
* gcc.dg/gomp/for-1.c: Test column.
* gcc.dg/misc-column.c: Add column tests for unary arguments.
cp/
* typeck.c (build_x_indirect_ref): Add location argument.
(cp_build_binary_op): Pass location to warn_for_div_by_zero.
(cp_build_unary_op): Add location argument.
(cp_build_modify_expr): Same.
* class.c (build_base_path): Pass location to build_indirect_ref.
* semantics.c (handle_omp_for_class_iterator): Pass elocus to
build_modify_expr.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@140914 138bc75d-0d04-0410-961f-82ee72b054a4

16 files changed:
gcc/ChangeLog
gcc/c-common.c
gcc/c-common.h
gcc/c-decl.c
gcc/c-omp.c
gcc/c-parser.c
gcc/c-typeck.c
gcc/cp/ChangeLog
gcc/cp/class.c
gcc/cp/semantics.c
gcc/cp/typeck.c
gcc/objc/ChangeLog
gcc/objc/objc-act.c
gcc/testsuite/ChangeLog
gcc/testsuite/gcc.dg/gomp/for-1.c
gcc/testsuite/gcc.dg/misc-column.c

index b983fe5..a3cec06 100644 (file)
@@ -1,3 +1,38 @@
+2008-10-06  Aldy Hernandez  <aldyh@redhat.com>
+
+       build_modify_expr.
+       * c-decl.c (finish_decl): Pass input_location to build_unary_op.
+       * c-typeck.c (array_to_pointer_conversion): Pass location to
+       build_unary_op.
+       (function_to_pointer_conversion): Use error_at and warning_at.
+       (build_indirect_ref): Same.
+       (build_array_ref): Pass location to build_binary_op.
+       (parser_build_unary_op): Do not set location after calling
+       build_unary_op.
+       (build_unary_op): Add location argument.  Use it throughout.  Set
+       EXPR_LOCATION before returning new tree.
+       (build_modify_expr): Same.
+       (build_binary_op): Use location throughout.  Set EXPR_LOCATION before
+       returning node.
+       * c-omp.c (c_finish_omp_atomic): Pass location to build_unary_op,
+       build_indirect_ref, build_modify_expr.
+       (c_finish_omp_for): Same.  Use error_at instead of error.
+       * c-common.c (c_common_truthvalue_conversion): Pass location to
+       build_unary_op.
+       (warn_for_div_by_zero): Add location argument.
+       * c-common.h: Add argument to build_modify_expr, build_indirect_ref,
+       build_unary_op, warn_for_div_by_zero.
+       * c-parser.c (c_parser_typeof_specifier): Use
+       protected_set_expr_location.
+       (c_parser_statement_after_labels): Same.
+       (c_parser_condition): Same.
+       (c_parser_expr_no_commas): Pass correct location to build_modify_expr.
+       (c_parser_conditional_expression): Use protected_set_expr_location.
+       (c_parser_unary_expression): Pass location to build_indirect_ref.
+       (c_parser_postfix_expression_after_primary): Pass location to
+       build_indirect_ref, build_unary_op.
+       (c_parser_omp_for_loop): Set the increment expression's EXPR_LOCATION.
+
 2008-10-06  Joshua Kinard  <kumba@gentoo.org>
 
        * doc/invoke.texi: List r1x000 family under the -march MIPS option.
index 7665b62..6b37c34 100644 (file)
@@ -3411,7 +3411,7 @@ c_common_truthvalue_conversion (location_t location, tree expr)
             : truthvalue_false_node;
 
     case FUNCTION_DECL:
-      expr = build_unary_op (ADDR_EXPR, expr, 0);
+      expr = build_unary_op (location, ADDR_EXPR, expr, 0);
       /* Fall through.  */
 
     case ADDR_EXPR:
@@ -3514,10 +3514,12 @@ c_common_truthvalue_conversion (location_t location, tree expr)
              (EXPR_LOCATION (expr),
               (TREE_SIDE_EFFECTS (expr)
                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
-       c_common_truthvalue_conversion (location,
-                                       build_unary_op (REALPART_EXPR, t, 0)),
-       c_common_truthvalue_conversion (location,
-                                       build_unary_op (IMAGPART_EXPR, t, 0)),
+       c_common_truthvalue_conversion
+              (location,
+               build_unary_op (location, REALPART_EXPR, t, 0)),
+       c_common_truthvalue_conversion
+              (location,
+               build_unary_op (location, IMAGPART_EXPR, t, 0)),
               0));
     }
 
@@ -8182,10 +8184,11 @@ warn_for_unused_label (tree label)
 struct gcc_targetcm targetcm = TARGETCM_INITIALIZER;
 #endif
 
-/* Warn for division by zero according to the value of DIVISOR.  */
+/* Warn for division by zero according to the value of DIVISOR.  LOC
+   is the location of the division operator.  */
 
 void
-warn_for_div_by_zero (tree divisor)
+warn_for_div_by_zero (location_t loc, tree divisor)
 {
   /* If DIVISOR is zero, and has integral or fixed-point type, issue a warning
      about division by zero.  Do not issue a warning if DIVISOR has a
@@ -8193,7 +8196,7 @@ warn_for_div_by_zero (tree divisor)
      generating a NaN.  */
   if (skip_evaluation == 0
       && (integer_zerop (divisor) || fixed_zerop (divisor)))
-    warning (OPT_Wdiv_by_zero, "division by zero");
+    warning_at (loc, OPT_Wdiv_by_zero, "division by zero");
 }
 
 /* Subroutine of build_binary_op. Give warnings for comparisons
index 622100a..cd4eb31 100644 (file)
@@ -356,8 +356,8 @@ extern tree add_stmt (tree);
 extern void push_cleanup (tree, tree, bool);
 extern tree pushdecl_top_level (tree);
 extern tree pushdecl (tree);
-extern tree build_modify_expr (tree, enum tree_code, tree);
-extern tree build_indirect_ref (tree, const char *, location_t);
+extern tree build_modify_expr (location_t, tree, enum tree_code, tree);
+extern tree build_indirect_ref (location_t, tree, const char *);
 
 extern int c_expand_decl (tree);
 
@@ -815,7 +815,7 @@ extern tree build_case_label (tree, tree, tree);
 /* These functions must be defined by each front-end which implements
    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_unary_op (location_t, enum tree_code, tree, int);
 extern tree build_binary_op (location_t, enum tree_code, tree, tree, int);
 extern tree perform_integral_promotions (tree);
 
@@ -915,7 +915,7 @@ extern void warn_array_subscript_with_type_char (tree);
 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_div_by_zero (location_t, tree divisor);
 extern void warn_for_sign_compare (location_t,
                                   tree orig_op0, tree orig_op1, 
                                   tree op0, tree op1, 
index 7026555..2a6dcf2 100644 (file)
@@ -3650,7 +3650,7 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
          tree cleanup;
 
          /* Build "cleanup(&decl)" for the destructor.  */
-         cleanup = build_unary_op (ADDR_EXPR, decl, 0);
+         cleanup = build_unary_op (input_location, ADDR_EXPR, decl, 0);
          cleanup = build_tree_list (NULL_TREE, cleanup);
          cleanup = build_function_call (cleanup_decl, cleanup);
 
index 6d9d5fa..b06c830 100644 (file)
@@ -124,7 +124,7 @@ c_finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
 
   /* Take and save the address of the lhs.  From then on we'll reference it
      via indirection.  */
-  addr = build_unary_op (ADDR_EXPR, lhs, 0);
+  addr = build_unary_op (input_location, ADDR_EXPR, lhs, 0);
   if (addr == error_mark_node)
     return error_mark_node;
   addr = save_expr (addr);
@@ -137,12 +137,12 @@ c_finish_omp_atomic (enum tree_code code, tree lhs, tree rhs)
       tree var = create_tmp_var_raw (TREE_TYPE (addr), NULL);
       addr = build4 (TARGET_EXPR, TREE_TYPE (addr), var, addr, NULL, NULL);
     }
-  lhs = build_indirect_ref (addr, NULL, EXPR_LOCATION (addr));
+  lhs = build_indirect_ref (input_location, addr, NULL);
 
   /* There are lots of warnings, errors, and conversions that need to happen
      in the course of interpreting a statement.  Use the normal mechanisms
      to do this, and then take it apart again.  */
-  x = build_modify_expr (lhs, code, rhs);
+  x = build_modify_expr (input_location, lhs, code, rhs);
   if (x == error_mark_node)
     return error_mark_node;
   gcc_assert (TREE_CODE (x) == MODIFY_EXPR);  
@@ -242,7 +242,7 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
       if (!INTEGRAL_TYPE_P (TREE_TYPE (decl))
          && TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE)
        {
-         error ("%Hinvalid type for iteration variable %qE", &elocus, decl);
+         error_at (elocus, "invalid type for iteration variable %qE", decl);
          fail = true;
        }
 
@@ -255,20 +255,19 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
          init = DECL_INITIAL (decl);
          if (init == NULL)
            {
-             error ("%H%qE is not initialized", &elocus, decl);
+             error_at (elocus, "%qE is not initialized", decl);
              init = integer_zero_node;
              fail = true;
            }
 
-         init = build_modify_expr (decl, NOP_EXPR, init);
-         SET_EXPR_LOCATION (init, elocus);
+         init = build_modify_expr (elocus, decl, NOP_EXPR, init);
        }
       gcc_assert (TREE_CODE (init) == MODIFY_EXPR);
       gcc_assert (TREE_OPERAND (init, 0) == decl);
 
       if (cond == NULL_TREE)
        {
-         error ("%Hmissing controlling predicate", &elocus);
+         error_at (elocus, "missing controlling predicate");
          fail = true;
        }
       else
@@ -329,14 +328,14 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
 
          if (!cond_ok)
            {
-             error ("%Hinvalid controlling predicate", &elocus);
+             error_at (elocus, "invalid controlling predicate");
              fail = true;
            }
        }
 
       if (incr == NULL_TREE)
        {
-         error ("%Hmissing increment expression", &elocus);
+         error_at (elocus, "missing increment expression");
          fail = true;
        }
       else
@@ -402,7 +401,7 @@ c_finish_omp_for (location_t locus, tree declv, tree initv, tree condv,
            }
          if (!incr_ok)
            {
-             error ("%Hinvalid increment expression", &elocus);
+             error_at (elocus, "invalid increment expression");
              fail = true;
            }
        }
index 9597660..f08b281 100644 (file)
@@ -2098,8 +2098,7 @@ c_parser_typeof_specifier (c_parser *parser)
          if (DECL_P (e) || CONSTANT_CLASS_P (e))
            e = build1 (NOP_EXPR, void_type_node, e);
 
-         if (CAN_HAVE_LOCATION_P (e))
-           SET_EXPR_LOCATION (e, here);
+         protected_set_expr_location (e, here);
 
          add_stmt (e);
        }
@@ -3789,8 +3788,7 @@ c_parser_statement_after_labels (c_parser *parser)
      (recursively) all of the component statements should already have
      line numbers assigned.  ??? Can we discard no-op statements
      earlier?  */
-  if (stmt && CAN_HAVE_LOCATION_P (stmt))
-    SET_EXPR_LOCATION (stmt, loc);
+  protected_set_expr_location (stmt, loc);
 
   parser->in_if_block = in_if_block;
 }
@@ -3805,8 +3803,7 @@ c_parser_condition (c_parser *parser)
   loc = c_parser_peek_token (parser)->location;
   cond = c_objc_common_truthvalue_conversion 
     (loc, c_parser_expression_conv (parser).value);
-  if (CAN_HAVE_LOCATION_P (cond))
-    SET_EXPR_LOCATION (cond, loc);
+  protected_set_expr_location (cond, loc);
   if (warn_sequence_point)
     verify_sequence_points (cond);
   return cond;
@@ -4361,8 +4358,10 @@ c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
 {
   struct c_expr lhs, rhs, ret;
   enum tree_code code;
+  location_t op_location;
   gcc_assert (!after || c_dialect_objc ());
   lhs = c_parser_conditional_expression (parser, after);
+  op_location = c_parser_peek_token (parser)->location;
   switch (c_parser_peek_token (parser)->type)
     {
     case CPP_EQ:
@@ -4404,7 +4403,7 @@ c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
   c_parser_consume_token (parser);
   rhs = c_parser_expr_no_commas (parser, NULL);
   rhs = default_function_array_conversion (rhs);
-  ret.value = build_modify_expr (lhs.value, code, rhs.value);
+  ret.value = build_modify_expr (op_location, lhs.value, code, rhs.value);
   if (code == NOP_EXPR)
     ret.original_code = MODIFY_EXPR;
   else
@@ -4439,6 +4438,7 @@ c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
 
   cond_loc = c_parser_peek_token (parser)->location;
   cond = c_parser_binary_expression (parser, after);
+  protected_set_expr_location (cond.value, cond_loc);
 
   if (c_parser_next_token_is_not (parser, CPP_QUERY))
     return cond;
@@ -4836,7 +4836,7 @@ c_parser_unary_expression (c_parser *parser)
       c_parser_consume_token (parser);
       op = c_parser_cast_expression (parser, NULL);
       op = default_function_array_conversion (op);
-      ret.value = build_indirect_ref (op.value, "unary *", loc);
+      ret.value = build_indirect_ref (loc, op.value, "unary *");
       ret.original_code = ERROR_MARK;
       return ret;
     case CPP_PLUS:
@@ -5594,8 +5594,9 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
              return expr;
            }
          c_parser_consume_token (parser);
-         expr.value = build_component_ref (build_indirect_ref (expr.value,
-                                                               "->", loc),
+         expr.value = build_component_ref (build_indirect_ref (loc,
+                                                               expr.value,
+                                                               "->"),
                                            ident);
          expr.original_code = ERROR_MARK;
          break;
@@ -5603,14 +5604,16 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
          /* Postincrement.  */
          c_parser_consume_token (parser);
          expr = default_function_array_conversion (expr);
-         expr.value = build_unary_op (POSTINCREMENT_EXPR, expr.value, 0);
+         expr.value = build_unary_op (loc,
+                                      POSTINCREMENT_EXPR, expr.value, 0);
          expr.original_code = ERROR_MARK;
          break;
        case CPP_MINUS_MINUS:
          /* Postdecrement.  */
          c_parser_consume_token (parser);
          expr = default_function_array_conversion (expr);
-         expr.value = build_unary_op (POSTDECREMENT_EXPR, expr.value, 0);
+         expr.value = build_unary_op (loc,
+                                      POSTDECREMENT_EXPR, expr.value, 0);
          expr.original_code = ERROR_MARK;
          break;
        default:
@@ -7594,14 +7597,17 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
               && c_parser_peek_2nd_token (parser)->type == CPP_EQ)
        {
          struct c_expr init_exp;
+         location_t init_loc;
 
          decl = c_parser_postfix_expression (parser).value;
 
          c_parser_require (parser, CPP_EQ, "expected %<=%>");
+         init_loc = c_parser_peek_token (parser)->location;
 
          init_exp = c_parser_expr_no_commas (parser, NULL);
          init_exp = default_function_array_conversion (init_exp);
-         init = build_modify_expr (decl, NOP_EXPR, init_exp.value);
+         init = build_modify_expr (init_loc,
+                                   decl, NOP_EXPR, init_exp.value);
          init = c_process_expr_stmt (init);
 
          c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
@@ -7625,15 +7631,19 @@ c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
 
          cond = c_parser_expression_conv (parser).value;
          cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
-         if (CAN_HAVE_LOCATION_P (cond))
-           SET_EXPR_LOCATION (cond, cond_loc);
+         protected_set_expr_location (cond, cond_loc);
        }
       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
 
       /* Parse the increment expression.  */
       incr = NULL_TREE;
       if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
-       incr = c_process_expr_stmt (c_parser_expression (parser).value);
+       {
+         location_t incr_loc = c_parser_peek_token (parser)->location;
+
+         incr = c_process_expr_stmt (c_parser_expression (parser).value);
+         protected_set_expr_location (incr, incr_loc);
+       }
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 
       if (decl == NULL || decl == error_mark_node || init == error_mark_node)
index c6474ed..ab8df37 100644 (file)
@@ -1618,7 +1618,7 @@ array_to_pointer_conversion (tree 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);
+  adr = build_unary_op (EXPR_LOCATION (exp), ADDR_EXPR, exp, 1);
   return convert (ptrtype, adr);
 }
 
@@ -1635,7 +1635,7 @@ function_to_pointer_conversion (tree exp)
   if (TREE_NO_WARNING (orig_exp))
     TREE_NO_WARNING (exp) = 1;
 
-  return build_unary_op (ADDR_EXPR, exp, 0);
+  return build_unary_op (EXPR_LOCATION (exp), ADDR_EXPR, exp, 0);
 }
 
 /* Perform the default conversion of arrays and functions to pointers.
@@ -1972,7 +1972,7 @@ build_component_ref (tree datum, tree component)
    LOC is the location to use for the generated tree.  */
 
 tree
-build_indirect_ref (tree ptr, const char *errorstring, location_t loc)
+build_indirect_ref (location_t loc, tree ptr, const char *errorstring)
 {
   tree pointer = default_conversion (ptr);
   tree type = TREE_TYPE (pointer);
@@ -2008,11 +2008,11 @@ build_indirect_ref (tree ptr, const char *errorstring, location_t loc)
 
          if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
            {
-             error ("dereferencing pointer to incomplete type");
+             error_at (loc, "dereferencing pointer to incomplete type");
              return error_mark_node;
            }
          if (VOID_TYPE_P (t) && skip_evaluation == 0)
-           warning (0, "dereferencing %<void *%> pointer");
+           warning_at (loc, 0, "dereferencing %<void *%> pointer");
 
          /* We *must* set TREE_READONLY when dereferencing a pointer to const,
             so that we get the proper error message if the result is used
@@ -2030,7 +2030,8 @@ build_indirect_ref (tree ptr, const char *errorstring, location_t loc)
        }
     }
   else if (TREE_CODE (pointer) != ERROR_MARK)
-    error ("invalid type argument of %qs (have %qT)", errorstring, type);
+    error_at (loc,
+             "invalid type argument of %qs (have %qT)", errorstring, type);
   return error_mark_node;
 }
 
@@ -2164,8 +2165,8 @@ build_array_ref (tree array, tree index, location_t loc)
       gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
 
       return build_indirect_ref
-       (build_binary_op (loc, PLUS_EXPR, ar, index, 0),
-        "array indexing", loc);
+       (loc, build_binary_op (loc, PLUS_EXPR, ar, index, 0),
+        "array indexing");
     }
 }
 \f
@@ -2748,8 +2749,7 @@ parser_build_unary_op (enum tree_code code, struct c_expr arg, location_t loc)
   struct c_expr result;
 
   result.original_code = ERROR_MARK;
-  result.value = build_unary_op (code, arg.value, 0);
-  protected_set_expr_location (result.value, loc);
+  result.value = build_unary_op (loc, code, arg.value, 0);
 
   if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
     overflow_warning (result.value);
@@ -2901,16 +2901,20 @@ pointer_diff (tree op0, tree op1)
    the default promotions (such as from short to int).
    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
    allows non-lvalues; this is only used to handle conversion of non-lvalue
-   arrays to pointers in C99.  */
+   arrays to pointers in C99.
+
+   LOCATION is the location of the operator.  */
 
 tree
-build_unary_op (enum tree_code code, tree xarg, int flag)
+build_unary_op (location_t location,
+               enum tree_code code, tree xarg, int flag)
 {
   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
   tree arg = xarg;
   tree argtype = 0;
   enum tree_code typecode;
   tree val;
+  tree ret = error_mark_node;
   int noconvert = flag;
   const char *invalid_op_diag;
 
@@ -2926,7 +2930,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
   if ((invalid_op_diag
        = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
     {
-      error (invalid_op_diag);
+      error_at (location, invalid_op_diag);
       return error_mark_node;
     }
 
@@ -2940,7 +2944,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
            || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
            || typecode == VECTOR_TYPE))
        {
-         error ("wrong type argument to unary plus");
+         error_at (location, "wrong type argument to unary plus");
          return error_mark_node;
        }
       else if (!noconvert)
@@ -2953,7 +2957,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
            || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
            || typecode == VECTOR_TYPE))
        {
-         error ("wrong type argument to unary minus");
+         error_at (location, "wrong type argument to unary minus");
          return error_mark_node;
        }
       else if (!noconvert)
@@ -2972,14 +2976,14 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
       else if (typecode == COMPLEX_TYPE)
        {
          code = CONJ_EXPR;
-         pedwarn (input_location, OPT_pedantic, 
+         pedwarn (location, OPT_pedantic, 
                   "ISO C does not support %<~%> for complex conjugation");
          if (!noconvert)
            arg = default_conversion (arg);
        }
       else
        {
-         error ("wrong type argument to bit-complement");
+         error_at (location, "wrong type argument to bit-complement");
          return error_mark_node;
        }
       break;
@@ -2987,7 +2991,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
     case ABS_EXPR:
       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
        {
-         error ("wrong type argument to abs");
+         error_at (location, "wrong type argument to abs");
          return error_mark_node;
        }
       else if (!noconvert)
@@ -2999,7 +3003,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
            || typecode == COMPLEX_TYPE))
        {
-         error ("wrong type argument to conjugation");
+         error_at (location, "wrong type argument to conjugation");
          return error_mark_node;
        }
       else if (!noconvert)
@@ -3011,27 +3015,31 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
          && typecode != REAL_TYPE && typecode != POINTER_TYPE
          && typecode != COMPLEX_TYPE)
        {
-         error ("wrong type argument to unary exclamation mark");
+         error_at (location,
+                   "wrong type argument to unary exclamation mark");
          return error_mark_node;
        }
-      arg = c_objc_common_truthvalue_conversion (input_location, arg);
-      return invert_truthvalue (arg);
+      arg = c_objc_common_truthvalue_conversion (location, arg);
+      ret = invert_truthvalue (arg);
+      goto return_build_unary_op;
 
     case REALPART_EXPR:
       if (TREE_CODE (arg) == COMPLEX_CST)
-       return TREE_REALPART (arg);
+       ret = TREE_REALPART (arg);
       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
-       return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+       ret = fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
       else
-       return arg;
+       ret = arg;
+      goto return_build_unary_op;
 
     case IMAGPART_EXPR:
       if (TREE_CODE (arg) == COMPLEX_CST)
-       return TREE_IMAGPART (arg);
+       ret = TREE_IMAGPART (arg);
       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
-       return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
+       ret = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
       else
-       return convert (TREE_TYPE (arg), integer_zero_node);
+       ret = convert (TREE_TYPE (arg), integer_zero_node);
+      goto return_build_unary_op;
 
     case PREINCREMENT_EXPR:
     case POSTINCREMENT_EXPR:
@@ -3044,17 +3052,18 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
        {
          tree real, imag;
 
-         pedwarn (input_location, OPT_pedantic, 
+         pedwarn (location, OPT_pedantic, 
                   "ISO C does not support %<++%> and %<--%> on complex types");
 
          arg = stabilize_reference (arg);
-         real = build_unary_op (REALPART_EXPR, arg, 1);
-         imag = build_unary_op (IMAGPART_EXPR, arg, 1);
-         real = build_unary_op (code, real, 1);
+         real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg, 1);
+         imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg, 1);
+         real = build_unary_op (EXPR_LOCATION (arg), code, real, 1);
          if (real == error_mark_node || imag == error_mark_node)
            return error_mark_node;
-         return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
-                        real, imag);
+         ret = build2 (COMPLEX_EXPR, TREE_TYPE (arg),
+                       real, imag);
+         goto return_build_unary_op;
        }
 
       /* Report invalid types.  */
@@ -3063,9 +3072,9 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
          && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
        {
          if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
-           error ("wrong type argument to increment");
+           error_at (location, "wrong type argument to increment");
          else
-           error ("wrong type argument to decrement");
+           error_at (location, "wrong type argument to decrement");
 
          return error_mark_node;
        }
@@ -3086,18 +3095,20 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
            if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
              {
                if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
-                 error ("increment of pointer to unknown structure");
+                 error_at (location,
+                           "increment of pointer to unknown structure");
                else
-                 error ("decrement of pointer to unknown structure");
+                 error_at (location,
+                           "decrement of pointer to unknown structure");
              }
            else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
                     || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
              {
                if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
-                 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+                 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
                           "wrong type argument to increment");
                else
-                 pedwarn (input_location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
+                 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith, 
                           "wrong type argument to decrement");
              }
 
@@ -3154,7 +3165,8 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
        val = convert (result_type, val);
        if (TREE_CODE (val) != code)
          TREE_NO_WARNING (val) = 1;
-       return val;
+       ret = val;
+       goto return_build_unary_op;
       }
 
     case ADDR_EXPR:
@@ -3166,7 +3178,8 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
          /* Don't let this be an lvalue.  */
          if (lvalue_p (TREE_OPERAND (arg, 0)))
            return non_lvalue (TREE_OPERAND (arg, 0));
-         return TREE_OPERAND (arg, 0);
+         ret = TREE_OPERAND (arg, 0);
+         goto return_build_unary_op;
        }
 
       /* For &x[y], return x+y */
@@ -3175,7 +3188,7 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
          tree op0 = TREE_OPERAND (arg, 0);
          if (!c_mark_addressable (op0))
            return error_mark_node;
-         return build_binary_op (EXPR_LOCATION (xarg), PLUS_EXPR,
+         return build_binary_op (location, PLUS_EXPR,
                                  (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
                                   ? array_to_pointer_conversion (op0)
                                   : op0),
@@ -3218,12 +3231,14 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
          tree op0 = fold_convert (sizetype, fold_offsetof (arg, val)), op1;
 
          op1 = fold_convert (argtype, TREE_OPERAND (val, 0));
-         return fold_build2 (POINTER_PLUS_EXPR, argtype, op1, op0);
+         ret = fold_build2 (POINTER_PLUS_EXPR, argtype, op1, op0);
+         goto return_build_unary_op;
        }
 
       val = build1 (ADDR_EXPR, argtype, arg);
 
-      return val;
+      ret = val;
+      goto return_build_unary_op;
 
     default:
       gcc_unreachable ();
@@ -3231,8 +3246,12 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
 
   if (argtype == 0)
     argtype = TREE_TYPE (arg);
-  return require_constant_value ? fold_build1_initializer (code, argtype, arg)
-                               : fold_build1 (code, argtype, arg);
+  ret = require_constant_value ? fold_build1_initializer (code, argtype, arg)
+                              : fold_build1 (code, argtype, arg);
+ return_build_unary_op:
+  gcc_assert (ret != error_mark_node);
+  protected_set_expr_location (ret, location);
+  return ret;
 }
 
 /* Return nonzero if REF is an lvalue valid for this language.
@@ -3837,10 +3856,13 @@ c_cast_expr (struct c_type_name *type_name, tree expr)
 /* Build an assignment expression of lvalue LHS from value RHS.
    MODIFYCODE is the code for a binary operator that we use
    to combine the old value of LHS with RHS to get the new value.
-   Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
+   Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
+
+   LOCATION is the location of the MODIFYCODE operator.  */
 
 tree
-build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
+build_modify_expr (location_t location,
+                  tree lhs, enum tree_code modifycode, tree rhs)
 {
   tree result;
   tree newrhs;
@@ -3867,7 +3889,7 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
   if (modifycode != NOP_EXPR)
     {
       lhs = stabilize_reference (lhs);
-      newrhs = build_binary_op (EXPR_LOCATION (lhs),
+      newrhs = build_binary_op (location,
                                modifycode, lhs, rhs, 1);
     }
 
@@ -3915,13 +3937,17 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
     {
       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
       if (result)
-       return result;
+       {
+         protected_set_expr_location (result, location);
+         return result;
+       }
     }
 
   /* Scan operands.  */
 
   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
   TREE_SIDE_EFFECTS (result) = 1;
+  protected_set_expr_location (result, location);
 
   /* If we got the LHS in a different type for storing in,
      convert the result back to the nominal type of LHS
@@ -3930,8 +3956,11 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
 
   if (olhstype == TREE_TYPE (result))
     return result;
-  return convert_for_assignment (olhstype, result, ic_assign,
-                                NULL_TREE, NULL_TREE, 0);
+
+  result = convert_for_assignment (olhstype, result, ic_assign,
+                                  NULL_TREE, NULL_TREE, 0);
+  protected_set_expr_location (result, location);
+  return result;
 }
 \f
 /* Convert value RHS to type TYPE as preparation for an assignment
@@ -7942,6 +7971,7 @@ build_binary_op (location_t location, enum tree_code code,
   tree type0, type1;
   enum tree_code code0, code1;
   tree op0, op1;
+  tree ret = error_mark_node;
   const char *invalid_op_diag;
 
   /* Expression code to give to the expression when it is built.
@@ -8035,9 +8065,15 @@ build_binary_op (location_t location, enum tree_code code,
     case PLUS_EXPR:
       /* Handle the pointer + int case.  */
       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
-       return pointer_int_sum (PLUS_EXPR, op0, op1);
+       {
+         ret = pointer_int_sum (PLUS_EXPR, op0, op1);
+         goto return_build_binary_op;
+       }
       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
-       return pointer_int_sum (PLUS_EXPR, op1, op0);
+       {
+         ret = pointer_int_sum (PLUS_EXPR, op1, op0);
+         goto return_build_binary_op;
+       }
       else
        common = 1;
       break;
@@ -8047,10 +8083,16 @@ build_binary_op (location_t location, enum tree_code code,
         We must subtract them as integers, then divide by object size.  */
       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
          && comp_target_types (type0, type1))
-       return pointer_diff (op0, op1);
+       {
+         ret = pointer_diff (op0, op1);
+         goto return_build_binary_op;
+       }
       /* Handle pointer minus int.  Just like pointer plus int.  */
       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
-       return pointer_int_sum (MINUS_EXPR, op0, op1);
+       {
+         ret = pointer_int_sum (MINUS_EXPR, op0, op1);
+         goto return_build_binary_op;
+       }
       else
        common = 1;
       break;
@@ -8064,7 +8106,7 @@ build_binary_op (location_t location, enum tree_code code,
     case FLOOR_DIV_EXPR:
     case ROUND_DIV_EXPR:
     case EXACT_DIV_EXPR:
-      warn_for_div_by_zero (op1);
+      warn_for_div_by_zero (location, op1);
 
       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
           || code0 == FIXED_POINT_TYPE
@@ -8111,7 +8153,7 @@ build_binary_op (location_t location, enum tree_code code,
 
     case TRUNC_MOD_EXPR:
     case FLOOR_MOD_EXPR:
-      warn_for_div_by_zero (op1);
+      warn_for_div_by_zero (location, op1);
 
       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
        {
@@ -8435,7 +8477,10 @@ build_binary_op (location_t location, enum tree_code code,
            = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
 
          if (val != 0)
-           return val;
+           {
+             ret = val;
+             goto return_build_binary_op;
+           }
 
          op0 = xop0, op1 = xop1;
          converted = 1;
@@ -8477,18 +8522,19 @@ build_binary_op (location_t location, enum tree_code code,
   if (build_type == NULL_TREE)
     build_type = result_type;
 
-  {
-    /* Treat expressions in initializers specially as they can't trap.  */
-    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);
-    return result;
-  }
+  /* Treat expressions in initializers specially as they can't trap.  */
+  ret = require_constant_value ? fold_build2_initializer (resultcode,
+                                                         build_type,
+                                                         op0, op1)
+                              : fold_build2 (resultcode, build_type,
+                                             op0, op1);
+  if (final_type != 0)
+    ret = convert (final_type, ret);
+
+ return_build_binary_op:
+  gcc_assert (ret != error_mark_node);
+  protected_set_expr_location (ret, location);
+  return ret;
 }
 
 
index eeeb239..dc18acc 100644 (file)
@@ -1,3 +1,13 @@
+2008-10-06  Aldy Hernandez  <aldyh@redhat.com>
+
+       * typeck.c (build_x_indirect_ref): Add location argument.
+       (cp_build_binary_op): Pass location to warn_for_div_by_zero.
+       (cp_build_unary_op): Add location argument.
+       (cp_build_modify_expr): Same.
+       * class.c (build_base_path): Pass location to build_indirect_ref.
+       * semantics.c (handle_omp_for_class_iterator): Pass elocus to
+       build_modify_expr.
+
 2008-10-05  Dodji Seketeli  <dodji@redhat.com>
 
        PR c++/37410
index ab8391b..910dc29 100644 (file)
@@ -299,7 +299,7 @@ build_base_path (enum tree_code code,
     {
       expr = build_nop (build_pointer_type (target_type), expr);
       if (!want_pointer)
-       expr = build_indirect_ref (expr, NULL, EXPR_LOCATION (expr));
+       expr = build_indirect_ref (EXPR_LOCATION (expr), expr, NULL);
       return expr;
     }
 
index 13e9a0f..b1bbb38 100644 (file)
@@ -4109,7 +4109,7 @@ handle_omp_for_class_iterator (int i, location_t locus, tree declv, tree initv,
   cond = cp_build_binary_op (elocus,
                             TREE_CODE (cond), decl, diff,
                             tf_warning_or_error);
-  incr = build_modify_expr (decl, PLUS_EXPR, incr);
+  incr = build_modify_expr (elocus, decl, PLUS_EXPR, incr);
 
   orig_body = *body;
   *body = push_stmt_list ();
index 75bcf9c..b115e28 100644 (file)
@@ -2405,8 +2405,8 @@ build_x_indirect_ref (tree expr, const char *errorstring,
 
 /* Helper function called from c-common.  */
 tree
-build_indirect_ref (tree ptr, const char *errorstring, 
-                   location_t loc __attribute__ ((__unused__)))
+build_indirect_ref (location_t loc __attribute__ ((__unused__)),
+                   tree ptr, const char *errorstring)
 {
   return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error);
 }
@@ -3349,7 +3349,7 @@ cp_build_binary_op (location_t location,
        {
          enum tree_code tcode0 = code0, tcode1 = code1;
 
-         warn_for_div_by_zero (op1);
+         warn_for_div_by_zero (location, op1);
 
          if (tcode0 == COMPLEX_TYPE || tcode0 == VECTOR_TYPE)
            tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
@@ -3385,7 +3385,7 @@ cp_build_binary_op (location_t location,
 
     case TRUNC_MOD_EXPR:
     case FLOOR_MOD_EXPR:
-      warn_for_div_by_zero (op1);
+      warn_for_div_by_zero (location, op1);
 
       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
        {
@@ -4642,7 +4642,8 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
 
 /* Hook for the c-common bits that build a unary op.  */
 tree
-build_unary_op (enum tree_code code, tree xarg, int noconvert)
+build_unary_op (location_t location ATTRIBUTE_UNUSED,
+               enum tree_code code, tree xarg, int noconvert)
 {
   return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error);
 }
@@ -5757,7 +5758,8 @@ cp_build_c_cast (tree type, tree expr, tsubst_flags_t complain)
 \f
 /* For use from the C common bits.  */
 tree
-build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
+build_modify_expr (location_t location ATTRIBUTE_UNUSED,
+                  tree lhs, enum tree_code modifycode, tree rhs)
 {
   return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error);
 }
@@ -5940,7 +5942,7 @@ 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 (EXPR_LOCATION (lhs),
+         newrhs = cp_build_binary_op (input_location,
                                       modifycode, lhs, rhs,
                                       complain);
          if (newrhs == error_mark_node)
index fb9b664..f980814 100644 (file)
@@ -1,3 +1,29 @@
+2008-10-06  Aldy Hernandez  <aldyh@redhat.com>
+
+       * objc-act.c (objc_build_string_object): Pass location to
+       build_unary_op.
+       (init_def_list): Same.
+       (init_objc_symtab): Same.
+       (init_module_descriptor): Same.
+       (build_module_initializer_routine): Same.
+       (generate_static_references): Same.
+       (build_typed_selector_reference): Same.
+       (add_objc_string): Same.
+       (objc_substitute_decl): Same.
+       (objc_build_ivar_assignment): Same.
+       (objc_build_global_assignment): Same.
+       (objc_build_strong_cast_assignment): Same.
+       (generate_protocols): Same.
+       (build_protocol_initializer): Same.
+       (build_dispatch_table_initializer): Same.
+       (generate_protocol_list): Same.
+       (build_category_initializer): Same.
+       (build_shared_structure_initializer): Same.
+       (generate_shared_structures): Same.
+       (objc_build_protocol_expr): Same.
+       (build_ivar_reference): Same.
+       (get_super_receiver): Same.
+
 2008-09-23  Aldy Hernandez  <aldyh@redhat.com>
 
        * objc-act.c (next_sjlj_build_enter_and_setjmp): Call
index 9ea40ea..c23fb9e 100644 (file)
@@ -1940,10 +1940,12 @@ objc_build_string_object (tree string)
       initlist
        = build_tree_list (fields,
                           flag_next_runtime
-                          ? build_unary_op (ADDR_EXPR, string_class_decl, 0)
+                          ? build_unary_op (input_location,
+                                            ADDR_EXPR, string_class_decl, 0)
                           : build_int_cst (NULL_TREE, 0));
       fields = TREE_CHAIN (fields);
-      initlist = tree_cons (fields, build_unary_op (ADDR_EXPR, string, 1),
+      initlist = tree_cons (fields, build_unary_op (input_location,
+                                                   ADDR_EXPR, string, 1),
                            initlist);
       fields = TREE_CHAIN (fields);
       initlist = tree_cons (fields, build_int_cst (NULL_TREE, length),
@@ -1966,7 +1968,8 @@ objc_build_string_object (tree string)
     }
 
   addr = convert (build_pointer_type (constant_string_type),
-                 build_unary_op (ADDR_EXPR, desc->constructor, 1));
+                 build_unary_op (input_location,
+                                 ADDR_EXPR, desc->constructor, 1));
 
   return addr;
 }
@@ -2104,7 +2107,8 @@ init_def_list (tree type)
       {
        if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
          {
-           expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
+           expr = build_unary_op (input_location,
+                                  ADDR_EXPR, impent->class_decl, 0);
            initlist = tree_cons (NULL_TREE, expr, initlist);
          }
       }
@@ -2114,7 +2118,8 @@ init_def_list (tree type)
       {
        if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
          {
-           expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
+           expr = build_unary_op (input_location,
+                                  ADDR_EXPR, impent->class_decl, 0);
            initlist = tree_cons (NULL_TREE, expr, initlist);
          }
       }
@@ -2125,7 +2130,8 @@ init_def_list (tree type)
       tree expr;
 
       if (static_instances_decl)
-       expr = build_unary_op (ADDR_EXPR, static_instances_decl, 0);
+       expr = build_unary_op (input_location,
+                              ADDR_EXPR, static_instances_decl, 0);
       else
        expr = build_int_cst (NULL_TREE, 0);
 
@@ -2155,7 +2161,7 @@ init_objc_symtab (tree type)
     initlist
       = tree_cons (NULL_TREE,
                   convert (build_pointer_type (objc_selector_type),
-                           build_unary_op (ADDR_EXPR,
+                           build_unary_op (input_location, ADDR_EXPR,
                                            UOBJC_SELECTOR_TABLE_decl, 1)),
                   initlist);
 
@@ -2262,7 +2268,8 @@ init_module_descriptor (tree type)
   /* symtab = { ..., _OBJC_SYMBOLS, ... } */
 
   if (UOBJC_SYMBOLS_decl)
-    expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
+    expr = build_unary_op (input_location,
+                          ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
   else
     expr = build_int_cst (NULL_TREE, 0);
   initlist = tree_cons (NULL_TREE, expr, initlist);
@@ -2345,7 +2352,7 @@ build_module_initializer_routine (void)
            (execclass_decl,
             build_tree_list
             (NULL_TREE,
-             build_unary_op (ADDR_EXPR,
+             build_unary_op (input_location, ADDR_EXPR,
                              UOBJC_MODULES_decl, 0))));
   add_stmt (c_end_compound_stmt (body, true));
 
@@ -2440,13 +2447,15 @@ generate_static_references (void)
       klass = TREE_VALUE (cl_chain);
       class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names);
       initlist = build_tree_list (NULL_TREE,
-                                 build_unary_op (ADDR_EXPR, class_name, 1));
+                                 build_unary_op (input_location, 
+                                                 ADDR_EXPR, class_name, 1));
 
       /* Output {..., instance, ...}.  */
       for (in_chain = TREE_PURPOSE (cl_chain);
           in_chain; in_chain = TREE_CHAIN (in_chain))
        {
-         expr = build_unary_op (ADDR_EXPR, TREE_VALUE (in_chain), 1);
+         expr = build_unary_op (input_location,
+                                ADDR_EXPR, TREE_VALUE (in_chain), 1);
          initlist = tree_cons (NULL_TREE, expr, initlist);
        }
 
@@ -2456,7 +2465,8 @@ generate_static_references (void)
       expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
       finish_var_decl (decl, expr);
       decls
-       = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, decl, 1), decls);
+       = tree_cons (NULL_TREE, build_unary_op (input_location,
+                                               ADDR_EXPR, decl, 1), decls);
     }
 
   decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), decls);
@@ -2628,7 +2638,7 @@ build_typed_selector_reference (tree ident, tree prototype)
   *chain = tree_cons (prototype, ident, NULL_TREE);
 
  return_at_index:
-  expr = build_unary_op (ADDR_EXPR,
+  expr = build_unary_op (input_location, ADDR_EXPR,
                         build_array_ref (UOBJC_SELECTOR_TABLE_decl,
                                          build_int_cst (NULL_TREE, index),
                                          input_location),
@@ -2801,7 +2811,8 @@ add_objc_string (tree ident, enum string_section section)
     {
       if (TREE_VALUE (*chain) == ident)
        return convert (string_type_node,
-                       build_unary_op (ADDR_EXPR, TREE_PURPOSE (*chain), 1));
+                       build_unary_op (input_location,
+                                       ADDR_EXPR, TREE_PURPOSE (*chain), 1));
 
       chain = &TREE_CHAIN (*chain);
     }
@@ -2820,7 +2831,8 @@ add_objc_string (tree ident, enum string_section section)
 
   *chain = tree_cons (decl, ident, NULL_TREE);
 
-  return convert (string_type_node, build_unary_op (ADDR_EXPR, decl, 1));
+  return convert (string_type_node, build_unary_op (input_location,
+                                                   ADDR_EXPR, decl, 1));
 }
 
 static GTY(()) int class_names_idx;
@@ -3052,10 +3064,10 @@ objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
                              TREE_OPERAND (expr, 1),
                              input_location);
     case INDIRECT_REF:
-      return build_indirect_ref (objc_substitute_decl (TREE_OPERAND (expr, 0),
+      return build_indirect_ref (input_location,
+                                objc_substitute_decl (TREE_OPERAND (expr, 0),
                                                       oldexpr,
-                                                      newexpr), "->",
-                                input_location);
+                                                      newexpr), "->");
     default:
       return expr;
     }
@@ -3077,7 +3089,8 @@ objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
        ? objc_assign_ivar_fast_decl
        : objc_assign_ivar_decl);
 
-  offs = convert (integer_type_node, build_unary_op (ADDR_EXPR, offs, 0));
+  offs = convert (integer_type_node, build_unary_op (input_location,
+                                                    ADDR_EXPR, offs, 0));
   offs = fold (offs);
   func_params = tree_cons (NULL_TREE,
        convert (objc_object_type, rhs),
@@ -3095,7 +3108,7 @@ objc_build_global_assignment (tree lhs, tree rhs)
   tree func_params = tree_cons (NULL_TREE,
        convert (objc_object_type, rhs),
            tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
-                     build_unary_op (ADDR_EXPR, lhs, 0)),
+                     build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
                    NULL_TREE));
 
   assemble_external (objc_assign_global_decl);
@@ -3108,7 +3121,7 @@ objc_build_strong_cast_assignment (tree lhs, tree rhs)
   tree func_params = tree_cons (NULL_TREE,
        convert (objc_object_type, rhs),
            tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
-                     build_unary_op (ADDR_EXPR, lhs, 0)),
+                     build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
                    NULL_TREE));
 
   assemble_external (objc_assign_strong_cast_decl);
@@ -4672,7 +4685,8 @@ generate_protocols (void)
       if (refs_decl)
        refs_expr = convert (build_pointer_type (build_pointer_type
                                                 (objc_protocol_template)),
-                            build_unary_op (ADDR_EXPR, refs_decl, 0));
+                            build_unary_op (input_location,
+                                            ADDR_EXPR, refs_decl, 0));
       else
        refs_expr = build_int_cst (NULL_TREE, 0);
 
@@ -4709,7 +4723,8 @@ build_protocol_initializer (tree type, tree protocol_name,
   else
     {
       expr = convert (objc_method_proto_list_ptr,
-                     build_unary_op (ADDR_EXPR, instance_methods, 0));
+                     build_unary_op (input_location, 
+                                     ADDR_EXPR, instance_methods, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -4718,7 +4733,8 @@ build_protocol_initializer (tree type, tree protocol_name,
   else
     {
       expr = convert (objc_method_proto_list_ptr,
-                     build_unary_op (ADDR_EXPR, class_methods, 0));
+                     build_unary_op (input_location, 
+                                     ADDR_EXPR, class_methods, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -5287,7 +5303,7 @@ build_dispatch_table_initializer (tree type, tree entries)
       elemlist
        = tree_cons (NULL_TREE,
                     convert (ptr_type_node,
-                             build_unary_op (ADDR_EXPR,
+                             build_unary_op (input_location, ADDR_EXPR,
                                              METHOD_DEFINITION (entries), 1)),
                     elemlist);
 
@@ -5471,7 +5487,8 @@ generate_protocol_list (tree i_or_p)
       if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
          && PROTOCOL_FORWARD_DECL (pval))
        {
-         e = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (pval), 0);
+         e = build_unary_op (input_location, ADDR_EXPR, 
+                             PROTOCOL_FORWARD_DECL (pval), 0);
          initlist = tree_cons (NULL_TREE, e, initlist);
        }
     }
@@ -5514,7 +5531,8 @@ build_category_initializer (tree type, tree cat_name, tree class_name,
   else
     {
       expr = convert (objc_method_list_ptr,
-                     build_unary_op (ADDR_EXPR, instance_methods, 0));
+                     build_unary_op (input_location, ADDR_EXPR, 
+                                     instance_methods, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
   if (!class_methods)
@@ -5522,7 +5540,8 @@ build_category_initializer (tree type, tree cat_name, tree class_name,
   else
     {
       expr = convert (objc_method_list_ptr,
-                     build_unary_op (ADDR_EXPR, class_methods, 0));
+                     build_unary_op (input_location, ADDR_EXPR, 
+                                     class_methods, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -5534,7 +5553,8 @@ build_category_initializer (tree type, tree cat_name, tree class_name,
       expr = convert (build_pointer_type
                      (build_pointer_type
                       (objc_protocol_template)),
-                     build_unary_op (ADDR_EXPR, protocol_list, 0));
+                     build_unary_op (input_location, ADDR_EXPR, 
+                                     protocol_list, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -5599,7 +5619,8 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
   else
     {
       expr = convert (objc_ivar_list_ptr,
-                     build_unary_op (ADDR_EXPR, ivar_list, 0));
+                     build_unary_op (input_location, ADDR_EXPR, 
+                                     ivar_list, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -5609,7 +5630,8 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
   else
     {
       expr = convert (objc_method_list_ptr,
-                     build_unary_op (ADDR_EXPR, dispatch_table, 0));
+                     build_unary_op (input_location, ADDR_EXPR, 
+                                     dispatch_table, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -5636,7 +5658,8 @@ build_shared_structure_initializer (tree type, tree isa, tree super,
       expr = convert (build_pointer_type
                      (build_pointer_type
                       (objc_protocol_template)),
-                     build_unary_op (ADDR_EXPR, protocol_list, 0));
+                     build_unary_op (input_location, ADDR_EXPR, 
+                                     protocol_list, 0));
       initlist = tree_cons (NULL_TREE, expr, initlist);
     }
 
@@ -5790,7 +5813,7 @@ generate_shared_structures (int cls_flags)
   initlist
     = build_shared_structure_initializer
       (TREE_TYPE (decl),
-       build_unary_op (ADDR_EXPR, UOBJC_METACLASS_decl, 0),
+       build_unary_op (input_location, ADDR_EXPR, UOBJC_METACLASS_decl, 0),
        super_expr, name_expr,
        convert (integer_type_node,
                TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
@@ -6582,7 +6605,8 @@ objc_build_protocol_expr (tree protoname)
   if (!PROTOCOL_FORWARD_DECL (p))
     build_protocol_reference (p);
 
-  expr = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
+  expr = build_unary_op (input_location, 
+                        ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
 
   /* ??? Ideally we'd build the reference with objc_protocol_type directly,
      if we have it, rather than converting it here.  */
@@ -6720,8 +6744,8 @@ build_ivar_reference (tree id)
       self_decl = convert (objc_instance_type, self_decl); /* cast */
     }
 
-  return objc_build_component_ref (build_indirect_ref (self_decl, "->",
-                                                      input_location), id);
+  return objc_build_component_ref (build_indirect_ref (input_location,
+                                                      self_decl, "->"), id);
 }
 \f
 /* Compute a hash value for a given method SEL_NAME.  */
@@ -8701,7 +8725,8 @@ get_super_receiver (void)
 
       /* Set receiver to self.  */
       super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
-      super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl);
+      super_expr = build_modify_expr (input_location, 
+                                     super_expr, NOP_EXPR, self_decl);
       super_expr_list = super_expr;
 
       /* Set class to begin searching.  */
@@ -8713,7 +8738,7 @@ get_super_receiver (void)
          /* [_cls, __cls]Super are "pre-built" in
             synth_forward_declarations.  */
 
-         super_expr = build_modify_expr (super_expr, NOP_EXPR,
+         super_expr = build_modify_expr (input_location, super_expr, NOP_EXPR,
                                          ((TREE_CODE (objc_method_context)
                                            == INSTANCE_METHOD_DECL)
                                           ? ucls_super_ref
@@ -8744,8 +8769,9 @@ get_super_receiver (void)
                   "isa" is the first ivar in a class (which it must be).  */
                super_class
                  = build_indirect_ref
-                   (build_c_cast (build_pointer_type (objc_class_type),
-                                  super_class), "unary *", input_location);
+                     (input_location,
+                      build_c_cast (build_pointer_type (objc_class_type),
+                                    super_class), "unary *");
            }
          else
            {
@@ -8764,14 +8790,15 @@ get_super_receiver (void)
            }
 
          super_expr
-           = build_modify_expr (super_expr, NOP_EXPR,
+           = build_modify_expr (input_location, super_expr, NOP_EXPR,
                                 build_c_cast (TREE_TYPE (super_expr),
                                               super_class));
        }
 
       super_expr_list = build_compound_expr (super_expr_list, super_expr);
 
-      super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
+      super_expr = build_unary_op (input_location, 
+                                  ADDR_EXPR, UOBJC_SUPER_decl, 0);
       super_expr_list = build_compound_expr (super_expr_list, super_expr);
 
       return super_expr_list;
index 04f2171..0391f3d 100644 (file)
@@ -1,3 +1,8 @@
+2008-10-06  Aldy Hernandez  <aldyh@redhat.com>
+
+       * gcc.dg/gomp/for-1.c: Test column.
+       * gcc.dg/misc-column.c: Add column tests for unary arguments.
+
 2008-10-06  Eric Botcazou  <ebotcazou@adacore.com>
 
        * gnat.dg/unchecked_convert2.adb: New test.
index bf50f25..840f947 100644 (file)
@@ -44,6 +44,6 @@ void foo (int j, int k)
     baz (i);
 
   #pragma omp for
-  for (i = 0; i < 10; i-=3, j+=2)      /* { dg-error "invalid increment expression" } */
+  for (i = 0; i < 10; i-=3, j+=2)      /* { dg-error "23:invalid increment expression" } */
     baz (i);
 }
index f84a553..a24427e 100644 (file)
@@ -1,5 +1,6 @@
 /* { dg-options "-fshow-column -Wall -Wfloat-equal -pedantic" } */
 
+int i, j;
 float a, b;
 
 int *p;
@@ -26,4 +27,14 @@ void foo (void)
 
   if (p < 0) /* { dg-warning "9:ordered comparison of pointer with" } */
     bar();
+
+  -q;   /* { dg-error "3:wrong type argument to unary" } */
+
+  ~q;    /* { dg-error "3:wrong type argument to bit" } */
+
+  ++*q; /* { dg-error "3:wrong type argument to increment" } */
+
+  i = j / 0;  /* { dg-warning "9:division by zero" } */
+
+  i /= 0; /* { dg-warning "5:division by zero" } */
 }