[llvm] Make llvm::Any similar to std::any

[sebastian-ne]

Summary

This facilitates replacing llvm::Any with std::any.

• Deprecate any_isa in favor of using any_cast(Any*) and checking for nullptr because C++17 has no any_isa.
• Remove the assert from any_cast(Any*), so it returns nullptr if the type is not correct. This aligns it with std::any_cast(any*).

Use any_cast(Any*) throughout LLVM instead of checks with any_isa.

This is the first part outlined in
https://discourse.llvm.org/t/rfc-switching-from-llvm-any-to-std-any/67176

[jloser]

I'm +1 for the direction here; I took a brief look but will look closely either later tonight or tomorrow before I approve. Thanks for doing this!

[jsilvanus]

LGTM, but let's wait for the other reviewers.

[barannikov88]

Just thoughts.

llvm::any_isa is usually paired with llvm::any_cast; replacing them with llvm::any_cast and nullptr check seems fine.
However,

• std::any uses RTTI, so it is unlikely to ever replace llvm::Any. This is not exactly true, see the comments below.
• llvm::any_isa<> is kind of convenient and is aligned with llvm::isa<>. Same for llvm::any_cast.
• With that in mind, introducing new llvm::any_cast_or_null to follow llvm::cast_or_null instead of changing the semantics of llvm::any_cast might be a better idea.

[barannikov88]

lldb/include/lldb/Core/RichManglingContext.h

90–91

This is not intuitively clear. In assert you pass an address, but in 'return' below the object is passed by reference.

[jsilvanus]

In D139973#4004344, @barannikov88 wrote:

• std::any uses RTTI, so it is unlikely to ever replace llvm::Any.

I just checked on Godbolt that gcc 12.2 with libstdc++, clang 15.0 with both libstd++ and libc++ and MSVC 19.33 support std::any without RTTI.
But gcc and clang do not provide std::any::type without RTTI though.

Are you aware of any documentation on what can be relied on without RTTI?

[barannikov88]

In D139973#4004408, @jsilvanus wrote:

I just checked on Godbolt that gcc 12.2 with libstdc++, clang 15.0 with both libstd++ and libc++ and MSVC 19.33 support std::any without RTTI.
But gcc and clang do not provide std::any::type without RTTI though.

Are you aware of any documentation on what can be relied on without RTTI?

It is surprising to me that std::any can work without RTTI. Never thought it could be implemented.
This "compare function pointer" trick is awesome, but it might not always work as explained in this commit.
This question however, suggest that any_cast doesn't always work with RTTI either, which is weird.
I don't know of any other potential issues. std::visitor can't be used with std::any in absense of std::any::type, but that's minor, I think.

[barannikov88]

llvm/lib/Passes/StandardInstrumentations.cpp

193

Redundant braces.

[barannikov88]

Related: https://reviews.llvm.org/D139974

[sebastian-ne]

It is surprising to me that std::any can work without RTTI. Never thought it could be implemented.

It seems like libstdc++ and libc++ both implement it the way llvm::Any is implemented when RTTI is not available (actually, I think llvm::Any was copied from libstdc++ at some point).

This "compare function pointer" trick is awesome, but it might not always work as explained in this commit.
This question however, suggest that any_cast doesn't always work with RTTI either, which is weird.
I don't know of any other potential issues. std::visitor can't be used with std::any in absense of std::any::type, but that's minor, I think.

As you noticed, it is very difficult to implement Any correctly on every platform under any circumstances and compiler flags.
That is exactly what this patch aims at: Moving the responsibility to implement Any correctly to the standard library.

Unfortunatly, we can’t replace llvm::Any with std::any just yet, because of bugs in msvc that were only fixed recently.

llvm::any_isa<> is kind of convenient and is aligned with llvm::isa<>. Same for llvm::any_cast.

It is, however, there is no std::any_isa or std::any_cast_or_null, so the question gets wether we want to keep llvm::Any around as a wrapper of std::any once we can use it (in this case this patch would be obsolete)
or if we we want to remove llvm::Any and use std::any only.

lldb/include/lldb/Core/RichManglingContext.h

90–91

I changed it to use an address + explicit dereference in the return. I hope that makes it clearer.

[barannikov88]

In D139973#4005120, @sebastian-ne wrote:

the question gets wether we want to keep llvm::Any around as a wrapper of std::any once we can use it (in this case this patch would be obsolete)
or if we we want to remove llvm::Any and use std::any only.

Since there are not many uses of Any, it is hard to say which option would be preferable in the long term.
Perhaps, it would be possible to remove llvm::Any and use std::any with llvm::any_isa as an extension.
Anyway, this patch makes it possible to avoid double casting, which is an improvement by itself.

