6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-05-22 03:39:03 +00:00
Code Issues Projects Releases Wiki Activity

Attempt to make the comments for dwarf debug look more like

Browse Source 
the coding standard would like.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@168737 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Christopher 2012-11-27 22:43:45 +00:00
parent 4288502af9
commit b6dc8655e1
2 changed files with 200 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
View File

@ -94,8 +94,8 @@ namespace {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// Configuration values for initial hash set sizes (log2). // Configuration values for initial hash set sizes (log2).
/// //
static const unsigned InitAbbreviationsSetSize = 9; // log2(512) static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
namespace llvm { namespace llvm {
@ -196,8 +196,8 @@ DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
DwarfDebug::~DwarfDebug() { DwarfDebug::~DwarfDebug() {
} }
/// emitSectionSym - Switch to the specified MCSection and emit an assembler // Switch to the specified MCSection and emit an assembler
/// temporary label to it if SymbolStem is specified. // temporary label to it if SymbolStem is specified.
static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section, static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
const char *SymbolStem = 0) { const char *SymbolStem = 0) {
Asm->OutStreamer.SwitchSection(Section); Asm->OutStreamer.SwitchSection(Section);
@ -220,8 +220,8 @@ MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
return Entry.first = Asm->GetTempSymbol("string", Entry.second); return Entry.first = Asm->GetTempSymbol("string", Entry.second);
} }
/// assignAbbrevNumber - Define a unique number for the abbreviation. // Define a unique number for the abbreviation.
/// //
void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) { void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
// Profile the node so that we can make it unique. // Profile the node so that we can make it unique.
FoldingSetNodeID ID; FoldingSetNodeID ID;
@ -243,9 +243,9 @@ void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
} }
} }
/// getRealLinkageName - If special LLVM prefix that is used to inform the asm // If special LLVM prefix that is used to inform the asm
/// printer to not emit usual symbol prefix before the symbol name is used then // printer to not emit usual symbol prefix before the symbol name is used then
/// return linkage name after skipping this special LLVM prefix. // return linkage name after skipping this special LLVM prefix.
static StringRef getRealLinkageName(StringRef LinkageName) { static StringRef getRealLinkageName(StringRef LinkageName) {
char One = '\1'; char One = '\1';
if (LinkageName.startswith(StringRef(&One, 1))) if (LinkageName.startswith(StringRef(&One, 1)))
@ -310,10 +310,9 @@ static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
} }
} }
/// updateSubprogramScopeDIE - Find DIE for the given subprogram and // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. // and DW_AT_high_pc attributes. If there are global variables in this
/// If there are global variables in this scope then create and insert // scope then create and insert DIEs for these variables.
/// DIEs for these variables.
DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
const MDNode *SPNode) { const MDNode *SPNode) {
DIE *SPDie = SPCU->getDIE(SPNode); DIE *SPDie = SPCU->getDIE(SPNode);
@ -383,8 +382,8 @@ DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
return SPDie; return SPDie;
} }
/// constructLexicalScope - Construct new DW_TAG_lexical_block // Construct new DW_TAG_lexical_block for this scope and attach
/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. // DW_AT_low_pc/DW_AT_high_pc labels.
DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU, DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
LexicalScope *Scope) { LexicalScope *Scope) {
DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block); DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
@ -427,9 +426,8 @@ DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
return ScopeDIE; return ScopeDIE;
} }
/// constructInlinedScopeDIE - This scope represents inlined body of // This scope represents inlined body of a function. Construct DIE to
/// a function. Construct DIE to represent this concrete inlined copy // represent this concrete inlined copy of the function.
/// of the function.
DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU, DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
LexicalScope *Scope) { LexicalScope *Scope) {
const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges(); const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
@ -511,7 +509,7 @@ DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
return ScopeDIE; return ScopeDIE;
} }
/// constructScopeDIE - Construct a DIE for this scope. // Construct a DIE for this scope.
DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) { DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
if (!Scope || !Scope->getScopeNode()) if (!Scope || !Scope->getScopeNode())
return NULL; return NULL;
@ -580,10 +578,10 @@ DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
return ScopeDIE; return ScopeDIE;
} }
/// getOrCreateSourceID - Look up the source id with the given directory and // Look up the source id with the given directory and source file names.
/// source file names. If none currently exists, create a new id and insert it // If none currently exists, create a new id and insert it in the
/// in the SourceIds map. This can update DirectoryNames and SourceFileNames // SourceIds map. This can update DirectoryNames and SourceFileNames maps
/// maps as well. // as well.
unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
StringRef DirName) { StringRef DirName) {
// If FE did not provide a file name, then assume stdin. // If FE did not provide a file name, then assume stdin.
@ -612,8 +610,7 @@ unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
return SrcId; return SrcId;
} }
/// constructCompileUnit - Create new CompileUnit for the given // Create new CompileUnit for the given metadata node with tag DW_TAG_compile_unit.
/// metadata node with tag DW_TAG_compile_unit.
CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) { CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
DICompileUnit DIUnit(N); DICompileUnit DIUnit(N);
StringRef FN = DIUnit.getFilename(); StringRef FN = DIUnit.getFilename();
@ -657,7 +654,7 @@ CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
return NewCU; return NewCU;
} }
/// construct SubprogramDIE - Construct subprogram DIE. // Construct subprogram DIE.
void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
const MDNode *N) { const MDNode *N) {
CompileUnit *&CURef = SPMap[N]; CompileUnit *&CURef = SPMap[N];
@ -682,8 +679,7 @@ void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
return; return;
} }
/// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such // Collect debug info from named mdnodes such as llvm.dbg.enum and llvm.dbg.ty.
/// as llvm.dbg.enum and llvm.dbg.ty
void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) { void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp")) if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
@ -714,8 +710,8 @@ void DwarfDebug::collectInfoFromNamedMDNodes(const Module *M) {
} }
} }
/// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder. // Collect debug info using DebugInfoFinder.
/// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder. // FIXME - Remove this when dragonegg switches to DIBuilder.
bool DwarfDebug::collectLegacyDebugInfo(const Module *M) { bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
DebugInfoFinder DbgFinder; DebugInfoFinder DbgFinder;
DbgFinder.processModule(*M); DbgFinder.processModule(*M);
@ -756,9 +752,9 @@ bool DwarfDebug::collectLegacyDebugInfo(const Module *M) {
return HasDebugInfo; return HasDebugInfo;
} }
/// beginModule - Emit all Dwarf sections that should come prior to the // Emit all Dwarf sections that should come prior to the content. Create
/// content. Create global DIEs and emit initial debug info sections. // global DIEs and emit initial debug info sections. This is invoked by
/// This is invoked by the target AsmPrinter. // the target AsmPrinter.
void DwarfDebug::beginModule() { void DwarfDebug::beginModule() {
if (DisableDebugInfoPrinting) if (DisableDebugInfoPrinting)
return; return;
@ -887,8 +883,7 @@ void DwarfDebug::endSections() {
} }
} }
/// endModule - Emit all Dwarf sections that should come after the content. // Emit all Dwarf sections that should come after the content.
///
void DwarfDebug::endModule() { void DwarfDebug::endModule() {
if (!FirstCU) return; if (!FirstCU) return;
@ -983,7 +978,7 @@ void DwarfDebug::endModule() {
FirstCU = NULL; // Reset for the next Module, if any. FirstCU = NULL; // Reset for the next Module, if any.
} }
/// findAbstractVariable - Find abstract variable, if any, associated with Var. // Find abstract variable, if any, associated with Var.
DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV, DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
DebugLoc ScopeLoc) { DebugLoc ScopeLoc) {
LLVMContext &Ctx = DV->getContext(); LLVMContext &Ctx = DV->getContext();
@ -1003,8 +998,7 @@ DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
return AbsDbgVariable; return AbsDbgVariable;
} }
/// addCurrentFnArgument - If Var is a current function argument then add // If Var is a current function argument then add it to CurrentFnArguments list.
/// it to CurrentFnArguments list.
bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF, bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
DbgVariable *Var, LexicalScope *Scope) { DbgVariable *Var, LexicalScope *Scope) {
if (!LScopes.isCurrentFunctionScope(Scope)) if (!LScopes.isCurrentFunctionScope(Scope))
@ -1027,8 +1021,7 @@ bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
return true; return true;
} }
/// collectVariableInfoFromMMITable - Collect variable information from // Collect variable information from side table maintained by MMI.
/// side table maintained by MMI.
void void
DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF, DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
SmallPtrSet<const MDNode *, 16> &Processed) { SmallPtrSet<const MDNode *, 16> &Processed) {
@ -1057,8 +1050,8 @@ DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
} }
} }
/// isDbgValueInDefinedReg - Return true if debug value, encoded by // Return true if debug value, encoded by DBG_VALUE instruction, is in a
/// DBG_VALUE instruction, is in a defined reg. // defined reg.
static bool isDbgValueInDefinedReg(const MachineInstr *MI) { static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!"); assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
return MI->getNumOperands() == 3 && return MI->getNumOperands() == 3 &&
@ -1066,8 +1059,7 @@ static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0; MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
} }
/// getDebugLocEntry - Get .debug_loc entry for the instruction range starting // Get .debug_loc entry for the instruction range starting at MI.
/// at MI.
static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm, static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
const MCSymbol *FLabel, const MCSymbol *FLabel,
const MCSymbol *SLabel, const MCSymbol *SLabel,
@ -1093,12 +1085,12 @@ static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!"); llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
} }
/// collectVariableInfo - Find variables for each lexical scope. // Find variables for each lexical scope.
void void
DwarfDebug::collectVariableInfo(const MachineFunction *MF, DwarfDebug::collectVariableInfo(const MachineFunction *MF,
SmallPtrSet<const MDNode *, 16> &Processed) { SmallPtrSet<const MDNode *, 16> &Processed) {
/// collection info from MMI table. // collection info from MMI table.
collectVariableInfoFromMMITable(MF, Processed); collectVariableInfoFromMMITable(MF, Processed);
for (SmallVectorImpl<const MDNode*>::const_iterator for (SmallVectorImpl<const MDNode*>::const_iterator
@ -1204,19 +1196,19 @@ DwarfDebug::collectVariableInfo(const MachineFunction *MF,
} }
} }
/// getLabelBeforeInsn - Return Label preceding the instruction. // Return Label preceding the instruction.
const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) { const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
MCSymbol *Label = LabelsBeforeInsn.lookup(MI); MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
assert(Label && "Didn't insert label before instruction"); assert(Label && "Didn't insert label before instruction");
return Label; return Label;
} }
/// getLabelAfterInsn - Return Label immediately following the instruction. // Return Label immediately following the instruction.
const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) { const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
return LabelsAfterInsn.lookup(MI); return LabelsAfterInsn.lookup(MI);
} }
/// beginInstruction - Process beginning of an instruction. // Process beginning of an instruction.
void DwarfDebug::beginInstruction(const MachineInstr *MI) { void DwarfDebug::beginInstruction(const MachineInstr *MI) {
// Check if source location changes, but ignore DBG_VALUE locations. // Check if source location changes, but ignore DBG_VALUE locations.
if (!MI->isDebugValue()) { if (!MI->isDebugValue()) {
@ -1258,7 +1250,7 @@ void DwarfDebug::beginInstruction(const MachineInstr *MI) {
I->second = PrevLabel; I->second = PrevLabel;
} }
/// endInstruction - Process end of an instruction. // Process end of an instruction.
void DwarfDebug::endInstruction(const MachineInstr *MI) { void DwarfDebug::endInstruction(const MachineInstr *MI) {
// Don't create a new label after DBG_VALUE instructions. // Don't create a new label after DBG_VALUE instructions.
// They don't generate code. // They don't generate code.
@ -1284,11 +1276,10 @@ void DwarfDebug::endInstruction(const MachineInstr *MI) {
I->second = PrevLabel; I->second = PrevLabel;
} }
/// identifyScopeMarkers() - // Each LexicalScope has first instruction and last instruction to mark
/// Each LexicalScope has first instruction and last instruction to mark // beginning and end of a scope respectively. Create an inverse map that list
/// beginning and end of a scope respectively. Create an inverse map that list // scopes starts (and ends) with an instruction. One instruction may start (or
/// scopes starts (and ends) with an instruction. One instruction may start (or // end) multiple scopes. Ignore scopes that are not reachable.
/// end) multiple scopes. Ignore scopes that are not reachable.
void DwarfDebug::identifyScopeMarkers() { void DwarfDebug::identifyScopeMarkers() {
SmallVector<LexicalScope *, 4> WorkList; SmallVector<LexicalScope *, 4> WorkList;
WorkList.push_back(LScopes.getCurrentFunctionScope()); WorkList.push_back(LScopes.getCurrentFunctionScope());
@ -1317,15 +1308,15 @@ void DwarfDebug::identifyScopeMarkers() {
} }
} }
/// getScopeNode - Get MDNode for DebugLoc's scope. // Get MDNode for DebugLoc's scope.
static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) { static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
if (MDNode *InlinedAt = DL.getInlinedAt(Ctx)) if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx); return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
return DL.getScope(Ctx); return DL.getScope(Ctx);
} }
/// getFnDebugLoc - Walk up the scope chain of given debug loc and find // Walk up the scope chain of given debug loc and find line number info
/// line number info for the function. // for the function.
static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) { static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
const MDNode *Scope = getScopeNode(DL, Ctx); const MDNode *Scope = getScopeNode(DL, Ctx);
DISubprogram SP = getDISubprogram(Scope); DISubprogram SP = getDISubprogram(Scope);
@ -1341,8 +1332,8 @@ static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
return DebugLoc(); return DebugLoc();
} }
/// beginFunction - Gather pre-function debug information. Assumes being // Gather pre-function debug information. Assumes being called immediately
/// emitted immediately after the function entry point. // after the function entry point has been emitted.
void DwarfDebug::beginFunction(const MachineFunction *MF) { void DwarfDebug::beginFunction(const MachineFunction *MF) {
if (!MMI->hasDebugInfo()) return; if (!MMI->hasDebugInfo()) return;
LScopes.initialize(*MF); LScopes.initialize(*MF);
@ -1357,7 +1348,7 @@ void DwarfDebug::beginFunction(const MachineFunction *MF) {
assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned"); assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
/// LiveUserVar - Map physreg numbers to the MDNode they contain. // LiveUserVar - Map physreg numbers to the MDNode they contain.
std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs()); std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
@ -1522,8 +1513,7 @@ void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
// Vars.push_back(Var); // Vars.push_back(Var);
} }
/// endFunction - Gather and emit post-function debug information. // Gather and emit post-function debug information.
///
void DwarfDebug::endFunction(const MachineFunction *MF) { void DwarfDebug::endFunction(const MachineFunction *MF) {
if (!MMI->hasDebugInfo() || LScopes.empty()) return; if (!MMI->hasDebugInfo() || LScopes.empty()) return;
@ -1588,9 +1578,8 @@ void DwarfDebug::endFunction(const MachineFunction *MF) {
PrevLabel = NULL; PrevLabel = NULL;
} }
/// recordSourceLine - Register a source line with debug info. Returns the // Register a source line with debug info. Returns the unique label that was
/// unique label that was emitted and which provides correspondence to // emitted and which provides correspondence to the source line list.
/// the source line list.
void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S, void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
unsigned Flags) { unsigned Flags) {
StringRef Fn; StringRef Fn;
@ -1631,8 +1620,7 @@ void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
// Emit Methods // Emit Methods
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// computeSizeAndOffset - Compute the size and offset of a DIE. // Compute the size and offset of a DIE.
///
unsigned unsigned
DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) { DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
// Get the children. // Get the children.
@ -1675,8 +1663,7 @@ DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
return Offset; return Offset;
} }
/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. // Compute the size and offset of all the DIEs.
///
void DwarfDebug::computeSizeAndOffsets() { void DwarfDebug::computeSizeAndOffsets() {
for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(), for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
E = CUMap.end(); I != E; ++I) { E = CUMap.end(); I != E; ++I) {
@ -1690,8 +1677,7 @@ void DwarfDebug::computeSizeAndOffsets() {
} }
} }
/// emitSectionLabels - Emit initial Dwarf sections with a label at // Emit initial Dwarf sections with a label at the start of each one.
/// the start of each one.
void DwarfDebug::emitSectionLabels() { void DwarfDebug::emitSectionLabels() {
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
@ -1720,8 +1706,7 @@ void DwarfDebug::emitSectionLabels() {
emitSectionSym(Asm, TLOF.getDataSection()); emitSectionSym(Asm, TLOF.getDataSection());
} }
/// emitDIE - Recursively emits a debug information entry. // Recursively emits a debug information entry.
///
void DwarfDebug::emitDIE(DIE *Die) { void DwarfDebug::emitDIE(DIE *Die) {
// Get the abbreviation for this DIE. // Get the abbreviation for this DIE.
unsigned AbbrevNumber = Die->getAbbrevNumber(); unsigned AbbrevNumber = Die->getAbbrevNumber();
@ -1810,8 +1795,7 @@ void DwarfDebug::emitDIE(DIE *Die) {
} }
} }
/// emitDebugInfo - Emit the debug info section. // Emit the debug info section.
///
void DwarfDebug::emitDebugInfo() { void DwarfDebug::emitDebugInfo() {
// Start debug info section. // Start debug info section.
Asm->OutStreamer.SwitchSection( Asm->OutStreamer.SwitchSection(
@ -1846,8 +1830,7 @@ void DwarfDebug::emitDebugInfo() {
} }
} }
/// emitAbbreviations - Emit the abbreviation section. // Emit the abbreviation section.
///
void DwarfDebug::emitAbbreviations() { void DwarfDebug::emitAbbreviations() {
// Check to see if it is worth the effort. // Check to see if it is worth the effort.
if (!Abbreviations.empty()) { if (!Abbreviations.empty()) {
@ -1876,9 +1859,7 @@ void DwarfDebug::emitAbbreviations() {
} }
} }
/// emitEndOfLineMatrix - Emit the last address of the section and the end of // Emit the last address of the section and the end of the line matrix.
/// the line matrix.
///
void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
// Define last address of section. // Define last address of section.
Asm->OutStreamer.AddComment("Extended Op"); Asm->OutStreamer.AddComment("Extended Op");
@ -1902,8 +1883,7 @@ void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
Asm->EmitInt8(1); Asm->EmitInt8(1);
} }
/// emitAccelNames - Emit visible names into a hashed accelerator table // Emit visible names into a hashed accelerator table section.
/// section.
void DwarfDebug::emitAccelNames() { void DwarfDebug::emitAccelNames() {
DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
dwarf::DW_FORM_data4)); dwarf::DW_FORM_data4));
@ -1931,8 +1911,7 @@ void DwarfDebug::emitAccelNames() {
AT.Emit(Asm, SectionBegin, this); AT.Emit(Asm, SectionBegin, this);
} }
/// emitAccelObjC - Emit objective C classes and categories into a hashed // Emit objective C classes and categories into a hashed accelerator table section.
/// accelerator table section.
void DwarfDebug::emitAccelObjC() { void DwarfDebug::emitAccelObjC() {
DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
dwarf::DW_FORM_data4)); dwarf::DW_FORM_data4));
@ -1960,8 +1939,7 @@ void DwarfDebug::emitAccelObjC() {
AT.Emit(Asm, SectionBegin, this); AT.Emit(Asm, SectionBegin, this);
} }
/// emitAccelNamespace - Emit namespace dies into a hashed accelerator // Emit namespace dies into a hashed accelerator table.
/// table.
void DwarfDebug::emitAccelNamespaces() { void DwarfDebug::emitAccelNamespaces() {
DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
dwarf::DW_FORM_data4)); dwarf::DW_FORM_data4));
@ -1989,7 +1967,7 @@ void DwarfDebug::emitAccelNamespaces() {
AT.Emit(Asm, SectionBegin, this); AT.Emit(Asm, SectionBegin, this);
} }
/// emitAccelTypes() - Emit type dies into a hashed accelerator table. // Emit type dies into a hashed accelerator table.
void DwarfDebug::emitAccelTypes() { void DwarfDebug::emitAccelTypes() {
std::vector<DwarfAccelTable::Atom> Atoms; std::vector<DwarfAccelTable::Atom> Atoms;
Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset, Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
@ -2072,8 +2050,7 @@ void DwarfDebug::emitDebugPubTypes() {
} }
} }
/// emitDebugStr - Emit visible names into a debug str section. // Emit visible names into a debug str section.
///
void DwarfDebug::emitDebugStr() { void DwarfDebug::emitDebugStr() {
// Check to see if it is worth the effort. // Check to see if it is worth the effort.
if (StringPool.empty()) return; if (StringPool.empty()) return;
@ -2104,8 +2081,7 @@ void DwarfDebug::emitDebugStr() {
} }
} }
/// emitDebugLoc - Emit visible names into a debug loc section. // Emit visible names into a debug loc section.
///
void DwarfDebug::emitDebugLoc() { void DwarfDebug::emitDebugLoc() {
if (DotDebugLocEntries.empty()) if (DotDebugLocEntries.empty())
return; return;
@ -2204,16 +2180,14 @@ void DwarfDebug::emitDebugLoc() {
} }
} }
/// emitDebugARanges - Emit visible names into a debug aranges section. // Emit visible names into a debug aranges section.
///
void DwarfDebug::emitDebugARanges() { void DwarfDebug::emitDebugARanges() {
// Start the dwarf aranges section. // Start the dwarf aranges section.
Asm->OutStreamer.SwitchSection( Asm->OutStreamer.SwitchSection(
Asm->getObjFileLowering().getDwarfARangesSection()); Asm->getObjFileLowering().getDwarfARangesSection());
} }
/// emitDebugRanges - Emit visible names into a debug ranges section. // Emit visible names into a debug ranges section.
///
void DwarfDebug::emitDebugRanges() { void DwarfDebug::emitDebugRanges() {
// Start the dwarf ranges section. // Start the dwarf ranges section.
Asm->OutStreamer.SwitchSection( Asm->OutStreamer.SwitchSection(
@ -2229,8 +2203,7 @@ void DwarfDebug::emitDebugRanges() {
} }
} }
/// emitDebugMacInfo - Emit visible names into a debug macinfo section. // Emit visible names into a debug macinfo section.
///
void DwarfDebug::emitDebugMacInfo() { void DwarfDebug::emitDebugMacInfo() {
if (const MCSection *LineInfo = if (const MCSection *LineInfo =
Asm->getObjFileLowering().getDwarfMacroInfoSection()) { Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
@ -2239,24 +2212,24 @@ void DwarfDebug::emitDebugMacInfo() {
} }
} }
/// emitDebugInlineInfo - Emit inline info using following format. // Emit inline info using following format.
/// Section Header: // Section Header:
/// 1. length of section // 1. length of section
/// 2. Dwarf version number // 2. Dwarf version number
/// 3. address size. // 3. address size.
/// //
/// Entries (one "entry" for each function that was inlined): // Entries (one "entry" for each function that was inlined):
/// //
/// 1. offset into __debug_str section for MIPS linkage name, if exists; // 1. offset into __debug_str section for MIPS linkage name, if exists;
/// otherwise offset into __debug_str for regular function name. // otherwise offset into __debug_str for regular function name.
/// 2. offset into __debug_str section for regular function name. // 2. offset into __debug_str section for regular function name.
/// 3. an unsigned LEB128 number indicating the number of distinct inlining // 3. an unsigned LEB128 number indicating the number of distinct inlining
/// instances for the function. // instances for the function.
/// //
/// The rest of the entry consists of a {die_offset, low_pc} pair for each // The rest of the entry consists of a {die_offset, low_pc} pair for each
/// inlined instance; the die_offset points to the inlined_subroutine die in the // inlined instance; the die_offset points to the inlined_subroutine die in the
/// __debug_info section, and the low_pc is the starting address for the // __debug_info section, and the low_pc is the starting address for the
/// inlining instance. // inlining instance.
void DwarfDebug::emitDebugInlineInfo() { void DwarfDebug::emitDebugInlineInfo() {
if (!Asm->MAI->doesDwarfUseInlineInfoSection()) if (!Asm->MAI->doesDwarfUseInlineInfoSection())
return; return;

269
lib/CodeGen/AsmPrinter/DwarfDebug.h
View File

@ -43,8 +43,7 @@ class DIEBlock;
class DIEEntry; class DIEEntry;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// SrcLineInfo - This class is used to record source line correspondence. /// \brief This class is used to record source line correspondence.
///
class SrcLineInfo { class SrcLineInfo {
unsigned Line; // Source line number. unsigned Line; // Source line number.
unsigned Column; // Source column. unsigned Column; // Source column.
@ -61,8 +60,8 @@ public:
MCSymbol *getLabel() const { return Label; } MCSymbol *getLabel() const { return Label; }
}; };
/// DotDebugLocEntry - This struct describes location entries emitted in /// \brief This struct describes location entries emitted in the .debug_loc
/// .debug_loc section. /// section.
typedef struct DotDebugLocEntry { typedef struct DotDebugLocEntry {
const MCSymbol *Begin; const MCSymbol *Begin;
const MCSymbol *End; const MCSymbol *End;
@ -101,7 +100,7 @@ typedef struct DotDebugLocEntry {
: Begin(B), End(E), Variable(0), Merged(false), : Begin(B), End(E), Variable(0), Merged(false),
Constant(true) { Constants.CIP = IPtr; EntryKind = E_ConstantInt; } Constant(true) { Constants.CIP = IPtr; EntryKind = E_ConstantInt; }
/// Empty entries are also used as a trigger to emit temp label. Such /// \brief Empty entries are also used as a trigger to emit temp label. Such
/// labels are referenced is used to find debug_loc offset for a given DIE. /// labels are referenced is used to find debug_loc offset for a given DIE.
bool isEmpty() { return Begin == 0 && End == 0; } bool isEmpty() { return Begin == 0 && End == 0; }
bool isMerged() { return Merged; } bool isMerged() { return Merged; }
@ -121,8 +120,7 @@ typedef struct DotDebugLocEntry {
} DotDebugLocEntry; } DotDebugLocEntry;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// DbgVariable - This class is used to track local variable information. /// \brief This class is used to track local variable information.
///
class DbgVariable { class DbgVariable {
DIVariable Var; // Variable Descriptor. DIVariable Var; // Variable Descriptor.
DIE *TheDIE; // Variable DIE. DIE *TheDIE; // Variable DIE.
@ -155,7 +153,7 @@ public:
return dwarf::DW_TAG_variable; return dwarf::DW_TAG_variable;
} }
/// isArtificial - Return true if DbgVariable is artificial. /// \brief Return true if DbgVariable is artificial.
bool isArtificial() const { bool isArtificial() const {
if (Var.isArtificial()) if (Var.isArtificial())
return true; return true;
@ -190,14 +188,15 @@ public:
DIType getType() const; DIType getType() const;
}; };
/// \brief Collects and handles dwarf debug information.
class DwarfDebug { class DwarfDebug {
/// Asm - Target of Dwarf emission. // Target of Dwarf emission.
AsmPrinter *Asm; AsmPrinter *Asm;
/// MMI - Collected machine module information. // Collected machine module information.
MachineModuleInfo *MMI; MachineModuleInfo *MMI;
/// DIEValueAllocator - All DIEValues are allocated through this allocator. // All DIEValues are allocated through this allocator.
BumpPtrAllocator DIEValueAllocator; BumpPtrAllocator DIEValueAllocator;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
@ -206,92 +205,86 @@ class DwarfDebug {
CompileUnit *FirstCU; CompileUnit *FirstCU;
/// Maps MDNode with its corresponding CompileUnit. // Maps MDNode with its corresponding CompileUnit.
DenseMap <const MDNode *, CompileUnit *> CUMap; DenseMap <const MDNode *, CompileUnit *> CUMap;
/// Maps subprogram MDNode with its corresponding CompileUnit. // Maps subprogram MDNode with its corresponding CompileUnit.
DenseMap <const MDNode *, CompileUnit *> SPMap; DenseMap <const MDNode *, CompileUnit *> SPMap;
/// AbbreviationsSet - Used to uniquely define abbreviations. // Used to uniquely define abbreviations.
///
FoldingSet<DIEAbbrev> AbbreviationsSet; FoldingSet<DIEAbbrev> AbbreviationsSet;
/// Abbreviations - A list of all the unique abbreviations in use. // A list of all the unique abbreviations in use.
///
std::vector<DIEAbbrev *> Abbreviations; std::vector<DIEAbbrev *> Abbreviations;
/// SourceIdMap - Source id map, i.e. pair of source filename and directory, // Source id map, i.e. pair of source filename and directory,
/// separated by a zero byte, mapped to a unique id. // separated by a zero byte, mapped to a unique id.
StringMap<unsigned, BumpPtrAllocator&> SourceIdMap; StringMap<unsigned, BumpPtrAllocator&> SourceIdMap;
/// StringPool - A String->Symbol mapping of strings used by indirect // A String->Symbol mapping of strings used by indirect
/// references. // references.
StringMap<std::pair<MCSymbol*, unsigned>, BumpPtrAllocator&> StringPool; StringMap<std::pair<MCSymbol*, unsigned>, BumpPtrAllocator&> StringPool;
unsigned NextStringPoolNumber; unsigned NextStringPoolNumber;
/// SectionMap - Provides a unique id per text section. // Provides a unique id per text section.
///
SetVector<const MCSection*> SectionMap; SetVector<const MCSection*> SectionMap;
/// CurrentFnArguments - List of Arguments (DbgValues) for current function. // List of Arguments (DbgValues) for current function.
SmallVector<DbgVariable *, 8> CurrentFnArguments; SmallVector<DbgVariable *, 8> CurrentFnArguments;
LexicalScopes LScopes; LexicalScopes LScopes;
/// AbstractSPDies - Collection of abstract subprogram DIEs. // Collection of abstract subprogram DIEs.
DenseMap<const MDNode *, DIE *> AbstractSPDies; DenseMap<const MDNode *, DIE *> AbstractSPDies;
/// ScopeVariables - Collection of dbg variables of a scope. // Collection of dbg variables of a scope.
DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> > ScopeVariables; DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> > ScopeVariables;
/// AbstractVariables - Collection of abstract variables. // Collection of abstract variables.
DenseMap<const MDNode *, DbgVariable *> AbstractVariables; DenseMap<const MDNode *, DbgVariable *> AbstractVariables;
/// DotDebugLocEntries - Collection of DotDebugLocEntry. // Collection of DotDebugLocEntry.
SmallVector<DotDebugLocEntry, 4> DotDebugLocEntries; SmallVector<DotDebugLocEntry, 4> DotDebugLocEntries;
/// InlinedSubprogramDIEs - Collection of subprogram DIEs that are marked // Collection of subprogram DIEs that are marked (at the end of the module)
/// (at the end of the module) as DW_AT_inline. // as DW_AT_inline.
SmallPtrSet<DIE *, 4> InlinedSubprogramDIEs; SmallPtrSet<DIE *, 4> InlinedSubprogramDIEs;
/// InlineInfo - Keep track of inlined functions and their location. This // Keep track of inlined functions and their location. This
/// information is used to populate the debug_inlined section. // information is used to populate the debug_inlined section.
typedef std::pair<const MCSymbol *, DIE *> InlineInfoLabels; typedef std::pair<const MCSymbol *, DIE *> InlineInfoLabels;
DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> > InlineInfo; DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> > InlineInfo;
SmallVector<const MDNode *, 4> InlinedSPNodes; SmallVector<const MDNode *, 4> InlinedSPNodes;
// ProcessedSPNodes - This is a collection of subprogram MDNodes that // This is a collection of subprogram MDNodes that are processed to create DIEs.
// are processed to create DIEs.
SmallPtrSet<const MDNode *, 16> ProcessedSPNodes; SmallPtrSet<const MDNode *, 16> ProcessedSPNodes;
/// LabelsBeforeInsn - Maps instruction with label emitted before // Maps instruction with label emitted before instruction.
/// instruction.
DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn; DenseMap<const MachineInstr *, MCSymbol *> LabelsBeforeInsn;
/// LabelsAfterInsn - Maps instruction with label emitted after // Maps instruction with label emitted after instruction.
/// instruction.
DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn; DenseMap<const MachineInstr *, MCSymbol *> LabelsAfterInsn;
/// UserVariables - Every user variable mentioned by a DBG_VALUE instruction // Every user variable mentioned by a DBG_VALUE instruction in order of
/// in order of appearance. // appearance.
SmallVector<const MDNode*, 8> UserVariables; SmallVector<const MDNode*, 8> UserVariables;
/// DbgValues - For each user variable, keep a list of DBG_VALUE // For each user variable, keep a list of DBG_VALUE instructions in order.
/// instructions in order. The list can also contain normal instructions that // The list can also contain normal instructions that clobber the previous
/// clobber the previous DBG_VALUE. // DBG_VALUE.
typedef DenseMap<const MDNode*, SmallVector<const MachineInstr*, 4> > typedef DenseMap<const MDNode*, SmallVector<const MachineInstr*, 4> >
DbgValueHistoryMap; DbgValueHistoryMap;
DbgValueHistoryMap DbgValues; DbgValueHistoryMap DbgValues;
SmallVector<const MCSymbol *, 8> DebugRangeSymbols; SmallVector<const MCSymbol *, 8> DebugRangeSymbols;
/// Previous instruction's location information. This is used to determine // Previous instruction's location information. This is used to determine
/// label location to indicate scope boundries in dwarf debug info. // label location to indicate scope boundries in dwarf debug info.
DebugLoc PrevInstLoc; DebugLoc PrevInstLoc;
MCSymbol *PrevLabel; MCSymbol *PrevLabel;
/// PrologEndLoc - This location indicates end of function prologue and // This location indicates end of function prologue and beginning of function
/// beginning of function body. // body.
DebugLoc PrologEndLoc; DebugLoc PrologEndLoc;
struct FunctionDebugFrameInfo { struct FunctionDebugFrameInfo {
@ -323,183 +316,146 @@ class DwarfDebug {
bool HasDwarfFission; bool HasDwarfFission;
private: private:
/// assignAbbrevNumber - Define a unique number for the abbreviation. /// \brief Define a unique number for the abbreviation.
///
void assignAbbrevNumber(DIEAbbrev &Abbrev); void assignAbbrevNumber(DIEAbbrev &Abbrev);
void addScopeVariable(LexicalScope *LS, DbgVariable *Var); void addScopeVariable(LexicalScope *LS, DbgVariable *Var);
/// findAbstractVariable - Find abstract variable associated with Var. /// \brief Find abstract variable associated with Var.
DbgVariable *findAbstractVariable(DIVariable &Var, DebugLoc Loc); DbgVariable *findAbstractVariable(DIVariable &Var, DebugLoc Loc);
/// updateSubprogramScopeDIE - Find DIE for the given subprogram and /// \brief Find DIE for the given subprogram and attach appropriate
/// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes. /// DW_AT_low_pc and DW_AT_high_pc attributes. If there are global
/// If there are global variables in this scope then create and insert /// variables in this scope then create and insert DIEs for these
/// DIEs for these variables. /// variables.
DIE *updateSubprogramScopeDIE(CompileUnit *SPCU, const MDNode *SPNode); DIE *updateSubprogramScopeDIE(CompileUnit *SPCU, const MDNode *SPNode);
/// constructLexicalScope - Construct new DW_TAG_lexical_block /// \brief Construct new DW_TAG_lexical_block for this scope and
/// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels. /// attach DW_AT_low_pc/DW_AT_high_pc labels.
DIE *constructLexicalScopeDIE(CompileUnit *TheCU, LexicalScope *Scope); DIE *constructLexicalScopeDIE(CompileUnit *TheCU, LexicalScope *Scope);
/// constructInlinedScopeDIE - This scope represents inlined body of /// \brief This scope represents inlined body of a function. Construct
/// a function. Construct DIE to represent this concrete inlined copy /// DIE to represent this concrete inlined copy of the function.
/// of the function.
DIE *constructInlinedScopeDIE(CompileUnit *TheCU, LexicalScope *Scope); DIE *constructInlinedScopeDIE(CompileUnit *TheCU, LexicalScope *Scope);
/// constructScopeDIE - Construct a DIE for this scope. /// \brief Construct a DIE for this scope.
DIE *constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope); DIE *constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope);
/// emitSectionLabels - Emit initial Dwarf sections with a label at /// \brief Emit initial Dwarf sections with a label at the start of each one.
/// the start of each one.
void emitSectionLabels(); void emitSectionLabels();
/// emitDIE - Recursively Emits a debug information entry. /// \brief Recursively Emits a debug information entry.
///
void emitDIE(DIE *Die); void emitDIE(DIE *Die);
/// computeSizeAndOffset - Compute the size and offset of a DIE given /// \brief Compute the size and offset of a DIE given an incoming Offset.
/// an incoming Offset.
///
unsigned computeSizeAndOffset(DIE *Die, unsigned Offset); unsigned computeSizeAndOffset(DIE *Die, unsigned Offset);
/// computeSizeAndOffsets - Compute the size and offset of all the DIEs. /// \brief Compute the size and offset of all the DIEs.
///
void computeSizeAndOffsets(); void computeSizeAndOffsets();
/// computeInlinedDIEs - Attach DW_AT_inline attribute with inlined /// \brief Attach DW_AT_inline attribute with inlined subprogram DIEs.
/// subprogram DIEs.
void computeInlinedDIEs(); void computeInlinedDIEs();
/// collectDeadVariables - Collect info for variables that were optimized out. /// \brief Collect info for variables that were optimized out.
void collectDeadVariables(); void collectDeadVariables();
/// finalizeModuleInfo - Finish off debug information after all functions /// \brief Finish off debug information after all functions have been
/// have been processed. /// processed.
void finalizeModuleInfo(); void finalizeModuleInfo();
/// endSections - Emit labels to close any remaining sections that have /// \brief Emit labels to close any remaining sections that have been left
/// been left open. /// open.
void endSections(); void endSections();
/// emitDebugInfo - Emit the debug info section. /// \brief Emit the debug info section.
///
void emitDebugInfo(); void emitDebugInfo();
/// emitAbbreviations - Emit the abbreviation section. /// \brief Emit the abbreviation section.
///
void emitAbbreviations(); void emitAbbreviations();
/// emitEndOfLineMatrix - Emit the last address of the section and the end of /// \brief Emit the last address of the section and the end of
/// the line matrix. /// the line matrix.
///
void emitEndOfLineMatrix(unsigned SectionEnd); void emitEndOfLineMatrix(unsigned SectionEnd);
/// emitAccelNames - Emit visible names into a hashed accelerator table /// \brief Emit visible names into a hashed accelerator table section.
/// section.
void emitAccelNames(); void emitAccelNames();
/// emitAccelObjC - Emit objective C classes and categories into a hashed /// \brief Emit objective C classes and categories into a hashed
/// accelerator table section. /// accelerator table section.
void emitAccelObjC(); void emitAccelObjC();
/// emitAccelNamespace - Emit namespace dies into a hashed accelerator /// \brief Emit namespace dies into a hashed accelerator table.
/// table.
void emitAccelNamespaces(); void emitAccelNamespaces();
/// emitAccelTypes() - Emit type dies into a hashed accelerator table. /// \brief Emit type dies into a hashed accelerator table.
///
void emitAccelTypes(); void emitAccelTypes();
/// emitDebugPubTypes - Emit visible types into a debug pubtypes section. /// \brief Emit visible types into a debug pubtypes section.
///
void emitDebugPubTypes(); void emitDebugPubTypes();
/// emitDebugStr - Emit visible names into a debug str section. /// \brief Emit visible names into a debug str section.
///
void emitDebugStr(); void emitDebugStr();
/// emitDebugLoc - Emit visible names into a debug loc section. /// \brief Emit visible names into a debug loc section.
///
void emitDebugLoc(); void emitDebugLoc();
/// emitDebugARanges - Emit visible names into a debug aranges section. /// \brief Emit visible names into a debug aranges section.
///
void emitDebugARanges(); void emitDebugARanges();
/// emitDebugRanges - Emit visible names into a debug ranges section. /// \brief Emit visible names into a debug ranges section.
///
void emitDebugRanges(); void emitDebugRanges();
/// emitDebugMacInfo - Emit visible names into a debug macinfo section. /// \brief Emit visible names into a debug macinfo section.
///
void emitDebugMacInfo(); void emitDebugMacInfo();
/// emitDebugInlineInfo - Emit inline info using following format. /// \brief Emit inline info using custom format.
/// Section Header:
/// 1. length of section
/// 2. Dwarf version number
/// 3. address size.
///
/// Entries (one "entry" for each function that was inlined):
///
/// 1. offset into __debug_str section for MIPS linkage name, if exists;
/// otherwise offset into __debug_str for regular function name.
/// 2. offset into __debug_str section for regular function name.
/// 3. an unsigned LEB128 number indicating the number of distinct inlining
/// instances for the function.
///
/// The rest of the entry consists of a {die_offset, low_pc} pair for each
/// inlined instance; the die_offset points to the inlined_subroutine die in
/// the __debug_info section, and the low_pc is the starting address for the
/// inlining instance.
void emitDebugInlineInfo(); void emitDebugInlineInfo();
/// constructCompileUnit - Create new CompileUnit for the given /// \brief Create new CompileUnit for the given metadata node with tag
/// metadata node with tag DW_TAG_compile_unit. /// DW_TAG_compile_unit.
CompileUnit *constructCompileUnit(const MDNode *N); CompileUnit *constructCompileUnit(const MDNode *N);
/// construct SubprogramDIE - Construct subprogram DIE. /// \brief Construct subprogram DIE.
void constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N); void constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N);
/// recordSourceLine - Register a source line with debug info. Returns the /// \brief Register a source line with debug info. Returns the unique
/// unique label that was emitted and which provides correspondence to /// label that was emitted and which provides correspondence to the
/// the source line list. /// source line list.
void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope, void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
unsigned Flags); unsigned Flags);
/// identifyScopeMarkers() - Indentify instructions that are marking the /// \brief Indentify instructions that are marking the beginning of or
/// beginning of or ending of a scope. /// ending of a scope.
void identifyScopeMarkers(); void identifyScopeMarkers();
/// addCurrentFnArgument - If Var is an current function argument that add /// \brief If Var is an current function argument that add it in
/// it in CurrentFnArguments list. /// CurrentFnArguments list.
bool addCurrentFnArgument(const MachineFunction *MF, bool addCurrentFnArgument(const MachineFunction *MF,
DbgVariable *Var, LexicalScope *Scope); DbgVariable *Var, LexicalScope *Scope);
/// collectVariableInfo - Populate LexicalScope entries with variables' info. /// \brief Populate LexicalScope entries with variables' info.
void collectVariableInfo(const MachineFunction *, void collectVariableInfo(const MachineFunction *,
SmallPtrSet<const MDNode *, 16> &ProcessedVars); SmallPtrSet<const MDNode *, 16> &ProcessedVars);
/// collectVariableInfoFromMMITable - Collect variable information from /// \brief Collect variable information from the side table maintained
/// side table maintained by MMI. /// by MMI.
void collectVariableInfoFromMMITable(const MachineFunction * MF, void collectVariableInfoFromMMITable(const MachineFunction * MF,
SmallPtrSet<const MDNode *, 16> &P); SmallPtrSet<const MDNode *, 16> &P);
/// requestLabelBeforeInsn - Ensure that a label will be emitted before MI. /// \brief Ensure that a label will be emitted before MI.
void requestLabelBeforeInsn(const MachineInstr *MI) { void requestLabelBeforeInsn(const MachineInstr *MI) {
LabelsBeforeInsn.insert(std::make_pair(MI, (MCSymbol*)0)); LabelsBeforeInsn.insert(std::make_pair(MI, (MCSymbol*)0));
} }
/// getLabelBeforeInsn - Return Label preceding the instruction. /// \brief Return Label preceding the instruction.
const MCSymbol *getLabelBeforeInsn(const MachineInstr *MI); const MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
/// requestLabelAfterInsn - Ensure that a label will be emitted after MI. /// \brief Ensure that a label will be emitted after MI.
void requestLabelAfterInsn(const MachineInstr *MI) { void requestLabelAfterInsn(const MachineInstr *MI) {
LabelsAfterInsn.insert(std::make_pair(MI, (MCSymbol*)0)); LabelsAfterInsn.insert(std::make_pair(MI, (MCSymbol*)0));
} }
/// getLabelAfterInsn - Return Label immediately following the instruction. /// \brief Return Label immediately following the instruction.
const MCSymbol *getLabelAfterInsn(const MachineInstr *MI); const MCSymbol *getLabelAfterInsn(const MachineInstr *MI);
public: public:
@ -509,60 +465,57 @@ public:
DwarfDebug(AsmPrinter *A, Module *M); DwarfDebug(AsmPrinter *A, Module *M);
~DwarfDebug(); ~DwarfDebug();
/// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such /// \brief Collect debug info from named mdnodes such as llvm.dbg.enum
/// as llvm.dbg.enum and llvm.dbg.ty /// and llvm.dbg.ty
void collectInfoFromNamedMDNodes(const Module *M); void collectInfoFromNamedMDNodes(const Module *M);
/// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder. /// \brief Collect debug info using DebugInfoFinder.
/// FIXME - Remove this when DragonEgg switches to DIBuilder. /// FIXME - Remove this when DragonEgg switches to DIBuilder.
bool collectLegacyDebugInfo(const Module *M); bool collectLegacyDebugInfo(const Module *M);
/// beginModule - Emit all Dwarf sections that should come prior to the /// \brief Emit all Dwarf sections that should come prior to the
/// content. /// content.
void beginModule(); void beginModule();
/// endModule - Emit all Dwarf sections that should come after the content. /// \brief Emit all Dwarf sections that should come after the content.
///
void endModule(); void endModule();
/// beginFunction - Gather pre-function debug information. Assumes being /// \brief Gather pre-function debug information.
/// emitted immediately after the function entry point.
void beginFunction(const MachineFunction *MF); void beginFunction(const MachineFunction *MF);
/// endFunction - Gather and emit post-function debug information. /// \brief Gather and emit post-function debug information.
///
void endFunction(const MachineFunction *MF); void endFunction(const MachineFunction *MF);
/// beginInstruction - Process beginning of an instruction. /// \brief Process beginning of an instruction.
void beginInstruction(const MachineInstr *MI); void beginInstruction(const MachineInstr *MI);
/// endInstruction - Prcess end of an instruction. /// \brief Process end of an instruction.
void endInstruction(const MachineInstr *MI); void endInstruction(const MachineInstr *MI);
/// getOrCreateSourceID - Look up the source id with the given directory and /// \brief Look up the source id with the given directory and source file
/// source file names. If none currently exists, create a new id and insert it /// names. If none currently exists, create a new id and insert it in the
/// in the SourceIds map. /// SourceIds map.
unsigned getOrCreateSourceID(StringRef DirName, StringRef FullName); unsigned getOrCreateSourceID(StringRef DirName, StringRef FullName);
/// getStringPool - returns the entry into the start of the pool. /// \brief Returns the entry into the start of the pool.
MCSymbol *getStringPool(); MCSymbol *getStringPool();
/// getStringPoolEntry - returns an entry into the string pool with the given /// \brief Returns an entry into the string pool with the given
/// string text. /// string text.
MCSymbol *getStringPoolEntry(StringRef Str); MCSymbol *getStringPoolEntry(StringRef Str);
/// useDarwinGDBCompat - returns whether or not to limit some of our debug /// \brief Returns whether or not to limit some of our debug
/// output to the limitations of darwin gdb. /// output to the limitations of darwin gdb.
bool useDarwinGDBCompat() { return IsDarwinGDBCompat; } bool useDarwinGDBCompat() { return IsDarwinGDBCompat; }
// Experimental DWARF5 features. // Experimental DWARF5 features.
/// useDwarfAccelTables - returns whether or not to emit tables that /// \brief Returns whether or not to emit tables that dwarf consumers can
/// dwarf consumers can use to accelerate lookup. /// use to accelerate lookup.
bool useDwarfAccelTables() { return HasDwarfAccelTables; } bool useDwarfAccelTables() { return HasDwarfAccelTables; }
/// useDwarfFission - returns whether or not to change the current debug /// \brief Returns whether or not to change the current debug info for the
/// info for the fission proposal support. /// fission proposal support.
bool useDwarfFission() { return HasDwarfFission; } bool useDwarfFission() { return HasDwarfFission; }
}; };
} // End of namespace llvm } // End of namespace llvm