[nfc][llvm] Replace pointer cast functions in PointerUnion by llvm casting functions.

[shraiysh]

Summary

This patch replaces the uses of PointerUnion.is function by llvm::isa,
PointerUnion.get function by llvm::cast, and PointerUnion.dyn_cast by
llvm::dyn_cast_if_present. This is according to the FIXME in
the definition of the class PointerUnion.

This patch does not remove them as they are being used in other
subprojects.

[mehdi_amini]

Thanks!

llvm/include/llvm/ADT/FunctionExtras.h

protected:
   // A compressed pointer to either our dispatching callback or our table of
   // dispatching callbacks and the flag for whether the callable itself is
   // stored inline or not.
   PointerIntPair<CallbackPointerUnionT, 1, bool> CallbackAndInlineFlag;
 
   bool isInlineStorage() const { return CallbackAndInlineFlag.getInt(); }
 
   bool isTrivialCallback() const {
-    return CallbackAndInlineFlag.getPointer().template is<TrivialCallback *>();
+    return isa<TrivialCallback *>(CallbackAndInlineFlag.getPointer());
   }
 
   CallPtrT getTrivialCallback() const {
-    return CallbackAndInlineFlag.getPointer().template get<TrivialCallback *>()->CallPtr;
+    return cast<TrivialCallback *>(CallbackAndInlineFlag.getPointer())->CallPtr;
   }
 
   NonTrivialCallbacks *getNonTrivialCallbacks() const {
-    return CallbackAndInlineFlag.getPointer()
-        .template get<NonTrivialCallbacks *>();
+    return cast<NonTrivialCallbacks *>(CallbackAndInlineFlag.getPointer());
   }
 
   CallPtrT getCallPtr() const {
     return isTrivialCallback() ? getTrivialCallback()
                                : getNonTrivialCallbacks()->CallPtr;
   }
 
   // These three functions are only const in the narrow sense. They return

llvm/include/llvm/ADT/PointerUnion.h

