CbC/CbC_gcc: gcc/tree-ssa-loop-prefetch.c comparison

comparison gcc/tree-ssa-loop-prefetch.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Array prefetching.
-Copyright (C) 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 2005-2017 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
+#include "target.h"
+#include "rtl.h"
 #include "tree.h"
-#include "tm_p.h"
+#include "gimple.h"
-#include "basic-block.h"
+#include "predict.h"
-#include "output.h"
+#include "tree-pass.h"
+#include "gimple-ssa.h"
+#include "optabs-query.h"
 #include "tree-pretty-print.h"
-#include "tree-flow.h"
+#include "fold-const.h"
-#include "tree-dump.h"
+#include "stor-layout.h"
-#include "timevar.h"
+#include "gimplify.h"
+#include "gimple-iterator.h"
+#include "gimplify-me.h"
+#include "tree-ssa-loop-ivopts.h"
+#include "tree-ssa-loop-manip.h"
+#include "tree-ssa-loop-niter.h"
+#include "tree-ssa-loop.h"
+#include "ssa.h"
+#include "tree-into-ssa.h"
 #include "cfgloop.h"
-#include "tree-pass.h"
-#include "insn-config.h"
-#include "recog.h"
-#include "hashtab.h"
-#include "tree-chrec.h"
 #include "tree-scalar-evolution.h"
-#include "diagnostic-core.h"
 #include "params.h"
 #include "langhooks.h"
 #include "tree-inline.h"
 #include "tree-data-ref.h"
+#include "diagnostic-core.h"
+#include "dbgcnt.h"
-/* FIXME: Needed for optabs, but this should all be moved to a TBD interface
-between the GIMPLE and RTL worlds.  */
-#include "expr.h"
-#include "optabs.h"
 /* This pass inserts prefetch instructions to optimize cache usage during
 accesses to arrays in loops.  It processes loops sequentially and:
 1) Gathers all memory references in the single loop.
 #ifndef ACCEPTABLE_MISS_RATE
 #define ACCEPTABLE_MISS_RATE 50
 #endif
-#ifndef HAVE_prefetch
-#define HAVE_prefetch 0
-#endif
 #define L1_CACHE_SIZE_BYTES ((unsigned) (L1_CACHE_SIZE * 1024))
 #define L2_CACHE_SIZE_BYTES ((unsigned) (L2_CACHE_SIZE * 1024))
 /* We consider a memory access nontemporal if it is not reused sooner than
 after L2_CACHE_SIZE_BYTES of memory are accessed.  However, we ignore
 {
 tree base;			/* Base of the reference.  */
 tree step;			/* Step of the reference.  */
 struct mem_ref *refs;		/* References in the group.  */
 struct mem_ref_group *next;	/* Next group of references.  */
+unsigned int uid;		/* Group UID, used only for debugging.  */
 };
 /* Assigned to PREFETCH_BEFORE when all iterations are to be prefetched.  */
-#define PREFETCH_ALL		(~(unsigned HOST_WIDE_INT) 0)
+#define PREFETCH_ALL		HOST_WIDE_INT_M1U
 /* Do not generate a prefetch if the unroll factor is significantly less
 than what is required by the prefetch.  This is to avoid redundant
 prefetches.  For example, when prefetch_mod is 16 and unroll_factor is
 2, prefetching requires unrolling the loop 16 times, but
 /* The memory reference.  */
 struct mem_ref
 {
-gimple stmt;			/* Statement in that the reference appears.  */
+gimple *stmt;			/* Statement in that the reference appears.  */
 tree mem;			/* The reference.  */
 HOST_WIDE_INT delta;		/* Constant offset of the reference.  */
 struct mem_ref_group *group;	/* The group of references it belongs to.  */
 unsigned HOST_WIDE_INT prefetch_mod;
 				/* Prefetch only each PREFETCH_MOD-th
 				/* Prefetch only first PREFETCH_BEFORE
 				   iterations.  */
 unsigned reuse_distance;	/* The amount of data accessed before the first
 				   reuse of this value.  */
 struct mem_ref *next;		/* The next reference in the group.  */
+unsigned int uid;		/* Ref UID, used only for debugging.  */
 unsigned write_p : 1;		/* Is it a write?  */
 unsigned independent_p : 1;	/* True if the reference is independent on
 				   all other references inside the loop.  */
 unsigned issue_prefetch_p : 1;	/* Should we really issue the prefetch?  */
 unsigned storent_p : 1;	/* True if we changed the store to a
 				   nontemporal one.  */
 };
