gcc/gcc/tree-data-ref.c

21 /* This pass walks a given loop structure searching for array
35      information allows a loop parallelization),
42        - loop carried level dependence
120 #include "tree-ssa-loop-niter.h"
121 #include "tree-ssa-loop.h"
161 					   struct loop *);
468       struct loop *loopi;
479       fprintf (outf, "  inner loop index: %d\n", DDR_INNER_LOOP (ddr));
480       fprintf (outf, "  loop nest: (");
785 /* Analyzes the behavior of the memory reference DR in the innermost loop or
790 dr_analyze_innermost (struct data_reference *dr, struct loop *nest)
793   struct loop *loop = loop_containing_stmt (stmt);
801   bool in_loop = (loop && loop->num);
835       if (!simple_iv (loop, loop_containing_stmt (stmt), base, &base_iv,
872       else if (!simple_iv (loop, loop_containing_stmt (stmt),
916    DR, analyzed in LOOP and instantiated in loop nest NEST.  */
919 dr_analyze_indices (struct data_reference *dr, loop_p nest, loop_p loop)
958 	  access_fn = analyze_scalar_evolution (loop, op);
959 	  access_fn = instantiate_scev (before_loop, loop, access_fn);
990       access_fn = analyze_scalar_evolution (loop, op);
991       access_fn = instantiate_scev (before_loop, loop, access_fn);
1084    data_reference description of MEMREF.  NEST is the outermost loop
1085    in which the reference should be instantiated, LOOP is the loop in
1089 create_data_ref (loop_p nest, loop_p loop, tree memref, gimple stmt,
1107   dr_analyze_indices (dr, nest, loop);
1388 object_address_invariant_in_loop_p (const struct loop *loop, const_tree obj)
1397 						      loop->num)
1399 							 loop->num))
1405 						      loop->num))
1416 						  loop->num);
1430   /* If we are not processing a loop nest but scalar code we
1433      similar to how loop invariant motion applies extra offset-based
1493      that is being subsetted in the loop nest.  */
1574   /* If the base of the object is not invariant in the loop nest, we cannot
1803 	     overlaps for each iteration in the loop.  */
1842 max_stmt_executions_tree (struct loop *loop)
1846   if (!max_stmt_executions (loop, &nit))
1881 	 changes during the execution of the loop, from 0 to
1882 	 loop->nb_iterations.  */
1995 		      struct loop *loop = get_chrec_loop (chrec_b);
2006 			 outside the loop bounds.  */
2007 		      numiter = max_stmt_executions_int (loop);
2075 		      struct loop *loop = get_chrec_loop (chrec_b);
2084 			 outside the loop bounds.  */
2085 		      numiter = max_stmt_executions_int (loop);
2542 	 loop.  */
2558      happens before the upper bound loop.nb_iterations.  Otherwise
2727 		     loop, there is no dependence.  */
2960 		       struct loop *loop_nest)
3063 				tree *last_conflicts, struct loop *loop_nest)
3170    haven't yet determined a distance for this outer loop, push a new
3172    of 1 for this outer loop.  Example:
3187   /* For each outer loop where init_v is not set, the accesses are
3188      in dependence of distance 1 in the loop.  */
3246 	     recorded a distance for this loop (a distance coming from
3250 	     | loop i = 0, N, 1
3371 		   the outer loop, so this cannot be represented by a
3436 /* Compute the classic per loop distance vector.  DDR is the data
3442 			   struct loop *loop_nest)
3478 	 the program, thus for the following loop
3494 	 the outer loop, ie. we're actually looking upwind.  In this
3606 /* Compute the classic per loop direction vector.  DDR is the data
3633 			       struct loop *loop_nest)
3692 			     struct loop *loop_nest)
3707 					   const struct loop *loop_nest)
3753 	/* Compute the innermost loop index.  */
3784    to set up a system for each loop level, setting outer loops
3785    variation to zero, and current loop variation to positive or zero.
3794   struct loop *loopi, *loopj;
3797   /* Set a new problem for each loop in the nest.  The basis is the
3956   struct loop *loopi;
3980      - coef[nb_loops + 1, 2*nb_loops] are the loop variables: "loop_x".
4060    loop distances are zero, and fix this inner component to be
4062    distance, and set a new problem where the distance on this loop is
4065    inner loop a new problem:
4257 			   struct loop *loop_nest)
4437 	      struct loop *loop = gimple_bb (stmt)->loop_father;
4440 	      if (loop == NULL
4441 		  || loop->simduid != SSA_NAME_VAR (uid))
4535    loop of the loop nest in which the references should be analyzed.  */
4538 find_data_references_in_stmt (struct loop *nest, gimple stmt,
4563    NEST is the outermost loop of the loop nest in which the references
4564    should be instantiated, LOOP is the loop in which the references
4568 graphite_find_data_references_in_stmt (loop_p nest, loop_p loop, gimple stmt,
4582       dr = create_data_ref (nest, loop, ref->ref, stmt, ref->is_read);
4596 find_data_references_in_bb (struct loop *loop, basic_block bb,
4605       if (!find_data_references_in_stmt (loop, stmt, datarefs))
4626 find_data_references_in_loop (struct loop *loop,
4632   bbs = get_loop_body_in_dom_order (loop);
4634   for (i = 0; i < loop->num_nodes; i++)
4638       if (find_data_references_in_bb (loop, bb, datarefs) == chrec_dont_know)
4652 find_loop_nest_1 (struct loop *loop, vec<loop_p> *loop_nest)
4668   if (loop->next)
4671   loop_nest->safe_push (loop);
4672   if (loop->inner)
4673     return find_loop_nest_1 (loop->inner, loop_nest);
4683 find_loop_nest (struct loop *loop, vec<loop_p> *loop_nest)
4685   loop_nest->safe_push (loop);
4686   if (loop->inner)
4687     return find_loop_nest_1 (loop->inner, loop_nest);
4692    Given a loop nest LOOP, the following vectors are returned:
4693    DATAREFS is initialized to all the array elements contained in this loop,
4699 compute_data_dependences_for_loop (struct loop *loop,
4709   /* If the loop nest is not well formed, or one of the data references
4712   if (!loop
4713       || !find_loop_nest (loop, loop_nest)
4714       || find_data_references_in_loop (loop, datarefs) == chrec_dont_know
4811 analyze_all_data_dependences (struct loop *loop)
4823   compute_data_dependences_for_loop (loop, false, &loop_nest, &datarefs,
4868   struct loop *loop_nest;