This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH][RFC] Make FRE/PRE apply copy/constant propagation


On Wed, 14 May 2014, Richard Biener wrote:

> 
> This makes FRE/PRE substitute values into all uses instead of leaving
> copies and initializations from constants in the IL which requires
> a copyprop pass to clean up things (which we usually place directly
> after FRE/PRE).
> 
> This should open the possibility to remove some of the passes,
> respectively the two copy-prop passes right after the two FREs
> and the copyprop pass we do early in loop opts.
> 
> The patch exposes a weakness in invariant motion cost computation
> and thus gfortran.dg/vect/fast-math-vect-8.f90 fails for me
> on i?86 (but not on x86_64).
> 
> I want to revisit some of the ???s and uglinesses in the patch,
> but this is a state that passes bootstrap and regtest otherwise
> and thus ready.
> 
> Any comments?

Ok, so here goes the final variant I am about to commit.

Bootstrapped and tested on x86_64-unknown-linux-gnu.

Richard.

2014-06-13  Richard Biener  <rguenther@suse.de>

	* tree-ssa-pre.c (eliminate_dom_walker::before_dom_children):
	Rewrite to propagate the VN result into all uses where
	possible and to remove stmts becoming dead because of that.
	(eliminate): Generalize stmt removal handling, remove in
	reverse dominator order to support proper debug stmt
	generation.  Update stmts before removing stmts.
	* tree-ssa-propagate.c (propagate_tree_value): Remove
	bogus assert.

	* c-c++-common/pr46562-2.c: Adjust.
	* g++.dg/tree-ssa/pr8781.C: Likewise.
	* gcc.dg/tree-ssa/ssa-fre-24.c: Likewise.
	* gcc.dg/tree-ssa/ssa-fre-25.c: Likewise.
	* gcc.dg/tree-ssa/ssa-fre-32.c: Likewise.
	* gcc.dg/tree-ssa/ssa-fre-39.c: Likewise.
	* gcc.dg/tree-ssa/ssa-pre-16.c: Likewise.


Index: trunk/gcc/tree-ssa-pre.c
===================================================================
*** trunk.orig/gcc/tree-ssa-pre.c	2014-06-12 13:05:07.459653680 +0200
--- trunk/gcc/tree-ssa-pre.c	2014-06-13 09:48:28.646517479 +0200
*************** eliminate_dom_walker::before_dom_childre
*** 4012,4131 ****
    /* Mark new bb.  */
    el_avail_stack.safe_push (NULL_TREE);
  
!   /* If this block is not reachable do nothing.  */
!   edge_iterator ei;
!   edge e;
!   FOR_EACH_EDGE (e, ei, b->preds)
!     if (e->flags & EDGE_EXECUTABLE)
!       break;
!   if (!e)
!     return;
  
    for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
      {
!       gimple stmt, phi = gsi_stmt (gsi);
!       tree sprime = NULL_TREE, res = PHI_RESULT (phi);
!       gimple_stmt_iterator gsi2;
! 
!       /* We want to perform redundant PHI elimination.  Do so by
! 	 replacing the PHI with a single copy if possible.
! 	 Do not touch inserted, single-argument or virtual PHIs.  */
!       if (gimple_phi_num_args (phi) == 1
! 	  || virtual_operand_p (res))
! 	{
! 	  gsi_next (&gsi);
! 	  continue;
! 	}
  
!       sprime = eliminate_avail (res);
!       if (!sprime
! 	  || sprime == res)
  	{
- 	  eliminate_push_avail (res);
  	  gsi_next (&gsi);
  	  continue;
  	}
-       else if (is_gimple_min_invariant (sprime))
- 	{
- 	  if (!useless_type_conversion_p (TREE_TYPE (res),
- 					  TREE_TYPE (sprime)))
- 	    sprime = fold_convert (TREE_TYPE (res), sprime);
- 	}
  
!       if (dump_file && (dump_flags & TDF_DETAILS))
  	{
! 	  fprintf (dump_file, "Replaced redundant PHI node defining ");
! 	  print_generic_expr (dump_file, res, 0);
! 	  fprintf (dump_file, " with ");
! 	  print_generic_expr (dump_file, sprime, 0);
! 	  fprintf (dump_file, "\n");
! 	}
  
!       remove_phi_node (&gsi, false);
  
!       if (inserted_exprs
! 	  && !bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res))
! 	  && TREE_CODE (sprime) == SSA_NAME)
! 	gimple_set_plf (SSA_NAME_DEF_STMT (sprime), NECESSARY, true);
! 
!       if (!useless_type_conversion_p (TREE_TYPE (res), TREE_TYPE (sprime)))
! 	sprime = fold_convert (TREE_TYPE (res), sprime);
!       stmt = gimple_build_assign (res, sprime);
!       gimple_set_plf (stmt, NECESSARY, gimple_plf (phi, NECESSARY));
! 
!       gsi2 = gsi_after_labels (b);
!       gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
!       /* Queue the copy for eventual removal.  */
!       el_to_remove.safe_push (stmt);
!       /* If we inserted this PHI node ourself, it's not an elimination.  */
!       if (inserted_exprs
! 	  && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
! 	pre_stats.phis--;
!       else
! 	pre_stats.eliminations++;
!     }
  
