cl::desc("Make an absence of debug location information explicit."),
cl::init(false));
-static cl::opt<bool>
-GenerateODRHash("generate-odr-hash", cl::Hidden,
- cl::desc("Add an ODR hash to external type DIEs."),
- cl::init(false));
-
static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
cl::desc("Add the CU hash as the dwo_id."),
cl::init(false));
static cl::opt<DefaultOnOff>
SplitDwarf("split-dwarf", cl::Hidden,
- cl::desc("Output prototype dwarf split debug info."),
+ cl::desc("Output DWARF5 split debug info."),
cl::values(clEnumVal(Default, "Default for platform"),
clEnumVal(Enable, "Enabled"),
clEnumVal(Disable, "Disabled"), clEnumValEnd),
static cl::opt<unsigned>
DwarfVersionNumber("dwarf-version", cl::Hidden,
- cl::desc("Generate DWARF for dwarf version."),
- cl::init(0));
+ cl::desc("Generate DWARF for dwarf version."), cl::init(0));
+
+static cl::opt<bool>
+DwarfCURanges("generate-dwarf-cu-ranges", cl::Hidden,
+ cl::desc("Generate DW_AT_ranges for compile units"),
+ cl::init(false));
static const char *const DWARFGroupName = "DWARF Emission";
static const char *const DbgTimerName = "DWARF Debug Writer";
//===----------------------------------------------------------------------===//
-// Configuration values for initial hash set sizes (log2).
-//
-static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
-
namespace llvm {
/// resolve - Look in the DwarfDebug map for the MDNode that
}
DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
- : Asm(A), MMI(Asm->MMI), FirstCU(0),
- AbbreviationsSet(InitAbbreviationsSetSize),
- SourceIdMap(DIEValueAllocator), PrevLabel(NULL), GlobalCUIndexCount(0),
- GlobalRangeCount(0), InfoHolder(A, &AbbreviationsSet, Abbreviations,
- "info_string", DIEValueAllocator),
- SkeletonAbbrevSet(InitAbbreviationsSetSize),
- SkeletonHolder(A, &SkeletonAbbrevSet, SkeletonAbbrevs, "skel_string",
- DIEValueAllocator) {
-
- DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
- DwarfStrSectionSym = TextSectionSym = 0;
+ : Asm(A), MMI(Asm->MMI), FirstCU(0), SourceIdMap(DIEValueAllocator),
+ PrevLabel(NULL), GlobalRangeCount(0),
+ InfoHolder(A, "info_string", DIEValueAllocator),
+ SkeletonHolder(A, "skel_string", DIEValueAllocator) {
+
+ DwarfInfoSectionSym = DwarfAbbrevSectionSym = DwarfStrSectionSym = 0;
DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
DwarfAddrSectionSym = 0;
DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
FunctionBeginSym = FunctionEndSym = 0;
- CurFn = 0; CurMI = 0;
+ CurFn = 0;
+ CurMI = 0;
// Turn on accelerator tables for Darwin by default, pubnames by
// default for non-Darwin, and handle split dwarf.
return TmpSym;
}
-DwarfUnits::~DwarfUnits() {
- for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
- ++I)
+DwarfFile::~DwarfFile() {
+ for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
+ I != E; ++I)
delete *I;
}
-MCSymbol *DwarfUnits::getStringPoolSym() {
+MCSymbol *DwarfFile::getStringPoolSym() {
return Asm->GetTempSymbol(StringPref);
}
-MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
+MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
std::pair<MCSymbol *, unsigned> &Entry =
StringPool.GetOrCreateValue(Str).getValue();
if (Entry.first)
return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
}
-unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
+unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
std::pair<MCSymbol *, unsigned> &Entry =
StringPool.GetOrCreateValue(Str).getValue();
if (Entry.first)
return Entry.second;
}
-unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
+unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym) {
return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
}
-unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
+unsigned DwarfFile::getAddrPoolIndex(const MCExpr *Sym) {
std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
if (P.second)
// Define a unique number for the abbreviation.
//
-void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
+void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
// Check the set for priors.
- DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
+ DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
// If it's newly added.
if (InSet == &Abbrev) {
// 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.
-static void addSubprogramNames(Unit *TheU, DISubprogram SP, DIE *Die) {
+static void addSubprogramNames(DwarfUnit *TheU, DISubprogram SP, DIE *Die) {
if (!SP.isDefinition())
return;
TheU->addAccelName(SP.getName(), Die);
// 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 *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram SP) {
+DIE *DwarfDebug::updateSubprogramScopeDIE(DwarfCompileUnit *SPCU,
+ DISubprogram SP) {
DIE *SPDie = SPCU->getDIE(SP);
assert(SPDie && "Unable to find subprogram DIE!");
}
}
- MCSymbol *FuncBegin =
- Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
- MCSymbol *FuncEnd = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
- SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FuncBegin);
- SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FuncEnd);
+ SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc, FunctionBeginSym);
+ SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc, FunctionEndSym);
+
+ // Add this range to the list of ranges for the CU.
+ RangeSpan Span(FunctionBeginSym, FunctionEndSym);
+ SPCU->addRange(llvm_move(Span));
const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
MachineLocation Location(RI->getFrameRegister(*Asm->MF));
return !End;
}
-void DwarfDebug::addScopeRangeList(CompileUnit *TheCU, DIE *ScopeDIE,
+static void addSectionLabel(AsmPrinter *Asm, DwarfUnit *U, DIE *D,
+ dwarf::Attribute A, const MCSymbol *L,
+ const MCSymbol *Sec) {
+ if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
+ U->addSectionLabel(D, A, L);
+ else
+ U->addSectionDelta(D, A, L, Sec);
+}
+
+void DwarfDebug::addScopeRangeList(DwarfCompileUnit *TheCU, DIE *ScopeDIE,
const SmallVectorImpl<InsnRange> &Range) {
// Emit offset in .debug_range as a relocatable label. emitDIE will handle
// emitting it appropriately.
- TheCU->addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges,
- Asm->GetTempSymbol("debug_ranges", GlobalRangeCount));
- RangeSpanList *List = new RangeSpanList(GlobalRangeCount++);
+ MCSymbol *RangeSym = Asm->GetTempSymbol("debug_ranges", GlobalRangeCount++);
+ addSectionLabel(Asm, TheCU, ScopeDIE, dwarf::DW_AT_ranges, RangeSym,
+ DwarfDebugRangeSectionSym);
+
+ RangeSpanList List(RangeSym);
for (SmallVectorImpl<InsnRange>::const_iterator RI = Range.begin(),
RE = Range.end();
RI != RE; ++RI) {
RangeSpan Span(getLabelBeforeInsn(RI->first),
getLabelAfterInsn(RI->second));
- List->addRange(Span);
+ List.addRange(llvm_move(Span));
}
// Add the range list to the set of ranges to be emitted.
- TheCU->addRangeList(List);
+ TheCU->addRangeList(llvm_move(List));
}
// Construct new DW_TAG_lexical_block for this scope and attach
// DW_AT_low_pc/DW_AT_high_pc labels.
-DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
+DIE *DwarfDebug::constructLexicalScopeDIE(DwarfCompileUnit *TheCU,
LexicalScope *Scope) {
if (isLexicalScopeDIENull(Scope))
return 0;
// This scope represents inlined body of a function. Construct DIE to
// represent this concrete inlined copy of the function.
-DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
+DIE *DwarfDebug::constructInlinedScopeDIE(DwarfCompileUnit *TheCU,
LexicalScope *Scope) {
const SmallVectorImpl<InsnRange> &ScopeRanges = Scope->getRanges();
- assert(ScopeRanges.empty() == false &&
+ assert(!ScopeRanges.empty() &&
"LexicalScope does not have instruction markers!");
if (!Scope->getScopeNode())
return ScopeDIE;
}
-DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
+DIE *DwarfDebug::createScopeChildrenDIE(DwarfCompileUnit *TheCU,
+ LexicalScope *Scope,
SmallVectorImpl<DIE *> &Children) {
DIE *ObjectPointer = NULL;
}
// Construct a DIE for this scope.
-DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
+DIE *DwarfDebug::constructScopeDIE(DwarfCompileUnit *TheCU,
+ LexicalScope *Scope) {
if (!Scope || !Scope->getScopeNode())
return NULL;
return SrcId;
}
-// Create new CompileUnit for the given metadata node with tag
+void DwarfDebug::addGnuPubAttributes(DwarfUnit *U, DIE *D) const {
+ if (!GenerateGnuPubSections)
+ return;
+
+ addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubnames,
+ Asm->GetTempSymbol("gnu_pubnames", U->getUniqueID()),
+ DwarfGnuPubNamesSectionSym);
+
+ addSectionLabel(Asm, U, D, dwarf::DW_AT_GNU_pubtypes,
+ Asm->GetTempSymbol("gnu_pubtypes", U->getUniqueID()),
+ DwarfGnuPubTypesSectionSym);
+}
+
+// Create new DwarfCompileUnit for the given metadata node with tag
// DW_TAG_compile_unit.
-CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
+DwarfCompileUnit *DwarfDebug::constructDwarfCompileUnit(DICompileUnit DIUnit) {
StringRef FN = DIUnit.getFilename();
CompilationDir = DIUnit.getDirectory();
DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
- CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, Die, DIUnit, Asm,
- this, &InfoHolder);
+ DwarfCompileUnit *NewCU = new DwarfCompileUnit(
+ InfoHolder.getUnits().size(), Die, DIUnit, Asm, this, &InfoHolder);
+ InfoHolder.addUnit(NewCU);
FileIDCUMap[NewCU->getUniqueID()] = 0;
// Call this to emit a .file directive if it wasn't emitted for the source
DIUnit.getLanguage());
NewCU->addString(Die, dwarf::DW_AT_name, FN);
- // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
- // into an entity. We're using 0 (or a NULL label) for this. For
- // split dwarf it's in the skeleton CU so omit it here.
- if (!useSplitDwarf())
- NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
-
// Define start line table label for each Compile Unit.
MCSymbol *LineTableStartSym =
Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
// The line table entries are not always emitted in assembly, so it
// is not okay to use line_table_start here.
if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(
- Die, dwarf::DW_AT_stmt_list,
- UseTheFirstCU ? Asm->GetTempSymbol("section_line")
- : LineTableStartSym);
+ NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
+ UseTheFirstCU ? Asm->GetTempSymbol("section_line")
+ : LineTableStartSym);
else if (UseTheFirstCU)
NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
else
- NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list,
- LineTableStartSym, DwarfLineSectionSym);
+ NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list, LineTableStartSym,
+ DwarfLineSectionSym);
// If we're using split dwarf the compilation dir is going to be in the
// skeleton CU and so we don't need to duplicate it here.
if (!CompilationDir.empty())
NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
- // Flags to let the linker know we have emitted new style pubnames. Only
- // emit it here if we don't have a skeleton CU for split dwarf.
- if (GenerateGnuPubSections) {
- if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(
- Die, dwarf::DW_AT_GNU_pubnames,
- Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
- else
- NewCU->addSectionDelta(
- Die, dwarf::DW_AT_GNU_pubnames,
- Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
- DwarfGnuPubNamesSectionSym);
-
- if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(
- Die, dwarf::DW_AT_GNU_pubtypes,
- Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
- else
- NewCU->addSectionDelta(
- Die, dwarf::DW_AT_GNU_pubtypes,
- Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
- DwarfGnuPubTypesSectionSym);
- }
+ addGnuPubAttributes(NewCU, Die);
}
if (DIUnit.isOptimized())
if (!FirstCU)
FirstCU = NewCU;
- InfoHolder.addUnit(NewCU);
+ if (useSplitDwarf()) {
+ NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoDWOSection(),
+ DwarfInfoDWOSectionSym);
+ NewCU->setSkeleton(constructSkeletonCU(NewCU));
+ } else
+ NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
+ DwarfInfoSectionSym);
CUMap.insert(std::make_pair(DIUnit, NewCU));
CUDieMap.insert(std::make_pair(Die, NewCU));
}
// Construct subprogram DIE.
-void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
+void DwarfDebug::constructSubprogramDIE(DwarfCompileUnit *TheCU,
+ const MDNode *N) {
// FIXME: We should only call this routine once, however, during LTO if a
// program is defined in multiple CUs we could end up calling it out of
// beginModule as we walk the CUs.
- CompileUnit *&CURef = SPMap[N];
+ DwarfCompileUnit *&CURef = SPMap[N];
if (CURef)
return;
CURef = TheCU;
TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
}
-void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
+void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
const MDNode *N) {
DIImportedEntity Module(N);
if (!Module.Verify())
constructImportedEntityDIE(TheCU, Module, D);
}
-void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
- DIE *Context) {
+void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
+ const MDNode *N, DIE *Context) {
DIImportedEntity Module(N);
if (!Module.Verify())
return;
return constructImportedEntityDIE(TheCU, Module, Context);
}
-void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
+void DwarfDebug::constructImportedEntityDIE(DwarfCompileUnit *TheCU,
const DIImportedEntity &Module,
DIE *Context) {
assert(Module.Verify() &&
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
DICompileUnit CUNode(CU_Nodes->getOperand(i));
- CompileUnit *CU = constructCompileUnit(CUNode);
+ DwarfCompileUnit *CU = constructDwarfCompileUnit(CUNode);
DIArray ImportedEntities = CUNode.getImportedEntities();
for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
ScopesWithImportedEntities.push_back(std::make_pair(
continue;
// Construct subprogram DIE and add variables DIEs.
- CompileUnit *SPCU = static_cast<CompileUnit *>(CUMap.lookup(TheCU));
+ DwarfCompileUnit *SPCU =
+ static_cast<DwarfCompileUnit *>(CUMap.lookup(TheCU));
assert(SPCU && "Unable to find Compile Unit!");
// FIXME: See the comment in constructSubprogramDIE about duplicate
// subprogram DIEs.
}
}
-// Type Signature [7.27] and ODR Hash code.
-
-/// \brief Grabs the string in whichever attribute is passed in and returns
-/// a reference to it. Returns "" if the attribute doesn't exist.
-static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
- DIEValue *V = Die->findAttribute(Attr);
-
- if (DIEString *S = dyn_cast_or_null<DIEString>(V))
- return S->getString();
-
- return StringRef("");
-}
-
-/// Return true if the current DIE is contained within an anonymous namespace.
-static bool isContainedInAnonNamespace(DIE *Die) {
- DIE *Parent = Die->getParent();
-
- while (Parent) {
- if (Parent->getTag() == dwarf::DW_TAG_namespace &&
- getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
- return true;
- Parent = Parent->getParent();
- }
-
- return false;
-}
-
-/// Test if the current CU language is C++ and that we have
-/// a named type that is not contained in an anonymous namespace.
-static bool shouldAddODRHash(TypeUnit *CU, DIE *Die) {
- return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
- getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
- !isContainedInAnonNamespace(Die);
-}
-
void DwarfDebug::finalizeModuleInfo() {
// Collect info for variables that were optimized out.
collectDeadVariables();
// Attach DW_AT_inline attribute with inlined subprogram DIEs.
computeInlinedDIEs();
- // Handle anything that needs to be done on a per-cu basis.
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
+ // Handle anything that needs to be done on a per-unit basis after
+ // all other generation.
+ for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+ E = getUnits().end();
I != E; ++I) {
- Unit *TheU = *I;
+ DwarfUnit *TheU = *I;
// Emit DW_AT_containing_type attribute to connect types with their
// vtable holding type.
TheU->constructContainingTypeDIEs();
- // If we're splitting the dwarf out now that we've got the entire
- // CU then construct a skeleton CU based upon it.
- if (useSplitDwarf() &&
- TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
- uint64_t ID = 0;
- if (GenerateCUHash) {
- DIEHash CUHash;
- ID = CUHash.computeCUSignature(*TheU->getUnitDie());
+ // Add CU specific attributes if we need to add any.
+ if (TheU->getUnitDie()->getTag() == dwarf::DW_TAG_compile_unit) {
+ // If we're splitting the dwarf out now that we've got the entire
+ // CU then add the dwo id to it.
+ DwarfCompileUnit *SkCU =
+ static_cast<DwarfCompileUnit *>(TheU->getSkeleton());
+ if (useSplitDwarf()) {
+ // This should be a unique identifier when we want to build .dwp files.
+ uint64_t ID = 0;
+ if (GenerateCUHash) {
+ DIEHash CUHash;
+ ID = CUHash.computeCUSignature(*TheU->getUnitDie());
+ }
+ TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
+ dwarf::DW_FORM_data8, ID);
+ SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
+ dwarf::DW_FORM_data8, ID);
}
- // This should be a unique identifier when we want to build .dwp files.
- TheU->addUInt(TheU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
- dwarf::DW_FORM_data8, ID);
- // Now construct the skeleton CU associated.
- CompileUnit *SkCU = constructSkeletonCU(static_cast<CompileUnit *>(TheU));
- // This should be a unique identifier when we want to build .dwp files.
- SkCU->addUInt(SkCU->getUnitDie(), dwarf::DW_AT_GNU_dwo_id,
- dwarf::DW_FORM_data8, ID);
+
+ // If we've requested ranges and have them emit a DW_AT_ranges attribute
+ // on the unit that will remain in the .o file, otherwise add a
+ // DW_AT_low_pc.
+ // FIXME: Also add a high pc if we can.
+ // FIXME: We should use ranges if we have multiple compile units.
+ DwarfCompileUnit *U = SkCU ? SkCU : static_cast<DwarfCompileUnit *>(TheU);
+ if (DwarfCURanges && TheU->getRanges().size())
+ addSectionLabel(Asm, U, U->getUnitDie(), dwarf::DW_AT_ranges,
+ Asm->GetTempSymbol("cu_ranges", U->getUniqueID()),
+ DwarfDebugRangeSectionSym);
+ else
+ U->addUInt(U->getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
+ 0);
}
}
// Emit info into a debug ranges section.
emitDebugRanges();
- // Emit info into a debug macinfo section.
- emitDebugMacInfo();
-
if (useSplitDwarf()) {
emitDebugStrDWO();
emitDebugInfoDWO();
// Make sure that each lexical scope will have a begin/end label.
identifyScopeMarkers();
- // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
+ // Set DwarfDwarfCompileUnitID in MCContext to the Compile Unit this function
// belongs to so that we add to the correct per-cu line table in the
// non-asm case.
LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
- CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
+ DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
assert(TheCU && "Unable to find compile unit!");
if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
// Use a single line table if we are using .loc and generating assembly.
FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
// Assumes in correct section after the entry point.
Asm->OutStreamer.EmitLabel(FunctionEndSym);
- // Set DwarfCompileUnitID in MCContext to default value.
+ // Set DwarfDwarfCompileUnitID in MCContext to default value.
Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
SmallPtrSet<const MDNode *, 16> ProcessedVars;
collectVariableInfo(ProcessedVars);
LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
- CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
+ DwarfCompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
assert(TheCU && "Unable to find compile unit!");
// Construct abstract scopes.
// Compute the size and offset of a DIE. The offset is relative to start of the
// CU. It returns the offset after laying out the DIE.
-unsigned DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
+unsigned DwarfFile::computeSizeAndOffset(DIE *Die, unsigned Offset) {
// Get the children.
const std::vector<DIE *> &Children = Die->getChildren();
assignAbbrevNumber(Die->getAbbrev());
// Get the abbreviation for this DIE.
- unsigned AbbrevNumber = Die->getAbbrevNumber();
- const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
+ const DIEAbbrev &Abbrev = Die->getAbbrev();
// Set DIE offset
Die->setOffset(Offset);
// Start the size with the size of abbreviation code.
- Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
+ Offset += MCAsmInfo::getULEB128Size(Die->getAbbrevNumber());
const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
- const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
+ const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
// Size the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i)
// Size the DIE children if any.
if (!Children.empty()) {
- assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
+ assert(Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
"Children flag not set");
for (unsigned j = 0, M = Children.size(); j < M; ++j)
}
// Compute the size and offset for each DIE.
-void DwarfUnits::computeSizeAndOffsets() {
+void DwarfFile::computeSizeAndOffsets() {
// Offset from the first CU in the debug info section is 0 initially.
unsigned SecOffset = 0;
// Iterate over each compile unit and set the size and offsets for each
// DIE within each compile unit. All offsets are CU relative.
- for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
+ for (SmallVectorImpl<DwarfUnit *>::const_iterator I = CUs.begin(),
+ E = CUs.end();
I != E; ++I) {
(*I)->setDebugInfoOffset(SecOffset);
// Dwarf sections base addresses.
DwarfInfoSectionSym =
emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
+ if (useSplitDwarf())
+ DwarfInfoDWOSectionSym =
+ emitSectionSym(Asm, TLOF.getDwarfInfoDWOSection(), "section_info_dwo");
DwarfAbbrevSectionSym =
emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
if (useSplitDwarf())
DwarfDebugLocSectionSym =
emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
-
- TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
- emitSectionSym(Asm, TLOF.getDataSection());
}
// Recursively emits a debug information entry.
-void DwarfDebug::emitDIE(DIE *Die, ArrayRef<DIEAbbrev *> Abbrevs) {
+void DwarfDebug::emitDIE(DIE *Die) {
// Get the abbreviation for this DIE.
- unsigned AbbrevNumber = Die->getAbbrevNumber();
- const DIEAbbrev *Abbrev = Abbrevs[AbbrevNumber - 1];
+ const DIEAbbrev &Abbrev = Die->getAbbrev();
// Emit the code (index) for the abbreviation.
if (Asm->isVerbose())
- Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
- Twine::utohexstr(Die->getOffset()) + ":0x" +
- Twine::utohexstr(Die->getSize()) + " " +
- dwarf::TagString(Abbrev->getTag()));
- Asm->EmitULEB128(AbbrevNumber);
+ Asm->OutStreamer.AddComment("Abbrev [" + Twine(Abbrev.getNumber()) +
+ "] 0x" + Twine::utohexstr(Die->getOffset()) +
+ ":0x" + Twine::utohexstr(Die->getSize()) + " " +
+ dwarf::TagString(Abbrev.getTag()));
+ Asm->EmitULEB128(Abbrev.getNumber());
const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
- const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
+ const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
// Emit the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i) {
// For DW_FORM_ref_addr, output the offset from beginning of debug info
// section. Origin->getOffset() returns the offset from start of the
// compile unit.
- CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
+ DwarfCompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
assert(CU && "CUDie should belong to a CU.");
Addr += CU->getDebugInfoOffset();
if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
+ Asm->EmitLabelPlusOffset(CU->getSectionSym(), Addr,
DIEEntry::getRefAddrSize(Asm));
else
- Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
- DwarfInfoSectionSym,
+ Asm->EmitLabelOffsetDifference(CU->getSectionSym(), Addr,
+ CU->getSectionSym(),
DIEEntry::getRefAddrSize(Asm));
} else {
// Make sure Origin belong to the same CU.
}
break;
}
- case dwarf::DW_AT_ranges: {
- // DW_AT_range Value encodes offset in debug_range section.
- DIELabel *V = cast<DIELabel>(Values[i]);
-
- if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- Asm->EmitSectionOffset(V->getValue(), DwarfDebugRangeSectionSym);
- else
- Asm->EmitLabelDifference(V->getValue(), DwarfDebugRangeSectionSym, 4);
- break;
- }
case dwarf::DW_AT_location: {
if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
}
// Emit the DIE children if any.
- if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
+ if (Abbrev.getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
const std::vector<DIE *> &Children = Die->getChildren();
for (unsigned j = 0, M = Children.size(); j < M; ++j)
- emitDIE(Children[j], Abbrevs);
+ emitDIE(Children[j]);
- if (Asm->isVerbose())
- Asm->OutStreamer.AddComment("End Of Children Mark");
+ Asm->OutStreamer.AddComment("End Of Children Mark");
Asm->EmitInt8(0);
}
}
// Emit the various dwarf units to the unit section USection with
// the abbreviations going into ASection.
-void DwarfUnits::emitUnits(DwarfDebug *DD, const MCSection *USection,
- const MCSection *ASection,
- const MCSymbol *ASectionSym) {
- Asm->OutStreamer.SwitchSection(USection);
- for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
- ++I) {
- Unit *TheU = *I;
+void DwarfFile::emitUnits(DwarfDebug *DD, const MCSection *ASection,
+ const MCSymbol *ASectionSym) {
+ for (SmallVectorImpl<DwarfUnit *>::iterator I = CUs.begin(), E = CUs.end();
+ I != E; ++I) {
+ DwarfUnit *TheU = *I;
DIE *Die = TheU->getUnitDie();
+ const MCSection *USection = TheU->getSection();
+ Asm->OutStreamer.SwitchSection(USection);
// Emit the compile units header.
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol(USection->getLabelBeginName(), TheU->getUniqueID()));
+ Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
// Emit size of content not including length itself
Asm->OutStreamer.AddComment("Length of Unit");
TheU->emitHeader(ASection, ASectionSym);
- DD->emitDIE(Die, Abbreviations);
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol(USection->getLabelEndName(), TheU->getUniqueID()));
+ DD->emitDIE(Die);
+ Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
}
}
// Emit the debug info section.
void DwarfDebug::emitDebugInfo() {
- DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
+ DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
- Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
- Asm->getObjFileLowering().getDwarfAbbrevSection(),
+ Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfAbbrevSection(),
DwarfAbbrevSectionSym);
}
// Emit the abbreviation section.
void DwarfDebug::emitAbbreviations() {
- if (!useSplitDwarf())
- emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
- &Abbreviations);
- else
- emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
+ DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
+
+ Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
}
-void DwarfDebug::emitAbbrevs(const MCSection *Section,
- std::vector<DIEAbbrev *> *Abbrevs) {
+void DwarfFile::emitAbbrevs(const MCSection *Section) {
// Check to see if it is worth the effort.
- if (!Abbrevs->empty()) {
+ if (!Abbreviations.empty()) {
// Start the debug abbrev section.
Asm->OutStreamer.SwitchSection(Section);
- MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
- Asm->OutStreamer.EmitLabel(Begin);
-
// For each abbrevation.
- for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
+ for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
// Get abbreviation data
- const DIEAbbrev *Abbrev = Abbrevs->at(i);
+ const DIEAbbrev *Abbrev = Abbreviations[i];
// Emit the abbrevations code (base 1 index.)
Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
// Mark end of abbreviations.
Asm->EmitULEB128(0, "EOM(3)");
-
- MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
- Asm->OutStreamer.EmitLabel(End);
}
}
void DwarfDebug::emitAccelNames() {
DwarfAccelTable AT(
DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
+ for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+ E = getUnits().end();
I != E; ++I) {
- Unit *TheU = *I;
+ DwarfUnit *TheU = *I;
const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelNames();
for (StringMap<std::vector<const DIE *> >::const_iterator
GI = Names.begin(),
void DwarfDebug::emitAccelObjC() {
DwarfAccelTable AT(
DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
+ for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+ E = getUnits().end();
I != E; ++I) {
- Unit *TheU = *I;
+ DwarfUnit *TheU = *I;
const StringMap<std::vector<const DIE *> > &Names = TheU->getAccelObjC();
for (StringMap<std::vector<const DIE *> >::const_iterator
GI = Names.begin(),
void DwarfDebug::emitAccelNamespaces() {
DwarfAccelTable AT(
DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
+ for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+ E = getUnits().end();
I != E; ++I) {
- Unit *TheU = *I;
+ DwarfUnit *TheU = *I;
const StringMap<std::vector<const DIE *> > &Names =
TheU->getAccelNamespace();
for (StringMap<std::vector<const DIE *> >::const_iterator
Atoms.push_back(
DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
DwarfAccelTable AT(Atoms);
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
+ for (SmallVectorImpl<DwarfUnit *>::const_iterator I = getUnits().begin(),
+ E = getUnits().end();
I != E; ++I) {
- Unit *TheU = *I;
+ DwarfUnit *TheU = *I;
const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
TheU->getAccelTypes();
for (StringMap<
// reference in the pubname header doesn't change.
/// computeIndexValue - Compute the gdb index value for the DIE and CU.
-static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
+static dwarf::PubIndexEntryDescriptor computeIndexValue(DwarfUnit *CU,
const DIE *Die) {
dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
/// emitDebugPubNames - Emit visible names into a debug pubnames section.
///
void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
- const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
const MCSection *PSec =
GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
: Asm->getObjFileLowering().getDwarfPubNamesSection();
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
- I != E; ++I) {
- Unit *TheU = *I;
+ DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
+ const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
+ for (unsigned i = 0; i != Units.size(); ++i) {
+ DwarfUnit *TheU = Units[i];
unsigned ID = TheU->getUniqueID();
// Start the dwarf pubnames section.
// Emit a label so we can reference the beginning of this pubname section.
if (GnuStyle)
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol("gnu_pubnames", TheU->getUniqueID()));
+ Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames", ID));
// Emit the header.
Asm->OutStreamer.AddComment("Length of Public Names Info");
- Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
- Asm->GetTempSymbol("pubnames_begin", ID), 4);
+ MCSymbol *BeginLabel = Asm->GetTempSymbol("pubnames_begin", ID);
+ MCSymbol *EndLabel = Asm->GetTempSymbol("pubnames_end", ID);
+ Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
- Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
+ Asm->OutStreamer.EmitLabel(BeginLabel);
Asm->OutStreamer.AddComment("DWARF Version");
Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
- Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
- DwarfInfoSectionSym);
+ Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
Asm->OutStreamer.AddComment("Compilation Unit Length");
- Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
- Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
- 4);
+ Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
// Emit the pubnames for this compilation unit.
- const StringMap<const DIE *> &Globals = TheU->getGlobalNames();
+ const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalNames();
for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
GE = Globals.end();
GI != GE; ++GI) {
Asm->EmitInt8(Desc.toBits());
}
- if (Asm->isVerbose())
- Asm->OutStreamer.AddComment("External Name");
+ Asm->OutStreamer.AddComment("External Name");
Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
}
Asm->OutStreamer.AddComment("End Mark");
Asm->EmitInt32(0);
- Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
+ Asm->OutStreamer.EmitLabel(EndLabel);
}
}
void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
- const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
const MCSection *PSec =
GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
: Asm->getObjFileLowering().getDwarfPubTypesSection();
- for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
- E = getUnits().end();
- I != E; ++I) {
- Unit *TheU = *I;
+ DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
+ const SmallVectorImpl<DwarfUnit *> &Units = Holder.getUnits();
+ for (unsigned i = 0; i != Units.size(); ++i) {
+ DwarfUnit *TheU = Units[i];
+ unsigned ID = TheU->getUniqueID();
+
// Start the dwarf pubtypes section.
Asm->OutStreamer.SwitchSection(PSec);
// Emit a label so we can reference the beginning of this pubtype section.
if (GnuStyle)
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol("gnu_pubtypes", TheU->getUniqueID()));
+ Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes", ID));
// Emit the header.
Asm->OutStreamer.AddComment("Length of Public Types Info");
- Asm->EmitLabelDifference(
- Asm->GetTempSymbol("pubtypes_end", TheU->getUniqueID()),
- Asm->GetTempSymbol("pubtypes_begin", TheU->getUniqueID()), 4);
+ MCSymbol *BeginLabel = Asm->GetTempSymbol("pubtypes_begin", ID);
+ MCSymbol *EndLabel = Asm->GetTempSymbol("pubtypes_end", ID);
+ Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol("pubtypes_begin", TheU->getUniqueID()));
+ Asm->OutStreamer.EmitLabel(BeginLabel);
- if (Asm->isVerbose())
- Asm->OutStreamer.AddComment("DWARF Version");
+ Asm->OutStreamer.AddComment("DWARF Version");
Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
- Asm->EmitSectionOffset(
- Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()),
- DwarfInfoSectionSym);
+ Asm->EmitSectionOffset(TheU->getLabelBegin(), TheU->getSectionSym());
Asm->OutStreamer.AddComment("Compilation Unit Length");
- Asm->EmitLabelDifference(
- Asm->GetTempSymbol(ISec->getLabelEndName(), TheU->getUniqueID()),
- Asm->GetTempSymbol(ISec->getLabelBeginName(), TheU->getUniqueID()), 4);
+ Asm->EmitLabelDifference(TheU->getLabelEnd(), TheU->getLabelBegin(), 4);
// Emit the pubtypes.
- const StringMap<const DIE *> &Globals = TheU->getGlobalTypes();
+ const StringMap<const DIE *> &Globals = getUnits()[ID]->getGlobalTypes();
for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
GE = Globals.end();
GI != GE; ++GI) {
const char *Name = GI->getKeyData();
const DIE *Entity = GI->second;
- if (Asm->isVerbose())
- Asm->OutStreamer.AddComment("DIE offset");
+ Asm->OutStreamer.AddComment("DIE offset");
Asm->EmitInt32(Entity->getOffset());
if (GnuStyle) {
Asm->EmitInt8(Desc.toBits());
}
- if (Asm->isVerbose())
- Asm->OutStreamer.AddComment("External Name");
+ Asm->OutStreamer.AddComment("External Name");
// Emit the name with a terminating null byte.
Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
Asm->OutStreamer.AddComment("End Mark");
Asm->EmitInt32(0);
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol("pubtypes_end", TheU->getUniqueID()));
+ Asm->OutStreamer.EmitLabel(EndLabel);
}
}
// Emit strings into a string section.
-void DwarfUnits::emitStrings(const MCSection *StrSection,
- const MCSection *OffsetSection = NULL,
- const MCSymbol *StrSecSym = NULL) {
+void DwarfFile::emitStrings(const MCSection *StrSection,
+ const MCSection *OffsetSection = NULL,
+ const MCSymbol *StrSecSym = NULL) {
if (StringPool.empty())
return;
}
}
-
// Emit addresses into the section given.
-void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
+void DwarfFile::emitAddresses(const MCSection *AddrSection) {
if (AddressPool.empty())
return;
// Emit visible names into a debug str section.
void DwarfDebug::emitDebugStr() {
- DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
+ DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
}
}
};
-static bool CUSort(const Unit *A, const Unit *B) {
+static bool CUSort(const DwarfUnit *A, const DwarfUnit *B) {
return (A->getUniqueID() < B->getUniqueID());
}
Asm->OutStreamer.SwitchSection(
Asm->getObjFileLowering().getDwarfARangesSection());
- typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
+ typedef DenseMap<DwarfCompileUnit *, std::vector<ArangeSpan> > SpansType;
SpansType Spans;
}
}
- const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
unsigned PtrSize = Asm->getDataLayout().getPointerSize();
// Build a list of CUs used.
- std::vector<CompileUnit *> CUs;
+ std::vector<DwarfCompileUnit *> CUs;
for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
- CompileUnit *CU = it->first;
+ DwarfCompileUnit *CU = it->first;
CUs.push_back(CU);
}
// Emit an arange table for each CU we used.
for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
- CompileUnit *CU = CUs[CUIdx];
+ DwarfCompileUnit *CU = CUs[CUIdx];
std::vector<ArangeSpan> &List = Spans[CU];
// Emit size of content not including length itself.
Asm->OutStreamer.AddComment("DWARF Arange version number");
Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
- Asm->EmitSectionOffset(
- Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
- DwarfInfoSectionSym);
+ Asm->EmitSectionOffset(CU->getLocalLabelBegin(), CU->getLocalSectionSym());
Asm->OutStreamer.AddComment("Address Size (in bytes)");
Asm->EmitInt8(PtrSize);
Asm->OutStreamer.AddComment("Segment Size (in bytes)");
unsigned char Size = Asm->getDataLayout().getPointerSize();
// Grab the specific ranges for the compile units in the module.
- for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
- E = CUMap.end();
+ for (DenseMap<const MDNode *, DwarfCompileUnit *>::iterator I = CUMap.begin(),
+ E = CUMap.end();
I != E; ++I) {
- CompileUnit *TheCU = I->second;
- unsigned ID = TheCU->getUniqueID();
+ DwarfCompileUnit *TheCU = I->second;
// Emit a symbol so we can find the beginning of our ranges.
- Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_ranges", ID));
+ Asm->OutStreamer.EmitLabel(TheCU->getLabelRange());
// Iterate over the misc ranges for the compile units in the module.
- const SmallVectorImpl<RangeSpanList *> &RangeLists = TheCU->getRangeLists();
- for (SmallVectorImpl<RangeSpanList *>::const_iterator
- I = RangeLists.begin(),
- E = RangeLists.end();
+ const SmallVectorImpl<RangeSpanList> &RangeLists = TheCU->getRangeLists();
+ for (SmallVectorImpl<RangeSpanList>::const_iterator I = RangeLists.begin(),
+ E = RangeLists.end();
I != E; ++I) {
- RangeSpanList *List = *I;
+ const RangeSpanList &List = *I;
- // Emit a symbol so we can find the beginning of the range.
- Asm->OutStreamer.EmitLabel(
- Asm->GetTempSymbol("debug_ranges", List->getIndex()));
+ // Emit our symbol so we can find the beginning of the range.
+ Asm->OutStreamer.EmitLabel(List.getSym());
for (SmallVectorImpl<RangeSpan>::const_iterator
- I = List->getRanges().begin(),
- E = List->getRanges().end();
- I != E; ++I) {
- RangeSpan Range = *I;
- // We occasionally have ranges without begin/end labels.
- // FIXME: Verify and fix.
+ RI = List.getRanges().begin(),
+ RE = List.getRanges().end();
+ RI != RE; ++RI) {
+ const RangeSpan &Range = *RI;
const MCSymbol *Begin = Range.getStart();
const MCSymbol *End = Range.getEnd();
- Begin ? Asm->OutStreamer.EmitSymbolValue(Begin, Size)
- : Asm->OutStreamer.EmitIntValue(0, Size);
- End ? Asm->OutStreamer.EmitSymbolValue(End, Size)
- : Asm->OutStreamer.EmitIntValue(0, Size);
+ assert(Begin && "Range without a begin symbol?");
+ assert(End && "Range without an end symbol?");
+ Asm->OutStreamer.EmitSymbolValue(Begin, Size);
+ Asm->OutStreamer.EmitSymbolValue(End, Size);
}
// And terminate the list with two 0 values.
Asm->OutStreamer.EmitIntValue(0, Size);
Asm->OutStreamer.EmitIntValue(0, Size);
}
- }
-}
-// Emit visible names into a debug macinfo section.
-void DwarfDebug::emitDebugMacInfo() {
- if (const MCSection *LineInfo =
- Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
- // Start the dwarf macinfo section.
- Asm->OutStreamer.SwitchSection(LineInfo);
+ // Now emit a range for the CU itself.
+ if (DwarfCURanges) {
+ Asm->OutStreamer.EmitLabel(
+ Asm->GetTempSymbol("cu_ranges", TheCU->getUniqueID()));
+ const SmallVectorImpl<RangeSpan> &Ranges = TheCU->getRanges();
+ for (uint32_t i = 0, e = Ranges.size(); i != e; ++i) {
+ RangeSpan Range = Ranges[i];
+ const MCSymbol *Begin = Range.getStart();
+ const MCSymbol *End = Range.getEnd();
+ assert(Begin && "Range without a begin symbol?");
+ assert(End && "Range without an end symbol?");
+ Asm->OutStreamer.EmitSymbolValue(Begin, Size);
+ Asm->OutStreamer.EmitSymbolValue(End, Size);
+ }
+ // And terminate the list with two 0 values.
+ Asm->OutStreamer.EmitIntValue(0, Size);
+ Asm->OutStreamer.EmitIntValue(0, Size);
+ }
}
}
// This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
// DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
// DW_AT_ranges_base, DW_AT_addr_base.
-CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
+// TODO: Implement DW_AT_ranges_base.
+DwarfCompileUnit *DwarfDebug::constructSkeletonCU(const DwarfCompileUnit *CU) {
DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
- CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
- Asm, this, &SkeletonHolder);
+ DwarfCompileUnit *NewCU = new DwarfCompileUnit(
+ CU->getUniqueID(), Die, CU->getNode(), Asm, this, &SkeletonHolder);
+ NewCU->initSection(Asm->getObjFileLowering().getDwarfInfoSection(),
+ DwarfInfoSectionSym);
NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
CU->getNode().getSplitDebugFilename());
else
NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
- // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
- // into an entity. We're using 0, or a NULL label for this.
- NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
-
// DW_AT_stmt_list is a offset of line number information for this
// compile unit in debug_line section.
// FIXME: Should handle multiple compile units.
if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
- DwarfLineSectionSym);
+ NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list, DwarfLineSectionSym);
else
NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
if (!CompilationDir.empty())
NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
- // Flags to let the linker know we have emitted new style pubnames.
- if (GenerateGnuPubSections) {
- if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(
- Die, dwarf::DW_AT_GNU_pubnames,
- Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
- else
- NewCU->addSectionDelta(
- Die, dwarf::DW_AT_GNU_pubnames,
- Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
- DwarfGnuPubNamesSectionSym);
-
- if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(
- Die, dwarf::DW_AT_GNU_pubtypes,
- Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
- else
- NewCU->addSectionDelta(
- Die, dwarf::DW_AT_GNU_pubtypes,
- Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
- DwarfGnuPubTypesSectionSym);
- }
-
- // Attribute if we've emitted any ranges and their location for the compile unit.
- if (CU->getRangeLists().size()) {
- if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
- NewCU->addSectionLabel(
- Die, dwarf::DW_AT_GNU_ranges_base,
- Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()));
- else
- NewCU->addSectionDelta(
- Die, dwarf::DW_AT_GNU_ranges_base,
- Asm->GetTempSymbol("gnu_ranges", NewCU->getUniqueID()),
- DwarfDebugRangeSectionSym);
- }
+ addGnuPubAttributes(NewCU, Die);
SkeletonHolder.addUnit(NewCU);
return NewCU;
}
-void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
- assert(useSplitDwarf() && "No split dwarf debug info?");
- emitAbbrevs(Section, &SkeletonAbbrevs);
-}
-
// Emit the .debug_info.dwo section for separated dwarf. This contains the
// compile units that would normally be in debug_info.
void DwarfDebug::emitDebugInfoDWO() {
assert(useSplitDwarf() && "No split dwarf debug info?");
- InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
+ InfoHolder.emitUnits(this,
Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
DwarfAbbrevDWOSectionSym);
}
// abbreviations for the .debug_info.dwo section.
void DwarfDebug::emitDebugAbbrevDWO() {
assert(useSplitDwarf() && "No split dwarf?");
- emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
- &Abbreviations);
+ InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
}
// Emit the .debug_str.dwo section for separated dwarf. This contains the
OffSec, StrSym);
}
-void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
- DICompositeType CTy) {
- DenseMap<const MDNode *,
- std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
- TypeUnits.find(CTy);
- SmallVector<DIE *, 8> References;
- References.push_back(RefDie);
- if (I != TypeUnits.end()) {
- if (I->second.second) {
- I->second.second->push_back(RefDie);
- return;
- }
- } else {
+void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, StringRef Identifier,
+ DIE *RefDie, DICompositeType CTy) {
+ const DwarfTypeUnit *&TU = DwarfTypeUnits[CTy];
+ if (!TU) {
DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
- TypeUnit *NewTU = new TypeUnit(GlobalCUIndexCount++, UnitDie, Language, Asm,
- this, &InfoHolder);
+ DwarfTypeUnit *NewTU =
+ new DwarfTypeUnit(InfoHolder.getUnits().size(), UnitDie, Language, Asm,
+ this, &InfoHolder);
+ TU = NewTU;
+ InfoHolder.addUnit(NewTU);
+
NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
Language);
- // Register the type in the TypeUnits map with a vector of references to be
- // populated whenever a reference is required.
- I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
- .first;
-
- // Construct the type, this may, recursively, require more type units that
- // may in turn require this type again - in which case they will add DIEs to
- // the References vector.
DIE *Die = NewTU->createTypeDIE(CTy);
- if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
- NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
- dwarf::DW_FORM_data8,
- DIEHash().computeDIEODRSignature(*Die));
- // FIXME: This won't handle circularly referential structures, as the DIE
- // may have references to other DIEs still under construction and missing
- // their signature. Hashing should walk through the signatures to their
- // referenced type, or possibly walk the precomputed hashes of related types
- // at the end.
- uint64_t Signature = DIEHash().computeTypeSignature(*Die);
-
- // Remove the References vector and add the type hash.
- I->second.first = Signature;
- I->second.second = NULL;
+ MD5 Hash;
+ Hash.update(Identifier);
+ // ... take the least significant 8 bytes and return those. Our MD5
+ // implementation always returns its results in little endian, swap bytes
+ // appropriately.
+ MD5::MD5Result Result;
+ Hash.final(Result);
+ uint64_t Signature = *reinterpret_cast<uint64_t *>(Result + 8);
+ NewTU->setTypeSignature(Signature);
+ NewTU->setType(Die);
- InfoHolder.addUnit(NewTU);
+ NewTU->initSection(
+ useSplitDwarf()
+ ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
+ : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
}
- // Populate all the signatures.
- for (unsigned i = 0, e = References.size(); i != e; ++i) {
- CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
- dwarf::DW_FORM_ref_sig8, I->second.first);
- }
+ CUMap.begin()->second->addDIETypeSignature(RefDie, *TU);
}