diff options
Diffstat (limited to 'llvm/lib/IR/Verifier.cpp')
| -rw-r--r-- | llvm/lib/IR/Verifier.cpp | 206 |
1 files changed, 103 insertions, 103 deletions
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index afce3e2bf56..3ccc48e3ffd 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -305,11 +305,11 @@ private: template <class Ty> bool isValidMetadataArray(const MDTuple &N); #define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N); #include "llvm/IR/Metadata.def" - void visitMDScope(const MDScope &N); - void visitMDDerivedTypeBase(const MDDerivedTypeBase &N); - void visitMDVariable(const MDVariable &N); - void visitMDLexicalBlockBase(const MDLexicalBlockBase &N); - void visitMDTemplateParameter(const MDTemplateParameter &N); + void visitDIScope(const DIScope &N); + void visitDIDerivedTypeBase(const DIDerivedTypeBase &N); + void visitDIVariable(const DIVariable &N); + void visitDILexicalBlockBase(const DILexicalBlockBase &N); + void visitDITemplateParameter(const DITemplateParameter &N); void visitTemplateParams(const MDNode &N, const Metadata &RawParams); @@ -321,17 +321,17 @@ private: /// \brief Check for a valid type reference. /// - /// Checks for subclasses of \a MDType, or \a isValidUUID(). + /// Checks for subclasses of \a DIType, or \a isValidUUID(). bool isTypeRef(const MDNode &N, const Metadata *MD); /// \brief Check for a valid scope reference. /// - /// Checks for subclasses of \a MDScope, or \a isValidUUID(). + /// Checks for subclasses of \a DIScope, or \a isValidUUID(). bool isScopeRef(const MDNode &N, const Metadata *MD); /// \brief Check for a valid debug info reference. /// - /// Checks for subclasses of \a DebugNode, or \a isValidUUID(). + /// Checks for subclasses of \a DINode, or \a isValidUUID(). bool isDIRef(const MDNode &N, const Metadata *MD); // InstVisitor overrides... @@ -605,7 +605,7 @@ void Verifier::visitNamedMDNode(const NamedMDNode &NMD) { MDNode *MD = NMD.getOperand(i); if (NMD.getName() == "llvm.dbg.cu") { - Assert(MD && isa<MDCompileUnit>(MD), "invalid compile unit", &NMD, MD); + Assert(MD && isa<DICompileUnit>(MD), "invalid compile unit", &NMD, MD); } if (!MD) @@ -711,17 +711,17 @@ bool Verifier::isValidUUID(const MDNode &N, const Metadata *MD) { /// \brief Check if a value can be a reference to a type. bool Verifier::isTypeRef(const MDNode &N, const Metadata *MD) { - return !MD || isValidUUID(N, MD) || isa<MDType>(MD); + return !MD || isValidUUID(N, MD) || isa<DIType>(MD); } /// \brief Check if a value can be a ScopeRef. bool Verifier::isScopeRef(const MDNode &N, const Metadata *MD) { - return !MD || isValidUUID(N, MD) || isa<MDScope>(MD); + return !MD || isValidUUID(N, MD) || isa<DIScope>(MD); } /// \brief Check if a value can be a debug info ref. bool Verifier::isDIRef(const MDNode &N, const Metadata *MD) { - return !MD || isValidUUID(N, MD) || isa<DebugNode>(MD); + return !MD || isValidUUID(N, MD) || isa<DINode>(MD); } template <class Ty> @@ -748,40 +748,40 @@ bool isValidMetadataNullArray(const MDTuple &N) { return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ true); } -void Verifier::visitMDLocation(const MDLocation &N) { - Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()), +void Verifier::visitDILocation(const DILocation &N) { + Assert(N.getRawScope() && isa<DILocalScope>(N.getRawScope()), "location requires a valid scope", &N, N.getRawScope()); if (auto *IA = N.getRawInlinedAt()) - Assert(isa<MDLocation>(IA), "inlined-at should be a location", &N, IA); + Assert(isa<DILocation>(IA), "inlined-at should be a location", &N, IA); } -void Verifier::visitGenericDebugNode(const GenericDebugNode &N) { +void Verifier::visitGenericDINode(const GenericDINode &N) { Assert(N.getTag(), "invalid tag", &N); } -void Verifier::visitMDScope(const MDScope &N) { +void Verifier::visitDIScope(const DIScope &N) { if (auto *F = N.getRawFile()) - Assert(isa<MDFile>(F), "invalid file", &N, F); + Assert(isa<DIFile>(F), "invalid file", &N, F); } -void Verifier::visitMDSubrange(const MDSubrange &N) { +void Verifier::visitDISubrange(const DISubrange &N) { Assert(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N); Assert(N.getCount() >= -1, "invalid subrange count", &N); } -void Verifier::visitMDEnumerator(const MDEnumerator &N) { +void Verifier::visitDIEnumerator(const DIEnumerator &N) { Assert(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N); } -void Verifier::visitMDBasicType(const MDBasicType &N) { +void Verifier::visitDIBasicType(const DIBasicType &N) { Assert(N.getTag() == dwarf::DW_TAG_base_type || N.getTag() == dwarf::DW_TAG_unspecified_type, "invalid tag", &N); } -void Verifier::visitMDDerivedTypeBase(const MDDerivedTypeBase &N) { +void Verifier::visitDIDerivedTypeBase(const DIDerivedTypeBase &N) { // Common scope checks. - visitMDScope(N); + visitDIScope(N); Assert(isScopeRef(N, N.getScope()), "invalid scope", &N, N.getScope()); Assert(isTypeRef(N, N.getBaseType()), "invalid base type", &N, @@ -808,9 +808,9 @@ void Verifier::visitMDDerivedTypeBase(const MDDerivedTypeBase &N) { } } -void Verifier::visitMDDerivedType(const MDDerivedType &N) { +void Verifier::visitDIDerivedType(const DIDerivedType &N) { // Common derived type checks. - visitMDDerivedTypeBase(N); + visitDIDerivedTypeBase(N); Assert(N.getTag() == dwarf::DW_TAG_typedef || N.getTag() == dwarf::DW_TAG_pointer_type || @@ -831,22 +831,22 @@ void Verifier::visitMDDerivedType(const MDDerivedType &N) { } static bool hasConflictingReferenceFlags(unsigned Flags) { - return (Flags & DebugNode::FlagLValueReference) && - (Flags & DebugNode::FlagRValueReference); + return (Flags & DINode::FlagLValueReference) && + (Flags & DINode::FlagRValueReference); } void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) { auto *Params = dyn_cast<MDTuple>(&RawParams); Assert(Params, "invalid template params", &N, &RawParams); for (Metadata *Op : Params->operands()) { - Assert(Op && isa<MDTemplateParameter>(Op), "invalid template parameter", &N, + Assert(Op && isa<DITemplateParameter>(Op), "invalid template parameter", &N, Params, Op); } } -void Verifier::visitMDCompositeType(const MDCompositeType &N) { +void Verifier::visitDICompositeType(const DICompositeType &N) { // Common derived type checks. - visitMDDerivedTypeBase(N); + visitDIDerivedTypeBase(N); Assert(N.getTag() == dwarf::DW_TAG_array_type || N.getTag() == dwarf::DW_TAG_structure_type || @@ -868,7 +868,7 @@ void Verifier::visitMDCompositeType(const MDCompositeType &N) { visitTemplateParams(N, *Params); } -void Verifier::visitMDSubroutineType(const MDSubroutineType &N) { +void Verifier::visitDISubroutineType(const DISubroutineType &N) { Assert(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N); if (auto *Types = N.getRawTypeArray()) { Assert(isa<MDTuple>(Types), "invalid composite elements", &N, Types); @@ -880,24 +880,24 @@ void Verifier::visitMDSubroutineType(const MDSubroutineType &N) { &N); } -void Verifier::visitMDFile(const MDFile &N) { +void Verifier::visitDIFile(const DIFile &N) { Assert(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N); } -void Verifier::visitMDCompileUnit(const MDCompileUnit &N) { +void Verifier::visitDICompileUnit(const DICompileUnit &N) { Assert(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N); // Don't bother verifying the compilation directory or producer string // as those could be empty. - Assert(N.getRawFile() && isa<MDFile>(N.getRawFile()), - "invalid file", &N, N.getRawFile()); + Assert(N.getRawFile() && isa<DIFile>(N.getRawFile()), "invalid file", &N, + N.getRawFile()); Assert(!N.getFile()->getFilename().empty(), "invalid filename", &N, N.getFile()); if (auto *Array = N.getRawEnumTypes()) { Assert(isa<MDTuple>(Array), "invalid enum list", &N, Array); for (Metadata *Op : N.getEnumTypes()->operands()) { - auto *Enum = dyn_cast_or_null<MDCompositeType>(Op); + auto *Enum = dyn_cast_or_null<DICompositeType>(Op); Assert(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type, "invalid enum type", &N, N.getEnumTypes(), Op); } @@ -905,36 +905,36 @@ void Verifier::visitMDCompileUnit(const MDCompileUnit &N) { if (auto *Array = N.getRawRetainedTypes()) { Assert(isa<MDTuple>(Array), "invalid retained type list", &N, Array); for (Metadata *Op : N.getRetainedTypes()->operands()) { - Assert(Op && isa<MDType>(Op), "invalid retained type", &N, Op); + Assert(Op && isa<DIType>(Op), "invalid retained type", &N, Op); } } if (auto *Array = N.getRawSubprograms()) { Assert(isa<MDTuple>(Array), "invalid subprogram list", &N, Array); for (Metadata *Op : N.getSubprograms()->operands()) { - Assert(Op && isa<MDSubprogram>(Op), "invalid subprogram ref", &N, Op); + Assert(Op && isa<DISubprogram>(Op), "invalid subprogram ref", &N, Op); } } if (auto *Array = N.getRawGlobalVariables()) { Assert(isa<MDTuple>(Array), "invalid global variable list", &N, Array); for (Metadata *Op : N.getGlobalVariables()->operands()) { - Assert(Op && isa<MDGlobalVariable>(Op), "invalid global variable ref", &N, + Assert(Op && isa<DIGlobalVariable>(Op), "invalid global variable ref", &N, Op); } } if (auto *Array = N.getRawImportedEntities()) { Assert(isa<MDTuple>(Array), "invalid imported entity list", &N, Array); for (Metadata *Op : N.getImportedEntities()->operands()) { - Assert(Op && isa<MDImportedEntity>(Op), "invalid imported entity ref", &N, + Assert(Op && isa<DIImportedEntity>(Op), "invalid imported entity ref", &N, Op); } } } -void Verifier::visitMDSubprogram(const MDSubprogram &N) { +void Verifier::visitDISubprogram(const DISubprogram &N) { Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N); Assert(isScopeRef(N, N.getRawScope()), "invalid scope", &N, N.getRawScope()); if (auto *T = N.getRawType()) - Assert(isa<MDSubroutineType>(T), "invalid subroutine type", &N, T); + Assert(isa<DISubroutineType>(T), "invalid subroutine type", &N, T); Assert(isTypeRef(N, N.getRawContainingType()), "invalid containing type", &N, N.getRawContainingType()); if (auto *RawF = N.getRawFunction()) { @@ -947,14 +947,14 @@ void Verifier::visitMDSubprogram(const MDSubprogram &N) { if (auto *Params = N.getRawTemplateParams()) visitTemplateParams(N, *Params); if (auto *S = N.getRawDeclaration()) { - Assert(isa<MDSubprogram>(S) && !cast<MDSubprogram>(S)->isDefinition(), + Assert(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(), "invalid subprogram declaration", &N, S); } if (auto *RawVars = N.getRawVariables()) { auto *Vars = dyn_cast<MDTuple>(RawVars); Assert(Vars, "invalid variable list", &N, RawVars); for (Metadata *Op : Vars->operands()) { - Assert(Op && isa<MDLocalVariable>(Op), "invalid local variable", &N, Vars, + Assert(Op && isa<DILocalVariable>(Op), "invalid local variable", &N, Vars, Op); } } @@ -973,20 +973,20 @@ void Verifier::visitMDSubprogram(const MDSubprogram &N) { SmallPtrSet<const MDNode *, 32> Seen; for (auto &BB : *F) for (auto &I : BB) { - // Be careful about using MDLocation here since we might be dealing with + // Be careful about using DILocation here since we might be dealing with // broken code (this is the Verifier after all). - MDLocation *DL = - dyn_cast_or_null<MDLocation>(I.getDebugLoc().getAsMDNode()); + DILocation *DL = + dyn_cast_or_null<DILocation>(I.getDebugLoc().getAsMDNode()); if (!DL) continue; if (!Seen.insert(DL).second) continue; - MDLocalScope *Scope = DL->getInlinedAtScope(); + DILocalScope *Scope = DL->getInlinedAtScope(); if (Scope && !Seen.insert(Scope).second) continue; - MDSubprogram *SP = Scope ? Scope->getSubprogram() : nullptr; + DISubprogram *SP = Scope ? Scope->getSubprogram() : nullptr; if (SP && !Seen.insert(SP).second) continue; @@ -997,43 +997,43 @@ void Verifier::visitMDSubprogram(const MDSubprogram &N) { } } -void Verifier::visitMDLexicalBlockBase(const MDLexicalBlockBase &N) { +void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) { Assert(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N); - Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()), + Assert(N.getRawScope() && isa<DILocalScope>(N.getRawScope()), "invalid local scope", &N, N.getRawScope()); } -void Verifier::visitMDLexicalBlock(const MDLexicalBlock &N) { - visitMDLexicalBlockBase(N); +void Verifier::visitDILexicalBlock(const DILexicalBlock &N) { + visitDILexicalBlockBase(N); Assert(N.getLine() || !N.getColumn(), "cannot have column info without line info", &N); } -void Verifier::visitMDLexicalBlockFile(const MDLexicalBlockFile &N) { - visitMDLexicalBlockBase(N); +void Verifier::visitDILexicalBlockFile(const DILexicalBlockFile &N) { + visitDILexicalBlockBase(N); } -void Verifier::visitMDNamespace(const MDNamespace &N) { +void Verifier::visitDINamespace(const DINamespace &N) { Assert(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N); if (auto *S = N.getRawScope()) - Assert(isa<MDScope>(S), "invalid scope ref", &N, S); + Assert(isa<DIScope>(S), "invalid scope ref", &N, S); } -void Verifier::visitMDTemplateParameter(const MDTemplateParameter &N) { +void Verifier::visitDITemplateParameter(const DITemplateParameter &N) { Assert(isTypeRef(N, N.getType()), "invalid type ref", &N, N.getType()); } -void Verifier::visitMDTemplateTypeParameter(const MDTemplateTypeParameter &N) { - visitMDTemplateParameter(N); +void Verifier::visitDITemplateTypeParameter(const DITemplateTypeParameter &N) { + visitDITemplateParameter(N); Assert(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag", &N); } -void Verifier::visitMDTemplateValueParameter( - const MDTemplateValueParameter &N) { - visitMDTemplateParameter(N); +void Verifier::visitDITemplateValueParameter( + const DITemplateValueParameter &N) { + visitDITemplateParameter(N); Assert(N.getTag() == dwarf::DW_TAG_template_value_parameter || N.getTag() == dwarf::DW_TAG_GNU_template_template_param || @@ -1041,17 +1041,17 @@ void Verifier::visitMDTemplateValueParameter( "invalid tag", &N); } -void Verifier::visitMDVariable(const MDVariable &N) { +void Verifier::visitDIVariable(const DIVariable &N) { if (auto *S = N.getRawScope()) - Assert(isa<MDScope>(S), "invalid scope", &N, S); + Assert(isa<DIScope>(S), "invalid scope", &N, S); Assert(isTypeRef(N, N.getRawType()), "invalid type ref", &N, N.getRawType()); if (auto *F = N.getRawFile()) - Assert(isa<MDFile>(F), "invalid file", &N, F); + Assert(isa<DIFile>(F), "invalid file", &N, F); } -void Verifier::visitMDGlobalVariable(const MDGlobalVariable &N) { +void Verifier::visitDIGlobalVariable(const DIGlobalVariable &N) { // Checks common to all variables. - visitMDVariable(N); + visitDIVariable(N); Assert(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N); Assert(!N.getName().empty(), "missing global variable name", &N); @@ -1061,40 +1061,40 @@ void Verifier::visitMDGlobalVariable(const MDGlobalVariable &N) { "invalid global varaible ref", &N, V); } if (auto *Member = N.getRawStaticDataMemberDeclaration()) { - Assert(isa<MDDerivedType>(Member), "invalid static data member declaration", + Assert(isa<DIDerivedType>(Member), "invalid static data member declaration", &N, Member); } } -void Verifier::visitMDLocalVariable(const MDLocalVariable &N) { +void Verifier::visitDILocalVariable(const DILocalVariable &N) { // Checks common to all variables. - visitMDVariable(N); + visitDIVariable(N); Assert(N.getTag() == dwarf::DW_TAG_auto_variable || N.getTag() == dwarf::DW_TAG_arg_variable, "invalid tag", &N); - Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()), + Assert(N.getRawScope() && isa<DILocalScope>(N.getRawScope()), "local variable requires a valid scope", &N, N.getRawScope()); } -void Verifier::visitMDExpression(const MDExpression &N) { +void Verifier::visitDIExpression(const DIExpression &N) { Assert(N.isValid(), "invalid expression", &N); } -void Verifier::visitMDObjCProperty(const MDObjCProperty &N) { +void Verifier::visitDIObjCProperty(const DIObjCProperty &N) { Assert(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N); if (auto *T = N.getRawType()) - Assert(isa<MDType>(T), "invalid type ref", &N, T); + Assert(isa<DIType>(T), "invalid type ref", &N, T); if (auto *F = N.getRawFile()) - Assert(isa<MDFile>(F), "invalid file", &N, F); + Assert(isa<DIFile>(F), "invalid file", &N, F); } -void Verifier::visitMDImportedEntity(const MDImportedEntity &N) { +void Verifier::visitDIImportedEntity(const DIImportedEntity &N) { Assert(N.getTag() == dwarf::DW_TAG_imported_module || N.getTag() == dwarf::DW_TAG_imported_declaration, "invalid tag", &N); if (auto *S = N.getRawScope()) - Assert(isa<MDScope>(S), "invalid scope for imported entity", &N, S); + Assert(isa<DIScope>(S), "invalid scope for imported entity", &N, S); Assert(isDIRef(N, N.getEntity()), "invalid imported entity", &N, N.getEntity()); } @@ -2904,7 +2904,7 @@ void Verifier::visitInstruction(Instruction &I) { } if (MDNode *N = I.getDebugLoc().getAsMDNode()) { - Assert(isa<MDLocation>(N), "invalid !dbg metadata attachment", &I, N); + Assert(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N); visitMDNode(*N); } @@ -3373,18 +3373,18 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { /// /// This carefully grabs the subprogram from a local scope, avoiding the /// built-in assertions that would typically fire. -static MDSubprogram *getSubprogram(Metadata *LocalScope) { +static DISubprogram *getSubprogram(Metadata *LocalScope) { if (!LocalScope) return nullptr; - if (auto *SP = dyn_cast<MDSubprogram>(LocalScope)) + if (auto *SP = dyn_cast<DISubprogram>(LocalScope)) return SP; - if (auto *LB = dyn_cast<MDLexicalBlockBase>(LocalScope)) + if (auto *LB = dyn_cast<DILexicalBlockBase>(LocalScope)) return getSubprogram(LB->getRawScope()); // Just return null; broken scope chains are checked elsewhere. - assert(!isa<MDLocalScope>(LocalScope) && "Unknown type of local scope"); + assert(!isa<DILocalScope>(LocalScope) && "Unknown type of local scope"); return nullptr; } @@ -3394,29 +3394,29 @@ void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) { Assert(isa<ValueAsMetadata>(MD) || (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()), "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD); - Assert(isa<MDLocalVariable>(DII.getRawVariable()), + Assert(isa<DILocalVariable>(DII.getRawVariable()), "invalid llvm.dbg." + Kind + " intrinsic variable", &DII, DII.getRawVariable()); - Assert(isa<MDExpression>(DII.getRawExpression()), + Assert(isa<DIExpression>(DII.getRawExpression()), "invalid llvm.dbg." + Kind + " intrinsic expression", &DII, DII.getRawExpression()); // Ignore broken !dbg attachments; they're checked elsewhere. if (MDNode *N = DII.getDebugLoc().getAsMDNode()) - if (!isa<MDLocation>(N)) + if (!isa<DILocation>(N)) return; BasicBlock *BB = DII.getParent(); Function *F = BB ? BB->getParent() : nullptr; // The scopes for variables and !dbg attachments must agree. - MDLocalVariable *Var = DII.getVariable(); - MDLocation *Loc = DII.getDebugLoc(); + DILocalVariable *Var = DII.getVariable(); + DILocation *Loc = DII.getDebugLoc(); Assert(Loc, "llvm.dbg." + Kind + " intrinsic requires a !dbg attachment", &DII, BB, F); - MDSubprogram *VarSP = getSubprogram(Var->getRawScope()); - MDSubprogram *LocSP = getSubprogram(Loc->getRawScope()); + DISubprogram *VarSP = getSubprogram(Var->getRawScope()); + DISubprogram *LocSP = getSubprogram(Loc->getRawScope()); if (!VarSP || !LocSP) return; // Broken scope chains are checked elsewhere. @@ -3427,16 +3427,16 @@ void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) { } template <class MapTy> -static uint64_t getVariableSize(const MDLocalVariable &V, const MapTy &Map) { +static uint64_t getVariableSize(const DILocalVariable &V, const MapTy &Map) { // Be careful of broken types (checked elsewhere). const Metadata *RawType = V.getRawType(); while (RawType) { // Try to get the size directly. - if (auto *T = dyn_cast<MDType>(RawType)) + if (auto *T = dyn_cast<DIType>(RawType)) if (uint64_t Size = T->getSizeInBits()) return Size; - if (auto *DT = dyn_cast<MDDerivedType>(RawType)) { + if (auto *DT = dyn_cast<DIDerivedType>(RawType)) { // Look at the base type. RawType = DT->getRawBaseType(); continue; @@ -3459,15 +3459,15 @@ static uint64_t getVariableSize(const MDLocalVariable &V, const MapTy &Map) { template <class MapTy> void Verifier::verifyBitPieceExpression(const DbgInfoIntrinsic &I, const MapTy &TypeRefs) { - MDLocalVariable *V; - MDExpression *E; + DILocalVariable *V; + DIExpression *E; if (auto *DVI = dyn_cast<DbgValueInst>(&I)) { - V = dyn_cast_or_null<MDLocalVariable>(DVI->getRawVariable()); - E = dyn_cast_or_null<MDExpression>(DVI->getRawExpression()); + V = dyn_cast_or_null<DILocalVariable>(DVI->getRawVariable()); + E = dyn_cast_or_null<DIExpression>(DVI->getRawExpression()); } else { auto *DDI = cast<DbgDeclareInst>(&I); - V = dyn_cast_or_null<MDLocalVariable>(DDI->getRawVariable()); - E = dyn_cast_or_null<MDExpression>(DDI->getRawExpression()); + V = dyn_cast_or_null<DILocalVariable>(DDI->getRawVariable()); + E = dyn_cast_or_null<DIExpression>(DDI->getRawExpression()); } // We don't know whether this intrinsic verified correctly. @@ -3503,11 +3503,11 @@ void Verifier::verifyTypeRefs() { return; // Visit all the compile units again to map the type references. - SmallDenseMap<const MDString *, const MDType *, 32> TypeRefs; + SmallDenseMap<const MDString *, const DIType *, 32> TypeRefs; for (auto *CU : CUs->operands()) - if (auto Ts = cast<MDCompileUnit>(CU)->getRetainedTypes()) - for (MDType *Op : Ts) - if (auto *T = dyn_cast<MDCompositeType>(Op)) + if (auto Ts = cast<DICompileUnit>(CU)->getRetainedTypes()) + for (DIType *Op : Ts) + if (auto *T = dyn_cast<DICompositeType>(Op)) if (auto *S = T->getRawIdentifier()) { UnresolvedTypeRefs.erase(S); TypeRefs.insert(std::make_pair(S, T)); |