!   for (gsi = gsi_start_bb (b); !gsi_end_p (gsi); gsi_next (&gsi))
!     {
!       tree lhs = NULL_TREE;
!       tree rhs = NULL_TREE;
  
!       stmt = gsi_stmt (gsi);
! 
!       if (gimple_has_lhs (stmt))
! 	lhs = gimple_get_lhs (stmt);
  
!       if (gimple_assign_single_p (stmt))
! 	rhs = gimple_assign_rhs1 (stmt);
  
!       /* Lookup the RHS of the expression, see if we have an
! 	 available computation for it.  If so, replace the RHS with
! 	 the available computation.  */
!       if (gimple_has_lhs (stmt)
! 	  && TREE_CODE (lhs) == SSA_NAME
! 	  && !gimple_has_volatile_ops  (stmt))
! 	{
! 	  tree sprime;
! 	  gimple orig_stmt = stmt;
  
! 	  sprime = eliminate_avail (lhs);
! 	  /* If there is no usable leader mark lhs as leader for its value.  */
! 	  if (!sprime)
! 	    eliminate_push_avail (lhs);
  
  	  /* See PR43491.  Do not replace a global register variable when
  	     it is a the RHS of an assignment.  Do replace local register
  	     variables since gcc does not guarantee a local variable will
  	     be allocated in register.
! 	     Do not perform copy propagation or undo constant propagation.  */
! 	  if (gimple_assign_single_p (stmt)
! 	      && (TREE_CODE (rhs) == SSA_NAME
! 		  || is_gimple_min_invariant (rhs)
! 		  || (TREE_CODE (rhs) == VAR_DECL
! 		      && is_global_var (rhs)
! 		      && DECL_HARD_REGISTER (rhs))))
! 	    continue;
! 
  	  if (!sprime)
  	    {
  	      /* If there is no existing usable leader but SCCVN thinks
--- 4012,4104 ----
    /* Mark new bb.  */
    el_avail_stack.safe_push (NULL_TREE);
  
!   /* ???  If we do nothing for unreachable blocks then this will confuse
!      tailmerging.  Eventually we can reduce its reliance on SCCVN now
!      that we fully copy/constant-propagate (most) things.  */
  
    for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
      {
!       gimple phi = gsi_stmt (gsi);
!       tree res = PHI_RESULT (phi);
  
!       if (virtual_operand_p (res))
  	{
  	  gsi_next (&gsi);
  	  continue;
  	}
  
!       tree sprime = eliminate_avail (res);
!       if (sprime
! 	  && sprime != res)
  	{
! 	  if (dump_file && (dump_flags & TDF_DETAILS))
! 	    {
! 	      fprintf (dump_file, "Replaced redundant PHI node defining ");
! 	      print_generic_expr (dump_file, res, 0);
! 	      fprintf (dump_file, " with ");
! 	      print_generic_expr (dump_file, sprime, 0);
! 	      fprintf (dump_file, "\n");
! 	    }
  
! 	  /* If we inserted this PHI node ourself, it's not an elimination.  */
! 	  if (inserted_exprs
! 	      && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
! 	    pre_stats.phis--;
! 	  else
! 	    pre_stats.eliminations++;
  
! 	  /* If we will propagate into all uses don't bother to do
! 	     anything.  */
! 	  if (may_propagate_copy (res, sprime))
! 	    {
! 	      /* Mark the PHI for removal.  */
! 	      el_to_remove.safe_push (phi);
! 	      gsi_next (&gsi);
! 	      continue;
! 	    }
  
! 	  remove_phi_node (&gsi, false);
  
! 	  if (inserted_exprs
! 	      && !bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res))
! 	      && TREE_CODE (sprime) == SSA_NAME)
! 	    gimple_set_plf (SSA_NAME_DEF_STMT (sprime), NECESSARY, true);
  
! 	  if (!useless_type_conversion_p (TREE_TYPE (res), TREE_TYPE (sprime)))
! 	    sprime = fold_convert (TREE_TYPE (res), sprime);
! 	  gimple stmt = gimple_build_assign (res, sprime);
! 	  /* ???  It cannot yet be necessary (DOM walk).  */
! 	  gimple_set_plf (stmt, NECESSARY, gimple_plf (phi, NECESSARY));
  
! 	  gimple_stmt_iterator gsi2 = gsi_after_labels (b);
! 	  gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
! 	  continue;
! 	}
  
!       eliminate_push_avail (res);
!       gsi_next (&gsi);
!     }
  
+   for (gsi = gsi_start_bb (b); !gsi_end_p (gsi); gsi_next (&gsi))
+     {
+       tree sprime = NULL_TREE;
+       stmt = gsi_stmt (gsi);
+       tree lhs = gimple_get_lhs (stmt);
+       if (lhs && TREE_CODE (lhs) == SSA_NAME
+ 	  && !gimple_has_volatile_ops (stmt)
  	  /* See PR43491.  Do not replace a global register variable when
  	     it is a the RHS of an assignment.  Do replace local register
  	     variables since gcc does not guarantee a local variable will
  	     be allocated in register.
! 	     ???  The fix isn't effective here.  This should instead
! 	     be ensured by not value-numbering them the same but treating
! 	     them like volatiles?  */
! 	  && !(gimple_assign_single_p (stmt)
! 	       && (TREE_CODE (gimple_assign_rhs1 (stmt)) == VAR_DECL
! 		   && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt))
! 		   && is_global_var (gimple_assign_rhs1 (stmt)))))
! 	{
! 	  sprime = eliminate_avail (lhs);
  	  if (!sprime)
  	    {
  	      /* If there is no existing usable leader but SCCVN thinks
*************** eliminate_dom_walker::before_dom_childre
*** 4139,4246 ****
  		  && (sprime = eliminate_insert (&gsi, val)) != NULL_TREE)
  		eliminate_push_avail (sprime);
  	    }
- 	  else if (is_gimple_min_invariant (sprime))
- 	    {
- 	      /* If there is no existing leader but SCCVN knows this
- 		 value is constant, use that constant.  */
- 	      if (!useless_type_conversion_p (TREE_TYPE (lhs),
- 					      TREE_TYPE (sprime)))
- 		sprime = fold_convert (TREE_TYPE (lhs), sprime);
  
! 	      if (dump_file && (dump_flags & TDF_DETAILS))
! 		{
! 		  fprintf (dump_file, "Replaced ");
! 		  print_gimple_expr (dump_file, stmt, 0, 0);
! 		  fprintf (dump_file, " with ");
! 		  print_generic_expr (dump_file, sprime, 0);
! 		  fprintf (dump_file, " in ");
! 		  print_gimple_stmt (dump_file, stmt, 0, 0);
! 		}
! 	      pre_stats.eliminations++;
! 
! 	      tree vdef = gimple_vdef (stmt);
! 	      tree vuse = gimple_vuse (stmt);
! 	      propagate_tree_value_into_stmt (&gsi, sprime);
! 	      stmt = gsi_stmt (gsi);
! 	      update_stmt (stmt);
! 	      if (vdef != gimple_vdef (stmt))
! 		VN_INFO (vdef)->valnum = vuse;
! 
! 	      /* If we removed EH side-effects from the statement, clean
! 		 its EH information.  */
! 	      if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
! 		{
! 		  bitmap_set_bit (need_eh_cleanup,
! 				  gimple_bb (stmt)->index);
! 		  if (dump_file && (dump_flags & TDF_DETAILS))
! 		    fprintf (dump_file, "  Removed EH side-effects.\n");
! 		}
! 	      continue;
  	    }
  
  	  if (sprime
! 	      && sprime != lhs
! 	      && (rhs == NULL_TREE
! 		  || TREE_CODE (rhs) != SSA_NAME
! 		  || may_propagate_copy (rhs, sprime)))
  	    {
! 	      bool can_make_abnormal_goto
! 		  = is_gimple_call (stmt)
! 		  && stmt_can_make_abnormal_goto (stmt);
! 
! 	      gcc_assert (sprime != rhs);
! 
! 	      /* Inhibit the use of an inserted PHI on a loop header when
! 		 the address of the memory reference is a simple induction
! 		 variable.  In other cases the vectorizer won't do anything
! 		 anyway (either it's loop invariant or a complicated
! 		 expression).  */
! 	      if (do_pre
! 		  && flag_tree_loop_vectorize
! 		  && gimple_assign_single_p (stmt)
! 		  && TREE_CODE (sprime) == SSA_NAME
! 		  && loop_outer (b->loop_father))
! 		{
! 		  gimple def_stmt = SSA_NAME_DEF_STMT (sprime);
! 		  basic_block def_bb = gimple_bb (def_stmt);
! 		  if (gimple_code (def_stmt) == GIMPLE_PHI
! 		      && b->loop_father->header == def_bb
! 		      && has_zero_uses (sprime))
  		    {
! 		      ssa_op_iter iter;
! 		      tree op;
! 		      bool found = false;
! 		      FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
  			{
! 			  affine_iv iv;
! 			  def_bb = gimple_bb (SSA_NAME_DEF_STMT (op));
! 			  if (def_bb
! 			      && flow_bb_inside_loop_p (b->loop_father,
! 							def_bb)
! 			      && simple_iv (b->loop_father,
! 					    b->loop_father, op, &iv, true))
! 			    {
! 			      found = true;
! 			      break;
! 			    }
  			}
! 		      if (found)
  			{
! 			  if (dump_file && (dump_flags & TDF_DETAILS))
! 			    {
! 			      fprintf (dump_file, "Not replacing ");
! 			      print_gimple_expr (dump_file, stmt, 0, 0);
! 			      fprintf (dump_file, " with ");
! 			      print_generic_expr (dump_file, sprime, 0);
! 			      fprintf (dump_file, " which would add a loop"
! 				       " carried dependence to loop %d\n",
! 				       b->loop_father->num);
! 			    }
! 			  continue;
  			}
  		    }
  		}
  
  	      if (dump_file && (dump_flags & TDF_DETAILS))
  		{
  		  fprintf (dump_file, "Replaced ");
--- 4112,4240 ----
  		  && (sprime = eliminate_insert (&gsi, val)) != NULL_TREE)
  		eliminate_push_avail (sprime);
  	    }
  
! 	  /* If this now constitutes a copy duplicate points-to
! 	     and range info appropriately.  This is especially
! 	     important for inserted code.  See tree-ssa-copy.c
! 	     for similar code.  */
! 	  if (sprime
! 	      && TREE_CODE (sprime) == SSA_NAME)
! 	    {
! 	      basic_block sprime_b = gimple_bb (SSA_NAME_DEF_STMT (sprime));
! 	      if (POINTER_TYPE_P (TREE_TYPE (lhs))
! 		  && SSA_NAME_PTR_INFO (lhs)
! 		  && !SSA_NAME_PTR_INFO (sprime))
! 		{
! 		  duplicate_ssa_name_ptr_info (sprime,
! 					       SSA_NAME_PTR_INFO (lhs));
! 		  if (b != sprime_b)
! 		    mark_ptr_info_alignment_unknown
! 			(SSA_NAME_PTR_INFO (sprime));
! 		}
! 	      else if (!POINTER_TYPE_P (TREE_TYPE (lhs))
! 		       && SSA_NAME_RANGE_INFO (lhs)
! 		       && !SSA_NAME_RANGE_INFO (sprime)
! 		       && b == sprime_b)
! 		duplicate_ssa_name_range_info (sprime,
! 					       SSA_NAME_RANGE_TYPE (lhs),
! 					       SSA_NAME_RANGE_INFO (lhs));
  	    }
  
+ 	  /* Inhibit the use of an inserted PHI on a loop header when
+ 	     the address of the memory reference is a simple induction
+ 	     variable.  In other cases the vectorizer won't do anything
+ 	     anyway (either it's loop invariant or a complicated
+ 	     expression).  */
  	  if (sprime
! 	      && TREE_CODE (sprime) == SSA_NAME
! 	      && do_pre
! 	      && flag_tree_loop_vectorize
! 	      && loop_outer (b->loop_father)
! 	      && has_zero_uses (sprime)
! 	      && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (sprime))
! 	      && gimple_assign_load_p (stmt))
  	    {
! 	      gimple def_stmt = SSA_NAME_DEF_STMT (sprime);
! 	      basic_block def_bb = gimple_bb (def_stmt);
! 	      if (gimple_code (def_stmt) == GIMPLE_PHI
! 		  && b->loop_father->header == def_bb)
! 		{
! 		  ssa_op_iter iter;
! 		  tree op;
! 		  bool found = false;
! 		  FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
  		    {
! 		      affine_iv iv;
! 		      def_bb = gimple_bb (SSA_NAME_DEF_STMT (op));
! 		      if (def_bb
! 			  && flow_bb_inside_loop_p (b->loop_father, def_bb)
! 			  && simple_iv (b->loop_father,
! 					b->loop_father, op, &iv, true))
  			{
! 			  found = true;
! 			  break;
  			}
! 		    }
! 		  if (found)
! 		    {
! 		      if (dump_file && (dump_flags & TDF_DETAILS))
  			{
! 			  fprintf (dump_file, "Not replacing ");
! 			  print_gimple_expr (dump_file, stmt, 0, 0);
! 			  fprintf (dump_file, " with ");
! 			  print_generic_expr (dump_file, sprime, 0);
! 			  fprintf (dump_file, " which would add a loop"
! 				   " carried dependence to loop %d\n",
! 				   b->loop_father->num);
  			}
+ 		      /* Don't keep sprime available.  */
+ 		      eliminate_push_avail (lhs);
+ 		      sprime = NULL_TREE;
+ 		    }
+ 		}
+ 	    }
+ 
+ 	  if (sprime)
+ 	    {
+ 	      /* If we can propagate the value computed for LHS into
+ 		 all uses don't bother doing anything with this stmt.  */
+ 	      if (may_propagate_copy (lhs, sprime))
+ 		{
+ 		  /* Mark it for removal.  */
+ 		  el_to_remove.safe_push (stmt);
+ 
+ 		  /* ???  Don't count copy/constant propagations.  */
+ 		  if (gimple_assign_single_p (stmt)
+ 		      && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
+ 			  || gimple_assign_rhs1 (stmt) == sprime))
+ 		    continue;
+ 
+ 		  if (dump_file && (dump_flags & TDF_DETAILS))
+ 		    {
+ 		      fprintf (dump_file, "Replaced ");
+ 		      print_gimple_expr (dump_file, stmt, 0, 0);
+ 		      fprintf (dump_file, " with ");
+ 		      print_generic_expr (dump_file, sprime, 0);
+ 		      fprintf (dump_file, " in all uses of ");
+ 		      print_gimple_stmt (dump_file, stmt, 0, 0);
  		    }
+ 
+ 		  pre_stats.eliminations++;
+ 		  continue;
  		}
  
+ 	      /* If this is an assignment from our leader (which
+ 	         happens in the case the value-number is a constant)
+ 		 then there is nothing to do.  */
+ 	      if (gimple_assign_single_p (stmt)
+ 		  && sprime == gimple_assign_rhs1 (stmt))
+ 		continue;
+ 
+ 	      /* Else replace its RHS.  */
+ 	      bool can_make_abnormal_goto
+ 		  = is_gimple_call (stmt)
+ 		  && stmt_can_make_abnormal_goto (stmt);
+ 
  	      if (dump_file && (dump_flags & TDF_DETAILS))
  		{
  		  fprintf (dump_file, "Replaced ");
*************** eliminate_dom_walker::before_dom_childre
*** 4254,4269 ****
  	      if (TREE_CODE (sprime) == SSA_NAME)
  		gimple_set_plf (SSA_NAME_DEF_STMT (sprime),
  				NECESSARY, true);
- 	      /* We need to make sure the new and old types actually match,
- 		 which may require adding a simple cast, which fold_convert
- 		 will do for us.  */
- 	      if ((!rhs || TREE_CODE (rhs) != SSA_NAME)
- 		  && !useless_type_conversion_p (gimple_expr_type (stmt),
- 						 TREE_TYPE (sprime)))
- 		sprime = fold_convert (gimple_expr_type (stmt), sprime);
  
  	      pre_stats.eliminations++;
! 
  	      tree vdef = gimple_vdef (stmt);
  	      tree vuse = gimple_vuse (stmt);
  	      propagate_tree_value_into_stmt (&gsi, sprime);
--- 4248,4259 ----
  	      if (TREE_CODE (sprime) == SSA_NAME)
  		gimple_set_plf (SSA_NAME_DEF_STMT (sprime),
  				NECESSARY, true);
  
  	      pre_stats.eliminations++;
! 	      gimple orig_stmt = stmt;
! 	      if (!useless_type_conversion_p (TREE_TYPE (lhs),
! 					      TREE_TYPE (sprime)))
! 		sprime = fold_convert (TREE_TYPE (lhs), sprime);
  	      tree vdef = gimple_vdef (stmt);
  	      tree vuse = gimple_vuse (stmt);
  	      propagate_tree_value_into_stmt (&gsi, sprime);
*************** eliminate_dom_walker::before_dom_childre
*** 4291,4425 ****
  		  if (dump_file && (dump_flags & TDF_DETAILS))
  		    fprintf (dump_file, "  Removed AB side-effects.\n");
  		}
  	    }
  	}
        /* If the statement is a scalar store, see if the expression
! 	 has the same value number as its rhs.  If so, the store is
! 	 dead.  */
!       else if (gimple_assign_single_p (stmt)
! 	       && !gimple_has_volatile_ops (stmt)
! 	       && !is_gimple_reg (gimple_assign_lhs (stmt))
! 	       && (TREE_CODE (rhs) == SSA_NAME
! 		   || is_gimple_min_invariant (rhs)))
! 	{
! 	  tree val;
! 	  val = vn_reference_lookup (gimple_assign_lhs (stmt),
! 				     gimple_vuse (stmt), VN_WALK, NULL);
! 	  if (TREE_CODE (rhs) == SSA_NAME)
! 	    rhs = VN_INFO (rhs)->valnum;
! 	  if (val
! 	      && operand_equal_p (val, rhs, 0))
! 	    {
! 	      if (dump_file && (dump_flags & TDF_DETAILS))
! 		{
! 		  fprintf (dump_file, "Deleted redundant store ");
! 		  print_gimple_stmt (dump_file, stmt, 0, 0);
! 		}
  
! 	      /* Queue stmt for removal.  */
! 	      el_to_remove.safe_push (stmt);
! 	    }
! 	}
!       /* Visit COND_EXPRs and fold the comparison with the
! 	 available value-numbers.  */
!       else if (gimple_code (stmt) == GIMPLE_COND)
  	{
! 	  tree op0 = gimple_cond_lhs (stmt);
! 	  tree op1 = gimple_cond_rhs (stmt);
! 	  tree result;
! 
! 	  if (TREE_CODE (op0) == SSA_NAME)
! 	    op0 = VN_INFO (op0)->valnum;
! 	  if (TREE_CODE (op1) == SSA_NAME)
! 	    op1 = VN_INFO (op1)->valnum;
! 	  result = fold_binary (gimple_cond_code (stmt), boolean_type_node,
! 				op0, op1);
! 	  if (result && TREE_CODE (result) == INTEGER_CST)
! 	    {
! 	      if (integer_zerop (result))
! 		gimple_cond_make_false (stmt);
! 	      else
! 		gimple_cond_make_true (stmt);
! 	      update_stmt (stmt);
! 	      el_todo = TODO_cleanup_cfg;
  	    }
  	}
        /* Visit indirect calls and turn them into direct calls if
! 	 possible.  */
        if (is_gimple_call (stmt))
  	{
! 	  tree orig_fn = gimple_call_fn (stmt);
! 	  tree fn;
! 	  if (!orig_fn)
! 	    continue;
! 	  if (TREE_CODE (orig_fn) == SSA_NAME)
! 	    fn = VN_INFO (orig_fn)->valnum;
! 	  else if (TREE_CODE (orig_fn) == OBJ_TYPE_REF
! 		   && TREE_CODE (OBJ_TYPE_REF_EXPR (orig_fn)) == SSA_NAME)
  	    {
! 	      fn = VN_INFO (OBJ_TYPE_REF_EXPR (orig_fn))->valnum;
! 	      if (!gimple_call_addr_fndecl (fn))
  		{
! 		  fn = ipa_intraprocedural_devirtualization (stmt);
! 		  if (fn)
! 		    fn = build_fold_addr_expr (fn);
  		}
  	    }
! 	  else
! 	    continue;
! 	  if (gimple_call_addr_fndecl (fn) != NULL_TREE
! 	      && useless_type_conversion_p (TREE_TYPE (orig_fn),
! 					    TREE_TYPE (fn))
!               && dbg_cnt (devirt))
! 	    {
! 	      bool can_make_abnormal_goto
! 		  = stmt_can_make_abnormal_goto (stmt);
! 	      bool was_noreturn = gimple_call_noreturn_p (stmt);
! 
! 	      if (dump_enabled_p ())
! 		{
!                   location_t loc = gimple_location (stmt);
!                   dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc,
!                                    "converting indirect call to function %s\n",
!                                    cgraph_get_node (gimple_call_addr_fndecl (fn))->name ());
! 		}
! 
! 	      gimple_call_set_fn (stmt, fn);
! 	      tree vdef = gimple_vdef (stmt);
! 	      tree vuse = gimple_vuse (stmt);
! 	      update_stmt (stmt);
! 	      if (vdef != gimple_vdef (stmt))
! 		VN_INFO (vdef)->valnum = vuse;
  
  	      /* When changing a call into a noreturn call, cfg cleanup
  		 is needed to fix up the noreturn call.  */
  	      if (!was_noreturn && gimple_call_noreturn_p (stmt))
  		el_todo |= TODO_cleanup_cfg;
  
! 	      /* If we removed EH side-effects from the statement, clean
! 		 its EH information.  */
! 	      if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
! 		{
! 		  bitmap_set_bit (need_eh_cleanup,
! 				  gimple_bb (stmt)->index);
! 		  if (dump_file && (dump_flags & TDF_DETAILS))
! 		    fprintf (dump_file, "  Removed EH side-effects.\n");
! 		}
! 
! 	      /* Likewise for AB side-effects.  */
! 	      if (can_make_abnormal_goto
! 		  && !stmt_can_make_abnormal_goto (stmt))
! 		{
! 		  bitmap_set_bit (need_ab_cleanup,
! 				  gimple_bb (stmt)->index);
! 		  if (dump_file && (dump_flags & TDF_DETAILS))
! 		    fprintf (dump_file, "  Removed AB side-effects.\n");
! 		}
  
! 	      /* Changing an indirect call to a direct call may
! 		 have exposed different semantics.  This may
! 		 require an SSA update.  */
! 	      el_todo |= TODO_update_ssa_only_virtuals;
  	    }
  	}
      }
