bool isRValueReference() const {
return (getFlags() & FlagRValueReference) != 0;
}
- bool isValid() const { return DbgNode && isType(); }
+ bool isValid() const { return DbgNode && isa<MDType>(*this); }
};
/// \brief A basic type, like 'int' or 'float'.
}
DIArray getElements() const {
- assert(!isSubroutineType() && "no elements for DISubroutineType");
+ assert(!isa<MDSubroutineType>(*this) && "no elements for DISubroutineType");
return DIArray(get()->getElements());
}
void DIBuilder::finalize() {
DIArray Enums = getOrCreateArray(AllEnumTypes);
- DIType(TempEnumTypes).replaceAllUsesWith(Enums);
+ TempEnumTypes->replaceAllUsesWith(Enums);
SmallVector<Metadata *, 16> RetainValues;
// Declarations and definitions of the same type may be retained. Some
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<MDSubprogram>(SPs.getElement(i));
if (MDNode *Temp = SP.getVariablesNodes()) {
const auto &PV = PreservedVariables.lookup(SP);
SmallVector<Metadata *, 4> 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<Metadata *, 16> 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.
// 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);
}
trackIfUnresolved(CUNode);
- return DICompileUnit(CUNode);
+ return CUNode;
}
static DIImportedEntity
}
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);
}
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);
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);
DIType VTableHolder,
MDNode *TemplateParams,
StringRef UniqueIdentifier) {
- assert((!Context || Context.isScope() || Context.isType()) &&
+ assert((!Context || isa<MDScope>(Context)) &&
"createClassType should be called with a valid Context");
// TAG_class_type is encoded in DICompositeType format.
DICompositeType R = MDCompositeType::get(
SmallVector<llvm::Metadata *, 16> Elts;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
if (Elements[i] && isa<MDNode>(Elements[i]))
- Elts.push_back(MDTypeRef::get(DIType(cast<MDNode>(Elements[i]))));
+ Elts.push_back(MDTypeRef::get(cast<MDType>(Elements[i])));
else
Elts.push_back(Elements[i]);
}
}
static void checkGlobalVariableScope(DIDescriptor Context) {
- MDNode *TheCtx = getNonCompileUnitScope(Context);
- if (DIScope(TheCtx).isCompositeType()) {
- assert(!DICompositeType(TheCtx).getIdentifier() &&
+ if (DICompositeType CT =
+ dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
+ assert(!CT.getIdentifier() &&
"Context of a global variable should not be a type with identifier");
- }
}
DIGlobalVariable DIBuilder::createGlobalVariable(
// 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<MDLocalScope>(Context.get()), Name, File,
"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<MDSubroutineType>(Ty.get()), isLocalToUnit,
+ auto *SP = MDSubprogram::get(
+ VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName,
+ F.get(), LineNo, cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
isDefinition, LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags,
isOptimized, getConstantOrNull(Fn), cast_or_null<MDTuple>(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,
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);
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);
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);
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);
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<MDDerivedType>(Ty) && !Ty.getSizeInBits()) {
+ DIDerivedType DT = cast<MDDerivedType>(Ty);
Ty = DT.getTypeDerivedFrom().resolve(Map);
}
assert(Ty.getSizeInBits() && "type with size 0");
bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
assert(CurFn && "Invalid function");
- if (!getContext().isSubprogram())
+ DISubprogram SP = dyn_cast<MDSubprogram>(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 {
}
DIScopeRef DIScope::getContext() const {
+ if (DIType T = dyn_cast<MDType>(*this))
+ return T.getContext();
- if (isType())
- return DIType(DbgNode).getContext();
-
- if (isSubprogram())
- return DIScopeRef(DISubprogram(DbgNode).getContext());
+ if (DISubprogram SP = dyn_cast<MDSubprogram>(*this))
+ return DIScopeRef(SP.getContext());
- if (isLexicalBlock())
- return DIScopeRef(DILexicalBlock(DbgNode).getContext());
+ if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(*this))
+ return DIScopeRef(LB.getContext());
- if (isLexicalBlockFile())
- return DIScopeRef(DILexicalBlockFile(DbgNode).getContext());
+ if (DINameSpace NS = dyn_cast<MDNamespace>(*this))
+ return DIScopeRef(NS.getContext());
- if (isNameSpace())
- return DIScopeRef(DINameSpace(DbgNode).getContext());
-
- assert((isFile() || isCompileUnit()) && "Unhandled type of scope.");
+ assert((isa<MDFile>(*this) || isa<MDCompileUnit>(*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<MDType>(*this))
+ return T.getName();
+ if (DISubprogram SP = dyn_cast<MDSubprogram>(*this))
+ return SP.getName();
+ if (DINameSpace NS = dyn_cast<MDNamespace>(*this))
+ return NS.getName();
+ assert((isa<MDLexicalBlockBase>(*this) || isa<MDFile>(*this) ||
+ isa<MDCompileUnit>(*this)) &&
"Unhandled type of scope.");
return StringRef();
}
}
DICompositeType llvm::getDICompositeType(DIType T) {
- if (T.isCompositeType())
- return DICompositeType(T);
+ if (auto *C = dyn_cast_or_null<MDCompositeTypeBase>(T))
+ return C;
- if (T.isDerivedType()) {
+ if (auto *D = dyn_cast_or_null<MDDerivedTypeBase>(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<MDCompileUnit>(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<MDCompositeType>(Retain.getElement(Ti)))
continue;
- DICompositeType Ty(Retain.getElement(Ti));
+ DICompositeType Ty = cast<MDCompositeType>(Retain.getElement(Ti));
if (MDString *TypeId = Ty.getIdentifier()) {
// Definition has priority over declaration.
// Try to insert (TypeId, Ty) to Map.
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<MDCompileUnit>(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<MDGlobalVariable>(GVs.getElement(i));
if (addGlobalVariable(DIG)) {
processScope(DIG.getContext());
processType(DIG.getType().resolve(TypeIdentifierMap));
}
DIArray SPs = CU.getSubprograms();
for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
- processSubprogram(DISubprogram(SPs.getElement(i)));
+ processSubprogram(cast<MDSubprogram>(SPs.getElement(i)));
DIArray EnumTypes = CU.getEnumTypes();
for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
- processType(DIType(EnumTypes.getElement(i)));
+ processType(cast<MDType>(EnumTypes.getElement(i)));
DIArray RetainedTypes = CU.getRetainedTypes();
for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
- processType(DIType(RetainedTypes.getElement(i)));
+ processType(cast<MDType>(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<MDImportedEntity>(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<MDType>(Entity))
+ processType(T);
+ else if (auto *SP = dyn_cast<MDSubprogram>(Entity))
+ processSubprogram(SP);
+ else if (auto *NS = dyn_cast<MDNamespace>(Entity))
+ processScope(NS->getScope());
}
}
}
if (!addType(DT))
return;
processScope(DT.getContext().resolve(TypeIdentifierMap));
- if (DT.isCompositeType()) {
- DICompositeType DCT(DT);
+ if (DICompositeType DCT = dyn_cast<MDCompositeTypeBase>(DT)) {
processType(DCT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
- if (DT.isSubroutineType()) {
- DITypeArray DTA = DISubroutineType(DT).getTypeArray();
+ if (DISubroutineType ST = dyn_cast<MDSubroutineType>(DCT)) {
+ DITypeArray DTA = ST.getTypeArray();
for (unsigned i = 0, e = DTA.getNumElements(); i != e; ++i)
processType(DTA.getElement(i).resolve(TypeIdentifierMap));
return;
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<MDType>(D))
+ processType(T);
+ else if (DISubprogram SP = dyn_cast<MDSubprogram>(D))
+ processSubprogram(SP);
}
- } else if (DT.isDerivedType()) {
- DIDerivedType DDT(DT);
+ } else if (DIDerivedType DDT = dyn_cast<MDDerivedTypeBase>(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<MDType>(Scope)) {
processType(Ty);
return;
}
- if (Scope.isCompileUnit()) {
- addCompileUnit(DICompileUnit(Scope));
+ if (DICompileUnit CU = dyn_cast<MDCompileUnit>(Scope)) {
+ addCompileUnit(CU);
return;
}
- if (Scope.isSubprogram()) {
- processSubprogram(DISubprogram(Scope));
+ if (DISubprogram SP = dyn_cast<MDSubprogram>(Scope)) {
+ processSubprogram(SP);
return;
}
if (!addScope(Scope))
return;
- if (Scope.isLexicalBlock()) {
- DILexicalBlock LB(Scope);
+ if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(Scope)) {
processScope(LB.getContext());
- } else if (Scope.isNameSpace()) {
- DINameSpace NS(Scope);
+ } else if (DINameSpace NS = dyn_cast<MDNamespace>(Scope)) {
processScope(NS.getContext());
}
}
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<MDTemplateTypeParameter>(Element)) {
processType(TType.getType().resolve(TypeIdentifierMap));
- } else if (Element.isTemplateValueParameter()) {
- DITemplateValueParameter TVal(Element);
+ } else if (DITemplateValueParameter TVal =
+ dyn_cast<MDTemplateValueParameter>(Element)) {
processType(TVal.getType().resolve(TypeIdentifierMap));
}
}
return;
InitializeTypeMap(M);
- DIDescriptor DV(N);
- if (!DV.isVariable())
+ DIVariable DV = dyn_cast<MDLocalVariable>(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) {
return;
InitializeTypeMap(M);
- DIDescriptor DV(N);
- if (!DV.isVariable())
+ DIVariable DV = dyn_cast<MDLocalVariable>(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) {
if (!DL)
return;
- DIScope Scope(DL.getScope());
- assert(Scope.isScope() && "Scope of a DebugLoc should be a DIScope.");
+ DIScope Scope = cast<MDScope>(DL.getScope());
// Omit the directory, because it's likely to be long and uninteresting.
CommentOS << Scope.getFilename();
CommentOS << ':' << DL.getLine();
return R;
for (MDNode *N : CU_Nodes->operands()) {
- DICompileUnit CUNode(N);
+ DICompileUnit CUNode = cast<MDCompileUnit>(N);
DIArray SPs = CUNode.getSubprograms();
for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
- DISubprogram SP(SPs.getElement(i));
+ DISubprogram SP = cast<MDSubprogram>(SPs.getElement(i));
if (Function *F = SP.getFunction())
R.insert(std::make_pair(F, SP));
}
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();
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 << "<unknown>";
+ DIScope Scope = cast<MDScope>(getScope());
+ OS << Scope.getFilename();
OS << ':' << getLine();
if (getCol() != 0)
OS << ':' << getCol();
if (!CompileUnits)
return;
for (unsigned I = 0, E = CompileUnits->getNumOperands(); I != E; ++I) {
- DICompileUnit CU(CompileUnits->getOperand(I));
+ DICompileUnit CU = cast<MDCompileUnit>(CompileUnits->getOperand(I));
assert(CU && "Expected valid compile unit");
- DITypedArray<DISubprogram> 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;
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<MDNamespace>(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<MDType>(Context)) {
if (!TY.getName().empty()) {
getContextName(TY.getContext().resolve(TypeIdentifierMap), N);
N = N + TY.getName().str() + "::";
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<MDSubprogram>(NMD->getOperand(i));
if (!SP)
continue;
getContextName(SP.getContext().resolve(TypeIdentifierMap), Name);
EXPECT_EQ(2U, SubprogramCount);
auto Iter = Finder->subprograms().begin();
- DISubprogram Sub1(*Iter);
- EXPECT_TRUE(Sub1.isSubprogram());
+ DISubprogram Sub1 = cast<MDSubprogram>(*Iter);
Iter++;
- DISubprogram Sub2(*Iter);
- EXPECT_TRUE(Sub2.isSubprogram());
+ DISubprogram Sub2 = cast<MDSubprogram>(*Iter);
EXPECT_TRUE((Sub1.getFunction() == OldFunc && Sub2.getFunction() == NewFunc)
|| (Sub1.getFunction() == NewFunc && Sub2.getFunction() == OldFunc));
EXPECT_EQ(2U, Finder->compile_unit_count());
auto Iter = Finder->compile_units().begin();
- DICompileUnit CU1(*Iter);
- EXPECT_TRUE(CU1.isCompileUnit());
+ DICompileUnit CU1 = cast<MDCompileUnit>(*Iter);
Iter++;
- DICompileUnit CU2(*Iter);
- EXPECT_TRUE(CU2.isCompileUnit());
+ DICompileUnit CU2 = cast<MDCompileUnit>(*Iter);
EXPECT_TRUE(CU1.getSubprograms().getNumElements() == 0
|| CU2.getSubprograms().getNumElements() == 0);
}
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<MDSubprogram>(OldDL.getScope());
+ DISubprogram NewSubprogram = cast<MDSubprogram>(NewDL.getScope());
EXPECT_EQ(OldFunc, OldSubprogram.getFunction());
EXPECT_EQ(NewFunc, NewSubprogram.getFunction());
}
getParent()->getParent());
// Old variable must belong to the old function
- EXPECT_EQ(OldFunc, DISubprogram(DIVariable(OldIntrin->getVariable())
- .getContext()).getFunction());
+ EXPECT_EQ(OldFunc, DISubprogram(cast<MDSubprogram>(
+ 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<MDSubprogram>(
+ NewIntrin->getVariable()->getScope()))
+ .getFunction());
} else if (DbgValueInst* OldIntrin = dyn_cast<DbgValueInst>(&OldI)) {
DbgValueInst* NewIntrin = dyn_cast<DbgValueInst>(&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<MDSubprogram>(
+ 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<MDSubprogram>(
+ NewIntrin->getVariable()->getScope()))
+ .getFunction());
}
++OldIter;
projects / platform / upstream / llvm.git / commitdiff