[Polly][ScopBuilder] Revise statement naming when there are multiple statements per BB.

[Meinersbur]

Summary

The goal is to have -polly-stmt-granularity=bb and -polly-stmt-granularity=scalar-indep to have the same names if there is just one statement per basic block.

This fixes a fluke when Polybench's jacobi-2d is optimized differently depending on the -polly-stmt-granularity option, although both options create the same SCoP, just with different statement names.

The new naming scheme is:

With -polly-use-llvm-names=0:
Stmt<BBIdx as decimal><Idx within BB as letter>

With -polly-use-llvm-names=1:
Stmt_BBName_<Idx within BB as letter>

The <Idx within BB> suffix is omitted for the main statement of a BB. The main statement is either the one containing the first store or call (those cannot be removed by the simplifyer), or if there is no such instruction, the first. If after simplification there is just a single statement left, it should be the main statement and have the same names as with -polly-stmt-granularity=bb.

[grosser]

LGTM

polly/trunk/lib/Analysis/ScopBuilder.cpp

 
 bool ScopBuilder::shouldModelInst(Instruction *Inst, Loop *L) {
   return !isa<TerminatorInst>(Inst) && !isIgnoredIntrinsic(Inst) &&
          !canSynthesize(Inst, *scop, &SE, L);
 }
 
 /// Generate a name for a statement.
 ///