--- 4281,4463 ----
  		  if (dump_file && (dump_flags & TDF_DETAILS))
  		    fprintf (dump_file, "  Removed AB side-effects.\n");
  		}
+ 
+ 	      continue;
  	    }
  	}
+ 
        /* If the statement is a scalar store, see if the expression
!          has the same value number as its rhs.  If so, the store is
!          dead.  */
!       if (gimple_assign_single_p (stmt)
! 	  && !gimple_has_volatile_ops (stmt)
! 	  && !is_gimple_reg (gimple_assign_lhs (stmt))
! 	  && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
! 	      || is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
!         {
!           tree val;
! 	  tree rhs = gimple_assign_rhs1 (stmt);
!           val = vn_reference_lookup (gimple_assign_lhs (stmt),
!                                      gimple_vuse (stmt), VN_WALK, NULL);
!           if (TREE_CODE (rhs) == SSA_NAME)
!             rhs = VN_INFO (rhs)->valnum;
!           if (val
!               && operand_equal_p (val, rhs, 0))
!             {
!               if (dump_file && (dump_flags & TDF_DETAILS))
!                 {
!                   fprintf (dump_file, "Deleted redundant store ");
!                   print_gimple_stmt (dump_file, stmt, 0, 0);
!                 }
  
!               /* Queue stmt for removal.  */
!               el_to_remove.safe_push (stmt);
! 	      continue;
!             }
!         }
! 
!       bool can_make_abnormal_goto = stmt_can_make_abnormal_goto (stmt);
!       bool was_noreturn = (is_gimple_call (stmt)
! 			   && gimple_call_noreturn_p (stmt));
!       tree vdef = gimple_vdef (stmt);
!       tree vuse = gimple_vuse (stmt);
! 
!       /* If we didn't replace the whole stmt (or propagate the result
!          into all uses), replace all uses on this stmt with their
! 	 leaders.  */
!       use_operand_p use_p;
!       ssa_op_iter iter;
!       FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
  	{
! 	  tree use = USE_FROM_PTR (use_p);
! 	  /* ???  The call code above leaves stmt operands un-updated.  */
! 	  if (TREE_CODE (use) != SSA_NAME)
! 	    continue;
! 	  tree sprime = eliminate_avail (use);
! 	  if (sprime && sprime != use
! 	      && may_propagate_copy (use, sprime)
! 	      /* We substitute into debug stmts to avoid excessive
! 	         debug temporaries created by removed stmts, but we need
! 		 to avoid doing so for inserted sprimes as we never want
! 		 to create debug temporaries for them.  */
! 	      && (!inserted_exprs
! 		  || TREE_CODE (sprime) != SSA_NAME
! 		  || !is_gimple_debug (stmt)
! 		  || !bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (sprime))))
! 	    {
! 	      propagate_value (use_p, sprime);
! 	      gimple_set_modified (stmt, true);
! 	      if (TREE_CODE (sprime) == SSA_NAME
! 		  && !is_gimple_debug (stmt))
! 		gimple_set_plf (SSA_NAME_DEF_STMT (sprime),
! 				NECESSARY, true);
  	    }
  	}
