CbC/CbC_gcc: gcc/lambda-code.c comparison

comparison gcc/lambda-code.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	a06113de4d67
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
 Free Software Foundation, Inc.
 Contributed by Daniel Berlin <dberlin@dberlin.org>
 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 Free
 Software Foundation; either version 3, or (at your option) any later
 version.
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 #include "config.h"
 #include "vecprim.h"
 #include "pointer-set.h"
 /* This loop nest code generation is based on non-singular matrix
 math.
 A little terminology and a general sketch of the algorithm.  See "A singular
 loop transformation framework based on non-singular matrices" by Wei Li and
 Keshav Pingali for formal proofs that the various statements below are
 correct.
 A loop iteration space represents the points traversed by the loop.  A point in the
 iteration space can be represented by a vector of size <loop depth>.  You can
 therefore represent the iteration space as an integral combinations of a set
 of basis vectors.
 A loop iteration space is dense if every integer point between the loop
 bounds is a point in the iteration space.  Every loop with a step of 1
 therefore has a dense iteration space.
 for i = 1 to 3, step 1 is a dense iteration space.
 A loop iteration space is sparse if it is not dense.  That is, the iteration
 space skips integer points that are within the loop bounds.
 for i = 1 to 3, step 2 is a sparse iteration space, because the integer point
 2 is skipped.
 Dense source spaces are easy to transform, because they don't skip any
 points to begin with.  Thus we can compute the exact bounds of the target
 space using min/max and floor/ceil.
 For a dense source space, we take the transformation matrix, decompose it
 into a lower triangular part (H) and a unimodular part (U).
 We then compute the auxiliary space from the unimodular part (source loop
 nest . U = auxiliary space) , which has two important properties:
 1. It traverses the iterations in the same lexicographic order as the source
 space.
 2. It is a dense space when the source is a dense space (even if the target
 space is going to be sparse).
 Given the auxiliary space, we use the lower triangular part to compute the
 bounds in the target space by simple matrix multiplication.
 The gaps in the target space (IE the new loop step sizes) will be the
 diagonals of the H matrix.
 the dense space to make it sparse).  We then compose this transform with the
 transformation matrix specified by the user (since our matrix transformations
 are closed under composition, this is okay).  We can then use the base space
 (which is dense) plus the composed transformation matrix, to compute the rest
 of the transform using the dense space algorithm above.
 In other words, our sparse source space (B) is decomposed into a dense base
 space (A), and a matrix (L) that transforms A into B, such that A.L = B.
 We then compute the composition of L and the user transformation matrix (T),
 so that T is now a transform from A to the result, instead of from B to the
 result.
 IE A.(LT) = result instead of B.T = result
 Since A is now a dense source space, we can use the dense source space
 algorithm above to compute the result of applying transform (LT) to A.
 Fourier-Motzkin elimination is used to compute the bounds of the base space
 of the lattice.  */
 static bool perfect_nestify (struct loop *, VEC(tree,heap) *,
 			     VEC(tree,heap) *, VEC(int,heap) *,
 			     VEC(tree,heap) *);
 /* Lattice stuff that is internal to the code generation algorithm.  */
 typedef struct lambda_lattice_s
 			   invariants, 'A');
 fprintf (outfile, "  denominator: %d\n", LLE_DENOMINATOR (expr));
 }
 /* Print a lambda loop structure LOOP to OUTFILE.  The depth/number of
 coefficients is given by DEPTH, the number of invariants is
 given by INVARIANTS, and the character to start variable names with is given
 by START.  */
 void
 print_lambda_loop (FILE * outfile, lambda_loop loop, int depth,
 else
 	{
 	  /* Otherwise, we need the lower bound expression (which must
 	     be an affine function)  to determine the base.  */
 	  expression = LL_LOWER_BOUND (loop);
 	  gcc_assert (expression && !LLE_NEXT (expression)
 		      && LLE_DENOMINATOR (expression) == 1);
 	  /* The lower triangular portion of the base is going to be the
 	     coefficient times the step */
 	  for (j = 0; j < i; j++)
 in b1 ... bk, and some a in a1...ai)
 You can then eliminate this x from the non-constant inequalities by
 rewriting these as a <= b, x >= constant, and delete the x variable.
 You can then repeat this for any remaining x variables, and then we have
 an easy to use variable <= constant (or no variables at all) form that we
 can construct our bounds from.
 In our case, each time we eliminate, we construct part of the bound from
 the ith variable, then delete the ith variable.
 Remember the constant are in our vector a, our coefficient matrix is A,
 and our invariant coefficient matrix is B.
 SIZE is the size of the matrices being passed.
 DEPTH is the loop nest depth.
 INVARIANTS is the number of loop invariants.
 A, B, and a are the coefficient matrix, invariant coefficient, and a
 vector of constants, respectively.  */
 static lambda_loopnest
 compute_nest_using_fourier_motzkin (int size,
 				    int depth,
 				    int invariants,
 				    lambda_matrix A,
 				    lambda_matrix B,
 lambda_vector a,
 struct obstack * lambda_obstack)
 for (j = 0; j < size; j++)
 	{
 	  if (A[j][i] < 0)
 	    {
 	      /* Any linear expression in the matrix with a coefficient less
 		 than 0 becomes part of the new lower bound.  */
 expression = lambda_linear_expression_new (depth, invariants,
 lambda_obstack);
 	      for (k = 0; k < i; k++)
 		LLE_COEFFICIENTS (expression)[k] = A[j][k];
 	    }
 	  else if (A[j][i] > 0)
 	    {
 	      /* Any linear expression with a coefficient greater than 0
 		 becomes part of the new upper bound.  */
 expression = lambda_linear_expression_new (depth, invariants,
 lambda_obstack);
 	      for (k = 0; k < i; k++)
 		LLE_COEFFICIENTS (expression)[k] = -1 * A[j][k];
 return auxillary_nest;
 }
 /* Compute the loop bounds for the auxiliary space NEST.
 Input system used is Ax <= b.  TRANS is the unimodular transformation.
 Given the original nest, this function will
 1. Convert the nest into matrix form, which consists of a matrix for the
 coefficients, a matrix for the
 invariant coefficients, and a vector for the constants.
 2. Use the matrix form to calculate the lattice base for the nest (which is
 a dense space)
 3. Compose the dense space transform with the user specified transform, to
 get a transform we can easily calculate transformed bounds for.
 4. Multiply the composed transformation matrix times the matrix form of the
 loop.
 5. Transform the newly created matrix (from step 4) back into a loop nest
 using Fourier-Motzkin elimination to figure out the bounds.  */
 	    B[size][j] *= -1;
 	  size++;
 	  /* Need to increase matrix sizes above.  */
 	  gcc_assert (size <= 127);
 	}
 /* Then do the exact same thing for the upper bounds.  */
 if (LL_STEP (loop) > 0)
 	expression = LL_UPPER_BOUND (loop);
 return compute_nest_using_fourier_motzkin (size, depth, invariants,
 A, B1, a1, lambda_obstack);
 }
 /* Compute the loop bounds for the target space, using the bounds of
 the auxiliary nest AUXILLARY_NEST, and the triangular matrix H.
 The target space loop bounds are computed by multiplying the triangular
 matrix H by the auxiliary nest, to get the new loop bounds.  The sign of
 the loop steps (positive or negative) is then used to swap the bounds if
 the loop counts downwards.
 Return the target loopnest.  */
 /* Transform NEST according to TRANS, and return the new loopnest.
 This involves
 1. Computing a lattice base for the transformation
 2. Composing the dense base with the specified transformation (TRANS)
 3. Decomposing the combined transformation into a lower triangular portion,
 and a unimodular portion.
 4. Computing the auxiliary nest using the unimodular portion.
 5. Computing the target nest using the auxiliary nest and the lower
 triangular portion.  */
 lambda_loopnest
 lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans,
 struct obstack * lambda_obstack)
 {
 return lle;
 }
 /* Return the depth of the loopnest NEST */
 static int
 depth_of_nest (struct loop *nest)
 {
 size_t depth = 0;
 while (nest)
 {
 lboundvar = PHI_ARG_DEF (phi, 0);
 lbound = gcc_tree_to_linear_expression (depth, lboundvar,
 					      outerinductionvars, *invariants,
 0, lambda_obstack);
 }
 if (!lbound)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file,
 && invariant_in_loop_and_outer_loops (loop, test_rhs))
 VEC_quick_push (tree, *invariants, test_rhs);
 else if (TREE_CODE (test_lhs) == SSA_NAME
 	   && invariant_in_loop_and_outer_loops (loop, test_lhs))
 VEC_quick_push (tree, *invariants, test_lhs);
 /* The non-induction variable part of the test is the upper bound variable.
 */
 if (test_lhs == inductionvar)
 uboundvar = test_rhs;
 else
 uboundvar = test_lhs;
 /* We only size the vectors assuming we have, at max, 2 times as many
 invariants as we do loops (one for each bound).
 This is just an arbitrary number, but it has to be matched against the
 code below.  */
 gcc_assert (VEC_length (tree, *invariants) <= (unsigned int) (2 * depth));
 /* We might have some leftover.  */
 if (gimple_cond_code (exit_cond) == LT_EXPR)
 extra = -1 * stepint;
 else if (gimple_cond_code (exit_cond) == NE_EXPR)
 extra = -1 * stepint;
 else if (gimple_cond_code (exit_cond) == GT_EXPR)
 extra = -1 * stepint;
 else if (gimple_cond_code (exit_cond) == EQ_EXPR)
 extra = 1 * stepint;
 ubound = gcc_tree_to_linear_expression (depth, uboundvar,
 					  outerinductionvars,
 *invariants, extra, lambda_obstack);
 uboundresult = build2 (PLUS_EXPR, TREE_TYPE (uboundvar), uboundvar,
 			 build_int_cst (TREE_TYPE (uboundvar), extra));
 test_lhs = gimple_cond_lhs (expr);
 test_rhs = gimple_cond_rhs (expr);
 /* Find the side that is invariant in this loop. The ivar must be the other
 side.  */
 if (expr_invariant_in_loop_p (loop, test_lhs))
 ivarop = test_rhs;
 else if (expr_invariant_in_loop_p (loop, test_rhs))
 ivarop = test_lhs;
 else
 DEF_VEC_P(lambda_loop);
 DEF_VEC_ALLOC_P(lambda_loop,heap);
 /* Generate a lambda loopnest from a gcc loopnest LOOP_NEST.
 Return the new loop nest.
 INDUCTIONVARS is a pointer to an array of induction variables for the
 loopnest that will be filled in during this process.
 INVARIANTS is a pointer to an array of invariants that will be filled in
 during this process.  */
 if (!perfect_nestify (loop_nest, lboundvars, uboundvars, steps,
 			    *inductionvars))
 	{
 	  if (dump_file)
 	    fprintf (dump_file,
 		     "Not a perfect loop nest and couldn't convert to one.\n");
 	  goto fail;
 	}
 else if (dump_file)
 	fprintf (dump_file,
 		 "Successfully converted loop nest to perfect loop nest.\n");
 fail:
 VEC_free (lambda_loop, heap, loops);
 VEC_free (tree, heap, uboundvars);
 VEC_free (tree, heap, lboundvars);
 VEC_free (int, heap, steps);
 return ret;
 }
 /* Convert a lambda body vector LBV to a gcc tree, and return the new tree.
 STMTS_TO_INSERT is a pointer to a tree where the statements we need to be
 inserted for us are stored.  INDUCTION_VARS is the array of induction
 variables for the loop this LBV is from.  TYPE is the tree type to use for
 the variables and trees involved.  */
 static tree
 lbv_to_gcc_expression (lambda_body_vector lbv,
 		       tree type, VEC(tree,heap) *induction_vars,
 		       gimple_seq *stmts_to_insert)
 {
 int k;
 tree resvar;
 tree expr = build_linear_expr (type, LBV_COEFFICIENTS (lbv), induction_vars);
 /* Convert a linear expression from coefficient and constant form to a
 gcc tree.
 Return the tree that represents the final value of the expression.
 LLE is the linear expression to convert.
 OFFSET is the linear offset to apply to the expression.
 TYPE is the tree type to use for the variables and math.
 INDUCTION_VARS is a vector of induction variables for the loops.
 INVARIANTS is a vector of the loop nest invariants.
 WRAP specifies what tree code to wrap the results in, if there is more than
 one (it is either MAX_EXPR, or MIN_EXPR).
 STMTS_TO_INSERT Is a pointer to the statement list we fill in with
 /* Build up the linear expressions.  */
 for (; lle != NULL; lle = LLE_NEXT (lle))
 {
 expr = build_linear_expr (type, LLE_COEFFICIENTS (lle), induction_vars);
 expr = fold_build2 (PLUS_EXPR, type, expr,
 			  build_linear_expr (type,
 					     LLE_INVARIANT_COEFFICIENTS (lle),
 					     invariants));
 k = LLE_CONSTANT (lle);
 if (k)
 remove_phi_node (&si, true);
 }
 else
 {
 gsi_remove (&si, true);
 release_defs (iv_stmt);
 }
 }
 /* Transform a lambda loopnest NEW_LOOPNEST, which had TRANSFORM applied to
 it, back into gcc code.  This changes the
 loops, their induction variables, and their bodies, so that they
 match the transformed loopnest.
 OLD_LOOPNEST is the loopnest before we've replaced it with the new
 loopnest.
 OLD_IVS is a vector of induction variables from the old loopnest.
 INVARIANTS is a vector of loop invariants from the old loopnest.
 NEW_LOOPNEST is the new lambda loopnest to replace OLD_LOOPNEST with.
 TRANSFORM is the matrix transform that was applied to OLD_LOOPNEST to get
 NEW_LOOPNEST.  */
 void
 lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
 				 VEC(tree,heap) *old_ivs,
 newloop = LN_LOOPS (new_loopnest)[i];
 /* Linear offset is a bit tricky to handle.  Punt on the unhandled
 cases for now.  */
 offset = LL_LINEAR_OFFSET (newloop);
 gcc_assert (LLE_DENOMINATOR (offset) == 1 &&
 		  lambda_vector_zerop (LLE_COEFFICIENTS (offset), depth));
 /* Now build the  new lower bounds, and insert the statements
 necessary to generate it on the loop preheader.  */
 stmts = NULL;
 newlowerbound = lle_to_gcc_expression (LL_LOWER_BOUND (newloop),
 					     LL_LINEAR_OFFSET (newloop),
 bsi = gsi_for_stmt (exitcond);
 gsi_insert_before (&bsi, inc_stmt, GSI_SAME_STMT);
 /* Replace the exit condition with the new upper bound
 comparison.  */
 testtype = LL_STEP (newloop) >= 0 ? LE_EXPR : GE_EXPR;
 /* We want to build a conditional where true means exit the loop, and
 	 false means continue the loop.
 	 So swap the testtype if this isn't the way things are.*/
 if (exit->flags & EDGE_FALSE_VALUE)
 	  /* Compute the new expression for the induction
 	     variable.  */
 	  depth = VEC_length (tree, new_ivs);
 lbv = lambda_body_vector_new (depth, lambda_obstack);
 	  LBV_COEFFICIENTS (lbv)[i] = 1;
 newlbv = lambda_body_vector_compute_new (transform, lbv,
 lambda_obstack);
 	  stmts = NULL;
 	  newiv = lbv_to_gcc_expression (newlbv, TREE_TYPE (oldiv),
 static bool
 stmt_uses_phi_result (gimple stmt, tree phi_result)
 {
 tree use = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_USE);
 /* This is conservatively true, because we only want SIMPLE bumpers
 of the form x +- constant for our pass.  */
 return (use == phi_result);
 }
 /* STMT is a bumper stmt for LOOP if the version it defines is used in the
 in-loop-edge in a phi node, and the operand it uses is the result of that
 phi node.
 I.E. i_29 = i_3 + 1
 i_3 = PHI (0, i_29);  */
 static bool
 stmt_is_bumper_for_loop (struct loop *loop, gimple stmt)
 {
 gimple use;
 tree def;
 imm_use_iterator iter;
 use_operand_p use_p;
 def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
 if (!def)
 return false;
 FOR_EACH_IMM_USE_FAST (use_p, iter, def)
 if (gimple_code (use) == GIMPLE_PHI)
 	{
 	  if (phi_loop_edge_uses_def (loop, use, def))
 	    if (stmt_uses_phi_result (stmt, PHI_RESULT (use)))
 	      return true;
 	}
 }
 return false;
 }
 /* Return true if LOOP is a perfect loop nest.
 Perfect loop nests are those loop nests where all code occurs in the
 innermost loop body.
 If S is a program statement, then
 i.e.
 DO I = 1, 20
 S1
 DO J = 1, 20
 ...
 END DO
 END DO
 is not a perfect loop nest because of S1.
 DO I = 1, 20
 DO J = 1, 20
 S1
 	...
 END DO
 END DO
 is a perfect loop nest.
 Since we don't have high level loops anymore, we basically have to walk our
 statements and ignore those that are there because the loop needs them (IE
 the induction variable increment, and jump back to the top of the loop).  */
 avoid creating duplicate temporaries and FIRSTBSI is statement
 iterator where new temporaries should be inserted at the beginning
 of body basic block.  */
 static void
 replace_uses_equiv_to_x_with_y (struct loop *loop, gimple stmt, tree x,
 				int xstep, tree y, tree yinit,
 				htab_t replacements,
 				gimple_stmt_iterator *firstbsi)
 {
 ssa_op_iter iter;
 {
 if (gimple_code (stmt) != GIMPLE_PHI
 || gimple_phi_num_args (stmt) != 1
 || gimple_bb (stmt) != single_exit (loop)->dest)
 return false;
 return true;
 }
 /* Return true if STMT can be put back into the loop INNER, by
 copying it to the beginning of that loop and changing the uses.  */
 static bool
 can_put_in_inner_loop (struct loop *inner, gimple stmt)
 {
 imm_use_iterator imm_iter;
 use_operand_p use_p;
 gcc_assert (is_gimple_assign (stmt));
-if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)
+if (gimple_vuse (stmt)
 || !stmt_invariant_in_loop_p (inner, stmt))
 return false;
 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_assign_lhs (stmt))
 {
 if (!exit_phi_for_loop_p (inner, USE_STMT (use_p)))
 	{
 	  basic_block immbb = gimple_bb (USE_STMT (use_p));
 	  if (!flow_bb_inside_loop_p (inner, immbb))
 	    return false;
 	}
 }
 return true;
 }
 /* Return true if STMT can be put *after* the inner loop of LOOP.  */
 static bool
 can_put_after_inner_loop (struct loop *loop, gimple stmt)
 {
 imm_use_iterator imm_iter;
 use_operand_p use_p;
-if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
+if (gimple_vuse (stmt))
 return false;
 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, gimple_assign_lhs (stmt))
 {
 if (!exit_phi_for_loop_p (loop, USE_STMT (use_p)))
 	{
 	  basic_block immbb = gimple_bb (USE_STMT (use_p));
 	  if (!dominated_by_p (CDI_DOMINATORS,
 			       immbb,
 			       loop->inner->header)
 	      && !can_put_in_inner_loop (loop->inner, stmt))
 	    return false;
 {
 gimple_stmt_iterator bsi;
 gimple exit_condition = get_loop_exit_condition (loop);
 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
 {
 gimple stmt = gsi_stmt (bsi);
 if (stmt == exit_condition
 	  || not_interesting_stmt (stmt)
 	  || stmt_is_bumper_for_loop (loop, stmt))
 /* If the bb of a statement we care about isn't dominated by the
 	 header of the inner loop, then we can't handle this case
 	 right now.  This test ensures that the statement comes
 	 completely *after* the inner loop.  */
 if (!dominated_by_p (CDI_DOMINATORS,
 			   gimple_bb (stmt),
 			   loop->inner->header))
 	return true;
 }
 return false;
 gimple_stmt_iterator si;
 /* Can't handle triply nested+ loops yet.  */
 if (!loop->inner || loop->inner->inner)
 return false;
 bbs = get_loop_body (loop);
 for (i = 0; i < loop->num_nodes; i++)
 if (bbs[i]->loop_father == loop
 	&& cannot_convert_bb_to_perfect_nest (bbs[i], loop))
 goto fail;
 for (si = gsi_start_phis (single_exit (loop)->dest);
 !gsi_end_p (si);
 gsi_next (&si))
 if (gimple_phi_num_args (gsi_stmt (si)) != 1)
 goto fail;
 free (bbs);
 return true;
 fail:
 free (bbs);
 return false;
 }
+DEF_VEC_I(source_location);
+DEF_VEC_ALLOC_I(source_location,heap);
 /* Transform the loop nest into a perfect nest, if possible.
 LOOP is the loop nest to transform into a perfect nest
 LBOUNDS are the lower bounds for the loops to transform
 UBOUNDS are the upper bounds for the loops to transform
 STEPS is the STEPS for the loops to transform.
 LOOPIVS is the induction variables for the loops to transform.
 Basically, for the case of
 FOR (i = 0; i < 50; i++)
 {
 FOR (j =0; j < 50; j++)
 FOR (j = 0; j < 50; j++)
 {
 <whatever>
 }
 }
 FOR (i = 0; i < 50; i ++)
 {
 <some code>
 }
 gimple phi;
 tree uboundvar;
 gimple stmt;
 tree oldivvar, ivvar, ivvarinced;
 VEC(tree,heap) *phis = NULL;
+VEC(source_location,heap) *locations = NULL;
 htab_t replacements = NULL;
 /* Create the new loop.  */
 olddest = single_exit (loop)->dest;
 preheaderbb = split_edge (single_exit (loop));
 headerbb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
 /* Push the exit phi nodes that we are moving.  */
 for (bsi = gsi_start_phis (olddest); !gsi_end_p (bsi); gsi_next (&bsi))
 {
 phi = gsi_stmt (bsi);
 VEC_reserve (tree, heap, phis, 2);
+VEC_reserve (source_location, heap, locations, 1);
 VEC_quick_push (tree, phis, PHI_RESULT (phi));
 VEC_quick_push (tree, phis, PHI_ARG_DEF (phi, 0));
+VEC_quick_push (source_location, locations,
+		      gimple_phi_arg_location (phi, 0));
 }
 e = redirect_edge_and_branch (single_succ_edge (preheaderbb), headerbb);
 /* Remove the exit phis from the old basic block.  */
 for (bsi = gsi_start_phis (olddest); !gsi_end_p (bsi); )
 /* and add them back to the new basic block.  */
 while (VEC_length (tree, phis) != 0)
 {
 tree def;
 tree phiname;
+source_location locus;
 def = VEC_pop (tree, phis);
 phiname = VEC_pop (tree, phis);
+locus = VEC_pop (source_location, locations);
 phi = create_phi_node (phiname, preheaderbb);
-add_phi_arg (phi, def, single_pred_edge (preheaderbb));
+add_phi_arg (phi, def, single_pred_edge (preheaderbb), locus);
 }
 flush_pending_stmts (e);
 VEC_free (tree, heap, phis);
 bodybb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
 latchbb = create_empty_bb (EXIT_BLOCK_PTR->prev_bb);
 make_edge (headerbb, bodybb, EDGE_FALLTHRU);
 cond_stmt = gimple_build_cond (NE_EXPR, integer_one_node, integer_zero_node,
 				 NULL_TREE, NULL_TREE);
 bsi = gsi_start_bb (bodybb);
 gsi_insert_after (&bsi, cond_stmt, GSI_NEW_STMT);
 e = make_edge (bodybb, olddest, EDGE_FALSE_VALUE);
 make_edge (bodybb, latchbb, EDGE_TRUE_VALUE);
 make_edge (latchbb, headerbb, EDGE_FALLTHRU);
 /* Update the loop structures.  */
 newloop = duplicate_loop (loop, olddest->loop_father);
 newloop->header = headerbb;
 newloop->latch = latchbb;
 add_bb_to_loop (latchbb, newloop);
 add_bb_to_loop (bodybb, newloop);
 add_bb_to_loop (headerbb, newloop);
 set_immediate_dominator (CDI_DOMINATORS, bodybb, headerbb);
 set_immediate_dominator (CDI_DOMINATORS, headerbb, preheaderbb);
 set_immediate_dominator (CDI_DOMINATORS, preheaderbb,
 			   single_exit (loop)->src);
 set_immediate_dominator (CDI_DOMINATORS, latchbb, bodybb);
 set_immediate_dominator (CDI_DOMINATORS, olddest,
 			   recompute_dominator (CDI_DOMINATORS, olddest));
 /* Create the new iv.  */
 ivvar = create_tmp_var (TREE_TYPE (oldivvar), "perfectiv");
 add_referenced_var (ivvar);
 standard_iv_increment_position (newloop, &bsi, &insert_after);
 create_iv (VEC_index (tree, lbounds, 0),
 	     build_int_cst (TREE_TYPE (oldivvar), VEC_index (int, steps, 0)),
 	     ivvar, newloop, &bsi, insert_after, &ivvar, &ivvarinced);
 /* Create the new upper bound.  This may be not just a variable, so we copy
 it to one just in case.  */
 exit_condition = get_loop_exit_condition (newloop);
 update_stmt (stmt);
 gimple_cond_set_condition (exit_condition, GE_EXPR, uboundvar, ivvarinced);
 update_stmt (exit_condition);
 replacements = htab_create_ggc (20, tree_map_hash,
 				  tree_map_eq, NULL);
 bbs = get_loop_body_in_dom_order (loop);
 /* Now move the statements, and replace the induction variable in the moved
 statements with the correct loop induction variable.  */
 oldivvar = VEC_index (tree, loopivs, 0);
 firstbsi = gsi_start_bb (bodybb);
 for (i = loop->num_nodes - 1; i >= 0 ; i--)
 	  /* If this is true, we are *before* the inner loop.
 	     If this isn't true, we are *after* it.
 	     The only time can_convert_to_perfect_nest returns true when we
 	     have statements before the inner loop is if they can be moved
 	     into the inner loop.
 	     The only time can_convert_to_perfect_nest returns true when we
 	     have statements after the inner loop is if they can be moved into
 	     the new split loop.  */
 	  if (dominated_by_p (CDI_DOMINATORS, loop->inner->header, bbs[i]))
 	    {
 	      gimple_stmt_iterator header_bsi
 		= gsi_after_labels (loop->inner->header);
 	      for (bsi = gsi_start_bb (bbs[i]); !gsi_end_p (bsi);)
 		{
 		  gimple stmt = gsi_stmt (bsi);
 		  if (stmt == exit_condition
 		      || not_interesting_stmt (stmt)
 		      || stmt_is_bumper_for_loop (loop, stmt))
 		  gsi_move_before (&bsi, &header_bsi);
 		}
 	    }
 	  else
 	    {
 	      /* Note that the bsi only needs to be explicitly incremented
 		 when we don't move something, since it is automatically
 		 incremented when we do.  */
 	      for (bsi = gsi_start_bb (bbs[i]); !gsi_end_p (bsi);)
 		{
-		  ssa_op_iter i;
-		  tree n;
 		  gimple stmt = gsi_stmt (bsi);
 		  if (stmt == exit_condition
 		      || not_interesting_stmt (stmt)
 		      || stmt_is_bumper_for_loop (loop, stmt))
 		    {
 		      gsi_next (&bsi);
 		      continue;
 		    }
 		  replace_uses_equiv_to_x_with_y
 		    (loop, stmt, oldivvar, VEC_index (int, steps, 0), ivvar,
 		     VEC_index (tree, lbounds, 0), replacements, &firstbsi);
 		  gsi_move_before (&bsi, &tobsi);
 		  /* If the statement has any virtual operands, they may
 		     need to be rewired because the original loop may
 		     still reference them.  */
-		  FOR_EACH_SSA_TREE_OPERAND (n, stmt, i, SSA_OP_ALL_VIRTUALS)
+		  if (gimple_vuse (stmt))
-		    mark_sym_for_renaming (SSA_NAME_VAR (n));
+		    mark_sym_for_renaming (gimple_vop (cfun));
 		}
 	    }
 	}
 }
 free (bbs);
 htab_delete (replacements);
 distance vectors to lexicographically positive vectors.  Note that
 a unimodular matrix must transform the zero vector (and only it) to
 the zero vector." S.Muchnick.  */
 bool
 lambda_transform_legal_p (lambda_trans_matrix trans,
 			  int nb_loops,
 			  VEC (ddr_p, heap) *dependence_relations)
 {
 unsigned int i, j;
 lambda_vector distres;
 	continue;
 /* Conservatively answer: "this transformation is not valid".  */
 if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
 	return false;
 /* If the dependence could not be captured by a distance vector,
 	 conservatively answer that the transform is not valid.  */
 if (DDR_NUM_DIST_VECTS (ddr) == 0)
 	return false;
 /* Compute trans.dist_vect */
 for (j = 0; j < DDR_NUM_DIST_VECTS (ddr); j++)
 	{
 	  lambda_matrix_vector_mult (LTM_MATRIX (trans), nb_loops, nb_loops,
 				     DDR_DIST_VECT (ddr, j), distres);
 	  if (!lambda_vector_lexico_pos (distres, nb_loops))
 	    return false;
 	}
 return av_for_af_base (TREE_OPERAND (base_expr, 0), cy, am, cst)
 	&& av_for_af_base (TREE_OPERAND (base_expr, 1), cy, am, -1 * cst);
 case MULT_EXPR:
 if (TREE_CODE (TREE_OPERAND (base_expr, 0)) == INTEGER_CST)
 	result = av_for_af_base (TREE_OPERAND (base_expr, 1),
 				 cy, am, cst *
 				 int_cst_value (TREE_OPERAND (base_expr, 0)));
 else if (TREE_CODE (TREE_OPERAND (base_expr, 1)) == INTEGER_CST)
 	result = av_for_af_base (TREE_OPERAND (base_expr, 0),
 				 cy, am, cst *

Mercurial > hg > CbC > CbC_gcc

comparison gcc/lambda-code.c @ 55:77e2b8dfacca gcc-4.4.5