-/// @param S     The parent SCoP.
-/// @param BB    The basic block the statement will represent.
-/// @param Count The index of the created statement in @p BB.
-static std::string makeStmtName(Scop *S, BasicBlock *BB, int Count) {
-  std::string Suffix = "";
-  if (Count != 0)
+/// @param BB     The basic block the statement will represent.
+/// @param BBIdx  The index of the @p BB relative to other BBs/regions.
+/// @param Count  The index of the created statement in @p BB.
+/// @param IsMain Whether this is the main of all statement for @p BB. If true,
+///               no suffix will be added.
+static std::string makeStmtName(BasicBlock *BB, long BBIdx, int Count,
+                                bool IsMain) {
+  std::string Suffix;
+  if (!IsMain) {
+    if (UseInstructionNames)
+      Suffix = '_';
+    if (Count < 26)
+      Suffix += 'a' + Count;
+    else
       Suffix += std::to_string(Count);
-  return getIslCompatibleName("Stmt", BB, S->getNextStmtIdx(), Suffix,
-                              UseInstructionNames);
+  }
+  return getIslCompatibleName("Stmt", BB, BBIdx, Suffix, UseInstructionNames);
 }
 
 /// Generate a name for a statement that represents a non-affine subregion.
 ///
-/// @param S The parent SCoP.
-/// @param R The region the statement will represent.
-static std::string makeStmtName(Scop *S, Region *R) {
-  return getIslCompatibleName("Stmt", R->getNameStr(), S->getNextStmtIdx(), "",
+/// @param R    The region the statement will represent.
+/// @param RIdx The index of the @p R relative to other BBs/regions.
+static std::string makeStmtName(Region *R, long RIdx) {
+  return getIslCompatibleName("Stmt", R->getNameStr(), RIdx, "",
                               UseInstructionNames);
 }
 
 void ScopBuilder::buildSequentialBlockStmts(BasicBlock *BB, bool SplitOnStore) {
   Loop *SurroundingLoop = LI.getLoopFor(BB);
 
   int Count = 0;
+  long BBIdx = scop->getNextStmtIdx();
   std::vector<Instruction *> Instructions;
   for (Instruction &Inst : *BB) {
     if (shouldModelInst(&Inst, SurroundingLoop))
       Instructions.push_back(&Inst);
     if (Inst.getMetadata("polly_split_after") ||
         (SplitOnStore && isa<StoreInst>(Inst))) {
-      std::string Name = makeStmtName(scop.get(), BB, Count);
+      std::string Name = makeStmtName(BB, BBIdx, Count, Count == 0);
       scop->addScopStmt(BB, Name, SurroundingLoop, Instructions);
       Count++;
       Instructions.clear();
     }
   }
 
-  std::string Name = makeStmtName(scop.get(), BB, Count);
+  std::string Name = makeStmtName(BB, BBIdx, Count, Count == 0);
   scop->addScopStmt(BB, Name, SurroundingLoop, Instructions);
 }
 
 /// Is @p Inst an ordered instruction?
 ///
 /// An unordered instruction is an instruction, such that a sequence of
 /// unordered instructions can be permuted without changing semantics. Any
 /// instruction for which this is not always the case is ordered.

 
 void ScopBuilder::buildEqivClassBlockStmts(BasicBlock *BB) {
   Loop *L = LI.getLoopFor(BB);
 
   // Extracting out modeled instructions saves us from checking
   // shouldModelInst() repeatedly.
   SmallVector<Instruction *, 32> ModeledInsts;
   EquivalenceClasses<Instruction *> UnionFind;
+  Instruction *MainInst = nullptr;
   for (Instruction &Inst : *BB) {
     if (!shouldModelInst(&Inst, L))
       continue;
     ModeledInsts.push_back(&Inst);
     UnionFind.insert(&Inst);
+
+    // When a BB is split into multiple statements, the main statement is the
+    // one containing the 'main' instruction. We select the first instruction
+    // that is unlikely to be removed (because it has side-effects) as the main
+    // one. It is used to ensure that at least one statement from the bb has the
+    // same name as with -polly-stmt-granularity=bb.
+    if (!MainInst && (isa<StoreInst>(Inst) ||
+                      (isa<CallInst>(Inst) && !isa<IntrinsicInst>(Inst))))
+      MainInst = &Inst;
   }
 
   // 'nullptr' represents the last statement for a basic block. It contains no
   // instructions, but holds the PHI write accesses for successor basic blocks.
   // If a PHI has an incoming value defined in this BB, it can also be merged
   // with other statements.
   // TODO: We wouldn't need this if we would add PHIWrites into the statement
   // that defines the incoming value (if in the BB) instead of always the last,
if (LeaderIt == UnionFind.member_end())
       continue;
 
     std::vector<Instruction *> &InstList = LeaderToInstList[*LeaderIt];
     InstList.push_back(&Inst);
   }
 
   // Finally build the statements.
   int Count = 0;
+  long BBIdx = scop->getNextStmtIdx();
   for (auto &Instructions : reverse(LeaderToInstList)) {
     std::vector<Instruction *> &InstList = Instructions.second;
+
+    // If there is no main instruction, make the first statement the main.
+    bool IsMain;
+    if (MainInst)
+      IsMain = std::find(InstList.begin(), InstList.end(), MainInst) !=
+               InstList.end();
+    else
+      IsMain = (Count == 0);
+
     std::reverse(InstList.begin(), InstList.end());
-    std::string Name = makeStmtName(scop.get(), BB, Count);
+    std::string Name = makeStmtName(BB, BBIdx, Count, IsMain);
     scop->addScopStmt(BB, Name, L, std::move(InstList));
     Count += 1;
   }
 }
 
 void ScopBuilder::buildStmts(Region &SR) {
   if (scop->isNonAffineSubRegion(&SR)) {
     std::vector<Instruction *> Instructions;
     Loop *SurroundingLoop =
         getFirstNonBoxedLoopFor(SR.getEntry(), LI, scop->getBoxedLoops());
     for (Instruction &Inst : *SR.getEntry())
       if (shouldModelInst(&Inst, SurroundingLoop))
         Instructions.push_back(&Inst);
-    std::string Name = makeStmtName(scop.get(), &SR);
+    long RIdx = scop->getNextStmtIdx();
+    std::string Name = makeStmtName(&SR, RIdx);
     scop->addScopStmt(&SR, Name, SurroundingLoop, Instructions);
     return;
   }
 
   for (auto I = SR.element_begin(), E = SR.element_end(); I != E; ++I)
     if (I->isSubRegion())
       buildStmts(*I->getNodeAs<Region>());
     else {

polly/trunk/test/ScopInfo/granularity_same_name.ll

+; RUN: opt %loadPolly -polly-stmt-granularity=bb           -polly-use-llvm-names=0 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=IDX
+; RUN: opt %loadPolly -polly-stmt-granularity=bb           -polly-use-llvm-names=1 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=BB
+; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-use-llvm-names=0 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=IDX
+; RUN: opt %loadPolly -polly-stmt-granularity=scalar-indep -polly-use-llvm-names=1 -polly-scops -analyze < %s | FileCheck %s -match-full-lines -check-prefix=BB
+;
+; Check that the statement has the same name, regardless of how the
+; basic block is split into multiple statements.
+; Note that %unrelatedA and %unrelatedB can be put into separate
+; statements, but are removed because those have no side-effects.
+;
+; for (int j = 0; j < n; j += 1) {
+; body:
+;   double unrelatedA = 21.0 + 21.0;
+;   A[0] = 0.0;
+;   double unrelatedB = 21.0 + 21.0;
+; }
+;
+define void @func(i32 %n, double* noalias nonnull %A) {
+entry:
+  br label %for
+
+for:
+  %j = phi i32 [0, %entry], [%j.inc, %inc]
+  %j.cmp = icmp slt i32 %j, %n
+  br i1 %j.cmp, label %body, label %exit
+
+    body:
+      %unrelatedA = fadd double 21.0, 21.0
+      store double 0.0, double* %A
+      %unrelatedB = fadd double 21.0, 21.0
+      br label %inc
+
+inc:
+  %j.inc = add nuw nsw i32 %j, 1
+  br label %for
+
+exit:
+  br label %return
+
+return:
+  ret void
+}
+
+
+; IDX:      Statements {
+; IDX-NEXT:     Stmt1
+
+; BB:       Statements {
+; BB-NEXT:      Stmt_body

polly/trunk/test/ScopInfo/granularity_scalar-indep.ll

 ; CHECK-NEXT:         ReadAccess :=       [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [n] -> { Stmt_body[i0] -> MemRef_A[0] };
 ; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [n] -> { Stmt_body[i0] -> MemRef_A[0] };
 ; CHECK-NEXT:         Instructions {
 ; CHECK-NEXT:               %valA = load double, double* %A
 ; CHECK-NEXT:               store double %valA, double* %A
 ; CHECK-NEXT:         }
-; CHECK-NEXT:     Stmt_body1
+; CHECK-NEXT:     Stmt_body_b
 ; CHECK-NEXT:         Domain :=
-; CHECK-NEXT:             [n] -> { Stmt_body1[i0] : 0 <= i0 < n };
+; CHECK-NEXT:             [n] -> { Stmt_body_b[i0] : 0 <= i0 < n };
 ; CHECK-NEXT:         Schedule :=
-; CHECK-NEXT:             [n] -> { Stmt_body1[i0] -> [i0, 1] };
+; CHECK-NEXT:             [n] -> { Stmt_body_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:             [n] -> { Stmt_body1[i0] -> MemRef_B[0] };
+; CHECK-NEXT:             [n] -> { Stmt_body_b[i0] -> MemRef_B[0] };
 ; CHECK-NEXT:         Instructions {
 ; CHECK-NEXT:               %valB = fadd double 2.100000e+01, 2.100000e+01
 ; CHECK-NEXT:               store double %valB, double* %B
 ; CHECK-NEXT:         }
 ; CHECK-NEXT: }

polly/trunk/test/ScopInfo/granularity_scalar-indep_epilogue.ll

 ; CHECK-NEXT:         ReadAccess :=       [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [n] -> { Stmt_bodyA[i0] -> MemRef_A[0] };
 ; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [n] -> { Stmt_bodyA[i0] -> MemRef_A[0] };
 ; CHECK-NEXT:         Instructions {
 ; CHECK-NEXT:             %valA = load double, double* %A
 ; CHECK-NEXT:             store double %valA, double* %A
 ; CHECK-NEXT:         }
-; CHECK-NEXT:     Stmt_bodyA1
+; CHECK-NEXT:     Stmt_bodyA_b
 ; CHECK-NEXT:         Domain :=
-; CHECK-NEXT:             [n] -> { Stmt_bodyA1[i0] : 0 <= i0 < n };
+; CHECK-NEXT:             [n] -> { Stmt_bodyA_b[i0] : 0 <= i0 < n };
 ; CHECK-NEXT:         Schedule :=
-; CHECK-NEXT:             [n] -> { Stmt_bodyA1[i0] -> [i0, 1] };
+; CHECK-NEXT:             [n] -> { Stmt_bodyA_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [n] -> { Stmt_bodyA1[i0] -> MemRef_phi__phi[] };
+; CHECK-NEXT:             [n] -> { Stmt_bodyA_b[i0] -> MemRef_phi__phi[] };
 ; CHECK-NEXT:         Instructions {
 ; CHECK-NEXT:         }
 ; CHECK-NEXT: }

polly/trunk/test/ScopInfo/stmt_split_exit_of_region_stmt.ll

 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4, !polly_split_after !0
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 2] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 2] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:   }
 ;
-; Function Attrs: noinline nounwind uwtable 
+; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, i32* %B, double* %C) {
 entry:
   br label %for.cond
 
 for.cond:                                         ; preds = %for.inc, %entry
   %i.0 = phi i32 [ 0, %entry ], [ %add, %for.inc ]
   %cmp = icmp slt i32 %i.0, 1024
   br i1 %cmp, label %for.body, label %for.end

polly/trunk/test/ScopInfo/stmt_split_no_dependence.ll

 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4, !polly_split_after !0
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:    }
 ;
 ; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, i32* %B) #0 {
 entry:

polly/trunk/test/ScopInfo/stmt_split_on_store.ll

 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:    }
 ;
 ; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, i32* %B) #0 {
 entry:

polly/trunk/test/ScopInfo/stmt_split_on_synthesizable.ll

 ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
 ;
 ; CHECK:    Statements {
 ; CHECK-NEXT:   Stmt_Stmt
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:   }
 ;
 ; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, i32* %B, double* %C) #0 {
 entry:

polly/trunk/test/ScopInfo/stmt_split_phi_in_beginning_bb.ll

 ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
 ;
 ; CHECK:    Statements {
 ; CHECK-NEXT:   Stmt_Stmt
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %phi, i32* %arrayidx, align 4, !polly_split_after !0
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:   }
 ;
 ; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, i32* %B) #0 {
 entry:

polly/trunk/test/ScopInfo/stmt_split_phi_in_stmt.ll

 ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
 ;
 ; CHECK:    Statements {
 ; CHECK-NEXT:   Stmt_Stmt
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4, !polly_split_after !0
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[i0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_phi__phi[] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_phi__phi[] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             %d = fadd double 2.100000e+01, 2.100000e+01
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:   Stmt_for_inc
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_for_inc[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=

polly/trunk/test/ScopInfo/stmt_split_scalar_dependence.ll

 ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
 ;
 ; CHECK:    Statements {
 ; CHECK-NEXT:   Stmt_Stmt
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> [i0, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:           { Stmt_Stmt[i0] -> MemRef_a[] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             %a = fadd double 2.100000e+01, 2.100000e+01
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4, !polly_split_after !0
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] : 0 <= i0 <= 1023 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> [i0, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> [i0, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_B[0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_B[0] };
 ; CHECK-NEXT:       ReadAccess :=  [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:           { Stmt_Stmt1[i0] -> MemRef_a[] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0] -> MemRef_a[] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store double %a, double* %B
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:   }
 ;
 ; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, double* %B) #0 {
 entry:

polly/trunk/test/ScopInfo/stmt_split_within_loop.ll

 ; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
 ;
 ; CHECK:    Statements {
 ; CHECK-NEXT:   Stmt_Stmt
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0, i1] : 0 <= i0 <= 1023 and 0 <= i1 <= 512 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_Stmt[i0, i1] -> [i0, i1, 0] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_Stmt[i0, i1] -> MemRef_A[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx, align 4, !polly_split_after !0
 ; CHECK-NEXT:       }
-; CHECK-NEXT:   Stmt_Stmt1
+; CHECK-NEXT:   Stmt_Stmt_b
 ; CHECK-NEXT:       Domain :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0, i1] : 0 <= i0 <= 1023 and 0 <= i1 <= 512 };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0, i1] : 0 <= i0 <= 1023 and 0 <= i1 <= 512 };
 ; CHECK-NEXT:       Schedule :=
-; CHECK-NEXT:           { Stmt_Stmt1[i0, i1] -> [i0, i1, 1] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0, i1] -> [i0, i1, 1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
-; CHECK-NEXT:           { Stmt_Stmt1[i0, i1] -> MemRef_B[i0] };
+; CHECK-NEXT:           { Stmt_Stmt_b[i0, i1] -> MemRef_B[i0] };
 ; CHECK-NEXT:       Instructions {
 ; CHECK-NEXT:             store i32 %i.0, i32* %arrayidx2, align 4
 ; CHECK-NEXT:             %cond = icmp slt i32 %j, 512
 ; CHECK-NEXT:       }
 ; CHECK-NEXT:   }
 ;
 ; Function Attrs: noinline nounwind uwtable
 define void @func(i32* %A, i32* %B, double* %C) #0 {