+ 
        /* Visit indirect calls and turn them into direct calls if
! 	 possible using the devirtualization machinery.  */
        if (is_gimple_call (stmt))
  	{
! 	  tree fn = gimple_call_fn (stmt);
! 	  if (fn
! 	      && TREE_CODE (fn) == OBJ_TYPE_REF
! 	      && TREE_CODE (OBJ_TYPE_REF_EXPR (fn)) == SSA_NAME)
  	    {
! 	      fn = ipa_intraprocedural_devirtualization (stmt);
! 	      if (fn && dbg_cnt (devirt))
  		{
! 		  if (dump_enabled_p ())
! 		    {
! 		      location_t loc = gimple_location (stmt);
! 		      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc,
! 				       "converting indirect call to "
! 				       "function %s\n",
! 				       cgraph_get_node (fn)->name ());
! 		    }
! 		  gimple_call_set_fndecl (stmt, fn);
! 		  gimple_set_modified (stmt, true);
  		}
  	    }
! 	}
  
+       if (gimple_modified_p (stmt))
+ 	{
+ 	  /* If a formerly non-invariant ADDR_EXPR is turned into an
+ 	     invariant one it was on a separate stmt.  */
+ 	  if (gimple_assign_single_p (stmt)
+ 	      && TREE_CODE (gimple_assign_rhs1 (stmt)) == ADDR_EXPR)
+ 	    recompute_tree_invariant_for_addr_expr (gimple_assign_rhs1 (stmt));
+ 	  gimple old_stmt = stmt;
+ 	  if (is_gimple_call (stmt))
+ 	    {
+ 	      /* ???  Only fold calls inplace for now, this may create new
+ 		 SSA names which in turn will confuse free_scc_vn SSA name
+ 		 release code.  */
+ 	      fold_stmt_inplace (&gsi);
  	      /* When changing a call into a noreturn call, cfg cleanup
  		 is needed to fix up the noreturn call.  */
  	      if (!was_noreturn && gimple_call_noreturn_p (stmt))
  		el_todo |= TODO_cleanup_cfg;
+ 	    }
+ 	  else
+ 	    {
+ 	      fold_stmt (&gsi);
+ 	      stmt = gsi_stmt (gsi);
+ 	      if ((gimple_code (stmt) == GIMPLE_COND
+ 		   && (gimple_cond_true_p (stmt)
+ 		       || gimple_cond_false_p (stmt)))
+ 		  || (gimple_code (stmt) == GIMPLE_SWITCH
+ 		      && TREE_CODE (gimple_switch_index (stmt)) == INTEGER_CST))
+ 		el_todo |= TODO_cleanup_cfg;
+ 	    }
+ 	  /* If we removed EH side-effects from the statement, clean
+ 	     its EH information.  */
+ 	  if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
+ 	    {
+ 	      bitmap_set_bit (need_eh_cleanup,
+ 			      gimple_bb (stmt)->index);
+ 	      if (dump_file && (dump_flags & TDF_DETAILS))
+ 		fprintf (dump_file, "  Removed EH side-effects.\n");
+ 	    }
+ 	  /* Likewise for AB side-effects.  */
+ 	  if (can_make_abnormal_goto
+ 	      && !stmt_can_make_abnormal_goto (stmt))
+ 	    {
+ 	      bitmap_set_bit (need_ab_cleanup,
+ 			      gimple_bb (stmt)->index);
+ 	      if (dump_file && (dump_flags & TDF_DETAILS))
+ 		fprintf (dump_file, "  Removed AB side-effects.\n");
+ 	    }
+ 	  update_stmt (stmt);
+ 	  if (vdef != gimple_vdef (stmt))
+ 	    VN_INFO (vdef)->valnum = vuse;
+ 	}
  
