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"
30 #include "hard-reg-set.h"
33 #include "fold-const.h"
34 #include "tree-pretty-print.h"
35 #include "internal-fn.h"
36 #include "gimple-fold.h"
39 #include "gimple-iterator.h"
40 #include "gimplify-me.h"
42 #include "tree-ssa-loop.h"
43 #include "tree-into-ssa.h"
45 #include "tree-chrec.h"
46 #include "tree-data-ref.h"
47 #include "tree-scalar-evolution.h"
48 #include "tree-pass.h"
49 #include "value-prof.h"
51 #include "tree-ssa-propagate.h"
52 #include "tree-hash-traits.h"
54 /* Helper function for debug_rename_map. */
57 debug_rename_map_1 (tree_node
*const &old_name
, tree_node
*const &expr
,
60 fprintf (stderr
, "(");
61 print_generic_expr (stderr
, old_name
, 0);
62 fprintf (stderr
, ", ");
63 print_generic_expr (stderr
, expr
, 0);
64 fprintf (stderr
, ")\n");
68 typedef hash_map
<tree_ssa_name_hash
, tree
> rename_map_type
;
71 /* Print to stderr all the elements of RENAME_MAP. */
74 debug_rename_map (rename_map_type
*rename_map
)
76 rename_map
->traverse
<void *, debug_rename_map_1
> (NULL
);
80 /* Record LOOP as occurring in REGION. */
83 sese_record_loop (sese_info_p region
, loop_p loop
)
85 if (sese_contains_loop (region
, loop
))
88 bitmap_set_bit (SESE_LOOPS (region
), loop
->num
);
89 SESE_LOOP_NEST (region
).safe_push (loop
);
92 /* Build the loop nests contained in REGION. Returns true when the
93 operation was successful. */
96 build_sese_loop_nests (sese_info_p region
)
100 struct loop
*loop0
, *loop1
;
102 FOR_EACH_BB_FN (bb
, cfun
)
103 if (bb_in_sese_p (bb
, region
->region
))
105 struct loop
*loop
= bb
->loop_father
;
107 /* Only add loops if they are completely contained in the SCoP. */
108 if (loop
->header
== bb
109 && bb_in_sese_p (loop
->latch
, region
->region
))
110 sese_record_loop (region
, loop
);
113 /* Make sure that the loops in the SESE_LOOP_NEST are ordered. It
114 can be the case that an inner loop is inserted before an outer
115 loop. To avoid this, semi-sort once. */
116 FOR_EACH_VEC_ELT (SESE_LOOP_NEST (region
), i
, loop0
)
118 if (SESE_LOOP_NEST (region
).length () == i
+ 1)
121 loop1
= SESE_LOOP_NEST (region
)[i
+ 1];
122 if (loop0
->num
> loop1
->num
)
124 SESE_LOOP_NEST (region
)[i
] = loop1
;
125 SESE_LOOP_NEST (region
)[i
+ 1] = loop0
;
130 /* For a USE in BB, if BB is outside REGION, mark the USE in the
134 sese_build_liveouts_use (sese_info_p region
, bitmap liveouts
, basic_block bb
,
137 gcc_assert (!bb_in_sese_p (bb
, region
->region
));
138 if (TREE_CODE (use
) != SSA_NAME
)
141 basic_block def_bb
= gimple_bb (SSA_NAME_DEF_STMT (use
));
143 if (!def_bb
|| !bb_in_sese_p (def_bb
, region
->region
))
146 unsigned ver
= SSA_NAME_VERSION (use
);
147 bitmap_set_bit (liveouts
, ver
);
150 /* Marks for rewrite all the SSA_NAMES defined in REGION and that are
151 used in BB that is outside of the REGION. */
154 sese_build_liveouts_bb (sese_info_p region
, bitmap liveouts
, basic_block bb
)
161 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
162 for (gphi_iterator bsi
= gsi_start_phis (e
->dest
); !gsi_end_p (bsi
);
164 sese_build_liveouts_use (region
, liveouts
, bb
,
165 PHI_ARG_DEF_FROM_EDGE (bsi
.phi (), e
));
167 for (gimple_stmt_iterator bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
);
170 gimple
*stmt
= gsi_stmt (bsi
);
172 if (is_gimple_debug (stmt
))
175 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
176 sese_build_liveouts_use (region
, liveouts
, bb
, USE_FROM_PTR (use_p
));
180 /* For a USE in BB, return true if BB is outside REGION and it's not
181 in the LIVEOUTS set. */
184 sese_bad_liveouts_use (sese_info_p region
, bitmap liveouts
, basic_block bb
,
187 gcc_assert (!bb_in_sese_p (bb
, region
->region
));
189 if (TREE_CODE (use
) != SSA_NAME
)
192 unsigned ver
= SSA_NAME_VERSION (use
);
194 /* If it's in liveouts, the variable will get a new PHI node, and
195 the debug use will be properly adjusted. */
196 if (bitmap_bit_p (liveouts
, ver
))
199 basic_block def_bb
= gimple_bb (SSA_NAME_DEF_STMT (use
));
201 if (!def_bb
|| !bb_in_sese_p (def_bb
, region
->region
))
207 /* Reset debug stmts that reference SSA_NAMES defined in REGION that
208 are not marked as liveouts. */
211 sese_reset_debug_liveouts_bb (sese_info_p region
, bitmap liveouts
, basic_block bb
)
213 gimple_stmt_iterator bsi
;
217 for (bsi
= gsi_start_bb (bb
); !gsi_end_p (bsi
); gsi_next (&bsi
))
219 gimple
*stmt
= gsi_stmt (bsi
);
221 if (!is_gimple_debug (stmt
))
224 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
225 if (sese_bad_liveouts_use (region
, liveouts
, bb
,
226 USE_FROM_PTR (use_p
)))
228 gimple_debug_bind_reset_value (stmt
);
235 /* Build the LIVEOUTS of REGION: the set of variables defined inside
236 and used outside the REGION. */
239 sese_build_liveouts (sese_info_p region
, bitmap liveouts
)
243 /* FIXME: We could start iterating form the successor of sese. */
244 FOR_EACH_BB_FN (bb
, cfun
)
245 if (!bb_in_sese_p (bb
, region
->region
))
246 sese_build_liveouts_bb (region
, liveouts
, bb
);
248 /* FIXME: We could start iterating form the successor of sese. */
249 if (MAY_HAVE_DEBUG_STMTS
)
250 FOR_EACH_BB_FN (bb
, cfun
)
251 if (!bb_in_sese_p (bb
, region
->region
))
252 sese_reset_debug_liveouts_bb (region
, liveouts
, bb
);
255 /* Builds a new SESE region from edges ENTRY and EXIT. */
258 new_sese_info (edge entry
, edge exit
)
260 sese_info_p region
= XNEW (struct sese_info_t
);
262 region
->region
.entry
= entry
;
263 region
->region
.exit
= exit
;
264 SESE_LOOPS (region
) = BITMAP_ALLOC (NULL
);
265 SESE_LOOP_NEST (region
).create (3);
266 SESE_PARAMS (region
).create (3);
267 region
->parameter_rename_map
= new parameter_rename_map_t
;
272 /* Deletes REGION. */
275 free_sese_info (sese_info_p region
)
277 if (SESE_LOOPS (region
))
278 SESE_LOOPS (region
) = BITMAP_ALLOC (NULL
);
280 SESE_PARAMS (region
).release ();
281 SESE_LOOP_NEST (region
).release ();
282 delete region
->parameter_rename_map
;
283 region
->parameter_rename_map
= NULL
;
288 /* Add exit phis for USE on EXIT. */
291 sese_add_exit_phis_edge (basic_block exit
, tree use
, edge false_e
, edge true_e
)
293 gphi
*phi
= create_phi_node (NULL_TREE
, exit
);
294 create_new_def_for (use
, phi
, gimple_phi_result_ptr (phi
));
295 add_phi_arg (phi
, use
, false_e
, UNKNOWN_LOCATION
);
296 add_phi_arg (phi
, use
, true_e
, UNKNOWN_LOCATION
);
300 /* Insert in the block BB phi nodes for variables defined in REGION
301 and used outside the REGION. The code generation moves REGION in
302 the else clause of an "if (1)" and generates code in the then
303 clause that is at this point empty:
312 sese_insert_phis_for_liveouts (sese_info_p region
, basic_block bb
,
313 edge false_e
, edge true_e
)
317 bitmap liveouts
= BITMAP_ALLOC (NULL
);
319 update_ssa (TODO_update_ssa
);
321 sese_build_liveouts (region
, liveouts
);
322 EXECUTE_IF_SET_IN_BITMAP (liveouts
, 0, i
, bi
)
323 sese_add_exit_phis_edge (bb
, ssa_name (i
), false_e
, true_e
);
324 BITMAP_FREE (liveouts
);
326 update_ssa (TODO_update_ssa
);
329 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */
332 get_true_edge_from_guard_bb (basic_block bb
)
337 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
338 if (e
->flags
& EDGE_TRUE_VALUE
)
345 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared. */
348 get_false_edge_from_guard_bb (basic_block bb
)
353 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
354 if (!(e
->flags
& EDGE_TRUE_VALUE
))
361 /* Returns the expression associated to OLD_NAME in RENAME_MAP. */
364 get_rename (rename_map_type
*rename_map
, tree old_name
)
366 gcc_assert (TREE_CODE (old_name
) == SSA_NAME
);
367 tree
*expr
= rename_map
->get (old_name
);
374 /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */
377 set_rename (rename_map_type
*rename_map
, tree old_name
, tree expr
,
380 if (old_name
== expr
)
383 rename_map
->put (old_name
, expr
);
387 /* For a parameter of a scop we dont want to rename it. */
388 FOR_EACH_VEC_ELT (SESE_PARAMS (region
), i
, t
)
390 region
->parameter_rename_map
->put(old_name
, expr
);
393 /* Renames the scalar uses of the statement COPY, using the
394 substitution map RENAME_MAP, inserting the gimplification code at
395 GSI_TGT, for the translation REGION, with the original copied
396 statement in LOOP, and using the induction variable renaming map
397 IV_MAP. Returns true when something has been renamed. GLOOG_ERROR
398 is set when the code generation cannot continue. */
401 rename_uses (gimple
*copy
, rename_map_type
*rename_map
,
402 gimple_stmt_iterator
*gsi_tgt
,
403 sese_info_p region
, loop_p loop
, vec
<tree
> iv_map
,
408 bool changed
= false;
410 if (is_gimple_debug (copy
))
412 if (gimple_debug_bind_p (copy
))
413 gimple_debug_bind_reset_value (copy
);
414 else if (gimple_debug_source_bind_p (copy
))
422 FOR_EACH_SSA_USE_OPERAND (use_p
, copy
, op_iter
, SSA_OP_USE
)
424 tree old_name
= USE_FROM_PTR (use_p
);
428 if (TREE_CODE (old_name
) != SSA_NAME
429 || SSA_NAME_IS_DEFAULT_DEF (old_name
))
433 new_expr
= get_rename (rename_map
, old_name
);
436 tree type_old_name
= TREE_TYPE (old_name
);
437 tree type_new_expr
= TREE_TYPE (new_expr
);
439 if (type_old_name
!= type_new_expr
440 || TREE_CODE (new_expr
) != SSA_NAME
)
442 tree var
= create_tmp_var (type_old_name
, "var");
444 if (!useless_type_conversion_p (type_old_name
, type_new_expr
))
445 new_expr
= fold_convert (type_old_name
, new_expr
);
447 new_expr
= force_gimple_operand (new_expr
, &stmts
, true, var
);
448 gsi_insert_seq_before (gsi_tgt
, stmts
, GSI_SAME_STMT
);
451 replace_exp (use_p
, new_expr
);
455 scev
= scalar_evolution_in_region (region
->region
, loop
, old_name
);
457 /* At this point we should know the exact scev for each
458 scalar SSA_NAME used in the scop: all the other scalar
459 SSA_NAMEs should have been translated out of SSA using
460 arrays with one element. */
461 if (chrec_contains_undetermined (scev
))
464 new_expr
= build_zero_cst (TREE_TYPE (old_name
));
467 new_expr
= chrec_apply_map (scev
, iv_map
);
469 /* The apply should produce an expression tree containing
470 the uses of the new induction variables. We should be
471 able to use new_expr instead of the old_name in the newly
472 generated loop nest. */
473 if (chrec_contains_undetermined (new_expr
)
474 || tree_contains_chrecs (new_expr
, NULL
))
477 new_expr
= build_zero_cst (TREE_TYPE (old_name
));
480 /* Replace the old_name with the new_expr. */
481 new_expr
= force_gimple_operand (unshare_expr (new_expr
), &stmts
,
484 gsi_insert_seq_before (gsi_tgt
, stmts
, GSI_SAME_STMT
);
485 replace_exp (use_p
, new_expr
);
487 if (TREE_CODE (new_expr
) == INTEGER_CST
488 && is_gimple_assign (copy
))
490 tree rhs
= gimple_assign_rhs1 (copy
);
492 if (TREE_CODE (rhs
) == ADDR_EXPR
)
493 recompute_tree_invariant_for_addr_expr (rhs
);
496 set_rename (rename_map
, old_name
, new_expr
, region
);
502 /* Duplicates the statements of basic block BB into basic block NEW_BB
503 and compute the new induction variables according to the IV_MAP.
504 GLOOG_ERROR is set when the code generation cannot continue. */
507 graphite_copy_stmts_from_block (basic_block bb
, basic_block new_bb
,
508 rename_map_type
*rename_map
,
509 vec
<tree
> iv_map
, sese_info_p region
,
512 gimple_stmt_iterator gsi
, gsi_tgt
;
513 loop_p loop
= bb
->loop_father
;
515 gsi_tgt
= gsi_start_bb (new_bb
);
516 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
520 gimple
*stmt
= gsi_stmt (gsi
);
524 /* Do not copy labels or conditions. */
525 if (gimple_code (stmt
) == GIMPLE_LABEL
526 || gimple_code (stmt
) == GIMPLE_COND
)
529 /* Do not copy induction variables. */
530 if (is_gimple_assign (stmt
)
531 && (lhs
= gimple_assign_lhs (stmt
))
532 && TREE_CODE (lhs
) == SSA_NAME
533 && is_gimple_reg (lhs
)
534 && scev_analyzable_p (lhs
, region
->region
))
537 /* Do not copy parameters that have been generated in the header of the
539 if (is_gimple_assign (stmt
)
540 && (lhs
= gimple_assign_lhs (stmt
))
541 && TREE_CODE (lhs
) == SSA_NAME
542 && region
->parameter_rename_map
->get(lhs
))
545 /* Create a new copy of STMT and duplicate STMT's virtual
547 copy
= gimple_copy (stmt
);
548 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
550 maybe_duplicate_eh_stmt (copy
, stmt
);
551 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
553 /* Create new names for all the definitions created by COPY and
554 add replacement mappings for each new name. */
555 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
557 tree old_name
= DEF_FROM_PTR (def_p
);
558 tree new_name
= create_new_def_for (old_name
, copy
, def_p
);
559 set_rename (rename_map
, old_name
, new_name
, region
);
562 if (rename_uses (copy
, rename_map
, &gsi_tgt
, region
, loop
, iv_map
,
565 gcc_assert (gsi_stmt (gsi_tgt
) == copy
);
566 fold_stmt_inplace (&gsi_tgt
);
569 /* For each SSA_NAME in the parameter_rename_map rename their usage. */
572 if (!is_gimple_debug (copy
))
573 FOR_EACH_SSA_USE_OPERAND (use_p
, copy
, iter
, SSA_OP_USE
)
575 tree old_name
= USE_FROM_PTR (use_p
);
577 if (TREE_CODE (old_name
) != SSA_NAME
578 || SSA_NAME_IS_DEFAULT_DEF (old_name
))
581 tree
*new_expr
= region
->parameter_rename_map
->get (old_name
);
585 replace_exp (use_p
, *new_expr
);
592 /* Copies BB and includes in the copied BB all the statements that can
593 be reached following the use-def chains from the memory accesses,
594 and returns the next edge following this new block. GLOOG_ERROR is
595 set when the code generation cannot continue. */
598 copy_bb_and_scalar_dependences (basic_block bb
, sese_info_p region
,
599 edge next_e
, vec
<tree
> iv_map
,
602 basic_block new_bb
= split_edge (next_e
);
603 rename_map_type
rename_map (10);
605 next_e
= single_succ_edge (new_bb
);
606 graphite_copy_stmts_from_block (bb
, new_bb
, &rename_map
, iv_map
, region
,
608 remove_phi_nodes (new_bb
);
613 /* Returns the outermost loop in SCOP that contains BB. */
616 outermost_loop_in_sese_1 (sese_l
®ion
, basic_block bb
)
620 nest
= bb
->loop_father
;
621 while (loop_outer (nest
)
622 && loop_in_sese_p (loop_outer (nest
), region
))
623 nest
= loop_outer (nest
);
628 /* Same as outermost_loop_in_sese_1, returns the outermost loop
629 containing BB in REGION, but makes sure that the returned loop
630 belongs to the REGION, and so this returns the first loop in the
631 REGION when the loop containing BB does not belong to REGION. */
634 outermost_loop_in_sese (sese_l
®ion
, basic_block bb
)
636 loop_p nest
= outermost_loop_in_sese_1 (region
, bb
);
638 if (loop_in_sese_p (nest
, region
))
641 /* When the basic block BB does not belong to a loop in the region,
642 return the first loop in the region. */
645 if (loop_in_sese_p (nest
, region
))
654 /* Sets the false region of an IF_REGION to REGION. */
657 if_region_set_false_region (ifsese if_region
, sese_info_p region
)
659 basic_block condition
= if_region_get_condition_block (if_region
);
660 edge false_edge
= get_false_edge_from_guard_bb (condition
);
661 basic_block dummy
= false_edge
->dest
;
662 edge entry_region
= region
->region
.entry
;
663 edge exit_region
= region
->region
.exit
;
664 basic_block before_region
= entry_region
->src
;
665 basic_block last_in_region
= exit_region
->src
;
666 hashval_t hash
= htab_hash_pointer (exit_region
);
668 = current_loops
->exits
->find_slot_with_hash (exit_region
, hash
, NO_INSERT
);
670 entry_region
->flags
= false_edge
->flags
;
671 false_edge
->flags
= exit_region
->flags
;
673 redirect_edge_pred (entry_region
, condition
);
674 redirect_edge_pred (exit_region
, before_region
);
675 redirect_edge_pred (false_edge
, last_in_region
);
676 redirect_edge_succ (false_edge
, single_succ (dummy
));
677 delete_basic_block (dummy
);
679 exit_region
->flags
= EDGE_FALLTHRU
;
680 recompute_all_dominators ();
682 region
->region
.exit
= false_edge
;
684 free (if_region
->false_region
);
685 if_region
->false_region
= region
;
689 struct loop_exit
*loop_exit
= ggc_cleared_alloc
<struct loop_exit
> ();
691 memcpy (loop_exit
, *((struct loop_exit
**) slot
), sizeof (struct loop_exit
));
692 current_loops
->exits
->clear_slot (slot
);
694 hashval_t hash
= htab_hash_pointer (false_edge
);
695 slot
= current_loops
->exits
->find_slot_with_hash (false_edge
, hash
,
697 loop_exit
->e
= false_edge
;
699 false_edge
->src
->loop_father
->exits
->next
= loop_exit
;
703 /* Creates an IFSESE with CONDITION on edge ENTRY. */
706 create_if_region_on_edge (edge entry
, tree condition
)
710 sese_info_p sese_region
= XNEW (struct sese_info_t
);
711 sese_info_p true_region
= XNEW (struct sese_info_t
);
712 sese_info_p false_region
= XNEW (struct sese_info_t
);
713 ifsese if_region
= XNEW (struct ifsese_s
);
714 edge exit
= create_empty_if_region_on_edge (entry
, condition
);
716 if_region
->region
= sese_region
;
717 if_region
->region
->region
.entry
= entry
;
718 if_region
->region
->region
.exit
= exit
;
720 FOR_EACH_EDGE (e
, ei
, entry
->dest
->succs
)
722 if (e
->flags
& EDGE_TRUE_VALUE
)
724 true_region
->region
.entry
= e
;
725 true_region
->region
.exit
= single_succ_edge (e
->dest
);
726 if_region
->true_region
= true_region
;
728 else if (e
->flags
& EDGE_FALSE_VALUE
)
730 false_region
->region
.entry
= e
;
731 false_region
->region
.exit
= single_succ_edge (e
->dest
);
732 if_region
->false_region
= false_region
;
739 /* Moves REGION in a condition expression:
747 move_sese_in_condition (sese_info_p region
)
749 basic_block pred_block
= split_edge (region
->region
.entry
);
752 region
->region
.entry
= single_succ_edge (pred_block
);
753 if_region
= create_if_region_on_edge (single_pred_edge (pred_block
),
755 if_region_set_false_region (if_region
, region
);
760 /* Replaces the condition of the IF_REGION with CONDITION:
768 set_ifsese_condition (ifsese if_region
, tree condition
)
770 sese_info_p region
= if_region
->region
;
771 edge entry
= region
->region
.entry
;
772 basic_block bb
= entry
->dest
;
773 gimple
*last
= last_stmt (bb
);
774 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
777 gcc_assert (gimple_code (last
) == GIMPLE_COND
);
779 gsi_remove (&gsi
, true);
780 gsi
= gsi_last_bb (bb
);
781 condition
= force_gimple_operand_gsi (&gsi
, condition
, true, NULL
,
782 false, GSI_NEW_STMT
);
783 cond_stmt
= gimple_build_cond_from_tree (condition
, NULL_TREE
, NULL_TREE
);
784 gsi
= gsi_last_bb (bb
);
785 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
788 /* Return true when T is defined outside REGION or when no definitions are
789 variant in REGION. */
792 invariant_in_sese_p_rec (tree t
, sese_l
®ion
)
796 if (!defined_in_sese_p (t
, region
))
799 gimple
*stmt
= SSA_NAME_DEF_STMT (t
);
801 if (gimple_code (stmt
) == GIMPLE_PHI
802 || gimple_code (stmt
) == GIMPLE_CALL
)
805 /* VDEF is variant when it is in the region. */
806 if (gimple_vdef (stmt
))
809 /* A VUSE may or may not be variant following the VDEFs. */
810 if (tree vuse
= gimple_vuse (stmt
))
811 return invariant_in_sese_p_rec (vuse
, region
);
813 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
)
815 tree use
= USE_FROM_PTR (use_p
);
817 if (!defined_in_sese_p (use
, region
))
820 if (!invariant_in_sese_p_rec (use
, region
))
827 /* Returns the scalar evolution of T in REGION. Every variable that
828 is not defined in the REGION is considered a parameter. */
831 scalar_evolution_in_region (sese_l
®ion
, loop_p loop
, tree t
)
834 struct loop
*def_loop
;
835 basic_block before
= region
.entry
->src
;
837 /* SCOP parameters. */
838 if (TREE_CODE (t
) == SSA_NAME
839 && !defined_in_sese_p (t
, region
))
842 if (TREE_CODE (t
) != SSA_NAME
843 || loop_in_sese_p (loop
, region
))
844 return instantiate_scev (before
, loop
,
845 analyze_scalar_evolution (loop
, t
));
847 def
= SSA_NAME_DEF_STMT (t
);
848 def_loop
= loop_containing_stmt (def
);
850 if (loop_in_sese_p (def_loop
, region
))
852 t
= analyze_scalar_evolution (def_loop
, t
);
853 def_loop
= superloop_at_depth (def_loop
, loop_depth (loop
) + 1);
854 t
= compute_overall_effect_of_inner_loop (def_loop
, t
);
858 if (invariant_in_sese_p_rec (t
, region
))
861 return instantiate_scev (before
, loop
, t
);