[jloser]

Sorry for the delay here; this patch LGTM! Thanks.

clang/unittests/Tooling/RefactoringTest.cpp

EXPECT_TRUE(checkReplacementError(
       std::move(Err), replacement_error::wrong_file_path,
       Replacement(Context.Sources, DefaultLoc, 0, "a"),
       Replacement(Context.Sources, SourceLocation(), 0, "b")));
 }
 
 TEST_F(AtomicChangeTest, Metadata) {
   AtomicChange Change(Context.Sources, DefaultLoc, 17);
   const llvm::Any &Metadata = Change.getMetadata();
-  ASSERT_TRUE(llvm::any_isa<int>(Metadata));
+  ASSERT_TRUE(llvm::any_cast<int>(&Metadata));
   EXPECT_EQ(llvm::any_cast<int>(Metadata), 17);
 }
 
 TEST_F(AtomicChangeTest, NoMetadata) {
   AtomicChange Change(Context.Sources, DefaultLoc);
   EXPECT_FALSE(Change.getMetadata().has_value());
 }
 

clang/unittests/Tooling/TransformerTest.cpp

Transformer T(
       consumer());
   T.registerMatchers(&MatchFinder);
   auto Factory = newFrontendActionFactory(&MatchFinder);
   EXPECT_TRUE(runToolOnCodeWithArgs(
       Factory->create(), Input, std::vector<std::string>(), "input.cc",
       "clang-tool", std::make_shared<PCHContainerOperations>(), {}));
   ASSERT_EQ(Changes.size(), 1u);
   const llvm::Any &Metadata = Changes[0].getMetadata();
-  ASSERT_TRUE(llvm::any_isa<int>(Metadata));
+  ASSERT_TRUE(llvm::any_cast<int>(&Metadata));
   EXPECT_THAT(llvm::any_cast<int>(Metadata), 5);
 }
 
 TEST_F(TransformerTest, MultiChange) {
   std::string Input = R"cc(
     void foo() {
       if (10 > 1.0)
         log(1) << "oh no!";

lldb/include/lldb/Core/RichManglingContext.h

private:
   /// Uniform handling of string buffers for ItaniumPartialDemangler.
   llvm::StringRef processIPDStrResult(char *ipd_res, size_t res_len);
 
   /// Cast the given parser to the given type. Ideally we would have a type
   /// trait to deduce \a ParserT from a given InfoProvider, but unfortunately we
   /// can't access CPlusPlusLanguage::MethodName from within the header.
   template <class ParserT> static ParserT *get(llvm::Any parser) {
     assert(parser.has_value());
-    assert(llvm::any_isa<ParserT *>(parser));
+    assert(llvm::any_cast<ParserT *>(&parser));
     return llvm::any_cast<ParserT *>(parser);
   }
 };
 
 } // namespace lldb_private
 
 #endif

llvm/include/llvm/ADT/Any.h

Any &operator=(Any Other) {
     return *this;
   }
 
   bool has_value() const { return !!Storage; }
 
   void reset() { Storage.reset(); }
 
 private:
+  // Only used for the internal llvm::Any implementation
+  template <typename T> bool isa() const {
+    if (!Storage)
+      return false;
+    return Storage->id() == &Any::TypeId<remove_cvref_t<T>>::Id;
+  }
+
   template <class T> friend T any_cast(const Any &Value);
   template <class T> friend T any_cast(Any &Value);
   template <class T> friend T any_cast(Any &&Value);
   template <class T> friend const T *any_cast(const Any *Value);
   template <class T> friend T *any_cast(Any *Value);
   template <typename T> friend bool any_isa(const Any &Value);
 
   std::unique_ptr<StorageBase> Storage;
 };
 
 template <typename T> const char Any::TypeId<T>::Id = 0;
 
