using namespace llvm;
using namespace llvm::dwarf;
-/// \brief Return the size reported by the variable's type.
-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 (isa<MDDerivedType>(Ty) && !Ty.getSizeInBits()) {
- DIDerivedType DT = cast<MDDerivedType>(Ty);
- Ty = DT.getTypeDerivedFrom().resolve(Map);
- }
- assert(Ty.getSizeInBits() && "type with size 0");
- return Ty.getSizeInBits();
-}
-
//===----------------------------------------------------------------------===//
// Simple Descriptor Constructors and other Methods
//===----------------------------------------------------------------------===//
-void DIDescriptor::replaceAllUsesWith(LLVMContext &, DIDescriptor D) {
- assert(DbgNode && "Trying to replace an unverified type!");
- assert(DbgNode->isTemporary() && "Expected temporary node");
- TempMDNode Temp(get());
-
- // Since we use a TrackingVH for the node, its easy for clients to manufacture
- // legitimate situations where they want to replaceAllUsesWith() on something
- // which, due to uniquing, has merged with the source. We shield clients from
- // this detail by allowing a value to be replaced with replaceAllUsesWith()
- // itself.
- if (Temp.get() == D.get()) {
- DbgNode = MDNode::replaceWithUniqued(std::move(Temp));
- return;
- }
-
- Temp->replaceAllUsesWith(D.get());
- DbgNode = D.get();
-}
-
-void DIDescriptor::replaceAllUsesWith(MDNode *D) {
- assert(DbgNode && "Trying to replace an unverified type!");
- assert(DbgNode != D && "This replacement should always happen");
- assert(DbgNode->isTemporary() && "Expected temporary node");
- TempMDNode Node(get());
- Node->replaceAllUsesWith(D);
-}
-
DIScopeRef DIScope::getRef() const { return MDScopeRef::get(get()); }
-bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
- assert(CurFn && "Invalid function");
- 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 !SP.describes(CurFn);
-}
-
-Function *DISubprogram::getFunction() const {
- if (auto *N = get())
- if (auto *C = dyn_cast_or_null<ConstantAsMetadata>(N->getFunction()))
- return dyn_cast<Function>(C->getValue());
- return nullptr;
-}
-
-bool DISubprogram::describes(const Function *F) {
- assert(F && "Invalid function");
- if (F == getFunction())
- return true;
- StringRef Name = getLinkageName();
- if (Name.empty())
- Name = getName();
- if (F->getName() == Name)
- return true;
- return false;
-}
-
-GlobalVariable *DIGlobalVariable::getGlobal() const {
- return dyn_cast_or_null<GlobalVariable>(getConstant());
-}
-
-DIScopeRef DIScope::getContext() const {
- if (DIType T = dyn_cast<MDType>(*this))
- return T.getContext();
-
- if (DISubprogram SP = dyn_cast<MDSubprogram>(*this))
- return MDScopeRef(SP.getContext());
-
- if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(*this))
- return MDScopeRef(LB.getContext());
-
- if (DINameSpace NS = dyn_cast<MDNamespace>(*this))
- return MDScopeRef(NS.getContext());
-
- assert((isa<MDFile>(*this) || isa<MDCompileUnit>(*this)) &&
- "Unhandled type of scope.");
- return MDScopeRef();
-}
-
-StringRef DIScope::getName() const {
- 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();
-}
-
-StringRef DIScope::getFilename() const {
- if (auto *N = get())
- if (auto *F = N->getFile())
- return F->getFilename();
- return "";
-}
-
-StringRef DIScope::getDirectory() const {
- if (auto *N = get())
- if (auto *F = N->getFile())
- return F->getDirectory();
- return "";
-}
-
void DICompileUnit::replaceSubprograms(DIArray Subprograms) {
get()->replaceSubprograms(MDSubprogramArray(Subprograms));
}
get()->replaceGlobalVariables(MDGlobalVariableArray(GlobalVariables));
}
-DILocation DILocation::copyWithNewScope(LLVMContext &Ctx,
- DILexicalBlockFile NewScope) {
- assert(NewScope && "Expected valid scope");
-
- const auto *Old = cast<MDLocation>(DbgNode);
- return DILocation(MDLocation::get(Ctx, Old->getLine(), Old->getColumn(),
- NewScope, Old->getInlinedAt()));
-}
-
-unsigned DILocation::computeNewDiscriminator(LLVMContext &Ctx) {
- std::pair<const char *, unsigned> Key(getFilename().data(), getLineNumber());
- return ++Ctx.pImpl->DiscriminatorTable[Key];
-}
-
DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
LLVMContext &VMContext) {
return cast<MDLocalVariable>(DV)
DebugLoc DLoc = Inst->getDebugLoc();
const MDNode *Scope = DLoc.getInlinedAtScope();
DISubprogram Subprogram = getDISubprogram(Scope);
- return Subprogram.describes(F) ? Subprogram : DISubprogram();
+ return Subprogram->describes(F) ? Subprogram : DISubprogram();
}
return DISubprogram();
addCompileUnit(CU);
for (DIGlobalVariable DIG : CU->getGlobalVariables()) {
if (addGlobalVariable(DIG)) {
- processScope(DIG.getContext());
- processType(DIG.getType().resolve(TypeIdentifierMap));
+ processScope(DIG->getScope());
+ processType(DIG->getType().resolve(TypeIdentifierMap));
}
}
for (auto *SP : CU->getSubprograms())
for (auto *RT : CU->getRetainedTypes())
processType(RT);
for (DIImportedEntity Import : CU->getImportedEntities()) {
- DIDescriptor Entity = Import.getEntity().resolve(TypeIdentifierMap);
+ auto *Entity = Import->getEntity().resolve(TypeIdentifierMap);
if (auto *T = dyn_cast<MDType>(Entity))
processType(T);
else if (auto *SP = dyn_cast<MDSubprogram>(Entity))
if (!Loc)
return;
InitializeTypeMap(M);
- processScope(Loc.getScope());
- processLocation(M, Loc.getOrigLocation());
+ processScope(Loc->getScope());
+ processLocation(M, Loc->getInlinedAt());
}
void DebugInfoFinder::processType(DIType DT) {
}
if (!addScope(Scope))
return;
- if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(Scope)) {
- processScope(LB.getContext());
- } else if (DINameSpace NS = dyn_cast<MDNamespace>(Scope)) {
- processScope(NS.getContext());
+ if (auto *LB = dyn_cast<MDLexicalBlockBase>(Scope)) {
+ processScope(LB->getScope());
+ } else if (auto *NS = dyn_cast<MDNamespace>(Scope)) {
+ processScope(NS->getScope());
}
}
void DebugInfoFinder::processSubprogram(DISubprogram SP) {
if (!addSubprogram(SP))
return;
- processScope(SP.getContext().resolve(TypeIdentifierMap));
- processType(SP.getType());
- for (auto *Element : SP.getTemplateParams()) {
- if (DITemplateTypeParameter TType =
- dyn_cast<MDTemplateTypeParameter>(Element)) {
- processType(TType.getType().resolve(TypeIdentifierMap));
- } else if (DITemplateValueParameter TVal =
- dyn_cast<MDTemplateValueParameter>(Element)) {
- processType(TVal.getType().resolve(TypeIdentifierMap));
+ processScope(SP->getScope().resolve(TypeIdentifierMap));
+ processType(SP->getType());
+ for (auto *Element : SP->getTemplateParams()) {
+ if (auto *TType = dyn_cast<MDTemplateTypeParameter>(Element)) {
+ processType(TType->getType().resolve(TypeIdentifierMap));
+ } else if (auto *TVal = dyn_cast<MDTemplateValueParameter>(Element)) {
+ processType(TVal->getType().resolve(TypeIdentifierMap));
}
}
}
if (!NodesSeen.insert(DV).second)
return;
- processScope(DV.getContext());
- processType(DV.getType().resolve(TypeIdentifierMap));
+ processScope(DV->getScope());
+ processType(DV->getType().resolve(TypeIdentifierMap));
}
void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
if (!NodesSeen.insert(DV).second)
return;
- processScope(DV.getContext());
- processType(DV.getType().resolve(TypeIdentifierMap));
+ processScope(DV->getScope());
+ processType(DV->getType().resolve(TypeIdentifierMap));
}
bool DebugInfoFinder::addType(DIType DT) {
get()->print(OS);
}
-static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
- const LLVMContext &Ctx) {
- if (!DL)
- return;
-
- DIScope Scope = cast<MDScope>(DL.getScope());
- // Omit the directory, because it's likely to be long and uninteresting.
- CommentOS << Scope.getFilename();
- CommentOS << ':' << DL.getLine();
- if (DL.getCol() != 0)
- CommentOS << ':' << DL.getCol();
-
- DebugLoc InlinedAtDL = DL.getInlinedAt();
- if (!InlinedAtDL)
- return;
-
- CommentOS << " @[ ";
- printDebugLoc(InlinedAtDL, CommentOS, Ctx);
- CommentOS << " ]";
-}
-
-void DIVariable::printExtendedName(raw_ostream &OS) const {
- const LLVMContext &Ctx = DbgNode->getContext();
- StringRef Res = getName();
- if (!Res.empty())
- OS << Res << "," << getLineNumber();
- if (auto *InlinedAt = get()->getInlinedAt()) {
- if (DebugLoc InlinedAtDL = InlinedAt) {
- OS << " @[";
- printDebugLoc(InlinedAtDL, OS, Ctx);
- OS << "]";
- }
- }
-}
-
template <>
DIDescriptor
DIRef<DIDescriptor>::resolve(const DITypeIdentifierMap &Map) const {
for (MDNode *N : CU_Nodes->operands()) {
DICompileUnit CUNode = cast<MDCompileUnit>(N);
for (DISubprogram SP : CUNode->getSubprograms()) {
- if (Function *F = SP.getFunction())
+ if (Function *F = SP->getFunction())
R.insert(std::make_pair(F, SP));
}
}