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

1 files changed, 74 insertions, 74 deletions

diff --git a/contrib/libs/llvm12/lib/Transforms/Utils/LoopUnroll.cpp b/contrib/libs/llvm12/lib/Transforms/Utils/LoopUnroll.cpp
index 6a80eba7a1..d4cd574052 100644
--- a/contrib/libs/llvm12/lib/Transforms/Utils/LoopUnroll.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/Utils/LoopUnroll.cpp
@@ -59,7 +59,7 @@
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Transforms/Utils/Local.h"
-#include "llvm/Transforms/Utils/LoopPeel.h" 
+#include "llvm/Transforms/Utils/LoopPeel.h"
 #include "llvm/Transforms/Utils/LoopSimplify.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 #include "llvm/Transforms/Utils/SimplifyIndVar.h"
@@ -109,15 +109,15 @@ UnrollVerifyDomtree("unroll-verify-domtree", cl::Hidden,
 /// insert a phi-node, otherwise LCSSA will be broken.
 /// The function is just a helper function for llvm::UnrollLoop that returns
 /// true if this situation occurs, indicating that LCSSA needs to be fixed.
-static bool needToInsertPhisForLCSSA(Loop *L, 
-                                     const std::vector<BasicBlock *> &Blocks, 
+static bool needToInsertPhisForLCSSA(Loop *L,
+                                     const std::vector<BasicBlock *> &Blocks,
                                      LoopInfo *LI) {
   for (BasicBlock *BB : Blocks) {
     if (LI->getLoopFor(BB) == L)
       continue;
     for (Instruction &I : *BB) {
       for (Use &U : I.operands()) {
-        if (const auto *Def = dyn_cast<Instruction>(U)) { 
+        if (const auto *Def = dyn_cast<Instruction>(U)) {
           Loop *DefLoop = LI->getLoopFor(Def->getParent());
           if (!DefLoop)
             continue;
@@ -288,12 +288,12 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
                                   OptimizationRemarkEmitter *ORE,
                                   bool PreserveLCSSA, Loop **RemainderLoop) {
 
-  if (!L->getLoopPreheader()) { 
+  if (!L->getLoopPreheader()) {
     LLVM_DEBUG(dbgs() << "  Can't unroll; loop preheader-insertion failed.\n");
     return LoopUnrollResult::Unmodified;
   }
 
-  if (!L->getLoopLatch()) { 
+  if (!L->getLoopLatch()) {
     LLVM_DEBUG(dbgs() << "  Can't unroll; loop exit-block-insertion failed.\n");
     return LoopUnrollResult::Unmodified;
   }
@@ -304,7 +304,7 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
     return LoopUnrollResult::Unmodified;
   }
 
-  if (L->getHeader()->hasAddressTaken()) { 
+  if (L->getHeader()->hasAddressTaken()) {
     // The loop-rotate pass can be helpful to avoid this in many cases.
     LLVM_DEBUG(
         dbgs() << "  Won't unroll loop: address of header block is taken.\n");
@@ -362,58 +362,58 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
     }
   }
 
-  // All these values should be taken only after peeling because they might have 
-  // changed. 
-  BasicBlock *Preheader = L->getLoopPreheader(); 
-  BasicBlock *Header = L->getHeader(); 
-  BasicBlock *LatchBlock = L->getLoopLatch(); 
-  SmallVector<BasicBlock *, 4> ExitBlocks; 
-  L->getExitBlocks(ExitBlocks); 
-  std::vector<BasicBlock *> OriginalLoopBlocks = L->getBlocks(); 
- 
-  // Go through all exits of L and see if there are any phi-nodes there. We just 
-  // conservatively assume that they're inserted to preserve LCSSA form, which 
-  // means that complete unrolling might break this form. We need to either fix 
-  // it in-place after the transformation, or entirely rebuild LCSSA. TODO: For 
-  // now we just recompute LCSSA for the outer loop, but it should be possible 
-  // to fix it in-place. 
-  bool NeedToFixLCSSA = 
-      PreserveLCSSA && CompletelyUnroll && 
-      any_of(ExitBlocks, 
-             [](const BasicBlock *BB) { return isa<PHINode>(BB->begin()); }); 
- 
-  // The current loop unroll pass can unroll loops that have 
-  // (1) single latch; and 
-  // (2a) latch is unconditional; or 
-  // (2b) latch is conditional and is an exiting block 
-  // FIXME: The implementation can be extended to work with more complicated 
-  // cases, e.g. loops with multiple latches. 
-  BranchInst *LatchBI = dyn_cast<BranchInst>(LatchBlock->getTerminator()); 
- 
-  // A conditional branch which exits the loop, which can be optimized to an 
-  // unconditional branch in the unrolled loop in some cases. 
-  BranchInst *ExitingBI = nullptr; 
-  bool LatchIsExiting = L->isLoopExiting(LatchBlock); 
-  if (LatchIsExiting) 
-    ExitingBI = LatchBI; 
-  else if (BasicBlock *ExitingBlock = L->getExitingBlock()) 
-    ExitingBI = dyn_cast<BranchInst>(ExitingBlock->getTerminator()); 
-  if (!LatchBI || (LatchBI->isConditional() && !LatchIsExiting)) { 
-    // If the peeling guard is changed this assert may be relaxed or even 
-    // deleted. 
-    assert(!Peeled && "Peeling guard changed!"); 
-    LLVM_DEBUG( 
-        dbgs() << "Can't unroll; a conditional latch must exit the loop"); 
-    return LoopUnrollResult::Unmodified; 
-  } 
-  LLVM_DEBUG({ 
-    if (ExitingBI) 
-      dbgs() << "  Exiting Block = " << ExitingBI->getParent()->getName() 
-             << "\n"; 
-    else 
-      dbgs() << "  No single exiting block\n"; 
-  }); 
- 
+  // All these values should be taken only after peeling because they might have
+  // changed.
+  BasicBlock *Preheader = L->getLoopPreheader();
+  BasicBlock *Header = L->getHeader();
+  BasicBlock *LatchBlock = L->getLoopLatch();
+  SmallVector<BasicBlock *, 4> ExitBlocks;
+  L->getExitBlocks(ExitBlocks);
+  std::vector<BasicBlock *> OriginalLoopBlocks = L->getBlocks();
+
+  // Go through all exits of L and see if there are any phi-nodes there. We just
+  // conservatively assume that they're inserted to preserve LCSSA form, which
+  // means that complete unrolling might break this form. We need to either fix
+  // it in-place after the transformation, or entirely rebuild LCSSA. TODO: For
+  // now we just recompute LCSSA for the outer loop, but it should be possible
+  // to fix it in-place.
+  bool NeedToFixLCSSA =
+      PreserveLCSSA && CompletelyUnroll &&
+      any_of(ExitBlocks,
+             [](const BasicBlock *BB) { return isa<PHINode>(BB->begin()); });
+
+  // The current loop unroll pass can unroll loops that have
+  // (1) single latch; and
+  // (2a) latch is unconditional; or
+  // (2b) latch is conditional and is an exiting block
+  // FIXME: The implementation can be extended to work with more complicated
+  // cases, e.g. loops with multiple latches.
+  BranchInst *LatchBI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
+
+  // A conditional branch which exits the loop, which can be optimized to an
+  // unconditional branch in the unrolled loop in some cases.
+  BranchInst *ExitingBI = nullptr;
+  bool LatchIsExiting = L->isLoopExiting(LatchBlock);
+  if (LatchIsExiting)
+    ExitingBI = LatchBI;
+  else if (BasicBlock *ExitingBlock = L->getExitingBlock())
+    ExitingBI = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
+  if (!LatchBI || (LatchBI->isConditional() && !LatchIsExiting)) {
+    // If the peeling guard is changed this assert may be relaxed or even
+    // deleted.
+    assert(!Peeled && "Peeling guard changed!");
+    LLVM_DEBUG(
+        dbgs() << "Can't unroll; a conditional latch must exit the loop");
+    return LoopUnrollResult::Unmodified;
+  }
+  LLVM_DEBUG({
+    if (ExitingBI)
+      dbgs() << "  Exiting Block = " << ExitingBI->getParent()->getName()
+             << "\n";
+    else
+      dbgs() << "  No single exiting block\n";
+  });
+
   // Loops containing convergent instructions must have a count that divides
   // their TripMultiple.
   LLVM_DEBUG(
@@ -590,11 +590,11 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
                          << DIL->getFilename() << " Line: " << DIL->getLine());
           }
 
-  // Identify what noalias metadata is inside the loop: if it is inside the 
-  // loop, the associated metadata must be cloned for each iteration. 
-  SmallVector<MDNode *, 6> LoopLocalNoAliasDeclScopes; 
-  identifyNoAliasScopesToClone(L->getBlocks(), LoopLocalNoAliasDeclScopes); 
- 
+  // Identify what noalias metadata is inside the loop: if it is inside the
+  // loop, the associated metadata must be cloned for each iteration.
+  SmallVector<MDNode *, 6> LoopLocalNoAliasDeclScopes;
+  identifyNoAliasScopesToClone(L->getBlocks(), LoopLocalNoAliasDeclScopes);
+
   for (unsigned It = 1; It != ULO.Count; ++It) {
     SmallVector<BasicBlock *, 8> NewBlocks;
     SmallDenseMap<const Loop *, Loop *, 4> NewLoops;
@@ -688,15 +688,15 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
             AC->registerAssumption(II);
       }
     }
- 
-    { 
-      // Identify what other metadata depends on the cloned version. After 
-      // cloning, replace the metadata with the corrected version for both 
-      // memory instructions and noalias intrinsics. 
-      std::string ext = (Twine("It") + Twine(It)).str(); 
-      cloneAndAdaptNoAliasScopes(LoopLocalNoAliasDeclScopes, NewBlocks, 
-                                 Header->getContext(), ext); 
-    } 
+
+    {
+      // Identify what other metadata depends on the cloned version. After
+      // cloning, replace the metadata with the corrected version for both
+      // memory instructions and noalias intrinsics.
+      std::string ext = (Twine("It") + Twine(It)).str();
+      cloneAndAdaptNoAliasScopes(LoopLocalNoAliasDeclScopes, NewBlocks,
+                                 Header->getContext(), ext);
+    }
   }
 
   // Loop over the PHI nodes in the original block, setting incoming values.
@@ -884,7 +884,7 @@ LoopUnrollResult llvm::UnrollLoop(Loop *L, UnrollLoopOptions ULO, LoopInfo *LI,
       if (MergeBlockIntoPredecessor(Dest, &DTU, LI)) {
         // Dest has been folded into Fold. Update our worklists accordingly.
         std::replace(Latches.begin(), Latches.end(), Dest, Fold);
-        llvm::erase_value(UnrolledLoopBlocks, Dest); 
+        llvm::erase_value(UnrolledLoopBlocks, Dest);
       }
     }
   }