+/* Dumps information about memory reference */
+static void
+dump_mem_details (FILE *file, tree base, tree step,
+	    HOST_WIDE_INT delta, bool write_p)
+{
+fprintf (file, "(base ");
+print_generic_expr (file, base, TDF_SLIM);
+fprintf (file, ", step ");
+if (cst_and_fits_in_hwi (step))
+fprintf (file, HOST_WIDE_INT_PRINT_DEC, int_cst_value (step));
+else
+print_generic_expr (file, step, TDF_SLIM);
+fprintf (file, ")\n");
+fprintf (file, "  delta " HOST_WIDE_INT_PRINT_DEC "\n", delta);
+fprintf (file, "  %s\n\n", write_p ? "write" : "read");
+}
 /* Dumps information about reference REF to FILE.  */
 static void
 dump_mem_ref (FILE *file, struct mem_ref *ref)
 {
-fprintf (file, "Reference %p:\n", (void *) ref);
+fprintf (file, "reference %u:%u (", ref->group->uid, ref->uid);
+print_generic_expr (file, ref->mem, TDF_SLIM);
-fprintf (file, "  group %p (base ", (void *) ref->group);
-print_generic_expr (file, ref->group->base, TDF_SLIM);
-fprintf (file, ", step ");
-if (cst_and_fits_in_hwi (ref->group->step))
-fprintf (file, HOST_WIDE_INT_PRINT_DEC, int_cst_value (ref->group->step));
-else
-print_generic_expr (file, ref->group->step, TDF_TREE);
 fprintf (file, ")\n");
-fprintf (file, "  delta ");
-fprintf (file, HOST_WIDE_INT_PRINT_DEC, ref->delta);
-fprintf (file, "\n");
-fprintf (file, "  %s\n", ref->write_p ? "write" : "read");
-fprintf (file, "\n");
 }
 /* Finds a group with BASE and STEP in GROUPS, or creates one if it does not
 exist.  */
 static struct mem_ref_group *
 find_or_create_group (struct mem_ref_group **groups, tree base, tree step)
 {
+/* Global count for setting struct mem_ref_group->uid.  */
+static unsigned int last_mem_ref_group_uid = 0;
 struct mem_ref_group *group;
 for (; *groups; groups = &(*groups)->next)
 {
 if (operand_equal_p ((*groups)->step, step, 0)
 	  && operand_equal_p ((*groups)->base, base, 0))
 	return *groups;
 /* If step is an integer constant, keep the list of groups sorted
 by decreasing step.  */
 if (cst_and_fits_in_hwi ((*groups)->step) && cst_and_fits_in_hwi (step)
-&& int_cst_value ((*groups)->step) < int_cst_value (step))
+	  && int_cst_value ((*groups)->step) < int_cst_value (step))
 	break;
 }
 group = XNEW (struct mem_ref_group);
 group->base = base;
 group->step = step;
 group->refs = NULL;
+group->uid = ++last_mem_ref_group_uid;
 group->next = *groups;
 *groups = group;
 return group;
 }
 /* Records a memory reference MEM in GROUP with offset DELTA and write status
 WRITE_P.  The reference occurs in statement STMT.  */
 static void
