Move some objects from GC to obstack in lambda-code.c

git-svn-id: https://gcc.gnu.org/svn/gcc/branches/boehms-gc@126944 138bc75d-0d04-0410-961f-82ee72b054a4

4 files changed, 103 insertions, 67 deletions

diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 9dd1b78f500..aa4feaf99b3 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -805,7 +805,7 @@ PRETTY_PRINT_H = pretty-print.h input.h $(OBSTACK_H)
 DIAGNOSTIC_H = diagnostic.h diagnostic.def $(PRETTY_PRINT_H) options.h
 C_PRETTY_PRINT_H = c-pretty-print.h $(PRETTY_PRINT_H) $(C_COMMON_H) $(TREE_H)
 SCEV_H = tree-scalar-evolution.h $(GGC_H) tree-chrec.h $(PARAMS_H)
-LAMBDA_H = lambda.h $(TREE_H) vec.h $(GGC_H)
+LAMBDA_H = lambda.h $(TREE_H) vec.h $(GGC_H) $(OBSTACK_H)
 TREE_DATA_REF_H = tree-data-ref.h $(LAMBDA_H)
 VARRAY_H = varray.h $(MACHMODE_H) $(SYSTEM_H) coretypes.h $(TM_H)
 TREE_INLINE_H = tree-inline.h varray.h $(SPLAY_TREE_H)
@@ -2623,7 +2623,7 @@ lambda-mat.o : lambda-mat.c $(LAMBDA_H) $(GGC_H) $(SYSTEM_H) $(CONFIG_H) \
 lambda-trans.o: lambda-trans.c $(LAMBDA_H) $(GGC_H) $(SYSTEM_H) $(CONFIG_H) \
    $(TM_H) coretypes.h $(TARGET_H) $(TREE_H)
 lambda-code.o: lambda-code.c $(LAMBDA_H) $(GGC_H) $(SYSTEM_H) $(CONFIG_H) \
-   $(TM_H) $(OPTABS_H) $(TREE_H) $(RTL_H) $(BASIC_BLOCK_H) \
+   $(TM_H) $(OPTABS_H) $(OBSTACK_H) $(TREE_H) $(RTL_H) $(BASIC_BLOCK_H) \
    $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(TIMEVAR_H) $(CFGLOOP_H) \
    $(TREE_DATA_REF_H) $(SCEV_H) $(EXPR_H) coretypes.h $(TARGET_H) \
    tree-chrec.h tree-pass.h vec.h vecprim.h
diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c
index 2a03fd31cd5..4158d914eef 100644
--- a/gcc/lambda-code.c
+++ b/gcc/lambda-code.c
@@ -34,6 +34,7 @@
 #include "timevar.h"
 #include "cfgloop.h"
 #include "expr.h"
+#include "obstack.h"
 #include "optabs.h"
 #include "tree-chrec.h"
 #include "tree-data-ref.h"
@@ -143,8 +144,9 @@ typedef struct
 
 static bool lle_equal (lambda_linear_expression, lambda_linear_expression,
 		       int, int);
-static lambda_lattice lambda_lattice_new (int, int);
-static lambda_lattice lambda_lattice_compute_base (lambda_loopnest);
+static lambda_lattice lambda_lattice_new (int, int, struct obstack *);
+static lambda_lattice lambda_lattice_compute_base (lambda_loopnest,
+                                                   struct obstack *);
 
 static tree find_induction_var_from_exit_cond (struct loop *);
 static bool can_convert_to_perfect_nest (struct loop *);
@@ -152,11 +154,11 @@ static bool can_convert_to_perfect_nest (struct loop *);
 /* Create a new lambda body vector.  */
 
 lambda_body_vector
