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

1 files changed, 229 insertions, 229 deletions

diff --git a/contrib/libs/llvm12/include/llvm/Passes/StandardInstrumentations.h b/contrib/libs/llvm12/include/llvm/Passes/StandardInstrumentations.h
index d66a0ec466..93df62b562 100644
--- a/contrib/libs/llvm12/include/llvm/Passes/StandardInstrumentations.h
+++ b/contrib/libs/llvm12/include/llvm/Passes/StandardInstrumentations.h
@@ -23,13 +23,13 @@
 #define LLVM_PASSES_STANDARDINSTRUMENTATIONS_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/OptBisect.h"
+#include "llvm/ADT/StringRef.h" 
+#include "llvm/IR/BasicBlock.h" 
+#include "llvm/IR/OptBisect.h" 
 #include "llvm/IR/PassTimingInfo.h"
-#include "llvm/IR/ValueHandle.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Transforms/IPO/SampleProfileProbe.h"
+#include "llvm/IR/ValueHandle.h" 
+#include "llvm/Support/CommandLine.h" 
+#include "llvm/Transforms/IPO/SampleProfileProbe.h" 
 
 #include <string>
 #include <utility>
@@ -37,8 +37,8 @@
 namespace llvm {
 
 class Module;
-class Function;
-class PassInstrumentationCallbacks;
+class Function; 
+class PassInstrumentationCallbacks; 
 
 /// Instrumentation to print IR before/after passes.
 ///
@@ -51,252 +51,252 @@ public:
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
-  void printBeforePass(StringRef PassID, Any IR);
+  void printBeforePass(StringRef PassID, Any IR); 
   void printAfterPass(StringRef PassID, Any IR);
   void printAfterPassInvalidated(StringRef PassID);
 
-  bool shouldPrintBeforePass(StringRef PassID);
-  bool shouldPrintAfterPass(StringRef PassID);
-
+  bool shouldPrintBeforePass(StringRef PassID); 
+  bool shouldPrintAfterPass(StringRef PassID); 
+ 
   using PrintModuleDesc = std::tuple<const Module *, std::string, StringRef>;
 
   void pushModuleDesc(StringRef PassID, Any IR);
   PrintModuleDesc popModuleDesc(StringRef PassID);
 
-  PassInstrumentationCallbacks *PIC;
+  PassInstrumentationCallbacks *PIC; 
   /// Stack of Module description, enough to print the module after a given
   /// pass.
   SmallVector<PrintModuleDesc, 2> ModuleDescStack;
   bool StoreModuleDesc = false;
 };
 
