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

[sebastian-ne]

Summary

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.

[sebastian-ne]

Seems like we can’t… msvc fails to link
https://developercommunity.visualstudio.com/t/stdany-doesnt-link-when-exceptions-are-disabled/376072

llvm/include/llvm/IR/PassInstrumentation.h

 ///    - Pass Manager requests PassInstrumentationAnalysis from analysis manager
 ///      and gets PassInstrumentation as its result.
 ///
 ///    - Pass Manager invokes PassInstrumentation entry points appropriately,
 ///      passing StringRef identification ("name") of the pass currently being
 ///      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.
 ///
 ///    - Some instrumentation points (BeforePass) allow to control execution
 ///      of a pass. For those callbacks returning false means pass will not be
 ///      executed.
 ///
 //===----------------------------------------------------------------------===//
 
 #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>
 
 namespace llvm {
 
 class PreservedAnalyses;
 class StringRef;
 
 /// This class manages callbacks registration, as well as provides a way for
 /// PassInstrumentation to pass control to the registered callbacks.
 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.
   // BeforeNonSkippedPassFuncs are called only if the pass should run.
   // TODO: currently AfterPassInvalidated does not accept IRUnit, since passing
   // 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:
   PassInstrumentationCallbacks() = default;
 
   /// Copying PassInstrumentationCallbacks is not intended.
   PassInstrumentationCallbacks(const PassInstrumentationCallbacks &) = delete;
   void operator=(const PassInstrumentationCallbacks &) = delete;
public:
   template <typename IRUnitT, typename PassT>
   bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
     if (!Callbacks)
       return true;
 
     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;
   }
 
   /// AfterPass instrumentation point - takes \p Pass instance that has
   /// just been executed and constant reference to \p IR it operates on.
   /// \p IR is guaranteed to be valid at this point.
   template <typename IRUnitT, typename PassT>
   void runAfterPass(const PassT &Pass, const IRUnitT &IR,
                     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
   /// that has just been executed. For use when IR has been invalidated
   /// by \p Pass execution.
   template <typename IRUnitT, typename PassT>
   void runAfterPassInvalidated(const PassT &Pass,
                                const PreservedAnalyses &PA) const {
     if (Callbacks)
       for (auto &C : Callbacks->AfterPassInvalidatedCallbacks)
         C(Pass.name(), PA);
   }
 
   /// BeforeAnalysis instrumentation point - takes \p Analysis instance
   /// to be executed and constant reference to IR it operates on.
   template <typename IRUnitT, typename PassT>
   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
   /// that has just been executed and constant reference to IR it operated on.
   template <typename IRUnitT, typename PassT>
   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
   /// that has just been invalidated and constant reference to IR it operated
   /// on.
   template <typename IRUnitT, typename PassT>
   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
   /// operated on.
   void runAnalysesCleared(StringRef Name) const {
     if (Callbacks)
       for (auto &C : Callbacks->AnalysesClearedCallbacks)
         C(Name);

llvm/include/llvm/Passes/StandardInstrumentations.h

 /// (typically Loop or SCC).
 class PrintIRInstrumentation {
 public:
   ~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;
   /// Stack of Module description, enough to print the module after a given
   /// pass.
   SmallVector<PrintModuleDesc, 2> ModuleDescStack;
 };
 
 class OptNoneInstrumentation {
 public:
   OptNoneInstrumentation(bool DebugLogging) : DebugLogging(DebugLogging) {}
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 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);
 };
 
 struct PrintPassOptions {
   /// Print adaptors and pass managers.
   bool Verbose = false;
   /// Don't print information for analyses.
   bool SkipAnalyses = false;

 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, 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);
 
 protected:
   // Register required callbacks.
   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.
   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;
 
   // 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;
+  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.
   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;

 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,
+  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 {
 public:
   IRChangedTester() : IRChangedPrinter(true) {}
   ~IRChangedTester() override;
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 protected:
   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.
   void handleInvalidated(StringRef PassID) override;
   // Do nothing.
   void handleFiltered(StringRef PassID, std::string &Name) override;
   // Do nothing.
   void handleIgnored(StringRef PassID, std::string &Name) override;
 
   // 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
 // before and after the pass to determine if it was changed by a pass.
 template <typename T> class BlockDataT {
 public:
   BlockDataT(const BasicBlock &B) : Label(B.getName().str()), Data(B) {
     raw_string_ostream SS(Body);
public:
   // this function is being handled as part of comparing a module.
   void compare(
       bool CompareModule,
       std::function<void(bool InModule, unsigned Minor,
                          const FuncDataT<T> &Before, const FuncDataT<T> &After)>
           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.
   static bool generateFunctionData(IRDataT<T> &Data, const Function &F);
 
   const IRDataT<T> &Before;
   const IRDataT<T> &After;
 };
public:
   InLineChangePrinter(bool VerboseMode, bool ColourMode)
       : TextChangeReporter<IRDataT<EmptyData>>(VerboseMode),
         UseColour(ColourMode) {}
   ~InLineChangePrinter() override;
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 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,
                              const FuncDataT<EmptyData> &Before,
                              const FuncDataT<EmptyData> &After);
 
   bool UseColour;
 };
public:
   // We intend this to be unique per-compilation, thus no copies.
   TimeProfilingPassesHandler(const TimeProfilingPassesHandler &) = delete;
   void operator=(const TimeProfilingPassesHandler &) = delete;
 
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 private:
   // Implementation of pass instrumentation callbacks.
-  void runBeforePass(StringRef PassID, Any IR);
+  void runBeforePass(StringRef PassID, std::any IR);
   void runAfterPass();
 };
 
 // Class that holds transitions between basic blocks.  The transitions
 // are contained in a map of values to names of basic blocks.
 class DCData {
 public:
   // Fill the map with the transitions from basic block \p B.
public:
   ~DotCfgChangeReporter() override;
   void registerCallbacks(PassInstrumentationCallbacks &PIC);
 
 protected:
   // Initialize the HTML file and output the header.
   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.
   void handleFiltered(StringRef PassID, std::string &Name) override;
   // Called when an ignored pass is encountered.
   void handleIgnored(StringRef PassID, std::string &Name) override;
 
   // Generate the pdf file into \p Dir / \p PDFFileName using \p DotFile as

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

 // 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);
+  void runAfterPass(StringRef PassID, std::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);

llvm/lib/CodeGen/MachinePassManager.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/MachinePassManager.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/PassManagerImpl.h"
 
+#include <any>
+
 using namespace llvm;
 
 namespace llvm {
 template class AllAnalysesOn<MachineFunction>;
 template class AnalysisManager<MachineFunction>;
 template class PassManager<MachineFunction>;
 
 Error MachineFunctionPassManager::run(Module &M,
Error MachineFunctionPassManager::run(Module &M,
 
   // Add a PIC to verify machine functions.
   if (VerifyMachineFunction) {
     PassInstrumentation PI = MFAM.getResult<PassInstrumentationAnalysis>(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);
     });
   }
 
   for (auto &F : InitializationFuncs) {
     if (auto Err = F(M, MFAM))
       return Err;
   }
 

llvm/lib/CodeGen/TargetPassConfig.cpp

static void registerPartialPipelineCallback(PassInstrumentationCallbacks &PIC,
   if (!StopBefore.empty() && !StopAfter.empty())
     report_fatal_error(Twine(StopBeforeOptName) + Twine(" and ") +
                        Twine(StopAfterOptName) + Twine(" specified!"));
 
   PIC.registerShouldRunOptionalPassCallback(
       [=, 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);
         bool StopAfterPass = !StopAfter.empty() && P.contains(StopAfter);
 
         // Implement -start-after/-stop-after
         if (EnableNext) {
           EnableCurrent = *EnableNext;
PIC.registerShouldRunOptionalPassCallback(
         return EnableCurrent;
       });
 }
 
 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))                                             \
     return false;
     DISABLE_PASS(DisableBlockPlacement, MachineBlockPlacementPass)
     DISABLE_PASS(DisableBranchFold, BranchFolderPass)
     DISABLE_PASS(DisableCopyProp, MachineCopyPropagationPass)
     DISABLE_PASS(DisableEarlyIfConversion, EarlyIfConverterPass)

llvm/lib/IR/LLVMContextImpl.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_IR_LLVMCONTEXTIMPL_H
 #define LLVM_LIB_IR_LLVMCONTEXTIMPL_H
 
 #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"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"

llvm/lib/IR/PassTimingInfo.cpp

 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/TypeName.h"
 #include "llvm/Support/raw_ostream.h"
+#include <any>
 #include <string>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "time-passes"
 
 namespace llvm {
 
void TimePassesHandler::stopAnalysisTimer(StringRef PassID) {
   }
 }
 
 void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (!Enabled)
     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

llvm/lib/Passes/StandardInstrumentations.cpp

 //===- Standard pass instrumentations handling ----------------*- C++ -*--===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines IR-printing pass instrumentation callbacks as well as
 /// StandardInstrumentations class that manages standard pass instrumentations.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Passes/StandardInstrumentations.h"
-#include "llvm/ADT/Any.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PrintPasses.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
+#include <any>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 cl::opt<bool> PreservedCFGCheckerInstrumentation::VerifyPreservedCFG(

 // The usual modifier options work as expected.
 static cl::opt<std::string>
     TestChanged("exec-on-ir-change", cl::Hidden, cl::init(""),
                 cl::desc("exe called with module IR after each pass that "
                          "changes it"));
 
 /// Extract Module out of \p IR unit. May return nullptr if \p IR does not match
 /// certain global filters. Will never return nullptr if \p Force is true.
-const Module *unwrapModule(Any IR, bool Force = false) {
-  if (any_isa<const Module *>(IR))
-    return any_cast<const Module *>(IR);
+const Module *unwrapModule(std::any IR, bool Force = false) {
+  if (const auto **M = std::any_cast<const Module *>(&IR))
+    return *M;
 
-  if (any_isa<const Function *>(IR)) {
-    const Function *F = any_cast<const Function *>(IR);
-    if (!Force && !isFunctionInPrintList(F->getName()))
+  if (const auto **F = std::any_cast<const Function *>(&IR)) {
+    if (!Force && !isFunctionInPrintList((*F)->getName()))
       return nullptr;
 
-    return F->getParent();
+    return (*F)->getParent();
   }
 
-  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
-    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
-    for (const LazyCallGraph::Node &N : *C) {
+  if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR)) {
+    for (const LazyCallGraph::Node &N : **C) {
       const Function &F = N.getFunction();
       if (Force || (!F.isDeclaration() && isFunctionInPrintList(F.getName()))) {
         return F.getParent();
       }
     }
     assert(!Force && "Expected a module");
     return nullptr;
   }
 
-  if (any_isa<const Loop *>(IR)) {
-    const Loop *L = any_cast<const Loop *>(IR);
-    const Function *F = L->getHeader()->getParent();
+  if (const auto **L = std::any_cast<const Loop *>(&IR)) {
+    const Function *F = (*L)->getHeader()->getParent();
     if (!Force && !isFunctionInPrintList(F->getName()))
       return nullptr;
     return F->getParent();
   }
 
   llvm_unreachable("Unknown IR unit");
 }
 

 
 void printIR(raw_ostream &OS, const Loop *L) {
   const Function *F = L->getHeader()->getParent();
   if (!isFunctionInPrintList(F->getName()))
     return;
   printLoop(const_cast<Loop &>(*L), OS);
 }
 
-std::string getIRName(Any IR) {
-  if (any_isa<const Module *>(IR))
+std::string getIRName(std::any IR) {
+  if (std::any_cast<const Module *>(&IR))
     return "[module]";
 
-  if (any_isa<const Function *>(IR)) {
-    const Function *F = any_cast<const Function *>(IR);
-    return F->getName().str();
+  if (const auto **F = std::any_cast<const Function *>(&IR)) {
+    return (*F)->getName().str();
   }
 
-  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
-    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
-    return C->getName();
+  if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR)) {
+    return (*C)->getName();
   }
 
-  if (any_isa<const Loop *>(IR)) {
-    const Loop *L = any_cast<const Loop *>(IR);
-    return L->getName().str();
+  if (const auto **L = std::any_cast<const Loop *>(&IR)) {
+    return (*L)->getName().str();
   }
 
   llvm_unreachable("Unknown wrapped IR type");
 }
 
 bool moduleContainsFilterPrintFunc(const Module &M) {
   return any_of(M.functions(),
                 [](const Function &F) {
                   return isFunctionInPrintList(F.getName());
                 }) ||
          isFunctionInPrintList("*");
 }
 
 bool sccContainsFilterPrintFunc(const LazyCallGraph::SCC &C) {
   return any_of(C,
                 [](const LazyCallGraph::Node &N) {
                   return isFunctionInPrintList(N.getName());
                 }) ||
          isFunctionInPrintList("*");
 }
 
-bool shouldPrintIR(Any IR) {
-  if (any_isa<const Module *>(IR)) {
-    const Module *M = any_cast<const Module *>(IR);
-    return moduleContainsFilterPrintFunc(*M);
+bool shouldPrintIR(std::any IR) {
+  if (const auto **M = std::any_cast<const Module *>(&IR)) {
+    return moduleContainsFilterPrintFunc(**M);
   }
 
-  if (any_isa<const Function *>(IR)) {
-    const Function *F = any_cast<const Function *>(IR);
-    return isFunctionInPrintList(F->getName());
+  if (const auto **F = std::any_cast<const Function *>(&IR)) {
+    return isFunctionInPrintList((*F)->getName());
   }
 
-  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
-    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
-    return sccContainsFilterPrintFunc(*C);
+  if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR)) {
+    return sccContainsFilterPrintFunc(**C);
   }
 
-  if (any_isa<const Loop *>(IR)) {
-    const Loop *L = any_cast<const Loop *>(IR);
-    return isFunctionInPrintList(L->getHeader()->getParent()->getName());
+  if (const auto **L = std::any_cast<const Loop *>(&IR)) {
+    return isFunctionInPrintList((*L)->getHeader()->getParent()->getName());
   }
   llvm_unreachable("Unknown wrapped IR type");
 }
 
 /// Generic IR-printing helper that unpacks a pointer to IRUnit wrapped into
-/// llvm::Any and does actual print job.
-void unwrapAndPrint(raw_ostream &OS, Any IR) {
+/// std::any and does actual print job.
+void unwrapAndPrint(raw_ostream &OS, std::any IR) {
   if (!shouldPrintIR(IR))
     return;
 
   if (forcePrintModuleIR()) {
     auto *M = unwrapModule(IR);
     assert(M && "should have unwrapped module");
     printIR(OS, M);
     return;
   }
 
-  if (any_isa<const Module *>(IR)) {
-    const Module *M = any_cast<const Module *>(IR);
-    printIR(OS, M);
+  if (const auto **M = std::any_cast<const Module *>(&IR)) {
+    printIR(OS, *M);
     return;
   }
 
-  if (any_isa<const Function *>(IR)) {
-    const Function *F = any_cast<const Function *>(IR);
-    printIR(OS, F);
+  if (const auto **F = std::any_cast<const Function *>(&IR)) {
+    printIR(OS, *F);
     return;
   }
 
-  if (any_isa<const LazyCallGraph::SCC *>(IR)) {
-    const LazyCallGraph::SCC *C = any_cast<const LazyCallGraph::SCC *>(IR);
-    printIR(OS, C);
+  if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR)) {
+    printIR(OS, *C);
     return;
   }
 
-  if (any_isa<const Loop *>(IR)) {
-    const Loop *L = any_cast<const Loop *>(IR);
-    printIR(OS, L);
+  if (const auto **L = std::any_cast<const Loop *>(&IR)) {
+    printIR(OS, *L);
     return;
   }
   llvm_unreachable("Unknown wrapped IR type");
 }
 
 // Return true when this is a pass for which changes should be ignored
 bool isIgnored(StringRef PassID) {
   return isSpecialPass(PassID,
if (SR.size() == 0)
       return S;
     S.append(SR[0] == '<' ? "&lt;" : "&gt;");
     SR = SR.drop_front();
   }
   llvm_unreachable("problems converting string to HTML");
 }
 
 // Return the module when that is the appropriate level of comparison for \p IR.
-const Module *getModuleForComparison(Any IR) {
-  if (any_isa<const Module *>(IR))
-    return any_cast<const Module *>(IR);
-  if (any_isa<const LazyCallGraph::SCC *>(IR))
-    return any_cast<const LazyCallGraph::SCC *>(IR)
+const Module *getModuleForComparison(std::any IR) {
+  if (const auto **M = std::any_cast<const Module *>(&IR))
+    return *M;
+  if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR))
+    return (*C)
         ->begin()
         ->getFunction()
         .getParent();
   return nullptr;
 }
 
 bool isInterestingFunction(const Function &F) {
   return isFunctionInPrintList(F.getName());
 }
 
 // Return true when this is a pass on IR for which printing
 // of changes is desired.
-bool isInteresting(Any IR, StringRef PassID, StringRef PassName) {
+bool isInteresting(std::any IR, StringRef PassID, StringRef PassName) {
   if (isIgnored(PassID) || !isPassInPrintList(PassName))
     return false;
-  if (any_isa<const Function *>(IR))
-    return isInterestingFunction(*any_cast<const Function *>(IR));
+  if (const auto **F = std::any_cast<const Function *>(&IR))
+    return isInterestingFunction(**F);
   return true;
 }
 
 } // namespace
 
 template <typename T> ChangeReporter<T>::~ChangeReporter() {
   assert(BeforeStack.empty() && "Problem with Change Printer stack.");
 }
 
 template <typename T>
-void ChangeReporter<T>::saveIRBeforePass(Any IR, StringRef PassID,
+void ChangeReporter<T>::saveIRBeforePass(std::any IR, StringRef PassID,
                                          StringRef PassName) {
   // Always need to place something on the stack because invalidated passes
   // are not given the IR so it cannot be determined whether the pass was for
   // something that was filtered out.
   BeforeStack.emplace_back();
 
   if (!isInteresting(IR, PassID, PassName))
     return;
   // Is this the initial IR?
   if (InitialIR) {
     InitialIR = false;
     if (VerboseMode)
       handleInitialIR(IR);
   }
 
   // Save the IR representation on the stack.
   T &Data = BeforeStack.back();
   generateIRRepresentation(IR, PassID, Data);
 }
 
 template <typename T>
-void ChangeReporter<T>::handleIRAfterPass(Any IR, StringRef PassID,
+void ChangeReporter<T>::handleIRAfterPass(std::any IR, StringRef PassID,
                                           StringRef PassName) {
   assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
 
   std::string Name = getIRName(IR);
 
   if (isIgnored(PassID)) {
     if (VerboseMode)
       handleIgnored(PassID, Name);
void ChangeReporter<T>::handleInvalidatedPass(StringRef PassID) {
   if (VerboseMode)
     handleInvalidated(PassID);
   BeforeStack.pop_back();
 }
 
 template <typename T>
 void ChangeReporter<T>::registerRequiredCallbacks(
     PassInstrumentationCallbacks &PIC) {
-  PIC.registerBeforeNonSkippedPassCallback([&PIC, this](StringRef P, Any IR) {
+  PIC.registerBeforeNonSkippedPassCallback([&PIC, this](StringRef P, std::any IR) {
     saveIRBeforePass(IR, P, PIC.getPassNameForClassName(P));
   });
 
   PIC.registerAfterPassCallback(
-      [&PIC, this](StringRef P, Any IR, const PreservedAnalyses &) {
+      [&PIC, this](StringRef P, std::any IR, const PreservedAnalyses &) {
         handleIRAfterPass(IR, P, PIC.getPassNameForClassName(P));
       });
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &) {
         handleInvalidatedPass(P);
       });
 }
 
 template <typename T>
 TextChangeReporter<T>::TextChangeReporter(bool Verbose)
     : ChangeReporter<T>(Verbose), Out(dbgs()) {}
 
-template <typename T> void TextChangeReporter<T>::handleInitialIR(Any IR) {
+template <typename T> void TextChangeReporter<T>::handleInitialIR(std::any IR) {
   // Always print the module.
   // Unwrap and print directly to avoid filtering problems in general routines.
   auto *M = unwrapModule(IR, /*Force=*/true);
   assert(M && "Expected module to be unwrapped when forced.");
   Out << "*** IR Dump At Start ***\n";
   M->print(Out, nullptr);
 }
 

 IRChangedPrinter::~IRChangedPrinter() = default;
 
 void IRChangedPrinter::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (PrintChanged == ChangePrinter::Verbose ||
       PrintChanged == ChangePrinter::Quiet)
     TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
 }
 
-void IRChangedPrinter::generateIRRepresentation(Any IR, StringRef PassID,
+void IRChangedPrinter::generateIRRepresentation(std::any IR, StringRef PassID,
                                                 std::string &Output) {
   raw_string_ostream OS(Output);
   unwrapAndPrint(OS, IR);
   OS.str();
 }
 
 void IRChangedPrinter::handleAfter(StringRef PassID, std::string &Name,
                                    const std::string &Before,
-                                   const std::string &After, Any) {
+                                   const std::string &After, std::any) {
   // Report the IR before the changes when requested.
   if (PrintChangedBefore)
     Out << "*** IR Dump Before " << PassID << " on " << Name << " ***\n"
         << Before;
 
   // We might not get anything to print if we only want to print a specific
   // function but it gets deleted.
   if (After.empty()) {
if (Result < 0) {
     dbgs() << "Error executing test-changed executable.";
     return;
   }
 
   if (auto Err = cleanUpTempFiles(FileName))
     dbgs() << "Unable to remove temporary file.";
 }
 
-void IRChangedTester::handleInitialIR(Any IR) {
+void IRChangedTester::handleInitialIR(std::any IR) {
   // Always test the initial module.
   // Unwrap and print directly to avoid filtering problems in general routines.
   std::string S;
   generateIRRepresentation(IR, "Initial IR", S);
   handleIR(S, "Initial IR");
 }
 
 void IRChangedTester::omitAfter(StringRef PassID, std::string &Name) {}
 void IRChangedTester::handleInvalidated(StringRef PassID) {}
 void IRChangedTester::handleFiltered(StringRef PassID, std::string &Name) {}
 void IRChangedTester::handleIgnored(StringRef PassID, std::string &Name) {}
 void IRChangedTester::handleAfter(StringRef PassID, std::string &Name,
                                   const std::string &Before,
-                                  const std::string &After, Any) {
+                                  const std::string &After, std::any) {
   handleIR(After, PassID);
 }
 
 template <typename T>
 void OrderedChangedData<T>::report(
     const OrderedChangedData &Before, const OrderedChangedData &After,
     function_ref<void(const T *, const T *)> HandlePair) {
   const auto &BFD = Before.getData();
IRDataT<T>::report(Before, After,
                        if (!B)
                          B = &Missing;
                        else if (!A)
                          A = &Missing;
                        CompareFunc(true, Minor++, *B, *A);
                      });
 }
 
-template <typename T> void IRComparer<T>::analyzeIR(Any IR, IRDataT<T> &Data) {
+template <typename T>
+void IRComparer<T>::analyzeIR(std::any IR, IRDataT<T> &Data) {
   if (const Module *M = getModuleForComparison(IR)) {
     // Create data for each existing/interesting function in the module.
     for (const Function &F : *M)
       generateFunctionData(Data, F);
     return;
   }
 
-  const Function *F = nullptr;
-  if (any_isa<const Function *>(IR))
-    F = any_cast<const Function *>(IR);
-  else {
-    assert(any_isa<const Loop *>(IR) && "Unknown IR unit.");
-    const Loop *L = any_cast<const Loop *>(IR);
-    F = L->getHeader()->getParent();
+  const Function **FPtr = std::any_cast<const Function *>(&IR);
+  const Function *F = FPtr ? *FPtr : nullptr;
+  if (!F) {
+    const Loop **L = std::any_cast<const Loop *>(&IR);
+    assert(L && "Unknown IR unit.");
+    F = (*L)->getHeader()->getParent();
   }
   assert(F && "Unknown IR unit.");
   generateFunctionData(Data, *F);
 }
 
 template <typename T>
 bool IRComparer<T>::generateFunctionData(IRDataT<T> &Data, const Function &F) {
   if (!F.isDeclaration() && isFunctionInPrintList(F.getName())) {
bool IRComparer<T>::generateFunctionData(IRDataT<T> &Data, const Function &F) {
   }
   return false;
 }
 
 PrintIRInstrumentation::~PrintIRInstrumentation() {
   assert(ModuleDescStack.empty() && "ModuleDescStack is not empty at exit");
 }
 
-void PrintIRInstrumentation::pushModuleDesc(StringRef PassID, Any IR) {
+void PrintIRInstrumentation::pushModuleDesc(StringRef PassID, std::any IR) {
   const Module *M = unwrapModule(IR);
   ModuleDescStack.emplace_back(M, getIRName(IR), PassID);
 }
 
 PrintIRInstrumentation::PrintModuleDesc
 PrintIRInstrumentation::popModuleDesc(StringRef PassID) {
   assert(!ModuleDescStack.empty() && "empty ModuleDescStack");
   PrintModuleDesc ModuleDesc = ModuleDescStack.pop_back_val();
   assert(std::get<2>(ModuleDesc).equals(PassID) && "malformed ModuleDescStack");
   return ModuleDesc;
 }
 
-void PrintIRInstrumentation::printBeforePass(StringRef PassID, Any IR) {
+void PrintIRInstrumentation::printBeforePass(StringRef PassID, std::any IR) {
   if (isIgnored(PassID))
     return;
 
   // Saving Module for AfterPassInvalidated operations.
   // Note: here we rely on a fact that we do not change modules while
   // traversing the pipeline, so the latest captured module is good
   // for all print operations that has not happen yet.
   if (shouldPrintAfterPass(PassID))
     pushModuleDesc(PassID, IR);
 
   if (!shouldPrintBeforePass(PassID))
     return;
 
   if (!shouldPrintIR(IR))
     return;
 
   dbgs() << "*** IR Dump Before " << PassID << " on " << getIRName(IR)
          << " ***\n";
   unwrapAndPrint(dbgs(), IR);
 }
 
-void PrintIRInstrumentation::printAfterPass(StringRef PassID, Any IR) {
+void PrintIRInstrumentation::printAfterPass(StringRef PassID, std::any IR) {
   if (isIgnored(PassID))
     return;
 
   if (!shouldPrintAfterPass(PassID))
     return;
 
   const Module *M;
   std::string IRName;

 void PrintIRInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   this->PIC = &PIC;
 
   // BeforePass callback is not just for printing, it also saves a Module
   // for later use in AfterPassInvalidated.
   if (shouldPrintBeforeSomePass() || shouldPrintAfterSomePass())
     PIC.registerBeforeNonSkippedPassCallback(
-        [this](StringRef P, Any IR) { this->printBeforePass(P, IR); });
+        [this](StringRef P, std::any IR) { this->printBeforePass(P, IR); });
 
   if (shouldPrintAfterSomePass()) {
     PIC.registerAfterPassCallback(
-        [this](StringRef P, Any IR, const PreservedAnalyses &) {
+        [this](StringRef P, std::any IR, const PreservedAnalyses &) {
           this->printAfterPass(P, IR);
         });
     PIC.registerAfterPassInvalidatedCallback(
         [this](StringRef P, const PreservedAnalyses &) {
           this->printAfterPassInvalidated(P);
         });
   }
 }
 
 void OptNoneInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerShouldRunOptionalPassCallback(
-      [this](StringRef P, Any IR) { return this->shouldRun(P, IR); });
+      [this](StringRef P, std::any IR) { return this->shouldRun(P, IR); });
 }
 
-bool OptNoneInstrumentation::shouldRun(StringRef PassID, Any IR) {
-  const Function *F = nullptr;
-  if (any_isa<const Function *>(IR)) {
-    F = any_cast<const Function *>(IR);
-  } else if (any_isa<const Loop *>(IR)) {
-    F = any_cast<const Loop *>(IR)->getHeader()->getParent();
+bool OptNoneInstrumentation::shouldRun(StringRef PassID, std::any IR) {
+  const Function **FPtr = std::any_cast<const Function *>(&IR);
+  const Function *F = FPtr ? *FPtr : nullptr;
+  if (!F) {
+    if (const auto **L = std::any_cast<const Loop *>(&IR))
+      F = (*L)->getHeader()->getParent();
   }
   bool ShouldRun = !(F && F->hasOptNone());
   if (!ShouldRun && DebugLogging) {
     errs() << "Skipping pass " << PassID << " on " << F->getName()
            << " due to optnone attribute\n";
   }
   return ShouldRun;
 }
 
-bool OptPassGateInstrumentation::shouldRun(StringRef PassName, Any IR) {
+bool OptPassGateInstrumentation::shouldRun(StringRef PassName, std::any IR) {
   if (isIgnored(PassName))
     return true;
 
   bool ShouldRun =
       Context.getOptPassGate().shouldRunPass(PassName, getIRName(IR));
   if (!ShouldRun && !this->HasWrittenIR && !OptBisectPrintIRPath.empty()) {
     // FIXME: print IR if limit is higher than number of opt-bisect
     // invocations

 }
 
 void OptPassGateInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   OptPassGate &PassGate = Context.getOptPassGate();
   if (!PassGate.isEnabled())
     return;
 
-  PIC.registerShouldRunOptionalPassCallback([this](StringRef PassName, Any IR) {
+  PIC.registerShouldRunOptionalPassCallback([this](StringRef PassName, std::any IR) {
     return this->shouldRun(PassName, IR);
   });
 }
 
 raw_ostream &PrintPassInstrumentation::print() {
   if (Opts.Indent) {
     assert(Indent >= 0);
     dbgs().indent(Indent);
   }
   return dbgs();
 }
 
 void PrintPassInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!Enabled)
     return;
 
   std::vector<StringRef> SpecialPasses;
   if (!Opts.Verbose) {
     SpecialPasses.emplace_back("PassManager");
     SpecialPasses.emplace_back("PassAdaptor");
   }
 
   PIC.registerBeforeSkippedPassCallback([this, SpecialPasses](StringRef PassID,
-                                                              Any IR) {
+                                                              std::any IR) {
     assert(!isSpecialPass(PassID, SpecialPasses) &&
            "Unexpectedly skipping special pass");
 
     print() << "Skipping pass: " << PassID << " on " << getIRName(IR) << "\n";
   });
   PIC.registerBeforeNonSkippedPassCallback([this, SpecialPasses](
-                                               StringRef PassID, Any IR) {
+                                               StringRef PassID, std::any IR) {
     if (isSpecialPass(PassID, SpecialPasses))
       return;
 
     auto &OS = print();
     OS << "Running pass: " << PassID << " on " << getIRName(IR);
-    if (any_isa<const Function *>(IR)) {
-      unsigned Count = any_cast<const Function *>(IR)->getInstructionCount();
+    if (const auto **F = std::any_cast<const Function *>(&IR)) {
+      unsigned Count = (*F)->getInstructionCount();
       OS << " (" << Count << " instruction";
       if (Count != 1)
         OS << 's';
       OS << ')';
-    } else if (any_isa<const LazyCallGraph::SCC *>(IR)) {
-      int Count = any_cast<const LazyCallGraph::SCC *>(IR)->size();
+    } else if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR)) {
+      int Count = (*C)->size();
       OS << " (" << Count << " node";
       if (Count != 1)
         OS << 's';
       OS << ')';
     }
     OS << "\n";
     Indent += 2;
   });
   PIC.registerAfterPassCallback(
-      [this, SpecialPasses](StringRef PassID, Any IR,
+      [this, SpecialPasses](StringRef PassID, std::any IR,
                             const PreservedAnalyses &) {
         if (isSpecialPass(PassID, SpecialPasses))
           return;
 
         Indent -= 2;
       });
   PIC.registerAfterPassInvalidatedCallback(
-      [this, SpecialPasses](StringRef PassID, Any IR) {
+      [this, SpecialPasses](StringRef PassID, std::any IR) {
         if (isSpecialPass(PassID, SpecialPasses))
           return;
 
         Indent -= 2;
       });
 
   if (!Opts.SkipAnalyses) {
-    PIC.registerBeforeAnalysisCallback([this](StringRef PassID, Any IR) {
+    PIC.registerBeforeAnalysisCallback([this](StringRef PassID, std::any IR) {
       print() << "Running analysis: " << PassID << " on " << getIRName(IR)
               << "\n";
       Indent += 2;
     });
     PIC.registerAfterAnalysisCallback(
-        [this](StringRef PassID, Any IR) { Indent -= 2; });
-    PIC.registerAnalysisInvalidatedCallback([this](StringRef PassID, Any IR) {
+        [this](StringRef PassID, std::any IR) { Indent -= 2; });
+    PIC.registerAnalysisInvalidatedCallback([this](StringRef PassID,
+                                                   std::any IR) {
       print() << "Invalidating analysis: " << PassID << " on " << getIRName(IR)
               << "\n";
     });
     PIC.registerAnalysesClearedCallback([this](StringRef IRName) {
       print() << "Clearing all analysis results for: " << IRName << "\n";
     });
   }
 }
auto checkCFG = [](StringRef Pass, StringRef FuncName, const CFG &GraphBefore,
     dbgs() << "Error: " << Pass
            << " does not invalidate CFG analyses but CFG changes detected in "
               "function @"
            << FuncName << ":\n";
     CFG::printDiff(dbgs(), GraphBefore, GraphAfter);
     report_fatal_error(Twine("CFG unexpectedly changed by ", Pass));
   };
 
-  PIC.registerBeforeNonSkippedPassCallback([this, &FAM](StringRef P, Any IR) {
+  PIC.registerBeforeNonSkippedPassCallback(
+      [this, &FAM](StringRef P, std::any IR) {
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
         assert(&PassStack.emplace_back(P));
 #endif
         (void)this;
-    if (!any_isa<const Function *>(IR))
+        const auto **F = std::any_cast<const Function *>(&IR);
+        if (!F)
           return;
 
-    const auto *F = any_cast<const Function *>(IR);
         // Make sure a fresh CFG snapshot is available before the pass.
-    FAM.getResult<PreservedCFGCheckerAnalysis>(*const_cast<Function *>(F));
+        FAM.getResult<PreservedCFGCheckerAnalysis>(*const_cast<Function *>(*F));
       });
 
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &PassPA) {
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
         assert(PassStack.pop_back_val() == P &&
                "Before and After callbacks must correspond");
 #endif
         (void)this;
       });
 
   PIC.registerAfterPassCallback([this, &FAM,
-                                 checkCFG](StringRef P, Any IR,
+                                 checkCFG](StringRef P, std::any IR,
                                            const PreservedAnalyses &PassPA) {
 #ifdef LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(PassStack.pop_back_val() == P &&
            "Before and After callbacks must correspond");
 #endif
     (void)this;
 
-    if (!any_isa<const Function *>(IR))
+    const auto **F = std::any_cast<const Function *>(&IR);
+    if (!F)
       return;
 
     if (!PassPA.allAnalysesInSetPreserved<CFGAnalyses>() &&
         !PassPA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>())
       return;
 
-    const auto *F = any_cast<const Function *>(IR);
     if (auto *GraphBefore = FAM.getCachedResult<PreservedCFGCheckerAnalysis>(
-            *const_cast<Function *>(F)))
-      checkCFG(P, F->getName(), *GraphBefore,
-               CFG(F, /* TrackBBLifetime */ false));
+            *const_cast<Function *>(*F)))
+      checkCFG(P, (*F)->getName(), *GraphBefore,
+               CFG(*F, /* TrackBBLifetime */ false));
   });
 }
 
 void VerifyInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerAfterPassCallback(
-      [this](StringRef P, Any IR, const PreservedAnalyses &PassPA) {
+      [this](StringRef P, std::any IR, const PreservedAnalyses &PassPA) {
         if (isIgnored(P) || P == "VerifierPass")
           return;
-        if (any_isa<const Function *>(IR) || any_isa<const Loop *>(IR)) {
-          const Function *F;
-          if (any_isa<const Loop *>(IR))
-            F = any_cast<const Loop *>(IR)->getHeader()->getParent();
-          else
-            F = any_cast<const Function *>(IR);
+        const Function **FPtr = std::any_cast<const Function *>(&IR);
+        const Function *F = FPtr ? *FPtr : nullptr;
+        if (!F) {
+          if (const auto **L = std::any_cast<const Loop *>(&IR))
+            F = (*L)->getHeader()->getParent();
+        }
+
+        if (F) {
           if (DebugLogging)
             dbgs() << "Verifying function " << F->getName() << "\n";
 
           if (verifyFunction(*F, &errs()))
             report_fatal_error("Broken function found, compilation aborted!");
-        } else if (any_isa<const Module *>(IR) ||
-                   any_isa<const LazyCallGraph::SCC *>(IR)) {
-          const Module *M;
-          if (any_isa<const LazyCallGraph::SCC *>(IR))
-            M = any_cast<const LazyCallGraph::SCC *>(IR)
-                    ->begin()
-                    ->getFunction()
-                    .getParent();
-          else
-            M = any_cast<const Module *>(IR);
+        } else {
+          const Module **MPtr = std::any_cast<const Module *>(&IR);
+          const Module *M = MPtr ? *MPtr : nullptr;
+          if (!M) {
+            if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR))
+              M = (*C)->begin()->getFunction().getParent();
+          }
+
+          if (M) {
             if (DebugLogging)
               dbgs() << "Verifying module " << M->getName() << "\n";
 
             if (verifyModule(*M, &errs()))
               report_fatal_error("Broken module found, compilation aborted!");
           }
+        }
       });
 }
 
 InLineChangePrinter::~InLineChangePrinter() = default;
 
-void InLineChangePrinter::generateIRRepresentation(Any IR, StringRef PassID,
+void InLineChangePrinter::generateIRRepresentation(std::any IR,
+                                                   StringRef PassID,
                                                    IRDataT<EmptyData> &D) {
   IRComparer<EmptyData>::analyzeIR(IR, D);
 }
 
 void InLineChangePrinter::handleAfter(StringRef PassID, std::string &Name,
                                       const IRDataT<EmptyData> &Before,
-                                      const IRDataT<EmptyData> &After, Any IR) {
+                                      const IRDataT<EmptyData> &After,
+                                      std::any IR) {
   SmallString<20> Banner =
       formatv("*** IR Dump After {0} on {1} ***\n", PassID, Name);
   Out << Banner;
   IRComparer<EmptyData>(Before, After)
       .compare(getModuleForComparison(IR),
                [&](bool InModule, unsigned Minor,
                    const FuncDataT<EmptyData> &Before,
                    const FuncDataT<EmptyData> &After) -> void {

 
 TimeProfilingPassesHandler::TimeProfilingPassesHandler() {}
 
 void TimeProfilingPassesHandler::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!getTimeTraceProfilerInstance())
     return;
   PIC.registerBeforeNonSkippedPassCallback(
-      [this](StringRef P, Any IR) { this->runBeforePass(P, IR); });
+      [this](StringRef P, std::any IR) { this->runBeforePass(P, IR); });
   PIC.registerAfterPassCallback(
-      [this](StringRef P, Any IR, const PreservedAnalyses &) {
+      [this](StringRef P, std::any IR, const PreservedAnalyses &) {
         this->runAfterPass();
       },
       true);
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &) { this->runAfterPass(); },
       true);
   PIC.registerBeforeAnalysisCallback(
-      [this](StringRef P, Any IR) { this->runBeforePass(P, IR); });
+      [this](StringRef P, std::any IR) { this->runBeforePass(P, IR); });
   PIC.registerAfterAnalysisCallback(
-      [this](StringRef P, Any IR) { this->runAfterPass(); }, true);
+      [this](StringRef P, std::any IR) { this->runAfterPass(); }, true);
 }
 
-void TimeProfilingPassesHandler::runBeforePass(StringRef PassID, Any IR) {
+void TimeProfilingPassesHandler::runBeforePass(StringRef PassID, std::any IR) {
   timeTraceProfilerBegin(PassID, getIRName(IR));
 }
 
 void TimeProfilingPassesHandler::runAfterPass() { timeTraceProfilerEnd(); }
 
 namespace {
 
 class DisplayNode;
if (Result < 0)
     return "Error executing system dot.";
 
   // Create the HTML tag refering to the PDF file.
   SmallString<200> S = formatv(
       "  <a href=\"{0}\" target=\"_blank\">{1}</a><br/>\n", PDFFileName, Text);
   return S.c_str();
 }
 
-void DotCfgChangeReporter::handleInitialIR(Any IR) {
+void DotCfgChangeReporter::handleInitialIR(std::any IR) {
   assert(HTML && "Expected outstream to be set");
   *HTML << "<button type=\"button\" class=\"collapsible\">0. "
         << "Initial IR (by function)</button>\n"
         << "<div class=\"content\">\n"
         << "  <p>\n";
   // Create representation of IR
   IRDataT<DCData> Data;
   IRComparer<DCData>::analyzeIR(IR, Data);
   // Now compare it against itself, which will have everything the
   // same and will generate the files.
   IRComparer<DCData>(Data, Data)
       .compare(getModuleForComparison(IR),
                [&](bool InModule, unsigned Minor,
                    const FuncDataT<DCData> &Before,
                    const FuncDataT<DCData> &After) -> void {
                  handleFunctionCompare("", " ", "Initial IR", "", InModule,
                                        Minor, Before, After);
                });
   *HTML << "  </p>\n"
         << "</div><br/>\n";
   ++N;
 }
 
-void DotCfgChangeReporter::generateIRRepresentation(Any IR, StringRef PassID,
+void DotCfgChangeReporter::generateIRRepresentation(std::any IR,
+                                                    StringRef PassID,
                                                     IRDataT<DCData> &Data) {
   IRComparer<DCData>::analyzeIR(IR, Data);
 }
 
 void DotCfgChangeReporter::omitAfter(StringRef PassID, std::string &Name) {
   assert(HTML && "Expected outstream to be set");
   SmallString<20> Banner =
       formatv("  <a>{0}. Pass {1} on {2} omitted because no change</a><br/>\n",
               N, makeHTMLReady(PassID), Name);
   *HTML << Banner;
   ++N;
 }
 
 void DotCfgChangeReporter::handleAfter(StringRef PassID, std::string &Name,
                                        const IRDataT<DCData> &Before,
-                                       const IRDataT<DCData> &After, Any IR) {
+                                       const IRDataT<DCData> &After,
+                                       std::any IR) {
   assert(HTML && "Expected outstream to be set");
   IRComparer<DCData>(Before, After)
       .compare(getModuleForComparison(IR),
                [&](bool InModule, unsigned Minor,
                    const FuncDataT<DCData> &Before,
                    const FuncDataT<DCData> &After) -> void {
                  handleFunctionCompare(Name, " Pass ", PassID, " on ", InModule,
                                        Minor, Before, After);
void PrintCrashIRInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!PrintCrashIR || CrashReporter)
     return;
 
   sys::AddSignalHandler(SignalHandler, nullptr);
   CrashReporter = this;
 
   PIC.registerBeforeNonSkippedPassCallback([&PIC, this](StringRef PassID,
-                                                        Any IR) {
+                                                        std::any IR) {
     SavedIR.clear();
     raw_string_ostream OS(SavedIR);
     OS << formatv("*** Dump of {0}IR Before Last Pass {1}",
                   llvm::forcePrintModuleIR() ? "Module " : "", PassID);
     if (!isInteresting(IR, PassID, PIC.getPassNameForClassName(PassID))) {
       OS << " Filtered Out ***\n";
       return;
     }

llvm/lib/Transforms/IPO/SampleProfileProbe.cpp

bool PseudoProbeVerifier::shouldVerifyFunction(const Function *F) {
   static std::unordered_set<std::string> VerifyFuncNames(
       VerifyPseudoProbeFuncList.begin(), VerifyPseudoProbeFuncList.end());
   return VerifyFuncNames.empty() || VerifyFuncNames.count(F->getName().str());
 }
 
 void PseudoProbeVerifier::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (VerifyPseudoProbe) {
     PIC.registerAfterPassCallback(
-        [this](StringRef P, Any IR, const PreservedAnalyses &) {
+        [this](StringRef P, std::any IR, const PreservedAnalyses &) {
           this->runAfterPass(P, IR);
         });
   }
 }
 
 // Callback to run after each transformation for the new pass manager.
-void PseudoProbeVerifier::runAfterPass(StringRef PassID, Any IR) {
+void PseudoProbeVerifier::runAfterPass(StringRef PassID, std::any IR) {
   std::string Banner =
       "\n*** Pseudo Probe Verification After " + PassID.str() + " ***\n";
   dbgs() << Banner;
-  if (any_isa<const Module *>(IR))
-    runAfterPass(any_cast<const Module *>(IR));
-  else if (any_isa<const Function *>(IR))
-    runAfterPass(any_cast<const Function *>(IR));
-  else if (any_isa<const LazyCallGraph::SCC *>(IR))
-    runAfterPass(any_cast<const LazyCallGraph::SCC *>(IR));
-  else if (any_isa<const Loop *>(IR))
-    runAfterPass(any_cast<const Loop *>(IR));
+  if (const auto **M = std::any_cast<const Module *>(&IR))
+    runAfterPass(*M);
+  else if (const auto **F = std::any_cast<const Function *>(&IR))
+    runAfterPass(*F);
+  else if (const auto **C = std::any_cast<const LazyCallGraph::SCC *>(&IR))
+    runAfterPass(*C);
+  else if (const auto **L = std::any_cast<const Loop *>(&IR))
+    runAfterPass(*L);
   else
     llvm_unreachable("Unknown IR unit");
 }
 
 void PseudoProbeVerifier::runAfterPass(const Module *M) {
   for (const Function &F : *M)
     runAfterPass(&F);
 }

llvm/lib/Transforms/Scalar/LoopPassManager.cpp

PreservedAnalyses FunctionToLoopPassAdaptor::run(Function &F,
   if (!LoopNestMode) {
     appendLoopsToWorklist(LI, Worklist);
   } else {
     for (Loop *L : LI)
       Worklist.insert(L);
   }
 
 #ifndef NDEBUG
-  PI.pushBeforeNonSkippedPassCallback([&LAR, &LI](StringRef PassID, Any IR) {
+  PI.pushBeforeNonSkippedPassCallback([&LAR, &LI](StringRef PassID, std::any IR) {
     if (isSpecialPass(PassID, {"PassManager"}))
       return;
-    assert(any_isa<const Loop *>(IR) || any_isa<const LoopNest *>(IR));
-    const Loop *L = any_isa<const Loop *>(IR)
-                        ? any_cast<const Loop *>(IR)
-                        : &any_cast<const LoopNest *>(IR)->getOutermostLoop();
+    assert(std::any_cast<const Loop *>(&IR) || std::any_cast<const LoopNest *>(&IR));
+    const Loop **LPtr = std::any_cast<const Loop *>(&IR);
+    const Loop *L = LPtr ? *LPtr : nullptr;
+    if (!L)
+      L = &std::any_cast<const LoopNest *>(IR)->getOutermostLoop();
     assert(L && "Loop should be valid for printing");
 
     // Verify the loop structure and LCSSA form before visiting the loop.
     L->verifyLoop();
     assert(L->isRecursivelyLCSSAForm(LAR.DT, LI) &&
            "Loops must remain in LCSSA form!");
   });
 #endif

llvm/lib/Transforms/Utils/Debugify.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassInstrumentation.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/JSON.h"
 #include <optional>
 
+#include <any>
+
 #define DEBUG_TYPE "debugify"
 
 using namespace llvm;
 
 namespace {
 
 cl::opt<bool> Quiet("debugify-quiet",
                     cl::desc("Suppress verbose debugify output"));
static bool isIgnoredPass(StringRef PassID) {
   return isSpecialPass(PassID, {"PassManager", "PassAdaptor",
                                 "AnalysisManagerProxy", "PrintFunctionPass",
                                 "PrintModulePass", "BitcodeWriterPass",
                                 "ThinLTOBitcodeWriterPass", "VerifierPass"});
 }
 
 void DebugifyEachInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
-  PIC.registerBeforeNonSkippedPassCallback([this](StringRef P, Any IR) {
+  PIC.registerBeforeNonSkippedPassCallback([this](StringRef P, std::any IR) {
     if (isIgnoredPass(P))
       return;
-    if (any_isa<const Function *>(IR))
-      applyDebugify(*const_cast<Function *>(any_cast<const Function *>(IR)),
+    if (const auto **F = std::any_cast<const Function *>(&IR))
+      applyDebugify(*const_cast<Function *>(*F),
                     Mode, DebugInfoBeforePass, P);
-    else if (any_isa<const Module *>(IR))
-      applyDebugify(*const_cast<Module *>(any_cast<const Module *>(IR)),
+    else if (const auto **M = std::any_cast<const Module *>(&IR))
+      applyDebugify(*const_cast<Module *>(*M),
                     Mode, DebugInfoBeforePass, P);
   });
-  PIC.registerAfterPassCallback([this](StringRef P, Any IR,
+  PIC.registerAfterPassCallback([this](StringRef P, std::any IR,
                                        const PreservedAnalyses &PassPA) {
     if (isIgnoredPass(P))
       return;
-    if (any_isa<const Function *>(IR)) {
-      auto &F = *const_cast<Function *>(any_cast<const Function *>(IR));
+    if (const auto **CF = std::any_cast<const Function *>(&IR)) {
+      auto &F = *const_cast<Function *>(*CF);
       Module &M = *F.getParent();
       auto It = F.getIterator();
       if (Mode == DebugifyMode::SyntheticDebugInfo)
         checkDebugifyMetadata(M, make_range(It, std::next(It)), P,
                               "CheckFunctionDebugify", /*Strip=*/true, DIStatsMap);
       else
         checkDebugInfoMetadata(
           M, make_range(It, std::next(It)), *DebugInfoBeforePass,
           "CheckModuleDebugify (original debuginfo)",
           P, OrigDIVerifyBugsReportFilePath);
-    } else if (any_isa<const Module *>(IR)) {
-      auto &M = *const_cast<Module *>(any_cast<const Module *>(IR));
+    } else if (const auto **CM = std::any_cast<const Module *>(&IR)) {
+      auto &M = *const_cast<Module *>(*CM);
       if (Mode == DebugifyMode::SyntheticDebugInfo)
        checkDebugifyMetadata(M, M.functions(), P, "CheckModuleDebugify",
                             /*Strip=*/true, DIStatsMap);
       else
         checkDebugInfoMetadata(
           M, M.functions(), *DebugInfoBeforePass,
           "CheckModuleDebugify (original debuginfo)",
           P, OrigDIVerifyBugsReportFilePath);

llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp

 static void runPasses(Oracle &O, Module &Program) {
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager MAM;
 
   PassInstrumentationCallbacks PIC;
   PIC.registerShouldRunOptionalPassCallback(
-      [&](StringRef, Any) { return !O.shouldKeep(); });
+      [&](StringRef, std::any) { return !O.shouldKeep(); });
   PassBuilder PB(nullptr, PipelineTuningOptions(), std::nullopt, &PIC);
 
   PB.registerModuleAnalyses(MAM);
   PB.registerCGSCCAnalyses(CGAM);
   PB.registerFunctionAnalyses(FAM);
   PB.registerLoopAnalyses(LAM);
   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
 

llvm/unittests/IR/PassBuilderCallbacksTest.cpp

 //===- unittests/IR/PassBuilderCallbacksTest.cpp - PB Callback Tests --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Testing/Support/Error.h"
+#include <any>
 #include <functional>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <llvm/ADT/Any.h>
 #include <llvm/Analysis/CGSCCPassManager.h>
 #include <llvm/Analysis/LoopAnalysisManager.h>
 #include <llvm/AsmParser/Parser.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/PassInstrumentation.h>
 #include <llvm/IR/PassManager.h>
 #include <llvm/Passes/PassBuilder.h>
 #include <llvm/Support/Regex.h>

 };
 
 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   return parseAssemblyString(IR, Err, C);
 }
 
 /// Helper for HasName matcher that returns getName both for IRUnit and
-/// for IRUnit pointer wrapper into llvm::Any (wrapped by PassInstrumentation).
+/// for IRUnit pointer wrapper into std::any (wrapped by PassInstrumentation).
 template <typename IRUnitT> std::string getName(const IRUnitT &IR) {
   return std::string(IR.getName());
 }
 
 template <> std::string getName(const StringRef &name) {
   return std::string(name);
 }
 
-template <> std::string getName(const llvm::Any &WrappedIR) {
-  if (any_isa<const Module *>(WrappedIR))
-    return any_cast<const Module *>(WrappedIR)->getName().str();
-  if (any_isa<const Function *>(WrappedIR))
-    return any_cast<const Function *>(WrappedIR)->getName().str();
-  if (any_isa<const Loop *>(WrappedIR))
-    return any_cast<const Loop *>(WrappedIR)->getName().str();
-  if (any_isa<const LoopNest *>(WrappedIR))
-    return any_cast<const LoopNest *>(WrappedIR)->getName().str();
-  if (any_isa<const LazyCallGraph::SCC *>(WrappedIR))
-    return any_cast<const LazyCallGraph::SCC *>(WrappedIR)->getName();
+template <> std::string getName(const std::any &WrappedIR) {
+  if (const auto *const *M = std::any_cast<const Module *>(&WrappedIR))
+    return (*M)->getName().str();
+  if (const auto *const *F = std::any_cast<const Function *>(&WrappedIR))
+    return (*F)->getName().str();
+  if (const auto *const *L = std::any_cast<const Loop *>(&WrappedIR))
+    return (*L)->getName().str();
+  if (const auto *const *L = std::any_cast<const LoopNest *>(&WrappedIR))
+    return (*L)->getName().str();
+  if (const auto *const *C = std::any_cast<const LazyCallGraph::SCC *>(&WrappedIR))
+    return (*C)->getName();
   return "<UNKNOWN>";
 }
 /// Define a custom matcher for objects which support a 'getName' method.
 ///
 /// LLVM often has IR objects or analysis objects which expose a name
 /// and in tests it is convenient to match these by name for readability.
 /// Usually, this name is either a StringRef or a plain std::string. This
 /// matcher supports any type exposing a getName() method of this form whose

 }
 
 struct MockPassInstrumentationCallbacks {
   PassInstrumentationCallbacks Callbacks;
 
   MockPassInstrumentationCallbacks() {
     ON_CALL(*this, runBeforePass(_, _)).WillByDefault(Return(true));
   }
-  MOCK_METHOD2(runBeforePass, bool(StringRef PassID, llvm::Any));
-  MOCK_METHOD2(runBeforeSkippedPass, void(StringRef PassID, llvm::Any));
-  MOCK_METHOD2(runBeforeNonSkippedPass, void(StringRef PassID, llvm::Any));
+  MOCK_METHOD2(runBeforePass, bool(StringRef PassID, std::any));
+  MOCK_METHOD2(runBeforeSkippedPass, void(StringRef PassID, std::any));
+  MOCK_METHOD2(runBeforeNonSkippedPass, void(StringRef PassID, std::any));
   MOCK_METHOD3(runAfterPass,
-               void(StringRef PassID, llvm::Any, const PreservedAnalyses &PA));
+               void(StringRef PassID, std::any, const PreservedAnalyses &PA));
   MOCK_METHOD2(runAfterPassInvalidated,
                void(StringRef PassID, const PreservedAnalyses &PA));
-  MOCK_METHOD2(runBeforeAnalysis, void(StringRef PassID, llvm::Any));
-  MOCK_METHOD2(runAfterAnalysis, void(StringRef PassID, llvm::Any));
+  MOCK_METHOD2(runBeforeAnalysis, void(StringRef PassID, std::any));
+  MOCK_METHOD2(runAfterAnalysis, void(StringRef PassID, std::any));
 
   void registerPassInstrumentation() {
     Callbacks.registerShouldRunOptionalPassCallback(
-        [this](StringRef P, llvm::Any IR) {
+        [this](StringRef P, std::any IR) {
           return this->runBeforePass(P, IR);
         });
     Callbacks.registerBeforeSkippedPassCallback(
-        [this](StringRef P, llvm::Any IR) {
+        [this](StringRef P, std::any IR) {
           this->runBeforeSkippedPass(P, IR);
         });
     Callbacks.registerBeforeNonSkippedPassCallback(
-        [this](StringRef P, llvm::Any IR) {
+        [this](StringRef P, std::any IR) {
           this->runBeforeNonSkippedPass(P, IR);
         });
     Callbacks.registerAfterPassCallback(
-        [this](StringRef P, llvm::Any IR, const PreservedAnalyses &PA) {
+        [this](StringRef P, std::any IR, const PreservedAnalyses &PA) {
           this->runAfterPass(P, IR, PA);
         });
     Callbacks.registerAfterPassInvalidatedCallback(
         [this](StringRef P, const PreservedAnalyses &PA) {
           this->runAfterPassInvalidated(P, PA);
         });
-    Callbacks.registerBeforeAnalysisCallback([this](StringRef P, llvm::Any IR) {
+    Callbacks.registerBeforeAnalysisCallback([this](StringRef P, std::any IR) {
       return this->runBeforeAnalysis(P, IR);
     });
     Callbacks.registerAfterAnalysisCallback(
-        [this](StringRef P, llvm::Any IR) { this->runAfterAnalysis(P, IR); });
+        [this](StringRef P, std::any IR) { this->runAfterAnalysis(P, IR); });
   }
 
   void ignoreNonMockPassInstrumentation(StringRef IRName) {
     // Generic EXPECT_CALLs are needed to match instrumentation on unimportant
     // parts of a pipeline that we do not care about (e.g. various passes added
     // by default by PassBuilder - Verifier pass etc).
     // Make sure to avoid ignoring Mock passes/analysis, we definitely want
     // to check these explicitly.