Mercurial > hg > CbC > CbC_gcc

comparison gcc/sese.c @ 67:f6334be47118

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date Tue, 22 Mar 2011 17:18:12 +0900
parents b7f97abdc517
children 04ced10e8804
comparison
equal deleted inserted replaced
65:65488c3d617d 67:f6334be47118
21 <http://www.gnu.org/licenses/>. */ 21 <http://www.gnu.org/licenses/>. */
22 22
23 #include "config.h" 23 #include "config.h"
24 #include "system.h" 24 #include "system.h"
25 #include "coretypes.h" 25 #include "coretypes.h"
26 #include "tm.h"
27 #include "ggc.h"
28 #include "tree.h"
29 #include "rtl.h"
30 #include "basic-block.h"
31 #include "diagnostic.h"
32 #include "tree-pretty-print.h" 26 #include "tree-pretty-print.h"
33 #include "tree-flow.h" 27 #include "tree-flow.h"
34 #include "toplev.h"
35 #include "tree-dump.h"
36 #include "timevar.h"
37 #include "cfgloop.h" 28 #include "cfgloop.h"
38 #include "tree-chrec.h" 29 #include "tree-chrec.h"
39 #include "tree-data-ref.h" 30 #include "tree-data-ref.h"
40 #include "tree-scalar-evolution.h" 31 #include "tree-scalar-evolution.h"
41 #include "tree-pass.h" 32 #include "tree-pass.h"
42 #include "domwalk.h"
43 #include "value-prof.h" 33 #include "value-prof.h"
44 #include "pointer-set.h"
45 #include "gimple.h"
46 #include "sese.h" 34 #include "sese.h"
47 35
48 /* Print to stderr the element ELT. */ 36 /* Print to stderr the element ELT. */
49 37
50 static void 38 static void
65 struct rename_map_elt_s *entry = (struct rename_map_elt_s *) *slot; 53 struct rename_map_elt_s *entry = (struct rename_map_elt_s *) *slot;
66 debug_rename_elt (entry); 54 debug_rename_elt (entry);
67 return 1; 55 return 1;
68 } 56 }
69 57
70 /* Print to stderr all the elements of MAP. */ 58 /* Print to stderr all the elements of RENAME_MAP. */
71 59
72 void 60 DEBUG_FUNCTION void
73 debug_rename_map (htab_t map) 61 debug_rename_map (htab_t rename_map)
74 { 62 {
75 htab_traverse (map, debug_rename_map_1, NULL); 63 htab_traverse (rename_map, debug_rename_map_1, NULL);
76 } 64 }
77 65
78 /* Computes a hash function for database element ELT. */ 66 /* Computes a hash function for database element ELT. */
79 67
80 hashval_t 68 hashval_t
116 return 1; 104 return 1;
117 } 105 }
118 106
119 /* Print to stderr all the elements of MAP. */ 107 /* Print to stderr all the elements of MAP. */
120 108
121 void 109 DEBUG_FUNCTION void
122 debug_ivtype_map (htab_t map) 110 debug_ivtype_map (htab_t map)
123 { 111 {
124 htab_traverse (map, debug_ivtype_map_1, NULL); 112 htab_traverse (map, debug_ivtype_map_1, NULL);
125 } 113 }
126 114
179 } 167 }
180 168
181 /* Make sure that the loops in the SESE_LOOP_NEST are ordered. It 169 /* Make sure that the loops in the SESE_LOOP_NEST are ordered. It
182 can be the case that an inner loop is inserted before an outer 170 can be the case that an inner loop is inserted before an outer
183 loop. To avoid this, semi-sort once. */ 171 loop. To avoid this, semi-sort once. */
184 for (i = 0; VEC_iterate (loop_p, SESE_LOOP_NEST (region), i, loop0); i++) 172 FOR_EACH_VEC_ELT (loop_p, SESE_LOOP_NEST (region), i, loop0)
185 { 173 {
186 if (VEC_length (loop_p, SESE_LOOP_NEST (region)) == i + 1) 174 if (VEC_length (loop_p, SESE_LOOP_NEST (region)) == i + 1)
187 break; 175 break;
188 176
189 loop1 = VEC_index (loop_p, SESE_LOOP_NEST (region), i + 1); 177 loop1 = VEC_index (loop_p, SESE_LOOP_NEST (region), i + 1);
392 BITMAP_FREE (liveouts); 380 BITMAP_FREE (liveouts);
393 381
394 update_ssa (TODO_update_ssa); 382 update_ssa (TODO_update_ssa);
395 } 383 }
396 384
397 /* Get the definition of NAME before the SESE. Keep track of the
398 basic blocks that have been VISITED in a bitmap. */
399
400 static tree
401 get_vdef_before_sese (sese region, tree name, sbitmap visited)
402 {
403 unsigned i;
404 gimple stmt = SSA_NAME_DEF_STMT (name);
405 basic_block def_bb = gimple_bb (stmt);
406
407 if (!def_bb || !bb_in_sese_p (def_bb, region))
408 return name;
409
410 if (TEST_BIT (visited, def_bb->index))
411 return NULL_TREE;
412
413 SET_BIT (visited, def_bb->index);
414
415 switch (gimple_code (stmt))
416 {
417 case GIMPLE_PHI:
418 for (i = 0; i < gimple_phi_num_args (stmt); i++)
419 {
420 tree arg = gimple_phi_arg_def (stmt, i);
421 tree res;
422
423 if (gimple_bb (SSA_NAME_DEF_STMT (arg))
424 && def_bb->index == gimple_bb (SSA_NAME_DEF_STMT (arg))->index)
425 continue;
426
427 res = get_vdef_before_sese (region, arg, visited);
428 if (res)
429 return res;
430 }
431 return NULL_TREE;
432
433 case GIMPLE_ASSIGN:
434 case GIMPLE_CALL:
435 {
436 use_operand_p use_p = gimple_vuse_op (stmt);
437 tree use = USE_FROM_PTR (use_p);
438
439 if (def_bb->index == gimple_bb (SSA_NAME_DEF_STMT (use))->index)
440 RESET_BIT (visited, def_bb->index);
441
442 return get_vdef_before_sese (region, use, visited);
443 }
444
445 default:
446 return NULL_TREE;
447 }
448 }
449
450 /* Adjust a virtual phi node PHI that is placed at the end of the
451 generated code for SCOP:
452
453 | if (1)
454 | generated code from REGION;
455 | else
456 | REGION;
457
458 The FALSE_E edge comes from the original code, TRUE_E edge comes
459 from the code generated for the SCOP. */
460
461 static void
462 sese_adjust_vphi (sese region, gimple phi, edge true_e)
463 {
464 unsigned i;
465
466 gcc_assert (gimple_phi_num_args (phi) == 2);
467
468 for (i = 0; i < gimple_phi_num_args (phi); i++)
469 if (gimple_phi_arg_edge (phi, i) == true_e)
470 {
471 tree true_arg, false_arg, before_scop_arg;
472 sbitmap visited;
473
474 true_arg = gimple_phi_arg_def (phi, i);
475 if (!SSA_NAME_IS_DEFAULT_DEF (true_arg))
476 return;
477
478 false_arg = gimple_phi_arg_def (phi, i == 0 ? 1 : 0);
479 if (SSA_NAME_IS_DEFAULT_DEF (false_arg))
480 return;
481
482 visited = sbitmap_alloc (last_basic_block);
483 sbitmap_zero (visited);
484 before_scop_arg = get_vdef_before_sese (region, false_arg, visited);
485 gcc_assert (before_scop_arg != NULL_TREE);
486 SET_PHI_ARG_DEF (phi, i, before_scop_arg);
487 sbitmap_free (visited);
488 }
489 }
490
491 /* Returns the expression associated to OLD_NAME in MAP. */
492
493 static tree
494 get_rename (htab_t map, tree old_name)
495 {
496 struct rename_map_elt_s tmp;
497 PTR *slot;
498
499 gcc_assert (TREE_CODE (old_name) == SSA_NAME);
500 tmp.old_name = old_name;
501 slot = htab_find_slot (map, &tmp, NO_INSERT);
502
503 if (slot && *slot)
504 return ((rename_map_elt) *slot)->expr;
505
506 return old_name;
507 }
508
509 /* Register in MAP the rename tuple (OLD_NAME, EXPR). */
510
511 void
512 set_rename (htab_t map, tree old_name, tree expr)
513 {
514 struct rename_map_elt_s tmp;
515 PTR *slot;
516
517 if (old_name == expr)
518 return;
519
520 tmp.old_name = old_name;
521 slot = htab_find_slot (map, &tmp, INSERT);
522
523 if (!slot)
524 return;
525
526 if (*slot)
527 free (*slot);
528
529 *slot = new_rename_map_elt (old_name, expr);
530 }
531
532 /* Renames the expression T following the tuples (OLD_NAME, EXPR) in
533 the rename map M. Returns the expression T after renaming. */
534
535 static tree
536 rename_variables_in_expr (htab_t m, tree t)
537 {
538 if (!t)
539 return t;
540
541 if (TREE_CODE (t) == SSA_NAME)
542 return get_rename (m, t);
543
544 switch (TREE_CODE_LENGTH (TREE_CODE (t)))
545 {
546 case 3:
547 TREE_OPERAND (t, 2) = rename_variables_in_expr (m, TREE_OPERAND (t, 2));
548
549 case 2:
550 TREE_OPERAND (t, 1) = rename_variables_in_expr (m, TREE_OPERAND (t, 1));
551
552 case 1:
553 TREE_OPERAND (t, 0) = rename_variables_in_expr (m, TREE_OPERAND (t, 0));
554
555 default:
556 return t;
557 }
558 }
559
560 /* Renames all the loop->nb_iterations expressions following the
561 tuples (OLD_NAME, EXPR) in RENAME_MAP. */
562
563 void
564 rename_nb_iterations (htab_t rename_map)
565 {
566 loop_iterator li;
567 struct loop *loop;
568
569 FOR_EACH_LOOP (li, loop, 0)
570 loop->nb_iterations = rename_variables_in_expr (rename_map,
571 loop->nb_iterations);
572 }
573
574 /* Renames all the parameters of SESE following the tuples (OLD_NAME,
575 EXPR) in RENAME_MAP. */
576
577 void
578 rename_sese_parameters (htab_t rename_map, sese region)
579 {
580 int i;
581 tree p;
582
583 for (i = 0; VEC_iterate (tree, SESE_PARAMS (region), i, p); i++)
584 VEC_replace (tree, SESE_PARAMS (region), i,
585 rename_variables_in_expr (rename_map, p));
586 }
587
588 /* Adjusts the phi nodes in the block BB for variables defined in
589 SCOP_REGION and used outside the SCOP_REGION. The code generation
590 moves SCOP_REGION in the else clause of an "if (1)" and generates
591 code in the then clause:
592
593 | if (1)
594 | generated code from REGION;
595 | else
596 | REGION;
597
598 To adjust the phi nodes after the condition, the RENAME_MAP is
599 used. */
600
601 void
602 sese_adjust_liveout_phis (sese region, htab_t rename_map, basic_block bb,
603 edge false_e, edge true_e)
604 {
605 gimple_stmt_iterator si;
606
607 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
608 {
609 unsigned i;
610 unsigned false_i = 0;
611 gimple phi = gsi_stmt (si);
612 tree res = gimple_phi_result (phi);
613
614 if (!is_gimple_reg (res))
615 {
616 sese_adjust_vphi (region, phi, true_e);
617 continue;
618 }
619
620 for (i = 0; i < gimple_phi_num_args (phi); i++)
621 if (gimple_phi_arg_edge (phi, i) == false_e)
622 {
623 false_i = i;
624 break;
625 }
626
627 for (i = 0; i < gimple_phi_num_args (phi); i++)
628 if (gimple_phi_arg_edge (phi, i) == true_e)
629 {
630 tree old_name = gimple_phi_arg_def (phi, false_i);
631 tree expr = get_rename (rename_map, old_name);
632 gimple_seq stmts;
633
634 gcc_assert (old_name != expr);
635
636 if (TREE_CODE (expr) != SSA_NAME
637 && is_gimple_reg (old_name))
638 {
639 tree type = TREE_TYPE (old_name);
640 tree var = create_tmp_var (type, "var");
641
642 expr = build2 (MODIFY_EXPR, type, var, expr);
643 expr = force_gimple_operand (expr, &stmts, true, NULL);
644 gsi_insert_seq_on_edge_immediate (true_e, stmts);
645 }
646
647 SET_PHI_ARG_DEF (phi, i, expr);
648 set_rename (rename_map, old_name, res);
649 }
650 }
651 }
652
653 /* Rename the SSA_NAMEs used in STMT and that appear in MAP. */
654
655 static void
656 rename_variables_in_stmt (gimple stmt, htab_t map, gimple_stmt_iterator *insert_gsi)
657 {
658 ssa_op_iter iter;
659 use_operand_p use_p;
660
661 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
662 {
663 tree use = USE_FROM_PTR (use_p);
664 tree expr, type_use, type_expr;
665 gimple_seq stmts;
666
667 if (TREE_CODE (use) != SSA_NAME)
668 continue;
669
670 expr = get_rename (map, use);
671 if (use == expr)
672 continue;
673
674 type_use = TREE_TYPE (use);
675 type_expr = TREE_TYPE (expr);
676
677 if (type_use != type_expr
678 || (TREE_CODE (expr) != SSA_NAME
679 && is_gimple_reg (use)))
680 {
681 tree var;
682
683 if (is_gimple_debug (stmt))
684 {
685 if (gimple_debug_bind_p (stmt))
686 gimple_debug_bind_reset_value (stmt);
687 else
688 gcc_unreachable ();
689
690 break;
691 }
692
693 var = create_tmp_var (type_use, "var");
694
695 if (type_use != type_expr)
696 expr = fold_convert (type_use, expr);
697
698 expr = build2 (MODIFY_EXPR, type_use, var, expr);
699 expr = force_gimple_operand (expr, &stmts, true, NULL);
700 gsi_insert_seq_before (insert_gsi, stmts, GSI_SAME_STMT);
701 }
702
703 replace_exp (use_p, expr);
704 }
705
706 update_stmt (stmt);
707 }
708
709 /* Returns true if NAME is a parameter of SESE. */
710
711 static bool
712 is_parameter (sese region, tree name)
713 {
714 int i;
715 tree p;
716
717 for (i = 0; VEC_iterate (tree, SESE_PARAMS (region), i, p); i++)
718 if (p == name)
719 return true;
720
721 return false;
722 }
723
724 /* Returns true if NAME is an induction variable. */
725
726 static bool
727 is_iv (tree name)
728 {
729 return gimple_code (SSA_NAME_DEF_STMT (name)) == GIMPLE_PHI;
730 }
731
732 static void expand_scalar_variables_stmt (gimple, basic_block, sese,
733 htab_t, gimple_stmt_iterator *);
734 static tree
735 expand_scalar_variables_expr (tree, tree, enum tree_code, tree, basic_block,
736 sese, htab_t, gimple_stmt_iterator *);
737
738 static tree
739 expand_scalar_variables_call (gimple stmt, basic_block bb, sese region,
740 htab_t map, gimple_stmt_iterator *gsi)
741 {
742 int i, nargs = gimple_call_num_args (stmt);
743 VEC (tree, gc) *args = VEC_alloc (tree, gc, nargs);
744 tree fn_type = TREE_TYPE (gimple_call_fn (stmt));
745 tree fn = gimple_call_fndecl (stmt);
746 tree call_expr, var, lhs;
747 gimple call;
748
749 for (i = 0; i < nargs; i++)
750 {
751 tree arg = gimple_call_arg (stmt, i);
752 tree t = TREE_TYPE (arg);
753
754 var = create_tmp_var (t, "var");
755 arg = expand_scalar_variables_expr (t, arg, TREE_CODE (arg), NULL,
756 bb, region, map, gsi);
757 arg = build2 (MODIFY_EXPR, t, var, arg);
758 arg = force_gimple_operand_gsi (gsi, arg, true, NULL,
759 true, GSI_SAME_STMT);
760 VEC_quick_push (tree, args, arg);
761 }
762
763 lhs = gimple_call_lhs (stmt);
764 var = create_tmp_var (TREE_TYPE (lhs), "var");
765 call_expr = build_call_vec (fn_type, fn, args);
766 call = gimple_build_call_from_tree (call_expr);
767 var = make_ssa_name (var, call);
768 gimple_call_set_lhs (call, var);
769 gsi_insert_before (gsi, call, GSI_SAME_STMT);
770
771 return var;
772 }
773
774 /* Copies at GSI all the scalar computations on which the ssa_name OP0
775 depends on in the SESE: these are all the scalar variables used in
776 the definition of OP0, that are defined outside BB and still in the
777 SESE, i.e. not a parameter of the SESE. The expression that is
778 returned contains only induction variables from the generated code:
779 MAP contains the induction variables renaming mapping, and is used
780 to translate the names of induction variables. */
781
782 static tree
783 expand_scalar_variables_ssa_name (tree type, tree op0, basic_block bb,
784 sese region, htab_t map,
785 gimple_stmt_iterator *gsi)
786 {
787 gimple def_stmt;
788 tree new_op;
789
790 if (is_parameter (region, op0)
791 || is_iv (op0))
792 return fold_convert (type, get_rename (map, op0));
793
794 def_stmt = SSA_NAME_DEF_STMT (op0);
795
796 /* Check whether we already have a rename for OP0. */
797 new_op = get_rename (map, op0);
798
799 if (new_op != op0
800 && gimple_bb (SSA_NAME_DEF_STMT (new_op)) == bb)
801 return fold_convert (type, new_op);
802
803 if (gimple_bb (def_stmt) == bb)
804 {
805 /* If the defining statement is in the basic block already
806 we do not need to create a new expression for it, we
807 only need to ensure its operands are expanded. */
808 expand_scalar_variables_stmt (def_stmt, bb, region, map, gsi);
809 return fold_convert (type, new_op);
810 }
811 else
812 {
813 if (!gimple_bb (def_stmt)
814 || !bb_in_sese_p (gimple_bb (def_stmt), region))
815 return fold_convert (type, new_op);
816
817 switch (gimple_code (def_stmt))
818 {
819 case GIMPLE_ASSIGN:
820 {
821 tree var0 = gimple_assign_rhs1 (def_stmt);
822 enum tree_code subcode = gimple_assign_rhs_code (def_stmt);
823 tree var1 = gimple_assign_rhs2 (def_stmt);
824 tree type = gimple_expr_type (def_stmt);
825
826 return expand_scalar_variables_expr (type, var0, subcode, var1, bb,
827 region, map, gsi);
828 }
829
830 case GIMPLE_CALL:
831 return expand_scalar_variables_call (def_stmt, bb, region, map, gsi);
832
833 default:
834 gcc_unreachable ();
835 return new_op;
836 }
837 }
838 }
839
840 /* Copies at GSI all the scalar computations on which the expression
841 OP0 CODE OP1 depends on in the SESE: these are all the scalar
842 variables used in OP0 and OP1, defined outside BB and still defined
843 in the SESE, i.e. not a parameter of the SESE. The expression that
844 is returned contains only induction variables from the generated
845 code: MAP contains the induction variables renaming mapping, and is
846 used to translate the names of induction variables. */
847
848 static tree
849 expand_scalar_variables_expr (tree type, tree op0, enum tree_code code,
850 tree op1, basic_block bb, sese region,
851 htab_t map, gimple_stmt_iterator *gsi)
852 {
853 if (TREE_CODE_CLASS (code) == tcc_constant
854 || TREE_CODE_CLASS (code) == tcc_declaration)
855 return op0;
856
857 /* For data references we have to duplicate also its memory
858 indexing. */
859 if (TREE_CODE_CLASS (code) == tcc_reference)
860 {
861 switch (code)
862 {
863 case REALPART_EXPR:
864 case IMAGPART_EXPR:
865 {
866 tree op = TREE_OPERAND (op0, 0);
867 tree res = expand_scalar_variables_expr
868 (type, op, TREE_CODE (op), NULL, bb, region, map, gsi);
869 return build1 (code, type, res);
870 }
871
872 case INDIRECT_REF:
873 {
874 tree old_name = TREE_OPERAND (op0, 0);
875 tree expr = expand_scalar_variables_ssa_name
876 (type, old_name, bb, region, map, gsi);
877
878 if (TREE_CODE (expr) != SSA_NAME
879 && is_gimple_reg (old_name))
880 {
881 tree type = TREE_TYPE (old_name);
882 tree var = create_tmp_var (type, "var");
883
884 expr = build2 (MODIFY_EXPR, type, var, expr);
885 expr = force_gimple_operand_gsi (gsi, expr, true, NULL,
886 true, GSI_SAME_STMT);
887 }
888
889 return fold_build1 (code, type, expr);
890 }
891
892 case ARRAY_REF:
893 {
894 tree op00 = TREE_OPERAND (op0, 0);
895 tree op01 = TREE_OPERAND (op0, 1);
896 tree op02 = TREE_OPERAND (op0, 2);
897 tree op03 = TREE_OPERAND (op0, 3);
898 tree base = expand_scalar_variables_expr
899 (TREE_TYPE (op00), op00, TREE_CODE (op00), NULL, bb, region,
900 map, gsi);
901 tree subscript = expand_scalar_variables_expr
902 (TREE_TYPE (op01), op01, TREE_CODE (op01), NULL, bb, region,
903 map, gsi);
904
905 return build4 (ARRAY_REF, type, base, subscript, op02, op03);
906 }
907
908 case COMPONENT_REF:
909 return op0;
910
911 default:
912 /* The above cases should catch everything. */
913 gcc_unreachable ();
914 }
915 }
916
917 if (TREE_CODE_CLASS (code) == tcc_unary)
918 {
919 tree op0_type = TREE_TYPE (op0);
920 enum tree_code op0_code = TREE_CODE (op0);
921 tree op0_expr = expand_scalar_variables_expr (op0_type, op0, op0_code,
922 NULL, bb, region, map, gsi);
923
924 return fold_build1 (code, type, op0_expr);
925 }
926
927 if (TREE_CODE_CLASS (code) == tcc_binary
928 || TREE_CODE_CLASS (code) == tcc_comparison)
929 {
930 tree op0_type = TREE_TYPE (op0);
931 enum tree_code op0_code = TREE_CODE (op0);
932 tree op0_expr = expand_scalar_variables_expr (op0_type, op0, op0_code,
933 NULL, bb, region, map, gsi);
934 tree op1_type = TREE_TYPE (op1);
935 enum tree_code op1_code = TREE_CODE (op1);
936 tree op1_expr = expand_scalar_variables_expr (op1_type, op1, op1_code,
937 NULL, bb, region, map, gsi);
938
939 return fold_build2 (code, type, op0_expr, op1_expr);
940 }
941
942 if (code == SSA_NAME)
943 return expand_scalar_variables_ssa_name (type, op0, bb, region, map, gsi);
944
945 if (code == ADDR_EXPR)
946 {
947 tree op00 = TREE_OPERAND (op0, 0);
948
949 if (handled_component_p (op00)
950 && TREE_CODE (op00) == ARRAY_REF)
951 {
952 tree e = expand_scalar_variables_expr (TREE_TYPE (op00), op00,
953 TREE_CODE (op00),
954 NULL, bb, region, map, gsi);
955 return fold_build1 (code, TREE_TYPE (op0), e);
956 }
957
958 return op0;
959 }
960
961 gcc_unreachable ();
962 return NULL;
963 }
964
965 /* Copies at the beginning of BB all the scalar computations on which
966 STMT depends on in the SESE: these are all the scalar variables used
967 in STMT, defined outside BB and still defined in the SESE, i.e. not a
968 parameter of the SESE. The expression that is returned contains
969 only induction variables from the generated code: MAP contains the
970 induction variables renaming mapping, and is used to translate the
971 names of induction variables. */
972
973 static void
974 expand_scalar_variables_stmt (gimple stmt, basic_block bb, sese region,
975 htab_t map, gimple_stmt_iterator *gsi)
976 {
977 ssa_op_iter iter;
978 use_operand_p use_p;
979
980 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
981 {
982 tree use = USE_FROM_PTR (use_p);
983 tree type = TREE_TYPE (use);
984 enum tree_code code = TREE_CODE (use);
985 tree use_expr;
986
987 if (!is_gimple_reg (use))
988 continue;
989
990 /* Don't expand USE if we already have a rename for it. */
991 use_expr = get_rename (map, use);
992 if (use_expr != use)
993 continue;
994
995 use_expr = expand_scalar_variables_expr (type, use, code, NULL, bb,
996 region, map, gsi);
997 use_expr = fold_convert (type, use_expr);
998
999 if (use_expr == use)
1000 continue;
1001
1002 if (is_gimple_debug (stmt))
1003 {
1004 if (gimple_debug_bind_p (stmt))
1005 gimple_debug_bind_reset_value (stmt);
1006 else
1007 gcc_unreachable ();
1008
1009 break;
1010 }
1011
1012 if (TREE_CODE (use_expr) != SSA_NAME)
1013 {
1014 tree var = create_tmp_var (type, "var");
1015
1016 use_expr = build2 (MODIFY_EXPR, type, var, use_expr);
1017 use_expr = force_gimple_operand_gsi (gsi, use_expr, true, NULL,
1018 true, GSI_SAME_STMT);
1019 }
1020
1021 replace_exp (use_p, use_expr);
1022 }
1023
1024 update_stmt (stmt);
1025 }
1026
1027 /* Copies at the beginning of BB all the scalar computations on which
1028 BB depends on in the SESE: these are all the scalar variables used
1029 in BB, defined outside BB and still defined in the SESE, i.e. not a
1030 parameter of the SESE. The expression that is returned contains
1031 only induction variables from the generated code: MAP contains the
1032 induction variables renaming mapping, and is used to translate the
1033 names of induction variables. */
1034
1035 static void
1036 expand_scalar_variables (basic_block bb, sese region, htab_t map)
1037 {
1038 gimple_stmt_iterator gsi;
1039
1040 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
1041 {
1042 gimple stmt = gsi_stmt (gsi);
1043 expand_scalar_variables_stmt (stmt, bb, region, map, &gsi);
1044 gsi_next (&gsi);
1045 }
1046 }
1047
1048 /* Rename all the SSA_NAMEs from block BB according to the MAP. */
1049
1050 static void
1051 rename_variables (basic_block bb, htab_t map)
1052 {
1053 gimple_stmt_iterator gsi;
1054 gimple_stmt_iterator insert_gsi = gsi_start_bb (bb);
1055
1056 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1057 rename_variables_in_stmt (gsi_stmt (gsi), map, &insert_gsi);
1058 }
1059
1060 /* Remove condition from BB. */
1061
1062 static void
1063 remove_condition (basic_block bb)
1064 {
1065 gimple last = last_stmt (bb);
1066
1067 if (last && gimple_code (last) == GIMPLE_COND)
1068 {
1069 gimple_stmt_iterator gsi = gsi_last_bb (bb);
1070 gsi_remove (&gsi, true);
1071 }
1072 }
1073
1074 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */ 385 /* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */
1075 386
1076 edge 387 edge
1077 get_true_edge_from_guard_bb (basic_block bb) 388 get_true_edge_from_guard_bb (basic_block bb)
1078 { 389 {
1101 412
1102 gcc_unreachable (); 413 gcc_unreachable ();
1103 return NULL; 414 return NULL;
1104 } 415 }
1105 416
1106 /* Returns true when NAME is defined in LOOP. */ 417 /* Returns the expression associated to OLD_NAME in RENAME_MAP. */
418
419 static tree
420 get_rename (htab_t rename_map, tree old_name)
421 {
422 struct rename_map_elt_s tmp;
423 PTR *slot;
424
425 gcc_assert (TREE_CODE (old_name) == SSA_NAME);
426 tmp.old_name = old_name;
427 slot = htab_find_slot (rename_map, &tmp, NO_INSERT);
428
429 if (slot && *slot)
430 return ((rename_map_elt) *slot)->expr;
431
432 return NULL_TREE;
433 }
434
435 /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */
436
437 static void
438 set_rename (htab_t rename_map, tree old_name, tree expr)
439 {
440 struct rename_map_elt_s tmp;
441 PTR *slot;
442
443 if (old_name == expr)
444 return;
445
446 tmp.old_name = old_name;
447 slot = htab_find_slot (rename_map, &tmp, INSERT);
448
449 if (!slot)
450 return;
451
452 if (*slot)
453 free (*slot);
454
455 *slot = new_rename_map_elt (old_name, expr);
456 }
457
458 /* Renames the scalar uses of the statement COPY, using the
459 substitution map RENAME_MAP, inserting the gimplification code at
460 GSI_TGT, for the translation REGION, with the original copied
461 statement in LOOP, and using the induction variable renaming map
462 IV_MAP. Returns true when something has been renamed. */
1107 463
1108 static bool 464 static bool
1109 name_defined_in_loop_p (tree name, loop_p loop) 465 rename_uses (gimple copy, htab_t rename_map, gimple_stmt_iterator *gsi_tgt,
1110 { 466 sese region, loop_p loop, VEC (tree, heap) *iv_map)
1111 return !SSA_NAME_IS_DEFAULT_DEF (name) 467 {
1112 && gimple_bb (SSA_NAME_DEF_STMT (name))->loop_father == loop; 468 use_operand_p use_p;
1113 } 469 ssa_op_iter op_iter;
1114 470 bool changed = false;
1115 /* Returns true when EXPR contains SSA_NAMEs defined in LOOP. */ 471
1116 472 if (is_gimple_debug (copy))
1117 static bool
1118 expr_defined_in_loop_p (tree expr, loop_p loop)
1119 {
1120 switch (TREE_CODE_LENGTH (TREE_CODE (expr)))
1121 { 473 {
1122 case 3: 474 if (gimple_debug_bind_p (copy))
1123 return expr_defined_in_loop_p (TREE_OPERAND (expr, 0), loop) 475 gimple_debug_bind_reset_value (copy);
1124 || expr_defined_in_loop_p (TREE_OPERAND (expr, 1), loop) 476 else
1125 || expr_defined_in_loop_p (TREE_OPERAND (expr, 2), loop); 477 gcc_unreachable ();
1126 478
1127 case 2:
1128 return expr_defined_in_loop_p (TREE_OPERAND (expr, 0), loop)
1129 || expr_defined_in_loop_p (TREE_OPERAND (expr, 1), loop);
1130
1131 case 1:
1132 return expr_defined_in_loop_p (TREE_OPERAND (expr, 0), loop);
1133
1134 case 0:
1135 return TREE_CODE (expr) == SSA_NAME
1136 && name_defined_in_loop_p (expr, loop);
1137
1138 default:
1139 return false; 479 return false;
1140 } 480 }
1141 } 481
1142 482 FOR_EACH_SSA_USE_OPERAND (use_p, copy, op_iter, SSA_OP_ALL_USES)
1143 /* Returns the gimple statement that uses NAME outside the loop it is
1144 defined in, returns NULL if there is no such loop close phi node.
1145 An invariant of the loop closed SSA form is that the only use of a
1146 variable, outside the loop it is defined in, is in the loop close
1147 phi node that just follows the loop. */
1148
1149 static gimple
1150 alive_after_loop (tree name)
1151 {
1152 use_operand_p use_p;
1153 imm_use_iterator imm_iter;
1154 loop_p loop = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_father;
1155
1156 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, name)
1157 { 483 {
1158 gimple stmt = USE_STMT (use_p); 484 tree old_name = USE_FROM_PTR (use_p);
1159 485 tree new_expr, scev;
1160 if (gimple_code (stmt) == GIMPLE_PHI 486 gimple_seq stmts;
1161 && gimple_bb (stmt)->loop_father != loop) 487
1162 return stmt; 488 if (TREE_CODE (old_name) != SSA_NAME
489 || !is_gimple_reg (old_name)
490 || SSA_NAME_IS_DEFAULT_DEF (old_name))
491 continue;
492
493 changed = true;
494 new_expr = get_rename (rename_map, old_name);
495 if (new_expr)
496 {
497 tree type_old_name = TREE_TYPE (old_name);
498 tree type_new_expr = TREE_TYPE (new_expr);
499
500 if (type_old_name != type_new_expr
501 || (TREE_CODE (new_expr) != SSA_NAME
502 && is_gimple_reg (old_name)))
503 {
504 tree var = create_tmp_var (type_old_name, "var");
505
506 if (type_old_name != type_new_expr)
507 new_expr = fold_convert (type_old_name, new_expr);
508
509 new_expr = build2 (MODIFY_EXPR, type_old_name, var, new_expr);
510 new_expr = force_gimple_operand (new_expr, &stmts, true, NULL);
511 gsi_insert_seq_before (gsi_tgt, stmts, GSI_SAME_STMT);
512 }
513
514 replace_exp (use_p, new_expr);
515 continue;
516 }
517
518 scev = scalar_evolution_in_region (region, loop, old_name);
519
520 /* At this point we should know the exact scev for each
521 scalar SSA_NAME used in the scop: all the other scalar
522 SSA_NAMEs should have been translated out of SSA using
523 arrays with one element. */
524 gcc_assert (!chrec_contains_undetermined (scev));
525
526 new_expr = chrec_apply_map (scev, iv_map);
527
528 /* The apply should produce an expression tree containing
529 the uses of the new induction variables. We should be
530 able to use new_expr instead of the old_name in the newly
531 generated loop nest. */
532 gcc_assert (!chrec_contains_undetermined (new_expr)
533 && !tree_contains_chrecs (new_expr, NULL));
534
535 /* Replace the old_name with the new_expr. */
536 new_expr = force_gimple_operand (unshare_expr (new_expr), &stmts,
537 true, NULL_TREE);
538 gsi_insert_seq_before (gsi_tgt, stmts, GSI_SAME_STMT);
539 replace_exp (use_p, new_expr);
540
541 if (TREE_CODE (new_expr) == INTEGER_CST
542 && is_gimple_assign (copy))
543 {
544 tree rhs = gimple_assign_rhs1 (copy);
545
546 if (TREE_CODE (rhs) == ADDR_EXPR)
547 recompute_tree_invariant_for_addr_expr (rhs);
548 }
549
550 set_rename (rename_map, old_name, new_expr);
1163 } 551 }
1164 552
1165 return NULL; 553 return changed;
1166 } 554 }
1167 555
1168 /* Return true if a close phi has not yet been inserted for the use of 556 /* Duplicates the statements of basic block BB into basic block NEW_BB
1169 variable NAME on the single exit of LOOP. */ 557 and compute the new induction variables according to the IV_MAP. */
1170 558
1171 static bool 559 static void
1172 close_phi_not_yet_inserted_p (loop_p loop, tree name) 560 graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb,
1173 { 561 htab_t rename_map,
1174 gimple_stmt_iterator psi; 562 VEC (tree, heap) *iv_map, sese region)
1175 basic_block bb = single_exit (loop)->dest;
1176
1177 for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
1178 if (gimple_phi_arg_def (gsi_stmt (psi), 0) == name)
1179 return false;
1180
1181 return true;
1182 }
1183
1184 /* A structure for passing parameters to add_loop_exit_phis. */
1185
1186 typedef struct alep {
1187 loop_p loop;
1188 VEC (rename_map_elt, heap) *new_renames;
1189 } *alep_p;
1190
1191 /* Helper function for htab_traverse in insert_loop_close_phis. */
1192
1193 static int
1194 add_loop_exit_phis (void **slot, void *data)
1195 {
1196 struct rename_map_elt_s *entry;
1197 alep_p a;
1198 loop_p loop;
1199 tree expr, new_name, old_name;
1200 bool def_in_loop_p, used_outside_p, need_close_phi_p;
1201 gimple old_close_phi;
1202
1203 if (!slot || !*slot || !data)
1204 return 1;
1205
1206 entry = (struct rename_map_elt_s *) *slot;
1207 a = (alep_p) data;
1208 loop = a->loop;
1209 new_name = expr = entry->expr;
1210 old_name = entry->old_name;
1211
1212 def_in_loop_p = expr_defined_in_loop_p (expr, loop);
1213 if (!def_in_loop_p)
1214 return 1;
1215
1216 /* Remove the old rename from the map when the expression is defined
1217 in the loop that we're closing. */
1218 free (*slot);
1219 *slot = NULL;
1220
1221 if (TREE_CODE (expr) != SSA_NAME)
1222 return 1;
1223
1224 old_close_phi = alive_after_loop (old_name);
1225 used_outside_p = (old_close_phi != NULL);
1226 need_close_phi_p = (used_outside_p
1227 && close_phi_not_yet_inserted_p (loop, new_name));
1228
1229 /* Insert a loop close phi node. */
1230 if (need_close_phi_p)
1231 {
1232 basic_block bb = single_exit (loop)->dest;
1233 gimple phi = create_phi_node (new_name, bb);
1234 tree new_res = create_new_def_for (gimple_phi_result (phi), phi,
1235 gimple_phi_result_ptr (phi));
1236
1237 add_phi_arg (phi, new_name, single_pred_edge (bb), UNKNOWN_LOCATION);
1238 VEC_safe_push (rename_map_elt, heap, a->new_renames,
1239 new_rename_map_elt (gimple_phi_result (old_close_phi),
1240 new_res));
1241 }
1242
1243 return 1;
1244 }
1245
1246 /* Traverses MAP and removes from it all the tuples (OLD, NEW) where
1247 NEW is defined in LOOP. Inserts on the exit of LOOP the close phi
1248 node "RES = phi (NEW)" corresponding to "OLD_RES = phi (OLD)" in
1249 the original code. Inserts in MAP the tuple (OLD_RES, RES). */
1250
1251 void
1252 insert_loop_close_phis (htab_t map, loop_p loop)
1253 {
1254 int i;
1255 struct alep a;
1256 rename_map_elt elt;
1257
1258 a.loop = loop;
1259 a.new_renames = VEC_alloc (rename_map_elt, heap, 3);
1260 update_ssa (TODO_update_ssa);
1261 htab_traverse (map, add_loop_exit_phis, &a);
1262 update_ssa (TODO_update_ssa);
1263
1264 for (i = 0; VEC_iterate (rename_map_elt, a.new_renames, i, elt); i++)
1265 {
1266 set_rename (map, elt->old_name, elt->expr);
1267 free (elt);
1268 }
1269
1270 VEC_free (rename_map_elt, heap, a.new_renames);
1271 }
1272
1273 /* Helper structure for htab_traverse in insert_guard_phis. */
1274
1275 struct igp {
1276 basic_block bb;
1277 edge true_edge, false_edge;
1278 htab_t before_guard;
1279 };
1280
1281 /* Return the default name that is before the guard. */
1282
1283 static tree
1284 default_before_guard (htab_t before_guard, tree old_name)
1285 {
1286 tree res = get_rename (before_guard, old_name);
1287
1288 if (res == old_name)
1289 {
1290 if (is_gimple_reg (res))
1291 return fold_convert (TREE_TYPE (res), integer_zero_node);
1292 return gimple_default_def (cfun, SSA_NAME_VAR (res));
1293 }
1294
1295 return res;
1296 }
1297
1298 /* Prepares EXPR to be a good phi argument when the phi result is
1299 RES. Insert needed statements on edge E. */
1300
1301 static tree
1302 convert_for_phi_arg (tree expr, tree res, edge e)
1303 {
1304 tree type = TREE_TYPE (res);
1305
1306 if (TREE_TYPE (expr) != type)
1307 expr = fold_convert (type, expr);
1308
1309 if (TREE_CODE (expr) != SSA_NAME
1310 && !is_gimple_min_invariant (expr))
1311 {
1312 tree var = create_tmp_var (type, "var");
1313 gimple_seq stmts;
1314
1315 expr = build2 (MODIFY_EXPR, type, var, expr);
1316 expr = force_gimple_operand (expr, &stmts, true, NULL);
1317 gsi_insert_seq_on_edge_immediate (e, stmts);
1318 }
1319
1320 return expr;
1321 }
1322
1323 /* Helper function for htab_traverse in insert_guard_phis. */
1324
1325 static int
1326 add_guard_exit_phis (void **slot, void *s)
1327 {
1328 struct rename_map_elt_s *entry = (struct rename_map_elt_s *) *slot;
1329 struct igp *i = (struct igp *) s;
1330 basic_block bb = i->bb;
1331 edge true_edge = i->true_edge;
1332 edge false_edge = i->false_edge;
1333 tree res = entry->old_name;
1334 tree name1 = entry->expr;
1335 tree name2 = default_before_guard (i->before_guard, res);
1336 gimple phi;
1337
1338 /* Nothing to be merged if the name before the guard is the same as
1339 the one after. */
1340 if (name1 == name2)
1341 return 1;
1342
1343 name1 = convert_for_phi_arg (name1, res, true_edge);
1344 name2 = convert_for_phi_arg (name2, res, false_edge);
1345
1346 phi = create_phi_node (res, bb);
1347 res = create_new_def_for (gimple_phi_result (phi), phi,
1348 gimple_phi_result_ptr (phi));
1349
1350 add_phi_arg (phi, name1, true_edge, UNKNOWN_LOCATION);
1351 add_phi_arg (phi, name2, false_edge, UNKNOWN_LOCATION);
1352
1353 entry->expr = res;
1354 *slot = entry;
1355 return 1;
1356 }
1357
1358 /* Iterate over RENAME_MAP and get tuples of the form (OLD, NAME1).
1359 If there is a correspondent tuple (OLD, NAME2) in BEFORE_GUARD,
1360 with NAME1 different than NAME2, then insert in BB the phi node:
1361
1362 | RES = phi (NAME1 (on TRUE_EDGE), NAME2 (on FALSE_EDGE))"
1363
1364 if there is no tuple for OLD in BEFORE_GUARD, insert
1365
1366 | RES = phi (NAME1 (on TRUE_EDGE),
1367 | DEFAULT_DEFINITION of NAME1 (on FALSE_EDGE))".
1368
1369 Finally register in RENAME_MAP the tuple (OLD, RES). */
1370
1371 void
1372 insert_guard_phis (basic_block bb, edge true_edge, edge false_edge,
1373 htab_t before_guard, htab_t rename_map)
1374 {
1375 struct igp i;
1376 i.bb = bb;
1377 i.true_edge = true_edge;
1378 i.false_edge = false_edge;
1379 i.before_guard = before_guard;
1380
1381 update_ssa (TODO_update_ssa);
1382 htab_traverse (rename_map, add_guard_exit_phis, &i);
1383 update_ssa (TODO_update_ssa);
1384 }
1385
1386 /* Create a duplicate of the basic block BB. NOTE: This does not
1387 preserve SSA form. */
1388
1389 static void
1390 graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t map)
1391 { 563 {
1392 gimple_stmt_iterator gsi, gsi_tgt; 564 gimple_stmt_iterator gsi, gsi_tgt;
565 loop_p loop = bb->loop_father;
1393 566
1394 gsi_tgt = gsi_start_bb (new_bb); 567 gsi_tgt = gsi_start_bb (new_bb);
1395 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 568 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1396 { 569 {
1397 def_operand_p def_p; 570 def_operand_p def_p;
1398 ssa_op_iter op_iter; 571 ssa_op_iter op_iter;
1399 gimple stmt = gsi_stmt (gsi); 572 gimple stmt = gsi_stmt (gsi);
1400 gimple copy; 573 gimple copy;
1401 574 tree lhs;
1402 if (gimple_code (stmt) == GIMPLE_LABEL) 575
576 /* Do not copy labels or conditions. */
577 if (gimple_code (stmt) == GIMPLE_LABEL
578 || gimple_code (stmt) == GIMPLE_COND)
579 continue;
580
581 /* Do not copy induction variables. */
582 if (is_gimple_assign (stmt)
583 && (lhs = gimple_assign_lhs (stmt))
584 && TREE_CODE (lhs) == SSA_NAME
585 && is_gimple_reg (lhs)
586 && scev_analyzable_p (lhs, region))
1403 continue; 587 continue;
1404 588
1405 /* Create a new copy of STMT and duplicate STMT's virtual 589 /* Create a new copy of STMT and duplicate STMT's virtual
1406 operands. */ 590 operands. */
1407 copy = gimple_copy (stmt); 591 copy = gimple_copy (stmt);
1412 gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt); 596 gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt);
1413 597
1414 /* Create new names for all the definitions created by COPY and 598 /* Create new names for all the definitions created by COPY and
1415 add replacement mappings for each new name. */ 599 add replacement mappings for each new name. */
1416 FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS) 600 FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
1417 { 601 {
1418 tree old_name = DEF_FROM_PTR (def_p); 602 tree old_name = DEF_FROM_PTR (def_p);
1419 tree new_name = create_new_def_for (old_name, copy, def_p); 603 tree new_name = create_new_def_for (old_name, copy, def_p);
1420 set_rename (map, old_name, new_name); 604 set_rename (rename_map, old_name, new_name);
1421 } 605 }
606
607 if (rename_uses (copy, rename_map, &gsi_tgt, region, loop, iv_map))
608 fold_stmt_inplace (copy);
609
610 update_stmt (copy);
1422 } 611 }
1423 } 612 }
1424 613
1425 /* Copies BB and includes in the copied BB all the statements that can 614 /* Copies BB and includes in the copied BB all the statements that can
1426 be reached following the use-def chains from the memory accesses, 615 be reached following the use-def chains from the memory accesses,
1427 and returns the next edge following this new block. */ 616 and returns the next edge following this new block. */
1428 617
1429 edge 618 edge
1430 copy_bb_and_scalar_dependences (basic_block bb, sese region, 619 copy_bb_and_scalar_dependences (basic_block bb, sese region,
1431 edge next_e, htab_t map) 620 edge next_e, VEC (tree, heap) *iv_map)
1432 { 621 {
1433 basic_block new_bb = split_edge (next_e); 622 basic_block new_bb = split_edge (next_e);
623 htab_t rename_map = htab_create (10, rename_map_elt_info,
624 eq_rename_map_elts, free);
1434 625
1435 next_e = single_succ_edge (new_bb); 626 next_e = single_succ_edge (new_bb);
1436 graphite_copy_stmts_from_block (bb, new_bb, map); 627 graphite_copy_stmts_from_block (bb, new_bb, rename_map, iv_map, region);
1437 remove_condition (new_bb);
1438 remove_phi_nodes (new_bb); 628 remove_phi_nodes (new_bb);
1439 expand_scalar_variables (new_bb, region, map); 629 htab_delete (rename_map);
1440 rename_variables (new_bb, map);
1441 630
1442 return next_e; 631 return next_e;
1443 } 632 }
1444 633
1445 /* Returns the outermost loop in SCOP that contains BB. */ 634 /* Returns the outermost loop in SCOP that contains BB. */
1491 free (if_region->false_region); 680 free (if_region->false_region);
1492 if_region->false_region = region; 681 if_region->false_region = region;
1493 682
1494 if (slot) 683 if (slot)
1495 { 684 {
1496 struct loop_exit *loop_exit = GGC_CNEW (struct loop_exit); 685 struct loop_exit *loop_exit = ggc_alloc_cleared_loop_exit ();
1497 686
1498 memcpy (loop_exit, *((struct loop_exit **) slot), sizeof (struct loop_exit)); 687 memcpy (loop_exit, *((struct loop_exit **) slot), sizeof (struct loop_exit));
1499 htab_clear_slot (current_loops->exits, slot); 688 htab_clear_slot (current_loops->exits, slot);
1500 689
1501 slot = htab_find_slot_with_hash (current_loops->exits, false_edge, 690 slot = htab_find_slot_with_hash (current_loops->exits, false_edge,
1599 { 788 {
1600 gimple def; 789 gimple def;
1601 struct loop *def_loop; 790 struct loop *def_loop;
1602 basic_block before = block_before_sese (region); 791 basic_block before = block_before_sese (region);
1603 792
793 /* SCOP parameters. */
794 if (TREE_CODE (t) == SSA_NAME
795 && !defined_in_sese_p (t, region))
796 return t;
797
1604 if (TREE_CODE (t) != SSA_NAME 798 if (TREE_CODE (t) != SSA_NAME
1605 || loop_in_sese_p (loop, region)) 799 || loop_in_sese_p (loop, region))
1606 return instantiate_scev (before, loop, 800 return instantiate_scev (before, loop,
1607 analyze_scalar_evolution (loop, t)); 801 analyze_scalar_evolution (loop, t));
1608
1609 if (!defined_in_sese_p (t, region))
1610 return t;
1611 802
1612 def = SSA_NAME_DEF_STMT (t); 803 def = SSA_NAME_DEF_STMT (t);
1613 def_loop = loop_containing_stmt (def); 804 def_loop = loop_containing_stmt (def);
1614 805
1615 if (loop_in_sese_p (def_loop, region)) 806 if (loop_in_sese_p (def_loop, region))