-class OptNoneInstrumentation {
-public:
-  OptNoneInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
-
-private:
-  bool DebugLogging;
-  bool shouldRun(StringRef PassID, Any IR);
-};
-
-class OptBisectInstrumentation {
-public:
-  OptBisectInstrumentation() {}
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
-};
-
-// Debug logging for transformation and analysis passes.
-class PrintPassInstrumentation {
-public:
-  PrintPassInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
-
-private:
-  bool DebugLogging;
-};
-
-class PreservedCFGCheckerInstrumentation {
-private:
-  // CFG is a map BB -> {(Succ, Multiplicity)}, where BB is a non-leaf basic
-  // block, {(Succ, Multiplicity)} set of all pairs of the block's successors
-  // and the multiplicity of the edge (BB->Succ). As the mapped sets are
-  // unordered the order of successors is not tracked by the CFG. In other words
-  // this allows basic block successors to be swapped by a pass without
-  // reporting a CFG change. CFG can be guarded by basic block tracking pointers
-  // in the Graph (BBGuard). That is if any of the block is deleted or RAUWed
-  // then the CFG is treated poisoned and no block pointer of the Graph is used.
-  struct CFG {
-    struct BBGuard final : public CallbackVH {
-      BBGuard(const BasicBlock *BB) : CallbackVH(BB) {}
-      void deleted() override { CallbackVH::deleted(); }
-      void allUsesReplacedWith(Value *) override { CallbackVH::deleted(); }
-      bool isPoisoned() const { return !getValPtr(); }
-    };
-
-    Optional<DenseMap<intptr_t, BBGuard>> BBGuards;
-    DenseMap<const BasicBlock *, DenseMap<const BasicBlock *, unsigned>> Graph;
-
-    CFG(const Function *F, bool TrackBBLifetime = false);
-
-    bool operator==(const CFG &G) const {
-      return !isPoisoned() && !G.isPoisoned() && Graph == G.Graph;
-    }
-
-    bool isPoisoned() const {
-      if (BBGuards)
-        for (auto &BB : *BBGuards) {
-          if (BB.second.isPoisoned())
-            return true;
-        }
-      return false;
-    }
-
-    static void printDiff(raw_ostream &out, const CFG &Before,
-                          const CFG &After);
-  };
-
-  SmallVector<std::pair<StringRef, Optional<CFG>>, 8> GraphStackBefore;
-
-public:
-  static cl::opt<bool> VerifyPreservedCFG;
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
-};
-
-// Base class for classes that report changes to the IR.
-// It presents an interface for such classes and provides calls
-// on various events as the new pass manager transforms the IR.
-// It also provides filtering of information based on hidden options
-// specifying which functions are interesting.
-// Calls are made for the following events/queries:
-// 1.  The initial IR processed.
-// 2.  To get the representation of the IR (of type \p T).
-// 3.  When a pass does not change the IR.
-// 4.  When a pass changes the IR (given both before and after representations
-//         of type \p T).
-// 5.  When an IR is invalidated.
-// 6.  When a pass is run on an IR that is not interesting (based on options).
-// 7.  When a pass is ignored (pass manager or adapter pass).
-// 8.  To compare two IR representations (of type \p T).
-template <typename IRUnitT> class ChangeReporter {
-protected:
-  ChangeReporter(bool RunInVerboseMode) : VerboseMode(RunInVerboseMode) {}
-
-public:
-  virtual ~ChangeReporter();
-
-  // Determine if this pass/IR is interesting and if so, save the IR
-  // otherwise it is left on the stack without data.
-  void saveIRBeforePass(Any IR, StringRef PassID);
-  // Compare the IR from before the pass after the pass.
-  void handleIRAfterPass(Any IR, StringRef PassID);
-  // Handle the situation where a pass is invalidated.
-  void handleInvalidatedPass(StringRef PassID);
-
-protected:
-  // Register required callbacks.
-  void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC);
-
-  // Return true when this is a defined function for which printing
-  // of changes is desired.
-  bool isInterestingFunction(const Function &F);
-
-  // Return true when this is a pass for which printing of changes is desired.
-  bool isInterestingPass(StringRef PassID);
-
-  // Return true when this is a pass on IR for which printing
-  // of changes is desired.
-  bool isInteresting(Any IR, StringRef PassID);
-
-  // Called on the first IR processed.
-  virtual void handleInitialIR(Any IR) = 0;
-  // Called before and after a pass to get the representation of the IR.
-  virtual void generateIRRepresentation(Any IR, StringRef PassID,
-                                        IRUnitT &Output) = 0;
-  // Called when the pass is not iteresting.
-  virtual void omitAfter(StringRef PassID, std::string &Name) = 0;
-  // Called when an interesting IR has changed.
-  virtual void handleAfter(StringRef PassID, std::string &Name,
-                           const IRUnitT &Before, const IRUnitT &After,
-                           Any) = 0;
-  // Called when an interesting pass is invalidated.
-  virtual void handleInvalidated(StringRef PassID) = 0;
-  // Called when the IR or pass is not interesting.
-  virtual void handleFiltered(StringRef PassID, std::string &Name) = 0;
-  // Called when an ignored pass is encountered.
-  virtual void handleIgnored(StringRef PassID, std::string &Name) = 0;
-  // Called to compare the before and after representations of the IR.
-  virtual bool same(const IRUnitT &Before, const IRUnitT &After) = 0;
-
-  // Stack of IRs before passes.
-  std::vector<IRUnitT> BeforeStack;
-  // Is this the first IR seen?
-  bool InitialIR = true;
-
-  // Run in verbose mode, printing everything?
-  const bool VerboseMode;
-};
-
-// An abstract template base class that handles printing banners and
-// reporting when things have not changed or are filtered out.
-template <typename IRUnitT>
-class TextChangeReporter : public ChangeReporter<IRUnitT> {
-protected:
-  TextChangeReporter(bool Verbose);
-
-  // Print a module dump of the first IR that is changed.
-  void handleInitialIR(Any IR) override;
-  // Report that the IR was omitted because it did not change.
-  void omitAfter(StringRef PassID, std::string &Name) override;
-  // Report that the pass was invalidated.
-  void handleInvalidated(StringRef PassID) override;
-  // Report that the IR was filtered out.
-  void handleFiltered(StringRef PassID, std::string &Name) override;
-  // Report that the pass was ignored.
-  void handleIgnored(StringRef PassID, std::string &Name) override;
-  // Make substitutions in \p S suitable for reporting changes
-  // after the pass and then print it.
-
-  raw_ostream &Out;
-};
-
-// A change printer based on the string representation of the IR as created
-// by unwrapAndPrint.  The string representation is stored in a std::string
-// to preserve it as the IR changes in each pass.  Note that the banner is
-// included in this representation but it is massaged before reporting.
-class IRChangedPrinter : public TextChangeReporter<std::string> {
-public:
-  IRChangedPrinter(bool VerboseMode)
-      : TextChangeReporter<std::string>(VerboseMode) {}
-  ~IRChangedPrinter() override;
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
-
-protected:
-  // Called before and after a pass to get the representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
-                                std::string &Output) override;
-  // Called when an interesting IR has changed.
-  void handleAfter(StringRef PassID, std::string &Name,
-                   const std::string &Before, const std::string &After,
-                   Any) override;
-  // Called to compare the before and after representations of the IR.
-  bool same(const std::string &Before, const std::string &After) override;
-};
-
-class VerifyInstrumentation {
-  bool DebugLogging;
-
-public:
-  VerifyInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
-  void registerCallbacks(PassInstrumentationCallbacks &PIC);
-};
-
+class OptNoneInstrumentation { 
+public: 
+  OptNoneInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {} 
+  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
+ 
+private: 
+  bool DebugLogging; 
+  bool shouldRun(StringRef PassID, Any IR); 
+}; 
+ 
+class OptBisectInstrumentation { 
+public: 
+  OptBisectInstrumentation() {} 
+  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
+}; 
+ 
+// Debug logging for transformation and analysis passes. 
+class PrintPassInstrumentation { 
+public: 
+  PrintPassInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {} 
+  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
+ 
+private: 
+  bool DebugLogging; 
+}; 
+ 
+class PreservedCFGCheckerInstrumentation { 
+private: 
+  // CFG is a map BB -> {(Succ, Multiplicity)}, where BB is a non-leaf basic 
+  // block, {(Succ, Multiplicity)} set of all pairs of the block's successors 
+  // and the multiplicity of the edge (BB->Succ). As the mapped sets are 
+  // unordered the order of successors is not tracked by the CFG. In other words 
+  // this allows basic block successors to be swapped by a pass without 
+  // reporting a CFG change. CFG can be guarded by basic block tracking pointers 
+  // in the Graph (BBGuard). That is if any of the block is deleted or RAUWed 
+  // then the CFG is treated poisoned and no block pointer of the Graph is used. 
+  struct CFG { 
+    struct BBGuard final : public CallbackVH { 
+      BBGuard(const BasicBlock *BB) : CallbackVH(BB) {} 
+      void deleted() override { CallbackVH::deleted(); } 
+      void allUsesReplacedWith(Value *) override { CallbackVH::deleted(); } 
+      bool isPoisoned() const { return !getValPtr(); } 
+    }; 
+ 
+    Optional<DenseMap<intptr_t, BBGuard>> BBGuards; 
+    DenseMap<const BasicBlock *, DenseMap<const BasicBlock *, unsigned>> Graph; 
+ 
+    CFG(const Function *F, bool TrackBBLifetime = false); 
+ 
+    bool operator==(const CFG &G) const { 
+      return !isPoisoned() && !G.isPoisoned() && Graph == G.Graph; 
+    } 
+ 
+    bool isPoisoned() const { 
+      if (BBGuards) 
+        for (auto &BB : *BBGuards) { 
+          if (BB.second.isPoisoned()) 
+            return true; 
+        } 
+      return false; 
+    } 
+ 
+    static void printDiff(raw_ostream &out, const CFG &Before, 
+                          const CFG &After); 
+  }; 
+ 
+  SmallVector<std::pair<StringRef, Optional<CFG>>, 8> GraphStackBefore; 
+ 
+public: 
+  static cl::opt<bool> VerifyPreservedCFG; 
+  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
+}; 
+ 
+// Base class for classes that report changes to the IR. 
+// It presents an interface for such classes and provides calls 
+// on various events as the new pass manager transforms the IR. 
+// It also provides filtering of information based on hidden options 
+// specifying which functions are interesting. 
+// Calls are made for the following events/queries: 
+// 1.  The initial IR processed. 
+// 2.  To get the representation of the IR (of type \p T). 
+// 3.  When a pass does not change the IR. 
+// 4.  When a pass changes the IR (given both before and after representations 
+//         of type \p T). 
+// 5.  When an IR is invalidated. 
+// 6.  When a pass is run on an IR that is not interesting (based on options). 
+// 7.  When a pass is ignored (pass manager or adapter pass). 
+// 8.  To compare two IR representations (of type \p T). 
+template <typename IRUnitT> class ChangeReporter { 
+protected: 
+  ChangeReporter(bool RunInVerboseMode) : VerboseMode(RunInVerboseMode) {} 
+ 
+public: 
+  virtual ~ChangeReporter(); 
+ 
+  // Determine if this pass/IR is interesting and if so, save the IR 
+  // otherwise it is left on the stack without data. 
+  void saveIRBeforePass(Any IR, StringRef PassID); 
+  // Compare the IR from before the pass after the pass. 
+  void handleIRAfterPass(Any IR, StringRef PassID); 
+  // Handle the situation where a pass is invalidated. 
+  void handleInvalidatedPass(StringRef PassID); 
+ 
+protected: 
+  // Register required callbacks. 
+  void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC); 
+ 
+  // Return true when this is a defined function for which printing 
+  // of changes is desired. 
+  bool isInterestingFunction(const Function &F); 
+ 
+  // Return true when this is a pass for which printing of changes is desired. 
+  bool isInterestingPass(StringRef PassID); 
+ 
+  // Return true when this is a pass on IR for which printing 
+  // of changes is desired. 
+  bool isInteresting(Any IR, StringRef PassID); 
+ 
+  // Called on the first IR processed. 
+  virtual void handleInitialIR(Any IR) = 0; 
+  // Called before and after a pass to get the representation of the IR. 
+  virtual void generateIRRepresentation(Any IR, StringRef PassID, 
+                                        IRUnitT &Output) = 0; 
+  // Called when the pass is not iteresting. 
+  virtual void omitAfter(StringRef PassID, std::string &Name) = 0; 
+  // Called when an interesting IR has changed. 
+  virtual void handleAfter(StringRef PassID, std::string &Name, 
+                           const IRUnitT &Before, const IRUnitT &After, 
+                           Any) = 0; 
+  // Called when an interesting pass is invalidated. 
+  virtual void handleInvalidated(StringRef PassID) = 0; 
+  // Called when the IR or pass is not interesting. 
+  virtual void handleFiltered(StringRef PassID, std::string &Name) = 0; 
+  // Called when an ignored pass is encountered. 
+  virtual void handleIgnored(StringRef PassID, std::string &Name) = 0; 
+  // Called to compare the before and after representations of the IR. 
+  virtual bool same(const IRUnitT &Before, const IRUnitT &After) = 0; 
+ 
+  // Stack of IRs before passes. 
+  std::vector<IRUnitT> BeforeStack; 
+  // Is this the first IR seen? 
+  bool InitialIR = true; 
+ 
+  // Run in verbose mode, printing everything? 
+  const bool VerboseMode; 
+}; 
+ 
+// An abstract template base class that handles printing banners and 
+// reporting when things have not changed or are filtered out. 
+template <typename IRUnitT> 
+class TextChangeReporter : public ChangeReporter<IRUnitT> { 
+protected: 
+  TextChangeReporter(bool Verbose); 
+ 
+  // Print a module dump of the first IR that is changed. 
+  void handleInitialIR(Any IR) override; 
+  // Report that the IR was omitted because it did not change. 
+  void omitAfter(StringRef PassID, std::string &Name) override; 
+  // Report that the pass was invalidated. 
+  void handleInvalidated(StringRef PassID) override; 
+  // Report that the IR was filtered out. 
+  void handleFiltered(StringRef PassID, std::string &Name) override; 
+  // Report that the pass was ignored. 
+  void handleIgnored(StringRef PassID, std::string &Name) override; 
+  // Make substitutions in \p S suitable for reporting changes 
+  // after the pass and then print it. 
+ 
+  raw_ostream &Out; 
+}; 
+ 
+// A change printer based on the string representation of the IR as created 
+// by unwrapAndPrint.  The string representation is stored in a std::string 
+// to preserve it as the IR changes in each pass.  Note that the banner is 
+// included in this representation but it is massaged before reporting. 
+class IRChangedPrinter : public TextChangeReporter<std::string> { 
+public: 
+  IRChangedPrinter(bool VerboseMode) 
+      : TextChangeReporter<std::string>(VerboseMode) {} 
+  ~IRChangedPrinter() override; 
+  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
+ 
+protected: 
+  // Called before and after a pass to get the representation of the IR. 
+  void generateIRRepresentation(Any IR, StringRef PassID, 
+                                std::string &Output) override; 
+  // Called when an interesting IR has changed. 
+  void handleAfter(StringRef PassID, std::string &Name, 
+                   const std::string &Before, const std::string &After, 
+                   Any) override; 
+  // Called to compare the before and after representations of the IR. 
+  bool same(const std::string &Before, const std::string &After) override; 
+}; 
+ 
+class VerifyInstrumentation { 
+  bool DebugLogging; 
+ 
+public: 
+  VerifyInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {} 
+  void registerCallbacks(PassInstrumentationCallbacks &PIC); 
+}; 
+ 
 /// This class provides an interface to register all the standard pass
 /// instrumentations and manages their state (if any).
 class StandardInstrumentations {
   PrintIRInstrumentation PrintIR;
-  PrintPassInstrumentation PrintPass;
+  PrintPassInstrumentation PrintPass; 
   TimePassesHandler TimePasses;
-  OptNoneInstrumentation OptNone;
-  OptBisectInstrumentation OptBisect;
-  PreservedCFGCheckerInstrumentation PreservedCFGChecker;
-  IRChangedPrinter PrintChangedIR;
-  PseudoProbeVerifier PseudoProbeVerification;
-  VerifyInstrumentation Verify;
-
-  bool VerifyEach;
-
+  OptNoneInstrumentation OptNone; 
+  OptBisectInstrumentation OptBisect; 
+  PreservedCFGCheckerInstrumentation PreservedCFGChecker; 
+  IRChangedPrinter PrintChangedIR; 
+  PseudoProbeVerifier PseudoProbeVerification; 
+  VerifyInstrumentation Verify; 
+
+  bool VerifyEach; 
+ 
 public:
-  StandardInstrumentations(bool DebugLogging, bool VerifyEach = false);
+  StandardInstrumentations(bool DebugLogging, bool VerifyEach = false); 
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
   TimePassesHandler &getTimePasses() { return TimePasses; }
 };
-
-extern template class ChangeReporter<std::string>;
-extern template class TextChangeReporter<std::string>;
-
+ 
+extern template class ChangeReporter<std::string>; 
+extern template class TextChangeReporter<std::string>; 
+ 
 } // namespace llvm
 
 #endif