Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 284 insertions, 284 deletions

diff --git a/contrib/libs/llvm12/lib/Analysis/SyncDependenceAnalysis.cpp b/contrib/libs/llvm12/lib/Analysis/SyncDependenceAnalysis.cpp
index 67a1365b69..f26176a2c5 100644
--- a/contrib/libs/llvm12/lib/Analysis/SyncDependenceAnalysis.cpp
+++ b/contrib/libs/llvm12/lib/Analysis/SyncDependenceAnalysis.cpp
@@ -1,4 +1,4 @@
-//===--- SyncDependenceAnalysis.cpp - Compute Control Divergence Effects --===//
+//===--- SyncDependenceAnalysis.cpp - Compute Control Divergence Effects --===// 
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -98,7 +98,7 @@
 // loop exit and the loop header (_after_ SSA construction).
 //
 //===----------------------------------------------------------------------===//
-#include "llvm/Analysis/SyncDependenceAnalysis.h"
+#include "llvm/Analysis/SyncDependenceAnalysis.h" 
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Analysis/PostDominators.h"
@@ -107,355 +107,355 @@
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 
-#include <functional>
+#include <functional> 
 #include <stack>
 #include <unordered_set>
 
 #define DEBUG_TYPE "sync-dependence"
 
-// The SDA algorithm operates on a modified CFG - we modify the edges leaving
-// loop headers as follows:
-//
-// * We remove all edges leaving all loop headers.
-// * We add additional edges from the loop headers to their exit blocks.
-//
-// The modification is virtual, that is whenever we visit a loop header we
-// pretend it had different successors.
-namespace {
-using namespace llvm;
-
-// Custom Post-Order Traveral
-//
-// We cannot use the vanilla (R)PO computation of LLVM because:
-// * We (virtually) modify the CFG.
-// * We want a loop-compact block enumeration, that is the numbers assigned by
-//   the traveral to the blocks of a loop are an interval.
-using POCB = std::function<void(const BasicBlock &)>;
-using VisitedSet = std::set<const BasicBlock *>;
-using BlockStack = std::vector<const BasicBlock *>;
-
-// forward
-static void computeLoopPO(const LoopInfo &LI, Loop &Loop, POCB CallBack,
-                          VisitedSet &Finalized);
-
-// for a nested region (top-level loop or nested loop)
-static void computeStackPO(BlockStack &Stack, const LoopInfo &LI, Loop *Loop,
-                           POCB CallBack, VisitedSet &Finalized) {
-  const auto *LoopHeader = Loop ? Loop->getHeader() : nullptr;
-  while (!Stack.empty()) {
-    const auto *NextBB = Stack.back();
-
-    auto *NestedLoop = LI.getLoopFor(NextBB);
-    bool IsNestedLoop = NestedLoop != Loop;
-
-    // Treat the loop as a node
-    if (IsNestedLoop) {
-      SmallVector<BasicBlock *, 3> NestedExits;
-      NestedLoop->getUniqueExitBlocks(NestedExits);
-      bool PushedNodes = false;
-      for (const auto *NestedExitBB : NestedExits) {
-        if (NestedExitBB == LoopHeader)
-          continue;
-        if (Loop && !Loop->contains(NestedExitBB))
-          continue;
-        if (Finalized.count(NestedExitBB))
-          continue;
-        PushedNodes = true;
-        Stack.push_back(NestedExitBB);
-      }
-      if (!PushedNodes) {
-        // All loop exits finalized -> finish this node
-        Stack.pop_back();
-        computeLoopPO(LI, *NestedLoop, CallBack, Finalized);
-      }
-      continue;
-    }
-
-    // DAG-style
-    bool PushedNodes = false;
-    for (const auto *SuccBB : successors(NextBB)) {
-      if (SuccBB == LoopHeader)
-        continue;
-      if (Loop && !Loop->contains(SuccBB))
-        continue;
-      if (Finalized.count(SuccBB))
-        continue;
-      PushedNodes = true;
-      Stack.push_back(SuccBB);
-    }
-    if (!PushedNodes) {
-      // Never push nodes twice
-      Stack.pop_back();
-      if (!Finalized.insert(NextBB).second)
-        continue;
-      CallBack(*NextBB);
-    }
-  }
-}
-
-static void computeTopLevelPO(Function &F, const LoopInfo &LI, POCB CallBack) {
-  VisitedSet Finalized;
-  BlockStack Stack;
-  Stack.reserve(24); // FIXME made-up number
-  Stack.push_back(&F.getEntryBlock());
-  computeStackPO(Stack, LI, nullptr, CallBack, Finalized);
-}
-
-static void computeLoopPO(const LoopInfo &LI, Loop &Loop, POCB CallBack,
-                          VisitedSet &Finalized) {
-  /// Call CallBack on all loop blocks.
-  std::vector<const BasicBlock *> Stack;
-  const auto *LoopHeader = Loop.getHeader();
-
-  // Visit the header last
-  Finalized.insert(LoopHeader);
-  CallBack(*LoopHeader);
-
-  // Initialize with immediate successors
-  for (const auto *BB : successors(LoopHeader)) {
-    if (!Loop.contains(BB))
-      continue;
-    if (BB == LoopHeader)
-      continue;
-    Stack.push_back(BB);
-  }
-
-  // Compute PO inside region
-  computeStackPO(Stack, LI, &Loop, CallBack, Finalized);
-}
-
-} // namespace
-
+// The SDA algorithm operates on a modified CFG - we modify the edges leaving 
+// loop headers as follows: 
+// 
+// * We remove all edges leaving all loop headers. 
+// * We add additional edges from the loop headers to their exit blocks. 
+// 
+// The modification is virtual, that is whenever we visit a loop header we 
+// pretend it had different successors. 
+namespace { 
+using namespace llvm; 
+ 
+// Custom Post-Order Traveral 
+// 
+// We cannot use the vanilla (R)PO computation of LLVM because: 
+// * We (virtually) modify the CFG. 
+// * We want a loop-compact block enumeration, that is the numbers assigned by 
+//   the traveral to the blocks of a loop are an interval. 
+using POCB = std::function<void(const BasicBlock &)>; 
+using VisitedSet = std::set<const BasicBlock *>; 
+using BlockStack = std::vector<const BasicBlock *>; 
+ 
+// forward 
+static void computeLoopPO(const LoopInfo &LI, Loop &Loop, POCB CallBack, 
+                          VisitedSet &Finalized); 
+ 
+// for a nested region (top-level loop or nested loop) 
+static void computeStackPO(BlockStack &Stack, const LoopInfo &LI, Loop *Loop, 
+                           POCB CallBack, VisitedSet &Finalized) { 
+  const auto *LoopHeader = Loop ? Loop->getHeader() : nullptr; 
+  while (!Stack.empty()) { 
+    const auto *NextBB = Stack.back(); 
+ 
+    auto *NestedLoop = LI.getLoopFor(NextBB); 
+    bool IsNestedLoop = NestedLoop != Loop; 
+ 
+    // Treat the loop as a node 
+    if (IsNestedLoop) { 
+      SmallVector<BasicBlock *, 3> NestedExits; 
+      NestedLoop->getUniqueExitBlocks(NestedExits); 
+      bool PushedNodes = false; 
+      for (const auto *NestedExitBB : NestedExits) { 
+        if (NestedExitBB == LoopHeader) 
+          continue; 
+        if (Loop && !Loop->contains(NestedExitBB)) 
+          continue; 
+        if (Finalized.count(NestedExitBB)) 
+          continue; 
+        PushedNodes = true; 
+        Stack.push_back(NestedExitBB); 
+      } 
+      if (!PushedNodes) { 
+        // All loop exits finalized -> finish this node 
+        Stack.pop_back(); 
+        computeLoopPO(LI, *NestedLoop, CallBack, Finalized); 
+      } 
+      continue; 
+    } 
+ 
+    // DAG-style 
+    bool PushedNodes = false; 
+    for (const auto *SuccBB : successors(NextBB)) { 
+      if (SuccBB == LoopHeader) 
+        continue; 
+      if (Loop && !Loop->contains(SuccBB)) 
+        continue; 
+      if (Finalized.count(SuccBB)) 
+        continue; 
+      PushedNodes = true; 
+      Stack.push_back(SuccBB); 
+    } 
+    if (!PushedNodes) { 
+      // Never push nodes twice 
+      Stack.pop_back(); 
+      if (!Finalized.insert(NextBB).second) 
+        continue; 
+      CallBack(*NextBB); 
+    } 
+  } 
+} 
+ 
+static void computeTopLevelPO(Function &F, const LoopInfo &LI, POCB CallBack) { 
+  VisitedSet Finalized; 
+  BlockStack Stack; 
+  Stack.reserve(24); // FIXME made-up number 
+  Stack.push_back(&F.getEntryBlock()); 
+  computeStackPO(Stack, LI, nullptr, CallBack, Finalized); 
+} 
+ 
+static void computeLoopPO(const LoopInfo &LI, Loop &Loop, POCB CallBack, 
+                          VisitedSet &Finalized) { 
+  /// Call CallBack on all loop blocks. 
+  std::vector<const BasicBlock *> Stack; 
+  const auto *LoopHeader = Loop.getHeader(); 
+ 
+  // Visit the header last 
+  Finalized.insert(LoopHeader); 
+  CallBack(*LoopHeader); 
+ 
+  // Initialize with immediate successors 
+  for (const auto *BB : successors(LoopHeader)) { 
+    if (!Loop.contains(BB)) 
+      continue; 
+    if (BB == LoopHeader) 
+      continue; 
+    Stack.push_back(BB); 
+  } 
+ 
+  // Compute PO inside region 
+  computeStackPO(Stack, LI, &Loop, CallBack, Finalized); 
+} 
+ 
+} // namespace 
+ 
 namespace llvm {
 
-ControlDivergenceDesc SyncDependenceAnalysis::EmptyDivergenceDesc;
+ControlDivergenceDesc SyncDependenceAnalysis::EmptyDivergenceDesc; 
 
 SyncDependenceAnalysis::SyncDependenceAnalysis(const DominatorTree &DT,
                                                const PostDominatorTree &PDT,
                                                const LoopInfo &LI)
-    : DT(DT), PDT(PDT), LI(LI) {
-  computeTopLevelPO(*DT.getRoot()->getParent(), LI,
-                    [&](const BasicBlock &BB) { LoopPO.appendBlock(BB); });
-}
+    : DT(DT), PDT(PDT), LI(LI) { 
+  computeTopLevelPO(*DT.getRoot()->getParent(), LI, 
+                    [&](const BasicBlock &BB) { LoopPO.appendBlock(BB); }); 
+} 
 
 SyncDependenceAnalysis::~SyncDependenceAnalysis() {}
 
 // divergence propagator for reducible CFGs
 struct DivergencePropagator {
-  const ModifiedPO &LoopPOT;
+  const ModifiedPO &LoopPOT; 
   const DominatorTree &DT;
   const PostDominatorTree &PDT;
   const LoopInfo &LI;
-  const BasicBlock &DivTermBlock;
-
-  // * if BlockLabels[IndexOf(B)] == C then C is the dominating definition at
-  //   block B
-  // * if BlockLabels[IndexOf(B)] ~ undef then we haven't seen B yet
-  // * if BlockLabels[IndexOf(B)] == B then B is a join point of disjoint paths
-  // from X or B is an immediate successor of X (initial value).
-  using BlockLabelVec = std::vector<const BasicBlock *>;
-  BlockLabelVec BlockLabels;
-  // divergent join and loop exit descriptor.
-  std::unique_ptr<ControlDivergenceDesc> DivDesc;
-
-  DivergencePropagator(const ModifiedPO &LoopPOT, const DominatorTree &DT,
-                       const PostDominatorTree &PDT, const LoopInfo &LI,
-                       const BasicBlock &DivTermBlock)
-      : LoopPOT(LoopPOT), DT(DT), PDT(PDT), LI(LI), DivTermBlock(DivTermBlock),
-        BlockLabels(LoopPOT.size(), nullptr),
-        DivDesc(new ControlDivergenceDesc) {}
+  const BasicBlock &DivTermBlock; 
+
+  // * if BlockLabels[IndexOf(B)] == C then C is the dominating definition at 
+  //   block B 
+  // * if BlockLabels[IndexOf(B)] ~ undef then we haven't seen B yet 
+  // * if BlockLabels[IndexOf(B)] == B then B is a join point of disjoint paths 
+  // from X or B is an immediate successor of X (initial value). 
+  using BlockLabelVec = std::vector<const BasicBlock *>; 
+  BlockLabelVec BlockLabels; 
+  // divergent join and loop exit descriptor. 
+  std::unique_ptr<ControlDivergenceDesc> DivDesc; 
+
+  DivergencePropagator(const ModifiedPO &LoopPOT, const DominatorTree &DT, 
+                       const PostDominatorTree &PDT, const LoopInfo &LI, 
+                       const BasicBlock &DivTermBlock) 
+      : LoopPOT(LoopPOT), DT(DT), PDT(PDT), LI(LI), DivTermBlock(DivTermBlock), 
+        BlockLabels(LoopPOT.size(), nullptr), 
+        DivDesc(new ControlDivergenceDesc) {} 
 
   void printDefs(raw_ostream &Out) {
-    Out << "Propagator::BlockLabels {\n";
-    for (int BlockIdx = (int)BlockLabels.size() - 1; BlockIdx > 0; --BlockIdx) {
-      const auto *Label = BlockLabels[BlockIdx];
-      Out << LoopPOT.getBlockAt(BlockIdx)->getName().str() << "(" << BlockIdx
-          << ") : ";
-      if (!Label) {
-        Out << "<null>\n";
+    Out << "Propagator::BlockLabels {\n"; 
+    for (int BlockIdx = (int)BlockLabels.size() - 1; BlockIdx > 0; --BlockIdx) { 
+      const auto *Label = BlockLabels[BlockIdx]; 
+      Out << LoopPOT.getBlockAt(BlockIdx)->getName().str() << "(" << BlockIdx 
+          << ") : "; 
+      if (!Label) { 
+        Out << "<null>\n"; 
       } else {
-        Out << Label->getName() << "\n";
+        Out << Label->getName() << "\n"; 
       }
     }
     Out << "}\n";
   }
 
-  // Push a definition (\p PushedLabel) to \p SuccBlock and return whether this
-  // causes a divergent join.
-  bool computeJoin(const BasicBlock &SuccBlock, const BasicBlock &PushedLabel) {
-    auto SuccIdx = LoopPOT.getIndexOf(SuccBlock);
+  // Push a definition (\p PushedLabel) to \p SuccBlock and return whether this 
+  // causes a divergent join. 
+  bool computeJoin(const BasicBlock &SuccBlock, const BasicBlock &PushedLabel) { 
+    auto SuccIdx = LoopPOT.getIndexOf(SuccBlock); 
 
-    // unset or same reaching label
-    const auto *OldLabel = BlockLabels[SuccIdx];
-    if (!OldLabel || (OldLabel == &PushedLabel)) {
-      BlockLabels[SuccIdx] = &PushedLabel;
-      return false;
+    // unset or same reaching label 
+    const auto *OldLabel = BlockLabels[SuccIdx]; 
+    if (!OldLabel || (OldLabel == &PushedLabel)) { 
+      BlockLabels[SuccIdx] = &PushedLabel; 
+      return false; 
     }
 
-    // Update the definition
-    BlockLabels[SuccIdx] = &SuccBlock;
-    return true;
-  }
-
-  // visiting a virtual loop exit edge from the loop header --> temporal
-  // divergence on join
-  bool visitLoopExitEdge(const BasicBlock &ExitBlock,
-                         const BasicBlock &DefBlock, bool FromParentLoop) {
-    // Pushing from a non-parent loop cannot cause temporal divergence.
-    if (!FromParentLoop)
-      return visitEdge(ExitBlock, DefBlock);
-
-    if (!computeJoin(ExitBlock, DefBlock))
-      return false;
-
-    // Identified a divergent loop exit
-    DivDesc->LoopDivBlocks.insert(&ExitBlock);
-    LLVM_DEBUG(dbgs() << "\tDivergent loop exit: " << ExitBlock.getName()
-                      << "\n");
-    return true;
+    // Update the definition 
+    BlockLabels[SuccIdx] = &SuccBlock; 
+    return true; 
+  } 
+
+  // visiting a virtual loop exit edge from the loop header --> temporal 
+  // divergence on join 
+  bool visitLoopExitEdge(const BasicBlock &ExitBlock, 
+                         const BasicBlock &DefBlock, bool FromParentLoop) { 
+    // Pushing from a non-parent loop cannot cause temporal divergence. 
+    if (!FromParentLoop) 
+      return visitEdge(ExitBlock, DefBlock); 
+
+    if (!computeJoin(ExitBlock, DefBlock)) 
+      return false; 
+ 
+    // Identified a divergent loop exit 
+    DivDesc->LoopDivBlocks.insert(&ExitBlock); 
+    LLVM_DEBUG(dbgs() << "\tDivergent loop exit: " << ExitBlock.getName() 
+                      << "\n"); 
+    return true; 
   }
 
-  // process \p SuccBlock with reaching definition \p DefBlock
-  bool visitEdge(const BasicBlock &SuccBlock, const BasicBlock &DefBlock) {
-    if (!computeJoin(SuccBlock, DefBlock))
-      return false;
-
-    // Divergent, disjoint paths join.
-    DivDesc->JoinDivBlocks.insert(&SuccBlock);
-    LLVM_DEBUG(dbgs() << "\tDivergent join: " << SuccBlock.getName());
-    return true;
-  }
-
-  std::unique_ptr<ControlDivergenceDesc> computeJoinPoints() {
-    assert(DivDesc);
-
-    LLVM_DEBUG(dbgs() << "SDA:computeJoinPoints: " << DivTermBlock.getName()
-                      << "\n");
-
-    const auto *DivBlockLoop = LI.getLoopFor(&DivTermBlock);
-
-    // Early stopping criterion
-    int FloorIdx = LoopPOT.size() - 1;
-    const BasicBlock *FloorLabel = nullptr;
-
+  // process \p SuccBlock with reaching definition \p DefBlock 
+  bool visitEdge(const BasicBlock &SuccBlock, const BasicBlock &DefBlock) { 
+    if (!computeJoin(SuccBlock, DefBlock)) 
+      return false; 
+
+    // Divergent, disjoint paths join. 
+    DivDesc->JoinDivBlocks.insert(&SuccBlock); 
+    LLVM_DEBUG(dbgs() << "\tDivergent join: " << SuccBlock.getName()); 
+    return true; 
+  } 
+
+  std::unique_ptr<ControlDivergenceDesc> computeJoinPoints() { 
+    assert(DivDesc); 
+ 
+    LLVM_DEBUG(dbgs() << "SDA:computeJoinPoints: " << DivTermBlock.getName() 
+                      << "\n"); 
+ 
+    const auto *DivBlockLoop = LI.getLoopFor(&DivTermBlock); 
+ 
+    // Early stopping criterion 
+    int FloorIdx = LoopPOT.size() - 1; 
+    const BasicBlock *FloorLabel = nullptr; 
+ 
     // bootstrap with branch targets
-    int BlockIdx = 0;
-
-    for (const auto *SuccBlock : successors(&DivTermBlock)) {
-      auto SuccIdx = LoopPOT.getIndexOf(*SuccBlock);
-      BlockLabels[SuccIdx] = SuccBlock;
-
-      // Find the successor with the highest index to start with
-      BlockIdx = std::max<int>(BlockIdx, SuccIdx);
-      FloorIdx = std::min<int>(FloorIdx, SuccIdx);
-
-      // Identify immediate divergent loop exits
-      if (!DivBlockLoop)
-        continue;
-
-      const auto *BlockLoop = LI.getLoopFor(SuccBlock);
-      if (BlockLoop && DivBlockLoop->contains(BlockLoop))
-        continue;
-      DivDesc->LoopDivBlocks.insert(SuccBlock);
-      LLVM_DEBUG(dbgs() << "\tImmediate divergent loop exit: "
-                        << SuccBlock->getName() << "\n");
+    int BlockIdx = 0; 
+
+    for (const auto *SuccBlock : successors(&DivTermBlock)) { 
+      auto SuccIdx = LoopPOT.getIndexOf(*SuccBlock); 
+      BlockLabels[SuccIdx] = SuccBlock; 
+
+      // Find the successor with the highest index to start with 
+      BlockIdx = std::max<int>(BlockIdx, SuccIdx); 
+      FloorIdx = std::min<int>(FloorIdx, SuccIdx); 
+
+      // Identify immediate divergent loop exits 
+      if (!DivBlockLoop) 
+        continue; 
+
+      const auto *BlockLoop = LI.getLoopFor(SuccBlock); 
+      if (BlockLoop && DivBlockLoop->contains(BlockLoop)) 
+        continue; 
+      DivDesc->LoopDivBlocks.insert(SuccBlock); 
+      LLVM_DEBUG(dbgs() << "\tImmediate divergent loop exit: " 
+                        << SuccBlock->getName() << "\n"); 
     }
 
     // propagate definitions at the immediate successors of the node in RPO
-    for (; BlockIdx >= FloorIdx; --BlockIdx) {
-      LLVM_DEBUG(dbgs() << "Before next visit:\n"; printDefs(dbgs()));
+    for (; BlockIdx >= FloorIdx; --BlockIdx) { 
+      LLVM_DEBUG(dbgs() << "Before next visit:\n"; printDefs(dbgs())); 
 
-      // Any label available here
-      const auto *Label = BlockLabels[BlockIdx];
-      if (!Label)
+      // Any label available here 
+      const auto *Label = BlockLabels[BlockIdx]; 
+      if (!Label) 
         continue;
 
-      // Ok. Get the block
-      const auto *Block = LoopPOT.getBlockAt(BlockIdx);
-      LLVM_DEBUG(dbgs() << "SDA::joins. visiting " << Block->getName() << "\n");
+      // Ok. Get the block 
+      const auto *Block = LoopPOT.getBlockAt(BlockIdx); 
+      LLVM_DEBUG(dbgs() << "SDA::joins. visiting " << Block->getName() << "\n"); 
 
       auto *BlockLoop = LI.getLoopFor(Block);
-      bool IsLoopHeader = BlockLoop && BlockLoop->getHeader() == Block;
-      bool CausedJoin = false;
-      int LoweredFloorIdx = FloorIdx;
-      if (IsLoopHeader) {
-        // Disconnect from immediate successors and propagate directly to loop
-        // exits.
+      bool IsLoopHeader = BlockLoop && BlockLoop->getHeader() == Block; 
+      bool CausedJoin = false; 
+      int LoweredFloorIdx = FloorIdx; 
+      if (IsLoopHeader) { 
+        // Disconnect from immediate successors and propagate directly to loop 
+        // exits. 
         SmallVector<BasicBlock *, 4> BlockLoopExits;
         BlockLoop->getExitBlocks(BlockLoopExits);
-
-        bool IsParentLoop = BlockLoop->contains(&DivTermBlock);
+ 
+        bool IsParentLoop = BlockLoop->contains(&DivTermBlock); 
         for (const auto *BlockLoopExit : BlockLoopExits) {
-          CausedJoin |= visitLoopExitEdge(*BlockLoopExit, *Label, IsParentLoop);
-          LoweredFloorIdx = std::min<int>(LoweredFloorIdx,
-                                          LoopPOT.getIndexOf(*BlockLoopExit));
+          CausedJoin |= visitLoopExitEdge(*BlockLoopExit, *Label, IsParentLoop); 
+          LoweredFloorIdx = std::min<int>(LoweredFloorIdx, 
+                                          LoopPOT.getIndexOf(*BlockLoopExit)); 
         }
       } else {
-        // Acyclic successor case
+        // Acyclic successor case 
         for (const auto *SuccBlock : successors(Block)) {
-          CausedJoin |= visitEdge(*SuccBlock, *Label);
-          LoweredFloorIdx =
-              std::min<int>(LoweredFloorIdx, LoopPOT.getIndexOf(*SuccBlock));
+          CausedJoin |= visitEdge(*SuccBlock, *Label); 
+          LoweredFloorIdx = 
+              std::min<int>(LoweredFloorIdx, LoopPOT.getIndexOf(*SuccBlock)); 
         }
       }
-
-      // Floor update
-      if (CausedJoin) {
-        // 1. Different labels pushed to successors
-        FloorIdx = LoweredFloorIdx;
-      } else if (FloorLabel != Label) {
-        // 2. No join caused BUT we pushed a label that is different than the
-        // last pushed label
-        FloorIdx = LoweredFloorIdx;
-        FloorLabel = Label;
-      }
+ 
+      // Floor update 
+      if (CausedJoin) { 
+        // 1. Different labels pushed to successors 
+        FloorIdx = LoweredFloorIdx; 
+      } else if (FloorLabel != Label) { 
+        // 2. No join caused BUT we pushed a label that is different than the 
+        // last pushed label 
+        FloorIdx = LoweredFloorIdx; 
+        FloorLabel = Label; 
+      } 
     }
 
     LLVM_DEBUG(dbgs() << "SDA::joins. After propagation:\n"; printDefs(dbgs()));
 
-    return std::move(DivDesc);
+    return std::move(DivDesc); 
   }
 };
 
-#ifndef NDEBUG
-static void printBlockSet(ConstBlockSet &Blocks, raw_ostream &Out) {
-  Out << "[";
-  bool First = true;
-  for (const auto *BB : Blocks) {
-    if (!First)
-      Out << ", ";
-    First = false;
-    Out << BB->getName();
+#ifndef NDEBUG 
+static void printBlockSet(ConstBlockSet &Blocks, raw_ostream &Out) { 
+  Out << "["; 
+  bool First = true; 
+  for (const auto *BB : Blocks) { 
+    if (!First) 
+      Out << ", "; 
+    First = false; 
+    Out << BB->getName(); 
   }
-  Out << "]";
+  Out << "]"; 
 }
-#endif
+#endif 
 
-const ControlDivergenceDesc &
-SyncDependenceAnalysis::getJoinBlocks(const Instruction &Term) {
+const ControlDivergenceDesc & 
+SyncDependenceAnalysis::getJoinBlocks(const Instruction &Term) { 
   // trivial case
-  if (Term.getNumSuccessors() <= 1) {
-    return EmptyDivergenceDesc;
+  if (Term.getNumSuccessors() <= 1) { 
+    return EmptyDivergenceDesc; 
   }
 
   // already available in cache?
-  auto ItCached = CachedControlDivDescs.find(&Term);
-  if (ItCached != CachedControlDivDescs.end())
+  auto ItCached = CachedControlDivDescs.find(&Term); 
+  if (ItCached != CachedControlDivDescs.end()) 
     return *ItCached->second;
 
   // compute all join points
-  // Special handling of divergent loop exits is not needed for LCSSA
+  // Special handling of divergent loop exits is not needed for LCSSA 
   const auto &TermBlock = *Term.getParent();
-  DivergencePropagator Propagator(LoopPO, DT, PDT, LI, TermBlock);
-  auto DivDesc = Propagator.computeJoinPoints();
-
-  LLVM_DEBUG(dbgs() << "Result (" << Term.getParent()->getName() << "):\n";
-             dbgs() << "JoinDivBlocks: ";
-             printBlockSet(DivDesc->JoinDivBlocks, dbgs());
-             dbgs() << "\nLoopDivBlocks: ";
-             printBlockSet(DivDesc->LoopDivBlocks, dbgs()); dbgs() << "\n";);
-
-  auto ItInserted = CachedControlDivDescs.emplace(&Term, std::move(DivDesc));
+  DivergencePropagator Propagator(LoopPO, DT, PDT, LI, TermBlock); 
+  auto DivDesc = Propagator.computeJoinPoints(); 
+
+  LLVM_DEBUG(dbgs() << "Result (" << Term.getParent()->getName() << "):\n"; 
+             dbgs() << "JoinDivBlocks: "; 
+             printBlockSet(DivDesc->JoinDivBlocks, dbgs()); 
+             dbgs() << "\nLoopDivBlocks: "; 
+             printBlockSet(DivDesc->LoopDivBlocks, dbgs()); dbgs() << "\n";); 
+ 
+  auto ItInserted = CachedControlDivDescs.emplace(&Term, std::move(DivDesc)); 
   assert(ItInserted.second);
   return *ItInserted.first->second;
 }