[LLVM] Replace `cast_or_null` with `cast_if_present`, NFC.

[bzcheeseman]

Summary

cast_if_present is simply the new version of cast_or_null - indeed cast_or_null calls cast_if_present. The if_present suffix more closely represents the capabilities of the function now, as it can correctly handle optionals and things that are not "null".

[bzcheeseman]

No consensus, closing this.

llvm/include/llvm/Analysis/AliasSetTracker.h

class AliasSet : public ilist_node<AliasSet> {
   void dropRef(AliasSetTracker &AST) {
     assert(RefCount >= 1 && "Invalid reference count detected!");
     if (--RefCount == 0)
       removeFromTracker(AST);
   }
 
   Instruction *getUnknownInst(unsigned i) const {
     assert(i < UnknownInsts.size());
-    return cast_or_null<Instruction>(UnknownInsts[i]);
+    return cast_if_present<Instruction>(UnknownInsts[i]);
   }
 
 public:
   AliasSet(const AliasSet &) = delete;
   AliasSet &operator=(const AliasSet &) = delete;
 
   /// Accessors...
   bool isRef() const { return Access & RefAccess; }

llvm/include/llvm/Analysis/MemorySSA.h

public:
   }
 
   void setOptimized(MemoryAccess *MA) {
     setOperand(1, MA);
     OptimizedID = MA->getID();
   }
 
   MemoryAccess *getOptimized() const {
-    return cast_or_null<MemoryAccess>(getOperand(1));
+    return cast_if_present<MemoryAccess>(getOperand(1));
   }
 
   bool isOptimized() const {
     return getOptimized() && OptimizedID == getOptimized()->getID();
   }
 
   void resetOptimized() {
     OptimizedID = INVALID_MEMORYACCESS_ID;
public:
   MemorySSAWalker *getWalker();
   MemorySSAWalker *getSkipSelfWalker();
 
   /// Given a memory Mod/Ref'ing instruction, get the MemorySSA
   /// access associated with it. If passed a basic block gets the memory phi
   /// node that exists for that block, if there is one. Otherwise, this will get
   /// a MemoryUseOrDef.
   MemoryUseOrDef *getMemoryAccess(const Instruction *I) const {
-    return cast_or_null<MemoryUseOrDef>(ValueToMemoryAccess.lookup(I));
+    return cast_if_present<MemoryUseOrDef>(ValueToMemoryAccess.lookup(I));
   }
 
   MemoryPhi *getMemoryAccess(const BasicBlock *BB) const {
-    return cast_or_null<MemoryPhi>(ValueToMemoryAccess.lookup(cast<Value>(BB)));
+    return cast_if_present<MemoryPhi>(
+        ValueToMemoryAccess.lookup(cast<Value>(BB)));
   }
 
   DominatorTree &getDomTree() const { return *DT; }
 
   void dump() const;
   void print(raw_ostream &) const;
 
   /// Return true if \p MA represents the live on entry value

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
 
   MDTuple *get() const { return const_cast<MDTuple *>(N); }
   MDTuple *operator->() const { return get(); }
   MDTuple &operator*() const { return *get(); }
 
   // FIXME: Fix callers and remove condition on N.
   unsigned size() const { return N ? N->getNumOperands() : 0u; }
   DIType *operator[](unsigned I) const {
-    return cast_or_null<DIType>(N->getOperand(I));
+    return cast_if_present<DIType>(N->getOperand(I));
   }
 
   class iterator {
     MDNode::op_iterator I = nullptr;
 
   public:
     using iterator_category = std::input_iterator_tag;
     using value_type = DIType *;
     using difference_type = std::ptrdiff_t;
     using pointer = void;
     using reference = DIType *;
 
     iterator() = default;
     explicit iterator(MDNode::op_iterator I) : I(I) {}
 
-    DIType *operator*() const { return cast_or_null<DIType>(*I); }
+    DIType *operator*() const { return cast_if_present<DIType>(*I); }
 
     iterator &operator++() {
       ++I;
       return *this;
     }
 
     iterator operator++(int) {
       iterator Temp(*this);
DINode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
          ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
       : MDNode(C, ID, Storage, Ops1, Ops2) {
     assert(Tag < 1u << 16);
     SubclassData16 = Tag;
   }
   ~DINode() = default;
 
   template <class Ty> Ty *getOperandAs(unsigned I) const {
-    return cast_or_null<Ty>(getOperand(I));
+    return cast_if_present<Ty>(getOperand(I));
   }
 
   StringRef getStringOperand(unsigned I) const {
     if (auto *S = getOperandAs<MDString>(I))
       return S->getString();
     return StringRef();
   }
 

 class DIScope : public DINode {
 protected:
   DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
           ArrayRef<Metadata *> Ops)
       : DINode(C, ID, Storage, Tag, Ops) {}
   ~DIScope() = default;
 
 public:
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
 
   inline StringRef getFilename() const;
   inline StringRef getDirectory() const;
   inline Optional<StringRef> getSource() const;
 
   StringRef getName() const;
   DIScope *getScope() const;
 
public:
 
   unsigned getLine() const { return Line; }
   uint64_t getSizeInBits() const { return SizeInBits; }
   uint32_t getAlignInBits() const { return AlignInBits; }
   uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
   uint64_t getOffsetInBits() const { return OffsetInBits; }
   DIFlags getFlags() const { return Flags; }
 
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
 
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
 
   /// Returns a new temporary DIType with updated Flags
   TempDIType cloneWithFlags(DIFlags NewFlags) const {
     auto NewTy = clone();
public:
 
   TempDIStringType clone() const { return cloneImpl(); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIStringTypeKind;
   }
 
   DIVariable *getStringLength() const {
-    return cast_or_null<DIVariable>(getRawStringLength());
+    return cast_if_present<DIVariable>(getRawStringLength());
   }
 
   DIExpression *getStringLengthExp() const {
-    return cast_or_null<DIExpression>(getRawStringLengthExp());
+    return cast_if_present<DIExpression>(getRawStringLengthExp());
   }
 
   DIExpression *getStringLocationExp() const {
-    return cast_or_null<DIExpression>(getRawStringLocationExp());
+    return cast_if_present<DIExpression>(getRawStringLocationExp());
   }
 
   unsigned getEncoding() const { return Encoding; }
 
   Metadata *getRawStringLength() const { return getOperand(3); }
 
   Metadata *getRawStringLengthExp() const { return getOperand(4); }
 
DEFINE_MDNODE_GET(DIDerivedType,
                      DINodeArray Annotations = nullptr),
                     (Tag, Name, File, Line, Scope, BaseType, SizeInBits,
                      AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,
                      ExtraData, Annotations))
 
   TempDIDerivedType clone() const { return cloneImpl(); }
 
   /// Get the base type this is derived from.
-  DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
+  DIType *getBaseType() const {
+    return cast_if_present<DIType>(getRawBaseType());
+  }
   Metadata *getRawBaseType() const { return getOperand(3); }
 
   /// \returns The DWARF address space of the memory pointed to or referenced by
   /// a pointer or reference type respectively.
   Optional<unsigned> getDWARFAddressSpace() const { return DWARFAddressSpace; }
 
   /// Get extra data associated with this derived type.
   ///
   /// Class type for pointer-to-members, objective-c property node for ivars,
   /// global constant wrapper for static members, or virtual base pointer offset
   /// for inheritance.
   ///
   /// TODO: Separate out types that need this extra operand: pointer-to-member
   /// types and member fields (static members and ivars).
   Metadata *getExtraData() const { return getRawExtraData(); }
   Metadata *getRawExtraData() const { return getOperand(4); }
 
   /// Get annotations associated with this derived type.
   DINodeArray getAnnotations() const {
-    return cast_or_null<MDTuple>(getRawAnnotations());
+    return cast_if_present<MDTuple>(getRawAnnotations());
   }
   Metadata *getRawAnnotations() const { return getOperand(5); }
 
   /// Get casted version of extra data.
   /// @{
   DIType *getClassType() const;
 
   DIObjCProperty *getObjCProperty() const {
buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag,
                MDString *Name, Metadata *File, unsigned Line, Metadata *Scope,
                Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits,
                uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements,
                unsigned RuntimeLang, Metadata *VTableHolder,
                Metadata *TemplateParams, Metadata *Discriminator,
                Metadata *DataLocation, Metadata *Associated,
                Metadata *Allocated, Metadata *Rank, Metadata *Annotations);
 
-  DIType *getBaseType() const { return cast_or_null<DIType>(getRawBaseType()); }
+  DIType *getBaseType() const {
+    return cast_if_present<DIType>(getRawBaseType());
+  }
   DINodeArray getElements() const {
-    return cast_or_null<MDTuple>(getRawElements());
+    return cast_if_present<MDTuple>(getRawElements());
   }
   DIType *getVTableHolder() const {
-    return cast_or_null<DIType>(getRawVTableHolder());
+    return cast_if_present<DIType>(getRawVTableHolder());
   }
   DITemplateParameterArray getTemplateParams() const {
-    return cast_or_null<MDTuple>(getRawTemplateParams());
+    return cast_if_present<MDTuple>(getRawTemplateParams());
   }
   StringRef getIdentifier() const { return getStringOperand(7); }
   unsigned getRuntimeLang() const { return RuntimeLang; }
 
   Metadata *getRawBaseType() const { return getOperand(3); }
   Metadata *getRawElements() const { return getOperand(4); }
   Metadata *getRawVTableHolder() const { return getOperand(5); }
   Metadata *getRawTemplateParams() const { return getOperand(6); }
ConstantInt *getRankConst() const {
     return nullptr;
   }
   DIExpression *getRankExp() const {
     return dyn_cast_if_present<DIExpression>(getRawRank());
   }
 
   Metadata *getRawAnnotations() const { return getOperand(13); }
   DINodeArray getAnnotations() const {
-    return cast_or_null<MDTuple>(getRawAnnotations());
+    return cast_if_present<MDTuple>(getRawAnnotations());
   }
 
   /// Replace operands.
   ///
   /// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
   /// this will be RAUW'ed and deleted.  Use a \a TrackingMDRef to keep track
   /// of its movement if necessary.
   /// @{
TempDISubroutineType cloneWithCC(uint8_t CC) const {
     auto NewTy = clone();
     NewTy->CC = CC;
     return NewTy;
   }
 
   uint8_t getCC() const { return CC; }
 
   DITypeRefArray getTypeArray() const {
-    return cast_or_null<MDTuple>(getRawTypeArray());
+    return cast_if_present<MDTuple>(getRawTypeArray());
   }
 
   Metadata *getRawTypeArray() const { return getOperand(3); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubroutineTypeKind;
   }
 };
public:
   DebugNameTableKind getNameTableKind() const {
     return (DebugNameTableKind)NameTableKind;
   }
   bool getRangesBaseAddress() const { return RangesBaseAddress; }
   StringRef getProducer() const { return getStringOperand(1); }
   StringRef getFlags() const { return getStringOperand(2); }
   StringRef getSplitDebugFilename() const { return getStringOperand(3); }
   DICompositeTypeArray getEnumTypes() const {
-    return cast_or_null<MDTuple>(getRawEnumTypes());
+    return cast_if_present<MDTuple>(getRawEnumTypes());
   }
   DIScopeArray getRetainedTypes() const {
-    return cast_or_null<MDTuple>(getRawRetainedTypes());
+    return cast_if_present<MDTuple>(getRawRetainedTypes());
   }
   DIGlobalVariableExpressionArray getGlobalVariables() const {
-    return cast_or_null<MDTuple>(getRawGlobalVariables());
+    return cast_if_present<MDTuple>(getRawGlobalVariables());
   }
   DIImportedEntityArray getImportedEntities() const {
-    return cast_or_null<MDTuple>(getRawImportedEntities());
+    return cast_if_present<MDTuple>(getRawImportedEntities());
   }
   DIMacroNodeArray getMacros() const {
-    return cast_or_null<MDTuple>(getRawMacros());
+    return cast_if_present<MDTuple>(getRawMacros());
   }
   uint64_t getDWOId() const { return DWOId; }
   void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
   bool getSplitDebugInlining() const { return SplitDebugInlining; }
   void setSplitDebugInlining(bool SplitDebugInlining) {
     this->SplitDebugInlining = SplitDebugInlining;
   }
   StringRef getSysRoot() const { return getStringOperand(9); }
public:
   /// Return a (temporary) clone of this.
   TempDILocation clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return SubclassData32; }
   unsigned getColumn() const { return SubclassData16; }
   DILocalScope *getScope() const { return cast<DILocalScope>(getRawScope()); }
 
   DILocation *getInlinedAt() const {
-    return cast_or_null<DILocation>(getRawInlinedAt());
+    return cast_if_present<DILocation>(getRawInlinedAt());
   }
 
   /// Check if the location corresponds to an implicit code.
   /// When the ImplicitCode flag is true, it means that the Instruction
   /// with this DILocation has been added by the front-end but it hasn't been
   /// written explicitly by the user (e.g. cleanup stuff in C++ put on a closing
   /// bracket). It's useful for code coverage to not show a counter on "empty"
   /// lines.
public:
   /// Return true if this subprogram is C++11 noreturn or C11 _Noreturn
   bool isNoReturn() const { return getFlags() & FlagNoReturn; }
 
   // Check if this routine is a compiler-generated thunk.
   //
   // Returns true if this subprogram is a thunk generated by the compiler.
   bool isThunk() const { return getFlags() & FlagThunk; }
 
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
 
   StringRef getName() const { return getStringOperand(2); }
   StringRef getLinkageName() const { return getStringOperand(3); }
   /// Only used by clients of CloneFunction, and only right after the cloning.
   void replaceLinkageName(MDString *LN) { replaceOperandWith(3, LN); }
 
   DISubroutineType *getType() const {
-    return cast_or_null<DISubroutineType>(getRawType());
+    return cast_if_present<DISubroutineType>(getRawType());
   }
   DIType *getContainingType() const {
-    return cast_or_null<DIType>(getRawContainingType());
+    return cast_if_present<DIType>(getRawContainingType());
   }
   void replaceType(DISubroutineType *Ty) {
     assert(isDistinct() && "Only distinct nodes can mutate");
     replaceOperandWith(4, Ty);
   }
 
   DICompileUnit *getUnit() const {
-    return cast_or_null<DICompileUnit>(getRawUnit());
+    return cast_if_present<DICompileUnit>(getRawUnit());
   }
   void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
   DITemplateParameterArray getTemplateParams() const {
-    return cast_or_null<MDTuple>(getRawTemplateParams());
+    return cast_if_present<MDTuple>(getRawTemplateParams());
   }
   DISubprogram *getDeclaration() const {
-    return cast_or_null<DISubprogram>(getRawDeclaration());
+    return cast_if_present<DISubprogram>(getRawDeclaration());
   }
   DINodeArray getRetainedNodes() const {
-    return cast_or_null<MDTuple>(getRawRetainedNodes());
+    return cast_if_present<MDTuple>(getRawRetainedNodes());
   }
   DITypeArray getThrownTypes() const {
-    return cast_or_null<MDTuple>(getRawThrownTypes());
+    return cast_if_present<MDTuple>(getRawThrownTypes());
   }
   DINodeArray getAnnotations() const {
-    return cast_or_null<MDTuple>(getRawAnnotations());
+    return cast_if_present<MDTuple>(getRawAnnotations());
   }
   StringRef getTargetFuncName() const {
     return (getRawTargetFuncName()) ? getStringOperand(12) : StringRef();
   }
 
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
DEFINE_MDNODE_GET(DINamespace,
                     (Scope, Name, ExportSymbols))
   DEFINE_MDNODE_GET(DINamespace,
                     (Metadata * Scope, MDString *Name, bool ExportSymbols),
                     (Scope, Name, ExportSymbols))
 
   TempDINamespace clone() const { return cloneImpl(); }
 
   bool getExportSymbols() const { return ExportSymbols; }
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
 
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DINamespaceKind;
   }
