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

28 files changed, 819 insertions, 819 deletions

diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
index 0a2c890d61..805cabbb03 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
@@ -44,9 +44,9 @@ struct AlignmentFromAssumptionsPass
   ScalarEvolution *SE = nullptr;
   DominatorTree *DT = nullptr;
 
-  bool extractAlignmentInfo(CallInst *I, unsigned Idx, Value *&AAPtr, 
-                            const SCEV *&AlignSCEV, const SCEV *&OffSCEV); 
-  bool processAssumption(CallInst *I, unsigned Idx); 
+  bool extractAlignmentInfo(CallInst *I, unsigned Idx, Value *&AAPtr,
+                            const SCEV *&AlignSCEV, const SCEV *&OffSCEV);
+  bool processAssumption(CallInst *I, unsigned Idx);
 };
 }
 
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AnnotationRemarks.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AnnotationRemarks.h
index 408ac969b2..78a4812cb8 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AnnotationRemarks.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/AnnotationRemarks.h
@@ -1,37 +1,37 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- AnnotationRemarks.cpp - Emit remarks for !annotation MD --*- C++ -*-===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// \file 
-// This file defines AnnotationRemarksPass for the new pass manager. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H 
-#define LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H 
- 
-#include "llvm/IR/Function.h" 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
-struct AnnotationRemarksPass : public PassInfoMixin<AnnotationRemarksPass> { 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
-} // namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- AnnotationRemarks.cpp - Emit remarks for !annotation MD --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// \file
+// This file defines AnnotationRemarksPass for the new pass manager.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H
+#define LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct AnnotationRemarksPass : public PassInfoMixin<AnnotationRemarksPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_ANNOTATION_REMARKS_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ConstraintElimination.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ConstraintElimination.h
index aabe7a8cda..f353d384e7 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ConstraintElimination.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ConstraintElimination.h
@@ -1,35 +1,35 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- ConstraintElimination.h - Constraint elimination pass ----*- C++ -*-===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H 
-#define LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-class ConstraintEliminationPass 
-    : public PassInfoMixin<ConstraintEliminationPass> { 
-public: 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- ConstraintElimination.h - Constraint elimination pass ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H
+#define LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class ConstraintEliminationPass
+    : public PassInfoMixin<ConstraintEliminationPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_CONSTRAINTELIMINATION_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/DCE.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/DCE.h
index d624328b36..344ebe68f9 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/DCE.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/DCE.h
@@ -30,12 +30,12 @@ class DCEPass : public PassInfoMixin<DCEPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
- 
-class RedundantDbgInstEliminationPass 
-    : public PassInfoMixin<RedundantDbgInstEliminationPass> { 
-public: 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
+
+class RedundantDbgInstEliminationPass
+    : public PassInfoMixin<RedundantDbgInstEliminationPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_DCE_H
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/GVN.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/GVN.h
index 8a41b18799..c2906dc22f 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/GVN.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/GVN.h
@@ -53,8 +53,8 @@ class FunctionPass;
 class IntrinsicInst;
 class LoadInst;
 class LoopInfo;
-class MemorySSA; 
-class MemorySSAUpdater; 
+class MemorySSA;
+class MemorySSAUpdater;
 class OptimizationRemarkEmitter;
 class PHINode;
 class TargetLibraryInfo;
@@ -80,7 +80,7 @@ struct GVNOptions {
   Optional<bool> AllowPRE = None;
   Optional<bool> AllowLoadPRE = None;
   Optional<bool> AllowLoadInLoopPRE = None;
-  Optional<bool> AllowLoadPRESplitBackedge = None; 
+  Optional<bool> AllowLoadPRESplitBackedge = None;
   Optional<bool> AllowMemDep = None;
 
   GVNOptions() = default;
@@ -102,12 +102,12 @@ struct GVNOptions {
     return *this;
   }
 
-  /// Enables or disables PRE of loads in GVN. 
-  GVNOptions &setLoadPRESplitBackedge(bool LoadPRESplitBackedge) { 
-    AllowLoadPRESplitBackedge = LoadPRESplitBackedge; 
-    return *this; 
-  } 
- 
+  /// Enables or disables PRE of loads in GVN.
+  GVNOptions &setLoadPRESplitBackedge(bool LoadPRESplitBackedge) {
+    AllowLoadPRESplitBackedge = LoadPRESplitBackedge;
+    return *this;
+  }
+
   /// Enables or disables use of MemDepAnalysis.
   GVNOptions &setMemDep(bool MemDep) {
     AllowMemDep = MemDep;
@@ -144,7 +144,7 @@ public:
   bool isPREEnabled() const;
   bool isLoadPREEnabled() const;
   bool isLoadInLoopPREEnabled() const;
-  bool isLoadPRESplitBackedgeEnabled() const; 
+  bool isLoadPRESplitBackedgeEnabled() const;
   bool isMemDepEnabled() const;
 
   /// This class holds the mapping between values and value numbers.  It is used
@@ -227,7 +227,7 @@ private:
   OptimizationRemarkEmitter *ORE = nullptr;
   ImplicitControlFlowTracking *ICF = nullptr;
   LoopInfo *LI = nullptr;
-  MemorySSAUpdater *MSSAU = nullptr; 
+  MemorySSAUpdater *MSSAU = nullptr;
 
   ValueTable VN;
 
@@ -263,7 +263,7 @@ private:
   bool runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
                const TargetLibraryInfo &RunTLI, AAResults &RunAA,
                MemoryDependenceResults *RunMD, LoopInfo *LI,
-               OptimizationRemarkEmitter *ORE, MemorySSA *MSSA = nullptr); 
+               OptimizationRemarkEmitter *ORE, MemorySSA *MSSA = nullptr);
 
   /// Push a new Value to the LeaderTable onto the list for its value number.
   void addToLeaderTable(uint32_t N, Value *V, const BasicBlock *BB) {
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/IndVarSimplify.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/IndVarSimplify.h
index cd5cb68c0e..885487f548 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/IndVarSimplify.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/IndVarSimplify.h
@@ -30,11 +30,11 @@ class Loop;
 class LPMUpdater;
 
 class IndVarSimplifyPass : public PassInfoMixin<IndVarSimplifyPass> {
-  /// Perform IV widening during the pass. 
-  bool WidenIndVars; 
- 
+  /// Perform IV widening during the pass.
+  bool WidenIndVars;
+
 public:
-  IndVarSimplifyPass(bool WidenIndVars = true) : WidenIndVars(WidenIndVars) {} 
+  IndVarSimplifyPass(bool WidenIndVars = true) : WidenIndVars(WidenIndVars) {}
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
 };
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/InferAddressSpaces.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/InferAddressSpaces.h
index 1132195c13..4d4a62e0c5 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/InferAddressSpaces.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/InferAddressSpaces.h
@@ -1,38 +1,38 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- InferAddressSpace.h - ----------------------------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H 
-#define LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-struct InferAddressSpacesPass : PassInfoMixin<InferAddressSpacesPass> { 
-  InferAddressSpacesPass(); 
-  InferAddressSpacesPass(unsigned AddressSpace); 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
- 
-private: 
-  unsigned FlatAddrSpace = 0; 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- InferAddressSpace.h - ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H
+#define LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct InferAddressSpacesPass : PassInfoMixin<InferAddressSpacesPass> {
+  InferAddressSpacesPass();
+  InferAddressSpacesPass(unsigned AddressSpace);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+private:
+  unsigned FlatAddrSpace = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_INFERADDRESSSPACES_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/JumpThreading.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/JumpThreading.h
index f24333c390..4d977dcd43 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/JumpThreading.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/JumpThreading.h
@@ -35,7 +35,7 @@
 
 namespace llvm {
 
-class AAResults; 
+class AAResults;
 class BasicBlock;
 class BinaryOperator;
 class BranchInst;
@@ -48,8 +48,8 @@ class IntrinsicInst;
 class LazyValueInfo;
 class LoadInst;
 class PHINode;
-class SelectInst; 
-class SwitchInst; 
+class SelectInst;
+class SwitchInst;
 class TargetLibraryInfo;
 class Value;
 
@@ -86,7 +86,7 @@ enum ConstantPreference { WantInteger, WantBlockAddress };
 class JumpThreadingPass : public PassInfoMixin<JumpThreadingPass> {
   TargetLibraryInfo *TLI;
   LazyValueInfo *LVI;
-  AAResults *AA; 
+  AAResults *AA;
   DomTreeUpdater *DTU;
   std::unique_ptr<BlockFrequencyInfo> BFI;
   std::unique_ptr<BranchProbabilityInfo> BPI;
@@ -100,16 +100,16 @@ class JumpThreadingPass : public PassInfoMixin<JumpThreadingPass> {
 
   unsigned BBDupThreshold;
   unsigned DefaultBBDupThreshold;
-  bool InsertFreezeWhenUnfoldingSelect; 
+  bool InsertFreezeWhenUnfoldingSelect;
 
 public:
-  JumpThreadingPass(bool InsertFreezeWhenUnfoldingSelect = false, int T = -1); 
+  JumpThreadingPass(bool InsertFreezeWhenUnfoldingSelect = false, int T = -1);
 
   // Glue for old PM.
-  bool runImpl(Function &F, TargetLibraryInfo *TLI, LazyValueInfo *LVI, 
-               AAResults *AA, DomTreeUpdater *DTU, bool HasProfileData, 
-               std::unique_ptr<BlockFrequencyInfo> BFI, 
-               std::unique_ptr<BranchProbabilityInfo> BPI); 
+  bool runImpl(Function &F, TargetLibraryInfo *TLI, LazyValueInfo *LVI,
+               AAResults *AA, DomTreeUpdater *DTU, bool HasProfileData,
+               std::unique_ptr<BlockFrequencyInfo> BFI,
+               std::unique_ptr<BranchProbabilityInfo> BPI);
 
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
@@ -118,65 +118,65 @@ public:
     BPI.reset();
   }
 
-  void findLoopHeaders(Function &F); 
-  bool processBlock(BasicBlock *BB); 
-  bool maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB); 
-  void updateSSA(BasicBlock *BB, BasicBlock *NewBB, 
+  void findLoopHeaders(Function &F);
+  bool processBlock(BasicBlock *BB);
+  bool maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB);
+  void updateSSA(BasicBlock *BB, BasicBlock *NewBB,
                  DenseMap<Instruction *, Value *> &ValueMapping);
-  DenseMap<Instruction *, Value *> cloneInstructions(BasicBlock::iterator BI, 
+  DenseMap<Instruction *, Value *> cloneInstructions(BasicBlock::iterator BI,
                                                      BasicBlock::iterator BE,
                                                      BasicBlock *NewBB,
                                                      BasicBlock *PredBB);
-  bool tryThreadEdge(BasicBlock *BB, 
+  bool tryThreadEdge(BasicBlock *BB,
                      const SmallVectorImpl<BasicBlock *> &PredBBs,
                      BasicBlock *SuccBB);
-  void threadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs, 
+  void threadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs,
                   BasicBlock *SuccBB);
-  bool duplicateCondBranchOnPHIIntoPred( 
+  bool duplicateCondBranchOnPHIIntoPred(
       BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs);
 
-  bool computeValueKnownInPredecessorsImpl( 
+  bool computeValueKnownInPredecessorsImpl(
       Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result,
       jumpthreading::ConstantPreference Preference,
       DenseSet<Value *> &RecursionSet, Instruction *CxtI = nullptr);
   bool
-  computeValueKnownInPredecessors(Value *V, BasicBlock *BB, 
+  computeValueKnownInPredecessors(Value *V, BasicBlock *BB,
                                   jumpthreading::PredValueInfo &Result,
                                   jumpthreading::ConstantPreference Preference,
                                   Instruction *CxtI = nullptr) {
     DenseSet<Value *> RecursionSet;
-    return computeValueKnownInPredecessorsImpl(V, BB, Result, Preference, 
+    return computeValueKnownInPredecessorsImpl(V, BB, Result, Preference,
                                                RecursionSet, CxtI);
   }
 
-  Constant *evaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB, 
+  Constant *evaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB,
                                       Value *cond);
-  bool maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond); 
-  void threadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB, 
+  bool maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond);
+  void threadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB,
                                    BasicBlock *BB, BasicBlock *SuccBB);
-  bool processThreadableEdges(Value *Cond, BasicBlock *BB, 
+  bool processThreadableEdges(Value *Cond, BasicBlock *BB,
                               jumpthreading::ConstantPreference Preference,
                               Instruction *CxtI = nullptr);
 
-  bool processBranchOnPHI(PHINode *PN); 
-  bool processBranchOnXOR(BinaryOperator *BO); 
-  bool processImpliedCondition(BasicBlock *BB); 
+  bool processBranchOnPHI(PHINode *PN);
+  bool processBranchOnXOR(BinaryOperator *BO);
+  bool processImpliedCondition(BasicBlock *BB);
 
-  bool simplifyPartiallyRedundantLoad(LoadInst *LI); 
-  void unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI, 
+  bool simplifyPartiallyRedundantLoad(LoadInst *LI);
+  void unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI,
                          PHINode *SIUse, unsigned Idx);
 
-  bool tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB); 
-  bool tryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB); 
-  bool tryToUnfoldSelectInCurrBB(BasicBlock *BB); 
+  bool tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB);
+  bool tryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB);
+  bool tryToUnfoldSelectInCurrBB(BasicBlock *BB);
 
-  bool processGuards(BasicBlock *BB); 
-  bool threadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI); 
+  bool processGuards(BasicBlock *BB);
+  bool threadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI);
 
 private:
