1 /* Single entry single exit control flow regions.
2 Copyright (C) 2008-2015 Free Software Foundation, Inc.
3 Contributed by Jan Sjodin <jan.sjodin@amd.com> and
4 Sebastian Pop <sebastian.pop@amd.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "tree-pass.h"
31 #include "tree-pretty-print.h"
32 #include "fold-const.h"
33 #include "gimple-fold.h"
36 #include "gimple-iterator.h"
37 #include "gimplify-me.h"
39 #include "tree-ssa-loop.h"
40 #include "tree-into-ssa.h"
42 #include "tree-data-ref.h"
43 #include "tree-scalar-evolution.h"
44 #include "value-prof.h"
46 #include "tree-ssa-propagate.h"
47 #include "tree-hash-traits.h"
49 /* Helper function for debug_rename_map. */
52 debug_rename_map_1 (tree_node
*const &old_name
, tree_node
*const &expr
,
55 fprintf (stderr
, "(");
56 print_generic_expr (stderr
, old_name
, 0);
57 fprintf (stderr
, ", ");
58 print_generic_expr (stderr
, expr
, 0);
59 fprintf (stderr
, ")\n");
63 typedef hash_map
<tree_ssa_name_hash
, tree
> rename_map_type
;
66 /* Print to stderr all the elements of RENAME_MAP. */
69 debug_rename_map (rename_map_type
*rename_map
)
71 rename_map
->traverse
<void *, debug_rename_map_1
> (NULL
);
75 /* Record LOOP as occurring in REGION. */
78 sese_record_loop (sese_info_p region
, loop_p loop
)
80 if (sese_contains_loop (region
, loop
))
83 bitmap_set_bit (SESE_LOOPS (region
), loop
->num
);
84 SESE_LOOP_NEST (region
).safe_push (loop
);
87 /* Build the loop nests contained in REGION. Returns true when the
88 operation was successful. */
91 build_sese_loop_nests (sese_info_p region
)
95 struct loop
*loop0
, *loop1
;
97 FOR_EACH_BB_FN (bb
, cfun
)
98 if (bb_in_sese_p (bb
, region
->region
))
100 struct loop
*loop
= bb
->loop_father
;
102 /* Only add loops if they are completely contained in the SCoP. */
103 if (loop
->header
== bb
104 && bb_in_sese_p (loop
->latch
, region
->region
))
105 sese_record_loop (region
, loop
);
108 /* Make sure that the loops in the SESE_LOOP_NEST are ordered. It
109 can be the case that an inner loop is inserted before an outer
110 loop. To avoid this, semi-sort once. */
111 FOR_EACH_VEC_ELT (SESE_LOOP_NEST (region
), i
, loop0
)
113 if (SESE_LOOP_NEST (region
).length () == i
+ 1)
116 loop1
= SESE_LOOP_NEST (region
)[i
+ 1];
117 if (loop0
->num
> loop1
->num
)
119 SESE_LOOP_NEST (region
)[i
] = loop1
;
120 SESE_LOOP_NEST (region
)[i
+ 1] = loop0
;
125 /* For a USE in BB, if BB is outside REGION, mark the USE in the
129 sese_build_liveouts_use (sese_info_p region
, bitmap liveouts
, basic_block bb
,
132 gcc_assert (!bb_in_sese_p (bb
, region
->region
));
133 if (TREE_CODE (use
) != SSA_NAME
)
136 basic_block def_bb
= gimple_bb (SSA_NAME_DEF_STMT (use
));
138 if (!def_bb
|| !bb_in_sese_p (def_bb
, region
->region
))
141 unsigned ver
= SSA_NAME_VERSION (use
);
142 bitmap_set_bit (liveouts
, ver
);
145 /* Marks for rewrite all the SSA_NAMES defined in REGION and that are
146 used in BB that is outside of the REGION. */
149 sese_build_liveouts_bb (sese_info_p region
, bitmap liveouts
, basic_block bb
)
156 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
157 for (gphi_iterator bsi
= gsi_start_phis (e
->dest
); !gsi_end_p (bsi
);
159 sese_build_liveouts_use (region
, liveouts
, bb
,
160 PHI_ARG_DEF_FROM_EDGE (bsi
.phi (), e
));
162 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);
165 gimple
*stmt
= gsi_stmt (bsi
);
167 if (is_gimple_debug (stmt
))
170 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
171 sese_build_liveouts_use (region
, liveouts
, bb
, USE_FROM_PTR (use_p
));
175 /* For a USE in BB, return true if BB is outside REGION and it's not
176 in the LIVEOUTS set. */
179 sese_bad_liveouts_use (sese_info_p region
, bitmap liveouts
, basic_block bb
,
182 gcc_assert (!bb_in_sese_p (bb
, region
->region
));
184 if (TREE_CODE (use
) != SSA_NAME
)
187 unsigned ver
= SSA_NAME_VERSION (use
);
189 /* If it's in liveouts, the variable will get a new PHI node, and
190 the debug use will be properly adjusted. */
191 if (bitmap_bit_p (liveouts
, ver
))
194 basic_block def_bb
= gimple_bb (SSA_NAME_DEF_STMT (use
));
196 if (!def_bb
|| !bb_in_sese_p (def_bb
, region
->region
))
202 /* Reset debug stmts that reference SSA_NAMES defined in REGION that
203 are not marked as liveouts. */
206 sese_reset_debug_liveouts_bb (sese_info_p region
, bitmap liveouts
, basic_block bb
)
208 gimple_stmt_iterator bsi
;
212 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
214 gimple
*stmt
= gsi_stmt (bsi
);
216 if (!is_gimple_debug (stmt
))
219 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
220 if (sese_bad_liveouts_use (region
, liveouts
, bb
,
221 USE_FROM_PTR (use_p
)))
223 gimple_debug_bind_reset_value (stmt
);
230 /* Build the LIVEOUTS of REGION: the set of variables defined inside
231 and used outside the REGION. */
234 sese_build_liveouts (sese_info_p region
, bitmap liveouts
)
238 /* FIXME: We could start iterating form the successor of sese. */
239 FOR_EACH_BB_FN (bb
, cfun
)
240 if (!bb_in_sese_p (bb
, region
->region
))
241 sese_build_liveouts_bb (region
, liveouts
, bb
);
243 /* FIXME: We could start iterating form the successor of sese. */
244 if (MAY_HAVE_DEBUG_STMTS
)
245 FOR_EACH_BB_FN (bb
, cfun
)
246 if (!bb_in_sese_p (bb
, region
->region
))
247 sese_reset_debug_liveouts_bb (region
, liveouts
, bb
);
250 /* Builds a new SESE region from edges ENTRY and EXIT. */
253 new_sese_info (edge entry
, edge exit
)
255 sese_info_p region
= XNEW (struct sese_info_t
);
257 region
->region
.entry
= entry
;
258 region
->region
.exit
= exit
;
259 SESE_LOOPS (region
) = BITMAP_ALLOC (NULL
);
260 SESE_LOOP_NEST (region
).create (3);
261 SESE_PARAMS (region
).create (3);
262 region
->bbs
.create (3);
267 /* Deletes REGION. */
270 free_sese_info (sese_info_p region
)
272 if (SESE_LOOPS (region
))
273 SESE_LOOPS (region
) = BITMAP_ALLOC (NULL
);
275 SESE_PARAMS (region
).release ();
276 SESE_LOOP_NEST (region
).release ();
281 /* Add exit phis for USE on EXIT. */
284 sese_add_exit_phis_edge (basic_block exit
, tree use
, edge false_e
, edge true_e
)
286 gphi
*phi
= create_phi_node (NULL_TREE
, exit
);
287 create_new_def_for (use
, phi
, gimple_phi_result_ptr (phi
));
288 add_phi_arg (phi
, use
, false_e
, UNKNOWN_LOCATION
);
289 add_phi_arg (phi
, use
, true_e
, UNKNOWN_LOCATION
);
293 /* Insert in the block BB phi nodes for variables defined in REGION
294 and used outside the REGION. The code generation moves REGION in
295 the else clause of an "if (1)" and generates code in the then
296 clause that is at this point empty:
305 sese_insert_phis_for_liveouts (sese_info_p region
, basic_block bb
,
306 edge false_e
, edge true_e
)
310 bitmap liveouts
= BITMAP_ALLOC (NULL
);
312 update_ssa (TODO_update_ssa
);
314 sese_build_liveouts (region
, liveouts
);
315 EXECUTE_IF_SET_IN_BITMAP (liveouts
, 0, i
, bi
)
316 sese_add_exit_phis_edge (bb
, ssa_name (i
), false_e
, true_e
);
317 BITMAP_FREE (liveouts
);
319 update_ssa (TODO_update_ssa
);
322 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */
325 get_true_edge_from_guard_bb (basic_block bb
)
330 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
331 if (e
->flags
& EDGE_TRUE_VALUE
)
338 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared. */
341 get_false_edge_from_guard_bb (basic_block bb
)
346 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
347 if (!(e
->flags
& EDGE_TRUE_VALUE
))
354 /* Returns the expression associated to OLD_NAME in RENAME_MAP. */
357 get_rename (rename_map_type
*rename_map
, tree old_name
)
359 gcc_assert (TREE_CODE (old_name
) == SSA_NAME
);
360 tree
*expr
= rename_map
->get (old_name
);
367 /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */
370 set_rename (rename_map_type
*rename_map
, tree old_name
, tree expr
)
374 fprintf (dump_file
, "[codegen] setting rename: old_name = ");
375 print_generic_expr (dump_file
, old_name
, 0);
376 fprintf (dump_file
, ", new_name = ");
377 print_generic_expr (dump_file
, expr
, 0);
378 fprintf (dump_file
, "\n");
381 if (old_name
== expr
)
384 rename_map
->put (old_name
, expr
);
387 /* Renames the scalar uses of the statement COPY, using the
388 substitution map RENAME_MAP, inserting the gimplification code at
389 GSI_TGT, for the translation REGION, with the original copied
390 statement in LOOP, and using the induction variable renaming map
391 IV_MAP. Returns true when something has been renamed. GLOOG_ERROR
392 is set when the code generation cannot continue. */
395 rename_uses (gimple
*copy
, rename_map_type
*rename_map
,
396 gimple_stmt_iterator
*gsi_tgt
,
397 sese_info_p region
, loop_p loop
, vec
<tree
> iv_map
,
402 bool changed
= false;
404 if (is_gimple_debug (copy
))
406 if (gimple_debug_bind_p (copy
))
407 gimple_debug_bind_reset_value (copy
);
408 else if (gimple_debug_source_bind_p (copy
))
416 FOR_EACH_SSA_USE_OPERAND (use_p
, copy
, op_iter
, SSA_OP_USE
)
418 tree old_name
= USE_FROM_PTR (use_p
);
422 if (TREE_CODE (old_name
) != SSA_NAME
423 || SSA_NAME_IS_DEFAULT_DEF (old_name
))
427 new_expr
= get_rename (rename_map
, old_name
);
430 tree type_old_name
= TREE_TYPE (old_name
);
431 tree type_new_expr
= TREE_TYPE (new_expr
);
433 if (type_old_name
!= type_new_expr
434 || TREE_CODE (new_expr
) != SSA_NAME
)
436 tree var
= create_tmp_var (type_old_name
, "var");
438 if (!useless_type_conversion_p (type_old_name
, type_new_expr
))
439 new_expr
= fold_convert (type_old_name
, new_expr
);
441 new_expr
= force_gimple_operand (new_expr
, &stmts
, true, var
);
442 gsi_insert_seq_before (gsi_tgt
, stmts
, GSI_SAME_STMT
);
445 replace_exp (use_p
, new_expr
);
449 scev
= scalar_evolution_in_region (region
->region
, loop
, old_name
);
451 /* At this point we should know the exact scev for each
452 scalar SSA_NAME used in the scop: all the other scalar
453 SSA_NAMEs should have been translated out of SSA using
454 arrays with one element. */
455 if (chrec_contains_undetermined (scev
))
458 new_expr
= build_zero_cst (TREE_TYPE (old_name
));
461 new_expr
= chrec_apply_map (scev
, iv_map
);
463 /* The apply should produce an expression tree containing
464 the uses of the new induction variables. We should be
465 able to use new_expr instead of the old_name in the newly
466 generated loop nest. */
467 if (chrec_contains_undetermined (new_expr
)
468 || tree_contains_chrecs (new_expr
, NULL
))
471 new_expr
= build_zero_cst (TREE_TYPE (old_name
));
474 /* Replace the old_name with the new_expr. */
475 new_expr
= force_gimple_operand (unshare_expr (new_expr
), &stmts
,
478 gsi_insert_seq_before (gsi_tgt
, stmts
, GSI_SAME_STMT
);
479 replace_exp (use_p
, new_expr
);
481 if (TREE_CODE (new_expr
) == INTEGER_CST
482 && is_gimple_assign (copy
))
484 tree rhs
= gimple_assign_rhs1 (copy
);
486 if (TREE_CODE (rhs
) == ADDR_EXPR
)
487 recompute_tree_invariant_for_addr_expr (rhs
);
490 set_rename (rename_map
, old_name
, new_expr
);
496 /* Duplicates the statements of basic block BB into basic block NEW_BB
497 and compute the new induction variables according to the IV_MAP.
498 GLOOG_ERROR is set when the code generation cannot continue. */
501 graphite_copy_stmts_from_block (basic_block bb
, basic_block new_bb
,
502 rename_map_type
*rename_map
,
503 vec
<tree
> iv_map
, sese_info_p region
,
506 gimple_stmt_iterator gsi
, gsi_tgt
;
507 loop_p loop
= bb
->loop_father
;
509 gsi_tgt
= gsi_start_bb (new_bb
);
510 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
514 gimple
*stmt
= gsi_stmt (gsi
);
518 /* Do not copy labels or conditions. */
519 if (gimple_code (stmt
) == GIMPLE_LABEL
520 || gimple_code (stmt
) == GIMPLE_COND
)
523 /* Do not copy induction variables. */
524 if (is_gimple_assign (stmt
)
525 && (lhs
= gimple_assign_lhs (stmt
))
526 && TREE_CODE (lhs
) == SSA_NAME
527 && is_gimple_reg (lhs
)
528 && scev_analyzable_p (lhs
, region
->region
))
531 /* Create a new copy of STMT and duplicate STMT's virtual
533 copy
= gimple_copy (stmt
);
534 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
536 maybe_duplicate_eh_stmt (copy
, stmt
);
537 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
539 /* Create new names for all the definitions created by COPY and
540 add replacement mappings for each new name. */
541 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
543 tree old_name
= DEF_FROM_PTR (def_p
);
544 tree new_name
= create_new_def_for (old_name
, copy
, def_p
);
545 set_rename (rename_map
, old_name
, new_name
);
548 if (rename_uses (copy
, rename_map
, &gsi_tgt
, region
, loop
, iv_map
,
551 gcc_assert (gsi_stmt (gsi_tgt
) == copy
);
552 fold_stmt_inplace (&gsi_tgt
);
559 /* Copies BB and includes in the copied BB all the statements that can
560 be reached following the use-def chains from the memory accesses,
561 and returns the next edge following this new block. GLOOG_ERROR is
562 set when the code generation cannot continue. */
565 copy_bb_and_scalar_dependences (basic_block bb
, sese_info_p region
,
566 edge next_e
, vec
<tree
> iv_map
,
569 basic_block new_bb
= split_edge (next_e
);
570 rename_map_type
rename_map (10);
572 next_e
= single_succ_edge (new_bb
);
573 graphite_copy_stmts_from_block (bb
, new_bb
, &rename_map
, iv_map
, region
,
575 remove_phi_nodes (new_bb
);
580 /* Returns the outermost loop in SCOP that contains BB. */
583 outermost_loop_in_sese_1 (sese_l
®ion
, basic_block bb
)
587 nest
= bb
->loop_father
;
588 while (loop_outer (nest
)
589 && loop_in_sese_p (loop_outer (nest
), region
))
590 nest
= loop_outer (nest
);
595 /* Same as outermost_loop_in_sese_1, returns the outermost loop
596 containing BB in REGION, but makes sure that the returned loop
597 belongs to the REGION, and so this returns the first loop in the
598 REGION when the loop containing BB does not belong to REGION. */
601 outermost_loop_in_sese (sese_l
®ion
, basic_block bb
)
603 loop_p nest
= outermost_loop_in_sese_1 (region
, bb
);
605 if (loop_in_sese_p (nest
, region
))
608 /* When the basic block BB does not belong to a loop in the region,
609 return the first loop in the region. */
612 if (loop_in_sese_p (nest
, region
))
621 /* Sets the false region of an IF_REGION to REGION. */
624 if_region_set_false_region (ifsese if_region
, sese_info_p region
)
626 basic_block condition
= if_region_get_condition_block (if_region
);
627 edge false_edge
= get_false_edge_from_guard_bb (condition
);
628 basic_block dummy
= false_edge
->dest
;
629 edge entry_region
= region
->region
.entry
;
630 edge exit_region
= region
->region
.exit
;
631 basic_block before_region
= entry_region
->src
;
632 basic_block last_in_region
= exit_region
->src
;
633 hashval_t hash
= htab_hash_pointer (exit_region
);
635 = current_loops
->exits
->find_slot_with_hash (exit_region
, hash
, NO_INSERT
);
637 entry_region
->flags
= false_edge
->flags
;
638 false_edge
->flags
= exit_region
->flags
;
640 redirect_edge_pred (entry_region
, condition
);
641 redirect_edge_pred (exit_region
, before_region
);
642 redirect_edge_pred (false_edge
, last_in_region
);
643 redirect_edge_succ (false_edge
, single_succ (dummy
));
644 delete_basic_block (dummy
);
646 exit_region
->flags
= EDGE_FALLTHRU
;
647 recompute_all_dominators ();
649 region
->region
.exit
= false_edge
;
651 free (if_region
->false_region
);
652 if_region
->false_region
= region
;
656 struct loop_exit
*loop_exit
= ggc_cleared_alloc
<struct loop_exit
> ();
658 memcpy (loop_exit
, *((struct loop_exit
**) slot
), sizeof (struct loop_exit
));
659 current_loops
->exits
->clear_slot (slot
);
661 hashval_t hash
= htab_hash_pointer (false_edge
);
662 slot
= current_loops
->exits
->find_slot_with_hash (false_edge
, hash
,
664 loop_exit
->e
= false_edge
;
666 false_edge
->src
->loop_father
->exits
->next
= loop_exit
;
670 /* Creates an IFSESE with CONDITION on edge ENTRY. */
673 create_if_region_on_edge (edge entry
, tree condition
)
677 sese_info_p sese_region
= XNEW (struct sese_info_t
);
678 sese_info_p true_region
= XNEW (struct sese_info_t
);
679 sese_info_p false_region
= XNEW (struct sese_info_t
);
680 ifsese if_region
= XNEW (struct ifsese_s
);
681 edge exit
= create_empty_if_region_on_edge (entry
, condition
);
683 if_region
->region
= sese_region
;
684 if_region
->region
->region
.entry
= entry
;
685 if_region
->region
->region
.exit
= exit
;
687 FOR_EACH_EDGE (e
, ei
, entry
->dest
->succs
)
689 if (e
->flags
& EDGE_TRUE_VALUE
)
691 true_region
->region
.entry
= e
;
692 true_region
->region
.exit
= single_succ_edge (e
->dest
);
693 if_region
->true_region
= true_region
;
695 else if (e
->flags
& EDGE_FALSE_VALUE
)
697 false_region
->region
.entry
= e
;
698 false_region
->region
.exit
= single_succ_edge (e
->dest
);
699 if_region
->false_region
= false_region
;
706 /* Moves REGION in a condition expression:
714 move_sese_in_condition (sese_info_p region
)
716 basic_block pred_block
= split_edge (region
->region
.entry
);
719 region
->region
.entry
= single_succ_edge (pred_block
);
720 if_region
= create_if_region_on_edge (single_pred_edge (pred_block
),
722 if_region_set_false_region (if_region
, region
);
727 /* Replaces the condition of the IF_REGION with CONDITION:
735 set_ifsese_condition (ifsese if_region
, tree condition
)
737 sese_info_p region
= if_region
->region
;
738 edge entry
= region
->region
.entry
;
739 basic_block bb
= entry
->dest
;
740 gimple
*last
= last_stmt (bb
);
741 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
744 gcc_assert (gimple_code (last
) == GIMPLE_COND
);
746 gsi_remove (&gsi
, true);
747 gsi
= gsi_last_bb (bb
);
748 condition
= force_gimple_operand_gsi (&gsi
, condition
, true, NULL
,
749 false, GSI_NEW_STMT
);
750 cond_stmt
= gimple_build_cond_from_tree (condition
, NULL_TREE
, NULL_TREE
);
751 gsi
= gsi_last_bb (bb
);
752 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
755 /* Return true when T is defined outside REGION or when no definitions are
756 variant in REGION. When HAS_VDEFS is a valid pointer, sets HAS_VDEFS to true
757 when T depends on memory that may change in REGION. */
760 invariant_in_sese_p_rec (tree t
, sese_l
®ion
, bool *has_vdefs
)
764 if (!defined_in_sese_p (t
, region
))
767 gimple
*stmt
= SSA_NAME_DEF_STMT (t
);
769 if (gimple_code (stmt
) == GIMPLE_PHI
770 || gimple_code (stmt
) == GIMPLE_CALL
)
773 /* VDEF is variant when it is in the region. */
774 if (gimple_vdef (stmt
))
781 /* A VUSE may or may not be variant following the VDEFs. */
782 if (tree vuse
= gimple_vuse (stmt
))
783 return invariant_in_sese_p_rec (vuse
, region
, has_vdefs
);
785 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
787 tree use
= USE_FROM_PTR (use_p
);
789 if (!defined_in_sese_p (use
, region
))
792 if (!invariant_in_sese_p_rec (use
, region
, has_vdefs
))
799 /* Returns the scalar evolution of T in REGION. Every variable that
800 is not defined in the REGION is considered a parameter. */
803 scalar_evolution_in_region (sese_l
®ion
, loop_p loop
, tree t
)
806 struct loop
*def_loop
;
807 basic_block before
= region
.entry
->src
;
809 /* SCOP parameters. */
810 if (TREE_CODE (t
) == SSA_NAME
811 && !defined_in_sese_p (t
, region
))
814 if (TREE_CODE (t
) != SSA_NAME
815 || loop_in_sese_p (loop
, region
))
816 return instantiate_scev (before
, loop
,
817 analyze_scalar_evolution (loop
, t
));
819 def
= SSA_NAME_DEF_STMT (t
);
820 def_loop
= loop_containing_stmt (def
);
822 if (loop_in_sese_p (def_loop
, region
))
824 t
= analyze_scalar_evolution (def_loop
, t
);
825 def_loop
= superloop_at_depth (def_loop
, loop_depth (loop
) + 1);
826 t
= compute_overall_effect_of_inner_loop (def_loop
, t
);
830 bool has_vdefs
= false;
831 if (invariant_in_sese_p_rec (t
, region
, &has_vdefs
))
834 /* T variates in REGION. */
836 return chrec_dont_know
;
838 return instantiate_scev (before
, loop
, t
);