DEFINE_MDNODE_GET(DIModule,
                      MDString *ConfigurationMacros, MDString *IncludePath,
                      MDString *APINotesFile, unsigned LineNo,
                      bool IsDecl = false),
                     (File, Scope, Name, ConfigurationMacros, IncludePath,
                      APINotesFile, LineNo, IsDecl))
 
   TempDIModule clone() const { return cloneImpl(); }
 
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
   StringRef getConfigurationMacros() const { return getStringOperand(3); }
   StringRef getIncludePath() const { return getStringOperand(4); }
   StringRef getAPINotesFile() const { return getStringOperand(5); }
   unsigned getLineNo() const { return LineNo; }
   bool getIsDecl() const { return IsDecl; }
 
   Metadata *getRawScope() const { return getOperand(1); }
protected:
 
   DITemplateParameter(LLVMContext &Context, unsigned ID, StorageType Storage,
                       unsigned Tag, bool IsDefault, ArrayRef<Metadata *> Ops)
       : DINode(Context, ID, Storage, Tag, Ops), IsDefault(IsDefault) {}
   ~DITemplateParameter() = default;
 
 public:
   StringRef getName() const { return getStringOperand(0); }
-  DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
+  DIType *getType() const { return cast_if_present<DIType>(getRawType()); }
 
   MDString *getRawName() const { return getOperandAs<MDString>(0); }
   Metadata *getRawType() const { return getOperand(1); }
   bool isDefault() const { return IsDefault; }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DITemplateTypeParameterKind ||
            MD->getMetadataID() == DITemplateValueParameterKind;

 
 protected:
   DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, signed Line,
              ArrayRef<Metadata *> Ops, uint32_t AlignInBits = 0);
   ~DIVariable() = default;
 
 public:
   unsigned getLine() const { return Line; }
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(1); }
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
-  DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
+  DIType *getType() const { return cast_if_present<DIType>(getRawType()); }
   uint32_t getAlignInBits() const { return AlignInBits; }
   uint32_t getAlignInBytes() const { return getAlignInBits() / CHAR_BIT; }
   /// Determines the size of the variable's type.
   Optional<uint64_t> getSizeInBits() const;
 
   /// Return the signedness of this variable's type, or None if this type is
   /// neither signed nor unsigned.
   Optional<DIBasicType::Signedness> getSignedness() const {
getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
           StringRef LinkageName, DIFile *File, unsigned Line, DIType *Type,
           bool IsLocalToUnit, bool IsDefinition,
           DIDerivedType *StaticDataMemberDeclaration, MDTuple *TemplateParams,
           uint32_t AlignInBits, DINodeArray Annotations, StorageType Storage,
           bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
                    IsLocalToUnit, IsDefinition, StaticDataMemberDeclaration,
-                   cast_or_null<Metadata>(TemplateParams), AlignInBits,
+                   cast_if_present<Metadata>(TemplateParams), AlignInBits,
                    Annotations.get(), Storage, ShouldCreate);
   }
   static DIGlobalVariable *
   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
           bool IsLocalToUnit, bool IsDefinition,
           Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
           uint32_t AlignInBits, Metadata *Annotations, StorageType Storage,
public:
 
   TempDIGlobalVariable clone() const { return cloneImpl(); }
 
   bool isLocalToUnit() const { return IsLocalToUnit; }
   bool isDefinition() const { return IsDefinition; }
   StringRef getDisplayName() const { return getStringOperand(4); }
   StringRef getLinkageName() const { return getStringOperand(5); }
   DIDerivedType *getStaticDataMemberDeclaration() const {
-    return cast_or_null<DIDerivedType>(getRawStaticDataMemberDeclaration());
+    return cast_if_present<DIDerivedType>(getRawStaticDataMemberDeclaration());
   }
   DINodeArray getAnnotations() const {
-    return cast_or_null<MDTuple>(getRawAnnotations());
+    return cast_if_present<MDTuple>(getRawAnnotations());
   }
 
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(5); }
   Metadata *getRawStaticDataMemberDeclaration() const { return getOperand(6); }
   Metadata *getRawTemplateParams() const { return getOperand(7); }
   MDTuple *getTemplateParams() const { return getOperandAs<MDTuple>(7); }
   Metadata *getRawAnnotations() const { return getOperand(8); }
 
