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

12 files changed, 438 insertions, 438 deletions

diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.cpp
index d6f06c7c8d..7f7f2dc89b 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.cpp
@@ -22,7 +22,7 @@
 #include "DependencyAnalysis.h"
 #include "ObjCARC.h"
 #include "ProvenanceAnalysis.h"
-#include "llvm/Analysis/AliasAnalysis.h" 
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/CFG.h"
 
 using namespace llvm;
@@ -53,7 +53,7 @@ bool llvm::objcarc::CanAlterRefCount(const Instruction *Inst, const Value *Ptr,
     return false;
   if (AliasAnalysis::onlyAccessesArgPointees(MRB)) {
     for (const Value *Op : Call->args()) {
-      if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op)) 
+      if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op))
         return true;
     }
     return false;
@@ -96,24 +96,24 @@ bool llvm::objcarc::CanUse(const Instruction *Inst, const Value *Ptr,
     // For calls, just check the arguments (and not the callee operand).
     for (auto OI = CS->arg_begin(), OE = CS->arg_end(); OI != OE; ++OI) {
       const Value *Op = *OI;
-      if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op)) 
+      if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op))
         return true;
     }
     return false;
   } else if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
     // Special-case stores, because we don't care about the stored value, just
     // the store address.
-    const Value *Op = GetUnderlyingObjCPtr(SI->getPointerOperand()); 
+    const Value *Op = GetUnderlyingObjCPtr(SI->getPointerOperand());
     // If we can't tell what the underlying object was, assume there is a
     // dependence.
-    return IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Op, Ptr); 
+    return IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Op, Ptr);
   }
 
   // Check each operand for a match.
   for (User::const_op_iterator OI = Inst->op_begin(), OE = Inst->op_end();
        OI != OE; ++OI) {
     const Value *Op = *OI;
-    if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op)) 
+    if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op))
       return true;
   }
   return false;
