CbC/CbC_gcc: gcc/tree-if-conv.c comparison

comparison gcc/tree-if-conv.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* If-conversion for vectorizer.
-Copyright (C) 2004-2018 Free Software Foundation, Inc.
+Copyright (C) 2004-2020 Free Software Foundation, Inc.
 Contributed by Devang Patel <dpatel@apple.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "tree-ssa-address.h"
 #include "dbgcnt.h"
 #include "tree-hash-traits.h"
 #include "varasm.h"
 #include "builtins.h"
-#include "params.h"
 #include "cfganal.h"
 #include "internal-fn.h"
 #include "fold-const.h"
+#include "tree-ssa-sccvn.h"
+#include "tree-cfgcleanup.h"
+#include "tree-ssa-dse.h"
 /* Only handle PHIs with no more arguments unless we are asked to by
 simd pragma.  */
 #define MAX_PHI_ARG_NUM \
-((unsigned) PARAM_VALUE (PARAM_MAX_TREE_IF_CONVERSION_PHI_ARGS))
+((unsigned) param_max_tree_if_conversion_phi_args)
 /* True if we've converted a statement that was only executed when some
 condition C was true, and if for correctness we need to predicate the
 statement to ensure that it is a no-op when C is false.  See
 predicate_statements for the kinds of predication we support.  */
 enum tree_code code1 = parse_predicate (c1, &op1a, &op1b);
 enum tree_code code2 = parse_predicate (c2, &op2a, &op2b);
 if (code1 != ERROR_MARK && code2 != ERROR_MARK)
 {
-tree t = maybe_fold_or_comparisons (code1, op1a, op1b,
+tree t = maybe_fold_or_comparisons (boolean_type_node, code1, op1a, op1b,
 					  code2, op2a, op2b);
 if (t)
 	return t;
 }
 the loop to be if-converted. Use predicate of cd-equivalent block
 for join bb if it exists: we call basic blocks bb1 and bb2
 cd-equivalent if they are executed under the same condition.  */
 static inline void
-add_to_predicate_list (struct loop *loop, basic_block bb, tree nc)
+add_to_predicate_list (class loop *loop, basic_block bb, tree nc)
 {
 tree bc, *tp;
 basic_block dom_bb;
 if (is_true_predicate (nc))
 /* Add the condition COND to the previous condition PREV_COND, and add
 this to the predicate list of the destination of edge E.  LOOP is
 the loop to be if-converted.  */
 static void
-add_to_dst_predicate_list (struct loop *loop, edge e,
+add_to_dst_predicate_list (class loop *loop, edge e,
 			   tree prev_cond, tree cond)
 {
 if (!flow_bb_inside_loop_p (loop, e->dest))
 return;
 }
 /* Return true if one of the successor edges of BB exits LOOP.  */
 static bool
-bb_with_exit_edge_p (struct loop *loop, basic_block bb)
+bb_with_exit_edge_p (class loop *loop, basic_block bb)
 {
 edge e;
 edge_iterator ei;
 FOR_EACH_EDGE (e, ei, bb->succs)
 and it belongs to basic block BB.  Note at this point, it is sure
 that PHI is if-convertible.  This function updates global variable
 ANY_COMPLICATED_PHI if PHI is complicated.  */
 static bool
-if_convertible_phi_p (struct loop *loop, basic_block bb, gphi *phi)
+if_convertible_phi_p (class loop *loop, basic_block bb, gphi *phi)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "-------------------------\n");
 print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
 {
 wi::overflow_type overflow;
 widest_int niter, valid_niter, delta, wi_step;
 tree ev, init, step;
 tree low, high;
-struct loop *loop = (struct loop*) dta;
+class loop *loop = (class loop*) dta;
 /* Only support within-bound access for array references.  */
 if (TREE_CODE (ref) != ARRAY_REF)
 return false;
 /* Return TRUE if ref is a within bound array reference.  */
 static bool
 ref_within_array_bound (gimple *stmt, tree ref)
 {
-struct loop *loop = loop_containing_stmt (stmt);
+class loop *loop = loop_containing_stmt (stmt);
 gcc_assert (loop != NULL);
 return for_each_index (&ref, idx_within_array_bound, loop);
 }
 /* an unconditionaly write won't trap if the base is written
 to unconditionally.  */
 if (base_master_dr
 	  && DR_BASE_W_UNCONDITIONALLY (*base_master_dr))
-	return PARAM_VALUE (PARAM_ALLOW_STORE_DATA_RACES);
+	return flag_store_data_races;
 /* or the base is known to be not readonly.  */
 else if (base_object_writable (DR_REF (a)))
-	return PARAM_VALUE (PARAM_ALLOW_STORE_DATA_RACES);
+	return flag_store_data_races;
 }
 return false;
 }
 EXIT_BB is the basic block containing the exit of the LOOP.  BB is
 inside LOOP.  */
 static bool
-if_convertible_bb_p (struct loop *loop, basic_block bb, basic_block exit_bb)
+if_convertible_bb_p (class loop *loop, basic_block bb, basic_block exit_bb)
 {
 edge e;
 edge_iterator ei;
 if (dump_file && (dump_flags & TDF_DETAILS))
 If-conversion suitable order is, breadth first sort (BFS) order
 with an additional constraint: select a block only if all its
 predecessors are already selected.  */
 static basic_block *
-get_loop_body_in_if_conv_order (const struct loop *loop)
+get_loop_body_in_if_conv_order (const class loop *loop)
 {
 basic_block *blocks, *blocks_in_bfs_order;
 basic_block bb;
 bitmap visited;
 unsigned int index = 0;
 }
 /* Build region by adding loop pre-header and post-header blocks.  */
 static vec<basic_block>
-build_region (struct loop *loop)
+build_region (class loop *loop)
 {
 vec<basic_block> region = vNULL;
 basic_block exit_bb = NULL;
 gcc_assert (ifc_bbs);
 /* Return true when LOOP is if-convertible.  This is a helper function
 for if_convertible_loop_p.  REFS and DDRS are initialized and freed
 in if_convertible_loop_p.  */
 static bool
-if_convertible_loop_p_1 (struct loop *loop, vec<data_reference_p> *refs)
+if_convertible_loop_p_1 (class loop *loop, vec<data_reference_p> *refs)
 {
 unsigned int i;
 basic_block exit_bb = NULL;
 vec<basic_block> region;
 - it has only one exit,
 - loop header is not the exit edge,
 - if its basic blocks and phi nodes are if convertible.  */
 static bool
-if_convertible_loop_p (struct loop *loop)
+if_convertible_loop_p (class loop *loop)
 {
 edge e;
 edge_iterator ei;
 bool res = false;
 vec<data_reference_p> refs;
 tree lhs, r_op1, r_op2;
 gimple *stmt;
 gimple *header_phi = NULL;
 enum tree_code reduction_op;
 basic_block bb = gimple_bb (phi);
-struct loop *loop = bb->loop_father;
+class loop *loop = bb->loop_father;
 edge latch_e = loop_latch_edge (loop);
 imm_use_iterator imm_iter;
 use_operand_p use_p;
 edge e;
 edge_iterator ei;
 /* Replaces in LOOP all the scalar phi nodes other than those in the
 LOOP->header block with conditional modify expressions.  */
 static void
-predicate_all_scalar_phis (struct loop *loop)
+predicate_all_scalar_phis (class loop *loop)
 {
 basic_block bb;
 unsigned int orig_loop_num_nodes = loop->num_nodes;
 unsigned int i;
 else
 {
 new_stmt
 	= gimple_build_call_internal (IFN_MASK_STORE, 4, addr, ptr,
 				      mask, rhs);
-gimple_set_vuse (new_stmt, gimple_vuse (stmt));
+gimple_move_vops (new_stmt, stmt);
-gimple_set_vdef (new_stmt, gimple_vdef (stmt));
-SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
 }
 gimple_call_set_nothrow (new_stmt, true);
 return new_stmt;
 }
 /* Combine all the basic blocks from LOOP into one or two super basic
 blocks.  Replace PHI nodes with conditional modify expressions.  */
 static void
-combine_blocks (struct loop *loop)
+combine_blocks (class loop *loop)
 {
 basic_block bb, exit_bb, merge_target_bb;
 unsigned int orig_loop_num_nodes = loop->num_nodes;
 unsigned int i;
 edge e;
 out using the current VUSE.  The def might be the one used
 	 after the loop.  */
 vphi = get_virtual_phi (bb);
 if (vphi)
 	{
+	  /* When there's just loads inside the loop a stray virtual
+	     PHI merging the uses can appear, update last_vdef from
+	     it.  */
+	  if (!last_vdef)
+	    last_vdef = gimple_phi_arg_def (vphi, 0);
 	  imm_use_iterator iter;
 	  use_operand_p use_p;
 	  gimple *use_stmt;
 	  FOR_EACH_IMM_USE_STMT (use_stmt, iter, gimple_phi_result (vphi))
 	    {
 	      FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 		SET_USE (use_p, last_vdef);
 	    }
+	  if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_phi_result (vphi)))
+	    SSA_NAME_OCCURS_IN_ABNORMAL_PHI (last_vdef) = 1;
 	  gsi = gsi_for_stmt (vphi);
 	  remove_phi_node (&gsi, true);
 	}
 /* Make stmts member of loop->header and clear range info from all stmts
 		  && USE_FROM_PTR (use_p) != last_vdef)
 		SET_USE (use_p, last_vdef);
 	      if (gimple_vdef (stmt))
 		last_vdef = gimple_vdef (stmt);
 	    }
+	  else
+	    /* If this is the first load we arrive at update last_vdef
+	       so we handle stray PHIs correctly.  */
+	    last_vdef = gimple_vuse (stmt);
 	  if (predicated[i])
 	    {
 	      ssa_op_iter i;
 	      tree op;
 	      FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF)
 	  FOR_EACH_IMM_USE_STMT (use_stmt, iter, gimple_phi_result (vphi))
 	    {
 	      FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 		SET_USE (use_p, last_vdef);
 	    }
+	  if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_phi_result (vphi)))
+	    SSA_NAME_OCCURS_IN_ABNORMAL_PHI (last_vdef) = 1;
 	  gimple_stmt_iterator gsi = gsi_for_stmt (vphi);
 	  remove_phi_node (&gsi, true);
 	}
 if (can_merge_blocks_p (loop->header, exit_bb))
 Note that this function intentionally invalidates profile.  Both edges
 out of LOOP_VECTORIZED must have 100% probability so the profile remains
 consistent after the condition is folded in the vectorizer.  */
-static struct loop *
+static class loop *
-version_loop_for_if_conversion (struct loop *loop)
+version_loop_for_if_conversion (class loop *loop, vec<gimple *> *preds)
 {
 basic_block cond_bb;
 tree cond = make_ssa_name (boolean_type_node);
-struct loop *new_loop;
+class loop *new_loop;
 gimple *g;
 gimple_stmt_iterator gsi;
 unsigned int save_length;
 g = gimple_build_call_internal (IFN_LOOP_VECTORIZED, 2,
 new_loop->dont_vectorize = true;
 new_loop->force_vectorize = false;
 gsi = gsi_last_bb (cond_bb);
 gimple_call_set_arg (g, 1, build_int_cst (integer_type_node, new_loop->num));
+if (preds)
+preds->safe_push (g);
 gsi_insert_before (&gsi, g, GSI_SAME_STMT);
 update_ssa (TODO_update_ssa);
 return new_loop;
 }
 predecessor.
 - The loop exit block has a single predecessor, which is the
 inner loop's exit block.  */
 static bool
-versionable_outer_loop_p (struct loop *loop)
+versionable_outer_loop_p (class loop *loop)
 {
 if (!loop_outer (loop)
 || loop->dont_vectorize
 || !loop->inner
 || loop->inner->next
 - LOOP has PHI with more than MAX_PHI_ARG_NUM arguments.
 Last restriction is valid only if AGGRESSIVE_IF_CONV is false.  */
 static bool
-ifcvt_split_critical_edges (struct loop *loop, bool aggressive_if_conv)
+ifcvt_split_critical_edges (class loop *loop, bool aggressive_if_conv)
 {
 basic_block *body;
 basic_block bb;
 unsigned int num = loop->num_nodes;
 unsigned int i;
 /* Delete redundant statements produced by predication which prevents
 loop vectorization.  */
 static void
-ifcvt_local_dce (basic_block bb)
+ifcvt_local_dce (class loop *loop)
 {
 gimple *stmt;
 gimple *stmt1;
 gimple *phi;
 gimple_stmt_iterator gsi;
 FOR_EACH_VEC_ELT (redundant_ssa_names, i, name_pair)
 replace_uses_by (name_pair->first, name_pair->second);
 redundant_ssa_names.release ();
+/* The loop has a single BB only.  */
+basic_block bb = loop->header;
+tree latch_vdef = NULL_TREE;
 worklist.create (64);
 /* Consider all phi as live statements.  */
 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 {
 phi = gsi_stmt (gsi);
 gimple_set_plf (phi, GF_PLF_2, true);
 worklist.safe_push (phi);
+if (virtual_operand_p (gimple_phi_result (phi)))
+	latch_vdef = PHI_ARG_DEF_FROM_EDGE (phi, loop_latch_edge (loop));
 }
 /* Consider load/store statements, CALL and COND as live.  */
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 {
 stmt = gsi_stmt (gsi);
 /* Delete dead statements.  */
 gsi = gsi_start_bb (bb);
 while (!gsi_end_p (gsi))
 {
 stmt = gsi_stmt (gsi);
+if (gimple_store_p (stmt))
+	{
+	  tree lhs = gimple_get_lhs (stmt);
+	  ao_ref write;
+	  ao_ref_init (&write, lhs);
+	  if (dse_classify_store (&write, stmt, false, NULL, NULL, latch_vdef)
+	      == DSE_STORE_DEAD)
+	    delete_dead_or_redundant_assignment (&gsi, "dead");
+	  else
+	    gsi_next (&gsi);
+	  continue;
+	}
 if (gimple_plf (stmt, GF_PLF_2))
 	{
 	  gsi_next (&gsi);
 	  continue;
 	}
 /* If-convert LOOP when it is legal.  For the moment this pass has no
 profitability analysis.  Returns non-zero todo flags when something
 changed.  */
 unsigned int
-tree_if_conversion (struct loop *loop)
+tree_if_conversion (class loop *loop, vec<gimple *> *preds)
 {
 unsigned int todo = 0;
 bool aggressive_if_conv;
-struct loop *rloop;
+class loop *rloop;
+bitmap exit_bbs;
 again:
 rloop = NULL;
 ifc_bbs = NULL;
 need_to_predicate = false;
 marked with simd pragma.  When that's the case, we try to if-convert
 loop containing PHIs with more than MAX_PHI_ARG_NUM arguments.  */
 aggressive_if_conv = loop->force_vectorize;
 if (!aggressive_if_conv)
 {
-struct loop *outer_loop = loop_outer (loop);
+class loop *outer_loop = loop_outer (loop);
 if (outer_loop && outer_loop->force_vectorize)
 	aggressive_if_conv = true;
 }
 if (!ifcvt_split_critical_edges (loop, aggressive_if_conv))
 still if-convert the original inner loop.  */
 if (need_to_predicate
 || any_complicated_phi
 || flag_tree_loop_if_convert != 1)
 {
-struct loop *vloop
+class loop *vloop
 	= (versionable_outer_loop_p (loop_outer (loop))
 	   ? loop_outer (loop) : loop);
-struct loop *nloop = version_loop_for_if_conversion (vloop);
+class loop *nloop = version_loop_for_if_conversion (vloop, preds);
 if (nloop == NULL)
 	goto cleanup;
 if (vloop != loop)
 	{
 	  /* If versionable_outer_loop_p decided to version the
 /* Now all statements are if-convertible.  Combine all the basic
 blocks into one huge basic block doing the if-conversion
 on-the-fly.  */
 combine_blocks (loop);
+/* Perform local CSE, this esp. helps the vectorizer analysis if loads
+and stores are involved.  CSE only the loop body, not the entry
+PHIs, those are to be kept in sync with the non-if-converted copy.
+???  We'll still keep dead stores though.  */
+exit_bbs = BITMAP_ALLOC (NULL);
+bitmap_set_bit (exit_bbs, single_exit (loop)->dest->index);
+bitmap_set_bit (exit_bbs, loop->latch->index);
+todo |= do_rpo_vn (cfun, loop_preheader_edge (loop), exit_bbs);
 /* Delete dead predicate computations.  */
-ifcvt_local_dce (loop->header);
+ifcvt_local_dce (loop);
+BITMAP_FREE (exit_bbs);
 todo |= TODO_cleanup_cfg;
 cleanup:
 if (ifc_bbs)
 }
 unsigned int
 pass_if_conversion::execute (function *fun)
 {
-struct loop *loop;
+class loop *loop;
 unsigned todo = 0;
 if (number_of_loops (fun) <= 1)
 return 0;
+auto_vec<gimple *> preds;
 FOR_EACH_LOOP (loop, 0)
 if (flag_tree_loop_if_convert == 1
 	|| ((flag_tree_loop_vectorize || loop->force_vectorize)
 	    && !loop->dont_vectorize))
-todo |= tree_if_conversion (loop);
+todo |= tree_if_conversion (loop, &preds);
 if (todo)
 {
 free_numbers_of_iterations_estimates (fun);
 scev_reset ();
 basic_block bb;
 FOR_EACH_BB_FN (bb, fun)
 	gcc_assert (!bb->aux);
 }
-return todo;
+/* Perform IL update now, it might elide some loops.  */
+if (todo & TODO_cleanup_cfg)
+{
+cleanup_tree_cfg ();
+if (need_ssa_update_p (fun))
+	todo |= TODO_update_ssa;
+}
+if (todo & TODO_update_ssa_any)
+update_ssa (todo & TODO_update_ssa_any);
+/* If if-conversion elided the loop fall back to the original one.  */
+for (unsigned i = 0; i < preds.length (); ++i)
+{
+gimple *g = preds[i];
+if (!gimple_bb (g))
+	continue;
+unsigned ifcvt_loop = tree_to_uhwi (gimple_call_arg (g, 0));
+if (!get_loop (fun, ifcvt_loop))
+	{
+	  if (dump_file)
+	    fprintf (dump_file, "If-converted loop vanished\n");
+	  fold_loop_internal_call (g, boolean_false_node);
+	}
+}
+return 0;
 }
 } // anon namespace
 gimple_opt_pass *

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-if-conv.c @ 145:1830386684a0