From 1545953510c396585f6bcadf55357d050ae0a113 Mon Sep 17 00:00:00 2001 From: "Duncan P. N. Exon Smith" Date: Mon, 6 Apr 2015 23:18:49 +0000 Subject: [PATCH] IR: Stop using DIDescriptor::is*() and auto-casting `DIDescriptor`'s subclasses allow construction from incompatible pointers, and `DIDescriptor` defines a series of `isa<>`-like functions (e.g., `isCompileUnit()` instead of `isa()`) that clients tend to use like this: if (DICompileUnit(N).isCompileUnit()) foo(DICompileUnit(N)); These construction patterns work together to make `DIDescriptor` behave differently from normal pointers. Instead, use built-in `isa<>`, `dyn_cast<>`, etc., and only build `DIDescriptor`s from pointers that are valid for their type. I've split this into a few commits for different parts of LLVM and clang (to decrease the patch size and increase the chance of review). Generally the changes I made were NFC, but in a few places I made things stricter if it made sense from the surrounded code. Eventually a follow-up commit will remove the API for the "old" way. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@234255 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/DebugInfo.h | 4 +- lib/IR/DIBuilder.cpp | 67 ++++++-------- lib/IR/DebugInfo.cpp | 158 ++++++++++++++++----------------- lib/IR/DebugLoc.cpp | 12 +-- lib/Linker/LinkModules.cpp | 8 +- tools/opt/BreakpointPrinter.cpp | 10 +-- unittests/Transforms/Utils/Cloning.cpp | 38 ++++---- 7 files changed, 134 insertions(+), 163 deletions(-) diff --git a/include/llvm/IR/DebugInfo.h b/include/llvm/IR/DebugInfo.h index 1972526b340..11d3b74bbf8 100644 --- a/include/llvm/IR/DebugInfo.h +++ b/include/llvm/IR/DebugInfo.h @@ -408,7 +408,7 @@ public: bool isRValueReference() const { return (getFlags() & FlagRValueReference) != 0; } - bool isValid() const { return DbgNode && isType(); } + bool isValid() const { return DbgNode && isa(*this); } }; /// \brief A basic type, like 'int' or 'float'. @@ -507,7 +507,7 @@ public: } DIArray getElements() const { - assert(!isSubroutineType() && "no elements for DISubroutineType"); + assert(!isa(*this) && "no elements for DISubroutineType"); return DIArray(get()->getElements()); } diff --git a/lib/IR/DIBuilder.cpp b/lib/IR/DIBuilder.cpp index 35e0ffc8c0d..662b1dfe261 100644 --- a/lib/IR/DIBuilder.cpp +++ b/lib/IR/DIBuilder.cpp @@ -75,7 +75,7 @@ void DIBuilder::trackIfUnresolved(MDNode *N) { void DIBuilder::finalize() { DIArray Enums = getOrCreateArray(AllEnumTypes); - DIType(TempEnumTypes).replaceAllUsesWith(Enums); + TempEnumTypes->replaceAllUsesWith(Enums); SmallVector RetainValues; // Declarations and definitions of the same type may be retained. Some @@ -87,27 +87,27 @@ void DIBuilder::finalize() { if (RetainSet.insert(AllRetainTypes[I]).second) RetainValues.push_back(AllRetainTypes[I]); DIArray RetainTypes = getOrCreateArray(RetainValues); - DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes); + TempRetainTypes->replaceAllUsesWith(RetainTypes); DIArray SPs = getOrCreateArray(AllSubprograms); - DIType(TempSubprograms).replaceAllUsesWith(SPs); + TempSubprograms->replaceAllUsesWith(SPs); for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) { - DISubprogram SP(SPs.getElement(i)); + DISubprogram SP = cast(SPs.getElement(i)); if (MDNode *Temp = SP.getVariablesNodes()) { const auto &PV = PreservedVariables.lookup(SP); SmallVector Variables(PV.begin(), PV.end()); DIArray AV = getOrCreateArray(Variables); - DIType(Temp).replaceAllUsesWith(AV); + Temp->replaceAllUsesWith(AV); } } DIArray GVs = getOrCreateArray(AllGVs); - DIType(TempGVs).replaceAllUsesWith(GVs); + TempGVs->replaceAllUsesWith(GVs); SmallVector RetainValuesI(AllImportedModules.begin(), AllImportedModules.end()); DIArray IMs = getOrCreateArray(RetainValuesI); - DIType(TempImportedModules).replaceAllUsesWith(IMs); + TempImportedModules->replaceAllUsesWith(IMs); // Now that all temp nodes have been replaced or deleted, resolve remaining // cycles. @@ -151,7 +151,7 @@ DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename, // TODO: Switch to getDistinct(). We never want to merge compile units based // on contents. - MDNode *CUNode = MDCompileUnit::get( + MDCompileUnit *CUNode = MDCompileUnit::get( VMContext, Lang, MDFile::get(VMContext, Filename, Directory), Producer, isOptimized, Flags, RunTimeVer, SplitName, Kind, TempEnumTypes, TempRetainTypes, TempSubprograms, TempGVs, TempImportedModules); @@ -167,7 +167,7 @@ DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename, } trackIfUnresolved(CUNode); - return DICompileUnit(CUNode); + return CUNode; } static DIImportedEntity @@ -261,7 +261,7 @@ DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base, } DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) { - assert(RTy.isType() && "Unable to create reference type"); + assert(RTy && "Unable to create reference type"); return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr, MDTypeRef::get(RTy), 0, 0, 0, 0); } @@ -276,8 +276,8 @@ DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File, DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) { // typedefs are encoded in DIDerivedType format. - assert(Ty.isType() && "Invalid type!"); - assert(FriendTy.isType() && "Invalid friend type!"); + assert(Ty && "Invalid type!"); + assert(FriendTy && "Invalid friend type!"); return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0, MDTypeRef::get(Ty), MDTypeRef::get(FriendTy), 0, 0, 0, 0); @@ -286,7 +286,7 @@ DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) { DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy, uint64_t BaseOffset, unsigned Flags) { - assert(Ty.isType() && "Unable to create inheritance"); + assert(Ty && "Unable to create inheritance"); return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr, 0, MDTypeRef::get(Ty), MDTypeRef::get(BaseTy), 0, 0, BaseOffset, Flags); @@ -395,7 +395,7 @@ DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name, DIType VTableHolder, MDNode *TemplateParams, StringRef UniqueIdentifier) { - assert((!Context || Context.isScope() || Context.isType()) && + assert((!Context || isa(Context)) && "createClassType should be called with a valid Context"); // TAG_class_type is encoded in DICompositeType format. DICompositeType R = MDCompositeType::get( @@ -564,7 +564,7 @@ DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef Elements) { SmallVector Elts; for (unsigned i = 0, e = Elements.size(); i != e; ++i) { if (Elements[i] && isa(Elements[i])) - Elts.push_back(MDTypeRef::get(DIType(cast(Elements[i])))); + Elts.push_back(MDTypeRef::get(cast(Elements[i]))); else Elts.push_back(Elements[i]); } @@ -576,11 +576,10 @@ DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) { } static void checkGlobalVariableScope(DIDescriptor Context) { - MDNode *TheCtx = getNonCompileUnitScope(Context); - if (DIScope(TheCtx).isCompositeType()) { - assert(!DICompositeType(TheCtx).getIdentifier() && + if (DICompositeType CT = + dyn_cast_or_null(getNonCompileUnitScope(Context))) + assert(!CT.getIdentifier() && "Context of a global variable should not be a type with identifier"); - } } DIGlobalVariable DIBuilder::createGlobalVariable( @@ -618,9 +617,7 @@ DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope, // FIXME: Why is "!Context" okay here? // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT // the only valid scopes)? - DIDescriptor Context(getNonCompileUnitScope(Scope)); - assert((!Context || Context.isScope()) && - "createLocalVariable should be called with a valid Context"); + DIScope Context = getNonCompileUnitScope(Scope); auto *Node = MDLocalVariable::get( VMContext, Tag, cast_or_null(Context.get()), Name, File, @@ -723,19 +720,17 @@ DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name, "Methods should have both a Context and a context that isn't " "the compile unit."); // FIXME: Do we want to use different scope/lines? - auto *Node = MDSubprogram::get( - VMContext, MDScopeRef::get(DIScope(Context)), Name, LinkageName, F.get(), - LineNo, cast_or_null(Ty.get()), isLocalToUnit, + auto *SP = MDSubprogram::get( + VMContext, MDScopeRef::get(cast(Context)), Name, LinkageName, + F.get(), LineNo, cast_or_null(Ty.get()), isLocalToUnit, isDefinition, LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags, isOptimized, getConstantOrNull(Fn), cast_or_null(TParam), nullptr, nullptr); if (isDefinition) - AllSubprograms.push_back(Node); - DISubprogram S(Node); - assert(S.isSubprogram() && "createMethod should return a valid DISubprogram"); - trackIfUnresolved(S); - return S; + AllSubprograms.push_back(SP); + trackIfUnresolved(SP); + return SP; } DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name, @@ -767,8 +762,7 @@ static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) { Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo, DIExpression Expr, Instruction *InsertBefore) { - assert(VarInfo.isVariable() && - "empty or invalid DIVariable passed to dbg.declare"); + assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare"); if (!DeclareFn) DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare); @@ -783,8 +777,7 @@ Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo, Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo, DIExpression Expr, BasicBlock *InsertAtEnd) { - assert(VarInfo.isVariable() && - "empty or invalid DIVariable passed to dbg.declare"); + assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare"); if (!DeclareFn) DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare); @@ -807,8 +800,7 @@ Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset, DIExpression Expr, Instruction *InsertBefore) { assert(V && "no value passed to dbg.value"); - assert(VarInfo.isVariable() && - "empty or invalid DIVariable passed to dbg.value"); + assert(VarInfo && "empty or invalid DIVariable passed to dbg.value"); if (!ValueFn) ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value); @@ -826,8 +818,7 @@ Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset, DIExpression Expr, BasicBlock *InsertAtEnd) { assert(V && "no value passed to dbg.value"); - assert(VarInfo.isVariable() && - "empty or invalid DIVariable passed to dbg.value"); + assert(VarInfo && "empty or invalid DIVariable passed to dbg.value"); if (!ValueFn) ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value); diff --git a/lib/IR/DebugInfo.cpp b/lib/IR/DebugInfo.cpp index 721fbc8c3a0..b4364be9137 100644 --- a/lib/IR/DebugInfo.cpp +++ b/lib/IR/DebugInfo.cpp @@ -100,8 +100,8 @@ unsigned DIVariable::getSizeInBits(const DITypeIdentifierMap &Map) { DIType Ty = getType().resolve(Map); // Follow derived types until we reach a type that // reports back a size. - while (Ty.isDerivedType() && !Ty.getSizeInBits()) { - DIDerivedType DT(&*Ty); + while (isa(Ty) && !Ty.getSizeInBits()) { + DIDerivedType DT = cast(Ty); Ty = DT.getTypeDerivedFrom().resolve(Map); } assert(Ty.getSizeInBits() && "type with size 0"); @@ -207,11 +207,12 @@ void DICompositeType::setContainingType(DICompositeType ContainingType) { bool DIVariable::isInlinedFnArgument(const Function *CurFn) { assert(CurFn && "Invalid function"); - if (!getContext().isSubprogram()) + DISubprogram SP = dyn_cast(getContext()); + if (!SP) return false; // This variable is not inlined function argument if its scope // does not describe current function. - return !DISubprogram(getContext()).describes(CurFn); + return !SP.describes(CurFn); } Function *DISubprogram::getFunction() const { @@ -238,35 +239,32 @@ GlobalVariable *DIGlobalVariable::getGlobal() const { } DIScopeRef DIScope::getContext() const { + if (DIType T = dyn_cast(*this)) + return T.getContext(); - if (isType()) - return DIType(DbgNode).getContext(); - - if (isSubprogram()) - return DIScopeRef(DISubprogram(DbgNode).getContext()); + if (DISubprogram SP = dyn_cast(*this)) + return DIScopeRef(SP.getContext()); - if (isLexicalBlock()) - return DIScopeRef(DILexicalBlock(DbgNode).getContext()); + if (DILexicalBlock LB = dyn_cast(*this)) + return DIScopeRef(LB.getContext()); - if (isLexicalBlockFile()) - return DIScopeRef(DILexicalBlockFile(DbgNode).getContext()); + if (DINameSpace NS = dyn_cast(*this)) + return DIScopeRef(NS.getContext()); - if (isNameSpace()) - return DIScopeRef(DINameSpace(DbgNode).getContext()); - - assert((isFile() || isCompileUnit()) && "Unhandled type of scope."); + assert((isa(*this) || isa(*this)) && + "Unhandled type of scope."); return DIScopeRef(nullptr); } StringRef DIScope::getName() const { - if (isType()) - return DIType(DbgNode).getName(); - if (isSubprogram()) - return DISubprogram(DbgNode).getName(); - if (isNameSpace()) - return DINameSpace(DbgNode).getName(); - assert((isLexicalBlock() || isLexicalBlockFile() || isFile() || - isCompileUnit()) && + if (DIType T = dyn_cast(*this)) + return T.getName(); + if (DISubprogram SP = dyn_cast(*this)) + return SP.getName(); + if (DINameSpace NS = dyn_cast(*this)) + return NS.getName(); + assert((isa(*this) || isa(*this) || + isa(*this)) && "Unhandled type of scope."); return StringRef(); } @@ -341,31 +339,31 @@ DISubprogram llvm::getDISubprogram(const Function *F) { } DICompositeType llvm::getDICompositeType(DIType T) { - if (T.isCompositeType()) - return DICompositeType(T); + if (auto *C = dyn_cast_or_null(T)) + return C; - if (T.isDerivedType()) { + if (auto *D = dyn_cast_or_null(T)) { // This function is currently used by dragonegg and dragonegg does // not generate identifier for types, so using an empty map to resolve // DerivedFrom should be fine. DITypeIdentifierMap EmptyMap; return getDICompositeType( - DIDerivedType(T).getTypeDerivedFrom().resolve(EmptyMap)); + DIDerivedType(D).getTypeDerivedFrom().resolve(EmptyMap)); } - return DICompositeType(); + return nullptr; } DITypeIdentifierMap llvm::generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes) { DITypeIdentifierMap Map; for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) { - DICompileUnit CU(CU_Nodes->getOperand(CUi)); + DICompileUnit CU = cast(CU_Nodes->getOperand(CUi)); DIArray Retain = CU.getRetainedTypes(); for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) { - if (!Retain.getElement(Ti).isCompositeType()) + if (!isa(Retain.getElement(Ti))) continue; - DICompositeType Ty(Retain.getElement(Ti)); + DICompositeType Ty = cast(Retain.getElement(Ti)); if (MDString *TypeId = Ty.getIdentifier()) { // Definition has priority over declaration. // Try to insert (TypeId, Ty) to Map. @@ -408,11 +406,11 @@ void DebugInfoFinder::processModule(const Module &M) { InitializeTypeMap(M); if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) { for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { - DICompileUnit CU(CU_Nodes->getOperand(i)); + DICompileUnit CU = cast(CU_Nodes->getOperand(i)); addCompileUnit(CU); DIArray GVs = CU.getGlobalVariables(); for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) { - DIGlobalVariable DIG(GVs.getElement(i)); + DIGlobalVariable DIG = cast(GVs.getElement(i)); if (addGlobalVariable(DIG)) { processScope(DIG.getContext()); processType(DIG.getType().resolve(TypeIdentifierMap)); @@ -420,25 +418,23 @@ void DebugInfoFinder::processModule(const Module &M) { } DIArray SPs = CU.getSubprograms(); for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) - processSubprogram(DISubprogram(SPs.getElement(i))); + processSubprogram(cast(SPs.getElement(i))); DIArray EnumTypes = CU.getEnumTypes(); for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) - processType(DIType(EnumTypes.getElement(i))); + processType(cast(EnumTypes.getElement(i))); DIArray RetainedTypes = CU.getRetainedTypes(); for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) - processType(DIType(RetainedTypes.getElement(i))); + processType(cast(RetainedTypes.getElement(i))); DIArray Imports = CU.getImportedEntities(); for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) { - DIImportedEntity Import = DIImportedEntity(Imports.getElement(i)); - if (!Import) - continue; + DIImportedEntity Import = cast(Imports.getElement(i)); DIDescriptor Entity = Import.getEntity().resolve(TypeIdentifierMap); - if (Entity.isType()) - processType(DIType(Entity)); - else if (Entity.isSubprogram()) - processSubprogram(DISubprogram(Entity)); - else if (Entity.isNameSpace()) - processScope(DINameSpace(Entity).getContext()); + if (auto *T = dyn_cast(Entity)) + processType(T); + else if (auto *SP = dyn_cast(Entity)) + processSubprogram(SP); + else if (auto *NS = dyn_cast(Entity)) + processScope(NS->getScope()); } } } @@ -456,11 +452,10 @@ void DebugInfoFinder::processType(DIType DT) { if (!addType(DT)) return; processScope(DT.getContext().resolve(TypeIdentifierMap)); - if (DT.isCompositeType()) { - DICompositeType DCT(DT); + if (DICompositeType DCT = dyn_cast(DT)) { processType(DCT.getTypeDerivedFrom().resolve(TypeIdentifierMap)); - if (DT.isSubroutineType()) { - DITypeArray DTA = DISubroutineType(DT).getTypeArray(); + if (DISubroutineType ST = dyn_cast(DCT)) { + DITypeArray DTA = ST.getTypeArray(); for (unsigned i = 0, e = DTA.getNumElements(); i != e; ++i) processType(DTA.getElement(i).resolve(TypeIdentifierMap)); return; @@ -468,38 +463,36 @@ void DebugInfoFinder::processType(DIType DT) { DIArray DA = DCT.getElements(); for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) { DIDescriptor D = DA.getElement(i); - if (D.isType()) - processType(DIType(D)); - else if (D.isSubprogram()) - processSubprogram(DISubprogram(D)); + if (DIType T = dyn_cast(D)) + processType(T); + else if (DISubprogram SP = dyn_cast(D)) + processSubprogram(SP); } - } else if (DT.isDerivedType()) { - DIDerivedType DDT(DT); + } else if (DIDerivedType DDT = dyn_cast(DT)) { processType(DDT.getTypeDerivedFrom().resolve(TypeIdentifierMap)); } } void DebugInfoFinder::processScope(DIScope Scope) { - if (Scope.isType()) { - DIType Ty(Scope); + if (!Scope) + return; + if (DIType Ty = dyn_cast(Scope)) { processType(Ty); return; } - if (Scope.isCompileUnit()) { - addCompileUnit(DICompileUnit(Scope)); + if (DICompileUnit CU = dyn_cast(Scope)) { + addCompileUnit(CU); return; } - if (Scope.isSubprogram()) { - processSubprogram(DISubprogram(Scope)); + if (DISubprogram SP = dyn_cast(Scope)) { + processSubprogram(SP); return; } if (!addScope(Scope)) return; - if (Scope.isLexicalBlock()) { - DILexicalBlock LB(Scope); + if (DILexicalBlock LB = dyn_cast(Scope)) { processScope(LB.getContext()); - } else if (Scope.isNameSpace()) { - DINameSpace NS(Scope); + } else if (DINameSpace NS = dyn_cast(Scope)) { processScope(NS.getContext()); } } @@ -512,11 +505,11 @@ void DebugInfoFinder::processSubprogram(DISubprogram SP) { DIArray TParams = SP.getTemplateParams(); for (unsigned I = 0, E = TParams.getNumElements(); I != E; ++I) { DIDescriptor Element = TParams.getElement(I); - if (Element.isTemplateTypeParameter()) { - DITemplateTypeParameter TType(Element); + if (DITemplateTypeParameter TType = + dyn_cast(Element)) { processType(TType.getType().resolve(TypeIdentifierMap)); - } else if (Element.isTemplateValueParameter()) { - DITemplateValueParameter TVal(Element); + } else if (DITemplateValueParameter TVal = + dyn_cast(Element)) { processType(TVal.getType().resolve(TypeIdentifierMap)); } } @@ -529,14 +522,14 @@ void DebugInfoFinder::processDeclare(const Module &M, return; InitializeTypeMap(M); - DIDescriptor DV(N); - if (!DV.isVariable()) + DIVariable DV = dyn_cast(N); + if (!DV) return; if (!NodesSeen.insert(DV).second) return; - processScope(DIVariable(N).getContext()); - processType(DIVariable(N).getType().resolve(TypeIdentifierMap)); + processScope(DV.getContext()); + processType(DV.getType().resolve(TypeIdentifierMap)); } void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) { @@ -545,14 +538,14 @@ void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) { return; InitializeTypeMap(M); - DIDescriptor DV(N); - if (!DV.isVariable()) + DIVariable DV = dyn_cast(N); + if (!DV) return; if (!NodesSeen.insert(DV).second) return; - processScope(DIVariable(N).getContext()); - processType(DIVariable(N).getType().resolve(TypeIdentifierMap)); + processScope(DV.getContext()); + processType(DV.getType().resolve(TypeIdentifierMap)); } bool DebugInfoFinder::addType(DIType DT) { @@ -631,8 +624,7 @@ static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS, if (!DL) return; - DIScope Scope(DL.getScope()); - assert(Scope.isScope() && "Scope of a DebugLoc should be a DIScope."); + DIScope Scope = cast(DL.getScope()); // Omit the directory, because it's likely to be long and uninteresting. CommentOS << Scope.getFilename(); CommentOS << ':' << DL.getLine(); @@ -770,10 +762,10 @@ llvm::makeSubprogramMap(const Module &M) { return R; for (MDNode *N : CU_Nodes->operands()) { - DICompileUnit CUNode(N); + DICompileUnit CUNode = cast(N); DIArray SPs = CUNode.getSubprograms(); for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) { - DISubprogram SP(SPs.getElement(i)); + DISubprogram SP = cast(SPs.getElement(i)); if (Function *F = SP.getFunction()) R.insert(std::make_pair(F, SP)); } diff --git a/lib/IR/DebugLoc.cpp b/lib/IR/DebugLoc.cpp index 95f6d67c542..df4802d9549 100644 --- a/lib/IR/DebugLoc.cpp +++ b/lib/IR/DebugLoc.cpp @@ -50,8 +50,7 @@ MDNode *DebugLoc::getInlinedAtScope() const { DebugLoc DebugLoc::getFnDebugLoc() const { // FIXME: Add a method on \a MDLocation that does this work. const MDNode *Scope = getInlinedAtScope(); - DISubprogram SP = getDISubprogram(Scope); - if (SP.isSubprogram()) + if (DISubprogram SP = getDISubprogram(Scope)) return DebugLoc::get(SP.getScopeLineNumber(), 0, SP); return DebugLoc(); @@ -87,13 +86,8 @@ void DebugLoc::print(raw_ostream &OS) const { return; // Print source line info. - DIScope Scope(getScope()); - assert((!Scope || Scope.isScope()) && - "Scope of a DebugLoc should be null or a DIScope."); - if (Scope) - OS << Scope.getFilename(); - else - OS << ""; + DIScope Scope = cast(getScope()); + OS << Scope.getFilename(); OS << ':' << getLine(); if (getCol() != 0) OS << ':' << getCol(); diff --git a/lib/Linker/LinkModules.cpp b/lib/Linker/LinkModules.cpp index 21edc504080..75849db4999 100644 --- a/lib/Linker/LinkModules.cpp +++ b/lib/Linker/LinkModules.cpp @@ -1269,14 +1269,14 @@ void ModuleLinker::stripReplacedSubprograms() { if (!CompileUnits) return; for (unsigned I = 0, E = CompileUnits->getNumOperands(); I != E; ++I) { - DICompileUnit CU(CompileUnits->getOperand(I)); + DICompileUnit CU = cast(CompileUnits->getOperand(I)); assert(CU && "Expected valid compile unit"); - DITypedArray SPs(CU.getSubprograms()); + MDSubprogramArray SPs(CU.getSubprograms()); assert(SPs && "Expected valid subprogram array"); - for (unsigned S = 0, SE = SPs.getNumElements(); S != SE; ++S) { - DISubprogram SP = SPs.getElement(S); + for (unsigned S = 0, SE = SPs.size(); S != SE; ++S) { + DISubprogram SP = SPs[S]; if (!SP || !SP.getFunction() || !Functions.count(SP.getFunction())) continue; diff --git a/tools/opt/BreakpointPrinter.cpp b/tools/opt/BreakpointPrinter.cpp index 3cbc0ae50f1..eb89b9bca80 100644 --- a/tools/opt/BreakpointPrinter.cpp +++ b/tools/opt/BreakpointPrinter.cpp @@ -30,14 +30,12 @@ struct BreakpointPrinter : public ModulePass { BreakpointPrinter(raw_ostream &out) : ModulePass(ID), Out(out) {} void getContextName(DIDescriptor Context, std::string &N) { - if (Context.isNameSpace()) { - DINameSpace NS(Context); + if (DINameSpace NS = dyn_cast(Context)) { if (!NS.getName().empty()) { getContextName(NS.getContext(), N); N = N + NS.getName().str() + "::"; } - } else if (Context.isType()) { - DIType TY(Context); + } else if (DIType TY = dyn_cast(Context)) { if (!TY.getName().empty()) { getContextName(TY.getContext().resolve(TypeIdentifierMap), N); N = N + TY.getName().str() + "::"; @@ -55,9 +53,7 @@ struct BreakpointPrinter : public ModulePass { if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp")) for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { std::string Name; - DISubprogram SP(NMD->getOperand(i)); - assert((!SP || SP.isSubprogram()) && - "A MDNode in llvm.dbg.sp should be null or a DISubprogram."); + DISubprogram SP = cast_or_null(NMD->getOperand(i)); if (!SP) continue; getContextName(SP.getContext().resolve(TypeIdentifierMap), Name); diff --git a/unittests/Transforms/Utils/Cloning.cpp b/unittests/Transforms/Utils/Cloning.cpp index 185212bc4c8..4b2beb745d0 100644 --- a/unittests/Transforms/Utils/Cloning.cpp +++ b/unittests/Transforms/Utils/Cloning.cpp @@ -304,11 +304,9 @@ TEST_F(CloneFunc, Subprogram) { EXPECT_EQ(2U, SubprogramCount); auto Iter = Finder->subprograms().begin(); - DISubprogram Sub1(*Iter); - EXPECT_TRUE(Sub1.isSubprogram()); + DISubprogram Sub1 = cast(*Iter); Iter++; - DISubprogram Sub2(*Iter); - EXPECT_TRUE(Sub2.isSubprogram()); + DISubprogram Sub2 = cast(*Iter); EXPECT_TRUE((Sub1.getFunction() == OldFunc && Sub2.getFunction() == NewFunc) || (Sub1.getFunction() == NewFunc && Sub2.getFunction() == OldFunc)); @@ -322,11 +320,9 @@ TEST_F(CloneFunc, SubprogramInRightCU) { EXPECT_EQ(2U, Finder->compile_unit_count()); auto Iter = Finder->compile_units().begin(); - DICompileUnit CU1(*Iter); - EXPECT_TRUE(CU1.isCompileUnit()); + DICompileUnit CU1 = cast(*Iter); Iter++; - DICompileUnit CU2(*Iter); - EXPECT_TRUE(CU2.isCompileUnit()); + DICompileUnit CU2 = cast(*Iter); EXPECT_TRUE(CU1.getSubprograms().getNumElements() == 0 || CU2.getSubprograms().getNumElements() == 0); } @@ -355,10 +351,8 @@ TEST_F(CloneFunc, InstructionOwnership) { EXPECT_EQ(OldDL.getCol(), NewDL.getCol()); // But that they belong to different functions - DISubprogram OldSubprogram(OldDL.getScope()); - DISubprogram NewSubprogram(NewDL.getScope()); - EXPECT_TRUE(OldSubprogram.isSubprogram()); - EXPECT_TRUE(NewSubprogram.isSubprogram()); + DISubprogram OldSubprogram = cast(OldDL.getScope()); + DISubprogram NewSubprogram = cast(NewDL.getScope()); EXPECT_EQ(OldFunc, OldSubprogram.getFunction()); EXPECT_EQ(NewFunc, NewSubprogram.getFunction()); } @@ -394,21 +388,25 @@ TEST_F(CloneFunc, DebugIntrinsics) { getParent()->getParent()); // Old variable must belong to the old function - EXPECT_EQ(OldFunc, DISubprogram(DIVariable(OldIntrin->getVariable()) - .getContext()).getFunction()); + EXPECT_EQ(OldFunc, DISubprogram(cast( + OldIntrin->getVariable()->getScope())) + .getFunction()); // New variable must belong to the New function - EXPECT_EQ(NewFunc, DISubprogram(DIVariable(NewIntrin->getVariable()) - .getContext()).getFunction()); + EXPECT_EQ(NewFunc, DISubprogram(cast( + NewIntrin->getVariable()->getScope())) + .getFunction()); } else if (DbgValueInst* OldIntrin = dyn_cast(&OldI)) { DbgValueInst* NewIntrin = dyn_cast(&NewI); EXPECT_TRUE(NewIntrin); // Old variable must belong to the old function - EXPECT_EQ(OldFunc, DISubprogram(DIVariable(OldIntrin->getVariable()) - .getContext()).getFunction()); + EXPECT_EQ(OldFunc, DISubprogram(cast( + OldIntrin->getVariable()->getScope())) + .getFunction()); // New variable must belong to the New function - EXPECT_EQ(NewFunc, DISubprogram(DIVariable(NewIntrin->getVariable()) - .getContext()).getFunction()); + EXPECT_EQ(NewFunc, DISubprogram(cast( + NewIntrin->getVariable()->getScope())) + .getFunction()); } ++OldIter; -- 2.11.0