public:
   /// it.
   First const *getAddrOfPtr1() const {
     return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
   }
 
   /// If the union is set to the first pointer type get an address pointing to
   /// it.
   First *getAddrOfPtr1() {
-    assert(is<First>() && "Val is not the first pointer");
+    assert(isa<First>(*this) && "Val is not the first pointer");
     assert(
-        PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==
+        PointerLikeTypeTraits<First>::getAsVoidPointer(cast<First>(*this)) ==
             this->Val.getPointer() &&
         "Can't get the address because PointerLikeTypeTraits changes the ptr");
     return const_cast<First *>(
         reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
   }
 
   /// Assignment from nullptr which just clears the union.
   const PointerUnion &operator=(std::nullptr_t) {

llvm/include/llvm/ADT/TinyPtrVector.h

 
 private:
   PtrUnion Val;
 
 public:
   TinyPtrVector() = default;
 
   ~TinyPtrVector() {
-    if (VecTy *V = Val.template dyn_cast<VecTy*>())
+    if (VecTy *V = dyn_cast_if_present<VecTy *>(Val))
       delete V;
   }
 
   TinyPtrVector(const TinyPtrVector &RHS) : Val(RHS.Val) {
-    if (VecTy *V = Val.template dyn_cast<VecTy*>())
+    if (VecTy *V = dyn_cast_if_present<VecTy *>(Val))
       Val = new VecTy(*V);
   }
 
   TinyPtrVector &operator=(const TinyPtrVector &RHS) {
     if (this == &RHS)
       return *this;
     if (RHS.empty()) {
       this->clear();
       return *this;
     }
 
     // Try to squeeze into the single slot. If it won't fit, allocate a copied
     // vector.
-    if (Val.template is<EltTy>()) {
+    if (isa<EltTy>(Val)) {
       if (RHS.size() == 1)
         Val = RHS.front();
       else
-        Val = new VecTy(*RHS.Val.template get<VecTy*>());
+        Val = new VecTy(*cast<VecTy *>(RHS.Val));
       return *this;
     }
 
     // If we have a full vector allocated, try to re-use it.
-    if (RHS.Val.template is<EltTy>()) {
-      Val.template get<VecTy*>()->clear();
-      Val.template get<VecTy*>()->push_back(RHS.front());
+    if (isa<EltTy>(RHS.Val)) {
+      cast<VecTy *>(Val)->clear();
+      cast<VecTy *>(Val)->push_back(RHS.front());
     } else {
-      *Val.template get<VecTy*>() = *RHS.Val.template get<VecTy*>();
+      *cast<VecTy *>(Val) = *cast<VecTy *>(RHS.Val);
     }
     return *this;
   }
 
   TinyPtrVector(TinyPtrVector &&RHS) : Val(RHS.Val) {
     RHS.Val = (EltTy)nullptr;
   }
 
   TinyPtrVector &operator=(TinyPtrVector &&RHS) {
     if (this == &RHS)
       return *this;
     if (RHS.empty()) {
       this->clear();
       return *this;
     }
 
     // If this vector has been allocated on the heap, re-use it if cheap. If it
     // would require more copying, just delete it and we'll steal the other
     // side.
-    if (VecTy *V = Val.template dyn_cast<VecTy*>()) {
-      if (RHS.Val.template is<EltTy>()) {
+    if (VecTy *V = dyn_cast_if_present<VecTy *>(Val)) {
+      if (isa<EltTy>(RHS.Val)) {
         V->clear();
         V->push_back(RHS.front());
         RHS.Val = EltTy();
         return *this;
       }
       delete V;
     }
 
TinyPtrVector(size_t Count, EltTy Value)
       : Val(Count == 0 ? PtrUnion()
                        : Count == 1 ? PtrUnion(Value)
                                     : PtrUnion(new VecTy(Count, Value))) {}
 
   // implicit conversion operator to ArrayRef.
   operator ArrayRef<EltTy>() const {
     if (Val.isNull())
       return std::nullopt;
-    if (Val.template is<EltTy>())
+    if (isa<EltTy>(Val))
       return *Val.getAddrOfPtr1();
-    return *Val.template get<VecTy*>();
+    return *cast<VecTy *>(Val);
   }
 
   // implicit conversion operator to MutableArrayRef.
   operator MutableArrayRef<EltTy>() {
     if (Val.isNull())
       return std::nullopt;
-    if (Val.template is<EltTy>())
+    if (isa<EltTy>(Val))
       return *Val.getAddrOfPtr1();
-    return *Val.template get<VecTy*>();
+    return *cast<VecTy *>(Val);
   }
 
   // Implicit conversion to ArrayRef<U> if EltTy* implicitly converts to U*.
   template <
       typename U,
       std::enable_if_t<std::is_convertible<ArrayRef<EltTy>, ArrayRef<U>>::value,
                        bool> = false>
   operator ArrayRef<U>() const {
     return operator ArrayRef<EltTy>();
   }
 
   bool empty() const {
     // This vector can be empty if it contains no element, or if it
     // contains a pointer to an empty vector.
     if (Val.isNull()) return true;
-    if (VecTy *Vec = Val.template dyn_cast<VecTy*>())
+    if (VecTy *Vec = dyn_cast_if_present<VecTy *>(Val))
       return Vec->empty();
     return false;
   }
 
   unsigned size() const {
     if (empty())
       return 0;
-    if (Val.template is<EltTy>())
+    if (isa<EltTy>(Val))
       return 1;
-    return Val.template get<VecTy*>()->size();
+    return cast<VecTy *>(Val)->size();
   }
 
   using iterator = EltTy *;
   using const_iterator = const EltTy *;
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
   iterator begin() {
-    if (Val.template is<EltTy>())
+    if (isa<EltTy>(Val))
       return Val.getAddrOfPtr1();
 
-    return Val.template get<VecTy *>()->begin();
+    return cast<VecTy *>(Val)->begin();
   }
 
   iterator end() {
-    if (Val.template is<EltTy>())
+    if (isa<EltTy>(Val))
       return begin() + (Val.isNull() ? 0 : 1);
 
-    return Val.template get<VecTy *>()->end();
+    return cast<VecTy *>(Val)->end();
   }
 
   const_iterator begin() const {
     return (const_iterator)const_cast<TinyPtrVector*>(this)->begin();
   }
 
   const_iterator end() const {
     return (const_iterator)const_cast<TinyPtrVector*>(this)->end();
   }
 
   reverse_iterator rbegin() { return reverse_iterator(end()); }
   reverse_iterator rend() { return reverse_iterator(begin()); }
 
   const_reverse_iterator rbegin() const {
     return const_reverse_iterator(end());
   }
 
   const_reverse_iterator rend() const {
     return const_reverse_iterator(begin());
   }
 
   EltTy operator[](unsigned i) const {
     assert(!Val.isNull() && "can't index into an empty vector");
-    if (Val.template is<EltTy>()) {
+    if (isa<EltTy>(Val)) {
       assert(i == 0 && "tinyvector index out of range");
-      return Val.template get<EltTy>();
+      return cast<EltTy>(Val);
     }
 
-    assert(i < Val.template get<VecTy*>()->size() &&
-           "tinyvector index out of range");
-    return (*Val.template get<VecTy*>())[i];
+    assert(i < cast<VecTy *>(Val)->size() && "tinyvector index out of range");
+    return (*cast<VecTy *>(Val))[i];
   }
 
   EltTy front() const {
     assert(!empty() && "vector empty");
-    if (Val.template is<EltTy>())
-      return Val.template get<EltTy>();
-    return Val.template get<VecTy*>()->front();
+    if (isa<EltTy>(Val))
+      return cast<EltTy>(Val);
+    return cast<VecTy *>(Val)->front();
   }
 
   EltTy back() const {
     assert(!empty() && "vector empty");
-    if (Val.template is<EltTy>())
-      return Val.template get<EltTy>();
-    return Val.template get<VecTy*>()->back();
+    if (isa<EltTy>(Val))
+      return cast<EltTy>(Val);
+    return cast<VecTy *>(Val)->back();
   }
 
   void push_back(EltTy NewVal) {
     // If we have nothing, add something.
     if (Val.isNull()) {
       Val = NewVal;
       assert(!Val.isNull() && "Can't add a null value");
       return;
     }
 
     // If we have a single value, convert to a vector.
-    if (Val.template is<EltTy>()) {
-      EltTy V = Val.template get<EltTy>();
+    if (isa<EltTy>(Val)) {
+      EltTy V = cast<EltTy>(Val);
       Val = new VecTy();
-      Val.template get<VecTy*>()->push_back(V);
+      cast<VecTy *>(Val)->push_back(V);
     }
 
     // Add the new value, we know we have a vector.
-    Val.template get<VecTy*>()->push_back(NewVal);
+    cast<VecTy *>(Val)->push_back(NewVal);
   }
 
   void pop_back() {
     // If we have a single value, convert to empty.
-    if (Val.template is<EltTy>())
+    if (isa<EltTy>(Val))
       Val = (EltTy)nullptr;
-    else if (VecTy *Vec = Val.template get<VecTy*>())
+    else if (VecTy *Vec = cast<VecTy *>(Val))
       Vec->pop_back();
   }
 
   void clear() {
     // If we have a single value, convert to empty.
-    if (Val.template is<EltTy>()) {
+    if (isa<EltTy>(Val)) {
       Val = EltTy();
-    } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
+    } else if (VecTy *Vec = dyn_cast_if_present<VecTy *>(Val)) {
       // If we have a vector form, just clear it.
       Vec->clear();
     }
     // Otherwise, we're already empty.
   }
 
   iterator erase(iterator I) {
     assert(I >= begin() && "Iterator to erase is out of bounds.");
     assert(I < end() && "Erasing at past-the-end iterator.");
 
     // If we have a single value, convert to empty.
-    if (Val.template is<EltTy>()) {
+    if (isa<EltTy>(Val)) {
       if (I == begin())
         Val = EltTy();
-    } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
+    } else if (VecTy *Vec = dyn_cast_if_present<VecTy *>(Val)) {
       // multiple items in a vector; just do the erase, there is no
       // benefit to collapsing back to a pointer
       return Vec->erase(I);
     }
     return end();
   }
 
   iterator erase(iterator S, iterator E) {
     assert(S >= begin() && "Range to erase is out of bounds.");
     assert(S <= E && "Trying to erase invalid range.");
     assert(E <= end() && "Trying to erase past the end.");
 
-    if (Val.template is<EltTy>()) {
+    if (isa<EltTy>(Val)) {
       if (S == begin() && S != E)
         Val = EltTy();
-    } else if (VecTy *Vec = Val.template dyn_cast<VecTy*>()) {
+    } else if (VecTy *Vec = dyn_cast_if_present<VecTy *>(Val)) {
       return Vec->erase(S, E);
     }
     return end();
   }
 
   iterator insert(iterator I, const EltTy &Elt) {
     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
     assert(I <= this->end() && "Inserting past the end of the vector.");
     if (I == end()) {
       push_back(Elt);
       return std::prev(end());
     }
     assert(!Val.isNull() && "Null value with non-end insert iterator.");
-    if (Val.template is<EltTy>()) {
-      EltTy V = Val.template get<EltTy>();
+    if (isa<EltTy>(Val)) {
+      EltTy V = cast<EltTy>(Val);
       assert(I == begin());
       Val = Elt;
       push_back(V);
       return begin();
     }
 
-    return Val.template get<VecTy*>()->insert(I, Elt);
+    return cast<VecTy *>(Val)->insert(I, Elt);
   }
 
   template<typename ItTy>
   iterator insert(iterator I, ItTy From, ItTy To) {
     assert(I >= this->begin() && "Insertion iterator is out of bounds.");
     assert(I <= this->end() && "Inserting past the end of the vector.");
     if (From == To)
       return I;
 
     // If we have a single value, convert to a vector.
     ptrdiff_t Offset = I - begin();
     if (Val.isNull()) {
       if (std::next(From) == To) {
         Val = *From;
         return begin();
       }
 
       Val = new VecTy();
-    } else if (Val.template is<EltTy>()) {
-      EltTy V = Val.template get<EltTy>();
+    } else if (isa<EltTy>(Val)) {
+      EltTy V = cast<EltTy>(Val);
       Val = new VecTy();
-      Val.template get<VecTy*>()->push_back(V);
+      cast<VecTy *>(Val)->push_back(V);
     }
-    return Val.template get<VecTy*>()->insert(begin() + Offset, From, To);
+    return cast<VecTy *>(Val)->insert(begin() + Offset, From, To);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_TINYPTRVECTOR_H

llvm/include/llvm/CodeGen/DwarfStringPoolEntry.h

public:
   /// thus specified entry mustn`t be reallocated.
   DwarfStringPoolEntryRef(const StringMapEntry<DwarfStringPoolEntry> &Entry)
       : MapEntry(&Entry) {}
 
   /// ASSUMPTION: DwarfStringPoolEntryRef keeps pointer to \p Entry,
   /// thus specified entry mustn`t be reallocated.
   DwarfStringPoolEntryRef(const StringMapEntry<DwarfStringPoolEntry *> &Entry)
       : MapEntry(&Entry) {
-    assert(MapEntry.get<ByPtrStringEntryPtr>()->second != nullptr);
+    assert(cast<ByPtrStringEntryPtr>(MapEntry)->second != nullptr);
   }
 
   explicit operator bool() const { return !MapEntry.isNull(); }
 
   /// \returns symbol for the dwarf string.
   MCSymbol *getSymbol() const {
     assert(getEntry().Symbol && "No symbol available!");
     return getEntry().Symbol;
   }
 
   /// \returns offset for the dwarf string.
   uint64_t getOffset() const { return getEntry().Offset; }
 
   /// \returns index for the dwarf string.
   unsigned getIndex() const {
     assert(getEntry().isIndexed() && "Index is not set!");
     return getEntry().Index;
   }
 
   /// \returns string.
   StringRef getString() const {
-    if (MapEntry.is<ByValStringEntryPtr>())
-      return MapEntry.get<ByValStringEntryPtr>()->first();
+    if (isa<ByValStringEntryPtr>(MapEntry))
+      return cast<ByValStringEntryPtr>(MapEntry)->first();
 
-    return MapEntry.get<ByPtrStringEntryPtr>()->first();
+    return cast<ByPtrStringEntryPtr>(MapEntry)->first();
   }
 
   /// \returns the entire string pool entry for convenience.
   const DwarfStringPoolEntry &getEntry() const {
-    if (MapEntry.is<ByValStringEntryPtr>())
-      return MapEntry.get<ByValStringEntryPtr>()->second;
+    if (isa<ByValStringEntryPtr>(MapEntry))
+      return cast<ByValStringEntryPtr>(MapEntry)->second;
 
-    return *MapEntry.get<ByPtrStringEntryPtr>()->second;
+    return *cast<ByPtrStringEntryPtr>(MapEntry)->second;
   }
 
   bool operator==(const DwarfStringPoolEntryRef &X) const {
     return MapEntry.getOpaqueValue() == X.MapEntry.getOpaqueValue();
   }
 
   bool operator!=(const DwarfStringPoolEntryRef &X) const {
     return MapEntry.getOpaqueValue() != X.MapEntry.getOpaqueValue();
   }
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/CodeGen/MachineMemOperand.h

explicit MachinePointerInfo(unsigned AddressSpace = 0, int64_t offset = 0)
         StackID(0) {}
 
   explicit MachinePointerInfo(
     PointerUnion<const Value *, const PseudoSourceValue *> v,
     int64_t offset = 0,
     uint8_t ID = 0)
     : V(v), Offset(offset), StackID(ID) {
     if (V) {
-      if (const auto *ValPtr = V.dyn_cast<const Value*>())
+      if (const auto *ValPtr = dyn_cast_if_present<const Value *>(V))
         AddrSpace = ValPtr->getType()->getPointerAddressSpace();
       else
-        AddrSpace = V.get<const PseudoSourceValue*>()->getAddressSpace();
+        AddrSpace = cast<const PseudoSourceValue *>(V)->getAddressSpace();
     }
   }
 
   MachinePointerInfo getWithOffset(int64_t O) const {
     if (V.isNull())
       return MachinePointerInfo(AddrSpace, Offset + O);
-    if (V.is<const Value*>())
-      return MachinePointerInfo(V.get<const Value*>(), Offset + O, StackID);
-    return MachinePointerInfo(V.get<const PseudoSourceValue*>(), Offset + O,
+    if (isa<const Value *>(V))
+      return MachinePointerInfo(cast<const Value *>(V), Offset + O, StackID);
+    return MachinePointerInfo(cast<const PseudoSourceValue *>(V), Offset + O,
                               StackID);
   }
 
   /// Return true if memory region [V, V+Offset+Size) is known to be
   /// dereferenceable.
   bool isDereferenceable(unsigned Size, LLVMContext &C,
                          const DataLayout &DL) const;
 
public:
 
   /// Return the base address of the memory access. This may either be a normal
   /// LLVM IR Value, or one of the special values used in CodeGen.
   /// Special values are those obtained via
   /// PseudoSourceValue::getFixedStack(int), PseudoSourceValue::getStack, and
   /// other PseudoSourceValue member functions which return objects which stand
   /// for frame/stack pointer relative references and other special references
   /// which are not representable in the high-level IR.
-  const Value *getValue() const { return PtrInfo.V.dyn_cast<const Value*>(); }
+  const Value *getValue() const {
+    return dyn_cast_if_present<const Value *>(PtrInfo.V);
+  }
 
   const PseudoSourceValue *getPseudoValue() const {
-    return PtrInfo.V.dyn_cast<const PseudoSourceValue*>();
+    return dyn_cast_if_present<const PseudoSourceValue *>(PtrInfo.V);
   }
 
   const void *getOpaqueValue() const { return PtrInfo.V.getOpaqueValue(); }
 
   /// Return the raw flags of the source value, \see Flags.
   Flags getFlags() const { return FlagVals; }
 
   /// Bitwise OR the current flags with the given flags.

llvm/include/llvm/CodeGen/MachineRegisterInfo.h

public:
   //===--------------------------------------------------------------------===//
   // Virtual Register Info
   //===--------------------------------------------------------------------===//
 
   /// Return the register class of the specified virtual register.
   /// This shouldn't be used directly unless \p Reg has a register class.
   /// \see getRegClassOrNull when this might happen.
   const TargetRegisterClass *getRegClass(Register Reg) const {
-    assert(VRegInfo[Reg.id()].first.is<const TargetRegisterClass *>() &&
+    assert(isa<const TargetRegisterClass *>(VRegInfo[Reg.id()].first) &&
            "Register class not set, wrong accessor");
-    return VRegInfo[Reg.id()].first.get<const TargetRegisterClass *>();
+    return cast<const TargetRegisterClass *>(VRegInfo[Reg.id()].first);
   }
 
   /// Return the register class of \p Reg, or null if Reg has not been assigned
   /// a register class yet.
   ///
   /// \note A null register class can only happen when these two
   /// conditions are met:
   /// 1. Generic virtual registers are created.
   /// 2. The machine function has not completely been through the
   ///    instruction selection process.
   /// None of this condition is possible without GlobalISel for now.
   /// In other words, if GlobalISel is not used or if the query happens after
   /// the select pass, using getRegClass is safe.
   const TargetRegisterClass *getRegClassOrNull(Register Reg) const {
     const RegClassOrRegBank &Val = VRegInfo[Reg].first;
-    return Val.dyn_cast<const TargetRegisterClass *>();
+    return dyn_cast_if_present<const TargetRegisterClass *>(Val);
   }
 
   /// Return the register bank of \p Reg, or null if Reg has not been assigned
   /// a register bank or has been assigned a register class.
   /// \note It is possible to get the register bank from the register class via
   /// RegisterBankInfo::getRegBankFromRegClass.
   const RegisterBank *getRegBankOrNull(Register Reg) const {
     const RegClassOrRegBank &Val = VRegInfo[Reg].first;
-    return Val.dyn_cast<const RegisterBank *>();
+    return dyn_cast_if_present<const RegisterBank *>(Val);
   }
 
   /// Return the register bank or register class of \p Reg.
   /// \note Before the register bank gets assigned (i.e., before the
   /// RegBankSelect pass) \p Reg may not have either.
   const RegClassOrRegBank &getRegClassOrRegBank(Register Reg) const {
     return VRegInfo[Reg].first;
   }

llvm/include/llvm/CodeGen/SelectionDAGNodes.h

public:
   ArrayRef<MachineMemOperand *> memoperands() const {
     // Special case the common cases.
     if (NumMemRefs == 0)
       return {};
     if (NumMemRefs == 1)
       return ArrayRef(MemRefs.getAddrOfPtr1(), 1);
 
     // Otherwise we have an actual array.
-    return ArrayRef(MemRefs.get<MachineMemOperand **>(), NumMemRefs);
+    return ArrayRef(cast<MachineMemOperand **>(MemRefs), NumMemRefs);
   }
   mmo_iterator memoperands_begin() const { return memoperands().begin(); }
   mmo_iterator memoperands_end() const { return memoperands().end(); }
   bool memoperands_empty() const { return memoperands().empty(); }
 
   /// Clear out the memory reference descriptor list.
   void clearMemRefs() {
     MemRefs = nullptr;

llvm/include/llvm/CodeGen/WasmEHFuncInfo.h

struct WasmEHFuncInfo {
   // When there is an entry <A, B>, if an exception is not caught by A, it
   // should next unwind to the EH pad B.
   DenseMap<BBOrMBB, BBOrMBB> SrcToUnwindDest;
   DenseMap<BBOrMBB, SmallPtrSet<BBOrMBB, 4>> UnwindDestToSrcs; // reverse map
 
   // Helper functions
   const BasicBlock *getUnwindDest(const BasicBlock *BB) const {
     assert(hasUnwindDest(BB));
-    return SrcToUnwindDest.lookup(BB).get<const BasicBlock *>();
+    return cast<const BasicBlock *>(SrcToUnwindDest.lookup(BB));
   }
   SmallPtrSet<const BasicBlock *, 4> getUnwindSrcs(const BasicBlock *BB) const {
     assert(hasUnwindSrcs(BB));
     const auto &Set = UnwindDestToSrcs.lookup(BB);
     SmallPtrSet<const BasicBlock *, 4> Ret;
     for (const auto P : Set)
-      Ret.insert(P.get<const BasicBlock *>());
+      Ret.insert(cast<const BasicBlock *>(P));
     return Ret;
   }
   void setUnwindDest(const BasicBlock *BB, const BasicBlock *Dest) {
     SrcToUnwindDest[BB] = Dest;
     UnwindDestToSrcs[Dest].insert(BB);
   }
   bool hasUnwindDest(const BasicBlock *BB) const {
     return SrcToUnwindDest.count(BB);
   }
   bool hasUnwindSrcs(const BasicBlock *BB) const {
     return UnwindDestToSrcs.count(BB);
   }
 
   MachineBasicBlock *getUnwindDest(MachineBasicBlock *MBB) const {
     assert(hasUnwindDest(MBB));
-    return SrcToUnwindDest.lookup(MBB).get<MachineBasicBlock *>();
+    return cast<MachineBasicBlock *>(SrcToUnwindDest.lookup(MBB));
   }
   SmallPtrSet<MachineBasicBlock *, 4>
   getUnwindSrcs(MachineBasicBlock *MBB) const {
     assert(hasUnwindSrcs(MBB));
     const auto &Set = UnwindDestToSrcs.lookup(MBB);
     SmallPtrSet<MachineBasicBlock *, 4> Ret;
     for (const auto P : Set)
-      Ret.insert(P.get<MachineBasicBlock *>());
+      Ret.insert(cast<MachineBasicBlock *>(P));
     return Ret;
   }
   void setUnwindDest(MachineBasicBlock *MBB, MachineBasicBlock *Dest) {
     SrcToUnwindDest[MBB] = Dest;
     UnwindDestToSrcs[Dest].insert(MBB);
   }
   bool hasUnwindDest(MachineBasicBlock *MBB) const {
     return SrcToUnwindDest.count(MBB);

llvm/include/llvm/IR/GetElementPtrTypeIterator.h

bool operator!=(const generic_gep_type_iterator &x) const {
     return !operator==(x);
   }
 
   // FIXME: Make this the iterator's operator*() after the 4.0 release.
   // operator*() had a different meaning in earlier releases, so we're
   // temporarily not giving this iterator an operator*() to avoid a subtle
   // semantics break.
   Type *getIndexedType() const {
-    if (auto *T = CurTy.dyn_cast<Type *>())
+    if (auto *T = dyn_cast_if_present<Type *>(CurTy))
       return T;
-    return CurTy.get<StructType *>()->getTypeAtIndex(getOperand());
+    return cast<StructType *>(CurTy)->getTypeAtIndex(getOperand());
   }
 
   Value *getOperand() const { return const_cast<Value *>(&**OpIt); }
 
   generic_gep_type_iterator &operator++() { // Preincrement
     Type *Ty = getIndexedType();
     if (auto *ATy = dyn_cast<ArrayType>(Ty))
       CurTy = ATy->getElementType();
public:
   //
   // FIXME: Most current users of this class are just interested in byte
   // offsets (a few need to know whether the outer type is a struct because
   // they are trying to replace a constant with a variable, which is only
   // legal for arrays, e.g. canReplaceOperandWithVariable in SimplifyCFG.cpp);
   // we should provide a more minimal API here that exposes not much more than
   // that.
 
-  bool isStruct() const { return CurTy.is<StructType *>(); }
-  bool isSequential() const { return CurTy.is<Type *>(); }
+  bool isStruct() const { return isa<StructType *>(CurTy); }
+  bool isSequential() const { return isa<Type *>(CurTy); }
 
-  StructType *getStructType() const { return CurTy.get<StructType *>(); }
+  StructType *getStructType() const { return cast<StructType *>(CurTy); }
 
   StructType *getStructTypeOrNull() const {
-    return CurTy.dyn_cast<StructType *>();
+    return dyn_cast_if_present<StructType *>(CurTy);
   }
 };
 
   using gep_type_iterator = generic_gep_type_iterator<>;
 
   inline gep_type_iterator gep_type_begin(const User *GEP) {
     auto *GEPOp = cast<GEPOperator>(GEP);
     return gep_type_iterator::begin(

llvm/include/llvm/IR/IntrinsicInst.h

public:
 
   location_op_iterator(const location_op_iterator &R) : I(R.I) {}
   location_op_iterator &operator=(const location_op_iterator &R) {
     I = R.I;
     return *this;
   }
   bool operator==(const location_op_iterator &RHS) const { return I == RHS.I; }
   const Value *operator*() const {
-    ValueAsMetadata *VAM = I.is<ValueAsMetadata *>()
-                               ? I.get<ValueAsMetadata *>()
-                               : *I.get<ValueAsMetadata **>();
+    ValueAsMetadata *VAM = isa<ValueAsMetadata *>(I)
+                               ? cast<ValueAsMetadata *>(I)
+                               : *cast<ValueAsMetadata **>(I);
     return VAM->getValue();
   };
   Value *operator*() {
-    ValueAsMetadata *VAM = I.is<ValueAsMetadata *>()
-                               ? I.get<ValueAsMetadata *>()
-                               : *I.get<ValueAsMetadata **>();
+    ValueAsMetadata *VAM = isa<ValueAsMetadata *>(I)
+                               ? cast<ValueAsMetadata *>(I)
+                               : *cast<ValueAsMetadata **>(I);
     return VAM->getValue();
   }
   location_op_iterator &operator++() {
-    if (I.is<ValueAsMetadata *>())
-      I = I.get<ValueAsMetadata *>() + 1;
+    if (isa<ValueAsMetadata *>(I))
+      I = cast<ValueAsMetadata *>(I) + 1;
     else
-      I = I.get<ValueAsMetadata **>() + 1;
+      I = cast<ValueAsMetadata **>(I) + 1;
     return *this;
   }
   location_op_iterator &operator--() {
-    if (I.is<ValueAsMetadata *>())
-      I = I.get<ValueAsMetadata *>() - 1;
+    if (isa<ValueAsMetadata *>(I))
+      I = cast<ValueAsMetadata *>(I) - 1;
     else
-      I = I.get<ValueAsMetadata **>() - 1;
+      I = cast<ValueAsMetadata **>(I) - 1;
     return *this;
   }
 };
 
 /// Lightweight class that wraps the location operand metadata of a debug
 /// intrinsic. The raw location may be a ValueAsMetadata, an empty MDTuple,
 /// or a DIArgList.
 class RawLocationWrapper {

llvm/include/llvm/IR/Metadata.h

public:
   ContextAndReplaceableUses &
   operator=(const ContextAndReplaceableUses &) = delete;
   ~ContextAndReplaceableUses() { delete getReplaceableUses(); }
 
   operator LLVMContext &() { return getContext(); }
 
   /// Whether this contains RAUW support.
   bool hasReplaceableUses() const {
-    return Ptr.is<ReplaceableMetadataImpl *>();
+    return isa<ReplaceableMetadataImpl *>(Ptr);
   }
 
   LLVMContext &getContext() const {
     if (hasReplaceableUses())
       return getReplaceableUses()->getContext();
-    return *Ptr.get<LLVMContext *>();
+    return *cast<LLVMContext *>(Ptr);
   }
 
   ReplaceableMetadataImpl *getReplaceableUses() const {
     if (hasReplaceableUses())
-      return Ptr.get<ReplaceableMetadataImpl *>();
+      return cast<ReplaceableMetadataImpl *>(Ptr);
     return nullptr;
   }
 
   /// Ensure that this has RAUW support, and then return it.
   ReplaceableMetadataImpl *getOrCreateReplaceableUses() {
     if (!hasReplaceableUses())
       makeReplaceable(std::make_unique<ReplaceableMetadataImpl>(getContext()));
     return getReplaceableUses();

llvm/include/llvm/Transforms/Utils/Evaluator.h

public:
     MutableValue(const MutableValue &) = delete;
     MutableValue(MutableValue &&Other) {
       Val = Other.Val;
       Other.Val = nullptr;
     }
     ~MutableValue() { clear(); }
 
     Type *getType() const {
-      if (auto *C = Val.dyn_cast<Constant *>())
+      if (auto *C = dyn_cast_if_present<Constant *>(Val))
         return C->getType();
-      return Val.get<MutableAggregate *>()->Ty;
+      return cast<MutableAggregate *>(Val)->Ty;
     }
 
     Constant *toConstant() const {
-      if (auto *C = Val.dyn_cast<Constant *>())
+      if (auto *C = dyn_cast_if_present<Constant *>(Val))
         return C;
-      return Val.get<MutableAggregate *>()->toConstant();
+      return cast<MutableAggregate *>(Val)->toConstant();
     }
 
     Constant *read(Type *Ty, APInt Offset, const DataLayout &DL) const;
     bool write(Constant *V, APInt Offset, const DataLayout &DL);
   };
 
   struct MutableAggregate {
     Type *Ty;

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

for (int i = Elements.size() - 1; i >= 0; --i) {
 
     const DISubrange *Subrange = cast<DISubrange>(Element);
     int64_t Count = -1;
 
     // If Subrange has a Count field, use it.
     // Otherwise, if it has an upperboud, use (upperbound - lowerbound + 1),
     // where lowerbound is from the LowerBound field of the Subrange,
     // or the language default lowerbound if that field is unspecified.
-    if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt *>())
+    if (auto *CI = dyn_cast_if_present<ConstantInt *>(Subrange->getCount()))
       Count = CI->getSExtValue();
-    else if (auto *UI = Subrange->getUpperBound().dyn_cast<ConstantInt *>()) {
+    else if (auto *UI = dyn_cast_if_present<ConstantInt *>(
+                 Subrange->getUpperBound())) {
       // Fortran uses 1 as the default lowerbound; other languages use 0.
       int64_t Lowerbound = (moduleIsInFortran()) ? 1 : 0;
-      auto *LI = Subrange->getLowerBound().dyn_cast<ConstantInt *>();
+      auto *LI = dyn_cast_if_present<ConstantInt *>(Subrange->getLowerBound());
       Lowerbound = (LI) ? LI->getSExtValue() : Lowerbound;
       Count = UI->getSExtValue() - Lowerbound + 1;
     }
 
     // Forward declarations of arrays without a size and VLAs use a count of -1.
     // Emit a count of zero in these cases to match what MSVC does for arrays
     // without a size. MSVC doesn't support VLAs, so it's not clear what we
     // should do for them even if we could distinguish them.
if (!GlobalVariables.empty() || !StaticConstMembers.empty()) {
     emitGlobalVariableList(GlobalVariables);
     emitStaticConstMemberList();
     endCVSubsection(EndLabel);
   }
 
   // Second, emit each global that is in a comdat into its own .debug$S
   // section along with its own symbol substream.
   for (const CVGlobalVariable &CVGV : ComdatVariables) {
-    const GlobalVariable *GV = CVGV.GVInfo.get<const GlobalVariable *>();
+    const GlobalVariable *GV = cast<const GlobalVariable *>(CVGV.GVInfo);
     MCSymbol *GVSym = Asm->getSymbol(GV);
     OS.AddComment("Symbol subsection for " +
                   Twine(GlobalValue::dropLLVMManglingEscape(GV->getName())));
     switchToDebugSectionForSymbol(GVSym);
     MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
     // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
     emitDebugInfoForGlobal(CVGV);
     endCVSubsection(EndLabel);
void CodeViewDebug::emitDebugInfoForGlobal(const CVGlobalVariable &CVGV) {
   // in its name so that we can reference the variable in the command line
   // of the VS debugger.
   std::string QualifiedName =
       (moduleIsInFortran() || (Scope && isa<DILocalScope>(Scope)))
           ? std::string(DIGV->getName())
           : getFullyQualifiedName(Scope, DIGV->getName());
 
   if (const GlobalVariable *GV =
-          CVGV.GVInfo.dyn_cast<const GlobalVariable *>()) {
+          dyn_cast_if_present<const GlobalVariable *>(CVGV.GVInfo)) {
     // DataSym record, see SymbolRecord.h for more info. Thread local data
     // happens to have the same format as global data.
     MCSymbol *GVSym = Asm->getSymbol(GV);
     SymbolKind DataSym = GV->isThreadLocal()
                              ? (DIGV->isLocalToUnit() ? SymbolKind::S_LTHREAD32
                                                       : SymbolKind::S_GTHREAD32)
                              : (DIGV->isLocalToUnit() ? SymbolKind::S_LDATA32
                                                       : SymbolKind::S_GDATA32);
if (const GlobalVariable *GV =
 
     OS.AddComment("Segment");
     OS.emitCOFFSectionIndex(GVSym);
     OS.AddComment("Name");
     const unsigned LengthOfDataRecord = 12;
     emitNullTerminatedSymbolName(OS, QualifiedName, LengthOfDataRecord);
     endSymbolRecord(DataEnd);
   } else {
-    const DIExpression *DIE = CVGV.GVInfo.get<const DIExpression *>();
+    const DIExpression *DIE = cast<const DIExpression *>(CVGV.GVInfo);
     assert(DIE->isConstant() &&
            "Global constant variables must contain a constant expression.");
 
     // Use unsigned for floats.
     bool isUnsigned = isFloatDIType(DIGV->getType())
                           ? true
                           : DebugHandlerBase::isUnsignedDIType(DIGV->getType());
     APSInt Value(APInt(/*BitWidth=*/64, DIE->getElement(1)), isUnsigned);
     emitConstantSymbolRecord(DIGV->getType(), Value, QualifiedName);
   }
 }

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

if (!Abbreviations.empty()) {
     AP->emitDwarfAbbrevs(Abbreviations);
   }
 }
 
 //===----------------------------------------------------------------------===//
 // DIE Implementation
 //===----------------------------------------------------------------------===//
 
-DIE *DIE::getParent() const {
-  return Owner.dyn_cast<DIE*>();
-}
+DIE *DIE::getParent() const { return dyn_cast_if_present<DIE *>(Owner); }
 
 DIEAbbrev DIE::generateAbbrev() const {
   DIEAbbrev Abbrev(Tag, hasChildren());
   for (const DIEValue &V : values())
     if (V.getForm() == dwarf::DW_FORM_implicit_const)
       Abbrev.AddImplicitConstAttribute(V.getAttribute(),
                                        V.getDIEInteger().getValue());
     else
while (p) {
     p = p->getParent();
   }
   return nullptr;
 }
 
 DIEUnit *DIE::getUnit() const {
   const DIE *UnitDie = getUnitDie();
   if (UnitDie)
-    return UnitDie->Owner.dyn_cast<DIEUnit*>();
+    return dyn_cast_if_present<DIEUnit *>(UnitDie->Owner);
   return nullptr;
 }
 
 DIEValue DIE::findAttribute(dwarf::Attribute Attribute) const {
   // Iterate through all the attributes until we find the one we're
   // looking for, if we can't find it return NULL.
   for (const auto &V : values())
     if (V.getAttribute() == Attribute)

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (auto *DLVar = Array->getDataLocation())
     Result.push_back(DLVar);
   if (auto *AsVar = Array->getAssociated())
     Result.push_back(AsVar);
   if (auto *AlVar = Array->getAllocated())
     Result.push_back(AlVar);
   for (auto *El : Array->getElements()) {
     if (auto *Subrange = dyn_cast<DISubrange>(El)) {
       if (auto Count = Subrange->getCount())
-        if (auto *Dependency = Count.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Count))
           Result.push_back(Dependency);
       if (auto LB = Subrange->getLowerBound())
-        if (auto *Dependency = LB.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(LB))
           Result.push_back(Dependency);
       if (auto UB = Subrange->getUpperBound())
-        if (auto *Dependency = UB.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(UB))
           Result.push_back(Dependency);
       if (auto ST = Subrange->getStride())
-        if (auto *Dependency = ST.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(ST))
           Result.push_back(Dependency);
     } else if (auto *GenericSubrange = dyn_cast<DIGenericSubrange>(El)) {
       if (auto Count = GenericSubrange->getCount())
-        if (auto *Dependency = Count.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(Count))
           Result.push_back(Dependency);
       if (auto LB = GenericSubrange->getLowerBound())
-        if (auto *Dependency = LB.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(LB))
           Result.push_back(Dependency);
       if (auto UB = GenericSubrange->getUpperBound())
-        if (auto *Dependency = UB.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(UB))
           Result.push_back(Dependency);
       if (auto ST = GenericSubrange->getStride())
-        if (auto *Dependency = ST.dyn_cast<DIVariable *>())
+        if (auto *Dependency = dyn_cast_if_present<DIVariable *>(ST))
           Result.push_back(Dependency);
     }
   }
   return Result;
 }
 
 /// Sort local variables so that variables appearing inside of helper
 /// expressions come first.

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
   // The LowerBound value defines the lower bounds which is typically zero for
   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
   // Count == -1 then the array is unbounded and we do not emit
   // DW_AT_lower_bound and DW_AT_count attributes.
   int64_t DefaultLowerBound = getDefaultLowerBound();
 
   auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
                                DISubrange::BoundType Bound) -> void {
-    if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
+    if (auto *BV = dyn_cast_if_present<DIVariable *>(Bound)) {
       if (auto *VarDIE = getDIE(BV))
         addDIEEntry(DW_Subrange, Attr, *VarDIE);
-    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
+    } else if (auto *BE = dyn_cast_if_present<DIExpression *>(Bound)) {
       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
       DIEDwarfExpression DwarfExpr(*Asm, getCU(), *Loc);
       DwarfExpr.setMemoryLocationKind();
       DwarfExpr.addExpression(BE);
       addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
-    } else if (auto *BI = Bound.dyn_cast<ConstantInt *>()) {
+    } else if (auto *BI = dyn_cast_if_present<ConstantInt *>(Bound)) {
       if (Attr == dwarf::DW_AT_count) {
         if (BI->getSExtValue() != -1)
           addUInt(DW_Subrange, Attr, std::nullopt, BI->getSExtValue());
       } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
                  BI->getSExtValue() != DefaultLowerBound)
         addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
     }
   };
void DwarfUnit::constructGenericSubrangeDIE(DIE &Buffer,
   DIE &DwGenericSubrange =
       createAndAddDIE(dwarf::DW_TAG_generic_subrange, Buffer);
   addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
 
   int64_t DefaultLowerBound = getDefaultLowerBound();
 
   auto AddBoundTypeEntry = [&](dwarf::Attribute Attr,
                                DIGenericSubrange::BoundType Bound) -> void {
-    if (auto *BV = Bound.dyn_cast<DIVariable *>()) {
+    if (auto *BV = dyn_cast_if_present<DIVariable *>(Bound)) {
       if (auto *VarDIE = getDIE(BV))
         addDIEEntry(DwGenericSubrange, Attr, *VarDIE);
-    } else if (auto *BE = Bound.dyn_cast<DIExpression *>()) {
+    } else if (auto *BE = dyn_cast_if_present<DIExpression *>(Bound)) {
       if (BE->isConstant() &&
           DIExpression::SignedOrUnsignedConstant::SignedConstant ==
               *BE->isConstant()) {
         if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
             static_cast<int64_t>(BE->getElement(1)) != DefaultLowerBound)
           addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
                   BE->getElement(1));
       } else {
static bool hasVectorBeenPadded(const DICompositeType *CTy) {
   // Locate the number of elements in the vector.
   const DINodeArray Elements = CTy->getElements();
   assert(Elements.size() == 1 &&
          Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
          "Invalid vector element array, expected one element of type subrange");
   const auto Subrange = cast<DISubrange>(Elements[0]);
   const auto NumVecElements =
       Subrange->getCount()
-          ? Subrange->getCount().get<ConstantInt *>()->getSExtValue()
+          ? cast<ConstantInt *>(Subrange->getCount())->getSExtValue()
           : 0;
 
   // Ensure we found the element count and that the actual size is wide
   // enough to contain the requested size.
   assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
   return ActualSize != (NumVecElements * ElementSize);
 }
 

llvm/lib/CodeGen/AsmPrinter/WinException.cpp

if (VerboseAsm)
       OS.AddComment(Comment);
   };
 
   assert(BeginLabel && EndLabel);
   while (State != -1) {
     const SEHUnwindMapEntry &UME = FuncInfo.SEHUnwindMap[State];
     const MCExpr *FilterOrFinally;
     const MCExpr *ExceptOrNull;
-    auto *Handler = UME.Handler.get<MachineBasicBlock *>();
+    auto *Handler = cast<MachineBasicBlock *>(UME.Handler);
     if (UME.IsFinally) {
       FilterOrFinally = create32bitRef(getMCSymbolForMBB(Asm, Handler));
       ExceptOrNull = MCConstantExpr::create(0, Ctx);
     } else {
       // For an except, the filter can be 1 (catch-all) or a function
       // label.
       FilterOrFinally = UME.Filter ? create32bitRef(UME.Filter)
                                    : MCConstantExpr::create(1, Ctx);
void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) {
 
   // UnwindMapEntry {
   //   int32_t ToState;
   //   void  (*Action)();
   // };
   if (UnwindMapXData) {
     OS.emitLabel(UnwindMapXData);
     for (const CxxUnwindMapEntry &UME : FuncInfo.CxxUnwindMap) {
-      MCSymbol *CleanupSym =
-          getMCSymbolForMBB(Asm, UME.Cleanup.dyn_cast<MachineBasicBlock *>());
+      MCSymbol *CleanupSym = getMCSymbolForMBB(
+          Asm, dyn_cast_if_present<MachineBasicBlock *>(UME.Cleanup));
       AddComment("ToState");
       OS.emitInt32(UME.ToState);
 
       AddComment("Action");
       OS.emitValue(create32bitRef(CleanupSym), 4);
     }
   }
 
for (size_t I = 0, E = FuncInfo.TryBlockMap.size(); I != E; ++I) {
         if (HT.CatchObj.FrameIndex != INT_MAX) {
           int Offset = getFrameIndexOffset(HT.CatchObj.FrameIndex, FuncInfo);
           assert(Offset != 0 && "Illegal offset for catch object!");
           FrameAllocOffsetRef = MCConstantExpr::create(Offset, Asm->OutContext);
         } else {
           FrameAllocOffsetRef = MCConstantExpr::create(0, Asm->OutContext);
         }
 
-        MCSymbol *HandlerSym =
-            getMCSymbolForMBB(Asm, HT.Handler.dyn_cast<MachineBasicBlock *>());
+        MCSymbol *HandlerSym = getMCSymbolForMBB(
+            Asm, dyn_cast_if_present<MachineBasicBlock *>(HT.Handler));
 
         AddComment("Adjectives");
         OS.emitInt32(HT.Adjectives);
 
         AddComment("Type");
         OS.emitValue(create32bitRef(HT.TypeDescriptor), 4);
 
         AddComment("CatchObjOffset");
if (PerName == "_except_handler4") {
     OS.emitInt32(EHCookieOffset);
     AddComment("EHCookieXOROffset");
     OS.emitInt32(0);
     BaseState = -2;
   }
 
   assert(!FuncInfo.SEHUnwindMap.empty());
   for (const SEHUnwindMapEntry &UME : FuncInfo.SEHUnwindMap) {
-    auto *Handler = UME.Handler.get<MachineBasicBlock *>();
+    auto *Handler = cast<MachineBasicBlock *>(UME.Handler);
     const MCSymbol *ExceptOrFinally =
         UME.IsFinally ? getMCSymbolForMBB(Asm, Handler) : Handler->getSymbol();
     // -1 is usually the base state for "unwind to caller", but for
     // _except_handler4 it's -2. Do that replacement here if necessary.
     int ToState = UME.ToState == -1 ? BaseState : UME.ToState;
     AddComment("ToState");
     OS.emitInt32(ToState);
     AddComment(UME.IsFinally ? "Null" : "FilterFunction");
void WinException::emitCLRExceptionTable(const MachineFunction *MF) {
 
   // Build a map from handler MBBs to their corresponding states (i.e. their
   // indices in the ClrEHUnwindMap).
   int NumStates = FuncInfo.ClrEHUnwindMap.size();
   assert(NumStates > 0 && "Don't need exception table!");
   DenseMap<const MachineBasicBlock *, int> HandlerStates;
   for (int State = 0; State < NumStates; ++State) {
     MachineBasicBlock *HandlerBlock =
-        FuncInfo.ClrEHUnwindMap[State].Handler.get<MachineBasicBlock *>();
+        cast<MachineBasicBlock *>(FuncInfo.ClrEHUnwindMap[State].Handler);
     HandlerStates[HandlerBlock] = State;
     // Use this loop through all handlers to verify our assumption (used in
     // the MinEnclosingState computation) that enclosing funclets have lower
     // state numbers than their enclosed funclets.
     assert(FuncInfo.ClrEHUnwindMap[State].HandlerParentState < State &&
            "ill-formed state numbering");
   }
   // Map the main function to the NullState.
for (ClrClause &Clause : Clauses) {
     // them so the runtime can distinguish the point to which the call will
     // return from the point at which the fault occurs.
 
     const MCExpr *ClauseBegin =
         getOffsetPlusOne(Clause.StartLabel, FuncBeginSym);
     const MCExpr *ClauseEnd = getOffsetPlusOne(Clause.EndLabel, FuncBeginSym);
 
     const ClrEHUnwindMapEntry &Entry = FuncInfo.ClrEHUnwindMap[Clause.State];
-    MachineBasicBlock *HandlerBlock = Entry.Handler.get<MachineBasicBlock *>();
+    MachineBasicBlock *HandlerBlock = cast<MachineBasicBlock *>(Entry.Handler);
     MCSymbol *BeginSym = getMCSymbolForMBB(Asm, HandlerBlock);
     const MCExpr *HandlerBegin = getOffset(BeginSym, FuncBeginSym);
     MCSymbol *EndSym = EndSymbolMap[Clause.State];
     const MCExpr *HandlerEnd = getOffset(EndSym, FuncBeginSym);
 
     uint32_t Flags = 0;
     switch (Entry.HandlerType) {
     case ClrHandlerType::Catch:

llvm/lib/CodeGen/GlobalISel/CSEInfo.cpp

 
 const GISelInstProfileBuilder &
 GISelInstProfileBuilder::addNodeIDReg(Register Reg) const {
   LLT Ty = MRI.getType(Reg);
   if (Ty.isValid())
     addNodeIDRegType(Ty);
 
   if (const RegClassOrRegBank &RCOrRB = MRI.getRegClassOrRegBank(Reg)) {
-    if (const auto *RB = RCOrRB.dyn_cast<const RegisterBank *>())
+    if (const auto *RB = dyn_cast_if_present<const RegisterBank *>(RCOrRB))
       addNodeIDRegType(RB);
-    else if (const auto *RC = RCOrRB.dyn_cast<const TargetRegisterClass *>())
+    else if (const auto *RC =
+                 dyn_cast_if_present<const TargetRegisterClass *>(RCOrRB))
       addNodeIDRegType(RC);
   }
   return *this;
 }
 
 const GISelInstProfileBuilder &GISelInstProfileBuilder::addNodeIDMachineOperand(
     const MachineOperand &MO) const {
   if (MO.isReg()) {

llvm/lib/CodeGen/GlobalISel/Utils.cpp

if (SNaN) {
     }
   }
 
   return false;
 }
 
 Align llvm::inferAlignFromPtrInfo(MachineFunction &MF,
                                   const MachinePointerInfo &MPO) {
-  auto PSV = MPO.V.dyn_cast<const PseudoSourceValue *>();
+  auto PSV = dyn_cast_if_present<const PseudoSourceValue *>(MPO.V);
   if (auto FSPV = dyn_cast_or_null<FixedStackPseudoSourceValue>(PSV)) {
     MachineFrameInfo &MFI = MF.getFrameInfo();
     return commonAlignment(MFI.getObjectAlign(FSPV->getFrameIndex()),
                            MPO.Offset);
   }
 
-  if (const Value *V = MPO.V.dyn_cast<const Value *>()) {
+  if (const Value *V = dyn_cast_if_present<const Value *>(MPO.V)) {
     const Module *M = MF.getFunction().getParent();
     return V->getPointerAlignment(M->getDataLayout());
   }
 
   return Align(1);
 }
 
 Register llvm::getFunctionLiveInPhysReg(MachineFunction &MF,

llvm/lib/CodeGen/MachineOperand.cpp

 /// getAddrSpace - Return the LLVM IR address space number that this pointer
 /// points into.
 unsigned MachinePointerInfo::getAddrSpace() const { return AddrSpace; }
 
 /// isDereferenceable - Return true if V is always dereferenceable for
 /// Offset + Size byte.
 bool MachinePointerInfo::isDereferenceable(unsigned Size, LLVMContext &C,
                                            const DataLayout &DL) const {
-  if (!V.is<const Value *>())
+  if (!isa<const Value *>(V))
     return false;
 
-  const Value *BasePtr = V.get<const Value *>();
+  const Value *BasePtr = cast<const Value *>(V);
   if (BasePtr == nullptr)
     return false;
 
   return isDereferenceableAndAlignedPointer(
       BasePtr, Align(1), APInt(DL.getPointerSizeInBits(), Offset + Size), DL);
 }
 
 /// getConstantPool - Return a MachinePointerInfo record that refers to the

 
 MachineMemOperand::MachineMemOperand(MachinePointerInfo ptrinfo, Flags f,
                                      LLT type, Align a, const AAMDNodes &AAInfo,
                                      const MDNode *Ranges, SyncScope::ID SSID,
                                      AtomicOrdering Ordering,
                                      AtomicOrdering FailureOrdering)
     : PtrInfo(ptrinfo), MemoryType(type), FlagVals(f), BaseAlign(a),
       AAInfo(AAInfo), Ranges(Ranges) {
-  assert((PtrInfo.V.isNull() || PtrInfo.V.is<const PseudoSourceValue *>() ||
-          isa<PointerType>(PtrInfo.V.get<const Value *>()->getType())) &&
+  assert((PtrInfo.V.isNull() || isa<const PseudoSourceValue *>(PtrInfo.V) ||
+          isa<PointerType>(cast<const Value *>(PtrInfo.V)->getType())) &&
          "invalid pointer value");
   assert((isLoad() || isStore()) && "Not a load/store!");
 
   AtomicInfo.SSID = static_cast<unsigned>(SSID);
   assert(getSyncScopeID() == SSID && "Value truncated");
   AtomicInfo.Ordering = static_cast<unsigned>(Ordering);
   assert(getSuccessOrdering() == Ordering && "Value truncated");
   AtomicInfo.FailureOrdering = static_cast<unsigned>(FailureOrdering);

llvm/lib/CodeGen/MachineRegisterInfo.cpp

MachineRegisterInfo::constrainRegAttrs(Register Reg,
   if (RegTy.isValid() && ConstrainingRegTy.isValid() &&
       RegTy != ConstrainingRegTy)
     return false;
   const auto ConstrainingRegCB = getRegClassOrRegBank(ConstrainingReg);
   if (!ConstrainingRegCB.isNull()) {
     const auto RegCB = getRegClassOrRegBank(Reg);
     if (RegCB.isNull())
       setRegClassOrRegBank(Reg, ConstrainingRegCB);
-    else if (RegCB.is<const TargetRegisterClass *>() !=
-             ConstrainingRegCB.is<const TargetRegisterClass *>())
+    else if (isa<const TargetRegisterClass *>(RegCB) !=
+             isa<const TargetRegisterClass *>(ConstrainingRegCB))
       return false;
-    else if (RegCB.is<const TargetRegisterClass *>()) {
+    else if (isa<const TargetRegisterClass *>(RegCB)) {
       if (!::constrainRegClass(
-              *this, Reg, RegCB.get<const TargetRegisterClass *>(),
-              ConstrainingRegCB.get<const TargetRegisterClass *>(), MinNumRegs))
+              *this, Reg, cast<const TargetRegisterClass *>(RegCB),
+              cast<const TargetRegisterClass *>(ConstrainingRegCB), MinNumRegs))
         return false;
     } else if (RegCB != ConstrainingRegCB)
       return false;
   }
   if (ConstrainingRegTy.isValid())
     setType(Reg, ConstrainingRegTy);
   return true;
 }

llvm/lib/CodeGen/RegisterBankInfo.cpp

RegisterBankInfo::getRegBank(Register Reg, const MachineRegisterInfo &MRI,
   if (!Reg.isVirtual()) {
     // FIXME: This was probably a copy to a virtual register that does have a
     // type we could use.
     const TargetRegisterClass *RC = getMinimalPhysRegClass(Reg, TRI);
     return RC ? &getRegBankFromRegClass(*RC, LLT()) : nullptr;
   }
 
   const RegClassOrRegBank &RegClassOrBank = MRI.getRegClassOrRegBank(Reg);
-  if (auto *RB = RegClassOrBank.dyn_cast<const RegisterBank *>())
+  if (auto *RB = dyn_cast_if_present<const RegisterBank *>(RegClassOrBank))
     return RB;
-  if (auto *RC = RegClassOrBank.dyn_cast<const TargetRegisterClass *>())
+  if (auto *RC =
+          dyn_cast_if_present<const TargetRegisterClass *>(RegClassOrBank))
     return &getRegBankFromRegClass(*RC, MRI.getType(Reg));
   return nullptr;
 }
 
 const TargetRegisterClass *
 RegisterBankInfo::getMinimalPhysRegClass(Register Reg,
                                          const TargetRegisterInfo &TRI) const {
   assert(Reg.isPhysical() && "Reg must be a physreg");
const RegisterBank *RegisterBankInfo::getRegBankFromConstraints(
   return &RegBank;
 }
 
 const TargetRegisterClass *RegisterBankInfo::constrainGenericRegister(
     Register Reg, const TargetRegisterClass &RC, MachineRegisterInfo &MRI) {
 
   // If the register already has a class, fallback to MRI::constrainRegClass.
   auto &RegClassOrBank = MRI.getRegClassOrRegBank(Reg);
-  if (RegClassOrBank.is<const TargetRegisterClass *>())
+  if (isa<const TargetRegisterClass *>(RegClassOrBank))
     return MRI.constrainRegClass(Reg, &RC);
 
-  const RegisterBank *RB = RegClassOrBank.get<const RegisterBank *>();
+  const RegisterBank *RB = cast<const RegisterBank *>(RegClassOrBank);
   // Otherwise, all we can do is ensure the bank covers the class, and set it.
   if (RB && !RB->covers(RC))
     return nullptr;
 
   // If nothing was set or the class is simply compatible, set it.
   MRI.setRegClass(Reg, &RC);
   return &RC;
 }

llvm/lib/CodeGen/ScheduleDAGInstrs.cpp

 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const PseudoSourceValue* PSV) {
   PSV->printCustom(OS);
   return OS;
 }
 
 void ScheduleDAGInstrs::Value2SUsMap::dump() {
   for (const auto &[ValType, SUs] : *this) {
-    if (ValType.is<const Value*>()) {
-      const Value *V = ValType.get<const Value*>();
+    if (isa<const Value *>(ValType)) {
+      const Value *V = cast<const Value *>(ValType);
       if (isa<UndefValue>(V))
         dbgs() << "Unknown";
       else
         V->printAsOperand(dbgs());
-    }
-    else if (ValType.is<const PseudoSourceValue*>())
-      dbgs() << ValType.get<const PseudoSourceValue*>();
+    } else if (isa<const PseudoSourceValue *>(ValType))
+      dbgs() << cast<const PseudoSourceValue *>(ValType);
     else
       llvm_unreachable("Unknown Value type.");
 
     dbgs() << " : ";
     dumpSUList(SUs);
   }
 }
 

llvm/lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
 
   if (isFuncletEHPersonality(Personality)) {
     WinEHFuncInfo &EHInfo = *MF->getWinEHFuncInfo();
 
     // Map all BB references in the WinEH data to MBBs.
     for (WinEHTryBlockMapEntry &TBME : EHInfo.TryBlockMap) {
       for (WinEHHandlerType &H : TBME.HandlerArray) {
         if (H.Handler)
-          H.Handler = MBBMap[H.Handler.get<const BasicBlock *>()];
+          H.Handler = MBBMap[cast<const BasicBlock *>(H.Handler)];
       }
     }
     for (CxxUnwindMapEntry &UME : EHInfo.CxxUnwindMap)
       if (UME.Cleanup)
-        UME.Cleanup = MBBMap[UME.Cleanup.get<const BasicBlock *>()];
+        UME.Cleanup = MBBMap[cast<const BasicBlock *>(UME.Cleanup)];
     for (SEHUnwindMapEntry &UME : EHInfo.SEHUnwindMap) {
-      const auto *BB = UME.Handler.get<const BasicBlock *>();
+      const auto *BB = cast<const BasicBlock *>(UME.Handler);
       UME.Handler = MBBMap[BB];
     }
     for (ClrEHUnwindMapEntry &CME : EHInfo.ClrEHUnwindMap) {
-      const auto *BB = CME.Handler.get<const BasicBlock *>();
+      const auto *BB = cast<const BasicBlock *>(CME.Handler);
       CME.Handler = MBBMap[BB];
     }
   } else if (Personality == EHPersonality::Wasm_CXX) {
     WasmEHFuncInfo &EHInfo = *MF->getWasmEHFuncInfo();
     calculateWasmEHInfo(&fn, EHInfo);
 
     // Map all BB references in the Wasm EH data to MBBs.
     DenseMap<BBOrMBB, BBOrMBB> SrcToUnwindDest;
     for (auto &KV : EHInfo.SrcToUnwindDest) {
-      const auto *Src = KV.first.get<const BasicBlock *>();
-      const auto *Dest = KV.second.get<const BasicBlock *>();
+      const auto *Src = cast<const BasicBlock *>(KV.first);
+      const auto *Dest = cast<const BasicBlock *>(KV.second);
       SrcToUnwindDest[MBBMap[Src]] = MBBMap[Dest];
     }
     EHInfo.SrcToUnwindDest = std::move(SrcToUnwindDest);
     DenseMap<BBOrMBB, SmallPtrSet<BBOrMBB, 4>> UnwindDestToSrcs;
     for (auto &KV : EHInfo.UnwindDestToSrcs) {
-      const auto *Dest = KV.first.get<const BasicBlock *>();
+      const auto *Dest = cast<const BasicBlock *>(KV.first);
       UnwindDestToSrcs[MBBMap[Dest]] = SmallPtrSet<BBOrMBB, 4>();
       for (const auto P : KV.second)
         UnwindDestToSrcs[MBBMap[Dest]].insert(
-            MBBMap[P.get<const BasicBlock *>()]);
+            MBBMap[cast<const BasicBlock *>(P)]);
     }
     EHInfo.UnwindDestToSrcs = std::move(UnwindDestToSrcs);
   }
 }
 
 /// clear - Clear out all the function-specific state. This returns this
 /// FunctionLoweringInfo to an empty state, ready to be used for a
 /// different function.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

if (NewAlign > Alignment) {
       Alignment = NewAlign;
     }
   }
 
   // Prepare AAInfo for loads/stores after lowering this memcpy.
   AAMDNodes NewAAInfo = AAInfo;
   NewAAInfo.TBAA = NewAAInfo.TBAAStruct = nullptr;
 
-  const Value *SrcVal = SrcPtrInfo.V.dyn_cast<const Value *>();
+  const Value *SrcVal = dyn_cast_if_present<const Value *>(SrcPtrInfo.V);
   bool isConstant =
       AA && SrcVal &&
       AA->pointsToConstantMemory(MemoryLocation(SrcVal, Size, AAInfo));
 
   MachineMemOperand::Flags MMOFlags =
       isVol ? MachineMemOperand::MOVolatile : MachineMemOperand::MONone;
   SmallVector<SDValue, 16> OutLoadChains;
   SmallVector<SDValue, 16> OutStoreChains;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

class SelectionDAGBuilder {
   public:
     DanglingDebugInfo() = default;
     DanglingDebugInfo(const DbgValueInst *DI, unsigned SDNO)
         : Info(DI), SDNodeOrder(SDNO) {}
     DanglingDebugInfo(const VarLocInfo *VarLoc, unsigned SDNO)
         : Info(VarLoc), SDNodeOrder(SDNO) {}
 
     DILocalVariable *getVariable(const FunctionVarLocs *Locs) const {
-      if (Info.is<VarLocTy>())
-        return Locs->getDILocalVariable(Info.get<VarLocTy>()->VariableID);
-      return Info.get<DbgValTy>()->getVariable();
+      if (isa<VarLocTy>(Info))
+        return Locs->getDILocalVariable(cast<VarLocTy>(Info)->VariableID);
+      return cast<DbgValTy>(Info)->getVariable();
     }
     DIExpression *getExpression() const {
-      if (Info.is<VarLocTy>())
-        return Info.get<VarLocTy>()->Expr;
-      return Info.get<DbgValTy>()->getExpression();
+      if (isa<VarLocTy>(Info))
+        return cast<VarLocTy>(Info)->Expr;
+      return cast<DbgValTy>(Info)->getExpression();
     }
     Value *getVariableLocationOp(unsigned Idx) const {
       assert(Idx == 0 && "Dangling variadic debug values not supported yet");
-      if (Info.is<VarLocTy>())
-        return Info.get<VarLocTy>()->Values.getVariableLocationOp(Idx);
-      return Info.get<DbgValTy>()->getVariableLocationOp(Idx);
+      if (isa<VarLocTy>(Info))
+        return cast<VarLocTy>(Info)->Values.getVariableLocationOp(Idx);
+      return cast<DbgValTy>(Info)->getVariableLocationOp(Idx);
     }
     DebugLoc getDebugLoc() const {
-      if (Info.is<VarLocTy>())
-        return Info.get<VarLocTy>()->DL;
-      return Info.get<DbgValTy>()->getDebugLoc();
+      if (isa<VarLocTy>(Info))
+        return cast<VarLocTy>(Info)->DL;
+      return cast<DbgValTy>(Info)->getDebugLoc();
     }
     unsigned getSDNodeOrder() const { return SDNodeOrder; }
 
     /// Helper for printing DanglingDebugInfo. This hoop-jumping is to
     /// accommodate the fact that an argument is required for getVariable.
     /// Call SelectionDAGBuilder::printDDI instead of using directly.
     struct Print {
       Print(const DanglingDebugInfo &DDI, const FunctionVarLocs *VarLocs)

llvm/lib/CodeGen/WinEHPrepare.cpp

while (!Worklist.empty()) {
     }
   }
 
   // Step two: record the TryParentState of each state.  For cleanuppads that
   // don't have cleanuprets, we may need to infer this from their child pads,
   // so visit pads in descendant-most to ancestor-most order.
   for (ClrEHUnwindMapEntry &Entry : llvm::reverse(FuncInfo.ClrEHUnwindMap)) {
     const Instruction *Pad =
-        Entry.Handler.get<const BasicBlock *>()->getFirstNonPHI();
+        cast<const BasicBlock *>(Entry.Handler)->getFirstNonPHI();
     // For most pads, the TryParentState is the state associated with the
     // unwind dest of exceptional exits from it.
     const BasicBlock *UnwindDest;
     if (const auto *Catch = dyn_cast<CatchPadInst>(Pad)) {
       // If a catch is not the last in its catchswitch, its TryParentState is
       // the state associated with the next catch in the switch, even though
       // that's not the unwind dest of exceptions escaping the catch.  Those
       // cases were already assigned a TryParentState in the first pass, so
if (const auto *Catch = dyn_cast<CatchPadInst>(Pad)) {
           UserUnwindDest = Invoke->getUnwindDest();
         } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(U)) {
           UserUnwindDest = CatchSwitch->getUnwindDest();
         } else if (auto *ChildCleanup = dyn_cast<CleanupPadInst>(U)) {
           int UserState = FuncInfo.EHPadStateMap[ChildCleanup];
           int UserUnwindState =
               FuncInfo.ClrEHUnwindMap[UserState].TryParentState;
           if (UserUnwindState != -1)
-            UserUnwindDest = FuncInfo.ClrEHUnwindMap[UserUnwindState]
-                                 .Handler.get<const BasicBlock *>();
+            UserUnwindDest = cast<const BasicBlock *>(
+                FuncInfo.ClrEHUnwindMap[UserUnwindState].Handler);
         }
 
         // Not having an unwind dest for this user might indicate that it
         // doesn't unwind, so can't be taken as proof that the cleanup itself
         // may unwind to caller (see e.g. SimplifyUnreachable and
         // RemoveUnwindEdge).
         if (!UserUnwindDest)
           continue;

llvm/lib/DebugInfo/LogicalView/LVReaderHandler.cpp

Error LVReaderHandler::process() {
 
   return Error::success();
 }
 
 Error LVReaderHandler::createReader(StringRef Filename, LVReaders &Readers,
                                     PdbOrObj &Input, StringRef FileFormatName,
                                     StringRef ExePath) {
   auto CreateOneReader = [&]() -> std::unique_ptr<LVReader> {
-    if (Input.is<ObjectFile *>()) {
-      ObjectFile &Obj = *Input.get<ObjectFile *>();
+    if (isa<ObjectFile *>(Input)) {
+      ObjectFile &Obj = *cast<ObjectFile *>(Input);
       if (Obj.isCOFF()) {
         COFFObjectFile *COFF = cast<COFFObjectFile>(&Obj);
         return std::make_unique<LVCodeViewReader>(Filename, FileFormatName,
                                                   *COFF, W, ExePath);
       }
       if (Obj.isELF() || Obj.isMachO())
         return std::make_unique<LVELFReader>(Filename, FileFormatName, Obj, W);
     }
-    if (Input.is<PDBFile *>()) {
-      PDBFile &Pdb = *Input.get<PDBFile *>();
+    if (isa<PDBFile *>(Input)) {
+      PDBFile &Pdb = *cast<PDBFile *>(Input);
       return std::make_unique<LVCodeViewReader>(Filename, FileFormatName, Pdb,
                                                 W, ExePath);
     }
     return nullptr;
   };
 
   std::unique_ptr<LVReader> ReaderObj = CreateOneReader();
   if (!ReaderObj)
Error LVReaderHandler::handleMach(LVReaders &Readers, StringRef Filename,
   }
   return Error::success();
 }
 
 Error LVReaderHandler::handleObject(LVReaders &Readers, StringRef Filename,
                                     Binary &Binary) {
   if (PdbOrObj Input = dyn_cast<ObjectFile>(&Binary))
     return createReader(Filename, Readers, Input,
-                        Input.get<ObjectFile *>()->getFileFormatName());
+                        cast<ObjectFile *>(Input)->getFileFormatName());
 
   if (MachOUniversalBinary *Fat = dyn_cast<MachOUniversalBinary>(&Binary))
     return handleMach(Readers, Filename, *Fat);
 
   if (Archive *Arch = dyn_cast<Archive>(&Binary))
     return handleArchive(Readers, Filename, *Arch);
 
   return createStringError(errc::not_supported,

llvm/lib/DebugInfo/PDB/Native/InputFile.cpp

Expected<InputFile> InputFile::open(StringRef Path, bool AllowUnknownFile) {
 
   IF.UnknownFile = std::move(*Result);
   IF.PdbOrObj = IF.UnknownFile.get();
   return std::move(IF);
 }
 
 PDBFile &InputFile::pdb() {
   assert(isPdb());
-  return *PdbOrObj.get<PDBFile *>();
+  return *cast<PDBFile *>(PdbOrObj);
 }
 
 const PDBFile &InputFile::pdb() const {
   assert(isPdb());
-  return *PdbOrObj.get<PDBFile *>();
+  return *cast<PDBFile *>(PdbOrObj);
 }
 
 object::COFFObjectFile &InputFile::obj() {
   assert(isObj());
-  return *PdbOrObj.get<object::COFFObjectFile *>();
+  return *cast<object::COFFObjectFile *>(PdbOrObj);
 }
 
 const object::COFFObjectFile &InputFile::obj() const {
   assert(isObj());
-  return *PdbOrObj.get<object::COFFObjectFile *>();
+  return *cast<object::COFFObjectFile *>(PdbOrObj);
 }
 
 MemoryBuffer &InputFile::unknown() {
   assert(isUnknown());
-  return *PdbOrObj.get<MemoryBuffer *>();
+  return *cast<MemoryBuffer *>(PdbOrObj);
 }
 
 const MemoryBuffer &InputFile::unknown() const {
   assert(isUnknown());
-  return *PdbOrObj.get<MemoryBuffer *>();
+  return *cast<MemoryBuffer *>(PdbOrObj);
 }
 
 StringRef InputFile::getFilePath() const {
   if (isPdb())
     return pdb().getFilePath();
   if (isObj())
     return obj().getFileName();
   assert(isUnknown());

 }
 
 bool InputFile::hasIds() const {
   if (isObj())
     return false;
   return pdb().hasPDBIpiStream();
 }
 
-bool InputFile::isPdb() const { return PdbOrObj.is<PDBFile *>(); }
+bool InputFile::isPdb() const { return isa<PDBFile *>(PdbOrObj); }
 
 bool InputFile::isObj() const {
-  return PdbOrObj.is<object::COFFObjectFile *>();
+  return isa<object::COFFObjectFile *>(PdbOrObj);
 }
 
-bool InputFile::isUnknown() const { return PdbOrObj.is<MemoryBuffer *>(); }
+bool InputFile::isUnknown() const { return isa<MemoryBuffer *>(PdbOrObj); }
 
 codeview::LazyRandomTypeCollection &
 InputFile::getOrCreateTypeCollection(TypeCollectionKind Kind) {
   if (Types && Kind == kTypes)
     return *Types;
   if (Ids && Kind == kIds)
     return *Ids;
 

llvm/lib/IR/DIBuilder.cpp

DIBuilder::createArrayType(uint64_t Size, uint32_t AlignInBits, DIType *Ty,
                            PointerUnion<DIExpression *, DIVariable *> DL,
                            PointerUnion<DIExpression *, DIVariable *> AS,
                            PointerUnion<DIExpression *, DIVariable *> AL,
                            PointerUnion<DIExpression *, DIVariable *> RK) {
   auto *R = DICompositeType::get(
       VMContext, dwarf::DW_TAG_array_type, "", nullptr, 0, nullptr, Ty, Size,
       AlignInBits, 0, DINode::FlagZero, Subscripts, 0, nullptr, nullptr, "",
       nullptr,
-      DL.is<DIExpression *>() ? (Metadata *)DL.get<DIExpression *>()
-                              : (Metadata *)DL.get<DIVariable *>(),
-      AS.is<DIExpression *>() ? (Metadata *)AS.get<DIExpression *>()
-                              : (Metadata *)AS.get<DIVariable *>(),
-      AL.is<DIExpression *>() ? (Metadata *)AL.get<DIExpression *>()
-                              : (Metadata *)AL.get<DIVariable *>(),
-      RK.is<DIExpression *>() ? (Metadata *)RK.get<DIExpression *>()
-                              : (Metadata *)RK.get<DIVariable *>());
+      isa<DIExpression *>(DL) ? (Metadata *)cast<DIExpression *>(DL)
+                              : (Metadata *)cast<DIVariable *>(DL),
+      isa<DIExpression *>(AS) ? (Metadata *)cast<DIExpression *>(AS)
+                              : (Metadata *)cast<DIVariable *>(AS),
+      isa<DIExpression *>(AL) ? (Metadata *)cast<DIExpression *>(AL)
+                              : (Metadata *)cast<DIVariable *>(AL),
+      isa<DIExpression *>(RK) ? (Metadata *)cast<DIExpression *>(RK)
+                              : (Metadata *)cast<DIVariable *>(RK));
   trackIfUnresolved(R);
   return R;
 }
 
 DICompositeType *DIBuilder::createVectorType(uint64_t Size,
                                              uint32_t AlignInBits, DIType *Ty,
                                              DINodeArray Subscripts) {
   auto *R = DICompositeType::get(VMContext, dwarf::DW_TAG_array_type, "",
DISubrange *DIBuilder::getOrCreateSubrange(Metadata *CountNode, Metadata *LB,
                                            Metadata *UB, Metadata *Stride) {
   return DISubrange::get(VMContext, CountNode, LB, UB, Stride);
 }
 
 DIGenericSubrange *DIBuilder::getOrCreateGenericSubrange(
     DIGenericSubrange::BoundType CountNode, DIGenericSubrange::BoundType LB,
     DIGenericSubrange::BoundType UB, DIGenericSubrange::BoundType Stride) {
   auto ConvToMetadata = [&](DIGenericSubrange::BoundType Bound) -> Metadata * {
-    return Bound.is<DIExpression *>() ? (Metadata *)Bound.get<DIExpression *>()
-                                      : (Metadata *)Bound.get<DIVariable *>();
+    return isa<DIExpression *>(Bound) ? (Metadata *)cast<DIExpression *>(Bound)
+                                      : (Metadata *)cast<DIVariable *>(Bound);
   };
   return DIGenericSubrange::get(VMContext, ConvToMetadata(CountNode),
                                 ConvToMetadata(LB), ConvToMetadata(UB),
                                 ConvToMetadata(Stride));
 }
 
 static void checkGlobalVariableScope(DIScope *Context) {
 #ifndef NDEBUG

llvm/lib/IR/Metadata.cpp

 bool MetadataTracking::isReplaceable(const Metadata &MD) {
   return ReplaceableMetadataImpl::isReplaceable(MD);
 }
 
 SmallVector<Metadata *> ReplaceableMetadataImpl::getAllArgListUsers() {
   SmallVector<std::pair<OwnerTy, uint64_t> *> MDUsersWithID;
   for (auto Pair : UseMap) {
     OwnerTy Owner = Pair.second.first;
-    if (!Owner.is<Metadata *>())
+    if (!isa<Metadata *>(Owner))
       continue;
-    Metadata *OwnerMD = Owner.get<Metadata *>();
+    Metadata *OwnerMD = cast<Metadata *>(Owner);
     if (OwnerMD->getMetadataID() == Metadata::DIArgListKind)
       MDUsersWithID.push_back(&UseMap[Pair.first]);
   }
   llvm::sort(MDUsersWithID, [](auto UserA, auto UserB) {
     return UserA->second < UserB->second;
   });
   SmallVector<Metadata *> MDUsers;
   for (auto *UserWithID : MDUsersWithID)
-    MDUsers.push_back(UserWithID->first.get<Metadata *>());
+    MDUsers.push_back(cast<Metadata *>(UserWithID->first));
   return MDUsers;
 }
 
 void ReplaceableMetadataImpl::addRef(void *Ref, OwnerTy Owner) {
   bool WasInserted =
       UseMap.insert(std::make_pair(Ref, std::make_pair(Owner, NextIndex)))
           .second;
   (void)WasInserted;
using UseTy =
       std::pair<void *, std::pair<MetadataTracking::OwnerTy, uint64_t>>;
   // Copy out uses and update value of Constant used by debug info metadata with undef below
   SmallVector<UseTy, 8> Uses(MD->UseMap.begin(), MD->UseMap.end());
 
   for (const auto &Pair : Uses) {
     MetadataTracking::OwnerTy Owner = Pair.second.first;
     if (!Owner)
       continue;
-    if (!Owner.is<Metadata *>())
+    if (!isa<Metadata *>(Owner))
       continue;
-    auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
+    auto *OwnerMD = dyn_cast_if_present<MDNode>(cast<Metadata *>(Owner));
     if (!OwnerMD)
       continue;
     if (isa<DINode>(OwnerMD)) {
       OwnerMD->handleChangedOperand(
           Pair.first, ValueAsMetadata::get(UndefValue::get(C.getType())));
     }
   }
 }
if (!Owner) {
       Ref = MD;
       if (MD)
         MetadataTracking::track(Ref);
       UseMap.erase(Pair.first);
       continue;
     }
 
     // Check for MetadataAsValue.
-    if (Owner.is<MetadataAsValue *>()) {
-      Owner.get<MetadataAsValue *>()->handleChangedMetadata(MD);
+    if (isa<MetadataAsValue *>(Owner)) {
+      cast<MetadataAsValue *>(Owner)->handleChangedMetadata(MD);
       continue;
     }
 
     // There's a Metadata owner -- dispatch.
-    Metadata *OwnerMD = Owner.get<Metadata *>();
+    Metadata *OwnerMD = cast<Metadata *>(Owner);
     switch (OwnerMD->getMetadataID()) {
 #define HANDLE_METADATA_LEAF(CLASS)                                            \
   case Metadata::CLASS##Kind:                                                  \
     cast<CLASS>(OwnerMD)->handleChangedOperand(Pair.first, MD);                \
     continue;
 #include "llvm/IR/Metadata.def"
     default:
       llvm_unreachable("Invalid metadata subclass");
void ReplaceableMetadataImpl::resolveAllUses(bool ResolveUsers) {
   llvm::sort(Uses, [](const UseTy &L, const UseTy &R) {
     return L.second.second < R.second.second;
   });
   UseMap.clear();
   for (const auto &Pair : Uses) {
     auto Owner = Pair.second.first;
     if (!Owner)
       continue;
-    if (Owner.is<MetadataAsValue *>())
+    if (isa<MetadataAsValue *>(Owner))
       continue;
 
     // Resolve MDNodes that point at this.
-    auto *OwnerMD = dyn_cast<MDNode>(Owner.get<Metadata *>());
+    auto *OwnerMD = dyn_cast_if_present<MDNode>(cast<Metadata *>(Owner));
     if (!OwnerMD)
       continue;
     if (OwnerMD->isResolved())
       continue;
     OwnerMD->decrementUnresolvedOperandCount();
   }
 }
 

llvm/lib/IR/Verifier.cpp

CheckDI(HasAssumedSizedArraySupport || N.getRawCountNode() ||
           "Subrange must contain count or upperBound", &N);
   CheckDI(!N.getRawCountNode() || !N.getRawUpperBound(),
           "Subrange can have any one of count or upperBound", &N);
   auto *CBound = N.getRawCountNode();
   CheckDI(!CBound || isa<ConstantAsMetadata>(CBound) ||
               isa<DIVariable>(CBound) || isa<DIExpression>(CBound),
           "Count must be signed constant or DIVariable or DIExpression", &N);
   auto Count = N.getCount();
-  CheckDI(!Count || !Count.is<ConstantInt *>() ||
-              Count.get<ConstantInt *>()->getSExtValue() >= -1,
+  CheckDI(!Count || !isa<ConstantInt *>(Count) ||
+              cast<ConstantInt *>(Count)->getSExtValue() >= -1,
           "invalid subrange count", &N);
   auto *LBound = N.getRawLowerBound();
   CheckDI(!LBound || isa<ConstantAsMetadata>(LBound) ||
               isa<DIVariable>(LBound) || isa<DIExpression>(LBound),
           "LowerBound must be signed constant or DIVariable or DIExpression",
           &N);
   auto *UBound = N.getRawUpperBound();
   CheckDI(!UBound || isa<ConstantAsMetadata>(UBound) ||

llvm/lib/LTO/LTO.cpp

LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
   for (const InputFile::Symbol &Sym : Syms) {
     assert(ResI != ResE);
     SymbolResolution Res = *ResI++;
 
     assert(MsymI != MsymE);
     ModuleSymbolTable::Symbol Msym = *MsymI++;
     Skip();
 
-    if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
+    if (GlobalValue *GV = dyn_cast_if_present<GlobalValue *>(Msym)) {
       if (Res.Prevailing) {
         if (Sym.isUndefined())
           continue;
         Mod.Keep.push_back(GV);
         // For symbols re-defined with linker -wrap and -defsym options,
         // set the linkage to weak to inhibit IPO. The linkage will be
         // restored by the linker.
         if (Res.LinkerRedefined)
if (GlobalValue *GV = dyn_cast_if_present<GlobalValue *>(Msym)) {
 
       // Set the 'local' flag based on the linker resolution for this symbol.
       if (Res.FinalDefinitionInLinkageUnit) {
         GV->setDSOLocal(true);
         if (GV->hasDLLImportStorageClass())
           GV->setDLLStorageClass(GlobalValue::DLLStorageClassTypes::
                                  DefaultStorageClass);
       }
-    } else if (auto *AS = Msym.dyn_cast<ModuleSymbolTable::AsmSymbol *>()) {
+    } else if (auto *AS =
+                   dyn_cast_if_present<ModuleSymbolTable::AsmSymbol *>(Msym)) {
       // Collect non-prevailing symbols.
       if (!Res.Prevailing)
         NonPrevailingAsmSymbols.insert(AS->first);
     } else {
       llvm_unreachable("unknown symbol type");
     }
 
     // Common resolution: collect the maximum size/alignment over all commons.

llvm/lib/LTO/LTOModule.cpp

 void LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) {
   SmallString<64> Buffer;
   {
     raw_svector_ostream OS(Buffer);
     SymTab.printSymbolName(OS, Sym);
     Buffer.c_str();
   }
 
-  const GlobalValue *V = Sym.get<GlobalValue *>();
+  const GlobalValue *V = cast<GlobalValue *>(Sym);
   addDefinedDataSymbol(Buffer, V);
 }
 
 void LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) {
   // Add to list of defined symbols.
   addDefinedSymbol(Name, v, false);
 
   if (!v->hasSection() /* || !isTargetDarwin */)

 void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) {
   SmallString<64> Buffer;
   {
     raw_svector_ostream OS(Buffer);
     SymTab.printSymbolName(OS, Sym);
     Buffer.c_str();
   }
 
-  const Function *F = cast<Function>(Sym.get<GlobalValue *>());
+  const Function *F = cast<Function>(cast<GlobalValue *>(Sym));
   addDefinedFunctionSymbol(Buffer, F);
 }
 
 void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) {
   // add to list of defined symbols
   addDefinedSymbol(Name, F, true);
 }
 
void LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym,
   // we already have the symbol
   if (!IterBool.second)
     return;
 
   NameAndAttributes &info = IterBool.first->second;
 
   info.name = IterBool.first->first();
 
-  const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>();
+  const GlobalValue *decl = dyn_cast_if_present<GlobalValue *>(Sym);
 
   if (decl->hasExternalWeakLinkage())
     info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF;
   else
     info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
 
   info.isFunction = isFunc;
   info.symbol = decl;
 }
 
 void LTOModule::parseSymbols() {
   for (auto Sym : SymTab.symbols()) {
-    auto *GV = Sym.dyn_cast<GlobalValue *>();
+    auto *GV = dyn_cast_if_present<GlobalValue *>(Sym);
     uint32_t Flags = SymTab.getSymbolFlags(Sym);
     if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
       continue;
 
     bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined;
 
     if (!GV) {
       SmallString<64> Buffer;

 }
 
 Expected<uint32_t> LTOModule::getMachOCPUSubType() const {
   return MachO::getCPUSubType(Triple(Mod->getTargetTriple()));
 }
 
 bool LTOModule::hasCtorDtor() const {
   for (auto Sym : SymTab.symbols()) {
-    if (auto *GV = Sym.dyn_cast<GlobalValue *>()) {
+    if (auto *GV = dyn_cast_if_present<GlobalValue *>(Sym)) {
       StringRef Name = GV->getName();
       if (Name.consume_front("llvm.global_")) {
         if (Name.equals("ctors") || Name.equals("dtors"))
           return true;
       }
     }
   }
   return false;
 }

llvm/lib/Object/IRSymtab.cpp

Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
   if (Flags & object::BasicSymbolRef::SF_Global)
     Sym.Flags |= 1 << storage::Symbol::FB_global;
   if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
     Sym.Flags |= 1 << storage::Symbol::FB_format_specific;
   if (Flags & object::BasicSymbolRef::SF_Executable)
     Sym.Flags |= 1 << storage::Symbol::FB_executable;
 
   Sym.ComdatIndex = -1;
-  auto *GV = Msym.dyn_cast<GlobalValue *>();
+  auto *GV = dyn_cast_if_present<GlobalValue *>(Msym);
   if (!GV) {
     // Undefined module asm symbols act as GC roots and are implicitly used.
     if (Flags & object::BasicSymbolRef::SF_Undefined)
       Sym.Flags |= 1 << storage::Symbol::FB_used;
     setStr(Sym.IRName, "");
     return Error::success();
   }
 

llvm/lib/Object/ModuleSymbolTable.cpp

void ModuleSymbolTable::CollectAsmSymvers(
   initializeRecordStreamer(M, [&](RecordStreamer &Streamer) {
     for (auto &KV : Streamer.symverAliases())
       for (auto &Alias : KV.second)
         AsmSymver(KV.first->getName(), Alias);
   });
 }
 
 void ModuleSymbolTable::printSymbolName(raw_ostream &OS, Symbol S) const {
-  if (S.is<AsmSymbol *>()) {
-    OS << S.get<AsmSymbol *>()->first;
+  if (isa<AsmSymbol *>(S)) {
+    OS << cast<AsmSymbol *>(S)->first;
     return;
   }
 
-  auto *GV = S.get<GlobalValue *>();
+  auto *GV = cast<GlobalValue *>(S);
   if (GV->hasDLLImportStorageClass())
     OS << "__imp_";
 
   Mang.getNameWithPrefix(OS, GV, false);
 }
 
 uint32_t ModuleSymbolTable::getSymbolFlags(Symbol S) const {
-  if (S.is<AsmSymbol *>())
-    return S.get<AsmSymbol *>()->second;
+  if (isa<AsmSymbol *>(S))
+    return cast<AsmSymbol *>(S)->second;
 
-  auto *GV = S.get<GlobalValue *>();
+  auto *GV = cast<GlobalValue *>(S);
 
   uint32_t Res = BasicSymbolRef::SF_None;
   if (GV->isDeclarationForLinker())
     Res |= BasicSymbolRef::SF_Undefined;
   else if (GV->hasHiddenVisibility() && !GV->hasLocalLinkage())
     Res |= BasicSymbolRef::SF_Hidden;
   if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
     if (GVar->isConstant())

llvm/lib/Target/X86/X86InstructionSelector.cpp

for (MachineOperand &MO : I.operands()) {
     Register Reg = MO.getReg();
     if (!Reg)
       continue;
     if (Reg.isPhysical())
       continue;
     LLT Ty = MRI.getType(Reg);
     const RegClassOrRegBank &RegClassOrBank = MRI.getRegClassOrRegBank(Reg);
     const TargetRegisterClass *RC =
-        RegClassOrBank.dyn_cast<const TargetRegisterClass *>();
+        dyn_cast_if_present<const TargetRegisterClass *>(RegClassOrBank);
     if (!RC) {
-      const RegisterBank &RB = *RegClassOrBank.get<const RegisterBank *>();
+      const RegisterBank &RB = *cast<const RegisterBank *>(RegClassOrBank);
       RC = getRegClass(Ty, RB);
       if (!RC) {
         LLVM_DEBUG(
             dbgs() << "Warning: DBG_VALUE operand has unexpected size/bank\n");
         break;
       }
     }
     RBI.constrainGenericRegister(Reg, *RC, MRI);

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

for (GlobalClassesTy::iterator I = GlobalClasses.begin(),
        I != E; ++I) {
     if (!I->isLeader())
       continue;
     ++NumTypeIdDisjointSets;
 
     unsigned MaxUniqueId = 0;
     for (GlobalClassesTy::member_iterator MI = GlobalClasses.member_begin(I);
          MI != GlobalClasses.member_end(); ++MI) {
-      if (auto *MD = MI->dyn_cast<Metadata *>())
+      if (auto *MD = dyn_cast_if_present<Metadata *>(*MI))
         MaxUniqueId = std::max(MaxUniqueId, TypeIdInfo[MD].UniqueId);
-      else if (auto *BF = MI->dyn_cast<ICallBranchFunnel *>())
+      else if (auto *BF = dyn_cast_if_present<ICallBranchFunnel *>(*MI))
         MaxUniqueId = std::max(MaxUniqueId, BF->UniqueId);
     }
     Sets.emplace_back(I, MaxUniqueId);
   }
   llvm::sort(Sets, llvm::less_second());
 
   // For each disjoint set we found...
   for (const auto &S : Sets) {
     // Build the list of type identifiers in this disjoint set.
     std::vector<Metadata *> TypeIds;
     std::vector<GlobalTypeMember *> Globals;
     std::vector<ICallBranchFunnel *> ICallBranchFunnels;
     for (GlobalClassesTy::member_iterator MI =
              GlobalClasses.member_begin(S.first);
          MI != GlobalClasses.member_end(); ++MI) {
-      if (MI->is<Metadata *>())
-        TypeIds.push_back(MI->get<Metadata *>());
-      else if (MI->is<GlobalTypeMember *>())
-        Globals.push_back(MI->get<GlobalTypeMember *>());
+      if (isa<Metadata *>(*MI))
+        TypeIds.push_back(cast<Metadata *>(*MI));
+      else if (isa<GlobalTypeMember *>(*MI))
+        Globals.push_back(cast<GlobalTypeMember *>(*MI));
       else
-        ICallBranchFunnels.push_back(MI->get<ICallBranchFunnel *>());
+        ICallBranchFunnels.push_back(cast<ICallBranchFunnel *>(*MI));
     }
 
     // Order type identifiers by unique ID for determinism. This ordering is
     // stable as there is a one-to-one mapping between metadata and unique IDs.
     llvm::sort(TypeIds, [&](Metadata *M1, Metadata *M2) {
       return TypeIdInfo[M1].UniqueId < TypeIdInfo[M2].UniqueId;
     });
 

llvm/lib/Transforms/IPO/MemProfContextDisambiguation.cpp

 struct IndexCall : public PointerUnion<CallsiteInfo *, AllocInfo *> {
   IndexCall() : PointerUnion() {}
   IndexCall(std::nullptr_t) : IndexCall() {}
   IndexCall(CallsiteInfo *StackNode) : PointerUnion(StackNode) {}
   IndexCall(AllocInfo *AllocNode) : PointerUnion(AllocNode) {}
 
   IndexCall *operator->() { return this; }
 
+  PointerUnion<CallsiteInfo *, AllocInfo *> getBase() const { return *this; }
+
   void print(raw_ostream &OS) const {
-    if (auto *AI = dyn_cast<AllocInfo *>())
+    if (auto *AI = llvm::dyn_cast_if_present<AllocInfo *>(getBase())) {
       OS << *AI;
-    else {
-      auto *CI = dyn_cast<CallsiteInfo *>();
+    } else {
+      auto *CI = llvm::dyn_cast_if_present<CallsiteInfo *>(getBase());
       assert(CI);
       OS << *CI;
     }
   }
 };
 
 /// CRTP derived class for graphs built from summary index (ThinLTO).
 class IndexCallsiteContextGraph

 
 uint64_t ModuleCallsiteContextGraph::getLastStackId(Instruction *Call) {
   CallStack<MDNode, MDNode::op_iterator> CallsiteContext(
       Call->getMetadata(LLVMContext::MD_callsite));
   return CallsiteContext.back();
 }
 
 uint64_t IndexCallsiteContextGraph::getLastStackId(IndexCall &Call) {
-  assert(Call.is<CallsiteInfo *>());
+  assert(isa<CallsiteInfo *>(Call.getBase()));
   CallStack<CallsiteInfo, SmallVector<unsigned>::const_iterator>
-      CallsiteContext(Call.dyn_cast<CallsiteInfo *>());
+      CallsiteContext(dyn_cast_if_present<CallsiteInfo *>(Call.getBase()));
   // Need to convert index into stack id.
   return Index.getStackIdAtIndex(CallsiteContext.back());
 }
 
 static std::string getMemProfFuncName(Twine Base, unsigned CloneNo) {
   if (!CloneNo)
     return Base.str();
   return (Base + ".memprof." + Twine(CloneNo)).str();
 }
 
 std::string ModuleCallsiteContextGraph::getLabel(const Function *Func,
                                                  const Instruction *Call,
                                                  unsigned CloneNo) const {
   return (Twine(Call->getFunction()->getName()) + " -> " +
           cast<CallBase>(Call)->getCalledFunction()->getName())
       .str();
 }
 
 std::string IndexCallsiteContextGraph::getLabel(const FunctionSummary *Func,
                                                 const IndexCall &Call,
                                                 unsigned CloneNo) const {
   auto VI = FSToVIMap.find(Func);
   assert(VI != FSToVIMap.end());
-  if (Call.is<AllocInfo *>())
+  if (isa<AllocInfo *>(Call.getBase()))
     return (VI->second.name() + " -> alloc").str();
   else {
-    auto *Callsite = Call.dyn_cast<CallsiteInfo *>();
+    auto *Callsite = dyn_cast_if_present<CallsiteInfo *>(Call.getBase());
     return (VI->second.name() + " -> " +
             getMemProfFuncName(Callsite->Callee.name(),
                                Callsite->Clones[CloneNo]))
         .str();
   }
 }
 
 std::vector<uint64_t>
 ModuleCallsiteContextGraph::getStackIdsWithContextNodesForCall(
     Instruction *Call) {
   CallStack<MDNode, MDNode::op_iterator> CallsiteContext(
       Call->getMetadata(LLVMContext::MD_callsite));
   return getStackIdsWithContextNodes<MDNode, MDNode::op_iterator>(
       CallsiteContext);
 }
 
 std::vector<uint64_t>
 IndexCallsiteContextGraph::getStackIdsWithContextNodesForCall(IndexCall &Call) {
-  assert(Call.is<CallsiteInfo *>());
+  assert(isa<CallsiteInfo *>(Call.getBase()));
   CallStack<CallsiteInfo, SmallVector<unsigned>::const_iterator>
-      CallsiteContext(Call.dyn_cast<CallsiteInfo *>());
+      CallsiteContext(dyn_cast_if_present<CallsiteInfo *>(Call.getBase()));
   return getStackIdsWithContextNodes<CallsiteInfo,
                                      SmallVector<unsigned>::const_iterator>(
       CallsiteContext);
 }
 
 template <typename DerivedCCG, typename FuncTy, typename CallTy>
 template <class NodeT, class IteratorT>
 std::vector<uint64_t>
bool ModuleCallsiteContextGraph::calleeMatchesFunc(Instruction *Call,
   if (CalleeFunc == Func)
     return true;
   auto *Alias = dyn_cast<GlobalAlias>(CalleeVal);
   return Alias && Alias->getAliasee() == Func;
 }
 
 bool IndexCallsiteContextGraph::calleeMatchesFunc(IndexCall &Call,
                                                   const FunctionSummary *Func) {
-  ValueInfo Callee = Call.dyn_cast<CallsiteInfo *>()->Callee;
+  ValueInfo Callee =
+      dyn_cast_if_present<CallsiteInfo *>(Call.getBase())->Callee;
   // If there is no summary list then this is a call to an externally defined
   // symbol.
   AliasSummary *Alias =
       Callee.getSummaryList().empty()
           ? nullptr
           : dyn_cast<AliasSummary>(Callee.getSummaryList()[0].get());
   assert(FSToVIMap.count(Func));
   return Callee == FSToVIMap[Func] ||

llvm/lib/Transforms/Utils/Evaluator.cpp

isSimpleEnoughValueToCommit(Constant *C,
   // If we already checked this constant, we win.
   if (!SimpleConstants.insert(C).second)
     return true;
   // Check the constant.
   return isSimpleEnoughValueToCommitHelper(C, SimpleConstants, DL);
 }
 
 void Evaluator::MutableValue::clear() {
-  if (auto *Agg = Val.dyn_cast<MutableAggregate *>())
+  if (auto *Agg = dyn_cast_if_present<MutableAggregate *>(Val))
     delete Agg;
   Val = nullptr;
 }
 
 Constant *Evaluator::MutableValue::read(Type *Ty, APInt Offset,
                                         const DataLayout &DL) const {
   TypeSize TySize = DL.getTypeStoreSize(Ty);
   const MutableValue *V = this;
-  while (const auto *Agg = V->Val.dyn_cast<MutableAggregate *>()) {
+  while (const auto *Agg = dyn_cast_if_present<MutableAggregate *>(V->Val)) {
     Type *AggTy = Agg->Ty;
     std::optional<APInt> Index = DL.getGEPIndexForOffset(AggTy, Offset);
     if (!Index || Index->uge(Agg->Elements.size()) ||
         !TypeSize::isKnownLE(TySize, DL.getTypeStoreSize(AggTy)))
       return nullptr;
 
     V = &Agg->Elements[Index->getZExtValue()];
   }
 
-  return ConstantFoldLoadFromConst(V->Val.get<Constant *>(), Ty, Offset, DL);
+  return ConstantFoldLoadFromConst(cast<Constant *>(V->Val), Ty, Offset, DL);
 }
 
 bool Evaluator::MutableValue::makeMutable() {
-  Constant *C = Val.get<Constant *>();
+  Constant *C = cast<Constant *>(Val);
   Type *Ty = C->getType();
   unsigned NumElements;
   if (auto *VT = dyn_cast<FixedVectorType>(Ty)) {
     NumElements = VT->getNumElements();
   } else if (auto *AT = dyn_cast<ArrayType>(Ty))
     NumElements = AT->getNumElements();
   else if (auto *ST = dyn_cast<StructType>(Ty))
     NumElements = ST->getNumElements();

 
 bool Evaluator::MutableValue::write(Constant *V, APInt Offset,
                                     const DataLayout &DL) {
   Type *Ty = V->getType();
   TypeSize TySize = DL.getTypeStoreSize(Ty);
   MutableValue *MV = this;
   while (Offset != 0 ||
          !CastInst::isBitOrNoopPointerCastable(Ty, MV->getType(), DL)) {
-    if (MV->Val.is<Constant *>() && !MV->makeMutable())
+    if (isa<Constant *>(MV->Val) && !MV->makeMutable())
       return false;
 
-    MutableAggregate *Agg = MV->Val.get<MutableAggregate *>();
+    MutableAggregate *Agg = cast<MutableAggregate *>(MV->Val);
     Type *AggTy = Agg->Ty;
     std::optional<APInt> Index = DL.getGEPIndexForOffset(AggTy, Offset);
     if (!Index || Index->uge(Agg->Elements.size()) ||
         !TypeSize::isKnownLE(TySize, DL.getTypeStoreSize(AggTy)))
       return false;
 
     MV = &Agg->Elements[Index->getZExtValue()];
   }

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

for (Instruction &I : BB->instructionsWithoutDebug(false)) {
           Legal->isInvariantAddressOfReduction(SI->getPointerOperand()))
         continue;
 
       auto RecipeOrValue = RecipeBuilder.tryToCreateWidenRecipe(
           Instr, Operands, Range, VPBB, Plan);
       if (!RecipeOrValue)
         RecipeOrValue = RecipeBuilder.handleReplication(Instr, Range, *Plan);
       // If Instr can be simplified to an existing VPValue, use it.
-      if (RecipeOrValue.is<VPValue *>()) {
-        auto *VPV = RecipeOrValue.get<VPValue *>();
+      if (isa<VPValue *>(RecipeOrValue)) {
+        auto *VPV = cast<VPValue *>(RecipeOrValue);
         Plan->addVPValue(Instr, VPV);
         // If the re-used value is a recipe, register the recipe for the
         // instruction, in case the recipe for Instr needs to be recorded.
         if (VPRecipeBase *R = VPV->getDefiningRecipe())
           RecipeBuilder.setRecipe(Instr, R);
         continue;
       }
       // Otherwise, add the new recipe.
-      VPRecipeBase *Recipe = RecipeOrValue.get<VPRecipeBase *>();
+      VPRecipeBase *Recipe = cast<VPRecipeBase *>(RecipeOrValue);
       for (auto *Def : Recipe->definedValues()) {
         auto *UV = Def->getUnderlyingValue();
         Plan->addVPValue(UV, Def);
       }
 
       RecipeBuilder.setRecipe(Instr, Recipe);
       if (isa<VPWidenIntOrFpInductionRecipe>(Recipe) &&
           HeaderVPBB->getFirstNonPhi() != VPBB->end()) {

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

static void cloneMemOperands(MachineInstr &DstMI, MachineInstr &SrcMI,
   PseudoSourceValueManager &PSVMgr = DstMF.getPSVManager();
 
   // We also need to remap the PseudoSourceValues from the new function's
   // PseudoSourceValueManager.
   SmallVector<MachineMemOperand *, 2> NewMMOs;
   for (MachineMemOperand *OldMMO : SrcMI.memoperands()) {
     MachinePointerInfo NewPtrInfo(OldMMO->getPointerInfo());
     if (const PseudoSourceValue *PSV =
-            NewPtrInfo.V.dyn_cast<const PseudoSourceValue *>()) {
+            dyn_cast_if_present<const PseudoSourceValue *>(NewPtrInfo.V)) {
       switch (PSV->kind()) {
       case PseudoSourceValue::Stack:
         NewPtrInfo.V = PSVMgr.getStack();
         break;
       case PseudoSourceValue::GOT:
         NewPtrInfo.V = PSVMgr.getGOT();
         break;
       case PseudoSourceValue::JumpTable:

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

 
 static void dropIRReferencesFromInstructions(Oracle &O, MachineFunction &MF) {
   for (MachineBasicBlock &MBB : MF) {
     for (MachineInstr &MI : MBB) {
       if (!O.shouldKeep()) {
         for (MachineMemOperand *MMO : MI.memoperands()) {
           // Leave behind pseudo source values.
           // TODO: Removing all MemOperand values is a further reduction step.
-          if (MMO->getPointerInfo().V.is<const Value *>())
+          if (isa<const Value *>(MMO->getPointerInfo().V))
             MMO->setValue(static_cast<const Value *>(nullptr));
         }
 
         // TODO: Try to remove GlobalValue references and metadata
       }
     }
   }
 }

llvm/unittests/ADT/PointerUnionTest.cpp

TEST_F(PointerUnionTest, Null) {
   EXPECT_FALSE(d4.isNull());
   EXPECT_TRUE(i4null.isNull());
   EXPECT_TRUE(f4null.isNull());
   EXPECT_TRUE(l4null.isNull());
   EXPECT_TRUE(d4null.isNull());
 }
 
 TEST_F(PointerUnionTest, Is) {
-  EXPECT_FALSE(a.is<int *>());
-  EXPECT_TRUE(a.is<float *>());
-  EXPECT_TRUE(b.is<int *>());
-  EXPECT_FALSE(b.is<float *>());
-  EXPECT_TRUE(n.is<int *>());
-  EXPECT_FALSE(n.is<float *>());
-  EXPECT_TRUE(i3.is<int *>());
-  EXPECT_TRUE(f3.is<float *>());
-  EXPECT_TRUE(l3.is<long long *>());
-  EXPECT_TRUE(i4.is<int *>());
-  EXPECT_TRUE(f4.is<float *>());
-  EXPECT_TRUE(l4.is<long long *>());
-  EXPECT_TRUE(d4.is<double *>());
-  EXPECT_TRUE(i4null.is<int *>());
-  EXPECT_TRUE(f4null.is<float *>());
-  EXPECT_TRUE(l4null.is<long long *>());
-  EXPECT_TRUE(d4null.is<double *>());
+  EXPECT_FALSE(isa<int *>(a));
+  EXPECT_TRUE(isa<float *>(a));
+  EXPECT_TRUE(isa<int *>(b));
+  EXPECT_FALSE(isa<float *>(b));
+  EXPECT_TRUE(isa<int *>(n));
+  EXPECT_FALSE(isa<float *>(n));
+  EXPECT_TRUE(isa<int *>(i3));
+  EXPECT_TRUE(isa<float *>(f3));
+  EXPECT_TRUE(isa<long long *>(l3));
+  EXPECT_TRUE(isa<int *>(i4));
+  EXPECT_TRUE(isa<float *>(f4));
+  EXPECT_TRUE(isa<long long *>(l4));
+  EXPECT_TRUE(isa<double *>(d4));
+  EXPECT_TRUE(isa<int *>(i4null));
+  EXPECT_TRUE(isa<float *>(f4null));
+  EXPECT_TRUE(isa<long long *>(l4null));
+  EXPECT_TRUE(isa<double *>(d4null));
 }
 
 TEST_F(PointerUnionTest, Get) {
-  EXPECT_EQ(a.get<float *>(), &f);
-  EXPECT_EQ(b.get<int *>(), &i);
-  EXPECT_EQ(n.get<int *>(), (int *)nullptr);
+  EXPECT_EQ(cast<float *>(a), &f);
+  EXPECT_EQ(cast<int *>(b), &i);
+  EXPECT_EQ(cast<int *>(n), (int *)nullptr);
 }
 
 template<int I> struct alignas(8) Aligned {};
 
 typedef PointerUnion<Aligned<0> *, Aligned<1> *, Aligned<2> *, Aligned<3> *,
                      Aligned<4> *, Aligned<5> *, Aligned<6> *, Aligned<7> *>
     PU8;
 
 TEST_F(PointerUnionTest, ManyElements) {
   Aligned<0> a0;
   Aligned<7> a7;
 
   PU8 a = &a0;
-  EXPECT_TRUE(a.is<Aligned<0>*>());
-  EXPECT_FALSE(a.is<Aligned<1>*>());
-  EXPECT_FALSE(a.is<Aligned<2>*>());
-  EXPECT_FALSE(a.is<Aligned<3>*>());
-  EXPECT_FALSE(a.is<Aligned<4>*>());
-  EXPECT_FALSE(a.is<Aligned<5>*>());
-  EXPECT_FALSE(a.is<Aligned<6>*>());
-  EXPECT_FALSE(a.is<Aligned<7>*>());
-  EXPECT_EQ(a.dyn_cast<Aligned<0>*>(), &a0);
+  EXPECT_TRUE(isa<Aligned<0> *>(a));
+  EXPECT_FALSE(isa<Aligned<1> *>(a));
+  EXPECT_FALSE(isa<Aligned<2> *>(a));
+  EXPECT_FALSE(isa<Aligned<3> *>(a));
+  EXPECT_FALSE(isa<Aligned<4> *>(a));
+  EXPECT_FALSE(isa<Aligned<5> *>(a));
+  EXPECT_FALSE(isa<Aligned<6> *>(a));
+  EXPECT_FALSE(isa<Aligned<7> *>(a));
+  EXPECT_EQ(dyn_cast_if_present<Aligned<0> *>(a), &a0);
   EXPECT_EQ(*a.getAddrOfPtr1(), &a0);
 
   a = &a7;
-  EXPECT_FALSE(a.is<Aligned<0>*>());
-  EXPECT_FALSE(a.is<Aligned<1>*>());
-  EXPECT_FALSE(a.is<Aligned<2>*>());
-  EXPECT_FALSE(a.is<Aligned<3>*>());
-  EXPECT_FALSE(a.is<Aligned<4>*>());
-  EXPECT_FALSE(a.is<Aligned<5>*>());
-  EXPECT_FALSE(a.is<Aligned<6>*>());
-  EXPECT_TRUE(a.is<Aligned<7>*>());
-  EXPECT_EQ(a.dyn_cast<Aligned<7>*>(), &a7);
+  EXPECT_FALSE(isa<Aligned<0> *>(a));
+  EXPECT_FALSE(isa<Aligned<1> *>(a));
+  EXPECT_FALSE(isa<Aligned<2> *>(a));
+  EXPECT_FALSE(isa<Aligned<3> *>(a));
+  EXPECT_FALSE(isa<Aligned<4> *>(a));
+  EXPECT_FALSE(isa<Aligned<5> *>(a));
+  EXPECT_FALSE(isa<Aligned<6> *>(a));
+  EXPECT_TRUE(isa<Aligned<7> *>(a));
+  EXPECT_EQ(dyn_cast_if_present<Aligned<7> *>(a), &a7);
 
   EXPECT_TRUE(a == PU8(&a7));
   EXPECT_TRUE(a != PU8(&a0));
 }
 
 TEST_F(PointerUnionTest, GetAddrOfPtr1) {
   EXPECT_TRUE((void *)b.getAddrOfPtr1() == (void *)&b);
   EXPECT_TRUE((void *)n.getAddrOfPtr1() == (void *)&n);

llvm/unittests/IR/MetadataTest.cpp

 typedef MetadataTest DISubrangeTest;
 
 TEST_F(DISubrangeTest, get) {
   auto *N = DISubrange::get(Context, 5, 7);
   auto Count = N->getCount();
   auto Lower = N->getLowerBound();
   EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
   ASSERT_TRUE(Count);
-  ASSERT_TRUE(Count.is<ConstantInt*>());
-  EXPECT_EQ(5, Count.get<ConstantInt*>()->getSExtValue());
-  EXPECT_EQ(7, Lower.get<ConstantInt *>()->getSExtValue());
+  ASSERT_TRUE(isa<ConstantInt *>(Count));
+  EXPECT_EQ(5, cast<ConstantInt *>(Count)->getSExtValue());
+  EXPECT_EQ(7, cast<ConstantInt *>(Lower)->getSExtValue());
   EXPECT_EQ(N, DISubrange::get(Context, 5, 7));
   EXPECT_EQ(DISubrange::get(Context, 5, 0), DISubrange::get(Context, 5));
 
   TempDISubrange Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DISubrangeTest, getEmptyArray) {
   auto *N = DISubrange::get(Context, -1, 0);
   auto Count = N->getCount();
   auto Lower = N->getLowerBound();
   EXPECT_EQ(dwarf::DW_TAG_subrange_type, N->getTag());
   ASSERT_TRUE(Count);
-  ASSERT_TRUE(Count.is<ConstantInt*>());
-  EXPECT_EQ(-1, Count.get<ConstantInt*>()->getSExtValue());
-  EXPECT_EQ(0, Lower.get<ConstantInt *>()->getSExtValue());
+  ASSERT_TRUE(isa<ConstantInt *>(Count));
+  EXPECT_EQ(-1, cast<ConstantInt *>(Count)->getSExtValue());
+  EXPECT_EQ(0, cast<ConstantInt *>(Lower)->getSExtValue());
   EXPECT_EQ(N, DISubrange::get(Context, -1, 0));
 }
 
 TEST_F(DISubrangeTest, getVariableCount) {
   DILocalScope *Scope = getSubprogram();
   DIFile *File = getFile();
   DIType *Type = getDerivedType();
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
   auto *VlaExpr = DILocalVariable::get(Context, Scope, "vla_expr", File, 8,
                                        Type, 2, Flags, 8, nullptr);
 
   auto *N = DISubrange::get(Context, VlaExpr, 0);
   auto Count = N->getCount();
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Count);
-  ASSERT_TRUE(Count.is<DIVariable*>());
-  EXPECT_EQ(VlaExpr, Count.get<DIVariable*>());
+  ASSERT_TRUE(isa<DIVariable *>(Count));
+  EXPECT_EQ(VlaExpr, cast<DIVariable *>(Count));
   ASSERT_TRUE(isa<DIVariable>(N->getRawCountNode()));
-  EXPECT_EQ(0, Lower.get<ConstantInt *>()->getSExtValue());
-  EXPECT_EQ("vla_expr", Count.get<DIVariable*>()->getName());
+  EXPECT_EQ(0, cast<ConstantInt *>(Lower)->getSExtValue());
+  EXPECT_EQ("vla_expr", cast<DIVariable *>(Count)->getName());
   EXPECT_EQ(N, DISubrange::get(Context, VlaExpr, 0));
 }
 
 TEST_F(DISubrangeTest, fortranAllocatableInt) {
   DILocalScope *Scope = getSubprogram();
   DIFile *File = getFile();
   DIType *Type = getDerivedType();
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(7);
auto *LIZero = ConstantAsMetadata::get(
       ConstantInt::getSigned(Type::getInt64Ty(Context), 0));
   auto *UIZero = ConstantAsMetadata::get(
       ConstantInt::getSigned(Type::getInt64Ty(Context), 0));
 
   auto *N = DISubrange::get(Context, nullptr, LI, UI, SI);
 
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Lower);
-  ASSERT_TRUE(Lower.is<ConstantInt *>());
-  EXPECT_EQ(cast<ConstantInt>(LI->getValue()), Lower.get<ConstantInt *>());
+  ASSERT_TRUE(isa<ConstantInt *>(Lower));
+  EXPECT_EQ(cast<ConstantInt>(LI->getValue()), cast<ConstantInt *>(Lower));
 
   auto Upper = N->getUpperBound();
   ASSERT_TRUE(Upper);
-  ASSERT_TRUE(Upper.is<ConstantInt *>());
-  EXPECT_EQ(cast<ConstantInt>(UI->getValue()), Upper.get<ConstantInt *>());
+  ASSERT_TRUE(isa<ConstantInt *>(Upper));
+  EXPECT_EQ(cast<ConstantInt>(UI->getValue()), cast<ConstantInt *>(Upper));
 
   auto Stride = N->getStride();
   ASSERT_TRUE(Stride);
-  ASSERT_TRUE(Stride.is<ConstantInt *>());
-  EXPECT_EQ(cast<ConstantInt>(SI->getValue()), Stride.get<ConstantInt *>());
+  ASSERT_TRUE(isa<ConstantInt *>(Stride));
+  EXPECT_EQ(cast<ConstantInt>(SI->getValue()), cast<ConstantInt *>(Stride));
 
   EXPECT_EQ(N, DISubrange::get(Context, nullptr, LI, UI, SI));
 
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LI, UIother, SI));
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LI, UEother, SI));
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LI, UVother, SI));
 
   auto *NZeroLower = DISubrange::get(Context, nullptr, LIZero, UI, SI);
TEST_F(DISubrangeTest, fortranAllocatableVar) {
   auto *SIother = ConstantAsMetadata::get(
       ConstantInt::getSigned(Type::getInt64Ty(Context), 20));
   auto *SEother = DIExpression::get(Context, {5, 6});
 
   auto *N = DISubrange::get(Context, nullptr, LV, UV, SV);
 
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Lower);
-  ASSERT_TRUE(Lower.is<DIVariable *>());
-  EXPECT_EQ(LV, Lower.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Lower));
+  EXPECT_EQ(LV, cast<DIVariable *>(Lower));
 
   auto Upper = N->getUpperBound();
   ASSERT_TRUE(Upper);
-  ASSERT_TRUE(Upper.is<DIVariable *>());
-  EXPECT_EQ(UV, Upper.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Upper));
+  EXPECT_EQ(UV, cast<DIVariable *>(Upper));
 
   auto Stride = N->getStride();
   ASSERT_TRUE(Stride);
-  ASSERT_TRUE(Stride.is<DIVariable *>());
-  EXPECT_EQ(SV, Stride.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Stride));
+  EXPECT_EQ(SV, cast<DIVariable *>(Stride));
 
   EXPECT_EQ(N, DISubrange::get(Context, nullptr, LV, UV, SV));
 
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LV, UV, SVother));
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LV, UV, SEother));
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LV, UV, SIother));
 }
 
auto *LIother = ConstantAsMetadata::get(
       ConstantInt::getSigned(Type::getInt64Ty(Context), 20));
   auto *LVother = DILocalVariable::get(Context, Scope, "lbother", File, 8, Type,
                                        2, Flags, 8, nullptr);
 
   auto *N = DISubrange::get(Context, nullptr, LE, UE, SE);
 
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Lower);
-  ASSERT_TRUE(Lower.is<DIExpression *>());
-  EXPECT_EQ(LE, Lower.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Lower));
+  EXPECT_EQ(LE, cast<DIExpression *>(Lower));
 
   auto Upper = N->getUpperBound();
   ASSERT_TRUE(Upper);
-  ASSERT_TRUE(Upper.is<DIExpression *>());
-  EXPECT_EQ(UE, Upper.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Upper));
+  EXPECT_EQ(UE, cast<DIExpression *>(Upper));
 
   auto Stride = N->getStride();
   ASSERT_TRUE(Stride);
-  ASSERT_TRUE(Stride.is<DIExpression *>());
-  EXPECT_EQ(SE, Stride.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Stride));
+  EXPECT_EQ(SE, cast<DIExpression *>(Stride));
 
   EXPECT_EQ(N, DISubrange::get(Context, nullptr, LE, UE, SE));
 
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LEother, UE, SE));
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LIother, UE, SE));
   EXPECT_NE(N, DISubrange::get(Context, nullptr, LVother, UE, SE));
 }
 
TEST_F(DIGenericSubrangeTest, fortranAssumedRankInt) {
   auto *UEother = DIExpression::get(Context, {5, 6});
   auto *LIZero = DIExpression::get(Context, {dwarf::DW_OP_consts, 0});
   auto *UIZero = DIExpression::get(Context, {dwarf::DW_OP_consts, 0});
 
   auto *N = DIGenericSubrange::get(Context, nullptr, LI, UI, SI);
 
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Lower);
-  ASSERT_TRUE(Lower.is<DIExpression *>());
-  EXPECT_EQ(dyn_cast_or_null<DIExpression>(LI), Lower.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Lower));
+  EXPECT_EQ(dyn_cast_or_null<DIExpression>(LI), cast<DIExpression *>(Lower));
 
   auto Upper = N->getUpperBound();
   ASSERT_TRUE(Upper);
-  ASSERT_TRUE(Upper.is<DIExpression *>());
-  EXPECT_EQ(dyn_cast_or_null<DIExpression>(UI), Upper.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Upper));
+  EXPECT_EQ(dyn_cast_or_null<DIExpression>(UI), cast<DIExpression *>(Upper));
 
   auto Stride = N->getStride();
   ASSERT_TRUE(Stride);
-  ASSERT_TRUE(Stride.is<DIExpression *>());
-  EXPECT_EQ(dyn_cast_or_null<DIExpression>(SI), Stride.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Stride));
+  EXPECT_EQ(dyn_cast_or_null<DIExpression>(SI), cast<DIExpression *>(Stride));
 
   EXPECT_EQ(N, DIGenericSubrange::get(Context, nullptr, LI, UI, SI));
 
   EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UIother, SI));
   EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UEother, SI));
   EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LI, UVother, SI));
 
   auto *NZeroLower = DIGenericSubrange::get(Context, nullptr, LIZero, UI, SI);
TEST_F(DIGenericSubrangeTest, fortranAssumedRankVar) {
   auto *SIother = DIExpression::get(
       Context, {dwarf::DW_OP_consts, static_cast<uint64_t>(-1)});
   auto *SEother = DIExpression::get(Context, {5, 6});
 
   auto *N = DIGenericSubrange::get(Context, nullptr, LV, UV, SV);
 
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Lower);
-  ASSERT_TRUE(Lower.is<DIVariable *>());
-  EXPECT_EQ(LV, Lower.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Lower));
+  EXPECT_EQ(LV, cast<DIVariable *>(Lower));
 
   auto Upper = N->getUpperBound();
   ASSERT_TRUE(Upper);
-  ASSERT_TRUE(Upper.is<DIVariable *>());
-  EXPECT_EQ(UV, Upper.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Upper));
+  EXPECT_EQ(UV, cast<DIVariable *>(Upper));
 
   auto Stride = N->getStride();
   ASSERT_TRUE(Stride);
-  ASSERT_TRUE(Stride.is<DIVariable *>());
-  EXPECT_EQ(SV, Stride.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Stride));
+  EXPECT_EQ(SV, cast<DIVariable *>(Stride));
 
   EXPECT_EQ(N, DIGenericSubrange::get(Context, nullptr, LV, UV, SV));
 
   EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LV, UV, SVother));
   EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LV, UV, SEother));
   EXPECT_NE(N, DIGenericSubrange::get(Context, nullptr, LV, UV, SIother));
 }
 
TEST_F(DIGenericSubrangeTest, useDIBuilder) {
   DIBuilder DIB(M);
 
   auto *N = DIB.getOrCreateGenericSubrange(
       DIGenericSubrange::BoundType(nullptr), DIGenericSubrange::BoundType(LV),
       DIGenericSubrange::BoundType(UE), DIGenericSubrange::BoundType(SE));
 
   auto Lower = N->getLowerBound();
   ASSERT_TRUE(Lower);
-  ASSERT_TRUE(Lower.is<DIVariable *>());
-  EXPECT_EQ(LV, Lower.get<DIVariable *>());
+  ASSERT_TRUE(isa<DIVariable *>(Lower));
+  EXPECT_EQ(LV, cast<DIVariable *>(Lower));
 
   auto Upper = N->getUpperBound();
   ASSERT_TRUE(Upper);
-  ASSERT_TRUE(Upper.is<DIExpression *>());
-  EXPECT_EQ(UE, Upper.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Upper));
+  EXPECT_EQ(UE, cast<DIExpression *>(Upper));
 
   auto Stride = N->getStride();
   ASSERT_TRUE(Stride);
-  ASSERT_TRUE(Stride.is<DIExpression *>());
-  EXPECT_EQ(SE, Stride.get<DIExpression *>());
+  ASSERT_TRUE(isa<DIExpression *>(Stride));
+  EXPECT_EQ(SE, cast<DIExpression *>(Stride));
 
   EXPECT_EQ(
       N, DIB.getOrCreateGenericSubrange(DIGenericSubrange::BoundType(nullptr),
                                         DIGenericSubrange::BoundType(LV),
                                         DIGenericSubrange::BoundType(UE),
                                         DIGenericSubrange::BoundType(SE)));
 
   EXPECT_NE(

llvm/utils/TableGen/AsmMatcherEmitter.cpp

struct MatchableInfo {
   /// TheDef - This is the definition of the instruction or InstAlias that this
   /// matchable came from.
   Record *const TheDef;
 
   /// DefRec - This is the definition that it came from.
   PointerUnion<const CodeGenInstruction*, const CodeGenInstAlias*> DefRec;
 
   const CodeGenInstruction *getResultInst() const {
-    if (DefRec.is<const CodeGenInstruction*>())
-      return DefRec.get<const CodeGenInstruction*>();
-    return DefRec.get<const CodeGenInstAlias*>()->ResultInst;
+    if (isa<const CodeGenInstruction *>(DefRec))
+      return cast<const CodeGenInstruction *>(DefRec);
+    return cast<const CodeGenInstAlias *>(DefRec)->ResultInst;
   }
 
   /// ResOperands - This is the operand list that should be built for the result
   /// MCInst.
   SmallVector<ResOperand, 8> ResOperands;
 
   /// Mnemonic - This is the first token of the matched instruction, its
   /// mnemonic.
struct MatchableInfo {
   MatchableInfo(const MatchableInfo &RHS)
       : AsmVariantID(RHS.AsmVariantID), AsmString(RHS.AsmString),
         TheDef(RHS.TheDef), DefRec(RHS.DefRec), ResOperands(RHS.ResOperands),
         Mnemonic(RHS.Mnemonic), AsmOperands(RHS.AsmOperands),
         RequiredFeatures(RHS.RequiredFeatures),
         ConversionFnKind(RHS.ConversionFnKind),
         HasDeprecation(RHS.HasDeprecation),
         UseInstAsmMatchConverter(RHS.UseInstAsmMatchConverter) {
-    assert(!DefRec.is<const CodeGenInstAlias *>());
+    assert(!isa<const CodeGenInstAlias *>(DefRec));
   }
 
   ~MatchableInfo() {
-    delete DefRec.dyn_cast<const CodeGenInstAlias*>();
+    delete dyn_cast_if_present<const CodeGenInstAlias *>(DefRec);
   }
 
   // Two-operand aliases clone from the main matchable, but mark the second
   // operand as a tied operand of the first for purposes of the assembler.
   void formTwoOperandAlias(StringRef Constraint);
 
   void initialize(const AsmMatcherInfo &Info,
                   SmallPtrSetImpl<Record*> &SingletonRegisters,
for (unsigned i = 0; i != II->AsmOperands.size(); ++i) {
 
       // Otherwise this is an operand reference.
       StringRef OperandName;
       if (Token[1] == '{')
         OperandName = Token.substr(2, Token.size() - 3);
       else
         OperandName = Token.substr(1);
 
-      if (II->DefRec.is<const CodeGenInstruction*>())
+      if (isa<const CodeGenInstruction *>(II->DefRec))
         buildInstructionOperandReference(II.get(), OperandName, i);
       else
         buildAliasOperandReference(II.get(), OperandName, Op);
     }
 
-    if (II->DefRec.is<const CodeGenInstruction*>()) {
+    if (isa<const CodeGenInstruction *>(II->DefRec)) {
       II->buildInstructionResultOperands();
       // If the instruction has a two-operand alias, build up the
       // matchable here. We'll add them in bulk at the end to avoid
       // confusing this loop.
       StringRef Constraint =
           II->TheDef->getValueAsString("TwoOperandAliasConstraint");
       if (Constraint != "") {
         // Start by making a copy of the original matchable.

 }
 
 /// buildInstructionOperandReference - The specified operand is a reference to a
 /// named operand such as $src.  Resolve the Class and OperandInfo pointers.
 void AsmMatcherInfo::
 buildInstructionOperandReference(MatchableInfo *II,
                                  StringRef OperandName,
                                  unsigned AsmOpIdx) {
-  const CodeGenInstruction &CGI = *II->DefRec.get<const CodeGenInstruction*>();
+  const CodeGenInstruction &CGI = *cast<const CodeGenInstruction *>(II->DefRec);
   const CGIOperandList &Operands = CGI.Operands;
   MatchableInfo::AsmOperand *Op = &II->AsmOperands[AsmOpIdx];
 
   // Map this token to an operand.
   unsigned Idx;
   if (!Operands.hasOperandNamed(OperandName, Idx))
     PrintFatalError(II->TheDef->getLoc(),
                     "error: unable to find operand: '" + OperandName + "'");

 }
 
 /// buildAliasOperandReference - When parsing an operand reference out of the
 /// matching string (e.g. "movsx $src, $dst"), determine what the class of the
 /// operand reference is by looking it up in the result pattern definition.
 void AsmMatcherInfo::buildAliasOperandReference(MatchableInfo *II,
                                                 StringRef OperandName,
                                                 MatchableInfo::AsmOperand &Op) {
-  const CodeGenInstAlias &CGA = *II->DefRec.get<const CodeGenInstAlias*>();
+  const CodeGenInstAlias &CGA = *cast<const CodeGenInstAlias *>(II->DefRec);
 
   // Set up the operand class.
   for (unsigned i = 0, e = CGA.ResultOperands.size(); i != e; ++i)
     if (CGA.ResultOperands[i].isRecord() &&
         CGA.ResultOperands[i].getName() == OperandName) {
       // It's safe to go with the first one we find, because CodeGenInstAlias
       // validates that all operands with the same name have the same record.
       Op.SubOpIdx = CGA.ResultInstOperandIndex[i].second;
for (unsigned AI = 0; AI < NumOperands; ++AI) {
              AsmOperands[SrcOperand+AI].SrcOpName == OpInfo.Name &&
              "unexpected AsmOperands for suboperands");
       ResOperands.push_back(ResOperand::getRenderedOp(SrcOperand + AI, 1));
     }
   }
 }
 
 void MatchableInfo::buildAliasResultOperands(bool AliasConstraintsAreChecked) {
-  const CodeGenInstAlias &CGA = *DefRec.get<const CodeGenInstAlias*>();
+  const CodeGenInstAlias &CGA = *cast<const CodeGenInstAlias *>(DefRec);
   const CodeGenInstruction *ResultInst = getResultInst();
 
   // Map of:  $reg -> #lastref
   //   where $reg is the name of the operand in the asm string
   //   where #lastref is the last processed index where $reg was referenced in
   //   the asm string.
   SmallDenseMap<StringRef, int> OperandRefs;