int Optimized, const char *Flags,
unsigned RuntimeVersion) {
DIBuilder *D = unwrap(Dref);
- DICompileUnit CU = D->createCompileUnit(Lang, File, Dir, Producer, Optimized,
- Flags, RuntimeVersion);
- return wrap(CU);
+ return wrap(D->createCompileUnit(Lang, File, Dir, Producer, Optimized, Flags,
+ RuntimeVersion));
}
LLVMMetadataRef LLVMDIBuilderCreateFile(LLVMDIBuilderRef Dref, const char *File,
const char *Dir) {
DIBuilder *D = unwrap(Dref);
- DIFile F = D->createFile(File, Dir);
- return wrap(F);
+ return wrap(D->createFile(File, Dir));
}
LLVMMetadataRef LLVMDIBuilderCreateLexicalBlock(LLVMDIBuilderRef Dref,
LLVMMetadataRef File,
unsigned Discriminator) {
DIBuilder *D = unwrap(Dref);
- DILexicalBlockFile LBF = D->createLexicalBlockFile(
- unwrap<MDLocalScope>(Scope), unwrap<MDFile>(File), Discriminator);
- return wrap(LBF);
+ return wrap(D->createLexicalBlockFile(unwrap<MDLocalScope>(Scope),
+ unwrap<MDFile>(File), Discriminator));
}
LLVMMetadataRef LLVMDIBuilderCreateFunction(
LLVMMetadataRef CompositeType, int IsLocalToUnit, int IsDefinition,
unsigned ScopeLine, unsigned Flags, int IsOptimized, LLVMValueRef Func) {
DIBuilder *D = unwrap(Dref);
- DISubprogram SP = D->createFunction(
- unwrap<MDScope>(Scope), Name, LinkageName,
- File ? unwrap<MDFile>(File) : nullptr, Line,
- unwrap<MDSubroutineType>(CompositeType), IsLocalToUnit, IsDefinition,
- ScopeLine, Flags, IsOptimized, unwrap<Function>(Func));
- return wrap(SP);
+ return wrap(D->createFunction(unwrap<MDScope>(Scope), Name, LinkageName,
+ File ? unwrap<MDFile>(File) : nullptr, Line,
+ unwrap<MDSubroutineType>(CompositeType),
+ IsLocalToUnit, IsDefinition, ScopeLine, Flags,
+ IsOptimized, unwrap<Function>(Func)));
}
LLVMMetadataRef LLVMDIBuilderCreateLocalVariable(
class LLVMContext;
class raw_ostream;
-class DIFile;
-class DISubprogram;
-class DILexicalBlock;
-class DILexicalBlockFile;
class DIVariable;
class DIObjCProperty;
template <> struct simplify_type<DESC>;
DECLARE_SIMPLIFY_DESCRIPTOR(DISubrange)
DECLARE_SIMPLIFY_DESCRIPTOR(DIEnumerator)
-DECLARE_SIMPLIFY_DESCRIPTOR(DIFile)
-DECLARE_SIMPLIFY_DESCRIPTOR(DICompileUnit)
-DECLARE_SIMPLIFY_DESCRIPTOR(DISubprogram)
-DECLARE_SIMPLIFY_DESCRIPTOR(DILexicalBlock)
-DECLARE_SIMPLIFY_DESCRIPTOR(DILexicalBlockFile)
-DECLARE_SIMPLIFY_DESCRIPTOR(DINameSpace)
DECLARE_SIMPLIFY_DESCRIPTOR(DITemplateTypeParameter)
DECLARE_SIMPLIFY_DESCRIPTOR(DITemplateValueParameter)
DECLARE_SIMPLIFY_DESCRIPTOR(DIGlobalVariable)
MDEnumerator &operator*() const { return *N; }
};
-class DIFile {
- MDFile *N;
-
-public:
- DIFile(const MDFile *N = nullptr) : N(const_cast<MDFile *>(N)) {}
-
- operator MDFile *() const { return N; }
- MDFile *operator->() const { return N; }
- MDFile &operator*() const { return *N; }
-};
-
-class DICompileUnit {
- MDCompileUnit *N;
-
-public:
- DICompileUnit(const MDCompileUnit *N = nullptr)
- : N(const_cast<MDCompileUnit *>(N)) {}
-
- operator MDCompileUnit *() const { return N; }
- MDCompileUnit *operator->() const { return N; }
- MDCompileUnit &operator*() const { return *N; }
-};
-
-class DISubprogram {
- MDSubprogram *N;
-
-public:
- DISubprogram(const MDSubprogram *N = nullptr)
- : N(const_cast<MDSubprogram *>(N)) {}
-
- operator MDSubprogram *() const { return N; }
- MDSubprogram *operator->() const { return N; }
- MDSubprogram &operator*() const { return *N; }
-};
-
-class DILexicalBlock {
- MDLexicalBlockBase *N;
-
-public:
- DILexicalBlock(const MDLexicalBlockBase *N = nullptr)
- : N(const_cast<MDLexicalBlockBase *>(N)) {}
-
- operator MDLexicalBlockBase *() const { return N; }
- MDLexicalBlockBase *operator->() const { return N; }
- MDLexicalBlockBase &operator*() const { return *N; }
-};
-
-class DILexicalBlockFile {
- MDLexicalBlockFile *N;
-
-public:
- DILexicalBlockFile(const MDLexicalBlockFile *N = nullptr)
- : N(const_cast<MDLexicalBlockFile *>(N)) {}
-
- operator MDLexicalBlockFile *() const { return N; }
- MDLexicalBlockFile *operator->() const { return N; }
- MDLexicalBlockFile &operator*() const { return *N; }
-};
-
-class DINameSpace {
- MDNamespace *N;
-
-public:
- DINameSpace(const MDNamespace *N = nullptr)
- : N(const_cast<MDNamespace *>(N)) {}
-
- operator MDNamespace *() const { return N; }
- MDNamespace *operator->() const { return N; }
- MDNamespace &operator*() const { return *N; }
-};
-
class DITemplateTypeParameter {
MDTemplateTypeParameter *N;
template <> struct simplify_type<DESC> : simplify_type<const DESC> {};
SIMPLIFY_DESCRIPTOR(DISubrange)
SIMPLIFY_DESCRIPTOR(DIEnumerator)
-SIMPLIFY_DESCRIPTOR(DIFile)
-SIMPLIFY_DESCRIPTOR(DICompileUnit)
-SIMPLIFY_DESCRIPTOR(DISubprogram)
-SIMPLIFY_DESCRIPTOR(DILexicalBlock)
-SIMPLIFY_DESCRIPTOR(DILexicalBlockFile)
-SIMPLIFY_DESCRIPTOR(DINameSpace)
SIMPLIFY_DESCRIPTOR(DITemplateTypeParameter)
SIMPLIFY_DESCRIPTOR(DITemplateValueParameter)
SIMPLIFY_DESCRIPTOR(DIGlobalVariable)
MDSubprogram *getDISubprogram(const MDNode *Scope);
/// \brief Find debug info for a given function.
-/// \returns a valid DISubprogram, if found. Otherwise, it returns an empty
-/// DISubprogram.
+///
+/// \returns a valid subprogram, if found. Otherwise, return \c nullptr.
MDSubprogram *getDISubprogram(const Function *F);
/// \brief Find underlying composite type.
namespace llvm {
-DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DICompileUnit Node,
+DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const MDCompileUnit *Node,
AsmPrinter *A, DwarfDebug *DW,
DwarfFile *DWU)
: DwarfUnit(UID, dwarf::DW_TAG_compile_unit, Node, A, DW, DWU),
// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
// and DW_AT_high_pc attributes. If there are global variables in this
// scope then create and insert DIEs for these variables.
-DIE &DwarfCompileUnit::updateSubprogramScopeDIE(DISubprogram SP) {
+DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const MDSubprogram *SP) {
DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
assert(Scope && Scope->getScopeNode());
assert(!Scope->getInlinedAt());
assert(!Scope->isAbstractScope());
- DISubprogram Sub = cast<MDSubprogram>(Scope->getScopeNode());
+ auto *Sub = cast<MDSubprogram>(Scope->getScopeNode());
DD->getProcessedSPNodes().insert(Sub);
if (AbsDef)
return;
- DISubprogram SP = cast<MDSubprogram>(Scope->getScopeNode());
+ auto *SP = cast<MDSubprogram>(Scope->getScopeNode());
DIE *ContextDIE;
return IMDie;
}
-void DwarfCompileUnit::finishSubprogramDefinition(DISubprogram SP) {
+void DwarfCompileUnit::finishSubprogramDefinition(const MDSubprogram *SP) {
DIE *D = getDIE(SP);
if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP)) {
if (D)
applySubprogramAttributesToDefinition(SP, *D);
}
}
-void DwarfCompileUnit::collectDeadVariables(DISubprogram SP) {
+void DwarfCompileUnit::collectDeadVariables(const MDSubprogram *SP) {
assert(SP && "CU's subprogram list contains a non-subprogram");
assert(SP->isDefinition() &&
"CU's subprogram list contains a subprogram declaration");
Die.addValue((dwarf::Attribute)0, Form, Value);
}
-void DwarfCompileUnit::applySubprogramAttributesToDefinition(DISubprogram SP,
- DIE &SPDie) {
+void DwarfCompileUnit::applySubprogramAttributesToDefinition(
+ const MDSubprogram *SP, DIE &SPDie) {
auto *SPDecl = SP->getDeclaration();
auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
bool includeMinimalInlineScopes() const;
public:
- DwarfCompileUnit(unsigned UID, DICompileUnit Node, AsmPrinter *A,
+ DwarfCompileUnit(unsigned UID, const MDCompileUnit *Node, AsmPrinter *A,
DwarfDebug *DW, DwarfFile *DWU);
DwarfCompileUnit *getSkeleton() const {
/// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
/// variables in this scope then create and insert DIEs for these
/// variables.
- DIE &updateSubprogramScopeDIE(DISubprogram SP);
+ DIE &updateSubprogramScopeDIE(const MDSubprogram *SP);
void constructScopeDIE(LexicalScope *Scope,
SmallVectorImpl<std::unique_ptr<DIE>> &FinalChildren);
std::unique_ptr<DIE>
constructImportedEntityDIE(const DIImportedEntity &Module);
- void finishSubprogramDefinition(DISubprogram SP);
+ void finishSubprogramDefinition(const MDSubprogram *SP);
- void collectDeadVariables(DISubprogram SP);
+ void collectDeadVariables(const MDSubprogram *SP);
/// Set the skeleton unit associated with this unit.
void setSkeleton(DwarfCompileUnit &Skel) { Skeleton = &Skel; }
/// Add a Dwarf expression attribute data and value.
void addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr);
- void applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie);
+ void applySubprogramAttributesToDefinition(const MDSubprogram *SP,
+ DIE &SPDie);
/// getRangeLists - Get the vector of range lists.
const SmallVectorImpl<RangeSpanList> &getRangeLists() const {
// TODO: Determine whether or not we should add names for programs
// that do not have a DW_AT_name or DW_AT_linkage_name field - this
// is only slightly different than the lookup of non-standard ObjC names.
-void DwarfDebug::addSubprogramNames(DISubprogram SP, DIE &Die) {
+void DwarfDebug::addSubprogramNames(const MDSubprogram *SP, DIE &Die) {
if (!SP->isDefinition())
return;
addAccelName(SP->getName(), Die);
// Create new DwarfCompileUnit for the given metadata node with tag
// DW_TAG_compile_unit.
-DwarfCompileUnit &DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
+DwarfCompileUnit &
+DwarfDebug::constructDwarfCompileUnit(const MDCompileUnit *DIUnit) {
StringRef FN = DIUnit->getFilename();
CompilationDir = DIUnit->getDirectory();
SingleCU = CU_Nodes->getNumOperands() == 1;
for (MDNode *N : CU_Nodes->operands()) {
- DICompileUnit CUNode = cast<MDCompileUnit>(N);
+ auto *CUNode = cast<MDCompileUnit>(N);
DwarfCompileUnit &CU = constructDwarfCompileUnit(CUNode);
for (auto *IE : CUNode->getImportedEntities())
ScopesWithImportedEntities.push_back(std::make_pair(IE->getScope(), IE));
if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
for (MDNode *N : CU_Nodes->operands()) {
- DICompileUnit TheCU = cast<MDCompileUnit>(N);
+ auto *TheCU = cast<MDCompileUnit>(N);
// Construct subprogram DIE and add variables DIEs.
DwarfCompileUnit *SPCU =
static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
// Find variables for each lexical scope.
-void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU, DISubprogram SP,
+void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU,
+ const MDSubprogram *SP,
DenseSet<InlinedVariable> &Processed) {
// Grab the variable info that was squirreled away in the MMI side-table.
collectVariableInfoFromMMITable(Processed);
Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
- DISubprogram SP = cast<MDSubprogram>(FnScope->getScopeNode());
+ auto *SP = cast<MDSubprogram>(FnScope->getScopeNode());
DwarfCompileUnit &TheCU = *SPMap.lookup(SP);
DenseSet<InlinedVariable> ProcessedVars;
#endif
// Construct abstract scopes.
for (LexicalScope *AScope : LScopes.getAbstractScopesList()) {
- DISubprogram SP = cast<MDSubprogram>(AScope->getScopeNode());
+ auto *SP = cast<MDSubprogram>(AScope->getScopeNode());
// Collect info for variables that were optimized out.
for (DIVariable DV : SP->getVariables()) {
if (!ProcessedVars.insert(InlinedVariable(DV, nullptr)).second)
/// \brief Create new DwarfCompileUnit for the given metadata node with tag
/// DW_TAG_compile_unit.
- DwarfCompileUnit &constructDwarfCompileUnit(DICompileUnit DIUnit);
+ DwarfCompileUnit &constructDwarfCompileUnit(const MDCompileUnit *DIUnit);
/// \brief Construct imported_module or imported_declaration DIE.
void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
void identifyScopeMarkers();
/// \brief Populate LexicalScope entries with variables' info.
- void collectVariableInfo(DwarfCompileUnit &TheCU, DISubprogram SP,
+ void collectVariableInfo(DwarfCompileUnit &TheCU, const MDSubprogram *SP,
DenseSet<InlinedVariable> &ProcessedVars);
/// \brief Build the location list for all DBG_VALUEs in the
/// or another context nested inside a subprogram.
bool isSubprogramContext(const MDNode *Context);
- void addSubprogramNames(DISubprogram SP, DIE &Die);
+ void addSubprogramNames(const MDSubprogram *SP, DIE &Die);
AddressPool &getAddressPool() { return AddrPool; }
class DIEAbbrev;
class MCSymbol;
class DIE;
-class DISubprogram;
class LexicalScope;
class StringRef;
class DwarfDebug;
return MachineReg == TRI.getFrameRegister(*AP.MF);
}
-
-DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node,
- AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
+DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag,
+ const MDCompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
+ DwarfFile *DWU)
: UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
assert(UnitTag == dwarf::DW_TAG_compile_unit ||
addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
}
-void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) {
+void DwarfUnit::addSourceLine(DIE &Die, const MDSubprogram *SP) {
assert(SP);
addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
}
-void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) {
+void DwarfUnit::addSourceLine(DIE &Die, const MDNamespace *NS) {
addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
}
}
}
-DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) {
+DIE *DwarfUnit::getOrCreateNameSpace(const MDNamespace *NS) {
// Construct the context before querying for the existence of the DIE in case
// such construction creates the DIE.
DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
return &NDie;
}
-DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) {
+DIE *DwarfUnit::getOrCreateSubprogramDIE(const MDSubprogram *SP, bool Minimal) {
// Construct the context before querying for the existence of the DIE in case
// such construction creates the DIE (as is the case for member function
// declarations).
return &SPDie;
}
-bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP,
+bool DwarfUnit::applySubprogramDefinitionAttributes(const MDSubprogram *SP,
DIE &SPDie) {
DIE *DeclDie = nullptr;
StringRef DeclLinkageName;
return true;
}
-void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
+void DwarfUnit::applySubprogramAttributes(const MDSubprogram *SP, DIE &SPDie,
bool Minimal) {
if (!Minimal)
if (applySubprogramDefinitionAttributes(SP, SPDie))
unsigned UniqueID;
/// MDNode for the compile unit.
- DICompileUnit CUNode;
+ const MDCompileUnit *CUNode;
/// Unit debug information entry.
DIE UnitDie;
/// The section this unit will be emitted in.
const MCSection *Section;
- DwarfUnit(unsigned UID, dwarf::Tag, DICompileUnit CU, AsmPrinter *A,
+ DwarfUnit(unsigned UID, dwarf::Tag, const MDCompileUnit *CU, AsmPrinter *A,
DwarfDebug *DW, DwarfFile *DWU);
/// \brief Add a string attribute data and value.
void addIndexedString(DIE &Die, dwarf::Attribute Attribute, StringRef Str);
- bool applySubprogramDefinitionAttributes(DISubprogram SP, DIE &SPDie);
+ bool applySubprogramDefinitionAttributes(const MDSubprogram *SP, DIE &SPDie);
public:
virtual ~DwarfUnit();
AsmPrinter* getAsmPrinter() const { return Asm; }
unsigned getUniqueID() const { return UniqueID; }
uint16_t getLanguage() const { return CUNode->getSourceLanguage(); }
- DICompileUnit getCUNode() const { return CUNode; }
+ const MDCompileUnit *getCUNode() const { return CUNode; }
DIE &getUnitDie() { return UnitDie; }
unsigned getDebugInfoOffset() const { return DebugInfoOffset; }
StringRef Directory);
void addSourceLine(DIE &Die, DIVariable V);
void addSourceLine(DIE &Die, DIGlobalVariable G);
- void addSourceLine(DIE &Die, DISubprogram SP);
+ void addSourceLine(DIE &Die, const MDSubprogram *SP);
void addSourceLine(DIE &Die, const MDType *Ty);
- void addSourceLine(DIE &Die, DINameSpace NS);
+ void addSourceLine(DIE &Die, const MDNamespace *NS);
void addSourceLine(DIE &Die, DIObjCProperty Ty);
/// \brief Add constant value entry in variable DIE.
void addType(DIE &Entity, const MDType *Ty,
dwarf::Attribute Attribute = dwarf::DW_AT_type);
- DIE *getOrCreateNameSpace(DINameSpace NS);
- DIE *getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal = false);
+ DIE *getOrCreateNameSpace(const MDNamespace *NS);
+ DIE *getOrCreateSubprogramDIE(const MDSubprogram *SP, bool Minimal = false);
- void applySubprogramAttributes(DISubprogram SP, DIE &SPDie,
+ void applySubprogramAttributes(const MDSubprogram *SP, DIE &SPDie,
bool Minimal = false);
/// \brief Find existing DIE or create new DIE for the given type.
StringRef GVName = GV->getName();
StringRef FuncName;
- if (DISubprogram SP = getDISubprogram(GV))
+ if (auto *SP = getDISubprogram(GV))
FuncName = SP->getDisplayName();
// FIXME Clang currently sets DisplayName to "bar" for a C++
DebugLoc DebugLoc::getFnDebugLoc() const {
// FIXME: Add a method on \a MDLocation that does this work.
const MDNode *Scope = getInlinedAtScope();
- if (DISubprogram SP = getDISubprogram(Scope))
+ if (auto *SP = getDISubprogram(Scope))
return DebugLoc::get(SP->getScopeLine(), 0, SP);
return DebugLoc();
if (!CompileUnits)
return;
for (unsigned I = 0, E = CompileUnits->getNumOperands(); I != E; ++I) {
- DICompileUnit CU = cast<MDCompileUnit>(CompileUnits->getOperand(I));
+ auto *CU = cast<MDCompileUnit>(CompileUnits->getOperand(I));
assert(CU && "Expected valid compile unit");
for (MDSubprogram *SP : CU->getSubprograms()) {
// Patch the pointer to LLVM function in debug info descriptor.
auto DI = FunctionDIs.find(F);
if (DI != FunctionDIs.end()) {
- DISubprogram SP = DI->second;
+ MDSubprogram *SP = DI->second;
SP->replaceFunction(NF);
// Ensure the map is updated so it can be reused on subsequent argument
// promotions of the same function.
// Patch the pointer to LLVM function in debug info descriptor.
auto DI = FunctionDIs.find(&Fn);
if (DI != FunctionDIs.end()) {
- DISubprogram SP = DI->second;
+ MDSubprogram *SP = DI->second;
SP->replaceFunction(NF);
// Ensure the map is updated so it can be reused on non-varargs argument
// eliminations of the same function.
for (MDCompileUnit *DIC : F.compile_units()) {
// Create our live subprogram list.
- MDSubprogramArray SPs = DIC->getSubprograms();
bool SubprogramChange = false;
- for (unsigned i = 0, e = SPs.size(); i != e; ++i) {
- DISubprogram DISP = SPs[i];
-
+ for (MDSubprogram *DISP : DIC->getSubprograms()) {
// Make sure we visit each subprogram only once.
if (!VisitedSet.insert(DISP).second)
continue;
Function *insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> >);
void insertIndirectCounterIncrement();
- std::string mangleName(DICompileUnit CU, const char *NewStem);
+ std::string mangleName(const MDCompileUnit *CU, const char *NewStem);
GCOVOptions Options;
return new GCOVProfiler(Options);
}
-static StringRef getFunctionName(MDSubprogram *SP) {
+static StringRef getFunctionName(const MDSubprogram *SP) {
if (!SP->getLinkageName().empty())
return SP->getLinkageName();
return SP->getName();
// object users can construct, the blocks and lines will be rooted here.
class GCOVFunction : public GCOVRecord {
public:
- GCOVFunction(DISubprogram SP, raw_ostream *os, uint32_t Ident,
+ GCOVFunction(const MDSubprogram *SP, raw_ostream *os, uint32_t Ident,
bool UseCfgChecksum, bool ExitBlockBeforeBody)
: SP(SP), Ident(Ident), UseCfgChecksum(UseCfgChecksum), CfgChecksum(0),
ReturnBlock(1, os) {
}
private:
- DISubprogram SP;
+ const MDSubprogram *SP;
uint32_t Ident;
uint32_t FuncChecksum;
bool UseCfgChecksum;
};
}
-std::string GCOVProfiler::mangleName(DICompileUnit CU, const char *NewStem) {
+std::string GCOVProfiler::mangleName(const MDCompileUnit *CU,
+ const char *NewStem) {
if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
MDNode *N = GCov->getOperand(i);
// this pass over the original .o's as they're produced, or run it after
// LTO, we'll generate the same .gcno files.
- DICompileUnit CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
+ auto *CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
std::error_code EC;
raw_fd_ostream out(mangleName(CU, "gcno"), EC, sys::fs::F_None);
std::string EdgeDestinations;
bool Result = false;
bool InsertIndCounterIncrCode = false;
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
- DICompileUnit CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
+ auto *CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
for (auto *SP : CU->getSubprograms()) {
Function *F = SP->getFunction();
NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
if (CU_Nodes) {
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
- DICompileUnit CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
+ auto *CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
std::string FilenameGcda = mangleName(CU, "gcda");
uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
Builder.CreateCall3(StartFile,
// number for it.
StringRef Filename = FirstDIL->getFilename();
auto *Scope = FirstDIL->getScope();
- DIFile File = Builder.createFile(Filename, Scope->getDirectory());
+ auto *File = Builder.createFile(Filename, Scope->getDirectory());
// FIXME: Calculate the discriminator here, based on local information,
// and delete MDLocation::computeNewDiscriminator(). The current
// same context. All we really need is to discriminate between
// FirstDIL and LastDIL -- a local map would suffice.
unsigned Discriminator = FirstDIL->computeNewDiscriminator();
- DILexicalBlockFile NewScope =
+ auto *NewScope =
Builder.createLexicalBlockFile(Scope, File, Discriminator);
auto *NewDIL =
MDLocation::get(Ctx, FirstDIL->getLine(), FirstDIL->getColumn(),
TypeMapper, Materializer);
}
-// Find the MDNode which corresponds to the DISubprogram data that described F.
-static MDNode* FindSubprogram(const Function *F, DebugInfoFinder &Finder) {
- for (DISubprogram Subprogram : Finder.subprograms()) {
+// Find the MDNode which corresponds to the subprogram data that described F.
+static MDSubprogram *FindSubprogram(const Function *F,
+ DebugInfoFinder &Finder) {
+ for (MDSubprogram *Subprogram : Finder.subprograms()) {
if (Subprogram->describes(F))
return Subprogram;
}
// Add an operand to an existing MDNode. The new operand will be added at the
// back of the operand list.
-static void AddOperand(DICompileUnit CU, MDSubprogramArray SPs, Metadata *NewSP) {
+static void AddOperand(MDCompileUnit *CU, MDSubprogramArray SPs,
+ Metadata *NewSP) {
SmallVector<Metadata *, 16> NewSPs;
NewSPs.reserve(SPs.size() + 1);
for (auto *SP : SPs)
DebugInfoFinder Finder;
Finder.processModule(*OldFunc->getParent());
- const MDNode *OldSubprogramMDNode = FindSubprogram(OldFunc, Finder);
+ const MDSubprogram *OldSubprogramMDNode = FindSubprogram(OldFunc, Finder);
if (!OldSubprogramMDNode) return;
// Ensure that OldFunc appears in the map.
// (if it's already there it must point to NewFunc anyway)
VMap[OldFunc] = NewFunc;
- DISubprogram NewSubprogram =
+ auto *NewSubprogram =
cast<MDSubprogram>(MapMetadata(OldSubprogramMDNode, VMap));
- for (DICompileUnit CU : Finder.compile_units()) {
+ for (auto *CU : Finder.compile_units()) {
auto Subprograms = CU->getSubprograms();
// If the compile unit's function list contains the old function, it should
// also contain the new one.
IRBuilder<> IBuilder(C);
// Function DI
- DIFile File = DBuilder.createFile("filename.c", "/file/dir/");
+ auto *File = DBuilder.createFile("filename.c", "/file/dir/");
DITypeArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
MDSubroutineType *FuncType =
DBuilder.createSubroutineType(File, ParamTypes);
- DICompileUnit CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
- "filename.c", "/file/dir", "CloneFunc", false, "", 0);
+ auto *CU =
+ DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
+ "/file/dir", "CloneFunc", false, "", 0);
- DISubprogram Subprogram = DBuilder.createFunction(CU, "f", "f", File, 4,
- FuncType, true, true, 3, 0, false, OldFunc);
+ auto *Subprogram = DBuilder.createFunction(
+ CU, "f", "f", File, 4, FuncType, true, true, 3, 0, false, OldFunc);
// Function body
BasicBlock* Entry = BasicBlock::Create(C, "", OldFunc);
EXPECT_EQ(2U, SubprogramCount);
auto Iter = Finder->subprograms().begin();
- DISubprogram Sub1 = cast<MDSubprogram>(*Iter);
+ auto *Sub1 = cast<MDSubprogram>(*Iter);
Iter++;
- DISubprogram Sub2 = cast<MDSubprogram>(*Iter);
+ auto *Sub2 = cast<MDSubprogram>(*Iter);
EXPECT_TRUE(
(Sub1->getFunction() == OldFunc && Sub2->getFunction() == NewFunc) ||
EXPECT_EQ(2U, Finder->compile_unit_count());
auto Iter = Finder->compile_units().begin();
- DICompileUnit CU1 = cast<MDCompileUnit>(*Iter);
+ auto *CU1 = cast<MDCompileUnit>(*Iter);
Iter++;
- DICompileUnit CU2 = cast<MDCompileUnit>(*Iter);
+ auto *CU2 = cast<MDCompileUnit>(*Iter);
EXPECT_TRUE(CU1->getSubprograms().size() == 0 ||
CU2->getSubprograms().size() == 0);
}
projects / oota-llvm.git / commitdiff