[llvm] Replace llvm::Any with std::any

llvm::Any had several bugs in the past, due to being sensitive to symbol
visibility. (See D101972 and D108943)

Even with these fixes applied, I still encounter the same issue on
Windows.

Similar to llvm::Optional going away in favor of std::optional, we can
use std::any from C++17.

Using std::any fixes the problem and puts the burden to do it correctly
on the standard library.

Differential Revision: https://reviews.llvm.org/D139532

Author: Flakebi

llvm/include/llvm/IR/PassInstrumentation.h

@@ -35,7 +35,7 @@
 ///      executed and IRUnit it works on. There can be different schemes of
 ///      providing names in future, currently it is just a name() of the pass.
 ///
-///    - PassInstrumentation wraps address of IRUnit into llvm::Any and passes
+///    - PassInstrumentation wraps address of IRUnit into std::any and passes
 ///      control to all the registered callbacks. Note that we specifically wrap
 ///      'const IRUnitT*' so as to avoid any accidental changes to IR in
 ///      instrumenting callbacks.
@@ -49,10 +49,10 @@
 #ifndef LLVM_IR_PASSINSTRUMENTATION_H
 #define LLVM_IR_PASSINSTRUMENTATION_H
 
-#include "llvm/ADT/Any.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
+#include <any>
 #include <type_traits>
 #include <vector>
 
