Re: RFA: tuples merge for GIMPLE_MODIFY_STMT

[Aldy Hernandez <aldyh at redhat dot com>]

> Actually, how about we rename PROTECTED_TREE_OPERAND as 
> GENERIC_TREE_OPERAND?  That is, after all, what the accessor does.

I have also renamed PROTECTED_TREE_TYPE to GENERIC_TREE_TYPE.  I will
commit this to the branch as soon as the bootstrap finishes.

Aldy

	* tree-ssa-loop-im.c: Rename all PROTECTED_TREE_OPERAND to
	GENERIC_TREE_OPERAND, and all PROTECTED_TREE_TYPE to
	GENERIC_TREE_TYPE.
	* tree-complex.c: Same.
	* tree-pretty-print.c: Same.
	* tree.c: Same.
	* tree.h: Same.
	* builtins.c: Same.
	* fold-const.c: Same.
	* tree-ssa-dom.c: Same.
	* tree-ssa-propagate.c: Same.
	* tree-ssa-alias.c: Same.
	* gimple-low.c: Same.
	* dwarf2out.c: Same.
	* c-pretty-print.c: Same.
	* gimplify.c: Same.
	* tree-inline.c: Same.
	* tree-outof-ssa.c: Same.
	* tree-ssa-structalias.c: Same.
	* tree-ssa-reassoc.c: Same.
	* stmt.c: Same.

Index: tree-ssa-loop-im.c
===================================================================
--- tree-ssa-loop-im.c	(revision 118179)
+++ tree-ssa-loop-im.c	(working copy)
@@ -423,7 +423,7 @@ stmt_cost (tree stmt)
   if (TREE_CODE (stmt) == COND_EXPR)
     return LIM_EXPENSIVE;
 
-  rhs = PROTECTED_TREE_OPERAND (stmt, 1);
+  rhs = GENERIC_TREE_OPERAND (stmt, 1);
 
   /* Hoisting memory references out should almost surely be a win.  */
   if (stmt_references_memory_p (stmt))