-lambda_body_vector_new (int size)
+lambda_body_vector_new (int size, struct obstack *lambda_obstack)
 {
   lambda_body_vector ret;
 
-  ret = ggc_alloc (sizeof (*ret));
+  ret = (lambda_body_vector)obstack_alloc (lambda_obstack, sizeof (*ret));
   LBV_COEFFICIENTS (ret) = lambda_vector_new (size);
   LBV_SIZE (ret) = size;
   LBV_DENOMINATOR (ret) = 1;
@@ -168,7 +170,8 @@ lambda_body_vector_new (int size)
 
 lambda_body_vector
 lambda_body_vector_compute_new (lambda_trans_matrix transform,
-				lambda_body_vector vect)
+                                lambda_body_vector vect,
+                                struct obstack *lambda_obstack)
 {
   lambda_body_vector temp;
   int depth;
@@ -178,7 +181,7 @@ lambda_body_vector_compute_new (lambda_trans_matrix transform,
 
   depth = LTM_ROWSIZE (transform);
 
-  temp = lambda_body_vector_new (depth);
+  temp = lambda_body_vector_new (depth, lambda_obstack);
   LBV_DENOMINATOR (temp) =
     LBV_DENOMINATOR (vect) * LTM_DENOMINATOR (transform);
   lambda_vector_matrix_mult (LBV_COEFFICIENTS (vect), depth,
@@ -224,11 +227,14 @@ lle_equal (lambda_linear_expression lle1, lambda_linear_expression lle2,
    of invariants INVARIANTS.  */
 
 lambda_linear_expression
-lambda_linear_expression_new (int dim, int invariants)
+lambda_linear_expression_new (int dim, int invariants,
+                              struct obstack * lambda_obstack)
 {
   lambda_linear_expression ret;
 
-  ret = ggc_alloc_cleared (sizeof (*ret));
+  ret = (lambda_linear_expression)obstack_alloc (lambda_obstack,
+                                                 sizeof (*ret));
+  memset (ret, 0, sizeof (*ret));
 
   LLE_COEFFICIENTS (ret) = lambda_vector_new (dim);
   LLE_CONSTANT (ret) = 0;
@@ -326,12 +332,14 @@ print_lambda_loop (FILE * outfile, lambda_loop loop, int depth,
    number of invariants.  */
 
 lambda_loopnest
-lambda_loopnest_new (int depth, int invariants)
+lambda_loopnest_new (int depth, int invariants, struct obstack *lambda_obstack)
 {
   lambda_loopnest ret;
-  ret = ggc_alloc (sizeof (*ret));
+  ret = (lambda_loopnest)obstack_alloc (lambda_obstack, sizeof (*ret));
 
-  LN_LOOPS (ret) = ggc_alloc_cleared (depth * sizeof (lambda_loop));
+  LN_LOOPS (ret) = (lambda_loop *)obstack_alloc (lambda_obstack,
+                                                 sizeof (struct lambda_loop_s));
+  memset (LN_LOOPS (ret), 0, sizeof (struct lambda_loop_s));
   LN_DEPTH (ret) = depth;
   LN_INVARIANTS (ret) = invariants;
 
@@ -358,10 +366,10 @@ print_lambda_loopnest (FILE * outfile, lambda_loopnest nest, char start)
    of invariants.  */
 
 static lambda_lattice
-lambda_lattice_new (int depth, int invariants)
+lambda_lattice_new (int depth, int invariants, struct obstack *lambda_obstack)
 {
-  lambda_lattice ret;
-  ret = ggc_alloc (sizeof (*ret));
+  lambda_lattice ret = (lambda_lattice)obstack_alloc (lambda_obstack,
+                                                      sizeof (*ret));
   LATTICE_BASE (ret) = lambda_matrix_new (depth, depth);
   LATTICE_ORIGIN (ret) = lambda_vector_new (depth);
   LATTICE_ORIGIN_INVARIANTS (ret) = lambda_matrix_new (depth, invariants);
@@ -378,7 +386,8 @@ lambda_lattice_new (int depth, int invariants)
    identity matrix) if NEST is a sparse space.  */
 
 static lambda_lattice
-lambda_lattice_compute_base (lambda_loopnest nest)
+lambda_lattice_compute_base (lambda_loopnest nest,
+                             struct obstack *lambda_obstack)
 {
   lambda_lattice ret;
   int depth, invariants;
@@ -391,7 +400,7 @@ lambda_lattice_compute_base (lambda_loopnest nest)
   depth = LN_DEPTH (nest);
   invariants = LN_INVARIANTS (nest);
 
-  ret = lambda_lattice_new (depth, invariants);
+  ret = lambda_lattice_new (depth, invariants, lambda_obstack);
   base = LATTICE_BASE (ret);
   for (i = 0; i < depth; i++)
     {
@@ -475,13 +484,14 @@ lcm (int a, int b)
    A, B, and a are the coefficient matrix, invariant coefficient, and a
    vector of constants, respectively.  */
 
-static lambda_loopnest 
+static lambda_loopnest
 compute_nest_using_fourier_motzkin (int size,
-				    int depth, 
-				    int invariants,
-				    lambda_matrix A,
-				    lambda_matrix B,
-				    lambda_vector a)
+                                    int depth,
+                                    int invariants,
+                                    lambda_matrix A,
+                                    lambda_matrix B,
+                                    lambda_vector a,
+                                    struct obstack *lambda_obstack)
 {
 
   int multiple, f1, f2;
@@ -497,7 +507,7 @@ compute_nest_using_fourier_motzkin (int size,
   B1 = lambda_matrix_new (128, invariants);
   a1 = lambda_vector_new (128);
 
-  auxillary_nest = lambda_loopnest_new (depth, invariants);
+  auxillary_nest = lambda_loopnest_new (depth, invariants, lambda_obstack);
 
   for (i = depth - 1; i >= 0; i--)
     {
@@ -510,8 +520,9 @@ compute_nest_using_fourier_motzkin (int size,
 	  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);
+		 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];
@@ -534,8 +545,9 @@ compute_nest_using_fourier_motzkin (int size,
 	  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);
+		 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];
 
@@ -627,7 +639,8 @@ compute_nest_using_fourier_motzkin (int size,
 
 static lambda_loopnest
 lambda_compute_auxillary_space (lambda_loopnest nest,
-				lambda_trans_matrix trans)
+                                lambda_trans_matrix trans,
+                                struct obstack *lambda_obstack)
 {
   lambda_matrix A, B, A1, B1;
   lambda_vector a, a1;
@@ -725,7 +738,7 @@ lambda_compute_auxillary_space (lambda_loopnest nest,
 
   /* Compute the lattice base x = base * y + origin, where y is the
      base space.  */
-  lattice = lambda_lattice_compute_base (nest);
+  lattice = lambda_lattice_compute_base (nest, lambda_obstack);
 
   /* Ax <= a + B then becomes ALy <= a+B - A*origin.  L is the lattice base  */
 
@@ -754,7 +767,7 @@ lambda_compute_auxillary_space (lambda_loopnest nest,
   lambda_matrix_mult (A1, invertedtrans, A, size, depth, depth);
 
   return compute_nest_using_fourier_motzkin (size, depth, invariants,
-					     A, B1, a1);
+                                             A, B1, a1, lambda_obstack);
 }
 
 /* Compute the loop bounds for the target space, using the bounds of
@@ -767,7 +780,8 @@ lambda_compute_auxillary_space (lambda_loopnest nest,
 
 static lambda_loopnest
 lambda_compute_target_space (lambda_loopnest auxillary_nest,
-			     lambda_trans_matrix H, lambda_vector stepsigns)
+                             lambda_trans_matrix H, lambda_vector stepsigns,
+                             struct obstack * lambda_obstack)
 {
   lambda_matrix inverse, H1;
   int determinant, i, j;
@@ -798,7 +812,7 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest,
   target = lambda_matrix_new (depth, depth);
   lambda_matrix_mult (H1, inverse, target, depth, depth, depth);
 
-  target_nest = lambda_loopnest_new (depth, invariants);
+  target_nest = lambda_loopnest_new (depth, invariants, lambda_obstack);
 
   for (i = 0; i < depth; i++)
     {
@@ -817,7 +831,8 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest,
       for (j = 0; j < i; j++)
 	target[i][j] = target[i][j] / gcd1;
 
-      expression = lambda_linear_expression_new (depth, invariants);
+      expression = lambda_linear_expression_new (depth, invariants,
+                                                 lambda_obstack);
       lambda_vector_copy (target[i], LLE_COEFFICIENTS (expression), depth);
       LLE_DENOMINATOR (expression) = determinant / gcd1;
       LLE_CONSTANT (expression) = 0;
@@ -840,7 +855,8 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest,
       for (; auxillary_expr != NULL;
 	   auxillary_expr = LLE_NEXT (auxillary_expr))
 	{
-	  target_expr = lambda_linear_expression_new (depth, invariants);
+          target_expr = lambda_linear_expression_new (depth, invariants,
+                                                      lambda_obstack);
 	  lambda_vector_matrix_mult (LLE_COEFFICIENTS (auxillary_expr),
 				     depth, inverse, depth,
 				     LLE_COEFFICIENTS (target_expr));
@@ -897,7 +913,8 @@ lambda_compute_target_space (lambda_loopnest auxillary_nest,
       for (; auxillary_expr != NULL;
 	   auxillary_expr = LLE_NEXT (auxillary_expr))
 	{
-	  target_expr = lambda_linear_expression_new (depth, invariants);
+          target_expr = lambda_linear_expression_new (depth, invariants,
+                                                      lambda_obstack);
 	  lambda_vector_matrix_mult (LLE_COEFFICIENTS (auxillary_expr),
 				     depth, inverse, depth,
 				     LLE_COEFFICIENTS (target_expr));
@@ -1022,7 +1039,8 @@ lambda_compute_step_signs (lambda_trans_matrix trans, lambda_vector stepsigns)
    triangular portion.  */ 
 
 lambda_loopnest
-lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans)
+lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans,
+                           struct obstack *lambda_obstack)
 {
   lambda_loopnest auxillary_nest, target_nest;
 
@@ -1051,7 +1069,7 @@ lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans)
     }
 
   /* Compute the lattice base.  */
-  lattice = lambda_lattice_compute_base (nest);
+  lattice = lambda_lattice_compute_base (nest, lambda_obstack);
   trans1 = lambda_trans_matrix_new (depth, depth);
 
   /* Multiply the transformation matrix by the lattice base.  */
@@ -1067,7 +1085,7 @@ lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans)
 
   /* Compute the auxiliary loop nest's space from the unimodular
      portion.  */
-  auxillary_nest = lambda_compute_auxillary_space (nest, U);
+  auxillary_nest = lambda_compute_auxillary_space (nest, U, lambda_obstack);
 
   /* Compute the loop step signs from the old step signs and the
      transformation matrix.  */
@@ -1075,7 +1093,8 @@ lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans)
 
   /* Compute the target loop nest space from the auxiliary nest and
      the lower triangular matrix H.  */
-  target_nest = lambda_compute_target_space (auxillary_nest, H, stepsigns);
+  target_nest = lambda_compute_target_space (auxillary_nest, H, stepsigns,
+                                             lambda_obstack);
   origin = lambda_vector_new (depth);
   origin_invariants = lambda_matrix_new (depth, invariants);
   lambda_matrix_vector_mult (LTM_MATRIX (trans), depth, depth,
@@ -1113,14 +1132,15 @@ lambda_loopnest_transform (lambda_loopnest nest, lambda_trans_matrix trans)
 static lambda_linear_expression
 gcc_tree_to_linear_expression (int depth, tree expr,
 			       VEC(tree,heap) *outerinductionvars,
-			       VEC(tree,heap) *invariants, int extra)
+                               VEC(tree,heap) *invariants, int extra,
+                               struct obstack *lambda_obstack)
 {
   lambda_linear_expression lle = NULL;
   switch (TREE_CODE (expr))
     {
     case INTEGER_CST:
       {
-	lle = lambda_linear_expression_new (depth, 2 * depth);
+        lle = lambda_linear_expression_new (depth, 2 * depth, lambda_obstack);
 	LLE_CONSTANT (lle) = TREE_INT_CST_LOW (expr);
 	if (extra != 0)
 	  LLE_CONSTANT (lle) += extra;
@@ -1137,7 +1157,8 @@ gcc_tree_to_linear_expression (int depth, tree expr,
 	    {
 	      if (SSA_NAME_VAR (iv) == SSA_NAME_VAR (expr))
 		{
-		  lle = lambda_linear_expression_new (depth, 2 * depth);
+                  lle = lambda_linear_expression_new (depth, 2 * depth,
+                                                      lambda_obstack);
 		  LLE_COEFFICIENTS (lle)[i] = 1;
 		  if (extra != 0)
 		    LLE_CONSTANT (lle) = extra;
@@ -1150,7 +1171,8 @@ gcc_tree_to_linear_expression (int depth, tree expr,
 	    {
 	      if (SSA_NAME_VAR (invar) == SSA_NAME_VAR (expr))
 		{
-		  lle = lambda_linear_expression_new (depth, 2 * depth);
+                  lle = lambda_linear_expression_new (depth, 2 * depth,
+                                                      lambda_obstack);
 		  LLE_INVARIANT_COEFFICIENTS (lle)[i] = 1;
 		  if (extra != 0)
 		    LLE_CONSTANT (lle) = extra;
@@ -1213,7 +1235,8 @@ gcc_loop_to_lambda_loop (struct loop *loop, int depth,
 			 VEC(tree,heap) * outerinductionvars,
 			 VEC(tree,heap) ** lboundvars,
 			 VEC(tree,heap) ** uboundvars,
-			 VEC(int,heap) ** steps)
+                         VEC(int,heap) ** steps,
+                         struct obstack *lambda_obstack)
 {
   tree phi;
   tree exit_cond;
@@ -1338,14 +1361,14 @@ gcc_loop_to_lambda_loop (struct loop *loop, int depth,
       lboundvar = PHI_ARG_DEF (phi, 1);
       lbound = gcc_tree_to_linear_expression (depth, lboundvar,
 					      outerinductionvars, *invariants,
-					      0);
+                                              0, lambda_obstack);
     }
   else
     {
       lboundvar = PHI_ARG_DEF (phi, 0);
       lbound = gcc_tree_to_linear_expression (depth, lboundvar,
 					      outerinductionvars, *invariants,
-					      0);
+                                              0, lambda_obstack);
     }
   
   if (!lbound)
@@ -1393,7 +1416,7 @@ gcc_loop_to_lambda_loop (struct loop *loop, int depth,
   
   ubound = gcc_tree_to_linear_expression (depth, uboundvar,
 					  outerinductionvars,
-					  *invariants, extra);
+                                          *invariants, extra, lambda_obstack);
   uboundresult = build2 (PLUS_EXPR, TREE_TYPE (uboundvar), uboundvar,
 			 build_int_cst (TREE_TYPE (uboundvar), extra));
   VEC_safe_push (tree, heap, *uboundvars, uboundresult);
@@ -1460,7 +1483,8 @@ lambda_loopnest
 gcc_loopnest_to_lambda_loopnest (struct loops *currloops,
 				 struct loop *loop_nest,
 				 VEC(tree,heap) **inductionvars,
-				 VEC(tree,heap) **invariants)
+                                 VEC(tree,heap) **invariants,
+                                 struct obstack *lambda_obstack)
 {
   lambda_loopnest ret = NULL;
   struct loop *temp = loop_nest;
@@ -1482,7 +1506,7 @@ gcc_loopnest_to_lambda_loopnest (struct loops *currloops,
       newloop = gcc_loop_to_lambda_loop (temp, depth, invariants,
 					 &inductionvar, *inductionvars,
 					 &lboundvars, &uboundvars,
-					 &steps);
+                                         &steps, lambda_obstack);
       if (!newloop)
 	goto fail;
 
@@ -1506,7 +1530,7 @@ gcc_loopnest_to_lambda_loopnest (struct loops *currloops,
 		 "Successfully converted loop nest to perfect loop nest.\n");
     }
 
-  ret = lambda_loopnest_new (depth, 2 * depth);
+  ret = lambda_loopnest_new (depth, 2 * depth, lambda_obstack);
 
   for (i = 0; VEC_iterate (lambda_loop, loops, i, newloop); i++)
     LN_LOOPS (ret)[i] = newloop;
@@ -1808,7 +1832,8 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
 				 VEC(tree,heap) *old_ivs,
 				 VEC(tree,heap) *invariants,
 				 lambda_loopnest new_loopnest,
-				 lambda_trans_matrix transform)
+                                 lambda_trans_matrix transform,
+                                 struct obstack *lambda_obstack)
 {
   struct loop *temp;
   size_t i = 0;
@@ -1951,10 +1976,11 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
 	  /* Compute the new expression for the induction
 	     variable.  */
 	  depth = VEC_length (tree, new_ivs);
-	  lbv = lambda_body_vector_new (depth);
+          lbv = lambda_body_vector_new (depth, lambda_obstack);
 	  LBV_COEFFICIENTS (lbv)[i] = 1;
 	  
-	  newlbv = lambda_body_vector_compute_new (transform, lbv);
+          newlbv = lambda_body_vector_compute_new (transform, lbv,
+                                                   lambda_obstack);
 
 	  newiv = lbv_to_gcc_expression (newlbv, TREE_TYPE (oldiv),
 					 new_ivs, &stmts);
diff --git a/gcc/lambda.h b/gcc/lambda.h
index 5eb63997c0d..c55aff895f3 100644
--- a/gcc/lambda.h
+++ b/gcc/lambda.h
@@ -22,6 +22,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #ifndef LAMBDA_H
 #define LAMBDA_H
 
+#include "obstack.h"
 #include "vec.h"
 
 /* An integer vector.  A vector formally consists of an element of a vector
@@ -98,7 +99,8 @@ typedef struct lambda_linear_expression_s
 #define LLE_DENOMINATOR(T) ((T)->denominator)
 #define LLE_NEXT(T) ((T)->next)
 
-lambda_linear_expression lambda_linear_expression_new (int, int);
+lambda_linear_expression lambda_linear_expression_new (int, int,
+                                                       struct obstack *);
 void print_lambda_linear_expression (FILE *, lambda_linear_expression, int,
 				     int, char);
 
@@ -138,8 +140,10 @@ typedef struct
 #define LN_DEPTH(T) ((T)->depth)
 #define LN_INVARIANTS(T) ((T)->invariants)
 
-lambda_loopnest lambda_loopnest_new (int, int);
-lambda_loopnest lambda_loopnest_transform (lambda_loopnest, lambda_trans_matrix);
+lambda_loopnest lambda_loopnest_new (int, int, struct obstack *);
+lambda_loopnest lambda_loopnest_transform (lambda_loopnest,
+                                           lambda_trans_matrix,
+                                           struct obstack *);
 struct loop;
 struct loops;
 bool perfect_nest_p (struct loop *);
@@ -192,17 +196,20 @@ void lambda_matrix_vector_mult (lambda_matrix, int, int, lambda_vector,
 				lambda_vector);
 bool lambda_trans_matrix_id_p (lambda_trans_matrix);
 
-lambda_body_vector lambda_body_vector_new (int);
-lambda_body_vector lambda_body_vector_compute_new (lambda_trans_matrix, 
-						   lambda_body_vector);
+lambda_body_vector lambda_body_vector_new (int, struct obstack *);
+lambda_body_vector lambda_body_vector_compute_new (lambda_trans_matrix,
+                                                   lambda_body_vector,
+                                                   struct obstack *);
 void print_lambda_body_vector (FILE *, lambda_body_vector);
 lambda_loopnest gcc_loopnest_to_lambda_loopnest (struct loops *,
 						 struct loop *,
 						 VEC(tree,heap) **,
-						 VEC(tree,heap) **);
+                                                 VEC(tree,heap) **,
+                                                 struct obstack *);
 void lambda_loopnest_to_gcc_loopnest (struct loop *,
 				      VEC(tree,heap) *, VEC(tree,heap) *,
-				      lambda_loopnest, lambda_trans_matrix);
+                                      lambda_loopnest, lambda_trans_matrix,
+                                      struct obstack *);
 
 
 static inline void lambda_vector_negate (lambda_vector, lambda_vector, int);
diff --git a/gcc/tree-loop-linear.c b/gcc/tree-loop-linear.c
index e0f5bd2991b..be8f3f347de 100644
--- a/gcc/tree-loop-linear.c
+++ b/gcc/tree-loop-linear.c
@@ -245,7 +245,9 @@ linear_transform_loops (struct loops *loops)
   unsigned int i;
   VEC(tree,heap) *oldivs = NULL;
   VEC(tree,heap) *invariants = NULL;
-  
+  struct obstack lambda_obstack;
+  gcc_obstack_init (&lambda_obstack);
+
   for (i = 1; i < loops->num; i++)
     {
       unsigned int depth = 0;
@@ -320,7 +322,7 @@ linear_transform_loops (struct loops *loops)
 	}
 
       before = gcc_loopnest_to_lambda_loopnest (loops, loop_nest, &oldivs,
-						&invariants);
+                                                &invariants, &lambda_obstack);
 
       if (!before)
 	continue;
@@ -331,7 +333,7 @@ linear_transform_loops (struct loops *loops)
 	  print_lambda_loopnest (dump_file, before, 'i');
 	}
   
-      after = lambda_loopnest_transform (before, trans);
+      after = lambda_loopnest_transform (before, trans, &lambda_obstack);
 
       if (dump_file)
 	{
@@ -340,7 +342,8 @@ linear_transform_loops (struct loops *loops)
 	}
 
       lambda_loopnest_to_gcc_loopnest (loop_nest, oldivs, invariants,
-				       after, trans);
+                                       after, trans, &lambda_obstack);
+      obstack_free (&lambda_obstack, NULL);
       modified = true;
 
       if (dump_file)