@@ -66,7 +66,7 @@ class StringRef;
 class PassInstrumentationCallbacks {
 public:
   // Before/After callbacks accept IRUnits whenever appropriate, so they need
-  // to take them as constant pointers, wrapped with llvm::Any.
+  // to take them as constant pointers, wrapped with std::any.
   // For the case when IRUnit has been invalidated there is a different
   // callback to use - AfterPassInvalidated.
   // We call all BeforePassFuncs to determine if a pass should run or not.
@@ -75,14 +75,14 @@ class PassInstrumentationCallbacks {
   // already invalidated IRUnit is unsafe. There are ways to handle invalidated
   // IRUnits in a safe way, and we might pursue that as soon as there is a
   // useful instrumentation that needs it.
-  using BeforePassFunc = bool(StringRef, Any);
-  using BeforeSkippedPassFunc = void(StringRef, Any);
-  using BeforeNonSkippedPassFunc = void(StringRef, Any);
-  using AfterPassFunc = void(StringRef, Any, const PreservedAnalyses &);
+  using BeforePassFunc = bool(StringRef, std::any);
+  using BeforeSkippedPassFunc = void(StringRef, std::any);
+  using BeforeNonSkippedPassFunc = void(StringRef, std::any);
+  using AfterPassFunc = void(StringRef, std::any, const PreservedAnalyses &);
   using AfterPassInvalidatedFunc = void(StringRef, const PreservedAnalyses &);
-  using BeforeAnalysisFunc = void(StringRef, Any);
-  using AfterAnalysisFunc = void(StringRef, Any);
-  using AnalysisInvalidatedFunc = void(StringRef, Any);
+  using BeforeAnalysisFunc = void(StringRef, std::any);
+  using AfterAnalysisFunc = void(StringRef, std::any);
+  using AnalysisInvalidatedFunc = void(StringRef, std::any);
   using AnalysesClearedFunc = void(StringRef);
 
 public:
@@ -233,15 +233,15 @@ class PassInstrumentation {
     bool ShouldRun = true;
     if (!isRequired(Pass)) {
       for (auto &C : Callbacks->ShouldRunOptionalPassCallbacks)
-        ShouldRun &= C(Pass.name(), llvm::Any(&IR));
+        ShouldRun &= C(Pass.name(), std::any(&IR));
     }
 
     if (ShouldRun) {
       for (auto &C : Callbacks->BeforeNonSkippedPassCallbacks)
-        C(Pass.name(), llvm::Any(&IR));
+        C(Pass.name(), std::any(&IR));
     } else {
       for (auto &C : Callbacks->BeforeSkippedPassCallbacks)
-        C(Pass.name(), llvm::Any(&IR));
+        C(Pass.name(), std::any(&IR));
     }
 
     return ShouldRun;
@@ -255,7 +255,7 @@ class PassInstrumentation {
                     const PreservedAnalyses &PA) const {
     if (Callbacks)
       for (auto &C : Callbacks->AfterPassCallbacks)
-        C(Pass.name(), llvm::Any(&IR), PA);
+        C(Pass.name(), std::any(&IR), PA);
   }
 
   /// AfterPassInvalidated instrumentation point - takes \p Pass instance
@@ -275,7 +275,7 @@ class PassInstrumentation {
   void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
     if (Callbacks)
       for (auto &C : Callbacks->BeforeAnalysisCallbacks)
-        C(Analysis.name(), llvm::Any(&IR));
+        C(Analysis.name(), std::any(&IR));
   }
 
   /// AfterAnalysis instrumentation point - takes \p Analysis instance
@@ -284,7 +284,7 @@ class PassInstrumentation {
   void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
     if (Callbacks)
       for (auto &C : Callbacks->AfterAnalysisCallbacks)
-        C(Analysis.name(), llvm::Any(&IR));
+        C(Analysis.name(), std::any(&IR));
   }
 
   /// AnalysisInvalidated instrumentation point - takes \p Analysis instance
@@ -294,7 +294,7 @@ class PassInstrumentation {
   void runAnalysisInvalidated(const PassT &Analysis, const IRUnitT &IR) const {
     if (Callbacks)
       for (auto &C : Callbacks->AnalysisInvalidatedCallbacks)
-        C(Analysis.name(), llvm::Any(&IR));
+        C(Analysis.name(), std::any(&IR));
   }
 
   /// AnalysesCleared instrumentation point - takes name of IR that analyses

llvm/include/llvm/Passes/StandardInstrumentations.h

@@ -46,16 +46,16 @@ class PrintIRInstrumentation {
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
-  void printBeforePass(StringRef PassID, Any IR);
-  void printAfterPass(StringRef PassID, Any IR);
+  void printBeforePass(StringRef PassID, std::any IR);
+  void printAfterPass(StringRef PassID, std::any IR);
   void printAfterPassInvalidated(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);
+  void pushModuleDesc(StringRef PassID, std::any IR);
   PrintModuleDesc popModuleDesc(StringRef PassID);
 
   PassInstrumentationCallbacks *PIC;
@@ -71,15 +71,15 @@ class OptNoneInstrumentation {
 
 private:
   bool DebugLogging;
-  bool shouldRun(StringRef PassID, Any IR);
+  bool shouldRun(StringRef PassID, std::any IR);
 };
 
 class OptPassGateInstrumentation {
   LLVMContext &Context;
   bool HasWrittenIR = false;
 public:
   OptPassGateInstrumentation(LLVMContext &Context) : Context(Context) {}
-  bool shouldRun(StringRef PassName, Any IR);
+  bool shouldRun(StringRef PassName, std::any IR);
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 };
 
@@ -181,9 +181,9 @@ template <typename IRUnitT> class 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, StringRef PassName);
+  void saveIRBeforePass(std::any IR, StringRef PassID, StringRef PassName);
   // Compare the IR from before the pass after the pass.
-  void handleIRAfterPass(Any IR, StringRef PassID, StringRef PassName);
+  void handleIRAfterPass(std::any IR, StringRef PassID, StringRef PassName);
   // Handle the situation where a pass is invalidated.
   void handleInvalidatedPass(StringRef PassID);
 
@@ -192,16 +192,16 @@ template <typename IRUnitT> class ChangeReporter {
   void registerRequiredCallbacks(PassInstrumentationCallbacks &PIC);
 
   // Called on the first IR processed.
-  virtual void handleInitialIR(Any IR) = 0;
+  virtual void handleInitialIR(std::any IR) = 0;
   // Called before and after a pass to get the representation of the IR.
-  virtual void generateIRRepresentation(Any IR, StringRef PassID,
+  virtual void generateIRRepresentation(std::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;
+                           std::any) = 0;
   // Called when an interesting pass is invalidated.
   virtual void handleInvalidated(StringRef PassID) = 0;
   // Called when the IR or pass is not interesting.
@@ -226,7 +226,7 @@ class TextChangeReporter : public ChangeReporter<IRUnitT> {
   TextChangeReporter(bool Verbose);
 
   // Print a module dump of the first IR that is changed.
-  void handleInitialIR(Any IR) override;
+  void handleInitialIR(std::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.
@@ -254,12 +254,12 @@ class IRChangedPrinter : public TextChangeReporter<std::string> {
 
 protected:
   // Called before and after a pass to get the representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
+  void generateIRRepresentation(std::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;
+                   std::any) override;
 };
 
 class IRChangedTester : public IRChangedPrinter {
@@ -272,7 +272,7 @@ class IRChangedTester : public IRChangedPrinter {
   void handleIR(const std::string &IR, StringRef PassID);
 
   // Check initial IR
-  void handleInitialIR(Any IR) override;
+  void handleInitialIR(std::any IR) override;
   // Do nothing.
   void omitAfter(StringRef PassID, std::string &Name) override;
   // Do nothing.
@@ -285,7 +285,7 @@ class IRChangedTester : public IRChangedPrinter {
   // Call test as interesting IR has changed.
   void handleAfter(StringRef PassID, std::string &Name,
                    const std::string &Before, const std::string &After,
-                   Any) override;
+                   std::any) override;
 };
 
 // Information that needs to be saved for a basic block in order to compare
@@ -385,7 +385,7 @@ template <typename T> class IRComparer {
           CompareFunc);
 
   // Analyze \p IR and build the IR representation in \p Data.
-  static void analyzeIR(Any IR, IRDataT<T> &Data);
+  static void analyzeIR(std::any IR, IRDataT<T> &Data);
 
 protected:
   // Generate the data for \p F into \p Data.
@@ -411,13 +411,13 @@ class InLineChangePrinter : public TextChangeReporter<IRDataT<EmptyData>> {
 
 protected:
   // Create a representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
+  void generateIRRepresentation(std::any IR, StringRef PassID,
                                 IRDataT<EmptyData> &Output) override;
 
   // Called when an interesting IR has changed.
   void handleAfter(StringRef PassID, std::string &Name,
                    const IRDataT<EmptyData> &Before,
-                   const IRDataT<EmptyData> &After, Any) override;
+                   const IRDataT<EmptyData> &After, std::any) override;
 
   void handleFunctionCompare(StringRef Name, StringRef Prefix, StringRef PassID,
                              StringRef Divider, bool InModule, unsigned Minor,
@@ -449,7 +449,7 @@ class TimeProfilingPassesHandler {
 
 private:
   // Implementation of pass instrumentation callbacks.
-  void runBeforePass(StringRef PassID, Any IR);
+  void runBeforePass(StringRef PassID, std::any IR);
   void runAfterPass();
 };
 
@@ -497,16 +497,16 @@ class DotCfgChangeReporter : public ChangeReporter<IRDataT<DCData>> {
   bool initializeHTML();
 
   // Called on the first IR processed.
-  void handleInitialIR(Any IR) override;
+  void handleInitialIR(std::any IR) override;
   // Called before and after a pass to get the representation of the IR.
-  void generateIRRepresentation(Any IR, StringRef PassID,
+  void generateIRRepresentation(std::any IR, StringRef PassID,
                                 IRDataT<DCData> &Output) override;
   // Called when the pass is not iteresting.
   void omitAfter(StringRef PassID, std::string &Name) override;
   // Called when an interesting IR has changed.
   void handleAfter(StringRef PassID, std::string &Name,
                    const IRDataT<DCData> &Before, const IRDataT<DCData> &After,
-                   Any) override;
+                   std::any) override;
   // Called when an interesting pass is invalidated.
   void handleInvalidated(StringRef PassID) override;
   // Called when the IR or pass is not interesting.

llvm/include/llvm/Transforms/IPO/SampleProfileProbe.h

@@ -61,7 +61,7 @@ class PseudoProbeVerifier {
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
   // Implementation of pass instrumentation callbacks for new pass manager.
-  void runAfterPass(StringRef PassID, Any IR);
+  void runAfterPass(StringRef PassID, std::any IR);
 
 private:
   // Allow a little bias due the rounding to integral factors.

llvm/lib/CodeGen/MachinePassManager.cpp

@@ -15,6 +15,8 @@
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/PassManagerImpl.h"
 
+#include <any>
+
 using namespace llvm;
 
 namespace llvm {
@@ -40,12 +42,12 @@ Error MachineFunctionPassManager::run(Module &M,
     // No need to pop this callback later since MIR pipeline is flat which means
     // current pipeline is the top-level pipeline. Callbacks are not used after
     // current pipeline.
-    PI.pushBeforeNonSkippedPassCallback([&MFAM](StringRef PassID, Any IR) {
-      assert(any_isa<const MachineFunction *>(IR));
-      const MachineFunction *MF = any_cast<const MachineFunction *>(IR);
+    PI.pushBeforeNonSkippedPassCallback([&MFAM](StringRef PassID, std::any IR) {
+      assert(std::any_cast<const MachineFunction *>(&IR));
+      const MachineFunction **MF = std::any_cast<const MachineFunction *>(&IR);
       assert(MF && "Machine function should be valid for printing");
       std::string Banner = std::string("After ") + std::string(PassID);
-      verifyMachineFunction(&MFAM, Banner, *MF);
+      verifyMachineFunction(&MFAM, Banner, **MF);
     });
   }
 

llvm/lib/CodeGen/TargetPassConfig.cpp

@@ -551,7 +551,7 @@ static void registerPartialPipelineCallback(PassInstrumentationCallbacks &PIC,
       [=, EnableCurrent = StartBefore.empty() && StartAfter.empty(),
        EnableNext = std::optional<bool>(), StartBeforeCount = 0u,
        StartAfterCount = 0u, StopBeforeCount = 0u,
-       StopAfterCount = 0u](StringRef P, Any) mutable {
+       StopAfterCount = 0u](StringRef P, std::any) mutable {
         bool StartBeforePass = !StartBefore.empty() && P.contains(StartBefore);
         bool StartAfterPass = !StartAfter.empty() && P.contains(StartAfter);
         bool StopBeforePass = !StopBefore.empty() && P.contains(StopBefore);
@@ -586,7 +586,7 @@ void llvm::registerCodeGenCallback(PassInstrumentationCallbacks &PIC,
                                    LLVMTargetMachine &LLVMTM) {
 
   // Register a callback for disabling passes.
-  PIC.registerShouldRunOptionalPassCallback([](StringRef P, Any) {
+  PIC.registerShouldRunOptionalPassCallback([](StringRef P, std::any) {
 
 #define DISABLE_PASS(Option, Name)                                             \
   if (Option && P.contains(#Name))                                             \

llvm/lib/IR/LLVMContextImpl.h

@@ -17,7 +17,6 @@
 #include "ConstantsContext.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
-#include "llvm/ADT/Any.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"

llvm/lib/IR/PassTimingInfo.cpp

@@ -26,6 +26,7 @@
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/TypeName.h"
 #include "llvm/Support/raw_ostream.h"
+#include <any>
 #include <string>
 
 using namespace llvm;
@@ -301,19 +302,19 @@ void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) {
     return;
 
   PIC.registerBeforeNonSkippedPassCallback(
-      [this](StringRef P, Any) { this->startPassTimer(P); });
+      [this](StringRef P, std::any) { this->startPassTimer(P); });
   PIC.registerAfterPassCallback(
-      [this](StringRef P, Any, const PreservedAnalyses &) {
+      [this](StringRef P, std::any, const PreservedAnalyses &) {
         this->stopPassTimer(P);
       });
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &) {
         this->stopPassTimer(P);
       });
   PIC.registerBeforeAnalysisCallback(
-      [this](StringRef P, Any) { this->startAnalysisTimer(P); });
+      [this](StringRef P, std::any) { this->startAnalysisTimer(P); });
   PIC.registerAfterAnalysisCallback(
-      [this](StringRef P, Any) { this->stopAnalysisTimer(P); });
+      [this](StringRef P, std::any) { this->stopAnalysisTimer(P); });
 }
 
 } // namespace llvm