-template <typename T> bool any_isa(const Any &Value) {
-  if (!Value.Storage)
-    return false;
-  return Value.Storage->id() == &Any::TypeId<remove_cvref_t<T>>::Id;
+template <typename T>
+LLVM_DEPRECATED("Use any_cast(Any*) != nullptr instead", "any_cast")
+bool any_isa(const Any &Value) {
+  return Value.isa<T>();
 }
 
 template <class T> T any_cast(const Any &Value) {
+  assert(Value.isa<T>() && "Bad any cast!");
   return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value));
 }
 
 template <class T> T any_cast(Any &Value) {
+  assert(Value.isa<T>() && "Bad any cast!");
   return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value));
 }
 
 template <class T> T any_cast(Any &&Value) {
+  assert(Value.isa<T>() && "Bad any cast!");
   return static_cast<T>(std::move(*any_cast<remove_cvref_t<T>>(&Value)));
 }
 
 template <class T> const T *any_cast(const Any *Value) {
   using U = remove_cvref_t<T>;
-  assert(Value && any_isa<T>(*Value) && "Bad any cast!");
-  if (!Value || !any_isa<U>(*Value))
+  if (!Value || !Value->isa<U>())
     return nullptr;
   return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value;
 }
 
 template <class T> T *any_cast(Any *Value) {
   using U = std::decay_t<T>;
-  assert(Value && any_isa<U>(*Value) && "Bad any cast!");
-  if (!Value || !any_isa<U>(*Value))
+  if (!Value || !Value->isa<U>())
     return nullptr;
   return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_ANY_H

llvm/lib/CodeGen/MachinePassManager.cpp

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));
+      assert(any_cast<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);
     });
   }
 
   for (auto &F : InitializationFuncs) {

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/Passes/StandardInstrumentations.cpp

 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);
