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

14 files changed, 1501 insertions, 1501 deletions

diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/AlwaysInliner.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/AlwaysInliner.h
index 4a9764b855..06ae0fecb4 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/AlwaysInliner.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/AlwaysInliner.h
@@ -41,7 +41,7 @@ public:
       : InsertLifetime(InsertLifetime) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
-  static bool isRequired() { return true; } 
+  static bool isRequired() { return true; }
 };
 
 /// Create a legacy pass manager instance of a pass to inline and remove
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/Annotation2Metadata.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/Annotation2Metadata.h
index 198d4cfc2c..17740ca383 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/Annotation2Metadata.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/Annotation2Metadata.h
@@ -1,41 +1,41 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- Annotation2Metadata.h - Add !annotation metadata. --------*- 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 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// New pass manager pass to convert @llvm.global.annotations to !annotation 
-// metadata. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H 
-#define LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-class Module; 
- 
-/// Pass to convert @llvm.global.annotations to !annotation metadata. 
-struct Annotation2MetadataPass : public PassInfoMixin<Annotation2MetadataPass> { 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_IPO_SCCP_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- Annotation2Metadata.h - Add !annotation metadata. --------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// New pass manager pass to convert @llvm.global.annotations to !annotation
+// metadata.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H
+#define LLVM_TRANSFORMS_IPO_ANNOTATION2METADATA_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+class Module;
+
+/// Pass to convert @llvm.global.annotations to !annotation metadata.
+struct Annotation2MetadataPass : public PassInfoMixin<Annotation2MetadataPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_SCCP_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/Attributor.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/Attributor.h
index fd82945466..96681071db 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/Attributor.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/Attributor.h
@@ -104,10 +104,10 @@
 #ifndef LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H
 #define LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H
 
-#include "llvm/ADT/DenseSet.h" 
-#include "llvm/ADT/GraphTraits.h" 
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/GraphTraits.h"
 #include "llvm/ADT/MapVector.h"
-#include "llvm/ADT/STLExtras.h" 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/AssumeBundleQueries.h"
 #include "llvm/Analysis/CFG.h"
@@ -121,27 +121,27 @@
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/Allocator.h"
-#include "llvm/Support/Casting.h" 
-#include "llvm/Support/TimeProfiler.h" 
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/TimeProfiler.h"
 #include "llvm/Transforms/Utils/CallGraphUpdater.h"
 
 namespace llvm {
 
-struct AADepGraphNode; 
-struct AADepGraph; 
+struct AADepGraphNode;
+struct AADepGraph;
 struct Attributor;
 struct AbstractAttribute;
 struct InformationCache;
 struct AAIsDead;
 
-class AAManager; 
-class AAResults; 
+class AAManager;
+class AAResults;
 class Function;
 
-/// The value passed to the line option that defines the maximal initialization 
-/// chain length. 
-extern unsigned MaxInitializationChainLength; 
- 
+/// The value passed to the line option that defines the maximal initialization
+/// chain length.
+extern unsigned MaxInitializationChainLength;
+
 ///{
 enum class ChangeStatus {
   CHANGED,
@@ -157,74 +157,74 @@ enum class DepClassTy {
 };
 ///}
 
-/// The data structure for the nodes of a dependency graph 
-struct AADepGraphNode { 
-public: 
-  virtual ~AADepGraphNode(){}; 
-  using DepTy = PointerIntPair<AADepGraphNode *, 1>; 
- 
-protected: 
-  /// Set of dependency graph nodes which should be updated if this one 
-  /// is updated. The bit encodes if it is optional. 
-  TinyPtrVector<DepTy> Deps; 
- 
-  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); } 
-  static AbstractAttribute *DepGetValAA(DepTy &DT) { 
-    return cast<AbstractAttribute>(DT.getPointer()); 
-  } 
- 
-  operator AbstractAttribute *() { return cast<AbstractAttribute>(this); } 
- 
-public: 
-  using iterator = 
-      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>; 
-  using aaiterator = 
-      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetValAA)>; 
- 
-  aaiterator begin() { return aaiterator(Deps.begin(), &DepGetValAA); } 
-  aaiterator end() { return aaiterator(Deps.end(), &DepGetValAA); } 
-  iterator child_begin() { return iterator(Deps.begin(), &DepGetVal); } 
-  iterator child_end() { return iterator(Deps.end(), &DepGetVal); } 
- 
-  virtual void print(raw_ostream &OS) const { OS << "AADepNode Impl\n"; } 
-  TinyPtrVector<DepTy> &getDeps() { return Deps; } 
- 
-  friend struct Attributor; 
-  friend struct AADepGraph; 
-}; 
- 
-/// The data structure for the dependency graph 
-/// 
-/// Note that in this graph if there is an edge from A to B (A -> B), 
-/// then it means that B depends on A, and when the state of A is 
-/// updated, node B should also be updated 
-struct AADepGraph { 
-  AADepGraph() {} 
-  ~AADepGraph() {} 
- 
-  using DepTy = AADepGraphNode::DepTy; 
-  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); } 
-  using iterator = 
-      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>; 
- 
-  /// There is no root node for the dependency graph. But the SCCIterator 
-  /// requires a single entry point, so we maintain a fake("synthetic") root 
-  /// node that depends on every node. 
-  AADepGraphNode SyntheticRoot; 
-  AADepGraphNode *GetEntryNode() { return &SyntheticRoot; } 
- 
-  iterator begin() { return SyntheticRoot.child_begin(); } 
-  iterator end() { return SyntheticRoot.child_end(); } 
- 
-  void viewGraph(); 
- 
-  /// Dump graph to file 
-  void dumpGraph(); 
- 
-  /// Print dependency graph 
-  void print(); 
-}; 
- 
+/// The data structure for the nodes of a dependency graph
+struct AADepGraphNode {
+public:
+  virtual ~AADepGraphNode(){};
+  using DepTy = PointerIntPair<AADepGraphNode *, 1>;
+
+protected:
+  /// Set of dependency graph nodes which should be updated if this one
+  /// is updated. The bit encodes if it is optional.
+  TinyPtrVector<DepTy> Deps;
+
+  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }
+  static AbstractAttribute *DepGetValAA(DepTy &DT) {
+    return cast<AbstractAttribute>(DT.getPointer());
+  }
+
+  operator AbstractAttribute *() { return cast<AbstractAttribute>(this); }
+
+public:
+  using iterator =
+      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;
+  using aaiterator =
+      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetValAA)>;
+
+  aaiterator begin() { return aaiterator(Deps.begin(), &DepGetValAA); }
+  aaiterator end() { return aaiterator(Deps.end(), &DepGetValAA); }
+  iterator child_begin() { return iterator(Deps.begin(), &DepGetVal); }
+  iterator child_end() { return iterator(Deps.end(), &DepGetVal); }
+
+  virtual void print(raw_ostream &OS) const { OS << "AADepNode Impl\n"; }
+  TinyPtrVector<DepTy> &getDeps() { return Deps; }
+
+  friend struct Attributor;
+  friend struct AADepGraph;
+};
+
+/// The data structure for the dependency graph
+///
+/// Note that in this graph if there is an edge from A to B (A -> B),
+/// then it means that B depends on A, and when the state of A is
+/// updated, node B should also be updated
+struct AADepGraph {
+  AADepGraph() {}
+  ~AADepGraph() {}
+
+  using DepTy = AADepGraphNode::DepTy;
+  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }
+  using iterator =
+      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;
+
+  /// There is no root node for the dependency graph. But the SCCIterator
+  /// requires a single entry point, so we maintain a fake("synthetic") root
+  /// node that depends on every node.
+  AADepGraphNode SyntheticRoot;
+  AADepGraphNode *GetEntryNode() { return &SyntheticRoot; }
+
+  iterator begin() { return SyntheticRoot.child_begin(); }
+  iterator end() { return SyntheticRoot.child_end(); }
+
+  void viewGraph();
+
+  /// Dump graph to file
+  void dumpGraph();
+
+  /// Print dependency graph
+  void print();
+};
+
 /// Helper to describe and deal with positions in the LLVM-IR.
 ///
 /// A position in the IR is described by an anchor value and an "offset" that