-record_ref (struct mem_ref_group *group, gimple stmt, tree mem,
+record_ref (struct mem_ref_group *group, gimple *stmt, tree mem,
 	    HOST_WIDE_INT delta, bool write_p)
 {
+unsigned int last_mem_ref_uid = 0;
 struct mem_ref **aref;
 /* Do not record the same address twice.  */
 for (aref = &group->refs; *aref; aref = &(*aref)->next)
 {
+last_mem_ref_uid = (*aref)->uid;
 /* It does not have to be possible for write reference to reuse the read
 	 prefetch, or vice versa.  */
 if (!WRITE_CAN_USE_READ_PREFETCH
 	  && write_p
 	  && !(*aref)->write_p)
 (*aref)->issue_prefetch_p = false;
 (*aref)->group = group;
 (*aref)->next = NULL;
 (*aref)->independent_p = false;
 (*aref)->storent_p = false;
+(*aref)->uid = last_mem_ref_uid + 1;
 if (dump_file && (dump_flags & TDF_DETAILS))
-dump_mem_ref (dump_file, *aref);
+{
+dump_mem_ref (dump_file, *aref);
+fprintf (dump_file, "  group %u ", group->uid);
+dump_mem_details (dump_file, group->base, group->step, delta,
+			write_p);
+}
 }
 /* Release memory references in GROUPS.  */
 static void
 /* A structure used to pass arguments to idx_analyze_ref.  */
 struct ar_data
 {
 struct loop *loop;			/* Loop of the reference.  */
-gimple stmt;				/* Statement of the reference.  */
+gimple *stmt;				/* Statement of the reference.  */
 tree *step;				/* Step of the memory reference.  */
 HOST_WIDE_INT *delta;			/* Offset of the memory reference.  */
 };
 /* Analyzes a single INDEX of a memory reference to obtain information
 references from REF_P.  */
 static bool
 analyze_ref (struct loop *loop, tree *ref_p, tree *base,
 	     tree *step, HOST_WIDE_INT *delta,
-	     gimple stmt)
+	     gimple *stmt)
 {
 struct ar_data ar_data;
 tree off;
 HOST_WIDE_INT bit_offset;
 tree ref = *ref_p;
 LOOP in statement STMT and it is write if WRITE_P.  Returns true if the
 reference was recorded, false otherwise.  */
 static bool
 gather_memory_references_ref (struct loop *loop, struct mem_ref_group **refs,
-			      tree ref, bool write_p, gimple stmt)
+			      tree ref, bool write_p, gimple *stmt)
 {
 tree base, step;
 HOST_WIDE_INT delta;
 struct mem_ref_group *agrp;
 /* Stop if the address of BASE could not be taken.  */
 if (may_be_nonaddressable_p (base))
 return false;
-/* Limit non-constant step prefetching only to the innermost loops.  */
+/* Limit non-constant step prefetching only to the innermost loops and
-if (!cst_and_fits_in_hwi (step) && loop->inner != NULL)
+only when the step is loop invariant in the entire loop nest. */
-return false;
+if (!cst_and_fits_in_hwi (step))
+{
+if (loop->inner != NULL)
+{
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "Memory expression %p\n",(void *) ref );
+	      print_generic_expr (dump_file, ref, TDF_SLIM);
+	      fprintf (dump_file,":");
+dump_mem_details (dump_file, base, step, delta, write_p);
+fprintf (dump_file,
+"Ignoring %p, non-constant step prefetching is "
+"limited to inner most loops \n",
+(void *) ref);
+}
+return false;
+}
+else
+{
+if (!expr_invariant_in_loop_p (loop_outermost (loop), step))
+{
+if (dump_file && (dump_flags & TDF_DETAILS))
+{
+fprintf (dump_file, "Memory expression %p\n",(void *) ref );
+		print_generic_expr (dump_file, ref, TDF_SLIM);
+fprintf (dump_file,":");
+dump_mem_details (dump_file, base, step, delta, write_p);
+fprintf (dump_file,
+"Not prefetching, ignoring %p due to "
+"loop variant step\n",
+(void *) ref);
+}
+return false;
+}
+}
+}
 /* Now we know that REF = &BASE + STEP * iter + DELTA, where DELTA and STEP
 are integer constants.  */
 agrp = find_or_create_group (refs, base, step);
 record_ref (agrp, stmt, ref, delta, write_p);
 {
 basic_block *body = get_loop_body_in_dom_order (loop);
 basic_block bb;
 unsigned i;
 gimple_stmt_iterator bsi;
-gimple stmt;
+gimple *stmt;
 tree lhs, rhs;
 struct mem_ref_group *refs = NULL;
 *no_other_refs = true;
 *ref_count = 0;
 		  || (is_gimple_call (stmt)
 		      && !(gimple_call_flags (stmt) & ECF_CONST)))
 		*no_other_refs = false;
 	      continue;
 	    }