+  if (const auto **M = 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 = 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 = 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 = 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))
+  if (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 = 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 = 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 = 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);
+  if (const auto **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 (const auto **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 (const auto **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());
+  if (const auto **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.
+/// Any and does actual print job.
 void unwrapAndPrint(raw_ostream &OS, 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 = 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 = 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 = 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 = 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,
while (true) {
     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)
+  if (const auto **M = any_cast<const Module *>(&IR))
+    return *M;
+  if (const auto **C = 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) {
   if (isIgnored(PassID) || !isPassInPrintList(PassName))
     return false;
-  if (any_isa<const Function *>(IR))
-    return isInterestingFunction(*any_cast<const Function *>(IR));
+  if (const auto **F = 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 IRComparer<T>::analyzeIR(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 = any_cast<const Function *>(&IR);
+  const Function *F = FPtr ? *FPtr : nullptr;
+  if (!F) {
+    const Loop **L = 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())) {

 
 void OptNoneInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerShouldRunOptionalPassCallback(
       [this](StringRef P, 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();
+  const Function **FPtr = any_cast<const Function *>(&IR);
+  const Function *F = FPtr ? *FPtr : nullptr;
+  if (!F) {
+    if (const auto **L = 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;
 }
void PrintPassInstrumentation::registerCallbacks(
   });
   PIC.registerBeforeNonSkippedPassCallback([this, SpecialPasses](
                                                StringRef PassID, 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 = 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 = any_cast<const LazyCallGraph::SCC *>(&IR)) {
+      int Count = (*C)->size();
       OS << " (" << Count << " node";
       if (Count != 1)
         OS << 's';
       OS << ')';
     }
     OS << "\n";
     Indent += 2;
   });
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, 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 = 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,
                                            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 = 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) {
         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 = any_cast<const Function *>(&IR);
+        const Function *F = FPtr ? *FPtr : nullptr;
+        if (!F) {
+          if (const auto **L = 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 = any_cast<const Module *>(&IR);
+          const Module *M = MPtr ? *MPtr : nullptr;
+          if (!M) {
+            if (const auto **C = 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(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,
+                                      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 {

llvm/lib/Transforms/IPO/SampleProfileProbe.cpp

void PseudoProbeVerifier::registerCallbacks(PassInstrumentationCallbacks &PIC) {
   }
 }
 
 // Callback to run after each transformation for the new pass manager.
 void PseudoProbeVerifier::runAfterPass(StringRef PassID, 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 = any_cast<const Module *>(&IR))
+    runAfterPass(*M);
+  else if (const auto **F = any_cast<const Function *>(&IR))
+    runAfterPass(*F);
+  else if (const auto **C = any_cast<const LazyCallGraph::SCC *>(&IR))
+    runAfterPass(*C);
+  else if (const auto **L = 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

if (!LoopNestMode) {
     for (Loop *L : LI)
       Worklist.insert(L);
   }
 
 #ifndef NDEBUG
   PI.pushBeforeNonSkippedPassCallback([&LAR, &LI](StringRef PassID, 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(any_cast<const Loop *>(&IR) || any_cast<const LoopNest *>(&IR));
+    const Loop **LPtr = any_cast<const Loop *>(&IR);
+    const Loop *L = LPtr ? *LPtr : nullptr;
+    if (!L)
+      L = &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

return isSpecialPass(PassID, {"PassManager", "PassAdaptor",
                                 "ThinLTOBitcodeWriterPass", "VerifierPass"});
 }
 
 void DebugifyEachInstrumentation::registerCallbacks(
     PassInstrumentationCallbacks &PIC) {
   PIC.registerBeforeNonSkippedPassCallback([this](StringRef P, 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 = 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 = any_cast<const Module *>(&IR))
+      applyDebugify(*const_cast<Module *>(*M),
                     Mode, DebugInfoBeforePass, P);
   });
   PIC.registerAfterPassCallback([this](StringRef P, 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 = 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 = 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/unittests/ADT/AnyTest.cpp

TEST(AnyTest, ConstructionAndAssignment) {
   llvm::Any A;
   llvm::Any B{7};
   llvm::Any C{8};
   llvm::Any D{"hello"};
   llvm::Any E{3.7};
 
   // An empty Any is not anything.
   EXPECT_FALSE(A.has_value());
-  EXPECT_FALSE(any_isa<int>(A));
+  EXPECT_FALSE(any_cast<int>(&A));
 
   // An int is an int but not something else.
   EXPECT_TRUE(B.has_value());
-  EXPECT_TRUE(any_isa<int>(B));
-  EXPECT_FALSE(any_isa<float>(B));
+  EXPECT_TRUE(any_cast<int>(&B));
+  EXPECT_FALSE(any_cast<float>(&B));
 
   EXPECT_TRUE(C.has_value());
-  EXPECT_TRUE(any_isa<int>(C));
+  EXPECT_TRUE(any_cast<int>(&C));
 
   // A const char * is a const char * but not an int.
   EXPECT_TRUE(D.has_value());
-  EXPECT_TRUE(any_isa<const char *>(D));
-  EXPECT_FALSE(any_isa<int>(D));
+  EXPECT_TRUE(any_cast<const char *>(&D));
+  EXPECT_FALSE(any_cast<int>(&D));
 
   // A double is a double but not a float.
   EXPECT_TRUE(E.has_value());
-  EXPECT_TRUE(any_isa<double>(E));
-  EXPECT_FALSE(any_isa<float>(E));
+  EXPECT_TRUE(any_cast<double>(&E));
+  EXPECT_FALSE(any_cast<float>(&E));
 
   // After copy constructing from an int, the new item and old item are both
   // ints.
   llvm::Any F(B);
   EXPECT_TRUE(B.has_value());
   EXPECT_TRUE(F.has_value());
-  EXPECT_TRUE(any_isa<int>(F));
-  EXPECT_TRUE(any_isa<int>(B));
+  EXPECT_TRUE(any_cast<int>(&F));
+  EXPECT_TRUE(any_cast<int>(&B));
 
   // After move constructing from an int, the new item is an int and the old one
   // isn't.
   llvm::Any G(std::move(C));
   EXPECT_FALSE(C.has_value());
   EXPECT_TRUE(G.has_value());
-  EXPECT_TRUE(any_isa<int>(G));
-  EXPECT_FALSE(any_isa<int>(C));
+  EXPECT_TRUE(any_cast<int>(&G));
+  EXPECT_FALSE(any_cast<int>(&C));
 
   // After copy-assigning from an int, the new item and old item are both ints.
   A = F;
   EXPECT_TRUE(A.has_value());
   EXPECT_TRUE(F.has_value());
-  EXPECT_TRUE(any_isa<int>(A));
-  EXPECT_TRUE(any_isa<int>(F));
+  EXPECT_TRUE(any_cast<int>(&A));
+  EXPECT_TRUE(any_cast<int>(&F));
 
   // After move-assigning from an int, the new item and old item are both ints.
   B = std::move(G);
   EXPECT_TRUE(B.has_value());
   EXPECT_FALSE(G.has_value());
-  EXPECT_TRUE(any_isa<int>(B));
-  EXPECT_FALSE(any_isa<int>(G));
+  EXPECT_TRUE(any_cast<int>(&B));
+  EXPECT_FALSE(any_cast<int>(&G));
 }
 
 TEST(AnyTest, GoodAnyCast) {
   llvm::Any A;
   llvm::Any B{7};
   llvm::Any C{8};
   llvm::Any D{"hello"};
   llvm::Any E{'x'};

llvm/unittests/IR/PassBuilderCallbacksTest.cpp

 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 Any &WrappedIR) {
+  if (const auto *const *M = any_cast<const Module *>(&WrappedIR))
+    return (*M)->getName().str();
+  if (const auto *const *F = any_cast<const Function *>(&WrappedIR))
+    return (*F)->getName().str();
+  if (const auto *const *L = any_cast<const Loop *>(&WrappedIR))
+    return (*L)->getName().str();
+  if (const auto *const *L = any_cast<const LoopNest *>(&WrappedIR))
+    return (*L)->getName().str();
+  if (const auto *const *C = 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