@@ -344,14 +344,14 @@ struct IRPosition {
 
   /// Return the associated function, if any.
   Function *getAssociatedFunction() const {
-    if (auto *CB = dyn_cast<CallBase>(&getAnchorValue())) { 
-      // We reuse the logic that associates callback calles to arguments of a 
-      // call site here to identify the callback callee as the associated 
-      // function. 
-      if (Argument *Arg = getAssociatedArgument()) 
-        return Arg->getParent(); 
+    if (auto *CB = dyn_cast<CallBase>(&getAnchorValue())) {
+      // We reuse the logic that associates callback calles to arguments of a
+      // call site here to identify the callback callee as the associated
+      // function.
+      if (Argument *Arg = getAssociatedArgument())
+        return Arg->getParent();
       return CB->getCalledFunction();
-    } 
+    }
     return getAnchorScope();
   }
 
@@ -399,11 +399,11 @@ struct IRPosition {
 
   /// Return the value this abstract attribute is associated with.
   Value &getAssociatedValue() const {
-    if (getCallSiteArgNo() < 0 || isa<Argument>(&getAnchorValue())) 
+    if (getCallSiteArgNo() < 0 || isa<Argument>(&getAnchorValue()))
       return getAnchorValue();
     assert(isa<CallBase>(&getAnchorValue()) && "Expected a call base!");
-    return *cast<CallBase>(&getAnchorValue()) 
-                ->getArgOperand(getCallSiteArgNo()); 
+    return *cast<CallBase>(&getAnchorValue())
+                ->getArgOperand(getCallSiteArgNo());
   }
 
   /// Return the type this abstract attribute is associated with.
@@ -413,24 +413,24 @@ struct IRPosition {
     return getAssociatedValue().getType();
   }
 
-  /// Return the callee argument number of the associated value if it is an 
-  /// argument or call site argument, otherwise a negative value. In contrast to 
-  /// `getCallSiteArgNo` this method will always return the "argument number" 
-  /// from the perspective of the callee. This may not the same as the call site 
-  /// if this is a callback call. 
-  int getCalleeArgNo() const { 
-    return getArgNo(/* CallbackCalleeArgIfApplicable */ true); 
-  }
-
-  /// Return the call site argument number of the associated value if it is an 
-  /// argument or call site argument, otherwise a negative value. In contrast to 
-  /// `getCalleArgNo` this method will always return the "operand number" from 
-  /// the perspective of the call site. This may not the same as the callee 
-  /// perspective if this is a callback call. 
-  int getCallSiteArgNo() const { 
-    return getArgNo(/* CallbackCalleeArgIfApplicable */ false); 
-  } 
- 
+  /// Return the callee argument number of the associated value if it is an
+  /// argument or call site argument, otherwise a negative value. In contrast to
+  /// `getCallSiteArgNo` this method will always return the "argument number"
+  /// from the perspective of the callee. This may not the same as the call site
+  /// if this is a callback call.
+  int getCalleeArgNo() const {
+    return getArgNo(/* CallbackCalleeArgIfApplicable */ true);
+  }
+
+  /// Return the call site argument number of the associated value if it is an
+  /// argument or call site argument, otherwise a negative value. In contrast to
+  /// `getCalleArgNo` this method will always return the "operand number" from
+  /// the perspective of the call site. This may not the same as the callee
+  /// perspective if this is a callback call.
+  int getCallSiteArgNo() const {
+    return getArgNo(/* CallbackCalleeArgIfApplicable */ false);
+  }
+
   /// Return the index in the attribute list for this position.
   unsigned getAttrIdx() const {
     switch (getPositionKind()) {
@@ -445,7 +445,7 @@ struct IRPosition {
       return AttributeList::ReturnIndex;
     case IRPosition::IRP_ARGUMENT:
     case IRPosition::IRP_CALL_SITE_ARGUMENT:
-      return getCallSiteArgNo() + AttributeList::FirstArgIndex; 
+      return getCallSiteArgNo() + AttributeList::FirstArgIndex;
     }
     llvm_unreachable(
         "There is no attribute index for a floating or invalid position!");
@@ -530,17 +530,17 @@ struct IRPosition {
     }
   }
 
-  /// Return true if the position is an argument or call site argument. 
-  bool isArgumentPosition() const { 
-    switch (getPositionKind()) { 
-    case IRPosition::IRP_ARGUMENT: 
-    case IRPosition::IRP_CALL_SITE_ARGUMENT: 
-      return true; 
-    default: 
-      return false; 
-    } 
-  } 
- 
+  /// Return true if the position is an argument or call site argument.
+  bool isArgumentPosition() const {
+    switch (getPositionKind()) {
+    case IRPosition::IRP_ARGUMENT:
+    case IRPosition::IRP_CALL_SITE_ARGUMENT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   /// Special DenseMap key values.
   ///
   ///{
@@ -587,25 +587,25 @@ private:
     verify();
   }
 
-  /// Return the callee argument number of the associated value if it is an 
-  /// argument or call site argument. See also `getCalleeArgNo` and 
-  /// `getCallSiteArgNo`. 
-  int getArgNo(bool CallbackCalleeArgIfApplicable) const { 
-    if (CallbackCalleeArgIfApplicable) 
-      if (Argument *Arg = getAssociatedArgument()) 
-        return Arg->getArgNo(); 
-    switch (getPositionKind()) { 
-    case IRPosition::IRP_ARGUMENT: 
-      return cast<Argument>(getAsValuePtr())->getArgNo(); 
-    case IRPosition::IRP_CALL_SITE_ARGUMENT: { 
-      Use &U = *getAsUsePtr(); 
-      return cast<CallBase>(U.getUser())->getArgOperandNo(&U); 
-    } 
-    default: 
-      return -1; 
-    } 
-  } 
- 
+  /// Return the callee argument number of the associated value if it is an
+  /// argument or call site argument. See also `getCalleeArgNo` and
+  /// `getCallSiteArgNo`.
+  int getArgNo(bool CallbackCalleeArgIfApplicable) const {
+    if (CallbackCalleeArgIfApplicable)
+      if (Argument *Arg = getAssociatedArgument())
+        return Arg->getArgNo();
+    switch (getPositionKind()) {
+    case IRPosition::IRP_ARGUMENT:
+      return cast<Argument>(getAsValuePtr())->getArgNo();
+    case IRPosition::IRP_CALL_SITE_ARGUMENT: {
+      Use &U = *getAsUsePtr();
+      return cast<CallBase>(U.getUser())->getArgOperandNo(&U);
+    }
+    default:
+      return -1;
+    }
+  }
+
   /// IRPosition for the use \p U. The position kind \p PK needs to be
   /// IRP_CALL_SITE_ARGUMENT, the anchor value is the user, the associated value
   /// the used value.
@@ -769,10 +769,10 @@ struct InformationCache {
             [&](const Function &F) {
               return AG.getAnalysis<PostDominatorTreeAnalysis>(F);
             }),
-        AG(AG), CGSCC(CGSCC) { 
-    if (CGSCC) 
-      initializeModuleSlice(*CGSCC); 
-  } 
+        AG(AG), CGSCC(CGSCC) {
+    if (CGSCC)
+      initializeModuleSlice(*CGSCC);
+  }
 
   ~InformationCache() {
     // The FunctionInfo objects are allocated via a BumpPtrAllocator, we call
@@ -781,68 +781,68 @@ struct InformationCache {
       It.getSecond()->~FunctionInfo();
   }
 
-  /// Apply \p CB to all uses of \p F. If \p LookThroughConstantExprUses is 
-  /// true, constant expression users are not given to \p CB but their uses are 
-  /// traversed transitively. 
-  template <typename CBTy> 
-  static void foreachUse(Function &F, CBTy CB, 
-                         bool LookThroughConstantExprUses = true) { 
-    SmallVector<Use *, 8> Worklist(make_pointer_range(F.uses())); 
- 
-    for (unsigned Idx = 0; Idx < Worklist.size(); ++Idx) { 
-      Use &U = *Worklist[Idx]; 
- 
-      // Allow use in constant bitcasts and simply look through them. 
-      if (LookThroughConstantExprUses && isa<ConstantExpr>(U.getUser())) { 
-        for (Use &CEU : cast<ConstantExpr>(U.getUser())->uses()) 
-          Worklist.push_back(&CEU); 
-        continue; 
-      } 
- 
-      CB(U); 
-    } 
-  } 
- 
-  /// Initialize the ModuleSlice member based on \p SCC. ModuleSlices contains 
-  /// (a subset of) all functions that we can look at during this SCC traversal. 
-  /// This includes functions (transitively) called from the SCC and the 
-  /// (transitive) callers of SCC functions. We also can look at a function if 
-  /// there is a "reference edge", i.a., if the function somehow uses (!=calls) 
-  /// a function in the SCC or a caller of a function in the SCC. 
-  void initializeModuleSlice(SetVector<Function *> &SCC) { 
-    ModuleSlice.insert(SCC.begin(), SCC.end()); 
- 
-    SmallPtrSet<Function *, 16> Seen; 
-    SmallVector<Function *, 16> Worklist(SCC.begin(), SCC.end()); 
-    while (!Worklist.empty()) { 
-      Function *F = Worklist.pop_back_val(); 
-      ModuleSlice.insert(F); 
- 
-      for (Instruction &I : instructions(*F)) 
-        if (auto *CB = dyn_cast<CallBase>(&I)) 
-          if (Function *Callee = CB->getCalledFunction()) 
-            if (Seen.insert(Callee).second) 
-              Worklist.push_back(Callee); 
-    } 
- 
-    Seen.clear(); 
-    Worklist.append(SCC.begin(), SCC.end()); 
-    while (!Worklist.empty()) { 
-      Function *F = Worklist.pop_back_val(); 
-      ModuleSlice.insert(F); 
- 
-      // Traverse all transitive uses. 
-      foreachUse(*F, [&](Use &U) { 
-        if (auto *UsrI = dyn_cast<Instruction>(U.getUser())) 
-          if (Seen.insert(UsrI->getFunction()).second) 
-            Worklist.push_back(UsrI->getFunction()); 
-      }); 
-    } 
-  } 
- 
-  /// The slice of the module we are allowed to look at. 
-  SmallPtrSet<Function *, 8> ModuleSlice; 
- 
+  /// Apply \p CB to all uses of \p F. If \p LookThroughConstantExprUses is
+  /// true, constant expression users are not given to \p CB but their uses are
+  /// traversed transitively.
+  template <typename CBTy>
+  static void foreachUse(Function &F, CBTy CB,
+                         bool LookThroughConstantExprUses = true) {
+    SmallVector<Use *, 8> Worklist(make_pointer_range(F.uses()));
+
+    for (unsigned Idx = 0; Idx < Worklist.size(); ++Idx) {
+      Use &U = *Worklist[Idx];
+
+      // Allow use in constant bitcasts and simply look through them.
+      if (LookThroughConstantExprUses && isa<ConstantExpr>(U.getUser())) {
+        for (Use &CEU : cast<ConstantExpr>(U.getUser())->uses())
+          Worklist.push_back(&CEU);
+        continue;
+      }
+
+      CB(U);
+    }
+  }
+
+  /// Initialize the ModuleSlice member based on \p SCC. ModuleSlices contains
+  /// (a subset of) all functions that we can look at during this SCC traversal.
+  /// This includes functions (transitively) called from the SCC and the
+  /// (transitive) callers of SCC functions. We also can look at a function if
+  /// there is a "reference edge", i.a., if the function somehow uses (!=calls)
+  /// a function in the SCC or a caller of a function in the SCC.
+  void initializeModuleSlice(SetVector<Function *> &SCC) {
+    ModuleSlice.insert(SCC.begin(), SCC.end());
+
+    SmallPtrSet<Function *, 16> Seen;
+    SmallVector<Function *, 16> Worklist(SCC.begin(), SCC.end());
+    while (!Worklist.empty()) {
+      Function *F = Worklist.pop_back_val();
+      ModuleSlice.insert(F);
+
+      for (Instruction &I : instructions(*F))
+        if (auto *CB = dyn_cast<CallBase>(&I))
+          if (Function *Callee = CB->getCalledFunction())
+            if (Seen.insert(Callee).second)
+              Worklist.push_back(Callee);
+    }
+
+    Seen.clear();
+    Worklist.append(SCC.begin(), SCC.end());
+    while (!Worklist.empty()) {
+      Function *F = Worklist.pop_back_val();
+      ModuleSlice.insert(F);
+
+      // Traverse all transitive uses.
+      foreachUse(*F, [&](Use &U) {
+        if (auto *UsrI = dyn_cast<Instruction>(U.getUser()))
+          if (Seen.insert(UsrI->getFunction()).second)
+            Worklist.push_back(UsrI->getFunction());
+      });
+    }
+  }
+
+  /// The slice of the module we are allowed to look at.
+  SmallPtrSet<Function *, 8> ModuleSlice;
+
   /// A vector type to hold instructions.
   using InstructionVectorTy = SmallVector<Instruction *, 8>;
 
@@ -871,7 +871,7 @@ struct InformationCache {
   }
 
   /// Return AliasAnalysis Result for function \p F.
-  AAResults *getAAResultsForFunction(const Function &F); 
+  AAResults *getAAResultsForFunction(const Function &F);
 
   /// Return true if \p Arg is involved in a must-tail call, thus the argument
   /// of the caller or callee.
@@ -899,26 +899,26 @@ struct InformationCache {
   /// Return the map conaining all the knowledge we have from `llvm.assume`s.
   const RetainedKnowledgeMap &getKnowledgeMap() const { return KnowledgeMap; }
 
-  /// Return if \p To is potentially reachable form \p From or not 
-  /// If the same query was answered, return cached result 
-  bool getPotentiallyReachable(const Instruction &From, const Instruction &To) { 
-    auto KeyPair = std::make_pair(&From, &To); 
-    auto Iter = PotentiallyReachableMap.find(KeyPair); 
-    if (Iter != PotentiallyReachableMap.end()) 
-      return Iter->second; 
-    const Function &F = *From.getFunction(); 
-    bool Result = isPotentiallyReachable( 
-        &From, &To, nullptr, AG.getAnalysis<DominatorTreeAnalysis>(F), 
-        AG.getAnalysis<LoopAnalysis>(F)); 
-    PotentiallyReachableMap.insert(std::make_pair(KeyPair, Result)); 
-    return Result; 
-  } 
- 
-  /// Check whether \p F is part of module slice. 
-  bool isInModuleSlice(const Function &F) { 
-    return ModuleSlice.count(const_cast<Function *>(&F)); 
-  } 
- 
+  /// Return if \p To is potentially reachable form \p From or not
+  /// If the same query was answered, return cached result
+  bool getPotentiallyReachable(const Instruction &From, const Instruction &To) {
+    auto KeyPair = std::make_pair(&From, &To);
+    auto Iter = PotentiallyReachableMap.find(KeyPair);
+    if (Iter != PotentiallyReachableMap.end())
+      return Iter->second;
+    const Function &F = *From.getFunction();
+    bool Result = isPotentiallyReachable(
+        &From, &To, nullptr, AG.getAnalysis<DominatorTreeAnalysis>(F),
+        AG.getAnalysis<LoopAnalysis>(F));
+    PotentiallyReachableMap.insert(std::make_pair(KeyPair, Result));
+    return Result;
+  }
+
+  /// Check whether \p F is part of module slice.
+  bool isInModuleSlice(const Function &F) {
+    return ModuleSlice.count(const_cast<Function *>(&F));
+  }
+
 private:
   struct FunctionInfo {
     ~FunctionInfo();
@@ -978,10 +978,10 @@ private:
   /// Set of inlineable functions
   SmallPtrSet<const Function *, 8> InlineableFunctions;
 
-  /// A map for caching results of queries for isPotentiallyReachable 
-  DenseMap<std::pair<const Instruction *, const Instruction *>, bool> 
-      PotentiallyReachableMap; 
- 
+  /// A map for caching results of queries for isPotentiallyReachable
+  DenseMap<std::pair<const Instruction *, const Instruction *>, bool>
+      PotentiallyReachableMap;
+
   /// Give the Attributor access to the members so
   /// Attributor::identifyDefaultAbstractAttributes(...) can initialize them.
   friend struct Attributor;
@@ -1084,7 +1084,7 @@ struct Attributor {
   /// attribute. Using this after Attributor started running is restricted to
   /// only the Attributor itself. Initial seeding of AAs can be done via this
   /// function.
-  /// NOTE: ForceUpdate is ignored in any stage other than the update stage. 
+  /// NOTE: ForceUpdate is ignored in any stage other than the update stage.
   template <typename AAType>
   const AAType &getOrCreateAAFor(const IRPosition &IRP,
                                  const AbstractAttribute *QueryingAA = nullptr,
@@ -1092,7 +1092,7 @@ struct Attributor {
                                  DepClassTy DepClass = DepClassTy::OPTIONAL,
                                  bool ForceUpdate = false) {
     if (AAType *AAPtr = lookupAAFor<AAType>(IRP, QueryingAA, TrackDependence)) {
-      if (ForceUpdate && Phase == AttributorPhase::UPDATE) 
+      if (ForceUpdate && Phase == AttributorPhase::UPDATE)
         updateAA(*AAPtr);
       return *AAPtr;
     }
@@ -1102,7 +1102,7 @@ struct Attributor {
     auto &AA = AAType::createForPosition(IRP, *this);
 
     // If we are currenty seeding attributes, enforce seeding rules.
-    if (Phase == AttributorPhase::SEEDING && !shouldSeedAttribute(AA)) { 
+    if (Phase == AttributorPhase::SEEDING && !shouldSeedAttribute(AA)) {
       AA.getState().indicatePessimisticFixpoint();
       return AA;
     }
@@ -1116,9 +1116,9 @@ struct Attributor {
       Invalidate |= FnScope->hasFnAttribute(Attribute::Naked) ||
                     FnScope->hasFnAttribute(Attribute::OptimizeNone);
 
-    // Avoid too many nested initializations to prevent a stack overflow. 
-    Invalidate |= InitializationChainLength > MaxInitializationChainLength; 
- 
+    // Avoid too many nested initializations to prevent a stack overflow.
+    Invalidate |= InitializationChainLength > MaxInitializationChainLength;
+
     // Bootstrap the new attribute with an initial update to propagate
     // information, e.g., function -> call site. If it is not on a given
     // Allowed we will not perform updates at all.
@@ -1127,39 +1127,39 @@ struct Attributor {
       return AA;
     }
 
-    { 
-      TimeTraceScope TimeScope(AA.getName() + "::initialize"); 
-      ++InitializationChainLength; 
-      AA.initialize(*this); 
-      --InitializationChainLength; 
-    } 
-
-    // Initialize and update is allowed for code outside of the current function 
-    // set, but only if it is part of module slice we are allowed to look at. 
-    // Only exception is AAIsDeadFunction whose initialization is prevented 
-    // directly, since we don't to compute it twice. 
+    {
+      TimeTraceScope TimeScope(AA.getName() + "::initialize");
+      ++InitializationChainLength;
+      AA.initialize(*this);
+      --InitializationChainLength;
+    }
+
+    // Initialize and update is allowed for code outside of the current function
+    // set, but only if it is part of module slice we are allowed to look at.
+    // Only exception is AAIsDeadFunction whose initialization is prevented
+    // directly, since we don't to compute it twice.
     if (FnScope && !Functions.count(const_cast<Function *>(FnScope))) {
-      if (!getInfoCache().isInModuleSlice(*FnScope)) { 
-        AA.getState().indicatePessimisticFixpoint(); 
-        return AA; 
-      } 
-    } 
- 
-    // If this is queried in the manifest stage, we force the AA to indicate 
-    // pessimistic fixpoint immediately. 
-    if (Phase == AttributorPhase::MANIFEST) { 
+      if (!getInfoCache().isInModuleSlice(*FnScope)) {
+        AA.getState().indicatePessimisticFixpoint();
+        return AA;
+      }
+    }
+
+    // If this is queried in the manifest stage, we force the AA to indicate
+    // pessimistic fixpoint immediately.
+    if (Phase == AttributorPhase::MANIFEST) {
       AA.getState().indicatePessimisticFixpoint();
       return AA;
     }
 
     // Allow seeded attributes to declare dependencies.
     // Remember the seeding state.
-    AttributorPhase OldPhase = Phase; 
-    Phase = AttributorPhase::UPDATE; 
+    AttributorPhase OldPhase = Phase;
+    Phase = AttributorPhase::UPDATE;
 
     updateAA(AA);
 
-    Phase = OldPhase; 
+    Phase = OldPhase;
 
     if (TrackDependence && AA.getState().isValidState())
       recordDependence(AA, const_cast<AbstractAttribute &>(*QueryingAA),
@@ -1228,11 +1228,11 @@ struct Attributor {
     assert(!AAPtr && "Attribute already in map!");
     AAPtr = &AA;
 
-    // Register AA with the synthetic root only before the manifest stage. 
-    if (Phase == AttributorPhase::SEEDING || Phase == AttributorPhase::UPDATE) 
-      DG.SyntheticRoot.Deps.push_back( 
-          AADepGraphNode::DepTy(&AA, unsigned(DepClassTy::REQUIRED))); 
- 
+    // Register AA with the synthetic root only before the manifest stage.
+    if (Phase == AttributorPhase::SEEDING || Phase == AttributorPhase::UPDATE)
+      DG.SyntheticRoot.Deps.push_back(
+          AADepGraphNode::DepTy(&AA, unsigned(DepClassTy::REQUIRED)));
+
     return AA;
   }
 
@@ -1541,22 +1541,22 @@ struct Attributor {
   bool checkForAllReadWriteInstructions(function_ref<bool(Instruction &)> Pred,
                                         AbstractAttribute &QueryingAA);
 
-  /// Create a shallow wrapper for \p F such that \p F has internal linkage 
-  /// afterwards. It also sets the original \p F 's name to anonymous 
-  /// 
-  /// A wrapper is a function with the same type (and attributes) as \p F 
-  /// that will only call \p F and return the result, if any. 
-  /// 
-  /// Assuming the declaration of looks like: 
-  ///   rty F(aty0 arg0, ..., atyN argN); 
-  /// 
-  /// The wrapper will then look as follows: 
-  ///   rty wrapper(aty0 arg0, ..., atyN argN) { 
-  ///     return F(arg0, ..., argN); 
-  ///   } 
-  /// 
-  static void createShallowWrapper(Function &F); 
- 
+  /// Create a shallow wrapper for \p F such that \p F has internal linkage
+  /// afterwards. It also sets the original \p F 's name to anonymous
+  ///
+  /// A wrapper is a function with the same type (and attributes) as \p F
+  /// that will only call \p F and return the result, if any.
+  ///
+  /// Assuming the declaration of looks like:
+  ///   rty F(aty0 arg0, ..., atyN argN);
+  ///
+  /// The wrapper will then look as follows:
+  ///   rty wrapper(aty0 arg0, ..., atyN argN) {
+  ///     return F(arg0, ..., argN);
+  ///   }
+  ///
+  static void createShallowWrapper(Function &F);
+
   /// Return the data layout associated with the anchor scope.
   const DataLayout &getDataLayout() const { return InfoCache.DL; }
 
@@ -1580,10 +1580,10 @@ private:
   /// Rewrites function signitures and updates the call graph.
   ChangeStatus cleanupIR();
 
-  /// Identify internal functions that are effectively dead, thus not reachable 
-  /// from a live entry point. The functions are added to ToBeDeletedFunctions. 
-  void identifyDeadInternalFunctions(); 
- 
+  /// Identify internal functions that are effectively dead, thus not reachable
+  /// from a live entry point. The functions are added to ToBeDeletedFunctions.
+  void identifyDeadInternalFunctions();
+
   /// Run `::update` on \p AA and track the dependences queried while doing so.
   /// Also adjust the state if we know further updates are not necessary.
   ChangeStatus updateAA(AbstractAttribute &AA);
@@ -1635,9 +1635,9 @@ private:
   /// Helper to update an underlying call graph.
   CallGraphUpdater &CGUpdater;
 
-  /// Abstract Attribute dependency graph 
-  AADepGraph DG; 
- 
+  /// Abstract Attribute dependency graph
+  AADepGraph DG;
+
   /// Set of functions for which we modified the content such that it might
   /// impact the call graph.
   SmallPtrSet<Function *, 8> CGModifiedFunctions;
@@ -1676,18 +1676,18 @@ private:
   /// Invoke instructions with at least a single dead successor block.
   SmallVector<WeakVH, 16> InvokeWithDeadSuccessor;
 
-  /// A flag that indicates which stage of the process we are in. Initially, the 
-  /// phase is SEEDING. Phase is changed in `Attributor::run()` 
-  enum class AttributorPhase { 
-    SEEDING, 
-    UPDATE, 
-    MANIFEST, 
-    CLEANUP, 
-  } Phase = AttributorPhase::SEEDING; 
-
-  /// The current initialization chain length. Tracked to avoid stack overflows. 
-  unsigned InitializationChainLength = 0; 
- 
+  /// A flag that indicates which stage of the process we are in. Initially, the
+  /// phase is SEEDING. Phase is changed in `Attributor::run()`
+  enum class AttributorPhase {
+    SEEDING,
+    UPDATE,
+    MANIFEST,
+    CLEANUP,
+  } Phase = AttributorPhase::SEEDING;
+
+  /// The current initialization chain length. Tracked to avoid stack overflows.
+  unsigned InitializationChainLength = 0;
+
   /// Functions, blocks, and instructions we delete after manifest is done.
   ///
   ///{
@@ -1695,8 +1695,8 @@ private:
   SmallPtrSet<BasicBlock *, 8> ToBeDeletedBlocks;
   SmallDenseSet<WeakVH, 8> ToBeDeletedInsts;
   ///}
- 
-  friend AADepGraph; 
+
+  friend AADepGraph;
 };
 
 /// An interface to query the internal state of an abstract attribute.
@@ -2175,7 +2175,7 @@ struct StateWrapper : public BaseType, public StateTy {
   StateType &getState() override { return *this; }
 
   /// See AbstractAttribute::getState(...).
-  const StateType &getState() const override { return *this; } 
+  const StateType &getState() const override { return *this; }
 };
 
 /// Helper class that provides common functionality to manifest IR attributes.
@@ -2269,7 +2269,7 @@ struct IRAttribute : public BaseType {
 ///       both directions will be added in the future.
 /// NOTE: The mechanics of adding a new "concrete" abstract attribute are
 ///       described in the file comment.
-struct AbstractAttribute : public IRPosition, public AADepGraphNode { 
+struct AbstractAttribute : public IRPosition, public AADepGraphNode {
   using StateType = AbstractState;
 
   AbstractAttribute(const IRPosition &IRP) : IRPosition(IRP) {}
@@ -2277,14 +2277,14 @@ struct AbstractAttribute : public IRPosition, public AADepGraphNode {
   /// Virtual destructor.
   virtual ~AbstractAttribute() {}
 
-  /// This function is used to identify if an \p DGN is of type 
-  /// AbstractAttribute so that the dyn_cast and cast can use such information 
-  /// to cast an AADepGraphNode to an AbstractAttribute. 
-  /// 
-  /// We eagerly return true here because all AADepGraphNodes except for the 
-  /// Synthethis Node are of type AbstractAttribute 
-  static bool classof(const AADepGraphNode *DGN) { return true; } 
- 
+  /// This function is used to identify if an \p DGN is of type
+  /// AbstractAttribute so that the dyn_cast and cast can use such information
+  /// to cast an AADepGraphNode to an AbstractAttribute.
+  ///
+  /// We eagerly return true here because all AADepGraphNodes except for the
+  /// Synthethis Node are of type AbstractAttribute
+  static bool classof(const AADepGraphNode *DGN) { return true; }
+
   /// Initialize the state with the information in the Attributor \p A.
   ///
   /// This function is called by the Attributor once all abstract attributes
@@ -2305,8 +2305,8 @@ struct AbstractAttribute : public IRPosition, public AADepGraphNode {
 
   /// Helper functions, for debug purposes only.
   ///{
-  void print(raw_ostream &OS) const override; 
-  virtual void printWithDeps(raw_ostream &OS) const; 
+  void print(raw_ostream &OS) const override;
+  virtual void printWithDeps(raw_ostream &OS) const;
   void dump() const { print(dbgs()); }
 
   /// This function should return the "summarized" assumed state as string.
@@ -2635,17 +2635,17 @@ struct AAReachability : public StateWrapper<BooleanState, AbstractAttribute> {
   /// Returns true if 'From' instruction is assumed to reach, 'To' instruction.
   /// Users should provide two positions they are interested in, and the class
   /// determines (and caches) reachability.
-  bool isAssumedReachable(Attributor &A, const Instruction &From, 
-                          const Instruction &To) const { 
-    return A.getInfoCache().getPotentiallyReachable(From, To); 
+  bool isAssumedReachable(Attributor &A, const Instruction &From,
+                          const Instruction &To) const {
+    return A.getInfoCache().getPotentiallyReachable(From, To);
   }
 
   /// Returns true if 'From' instruction is known to reach, 'To' instruction.
   /// Users should provide two positions they are interested in, and the class
   /// determines (and caches) reachability.
-  bool isKnownReachable(Attributor &A, const Instruction &From, 
-                        const Instruction &To) const { 
-    return A.getInfoCache().getPotentiallyReachable(From, To); 
+  bool isKnownReachable(Attributor &A, const Instruction &From,
+                        const Instruction &To) const {
+    return A.getInfoCache().getPotentiallyReachable(From, To);
   }
 
   /// Create an abstract attribute view for the position \p IRP.
@@ -2808,12 +2808,12 @@ public:
     return F.hasPersonalityFn() && !canSimplifyInvokeNoUnwind(&F);
   }
 
-  /// Return if the edge from \p From BB to \p To BB is assumed dead. 
-  /// This is specifically useful in AAReachability. 
-  virtual bool isEdgeDead(const BasicBlock *From, const BasicBlock *To) const { 
-    return false; 
-  } 
- 
+  /// Return if the edge from \p From BB to \p To BB is assumed dead.
+  /// This is specifically useful in AAReachability.
+  virtual bool isEdgeDead(const BasicBlock *From, const BasicBlock *To) const {
+    return false;
+  }
+
   /// See AbstractAttribute::getName()
   const std::string getName() const override { return "AAIsDead"; }
 
@@ -3470,7 +3470,7 @@ struct AAValueConstantRange
 
   /// See AbstractAttribute::getState(...).
   IntegerRangeState &getState() override { return *this; }
-  const IntegerRangeState &getState() const override { return *this; } 
+  const IntegerRangeState &getState() const override { return *this; }
 
   /// Create an abstract attribute view for the position \p IRP.
   static AAValueConstantRange &createForPosition(const IRPosition &IRP,
@@ -3518,279 +3518,279 @@ struct AAValueConstantRange
   static const char ID;
 };
 
-/// A class for a set state. 
-/// The assumed boolean state indicates whether the corresponding set is full 
-/// set or not. If the assumed state is false, this is the worst state. The 
-/// worst state (invalid state) of set of potential values is when the set 
-/// contains every possible value (i.e. we cannot in any way limit the value 
-/// that the target position can take). That never happens naturally, we only 
-/// force it. As for the conditions under which we force it, see 
-/// AAPotentialValues. 
-template <typename MemberTy, typename KeyInfo = DenseMapInfo<MemberTy>> 
-struct PotentialValuesState : AbstractState { 
-  using SetTy = DenseSet<MemberTy, KeyInfo>; 
- 
-  PotentialValuesState() : IsValidState(true), UndefIsContained(false) {} 
- 
-  PotentialValuesState(bool IsValid) 
-      : IsValidState(IsValid), UndefIsContained(false) {} 
- 
-  /// See AbstractState::isValidState(...) 
-  bool isValidState() const override { return IsValidState.isValidState(); } 
- 
-  /// See AbstractState::isAtFixpoint(...) 
-  bool isAtFixpoint() const override { return IsValidState.isAtFixpoint(); } 
- 
-  /// See AbstractState::indicatePessimisticFixpoint(...) 
-  ChangeStatus indicatePessimisticFixpoint() override { 
-    return IsValidState.indicatePessimisticFixpoint(); 
-  } 
- 
-  /// See AbstractState::indicateOptimisticFixpoint(...) 
-  ChangeStatus indicateOptimisticFixpoint() override { 
-    return IsValidState.indicateOptimisticFixpoint(); 
-  } 
- 
-  /// Return the assumed state 
-  PotentialValuesState &getAssumed() { return *this; } 
-  const PotentialValuesState &getAssumed() const { return *this; } 
- 
-  /// Return this set. We should check whether this set is valid or not by 
-  /// isValidState() before calling this function. 
-  const SetTy &getAssumedSet() const { 
-    assert(isValidState() && "This set shoud not be used when it is invalid!"); 
-    return Set; 
-  } 
- 
-  /// Returns whether this state contains an undef value or not. 
-  bool undefIsContained() const { 
-    assert(isValidState() && "This flag shoud not be used when it is invalid!"); 
-    return UndefIsContained; 
-  } 
- 
-  bool operator==(const PotentialValuesState &RHS) const { 
-    if (isValidState() != RHS.isValidState()) 
-      return false; 
-    if (!isValidState() && !RHS.isValidState()) 
-      return true; 
-    if (undefIsContained() != RHS.undefIsContained()) 
-      return false; 
-    return Set == RHS.getAssumedSet(); 
-  } 
- 
-  /// Maximum number of potential values to be tracked. 
-  /// This is set by -attributor-max-potential-values command line option 
-  static unsigned MaxPotentialValues; 
- 
-  /// Return empty set as the best state of potential values. 
-  static PotentialValuesState getBestState() { 
-    return PotentialValuesState(true); 
-  } 
- 
-  static PotentialValuesState getBestState(PotentialValuesState &PVS) { 
-    return getBestState(); 
-  } 
- 
-  /// Return full set as the worst state of potential values. 
-  static PotentialValuesState getWorstState() { 
-    return PotentialValuesState(false); 
-  } 
- 
-  /// Union assumed set with the passed value. 
-  void unionAssumed(const MemberTy &C) { insert(C); } 
- 
-  /// Union assumed set with assumed set of the passed state \p PVS. 
-  void unionAssumed(const PotentialValuesState &PVS) { unionWith(PVS); } 
- 
-  /// Union assumed set with an undef value. 
-  void unionAssumedWithUndef() { unionWithUndef(); } 
- 
-  /// "Clamp" this state with \p PVS. 
-  PotentialValuesState operator^=(const PotentialValuesState &PVS) { 
-    IsValidState ^= PVS.IsValidState; 
-    unionAssumed(PVS); 
-    return *this; 
-  } 
- 
-  PotentialValuesState operator&=(const PotentialValuesState &PVS) { 
-    IsValidState &= PVS.IsValidState; 
-    unionAssumed(PVS); 
-    return *this; 
-  } 
- 
-private: 
-  /// Check the size of this set, and invalidate when the size is no 
-  /// less than \p MaxPotentialValues threshold. 
-  void checkAndInvalidate() { 
-    if (Set.size() >= MaxPotentialValues) 
-      indicatePessimisticFixpoint(); 
-  } 
- 
-  /// If this state contains both undef and not undef, we can reduce 
-  /// undef to the not undef value. 
-  void reduceUndefValue() { UndefIsContained = UndefIsContained & Set.empty(); } 
- 
-  /// Insert an element into this set. 
-  void insert(const MemberTy &C) { 
-    if (!isValidState()) 
-      return; 
-    Set.insert(C); 
-    checkAndInvalidate(); 
-  } 
- 
-  /// Take union with R. 
-  void unionWith(const PotentialValuesState &R) { 
-    /// If this is a full set, do nothing.; 
-    if (!isValidState()) 
-      return; 
-    /// If R is full set, change L to a full set. 
-    if (!R.isValidState()) { 
-      indicatePessimisticFixpoint(); 
-      return; 
-    } 
-    for (const MemberTy &C : R.Set) 
-      Set.insert(C); 
-    UndefIsContained |= R.undefIsContained(); 
-    reduceUndefValue(); 
-    checkAndInvalidate(); 
-  } 
- 
-  /// Take union with an undef value. 
-  void unionWithUndef() { 
-    UndefIsContained = true; 
-    reduceUndefValue(); 
-  } 
- 
-  /// Take intersection with R. 
-  void intersectWith(const PotentialValuesState &R) { 
-    /// If R is a full set, do nothing. 
-    if (!R.isValidState()) 
-      return; 
-    /// If this is a full set, change this to R. 
-    if (!isValidState()) { 
-      *this = R; 
-      return; 
-    } 
-    SetTy IntersectSet; 
-    for (const MemberTy &C : Set) { 
-      if (R.Set.count(C)) 
-        IntersectSet.insert(C); 
-    } 
-    Set = IntersectSet; 
-    UndefIsContained &= R.undefIsContained(); 
-    reduceUndefValue(); 
-  } 
- 
-  /// A helper state which indicate whether this state is valid or not. 
-  BooleanState IsValidState; 
- 
-  /// Container for potential values 
-  SetTy Set; 
- 
-  /// Flag for undef value 
-  bool UndefIsContained; 
-}; 
- 
-using PotentialConstantIntValuesState = PotentialValuesState<APInt>; 
- 
-raw_ostream &operator<<(raw_ostream &OS, 
-                        const PotentialConstantIntValuesState &R); 
- 
-/// An abstract interface for potential values analysis. 
-/// 
-/// This AA collects potential values for each IR position. 
-/// An assumed set of potential values is initialized with the empty set (the 
-/// best state) and it will grow monotonically as we find more potential values 
-/// for this position. 
-/// The set might be forced to the worst state, that is, to contain every 
-/// possible value for this position in 2 cases. 
-///   1. We surpassed the \p MaxPotentialValues threshold. This includes the 
-///      case that this position is affected (e.g. because of an operation) by a 
-///      Value that is in the worst state. 
-///   2. We tried to initialize on a Value that we cannot handle (e.g. an 
-///      operator we do not currently handle). 
-/// 
-/// TODO: Support values other than constant integers. 
-struct AAPotentialValues 
-    : public StateWrapper<PotentialConstantIntValuesState, AbstractAttribute> { 
-  using Base = StateWrapper<PotentialConstantIntValuesState, AbstractAttribute>; 
-  AAPotentialValues(const IRPosition &IRP, Attributor &A) : Base(IRP) {} 
- 
-  /// See AbstractAttribute::getState(...). 
-  PotentialConstantIntValuesState &getState() override { return *this; } 
-  const PotentialConstantIntValuesState &getState() const override { 
-    return *this; 
-  } 
- 
-  /// Create an abstract attribute view for the position \p IRP. 
-  static AAPotentialValues &createForPosition(const IRPosition &IRP, 
-                                              Attributor &A); 
- 
-  /// Return assumed constant for the associated value 
-  Optional<ConstantInt *> 
-  getAssumedConstantInt(Attributor &A, 
-                        const Instruction *CtxI = nullptr) const { 
-    if (!isValidState()) 
-      return nullptr; 
-    if (getAssumedSet().size() == 1) 
-      return cast<ConstantInt>(ConstantInt::get(getAssociatedValue().getType(), 
-                                                *(getAssumedSet().begin()))); 
-    if (getAssumedSet().size() == 0) { 
-      if (undefIsContained()) 
-        return cast<ConstantInt>( 
-            ConstantInt::get(getAssociatedValue().getType(), 0)); 
-      return llvm::None; 
-    } 
- 
-    return nullptr; 
-  } 
- 
-  /// See AbstractAttribute::getName() 
-  const std::string getName() const override { return "AAPotentialValues"; } 
- 
-  /// See AbstractAttribute::getIdAddr() 
-  const char *getIdAddr() const override { return &ID; } 
- 
-  /// This function should return true if the type of the \p AA is 
-  /// AAPotentialValues 
-  static bool classof(const AbstractAttribute *AA) { 
-    return (AA->getIdAddr() == &ID); 
-  } 
- 
-  /// Unique ID (due to the unique address) 
-  static const char ID; 
-}; 
- 
-/// An abstract interface for all noundef attributes. 
-struct AANoUndef 
-    : public IRAttribute<Attribute::NoUndef, 
-                         StateWrapper<BooleanState, AbstractAttribute>> { 
-  AANoUndef(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {} 
- 
-  /// Return true if we assume that the underlying value is noundef. 
-  bool isAssumedNoUndef() const { return getAssumed(); } 
- 
-  /// Return true if we know that underlying value is noundef. 
-  bool isKnownNoUndef() const { return getKnown(); } 
- 
-  /// Create an abstract attribute view for the position \p IRP. 
-  static AANoUndef &createForPosition(const IRPosition &IRP, Attributor &A); 
- 
-  /// See AbstractAttribute::getName() 
-  const std::string getName() const override { return "AANoUndef"; } 
- 
-  /// See AbstractAttribute::getIdAddr() 
-  const char *getIdAddr() const override { return &ID; } 
- 
-  /// This function should return true if the type of the \p AA is AANoUndef 
-  static bool classof(const AbstractAttribute *AA) { 
-    return (AA->getIdAddr() == &ID); 
-  } 
- 
-  /// Unique ID (due to the unique address) 
-  static const char ID; 
-}; 
- 
+/// A class for a set state.
+/// The assumed boolean state indicates whether the corresponding set is full
+/// set or not. If the assumed state is false, this is the worst state. The
+/// worst state (invalid state) of set of potential values is when the set
+/// contains every possible value (i.e. we cannot in any way limit the value
+/// that the target position can take). That never happens naturally, we only
+/// force it. As for the conditions under which we force it, see
+/// AAPotentialValues.
+template <typename MemberTy, typename KeyInfo = DenseMapInfo<MemberTy>>
+struct PotentialValuesState : AbstractState {
+  using SetTy = DenseSet<MemberTy, KeyInfo>;
+
+  PotentialValuesState() : IsValidState(true), UndefIsContained(false) {}
+
+  PotentialValuesState(bool IsValid)
+      : IsValidState(IsValid), UndefIsContained(false) {}
+
+  /// See AbstractState::isValidState(...)
+  bool isValidState() const override { return IsValidState.isValidState(); }
+
+  /// See AbstractState::isAtFixpoint(...)
+  bool isAtFixpoint() const override { return IsValidState.isAtFixpoint(); }
+
+  /// See AbstractState::indicatePessimisticFixpoint(...)
+  ChangeStatus indicatePessimisticFixpoint() override {
+    return IsValidState.indicatePessimisticFixpoint();
+  }
+
+  /// See AbstractState::indicateOptimisticFixpoint(...)
+  ChangeStatus indicateOptimisticFixpoint() override {
+    return IsValidState.indicateOptimisticFixpoint();
+  }
+
+  /// Return the assumed state
+  PotentialValuesState &getAssumed() { return *this; }
+  const PotentialValuesState &getAssumed() const { return *this; }
+
+  /// Return this set. We should check whether this set is valid or not by
+  /// isValidState() before calling this function.
+  const SetTy &getAssumedSet() const {
+    assert(isValidState() && "This set shoud not be used when it is invalid!");
+    return Set;
+  }
+
+  /// Returns whether this state contains an undef value or not.
+  bool undefIsContained() const {
+    assert(isValidState() && "This flag shoud not be used when it is invalid!");
+    return UndefIsContained;
+  }
+
+  bool operator==(const PotentialValuesState &RHS) const {
+    if (isValidState() != RHS.isValidState())
+      return false;
+    if (!isValidState() && !RHS.isValidState())
+      return true;
+    if (undefIsContained() != RHS.undefIsContained())
+      return false;
+    return Set == RHS.getAssumedSet();
+  }
+
+  /// Maximum number of potential values to be tracked.
+  /// This is set by -attributor-max-potential-values command line option
+  static unsigned MaxPotentialValues;
+
+  /// Return empty set as the best state of potential values.
+  static PotentialValuesState getBestState() {
+    return PotentialValuesState(true);
+  }
+
+  static PotentialValuesState getBestState(PotentialValuesState &PVS) {
+    return getBestState();
+  }
+
+  /// Return full set as the worst state of potential values.
+  static PotentialValuesState getWorstState() {
+    return PotentialValuesState(false);
+  }
+
+  /// Union assumed set with the passed value.
+  void unionAssumed(const MemberTy &C) { insert(C); }
+
+  /// Union assumed set with assumed set of the passed state \p PVS.
+  void unionAssumed(const PotentialValuesState &PVS) { unionWith(PVS); }
+
+  /// Union assumed set with an undef value.
+  void unionAssumedWithUndef() { unionWithUndef(); }
+
+  /// "Clamp" this state with \p PVS.
+  PotentialValuesState operator^=(const PotentialValuesState &PVS) {
+    IsValidState ^= PVS.IsValidState;
+    unionAssumed(PVS);
+    return *this;
+  }
+
+  PotentialValuesState operator&=(const PotentialValuesState &PVS) {
+    IsValidState &= PVS.IsValidState;
+    unionAssumed(PVS);
+    return *this;
+  }
+
+private:
+  /// Check the size of this set, and invalidate when the size is no
+  /// less than \p MaxPotentialValues threshold.
+  void checkAndInvalidate() {
+    if (Set.size() >= MaxPotentialValues)
+      indicatePessimisticFixpoint();
+  }
+
+  /// If this state contains both undef and not undef, we can reduce
+  /// undef to the not undef value.
+  void reduceUndefValue() { UndefIsContained = UndefIsContained & Set.empty(); }
+
+  /// Insert an element into this set.
+  void insert(const MemberTy &C) {
+    if (!isValidState())
+      return;
+    Set.insert(C);
+    checkAndInvalidate();
+  }
+
+  /// Take union with R.
+  void unionWith(const PotentialValuesState &R) {
+    /// If this is a full set, do nothing.;
+    if (!isValidState())
+      return;
+    /// If R is full set, change L to a full set.
+    if (!R.isValidState()) {
+      indicatePessimisticFixpoint();
+      return;
+    }
+    for (const MemberTy &C : R.Set)
+      Set.insert(C);
+    UndefIsContained |= R.undefIsContained();
+    reduceUndefValue();
+    checkAndInvalidate();
+  }
+
+  /// Take union with an undef value.
+  void unionWithUndef() {
+    UndefIsContained = true;
+    reduceUndefValue();
+  }
+
+  /// Take intersection with R.
+  void intersectWith(const PotentialValuesState &R) {
+    /// If R is a full set, do nothing.
+    if (!R.isValidState())
+      return;
+    /// If this is a full set, change this to R.
+    if (!isValidState()) {
+      *this = R;
+      return;
+    }
+    SetTy IntersectSet;
+    for (const MemberTy &C : Set) {
+      if (R.Set.count(C))
+        IntersectSet.insert(C);
+    }
+    Set = IntersectSet;
+    UndefIsContained &= R.undefIsContained();
+    reduceUndefValue();
+  }
+
+  /// A helper state which indicate whether this state is valid or not.
+  BooleanState IsValidState;
+
+  /// Container for potential values
+  SetTy Set;
+
+  /// Flag for undef value
+  bool UndefIsContained;
+};
+
+using PotentialConstantIntValuesState = PotentialValuesState<APInt>;
+
+raw_ostream &operator<<(raw_ostream &OS,
+                        const PotentialConstantIntValuesState &R);
+
+/// An abstract interface for potential values analysis.
+///
+/// This AA collects potential values for each IR position.
+/// An assumed set of potential values is initialized with the empty set (the
+/// best state) and it will grow monotonically as we find more potential values
+/// for this position.
+/// The set might be forced to the worst state, that is, to contain every
+/// possible value for this position in 2 cases.
+///   1. We surpassed the \p MaxPotentialValues threshold. This includes the
+///      case that this position is affected (e.g. because of an operation) by a
+///      Value that is in the worst state.
+///   2. We tried to initialize on a Value that we cannot handle (e.g. an
+///      operator we do not currently handle).
+///
+/// TODO: Support values other than constant integers.
+struct AAPotentialValues
+    : public StateWrapper<PotentialConstantIntValuesState, AbstractAttribute> {
+  using Base = StateWrapper<PotentialConstantIntValuesState, AbstractAttribute>;
+  AAPotentialValues(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
+
+  /// See AbstractAttribute::getState(...).
+  PotentialConstantIntValuesState &getState() override { return *this; }
+  const PotentialConstantIntValuesState &getState() const override {
+    return *this;
+  }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AAPotentialValues &createForPosition(const IRPosition &IRP,
+                                              Attributor &A);
+
+  /// Return assumed constant for the associated value
+  Optional<ConstantInt *>
+  getAssumedConstantInt(Attributor &A,
+                        const Instruction *CtxI = nullptr) const {
+    if (!isValidState())
+      return nullptr;
+    if (getAssumedSet().size() == 1)
+      return cast<ConstantInt>(ConstantInt::get(getAssociatedValue().getType(),
+                                                *(getAssumedSet().begin())));
+    if (getAssumedSet().size() == 0) {
+      if (undefIsContained())
+        return cast<ConstantInt>(
+            ConstantInt::get(getAssociatedValue().getType(), 0));
+      return llvm::None;
+    }
+
+    return nullptr;
+  }
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AAPotentialValues"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is
+  /// AAPotentialValues
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
+/// An abstract interface for all noundef attributes.
+struct AANoUndef
+    : public IRAttribute<Attribute::NoUndef,
+                         StateWrapper<BooleanState, AbstractAttribute>> {
+  AANoUndef(const IRPosition &IRP, Attributor &A) : IRAttribute(IRP) {}
+
+  /// Return true if we assume that the underlying value is noundef.
+  bool isAssumedNoUndef() const { return getAssumed(); }
+
+  /// Return true if we know that underlying value is noundef.
+  bool isKnownNoUndef() const { return getKnown(); }
+
+  /// Create an abstract attribute view for the position \p IRP.
+  static AANoUndef &createForPosition(const IRPosition &IRP, Attributor &A);
+
+  /// See AbstractAttribute::getName()
+  const std::string getName() const override { return "AANoUndef"; }
+
+  /// See AbstractAttribute::getIdAddr()
+  const char *getIdAddr() const override { return &ID; }
+
+  /// This function should return true if the type of the \p AA is AANoUndef
+  static bool classof(const AbstractAttribute *AA) {
+    return (AA->getIdAddr() == &ID);
+  }
+
+  /// Unique ID (due to the unique address)
+  static const char ID;
+};
+
 /// Run options, used by the pass manager.
 enum AttributorRunOption {
   NONE = 0,
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/BlockExtractor.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/BlockExtractor.h
index 937c1cbb39..10ac54d79d 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/BlockExtractor.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/BlockExtractor.h
@@ -1,36 +1,36 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- BlockExtractor.h - Extracts blocks into their own functions --------===// 
-// 
-// 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 extracts the specified basic blocks from the module into their 
-// own functions. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H 
-#define LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
-struct BlockExtractorPass : PassInfoMixin<BlockExtractorPass> { 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
-} // namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- BlockExtractor.h - Extracts blocks into their own functions --------===//
+//
+// 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 extracts the specified basic blocks from the module into their
+// own functions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
+#define LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+struct BlockExtractorPass : PassInfoMixin<BlockExtractorPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_BLOCKEXTRACTOR_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/IROutliner.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/IROutliner.h
index bb1f1beb5a..0b90589079 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/IROutliner.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/IROutliner.h
@@ -1,369 +1,369 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- IROutliner.h - Extract similar IR regions into functions ------------==// 
-// 
-// 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 
-// The interface file for the IROutliner which is used by the IROutliner Pass. 
-// 
-// The outliner uses the IRSimilarityIdentifier to identify the similar regions 
-// of code.  It evaluates each set of IRSimilarityCandidates with an estimate of 
-// whether it will provide code size reduction.  Each region is extracted using 
-// the code extractor.  These extracted functions are consolidated into a single 
-// function and called from the extracted call site. 
-// 
-// For example: 
-// \code 
-//   %1 = add i32 %a, %b 
-//   %2 = add i32 %b, %a 
-//   %3 = add i32 %b, %a 
-//   %4 = add i32 %a, %b 
-// \endcode 
-// would become function 
-// \code 
-// define internal void outlined_ir_function(i32 %0, i32 %1) { 
-//   %1 = add i32 %0, %1 
-//   %2 = add i32 %1, %0 
-//   ret void 
-// } 
-// \endcode 
-// with calls: 
-// \code 
-//   call void outlined_ir_function(i32 %a, i32 %b) 
-//   call void outlined_ir_function(i32 %b, i32 %a) 
-// \endcode 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_IROUTLINER_H 
-#define LLVM_TRANSFORMS_IPO_IROUTLINER_H 
- 
-#include "llvm/Analysis/IRSimilarityIdentifier.h" 
-#include "llvm/IR/PassManager.h" 
-#include "llvm/IR/ValueMap.h" 
-#include "llvm/Support/InstructionCost.h" 
-#include "llvm/Transforms/Utils/CodeExtractor.h" 
-#include <set> 
- 
-struct OutlinableGroup; 
- 
-namespace llvm { 
-using namespace IRSimilarity; 
- 
-class Module; 
-class TargetTransformInfo; 
-class OptimizationRemarkEmitter; 
- 
-/// The OutlinableRegion holds all the information for a specific region, or 
-/// sequence of instructions. This includes what values need to be hoisted to 
-/// arguments from the extracted function, inputs and outputs to the region, and 
-/// mapping from the extracted function arguments to overall function arguments. 
-struct OutlinableRegion { 
-  /// Describes the region of code. 
-  IRSimilarityCandidate *Candidate; 
- 
-  /// If this region is outlined, the front and back IRInstructionData could 
-  /// potentially become invalidated if the only new instruction is a call. 
-  /// This ensures that we replace in the instruction in the IRInstructionData. 
-  IRInstructionData *NewFront = nullptr; 
-  IRInstructionData *NewBack = nullptr; 
- 
-  /// The number of extracted inputs from the CodeExtractor. 
-  unsigned NumExtractedInputs; 
- 
-  /// The corresponding BasicBlock with the appropriate stores for this 
-  /// OutlinableRegion in the overall function. 
-  unsigned OutputBlockNum; 
- 
-  /// Mapping the extracted argument number to the argument number in the 
-  /// overall function.  Since there will be inputs, such as elevated constants 
-  /// that are not the same in each region in a SimilarityGroup, or values that 
-  /// cannot be sunk into the extracted section in every region, we must keep 
-  /// track of which extracted argument maps to which overall argument. 
-  DenseMap<unsigned, unsigned> ExtractedArgToAgg; 
-  DenseMap<unsigned, unsigned> AggArgToExtracted; 
- 
-  /// Mapping of the argument number in the deduplicated function 
-  /// to a given constant, which is used when creating the arguments to the call 
-  /// to the newly created deduplicated function.  This is handled separately 
-  /// since the CodeExtractor does not recognize constants. 
-  DenseMap<unsigned, Constant *> AggArgToConstant; 
- 
-  /// The global value numbers that are used as outputs for this section. Once 
-  /// extracted, each output will be stored to an output register.  This 
-  /// documents the global value numbers that are used in this pattern. 
-  SmallVector<unsigned, 4> GVNStores; 
- 
-  /// Used to create an outlined function. 
-  CodeExtractor *CE = nullptr; 
- 
-  /// The call site of the extracted region. 
-  CallInst *Call = nullptr; 
- 
-  /// The function for the extracted region. 
-  Function *ExtractedFunction = nullptr; 
- 
-  /// Flag for whether we have split out the IRSimilarityCanidate. That is, 
-  /// make the region contained the IRSimilarityCandidate its own BasicBlock. 
-  bool CandidateSplit = false; 
- 
-  /// Flag for whether we should not consider this region for extraction. 
-  bool IgnoreRegion = false; 
- 
-  /// The BasicBlock that is before the start of the region BasicBlock, 
-  /// only defined when the region has been split. 
-  BasicBlock *PrevBB = nullptr; 
- 
-  /// The BasicBlock that contains the starting instruction of the region. 
-  BasicBlock *StartBB = nullptr; 
- 
-  /// The BasicBlock that contains the ending instruction of the region. 
-  BasicBlock *EndBB = nullptr; 
- 
-  /// The BasicBlock that is after the start of the region BasicBlock, 
-  /// only defined when the region has been split. 
-  BasicBlock *FollowBB = nullptr; 
- 
-  /// The Outlinable Group that contains this region and structurally similar 
-  /// regions to this region. 
-  OutlinableGroup *Parent = nullptr; 
- 
-  OutlinableRegion(IRSimilarityCandidate &C, OutlinableGroup &Group) 
-      : Candidate(&C), Parent(&Group) { 
-    StartBB = C.getStartBB(); 
-    EndBB = C.getEndBB(); 
-  } 
- 
-  /// For the contained region, split the parent BasicBlock at the starting and 
-  /// ending instructions of the contained IRSimilarityCandidate. 
-  void splitCandidate(); 
- 
-  /// For the contained region, reattach the BasicBlock at the starting and 
-  /// ending instructions of the contained IRSimilarityCandidate, or if the 
-  /// function has been extracted, the start and end of the BasicBlock 
-  /// containing the called function. 
-  void reattachCandidate(); 
- 
-  /// Get the size of the code removed from the region. 
-  /// 
-  /// \param [in] TTI - The TargetTransformInfo for the parent function. 
-  /// \returns the code size of the region 
-  InstructionCost getBenefit(TargetTransformInfo &TTI); 
-}; 
- 
-/// This class is a pass that identifies similarity in a Module, extracts 
-/// instances of the similarity, and then consolidating the similar regions 
-/// in an effort to reduce code size.  It uses the IRSimilarityIdentifier pass 
-/// to identify the similar regions of code, and then extracts the similar 
-/// sections into a single function.  See the above for an example as to 
-/// how code is extracted and consolidated into a single function. 
-class IROutliner { 
-public: 
-  IROutliner(function_ref<TargetTransformInfo &(Function &)> GTTI, 
-             function_ref<IRSimilarityIdentifier &(Module &)> GIRSI, 
-             function_ref<OptimizationRemarkEmitter &(Function &)> GORE) 
-      : getTTI(GTTI), getIRSI(GIRSI), getORE(GORE) {} 
-  bool run(Module &M); 
- 
-private: 
-  /// Find repeated similar code sequences in \p M and outline them into new 
-  /// Functions. 
-  /// 
-  /// \param [in] M - The module to outline from. 
-  /// \returns The number of Functions created. 
-  unsigned doOutline(Module &M); 
- 
-  /// Remove all the IRSimilarityCandidates from \p CandidateVec that have 
-  /// instructions contained in a previously outlined region and put the 
-  /// remaining regions in \p CurrentGroup. 
-  /// 
-  /// \param [in] CandidateVec - List of similarity candidates for regions with 
-  /// the same similarity structure. 
-  /// \param [in,out] CurrentGroup - Contains the potential sections to 
-  /// be outlined. 
-  void 
-  pruneIncompatibleRegions(std::vector<IRSimilarityCandidate> &CandidateVec, 
-                           OutlinableGroup &CurrentGroup); 
- 
-  /// Create the function based on the overall types found in the current 
-  /// regions being outlined. 
-  /// 
-  /// \param M - The module to outline from. 
-  /// \param [in,out] CG - The OutlinableGroup for the regions to be outlined. 
-  /// \param [in] FunctionNameSuffix - How many functions have we previously 
-  /// created. 
-  /// \returns the newly created function. 
-  Function *createFunction(Module &M, OutlinableGroup &CG, 
-                           unsigned FunctionNameSuffix); 
- 
-  /// Identify the needed extracted inputs in a section, and add to the overall 
-  /// function if needed. 
-  /// 
-  /// \param [in] M - The module to outline from. 
-  /// \param [in,out] Region - The region to be extracted. 
-  /// \param [in] NotSame - The global value numbers of the Values in the region 
-  /// that do not have the same Constant in each strucutrally similar region. 
-  void findAddInputsOutputs(Module &M, OutlinableRegion &Region, 
-                            DenseSet<unsigned> &NotSame); 
- 
-  /// Find the number of instructions that will be removed by extracting the 
-  /// OutlinableRegions in \p CurrentGroup. 
-  /// 
-  /// \param [in] CurrentGroup - The collection of OutlinableRegions to be 
-  /// analyzed. 
-  /// \returns the number of outlined instructions across all regions. 
-  InstructionCost findBenefitFromAllRegions(OutlinableGroup &CurrentGroup); 
- 
-  /// Find the number of instructions that will be added by reloading arguments. 
-  /// 
-  /// \param [in] CurrentGroup - The collection of OutlinableRegions to be 
-  /// analyzed. 
-  /// \returns the number of added reload instructions across all regions. 
-  InstructionCost findCostOutputReloads(OutlinableGroup &CurrentGroup); 
- 
-  /// Find the cost and the benefit of \p CurrentGroup and save it back to 
-  /// \p CurrentGroup. 
-  /// 
-  /// \param [in] M - The module being analyzed 
-  /// \param [in,out] CurrentGroup - The overall outlined section 
-  void findCostBenefit(Module &M, OutlinableGroup &CurrentGroup); 
- 
-  /// Update the output mapping based on the load instruction, and the outputs 
-  /// of the extracted function. 
-  /// 
-  /// \param Region - The region extracted 
-  /// \param Outputs - The outputs from the extracted function. 
-  /// \param LI - The load instruction used to update the mapping. 
-  void updateOutputMapping(OutlinableRegion &Region, 
-                           ArrayRef<Value *> Outputs, LoadInst *LI); 
- 
-  /// Extract \p Region into its own function. 
-  /// 
-  /// \param [in] Region - The region to be extracted into its own function. 
-  /// \returns True if it was successfully outlined. 
-  bool extractSection(OutlinableRegion &Region); 
- 
-  /// For the similarities found, and the extracted sections, create a single 
-  /// outlined function with appropriate output blocks as necessary. 
-  /// 
-  /// \param [in] M - The module to outline from 
-  /// \param [in] CurrentGroup - The set of extracted sections to consolidate. 
-  /// \param [in,out] FuncsToRemove - List of functions to remove from the 
-  /// module after outlining is completed. 
-  /// \param [in,out] OutlinedFunctionNum - the number of new outlined 
-  /// functions. 
-  void deduplicateExtractedSections(Module &M, OutlinableGroup &CurrentGroup, 
-                                    std::vector<Function *> &FuncsToRemove, 
-                                    unsigned &OutlinedFunctionNum); 
- 
-  /// If true, enables us to outline from functions that have LinkOnceFromODR 
-  /// linkages. 
-  bool OutlineFromLinkODRs = false; 
- 
-  /// If false, we do not worry if the cost is greater than the benefit.  This 
-  /// is for debugging and testing, so that we can test small cases to ensure 
-  /// that the outlining is being done correctly. 
-  bool CostModel = true; 
- 
-  /// The set of outlined Instructions, identified by their location in the 
-  /// sequential ordering of instructions in a Module. 
-  DenseSet<unsigned> Outlined; 
- 
-  /// TargetTransformInfo lambda for target specific information. 
-  function_ref<TargetTransformInfo &(Function &)> getTTI; 
- 
-  /// A mapping from newly created reloaded output values to the original value. 
-  /// If an value is replace by an output from an outlined region, this maps 
-  /// that Value, back to its original Value. 
-  DenseMap<Value *, Value *> OutputMappings; 
- 
-  /// IRSimilarityIdentifier lambda to retrieve IRSimilarityIdentifier. 
-  function_ref<IRSimilarityIdentifier &(Module &)> getIRSI; 
- 
-  /// The optimization remark emitter for the pass. 
-  function_ref<OptimizationRemarkEmitter &(Function &)> getORE; 
- 
-  /// The memory allocator used to allocate the CodeExtractors. 
-  SpecificBumpPtrAllocator<CodeExtractor> ExtractorAllocator; 
- 
-  /// The memory allocator used to allocate the OutlinableRegions. 
-  SpecificBumpPtrAllocator<OutlinableRegion> RegionAllocator; 
- 
-  /// The memory allocator used to allocate new IRInstructionData. 
-  SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator; 
- 
-  /// Custom InstVisitor to classify different instructions for whether it can 
-  /// be analyzed for similarity.  This is needed as there may be instruction we 
-  /// can identify as having similarity, but are more complicated to outline. 
-  struct InstructionAllowed : public InstVisitor<InstructionAllowed, bool> { 
-    InstructionAllowed() {} 
- 
-    // TODO: Determine a scheme to resolve when the label is similar enough. 
-    bool visitBranchInst(BranchInst &BI) { return false; } 
-    // TODO: Determine a scheme to resolve when the labels are similar enough. 
-    bool visitPHINode(PHINode &PN) { return false; } 
-    // TODO: Handle allocas. 
-    bool visitAllocaInst(AllocaInst &AI) { return false; } 
-    // VAArg instructions are not allowed since this could cause difficulty when 
-    // differentiating between different sets of variable instructions in 
-    // the deduplicated outlined regions. 
-    bool visitVAArgInst(VAArgInst &VI) { return false; } 
-    // We exclude all exception handling cases since they are so context 
-    // dependent. 
-    bool visitLandingPadInst(LandingPadInst &LPI) { return false; } 
-    bool visitFuncletPadInst(FuncletPadInst &FPI) { return false; } 
-    // DebugInfo should be included in the regions, but should not be 
-    // analyzed for similarity as it has no bearing on the outcome of the 
-    // program. 
-    bool visitDbgInfoIntrinsic(DbgInfoIntrinsic &DII) { return true; } 
-    // TODO: Handle specific intrinsics individually from those that can be 
-    // handled. 
-    bool IntrinsicInst(IntrinsicInst &II) { return false; } 
-    // We only handle CallInsts that are not indirect, since we cannot guarantee 
-    // that they have a name in these cases. 
-    bool visitCallInst(CallInst &CI) { 
-      Function *F = CI.getCalledFunction(); 
-      if (!F || CI.isIndirectCall() || !F->hasName()) 
-        return false; 
-      return true; 
-    } 
-    // TODO: Handle FreezeInsts.  Since a frozen value could be frozen inside 
-    // the outlined region, and then returned as an output, this will have to be 
-    // handled differently. 
-    bool visitFreezeInst(FreezeInst &CI) { return false; } 
-    // TODO: We do not current handle similarity that changes the control flow. 
-    bool visitInvokeInst(InvokeInst &II) { return false; } 
-    // TODO: We do not current handle similarity that changes the control flow. 
-    bool visitCallBrInst(CallBrInst &CBI) { return false; } 
-    // TODO: Handle interblock similarity. 
-    bool visitTerminator(Instruction &I) { return false; } 
-    bool visitInstruction(Instruction &I) { return true; } 
-  }; 
- 
-  /// A InstVisitor used to exclude certain instructions from being outlined. 
-  InstructionAllowed InstructionClassifier; 
-}; 
- 
-/// Pass to outline similar regions. 
-class IROutlinerPass : public PassInfoMixin<IROutlinerPass> { 
-public: 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_IPO_IROUTLINER_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- IROutliner.h - Extract similar IR regions into functions ------------==//
+//
+// 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
+// The interface file for the IROutliner which is used by the IROutliner Pass.
+//
+// The outliner uses the IRSimilarityIdentifier to identify the similar regions
+// of code.  It evaluates each set of IRSimilarityCandidates with an estimate of
+// whether it will provide code size reduction.  Each region is extracted using
+// the code extractor.  These extracted functions are consolidated into a single
+// function and called from the extracted call site.
+//
+// For example:
+// \code
+//   %1 = add i32 %a, %b
+//   %2 = add i32 %b, %a
+//   %3 = add i32 %b, %a
+//   %4 = add i32 %a, %b
+// \endcode
+// would become function
+// \code
+// define internal void outlined_ir_function(i32 %0, i32 %1) {
+//   %1 = add i32 %0, %1
+//   %2 = add i32 %1, %0
+//   ret void
+// }
+// \endcode
+// with calls:
+// \code
+//   call void outlined_ir_function(i32 %a, i32 %b)
+//   call void outlined_ir_function(i32 %b, i32 %a)
+// \endcode
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_IROUTLINER_H
+#define LLVM_TRANSFORMS_IPO_IROUTLINER_H
+
+#include "llvm/Analysis/IRSimilarityIdentifier.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/ValueMap.h"
+#include "llvm/Support/InstructionCost.h"
+#include "llvm/Transforms/Utils/CodeExtractor.h"
+#include <set>
+
+struct OutlinableGroup;
+
+namespace llvm {
+using namespace IRSimilarity;
+
+class Module;
+class TargetTransformInfo;
+class OptimizationRemarkEmitter;
+
+/// The OutlinableRegion holds all the information for a specific region, or
+/// sequence of instructions. This includes what values need to be hoisted to
+/// arguments from the extracted function, inputs and outputs to the region, and
+/// mapping from the extracted function arguments to overall function arguments.
+struct OutlinableRegion {
+  /// Describes the region of code.
+  IRSimilarityCandidate *Candidate;
+
+  /// If this region is outlined, the front and back IRInstructionData could
+  /// potentially become invalidated if the only new instruction is a call.
+  /// This ensures that we replace in the instruction in the IRInstructionData.
+  IRInstructionData *NewFront = nullptr;
+  IRInstructionData *NewBack = nullptr;
+
+  /// The number of extracted inputs from the CodeExtractor.
+  unsigned NumExtractedInputs;
+
+  /// The corresponding BasicBlock with the appropriate stores for this
+  /// OutlinableRegion in the overall function.
+  unsigned OutputBlockNum;
+
+  /// Mapping the extracted argument number to the argument number in the
+  /// overall function.  Since there will be inputs, such as elevated constants
+  /// that are not the same in each region in a SimilarityGroup, or values that
+  /// cannot be sunk into the extracted section in every region, we must keep
+  /// track of which extracted argument maps to which overall argument.
+  DenseMap<unsigned, unsigned> ExtractedArgToAgg;
+  DenseMap<unsigned, unsigned> AggArgToExtracted;
+
+  /// Mapping of the argument number in the deduplicated function
+  /// to a given constant, which is used when creating the arguments to the call
+  /// to the newly created deduplicated function.  This is handled separately
+  /// since the CodeExtractor does not recognize constants.
+  DenseMap<unsigned, Constant *> AggArgToConstant;
+
+  /// The global value numbers that are used as outputs for this section. Once
+  /// extracted, each output will be stored to an output register.  This
+  /// documents the global value numbers that are used in this pattern.
+  SmallVector<unsigned, 4> GVNStores;
+
+  /// Used to create an outlined function.
+  CodeExtractor *CE = nullptr;
+
+  /// The call site of the extracted region.
+  CallInst *Call = nullptr;
+
+  /// The function for the extracted region.
+  Function *ExtractedFunction = nullptr;
+
+  /// Flag for whether we have split out the IRSimilarityCanidate. That is,
+  /// make the region contained the IRSimilarityCandidate its own BasicBlock.
+  bool CandidateSplit = false;
+
+  /// Flag for whether we should not consider this region for extraction.
+  bool IgnoreRegion = false;
+
+  /// The BasicBlock that is before the start of the region BasicBlock,
+  /// only defined when the region has been split.
+  BasicBlock *PrevBB = nullptr;
+
+  /// The BasicBlock that contains the starting instruction of the region.
+  BasicBlock *StartBB = nullptr;
+
+  /// The BasicBlock that contains the ending instruction of the region.
+  BasicBlock *EndBB = nullptr;
+
+  /// The BasicBlock that is after the start of the region BasicBlock,
+  /// only defined when the region has been split.
+  BasicBlock *FollowBB = nullptr;
+
+  /// The Outlinable Group that contains this region and structurally similar
+  /// regions to this region.
+  OutlinableGroup *Parent = nullptr;
+
+  OutlinableRegion(IRSimilarityCandidate &C, OutlinableGroup &Group)
+      : Candidate(&C), Parent(&Group) {
+    StartBB = C.getStartBB();
+    EndBB = C.getEndBB();
+  }
+
+  /// For the contained region, split the parent BasicBlock at the starting and
+  /// ending instructions of the contained IRSimilarityCandidate.
+  void splitCandidate();
+
+  /// For the contained region, reattach the BasicBlock at the starting and
+  /// ending instructions of the contained IRSimilarityCandidate, or if the
+  /// function has been extracted, the start and end of the BasicBlock
+  /// containing the called function.
+  void reattachCandidate();
+
+  /// Get the size of the code removed from the region.
+  ///
+  /// \param [in] TTI - The TargetTransformInfo for the parent function.
+  /// \returns the code size of the region
+  InstructionCost getBenefit(TargetTransformInfo &TTI);
+};
+
+/// This class is a pass that identifies similarity in a Module, extracts
+/// instances of the similarity, and then consolidating the similar regions
+/// in an effort to reduce code size.  It uses the IRSimilarityIdentifier pass
+/// to identify the similar regions of code, and then extracts the similar
+/// sections into a single function.  See the above for an example as to
+/// how code is extracted and consolidated into a single function.
+class IROutliner {
+public:
+  IROutliner(function_ref<TargetTransformInfo &(Function &)> GTTI,
+             function_ref<IRSimilarityIdentifier &(Module &)> GIRSI,
+             function_ref<OptimizationRemarkEmitter &(Function &)> GORE)
+      : getTTI(GTTI), getIRSI(GIRSI), getORE(GORE) {}
+  bool run(Module &M);
+
+private:
+  /// Find repeated similar code sequences in \p M and outline them into new
+  /// Functions.
+  ///
+  /// \param [in] M - The module to outline from.
+  /// \returns The number of Functions created.
+  unsigned doOutline(Module &M);
+
+  /// Remove all the IRSimilarityCandidates from \p CandidateVec that have
+  /// instructions contained in a previously outlined region and put the
+  /// remaining regions in \p CurrentGroup.
+  ///
+  /// \param [in] CandidateVec - List of similarity candidates for regions with
+  /// the same similarity structure.
+  /// \param [in,out] CurrentGroup - Contains the potential sections to
+  /// be outlined.
+  void
+  pruneIncompatibleRegions(std::vector<IRSimilarityCandidate> &CandidateVec,
+                           OutlinableGroup &CurrentGroup);
+
+  /// Create the function based on the overall types found in the current
+  /// regions being outlined.
+  ///
+  /// \param M - The module to outline from.
+  /// \param [in,out] CG - The OutlinableGroup for the regions to be outlined.
+  /// \param [in] FunctionNameSuffix - How many functions have we previously
+  /// created.
+  /// \returns the newly created function.
+  Function *createFunction(Module &M, OutlinableGroup &CG,
+                           unsigned FunctionNameSuffix);
+
+  /// Identify the needed extracted inputs in a section, and add to the overall
+  /// function if needed.
+  ///
+  /// \param [in] M - The module to outline from.
+  /// \param [in,out] Region - The region to be extracted.
+  /// \param [in] NotSame - The global value numbers of the Values in the region
+  /// that do not have the same Constant in each strucutrally similar region.
+  void findAddInputsOutputs(Module &M, OutlinableRegion &Region,
+                            DenseSet<unsigned> &NotSame);
+
+  /// Find the number of instructions that will be removed by extracting the
+  /// OutlinableRegions in \p CurrentGroup.
+  ///
+  /// \param [in] CurrentGroup - The collection of OutlinableRegions to be
+  /// analyzed.
+  /// \returns the number of outlined instructions across all regions.
+  InstructionCost findBenefitFromAllRegions(OutlinableGroup &CurrentGroup);
+
+  /// Find the number of instructions that will be added by reloading arguments.
+  ///
+  /// \param [in] CurrentGroup - The collection of OutlinableRegions to be
+  /// analyzed.
+  /// \returns the number of added reload instructions across all regions.
+  InstructionCost findCostOutputReloads(OutlinableGroup &CurrentGroup);
+
+  /// Find the cost and the benefit of \p CurrentGroup and save it back to
+  /// \p CurrentGroup.
+  ///
+  /// \param [in] M - The module being analyzed
+  /// \param [in,out] CurrentGroup - The overall outlined section
+  void findCostBenefit(Module &M, OutlinableGroup &CurrentGroup);
+
+  /// Update the output mapping based on the load instruction, and the outputs
+  /// of the extracted function.
+  ///
+  /// \param Region - The region extracted
+  /// \param Outputs - The outputs from the extracted function.
+  /// \param LI - The load instruction used to update the mapping.
+  void updateOutputMapping(OutlinableRegion &Region,
+                           ArrayRef<Value *> Outputs, LoadInst *LI);
+
+  /// Extract \p Region into its own function.
+  ///
+  /// \param [in] Region - The region to be extracted into its own function.
+  /// \returns True if it was successfully outlined.
+  bool extractSection(OutlinableRegion &Region);
+
+  /// For the similarities found, and the extracted sections, create a single
+  /// outlined function with appropriate output blocks as necessary.
+  ///
+  /// \param [in] M - The module to outline from
+  /// \param [in] CurrentGroup - The set of extracted sections to consolidate.
+  /// \param [in,out] FuncsToRemove - List of functions to remove from the
+  /// module after outlining is completed.
+  /// \param [in,out] OutlinedFunctionNum - the number of new outlined
+  /// functions.
+  void deduplicateExtractedSections(Module &M, OutlinableGroup &CurrentGroup,
+                                    std::vector<Function *> &FuncsToRemove,
+                                    unsigned &OutlinedFunctionNum);
+
+  /// If true, enables us to outline from functions that have LinkOnceFromODR
+  /// linkages.
+  bool OutlineFromLinkODRs = false;
+
+  /// If false, we do not worry if the cost is greater than the benefit.  This
+  /// is for debugging and testing, so that we can test small cases to ensure
+  /// that the outlining is being done correctly.
+  bool CostModel = true;
+
+  /// The set of outlined Instructions, identified by their location in the
+  /// sequential ordering of instructions in a Module.
+  DenseSet<unsigned> Outlined;
+
+  /// TargetTransformInfo lambda for target specific information.
+  function_ref<TargetTransformInfo &(Function &)> getTTI;
+
+  /// A mapping from newly created reloaded output values to the original value.
+  /// If an value is replace by an output from an outlined region, this maps
+  /// that Value, back to its original Value.
+  DenseMap<Value *, Value *> OutputMappings;
+
+  /// IRSimilarityIdentifier lambda to retrieve IRSimilarityIdentifier.
+  function_ref<IRSimilarityIdentifier &(Module &)> getIRSI;
+
+  /// The optimization remark emitter for the pass.
+  function_ref<OptimizationRemarkEmitter &(Function &)> getORE;
+
+  /// The memory allocator used to allocate the CodeExtractors.
+  SpecificBumpPtrAllocator<CodeExtractor> ExtractorAllocator;
+
+  /// The memory allocator used to allocate the OutlinableRegions.
+  SpecificBumpPtrAllocator<OutlinableRegion> RegionAllocator;
+
+  /// The memory allocator used to allocate new IRInstructionData.
+  SpecificBumpPtrAllocator<IRInstructionData> InstDataAllocator;
+
+  /// Custom InstVisitor to classify different instructions for whether it can
+  /// be analyzed for similarity.  This is needed as there may be instruction we
+  /// can identify as having similarity, but are more complicated to outline.
+  struct InstructionAllowed : public InstVisitor<InstructionAllowed, bool> {
+    InstructionAllowed() {}
+
+    // TODO: Determine a scheme to resolve when the label is similar enough.
+    bool visitBranchInst(BranchInst &BI) { return false; }
+    // TODO: Determine a scheme to resolve when the labels are similar enough.
+    bool visitPHINode(PHINode &PN) { return false; }
+    // TODO: Handle allocas.
+    bool visitAllocaInst(AllocaInst &AI) { return false; }
+    // VAArg instructions are not allowed since this could cause difficulty when
+    // differentiating between different sets of variable instructions in
+    // the deduplicated outlined regions.
+    bool visitVAArgInst(VAArgInst &VI) { return false; }
+    // We exclude all exception handling cases since they are so context
+    // dependent.
+    bool visitLandingPadInst(LandingPadInst &LPI) { return false; }
+    bool visitFuncletPadInst(FuncletPadInst &FPI) { return false; }
+    // DebugInfo should be included in the regions, but should not be
+    // analyzed for similarity as it has no bearing on the outcome of the
+    // program.
+    bool visitDbgInfoIntrinsic(DbgInfoIntrinsic &DII) { return true; }
+    // TODO: Handle specific intrinsics individually from those that can be
+    // handled.
+    bool IntrinsicInst(IntrinsicInst &II) { return false; }
+    // We only handle CallInsts that are not indirect, since we cannot guarantee
+    // that they have a name in these cases.
+    bool visitCallInst(CallInst &CI) {
+      Function *F = CI.getCalledFunction();
+      if (!F || CI.isIndirectCall() || !F->hasName())
+        return false;
+      return true;
+    }
+    // TODO: Handle FreezeInsts.  Since a frozen value could be frozen inside
+    // the outlined region, and then returned as an output, this will have to be
+    // handled differently.
+    bool visitFreezeInst(FreezeInst &CI) { return false; }
+    // TODO: We do not current handle similarity that changes the control flow.
+    bool visitInvokeInst(InvokeInst &II) { return false; }
+    // TODO: We do not current handle similarity that changes the control flow.
+    bool visitCallBrInst(CallBrInst &CBI) { return false; }
+    // TODO: Handle interblock similarity.
+    bool visitTerminator(Instruction &I) { return false; }
+    bool visitInstruction(Instruction &I) { return true; }
+  };
+
+  /// A InstVisitor used to exclude certain instructions from being outlined.
+  InstructionAllowed InstructionClassifier;
+};
+
+/// Pass to outline similar regions.
+class IROutlinerPass : public PassInfoMixin<IROutlinerPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_IROUTLINER_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/Inliner.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/Inliner.h
index a5b5934b73..2430425c60 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/Inliner.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/Inliner.h
@@ -21,8 +21,8 @@
 #include "llvm/Analysis/InlineAdvisor.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/LazyCallGraph.h"
-#include "llvm/Analysis/ReplayInlineAdvisor.h" 
-#include "llvm/Analysis/Utils/ImportedFunctionsInliningStatistics.h" 
+#include "llvm/Analysis/ReplayInlineAdvisor.h"
+#include "llvm/Analysis/Utils/ImportedFunctionsInliningStatistics.h"
 #include "llvm/IR/PassManager.h"
 #include <utility>
 
@@ -104,8 +104,8 @@ protected:
 /// passes be composed to achieve the same end result.
 class InlinerPass : public PassInfoMixin<InlinerPass> {
 public:
-  InlinerPass(bool OnlyMandatory = false) : OnlyMandatory(OnlyMandatory) {} 
-  InlinerPass(InlinerPass &&Arg) = default; 
+  InlinerPass(bool OnlyMandatory = false) : OnlyMandatory(OnlyMandatory) {}
+  InlinerPass(InlinerPass &&Arg) = default;
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR);
@@ -113,8 +113,8 @@ public:
 private:
   InlineAdvisor &getAdvisor(const ModuleAnalysisManagerCGSCCProxy::Result &MAM,
                             FunctionAnalysisManager &FAM, Module &M);
-  std::unique_ptr<InlineAdvisor> OwnedAdvisor; 
-  const bool OnlyMandatory; 
+  std::unique_ptr<InlineAdvisor> OwnedAdvisor;
+  const bool OnlyMandatory;
 };
 
 /// Module pass, wrapping the inliner pass. This works in conjunction with the
@@ -127,7 +127,7 @@ class ModuleInlinerWrapperPass
 public:
   ModuleInlinerWrapperPass(
       InlineParams Params = getInlineParams(), bool Debugging = false,
-      bool MandatoryFirst = true, 
+      bool MandatoryFirst = true,
       InliningAdvisorMode Mode = InliningAdvisorMode::Default,
       unsigned MaxDevirtIterations = 0);
   ModuleInlinerWrapperPass(ModuleInlinerWrapperPass &&Arg) = default;
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/LoopExtractor.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/LoopExtractor.h
index 3b721a1279..ede8250980 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/LoopExtractor.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/LoopExtractor.h
@@ -1,43 +1,43 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- LoopExtractor.h - Extract each loop into a new function ------------===// 
-// 
-// 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 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// A pass wrapper around the ExtractLoop() scalar transformation to extract each 
-// top-level loop into its own new function. If the loop is the ONLY loop in a 
-// given function, it is not touched. This is a pass most useful for debugging 
-// via bugpoint. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H 
-#define LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-struct LoopExtractorPass : public PassInfoMixin<LoopExtractorPass> { 
-  LoopExtractorPass(unsigned NumLoops = ~0) : NumLoops(NumLoops) {} 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
- 
-private: 
-  unsigned NumLoops; 
-}; 
-} // namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- LoopExtractor.h - Extract each loop into a new function ------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// A pass wrapper around the ExtractLoop() scalar transformation to extract each
+// top-level loop into its own new function. If the loop is the ONLY loop in a
+// given function, it is not touched. This is a pass most useful for debugging
+// via bugpoint.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H
+#define LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct LoopExtractorPass : public PassInfoMixin<LoopExtractorPass> {
+  LoopExtractorPass(unsigned NumLoops = ~0) : NumLoops(NumLoops) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+
+private:
+  unsigned NumLoops;
+};
+} // namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_LOOPEXTRACTOR_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/LowerTypeTests.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/LowerTypeTests.h
index 8ad2193588..40761ef91e 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/LowerTypeTests.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/LowerTypeTests.h
@@ -205,14 +205,14 @@ bool isJumpTableCanonical(Function *F);
 } // end namespace lowertypetests
 
 class LowerTypeTestsPass : public PassInfoMixin<LowerTypeTestsPass> {
-  bool UseCommandLine = false; 
- 
-  ModuleSummaryIndex *ExportSummary = nullptr; 
-  const ModuleSummaryIndex *ImportSummary = nullptr; 
-  bool DropTypeTests = true; 
- 
+  bool UseCommandLine = false;
+
+  ModuleSummaryIndex *ExportSummary = nullptr;
+  const ModuleSummaryIndex *ImportSummary = nullptr;
+  bool DropTypeTests = true;
+
 public:
-  LowerTypeTestsPass() : UseCommandLine(true) {} 
+  LowerTypeTestsPass() : UseCommandLine(true) {}
   LowerTypeTestsPass(ModuleSummaryIndex *ExportSummary,
                      const ModuleSummaryIndex *ImportSummary,
                      bool DropTypeTests = false)
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/OpenMPOpt.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/OpenMPOpt.h
index 76aff7eb6f..4e8071e60c 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/OpenMPOpt.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/OpenMPOpt.h
@@ -40,11 +40,11 @@ struct OpenMPInModule {
   bool isKnown() { return Value != OpenMP::UNKNOWN; }
   operator bool() { return Value != OpenMP::NOT_FOUND; }
 
-  /// Does this function \p F contain any OpenMP runtime calls? 
-  bool containsOMPRuntimeCalls(Function *F) const { 
-    return FuncsWithOMPRuntimeCalls.contains(F); 
-  } 
- 
+  /// Does this function \p F contain any OpenMP runtime calls?
+  bool containsOMPRuntimeCalls(Function *F) const {
+    return FuncsWithOMPRuntimeCalls.contains(F);
+  }
+
   /// Return the known kernels (=GPU entry points) in the module.
   SmallPtrSetImpl<Kernel> &getKernels() { return Kernels; }
 
@@ -54,11 +54,11 @@ struct OpenMPInModule {
 private:
   enum class OpenMP { FOUND, NOT_FOUND, UNKNOWN } Value = OpenMP::UNKNOWN;
 
-  friend bool containsOpenMP(Module &M, OpenMPInModule &OMPInModule); 
- 
-  /// In which functions are OpenMP runtime calls present? 
-  SmallPtrSet<Function *, 32> FuncsWithOMPRuntimeCalls; 
- 
+  friend bool containsOpenMP(Module &M, OpenMPInModule &OMPInModule);
+
+  /// In which functions are OpenMP runtime calls present?
+  SmallPtrSet<Function *, 32> FuncsWithOMPRuntimeCalls;
+
   /// Collection of known kernels (=GPU entry points) in the module.
   SmallPtrSet<Kernel, 8> Kernels;
 };
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleContextTracker.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleContextTracker.h
index e5f5e5b737..11328fb5ac 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleContextTracker.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleContextTracker.h
@@ -1,163 +1,163 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- Transforms/IPO/SampleContextTracker.h --------------------*- 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 provides the interface for context-sensitive profile tracker used 
-/// by CSSPGO. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H 
-#define LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H 
- 
-#include "llvm/ADT/SmallSet.h" 
-#include "llvm/ADT/StringMap.h" 
-#include "llvm/ADT/StringRef.h" 
-#include "llvm/Analysis/CallGraph.h" 
-#include "llvm/IR/DebugInfoMetadata.h" 
-#include "llvm/IR/Instructions.h" 
-#include "llvm/ProfileData/SampleProf.h" 
-#include <list> 
-#include <map> 
-#include <vector> 
- 
-using namespace llvm; 
-using namespace sampleprof; 
- 
-namespace llvm { 
- 
-// Internal trie tree representation used for tracking context tree and sample 
-// profiles. The path from root node to a given node represents the context of 
-// that nodes' profile. 
-class ContextTrieNode { 
-public: 
-  ContextTrieNode(ContextTrieNode *Parent = nullptr, 
-                  StringRef FName = StringRef(), 
-                  FunctionSamples *FSamples = nullptr, 
-                  LineLocation CallLoc = {0, 0}) 
-      : ParentContext(Parent), FuncName(FName), FuncSamples(FSamples), 
-        CallSiteLoc(CallLoc){}; 
-  ContextTrieNode *getChildContext(const LineLocation &CallSite, 
-                                   StringRef CalleeName); 
-  ContextTrieNode *getHottestChildContext(const LineLocation &CallSite); 
-  ContextTrieNode *getOrCreateChildContext(const LineLocation &CallSite, 
-                                           StringRef CalleeName, 
-                                           bool AllowCreate = true); 
- 
-  ContextTrieNode &moveToChildContext(const LineLocation &CallSite, 
-                                      ContextTrieNode &&NodeToMove, 
-                                      StringRef ContextStrToRemove, 
-                                      bool DeleteNode = true); 
-  void removeChildContext(const LineLocation &CallSite, StringRef CalleeName); 
-  std::map<uint32_t, ContextTrieNode> &getAllChildContext(); 
-  const StringRef getFuncName() const; 
-  FunctionSamples *getFunctionSamples() const; 
-  void setFunctionSamples(FunctionSamples *FSamples); 
-  LineLocation getCallSiteLoc() const; 
-  ContextTrieNode *getParentContext() const; 
-  void setParentContext(ContextTrieNode *Parent); 
-  void dump(); 
- 
-private: 
-  static uint32_t nodeHash(StringRef ChildName, const LineLocation &Callsite); 
- 
-  // Map line+discriminator location to child context 
-  std::map<uint32_t, ContextTrieNode> AllChildContext; 
- 
-  // Link to parent context node 
-  ContextTrieNode *ParentContext; 
- 
-  // Function name for current context 
-  StringRef FuncName; 
- 
-  // Function Samples for current context 
-  FunctionSamples *FuncSamples; 
- 
-  // Callsite location in parent context 
-  LineLocation CallSiteLoc; 
-}; 
- 
-// Profile tracker that manages profiles and its associated context. It 
-// provides interfaces used by sample profile loader to query context profile or 
-// base profile for given function or location; it also manages context tree 
-// manipulation that is needed to accommodate inline decisions so we have 
-// accurate post-inline profile for functions. Internally context profiles 
-// are organized in a trie, with each node representing profile for specific 
-// calling context and the context is identified by path from root to the node. 
-class SampleContextTracker { 
-public: 
-  using ContextSamplesTy = SmallSet<FunctionSamples *, 16>; 
- 
-  SampleContextTracker(StringMap<FunctionSamples> &Profiles); 
-  // Query context profile for a specific callee with given name at a given 
-  // call-site. The full context is identified by location of call instruction. 
-  FunctionSamples *getCalleeContextSamplesFor(const CallBase &Inst, 
-                                              StringRef CalleeName); 
-  // Get samples for indirect call targets for call site at given location. 
-  std::vector<const FunctionSamples *> 
-  getIndirectCalleeContextSamplesFor(const DILocation *DIL); 
-  // Query context profile for a given location. The full context 
-  // is identified by input DILocation. 
-  FunctionSamples *getContextSamplesFor(const DILocation *DIL); 
-  // Query context profile for a given sample contxt of a function. 
-  FunctionSamples *getContextSamplesFor(const SampleContext &Context); 
-  // Get all context profile for given function. 
-  ContextSamplesTy &getAllContextSamplesFor(const Function &Func); 
-  ContextSamplesTy &getAllContextSamplesFor(StringRef Name); 
-  // Query base profile for a given function. A base profile is a merged view 
-  // of all context profiles for contexts that are not inlined. 
-  FunctionSamples *getBaseSamplesFor(const Function &Func, 
-                                     bool MergeContext = true); 
-  // Query base profile for a given function by name. 
-  FunctionSamples *getBaseSamplesFor(StringRef Name, bool MergeContext); 
-  // Mark a context profile as inlined when function is inlined. 
-  // This makes sure that inlined context profile will be excluded in 
-  // function's base profile. 
-  void markContextSamplesInlined(const FunctionSamples *InlinedSamples); 
-  void promoteMergeContextSamplesTree(const Instruction &Inst, 
-                                      StringRef CalleeName); 
-  void addCallGraphEdges(CallGraph &CG, StringMap<Function *> &SymbolMap); 
-  // Dump the internal context profile trie. 
-  void dump(); 
- 
-private: 
-  ContextTrieNode *getContextFor(const DILocation *DIL); 
-  ContextTrieNode *getContextFor(const SampleContext &Context); 
-  ContextTrieNode *getCalleeContextFor(const DILocation *DIL, 
-                                       StringRef CalleeName); 
-  ContextTrieNode *getOrCreateContextPath(const SampleContext &Context, 
-                                          bool AllowCreate); 
-  ContextTrieNode *getTopLevelContextNode(StringRef FName); 
-  ContextTrieNode &addTopLevelContextNode(StringRef FName); 
-  ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &NodeToPromo); 
-  void mergeContextNode(ContextTrieNode &FromNode, ContextTrieNode &ToNode, 
-                        StringRef ContextStrToRemove); 
-  ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &FromNode, 
-                                                  ContextTrieNode &ToNodeParent, 
-                                                  StringRef ContextStrToRemove); 
- 
-  // Map from function name to context profiles (excluding base profile) 
-  StringMap<ContextSamplesTy> FuncToCtxtProfileSet; 
- 
-  // Root node for context trie tree 
-  ContextTrieNode RootContext; 
-}; 
- 
-} // end namespace llvm 
-#endif // LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- Transforms/IPO/SampleContextTracker.h --------------------*- 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 provides the interface for context-sensitive profile tracker used
+/// by CSSPGO.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
+#define LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
+
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/ProfileData/SampleProf.h"
+#include <list>
+#include <map>
+#include <vector>
+
+using namespace llvm;
+using namespace sampleprof;
+
+namespace llvm {
+
+// Internal trie tree representation used for tracking context tree and sample
+// profiles. The path from root node to a given node represents the context of
+// that nodes' profile.
+class ContextTrieNode {
+public:
+  ContextTrieNode(ContextTrieNode *Parent = nullptr,
+                  StringRef FName = StringRef(),
+                  FunctionSamples *FSamples = nullptr,
+                  LineLocation CallLoc = {0, 0})
+      : ParentContext(Parent), FuncName(FName), FuncSamples(FSamples),
+        CallSiteLoc(CallLoc){};
+  ContextTrieNode *getChildContext(const LineLocation &CallSite,
+                                   StringRef CalleeName);
+  ContextTrieNode *getHottestChildContext(const LineLocation &CallSite);
+  ContextTrieNode *getOrCreateChildContext(const LineLocation &CallSite,
+                                           StringRef CalleeName,
+                                           bool AllowCreate = true);
+
+  ContextTrieNode &moveToChildContext(const LineLocation &CallSite,
+                                      ContextTrieNode &&NodeToMove,
+                                      StringRef ContextStrToRemove,
+                                      bool DeleteNode = true);
+  void removeChildContext(const LineLocation &CallSite, StringRef CalleeName);
+  std::map<uint32_t, ContextTrieNode> &getAllChildContext();
+  const StringRef getFuncName() const;
+  FunctionSamples *getFunctionSamples() const;
+  void setFunctionSamples(FunctionSamples *FSamples);
+  LineLocation getCallSiteLoc() const;
+  ContextTrieNode *getParentContext() const;
+  void setParentContext(ContextTrieNode *Parent);
+  void dump();
+
+private:
+  static uint32_t nodeHash(StringRef ChildName, const LineLocation &Callsite);
+
+  // Map line+discriminator location to child context
+  std::map<uint32_t, ContextTrieNode> AllChildContext;
+
+  // Link to parent context node
+  ContextTrieNode *ParentContext;
+
+  // Function name for current context
+  StringRef FuncName;
+
+  // Function Samples for current context
+  FunctionSamples *FuncSamples;
+
+  // Callsite location in parent context
+  LineLocation CallSiteLoc;
+};
+
+// Profile tracker that manages profiles and its associated context. It
+// provides interfaces used by sample profile loader to query context profile or
+// base profile for given function or location; it also manages context tree
+// manipulation that is needed to accommodate inline decisions so we have
+// accurate post-inline profile for functions. Internally context profiles
+// are organized in a trie, with each node representing profile for specific
+// calling context and the context is identified by path from root to the node.
+class SampleContextTracker {
+public:
+  using ContextSamplesTy = SmallSet<FunctionSamples *, 16>;
+
+  SampleContextTracker(StringMap<FunctionSamples> &Profiles);
+  // Query context profile for a specific callee with given name at a given
+  // call-site. The full context is identified by location of call instruction.
+  FunctionSamples *getCalleeContextSamplesFor(const CallBase &Inst,
+                                              StringRef CalleeName);
+  // Get samples for indirect call targets for call site at given location.
+  std::vector<const FunctionSamples *>
+  getIndirectCalleeContextSamplesFor(const DILocation *DIL);
+  // Query context profile for a given location. The full context
+  // is identified by input DILocation.
+  FunctionSamples *getContextSamplesFor(const DILocation *DIL);
+  // Query context profile for a given sample contxt of a function.
+  FunctionSamples *getContextSamplesFor(const SampleContext &Context);
+  // Get all context profile for given function.
+  ContextSamplesTy &getAllContextSamplesFor(const Function &Func);
+  ContextSamplesTy &getAllContextSamplesFor(StringRef Name);
+  // Query base profile for a given function. A base profile is a merged view
+  // of all context profiles for contexts that are not inlined.
+  FunctionSamples *getBaseSamplesFor(const Function &Func,
+                                     bool MergeContext = true);
+  // Query base profile for a given function by name.
+  FunctionSamples *getBaseSamplesFor(StringRef Name, bool MergeContext);
+  // Mark a context profile as inlined when function is inlined.
+  // This makes sure that inlined context profile will be excluded in
+  // function's base profile.
+  void markContextSamplesInlined(const FunctionSamples *InlinedSamples);
+  void promoteMergeContextSamplesTree(const Instruction &Inst,
+                                      StringRef CalleeName);
+  void addCallGraphEdges(CallGraph &CG, StringMap<Function *> &SymbolMap);
+  // Dump the internal context profile trie.
+  void dump();
+
+private:
+  ContextTrieNode *getContextFor(const DILocation *DIL);
+  ContextTrieNode *getContextFor(const SampleContext &Context);
+  ContextTrieNode *getCalleeContextFor(const DILocation *DIL,
+                                       StringRef CalleeName);
+  ContextTrieNode *getOrCreateContextPath(const SampleContext &Context,
+                                          bool AllowCreate);
+  ContextTrieNode *getTopLevelContextNode(StringRef FName);
+  ContextTrieNode &addTopLevelContextNode(StringRef FName);
+  ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &NodeToPromo);
+  void mergeContextNode(ContextTrieNode &FromNode, ContextTrieNode &ToNode,
+                        StringRef ContextStrToRemove);
+  ContextTrieNode &promoteMergeContextSamplesTree(ContextTrieNode &FromNode,
+                                                  ContextTrieNode &ToNodeParent,
+                                                  StringRef ContextStrToRemove);
+
+  // Map from function name to context profiles (excluding base profile)
+  StringMap<ContextSamplesTy> FuncToCtxtProfileSet;
+
+  // Root node for context trie tree
+  ContextTrieNode RootContext;
+};
+
+} // end namespace llvm
+#endif // LLVM_TRANSFORMS_IPO_SAMPLECONTEXTTRACKER_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfile.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfile.h
index be24fac675..9cc502eba6 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfile.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfile.h
@@ -31,18 +31,18 @@ class Module;
 /// The sample profiler data loader pass.
 class SampleProfileLoaderPass : public PassInfoMixin<SampleProfileLoaderPass> {
 public:
-  SampleProfileLoaderPass( 
-      std::string File = "", std::string RemappingFile = "", 
-      ThinOrFullLTOPhase LTOPhase = ThinOrFullLTOPhase::None) 
+  SampleProfileLoaderPass(
+      std::string File = "", std::string RemappingFile = "",
+      ThinOrFullLTOPhase LTOPhase = ThinOrFullLTOPhase::None)
       : ProfileFileName(File), ProfileRemappingFileName(RemappingFile),
-        LTOPhase(LTOPhase) {} 
+        LTOPhase(LTOPhase) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 
 private:
   std::string ProfileFileName;
   std::string ProfileRemappingFileName;
-  ThinOrFullLTOPhase LTOPhase; 
+  ThinOrFullLTOPhase LTOPhase;
 };
 
 } // end namespace llvm
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfileProbe.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfileProbe.h
index 55d7546fe7..7163fe38c0 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfileProbe.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/SampleProfileProbe.h
@@ -1,158 +1,158 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- Transforms/IPO/SampleProfileProbe.h ----------*- 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 provides the interface for the pseudo probe implementation for 
-/// AutoFDO. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H 
-#define LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H 
- 
-#include "llvm/ADT/DenseMap.h" 
-#include "llvm/Analysis/CallGraphSCCPass.h" 
-#include "llvm/Analysis/LazyCallGraph.h" 
-#include "llvm/Analysis/LoopInfo.h" 
-#include "llvm/IR/PassInstrumentation.h" 
-#include "llvm/IR/PassManager.h" 
-#include "llvm/IR/PseudoProbe.h" 
-#include "llvm/ProfileData/SampleProf.h" 
-#include "llvm/Target/TargetMachine.h" 
-#include <unordered_map> 
- 
-namespace llvm { 
- 
-class Module; 
- 
-using namespace sampleprof; 
-using BlockIdMap = std::unordered_map<BasicBlock *, uint32_t>; 
-using InstructionIdMap = std::unordered_map<Instruction *, uint32_t>; 
-using ProbeFactorMap = std::unordered_map<uint64_t, float>; 
-using FuncProbeFactorMap = StringMap<ProbeFactorMap>; 
- 
-enum class PseudoProbeReservedId { Invalid = 0, Last = Invalid }; 
- 
-class PseudoProbeDescriptor { 
-  uint64_t FunctionGUID; 
-  uint64_t FunctionHash; 
- 
-public: 
-  PseudoProbeDescriptor(uint64_t GUID, uint64_t Hash) 
-      : FunctionGUID(GUID), FunctionHash(Hash) {} 
-  uint64_t getFunctionGUID() const { return FunctionGUID; } 
-  uint64_t getFunctionHash() const { return FunctionHash; } 
-}; 
- 
-// A pseudo probe verifier that can be run after each IR passes to detect the 
-// violation of updating probe factors. In principle, the sum of distribution 
-// factor for a probe should be identical before and after a pass. For a 
-// function pass, the factor sum for a probe would be typically 100%. 
-class PseudoProbeVerifier { 
-public: 
-  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
- 
-  // Implementation of pass instrumentation callbacks for new pass manager. 
-  void runAfterPass(StringRef PassID, Any IR); 
- 
-private: 
-  // Allow a little bias due the rounding to integral factors. 
-  constexpr static float DistributionFactorVariance = 0.02f; 
-  // Distribution factors from last pass. 
-  FuncProbeFactorMap FunctionProbeFactors; 
- 
-  void collectProbeFactors(const BasicBlock *BB, ProbeFactorMap &ProbeFactors); 
-  void runAfterPass(const Module *M); 
-  void runAfterPass(const LazyCallGraph::SCC *C); 
-  void runAfterPass(const Function *F); 
-  void runAfterPass(const Loop *L); 
-  bool shouldVerifyFunction(const Function *F); 
-  void verifyProbeFactors(const Function *F, 
-                          const ProbeFactorMap &ProbeFactors); 
-}; 
- 
-// This class serves sample counts correlation for SampleProfileLoader by 
-// analyzing pseudo probes and their function descriptors injected by 
-// SampleProfileProber. 
-class PseudoProbeManager { 
-  DenseMap<uint64_t, PseudoProbeDescriptor> GUIDToProbeDescMap; 
- 
-  const PseudoProbeDescriptor *getDesc(const Function &F) const; 
- 
-public: 
-  PseudoProbeManager(const Module &M); 
-  bool moduleIsProbed(const Module &M) const; 
-  bool profileIsValid(const Function &F, const FunctionSamples &Samples) const; 
-}; 
- 
-/// Sample profile pseudo prober. 
-/// 
-/// Insert pseudo probes for block sampling and value sampling. 
-class SampleProfileProber { 
-public: 
-  // Give an empty module id when the prober is not used for instrumentation. 
-  SampleProfileProber(Function &F, const std::string &CurModuleUniqueId); 
-  void instrumentOneFunc(Function &F, TargetMachine *TM); 
- 
-private: 
-  Function *getFunction() const { return F; } 
-  uint64_t getFunctionHash() const { return FunctionHash; } 
-  uint32_t getBlockId(const BasicBlock *BB) const; 
-  uint32_t getCallsiteId(const Instruction *Call) const; 
-  void computeCFGHash(); 
-  void computeProbeIdForBlocks(); 
-  void computeProbeIdForCallsites(); 
- 
-  Function *F; 
- 
-  /// The current module ID that is used to name a static object as a comdat 
-  /// group. 
-  std::string CurModuleUniqueId; 
- 
-  /// A CFG hash code used to identify a function code changes. 
-  uint64_t FunctionHash; 
- 
-  /// Map basic blocks to the their pseudo probe ids. 
-  BlockIdMap BlockProbeIds; 
- 
-  /// Map indirect calls to the their pseudo probe ids. 
-  InstructionIdMap CallProbeIds; 
- 
-  /// The ID of the last probe, Can be used to number a new probe. 
-  uint32_t LastProbeId; 
-}; 
- 
-class SampleProfileProbePass : public PassInfoMixin<SampleProfileProbePass> { 
-  TargetMachine *TM; 
- 
-public: 
-  SampleProfileProbePass(TargetMachine *TM) : TM(TM) {} 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-class PseudoProbeUpdatePass : public PassInfoMixin<PseudoProbeUpdatePass> { 
-  void runOnFunction(Function &F, FunctionAnalysisManager &FAM); 
- 
-public: 
-  PseudoProbeUpdatePass() {} 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-} // end namespace llvm 
-#endif // LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- Transforms/IPO/SampleProfileProbe.h ----------*- 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 provides the interface for the pseudo probe implementation for
+/// AutoFDO.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
+#define LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Analysis/CallGraphSCCPass.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassInstrumentation.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/IR/PseudoProbe.h"
+#include "llvm/ProfileData/SampleProf.h"
+#include "llvm/Target/TargetMachine.h"
+#include <unordered_map>
+
+namespace llvm {
+
+class Module;
+
+using namespace sampleprof;
+using BlockIdMap = std::unordered_map<BasicBlock *, uint32_t>;
+using InstructionIdMap = std::unordered_map<Instruction *, uint32_t>;
+using ProbeFactorMap = std::unordered_map<uint64_t, float>;
+using FuncProbeFactorMap = StringMap<ProbeFactorMap>;
+
+enum class PseudoProbeReservedId { Invalid = 0, Last = Invalid };
+
+class PseudoProbeDescriptor {
+  uint64_t FunctionGUID;
+  uint64_t FunctionHash;
+
+public:
+  PseudoProbeDescriptor(uint64_t GUID, uint64_t Hash)
+      : FunctionGUID(GUID), FunctionHash(Hash) {}
+  uint64_t getFunctionGUID() const { return FunctionGUID; }
+  uint64_t getFunctionHash() const { return FunctionHash; }
+};
+
+// A pseudo probe verifier that can be run after each IR passes to detect the
+// violation of updating probe factors. In principle, the sum of distribution
+// factor for a probe should be identical before and after a pass. For a
+// function pass, the factor sum for a probe would be typically 100%.
+class PseudoProbeVerifier {
+public:
+  void registerCallbacks(PassInstrumentationCallbacks &PIC);
+
+  // Implementation of pass instrumentation callbacks for new pass manager.
+  void runAfterPass(StringRef PassID, Any IR);
+
+private:
+  // Allow a little bias due the rounding to integral factors.
+  constexpr static float DistributionFactorVariance = 0.02f;
+  // Distribution factors from last pass.
+  FuncProbeFactorMap FunctionProbeFactors;
+
+  void collectProbeFactors(const BasicBlock *BB, ProbeFactorMap &ProbeFactors);
+  void runAfterPass(const Module *M);
+  void runAfterPass(const LazyCallGraph::SCC *C);
+  void runAfterPass(const Function *F);
+  void runAfterPass(const Loop *L);
+  bool shouldVerifyFunction(const Function *F);
+  void verifyProbeFactors(const Function *F,
+                          const ProbeFactorMap &ProbeFactors);
+};
+
+// This class serves sample counts correlation for SampleProfileLoader by
+// analyzing pseudo probes and their function descriptors injected by
+// SampleProfileProber.
+class PseudoProbeManager {
+  DenseMap<uint64_t, PseudoProbeDescriptor> GUIDToProbeDescMap;
+
+  const PseudoProbeDescriptor *getDesc(const Function &F) const;
+
+public:
+  PseudoProbeManager(const Module &M);
+  bool moduleIsProbed(const Module &M) const;
+  bool profileIsValid(const Function &F, const FunctionSamples &Samples) const;
+};
+
+/// Sample profile pseudo prober.
+///
+/// Insert pseudo probes for block sampling and value sampling.
+class SampleProfileProber {
+public:
+  // Give an empty module id when the prober is not used for instrumentation.
+  SampleProfileProber(Function &F, const std::string &CurModuleUniqueId);
+  void instrumentOneFunc(Function &F, TargetMachine *TM);
+
+private:
+  Function *getFunction() const { return F; }
+  uint64_t getFunctionHash() const { return FunctionHash; }
+  uint32_t getBlockId(const BasicBlock *BB) const;
+  uint32_t getCallsiteId(const Instruction *Call) const;
+  void computeCFGHash();
+  void computeProbeIdForBlocks();
+  void computeProbeIdForCallsites();
+
+  Function *F;
+
+  /// The current module ID that is used to name a static object as a comdat
+  /// group.
+  std::string CurModuleUniqueId;
+
+  /// A CFG hash code used to identify a function code changes.
+  uint64_t FunctionHash;
+
+  /// Map basic blocks to the their pseudo probe ids.
+  BlockIdMap BlockProbeIds;
+
+  /// Map indirect calls to the their pseudo probe ids.
+  InstructionIdMap CallProbeIds;
+
+  /// The ID of the last probe, Can be used to number a new probe.
+  uint32_t LastProbeId;
+};
+
+class SampleProfileProbePass : public PassInfoMixin<SampleProfileProbePass> {
+  TargetMachine *TM;
+
+public:
+  SampleProfileProbePass(TargetMachine *TM) : TM(TM) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+class PseudoProbeUpdatePass : public PassInfoMixin<PseudoProbeUpdatePass> {
+  void runOnFunction(Function &F, FunctionAnalysisManager &FAM);
+
+public:
+  PseudoProbeUpdatePass() {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+#endif // LLVM_TRANSFORMS_IPO_SAMPLEPROFILEPROBE_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/StripSymbols.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/StripSymbols.h
index 21ce7b836f..83829c1fa8 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/StripSymbols.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/StripSymbols.h
@@ -1,58 +1,58 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- StripSymbols.h - Strip symbols and debug info from a module --------===// 
-// 
-// 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 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// The StripSymbols transformation implements code stripping. Specifically, it 
-// can delete: 
-// 
-//   * names for virtual registers 
-//   * symbols for internal globals and functions 
-//   * debug information 
-// 
-// Note that this transformation makes code much less readable, so it should 
-// only be used in situations where the 'strip' utility would be used, such as 
-// reducing code size or making it harder to reverse engineer code. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H 
-#define LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H 
- 
-#include "llvm/IR/PassManager.h" 
- 
-namespace llvm { 
- 
-struct StripSymbolsPass : PassInfoMixin<StripSymbolsPass> { 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-struct StripNonDebugSymbolsPass : PassInfoMixin<StripNonDebugSymbolsPass> { 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-struct StripDebugDeclarePass : PassInfoMixin<StripDebugDeclarePass> { 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-struct StripDeadDebugInfoPass : PassInfoMixin<StripDeadDebugInfoPass> { 
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- StripSymbols.h - Strip symbols and debug info from a module --------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// The StripSymbols transformation implements code stripping. Specifically, it
+// can delete:
+//
+//   * names for virtual registers
+//   * symbols for internal globals and functions
+//   * debug information
+//
+// Note that this transformation makes code much less readable, so it should
+// only be used in situations where the 'strip' utility would be used, such as
+// reducing code size or making it harder to reverse engineer code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
+#define LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct StripSymbolsPass : PassInfoMixin<StripSymbolsPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct StripNonDebugSymbolsPass : PassInfoMixin<StripNonDebugSymbolsPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct StripDebugDeclarePass : PassInfoMixin<StripDebugDeclarePass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+struct StripDeadDebugInfoPass : PassInfoMixin<StripDeadDebugInfoPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_IPO_STRIPSYMBOLS_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
diff --git a/contrib/libs/llvm12/include/llvm/Transforms/IPO/WholeProgramDevirt.h b/contrib/libs/llvm12/include/llvm/Transforms/IPO/WholeProgramDevirt.h
index 0e0cc1fd16..135d78a1d3 100644
--- a/contrib/libs/llvm12/include/llvm/Transforms/IPO/WholeProgramDevirt.h
+++ b/contrib/libs/llvm12/include/llvm/Transforms/IPO/WholeProgramDevirt.h
@@ -230,9 +230,9 @@ void setAfterReturnValues(MutableArrayRef<VirtualCallTarget> Targets,
 struct WholeProgramDevirtPass : public PassInfoMixin<WholeProgramDevirtPass> {
   ModuleSummaryIndex *ExportSummary;
   const ModuleSummaryIndex *ImportSummary;
-  bool UseCommandLine = false; 
-  WholeProgramDevirtPass() 
-      : ExportSummary(nullptr), ImportSummary(nullptr), UseCommandLine(true) {} 
+  bool UseCommandLine = false;
+  WholeProgramDevirtPass()
+      : ExportSummary(nullptr), ImportSummary(nullptr), UseCommandLine(true) {}
   WholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary,
                          const ModuleSummaryIndex *ImportSummary)
       : ExportSummary(ExportSummary), ImportSummary(ImportSummary) {