!       /* Make the new value available - for fully redundant LHS we
!          continue with the next stmt above.  */
!       if (lhs && TREE_CODE (lhs) == SSA_NAME)
! 	eliminate_push_avail (lhs);
!     }
  
!   /* Replace destination PHI arguments.  */
!   edge_iterator ei;
!   edge e;
!   FOR_EACH_EDGE (e, ei, b->succs)
!     {
!       for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
! 	{
! 	  gimple phi = gsi_stmt (gsi);
! 	  use_operand_p use_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, e);
! 	  tree arg = USE_FROM_PTR (use_p);
! 	  if (TREE_CODE (arg) != SSA_NAME
! 	      || virtual_operand_p (arg))
! 	    continue;
! 	  tree sprime = eliminate_avail (arg);
! 	  if (sprime && may_propagate_copy (arg, sprime))
! 	    {
! 	      propagate_value (use_p, sprime);
! 	      if (TREE_CODE (sprime) == SSA_NAME)
! 		gimple_set_plf (SSA_NAME_DEF_STMT (sprime), NECESSARY, true);
  	    }
  	}
      }
*************** eliminate (bool do_pre)
*** 4442,4448 ****
  {
    gimple_stmt_iterator gsi;
    gimple stmt;
-   unsigned i;
  
    need_eh_cleanup = BITMAP_ALLOC (NULL);
    need_ab_cleanup = BITMAP_ALLOC (NULL);
--- 4480,4485 ----
*************** eliminate (bool do_pre)
*** 4460,4500 ****
  
    /* We cannot remove stmts during BB walk, especially not release SSA
       names there as this confuses the VN machinery.  The stmts ending
!      up in el_to_remove are either stores or simple copies.  */
!   FOR_EACH_VEC_ELT (el_to_remove, i, stmt)
      {
!       tree lhs = gimple_assign_lhs (stmt);
!       tree rhs = gimple_assign_rhs1 (stmt);
!       use_operand_p use_p;
!       gimple use_stmt;
  
!       /* If there is a single use only, propagate the equivalency
! 	 instead of keeping the copy.  */
!       if (TREE_CODE (lhs) == SSA_NAME
! 	  && TREE_CODE (rhs) == SSA_NAME
! 	  && single_imm_use (lhs, &use_p, &use_stmt)
! 	  && may_propagate_copy (USE_FROM_PTR (use_p), rhs))
  	{
! 	  SET_USE (use_p, rhs);
! 	  update_stmt (use_stmt);
! 	  if (inserted_exprs
! 	      && bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (lhs))
! 	      && TREE_CODE (rhs) == SSA_NAME)
! 	    gimple_set_plf (SSA_NAME_DEF_STMT (rhs), NECESSARY, true);
  	}
  
!       /* If this is a store or a now unused copy, remove it.  */
!       if (TREE_CODE (lhs) != SSA_NAME
! 	  || has_zero_uses (lhs))
  	{
  	  basic_block bb = gimple_bb (stmt);
- 	  gsi = gsi_for_stmt (stmt);
  	  unlink_stmt_vdef (stmt);
  	  if (gsi_remove (&gsi, true))
  	    bitmap_set_bit (need_eh_cleanup, bb->index);
- 	  if (inserted_exprs
- 	      && TREE_CODE (lhs) == SSA_NAME)
- 	    bitmap_clear_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
  	  release_defs (stmt);
  	}
      }
--- 4497,4533 ----
  
    /* We cannot remove stmts during BB walk, especially not release SSA
       names there as this confuses the VN machinery.  The stmts ending
!      up in el_to_remove are either stores or simple copies.
!      Remove stmts in reverse order to make debug stmt creation possible.  */
!   while (!el_to_remove.is_empty ())
      {
!       stmt = el_to_remove.pop ();
  
!       if (dump_file && (dump_flags & TDF_DETAILS))
  	{
! 	  fprintf (dump_file, "Removing dead stmt ");
! 	  print_gimple_stmt (dump_file, stmt, 0, 0);
  	}
  
!       tree lhs;
!       if (gimple_code (stmt) == GIMPLE_PHI)
! 	lhs = gimple_phi_result (stmt);
!       else
! 	lhs = gimple_get_lhs (stmt);
! 
!       if (inserted_exprs
! 	  && TREE_CODE (lhs) == SSA_NAME)
! 	bitmap_clear_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
! 
!       gsi = gsi_for_stmt (stmt);
!       if (gimple_code (stmt) == GIMPLE_PHI)
! 	remove_phi_node (&gsi, true);
!       else
  	{
  	  basic_block bb = gimple_bb (stmt);
  	  unlink_stmt_vdef (stmt);
  	  if (gsi_remove (&gsi, true))
  	    bitmap_set_bit (need_eh_cleanup, bb->index);
  	  release_defs (stmt);
  	}
      }
Index: trunk/gcc/testsuite/c-c++-common/pr46562-2.c
===================================================================
*** trunk.orig/gcc/testsuite/c-c++-common/pr46562-2.c	2014-06-12 13:05:44.962651098 +0200
--- trunk/gcc/testsuite/c-c++-common/pr46562-2.c	2014-06-12 13:05:49.149650810 +0200
*************** int foo(void)
*** 9,13 ****
    return *p;
  }
  
! /* { dg-final { scan-tree-dump "= 0;" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
--- 9,13 ----
    return *p;
  }
  
! /* { dg-final { scan-tree-dump "return 0;" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
Index: trunk/gcc/tree-ssa-propagate.c
===================================================================
*** trunk.orig/gcc/tree-ssa-propagate.c	2014-06-12 13:05:44.962651098 +0200
--- trunk/gcc/tree-ssa-propagate.c	2014-06-12 13:05:49.149650810 +0200
*************** replace_exp (use_operand_p op_p, tree va
*** 1410,1420 ****
  void
  propagate_tree_value (tree *op_p, tree val)
  {
-   gcc_checking_assert (!(TREE_CODE (val) == SSA_NAME
- 			 && *op_p
- 			 && TREE_CODE (*op_p) == SSA_NAME
- 			 && !may_propagate_copy (*op_p, val)));
- 
    if (TREE_CODE (val) == SSA_NAME)
      *op_p = val;
    else
--- 1410,1415 ----
Index: trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-24.c
===================================================================
*** trunk.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-24.c	2014-06-12 13:05:44.963651098 +0200
--- trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-24.c	2014-06-12 13:05:49.150650810 +0200
*************** int bazzoo (void)
*** 30,34 ****
    return b.i;
  }
  
! /* { dg-final { scan-tree-dump-times "= 0;" 5 "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
--- 30,34 ----
    return b.i;
  }
  
! /* { dg-final { scan-tree-dump-times "return 0;" 4 "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
Index: trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-25.c
===================================================================
*** trunk.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-25.c	2014-06-12 13:05:44.963651098 +0200
--- trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-25.c	2014-06-12 13:05:49.150650810 +0200
*************** int foo (struct X *p)
*** 14,18 ****
  
  /* We should optimize this to return 0.  */
  