+	  if (! gimple_vuse (stmt))
+	    continue;
 	  lhs = gimple_assign_lhs (stmt);
 	  rhs = gimple_assign_rhs1 (stmt);
 	  if (REFERENCE_CLASS_P (rhs))
 ddown (HOST_WIDE_INT x, unsigned HOST_WIDE_INT by)
 {
 gcc_assert (by > 0);
 if (x >= 0)
-return x / by;
+return x / (HOST_WIDE_INT) by;
 else
-return (x + by - 1) / by;
+return (x + (HOST_WIDE_INT) by - 1) / (HOST_WIDE_INT) by;
 }
 /* Given a CACHE_LINE_SIZE and two inductive memory references
 with a common STEP greater than CACHE_LINE_SIZE and an address
 difference DELTA, compute the probability that they will fall
 /* The accesses are sure to meet.  Let us check when.  */
 hit_from = ddown (delta_b, PREFETCH_BLOCK) * PREFETCH_BLOCK;
 prefetch_before = (hit_from - delta_r + step - 1) / step;
 /* Do not reduce prefetch_before if we meet beyond cache size.  */
-if (prefetch_before > (unsigned) abs (L2_CACHE_SIZE_BYTES / step))
+if (prefetch_before > absu_hwi (L2_CACHE_SIZE_BYTES / step))
 prefetch_before = PREFETCH_ALL;
 if (prefetch_before < ref->prefetch_before)
 	ref->prefetch_before = prefetch_before;
 return;
 {
 prune_ref_by_reuse (ref_pruned, group->refs);
 if (dump_file && (dump_flags & TDF_DETAILS))
 	{
-	  fprintf (dump_file, "Reference %p:", (void *) ref_pruned);
+	  dump_mem_ref (dump_file, ref_pruned);
 	  if (ref_pruned->prefetch_before == PREFETCH_ALL
 	      && ref_pruned->prefetch_mod == 1)
 	    fprintf (dump_file, " no restrictions");
 	  else if (ref_pruned->prefetch_before == 0)
 /* For now do not issue prefetches for only first few of the
 iterations.  */
 if (ref->prefetch_before != PREFETCH_ALL)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
-fprintf (dump_file, "Ignoring %p due to prefetch_before\n",
+fprintf (dump_file, "Ignoring reference %u:%u due to prefetch_before\n",
-		 (void *) ref);
+		 ref->group->uid, ref->uid);
 return false;
 }
 /* Do not prefetch nontemporal stores.  */
 if (ref->storent_p)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
-fprintf (dump_file, "Ignoring nontemporal store %p\n", (void *) ref);
+fprintf (dump_file, "Ignoring nontemporal store reference %u:%u\n", ref->group->uid, ref->uid);
 return false;
 }
 return true;
 }
 	/* If more than half of the prefetches would be lost anyway, do not
 	   issue the prefetch.  */
 	if (2 * remaining_prefetch_slots < prefetch_slots)
 	  continue;
+	/* Stop prefetching if debug counter is activated.  */
+	if (!dbg_cnt (prefetch))
+	  continue;
 	ref->issue_prefetch_p = true;
+	if (dump_file && (dump_flags & TDF_DETAILS))
+	  fprintf (dump_file, "Decided to issue prefetch for reference %u:%u\n",
+		   ref->group->uid, ref->uid);
 	if (remaining_prefetch_slots <= prefetch_slots)
 	  return true;
 	remaining_prefetch_slots -= prefetch_slots;
 	any = true;
 static void
 issue_prefetch_ref (struct mem_ref *ref, unsigned unroll_factor, unsigned ahead)
 {
 HOST_WIDE_INT delta;
 tree addr, addr_base, write_p, local, forward;
-gimple prefetch;
+gcall *prefetch;
 gimple_stmt_iterator bsi;
 unsigned n_prefetches, ap;
 bool nontemporal = ref->reuse_distance >= L2_CACHE_SIZE_BYTES;
 if (dump_file && (dump_flags & TDF_DETAILS))
-fprintf (dump_file, "Issued%s prefetch for %p.\n",
+fprintf (dump_file, "Issued%s prefetch for reference %u:%u.\n",
 	     nontemporal ? " nontemporal" : "",
-	     (void *) ref);
+	     ref->group->uid, ref->uid);
 bsi = gsi_for_stmt (ref->stmt);
 n_prefetches = ((unroll_factor + ref->prefetch_mod - 1)
 		  / ref->prefetch_mod);
 if (cst_and_fits_in_hwi (ref->group->step))
 {
 /* Determine the address to prefetch.  */
 delta = (ahead + ap * ref->prefetch_mod) *
 		   int_cst_value (ref->group->step);
-addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
+addr = fold_build_pointer_plus_hwi (addr_base, delta);
-addr_base, size_int (delta));
+addr = force_gimple_operand_gsi (&bsi, unshare_expr (addr), true,
-addr = force_gimple_operand_gsi (&bsi, unshare_expr (addr), true, NULL,
+					   NULL, true, GSI_SAME_STMT);
-true, GSI_SAME_STMT);
 }
 else
 {
 /* The step size is non-constant but loop-invariant.  We use the
 heuristic to simply prefetch ahead iterations ahead.  */
 forward = fold_build2 (MULT_EXPR, sizetype,
 fold_convert (sizetype, ref->group->step),
 fold_convert (sizetype, size_int (ahead)));
-addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, addr_base,
+addr = fold_build_pointer_plus (addr_base, forward);
-			      forward);
 addr = force_gimple_operand_gsi (&bsi, unshare_expr (addr), true,
 					   NULL, true, GSI_SAME_STMT);
 }
