c++: use TARGET_EXPR accessors

While futzing around with PR116416 I noticed that we can use
the _SLOT and _INITIAL macros to make the code more readable.

gcc/c-family/ChangeLog:

	* c-pretty-print.cc (c_pretty_printer::primary_expression): Use
	TARGET_EXPR accessors.
	(c_pretty_printer::expression): Likewise.

gcc/cp/ChangeLog:

	* coroutines.cc (build_co_await): Use TARGET_EXPR accessors.
	(finish_co_yield_expr): Likewise.
	(register_awaits): Likewise.
	(tmp_target_expr_p): Likewise.
	(flatten_await_stmt): Likewise.
	* error.cc (dump_expr): Likewise.
	* semantics.cc (finish_omp_target_clauses): Likewise.
	* tree.cc (bot_manip): Likewise.
	(cp_tree_equal): Likewise.
	* typeck.cc (cxx_mark_addressable): Likewise.
	(cp_build_compound_expr): Likewise.
	(cp_build_modify_expr): Likewise.
	(check_return_expr): Likewise.

Reviewed-by: Jason Merrill <jason@redhat.com>

diff --git a/gcc/c-family/c-pretty-print.cc b/gcc/c-family/c-pretty-print.cc
index 26038818d759ba65e109523ed3f4fee17804fffe..0c764aecc3dee2dded70daa69f0d74774d74dabd 100644 (file)
--- a/gcc/c-family/c-pretty-print.cc
+++ b/gcc/c-family/c-pretty-print.cc
@@ -1376,14 +1376,14 @@ c_pretty_printer::primary_expression (tree e)
       pp_c_ws_string (this, "__builtin_memcpy");
       pp_c_left_paren (this);
       pp_ampersand (this);
-      primary_expression (TREE_OPERAND (e, 0));
+      primary_expression (TARGET_EXPR_SLOT (e));
       pp_separate_with (this, ',');
       pp_ampersand (this);
-      initializer (TREE_OPERAND (e, 1));
-      if (TREE_OPERAND (e, 2))
+      initializer (TARGET_EXPR_INITIAL (e));
+      if (TARGET_EXPR_CLEANUP (e))
        {
          pp_separate_with (this, ',');
-         expression (TREE_OPERAND (e, 2));
+         expression (TARGET_EXPR_CLEANUP (e));
        }
       pp_c_right_paren (this);
       break;
@@ -2838,7 +2838,7 @@ c_pretty_printer::expression (tree e)
       break;
 
     case TARGET_EXPR:
-      postfix_expression (TREE_OPERAND (e, 1));
+      postfix_expression (TARGET_EXPR_INITIAL (e));
       break;
 
     case BIND_EXPR:

diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc
index 70c9094d1d19fa03a68bc8721dcde95e9a1b50b7..4c7ea1dd3216a11d15885ee39c9b51cc741f4339 100644 (file)
--- a/gcc/cp/coroutines.cc
+++ b/gcc/cp/coroutines.cc
@@ -1258,7 +1258,7 @@ build_co_await (location_t loc, tree a, suspend_point_kind suspend_kind,
   if (TREE_CODE (awrs_call) == TARGET_EXPR)
     {
       te = awrs_call;
-      awrs_call = TREE_OPERAND (awrs_call, 1);
+      awrs_call = TARGET_EXPR_INITIAL (awrs_call);
     }
   TREE_VEC_ELT (awaiter_calls, 2) = awrs_call; /* await_resume().  */
 
@@ -1447,9 +1447,9 @@ finish_co_yield_expr (location_t kw, tree expr)
         its contained await.  Otherwise, just build the CO_YIELD_EXPR.  */
       if (TREE_CODE (op) == TARGET_EXPR)
        {
-         tree t = TREE_OPERAND (op, 1);
+         tree t = TARGET_EXPR_INITIAL (op);
          t = build2_loc (kw, CO_YIELD_EXPR, TREE_TYPE (t), expr, t);
-         TREE_OPERAND (op, 1) = t;
+         TARGET_EXPR_INITIAL (op) = t;
        }
       else
        op = build2_loc (kw, CO_YIELD_EXPR, TREE_TYPE (op), expr, op);
@@ -2711,7 +2711,7 @@ register_awaits (tree *stmt, int *, void *d)
   tree v = TREE_OPERAND (aw_expr, 3);
   tree o = TREE_VEC_ELT (v, 1);
   if (TREE_CODE (o) == TARGET_EXPR)
-    TREE_VEC_ELT (v, 1) = get_target_expr (TREE_OPERAND (o, 1));
+    TREE_VEC_ELT (v, 1) = get_target_expr (TARGET_EXPR_INITIAL (o));
   return NULL_TREE;
 }
 
