Draft: [llvm] Replace uses of llvm::Any with std::any

[jloser]

Summary

llvm::Any is an equivalent version of std::any for use prior to C++17. Now
that a minimum of C++17 standards mode is used for building, use std::any
instead.

The use of llvm::Any in other projects and the eventual removal of llvm::Any are
left for follow-up patches.

[jloser]

Fix references to llvm::Any in llvm/IR/PassInstrumentation.h.
Run git clang-format HEAD~1 to fix the clang-format CI step.

[jloser]

Replace uses of llvm::Any in lib/IR/PassTimingInfo.cpp.

[jloser]

Use std::any in llvm/lib/CodeGen/MachinePassManager.cpp.

[sebastian-ne]

I put up D139532, which includes the work done here and finishes it (also replaces any_cast with std::any_cast, compiles and passes llvm and clang tests).

[jloser]

In D131847#3977994, @sebastian-ne wrote:

I put up D139532, which includes the work done here and finishes it (also replaces any_cast with std::any_cast, compiles and passes llvm and clang tests).

Awesome, thanks! Sorry I never got back around to finishing up this idea - was working on other things. I'll close this review and we can revisit yours once the minimum MSVC version is updated to handle the bug mentioned in your revert.

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/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) {
+    PI.pushBeforeNonSkippedPassCallback([&MFAM](StringRef PassID, std::any IR) {
       assert(any_isa<const MachineFunction *>(IR));
       const MachineFunction *MF = 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);
     });
   }
 

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/Optional.h"
 #include "llvm/ADT/STLExtras.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::runAfterPass(StringRef PassID) {
   LLVM_DEBUG(dump());
 }
 
 void TimePassesHandler::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   if (!Enabled)
     return;
 
   PIC.registerBeforeNonSkippedPassCallback(
-      [this](StringRef P, Any) { this->runBeforePass(P); });
+      [this](StringRef P, std::any) { this->runBeforePass(P); });
   PIC.registerAfterPassCallback(
-      [this](StringRef P, Any, const PreservedAnalyses &) {
+      [this](StringRef P, std::any, const PreservedAnalyses &) {
         this->runAfterPass(P);
       });
   PIC.registerAfterPassInvalidatedCallback(
       [this](StringRef P, const PreservedAnalyses &) {
         this->runAfterPass(P);
       });
   PIC.registerBeforeAnalysisCallback(
-      [this](StringRef P, Any) { this->runBeforePass(P); });
+      [this](StringRef P, std::any) { this->runBeforePass(P); });
   PIC.registerAfterAnalysisCallback(
-      [this](StringRef P, Any) { this->runAfterPass(P); });
+      [this](StringRef P, std::any) { this->runAfterPass(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/Optional.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/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(
static cl::opt<bool>
     PrintCrashIR("print-on-crash",
                  cl::desc("Print the last form of the IR before crash"),
                  cl::init(false), cl::Hidden);
 
 namespace {
 
 /// 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) {
+const Module *unwrapModule(std::any IR, bool Force = false) {
   if (any_isa<const Module *>(IR))
     return any_cast<const Module *>(IR);
 
   if (any_isa<const Function *>(IR)) {
     const Function *F = any_cast<const Function *>(IR);
     if (!Force && !isFunctionInPrintList(F->getName()))
       return nullptr;
 

 
 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) {
+std::string getIRName(std::any IR) {
   if (any_isa<const Module *>(IR))
     return "[module]";
 
   if (any_isa<const Function *>(IR)) {
     const Function *F = any_cast<const Function *>(IR);
     return F->getName().str();
   }
 

 bool sccContainsFilterPrintFunc(const LazyCallGraph::SCC &C) {
   return any_of(C,
                 [](const LazyCallGraph::Node &N) {
                   return isFunctionInPrintList(N.getName());
                 }) ||
          isFunctionInPrintList("*");
 }
 
-bool shouldPrintIR(Any IR) {
+bool shouldPrintIR(std::any IR) {
   if (any_isa<const Module *>(IR)) {
     const Module *M = 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 (any_isa<const LazyCallGraph::SCC *>(IR)) {
     const LazyCallGraph::SCC *C = 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());
   }
   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 (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) {
+const Module *getModuleForComparison(std::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)
         ->begin()
         ->getFunction()
         .getParent();
   return nullptr;
bool isInterestingPass(StringRef PassID) {
 
   static std::unordered_set<std::string> PrintPassNames(PrintPassesList.begin(),
                                                         PrintPassesList.end());
   return PrintPassNames.empty() || PrintPassNames.count(PassID.str());
 }
 
 // Return true when this is a pass on IR for which printing
 // of changes is desired.
-bool isInteresting(Any IR, StringRef PassID) {
+bool isInteresting(std::any IR, StringRef PassID) {
   if (!isInterestingPass(PassID))
     return false;
   if (any_isa<const Function *>(IR))
     return isInterestingFunction(*any_cast<const Function *>(IR));
   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) {
   // 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))
     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) {
   assert(!BeforeStack.empty() && "Unexpected empty stack encountered.");
 
   std::string Name = getIRName(IR);
 
   if (isIgnored(PassID)) {
     if (VerboseMode)
       handleIgnored(PassID, Name);
   } else if (!isInteresting(IR, PassID)) {
if (VerboseMode)
     handleInvalidated(PassID);
   BeforeStack.pop_back();
 }
 
 template <typename T>
 void ChangeReporter<T>::registerRequiredCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerBeforeNonSkippedPassCallback(
-      [this](StringRef P, Any IR) { saveIRBeforePass(IR, P); });
+      [this](StringRef P, std::any IR) { saveIRBeforePass(IR, P); });
 
   PIC.registerAfterPassCallback(
-      [this](StringRef P, Any IR, const PreservedAnalyses &) {
+      [this](StringRef P, std::any IR, const PreservedAnalyses &) {
         handleIRAfterPass(IR, 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()) {
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;
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) {
+bool OptNoneInstrumentation::shouldRun(StringRef PassID, std::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 ShouldRun = !(F && F->hasOptNone());
   if (!ShouldRun && DebugLogging) {
     errs() << "Skipping pass " << PassID << " on " << F->getName()
            << " due to optnone attribute\n";
   }
   return ShouldRun;
 }
 
 void OptBisectInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   if (!getOptBisector().isEnabled())
     return;
-  PIC.registerShouldRunOptionalPassCallback([](StringRef PassID, Any IR) {
+  PIC.registerShouldRunOptionalPassCallback([](StringRef PassID, std::any IR) {
     return isIgnored(PassID) ||
            getOptBisector().checkPass(PassID, getIRName(IR));
   });
 }
 
 raw_ostream &PrintPassInstrumentation::print() {
   if (Opts.Indent) {
     assert(Indent >= 0);
void PrintPassInstrumentation::registerCallbacks(
 
   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();
       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();
       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))
           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));
       });
 
   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))
if (auto *GraphBefore = FAM.getCachedResult<PreservedCFGCheckerAnalysis>(
       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);
PIC.registerAfterPassCallback(
           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 {
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([this](StringRef PassID, Any IR) {
+  PIC.registerBeforeNonSkippedPassCallback([this](StringRef PassID,
+                                                  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)) {
       OS << " Filtered Out ***\n";
       return;
     }

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) {
+template <> std::string getName(const std::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();
MOCK_METHOD3(runAfterPass,
                void(StringRef PassID, llvm::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));
 
   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.