+if (addr_base != addr
+	  && TREE_CODE (addr_base) == SSA_NAME
+	  && TREE_CODE (addr) == SSA_NAME)
+	{
+	  duplicate_ssa_name_ptr_info (addr, SSA_NAME_PTR_INFO (addr_base));
+	  /* As this isn't a plain copy we have to reset alignment
+	     information.  */
+	  if (SSA_NAME_PTR_INFO (addr))
+	    mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (addr));
+	}
 /* Create the prefetch instruction.  */
-prefetch = gimple_build_call (built_in_decls[BUILT_IN_PREFETCH],
+prefetch = gimple_build_call (builtin_decl_explicit (BUILT_IN_PREFETCH),
 				    3, addr, write_p, local);
 gsi_insert_before (&bsi, prefetch, GSI_SAME_STMT);
 }
 }
 can be used.  */
 static bool
 nontemporal_store_p (struct mem_ref *ref)
 {
-enum machine_mode mode;
+machine_mode mode;
 enum insn_code code;
 /* REF must be a write that is not reused.  We require it to be independent
 on all other memory references in the loop, as the nontemporal stores may
 be reordered with respect to other memory references.  */
 {
 if (!nontemporal_store_p (ref))
 return false;
 if (dump_file && (dump_flags & TDF_DETAILS))
-fprintf (dump_file, "Marked reference %p as a nontemporal store.\n",
+fprintf (dump_file, "Marked reference %u:%u as a nontemporal store.\n",
-	     (void *) ref);
+	     ref->group->uid, ref->uid);
 gimple_assign_set_nontemporal_move (ref->stmt, true);
 ref->storent_p = true;
 return true;
 /* Issue a memory fence instruction after LOOP.  */
 static void
 emit_mfence_after_loop (struct loop *loop)
 {
-VEC (edge, heap) *exits = get_loop_exit_edges (loop);
+vec<edge> exits = get_loop_exit_edges (loop);
 edge exit;
-gimple call;
+gcall *call;
 gimple_stmt_iterator bsi;
 unsigned i;
-FOR_EACH_VEC_ELT (edge, exits, i, exit)
+FOR_EACH_VEC_ELT (exits, i, exit)
 {
 call = gimple_build_call (FENCE_FOLLOWING_MOVNT, 0);
 if (!single_pred_p (exit->dest)
 	  /* If possible, we prefer not to insert the fence on other paths
 	  && !(exit->flags & EDGE_ABNORMAL))
 	split_loop_exit_edge (exit);
 bsi = gsi_after_labels (exit->dest);
 gsi_insert_before (&bsi, call, GSI_NEW_STMT);
-mark_virtual_ops_for_renaming (call);
+}
-}
+exits.release ();
-VEC_free (edge, heap, exits);
 update_ssa (TODO_update_ssa_only_virtuals);
 }
 /* Returns true if we can use storent in loop, false otherwise.  */
 /* If we must issue a mfence insn after using storent, check that there
 is a suitable place for it at each of the loop exits.  */
 if (FENCE_FOLLOWING_MOVNT != NULL_TREE)
 {
-VEC (edge, heap) *exits = get_loop_exit_edges (loop);
+vec<edge> exits = get_loop_exit_edges (loop);
 unsigned i;
 edge exit;
-FOR_EACH_VEC_ELT (edge, exits, i, exit)
+FOR_EACH_VEC_ELT (exits, i, exit)
 	if ((exit->flags & EDGE_ABNORMAL)
-	    && exit->dest == EXIT_BLOCK_PTR)
+	    && exit->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
 	  ret = false;
-VEC_free (edge, heap, exits);
+exits.release ();
 }
 return ret;
 }
 return true;
 }
 /* Determine the coefficient by that unroll LOOP, from the information
 contained in the list of memory references REFS.  Description of
-umber of iterations of LOOP is stored to DESC.  NINSNS is the number of
+number of iterations of LOOP is stored to DESC.  NINSNS is the number of
 insns of the LOOP.  EST_NITER is the estimated number of iterations of
 the loop, or -1 if no estimate is available.  */
 static unsigned
 determine_unroll_factor (struct loop *loop, struct mem_ref_group *refs,
 access_fn = CHREC_LEFT (access_fn);
 if ((unsigned) loop_depth (aloop) <= min_depth)
 	continue;
-if (host_integerp (step, 0))
+if (tree_fits_shwi_p (step))
-	astep = tree_low_cst (step, 0);
+	astep = tree_to_shwi (step);
 else
 	astep = L1_CACHE_LINE_SIZE;
 strides[n - 1 - loop_depth (loop) + loop_depth (aloop)] += astep * stride;
 self_reuse_distance (data_reference_p dr, unsigned *loop_sizes, unsigned n,
 		     struct loop *loop)
 {
 tree stride, access_fn;
 HOST_WIDE_INT *strides, astride;
-VEC (tree, heap) *access_fns;
+vec<tree> access_fns;
 tree ref = DR_REF (dr);
 unsigned i, ret = ~0u;
 /* In the following example:
 the innermost loop in that the stride is less than cache size.  */
 strides = XCNEWVEC (HOST_WIDE_INT, n);
 access_fns = DR_ACCESS_FNS (dr);
-FOR_EACH_VEC_ELT (tree, access_fns, i, access_fn)
+FOR_EACH_VEC_ELT (access_fns, i, access_fn)
 {
 /* Keep track of the reference corresponding to the subscript, so that we
 	 know its stride.  */
 while (handled_component_p (ref) && TREE_CODE (ref) != ARRAY_REF)
 	ref = TREE_OPERAND (ref, 0);
 if (TREE_CODE (ref) == ARRAY_REF)
 	{
 	  stride = TYPE_SIZE_UNIT (TREE_TYPE (ref));
-	  if (host_integerp (stride, 1))
+	  if (tree_fits_uhwi_p (stride))
-	    astride = tree_low_cst (stride, 1);
+	    astride = tree_to_uhwi (stride);
 	  else
 	    astride = L1_CACHE_LINE_SIZE;
 	  ref = TREE_OPERAND (ref, 0);
 	}
 return ret;
 }
 /* Determines the distance till the first reuse of each reference in REFS
 in the loop nest of LOOP.  NO_OTHER_REFS is true if there are no other
-memory references in the loop.  */
+memory references in the loop.  Return false if the analysis fails.  */
-static void
+static bool
 determine_loop_nest_reuse (struct loop *loop, struct mem_ref_group *refs,
 			   bool no_other_refs)
 {
 struct loop *nest, *aloop;
-VEC (data_reference_p, heap) *datarefs = NULL;
+vec<data_reference_p> datarefs = vNULL;
-VEC (ddr_p, heap) *dependences = NULL;
+vec<ddr_p> dependences = vNULL;
 struct mem_ref_group *gr;
 struct mem_ref *ref, *refb;
-VEC (loop_p, heap) *vloops = NULL;
+auto_vec<loop_p> vloops;
 unsigned *loop_data_size;
 unsigned i, j, n;
 unsigned volume, dist, adist;
 HOST_WIDE_INT vol;
 data_reference_p dr;
 ddr_p dep;
 if (loop->inner)
-return;
+return true;
 /* Find the outermost loop of the loop nest of loop (we require that
 there are no sibling loops inside the nest).  */
 nest = loop;
 while (1)
 /* For each loop, determine the amount of data accessed in each iteration.
 We use this to estimate whether the reference is evicted from the
 cache before its reuse.  */
 find_loop_nest (nest, &vloops);
-n = VEC_length (loop_p, vloops);
+n = vloops.length ();
 loop_data_size = XNEWVEC (unsigned, n);
 volume = volume_of_references (refs);
 i = n;
 while (i-- != 0)
 {
 /* Bound the volume by the L2 cache size, since above this bound,
 	 all dependence distances are equivalent.  */
 if (volume > L2_CACHE_SIZE_BYTES)
 	continue;
-aloop = VEC_index (loop_p, vloops, i);
+aloop = vloops[i];
-vol = estimated_loop_iterations_int (aloop, false);
+vol = estimated_stmt_executions_int (aloop);
-if (vol < 0)
+if (vol == -1)
 	vol = expected_loop_iterations (aloop);
 volume *= vol;
 }
 /* Prepare the references in the form suitable for data dependence
 are used just as a heuristics to estimate temporality of the
 references, hence we do not need to worry about correctness).  */
 for (gr = refs; gr; gr = gr->next)
 for (ref = gr->refs; ref; ref = ref->next)
 {
-	dr = create_data_ref (nest, loop_containing_stmt (ref->stmt),
+	dr = create_data_ref (loop_preheader_edge (nest),
-			      ref->mem, ref->stmt, !ref->write_p);
+			      loop_containing_stmt (ref->stmt),
+			      ref->mem, ref->stmt, !ref->write_p, false);
 	if (dr)
 	  {
 	    ref->reuse_distance = volume;
 	    dr->aux = ref;
-	    VEC_safe_push (data_reference_p, heap, datarefs, dr);
+	    datarefs.safe_push (dr);
 	  }
 	else
 	  no_other_refs = false;
 }
-FOR_EACH_VEC_ELT (data_reference_p, datarefs, i, dr)
+FOR_EACH_VEC_ELT (datarefs, i, dr)
 {
 dist = self_reuse_distance (dr, loop_data_size, n, loop);
 ref = (struct mem_ref *) dr->aux;
 if (ref->reuse_distance > dist)
 	ref->reuse_distance = dist;
 if (no_other_refs)
 	ref->independent_p = true;
 }
-compute_all_dependences (datarefs, &dependences, vloops, true);
+if (!compute_all_dependences (datarefs, &dependences, vloops, true))
+return false;
-FOR_EACH_VEC_ELT (ddr_p, dependences, i, dep)
+FOR_EACH_VEC_ELT (dependences, i, dep)
 {
 if (DDR_ARE_DEPENDENT (dep) == chrec_known)
 	continue;
 ref = (struct mem_ref *) DDR_A (dep)->aux;
 refb = (struct mem_ref *) DDR_B (dep)->aux;
 if (DDR_ARE_DEPENDENT (dep) == chrec_dont_know
+	  || DDR_COULD_BE_INDEPENDENT_P (dep)
 	  || DDR_NUM_DIST_VECTS (dep) == 0)
 	{
 	  /* If the dependence cannot be analyzed, assume that there might be
 	     a reuse.  */
 	  dist = 0;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "Reuse distances:\n");
 for (gr = refs; gr; gr = gr->next)
 	for (ref = gr->refs; ref; ref = ref->next)
-	  fprintf (dump_file, " ref %p distance %u\n",
+	  fprintf (dump_file, " reference %u:%u distance %u\n",
-		   (void *) ref, ref->reuse_distance);
+		   ref->group->uid, ref->uid, ref->reuse_distance);
 }
+return true;
 }
 /* Determine whether or not the trip count to ahead ratio is too small based
 on prefitablility consideration.
 AHEAD: the iteration ahead distance,
 time = tree_num_loop_insns (loop, &eni_time_weights);
 if (time == 0)
 return false;
 ahead = (PREFETCH_LATENCY + time - 1) / time;
-est_niter = estimated_loop_iterations_int (loop, false);
+est_niter = estimated_stmt_executions_int (loop);
+if (est_niter == -1)
+est_niter = likely_max_stmt_executions_int (loop);
 /* Prefetching is not likely to be profitable if the trip count to ahead
 ratio is too small.  */
 if (trip_count_to_ahead_ratio_too_small_p (ahead, est_niter))
 return false;
 prune_by_reuse (refs);
 if (nothing_to_prefetch_p (refs))
 goto fail;
-determine_loop_nest_reuse (loop, refs, no_other_refs);
+if (!determine_loop_nest_reuse (loop, refs, no_other_refs))
+goto fail;
 /* Step 3: determine unroll factor.  */
 unroll_factor = determine_unroll_factor (loop, refs, ninsns, &desc,
 					   est_niter);
 /* Issue prefetch instructions for array references in loops.  */
 unsigned int
 tree_ssa_prefetch_arrays (void)
 {
-loop_iterator li;
 struct loop *loop;
 bool unrolled = false;
 int todo_flags = 0;
-if (!HAVE_prefetch
+if (!targetm.have_prefetch ()
 /* It is possible to ask compiler for say -mtune=i486 -march=pentium4.
 	 -mtune=i486 causes us having PREFETCH_BLOCK 0, since this is part
 	 of processor costs and i486 does not have prefetch, but
-	 -march=pentium4 causes HAVE_prefetch to be true.  Ugh.  */
+	 -march=pentium4 causes targetm.have_prefetch to be true.  Ugh.  */
 || PREFETCH_BLOCK == 0)
 return 0;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "\n");
 }
 initialize_original_copy_tables ();
-if (!built_in_decls[BUILT_IN_PREFETCH])
+if (!builtin_decl_explicit_p (BUILT_IN_PREFETCH))
 {
 tree type = build_function_type_list (void_type_node,
 					    const_ptr_type_node, NULL_TREE);
 tree decl = add_builtin_function ("__builtin_prefetch", type,
 					BUILT_IN_PREFETCH, BUILT_IN_NORMAL,
 					NULL, NULL_TREE);
 DECL_IS_NOVOPS (decl) = true;
-built_in_decls[BUILT_IN_PREFETCH] = decl;
+set_builtin_decl (BUILT_IN_PREFETCH, decl, false);
 }
-/* We assume that size of cache line is a power of two, so verify this
+FOR_EACH_LOOP (loop, LI_FROM_INNERMOST)
-here.  */
-gcc_assert ((PREFETCH_BLOCK & (PREFETCH_BLOCK - 1)) == 0);
-FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "Processing loop %d:\n", loop->num);
 unrolled |= loop_prefetch_arrays (loop);
 }
 free_original_copy_tables ();
 return todo_flags;
 }
+/* Prefetching.  */
+namespace {
+const pass_data pass_data_loop_prefetch =
+{
+GIMPLE_PASS, /* type */
+"aprefetch", /* name */
+OPTGROUP_LOOP, /* optinfo_flags */
+TV_TREE_PREFETCH, /* tv_id */
+( PROP_cfg | PROP_ssa ), /* properties_required */
+0, /* properties_provided */
+0, /* properties_destroyed */
+0, /* todo_flags_start */
+0, /* todo_flags_finish */
+};
+class pass_loop_prefetch : public gimple_opt_pass
+{
+public:
+pass_loop_prefetch (gcc::context *ctxt)
+: gimple_opt_pass (pass_data_loop_prefetch, ctxt)
+{}
+/* opt_pass methods: */
+virtual bool gate (function *) { return flag_prefetch_loop_arrays > 0; }
+virtual unsigned int execute (function *);
+}; // class pass_loop_prefetch
+unsigned int
+pass_loop_prefetch::execute (function *fun)
+{
+if (number_of_loops (fun) <= 1)
+return 0;
+if ((PREFETCH_BLOCK & (PREFETCH_BLOCK - 1)) != 0)
+{
+static bool warned = false;
+if (!warned)
+	{
+	  warning (OPT_Wdisabled_optimization,
+		   "%<l1-cache-size%> parameter is not a power of two %d",
+		   PREFETCH_BLOCK);
+	  warned = true;
+	}
+return 0;
+}
+return tree_ssa_prefetch_arrays ();
+}
+} // anon namespace
+gimple_opt_pass *
+make_pass_loop_prefetch (gcc::context *ctxt)
+{
+return new pass_loop_prefetch (ctxt);
+}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-loop-prefetch.c @ 111:04ced10e8804