@@ -2734,7 +2734,7 @@ tmp_target_expr_p (tree t)
 {
   if (TREE_CODE (t) != TARGET_EXPR)
     return false;
-  tree v = TREE_OPERAND (t, 0);
+  tree v = TARGET_EXPR_SLOT (t);
   if (!DECL_ARTIFICIAL (v))
     return false;
   if (DECL_NAME (v))
@@ -2941,7 +2941,7 @@ flatten_await_stmt (var_nest_node *n, hash_set<tree> *promoted,
                    {
                      temps_used->add (inner);
                      gcc_checking_assert
-                       (TREE_CODE (TREE_OPERAND (inner, 1)) != COND_EXPR);
+                       (TREE_CODE (TARGET_EXPR_INITIAL (inner)) != COND_EXPR);
                    }
                }
                break;
@@ -2972,7 +2972,7 @@ flatten_await_stmt (var_nest_node *n, hash_set<tree> *promoted,
          free (buf);
          bool already_present = promoted->add (var);
          gcc_checking_assert (!already_present);
-         tree inner = TREE_OPERAND (init, 1);
+         tree inner = TARGET_EXPR_INITIAL (init);
          gcc_checking_assert (TREE_CODE (inner) != COND_EXPR);
          init = cp_build_modify_expr (input_location, var, INIT_EXPR, init,
                                       tf_warning_or_error);
@@ -2981,7 +2981,7 @@ flatten_await_stmt (var_nest_node *n, hash_set<tree> *promoted,
          if (t == n->init && n->var == NULL_TREE)
            {
              n->var = var;
-             proxy_replace pr = {TREE_OPERAND (t, 0), var};
+             proxy_replace pr = {TARGET_EXPR_SLOT (t), var};
              cp_walk_tree (&init, replace_proxy, &pr, NULL);
              n->init = init;
              if (replace_in)
@@ -2995,7 +2995,7 @@ flatten_await_stmt (var_nest_node *n, hash_set<tree> *promoted,
              /* We have to replace the target expr... */
              *v.entry = var;
              /* ... and any uses of its var.  */
-             proxy_replace pr = {TREE_OPERAND (t, 0), var};
+             proxy_replace pr = {TARGET_EXPR_SLOT (t), var};
              cp_walk_tree (&n->init, replace_proxy, &pr, NULL);
              /* Compiler-generated temporaries can also have uses in
                 following arms of compound expressions, which will be listed

diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc
index 90e3630e3aa6c8996050e453de04983f69632d52..65f70c595cf880385f9eee65da00d23e6e5c4e1c 100644 (file)
--- a/gcc/cp/error.cc
+++ b/gcc/cp/error.cc
@@ -2525,8 +2525,8 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags)
         it initializes anything other that the parameter slot for the
         default argument.  Note we may have cleared out the first
         operand in expand_expr, so don't go killing ourselves.  */
-      if (TREE_OPERAND (t, 1))
-       dump_expr (pp, TREE_OPERAND (t, 1), flags | TFF_EXPR_IN_PARENS);
+      if (TARGET_EXPR_INITIAL (t))
+       dump_expr (pp, TARGET_EXPR_INITIAL (t), flags | TFF_EXPR_IN_PARENS);
       break;
 
     case POINTER_PLUS_EXPR:

diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index a061704e1a27e329488fa4ac871f9790bf7d64bc..0cb46c1986ca3ac764a13cc96564ba2670fe65f4 100644 (file)
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -10446,7 +10446,7 @@ finish_omp_target_clauses (location_t loc, tree body, tree *clauses_ptr)
     {
       tree lobj = *i;
       if (TREE_CODE (lobj) == TARGET_EXPR)
-       lobj = TREE_OPERAND (lobj, 0);
+       lobj = TARGET_EXPR_SLOT (lobj);
 
       tree lt = TREE_TYPE (lobj);
       gcc_assert (LAMBDA_TYPE_P (lt) && CLASS_TYPE_P (lt));

diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc
index f43febed124cc885a0100bdeba06e96e252eb199..e8d8b2ab6f70e83198a649f7bc5427d08422ad3e 100644 (file)
--- a/gcc/cp/tree.cc
+++ b/gcc/cp/tree.cc
@@ -3138,17 +3138,17 @@ bot_manip (tree* tp, int* walk_subtrees, void* data_)
     {
       tree u;
 
-      if (TREE_CODE (TREE_OPERAND (t, 1)) == AGGR_INIT_EXPR)
+      if (TREE_CODE (TARGET_EXPR_INITIAL (t)) == AGGR_INIT_EXPR)
        {
-         u = build_cplus_new (TREE_TYPE (t), TREE_OPERAND (t, 1),
+         u = build_cplus_new (TREE_TYPE (t), TARGET_EXPR_INITIAL (t),
                               tf_warning_or_error);
          if (u == error_mark_node)
            return u;
-         if (AGGR_INIT_ZERO_FIRST (TREE_OPERAND (t, 1)))
-           AGGR_INIT_ZERO_FIRST (TREE_OPERAND (u, 1)) = true;
+         if (AGGR_INIT_ZERO_FIRST (TARGET_EXPR_INITIAL (t)))
+           AGGR_INIT_ZERO_FIRST (TARGET_EXPR_INITIAL (u)) = true;
        }
       else
-       u = force_target_expr (TREE_TYPE (t), TREE_OPERAND (t, 1),
+       u = force_target_expr (TREE_TYPE (t), TARGET_EXPR_INITIAL (t),
                               tf_warning_or_error);
 
       TARGET_EXPR_IMPLICIT_P (u) = TARGET_EXPR_IMPLICIT_P (t);
@@ -3158,12 +3158,12 @@ bot_manip (tree* tp, int* walk_subtrees, void* data_)
 
       /* Map the old variable to the new one.  */
       splay_tree_insert (target_remap,
-                        (splay_tree_key) TREE_OPERAND (t, 0),
-                        (splay_tree_value) TREE_OPERAND (u, 0));
+                        (splay_tree_key) TARGET_EXPR_SLOT (t),
+                        (splay_tree_value) TARGET_EXPR_SLOT (u));
 
-      TREE_OPERAND (u, 1) = break_out_target_exprs (TREE_OPERAND (u, 1),
-                                                   data.clear_location);
-      if (TREE_OPERAND (u, 1) == error_mark_node)
+      TARGET_EXPR_INITIAL (u) = break_out_target_exprs (TARGET_EXPR_INITIAL (u),
+                                                       data.clear_location);
+      if (TARGET_EXPR_INITIAL (u) == error_mark_node)
        return error_mark_node;
 
       if (data.clear_location)
@@ -4034,8 +4034,8 @@ cp_tree_equal (tree t1, tree t2)
 
     case TARGET_EXPR:
       {
-       tree o1 = TREE_OPERAND (t1, 0);
-       tree o2 = TREE_OPERAND (t2, 0);
+       tree o1 = TARGET_EXPR_SLOT (t1);
+       tree o2 = TARGET_EXPR_SLOT (t2);
 
        /* Special case: if either target is an unallocated VAR_DECL,
           it means that it's going to be unified with whatever the
@@ -4050,7 +4050,8 @@ cp_tree_equal (tree t1, tree t2)
        else if (!cp_tree_equal (o1, o2))
          return false;
 
-       return cp_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
+       return cp_tree_equal (TARGET_EXPR_INITIAL (t1),
+                             TARGET_EXPR_INITIAL (t2));
       }
 
     case PARM_DECL:

diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index b6835286cff3ef5baf76fe6c3571055ac8eb4721..d1204d922bbd65e0ee2a9a18a444f661e1b97302 100644 (file)
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -7995,7 +7995,7 @@ cxx_mark_addressable (tree exp, bool array_ref_p)
 
       case TARGET_EXPR:
        TREE_ADDRESSABLE (x) = 1;
-       cxx_mark_addressable (TREE_OPERAND (x, 0));
+       cxx_mark_addressable (TARGET_EXPR_SLOT (x));
        return true;
 
       default:
@@ -8195,10 +8195,10 @@ cp_build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain)
       /* If the rhs is a TARGET_EXPR, then build the compound
         expression inside the target_expr's initializer. This
         helps the compiler to eliminate unnecessary temporaries.  */
-      tree init = TREE_OPERAND (rhs, 1);
+      tree init = TARGET_EXPR_INITIAL (rhs);
 
       init = build2 (COMPOUND_EXPR, TREE_TYPE (init), lhs, init);
-      TREE_OPERAND (rhs, 1) = init;
+      TARGET_EXPR_INITIAL (rhs) = init;
 
       if (eptype)
        rhs = build1 (EXCESS_PRECISION_EXPR, eptype, rhs);
@@ -9861,7 +9861,7 @@ cp_build_modify_expr (location_t loc, tree lhs, enum tree_code modifycode,
         expanded without a target.  */
       if (TREE_CODE (newrhs) == TARGET_EXPR)
        newrhs = build2 (COMPOUND_EXPR, TREE_TYPE (newrhs), newrhs,
-                        TREE_OPERAND (newrhs, 0));
+                        TARGET_EXPR_SLOT (newrhs));
     }
 
   if (newrhs == error_mark_node)
@@ -11448,9 +11448,9 @@ check_return_expr (tree retval, bool *no_warning, bool *dangling)
       /* We can't initialize a register from a AGGR_INIT_EXPR.  */
       else if (! cfun->returns_struct
               && TREE_CODE (retval) == TARGET_EXPR
-              && TREE_CODE (TREE_OPERAND (retval, 1)) == AGGR_INIT_EXPR)
+              && TREE_CODE (TARGET_EXPR_INITIAL (retval)) == AGGR_INIT_EXPR)
        retval = build2 (COMPOUND_EXPR, TREE_TYPE (retval), retval,
-                        TREE_OPERAND (retval, 0));
+                        TARGET_EXPR_SLOT (retval));
       else if (!processing_template_decl
               && maybe_warn_about_returning_address_of_local (retval, loc)
               && INDIRECT_TYPE_P (valtype))