1 /* Translation of ISL AST to Gimple.
2 Copyright (C) 2014 Free Software Foundation, Inc.
3 Contributed by Roman Gareev <gareevroman@gmail.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
26 #include <isl/union_map.h>
27 #include <isl/ast_build.h>
28 #if defined(__cplusplus)
31 #include <isl/val_gmp.h>
32 #if defined(__cplusplus)
38 #include "coretypes.h"
40 #include "basic-block.h"
41 #include "tree-ssa-alias.h"
42 #include "internal-fn.h"
43 #include "gimple-expr.h"
46 #include "gimple-iterator.h"
47 #include "tree-ssa-loop.h"
48 #include "tree-pass.h"
50 #include "tree-data-ref.h"
52 #include "tree-ssa-loop-manip.h"
53 #include "tree-scalar-evolution.h"
54 #include "gimple-ssa.h"
55 #include "tree-into-ssa.h"
59 #include "graphite-poly.h"
60 #include "graphite-isl-ast-to-gimple.h"
62 /* This flag is set when an error occurred during the translation of
65 static bool graphite_regenerate_error
;
67 /* We always try to use signed 128 bit types, but fall back to smaller types
68 in case a platform does not provide types of these sizes. In the future we
69 should use isl to derive the optimal type for each subexpression. */
71 static int max_mode_int_precision
=
72 GET_MODE_PRECISION (mode_for_size (MAX_FIXED_MODE_SIZE
, MODE_INT
, 0));
73 static int graphite_expression_type_precision
= 128 <= max_mode_int_precision
?
74 128 : max_mode_int_precision
;
76 /* Converts a GMP constant VAL to a tree and returns it. */
79 gmp_cst_to_tree (tree type
, mpz_t val
)
81 tree t
= type
? type
: integer_type_node
;
86 wide_int wi
= wi::from_mpz (t
, tmp
, true);
89 return wide_int_to_tree (t
, wi
);
92 /* Verifies properties that GRAPHITE should maintain during translation. */
95 graphite_verify (void)
97 #ifdef ENABLE_CHECKING
98 verify_loop_structure ();
99 verify_loop_closed_ssa (true);
103 /* IVS_PARAMS maps ISL's scattering and parameter identifiers
104 to corresponding trees. */
106 typedef std::map
<isl_id
*, tree
> ivs_params
;
108 /* Free all memory allocated for ISL's identifiers. */
110 void ivs_params_clear (ivs_params
&ip
)
112 std::map
<isl_id
*, tree
>::iterator it
;
113 for (it
= ip
.begin ();
114 it
!= ip
.end (); it
++)
116 isl_id_free (it
->first
);
121 gcc_expression_from_isl_expression (tree type
, __isl_take isl_ast_expr
*,
124 /* Return the tree variable that corresponds to the given isl ast identifier
125 expression (an isl_ast_expr of type isl_ast_expr_id). */
128 gcc_expression_from_isl_ast_expr_id (__isl_keep isl_ast_expr
*expr_id
,
131 gcc_assert (isl_ast_expr_get_type (expr_id
) == isl_ast_expr_id
);
132 isl_id
*tmp_isl_id
= isl_ast_expr_get_id (expr_id
);
133 std::map
<isl_id
*, tree
>::iterator res
;
134 res
= ip
.find (tmp_isl_id
);
135 isl_id_free (tmp_isl_id
);
136 gcc_assert (res
!= ip
.end () &&
137 "Could not map isl_id to tree expression");
138 isl_ast_expr_free (expr_id
);
142 /* Converts an isl_ast_expr_int expression E to a GCC expression tree of
146 gcc_expression_from_isl_expr_int (tree type
, __isl_take isl_ast_expr
*expr
)
148 gcc_assert (isl_ast_expr_get_type (expr
) == isl_ast_expr_int
);
149 isl_val
*val
= isl_ast_expr_get_val (expr
);
151 mpz_init (val_mpz_t
);
153 if (isl_val_get_num_gmp (val
, val_mpz_t
) == -1)
156 res
= gmp_cst_to_tree (type
, val_mpz_t
);
158 isl_ast_expr_free (expr
);
159 mpz_clear (val_mpz_t
);
163 /* Converts a binary isl_ast_expr_op expression E to a GCC expression tree of
167 binary_op_to_tree (tree type
, __isl_take isl_ast_expr
*expr
, ivs_params
&ip
)
169 isl_ast_expr
*arg_expr
= isl_ast_expr_get_op_arg (expr
, 0);
170 tree tree_lhs_expr
= gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
171 arg_expr
= isl_ast_expr_get_op_arg (expr
, 1);
172 tree tree_rhs_expr
= gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
173 enum isl_ast_op_type expr_type
= isl_ast_expr_get_op_type (expr
);
174 isl_ast_expr_free (expr
);
178 return fold_build2 (PLUS_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
181 return fold_build2 (MINUS_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
184 return fold_build2 (MULT_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
187 return fold_build2 (EXACT_DIV_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
189 case isl_ast_op_fdiv_q
:
190 return fold_build2 (FLOOR_DIV_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
193 return fold_build2 (TRUTH_ANDIF_EXPR
, type
,
194 tree_lhs_expr
, tree_rhs_expr
);
197 return fold_build2 (TRUTH_ORIF_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
200 return fold_build2 (EQ_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
203 return fold_build2 (LE_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
206 return fold_build2 (LT_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
209 return fold_build2 (GE_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
212 return fold_build2 (GT_EXPR
, type
, tree_lhs_expr
, tree_rhs_expr
);
219 /* Converts a ternary isl_ast_expr_op expression E to a GCC expression tree of
223 ternary_op_to_tree (tree type
, __isl_take isl_ast_expr
*expr
, ivs_params
&ip
)
225 gcc_assert (isl_ast_expr_get_op_type (expr
) == isl_ast_op_minus
);
226 isl_ast_expr
*arg_expr
= isl_ast_expr_get_op_arg (expr
, 0);
228 = gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
229 arg_expr
= isl_ast_expr_get_op_arg (expr
, 1);
230 tree tree_second_expr
231 = gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
232 arg_expr
= isl_ast_expr_get_op_arg (expr
, 2);
234 = gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
235 isl_ast_expr_free (expr
);
236 return fold_build3 (COND_EXPR
, type
, tree_first_expr
,
237 tree_second_expr
, tree_third_expr
);
240 /* Converts a unary isl_ast_expr_op expression E to a GCC expression tree of
244 unary_op_to_tree (tree type
, __isl_take isl_ast_expr
*expr
, ivs_params
&ip
)
246 gcc_assert (isl_ast_expr_get_op_type (expr
) == isl_ast_op_minus
);
247 isl_ast_expr
*arg_expr
= isl_ast_expr_get_op_arg (expr
, 0);
248 tree tree_expr
= gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
249 isl_ast_expr_free (expr
);
250 return fold_build1 (NEGATE_EXPR
, type
, tree_expr
);
253 /* Converts an isl_ast_expr_op expression E with unknown number of arguments
254 to a GCC expression tree of type TYPE. */
257 nary_op_to_tree (tree type
, __isl_take isl_ast_expr
*expr
, ivs_params
&ip
)
259 enum tree_code op_code
;
260 switch (isl_ast_expr_get_op_type (expr
))
273 isl_ast_expr
*arg_expr
= isl_ast_expr_get_op_arg (expr
, 0);
274 tree res
= gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
276 for (i
= 1; i
< isl_ast_expr_get_op_n_arg (expr
); i
++)
278 arg_expr
= isl_ast_expr_get_op_arg (expr
, i
);
279 tree t
= gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
280 res
= fold_build2 (op_code
, type
, res
, t
);
282 isl_ast_expr_free (expr
);
287 /* Converts an isl_ast_expr_op expression E to a GCC expression tree of
291 gcc_expression_from_isl_expr_op (tree type
, __isl_take isl_ast_expr
*expr
,
294 gcc_assert (isl_ast_expr_get_type (expr
) == isl_ast_expr_op
);
295 switch (isl_ast_expr_get_op_type (expr
))
297 /* These isl ast expressions are not supported yet. */
298 case isl_ast_op_error
:
299 case isl_ast_op_call
:
300 case isl_ast_op_and_then
:
301 case isl_ast_op_or_else
:
302 case isl_ast_op_pdiv_q
:
303 case isl_ast_op_pdiv_r
:
304 case isl_ast_op_select
:
309 return nary_op_to_tree (type
, expr
, ip
);
315 case isl_ast_op_fdiv_q
:
323 return binary_op_to_tree (type
, expr
, ip
);
325 case isl_ast_op_minus
:
326 return unary_op_to_tree (type
, expr
, ip
);
328 case isl_ast_op_cond
:
329 return ternary_op_to_tree (type
, expr
, ip
);
338 /* Converts an ISL AST expression E back to a GCC expression tree of
342 gcc_expression_from_isl_expression (tree type
, __isl_take isl_ast_expr
*expr
,
345 switch (isl_ast_expr_get_type (expr
))
347 case isl_ast_expr_id
:
348 return gcc_expression_from_isl_ast_expr_id (expr
, ip
);
350 case isl_ast_expr_int
:
351 return gcc_expression_from_isl_expr_int (type
, expr
);
353 case isl_ast_expr_op
:
354 return gcc_expression_from_isl_expr_op (type
, expr
, ip
);
363 /* Creates a new LOOP corresponding to isl_ast_node_for. Inserts an
364 induction variable for the new LOOP. New LOOP is attached to CFG
365 starting at ENTRY_EDGE. LOOP is inserted into the loop tree and
366 becomes the child loop of the OUTER_LOOP. NEWIVS_INDEX binds
367 ISL's scattering name to the induction variable created for the
368 loop of STMT. The new induction variable is inserted in the NEWIVS
369 vector and is of type TYPE. */
372 graphite_create_new_loop (edge entry_edge
, __isl_keep isl_ast_node
*node_for
,
373 loop_p outer
, tree type
, tree lb
, tree ub
,
376 isl_ast_expr
*for_inc
= isl_ast_node_for_get_inc (node_for
);
377 tree stride
= gcc_expression_from_isl_expression (type
, for_inc
, ip
);
378 tree ivvar
= create_tmp_var (type
, "graphite_IV");
379 tree iv
, iv_after_increment
;
380 loop_p loop
= create_empty_loop_on_edge
381 (entry_edge
, lb
, stride
, ub
, ivvar
, &iv
, &iv_after_increment
,
382 outer
? outer
: entry_edge
->src
->loop_father
);
384 isl_ast_expr
*for_iterator
= isl_ast_node_for_get_iterator (node_for
);
385 isl_id
*id
= isl_ast_expr_get_id (for_iterator
);
387 isl_ast_expr_free (for_iterator
);
392 translate_isl_ast (loop_p context_loop
, __isl_keep isl_ast_node
*node
,
393 edge next_e
, ivs_params
&ip
);
395 /* Create the loop for a isl_ast_node_for.
397 - NEXT_E is the edge where new generated code should be attached. */
400 translate_isl_ast_for_loop (loop_p context_loop
,
401 __isl_keep isl_ast_node
*node_for
, edge next_e
,
402 tree type
, tree lb
, tree ub
,
405 gcc_assert (isl_ast_node_get_type (node_for
) == isl_ast_node_for
);
406 struct loop
*loop
= graphite_create_new_loop (next_e
, node_for
, context_loop
,
408 edge last_e
= single_exit (loop
);
409 edge to_body
= single_succ_edge (loop
->header
);
410 basic_block after
= to_body
->dest
;
412 /* Create a basic block for loop close phi nodes. */
413 last_e
= single_succ_edge (split_edge (last_e
));
415 /* Translate the body of the loop. */
416 isl_ast_node
*for_body
= isl_ast_node_for_get_body (node_for
);
417 next_e
= translate_isl_ast (loop
, for_body
, to_body
, ip
);
418 isl_ast_node_free (for_body
);
419 redirect_edge_succ_nodup (next_e
, after
);
420 set_immediate_dominator (CDI_DOMINATORS
, next_e
->dest
, next_e
->src
);
422 /* TODO: Add checking for the loop parallelism. */
427 /* We use this function to get the upper bound because of the form,
428 which is used by isl to represent loops:
430 for (iterator = init; cond; iterator += inc)
438 The loop condition is an arbitrary expression, which contains the
439 current loop iterator.
441 (e.g. iterator + 3 < B && C > iterator + A)
443 We have to know the upper bound of the iterator to generate a loop
444 in Gimple form. It can be obtained from the special representation
445 of the loop condition, which is generated by isl,
446 if the ast_build_atomic_upper_bound option is set. In this case,
447 isl generates a loop condition that consists of the current loop
448 iterator, + an operator (< or <=) and an expression not involving
449 the iterator, which is processed and returned by this function.
451 (e.g iterator <= upper-bound-expression-without-iterator) */
453 static __isl_give isl_ast_expr
*
454 get_upper_bound (__isl_keep isl_ast_node
*node_for
)
456 gcc_assert (isl_ast_node_get_type (node_for
) == isl_ast_node_for
);
457 isl_ast_expr
*for_cond
= isl_ast_node_for_get_cond (node_for
);
458 gcc_assert (isl_ast_expr_get_type (for_cond
) == isl_ast_expr_op
);
460 switch (isl_ast_expr_get_op_type (for_cond
))
463 res
= isl_ast_expr_get_op_arg (for_cond
, 1);
468 // (iterator < ub) => (iterator <= ub - 1)
470 isl_val_int_from_si (isl_ast_expr_get_ctx (for_cond
), 1);
471 isl_ast_expr
*ub
= isl_ast_expr_get_op_arg (for_cond
, 1);
472 res
= isl_ast_expr_sub (ub
, isl_ast_expr_from_val (one
));
479 isl_ast_expr_free (for_cond
);
483 /* All loops generated by create_empty_loop_on_edge have the form of
490 } while (lower bound < upper bound);
492 We create a new if region protecting the loop to be executed, if
493 the execution count is zero (lower bound > upper bound). */
496 graphite_create_new_loop_guard (edge entry_edge
,
497 __isl_keep isl_ast_node
*node_for
, tree
*type
,
498 tree
*lb
, tree
*ub
, ivs_params
&ip
)
500 gcc_assert (isl_ast_node_get_type (node_for
) == isl_ast_node_for
);
505 build_nonstandard_integer_type (graphite_expression_type_precision
, 0);
506 isl_ast_expr
*for_init
= isl_ast_node_for_get_init (node_for
);
507 *lb
= gcc_expression_from_isl_expression (*type
, for_init
, ip
);
508 isl_ast_expr
*upper_bound
= get_upper_bound (node_for
);
509 *ub
= gcc_expression_from_isl_expression (*type
, upper_bound
, ip
);
511 /* When ub is simply a constant or a parameter, use lb <= ub. */
512 if (TREE_CODE (*ub
) == INTEGER_CST
|| TREE_CODE (*ub
) == SSA_NAME
)
513 cond_expr
= fold_build2 (LE_EXPR
, boolean_type_node
, *lb
, *ub
);
516 tree one
= (POINTER_TYPE_P (*type
)
517 ? convert_to_ptrofftype (integer_one_node
)
518 : fold_convert (*type
, integer_one_node
));
519 /* Adding +1 and using LT_EXPR helps with loop latches that have a
520 loop iteration count of "PARAMETER - 1". For PARAMETER == 0 this
521 becomes 2^k-1 due to integer overflow, and the condition lb <= ub
522 is true, even if we do not want this. However lb < ub + 1 is false,
524 tree ub_one
= fold_build2 (POINTER_TYPE_P (*type
) ? POINTER_PLUS_EXPR
525 : PLUS_EXPR
, *type
, *ub
, one
);
527 cond_expr
= fold_build2 (LT_EXPR
, boolean_type_node
, *lb
, ub_one
);
530 exit_edge
= create_empty_if_region_on_edge (entry_edge
, cond_expr
);
535 /* Translates an isl_ast_node_for to Gimple. */
538 translate_isl_ast_node_for (loop_p context_loop
, __isl_keep isl_ast_node
*node
,
539 edge next_e
, ivs_params
&ip
)
541 gcc_assert (isl_ast_node_get_type (node
) == isl_ast_node_for
);
543 edge last_e
= graphite_create_new_loop_guard (next_e
, node
, &type
,
545 edge true_e
= get_true_edge_from_guard_bb (next_e
->dest
);
547 translate_isl_ast_for_loop (context_loop
, node
, true_e
,
552 /* Inserts in iv_map a tuple (OLD_LOOP->num, NEW_NAME) for the induction
553 variables of the loops around GBB in SESE.
555 FIXME: Instead of using a vec<tree> that maps each loop id to a possible
556 chrec, we could consider using a map<int, tree> that maps loop ids to the
557 corresponding tree expressions. */
560 build_iv_mapping (vec
<tree
> iv_map
, gimple_bb_p gbb
,
561 __isl_keep isl_ast_expr
*user_expr
, ivs_params
&ip
,
564 gcc_assert (isl_ast_expr_get_type (user_expr
) == isl_ast_expr_op
&&
565 isl_ast_expr_get_op_type (user_expr
) == isl_ast_op_call
);
567 isl_ast_expr
*arg_expr
;
568 for (i
= 1; i
< isl_ast_expr_get_op_n_arg (user_expr
); i
++)
570 arg_expr
= isl_ast_expr_get_op_arg (user_expr
, i
);
572 build_nonstandard_integer_type (graphite_expression_type_precision
, 0);
573 tree t
= gcc_expression_from_isl_expression (type
, arg_expr
, ip
);
574 loop_p old_loop
= gbb_loop_at_index (gbb
, region
, i
- 1);
575 iv_map
[old_loop
->num
] = t
;
580 /* Translates an isl_ast_node_user to Gimple.
582 FIXME: We should remove iv_map.create (loop->num + 1), if it is possible. */
585 translate_isl_ast_node_user (__isl_keep isl_ast_node
*node
,
586 edge next_e
, ivs_params
&ip
)
588 gcc_assert (isl_ast_node_get_type (node
) == isl_ast_node_user
);
589 isl_ast_expr
*user_expr
= isl_ast_node_user_get_expr (node
);
590 isl_ast_expr
*name_expr
= isl_ast_expr_get_op_arg (user_expr
, 0);
591 gcc_assert (isl_ast_expr_get_type (name_expr
) == isl_ast_expr_id
);
592 isl_id
*name_id
= isl_ast_expr_get_id (name_expr
);
593 poly_bb_p pbb
= (poly_bb_p
) isl_id_get_user (name_id
);
595 gimple_bb_p gbb
= PBB_BLACK_BOX (pbb
);
597 isl_ast_expr_free (name_expr
);
598 isl_id_free (name_id
);
600 gcc_assert (GBB_BB (gbb
) != ENTRY_BLOCK_PTR_FOR_FN (cfun
) &&
601 "The entry block should not even appear within a scop");
603 loop_p loop
= gbb_loop (gbb
);
604 iv_map
.create (loop
->num
+ 1);
605 iv_map
.safe_grow_cleared (loop
->num
+ 1);
607 build_iv_mapping (iv_map
, gbb
, user_expr
, ip
, SCOP_REGION (pbb
->scop
));
608 isl_ast_expr_free (user_expr
);
609 next_e
= copy_bb_and_scalar_dependences (GBB_BB (gbb
),
610 SCOP_REGION (pbb
->scop
), next_e
,
612 &graphite_regenerate_error
);
614 mark_virtual_operands_for_renaming (cfun
);
615 update_ssa (TODO_update_ssa
);
619 /* Translates an ISL AST node NODE to GCC representation in the
620 context of a SESE. */
623 translate_isl_ast (loop_p context_loop
, __isl_keep isl_ast_node
*node
,
624 edge next_e
, ivs_params
&ip
)
626 switch (isl_ast_node_get_type (node
))
628 case isl_ast_node_error
:
631 case isl_ast_node_for
:
632 return translate_isl_ast_node_for (context_loop
, node
,
635 case isl_ast_node_if
:
638 case isl_ast_node_user
:
639 return translate_isl_ast_node_user (node
, next_e
, ip
);
641 case isl_ast_node_block
:
649 /* Prints NODE to FILE. */
652 print_isl_ast_node (FILE *file
, __isl_keep isl_ast_node
*node
,
653 __isl_keep isl_ctx
*ctx
)
655 isl_printer
*prn
= isl_printer_to_file (ctx
, file
);
656 prn
= isl_printer_set_output_format (prn
, ISL_FORMAT_C
);
657 prn
= isl_printer_print_ast_node (prn
, node
);
658 prn
= isl_printer_print_str (prn
, "\n");
659 isl_printer_free (prn
);
662 /* Add ISL's parameter identifiers and corresponding.trees to ivs_params */
665 add_parameters_to_ivs_params (scop_p scop
, ivs_params
&ip
)
667 sese region
= SCOP_REGION (scop
);
668 unsigned nb_parameters
= isl_set_dim (scop
->context
, isl_dim_param
);
669 gcc_assert (nb_parameters
== SESE_PARAMS (region
).length ());
671 for (i
= 0; i
< nb_parameters
; i
++)
673 isl_id
*tmp_id
= isl_set_get_dim_id (scop
->context
, isl_dim_param
, i
);
674 ip
[tmp_id
] = SESE_PARAMS (region
)[i
];
679 /* Generates a build, which specifies the constraints on the parameters. */
681 static __isl_give isl_ast_build
*
682 generate_isl_context (scop_p scop
)
684 isl_set
*context_isl
= isl_set_params (isl_set_copy (scop
->context
));
685 return isl_ast_build_from_context (context_isl
);
688 /* Generates a schedule, which specifies an order used to
689 visit elements in a domain. */
691 static __isl_give isl_union_map
*
692 generate_isl_schedule (scop_p scop
)
696 isl_union_map
*schedule_isl
=
697 isl_union_map_empty (isl_set_get_space (scop
->context
));
699 FOR_EACH_VEC_ELT (SCOP_BBS (scop
), i
, pbb
)
701 /* Dead code elimination: when the domain of a PBB is empty,
702 don't generate code for the PBB. */
703 if (isl_set_is_empty (pbb
->domain
))
706 isl_map
*bb_schedule
= isl_map_copy (pbb
->transformed
);
707 bb_schedule
= isl_map_intersect_domain (bb_schedule
,
708 isl_set_copy (pbb
->domain
));
710 isl_union_map_union (schedule_isl
,
711 isl_union_map_from_map (bb_schedule
));
716 static __isl_give isl_ast_node
*
717 scop_to_isl_ast (scop_p scop
, ivs_params
&ip
)
719 /* Generate loop upper bounds that consist of the current loop iterator,
720 an operator (< or <=) and an expression not involving the iterator.
721 If this option is not set, then the current loop iterator may appear several
722 times in the upper bound. See the isl manual for more details. */
723 isl_options_set_ast_build_atomic_upper_bound (scop
->ctx
, true);
725 add_parameters_to_ivs_params (scop
, ip
);
726 isl_union_map
*schedule_isl
= generate_isl_schedule (scop
);
727 isl_ast_build
*context_isl
= generate_isl_context (scop
);
728 isl_ast_node
*ast_isl
= isl_ast_build_ast_from_schedule (context_isl
,
730 isl_ast_build_free (context_isl
);
734 /* GIMPLE Loop Generator: generates loops from STMT in GIMPLE form for
735 the given SCOP. Return true if code generation succeeded.
737 FIXME: This is not yet a full implementation of the code generator
738 with ISL ASTs. Generation of GIMPLE code has to be completed. */
741 graphite_regenerate_ast_isl (scop_p scop
)
744 sese region
= SCOP_REGION (scop
);
745 ifsese if_region
= NULL
;
746 isl_ast_node
*root_node
;
749 timevar_push (TV_GRAPHITE_CODE_GEN
);
750 graphite_regenerate_error
= false;
751 root_node
= scop_to_isl_ast (scop
, ip
);
753 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
755 fprintf (dump_file
, "\nISL AST generated by ISL: \n");
756 print_isl_ast_node (dump_file
, root_node
, scop
->ctx
);
757 fprintf (dump_file
, "\n");
760 recompute_all_dominators ();
763 if_region
= move_sese_in_condition (region
);
764 sese_insert_phis_for_liveouts (region
,
765 if_region
->region
->exit
->src
,
766 if_region
->false_region
->exit
,
767 if_region
->true_region
->exit
);
768 recompute_all_dominators ();
771 context_loop
= SESE_ENTRY (region
)->src
->loop_father
;
773 translate_isl_ast (context_loop
, root_node
, if_region
->true_region
->entry
,
777 recompute_all_dominators ();
780 if (graphite_regenerate_error
)
781 set_ifsese_condition (if_region
, integer_zero_node
);
783 free (if_region
->true_region
);
784 free (if_region
->region
);
787 ivs_params_clear (ip
);
788 isl_ast_node_free (root_node
);
789 timevar_pop (TV_GRAPHITE_CODE_GEN
);
791 return !graphite_regenerate_error
;