Simplify main statement flag in ScopBuilder::buildEqivClassBlockStmts

[bin.narwal]

Summary

Hi,
When reading code in ScopBuilder::buildEqivClassBlockStmts, I think the main statement flag computation can be simplified, here is the patch. It's based on two simple facts that: 1, Instruction won't be removed once it's inserted into UnionFind. 2, Main statement must be set if there is non-trivial statement besides the last one. The patch also saves std::find call. Any comments?

BTW, this is my first patch to LLVM/Polly. Please correct me if there is anything wrong. Thanks in advance.

Thanks,

[Meinersbur]

The change looks good. Thank you for the contribution! Could you change the comments a bit as remarked inline?

Once you updated this diff, I can do the commit with a "Patch by: bin.narwal <[e-mail]>" line if you want.

lib/Analysis/ScopBuilder.cpp

2144 ↗

(On Diff #216147)

"yet" does not fit the context: The decision of which is the main statement has been made before, and will not change during this loop. I suggest to just remove the "yet" (or keep the original comment, I don't see any change in meaning)

2157 ↗

(On Diff #216147)

Could you add a comment about that Count == 0 means that there was no other main? Suggestion:

// The epilogue becomes the main statement only if there is no other statement that could become main.

[bin.narwal]

Hi Meinersbur,
Thanks very much for reviewing. Here is the updated patch according to your comments.

Thanks,

polly/trunk/lib/Analysis/ScopBuilder.cpp

 
 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;
+  Instruction *MainInst = nullptr, *MainLeader = 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
void ScopBuilder::buildEqivClassBlockStmts(BasicBlock *BB) {
 
   // Collect the instructions of all leaders. UnionFind's member iterator
   // unfortunately are not in any specific order.
   for (Instruction &Inst : reverse(*BB)) {
     auto LeaderIt = UnionFind.findLeader(&Inst);
     if (LeaderIt == UnionFind.member_end())
       continue;
 
+    if (&Inst == MainInst)
+      MainLeader = *LeaderIt;
     std::vector<Instruction *> &InstList = LeaderToInstList[*LeaderIt];
     InstList.push_back(&Inst);
   }
 
   // Finally build the statements.
   int Count = 0;
   long BBIdx = scop->getNextStmtIdx();
-  bool MainFound = false;
   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);
-    if (IsMain)
-      MainFound = true;
+    bool IsMain = (MainInst ? MainLeader == Instructions.first : Count == 0);
 
     std::reverse(InstList.begin(), InstList.end());
     std::string Name = makeStmtName(BB, BBIdx, Count, IsMain);
     scop->addScopStmt(BB, Name, L, std::move(InstList));
     Count += 1;
   }
 
   // Unconditionally add an epilogue (last statement). It contains no
   // instructions, but holds the PHI write accesses for successor basic blocks,
   // if the incoming value is not defined in another statement if the same BB.
+  // The epilogue becomes the main statement only if there is no other
+  // statement that could become main.
   // The epilogue will be removed if no PHIWrite is added to it.
-  std::string EpilogueName = makeStmtName(BB, BBIdx, Count, !MainFound, true);
+  std::string EpilogueName = makeStmtName(BB, BBIdx, Count, Count == 0, true);
   scop->addScopStmt(BB, EpilogueName, L, {});
 }
 
 void ScopBuilder::buildStmts(Region &SR) {
   if (scop->isNonAffineSubRegion(&SR)) {
     std::vector<Instruction *> Instructions;
     Loop *SurroundingLoop =
         getFirstNonBoxedLoopFor(SR.getEntry(), LI, scop->getBoxedLoops());