@@ -609,7 +609,7 @@ determine_invariantness_stmt (struct dom
       /* If divisor is invariant, convert a/b to a*(1/b), allowing reciprocal
 	 to be hoisted out of loop, saving expensive divide.  */
       if (pos == MOVE_POSSIBLE
-	  && (rhs = PROTECTED_TREE_OPERAND (stmt, 1)) != NULL
+	  && (rhs = GENERIC_TREE_OPERAND (stmt, 1)) != NULL
 	  && TREE_CODE (rhs) == RDIV_EXPR
 	  && flag_unsafe_math_optimizations
 	  && !flag_trapping_math
@@ -620,7 +620,7 @@ determine_invariantness_stmt (struct dom
 	{
 	  tree lhs, stmt1, stmt2, var, name;
 
-	  lhs = PROTECTED_TREE_OPERAND (stmt, 0);
+	  lhs = GENERIC_TREE_OPERAND (stmt, 0);
 
 	  /* stmt must be GIMPLE_MODIFY_STMT.  */
 	  var = create_tmp_var (TREE_TYPE (rhs), "reciptmp");
Index: tree-complex.c
===================================================================
--- tree-complex.c	(revision 118179)
+++ tree-complex.c	(working copy)
@@ -1383,8 +1383,8 @@ expand_complex_operations_1 (block_stmt_
 
     default:
       {
-	tree lhs = PROTECTED_TREE_OPERAND (stmt, 0);
-	tree rhs = PROTECTED_TREE_OPERAND (stmt, 1);
+	tree lhs = GENERIC_TREE_OPERAND (stmt, 0);
+	tree rhs = GENERIC_TREE_OPERAND (stmt, 1);
 
 	if (TREE_CODE (type) == COMPLEX_TYPE)
 	  expand_complex_move (bsi, stmt, type, lhs, rhs);
@@ -1392,7 +1392,7 @@ expand_complex_operations_1 (block_stmt_
 		  || TREE_CODE (rhs) == IMAGPART_EXPR)
 		 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
 	  {
-	    PROTECTED_TREE_OPERAND (stmt, 1)
+	    GENERIC_TREE_OPERAND (stmt, 1)
 	      = extract_component (bsi, TREE_OPERAND (rhs, 0),
 				   TREE_CODE (rhs) == IMAGPART_EXPR, false);
 	    update_stmt (stmt);
Index: tree-pretty-print.c
===================================================================
--- tree-pretty-print.c	(revision 118382)
+++ tree-pretty-print.c	(working copy)
@@ -1029,12 +1029,12 @@ dump_generic_node (pretty_printer *buffe
     case MODIFY_EXPR:
     case GIMPLE_MODIFY_STMT:
     case INIT_EXPR:
-      dump_generic_node (buffer, PROTECTED_TREE_OPERAND (node, 0), spc, flags,
+      dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
 	  		 false);
       pp_space (buffer);
       pp_character (buffer, '=');
       pp_space (buffer);
-      dump_generic_node (buffer, PROTECTED_TREE_OPERAND (node, 1), spc, flags,
+      dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
 	  		 false);
       break;
 
@@ -1496,7 +1496,7 @@ dump_generic_node (pretty_printer *buffe
 	  pp_space (buffer);
 	  if (TREE_CODE (op0) == MODIFY_EXPR
 	      || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
-	    dump_generic_node (buffer, PROTECTED_TREE_OPERAND (op0, 1),
+	    dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
 			       spc, flags, false);
 	  else
 	    dump_generic_node (buffer, op0, spc, flags, false);
Index: tree.c
===================================================================
--- tree.c	(revision 118895)
+++ tree.c	(working copy)
@@ -7908,8 +7908,8 @@ walk_tree (tree *tp, walk_tree_fn func, 
 	  if (len)
 	    {
 	      for (i = 0; i < len - 1; ++i)
-		WALK_SUBTREE (PROTECTED_TREE_OPERAND (*tp, i));
-	      WALK_SUBTREE_TAIL (PROTECTED_TREE_OPERAND (*tp, len - 1));
+		WALK_SUBTREE (GENERIC_TREE_OPERAND (*tp, i));
+	      WALK_SUBTREE_TAIL (GENERIC_TREE_OPERAND (*tp, len - 1));
 	    }
 	}
       /* If this is a type, walk the needed fields in the type.  */
@@ -7979,7 +7979,7 @@ tree_block (tree t)
 }
 
 tree *
-protected_tree_operand (tree node, int i)
+generic_tree_operand (tree node, int i)
 {
   if (GIMPLE_STMT_P (node))
     return &GIMPLE_STMT_OPERAND (node, i);
@@ -7987,7 +7987,7 @@ protected_tree_operand (tree node, int i
 }
 
 tree *
-protected_tree_type (tree node)
+generic_tree_type (tree node)
 {
   if (GIMPLE_STMT_P (node))
     return &void_type_node;
Index: tree.h
===================================================================
--- tree.h	(revision 118382)
+++ tree.h	(working copy)
@@ -950,12 +950,12 @@ extern void omp_clause_range_check_faile
 
    If you know the NODE is a GIMPLE statement, use GIMPLE_STMT_OPERAND.  If the
    NODE code is unknown at compile time, use this macro.  */
-#define PROTECTED_TREE_OPERAND(NODE, I) *(protected_tree_operand ((NODE), (I)))
+#define GENERIC_TREE_OPERAND(NODE, I) *(generic_tree_operand ((NODE), (I)))
 
 /* Like TREE_TYPE but returns void_type_node for gimple tuples that have
    no type.  */
 
-#define PROTECTED_TREE_TYPE(NODE) *(protected_tree_type ((NODE)))
+#define GENERIC_TREE_TYPE(NODE) *(generic_tree_type ((NODE)))
 
 /* Here is how primitive or already-canonicalized types' hash codes
    are made.  */
@@ -974,7 +974,7 @@ extern void omp_clause_range_check_faile
 	  || TREE_CODE (EXP) == NON_LVALUE_EXPR)		\
 	 && TREE_OPERAND (EXP, 0) != error_mark_node		\
 	 && (TYPE_MODE (TREE_TYPE (EXP))			\
-	     == TYPE_MODE (PROTECTED_TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
+	     == TYPE_MODE (GENERIC_TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
     (EXP) = TREE_OPERAND (EXP, 0)
 
 /* Like STRIP_NOPS, but don't let the signedness change either.  */
@@ -4433,8 +4433,8 @@ extern void set_expr_locus (tree,
 extern const char **expr_filename (tree);
 extern int *expr_lineno (tree);
 extern tree *tree_block (tree);
-extern tree *protected_tree_operand (tree, int);
-extern tree *protected_tree_type (tree);
+extern tree *generic_tree_operand (tree, int);
+extern tree *generic_tree_type (tree);
 
 /* In function.c */
 extern void expand_main_function (void);
Index: builtins.c
===================================================================
--- builtins.c	(revision 118382)
+++ builtins.c	(working copy)
@@ -6764,7 +6764,7 @@ integer_valued_real_p (tree t)
     case COMPOUND_EXPR:
     case GIMPLE_MODIFY_STMT:
     case BIND_EXPR:
-      return integer_valued_real_p (PROTECTED_TREE_OPERAND (t, 1));
+      return integer_valued_real_p (GENERIC_TREE_OPERAND (t, 1));
 
     case PLUS_EXPR:
     case MINUS_EXPR:
@@ -9355,7 +9355,7 @@ fold_builtin (tree fndecl, tree arglist,
   tree exp = fold_builtin_1 (fndecl, arglist, ignore);
   if (exp && !ignore)
     {
-      exp = build1 (NOP_EXPR, PROTECTED_TREE_TYPE (exp), exp);
+      exp = build1 (NOP_EXPR, GENERIC_TREE_TYPE (exp), exp);
       TREE_NO_WARNING (exp) = 1;
     }
 
Index: fold-const.c
===================================================================
--- fold-const.c	(revision 118462)
+++ fold-const.c	(working copy)
@@ -7446,15 +7446,15 @@ fold_unary (enum tree_code code, tree ty
 
       if ((TREE_CODE (op0) == MODIFY_EXPR
 	   || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
-	  && TREE_CONSTANT (PROTECTED_TREE_OPERAND (op0, 1))
+	  && TREE_CONSTANT (GENERIC_TREE_OPERAND (op0, 1))
 	  /* Detect assigning a bitfield.  */
-	  && !(TREE_CODE (PROTECTED_TREE_OPERAND (op0, 0)) == COMPONENT_REF
+	  && !(TREE_CODE (GENERIC_TREE_OPERAND (op0, 0)) == COMPONENT_REF
 	       && DECL_BIT_FIELD
-	       (TREE_OPERAND (PROTECTED_TREE_OPERAND (op0, 0), 1))))
+	       (TREE_OPERAND (GENERIC_TREE_OPERAND (op0, 0), 1))))
 	{
 	  /* Don't leave an assignment inside a conversion
 	     unless assigning a bitfield.  */
-	  tem = fold_build1 (code, type, PROTECTED_TREE_OPERAND (op0, 1));
+	  tem = fold_build1 (code, type, GENERIC_TREE_OPERAND (op0, 1));
 	  /* First do the assignment, then return converted constant.  */
 	  tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
 	  TREE_NO_WARNING (tem) = 1;
@@ -12223,7 +12223,7 @@ tree_expr_nonnegative_p (tree t)
     case COMPOUND_EXPR:
     case MODIFY_EXPR:
     case GIMPLE_MODIFY_STMT:
-      return tree_expr_nonnegative_p (PROTECTED_TREE_OPERAND (t, 1));
+      return tree_expr_nonnegative_p (GENERIC_TREE_OPERAND (t, 1));
 
     case BIND_EXPR:
       return tree_expr_nonnegative_p (expr_last (TREE_OPERAND (t, 1)));
@@ -12285,8 +12285,8 @@ tree_expr_nonnegative_p (tree t)
 	  }
 	if ((TREE_CODE (t) == MODIFY_EXPR
 	     || TREE_CODE (t) == GIMPLE_MODIFY_STMT)
-	    && PROTECTED_TREE_OPERAND (t, 0) == temp)
-	  return tree_expr_nonnegative_p (PROTECTED_TREE_OPERAND (t, 1));
+	    && GENERIC_TREE_OPERAND (t, 0) == temp)
+	  return tree_expr_nonnegative_p (GENERIC_TREE_OPERAND (t, 1));
 
 	return 0;
       }
@@ -12491,7 +12491,7 @@ tree_expr_nonzero_p (tree t)
     case MODIFY_EXPR:
     case GIMPLE_MODIFY_STMT:
     case BIND_EXPR:
-      return tree_expr_nonzero_p (PROTECTED_TREE_OPERAND (t, 1));
+      return tree_expr_nonzero_p (GENERIC_TREE_OPERAND (t, 1));
 
     case SAVE_EXPR:
     case NON_LVALUE_EXPR:
Index: tree-ssa-dom.c
===================================================================
--- tree-ssa-dom.c	(revision 118179)
+++ tree-ssa-dom.c	(working copy)
@@ -497,7 +497,7 @@ initialize_hash_element (tree expr, tree
   else
     {
       element->stmt = expr;
-      element->rhs = PROTECTED_TREE_OPERAND (expr, 1);
+      element->rhs = GENERIC_TREE_OPERAND (expr, 1);
     }
 
   element->lhs = lhs;
@@ -1502,7 +1502,7 @@ eliminate_redundant_computations (tree s
     }
   else
     {
-      expr_p = &PROTECTED_TREE_OPERAND (stmt, 1);
+      expr_p = &GENERIC_TREE_OPERAND (stmt, 1);
       modify_expr_p = true;
     }
 
Index: tree-ssa-propagate.c
===================================================================
--- tree-ssa-propagate.c	(revision 118753)
+++ tree-ssa-propagate.c	(working copy)
@@ -536,7 +536,7 @@ get_rhs (tree stmt)
       /* FALLTHRU */
 
     case GIMPLE_MODIFY_STMT:
-      stmt = PROTECTED_TREE_OPERAND (stmt, 1);
+      stmt = GENERIC_TREE_OPERAND (stmt, 1);
       if (TREE_CODE (stmt) == WITH_SIZE_EXPR)
 	return TREE_OPERAND (stmt, 0);
       else
Index: tree-ssa-alias.c
===================================================================
--- tree-ssa-alias.c	(revision 118382)
+++ tree-ssa-alias.c	(working copy)
@@ -431,7 +431,7 @@ compute_call_clobbered (struct alias_inf
 static bool
 lhs_may_store_to (tree stmt, tree sym ATTRIBUTE_UNUSED)
 {
-  tree lhs = PROTECTED_TREE_OPERAND (stmt, 0);
+  tree lhs = GENERIC_TREE_OPERAND (stmt, 0);
   
   lhs = get_base_address (lhs);
   
Index: gimple-low.c
===================================================================
--- gimple-low.c	(revision 118382)
+++ gimple-low.c	(working copy)
@@ -665,7 +665,7 @@ lower_builtin_setjmp (tree_stmt_iterator
   /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
   t = build_addr (next_label, current_function_decl);
   arg = tree_cons (NULL, t, NULL);
-  t = TREE_VALUE (PROTECTED_TREE_OPERAND (stmt, 1));
+  t = TREE_VALUE (GENERIC_TREE_OPERAND (stmt, 1));
   arg = tree_cons (NULL, t, arg);
   t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
   t = build_function_call_expr (t, arg);
Index: dwarf2out.c
===================================================================
--- dwarf2out.c	(revision 118382)
+++ dwarf2out.c	(working copy)
@@ -9233,7 +9233,7 @@ loc_descriptor_from_tree_1 (tree loc, in
     case VIEW_CONVERT_EXPR:
     case SAVE_EXPR:
     case GIMPLE_MODIFY_STMT:
-      return loc_descriptor_from_tree_1 (PROTECTED_TREE_OPERAND (loc, 0),
+      return loc_descriptor_from_tree_1 (GENERIC_TREE_OPERAND (loc, 0),
 					 want_address);
 
     case COMPONENT_REF:
Index: c-pretty-print.c
===================================================================
--- c-pretty-print.c	(revision 118179)
+++ c-pretty-print.c	(working copy)
@@ -1799,11 +1799,11 @@ pp_c_assignment_expression (c_pretty_pri
       || TREE_CODE (e) == GIMPLE_MODIFY_STMT
       || TREE_CODE (e) == INIT_EXPR)
     {
-      pp_c_unary_expression (pp, PROTECTED_TREE_OPERAND (e, 0));
+      pp_c_unary_expression (pp, GENERIC_TREE_OPERAND (e, 0));
       pp_c_whitespace (pp);
       pp_equal (pp);
       pp_space (pp);
-      pp_c_expression (pp, PROTECTED_TREE_OPERAND (e, 1));
+      pp_c_expression (pp, GENERIC_TREE_OPERAND (e, 1));
     }
   else
     pp_c_conditional_expression (pp, e);
Index: gimplify.c
===================================================================
--- gimplify.c	(revision 118462)
+++ gimplify.c	(working copy)
@@ -1142,7 +1142,7 @@ gimplify_return_expr (tree stmt, tree *p
     result_decl = NULL_TREE;
   else
     {
-      result_decl = PROTECTED_TREE_OPERAND (ret_expr, 0);
+      result_decl = GENERIC_TREE_OPERAND (ret_expr, 0);
       if (TREE_CODE (result_decl) == INDIRECT_REF)
 	/* See through a return by reference.  */
 	result_decl = TREE_OPERAND (result_decl, 0);
@@ -1182,7 +1182,7 @@ gimplify_return_expr (tree stmt, tree *p
   /* Smash the lhs of the GIMPLE_MODIFY_STMT to the temporary we plan to use.
      Then gimplify the whole thing.  */
   if (result != result_decl)
-    PROTECTED_TREE_OPERAND (ret_expr, 0) = result;
+    GENERIC_TREE_OPERAND (ret_expr, 0) = result;
 
   gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
 
@@ -2556,8 +2556,8 @@ gimplify_modify_expr_to_memcpy (tree *ex
 {
   tree args, t, to, to_ptr, from;
 
-  to = PROTECTED_TREE_OPERAND (*expr_p, 0);
-  from = PROTECTED_TREE_OPERAND (*expr_p, 1);
+  to = GENERIC_TREE_OPERAND (*expr_p, 0);
+  from = GENERIC_TREE_OPERAND (*expr_p, 1);
 
   args = tree_cons (NULL, size, NULL);
 
@@ -2588,7 +2588,7 @@ gimplify_modify_expr_to_memset (tree *ex
 {
   tree args, t, to, to_ptr;
 
-  to = PROTECTED_TREE_OPERAND (*expr_p, 0);
+  to = GENERIC_TREE_OPERAND (*expr_p, 0);
 
   args = tree_cons (NULL, size, NULL);
 
@@ -2924,7 +2924,7 @@ gimplify_init_constructor (tree *expr_p,
 			   tree *post_p, bool want_value)
 {
   tree object;
-  tree ctor = PROTECTED_TREE_OPERAND (*expr_p, 1);
+  tree ctor = GENERIC_TREE_OPERAND (*expr_p, 1);
   tree type = TREE_TYPE (ctor);
   enum gimplify_status ret;
   VEC(constructor_elt,gc) *elts;
@@ -2932,11 +2932,11 @@ gimplify_init_constructor (tree *expr_p,
   if (TREE_CODE (ctor) != CONSTRUCTOR)
     return GS_UNHANDLED;
 
-  ret = gimplify_expr (&PROTECTED_TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+  ret = gimplify_expr (&GENERIC_TREE_OPERAND (*expr_p, 0), pre_p, post_p,
 		       is_gimple_lvalue, fb_lvalue);
   if (ret == GS_ERROR)
     return ret;
-  object = PROTECTED_TREE_OPERAND (*expr_p, 0);
+  object = GENERIC_TREE_OPERAND (*expr_p, 0);
 
   elts = CONSTRUCTOR_ELTS (ctor);
 
@@ -3062,7 +3062,7 @@ gimplify_init_constructor (tree *expr_p,
 		  }
 	        walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
 
-		PROTECTED_TREE_OPERAND (*expr_p, 1) = new;
+		GENERIC_TREE_OPERAND (*expr_p, 1) = new;
 
 		/* This is no longer an assignment of a CONSTRUCTOR, but
 		   we still may have processing to do on the LHS.  So
@@ -3081,7 +3081,7 @@ gimplify_init_constructor (tree *expr_p,
 	      preeval_data.lhs_base_decl = NULL;
 	    preeval_data.lhs_alias_set = get_alias_set (object);
 
-	    gimplify_init_ctor_preeval (&PROTECTED_TREE_OPERAND (*expr_p, 1),
+	    gimplify_init_ctor_preeval (&GENERIC_TREE_OPERAND (*expr_p, 1),
 					pre_p, post_p, &preeval_data);
 	  }
 
@@ -3463,8 +3463,8 @@ gimplify_modify_expr_complex_part (tree 
   enum tree_code code, ocode;
   tree lhs, rhs, new_rhs, other, realpart, imagpart;
 
-  lhs = PROTECTED_TREE_OPERAND (*expr_p, 0);
-  rhs = PROTECTED_TREE_OPERAND (*expr_p, 1);
+  lhs = GENERIC_TREE_OPERAND (*expr_p, 0);
+  rhs = GENERIC_TREE_OPERAND (*expr_p, 1);
   code = TREE_CODE (lhs);
   lhs = TREE_OPERAND (lhs, 0);
 
@@ -3480,8 +3480,8 @@ gimplify_modify_expr_complex_part (tree 
   else
     new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
 
-  PROTECTED_TREE_OPERAND (*expr_p, 0) = lhs;
-  PROTECTED_TREE_OPERAND (*expr_p, 1) = new_rhs;
+  GENERIC_TREE_OPERAND (*expr_p, 0) = lhs;
+  GENERIC_TREE_OPERAND (*expr_p, 1) = new_rhs;
 
   if (want_value)
     {
@@ -3559,8 +3559,8 @@ tree_to_gimple_tuple (tree *tp)
 static enum gimplify_status
 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
 {
-  tree *from_p = &PROTECTED_TREE_OPERAND (*expr_p, 1);
-  tree *to_p = &PROTECTED_TREE_OPERAND (*expr_p, 0);
+  tree *from_p = &GENERIC_TREE_OPERAND (*expr_p, 1);
+  tree *to_p = &GENERIC_TREE_OPERAND (*expr_p, 0);
   enum gimplify_status ret = GS_UNHANDLED;
 
   gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
@@ -4942,7 +4942,7 @@ gimplify_omp_for (tree *expr_p, tree *pr
   t = OMP_FOR_INIT (for_stmt);
   gcc_assert (TREE_CODE (t) == MODIFY_EXPR
 	      || TREE_CODE (t) == GIMPLE_MODIFY_STMT);
-  decl = PROTECTED_TREE_OPERAND (t, 0);
+  decl = GENERIC_TREE_OPERAND (t, 0);
   gcc_assert (DECL_P (decl));
   gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl)));
 
@@ -4952,7 +4952,7 @@ gimplify_omp_for (tree *expr_p, tree *pr
   else
     omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
 
-  ret |= gimplify_expr (&PROTECTED_TREE_OPERAND (t, 1),
+  ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
 			&OMP_FOR_PRE_BODY (for_stmt),
 			NULL, is_gimple_val, fb_rvalue);
 
@@ -4960,9 +4960,9 @@ gimplify_omp_for (tree *expr_p, tree *pr
 
   t = OMP_FOR_COND (for_stmt);
   gcc_assert (COMPARISON_CLASS_P (t));
-  gcc_assert (PROTECTED_TREE_OPERAND (t, 0) == decl);
+  gcc_assert (GENERIC_TREE_OPERAND (t, 0) == decl);
 
-  ret |= gimplify_expr (&PROTECTED_TREE_OPERAND (t, 1),
+  ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
 			&OMP_FOR_PRE_BODY (for_stmt),
 			NULL, is_gimple_val, fb_rvalue);
 
Index: tree-inline.c
===================================================================
--- tree-inline.c	(revision 118382)
+++ tree-inline.c	(working copy)
@@ -1678,12 +1678,12 @@ estimate_num_insns_1 (tree *tp, int *wal
     case INIT_EXPR:
     case GIMPLE_MODIFY_STMT:
       /* Is the right and side a TARGET_EXPR?  */
-      if (TREE_CODE (PROTECTED_TREE_OPERAND (x, 1)) == TARGET_EXPR)
+      if (TREE_CODE (GENERIC_TREE_OPERAND (x, 1)) == TARGET_EXPR)
 	break;
       /* ... fall through ...  */
 
     case TARGET_EXPR:
-      x = PROTECTED_TREE_OPERAND (x, 0);
+      x = GENERIC_TREE_OPERAND (x, 0);
       /* Is this an assignments to a register?  */
       if (is_gimple_reg (x))
 	break;
Index: tree-outof-ssa.c
===================================================================
--- tree-outof-ssa.c	(revision 118462)
+++ tree-outof-ssa.c	(working copy)
@@ -1575,7 +1575,7 @@ check_replaceable (temp_expr_table_p tab
 
   /* Float expressions must go through memory if float-store is on.  */
   if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE
-					(PROTECTED_TREE_OPERAND (stmt, 1))))
+					(GENERIC_TREE_OPERAND (stmt, 1))))
     return false;
 
   /* Calls to functions with side-effects cannot be replaced.  */
Index: tree-ssa-structalias.c
===================================================================
--- tree-ssa-structalias.c	(revision 118382)
+++ tree-ssa-structalias.c	(working copy)
@@ -4752,7 +4752,7 @@ find_escape_constraints (tree stmt)
   gcc_assert (stmt_escape_type == ESCAPE_BAD_CAST
 	      || stmt_escape_type == ESCAPE_STORED_IN_GLOBAL
 	      || stmt_escape_type == ESCAPE_UNKNOWN);
-  rhs = PROTECTED_TREE_OPERAND (stmt, 1);
+  rhs = GENERIC_TREE_OPERAND (stmt, 1);
   
   /* Look through casts for the real escaping variable.
      Constants don't really escape, so ignore them.
Index: tree-ssa-reassoc.c
===================================================================
--- tree-ssa-reassoc.c	(revision 118179)
+++ tree-ssa-reassoc.c	(working copy)
@@ -1115,7 +1115,7 @@ static void
 linearize_expr_tree (VEC(operand_entry_t, heap) **ops, tree stmt)
 {
   block_stmt_iterator bsinow, bsilhs;
-  tree rhs = PROTECTED_TREE_OPERAND (stmt, 1);
+  tree rhs = GENERIC_TREE_OPERAND (stmt, 1);
   tree binrhs = TREE_OPERAND (rhs, 1);
   tree binlhs = TREE_OPERAND (rhs, 0);
   tree binlhsdef, binrhsdef;
Index: stmt.c
===================================================================
--- stmt.c	(revision 118179)
+++ stmt.c	(working copy)
@@ -1584,8 +1584,8 @@ expand_return (tree retval)
     }
   else if ((TREE_CODE (retval) == GIMPLE_MODIFY_STMT
 	    || TREE_CODE (retval) == INIT_EXPR)
-	   && TREE_CODE (PROTECTED_TREE_OPERAND (retval, 0)) == RESULT_DECL)
-    retval_rhs = PROTECTED_TREE_OPERAND (retval, 1);
+	   && TREE_CODE (GENERIC_TREE_OPERAND (retval, 0)) == RESULT_DECL)
+    retval_rhs = GENERIC_TREE_OPERAND (retval, 1);
   else
     retval_rhs = retval;
 
@@ -1604,7 +1604,7 @@ expand_return (tree retval)
      (and in expand_call).  */
 
   else if (retval_rhs != 0
-	   && TYPE_MODE (PROTECTED_TREE_TYPE (retval_rhs)) == BLKmode
+	   && TYPE_MODE (GENERIC_TREE_TYPE (retval_rhs)) == BLKmode
 	   && REG_P (result_rtl))
     {
       int i;