! /* { dg-final { scan-tree-dump "= 0;" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
--- 14,18 ----
  
  /* We should optimize this to return 0.  */
  
! /* { dg-final { scan-tree-dump "return 0;" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
Index: trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-32.c
===================================================================
*** trunk.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-32.c	2014-06-12 13:05:44.963651098 +0200
--- trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-32.c	2014-06-12 13:05:49.150650810 +0200
*************** bar (_Complex float x)
*** 23,28 ****
    return z;
  } 
  
! /* We should CSE all the way to replace the final assignment to z with x.  */
! /* { dg-final { scan-tree-dump-times "with x_1\\\(D\\\) in z" 3 "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
--- 23,28 ----
    return z;
  } 
  
! /* We should CSE all the way to replace the return value with x.  */
! /* { dg-final { scan-tree-dump-times "return x_\\d\+\\(D\\);" 2 "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
Index: trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-16.c
===================================================================
*** trunk.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-16.c	2014-06-12 13:05:44.964651098 +0200
--- trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-pre-16.c	2014-06-12 13:05:49.150650810 +0200
*************** int foo(int k, int *x)
*** 11,15 ****
    }  while (++j<k);
    return res;
  }
! /* { dg-final { scan-tree-dump-times "Eliminated: 1" 1 "pre"} } */
  /* { dg-final { cleanup-tree-dump "pre" } } */
--- 11,15 ----
    }  while (++j<k);
    return res;
  }
! /* { dg-final { scan-tree-dump-times "Eliminated: 2" 1 "pre"} } */
  /* { dg-final { cleanup-tree-dump "pre" } } */
Index: trunk/gcc/testsuite/g++.dg/tree-ssa/pr8781.C
===================================================================
*** trunk.orig/gcc/testsuite/g++.dg/tree-ssa/pr8781.C	2014-06-12 13:05:44.964651098 +0200
--- trunk/gcc/testsuite/g++.dg/tree-ssa/pr8781.C	2014-06-12 13:06:08.487649479 +0200
***************
*** 1,5 ****
  /* { dg-do compile } */
! /* { dg-options "-O -fno-tree-sra -fdump-tree-fre1-details" } */
  
  int f();
  
--- 1,5 ----
  /* { dg-do compile } */
! /* { dg-options "-O -fno-tree-sra -fdump-tree-fre1" } */
  
  int f();
  
*************** int x()
*** 24,28 ****
  
  /* We should optimize this to a direct call.  */
  
! /* { dg-final { scan-tree-dump "converting indirect call to function int f()" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
--- 24,28 ----
  
  /* We should optimize this to a direct call.  */
  
! /* { dg-final { scan-tree-dump-times "= f \\(\\);" 1 "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
Index: trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-39.c
===================================================================
*** trunk.orig/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-39.c	2014-06-12 13:05:44.964651098 +0200
--- trunk/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-39.c	2014-06-12 13:05:49.151650810 +0200
*************** int foo (int i)
*** 15,19 ****
  
  /* We should be able to value-number the final assignment to k to 1.  */
  
! /* { dg-final { scan-tree-dump "k_. = 1;" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */
--- 15,19 ----
  
  /* We should be able to value-number the final assignment to k to 1.  */
  
! /* { dg-final { scan-tree-dump "return 1;" "fre1" } } */
  /* { dg-final { cleanup-tree-dump "fre1" } } */


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]