diff options
Diffstat (limited to 'gcc')
| -rw-r--r-- | gcc/ChangeLog | 51 | ||||
| -rw-r--r-- | gcc/Makefile.in | 4 | ||||
| -rw-r--r-- | gcc/lambda-code.c | 118 | ||||
| -rw-r--r-- | gcc/lambda.h | 25 | ||||
| -rw-r--r-- | gcc/tree-loop-linear.c | 13 |
5 files changed, 149 insertions, 62 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index b93723a..7b0c483 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,54 @@ +2007-09-06 Laurynas Biveinis <laurynas.biveinis@gmail.com> + + * tree-loop-linear.c: Include obstack.h. + (linear_transform_loops): New obstack lambda_obstack. + Initialize it, pass it to gcc_loopnest_to_lambda_loopnest, + lambda_loopnest_transform, lambda_loopnest_to_gcc_loopnest calls + and free afterwards. + * lambda.h (struct obstack): New forward declaration. + (lambda_linear_expression_new): New parameter of type struct + obstack *. + (lambda_loopnest_new): Likewise. + (lambda_loopnest_transform): Likewise. + (lambda_body_vector_new): Likewise. + (lambda_body_vector_compute_new): Likewise. + (gcc_loopnest_to_lambda_loopnest): Likewise. + (lambda_loopnest_to_gcc_loopnest): Likewise. + * lambda-code.c: Include obstack.h. + (lambda_lattice_new): New parameter lambda_obstack. Use it for + allocation of ret. + (lambda_body_vector_new): Likewise. + (lambda_linear_expression_new): Likewise. + (lambda_lattice_new): Likewise. + (lambda_loopnest_new): Likewise. Additionally use obstack to + allocate LN_LOOPS(ret). + (lambda_lattice_compute_base): New parameter lambda_obstack. Pass + it to lambda_lattice_new. + (lambda_body_vector_compute_new): New parameter lambda_obstack. + Pass it to lambda_body_vector_new. + (lambda_lattice_compute_base): New paramater lambda_obstack. Pass + it to lambda_lattice_new. + (compute_nest_using_fourier_motzkin): New parameter lambda_obstack. + Pass it to lambda_loopnest_new, lambda_linear_expression_new. + (lambda_compute_target_space): Likewise. + (lambda_compute_auxillary_space): New parameter lambda_obstack. + Pass it to lambda_lattice_compute_base and + compute_nest_using_fourieer_motzkin. + (lambda_loopnest_transform): New parameter lambda_obstack. Pass + it to lambda_lattice_compute_base, lambda_lattice_auxillary_space + and lambda_lattice_compute_target_space. + (gcc_tree_to_linear_expression): Nex parameter lambda_obstack. + Pass it to lambda_linear_expression_new. + (gcc_loop_to_lambda_loop): New parameter lambda_obstack. Pass it + to gcc_tree_to_linear_expression. + (gcc_loopnest_to_lambda_loopnest): New parameter lambda_obstack. + Pass it to gcc_loop_to_lambda_loop and lambda_loopnest_new. + (lambda_loopnest_to_gcc_loopnest): New parameter lambda_obstack. + Pass it to lambda_body_vector_new and + lambda_body_vector_compute_new. + * Makefile.in (tree-loop-linear.o): Add $(OBSTACK_H) dependency. + (lambda-code.o): Likewise. + 2007-09-06 Chao-ying Fu <fu@mips.com> * ginclude/stdfix.h: New file. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 1030d8e..93f277a 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -2268,7 +2268,7 @@ tree-loop-linear.o: tree-loop-linear.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(GGC_H) $(OPTABS_H) $(TREE_H) $(RTL_H) $(BASIC_BLOCK_H) \ $(DIAGNOSTIC_H) $(TREE_FLOW_H) $(TREE_DUMP_H) $(TIMEVAR_H) $(CFGLOOP_H) \ tree-pass.h $(TREE_DATA_REF_H) $(SCEV_H) $(EXPR_H) $(LAMBDA_H) \ - $(TARGET_H) tree-chrec.h + $(TARGET_H) tree-chrec.h $(OBSTACK_H) tree-stdarg.o: tree-stdarg.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(TREE_H) $(FUNCTION_H) $(DIAGNOSTIC_H) $(TREE_FLOW_H) tree-pass.h \ tree-stdarg.h $(TARGET_H) langhooks.h @@ -2842,7 +2842,7 @@ 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) \ $(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 + tree-chrec.h tree-pass.h vec.h vecprim.h $(OBSTACK_H) params.o : params.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(PARAMS_H) toplev.h pointer-set.o: pointer-set.c pointer-set.h $(CONFIG_H) $(SYSTEM_H) hooks.o: hooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(HOOKS_H) diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c index 0391f19..c573437 100644 --- a/gcc/lambda-code.c +++ b/gcc/lambda-code.c @@ -28,6 +28,7 @@ #include "rtl.h" #include "basic-block.h" #include "diagnostic.h" +#include "obstack.h" #include "tree-flow.h" #include "tree-dump.h" #include "timevar.h" @@ -141,8 +142,9 @@ typedef struct lambda_lattice_s 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 *); @@ -150,11 +152,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_NEW (struct lambda_body_vector_s); + 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; @@ -166,7 +168,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; @@ -176,7 +179,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, @@ -222,12 +225,13 @@ 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_CNEW (struct lambda_linear_expression_s); - + ret = (lambda_linear_expression)obstack_alloc (lambda_obstack, + sizeof (*ret)); LLE_COEFFICIENTS (ret) = lambda_vector_new (dim); LLE_CONSTANT (ret) = 0; LLE_INVARIANT_COEFFICIENTS (ret) = lambda_vector_new (invariants); @@ -324,12 +328,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_NEW (struct lambda_loopnest_s); + ret = (lambda_loopnest)obstack_alloc (lambda_obstack, sizeof (*ret)); - LN_LOOPS (ret) = GGC_CNEWVEC (lambda_loop, depth); + LN_LOOPS (ret) = (lambda_loop *) + obstack_alloc (lambda_obstack, depth * sizeof(LN_LOOPS(ret))); LN_DEPTH (ret) = depth; LN_INVARIANTS (ret) = invariants; @@ -356,10 +362,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_NEW (struct lambda_lattice_s); + 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); @@ -376,7 +382,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; @@ -389,7 +396,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++) { @@ -479,7 +486,8 @@ compute_nest_using_fourier_motzkin (int size, int invariants, lambda_matrix A, lambda_matrix B, - lambda_vector a) + lambda_vector a, + struct obstack * lambda_obstack) { int multiple, f1, f2; @@ -495,7 +503,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--) { @@ -509,7 +517,8 @@ compute_nest_using_fourier_motzkin (int size, { /* 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); + expression = lambda_linear_expression_new (depth, invariants, + lambda_obstack); for (k = 0; k < i; k++) LLE_COEFFICIENTS (expression)[k] = A[j][k]; @@ -533,7 +542,8 @@ compute_nest_using_fourier_motzkin (int size, { /* Any linear expression with a coefficient greater than 0 becomes part of the new upper bound. */ - expression = lambda_linear_expression_new (depth, invariants); + expression = lambda_linear_expression_new (depth, invariants, + lambda_obstack); for (k = 0; k < i; k++) LLE_COEFFICIENTS (expression)[k] = -1 * A[j][k]; @@ -625,7 +635,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; @@ -723,7 +734,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 */ @@ -752,7 +763,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 @@ -765,7 +776,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; @@ -796,7 +808,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++) { @@ -815,7 +827,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; @@ -838,7 +851,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)); @@ -895,7 +909,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)); @@ -1020,7 +1035,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; @@ -1049,7 +1065,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. */ @@ -1065,7 +1081,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. */ @@ -1073,7 +1089,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, @@ -1111,14 +1128,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; @@ -1135,7 +1153,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; @@ -1148,7 +1167,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; @@ -1210,7 +1230,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; @@ -1335,14 +1356,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) @@ -1390,7 +1411,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); @@ -1456,7 +1477,8 @@ DEF_VEC_ALLOC_P(lambda_loop,heap); lambda_loopnest gcc_loopnest_to_lambda_loopnest (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; @@ -1478,7 +1500,7 @@ gcc_loopnest_to_lambda_loopnest (struct loop *loop_nest, newloop = gcc_loop_to_lambda_loop (temp, depth, invariants, &inductionvar, *inductionvars, &lboundvars, &uboundvars, - &steps); + &steps, lambda_obstack); if (!newloop) goto fail; @@ -1502,7 +1524,7 @@ gcc_loopnest_to_lambda_loopnest (struct loop *loop_nest, "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; @@ -1671,7 +1693,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; @@ -1818,10 +1841,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 f2ac6f1..e7a75fd 100644 --- a/gcc/lambda.h +++ b/gcc/lambda.h @@ -97,7 +97,10 @@ 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); +struct obstack; + +lambda_linear_expression lambda_linear_expression_new (int, int, + struct obstack *); void print_lambda_linear_expression (FILE *, lambda_linear_expression, int, int, char); @@ -137,8 +140,10 @@ typedef struct lambda_loopnest_s #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; bool perfect_nest_p (struct loop *); void print_lambda_loopnest (FILE *, lambda_loopnest, char); @@ -190,17 +195,19 @@ 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 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); static inline void lambda_vector_mult_const (lambda_vector, lambda_vector, int, int); diff --git a/gcc/tree-loop-linear.c b/gcc/tree-loop-linear.c index 3fb4d05..d04045d 100644 --- a/gcc/tree-loop-linear.c +++ b/gcc/tree-loop-linear.c @@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see #include "rtl.h" #include "basic-block.h" #include "diagnostic.h" +#include "obstack.h" #include "tree-flow.h" #include "tree-dump.h" #include "timevar.h" @@ -253,7 +254,7 @@ linear_transform_loops (void) VEC(tree,heap) *oldivs = NULL; VEC(tree,heap) *invariants = NULL; struct loop *loop_nest; - + FOR_EACH_LOOP (li, loop_nest, 0) { unsigned int depth = 0; @@ -263,6 +264,9 @@ linear_transform_loops (void) lambda_loopnest before, after; lambda_trans_matrix trans; bool problem = false; + struct obstack lambda_obstack; + gcc_obstack_init (&lambda_obstack); + /* If it's not a loop nest, we don't want it. We also don't handle sibling loops properly, which are loops of the following form: @@ -327,7 +331,7 @@ linear_transform_loops (void) } before = gcc_loopnest_to_lambda_loopnest (loop_nest, &oldivs, - &invariants); + &invariants, &lambda_obstack); if (!before) goto free_and_continue; @@ -338,7 +342,7 @@ linear_transform_loops (void) print_lambda_loopnest (dump_file, before, 'i'); } - after = lambda_loopnest_transform (before, trans); + after = lambda_loopnest_transform (before, trans, &lambda_obstack); if (dump_file) { @@ -347,13 +351,14 @@ linear_transform_loops (void) } lambda_loopnest_to_gcc_loopnest (loop_nest, oldivs, invariants, - after, trans); + after, trans, &lambda_obstack); modified = true; if (dump_file) fprintf (dump_file, "Successfully transformed loop.\n"); free_and_continue: + obstack_free (&lambda_obstack, NULL); free_dependence_relations (dependence_relations); free_data_refs (datarefs); } |