RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 02:52:53 +02:00
Code Issues Projects Releases Wiki Activity

IR: Stop using DIDescriptor::is*() and auto-casting

Browse Source 
`DIDescriptor`'s subclasses allow construction from incompatible
pointers, and `DIDescriptor` defines a series of `isa<>`-like functions
(e.g., `isCompileUnit()` instead of `isa<MDCompileUnit>()`) 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.

llvm-svn: 234255
This commit is contained in:
Duncan P. N. Exon Smith 2015-04-06 23:18:49 +00:00
parent 86a23c9deb
commit ba32e6fa81
7 changed files with 134 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/IR/DebugInfo.h
View File

@ -408,7 +408,7 @@ public:
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'.
@ -507,7 +507,7 @@ public:
}
DIArray getElements() const {
assert(!isSubroutineType() && "no elements for DISubroutineType");
assert(!isa<MDSubroutineType>(*this) && "no elements for DISubroutineType");
return DIArray(get()->getElements());
}

67
lib/IR/DIBuilder.cpp
View File

@ -75,7 +75,7 @@ void DIBuilder::trackIfUnresolved(MDNode *N) {
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
@ -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<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.
@ -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<MDScope>(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<Metadata *> Elements) {
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]);
}
@ -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<MDCompositeType>(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<MDLocalScope>(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<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,
@ -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);

158
lib/IR/DebugInfo.cpp
View File

@ -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<MDDerivedType>(Ty) && !Ty.getSizeInBits()) {
DIDerivedType DT = cast<MDDerivedType>(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<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 {
@ -238,35 +239,32 @@ GlobalVariable *DIGlobalVariable::getGlobal() const {
}
DIScopeRef DIScope::getContext() const {
if (DIType T = dyn_cast<MDType>(*this))
return T.getContext();
if (isType())
return DIType(DbgNode).getContext();
if (DISubprogram SP = dyn_cast<MDSubprogram>(*this))
return DIScopeRef(SP.getContext());
if (isSubprogram())
return DIScopeRef(DISubprogram(DbgNode).getContext());
if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(*this))
return DIScopeRef(LB.getContext());
if (isLexicalBlock())
return DIScopeRef(DILexicalBlock(DbgNode).getContext());
if (DINameSpace NS = dyn_cast<MDNamespace>(*this))
return DIScopeRef(NS.getContext());
if (isLexicalBlockFile())
return DIScopeRef(DILexicalBlockFile(DbgNode).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();
}
@ -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<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.
@ -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<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));
@ -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<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());
}
}
}
@ -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<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;
@ -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<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());
}
}
@ -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<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));
}
}
@ -529,14 +522,14 @@ void DebugInfoFinder::processDeclare(const Module &M,
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) {
@ -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<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) {
@ -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<MDScope>(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<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));
}

12
lib/IR/DebugLoc.cpp
View File

@ -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 << "<unknown>";
DIScope Scope = cast<MDScope>(getScope());
OS << Scope.getFilename();
OS << ':' << getLine();
if (getCol() != 0)
OS << ':' << getCol();

8
lib/Linker/LinkModules.cpp
View File

@ -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<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;

10
tools/opt/BreakpointPrinter.cpp
View File

@ -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<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() + "::";
@ -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<MDSubprogram>(NMD->getOperand(i));
if (!SP)
continue;
getContextName(SP.getContext().resolve(TypeIdentifierMap), Name);

38
unittests/Transforms/Utils/Cloning.cpp
View File

@ -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<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));
@ -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<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);
}
@ -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<MDSubprogram>(OldDL.getScope());
DISubprogram NewSubprogram = cast<MDSubprogram>(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<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;