-  BasicBlock *splitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *> Preds, 
+  BasicBlock *splitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *> Preds,
                               const char *Suffix);
-  void updateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB, 
+  void updateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB,
                                     BasicBlock *NewBB, BasicBlock *SuccBB);
   /// Check if the block has profile metadata for its outgoing edges.
   bool doesBlockHaveProfileData(BasicBlock *BB);
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopFlatten.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopFlatten.h
index 10ab54e1dc..94c153da09 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopFlatten.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopFlatten.h
@@ -1,43 +1,43 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- LoopFlatten.h - Loop Flatten ----------------  -----------*- C++ -*-===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// This file provides the interface for the Loop Flatten Pass. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H 
-#define LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H 
- 
-#include "llvm/Analysis/LoopAnalysisManager.h" 
-#include "llvm/Analysis/LoopInfo.h" 
-#include "llvm/IR/PassManager.h" 
-#include "llvm/Transforms/Scalar/LoopPassManager.h" 
- 
-namespace llvm { 
- 
-class LoopFlattenPass : public PassInfoMixin<LoopFlattenPass> { 
-public: 
-  LoopFlattenPass() = default; 
- 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- LoopFlatten.h - Loop Flatten ----------------  -----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides the interface for the Loop Flatten Pass.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H
+
+#include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class LoopFlattenPass : public PassInfoMixin<LoopFlattenPass> {
+public:
+  LoopFlattenPass() = default;
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPFLATTEN_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
index 3affa35521..33a39a0820 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopIdiomRecognize.h
@@ -30,19 +30,19 @@ namespace llvm {
 class Loop;
 class LPMUpdater;
 
-/// Options to disable Loop Idiom Recognize, which can be shared with other 
-/// passes. 
-struct DisableLIRP { 
-  /// When true, the entire pass is disabled. 
-  static bool All; 
- 
-  /// When true, Memset is disabled. 
-  static bool Memset; 
- 
-  /// When true, Memcpy is disabled. 
-  static bool Memcpy; 
-}; 
- 
+/// Options to disable Loop Idiom Recognize, which can be shared with other
+/// passes.
+struct DisableLIRP {
+  /// When true, the entire pass is disabled.
+  static bool All;
+
+  /// When true, Memset is disabled.
+  static bool Memset;
+
+  /// When true, Memcpy is disabled.
+  static bool Memcpy;
+};
+
 /// Performs Loop Idiom Recognize Pass.
 class LoopIdiomRecognizePass : public PassInfoMixin<LoopIdiomRecognizePass> {
 public:
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopInterchange.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopInterchange.h
index 94c3f00d17..61b9808304 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopInterchange.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopInterchange.h
@@ -1,35 +1,35 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- LoopInterchange.h - Loop interchange pass --------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H 
-#define LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H 
- 
-#include "llvm/IR/PassManager.h" 
-#include "llvm/Transforms/Scalar/LoopPassManager.h" 
- 
-namespace llvm { 
- 
-struct LoopInterchangePass : public PassInfoMixin<LoopInterchangePass> { 
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, 
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- LoopInterchange.h - Loop interchange pass --------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+struct LoopInterchangePass : public PassInfoMixin<LoopInterchangePass> {
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPINTERCHANGE_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopPassManager.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopPassManager.h
index c268c9c097..30d26eab5e 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopPassManager.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopPassManager.h
@@ -46,161 +46,161 @@
 #include "llvm/ADT/PriorityWorklist.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/LoopNestAnalysis.h" 
+#include "llvm/Analysis/LoopNestAnalysis.h"
 #include "llvm/IR/Dominators.h"
-#include "llvm/IR/PassInstrumentation.h" 
+#include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Transforms/Utils/LCSSA.h"
 #include "llvm/Transforms/Utils/LoopSimplify.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
-#include <memory> 
+#include <memory>
 
 namespace llvm {
 
 // Forward declarations of an update tracking API used in the pass manager.
 class LPMUpdater;
 
-namespace { 
- 
-template <typename PassT> 
-using HasRunOnLoopT = decltype(std::declval<PassT>().run( 
-    std::declval<Loop &>(), std::declval<LoopAnalysisManager &>(), 
-    std::declval<LoopStandardAnalysisResults &>(), 
-    std::declval<LPMUpdater &>())); 
- 
-} // namespace 
- 
+namespace {
+
+template <typename PassT>
+using HasRunOnLoopT = decltype(std::declval<PassT>().run(
+    std::declval<Loop &>(), std::declval<LoopAnalysisManager &>(),
+    std::declval<LoopStandardAnalysisResults &>(),
+    std::declval<LPMUpdater &>()));
+
+} // namespace
+
 // Explicit specialization and instantiation declarations for the pass manager.
 // See the comments on the definition of the specialization for details on how
 // it differs from the primary template.
 template <>
-class PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                  LPMUpdater &> 
-    : public PassInfoMixin< 
-          PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                      LPMUpdater &>> { 
-public: 
-  /// Construct a pass manager. 
-  /// 
-  /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs(). 
-  explicit PassManager(bool DebugLogging = false) 
-      : DebugLogging(DebugLogging) {} 
-
-  // FIXME: These are equivalent to the default move constructor/move 
-  // assignment. However, using = default triggers linker errors due to the 
-  // explicit instantiations below. Find a way to use the default and remove the 
-  // duplicated code here. 
-  PassManager(PassManager &&Arg) 
-      : IsLoopNestPass(std::move(Arg.IsLoopNestPass)), 
-        LoopPasses(std::move(Arg.LoopPasses)), 
-        LoopNestPasses(std::move(Arg.LoopNestPasses)), 
-        DebugLogging(std::move(Arg.DebugLogging)) {} 
- 
-  PassManager &operator=(PassManager &&RHS) { 
-    IsLoopNestPass = std::move(RHS.IsLoopNestPass); 
-    LoopPasses = std::move(RHS.LoopPasses); 
-    LoopNestPasses = std::move(RHS.LoopNestPasses); 
-    DebugLogging = std::move(RHS.DebugLogging); 
-    return *this; 
-  } 
- 
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, 
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U); 
- 
-  /// Add either a loop pass or a loop-nest pass to the pass manager. Append \p 
-  /// Pass to the list of loop passes if it has a dedicated \fn run() method for 
-  /// loops and to the list of loop-nest passes if the \fn run() method is for 
-  /// loop-nests instead. Also append whether \p Pass is loop-nest pass or not 
-  /// to the end of \var IsLoopNestPass so we can easily identify the types of 
-  /// passes in the pass manager later. 
-  template <typename PassT> 
-  std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value> 
-  addPass(PassT Pass) { 
-    using LoopPassModelT = 
-        detail::PassModel<Loop, PassT, PreservedAnalyses, LoopAnalysisManager, 
-                          LoopStandardAnalysisResults &, LPMUpdater &>; 
-    IsLoopNestPass.push_back(false); 
-    LoopPasses.emplace_back(new LoopPassModelT(std::move(Pass))); 
-  } 
- 
-  template <typename PassT> 
-  std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value> 
-  addPass(PassT Pass) { 
-    using LoopNestPassModelT = 
-        detail::PassModel<LoopNest, PassT, PreservedAnalyses, 
-                          LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                          LPMUpdater &>; 
-    IsLoopNestPass.push_back(true); 
-    LoopNestPasses.emplace_back(new LoopNestPassModelT(std::move(Pass))); 
-  } 
- 
-  // Specializations of `addPass` for `RepeatedPass`. These are necessary since 
-  // `RepeatedPass` has a templated `run` method that will result in incorrect 
-  // detection of `HasRunOnLoopT`. 
-  template <typename PassT> 
-  std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value> 
-  addPass(RepeatedPass<PassT> Pass) { 
-    using RepeatedLoopPassModelT = 
-        detail::PassModel<Loop, RepeatedPass<PassT>, PreservedAnalyses, 
-                          LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                          LPMUpdater &>; 
-    IsLoopNestPass.push_back(false); 
-    LoopPasses.emplace_back(new RepeatedLoopPassModelT(std::move(Pass))); 
-  } 
- 
-  template <typename PassT> 
-  std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value> 
-  addPass(RepeatedPass<PassT> Pass) { 
-    using RepeatedLoopNestPassModelT = 
-        detail::PassModel<LoopNest, RepeatedPass<PassT>, PreservedAnalyses, 
-                          LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                          LPMUpdater &>; 
-    IsLoopNestPass.push_back(true); 
-    LoopNestPasses.emplace_back( 
-        new RepeatedLoopNestPassModelT(std::move(Pass))); 
-  } 
- 
-  bool isEmpty() const { return LoopPasses.empty() && LoopNestPasses.empty(); } 
- 
-  static bool isRequired() { return true; } 
- 
-  size_t getNumLoopPasses() const { return LoopPasses.size(); } 
-  size_t getNumLoopNestPasses() const { return LoopNestPasses.size(); } 
- 
-protected: 
-  using LoopPassConceptT = 
-      detail::PassConcept<Loop, LoopAnalysisManager, 
-                          LoopStandardAnalysisResults &, LPMUpdater &>; 
-  using LoopNestPassConceptT = 
-      detail::PassConcept<LoopNest, LoopAnalysisManager, 
-                          LoopStandardAnalysisResults &, LPMUpdater &>; 
- 
-  // BitVector that identifies whether the passes are loop passes or loop-nest 
-  // passes (true for loop-nest passes). 
-  BitVector IsLoopNestPass; 
-  std::vector<std::unique_ptr<LoopPassConceptT>> LoopPasses; 
-  std::vector<std::unique_ptr<LoopNestPassConceptT>> LoopNestPasses; 
- 
-  /// Flag indicating whether we should do debug logging. 
-  bool DebugLogging; 
- 
-  /// Run either a loop pass or a loop-nest pass. Returns `None` if 
-  /// PassInstrumentation's BeforePass returns false. Otherwise, returns the 
-  /// preserved analyses of the pass. 
-  template <typename IRUnitT, typename PassT> 
-  Optional<PreservedAnalyses> 
-  runSinglePass(IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM, 
-                LoopStandardAnalysisResults &AR, LPMUpdater &U, 
-                PassInstrumentation &PI); 
- 
-  PreservedAnalyses runWithLoopNestPasses(Loop &L, LoopAnalysisManager &AM, 
-                                          LoopStandardAnalysisResults &AR, 
-                                          LPMUpdater &U); 
-  PreservedAnalyses runWithoutLoopNestPasses(Loop &L, LoopAnalysisManager &AM, 
-                                             LoopStandardAnalysisResults &AR, 
-                                             LPMUpdater &U); 
-}; 
- 
+class PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
+                  LPMUpdater &>
+    : public PassInfoMixin<
+          PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &,
+                      LPMUpdater &>> {
+public:
+  /// Construct a pass manager.
+  ///
+  /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs().
+  explicit PassManager(bool DebugLogging = false)
+      : DebugLogging(DebugLogging) {}
+
+  // FIXME: These are equivalent to the default move constructor/move
+  // assignment. However, using = default triggers linker errors due to the
+  // explicit instantiations below. Find a way to use the default and remove the
+  // duplicated code here.
+  PassManager(PassManager &&Arg)
+      : IsLoopNestPass(std::move(Arg.IsLoopNestPass)),
+        LoopPasses(std::move(Arg.LoopPasses)),
+        LoopNestPasses(std::move(Arg.LoopNestPasses)),
+        DebugLogging(std::move(Arg.DebugLogging)) {}
+
+  PassManager &operator=(PassManager &&RHS) {
+    IsLoopNestPass = std::move(RHS.IsLoopNestPass);
+    LoopPasses = std::move(RHS.LoopPasses);
+    LoopNestPasses = std::move(RHS.LoopNestPasses);
+    DebugLogging = std::move(RHS.DebugLogging);
+    return *this;
+  }
+
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+
+  /// Add either a loop pass or a loop-nest pass to the pass manager. Append \p
+  /// Pass to the list of loop passes if it has a dedicated \fn run() method for
+  /// loops and to the list of loop-nest passes if the \fn run() method is for
+  /// loop-nests instead. Also append whether \p Pass is loop-nest pass or not
+  /// to the end of \var IsLoopNestPass so we can easily identify the types of
+  /// passes in the pass manager later.
+  template <typename PassT>
+  std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(PassT Pass) {
+    using LoopPassModelT =
+        detail::PassModel<Loop, PassT, PreservedAnalyses, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+    IsLoopNestPass.push_back(false);
+    LoopPasses.emplace_back(new LoopPassModelT(std::move(Pass)));
+  }
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(PassT Pass) {
+    using LoopNestPassModelT =
+        detail::PassModel<LoopNest, PassT, PreservedAnalyses,
+                          LoopAnalysisManager, LoopStandardAnalysisResults &,
+                          LPMUpdater &>;
+    IsLoopNestPass.push_back(true);
+    LoopNestPasses.emplace_back(new LoopNestPassModelT(std::move(Pass)));
+  }
+
+  // Specializations of `addPass` for `RepeatedPass`. These are necessary since
+  // `RepeatedPass` has a templated `run` method that will result in incorrect
+  // detection of `HasRunOnLoopT`.
+  template <typename PassT>
+  std::enable_if_t<is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(RepeatedPass<PassT> Pass) {
+    using RepeatedLoopPassModelT =
+        detail::PassModel<Loop, RepeatedPass<PassT>, PreservedAnalyses,
+                          LoopAnalysisManager, LoopStandardAnalysisResults &,
+                          LPMUpdater &>;
+    IsLoopNestPass.push_back(false);
+    LoopPasses.emplace_back(new RepeatedLoopPassModelT(std::move(Pass)));
+  }
+
+  template <typename PassT>
+  std::enable_if_t<!is_detected<HasRunOnLoopT, PassT>::value>
+  addPass(RepeatedPass<PassT> Pass) {
+    using RepeatedLoopNestPassModelT =
+        detail::PassModel<LoopNest, RepeatedPass<PassT>, PreservedAnalyses,
+                          LoopAnalysisManager, LoopStandardAnalysisResults &,
+                          LPMUpdater &>;
+    IsLoopNestPass.push_back(true);
+    LoopNestPasses.emplace_back(
+        new RepeatedLoopNestPassModelT(std::move(Pass)));
+  }
+
+  bool isEmpty() const { return LoopPasses.empty() && LoopNestPasses.empty(); }
+
+  static bool isRequired() { return true; }
+
+  size_t getNumLoopPasses() const { return LoopPasses.size(); }
+  size_t getNumLoopNestPasses() const { return LoopNestPasses.size(); }
+
+protected:
+  using LoopPassConceptT =
+      detail::PassConcept<Loop, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+  using LoopNestPassConceptT =
+      detail::PassConcept<LoopNest, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+
+  // BitVector that identifies whether the passes are loop passes or loop-nest
+  // passes (true for loop-nest passes).
+  BitVector IsLoopNestPass;
+  std::vector<std::unique_ptr<LoopPassConceptT>> LoopPasses;
+  std::vector<std::unique_ptr<LoopNestPassConceptT>> LoopNestPasses;
+
+  /// Flag indicating whether we should do debug logging.
+  bool DebugLogging;
+
+  /// Run either a loop pass or a loop-nest pass. Returns `None` if
+  /// PassInstrumentation's BeforePass returns false. Otherwise, returns the
+  /// preserved analyses of the pass.
+  template <typename IRUnitT, typename PassT>
+  Optional<PreservedAnalyses>
+  runSinglePass(IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM,
+                LoopStandardAnalysisResults &AR, LPMUpdater &U,
+                PassInstrumentation &PI);
+
+  PreservedAnalyses runWithLoopNestPasses(Loop &L, LoopAnalysisManager &AM,
+                                          LoopStandardAnalysisResults &AR,
+                                          LPMUpdater &U);
+  PreservedAnalyses runWithoutLoopNestPasses(Loop &L, LoopAnalysisManager &AM,
+                                             LoopStandardAnalysisResults &AR,
+                                             LPMUpdater &U);
+};
+
 /// The Loop pass manager.
 ///
 /// See the documentation for the PassManager template for details. It runs
@@ -232,7 +232,7 @@ using RequireAnalysisLoopPass =
     RequireAnalysisPass<AnalysisT, Loop, LoopAnalysisManager,
                         LoopStandardAnalysisResults &, LPMUpdater &>;
 
-class FunctionToLoopPassAdaptor; 
+class FunctionToLoopPassAdaptor;
 
 /// This class provides an interface for updating the loop pass manager based
 /// on mutations to the loop nest.
@@ -240,13 +240,13 @@ class FunctionToLoopPassAdaptor;
 /// A reference to an instance of this class is passed as an argument to each
 /// Loop pass, and Loop passes should use it to update LPM infrastructure if
 /// they modify the loop nest structure.
-/// 
-/// \c LPMUpdater comes with two modes: the loop mode and the loop-nest mode. In 
-/// loop mode, all the loops in the function will be pushed into the worklist 
-/// and when new loops are added to the pipeline, their subloops are also 
-/// inserted recursively. On the other hand, in loop-nest mode, only top-level 
-/// loops are contained in the worklist and the addition of new (top-level) 
-/// loops will not trigger the addition of their subloops. 
+///
+/// \c LPMUpdater comes with two modes: the loop mode and the loop-nest mode. In
+/// loop mode, all the loops in the function will be pushed into the worklist
+/// and when new loops are added to the pipeline, their subloops are also
+/// inserted recursively. On the other hand, in loop-nest mode, only top-level
+/// loops are contained in the worklist and the addition of new (top-level)
+/// loops will not trigger the addition of their subloops.
 class LPMUpdater {
 public:
   /// This can be queried by loop passes which run other loop passes (like pass
@@ -268,8 +268,8 @@ public:
   /// state, this routine will mark that the current loop should be skipped by
   /// the rest of the pass management infrastructure.
   void markLoopAsDeleted(Loop &L, llvm::StringRef Name) {
-    assert((!LoopNestMode || L.isOutermost()) && 
-           "L should be a top-level loop in loop-nest mode."); 
+    assert((!LoopNestMode || L.isOutermost()) &&
+           "L should be a top-level loop in loop-nest mode.");
     LAM.clear(L, Name);
     assert((&L == CurrentL || CurrentL->contains(&L)) &&
            "Cannot delete a loop outside of the "
@@ -285,8 +285,8 @@ public:
   /// loops within them will be visited in postorder as usual for the loop pass
   /// manager.
   void addChildLoops(ArrayRef<Loop *> NewChildLoops) {
-    assert(!LoopNestMode && 
-           "Child loops should not be pushed in loop-nest mode."); 
+    assert(!LoopNestMode &&
+           "Child loops should not be pushed in loop-nest mode.");
     // Insert ourselves back into the worklist first, as this loop should be
     // revisited after all the children have been processed.
     Worklist.insert(CurrentL);
@@ -318,10 +318,10 @@ public:
              "All of the new loops must be siblings of the current loop!");
 #endif
 
-    if (LoopNestMode) 
-      Worklist.insert(NewSibLoops); 
-    else 
-      appendLoopsToWorklist(NewSibLoops, Worklist); 
+    if (LoopNestMode)
+      Worklist.insert(NewSibLoops);
+    else
+      appendLoopsToWorklist(NewSibLoops, Worklist);
 
     // No need to skip the current loop or revisit it, as sibling loops
     // shouldn't impact anything.
@@ -341,7 +341,7 @@ public:
   }
 
 private:
-  friend class llvm::FunctionToLoopPassAdaptor; 
+  friend class llvm::FunctionToLoopPassAdaptor;
 
   /// The \c FunctionToLoopPassAdaptor's worklist of loops to process.
   SmallPriorityWorklist<Loop *, 4> &Worklist;
@@ -351,7 +351,7 @@ private:
 
   Loop *CurrentL;
   bool SkipCurrentLoop;
-  const bool LoopNestMode; 
+  const bool LoopNestMode;
 
 #ifndef NDEBUG
   // In debug builds we also track the parent loop to implement asserts even in
@@ -360,33 +360,33 @@ private:
 #endif
 
   LPMUpdater(SmallPriorityWorklist<Loop *, 4> &Worklist,
-             LoopAnalysisManager &LAM, bool LoopNestMode = false) 
-      : Worklist(Worklist), LAM(LAM), LoopNestMode(LoopNestMode) {} 
+             LoopAnalysisManager &LAM, bool LoopNestMode = false)
+      : Worklist(Worklist), LAM(LAM), LoopNestMode(LoopNestMode) {}
 };
 
-template <typename IRUnitT, typename PassT> 
-Optional<PreservedAnalyses> LoopPassManager::runSinglePass( 
-    IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM, 
-    LoopStandardAnalysisResults &AR, LPMUpdater &U, PassInstrumentation &PI) { 
-  // Check the PassInstrumentation's BeforePass callbacks before running the 
-  // pass, skip its execution completely if asked to (callback returns false). 
-  if (!PI.runBeforePass<IRUnitT>(*Pass, IR)) 
-    return None; 
- 
-  PreservedAnalyses PA; 
-  { 
-    TimeTraceScope TimeScope(Pass->name(), IR.getName()); 
-    PA = Pass->run(IR, AM, AR, U); 
-  } 
- 
-  // do not pass deleted Loop into the instrumentation 
-  if (U.skipCurrentLoop()) 
-    PI.runAfterPassInvalidated<IRUnitT>(*Pass, PA); 
-  else 
-    PI.runAfterPass<IRUnitT>(*Pass, IR, PA); 
-  return PA; 
-} 
- 
+template <typename IRUnitT, typename PassT>
+Optional<PreservedAnalyses> LoopPassManager::runSinglePass(
+    IRUnitT &IR, PassT &Pass, LoopAnalysisManager &AM,
+    LoopStandardAnalysisResults &AR, LPMUpdater &U, PassInstrumentation &PI) {
+  // Check the PassInstrumentation's BeforePass callbacks before running the
+  // pass, skip its execution completely if asked to (callback returns false).
+  if (!PI.runBeforePass<IRUnitT>(*Pass, IR))
+    return None;
+
+  PreservedAnalyses PA;
+  {
+    TimeTraceScope TimeScope(Pass->name(), IR.getName());
+    PA = Pass->run(IR, AM, AR, U);
+  }
+
+  // do not pass deleted Loop into the instrumentation
+  if (U.skipCurrentLoop())
+    PI.runAfterPassInvalidated<IRUnitT>(*Pass, PA);
+  else
+    PI.runAfterPass<IRUnitT>(*Pass, IR, PA);
+  return PA;
+}
+
 /// Adaptor that maps from a function to its loops.
 ///
 /// Designed to allow composition of a LoopPass(Manager) and a
@@ -394,109 +394,109 @@ Optional<PreservedAnalyses> LoopPassManager::runSinglePass(
 /// FunctionAnalysisManager it will run the \c LoopAnalysisManagerFunctionProxy
 /// analysis prior to running the loop passes over the function to enable a \c
 /// LoopAnalysisManager to be used within this run safely.
-/// 
-/// The adaptor comes with two modes: the loop mode and the loop-nest mode, and 
-/// the worklist updater lived inside will be in the same mode as the adaptor 
-/// (refer to the documentation of \c LPMUpdater for more detailed explanation). 
-/// Specifically, in loop mode, all loops in the funciton will be pushed into 
-/// the worklist and processed by \p Pass, while only top-level loops are 
-/// processed in loop-nest mode. Please refer to the various specializations of 
-/// \fn createLoopFunctionToLoopPassAdaptor to see when loop mode and loop-nest 
-/// mode are used. 
+///
+/// The adaptor comes with two modes: the loop mode and the loop-nest mode, and
+/// the worklist updater lived inside will be in the same mode as the adaptor
+/// (refer to the documentation of \c LPMUpdater for more detailed explanation).
+/// Specifically, in loop mode, all loops in the funciton will be pushed into
+/// the worklist and processed by \p Pass, while only top-level loops are
+/// processed in loop-nest mode. Please refer to the various specializations of
+/// \fn createLoopFunctionToLoopPassAdaptor to see when loop mode and loop-nest
+/// mode are used.
 class FunctionToLoopPassAdaptor
-    : public PassInfoMixin<FunctionToLoopPassAdaptor> { 
+    : public PassInfoMixin<FunctionToLoopPassAdaptor> {
 public:
-  using PassConceptT = 
-      detail::PassConcept<Loop, LoopAnalysisManager, 
-                          LoopStandardAnalysisResults &, LPMUpdater &>; 
- 
-  explicit FunctionToLoopPassAdaptor(std::unique_ptr<PassConceptT> Pass, 
-                                     bool UseMemorySSA = false, 
-                                     bool UseBlockFrequencyInfo = false, 
-                                     bool DebugLogging = false, 
-                                     bool LoopNestMode = false) 
+  using PassConceptT =
+      detail::PassConcept<Loop, LoopAnalysisManager,
+                          LoopStandardAnalysisResults &, LPMUpdater &>;
+
+  explicit FunctionToLoopPassAdaptor(std::unique_ptr<PassConceptT> Pass,
+                                     bool UseMemorySSA = false,
+                                     bool UseBlockFrequencyInfo = false,
+                                     bool DebugLogging = false,
+                                     bool LoopNestMode = false)
       : Pass(std::move(Pass)), LoopCanonicalizationFPM(DebugLogging),
-        UseMemorySSA(UseMemorySSA), 
-        UseBlockFrequencyInfo(UseBlockFrequencyInfo), 
-        LoopNestMode(LoopNestMode) { 
+        UseMemorySSA(UseMemorySSA),
+        UseBlockFrequencyInfo(UseBlockFrequencyInfo),
+        LoopNestMode(LoopNestMode) {
     LoopCanonicalizationFPM.addPass(LoopSimplifyPass());
     LoopCanonicalizationFPM.addPass(LCSSAPass());
   }
 
   /// Runs the loop passes across every loop in the function.
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
-  static bool isRequired() { return true; } 
+  static bool isRequired() { return true; }
 
-  bool isLoopNestMode() const { return LoopNestMode; } 
+  bool isLoopNestMode() const { return LoopNestMode; }
 
 private:
-  std::unique_ptr<PassConceptT> Pass; 
+  std::unique_ptr<PassConceptT> Pass;
 
   FunctionPassManager LoopCanonicalizationFPM;
 
   bool UseMemorySSA = false;
-  bool UseBlockFrequencyInfo = false; 
-  const bool LoopNestMode; 
+  bool UseBlockFrequencyInfo = false;
+  const bool LoopNestMode;
 };
 
 /// A function to deduce a loop pass type and wrap it in the templated
 /// adaptor.
-/// 
-/// If \p Pass is a loop pass, the returned adaptor will be in loop mode. 
+///
+/// If \p Pass is a loop pass, the returned adaptor will be in loop mode.
 template <typename LoopPassT>
-inline std::enable_if_t<is_detected<HasRunOnLoopT, LoopPassT>::value, 
-                        FunctionToLoopPassAdaptor> 
+inline std::enable_if_t<is_detected<HasRunOnLoopT, LoopPassT>::value,
+                        FunctionToLoopPassAdaptor>
 createFunctionToLoopPassAdaptor(LoopPassT Pass, bool UseMemorySSA = false,
-                                bool UseBlockFrequencyInfo = false, 
+                                bool UseBlockFrequencyInfo = false,
+                                bool DebugLogging = false) {
+  using PassModelT =
+      detail::PassModel<Loop, LoopPassT, PreservedAnalyses, LoopAnalysisManager,
+                        LoopStandardAnalysisResults &, LPMUpdater &>;
+  return FunctionToLoopPassAdaptor(
+      std::make_unique<PassModelT>(std::move(Pass)), UseMemorySSA,
+      UseBlockFrequencyInfo, DebugLogging, false);
+}
+
+/// If \p Pass is a loop-nest pass, \p Pass will first be wrapped into a
+/// \c LoopPassManager and the returned adaptor will be in loop-nest mode.
+template <typename LoopNestPassT>
+inline std::enable_if_t<!is_detected<HasRunOnLoopT, LoopNestPassT>::value,
+                        FunctionToLoopPassAdaptor>
+createFunctionToLoopPassAdaptor(LoopNestPassT Pass, bool UseMemorySSA = false,
+                                bool UseBlockFrequencyInfo = false,
                                 bool DebugLogging = false) {
-  using PassModelT = 
-      detail::PassModel<Loop, LoopPassT, PreservedAnalyses, LoopAnalysisManager, 
-                        LoopStandardAnalysisResults &, LPMUpdater &>; 
-  return FunctionToLoopPassAdaptor( 
-      std::make_unique<PassModelT>(std::move(Pass)), UseMemorySSA, 
-      UseBlockFrequencyInfo, DebugLogging, false); 
+  LoopPassManager LPM(DebugLogging);
+  LPM.addPass(std::move(Pass));
+  using PassModelT =
+      detail::PassModel<Loop, LoopPassManager, PreservedAnalyses,
+                        LoopAnalysisManager, LoopStandardAnalysisResults &,
+                        LPMUpdater &>;
+  return FunctionToLoopPassAdaptor(std::make_unique<PassModelT>(std::move(LPM)),
+                                   UseMemorySSA, UseBlockFrequencyInfo,
+                                   DebugLogging, true);
+}
+
+/// If \p Pass is an instance of \c LoopPassManager, the returned adaptor will
+/// be in loop-nest mode if the pass manager contains only loop-nest passes.
+template <>
+inline FunctionToLoopPassAdaptor
+createFunctionToLoopPassAdaptor<LoopPassManager>(LoopPassManager LPM,
+                                                 bool UseMemorySSA,
+                                                 bool UseBlockFrequencyInfo,
+                                                 bool DebugLogging) {
+  // Check if LPM contains any loop pass and if it does not, returns an adaptor
+  // in loop-nest mode.
+  using PassModelT =
+      detail::PassModel<Loop, LoopPassManager, PreservedAnalyses,
+                        LoopAnalysisManager, LoopStandardAnalysisResults &,
+                        LPMUpdater &>;
+  bool LoopNestMode = (LPM.getNumLoopPasses() == 0);
+  return FunctionToLoopPassAdaptor(std::make_unique<PassModelT>(std::move(LPM)),
+                                   UseMemorySSA, UseBlockFrequencyInfo,
+                                   DebugLogging, LoopNestMode);
 }
 
-/// If \p Pass is a loop-nest pass, \p Pass will first be wrapped into a 
-/// \c LoopPassManager and the returned adaptor will be in loop-nest mode. 
-template <typename LoopNestPassT> 
-inline std::enable_if_t<!is_detected<HasRunOnLoopT, LoopNestPassT>::value, 
-                        FunctionToLoopPassAdaptor> 
-createFunctionToLoopPassAdaptor(LoopNestPassT Pass, bool UseMemorySSA = false, 
-                                bool UseBlockFrequencyInfo = false, 
-                                bool DebugLogging = false) { 
-  LoopPassManager LPM(DebugLogging); 
-  LPM.addPass(std::move(Pass)); 
-  using PassModelT = 
-      detail::PassModel<Loop, LoopPassManager, PreservedAnalyses, 
-                        LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                        LPMUpdater &>; 
-  return FunctionToLoopPassAdaptor(std::make_unique<PassModelT>(std::move(LPM)), 
-                                   UseMemorySSA, UseBlockFrequencyInfo, 
-                                   DebugLogging, true); 
-} 
- 
-/// If \p Pass is an instance of \c LoopPassManager, the returned adaptor will 
-/// be in loop-nest mode if the pass manager contains only loop-nest passes. 
-template <> 
-inline FunctionToLoopPassAdaptor 
-createFunctionToLoopPassAdaptor<LoopPassManager>(LoopPassManager LPM, 
-                                                 bool UseMemorySSA, 
-                                                 bool UseBlockFrequencyInfo, 
-                                                 bool DebugLogging) { 
-  // Check if LPM contains any loop pass and if it does not, returns an adaptor 
-  // in loop-nest mode. 
-  using PassModelT = 
-      detail::PassModel<Loop, LoopPassManager, PreservedAnalyses, 
-                        LoopAnalysisManager, LoopStandardAnalysisResults &, 
-                        LPMUpdater &>; 
-  bool LoopNestMode = (LPM.getNumLoopPasses() == 0); 
-  return FunctionToLoopPassAdaptor(std::make_unique<PassModelT>(std::move(LPM)), 
-                                   UseMemorySSA, UseBlockFrequencyInfo, 
-                                   DebugLogging, LoopNestMode); 
-} 
- 
 /// Pass for printing a loop's contents as textual IR.
 class PrintLoopPass : public PassInfoMixin<PrintLoopPass> {
   raw_ostream &OS;
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopReroll.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopReroll.h
index 53929a90a1..d4674af374 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopReroll.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopReroll.h
@@ -1,38 +1,38 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- LoopReroll.h - Loop rerolling pass ---------------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H 
-#define LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H 
- 
-#include "llvm/IR/PassManager.h" 
-#include "llvm/Transforms/Scalar/LoopPassManager.h" 
- 
-namespace llvm { 
- 
-class Function; 
- 
-class LoopRerollPass : public PassInfoMixin<LoopRerollPass> { 
-public: 
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, 
-                        LoopStandardAnalysisResults &AR, LPMUpdater &U); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- LoopReroll.h - Loop rerolling pass ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class Function;
+
+class LoopRerollPass : public PassInfoMixin<LoopRerollPass> {
+public:
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPREROLL_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopRotation.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopRotation.h
index 36eb74558a..907bf22274 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopRotation.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopRotation.h
@@ -29,14 +29,14 @@ namespace llvm {
 /// A simple loop rotation transformation.
 class LoopRotatePass : public PassInfoMixin<LoopRotatePass> {
 public:
-  LoopRotatePass(bool EnableHeaderDuplication = true, 
-                 bool PrepareForLTO = false); 
+  LoopRotatePass(bool EnableHeaderDuplication = true,
+                 bool PrepareForLTO = false);
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
                         LoopStandardAnalysisResults &AR, LPMUpdater &U);
 
 private:
   const bool EnableHeaderDuplication;
-  const bool PrepareForLTO; 
+  const bool PrepareForLTO;
 };
 }
 
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopUnrollPass.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopUnrollPass.h
index 9ba3f0ed28..d6c45889ef 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopUnrollPass.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopUnrollPass.h
@@ -29,7 +29,7 @@ class Function;
 class Loop;
 class LPMUpdater;
 
-/// Loop unroll pass that only does full loop unrolling and peeling. 
+/// Loop unroll pass that only does full loop unrolling and peeling.
 class LoopFullUnrollPass : public PassInfoMixin<LoopFullUnrollPass> {
   const int OptLevel;
 
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopVersioningLICM.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopVersioningLICM.h
index c554baddb9..1e16fabbe3 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopVersioningLICM.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LoopVersioningLICM.h
@@ -1,36 +1,36 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- LoopVersioningLICM.h - LICM Loop Versioning ------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H 
-#define LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H 
- 
-#include "llvm/IR/PassManager.h" 
-#include "llvm/Transforms/Scalar/LoopPassManager.h" 
- 
-namespace llvm { 
- 
-class LoopVersioningLICMPass : public PassInfoMixin<LoopVersioningLICMPass> { 
-public: 
-  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM, 
-                        LoopStandardAnalysisResults &LAR, LPMUpdater &U); 
-}; 
- 
-} // namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- LoopVersioningLICM.h - LICM Loop Versioning ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H
+#define LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class LoopVersioningLICMPass : public PassInfoMixin<LoopVersioningLICMPass> {
+public:
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &LAR, LPMUpdater &U);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_LOOPVERSIONINGLICM_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerAtomic.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerAtomic.h
index 6e98c10455..351afc1018 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerAtomic.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerAtomic.h
@@ -29,7 +29,7 @@ namespace llvm {
 class LowerAtomicPass : public PassInfoMixin<LowerAtomicPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
-  static bool isRequired() { return true; } 
+  static bool isRequired() { return true; }
 };
 }
 
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
index bf63ebe46e..c862c7fa33 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
@@ -24,7 +24,7 @@
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/Support/CommandLine.h" 
+#include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 
@@ -39,8 +39,8 @@ struct LowerExpectIntrinsicPass : PassInfoMixin<LowerExpectIntrinsicPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
 };
 
-extern cl::opt<uint32_t> LikelyBranchWeight; 
-extern cl::opt<uint32_t> UnlikelyBranchWeight; 
+extern cl::opt<uint32_t> LikelyBranchWeight;
+extern cl::opt<uint32_t> UnlikelyBranchWeight;
 }
 
 #endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h
index d2bbcc508b..58bcd51171 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/LowerMatrixIntrinsics.h
@@ -23,14 +23,14 @@
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
-class LowerMatrixIntrinsicsPass 
-    : public PassInfoMixin<LowerMatrixIntrinsicsPass> { 
-  bool Minimal; 
- 
-public: 
-  LowerMatrixIntrinsicsPass(bool Minimal = false) : Minimal(Minimal) {} 
+class LowerMatrixIntrinsicsPass
+    : public PassInfoMixin<LowerMatrixIntrinsicsPass> {
+  bool Minimal;
+
+public:
+  LowerMatrixIntrinsicsPass(bool Minimal = false) : Minimal(Minimal) {}
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
-  static bool isRequired() { return true; } 
+  static bool isRequired() { return true; }
 };
 } // namespace llvm
 
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/MemCpyOptimizer.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/MemCpyOptimizer.h
index 470e105c41..5615f3375c 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/MemCpyOptimizer.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/MemCpyOptimizer.h
@@ -28,19 +28,19 @@
 
 namespace llvm {
 
-class AAResults; 
+class AAResults;
 class AssumptionCache;
-class CallBase; 
+class CallBase;
 class CallInst;
 class DominatorTree;
 class Function;
 class Instruction;
-class LoadInst; 
+class LoadInst;
 class MemCpyInst;
 class MemMoveInst;
 class MemoryDependenceResults;
-class MemorySSA; 
-class MemorySSAUpdater; 
+class MemorySSA;
+class MemorySSAUpdater;
 class MemSetInst;
 class StoreInst;
 class TargetLibraryInfo;
@@ -49,11 +49,11 @@ class Value;
 class MemCpyOptPass : public PassInfoMixin<MemCpyOptPass> {
   MemoryDependenceResults *MD = nullptr;
   TargetLibraryInfo *TLI = nullptr;
-  AAResults *AA = nullptr; 
-  AssumptionCache *AC = nullptr; 
-  DominatorTree *DT = nullptr; 
-  MemorySSA *MSSA = nullptr; 
-  MemorySSAUpdater *MSSAU = nullptr; 
+  AAResults *AA = nullptr;
+  AssumptionCache *AC = nullptr;
+  DominatorTree *DT = nullptr;
+  MemorySSA *MSSA = nullptr;
+  MemorySSAUpdater *MSSAU = nullptr;
 
 public:
   MemCpyOptPass() = default;
@@ -61,9 +61,9 @@ public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   // Glue for the old PM.
-  bool runImpl(Function &F, MemoryDependenceResults *MD, TargetLibraryInfo *TLI, 
-               AAResults *AA, AssumptionCache *AC, DominatorTree *DT, 
-               MemorySSA *MSSA); 
+  bool runImpl(Function &F, MemoryDependenceResults *MD, TargetLibraryInfo *TLI,
+               AAResults *AA, AssumptionCache *AC, DominatorTree *DT,
+               MemorySSA *MSSA);
 
 private:
   // Helper functions
@@ -71,18 +71,18 @@ private:
   bool processMemSet(MemSetInst *SI, BasicBlock::iterator &BBI);
   bool processMemCpy(MemCpyInst *M, BasicBlock::iterator &BBI);
   bool processMemMove(MemMoveInst *M);
-  bool performCallSlotOptzn(Instruction *cpyLoad, Instruction *cpyStore, 
-                            Value *cpyDst, Value *cpySrc, uint64_t cpyLen, 
-                            Align cpyAlign, CallInst *C); 
+  bool performCallSlotOptzn(Instruction *cpyLoad, Instruction *cpyStore,
+                            Value *cpyDst, Value *cpySrc, uint64_t cpyLen,
+                            Align cpyAlign, CallInst *C);
   bool processMemCpyMemCpyDependence(MemCpyInst *M, MemCpyInst *MDep);
   bool processMemSetMemCpyDependence(MemCpyInst *MemCpy, MemSetInst *MemSet);
   bool performMemCpyToMemSetOptzn(MemCpyInst *MemCpy, MemSetInst *MemSet);
   bool processByValArgument(CallBase &CB, unsigned ArgNo);
   Instruction *tryMergingIntoMemset(Instruction *I, Value *StartPtr,
                                     Value *ByteVal);
-  bool moveUp(StoreInst *SI, Instruction *P, const LoadInst *LI); 
+  bool moveUp(StoreInst *SI, Instruction *P, const LoadInst *LI);
 
-  void eraseInstruction(Instruction *I); 
+  void eraseInstruction(Instruction *I);
   bool iterateOnFunction(Function &F);
 };
 
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/NaryReassociate.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/NaryReassociate.h
index a91076c0c9..06a9cdc04b 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/NaryReassociate.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/NaryReassociate.h
@@ -121,7 +121,7 @@ private:
   bool doOneIteration(Function &F);
 
   // Reassociates I for better CSE.
-  Instruction *tryReassociate(Instruction *I, const SCEV *&OrigSCEV); 
+  Instruction *tryReassociate(Instruction *I, const SCEV *&OrigSCEV);
 
   // Reassociate GEP for better CSE.
   Instruction *tryReassociateGEP(GetElementPtrInst *GEP);
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/Reg2Mem.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/Reg2Mem.h
index 78ee91f0f8..d2a5d8cb85 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/Reg2Mem.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/Reg2Mem.h
@@ -1,38 +1,38 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- Reg2Mem.h - Convert registers to allocas -----------------*- C++ -*-===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// This file provides the interface for the RegToMem Pass. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_REG2MEM_H 
-#define LLVM_TRANSFORMS_SCALAR_REG2MEM_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-class RegToMemPass : public PassInfoMixin<RegToMemPass> { 
-public: 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_REG2MEM_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- Reg2Mem.h - Convert registers to allocas -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file provides the interface for the RegToMem Pass.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_REG2MEM_H
+#define LLVM_TRANSFORMS_SCALAR_REG2MEM_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class RegToMemPass : public PassInfoMixin<RegToMemPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_REG2MEM_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SROA.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SROA.h
index 25471d0157..9f369eaf77 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SROA.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SROA.h
@@ -25,7 +25,7 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/IR/ValueHandle.h" 
+#include "llvm/IR/ValueHandle.h"
 #include <vector>
 
 namespace llvm {
@@ -85,8 +85,8 @@ class SROA : public PassInfoMixin<SROA> {
 
   /// A collection of instructions to delete.
   /// We try to batch deletions to simplify code and make things a bit more
-  /// efficient. We also make sure there is no dangling pointers. 
-  SmallVector<WeakVH, 8> DeadInsts; 
+  /// efficient. We also make sure there is no dangling pointers.
+  SmallVector<WeakVH, 8> DeadInsts;
 
   /// Post-promotion worklist.
   ///
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h
index dbdfa7502d..89f08f823d 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h
@@ -1,40 +1,40 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- ScalarizeMaskedMemIntrin.h - Scalarize unsupported masked mem ----===// 
-//                                    instrinsics 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// This pass replaces masked memory intrinsics - when unsupported by the target 
-// - with a chain of basic blocks, that deal with the elements one-by-one if the 
-// appropriate mask bit is set. 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-#ifndef LLVM_TRANSFORMS_SCALAR_SCALARIZE_MASKED_MEMINTRIN_H 
-#define LLVM_TRANSFORMS_SCALAR_SCALARIZE_MASKED_MEMINTRIN_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-struct ScalarizeMaskedMemIntrinPass 
-    : public PassInfoMixin<ScalarizeMaskedMemIntrinPass> { 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
-} // end namespace llvm 
- 
-#endif 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- ScalarizeMaskedMemIntrin.h - Scalarize unsupported masked mem ----===//
+//                                    instrinsics
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass replaces masked memory intrinsics - when unsupported by the target
+// - with a chain of basic blocks, that deal with the elements one-by-one if the
+// appropriate mask bit is set.
+//
+//===----------------------------------------------------------------------===//
+//
+#ifndef LLVM_TRANSFORMS_SCALAR_SCALARIZE_MASKED_MEMINTRIN_H
+#define LLVM_TRANSFORMS_SCALAR_SCALARIZE_MASKED_MEMINTRIN_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct ScalarizeMaskedMemIntrinPass
+    : public PassInfoMixin<ScalarizeMaskedMemIntrinPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // end namespace llvm
+
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h
index 219d4f2354..258501eda8 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h
@@ -1,38 +1,38 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- SeparateConstOffsetFromGEP.h ---------------------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H 
-#define LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-class SeparateConstOffsetFromGEPPass 
-    : public PassInfoMixin<SeparateConstOffsetFromGEPPass> { 
-  bool LowerGEP; 
- 
-public: 
-  SeparateConstOffsetFromGEPPass(bool LowerGEP = false) : LowerGEP(LowerGEP) {} 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- SeparateConstOffsetFromGEP.h ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H
+#define LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class SeparateConstOffsetFromGEPPass
+    : public PassInfoMixin<SeparateConstOffsetFromGEPPass> {
+  bool LowerGEP;
+
+public:
+  SeparateConstOffsetFromGEPPass(bool LowerGEP = false) : LowerGEP(LowerGEP) {}
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_SEPARATECONSTOFFSETFROMGEP_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SimplifyCFG.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SimplifyCFG.h
index 3e50d4b808..d87a05c3ac 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SimplifyCFG.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/SimplifyCFG.h
@@ -23,7 +23,7 @@
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/Transforms/Utils/SimplifyCFGOptions.h" 
+#include "llvm/Transforms/Utils/SimplifyCFGOptions.h"
 
 namespace llvm {
 
@@ -41,7 +41,7 @@ public:
   /// rather than optimal IR. That is, by default we bypass transformations that
   /// are likely to improve performance but make analysis for other passes more
   /// difficult.
-  SimplifyCFGPass(); 
+  SimplifyCFGPass();
 
   /// Construct a pass with optional optimizations.
   SimplifyCFGPass(const SimplifyCFGOptions &PassOptions);
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h
index 4418930cce..628f029de0 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StraightLineStrengthReduce.h
@@ -1,35 +1,35 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- StraightLineStrengthReduce.h - -----------------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H 
-#define LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-class StraightLineStrengthReducePass 
-    : public PassInfoMixin<StraightLineStrengthReducePass> { 
-public: 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
- 
-} // namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- StraightLineStrengthReduce.h - -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H
+#define LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class StraightLineStrengthReducePass
+    : public PassInfoMixin<StraightLineStrengthReducePass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_STRAIGHTLINESTRENGTHREDUCE_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StructurizeCFG.h b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StructurizeCFG.h
index 4435610177..b36082a59c 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StructurizeCFG.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/Scalar/StructurizeCFG.h
@@ -1,31 +1,31 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- StructurizeCFG.h ---------------------------------------------------===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H 
-#define LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
-struct StructurizeCFGPass : PassInfoMixin<StructurizeCFGPass> { 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); 
-}; 
-} // namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- StructurizeCFG.h ---------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
+#define LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct StructurizeCFGPass : PassInfoMixin<StructurizeCFGPass> {
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_STRUCTURIZECFG_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif