cp-gimplify.c (genericize_if_stmt): Use protected_set_expr_location.

	* cp-gimplify.c (genericize_if_stmt): Use protected_set_expr_location.
	(genericize_cp_loop): Likewise.
	* decl.c (cxx_maybe_build_cleanup): Likewise.
	* parser.c (cp_parser_binary_expression): Likewise.
	(cp_parser_omp_for_loop): Likewise.
	(cp_parser_omp_construct): Likewise.
	* semantics.c (finish_transaction_stmt): Likewise.
	(build_transaction_expr): Likewise.

From-SVN: r228560

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 1b2f6b4cd74cd834b004eb372dfa998ec8b0591e..3c785451126f1b70520f1fe2a2c43a9cf87e14da 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,14 @@
+2015-10-07  Marek Polacek  <polacek@redhat.com>
+
+       * cp-gimplify.c (genericize_if_stmt): Use protected_set_expr_location.
+       (genericize_cp_loop): Likewise.
+       * decl.c (cxx_maybe_build_cleanup): Likewise.
+       * parser.c (cp_parser_binary_expression): Likewise.
+       (cp_parser_omp_for_loop): Likewise.
+       (cp_parser_omp_construct): Likewise.
+       * semantics.c (finish_transaction_stmt): Likewise.
+       (build_transaction_expr): Likewise.
+
 2015-10-06  Jason Merrill  <jason@redhat.com>
 
        PR c++/67810

diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c
index 32a3a89cb042783eb2776e20a962f71dcb8d6420..9b6ac89d1a16815f1e0384f6a98e9f01cd1c5902 100644 (file)
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -207,8 +207,8 @@ genericize_if_stmt (tree *stmt_p)
     stmt = else_;
   else
     stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
-  if (CAN_HAVE_LOCATION_P (stmt) && !EXPR_HAS_LOCATION (stmt))
-    SET_EXPR_LOCATION (stmt, locus);
+  if (!EXPR_HAS_LOCATION (stmt))
+    protected_set_expr_location (stmt, locus);
   *stmt_p = stmt;
 }
 
@@ -231,8 +231,7 @@ genericize_cp_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
   blab = begin_bc_block (bc_break, start_locus);
   clab = begin_bc_block (bc_continue, start_locus);
 
-  if (incr && EXPR_P (incr))
-    SET_EXPR_LOCATION (incr, start_locus);
+  protected_set_expr_location (incr, start_locus);
 
   cp_walk_tree (&cond, cp_genericize_r, data, NULL);
   cp_walk_tree (&body, cp_genericize_r, data, NULL);

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index eff52819acaef34cfe1c775df972b630362be0ae..8eb9cc2e27fd8bd60e1d48886913832f8191a90f 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -14964,8 +14964,7 @@ cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
      a "jumpy" behaviour for users of debuggers when they step around
      the end of the block.  So let's unset the location of the
      destructor call instead.  */
-  if (cleanup != NULL && EXPR_P (cleanup))
-    SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
+  protected_set_expr_location (cleanup, UNKNOWN_LOCATION);
 
   if (cleanup
       && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl)))

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index f9b668ab0cbd70522c65a2646e1ae21901ff9000..d4ef7f9d864f10ae5be56148890ccef24c8a5507 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -8612,8 +8612,7 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p,
                                         rhs, rhs_type, &overload,
                                         complain_flags (decltype_p));
       current.lhs_type = current.tree_type;
-      if (EXPR_P (current.lhs))
-       SET_EXPR_LOCATION (current.lhs, current.loc);
+      protected_set_expr_location (current.lhs, current.loc);
 
       /* If the binary operator required the use of an overloaded operator,
         then this expression cannot be an integral constant-expression.
@@ -32046,8 +32045,8 @@ cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
            incr = cp_parser_omp_for_incr (parser, real_decl);
          else
            incr = cp_parser_expression (parser);
-         if (CAN_HAVE_LOCATION_P (incr) && !EXPR_HAS_LOCATION (incr))
-           SET_EXPR_LOCATION (incr, input_location);
+         if (!EXPR_HAS_LOCATION (incr))
+           protected_set_expr_location (incr, input_location);
        }
 
       if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
@@ -34045,8 +34044,7 @@ cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
       gcc_unreachable ();
     }
 
-  if (stmt)
-    SET_EXPR_LOCATION (stmt, pragma_tok->location);
+  protected_set_expr_location (stmt, pragma_tok->location);
 }
 \f
 /* Transactional Memory parsing routines.  */

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index ea403987b235f8d0666d53c24b5a016622507ae6..c1f43301b0058693ca7ae957b255238f656caec1 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -7086,9 +7086,8 @@ finish_transaction_stmt (tree stmt, tree compound_stmt, int flags, tree noex)
     {
       tree body = build_must_not_throw_expr (TRANSACTION_EXPR_BODY (stmt),
                                             noex);
-      /* This may not be true when the STATEMENT_LIST is empty.  */
-      if (EXPR_P (body))
-        SET_EXPR_LOCATION (body, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt)));
+      protected_set_expr_location
+       (body, EXPR_LOCATION (TRANSACTION_EXPR_BODY (stmt)));
       TREE_SIDE_EFFECTS (body) = 1;
       TRANSACTION_EXPR_BODY (stmt) = body;
     }
@@ -7108,8 +7107,7 @@ build_transaction_expr (location_t loc, tree expr, int flags, tree noex)
   if (noex)
     {
       expr = build_must_not_throw_expr (expr, noex);
-      if (EXPR_P (expr))
-       SET_EXPR_LOCATION (expr, loc);
+      protected_set_expr_location (expr, loc);
       TREE_SIDE_EFFECTS (expr) = 1;
     }
   ret = build1 (TRANSACTION_EXPR, TREE_TYPE (expr), expr);