@@ -209,13 +209,13 @@ llvm::objcarc::Depends(DependenceKind Flavor, Instruction *Inst,
 /// non-local dependencies on Arg.
 ///
 /// TODO: Cache results?
-static bool findDependencies(DependenceKind Flavor, const Value *Arg, 
-                             BasicBlock *StartBB, Instruction *StartInst, 
-                             SmallPtrSetImpl<Instruction *> &DependingInsts, 
-                             ProvenanceAnalysis &PA) { 
+static bool findDependencies(DependenceKind Flavor, const Value *Arg,
+                             BasicBlock *StartBB, Instruction *StartInst,
+                             SmallPtrSetImpl<Instruction *> &DependingInsts,
+                             ProvenanceAnalysis &PA) {
   BasicBlock::iterator StartPos = StartInst->getIterator();
 
-  SmallPtrSet<const BasicBlock *, 4> Visited; 
+  SmallPtrSet<const BasicBlock *, 4> Visited;
   SmallVector<std::pair<BasicBlock *, BasicBlock::iterator>, 4> Worklist;
   Worklist.push_back(std::make_pair(StartBB, StartPos));
   do {
@@ -228,14 +228,14 @@ static bool findDependencies(DependenceKind Flavor, const Value *Arg,
       if (LocalStartPos == StartBBBegin) {
         pred_iterator PI(LocalStartBB), PE(LocalStartBB, false);
         if (PI == PE)
-          // Return if we've reached the function entry. 
-          return false; 
-        // Add the predecessors to the worklist. 
-        do { 
-          BasicBlock *PredBB = *PI; 
-          if (Visited.insert(PredBB).second) 
-            Worklist.push_back(std::make_pair(PredBB, PredBB->end())); 
-        } while (++PI != PE); 
+          // Return if we've reached the function entry.
+          return false;
+        // Add the predecessors to the worklist.
+        do {
+          BasicBlock *PredBB = *PI;
+          if (Visited.insert(PredBB).second)
+            Worklist.push_back(std::make_pair(PredBB, PredBB->end()));
+        } while (++PI != PE);
         break;
       }
 
@@ -254,22 +254,22 @@ static bool findDependencies(DependenceKind Flavor, const Value *Arg,
     if (BB == StartBB)
       continue;
     for (const BasicBlock *Succ : successors(BB))
-      if (Succ != StartBB && !Visited.count(Succ)) 
-        return false; 
+      if (Succ != StartBB && !Visited.count(Succ))
+        return false;
   }
- 
-  return true; 
+
+  return true;
+}
+
+llvm::Instruction *llvm::objcarc::findSingleDependency(DependenceKind Flavor,
+                                                       const Value *Arg,
+                                                       BasicBlock *StartBB,
+                                                       Instruction *StartInst,
+                                                       ProvenanceAnalysis &PA) {
+  SmallPtrSet<Instruction *, 4> DependingInsts;
+
+  if (!findDependencies(Flavor, Arg, StartBB, StartInst, DependingInsts, PA) ||
+      DependingInsts.size() != 1)
+    return nullptr;
+  return *DependingInsts.begin();
 }
- 
-llvm::Instruction *llvm::objcarc::findSingleDependency(DependenceKind Flavor, 
-                                                       const Value *Arg, 
-                                                       BasicBlock *StartBB, 
-                                                       Instruction *StartInst, 
-                                                       ProvenanceAnalysis &PA) { 
-  SmallPtrSet<Instruction *, 4> DependingInsts; 
- 
-  if (!findDependencies(Flavor, Arg, StartBB, StartInst, DependingInsts, PA) || 
-      DependingInsts.size() != 1) 
-    return nullptr; 
-  return *DependingInsts.begin(); 
-} 
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.h b/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.h
index 706099e0ee..cf4c05ebe9 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.h
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/DependencyAnalysis.h
@@ -50,12 +50,12 @@ enum DependenceKind {
   RetainRVDep                 ///< Blocks objc_retainAutoreleasedReturnValue.
 };
 
-/// Find dependent instructions. If there is exactly one dependent instruction, 
-/// return it. Otherwise, return null. 
-llvm::Instruction *findSingleDependency(DependenceKind Flavor, const Value *Arg, 
-                                        BasicBlock *StartBB, 
-                                        Instruction *StartInst, 
-                                        ProvenanceAnalysis &PA); 
+/// Find dependent instructions. If there is exactly one dependent instruction,
+/// return it. Otherwise, return null.
+llvm::Instruction *findSingleDependency(DependenceKind Flavor, const Value *Arg,
+                                        BasicBlock *StartBB,
+                                        Instruction *StartInst,
+                                        ProvenanceAnalysis &PA);
 
 bool
 Depends(DependenceKind Flavor, Instruction *Inst, const Value *Arg,
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARC.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARC.cpp
index c4350f6230..970136392f 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARC.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARC.cpp
@@ -29,8 +29,8 @@ void llvm::initializeObjCARCOpts(PassRegistry &Registry) {
   initializeObjCARCAAWrapperPassPass(Registry);
   initializeObjCARCAPElimPass(Registry);
   initializeObjCARCExpandPass(Registry);
-  initializeObjCARCContractLegacyPassPass(Registry); 
-  initializeObjCARCOptLegacyPassPass(Registry); 
+  initializeObjCARCContractLegacyPassPass(Registry);
+  initializeObjCARCOptLegacyPassPass(Registry);
   initializePAEvalPass(Registry);
 }
 
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp
index 579fa5a5b4..6a928f2c7f 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp
@@ -26,11 +26,11 @@
 #include "ObjCARC.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/PassManager.h" 
+#include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/ObjCARC.h" 
+#include "llvm/Transforms/ObjCARC.h"
 
 using namespace llvm;
 using namespace llvm::objcarc;
@@ -41,7 +41,7 @@ namespace {
 
 /// Interprocedurally determine if calls made by the given call site can
 /// possibly produce autoreleases.
-bool MayAutorelease(const CallBase &CB, unsigned Depth = 0) { 
+bool MayAutorelease(const CallBase &CB, unsigned Depth = 0) {
   if (const Function *Callee = CB.getCalledFunction()) {
     if (!Callee->hasExactDefinition())
       return true;
@@ -60,7 +60,7 @@ bool MayAutorelease(const CallBase &CB, unsigned Depth = 0) {
   return true;
 }
 
-bool OptimizeBB(BasicBlock *BB) { 
+bool OptimizeBB(BasicBlock *BB) {
   bool Changed = false;
 
   Instruction *Push = nullptr;
@@ -98,7 +98,7 @@ bool OptimizeBB(BasicBlock *BB) {
   return Changed;
 }
 
-bool runImpl(Module &M) { 
+bool runImpl(Module &M) {
   if (!EnableARCOpts)
     return false;
 
@@ -144,40 +144,40 @@ bool runImpl(Module &M) {
 
   return Changed;
 }
- 
-/// Autorelease pool elimination. 
-class ObjCARCAPElim : public ModulePass { 
-  void getAnalysisUsage(AnalysisUsage &AU) const override; 
-  bool runOnModule(Module &M) override; 
- 
-public: 
-  static char ID; 
-  ObjCARCAPElim() : ModulePass(ID) { 
-    initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry()); 
-  } 
-}; 
-} // namespace 
- 
-char ObjCARCAPElim::ID = 0; 
-INITIALIZE_PASS(ObjCARCAPElim, "objc-arc-apelim", 
-                "ObjC ARC autorelease pool elimination", false, false) 
- 
-Pass *llvm::createObjCARCAPElimPass() { return new ObjCARCAPElim(); } 
- 
-void ObjCARCAPElim::getAnalysisUsage(AnalysisUsage &AU) const { 
-  AU.setPreservesCFG(); 
-} 
- 
-bool ObjCARCAPElim::runOnModule(Module &M) { 
-  if (skipModule(M)) 
-    return false; 
-  return runImpl(M); 
-} 
- 
-PreservedAnalyses ObjCARCAPElimPass::run(Module &M, ModuleAnalysisManager &AM) { 
-  if (!runImpl(M)) 
-    return PreservedAnalyses::all(); 
-  PreservedAnalyses PA; 
-  PA.preserveSet<CFGAnalyses>(); 
-  return PA; 
-} 
+
+/// Autorelease pool elimination.
+class ObjCARCAPElim : public ModulePass {
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnModule(Module &M) override;
+
+public:
+  static char ID;
+  ObjCARCAPElim() : ModulePass(ID) {
+    initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry());
+  }
+};
+} // namespace
+
+char ObjCARCAPElim::ID = 0;
+INITIALIZE_PASS(ObjCARCAPElim, "objc-arc-apelim",
+                "ObjC ARC autorelease pool elimination", false, false)
+
+Pass *llvm::createObjCARCAPElimPass() { return new ObjCARCAPElim(); }
+
+void ObjCARCAPElim::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesCFG();
+}
+
+bool ObjCARCAPElim::runOnModule(Module &M) {
+  if (skipModule(M))
+    return false;
+  return runImpl(M);
+}
+
+PreservedAnalyses ObjCARCAPElimPass::run(Module &M, ModuleAnalysisManager &AM) {
+  if (!runImpl(M))
+    return PreservedAnalyses::all();
+  PreservedAnalyses PA;
+  PA.preserveSet<CFGAnalyses>();
+  return PA;
+}
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCContract.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCContract.cpp
index 120880ad37..86d161116e 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCContract.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCContract.cpp
@@ -30,18 +30,18 @@
 #include "ObjCARC.h"
 #include "ProvenanceAnalysis.h"
 #include "llvm/ADT/Statistic.h"
-#include "llvm/Analysis/AliasAnalysis.h" 
+#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Operator.h"
-#include "llvm/IR/PassManager.h" 
+#include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/ObjCARC.h" 
+#include "llvm/Transforms/ObjCARC.h"
 
 using namespace llvm;
 using namespace llvm::objcarc;
@@ -56,63 +56,63 @@ STATISTIC(NumStoreStrongs, "Number objc_storeStrong calls formed");
 //===----------------------------------------------------------------------===//
 
 namespace {
-/// Late ARC optimizations 
-/// 
-/// These change the IR in a way that makes it difficult to be analyzed by 
-/// ObjCARCOpt, so it's run late. 
-
-class ObjCARCContract { 
-  bool Changed; 
-  AAResults *AA; 
-  DominatorTree *DT; 
-  ProvenanceAnalysis PA; 
-  ARCRuntimeEntryPoints EP; 
-
-  /// A flag indicating whether this optimization pass should run. 
-  bool Run; 
-
-  /// The inline asm string to insert between calls and RetainRV calls to make 
-  /// the optimization work on targets which need it. 
-  const MDString *RVInstMarker; 
-
-  /// The set of inserted objc_storeStrong calls. If at the end of walking the 
-  /// function we have found no alloca instructions, these calls can be marked 
-  /// "tail". 
-  SmallPtrSet<CallInst *, 8> StoreStrongCalls; 
-
-  /// Returns true if we eliminated Inst. 
-  bool tryToPeepholeInstruction( 
-      Function &F, Instruction *Inst, inst_iterator &Iter, 
-      bool &TailOkForStoreStrong, 
-      const DenseMap<BasicBlock *, ColorVector> &BlockColors); 
-
-  bool optimizeRetainCall(Function &F, Instruction *Retain); 
-
-  bool contractAutorelease(Function &F, Instruction *Autorelease, 
-                           ARCInstKind Class); 
-
-  void tryToContractReleaseIntoStoreStrong( 
-      Instruction *Release, inst_iterator &Iter, 
-      const DenseMap<BasicBlock *, ColorVector> &BlockColors); 
-
-public: 
-  bool init(Module &M); 
-  bool run(Function &F, AAResults *AA, DominatorTree *DT); 
-}; 
- 
-class ObjCARCContractLegacyPass : public FunctionPass { 
-  ObjCARCContract OCARCC; 
- 
-public: 
-  void getAnalysisUsage(AnalysisUsage &AU) const override; 
-  bool doInitialization(Module &M) override; 
-  bool runOnFunction(Function &F) override; 
- 
-  static char ID; 
-  ObjCARCContractLegacyPass() : FunctionPass(ID) { 
-    initializeObjCARCContractLegacyPassPass(*PassRegistry::getPassRegistry()); 
-  } 
-}; 
+/// Late ARC optimizations
+///
+/// These change the IR in a way that makes it difficult to be analyzed by
+/// ObjCARCOpt, so it's run late.
+
+class ObjCARCContract {
+  bool Changed;
+  AAResults *AA;
+  DominatorTree *DT;
+  ProvenanceAnalysis PA;
+  ARCRuntimeEntryPoints EP;
+
+  /// A flag indicating whether this optimization pass should run.
+  bool Run;
+
+  /// The inline asm string to insert between calls and RetainRV calls to make
+  /// the optimization work on targets which need it.
+  const MDString *RVInstMarker;
+
+  /// The set of inserted objc_storeStrong calls. If at the end of walking the
+  /// function we have found no alloca instructions, these calls can be marked
+  /// "tail".
+  SmallPtrSet<CallInst *, 8> StoreStrongCalls;
+
+  /// Returns true if we eliminated Inst.
+  bool tryToPeepholeInstruction(
+      Function &F, Instruction *Inst, inst_iterator &Iter,
+      bool &TailOkForStoreStrong,
+      const DenseMap<BasicBlock *, ColorVector> &BlockColors);
+
+  bool optimizeRetainCall(Function &F, Instruction *Retain);
+
+  bool contractAutorelease(Function &F, Instruction *Autorelease,
+                           ARCInstKind Class);
+
+  void tryToContractReleaseIntoStoreStrong(
+      Instruction *Release, inst_iterator &Iter,
+      const DenseMap<BasicBlock *, ColorVector> &BlockColors);
+
+public:
+  bool init(Module &M);
+  bool run(Function &F, AAResults *AA, DominatorTree *DT);
+};
+
+class ObjCARCContractLegacyPass : public FunctionPass {
+  ObjCARCContract OCARCC;
+
+public:
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool doInitialization(Module &M) override;
+  bool runOnFunction(Function &F) override;
+
+  static char ID;
+  ObjCARCContractLegacyPass() : FunctionPass(ID) {
+    initializeObjCARCContractLegacyPassPass(*PassRegistry::getPassRegistry());
+  }
+};
 }
 
 //===----------------------------------------------------------------------===//
@@ -156,17 +156,17 @@ bool ObjCARCContract::optimizeRetainCall(Function &F, Instruction *Retain) {
 }
 
 /// Merge an autorelease with a retain into a fused call.
-bool ObjCARCContract::contractAutorelease(Function &F, Instruction *Autorelease, 
-                                          ARCInstKind Class) { 
+bool ObjCARCContract::contractAutorelease(Function &F, Instruction *Autorelease,
+                                          ARCInstKind Class) {
   const Value *Arg = GetArgRCIdentityRoot(Autorelease);
 
   // Check that there are no instructions between the retain and the autorelease
   // (such as an autorelease_pop) which may change the count.
-  DependenceKind DK = Class == ARCInstKind::AutoreleaseRV 
-                          ? RetainAutoreleaseRVDep 
-                          : RetainAutoreleaseDep; 
-  auto *Retain = dyn_cast_or_null<CallInst>( 
-      findSingleDependency(DK, Arg, Autorelease->getParent(), Autorelease, PA)); 
+  DependenceKind DK = Class == ARCInstKind::AutoreleaseRV
+                          ? RetainAutoreleaseRVDep
+                          : RetainAutoreleaseDep;
+  auto *Retain = dyn_cast_or_null<CallInst>(
+      findSingleDependency(DK, Arg, Autorelease->getParent(), Autorelease, PA));
 
   if (!Retain || GetBasicARCInstKind(Retain) != ARCInstKind::Retain ||
       GetArgRCIdentityRoot(Retain) != Arg)
@@ -196,7 +196,7 @@ bool ObjCARCContract::contractAutorelease(Function &F, Instruction *Autorelease,
 static StoreInst *findSafeStoreForStoreStrongContraction(LoadInst *Load,
                                                          Instruction *Release,
                                                          ProvenanceAnalysis &PA,
-                                                         AAResults *AA) { 
+                                                         AAResults *AA) {
   StoreInst *Store = nullptr;
   bool SawRelease = false;
 
@@ -434,7 +434,7 @@ void ObjCARCContract::tryToContractReleaseIntoStoreStrong(
 
 bool ObjCARCContract::tryToPeepholeInstruction(
     Function &F, Instruction *Inst, inst_iterator &Iter,
-    bool &TailOkForStoreStrongs, 
+    bool &TailOkForStoreStrongs,
     const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
   // Only these library routines return their argument. In particular,
   // objc_retainBlock does not necessarily return its argument.
@@ -445,7 +445,7 @@ bool ObjCARCContract::tryToPeepholeInstruction(
     return false;
   case ARCInstKind::Autorelease:
   case ARCInstKind::AutoreleaseRV:
-    return contractAutorelease(F, Inst, Class); 
+    return contractAutorelease(F, Inst, Class);
   case ARCInstKind::Retain:
     // Attempt to convert retains to retainrvs if they are next to function
     // calls.
@@ -476,7 +476,7 @@ bool ObjCARCContract::tryToPeepholeInstruction(
       --BBI;
     } while (IsNoopInstruction(&*BBI));
 
-    if (GetRCIdentityRoot(&*BBI) == GetArgRCIdentityRoot(Inst)) { 
+    if (GetRCIdentityRoot(&*BBI) == GetArgRCIdentityRoot(Inst)) {
       LLVM_DEBUG(dbgs() << "Adding inline asm marker for the return value "
                            "optimization.\n");
       Changed = true;
@@ -533,22 +533,22 @@ bool ObjCARCContract::tryToPeepholeInstruction(
 //                              Top Level Driver
 //===----------------------------------------------------------------------===//
 
-bool ObjCARCContract::init(Module &M) { 
-  // If nothing in the Module uses ARC, don't do anything. 
-  Run = ModuleHasARC(M); 
-  if (!Run) 
-    return false; 
- 
-  EP.init(&M); 
- 
-  // Initialize RVInstMarker. 
-  const char *MarkerKey = "clang.arc.retainAutoreleasedReturnValueMarker"; 
-  RVInstMarker = dyn_cast_or_null<MDString>(M.getModuleFlag(MarkerKey)); 
- 
-  return false; 
-} 
- 
-bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) { 
+bool ObjCARCContract::init(Module &M) {
+  // If nothing in the Module uses ARC, don't do anything.
+  Run = ModuleHasARC(M);
+  if (!Run)
+    return false;
+
+  EP.init(&M);
+
+  // Initialize RVInstMarker.
+  const char *MarkerKey = "clang.arc.retainAutoreleasedReturnValueMarker";
+  RVInstMarker = dyn_cast_or_null<MDString>(M.getModuleFlag(MarkerKey));
+
+  return false;
+}
+
+bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) {
   if (!EnableARCOpts)
     return false;
 
@@ -557,9 +557,9 @@ bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) {
     return false;
 
   Changed = false;
-  AA = A; 
-  DT = D; 
-  PA.setAA(A); 
+  AA = A;
+  DT = D;
+  PA.setAA(A);
 
   DenseMap<BasicBlock *, ColorVector> BlockColors;
   if (F.hasPersonalityFn() &&
@@ -586,8 +586,8 @@ bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) {
 
     // First try to peephole Inst. If there is nothing further we can do in
     // terms of undoing objc-arc-expand, process the next inst.
-    if (tryToPeepholeInstruction(F, Inst, I, TailOkForStoreStrongs, 
-                                 BlockColors)) 
+    if (tryToPeepholeInstruction(F, Inst, I, TailOkForStoreStrongs,
+                                 BlockColors))
       continue;
 
     // Otherwise, try to undo objc-arc-expand.
@@ -722,45 +722,45 @@ bool ObjCARCContract::run(Function &F, AAResults *A, DominatorTree *D) {
 //                             Misc Pass Manager
 //===----------------------------------------------------------------------===//
 
-char ObjCARCContractLegacyPass::ID = 0; 
-INITIALIZE_PASS_BEGIN(ObjCARCContractLegacyPass, "objc-arc-contract", 
+char ObjCARCContractLegacyPass::ID = 0;
+INITIALIZE_PASS_BEGIN(ObjCARCContractLegacyPass, "objc-arc-contract",
                       "ObjC ARC contraction", false, false)
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
-INITIALIZE_PASS_END(ObjCARCContractLegacyPass, "objc-arc-contract", 
+INITIALIZE_PASS_END(ObjCARCContractLegacyPass, "objc-arc-contract",
                     "ObjC ARC contraction", false, false)
 
-void ObjCARCContractLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const { 
+void ObjCARCContractLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<AAResultsWrapperPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.setPreservesCFG();
 }
 
-Pass *llvm::createObjCARCContractPass() { 
-  return new ObjCARCContractLegacyPass(); 
-} 
-
-bool ObjCARCContractLegacyPass::doInitialization(Module &M) { 
-  return OCARCC.init(M); 
-} 
-
-bool ObjCARCContractLegacyPass::runOnFunction(Function &F) { 
-  auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults(); 
-  auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 
-  return OCARCC.run(F, AA, DT); 
-} 
-
-PreservedAnalyses ObjCARCContractPass::run(Function &F, 
-                                           FunctionAnalysisManager &AM) { 
-  ObjCARCContract OCAC; 
-  OCAC.init(*F.getParent()); 
-
-  bool Changed = OCAC.run(F, &AM.getResult<AAManager>(F), 
-                          &AM.getResult<DominatorTreeAnalysis>(F)); 
-  if (Changed) { 
-    PreservedAnalyses PA; 
-    PA.preserveSet<CFGAnalyses>(); 
-    return PA; 
-  } 
-  return PreservedAnalyses::all(); 
+Pass *llvm::createObjCARCContractPass() {
+  return new ObjCARCContractLegacyPass();
+}
+
+bool ObjCARCContractLegacyPass::doInitialization(Module &M) {
+  return OCARCC.init(M);
+}
+
+bool ObjCARCContractLegacyPass::runOnFunction(Function &F) {
+  auto *AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
+  auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+  return OCARCC.run(F, AA, DT);
+}
+
+PreservedAnalyses ObjCARCContractPass::run(Function &F,
+                                           FunctionAnalysisManager &AM) {
+  ObjCARCContract OCAC;
+  OCAC.init(*F.getParent());
+
+  bool Changed = OCAC.run(F, &AM.getResult<AAManager>(F),
+                          &AM.getResult<DominatorTreeAnalysis>(F));
+  if (Changed) {
+    PreservedAnalyses PA;
+    PA.preserveSet<CFGAnalyses>();
+    return PA;
+  }
+  return PreservedAnalyses::all();
 }
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCExpand.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCExpand.cpp
index 7a8e01d5d7..d2121dcebe 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCExpand.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCExpand.cpp
@@ -27,7 +27,7 @@
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/IR/PassManager.h" 
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
@@ -35,7 +35,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/ObjCARC.h" 
+#include "llvm/Transforms/ObjCARC.h"
 
 #define DEBUG_TYPE "objc-arc-expand"
 
@@ -43,12 +43,12 @@ using namespace llvm;
 using namespace llvm::objcarc;
 
 namespace {
-static bool runImpl(Function &F) { 
+static bool runImpl(Function &F) {
   if (!EnableARCOpts)
     return false;
 
   // If nothing in the Module uses ARC, don't do anything.
-  if (!ModuleHasARC(*F.getParent())) 
+  if (!ModuleHasARC(*F.getParent()))
     return false;
 
   bool Changed = false;
@@ -90,37 +90,37 @@ static bool runImpl(Function &F) {
 
   return Changed;
 }
- 
-/// Early ARC transformations. 
-class ObjCARCExpand : public FunctionPass { 
-  void getAnalysisUsage(AnalysisUsage &AU) const override; 
-  bool runOnFunction(Function &F) override; 
- 
-public: 
-  static char ID; 
-  ObjCARCExpand() : FunctionPass(ID) { 
-    initializeObjCARCExpandPass(*PassRegistry::getPassRegistry()); 
-  } 
-}; 
-} // namespace 
- 
-char ObjCARCExpand::ID = 0; 
-INITIALIZE_PASS(ObjCARCExpand, "objc-arc-expand", "ObjC ARC expansion", false, 
-                false) 
- 
-Pass *llvm::createObjCARCExpandPass() { return new ObjCARCExpand(); } 
- 
-void ObjCARCExpand::getAnalysisUsage(AnalysisUsage &AU) const { 
-  AU.setPreservesCFG(); 
-} 
- 
-bool ObjCARCExpand::runOnFunction(Function &F) { return runImpl(F); } 
- 
-PreservedAnalyses ObjCARCExpandPass::run(Function &F, 
-                                         FunctionAnalysisManager &AM) { 
-  if (!runImpl(F)) 
-    return PreservedAnalyses::all(); 
-  PreservedAnalyses PA; 
-  PA.preserveSet<CFGAnalyses>(); 
-  return PA; 
-} 
+
+/// Early ARC transformations.
+class ObjCARCExpand : public FunctionPass {
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool runOnFunction(Function &F) override;
+
+public:
+  static char ID;
+  ObjCARCExpand() : FunctionPass(ID) {
+    initializeObjCARCExpandPass(*PassRegistry::getPassRegistry());
+  }
+};
+} // namespace
+
+char ObjCARCExpand::ID = 0;
+INITIALIZE_PASS(ObjCARCExpand, "objc-arc-expand", "ObjC ARC expansion", false,
+                false)
+
+Pass *llvm::createObjCARCExpandPass() { return new ObjCARCExpand(); }
+
+void ObjCARCExpand::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesCFG();
+}
+
+bool ObjCARCExpand::runOnFunction(Function &F) { return runImpl(F); }
+
+PreservedAnalyses ObjCARCExpandPass::run(Function &F,
+                                         FunctionAnalysisManager &AM) {
+  if (!runImpl(F))
+    return PreservedAnalyses::all();
+  PreservedAnalyses PA;
+  PA.preserveSet<CFGAnalyses>();
+  return PA;
+}
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCOpts.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCOpts.cpp
index e6761a9000..1c44749951 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCOpts.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ObjCARCOpts.cpp
@@ -65,7 +65,7 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/ObjCARC.h" 
+#include "llvm/Transforms/ObjCARC.h"
 #include <cassert>
 #include <iterator>
 #include <utility>
@@ -481,133 +481,133 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, BBState &BBInfo) {
 namespace {
 
   /// The main ARC optimization pass.
-class ObjCARCOpt { 
-  bool Changed; 
-  ProvenanceAnalysis PA; 
-
-  /// A cache of references to runtime entry point constants. 
-  ARCRuntimeEntryPoints EP; 
-
-  /// A cache of MDKinds that can be passed into other functions to propagate 
-  /// MDKind identifiers. 
-  ARCMDKindCache MDKindCache; 
-
-  /// A flag indicating whether this optimization pass should run. 
-  bool Run; 
-
-  /// A flag indicating whether the optimization that removes or moves 
-  /// retain/release pairs should be performed. 
-  bool DisableRetainReleasePairing = false; 
-
-  /// Flags which determine whether each of the interesting runtime functions 
-  /// is in fact used in the current function. 
-  unsigned UsedInThisFunction; 
-
-  bool OptimizeRetainRVCall(Function &F, Instruction *RetainRV); 
-  void OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV, 
-                                 ARCInstKind &Class); 
-  void OptimizeIndividualCalls(Function &F); 
-
-  /// Optimize an individual call, optionally passing the 
-  /// GetArgRCIdentityRoot if it has already been computed. 
-  void OptimizeIndividualCallImpl( 
-      Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors, 
-      Instruction *Inst, ARCInstKind Class, const Value *Arg); 
-
-  /// Try to optimize an AutoreleaseRV with a RetainRV or ClaimRV.  If the 
-  /// optimization occurs, returns true to indicate that the caller should 
-  /// assume the instructions are dead. 
-  bool OptimizeInlinedAutoreleaseRVCall( 
-      Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors, 
-      Instruction *Inst, const Value *&Arg, ARCInstKind Class, 
-      Instruction *AutoreleaseRV, const Value *&AutoreleaseRVArg); 
-
-  void CheckForCFGHazards(const BasicBlock *BB, 
-                          DenseMap<const BasicBlock *, BBState> &BBStates, 
-                          BBState &MyStates) const; 
-  bool VisitInstructionBottomUp(Instruction *Inst, BasicBlock *BB, 
-                                BlotMapVector<Value *, RRInfo> &Retains, 
-                                BBState &MyStates); 
-  bool VisitBottomUp(BasicBlock *BB, 
-                     DenseMap<const BasicBlock *, BBState> &BBStates, 
-                     BlotMapVector<Value *, RRInfo> &Retains); 
-  bool VisitInstructionTopDown(Instruction *Inst, 
-                               DenseMap<Value *, RRInfo> &Releases, 
-                               BBState &MyStates); 
-  bool VisitTopDown(BasicBlock *BB, 
-                    DenseMap<const BasicBlock *, BBState> &BBStates, 
-                    DenseMap<Value *, RRInfo> &Releases); 
-  bool Visit(Function &F, DenseMap<const BasicBlock *, BBState> &BBStates, 
-             BlotMapVector<Value *, RRInfo> &Retains, 
-             DenseMap<Value *, RRInfo> &Releases); 
-
-  void MoveCalls(Value *Arg, RRInfo &RetainsToMove, RRInfo &ReleasesToMove, 
-                 BlotMapVector<Value *, RRInfo> &Retains, 
-                 DenseMap<Value *, RRInfo> &Releases, 
-                 SmallVectorImpl<Instruction *> &DeadInsts, Module *M); 
-
-  bool PairUpRetainsAndReleases(DenseMap<const BasicBlock *, BBState> &BBStates, 
-                                BlotMapVector<Value *, RRInfo> &Retains, 
-                                DenseMap<Value *, RRInfo> &Releases, Module *M, 
-                                Instruction *Retain, 
-                                SmallVectorImpl<Instruction *> &DeadInsts, 
-                                RRInfo &RetainsToMove, RRInfo &ReleasesToMove, 
-                                Value *Arg, bool KnownSafe, 
-                                bool &AnyPairsCompletelyEliminated); 
-
-  bool PerformCodePlacement(DenseMap<const BasicBlock *, BBState> &BBStates, 
-                            BlotMapVector<Value *, RRInfo> &Retains, 
-                            DenseMap<Value *, RRInfo> &Releases, Module *M); 
-
-  void OptimizeWeakCalls(Function &F); 
-
-  bool OptimizeSequences(Function &F); 
-
-  void OptimizeReturns(Function &F); 
+class ObjCARCOpt {
+  bool Changed;
+  ProvenanceAnalysis PA;
+
+  /// A cache of references to runtime entry point constants.
+  ARCRuntimeEntryPoints EP;
+
+  /// A cache of MDKinds that can be passed into other functions to propagate
+  /// MDKind identifiers.
+  ARCMDKindCache MDKindCache;
+
+  /// A flag indicating whether this optimization pass should run.
+  bool Run;
+
+  /// A flag indicating whether the optimization that removes or moves
+  /// retain/release pairs should be performed.
+  bool DisableRetainReleasePairing = false;
+
+  /// Flags which determine whether each of the interesting runtime functions
+  /// is in fact used in the current function.
+  unsigned UsedInThisFunction;
+
+  bool OptimizeRetainRVCall(Function &F, Instruction *RetainRV);
+  void OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
+                                 ARCInstKind &Class);
+  void OptimizeIndividualCalls(Function &F);
+
+  /// Optimize an individual call, optionally passing the
+  /// GetArgRCIdentityRoot if it has already been computed.
+  void OptimizeIndividualCallImpl(
+      Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
+      Instruction *Inst, ARCInstKind Class, const Value *Arg);
+
+  /// Try to optimize an AutoreleaseRV with a RetainRV or ClaimRV.  If the
+  /// optimization occurs, returns true to indicate that the caller should
+  /// assume the instructions are dead.
+  bool OptimizeInlinedAutoreleaseRVCall(
+      Function &F, DenseMap<BasicBlock *, ColorVector> &BlockColors,
+      Instruction *Inst, const Value *&Arg, ARCInstKind Class,
+      Instruction *AutoreleaseRV, const Value *&AutoreleaseRVArg);
+
+  void CheckForCFGHazards(const BasicBlock *BB,
+                          DenseMap<const BasicBlock *, BBState> &BBStates,
+                          BBState &MyStates) const;
+  bool VisitInstructionBottomUp(Instruction *Inst, BasicBlock *BB,
+                                BlotMapVector<Value *, RRInfo> &Retains,
+                                BBState &MyStates);
+  bool VisitBottomUp(BasicBlock *BB,
+                     DenseMap<const BasicBlock *, BBState> &BBStates,
+                     BlotMapVector<Value *, RRInfo> &Retains);
+  bool VisitInstructionTopDown(Instruction *Inst,
+                               DenseMap<Value *, RRInfo> &Releases,
+                               BBState &MyStates);
+  bool VisitTopDown(BasicBlock *BB,
+                    DenseMap<const BasicBlock *, BBState> &BBStates,
+                    DenseMap<Value *, RRInfo> &Releases);
+  bool Visit(Function &F, DenseMap<const BasicBlock *, BBState> &BBStates,
+             BlotMapVector<Value *, RRInfo> &Retains,
+             DenseMap<Value *, RRInfo> &Releases);
+
+  void MoveCalls(Value *Arg, RRInfo &RetainsToMove, RRInfo &ReleasesToMove,
+                 BlotMapVector<Value *, RRInfo> &Retains,
+                 DenseMap<Value *, RRInfo> &Releases,
+                 SmallVectorImpl<Instruction *> &DeadInsts, Module *M);
+
+  bool PairUpRetainsAndReleases(DenseMap<const BasicBlock *, BBState> &BBStates,
+                                BlotMapVector<Value *, RRInfo> &Retains,
+                                DenseMap<Value *, RRInfo> &Releases, Module *M,
+                                Instruction *Retain,
+                                SmallVectorImpl<Instruction *> &DeadInsts,
+                                RRInfo &RetainsToMove, RRInfo &ReleasesToMove,
+                                Value *Arg, bool KnownSafe,
+                                bool &AnyPairsCompletelyEliminated);
+
+  bool PerformCodePlacement(DenseMap<const BasicBlock *, BBState> &BBStates,
+                            BlotMapVector<Value *, RRInfo> &Retains,
+                            DenseMap<Value *, RRInfo> &Releases, Module *M);
+
+  void OptimizeWeakCalls(Function &F);
+
+  bool OptimizeSequences(Function &F);
+
+  void OptimizeReturns(Function &F);
 
 #ifndef NDEBUG
-  void GatherStatistics(Function &F, bool AfterOptimization = false); 
+  void GatherStatistics(Function &F, bool AfterOptimization = false);
 #endif
 
   public:
-    void init(Module &M); 
-    bool run(Function &F, AAResults &AA); 
-    void releaseMemory(); 
-}; 
-
-/// The main ARC optimization pass. 
-class ObjCARCOptLegacyPass : public FunctionPass { 
-public: 
-  ObjCARCOptLegacyPass() : FunctionPass(ID) { 
-    initializeObjCARCOptLegacyPassPass(*PassRegistry::getPassRegistry()); 
-  } 
-  void getAnalysisUsage(AnalysisUsage &AU) const override; 
-  bool doInitialization(Module &M) override { 
-    OCAO.init(M); 
-    return false; 
-  } 
-  bool runOnFunction(Function &F) override { 
-    return OCAO.run(F, getAnalysis<AAResultsWrapperPass>().getAAResults()); 
-  } 
-  void releaseMemory() override { OCAO.releaseMemory(); } 
-  static char ID; 
-
-private: 
-  ObjCARCOpt OCAO; 
-}; 
+    void init(Module &M);
+    bool run(Function &F, AAResults &AA);
+    void releaseMemory();
+};
+
+/// The main ARC optimization pass.
+class ObjCARCOptLegacyPass : public FunctionPass {
+public:
+  ObjCARCOptLegacyPass() : FunctionPass(ID) {
+    initializeObjCARCOptLegacyPassPass(*PassRegistry::getPassRegistry());
+  }
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  bool doInitialization(Module &M) override {
+    OCAO.init(M);
+    return false;
+  }
+  bool runOnFunction(Function &F) override {
+    return OCAO.run(F, getAnalysis<AAResultsWrapperPass>().getAAResults());
+  }
+  void releaseMemory() override { OCAO.releaseMemory(); }
+  static char ID;
+
+private:
+  ObjCARCOpt OCAO;
+};
 } // end anonymous namespace
 
-char ObjCARCOptLegacyPass::ID = 0; 
+char ObjCARCOptLegacyPass::ID = 0;
 
-INITIALIZE_PASS_BEGIN(ObjCARCOptLegacyPass, "objc-arc", "ObjC ARC optimization", 
-                      false, false) 
+INITIALIZE_PASS_BEGIN(ObjCARCOptLegacyPass, "objc-arc", "ObjC ARC optimization",
+                      false, false)
 INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
-INITIALIZE_PASS_END(ObjCARCOptLegacyPass, "objc-arc", "ObjC ARC optimization", 
-                    false, false) 
+INITIALIZE_PASS_END(ObjCARCOptLegacyPass, "objc-arc", "ObjC ARC optimization",
+                    false, false)
 
-Pass *llvm::createObjCARCOptPass() { return new ObjCARCOptLegacyPass(); } 
+Pass *llvm::createObjCARCOptPass() { return new ObjCARCOptLegacyPass(); }
 
-void ObjCARCOptLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const { 
+void ObjCARCOptLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<ObjCARCAAWrapperPass>();
   AU.addRequired<AAResultsWrapperPass>();
   // ARC optimization doesn't currently split critical edges.
@@ -675,7 +675,7 @@ bool ObjCARCOpt::OptimizeInlinedAutoreleaseRVCall(
 
     SmallVector<const Value *, 4> ArgUsers;
     getEquivalentPHIs(*PN, ArgUsers);
-    if (!llvm::is_contained(ArgUsers, AutoreleaseRVArg)) 
+    if (!llvm::is_contained(ArgUsers, AutoreleaseRVArg))
       return false;
   }
 
@@ -1125,7 +1125,7 @@ void ObjCARCOpt::OptimizeIndividualCallImpl(
     if (!HasNull)
       continue;
 
-    Instruction *DepInst = nullptr; 
+    Instruction *DepInst = nullptr;
 
     // Check that there is nothing that cares about the reference
     // count between the call and the phi.
@@ -1137,13 +1137,13 @@ void ObjCARCOpt::OptimizeIndividualCallImpl(
     case ARCInstKind::Release:
       // These can't be moved across things that care about the retain
       // count.
-      DepInst = findSingleDependency(NeedsPositiveRetainCount, Arg, 
-                                     Inst->getParent(), Inst, PA); 
+      DepInst = findSingleDependency(NeedsPositiveRetainCount, Arg,
+                                     Inst->getParent(), Inst, PA);
       break;
     case ARCInstKind::Autorelease:
       // These can't be moved across autorelease pool scope boundaries.
-      DepInst = findSingleDependency(AutoreleasePoolBoundary, Arg, 
-                                     Inst->getParent(), Inst, PA); 
+      DepInst = findSingleDependency(AutoreleasePoolBoundary, Arg,
+                                     Inst->getParent(), Inst, PA);
       break;
     case ARCInstKind::ClaimRV:
     case ARCInstKind::RetainRV:
@@ -1157,7 +1157,7 @@ void ObjCARCOpt::OptimizeIndividualCallImpl(
       llvm_unreachable("Invalid dependence flavor");
     }
 
-    if (DepInst != PN) 
+    if (DepInst != PN)
       continue;
 
     Changed = true;
@@ -2231,21 +2231,21 @@ bool ObjCARCOpt::OptimizeSequences(Function &F) {
 /// Check if there is a dependent call earlier that does not have anything in
 /// between the Retain and the call that can affect the reference count of their
 /// shared pointer argument. Note that Retain need not be in BB.
-static CallInst *HasSafePathToPredecessorCall(const Value *Arg, 
-                                              Instruction *Retain, 
-                                              ProvenanceAnalysis &PA) { 
-  auto *Call = dyn_cast_or_null<CallInst>(findSingleDependency( 
-      CanChangeRetainCount, Arg, Retain->getParent(), Retain, PA)); 
+static CallInst *HasSafePathToPredecessorCall(const Value *Arg,
+                                              Instruction *Retain,
+                                              ProvenanceAnalysis &PA) {
+  auto *Call = dyn_cast_or_null<CallInst>(findSingleDependency(
+      CanChangeRetainCount, Arg, Retain->getParent(), Retain, PA));
 
   // Check that the pointer is the return value of the call.
   if (!Call || Arg != Call)
-    return nullptr; 
+    return nullptr;
 
   // Check that the call is a regular call.
   ARCInstKind Class = GetBasicARCInstKind(Call);
-  return Class == ARCInstKind::CallOrUser || Class == ARCInstKind::Call 
-             ? Call 
-             : nullptr; 
+  return Class == ARCInstKind::CallOrUser || Class == ARCInstKind::Call
+             ? Call
+             : nullptr;
 }
 
 /// Find a dependent retain that precedes the given autorelease for which there
@@ -2255,8 +2255,8 @@ static CallInst *
 FindPredecessorRetainWithSafePath(const Value *Arg, BasicBlock *BB,
                                   Instruction *Autorelease,
                                   ProvenanceAnalysis &PA) {
-  auto *Retain = dyn_cast_or_null<CallInst>( 
-      findSingleDependency(CanChangeRetainCount, Arg, BB, Autorelease, PA)); 
+  auto *Retain = dyn_cast_or_null<CallInst>(
+      findSingleDependency(CanChangeRetainCount, Arg, BB, Autorelease, PA));
 
   // Check that we found a retain with the same argument.
   if (!Retain || !IsRetain(GetBasicARCInstKind(Retain)) ||
@@ -2274,9 +2274,9 @@ static CallInst *
 FindPredecessorAutoreleaseWithSafePath(const Value *Arg, BasicBlock *BB,
                                        ReturnInst *Ret,
                                        ProvenanceAnalysis &PA) {
-  SmallPtrSet<Instruction *, 4> DepInsts; 
-  auto *Autorelease = dyn_cast_or_null<CallInst>( 
-      findSingleDependency(NeedsPositiveRetainCount, Arg, BB, Ret, PA)); 
+  SmallPtrSet<Instruction *, 4> DepInsts;
+  auto *Autorelease = dyn_cast_or_null<CallInst>(
+      findSingleDependency(NeedsPositiveRetainCount, Arg, BB, Ret, PA));
 
   if (!Autorelease)
     return nullptr;
@@ -2315,27 +2315,27 @@ void ObjCARCOpt::OptimizeReturns(Function &F) {
     // Look for an ``autorelease'' instruction that is a predecessor of Ret and
     // dependent on Arg such that there are no instructions dependent on Arg
     // that need a positive ref count in between the autorelease and Ret.
-    CallInst *Autorelease = 
-        FindPredecessorAutoreleaseWithSafePath(Arg, &BB, Ret, PA); 
+    CallInst *Autorelease =
+        FindPredecessorAutoreleaseWithSafePath(Arg, &BB, Ret, PA);
 
     if (!Autorelease)
       continue;
 
     CallInst *Retain = FindPredecessorRetainWithSafePath(
-        Arg, Autorelease->getParent(), Autorelease, PA); 
+        Arg, Autorelease->getParent(), Autorelease, PA);
 
     if (!Retain)
       continue;
 
     // Check that there is nothing that can affect the reference count
     // between the retain and the call.  Note that Retain need not be in BB.
-    CallInst *Call = HasSafePathToPredecessorCall(Arg, Retain, PA); 
+    CallInst *Call = HasSafePathToPredecessorCall(Arg, Retain, PA);
 
     // Don't remove retainRV/autoreleaseRV pairs if the call isn't a tail call.
-    if (!Call || 
-        (!Call->isTailCall() && 
-         GetBasicARCInstKind(Retain) == ARCInstKind::RetainRV && 
-         GetBasicARCInstKind(Autorelease) == ARCInstKind::AutoreleaseRV)) 
+    if (!Call ||
+        (!Call->isTailCall() &&
+         GetBasicARCInstKind(Retain) == ARCInstKind::RetainRV &&
+         GetBasicARCInstKind(Autorelease) == ARCInstKind::AutoreleaseRV))
       continue;
 
     // If so, we can zap the retain and autorelease.
@@ -2372,14 +2372,14 @@ ObjCARCOpt::GatherStatistics(Function &F, bool AfterOptimization) {
 }
 #endif
 
-void ObjCARCOpt::init(Module &M) { 
+void ObjCARCOpt::init(Module &M) {
   if (!EnableARCOpts)
-    return; 
+    return;
 
   // If nothing in the Module uses ARC, don't do anything.
   Run = ModuleHasARC(M);
   if (!Run)
-    return; 
+    return;
 
   // Intuitively, objc_retain and others are nocapture, however in practice
   // they are not, because they return their argument value. And objc_release
@@ -2390,7 +2390,7 @@ void ObjCARCOpt::init(Module &M) {
   EP.init(&M);
 }
 
-bool ObjCARCOpt::run(Function &F, AAResults &AA) { 
+bool ObjCARCOpt::run(Function &F, AAResults &AA) {
   if (!EnableARCOpts)
     return false;
 
@@ -2404,7 +2404,7 @@ bool ObjCARCOpt::run(Function &F, AAResults &AA) {
                     << " >>>"
                        "\n");
 
-  PA.setAA(&AA); 
+  PA.setAA(&AA);
 
 #ifndef NDEBUG
   if (AreStatisticsEnabled()) {
@@ -2461,17 +2461,17 @@ void ObjCARCOpt::releaseMemory() {
 
 /// @}
 ///
- 
-PreservedAnalyses ObjCARCOptPass::run(Function &F, 
-                                      FunctionAnalysisManager &AM) { 
-  ObjCARCOpt OCAO; 
-  OCAO.init(*F.getParent()); 
- 
-  bool Changed = OCAO.run(F, AM.getResult<AAManager>(F)); 
-  if (Changed) { 
-    PreservedAnalyses PA; 
-    PA.preserveSet<CFGAnalyses>(); 
-    return PA; 
-  } 
-  return PreservedAnalyses::all(); 
-} 
+
+PreservedAnalyses ObjCARCOptPass::run(Function &F,
+                                      FunctionAnalysisManager &AM) {
+  ObjCARCOpt OCAO;
+  OCAO.init(*F.getParent());
+
+  bool Changed = OCAO.run(F, AM.getResult<AAManager>(F));
+  if (Changed) {
+    PreservedAnalyses PA;
+    PA.preserveSet<CFGAnalyses>();
+    return PA;
+  }
+  return PreservedAnalyses::all();
+}
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp
index 5b57b4837e..3d59b2edc5 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp
@@ -44,11 +44,11 @@ bool ProvenanceAnalysis::relatedSelect(const SelectInst *A,
   // check: just check for relations between the values on corresponding arms.
   if (const SelectInst *SB = dyn_cast<SelectInst>(B))
     if (A->getCondition() == SB->getCondition())
-      return related(A->getTrueValue(), SB->getTrueValue()) || 
-             related(A->getFalseValue(), SB->getFalseValue()); 
+      return related(A->getTrueValue(), SB->getTrueValue()) ||
+             related(A->getFalseValue(), SB->getFalseValue());
 
   // Check both arms of the Select node individually.
-  return related(A->getTrueValue(), B) || related(A->getFalseValue(), B); 
+  return related(A->getTrueValue(), B) || related(A->getFalseValue(), B);
 }
 
 bool ProvenanceAnalysis::relatedPHI(const PHINode *A,
@@ -60,7 +60,7 @@ bool ProvenanceAnalysis::relatedPHI(const PHINode *A,
     if (PNB->getParent() == A->getParent()) {
       for (unsigned i = 0, e = A->getNumIncomingValues(); i != e; ++i)
         if (related(A->getIncomingValue(i),
-                    PNB->getIncomingValueForBlock(A->getIncomingBlock(i)))) 
+                    PNB->getIncomingValueForBlock(A->getIncomingBlock(i))))
           return true;
       return false;
     }
@@ -68,7 +68,7 @@ bool ProvenanceAnalysis::relatedPHI(const PHINode *A,
   // Check each unique source of the PHI node against B.
   SmallPtrSet<const Value *, 4> UniqueSrc;
   for (Value *PV1 : A->incoming_values()) {
-    if (UniqueSrc.insert(PV1).second && related(PV1, B)) 
+    if (UniqueSrc.insert(PV1).second && related(PV1, B))
       return true;
   }
 
@@ -109,7 +109,7 @@ static bool IsStoredObjCPointer(const Value *P) {
   return false;
 }
 
-bool ProvenanceAnalysis::relatedCheck(const Value *A, const Value *B) { 
+bool ProvenanceAnalysis::relatedCheck(const Value *A, const Value *B) {
   // Ask regular AliasAnalysis, for a first approximation.
   switch (AA->alias(A, B)) {
   case NoAlias:
@@ -156,9 +156,9 @@ bool ProvenanceAnalysis::relatedCheck(const Value *A, const Value *B) {
   return true;
 }
 
-bool ProvenanceAnalysis::related(const Value *A, const Value *B) { 
-  A = GetUnderlyingObjCPtrCached(A, UnderlyingObjCPtrCache); 
-  B = GetUnderlyingObjCPtrCached(B, UnderlyingObjCPtrCache); 
+bool ProvenanceAnalysis::related(const Value *A, const Value *B) {
+  A = GetUnderlyingObjCPtrCached(A, UnderlyingObjCPtrCache);
+  B = GetUnderlyingObjCPtrCached(B, UnderlyingObjCPtrCache);
 
   // Quick check.
   if (A == B)
@@ -173,7 +173,7 @@ bool ProvenanceAnalysis::related(const Value *A, const Value *B) {
   if (!Pair.second)
     return Pair.first->second;
 
-  bool Result = relatedCheck(A, B); 
+  bool Result = relatedCheck(A, B);
   CachedResults[ValuePairTy(A, B)] = Result;
   return Result;
 }
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.h b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.h
index 5c3c99463e..a63e356ce1 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.h
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysis.h
@@ -31,7 +31,7 @@
 
 namespace llvm {
 
-class AAResults; 
+class AAResults;
 class DataLayout;
 class PHINode;
 class SelectInst;
@@ -49,7 +49,7 @@ namespace objcarc {
 /// not two pointers have the same provenance source and thus could
 /// potentially be related.
 class ProvenanceAnalysis {
-  AAResults *AA; 
+  AAResults *AA;
 
   using ValuePairTy = std::pair<const Value *, const Value *>;
   using CachedResultsTy = DenseMap<ValuePairTy, bool>;
@@ -58,7 +58,7 @@ class ProvenanceAnalysis {
 
   DenseMap<const Value *, WeakTrackingVH> UnderlyingObjCPtrCache;
 
-  bool relatedCheck(const Value *A, const Value *B); 
+  bool relatedCheck(const Value *A, const Value *B);
   bool relatedSelect(const SelectInst *A, const Value *B);
   bool relatedPHI(const PHINode *A, const Value *B);
 
@@ -67,11 +67,11 @@ public:
   ProvenanceAnalysis(const ProvenanceAnalysis &) = delete;
   ProvenanceAnalysis &operator=(const ProvenanceAnalysis &) = delete;
 
-  void setAA(AAResults *aa) { AA = aa; } 
+  void setAA(AAResults *aa) { AA = aa; }
 
-  AAResults *getAA() const { return AA; } 
+  AAResults *getAA() const { return AA; }
 
-  bool related(const Value *A, const Value *B); 
+  bool related(const Value *A, const Value *B);
 
   void clear() {
     CachedResults.clear();
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp
index 5a6ef9307c..6fdfe787d4 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp
@@ -12,7 +12,7 @@
 #include "llvm/Analysis/Passes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
-#include "llvm/IR/InstrTypes.h" 
+#include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
@@ -75,7 +75,7 @@ bool PAEval::runOnFunction(Function &F) {
       if (NameV1 >= NameV2)
         continue;
       errs() << NameV1 << " and " << NameV2;
-      if (PA.related(V1, V2)) 
+      if (PA.related(V1, V2))
         errs() << " are related.\n";
       else
         errs() << " are not related.\n";
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/PtrState.cpp b/contrib/libs/llvm12/lib/Transforms/ObjCARC/PtrState.cpp
index 4399ebcacc..6071ec3e4d 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/PtrState.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/PtrState.cpp
@@ -232,7 +232,7 @@ bool BottomUpPtrState::HandlePotentialAlterRefCount(Instruction *Inst,
   Sequence S = GetSeq();
 
   // Check for possible releases.
-  if (!CanDecrementRefCount(Inst, Ptr, PA, Class)) 
+  if (!CanDecrementRefCount(Inst, Ptr, PA, Class))
     return false;
 
   LLVM_DEBUG(dbgs() << "            CanAlterRefCount: Seq: " << S << "; "
@@ -383,7 +383,7 @@ bool TopDownPtrState::HandlePotentialAlterRefCount(Instruction *Inst,
                                                    ARCInstKind Class) {
   // Check for possible releases. Treat clang.arc.use as a releasing instruction
   // to prevent sinking a retain past it.
-  if (!CanDecrementRefCount(Inst, Ptr, PA, Class) && 
+  if (!CanDecrementRefCount(Inst, Ptr, PA, Class) &&
       Class != ARCInstKind::IntrinsicUser)
     return false;
 
diff --git a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ya.make b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ya.make
index d35523fe03..727ec42c3f 100644
--- a/contrib/libs/llvm12/lib/Transforms/ObjCARC/ya.make
+++ b/contrib/libs/llvm12/lib/Transforms/ObjCARC/ya.make
@@ -12,12 +12,12 @@ LICENSE(Apache-2.0 WITH LLVM-exception)
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 PEERDIR(
-    contrib/libs/llvm12 
-    contrib/libs/llvm12/include 
-    contrib/libs/llvm12/lib/Analysis 
-    contrib/libs/llvm12/lib/IR 
-    contrib/libs/llvm12/lib/Support 
-    contrib/libs/llvm12/lib/Transforms/Utils 
+    contrib/libs/llvm12
+    contrib/libs/llvm12/include
+    contrib/libs/llvm12/lib/Analysis
+    contrib/libs/llvm12/lib/IR
+    contrib/libs/llvm12/lib/Support
+    contrib/libs/llvm12/lib/Transforms/Utils
 )
 
 ADDINCL(