DEFINE_MDNODE_GET(DICommonBlock,
                     (Scope, Decl, Name, File, LineNo))
   DEFINE_MDNODE_GET(DICommonBlock,
                     (Metadata * Scope, Metadata *Decl, MDString *Name,
                      Metadata *File, unsigned LineNo),
                     (Scope, Decl, Name, File, LineNo))
 
   TempDICommonBlock clone() const { return cloneImpl(); }
 
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
   DIGlobalVariable *getDecl() const {
-    return cast_or_null<DIGlobalVariable>(getRawDecl());
+    return cast_if_present<DIGlobalVariable>(getRawDecl());
   }
   StringRef getName() const { return getStringOperand(2); }
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
   unsigned getLineNo() const { return LineNo; }
 
   Metadata *getRawScope() const { return getOperand(0); }
   Metadata *getRawDecl() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   Metadata *getRawFile() const { return getOperand(3); }
 
   static bool classof(const Metadata *MD) {
DILocalScope *getScope() const {
     return cast<DILocalScope>(DIVariable::getScope());
   }
 
   bool isParameter() const { return Arg; }
   unsigned getArg() const { return Arg; }
   DIFlags getFlags() const { return Flags; }
 
   DINodeArray getAnnotations() const {
-    return cast_or_null<MDTuple>(getRawAnnotations());
+    return cast_if_present<MDTuple>(getRawAnnotations());
   }
   Metadata *getRawAnnotations() const { return getOperand(4); }
 
   bool isArtificial() const { return getFlags() & FlagArtificial; }
   bool isObjectPointer() const { return getFlags() & FlagObjectPointer; }
 
   /// Check that a location is valid for this variable.
   ///
DEFINE_MDNODE_GET(DILabel,
                     (Scope, Name, File, Line))
 
   TempDILabel clone() const { return cloneImpl(); }
 
   /// Get the local scope for this label.
   ///
   /// Labels must be defined in a local scope.
   DILocalScope *getScope() const {
-    return cast_or_null<DILocalScope>(getRawScope());
+    return cast_if_present<DILocalScope>(getRawScope());
   }
   unsigned getLine() const { return Line; }
   StringRef getName() const { return getStringOperand(1); }
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
 
   Metadata *getRawScope() const { return getOperand(0); }
   MDString *getRawName() const { return getOperandAs<MDString>(1); }
   Metadata *getRawFile() const { return getOperand(2); }
 
   /// Check that a location is valid for this label.
   ///
   /// Check that \c DL exists, is in the same subprogram, and has the same
DEFINE_MDNODE_GET(DIObjCProperty,
                     (Name, File, Line, GetterName, SetterName, Attributes,
                      Type))
 
   TempDIObjCProperty clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
   unsigned getAttributes() const { return Attributes; }
   StringRef getName() const { return getStringOperand(0); }
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
   StringRef getGetterName() const { return getStringOperand(2); }
   StringRef getSetterName() const { return getStringOperand(3); }
-  DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
+  DIType *getType() const { return cast_if_present<DIType>(getRawType()); }
 
   StringRef getFilename() const {
     if (auto *F = getFile())
       return F->getFilename();
     return "";
   }
 
   StringRef getDirectory() const {
DEFINE_MDNODE_GET(DIImportedEntity,
                     (unsigned Tag, Metadata *Scope, Metadata *Entity,
                      Metadata *File, unsigned Line, MDString *Name,
                      Metadata *Elements = nullptr),
                     (Tag, Scope, Entity, File, Line, Name, Elements))
 
   TempDIImportedEntity clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
-  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
-  DINode *getEntity() const { return cast_or_null<DINode>(getRawEntity()); }
+  DIScope *getScope() const { return cast_if_present<DIScope>(getRawScope()); }
+  DINode *getEntity() const { return cast_if_present<DINode>(getRawEntity()); }
   StringRef getName() const { return getStringOperand(2); }
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
   DINodeArray getElements() const {
-    return cast_or_null<MDTuple>(getRawElements());
+    return cast_if_present<MDTuple>(getRawElements());
   }
 
   Metadata *getRawScope() const { return getOperand(0); }
   Metadata *getRawEntity() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   Metadata *getRawFile() const { return getOperand(3); }
   Metadata *getRawElements() const { return getOperand(4); }
 
DEFINE_MDNODE_GET(DIGlobalVariableExpression,
                     (Metadata * Variable, Metadata *Expression),
                     (Variable, Expression))
 
   TempDIGlobalVariableExpression clone() const { return cloneImpl(); }
 
   Metadata *getRawVariable() const { return getOperand(0); }
 
   DIGlobalVariable *getVariable() const {
-    return cast_or_null<DIGlobalVariable>(getRawVariable());
+    return cast_if_present<DIGlobalVariable>(getRawVariable());
   }
 
   Metadata *getRawExpression() const { return getOperand(1); }
 
   DIExpression *getExpression() const {
     return cast<DIExpression>(getRawExpression());
   }
 
DIMacroNode(LLVMContext &C, unsigned ID, StorageType Storage, unsigned MIType,
               ArrayRef<Metadata *> Ops1, ArrayRef<Metadata *> Ops2 = None)
       : MDNode(C, ID, Storage, Ops1, Ops2) {
     assert(MIType < 1u << 16);
     SubclassData16 = MIType;
   }
   ~DIMacroNode() = default;
 
   template <class Ty> Ty *getOperandAs(unsigned I) const {
-    return cast_or_null<Ty>(getOperand(I));
+    return cast_if_present<Ty>(getOperand(I));
   }
 
   StringRef getStringOperand(unsigned I) const {
     if (auto *S = getOperandAs<MDString>(I))
       return S->getString();
     return StringRef();
   }
 
#ifndef NDEBUG
     for (DIMacroNode *Op : getElements())
       assert(is_contained(Elements->operands(), Op) &&
              "Lost a macro node during macro node list replacement");
 #endif
     replaceOperandWith(1, Elements.get());
   }
 
   unsigned getLine() const { return Line; }
-  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIFile *getFile() const { return cast_if_present<DIFile>(getRawFile()); }
 
   DIMacroNodeArray getElements() const {
-    return cast_or_null<MDTuple>(getRawElements());
+    return cast_if_present<MDTuple>(getRawElements());
   }
 
   Metadata *getRawFile() const { return getOperand(0); }
   Metadata *getRawElements() const { return getOperand(1); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIMacroFileKind;
   }

llvm/include/llvm/IR/Instructions.h

void setCondition(Value *V) {
     assert(isConditional() && "Cannot set condition of unconditional branch!");
     Op<-3>() = V;
   }
 
   unsigned getNumSuccessors() const { return 1+isConditional(); }
 
   BasicBlock *getSuccessor(unsigned i) const {
     assert(i < getNumSuccessors() && "Successor # out of range for Branch!");
-    return cast_or_null<BasicBlock>((&Op<-1>() - i)->get());
+    return cast_if_present<BasicBlock>((&Op<-1>() - i)->get());
   }
 
   void setSuccessor(unsigned idx, BasicBlock *NewSucc) {
     assert(idx < getNumSuccessors() && "Successor # out of range for Branch!");
     *(&Op<-1>() - idx) = NewSucc;
   }
 
   /// Swap the successors of this branch instruction.
Value *getIndirectDestLabelUse(unsigned i) const {
     return getOperandUse(i + arg_size() + getNumTotalBundleOperands() + 1);
   }
 
   // Return the destination basic blocks...
   BasicBlock *getDefaultDest() const {
     return cast<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() - 1));
   }
   BasicBlock *getIndirectDest(unsigned i) const {
-    return cast_or_null<BasicBlock>(*(&Op<-1>() - getNumIndirectDests() + i));
+    return cast_if_present<BasicBlock>(
+        *(&Op<-1>() - getNumIndirectDests() + i));
   }
   SmallVector<BasicBlock *, 16> getIndirectDests() const {
     SmallVector<BasicBlock *, 16> IndirectDests;
     for (unsigned i = 0, e = getNumIndirectDests(); i < e; ++i)
       IndirectDests.push_back(getIndirectDest(i));
     return IndirectDests;
   }
   void setDefaultDest(BasicBlock *B) {

llvm/include/llvm/IR/Metadata.h

public:
 
   static LocalAsMetadata *getLocal(Value *Local) {
     return cast<LocalAsMetadata>(get(Local));
   }
 
   static ValueAsMetadata *getIfExists(Value *V);
 
   static ConstantAsMetadata *getConstantIfExists(Value *C) {
-    return cast_or_null<ConstantAsMetadata>(getIfExists(C));
+    return cast_if_present<ConstantAsMetadata>(getIfExists(C));
   }
 
   static LocalAsMetadata *getLocalIfExists(Value *Local) {
-    return cast_or_null<LocalAsMetadata>(getIfExists(Local));
+    return cast_if_present<LocalAsMetadata>(getIfExists(Local));
   }
 
   Value *getValue() const { return V; }
   Type *getType() const { return V->getType(); }
   LLVMContext &getContext() const { return V->getContext(); }
 
   SmallVector<Metadata *> getAllArgListUsers() {
     return ReplaceableMetadataImpl::getAllArgListUsers();

 ///     MDNode *N = ...;
 ///     auto *CI = mdconst::dyn_extract<ConstantInt>(N->getOperand(2));
 /// \endcode
 ///
 /// The full set of provided functions includes:
 ///
 ///   mdconst::hasa                <=> isa
 ///   mdconst::extract             <=> cast
-///   mdconst::extract_or_null     <=> cast_or_null
+///   mdconst::extract_or_null     <=> cast_if_present
 ///   mdconst::dyn_extract         <=> dyn_cast
 ///   mdconst::dyn_extract_or_null <=> dyn_cast_if_present
 ///
 /// The target of the cast must be a subclass of \a Constant.
 namespace mdconst {
 
 namespace detail {
 

 template <class X, class Y>
 inline std::enable_if_t<detail::IsValidReference<X, Y &>::value, X *>
 extract(Y &MD) {
   return extract(&MD);
 }
 
 /// Extract a Value from Metadata, allowing null.
 ///
-/// As an analogue to \a cast_or_null(), extract the \a Value subclass \c X
+/// As an analogue to \a cast_if_present(), extract the \a Value subclass \c X
 /// from \c MD, allowing \c MD to be null.
 template <class X, class Y>
 inline std::enable_if_t<detail::IsValidPointer<X, Y>::value, X *>
 extract_or_null(Y &&MD) {
-  if (auto *V = cast_or_null<ConstantAsMetadata>(MD))
+  if (auto *V = cast_if_present<ConstantAsMetadata>(MD))
     return cast<X>(V->getValue());
   return nullptr;
 }
 
 /// Extract a Value from Metadata, if any.
 ///
 /// As an analogue to \a dyn_cast_if_present(), extract the \a Value subclass \c
 /// X from \c MD, return null if \c MD doesn't contain a \a Value or if the \a
public:
   using value_type = T *;
   using difference_type = std::ptrdiff_t;
   using pointer = void;
   using reference = T *;
 
   TypedMDOperandIterator() = default;
   explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}
 
-  T *operator*() const { return cast_or_null<T>(*I); }
+  T *operator*() const { return cast_if_present<T>(*I); }
 
   TypedMDOperandIterator &operator++() {
     ++I;
     return *this;
   }
 
   TypedMDOperandIterator operator++(int) {
     TypedMDOperandIterator Temp(*this);
public:
 
   MDTuple *get() const { return const_cast<MDTuple *>(N); }
   MDTuple *operator->() const { return get(); }
   MDTuple &operator*() const { return *get(); }
 
   // FIXME: Fix callers and remove condition on N.
   unsigned size() const { return N ? N->getNumOperands() : 0u; }
   bool empty() const { return N ? N->getNumOperands() == 0 : true; }
-  T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }
+  T *operator[](unsigned I) const {
+    return cast_if_present<T>(N->getOperand(I));
+  }
 
   // FIXME: Fix callers and remove condition on N.
   using iterator = TypedMDOperandIterator<T>;
 
   iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }
   iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
 };
 

llvm/include/llvm/IR/OperandTraits.h

 //===----------------------------------------------------------------------===//
 //                          FixedNumOperand Trait Class
 //===----------------------------------------------------------------------===//
 
 /// FixedNumOperandTraits - determine the allocation regime of the Use array
 /// when it is a prefix to the User object, and the number of Use objects is
 /// known at compile time.
 
-template <typename SubClass, unsigned ARITY>
-struct FixedNumOperandTraits {
-  static Use *op_begin(SubClass* U) {
+template <typename SubClass, unsigned ARITY> struct FixedNumOperandTraits {
+  static Use *op_begin(SubClass *U) {
     static_assert(
         !std::is_polymorphic<SubClass>::value,
         "adding virtual methods to subclasses of User breaks use lists");
-    return reinterpret_cast<Use*>(U) - ARITY;
+    return reinterpret_cast<Use *>(U) - ARITY;
   }
-  static Use *op_end(SubClass* U) {
-    return reinterpret_cast<Use*>(U);
-  }
-  static unsigned operands(const User*) {
-    return ARITY;
-  }
+  static Use *op_end(SubClass *U) { return reinterpret_cast<Use *>(U); }
+  static unsigned operands(const User *) { return ARITY; }
 };
 
 //===----------------------------------------------------------------------===//
 //                          OptionalOperand Trait Class
 //===----------------------------------------------------------------------===//
 
 /// OptionalOperandTraits - when the number of operands may change at runtime.
 /// Naturally it may only decrease, because the allocations may not change.
 
 template <typename SubClass, unsigned ARITY = 1>
 struct OptionalOperandTraits : public FixedNumOperandTraits<SubClass, ARITY> {
-  static unsigned operands(const User *U) {
-    return U->getNumOperands();
-  }
+  static unsigned operands(const User *U) { return U->getNumOperands(); }
 };
 
 //===----------------------------------------------------------------------===//
 //                          VariadicOperand Trait Class
 //===----------------------------------------------------------------------===//
 
 /// VariadicOperandTraits - determine the allocation regime of the Use array
 /// when it is a prefix to the User object, and the number of Use objects is
 /// only known at allocation time.
 
 template <typename SubClass, unsigned MINARITY = 0>
 struct VariadicOperandTraits {
-  static Use *op_begin(SubClass* U) {
+  static Use *op_begin(SubClass *U) {
     static_assert(
         !std::is_polymorphic<SubClass>::value,
         "adding virtual methods to subclasses of User breaks use lists");
-    return reinterpret_cast<Use*>(U) - static_cast<User*>(U)->getNumOperands();
-  }
-  static Use *op_end(SubClass* U) {
-    return reinterpret_cast<Use*>(U);
-  }
-  static unsigned operands(const User *U) {
-    return U->getNumOperands();
+    return reinterpret_cast<Use *>(U) -
+           static_cast<User *>(U)->getNumOperands();
   }
+  static Use *op_end(SubClass *U) { return reinterpret_cast<Use *>(U); }
+  static unsigned operands(const User *U) { return U->getNumOperands(); }
 };
 
 //===----------------------------------------------------------------------===//
 //                          HungoffOperand Trait Class
 //===----------------------------------------------------------------------===//
 
 /// HungoffOperandTraits - determine the allocation regime of the Use array
 /// when it is not a prefix to the User object, but allocated at an unrelated
 /// heap address.
 ///
 /// This is the traits class that is needed when the Use array must be
 /// resizable.
 
-template <unsigned MINARITY = 1>
-struct HungoffOperandTraits {
-  static Use *op_begin(User* U) {
-    return U->getOperandList();
-  }
-  static Use *op_end(User* U) {
+template <unsigned MINARITY = 1> struct HungoffOperandTraits {
+  static Use *op_begin(User *U) { return U->getOperandList(); }
+  static Use *op_end(User *U) {
     return U->getOperandList() + U->getNumOperands();
   }
-  static unsigned operands(const User *U) {
-    return U->getNumOperands();
-  }
+  static unsigned operands(const User *U) { return U->getNumOperands(); }
 };
 
 /// Macro for generating in-class operand accessor declarations.
 /// It should only be called in the public section of the interface.
 ///
-#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS) \
-  public: \
-  inline VALUECLASS *getOperand(unsigned) const; \
-  inline void setOperand(unsigned, VALUECLASS*); \
-  inline op_iterator op_begin(); \
-  inline const_op_iterator op_begin() const; \
-  inline op_iterator op_end(); \
-  inline const_op_iterator op_end() const; \
-  protected: \
-  template <int> inline Use &Op(); \
-  template <int> inline const Use &Op() const; \
-  public: \
+#define DECLARE_TRANSPARENT_OPERAND_ACCESSORS(VALUECLASS)                      \
+public:                                                                        \
+  inline VALUECLASS *getOperand(unsigned) const;                               \
+  inline void setOperand(unsigned, VALUECLASS *);                              \
+  inline op_iterator op_begin();                                               \
+  inline const_op_iterator op_begin() const;                                   \
+  inline op_iterator op_end();                                                 \
+  inline const_op_iterator op_end() const;                                     \
+                                                                               \
+protected:                                                                     \
+  template <int> inline Use &Op();                                             \
+  template <int> inline const Use &Op() const;                                 \
+                                                                               \
+public:                                                                        \
   inline unsigned getNumOperands() const
 
 /// Macro for generating out-of-class operand accessor definitions
-#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS) \
-CLASS::op_iterator CLASS::op_begin() { \
-  return OperandTraits<CLASS>::op_begin(this); \
-} \
-CLASS::const_op_iterator CLASS::op_begin() const { \
-  return OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this)); \
-} \
-CLASS::op_iterator CLASS::op_end() { \
-  return OperandTraits<CLASS>::op_end(this); \
-} \
-CLASS::const_op_iterator CLASS::op_end() const { \
-  return OperandTraits<CLASS>::op_end(const_cast<CLASS*>(this)); \
-} \
-VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const { \
-  assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
-         && "getOperand() out of range!"); \
-  return cast_or_null<VALUECLASS>( \
-    OperandTraits<CLASS>::op_begin(const_cast<CLASS*>(this))[i_nocapture].get()); \
-} \
-void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) { \
-  assert(i_nocapture < OperandTraits<CLASS>::operands(this) \
-         && "setOperand() out of range!"); \
-  OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture; \
-} \
-unsigned CLASS::getNumOperands() const { \
-  return OperandTraits<CLASS>::operands(this); \
-} \
-template <int Idx_nocapture> Use &CLASS::Op() { \
-  return this->OpFrom<Idx_nocapture>(this); \
-} \
-template <int Idx_nocapture> const Use &CLASS::Op() const { \
-  return this->OpFrom<Idx_nocapture>(this); \
+#define DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CLASS, VALUECLASS)                \
+  CLASS::op_iterator CLASS::op_begin() {                                       \
+    return OperandTraits<CLASS>::op_begin(this);                               \
+  }                                                                            \
+  CLASS::const_op_iterator CLASS::op_begin() const {                           \
+    return OperandTraits<CLASS>::op_begin(const_cast<CLASS *>(this));          \
+  }                                                                            \
+  CLASS::op_iterator CLASS::op_end() {                                         \
+    return OperandTraits<CLASS>::op_end(this);                                 \
+  }                                                                            \
+  CLASS::const_op_iterator CLASS::op_end() const {                             \
+    return OperandTraits<CLASS>::op_end(const_cast<CLASS *>(this));            \
+  }                                                                            \
+  VALUECLASS *CLASS::getOperand(unsigned i_nocapture) const {                  \
+    assert(i_nocapture < OperandTraits<CLASS>::operands(this) &&               \
+           "getOperand() out of range!");                                      \
+    return cast_if_present<VALUECLASS>(                                        \
+        OperandTraits<CLASS>::op_begin(const_cast<CLASS *>(this))[i_nocapture] \
+            .get());                                                           \
+  }                                                                            \
+  void CLASS::setOperand(unsigned i_nocapture, VALUECLASS *Val_nocapture) {    \
+    assert(i_nocapture < OperandTraits<CLASS>::operands(this) &&               \
+           "setOperand() out of range!");                                      \
+    OperandTraits<CLASS>::op_begin(this)[i_nocapture] = Val_nocapture;         \
+  }                                                                            \
+  unsigned CLASS::getNumOperands() const {                                     \
+    return OperandTraits<CLASS>::operands(this);                               \
+  }                                                                            \
+  template <int Idx_nocapture> Use &CLASS::Op() {                              \
+    return this->OpFrom<Idx_nocapture>(this);                                  \
+  }                                                                            \
+  template <int Idx_nocapture> const Use &CLASS::Op() const {                  \
+    return this->OpFrom<Idx_nocapture>(this);                                  \
   }
 
-
-} // End llvm namespace
+} // namespace llvm
 
 #endif

llvm/include/llvm/IR/ValueMap.h

class ValueMapCallbackVH final : public CallbackVH {
   ValueMapCallbackVH(KeyT Key, ValueMapT *Map)
       : CallbackVH(const_cast<Value*>(static_cast<const Value*>(Key))),
         Map(Map) {}
 
   // Private constructor used to create empty/tombstone DenseMap keys.
   ValueMapCallbackVH(Value *V) : CallbackVH(V), Map(nullptr) {}
 
 public:
-  KeyT Unwrap() const { return cast_or_null<KeySansPointerT>(getValPtr()); }
+  KeyT Unwrap() const { return cast_if_present<KeySansPointerT>(getValPtr()); }
 
   void deleted() override {
     // Make a copy that won't get changed even when *this is destroyed.
     ValueMapCallbackVH Copy(*this);
     typename Config::mutex_type *M = Config::getMutex(Copy.Map->Data);
     std::unique_lock<typename Config::mutex_type> Guard;
     if (M)
       Guard = std::unique_lock<typename Config::mutex_type>(*M);

llvm/include/llvm/Transforms/IPO/Attributor.h

struct AAValueConstantRange
 
   /// Return an assumed constant for the associated value a program point \p
   /// CtxI.
   Optional<Constant *>
   getAssumedConstant(Attributor &A, const Instruction *CtxI = nullptr) const {
     ConstantRange RangeV = getAssumedConstantRange(A, CtxI);
     if (auto *C = RangeV.getSingleElement()) {
       Type *Ty = getAssociatedValue().getType();
-      return cast_or_null<Constant>(
+      return cast_if_present<Constant>(
           AA::getWithType(*ConstantInt::get(Ty->getContext(), *C), *Ty));
     }
     if (RangeV.isEmptySet())
       return llvm::None;
     return nullptr;
   }
 
   /// See AbstractAttribute::getName()
struct AAPotentialConstantValues
 
   /// Return assumed constant for the associated value
   Optional<Constant *>
   getAssumedConstant(Attributor &A, const Instruction *CtxI = nullptr) const {
     if (!isValidState())
       return nullptr;
     if (getAssumedSet().size() == 1) {
       Type *Ty = getAssociatedValue().getType();
-      return cast_or_null<Constant>(AA::getWithType(
+      return cast_if_present<Constant>(AA::getWithType(
           *ConstantInt::get(Ty->getContext(), *(getAssumedSet().begin())),
           *Ty));
     }
     if (getAssumedSet().size() == 0) {
       if (undefIsContained())
         return UndefValue::get(getAssociatedValue().getType());
       return llvm::None;
     }

llvm/lib/Analysis/AssumeBundleQueries.cpp

llvm::getKnowledgeForValue(const Value *V,
                            function_ref<bool(RetainedKnowledge, Instruction *,
                                              const CallBase::BundleOpInfo *)>
                                Filter) {
   NumAssumeQueries++;
   if (!DebugCounter::shouldExecute(AssumeQueryCounter))
     return RetainedKnowledge::none();
   if (AC) {
     for (AssumptionCache::ResultElem &Elem : AC->assumptionsFor(V)) {
-      auto *II = cast_or_null<AssumeInst>(Elem.Assume);
+      auto *II = cast_if_present<AssumeInst>(Elem.Assume);
       if (!II || Elem.Index == AssumptionCache::ExprResultIdx)
         continue;
       if (RetainedKnowledge RK = getKnowledgeFromBundle(
               *II, II->bundle_op_info_begin()[Elem.Index])) {
         if (V != RK.WasOn)
           continue;
         if (is_contained(AttrKinds, RK.AttrKind) &&
             Filter(RK, II, &II->bundle_op_info_begin()[Elem.Index])) {

llvm/lib/Analysis/MemorySSAUpdater.cpp

if (auto *Defs = MSSA->getWritableBlockDefs(StartBlock)) {
       if (auto *MD = dyn_cast<MemoryDef>(FirstDef))
         FirstDef = MD->getDefiningAccess();
 
       MSSA->renamePass(MU->getBlock(), FirstDef, Visited);
     }
     // We just inserted a phi into this block, so the incoming value will
     // become the phi anyway, so it does not matter what we pass.
     for (auto &MP : InsertedPHIs)
-      if (MemoryPhi *Phi = cast_or_null<MemoryPhi>(MP))
+      if (MemoryPhi *Phi = cast_if_present<MemoryPhi>(MP))
         MSSA->renamePass(Phi->getBlock(), nullptr, Visited);
   }
 }
 
 // Set every incoming edge {BB, MP->getBlock()} of MemoryPhi MP to NewDef.
 static void setMemoryPhiValueForBlock(MemoryPhi *MP, const BasicBlock *BB,
                                       MemoryAccess *NewDef) {
   // Replace any operand with us an incoming block with the new defining
if (!DefBeforeSameBlock) {
     SmallPtrSet<BasicBlock *, 2> DefiningBlocks;
 
     // If this is the last Def in the block, we may need additional Phis.
     // Compute IDF in all cases, as renaming needs to be done even when MD is
     // not the last access, because it can introduce a new access past which a
     // previous access was optimized; that access needs to be reoptimized.
     DefiningBlocks.insert(MD->getBlock());
     for (const auto &VH : InsertedPHIs)
-      if (const auto *RealPHI = cast_or_null<MemoryPhi>(VH))
+      if (const auto *RealPHI = cast_if_present<MemoryPhi>(VH))
         DefiningBlocks.insert(RealPHI->getBlock());
     ForwardIDFCalculator IDFs(*MSSA->DT);
     SmallVector<BasicBlock *, 32> IDFBlocks;
     IDFs.setDefiningBlocks(DefiningBlocks);
     IDFs.calculate(IDFBlocks);
     SmallVector<AssertingVH<MemoryPhi>, 4> NewInsertedPHIs;
     for (auto *BBIDF : IDFBlocks) {
       auto *MPhi = MSSA->getMemoryAccess(BBIDF);
static MemoryAccess *getNewDefiningAccessForClone(MemoryAccess *MA,
                                                   bool CloneWasSimplified,
                                                   MemorySSA *MSSA) {
   MemoryAccess *InsnDefining = MA;
   if (MemoryDef *DefMUD = dyn_cast<MemoryDef>(InsnDefining)) {
     if (!MSSA->isLiveOnEntryDef(DefMUD)) {
       Instruction *DefMUDI = DefMUD->getMemoryInst();
       assert(DefMUDI && "Found MemoryUseOrDef with no Instruction.");
       if (Instruction *NewDefMUDI =
-              cast_or_null<Instruction>(VMap.lookup(DefMUDI))) {
+              cast_if_present<Instruction>(VMap.lookup(DefMUDI))) {
         InsnDefining = MSSA->getMemoryAccess(NewDefMUDI);
         if (!CloneWasSimplified)
           assert(InsnDefining && "Defining instruction cannot be nullptr.");
         else if (!InsnDefining || isa<MemoryUse>(InsnDefining)) {
           // The clone was simplified, it's no longer a MemoryDef, look up.
           auto DefIt = DefMUD->getDefsIterator();
           // Since simplified clones only occur in single block cloning, a
           // previous definition must exist, otherwise NewDefMUDI would not
auto FixPhiIncomingValues = [&](MemoryPhi *Phi, MemoryPhi *NewPhi) {
     assert(Phi && NewPhi && "Invalid Phi nodes.");
     BasicBlock *NewPhiBB = NewPhi->getBlock();
     SmallPtrSet<BasicBlock *, 4> NewPhiBBPreds(pred_begin(NewPhiBB),
                                                pred_end(NewPhiBB));
     for (unsigned It = 0, E = Phi->getNumIncomingValues(); It < E; ++It) {
       MemoryAccess *IncomingAccess = Phi->getIncomingValue(It);
       BasicBlock *IncBB = Phi->getIncomingBlock(It);
 
-      if (BasicBlock *NewIncBB = cast_or_null<BasicBlock>(VMap.lookup(IncBB)))
+      if (BasicBlock *NewIncBB =
+              cast_if_present<BasicBlock>(VMap.lookup(IncBB)))
         IncBB = NewIncBB;
       else if (IgnoreIncomingWithNoClones)
         continue;
 
       // Now we have IncBB, and will need to add incoming from it to NewPhi.
 
       // If IncBB is not a predecessor of NewPhiBB, then do not add it.
       // NewPhiBB was cloned without that edge.
       if (!NewPhiBBPreds.count(IncBB))
         continue;
 
       // Determine incoming value and add it as incoming from IncBB.
       if (MemoryUseOrDef *IncMUD = dyn_cast<MemoryUseOrDef>(IncomingAccess)) {
         if (!MSSA->isLiveOnEntryDef(IncMUD)) {
           Instruction *IncI = IncMUD->getMemoryInst();
           assert(IncI && "Found MemoryUseOrDef with no Instruction.");
           if (Instruction *NewIncI =
-                  cast_or_null<Instruction>(VMap.lookup(IncI))) {
+                  cast_if_present<Instruction>(VMap.lookup(IncI))) {
             IncMUD = MSSA->getMemoryAccess(NewIncI);
             assert(IncMUD &&
                    "MemoryUseOrDef cannot be null, all preds processed.");
           }
         }
         NewPhi->addIncoming(IncMUD, IncBB);
       } else {
         MemoryPhi *IncPhi = cast<MemoryPhi>(IncomingAccess);
         if (MemoryAccess *NewDefPhi = MPhiMap.lookup(IncPhi))
           NewPhi->addIncoming(NewDefPhi, IncBB);
         else
           NewPhi->addIncoming(IncPhi, IncBB);
       }
     }
     if (auto *SingleAccess = onlySingleValue(NewPhi)) {
       MPhiMap[Phi] = SingleAccess;
       removeMemoryAccess(NewPhi);
     }
   };
 
   auto ProcessBlock = [&](BasicBlock *BB) {
-    BasicBlock *NewBlock = cast_or_null<BasicBlock>(VMap.lookup(BB));
+    BasicBlock *NewBlock = cast_if_present<BasicBlock>(VMap.lookup(BB));
     if (!NewBlock)
       return;
 
     assert(!MSSA->getWritableBlockAccesses(NewBlock) &&
            "Cloned block should have no accesses");
 
     // Add MemoryPhi.
     if (MemoryPhi *MPhi = MSSA->getMemoryAccess(BB)) {

 template <typename Iter>
 void MemorySSAUpdater::privateUpdateExitBlocksForClonedLoop(
     ArrayRef<BasicBlock *> ExitBlocks, Iter ValuesBegin, Iter ValuesEnd,
     DominatorTree &DT) {
   SmallVector<CFGUpdate, 4> Updates;
   // Update/insert phis in all successors of exit blocks.
   for (auto *Exit : ExitBlocks)
     for (const ValueToValueMapTy *VMap : make_range(ValuesBegin, ValuesEnd))
-      if (BasicBlock *NewExit = cast_or_null<BasicBlock>(VMap->lookup(Exit))) {
+      if (BasicBlock *NewExit =
+              cast_if_present<BasicBlock>(VMap->lookup(Exit))) {
         BasicBlock *ExitSucc = NewExit->getTerminator()->getSuccessor(0);
         Updates.push_back({DT.Insert, NewExit, ExitSucc});
       }
   applyInsertUpdates(Updates, DT);
 }
 
 void MemorySSAUpdater::updateExitBlocksForClonedLoop(
     ArrayRef<BasicBlock *> ExitBlocks, const ValueToValueMapTy &VMap,
for (auto &BBPredPair : PredMap) {
     GetNoLongerDomBlocks(PrevIDom, NewIDom, BlocksWithDefsToReplace);
   }
 
   tryRemoveTrivialPhis(InsertedPhis);
   // Create the set of blocks that now have a definition. We'll use this to
   // compute IDF and add Phis there next.
   SmallVector<BasicBlock *, 8> BlocksToProcess;
   for (auto &VH : InsertedPhis)
-    if (auto *MPhi = cast_or_null<MemoryPhi>(VH))
+    if (auto *MPhi = cast_if_present<MemoryPhi>(VH))
       BlocksToProcess.push_back(MPhi->getBlock());
 
   // Compute IDF and add Phis in all IDF blocks that do not have one.
   SmallVector<BasicBlock *, 32> IDFBlocks;
   if (!BlocksToProcess.empty()) {
     ForwardIDFCalculator IDFs(DT, GD);
     SmallPtrSet<BasicBlock *, 16> DefiningBlocks(BlocksToProcess.begin(),
                                                  BlocksToProcess.end());
void MemorySSAUpdater::removeMemoryAccess(MemoryAccess *MA, bool OptimizePhis) {
   if (!PhisToCheck.empty()) {
     SmallVector<WeakVH, 16> PhisToOptimize{PhisToCheck.begin(),
                                            PhisToCheck.end()};
     PhisToCheck.clear();
 
     unsigned PhisSize = PhisToOptimize.size();
     while (PhisSize-- > 0)
       if (MemoryPhi *MP =
-              cast_or_null<MemoryPhi>(PhisToOptimize.pop_back_val()))
+              cast_if_present<MemoryPhi>(PhisToOptimize.pop_back_val()))
         tryRemoveTrivialPhi(MP);
   }
 }
 
 void MemorySSAUpdater::removeBlocks(
     const SmallSetVector<BasicBlock *, 8> &DeadBlocks) {
   // First delete all uses of BB in MemoryPhis.
   for (BasicBlock *BB : DeadBlocks) {
for (MemoryAccess &MA : llvm::make_early_inc_range(*Acc)) {
       MSSA->removeFromLookups(&MA);
       MSSA->removeFromLists(&MA);
     }
   }
 }
 
 void MemorySSAUpdater::tryRemoveTrivialPhis(ArrayRef<WeakVH> UpdatedPHIs) {
   for (const auto &VH : UpdatedPHIs)
-    if (auto *MPhi = cast_or_null<MemoryPhi>(VH))
+    if (auto *MPhi = cast_if_present<MemoryPhi>(VH))
       tryRemoveTrivialPhi(MPhi);
 }
 
 void MemorySSAUpdater::changeToUnreachable(const Instruction *I) {
   const BasicBlock *BB = I->getParent();
   // Remove memory accesses in BB for I and all following instructions.
   auto BBI = I->getIterator(), BBE = BB->end();
   // FIXME: If this becomes too expensive, iterate until the first instruction

llvm/lib/Analysis/TargetLibraryInfo.cpp

TargetLibraryInfo TargetLibraryAnalysis::run(const Function &F,
                                              FunctionAnalysisManager &) {
   if (!BaselineInfoImpl)
     BaselineInfoImpl =
         TargetLibraryInfoImpl(Triple(F.getParent()->getTargetTriple()));
   return TargetLibraryInfo(*BaselineInfoImpl, &F);
 }
 
 unsigned TargetLibraryInfoImpl::getWCharSize(const Module &M) const {
-  if (auto *ShortWChar = cast_or_null<ConstantAsMetadata>(
-      M.getModuleFlag("wchar_size")))
+  if (auto *ShortWChar =
+          cast_if_present<ConstantAsMetadata>(M.getModuleFlag("wchar_size")))
     return cast<ConstantInt>(ShortWChar->getValue())->getZExtValue();
   return 0;
 }
 
 TargetLibraryInfoWrapperPass::TargetLibraryInfoWrapperPass()
     : ImmutablePass(ID), TLA(TargetLibraryInfoImpl()) {
   initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 }

llvm/lib/AsmParser/LLParser.cpp

GlobalValue *LLParser::getGlobalVal(const std::string &Name, Type *Ty,
   PointerType *PTy = dyn_cast<PointerType>(Ty);
   if (!PTy) {
     error(Loc, "global variable reference must have pointer type");
     return nullptr;
   }
 
   // Look this name up in the normal function symbol table.
   GlobalValue *Val =
-    cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
+      cast_if_present<GlobalValue>(M->getValueSymbolTable().lookup(Name));
 
   // If this is a forward reference for the value, see if we already created a
   // forward ref record.
   if (!Val) {
     auto I = ForwardRefVals.find(Name);
     if (I != ForwardRefVals.end())
       Val = I->second.first;
   }
 
   // If we have the value in the symbol table or fwd-ref table, return it.
   if (Val)
-    return cast_or_null<GlobalValue>(
+    return cast_if_present<GlobalValue>(
         checkValidVariableType(Loc, "@" + Name, Ty, Val));
 
   // Otherwise, create a new forward reference for this value and remember it.
   GlobalValue *FwdVal = createGlobalFwdRef(M, PTy);
   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
   return FwdVal;
 }
 
GlobalValue *LLParser::getGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
   if (!Val) {
     auto I = ForwardRefValIDs.find(ID);
     if (I != ForwardRefValIDs.end())
       Val = I->second.first;
   }
 
   // If we have the value in the symbol table or fwd-ref table, return it.
   if (Val)
-    return cast_or_null<GlobalValue>(
+    return cast_if_present<GlobalValue>(
         checkValidVariableType(Loc, "@" + Twine(ID), Ty, Val));
 
   // Otherwise, create a new forward reference for this value and remember it.
   GlobalValue *FwdVal = createGlobalFwdRef(M, PTy);
   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
   return FwdVal;
 }
 

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

while (true) {
     case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N]
       if (Record.empty())
         return error("Invalid named struct record");
 
       if (NumRecords >= TypeList.size())
         return error("Invalid TYPE table");
 
       // Check to see if this was forward referenced, if so fill in the temp.
-      StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
+      StructType *Res = cast_if_present<StructType>(TypeList[NumRecords]);
       if (Res) {
         Res->setName(TypeName);
         TypeList[NumRecords] = nullptr;
       } else  // Otherwise, create a new struct.
         Res = createIdentifiedStructType(Context, TypeName);
       TypeName.clear();
 
       SmallVector<Type*, 8> EltTys;
while (true) {
     case bitc::TYPE_CODE_OPAQUE: {       // OPAQUE: []
       if (Record.size() != 1)
         return error("Invalid opaque type record");
 
       if (NumRecords >= TypeList.size())
         return error("Invalid TYPE table");
 
       // Check to see if this was forward referenced, if so fill in the temp.
-      StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]);
+      StructType *Res = cast_if_present<StructType>(TypeList[NumRecords]);
       if (Res) {
         Res->setName(TypeName);
         TypeList[NumRecords] = nullptr;
       } else  // Otherwise, create a new struct with no body.
         Res = createIdentifiedStructType(Context, TypeName);
       TypeName.clear();
       ResultTy = Res;
       break;

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

auto getMDOrNullWithoutPlaceholders = [&](unsigned ID) -> Metadata * {
     if (ID)
       return MetadataList.getMetadataFwdRef(ID - 1);
     return nullptr;
   };
   auto getMDString = [&](unsigned ID) -> MDString * {
     // This requires that the ID is not really a forward reference.  In
     // particular, the MDString must already have been resolved.
     auto MDS = getMDOrNull(ID);
-    return cast_or_null<MDString>(MDS);
+    return cast_if_present<MDString>(MDS);
   };
 
   // Support for old type refs.
   auto getDITypeRefOrNull = [&](unsigned ID) {
     return MetadataList.upgradeTypeRef(getMDOrNull(ID));
   };
 
 #define GET_OR_DISTINCT(CLASS, ARGS)                                           \

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 /// emitted and which provides correspondence to the source line list.
 static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col,
                              const MDNode *S, unsigned Flags, unsigned CUID,
                              uint16_t DwarfVersion,
                              ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) {
   StringRef Fn;
   unsigned FileNo = 1;
   unsigned Discriminator = 0;
-  if (auto *Scope = cast_or_null<DIScope>(S)) {
+  if (auto *Scope = cast_if_present<DIScope>(S)) {
     Fn = Scope->getFilename();
     if (Line != 0 && DwarfVersion >= 4)
       if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
         Discriminator = LBF->getDiscriminator();
 
     FileNo = static_cast<DwarfCompileUnit &>(*DCUs[CUID])
                  .getOrCreateSourceID(Scope->getFile());
   }

llvm/lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::eliminateFallThrough(Function &F) {
   // Use a temporary array to avoid iterator being invalidated when
   // deleting blocks.
   SmallVector<WeakTrackingVH, 16> Blocks;
   for (auto &Block : llvm::drop_begin(F))
     Blocks.push_back(&Block);
 
   SmallSet<WeakTrackingVH, 16> Preds;
   for (auto &Block : Blocks) {
-    auto *BB = cast_or_null<BasicBlock>(Block);
+    auto *BB = cast_if_present<BasicBlock>(Block);
     if (!BB)
       continue;
     // If the destination block has a single pred, then this is a trivial
     // edge, just collapse it.
     BasicBlock *SinglePred = BB->getSinglePredecessor();
 
     // Don't merge if BB's address is taken.
     if (!SinglePred || SinglePred == BB || BB->hasAddressTaken())
       continue;
 
     BranchInst *Term = dyn_cast<BranchInst>(SinglePred->getTerminator());
     if (Term && !Term->isConditional()) {
       Changed = true;
       LLVM_DEBUG(dbgs() << "To merge:\n" << *BB << "\n\n\n");
 
       // Merge BB into SinglePred and delete it.
       MergeBlockIntoPredecessor(BB);
       Preds.insert(SinglePred);
     }
   }
 
   // (Repeatedly) merging blocks into their predecessors can create redundant
   // debug intrinsics.
   for (const auto &Pred : Preds)
-    if (auto *BB = cast_or_null<BasicBlock>(Pred))
+    if (auto *BB = cast_if_present<BasicBlock>(Pred))
       RemoveRedundantDbgInstrs(BB);
 
   return Changed;
 }
 
 /// Find a destination block from BB if BB is mergeable empty block.
 BasicBlock *CodeGenPrepare::findDestBlockOfMergeableEmptyBlock(BasicBlock *BB) {
   // If this block doesn't end with an uncond branch, ignore it.
bool CodeGenPrepare::eliminateMostlyEmptyBlocks(Function &F) {
   // Copy blocks into a temporary array to avoid iterator invalidation issues
   // as we remove them.
   // Note that this intentionally skips the entry block.
   SmallVector<WeakTrackingVH, 16> Blocks;
   for (auto &Block : llvm::drop_begin(F))
     Blocks.push_back(&Block);
 
   for (auto &Block : Blocks) {
-    BasicBlock *BB = cast_or_null<BasicBlock>(Block);
+    BasicBlock *BB = cast_if_present<BasicBlock>(Block);
     if (!BB)
       continue;
     BasicBlock *DestBB = findDestBlockOfMergeableEmptyBlock(BB);
     if (!DestBB ||
         !isMergingEmptyBlockProfitable(BB, DestBB, Preheaders.count(BB)))
       continue;
 
     eliminateMostlyEmptyBlock(BB);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (!Result.second.getNode()) {
     // Since there's no actual continuation from this block, nothing can be
     // relying on us setting vregs for them.
     PendingExports.clear();
   } else {
     DAG.setRoot(Result.second);
   }
 
   if (EHPadBB) {
-    DAG.setRoot(lowerEndEH(getRoot(), cast_or_null<InvokeInst>(CLI.CB), EHPadBB,
-                           BeginLabel));
+    DAG.setRoot(lowerEndEH(getRoot(), cast_if_present<InvokeInst>(CLI.CB),
+                           EHPadBB, BeginLabel));
   }
 
   return Result;
 }
 
 void SelectionDAGBuilder::LowerCallTo(const CallBase &CB, SDValue Callee,
                                       bool isTailCall,
                                       bool isMustTailCall,

llvm/lib/IR/DIBuilder.cpp

 static DIImportedEntity *
 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context,
                      Metadata *NS, DIFile *File, unsigned Line, StringRef Name,
                      DINodeArray Elements,
                      SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
   if (Line)
     assert(File && "Source location has line number but no file");
   unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size();
-  auto *M = DIImportedEntity::get(C, Tag, Context, cast_or_null<DINode>(NS),
+  auto *M = DIImportedEntity::get(C, Tag, Context, cast_if_present<DINode>(NS),
                                   File, Line, Name, Elements);
   if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
     // A new Imported Entity was just added to the context.
     // Add it to the Imported Modules list.
     AllImportedModules.emplace_back(M);
   return M;
 }
 
DICompositeType *DIBuilder::createClassType(
     DIType *VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) {
   assert((!Context || isa<DIScope>(Context)) &&
          "createClassType should be called with a valid Context");
 
   auto *R = DICompositeType::get(
       VMContext, dwarf::DW_TAG_structure_type, Name, File, LineNumber,
       getNonCompileUnitScope(Context), DerivedFrom, SizeInBits, AlignInBits,
       OffsetInBits, Flags, Elements, 0, VTableHolder,
-      cast_or_null<MDTuple>(TemplateParams), UniqueIdentifier);
+      cast_if_present<MDTuple>(TemplateParams), UniqueIdentifier);
   trackIfUnresolved(R);
   return R;
 }
 
 DICompositeType *DIBuilder::createStructType(
     DIScope *Context, StringRef Name, DIFile *File, unsigned LineNumber,
     uint64_t SizeInBits, uint32_t AlignInBits, DINode::DIFlags Flags,
     DIType *DerivedFrom, DINodeArray Elements, unsigned RunTimeLang,

 DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, bool isDefined,
     DIExpression *Expr, MDNode *Decl, MDTuple *TemplateParams,
     uint32_t AlignInBits, DINodeArray Annotations) {
   checkGlobalVariableScope(Context);
 
   auto *GV = DIGlobalVariable::getDistinct(
-      VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
+      VMContext, cast_if_present<DIScope>(Context), Name, LinkageName, F,
       LineNumber, Ty, IsLocalToUnit, isDefined,
-      cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
+      cast_if_present<DIDerivedType>(Decl), TemplateParams, AlignInBits,
       Annotations);
   if (!Expr)
     Expr = createExpression();
   auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr);
   AllGVs.push_back(N);
   return N;
 }
 
 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, MDNode *Decl,
     MDTuple *TemplateParams, uint32_t AlignInBits) {
   checkGlobalVariableScope(Context);
 
   return DIGlobalVariable::getTemporary(
-             VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
+             VMContext, cast_if_present<DIScope>(Context), Name, LinkageName, F,
              LineNumber, Ty, IsLocalToUnit, false,
-             cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
+             cast_if_present<DIDerivedType>(Decl), TemplateParams, AlignInBits,
              nullptr)
       .release();
 }
 
 static DILocalVariable *createLocalVariable(
     LLVMContext &VMContext,
     DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 1>> &PreservedVariables,
     DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File,
     unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags,
     uint32_t AlignInBits, DINodeArray Annotations = nullptr) {
   // FIXME: Why getNonCompileUnitScope()?
   // FIXME: Why is "!Context" okay here?
   // FIXME: Why doesn't this check for a subprogram or lexical block (AFAICT
   // the only valid scopes)?
   DIScope *Context = getNonCompileUnitScope(Scope);
 
   auto *Node = DILocalVariable::get(
-      VMContext, cast_or_null<DILocalScope>(Context), Name, File, LineNo, Ty,
+      VMContext, cast_if_present<DILocalScope>(Context), Name, File, LineNo, Ty,
       ArgNo, Flags, AlignInBits, Annotations);
   if (AlwaysPreserve) {
     // The optimizer may remove local variables. If there is an interest
     // to preserve variable info in such situation then stash it in a
     // named mdnode.
     DISubprogram *Fn = getDISubprogram(Scope);
     assert(Fn && "Missing subprogram for local variable");
     PreservedVariables[Fn].emplace_back(Node);
return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo,
                              File, LineNo, Ty, AlwaysPreserve, Flags,
                              /*AlignInBits=*/0, Annotations);
 }
 
 DILabel *DIBuilder::createLabel(DIScope *Scope, StringRef Name, DIFile *File,
                                 unsigned LineNo, bool AlwaysPreserve) {
   DIScope *Context = getNonCompileUnitScope(Scope);
 
-  auto *Node = DILabel::get(VMContext, cast_or_null<DILocalScope>(Context),
+  auto *Node = DILabel::get(VMContext, cast_if_present<DILocalScope>(Context),
                             Name, File, LineNo);
 
   if (AlwaysPreserve) {
     /// The optimizer may remove labels. If there is an interest
     /// to preserve label info in such situation then append it to
     /// the list of retained nodes of the DISubprogram.
     DISubprogram *Fn = getDISubprogram(Scope);
     assert(Fn && "Missing subprogram for label");

llvm/lib/IR/DebugInfo.cpp

void DebugInfoFinder::reset() {
   Scopes.clear();
   NodesSeen.clear();
 }
 
 void DebugInfoFinder::processModule(const Module &M) {
   for (auto *CU : M.debug_compile_units())
     processCompileUnit(CU);
   for (auto &F : M.functions()) {
-    if (auto *SP = cast_or_null<DISubprogram>(F.getSubprogram()))
+    if (auto *SP = cast_if_present<DISubprogram>(F.getSubprogram()))
       processSubprogram(SP);
     // There could be subprograms from inlined functions referenced from
     // instructions only. Walk the function to find them.
     for (const BasicBlock &BB : F)
       for (const Instruction &I : BB)
         processInstruction(M, I);
   }
 }
public:
 
   /// Recursively remap N and all its referenced children. Does a DF post-order
   /// traversal, so as to remap bottoms up.
   void traverseAndRemap(MDNode *N) { traverse(N); }
 
 private:
   // Create a new DISubprogram, to replace the one given.
   DISubprogram *getReplacementSubprogram(DISubprogram *MDS) {
-    auto *FileAndScope = cast_or_null<DIFile>(map(MDS->getFile()));
+    auto *FileAndScope = cast_if_present<DIFile>(map(MDS->getFile()));
     StringRef LinkageName = MDS->getName().empty() ? MDS->getLinkageName() : "";
     DISubprogram *Declaration = nullptr;
-    auto *Type = cast_or_null<DISubroutineType>(map(MDS->getType()));
+    auto *Type = cast_if_present<DISubroutineType>(map(MDS->getType()));
     DIType *ContainingType =
-        cast_or_null<DIType>(map(MDS->getContainingType()));
-    auto *Unit = cast_or_null<DICompileUnit>(map(MDS->getUnit()));
+        cast_if_present<DIType>(map(MDS->getContainingType()));
+    auto *Unit = cast_if_present<DICompileUnit>(map(MDS->getUnit()));
     auto Variables = nullptr;
     auto TemplateParams = nullptr;
 
     // Make a distinct DISubprogram, for situations that warrent it.
     auto distinctMDSubprogram = [&]() {
       return DISubprogram::getDistinct(
           MDS->getContext(), FileAndScope, MDS->getName(), LinkageName,
           FileAndScope, MDS->getLine(), Type, MDS->getScopeLine(),
private:
   }
 
   /// Create a new compile unit, to replace the one given
   DICompileUnit *getReplacementCU(DICompileUnit *CU) {
     // Drop skeleton CUs.
     if (CU->getDWOId())
       return nullptr;
 
-    auto *File = cast_or_null<DIFile>(map(CU->getFile()));
+    auto *File = cast_if_present<DIFile>(map(CU->getFile()));
     MDTuple *EnumTypes = nullptr;
     MDTuple *RetainedTypes = nullptr;
     MDTuple *GlobalVariables = nullptr;
     MDTuple *ImportedEntities = nullptr;
     return DICompileUnit::getDistinct(
         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,

llvm/lib/IR/DebugInfoMetadata.cpp

DEFINE_GETIMPL_LOOKUP(DIStringType,
                          StringLocationExp, SizeInBits, AlignInBits, Encoding));
   Metadata *Ops[] = {nullptr,      nullptr,         Name,
                      StringLength, StringLengthExp, StringLocationExp};
   DEFINE_GETIMPL_STORE(DIStringType, (Tag, SizeInBits, AlignInBits, Encoding),
                        Ops);
 }
 DIType *DIDerivedType::getClassType() const {
   assert(getTag() == dwarf::DW_TAG_ptr_to_member_type);
-  return cast_or_null<DIType>(getExtraData());
+  return cast_if_present<DIType>(getExtraData());
 }
 uint32_t DIDerivedType::getVBPtrOffset() const {
   assert(getTag() == dwarf::DW_TAG_inheritance);
-  if (auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
+  if (auto *CM = cast_if_present<ConstantAsMetadata>(getExtraData()))
     if (auto *CI = dyn_cast_if_present<ConstantInt>(CM->getValue()))
       return static_cast<uint32_t>(CI->getZExtValue());
   return 0;
 }
 Constant *DIDerivedType::getStorageOffsetInBits() const {
   assert(getTag() == dwarf::DW_TAG_member && isBitField());
-  if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
+  if (auto *C = cast_if_present<ConstantAsMetadata>(getExtraData()))
     return C->getValue();
   return nullptr;
 }
 
 Constant *DIDerivedType::getConstant() const {
   assert(getTag() == dwarf::DW_TAG_member && isStaticMember());
-  if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
+  if (auto *C = cast_if_present<ConstantAsMetadata>(getExtraData()))
     return C->getValue();
   return nullptr;
 }
 Constant *DIDerivedType::getDiscriminantValue() const {
   assert(getTag() == dwarf::DW_TAG_member && !isStaticMember());
-  if (auto *C = cast_or_null<ConstantAsMetadata>(getExtraData()))
+  if (auto *C = cast_if_present<ConstantAsMetadata>(getExtraData()))
     return C->getValue();
   return nullptr;
 }
 
 DIDerivedType *DIDerivedType::getImpl(
     LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File,
     unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
     uint32_t AlignInBits, uint64_t OffsetInBits,
assert((!New || isa<ValueAsMetadata>(New)) &&
          "DIArgList must be passed a ValueAsMetadata");
   untrack();
   bool Uniq = isUniqued();
   if (Uniq) {
     // We need to update the uniqueness once the Args are updated since they
     // form the key to the DIArgLists store.
     eraseFromStore();
   }
-  ValueAsMetadata *NewVM = cast_or_null<ValueAsMetadata>(New);
+  ValueAsMetadata *NewVM = cast_if_present<ValueAsMetadata>(New);
   for (ValueAsMetadata *&VM : Args) {
     if (&VM == OldVMPtr) {
       if (NewVM)
         VM = NewVM;
       else
         VM = ValueAsMetadata::get(UndefValue::get(VM->getValue()->getType()));
     }
   }

llvm/lib/IR/DebugLoc.cpp

 
 //===----------------------------------------------------------------------===//
 // DebugLoc Implementation
 //===----------------------------------------------------------------------===//
 DebugLoc::DebugLoc(const DILocation *L) : Loc(const_cast<DILocation *>(L)) {}
 DebugLoc::DebugLoc(const MDNode *L) : Loc(const_cast<MDNode *>(L)) {}
 
 DILocation *DebugLoc::get() const {
-  return cast_or_null<DILocation>(Loc.get());
+  return cast_if_present<DILocation>(Loc.get());
 }
 
 unsigned DebugLoc::getLine() const {
   assert(get() && "Expected valid DebugLoc");
   return get()->getLine();
 }
 
 unsigned DebugLoc::getCol() const {

llvm/lib/IR/Metadata.cpp

 
 unsigned NamedMDNode::getNumOperands() const {
   return (unsigned)getNMDOps(Operands).size();
 }
 
 MDNode *NamedMDNode::getOperand(unsigned i) const {
   assert(i < getNumOperands() && "Invalid Operand number!");
   auto *N = getNMDOps(Operands)[i].get();
-  return cast_or_null<MDNode>(N);
+  return cast_if_present<MDNode>(N);
 }
 
 void NamedMDNode::addOperand(MDNode *M) { getNMDOps(Operands).emplace_back(M); }
 
 void NamedMDNode::setOperand(unsigned I, MDNode *New) {
   assert(I < getNumOperands() && "Invalid operand number");
   getNMDOps(Operands)[I].reset(New);
 }
GlobalObject::VCallVisibility GlobalObject::getVCallVisibility() const {
   return VCallVisibility::VCallVisibilityPublic;
 }
 
 void Function::setSubprogram(DISubprogram *SP) {
   setMetadata(LLVMContext::MD_dbg, SP);
 }
 
 DISubprogram *Function::getSubprogram() const {
-  return cast_or_null<DISubprogram>(getMetadata(LLVMContext::MD_dbg));
+  return cast_if_present<DISubprogram>(getMetadata(LLVMContext::MD_dbg));
 }
 
 bool Function::isDebugInfoForProfiling() const {
   if (DISubprogram *SP = getSubprogram()) {
     if (DICompileUnit *CU = SP->getUnit()) {
       return CU->getDebugInfoForProfiling();
     }
   }

llvm/lib/IR/Module.cpp

Module::createRNG(const StringRef Name) const {
   return std::unique_ptr<RandomNumberGenerator>(
       new RandomNumberGenerator(Salt));
 }
 
 /// getNamedValue - Return the first global value in the module with
 /// the specified name, of arbitrary type.  This method returns null
 /// if a global with the specified name is not found.
 GlobalValue *Module::getNamedValue(StringRef Name) const {
-  return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
+  return cast_if_present<GlobalValue>(getValueSymbolTable().lookup(Name));
 }
 
 unsigned Module::getNumNamedValues() const {
   return getValueSymbolTable().size();
 }
 
 /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
 /// This ID is uniqued across modules in the current LLVMContext.
void Module::dropAllReferences() {
   for (GlobalAlias &GA : aliases())
     GA.dropAllReferences();
 
   for (GlobalIFunc &GIF : ifuncs())
     GIF.dropAllReferences();
 }
 
 unsigned Module::getNumberRegisterParameters() const {
-  auto *Val =
-      cast_or_null<ConstantAsMetadata>(getModuleFlag("NumRegisterParameters"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(
+      getModuleFlag("NumRegisterParameters"));
   if (!Val)
     return 0;
   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
 
 unsigned Module::getDwarfVersion() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
+  auto *Val =
+      cast_if_present<ConstantAsMetadata>(getModuleFlag("Dwarf Version"));
   if (!Val)
     return 0;
   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
 
 bool Module::isDwarf64() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("DWARF64"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("DWARF64"));
   return Val && cast<ConstantInt>(Val->getValue())->isOne();
 }
 
 unsigned Module::getCodeViewFlag() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("CodeView"));
   if (!Val)
     return 0;
   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
 
 unsigned Module::getInstructionCount() const {
   unsigned NumInstrs = 0;
   for (const Function &F : FunctionList)
     NumInstrs += F.getInstructionCount();
   return NumInstrs;
 }
 
 Comdat *Module::getOrInsertComdat(StringRef Name) {
   auto &Entry = *ComdatSymTab.insert(std::make_pair(Name, Comdat())).first;
   Entry.second.Name = &Entry;
   return &Entry.second;
 }
 
 PICLevel::Level Module::getPICLevel() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIC Level"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("PIC Level"));
 
   if (!Val)
     return PICLevel::NotPIC;
 
   return static_cast<PICLevel::Level>(
       cast<ConstantInt>(Val->getValue())->getZExtValue());
 }
 
 void Module::setPICLevel(PICLevel::Level PL) {
   // The merge result of a non-PIC object and a PIC object can only be reliably
   // used as a non-PIC object, so use the Min merge behavior.
   addModuleFlag(ModFlagBehavior::Min, "PIC Level", PL);
 }
 
 PIELevel::Level Module::getPIELevel() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("PIE Level"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("PIE Level"));
 
   if (!Val)
     return PIELevel::Default;
 
   return static_cast<PIELevel::Level>(
       cast<ConstantInt>(Val->getValue())->getZExtValue());
 }
 
 void Module::setPIELevel(PIELevel::Level PL) {
   addModuleFlag(ModFlagBehavior::Max, "PIE Level", PL);
 }
 
 Optional<CodeModel::Model> Module::getCodeModel() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("Code Model"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("Code Model"));
 
   if (!Val)
     return None;
 
   return static_cast<CodeModel::Model>(
       cast<ConstantInt>(Val->getValue())->getZExtValue());
 }
 

 Metadata *Module::getProfileSummary(bool IsCS) const {
   return (IsCS ? getModuleFlag("CSProfileSummary")
                : getModuleFlag("ProfileSummary"));
 }
 
 bool Module::getSemanticInterposition() const {
   Metadata *MF = getModuleFlag("SemanticInterposition");
 
-  auto *Val = cast_or_null<ConstantAsMetadata>(MF);
+  auto *Val = cast_if_present<ConstantAsMetadata>(MF);
   if (!Val)
     return false;
 
   return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
 
 void Module::setSemanticInterposition(bool SI) {
   addModuleFlag(ModFlagBehavior::Error, "SemanticInterposition", SI);
 }
 
 void Module::setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB) {
   OwnedMemoryBuffer = std::move(MB);
 }
 
 bool Module::getRtLibUseGOT() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
+  auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("RtLibUseGOT"));
   return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
 }
 
 void Module::setRtLibUseGOT() {
   addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
 }
 
 UWTableKind Module::getUwtable() const {
-  if (auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("uwtable")))
+  if (auto *Val = cast_if_present<ConstantAsMetadata>(getModuleFlag("uwtable")))
     return UWTableKind(cast<ConstantInt>(Val->getValue())->getZExtValue());
   return UWTableKind::None;
 }
 
 void Module::setUwtable(UWTableKind Kind) {
   addModuleFlag(ModFlagBehavior::Max, "uwtable", uint32_t(Kind));
 }
 
 FramePointerKind Module::getFramePointer() const {
-  auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
+  auto *Val =
+      cast_if_present<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
   return static_cast<FramePointerKind>(
       Val ? cast<ConstantInt>(Val->getValue())->getZExtValue() : 0);
 }
 
 void Module::setFramePointer(FramePointerKind Kind) {
   addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
 }
 

llvm/lib/IR/SafepointIRVerifier.cpp

while (!NewDead.empty()) {
             NewDead.push_back(S);
     }
   }
 
   void addDeadEdge(const Use &DeadEdge) {
     if (!DeadEdges.insert(&DeadEdge))
       return;
 
-    BasicBlock *BB = cast_or_null<BasicBlock>(DeadEdge.get());
+    BasicBlock *BB = cast_if_present<BasicBlock>(DeadEdge.get());
     if (hasLiveIncomingEdges(BB))
       return;
 
     addDeadBlock(BB);
   }
 };
 } // namespace
 

llvm/lib/MC/ELFObjectWriter.cpp

static bool isIFunc(const MCSymbolELF *Symbol) {
   }
   return true;
 }
 
 void ELFWriter::writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
                             ELFSymbolData &MSD, const MCAsmLayout &Layout) {
   const auto &Symbol = cast<MCSymbolELF>(*MSD.Symbol);
   const MCSymbolELF *Base =
-      cast_or_null<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
+      cast_if_present<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
 
   // This has to be in sync with when computeSymbolTable uses SHN_ABS or
   // SHN_COMMON.
   bool IsReserved = !Base || Symbol.isCommon();
 
   // Binding and Type share the same byte as upper and lower nibbles
   uint8_t Binding = Symbol.getBinding();
   uint8_t Type = Symbol.getType();

llvm/lib/MC/MCParser/ELFAsmParser.cpp

else if (TypeName == "llvm_offloading")
       Type = ELF::SHT_LLVM_OFFLOADING;
     else if (TypeName.getAsInteger(0, Type))
       return TokError("unknown section type");
   }
 
   if (UseLastGroup) {
     MCSectionSubPair CurrentSection = getStreamer().getCurrentSection();
     if (const MCSectionELF *Section =
-            cast_or_null<MCSectionELF>(CurrentSection.first))
+            cast_if_present<MCSectionELF>(CurrentSection.first))
       if (const MCSymbol *Group = Section->getGroup()) {
         GroupName = Group->getName();
         IsComdat = Section->isComdat();
         Flags |= ELF::SHF_GROUP;
       }
   }
 
   MCSectionELF *Section =

llvm/lib/MC/WasmObjectWriter.cpp

if (Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB ||
       Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB64 ||
       Type == wasm::R_WASM_TABLE_INDEX_SLEB ||
       Type == wasm::R_WASM_TABLE_INDEX_SLEB64 ||
       Type == wasm::R_WASM_TABLE_INDEX_I32 ||
       Type == wasm::R_WASM_TABLE_INDEX_I64) {
     // TABLE_INDEX relocs implicitly use the default indirect function table.
     // We require the function table to have already been defined.
     auto TableName = "__indirect_function_table";
-    MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(TableName));
+    MCSymbolWasm *Sym =
+        cast_if_present<MCSymbolWasm>(Ctx.lookupSymbol(TableName));
     if (!Sym) {
       report_fatal_error("missing indirect function table symbol");
     } else {
       if (!Sym->isFunctionTable())
         report_fatal_error("__indirect_function_table symbol has wrong type");
       // Ensure that __indirect_function_table reaches the output.
       Sym->setNoStrip();
       Asm.registerSymbol(*Sym);

llvm/lib/Target/Hexagon/HexagonCommonGEP.cpp

static BasicBlock *nearest_common_dominator(DominatorTree *DT, T &Blocks) {
   });
 
   // Allow null basic blocks in Blocks.  In such cases, return nullptr.
   typename T::iterator I = Blocks.begin(), E = Blocks.end();
   if (I == E || !*I)
     return nullptr;
   BasicBlock *Dom = cast<BasicBlock>(*I);
   while (++I != E) {
-    BasicBlock *B = cast_or_null<BasicBlock>(*I);
+    BasicBlock *B = cast_if_present<BasicBlock>(*I);
     Dom = B ? DT->findNearestCommonDominator(Dom, B) : nullptr;
     if (!Dom)
       return nullptr;
     }
     LLVM_DEBUG(dbgs() << "computed:" << Dom->getName() << '\n');
     return Dom;
 }
 
BasicBlock *HexagonCommonGEP::adjustForInvariance(GepNode *Node,
   // Traverse the loop nest upwards until we find a loop in which Node
   // is no longer invariant, or until we get to the upper limit of Node's
   // placement. The traversal will also stop when a suitable "preheader"
   // cannot be found for a given loop. The "preheader" may actually be
   // a regular block outside of the loop (i.e. not guarded), in which case
   // the Node will be speculated.
   // For nodes that are not in the main path of the containing loop (i.e.
   // are not executed in each iteration), do not move them out of the loop.
-  BasicBlock *LocB = cast_or_null<BasicBlock>(Loc[Node]);
+  BasicBlock *LocB = cast_if_present<BasicBlock>(Loc[Node]);
   if (LocB) {
     Loop *Lp = LI->getLoopFor(LocB);
     while (Lp) {
       if (!isInvariantIn(Node, Lp) || !isInMainPath(LocB, Lp))
         break;
       BasicBlock *NewLoc = preheader(DT, Lp);
       if (!NewLoc || !DT->dominates(TopB, NewLoc))
         break;
struct LocationAsBlock {
     const NodeToValueMap &Map;
   };
 
   raw_ostream &operator<< (raw_ostream &OS,
                            const LocationAsBlock &Loc) LLVM_ATTRIBUTE_UNUSED ;
   raw_ostream &operator<< (raw_ostream &OS, const LocationAsBlock &Loc) {
     for (const auto &I : Loc.Map) {
       OS << I.first << " -> ";
-      if (BasicBlock *B = cast_or_null<BasicBlock>(I.second))
+      if (BasicBlock *B = cast_if_present<BasicBlock>(I.second))
         OS << B->getName() << '(' << B << ')';
       else
         OS << "<null-block>";
       OS << '\n';
     }
     return OS;
   }
 
do {
       LastUsed = (Last->Flags & GepNode::Used);
       if (LastUsed)
         break;
       NodeChildrenMap::iterator CF = NCM.find(Last);
       LastCN = (CF != NCM.end()) ? CF->second.size() : 0;
       if (LastCN != 1)
         break;
       GepNode *Child = CF->second.front();
-      BasicBlock *ChildB = cast_or_null<BasicBlock>(Loc[Child]);
+      BasicBlock *ChildB = cast_if_present<BasicBlock>(Loc[Child]);
       if (ChildB != nullptr && LastB != ChildB)
         break;
       Last = Child;
     } while (true);
 
     BasicBlock::iterator InsertAt = LastB->getTerminator()->getIterator();
     if (LastUsed || LastCN > 0) {
       ValueVect Urs;

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

 
 // Perhaps this should go somewhere common.
 static wasm::WasmLimits DefaultLimits() {
   return {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
 }
 
 static MCSymbolWasm *GetOrCreateFunctionTableSymbol(MCContext &Ctx,
                                                     const StringRef &Name) {
-  MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(Name));
+  MCSymbolWasm *Sym = cast_if_present<MCSymbolWasm>(Ctx.lookupSymbol(Name));
   if (Sym) {
     if (!Sym->isFunctionTable())
       Ctx.reportError(SMLoc(), "symbol is not a wasm funcref table");
   } else {
     Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(Name));
     Sym->setFunctionTable();
     // The default function table is synthesized by the linker.
     Sym->setUndefined();

llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp

const MachineOperand &WebAssembly::getCalleeOp(const MachineInstr &MI) {
   default:
     llvm_unreachable("Not a call instruction");
   }
 }
 
 MCSymbolWasm *WebAssembly::getOrCreateFunctionTableSymbol(
     MCContext &Ctx, const WebAssemblySubtarget *Subtarget) {
   StringRef Name = "__indirect_function_table";
-  MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(Name));
+  MCSymbolWasm *Sym = cast_if_present<MCSymbolWasm>(Ctx.lookupSymbol(Name));
   if (Sym) {
     if (!Sym->isFunctionTable())
       Ctx.reportError(SMLoc(), "symbol is not a wasm funcref table");
   } else {
     Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(Name));
     Sym->setFunctionTable();
     // The default function table is synthesized by the linker.
     Sym->setUndefined();
   }
   // MVP object files can't have symtab entries for tables.
   if (!(Subtarget && Subtarget->hasReferenceTypes()))
     Sym->setOmitFromLinkingSection();
   return Sym;
 }
 
 MCSymbolWasm *WebAssembly::getOrCreateFuncrefCallTableSymbol(
     MCContext &Ctx, const WebAssemblySubtarget *Subtarget) {
   StringRef Name = "__funcref_call_table";
-  MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(Name));
+  MCSymbolWasm *Sym = cast_if_present<MCSymbolWasm>(Ctx.lookupSymbol(Name));
   if (Sym) {
     if (!Sym->isFunctionTable())
       Ctx.reportError(SMLoc(), "symbol is not a wasm funcref table");
   } else {
     Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(Name));
 
     // Setting Weak ensure only one table is left after linking when multiple
     // modules define the table.

llvm/lib/Transforms/IPO/GlobalDCE.cpp

void GlobalDCEPass::MarkLive(GlobalValue &GV,
   }
 }
 
 void GlobalDCEPass::ScanVTables(Module &M) {
   SmallVector<MDNode *, 2> Types;
   LLVM_DEBUG(dbgs() << "Building type info -> vtable map\n");
 
   auto *LTOPostLinkMD =
-      cast_or_null<ConstantAsMetadata>(M.getModuleFlag("LTOPostLink"));
+      cast_if_present<ConstantAsMetadata>(M.getModuleFlag("LTOPostLink"));
   bool LTOPostLink =
       LTOPostLinkMD &&
       (cast<ConstantInt>(LTOPostLinkMD->getValue())->getZExtValue() != 0);
 
   for (GlobalVariable &GV : M.globals()) {
     Types.clear();
     GV.getMetadata(LLVMContext::MD_type, Types);
     if (GV.isDeclaration() || Types.empty())

llvm/lib/Transforms/InstCombine/InstCombineShifts.cpp

if (isa<Constant>(Op0))
     if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
       if (Instruction *R = FoldOpIntoSelect(I, SI))
         return R;
 
   if (Constant *CUI = dyn_cast<Constant>(Op1))
     if (Instruction *Res = FoldShiftByConstant(Op0, CUI, I))
       return Res;
 
-  if (auto *NewShift = cast_or_null<Instruction>(
+  if (auto *NewShift = cast_if_present<Instruction>(
           reassociateShiftAmtsOfTwoSameDirectionShifts(&I, SQ)))
     return NewShift;
 
   // Pre-shift a constant shifted by a variable amount with constant offset:
   // C shift (A add nuw C1) --> (C shift C1) shift A
   Value *A;
   Constant *C, *C1;
   if (match(Op0, m_Constant(C)) &&

llvm/lib/Transforms/Scalar/FlattenCFGPass.cpp

for (auto &BB : F)
     Blocks.push_back(&BB);
 
   while (LocalChange) {
     LocalChange = false;
 
     // Loop over all of the basic blocks and try to flatten them.
     for (WeakVH &BlockHandle : Blocks) {
       // Skip blocks erased by FlattenCFG.
-      if (auto *BB = cast_or_null<BasicBlock>(BlockHandle))
+      if (auto *BB = cast_if_present<BasicBlock>(BlockHandle))
         if (FlattenCFG(BB, AA))
           LocalChange = true;
     }
     Changed |= LocalChange;
   }
   return Changed;
 }
 } // namespace

llvm/lib/Transforms/Scalar/InferAddressSpaces.cpp

bool InferAddressSpacesImpl::rewriteWithNewAddressSpaces(
   }
 
   if (ValueWithNewAddrSpace.empty())
     return false;
 
   // Fixes all the undef uses generated by cloneInstructionWithNewAddressSpace.
   for (const Use *UndefUse : UndefUsesToFix) {
     User *V = UndefUse->getUser();
-    User *NewV = cast_or_null<User>(ValueWithNewAddrSpace.lookup(V));
+    User *NewV = cast_if_present<User>(ValueWithNewAddrSpace.lookup(V));
     if (!NewV)
       continue;
 
     unsigned OperandNo = UndefUse->getOperandNo();
     assert(isa<UndefValue>(NewV->getOperand(OperandNo)));
     NewV->setOperand(OperandNo, ValueWithNewAddrSpace.lookup(UndefUse->get()));
   }
 

llvm/lib/Transforms/Scalar/LICM.cpp

 
 static void moveInstructionBefore(Instruction &I, Instruction &Dest,
                                   ICFLoopSafetyInfo &SafetyInfo,
                                   MemorySSAUpdater &MSSAU,
                                   ScalarEvolution *SE) {
   SafetyInfo.removeInstruction(&I);
   SafetyInfo.insertInstructionTo(&I, Dest.getParent());
   I.moveBefore(&Dest);
-  if (MemoryUseOrDef *OldMemAcc = cast_or_null<MemoryUseOrDef>(
+  if (MemoryUseOrDef *OldMemAcc = cast_if_present<MemoryUseOrDef>(
           MSSAU.getMemorySSA()->getMemoryAccess(&I)))
     MSSAU.moveToPlace(OldMemAcc, Dest.getParent(), MemorySSA::BeforeTerminator);
   if (SE)
     SE->forgetValue(&I);
 }
 
 static Instruction *sinkThroughTriviallyReplaceablePHI(
     PHINode *TPN, Instruction *I, LoopInfo *LI,

llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp

static bool mergeBlocksIntoPredecessors(Loop &L, DominatorTree &DT,
   DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
   // Copy blocks into a temporary array to avoid iterator invalidation issues
   // as we remove them.
   SmallVector<WeakTrackingVH, 16> Blocks(L.blocks());
 
   for (auto &Block : Blocks) {
     // Attempt to merge blocks in the trivial case. Don't modify blocks which
     // belong to other loops.
-    BasicBlock *Succ = cast_or_null<BasicBlock>(Block);
+    BasicBlock *Succ = cast_if_present<BasicBlock>(Block);
     if (!Succ)
       continue;
 
     BasicBlock *Pred = Succ->getSinglePredecessor();
     if (!Pred || !Pred->getSingleSuccessor() || LI.getLoopFor(Pred) != &L)
       continue;
 
     // Merge Succ into Pred and delete it.

llvm/lib/Transforms/Scalar/LoopSink.cpp

LLVM_DEBUG(dbgs() << "Sinking a clone of " << I << " To: " << N->getName()
                       << '\n');
     NumLoopSunkCloned++;
   }
   LLVM_DEBUG(dbgs() << "Sinking " << I << " To: " << MoveBB->getName() << '\n');
   NumLoopSunk++;
   I.moveBefore(&*MoveBB->getFirstInsertionPt());
 
   if (MSSAU)
-    if (MemoryUseOrDef *OldMemAcc = cast_or_null<MemoryUseOrDef>(
+    if (MemoryUseOrDef *OldMemAcc = cast_if_present<MemoryUseOrDef>(
             MSSAU->getMemorySSA()->getMemoryAccess(&I)))
       MSSAU->moveToPlace(OldMemAcc, MoveBB, MemorySSA::Beginning);
 
   return true;
 }
 
 /// Sinks instructions from loop's preheader to the loop body if the
 /// sum frequency of inserted copy is smaller than preheader's frequency.

llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp

Instruction *MemCpyOptPass::tryMergingIntoMemset(Instruction *StartInst,
   // after MemInsertPoint. It points to either LastMemDef or to the last user
   // before the insertion point of the memset, if there are any such users.
   MemoryUseOrDef *MemInsertPoint = nullptr;
   // Keeps track of the last MemoryDef between StartInst and the insertion point
   // for the new memset. This will become the defining access of the inserted
   // memsets.
   MemoryDef *LastMemDef = nullptr;
   for (++BI; !BI->isTerminator(); ++BI) {
-    auto *CurrentAcc = cast_or_null<MemoryUseOrDef>(
+    auto *CurrentAcc = cast_if_present<MemoryUseOrDef>(
         MSSAU->getMemorySSA()->getMemoryAccess(&*BI));
     if (CurrentAcc) {
       MemInsertPoint = CurrentAcc;
       if (auto *CurrentDef = dyn_cast<MemoryDef>(CurrentAcc))
         LastMemDef = CurrentDef;
     }
 
     // Calls that only access inaccessible memory do not block merging

llvm/lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

for (Instruction &I : *ClonedBB) {
         AC.registerAssumption(II);
     }
 
   // Update any PHI nodes in the cloned successors of the skipped blocks to not
   // have spurious incoming values.
   for (auto *LoopBB : L.blocks())
     if (SkipBlock(LoopBB))
       for (auto *SuccBB : successors(LoopBB))
-        if (auto *ClonedSuccBB = cast_or_null<BasicBlock>(VMap.lookup(SuccBB)))
+        if (auto *ClonedSuccBB =
+                cast_if_present<BasicBlock>(VMap.lookup(SuccBB)))
           for (PHINode &PN : ClonedSuccBB->phis())
             PN.removeIncomingValue(LoopBB, /*DeletePHIIfEmpty*/ false);
 
   // Remove the cloned parent as a predecessor of any successor we ended up
   // cloning other than the unswitched one.
   auto *ClonedParentBB = cast<BasicBlock>(VMap.lookup(ParentBB));
   for (auto *SuccBB : successors(ParentBB)) {
     if (SuccBB == UnswitchedSuccBB)
       continue;
 
-    auto *ClonedSuccBB = cast_or_null<BasicBlock>(VMap.lookup(SuccBB));
+    auto *ClonedSuccBB = cast_if_present<BasicBlock>(VMap.lookup(SuccBB));
     if (!ClonedSuccBB)
       continue;
 
     ClonedSuccBB->removePredecessor(ClonedParentBB,
                                     /*KeepOneInputPHIs*/ true);
   }
 
   // Replace the cloned branch with an unconditional branch to the cloned
static void buildClonedLoops(Loop &OrigL, ArrayRef<BasicBlock *> ExitBlocks,
   // accurate parent loop. If we only clone exits to some parent of the
   // original parent, we want to clone into that outer loop. We also keep track
   // of the loops that our cloned exit blocks participate in.
   Loop *ParentL = nullptr;
   SmallVector<BasicBlock *, 4> ClonedExitsInLoops;
   SmallDenseMap<BasicBlock *, Loop *, 16> ExitLoopMap;
   ClonedExitsInLoops.reserve(ExitBlocks.size());
   for (auto *ExitBB : ExitBlocks)
-    if (auto *ClonedExitBB = cast_or_null<BasicBlock>(VMap.lookup(ExitBB)))
+    if (auto *ClonedExitBB = cast_if_present<BasicBlock>(VMap.lookup(ExitBB)))
       if (Loop *ExitL = LI.getLoopFor(ExitBB)) {
         ExitLoopMap[ClonedExitBB] = ExitL;
         ClonedExitsInLoops.push_back(ClonedExitBB);
         if (!ParentL || (ParentL != ExitL && ParentL->contains(ExitL)))
           ParentL = ExitL;
       }
   assert((!ParentL || ParentL == OrigL.getParentLoop() ||
           ParentL->contains(OrigL.getParentLoop())) &&
          "The computed parent loop should always contain (or be) the parent of "
          "the original loop.");
 
   // We build the set of blocks dominated by the cloned header from the set of
   // cloned blocks out of the original loop. While not all of these will
   // necessarily be in the cloned loop, it is enough to establish that they
   // aren't in unreachable cycles, etc.
   SmallSetVector<BasicBlock *, 16> ClonedLoopBlocks;
   for (auto *BB : OrigL.blocks())
-    if (auto *ClonedBB = cast_or_null<BasicBlock>(VMap.lookup(BB)))
+    if (auto *ClonedBB = cast_if_present<BasicBlock>(VMap.lookup(BB)))
       ClonedLoopBlocks.insert(ClonedBB);
 
   // Rebuild the set of blocks that will end up in the cloned loop. We may have
   // skipped cloning some region of this loop which can in turn skip some of
   // the backedges so we have to rebuild the blocks in the loop based on the
   // backedges that remain after cloning.
   SmallVector<BasicBlock *, 16> Worklist;
   SmallPtrSet<BasicBlock *, 16> BlocksInClonedLoop;
if (!BlocksInClonedLoop.empty()) {
 
     ClonedL->reserveBlocks(BlocksInClonedLoop.size());
     // We don't want to just add the cloned loop blocks based on how we
     // discovered them. The original order of blocks was carefully built in
     // a way that doesn't rely on predecessor ordering. Rather than re-invent
     // that logic, we just re-walk the original blocks (and those of the child
     // loops) and filter them as we add them into the cloned loop.
     for (auto *BB : OrigL.blocks()) {
-      auto *ClonedBB = cast_or_null<BasicBlock>(VMap.lookup(BB));
+      auto *ClonedBB = cast_if_present<BasicBlock>(VMap.lookup(BB));
       if (!ClonedBB || !BlocksInClonedLoop.count(ClonedBB))
         continue;
 
       // Directly add the blocks that are only in this loop.
       if (LI.getLoopFor(BB) == &OrigL) {
         ClonedL->addBasicBlockToLoop(ClonedBB, LI);
         continue;
       }
 
       // We want to manually add it to this loop and parents.
       // Registering it with LoopInfo will happen when we clone the top
       // loop for this block.
       for (Loop *PL = ClonedL; PL; PL = PL->getParentLoop())
         PL->addBlockEntry(ClonedBB);
     }
 
     // Now add each child loop whose header remains within the cloned loop. All
     // of the blocks within the loop must satisfy the same constraints as the
     // header so once we pass the header checks we can just clone the entire
     // child loop nest.
     for (Loop *ChildL : OrigL) {
       auto *ClonedChildHeader =
-          cast_or_null<BasicBlock>(VMap.lookup(ChildL->getHeader()));
+          cast_if_present<BasicBlock>(VMap.lookup(ChildL->getHeader()));
       if (!ClonedChildHeader || !BlocksInClonedLoop.count(ClonedChildHeader))
         continue;
 
 #ifndef NDEBUG
       // We should never have a cloned child loop header but fail to have
       // all of the blocks for that child loop.
       for (auto *ChildLoopBB : ChildL->blocks())
         assert(BlocksInClonedLoop.count(
#ifndef NDEBUG
   }
 #endif
 
   // Now that all the blocks are placed into the correct containing loop in the
   // absence of child loops, find all the potentially cloned child loops and
   // clone them into whatever outer loop we placed their header into.
   for (Loop *ChildL : OrigL) {
     auto *ClonedChildHeader =
-        cast_or_null<BasicBlock>(VMap.lookup(ChildL->getHeader()));
+        cast_if_present<BasicBlock>(VMap.lookup(ChildL->getHeader()));
     if (!ClonedChildHeader || BlocksInClonedLoop.count(ClonedChildHeader))
       continue;
 
 #ifndef NDEBUG
     for (auto *ChildLoopBB : ChildL->blocks())
       assert(VMap.count(ChildLoopBB) &&
              "Cloned a child loop header but not all of that loops blocks!");
 #endif
 
     NonChildClonedLoops.push_back(cloneLoopNest(
         *ChildL, ExitLoopMap.lookup(ClonedChildHeader), VMap, LI));
   }
 }
 
 static void
 deleteDeadClonedBlocks(Loop &L, ArrayRef<BasicBlock *> ExitBlocks,
                        ArrayRef<std::unique_ptr<ValueToValueMapTy>> VMaps,
                        DominatorTree &DT, MemorySSAUpdater *MSSAU) {
   // Find all the dead clones, and remove them from their successors.
   SmallVector<BasicBlock *, 16> DeadBlocks;
   for (BasicBlock *BB : llvm::concat<BasicBlock *const>(L.blocks(), ExitBlocks))
     for (const auto &VMap : VMaps)
-      if (BasicBlock *ClonedBB = cast_or_null<BasicBlock>(VMap->lookup(BB)))
+      if (BasicBlock *ClonedBB = cast_if_present<BasicBlock>(VMap->lookup(BB)))
         if (!DT.isReachableFromEntry(ClonedBB)) {
           for (BasicBlock *SuccBB : successors(ClonedBB))
             SuccBB->removePredecessor(ClonedBB);
           DeadBlocks.push_back(ClonedBB);
         }
 
   // Remove all MemorySSA in the dead blocks
   if (MSSAU) {

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

if (PredecessorWithTwoSuccessors) {
     // Delete the unconditional branch from the predecessor.
     PredBB->getInstList().pop_back();
 
     // Move terminator instruction.
     PredBB->getInstList().splice(PredBB->end(), BB->getInstList());
 
     // Terminator may be a memory accessing instruction too.
     if (MSSAU)
-      if (MemoryUseOrDef *MUD = cast_or_null<MemoryUseOrDef>(
+      if (MemoryUseOrDef *MUD = cast_if_present<MemoryUseOrDef>(
               MSSAU->getMemorySSA()->getMemoryAccess(PredBB->getTerminator())))
         MSSAU->moveToPlace(MUD, PredBB, MemorySSA::End);
   }
   // Add unreachable to now empty BB.
   new UnreachableInst(BB->getContext(), BB);
 
   // Inherit predecessors name if it exists.
   if (!PredBB->hasName())

llvm/lib/Transforms/Utils/CloneFunction.cpp

#endif
   // Loop over all of the basic blocks in the old function.  If the block was
   // reachable, we have cloned it and the old block is now in the value map:
   // insert it into the new function in the right order.  If not, ignore it.
   //
   // Defer PHI resolution until rest of function is resolved.
   SmallVector<const PHINode *, 16> PHIToResolve;
   for (const BasicBlock &BI : *OldFunc) {
     Value *V = VMap.lookup(&BI);
-    BasicBlock *NewBB = cast_or_null<BasicBlock>(V);
+    BasicBlock *NewBB = cast_if_present<BasicBlock>(V);
     if (!NewBB)
       continue; // Dead block.
 
     // Add the new block to the new function.
     NewFunc->getBasicBlockList().push_back(NewBB);
 
     // Handle PHI nodes specially, as we have to remove references to dead
     // blocks.
for (unsigned phino = 0, e = PHIToResolve.size(); phino != e;) {
     // that are dead.
     for (; phino != PHIToResolve.size() &&
            PHIToResolve[phino]->getParent() == OldBB;
          ++phino) {
       OPN = PHIToResolve[phino];
       PHINode *PN = cast<PHINode>(VMap[OPN]);
       for (unsigned pred = 0, e = NumPreds; pred != e; ++pred) {
         Value *V = VMap.lookup(PN->getIncomingBlock(pred));
-        if (BasicBlock *MappedBlock = cast_or_null<BasicBlock>(V)) {
+        if (BasicBlock *MappedBlock = cast_if_present<BasicBlock>(V)) {
           Value *InVal =
               MapValue(PN->getIncomingValue(pred), VMap,
                        ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges);
           assert(InVal && "Unknown input value?");
           PN->setIncomingValue(pred, InVal);
           PN->setIncomingBlock(pred, MappedBlock);
         } else {
           PN->removeIncomingValue(pred, false);

llvm/lib/Transforms/Utils/Local.cpp

 
 void llvm::RecursivelyDeleteTriviallyDeadInstructions(
     SmallVectorImpl<WeakTrackingVH> &DeadInsts, const TargetLibraryInfo *TLI,
     MemorySSAUpdater *MSSAU,
     std::function<void(Value *)> AboutToDeleteCallback) {
   // Process the dead instruction list until empty.
   while (!DeadInsts.empty()) {
     Value *V = DeadInsts.pop_back_val();
-    Instruction *I = cast_or_null<Instruction>(V);
+    Instruction *I = cast_if_present<Instruction>(V);
     if (!I)
       continue;
     assert(isInstructionTriviallyDead(I, TLI) &&
            "Live instruction found in dead worklist!");
     assert(I->use_empty() && "Instructions with uses are not dead.");
 
     // Don't lose the debug info while deleting the instructions.
     salvageDebugInfo(*I);

llvm/lib/Transforms/Utils/ModuleUtils.cpp

 static void appendToUsedList(Module &M, StringRef Name, ArrayRef<GlobalValue *> Values) {
   GlobalVariable *GV = M.getGlobalVariable(Name);
   SmallPtrSet<Constant *, 16> InitAsSet;
   SmallVector<Constant *, 16> Init;
   if (GV) {
     if (GV->hasInitializer()) {
       auto *CA = cast<ConstantArray>(GV->getInitializer());
       for (auto &Op : CA->operands()) {
-        Constant *C = cast_or_null<Constant>(Op);
+        Constant *C = cast_if_present<Constant>(Op);
         if (InitAsSet.insert(C).second)
           Init.push_back(C);
       }
     }
     GV->eraseFromParent();
   }
 
   Type *Int8PtrTy = llvm::Type::getInt8PtrTy(M.getContext());

llvm/lib/Transforms/Utils/ValueMapper.cpp

public:
 
   void remapGlobalObjectMetadata(GlobalObject &GO);
 
   Value *mapValue(const Value *V);
   void remapInstruction(Instruction *I);
   void remapFunction(Function &F);
 
   Constant *mapConstant(const Constant *C) {
-    return cast_or_null<Constant>(mapValue(C));
+    return cast_if_present<Constant>(mapValue(C));
   }
 
   /// Map metadata.
   ///
   /// Find the mapping for MD.  Guarantees that the return will be resolved
   /// (not an MDNode, or MDNode::isResolved() returns true).
   Metadata *mapMetadata(const Metadata *MD);
 
Value *Mapper::mapBlockAddress(const BlockAddress &BA) {
   // F may not have materialized its initializer.  In that case, create a
   // dummy basic block for now, and replace it once we've materialized all
   // the initializers.
   BasicBlock *BB;
   if (F->empty()) {
     DelayedBBs.push_back(DelayedBasicBlock(BA));
     BB = DelayedBBs.back().TempBB.get();
   } else {
-    BB = cast_or_null<BasicBlock>(mapValue(BA.getBasicBlock()));
+    BB = cast_if_present<BasicBlock>(mapValue(BA.getBasicBlock()));
   }
 
   return getVM()[&BA] = BlockAddress::get(F, BB ? BB : BA.getBasicBlock());
 }
 
 Metadata *Mapper::mapToMetadata(const Metadata *Key, Metadata *Val) {
   getVM().MD()[Key].reset(Val);
   return Val;
while (!Worklist.empty()) {
     }
   }
   CurrentMCID = 0;
 
   // Finish logic for block addresses now that all global values have been
   // handled.
   while (!DelayedBBs.empty()) {
     DelayedBasicBlock DBB = DelayedBBs.pop_back_val();
-    BasicBlock *BB = cast_or_null<BasicBlock>(mapValue(DBB.OldBB));
+    BasicBlock *BB = cast_if_present<BasicBlock>(mapValue(DBB.OldBB));
     DBB.TempBB->replaceAllUsesWith(BB ? BB : DBB.OldBB);
   }
 }
 
 void Mapper::remapInstruction(Instruction *I) {
   // Remap operands.
   for (Use &Op : I->operands()) {
     Value *V = mapValue(Op);
if (PHINode *PN = dyn_cast<PHINode>(I)) {
     }
   }
 
   // Remap attached metadata.
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
   I->getAllMetadata(MDs);
   for (const auto &MI : MDs) {
     MDNode *Old = MI.second;
-    MDNode *New = cast_or_null<MDNode>(mapMetadata(Old));
+    MDNode *New = cast_if_present<MDNode>(mapMetadata(Old));
     if (New != Old)
       I->setMetadata(MI.first, New);
   }
 
   if (!TypeMapper)
     return;
 
   // If the instruction's type is being remapped, do so now.
for (auto *V : NewMembers) {
     Constant *NewV;
     if (IsOldCtorDtor) {
       auto *S = cast<ConstantStruct>(V);
       auto *E1 = cast<Constant>(mapValue(S->getOperand(0)));
       auto *E2 = cast<Constant>(mapValue(S->getOperand(1)));
       Constant *Null = Constant::getNullValue(VoidPtrTy);
       NewV = ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null);
     } else {
-      NewV = cast_or_null<Constant>(mapValue(V));
+      NewV = cast_if_present<Constant>(mapValue(V));
     }
     Elements.push_back(NewV);
   }
 
   GV.setInitializer(
       ConstantArray::get(cast<ArrayType>(GV.getValueType()), Elements));
 }
 
void ValueMapper::addFlags(RemapFlags Flags) {
   FlushingMapper(pImpl)->addFlags(Flags);
 }
 
 Value *ValueMapper::mapValue(const Value &V) {
   return FlushingMapper(pImpl)->mapValue(&V);
 }
 
 Constant *ValueMapper::mapConstant(const Constant &C) {
-  return cast_or_null<Constant>(mapValue(C));
+  return cast_if_present<Constant>(mapValue(C));
 }
 
 Metadata *ValueMapper::mapMetadata(const Metadata &MD) {
   return FlushingMapper(pImpl)->mapMetadata(&MD);
 }
 
 MDNode *ValueMapper::mapMDNode(const MDNode &N) {
-  return cast_or_null<MDNode>(mapMetadata(N));
+  return cast_if_present<MDNode>(mapMetadata(N));
 }
 
 void ValueMapper::remapInstruction(Instruction &I) {
   FlushingMapper(pImpl)->remapInstruction(&I);
 }
 
 void ValueMapper::remapFunction(Function &F) {
   FlushingMapper(pImpl)->remapFunction(F);

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

VPBasicBlock *VPRecipeBuilder::handleReplication(
   // Find if I uses a predicated instruction. If so, it will use its scalar
   // value. Avoid hoisting the insert-element which packs the scalar value into
   // a vector value, as that happens iff all users use the vector value.
   for (VPValue *Op : Recipe->operands()) {
     auto *PredR = dyn_cast_if_present<VPPredInstPHIRecipe>(Op->getDef());
     if (!PredR)
       continue;
     auto *RepR =
-        cast_or_null<VPReplicateRecipe>(PredR->getOperand(0)->getDef());
+        cast_if_present<VPReplicateRecipe>(PredR->getOperand(0)->getDef());
     assert(RepR->isPredicated() &&
            "expected Replicate recipe to be predicated");
     RepR->setAlsoPack(false);
   }
 
   // Finalize the recipe for Instr, first if it is not predicated.
   if (!IsPredicated) {
     LLVM_DEBUG(dbgs() << "LV: Scalarizing:" << *I << "\n");

llvm/lib/Transforms/Vectorize/VPlanSLP.cpp

SmallVector<VPlanSlp::MultiNodeOpTy, 4> VPlanSlp::reorderMultiNodeOps() {
 
   return FinalOrder;
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 void VPlanSlp::dumpBundle(ArrayRef<VPValue *> Values) {
   dbgs() << " Ops: ";
   for (auto *Op : Values) {
-    if (auto *VPInstr = cast_or_null<VPInstruction>(Op))
+    if (auto *VPInstr = cast_if_present<VPInstruction>(Op))
       if (auto *Instr = VPInstr->getUnderlyingInstr()) {
         dbgs() << *Instr << " | ";
         continue;
       }
     dbgs() << " nullptr | ";
   }
   dbgs() << "\n";
 }

llvm/tools/opt/BreakpointPrinter.cpp

void getContextName(const DIScope *Context, std::string &N) {
     }
   }
 
   bool runOnModule(Module &M) override {
     StringSet<> Processed;
     if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
       for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
         std::string Name;
-        auto *SP = cast_or_null<DISubprogram>(NMD->getOperand(i));
+        auto *SP = cast_if_present<DISubprogram>(NMD->getOperand(i));
         if (!SP)
           continue;
         getContextName(SP->getScope(), Name);
         Name = Name + SP->getName().str();
         if (!Name.empty() && Processed.insert(Name).second) {
           Out << Name << "\n";
         }
       }

llvm/utils/TableGen/DAGISelMatcherOpt.cpp

#if 0
         NewOptionsToMatch[i]->dump();
       }
 #endif
       AllOpcodeChecks = false;
     }
 
     // Check to see if this breaks a series of CheckTypeMatcher's.
     if (AllTypeChecks) {
-      CheckTypeMatcher *CTM =
-        cast_or_null<CheckTypeMatcher>(FindNodeWithKind(NewOptionsToMatch[i],
-                                                        Matcher::CheckType));
+      CheckTypeMatcher *CTM = cast_if_present<CheckTypeMatcher>(
+          FindNodeWithKind(NewOptionsToMatch[i], Matcher::CheckType));
       if (!CTM ||
           // iPTR checks could alias any other case without us knowing, don't
           // bother with them.
           CTM->getType() == MVT::iPTR ||
           // SwitchType only works for result #0.
           CTM->getResNo() != 0 ||
           // If the CheckType isn't at the start of the list, see if we can move
           // it there.