6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-17 04:24:00 +00:00
Code Issues Projects Releases Wiki Activity

Split out DwarfFile from DwarfDebug into its own .h/.cpp files.

Browse Source 
Some of these types (DwarfDebug in particular) are quite large to begin
with (and I keep forgetting whether DwarfFile is in DwarfDebug or
DwarfUnit... ) so having a few smaller files seems like goodness.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207010 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
David Blaikie
2014-04-23 18:54:00 +00:00
parent 08a4d0b36f
commit 1188a75aa0
5 changed files with 367 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/CodeGen/AsmPrinter/CMakeLists.txt
View File

@ -9,6 +9,7 @@ add_llvm_library(LLVMAsmPrinter
DwarfCFIException.cpp DwarfCFIException.cpp
DwarfDebug.cpp DwarfDebug.cpp
DwarfException.cpp DwarfException.cpp
DwarfFile.cpp
DwarfUnit.cpp DwarfUnit.cpp
ErlangGCPrinter.cpp ErlangGCPrinter.cpp
OcamlGCPrinter.cpp OcamlGCPrinter.cpp

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

@ -108,8 +108,6 @@ static const char *const DbgTimerName = "DWARF Debug Writer";
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace llvm {
/// resolve - Look in the DwarfDebug map for the MDNode that /// resolve - Look in the DwarfDebug map for the MDNode that
/// corresponds to the reference. /// corresponds to the reference.
template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const { template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
@ -167,8 +165,6 @@ DIType DbgVariable::getType() const {
return Ty; return Ty;
} }
} // end llvm namespace
DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M) DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
: Asm(A), MMI(Asm->MMI), FirstCU(0), PrevLabel(NULL), GlobalRangeCount(0), : Asm(A), MMI(Asm->MMI), FirstCU(0), PrevLabel(NULL), GlobalRangeCount(0),
InfoHolder(A, "info_string", DIEValueAllocator), InfoHolder(A, "info_string", DIEValueAllocator),
@ -225,65 +221,6 @@ static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
return TmpSym; return TmpSym;
} }
DwarfFile::DwarfFile(AsmPrinter *AP, const char *Pref, BumpPtrAllocator &DA)
: Asm(AP), StringPool(DA), NextStringPoolNumber(0), StringPref(Pref) {}
DwarfFile::~DwarfFile() {
}
MCSymbol *DwarfFile::getStringPoolSym() {
return Asm->GetTempSymbol(StringPref);
}
MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
std::pair<MCSymbol *, unsigned> &Entry =
StringPool.GetOrCreateValue(Str).getValue();
if (Entry.first)
return Entry.first;
Entry.second = NextStringPoolNumber++;
return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
}
unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
std::pair<MCSymbol *, unsigned> &Entry =
StringPool.GetOrCreateValue(Str).getValue();
if (Entry.first)
return Entry.second;
Entry.second = NextStringPoolNumber++;
Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
return Entry.second;
}
unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym, bool TLS) {
std::pair<AddrPool::iterator, bool> P = AddressPool.insert(
std::make_pair(Sym, AddressPoolEntry(AddressPool.size(), TLS)));
return P.first->second.Number;
}
// Define a unique number for the abbreviation.
//
void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
// Check the set for priors.
DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
// If it's newly added.
if (InSet == &Abbrev) {
// Add to abbreviation list.
Abbreviations.push_back(&Abbrev);
// Assign the vector position + 1 as its number.
Abbrev.setNumber(Abbreviations.size());
} else {
// Assign existing abbreviation number.
Abbrev.setNumber(InSet->getNumber());
}
}
void DwarfFile::addUnit(std::unique_ptr<DwarfUnit> U) {
CUs.push_back(std::move(U));
}
static bool isObjCClass(StringRef Name) { static bool isObjCClass(StringRef Name) {
return Name.startswith("+") || Name.startswith("-"); return Name.startswith("+") || Name.startswith("-");
} }
@ -1790,68 +1727,6 @@ void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
// Emit Methods // Emit Methods
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// 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 DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
// Record the abbreviation.
assignAbbrevNumber(Die.getAbbrev());
// Get the abbreviation for this DIE.
const DIEAbbrev &Abbrev = Die.getAbbrev();
// Set DIE offset
Die.setOffset(Offset);
// Start the size with the size of abbreviation code.
Offset += getULEB128Size(Die.getAbbrevNumber());
const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
// Size the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i)
// Size attribute value.
Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
// Get the children.
const auto &Children = Die.getChildren();
// Size the DIE children if any.
if (!Children.empty()) {
assert(Abbrev.hasChildren() && "Children flag not set");
for (auto &Child : Children)
Offset = computeSizeAndOffset(*Child, Offset);
// End of children marker.
Offset += sizeof(int8_t);
}
Die.setSize(Offset - Die.getOffset());
return Offset;
}
// Compute the size and offset for each DIE.
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 (const auto &TheU : CUs) {
TheU->setDebugInfoOffset(SecOffset);
// CU-relative offset is reset to 0 here.
unsigned Offset = sizeof(int32_t) + // Length of Unit Info
TheU->getHeaderSize(); // Unit-specific headers
// EndOffset here is CU-relative, after laying out
// all of the CU DIE.
unsigned EndOffset = computeSizeAndOffset(*TheU->getUnitDie(), Offset);
SecOffset += EndOffset;
}
}
// Emit initial Dwarf sections with a label at the start of each one. // Emit initial Dwarf sections with a label at the start of each one.
void DwarfDebug::emitSectionLabels() { void DwarfDebug::emitSectionLabels() {
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
@ -1941,28 +1816,6 @@ void DwarfDebug::emitDIE(DIE &Die) {
} }
} }
// Emit the various dwarf units to the unit section USection with
// the abbreviations going into ASection.
void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
for (const auto &TheU : CUs) {
DIE *Die = TheU->getUnitDie();
const MCSection *USection = TheU->getSection();
Asm->OutStreamer.SwitchSection(USection);
// Emit the compile units header.
Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
// Emit size of content not including length itself
Asm->OutStreamer.AddComment("Length of Unit");
Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
TheU->emitHeader(ASectionSym);
DD->emitDIE(*Die);
Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
}
}
// Emit the debug info section. // Emit the debug info section.
void DwarfDebug::emitDebugInfo() { void DwarfDebug::emitDebugInfo() {
DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
@ -1977,26 +1830,6 @@ void DwarfDebug::emitAbbreviations() {
Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection()); Holder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
} }
void DwarfFile::emitAbbrevs(const MCSection *Section) {
// Check to see if it is worth the effort.
if (!Abbreviations.empty()) {
// Start the debug abbrev section.
Asm->OutStreamer.SwitchSection(Section);
// For each abbrevation.
for (const DIEAbbrev *Abbrev : Abbreviations) {
// Emit the abbrevations code (base 1 index.)
Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
// Emit the abbreviations data.
Abbrev->Emit(Asm);
}
// Mark end of abbreviations.
Asm->EmitULEB128(0, "EOM(3)");
}
}
// Emit the last address of the section and the end of the line matrix. // Emit the last address of the section and the end of the line matrix.
void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) { void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
// Define last address of section. // Define last address of section.
@ -2252,69 +2085,6 @@ void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes); emitDebugPubSection(GnuStyle, PSec, "Types", &DwarfUnit::getGlobalTypes);
} }
// Emit strings into a string section.
void DwarfFile::emitStrings(const MCSection *StrSection,
const MCSection *OffsetSection = NULL,
const MCSymbol *StrSecSym = NULL) {
if (StringPool.empty())
return;
// Start the dwarf str section.
Asm->OutStreamer.SwitchSection(StrSection);
// Get all of the string pool entries and put them in an array by their ID so
// we can sort them.
SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
for (const auto &I : StringPool)
Entries.push_back(std::make_pair(I.second.second, &I));
array_pod_sort(Entries.begin(), Entries.end());
for (const auto &Entry : Entries) {
// Emit a label for reference from debug information entries.
Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
// Emit the string itself with a terminating null byte.
Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
Entry.second->getKeyLength() + 1));
}
// If we've got an offset section go ahead and emit that now as well.
if (OffsetSection) {
Asm->OutStreamer.SwitchSection(OffsetSection);
unsigned offset = 0;
unsigned size = 4; // FIXME: DWARF64 is 8.
for (const auto &Entry : Entries) {
Asm->OutStreamer.EmitIntValue(offset, size);
offset += Entry.second->getKeyLength() + 1;
}
}
}
// Emit addresses into the section given.
void DwarfFile::emitAddresses(const MCSection *AddrSection) {
if (AddressPool.empty())
return;
// Start the dwarf addr section.
Asm->OutStreamer.SwitchSection(AddrSection);
// Order the address pool entries by ID
SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
for (const auto &I : AddressPool)
Entries[I.second.Number] =
I.second.TLS
? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
: MCSymbolRefExpr::Create(I.first, Asm->OutContext);
for (const MCExpr *Entry : Entries)
Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
}
// Emit visible names into a debug str section. // Emit visible names into a debug str section.
void DwarfDebug::emitDebugStr() { void DwarfDebug::emitDebugStr() {
DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder; DwarfFile &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;

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

@ -14,6 +14,7 @@
#ifndef CODEGEN_ASMPRINTER_DWARFDEBUG_H__ #ifndef CODEGEN_ASMPRINTER_DWARFDEBUG_H__
#define CODEGEN_ASMPRINTER_DWARFDEBUG_H__ #define CODEGEN_ASMPRINTER_DWARFDEBUG_H__
#include "DwarfFile.h"
#include "AsmPrinterHandler.h" #include "AsmPrinterHandler.h"
#include "DIE.h" #include "DIE.h"
#include "DebugLocEntry.h" #include "DebugLocEntry.h"
@ -133,96 +134,6 @@ private:
template <typename T> T resolve(DIRef<T> Ref) const; template <typename T> T resolve(DIRef<T> Ref) const;
}; };
/// \brief Collects and handles information specific to a particular
/// collection of units. This collection represents all of the units
/// that will be ultimately output into a single object file.
class DwarfFile {
// Target of Dwarf emission, used for sizing of abbreviations.
AsmPrinter *Asm;
// Used to uniquely define abbreviations.
FoldingSet<DIEAbbrev> AbbreviationsSet;
// A list of all the unique abbreviations in use.
std::vector<DIEAbbrev *> Abbreviations;
// A pointer to all units in the section.
SmallVector<std::unique_ptr<DwarfUnit>, 1> CUs;
// Collection of strings for this unit and assorted symbols.
// A String->Symbol mapping of strings used by indirect
// references.
typedef StringMap<std::pair<MCSymbol *, unsigned>, BumpPtrAllocator &>
StrPool;
StrPool StringPool;
unsigned NextStringPoolNumber;
std::string StringPref;
struct AddressPoolEntry {
unsigned Number;
bool TLS;
AddressPoolEntry(unsigned Number, bool TLS) : Number(Number), TLS(TLS) {}
};
// Collection of addresses for this unit and assorted labels.
// A Symbol->unsigned mapping of addresses used by indirect
// references.
typedef DenseMap<const MCSymbol *, AddressPoolEntry> AddrPool;
AddrPool AddressPool;
public:
DwarfFile(AsmPrinter *AP, const char *Pref, BumpPtrAllocator &DA);
~DwarfFile();
const SmallVectorImpl<std::unique_ptr<DwarfUnit>> &getUnits() { return CUs; }
/// \brief Compute the size and offset of a DIE given an incoming Offset.
unsigned computeSizeAndOffset(DIE &Die, unsigned Offset);
/// \brief Compute the size and offset of all the DIEs.
void computeSizeAndOffsets();
/// \brief Define a unique number for the abbreviation.
void assignAbbrevNumber(DIEAbbrev &Abbrev);
/// \brief Add a unit to the list of CUs.
void addUnit(std::unique_ptr<DwarfUnit> U);
/// \brief Emit all of the units to the section listed with the given
/// abbreviation section.
void emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym);
/// \brief Emit a set of abbreviations to the specific section.
void emitAbbrevs(const MCSection *);
/// \brief Emit all of the strings to the section given.
void emitStrings(const MCSection *StrSection, const MCSection *OffsetSection,
const MCSymbol *StrSecSym);
/// \brief Emit all of the addresses to the section given.
void emitAddresses(const MCSection *AddrSection);
/// \brief Returns the entry into the start of the pool.
MCSymbol *getStringPoolSym();
/// \brief Returns an entry into the string pool with the given
/// string text.
MCSymbol *getStringPoolEntry(StringRef Str);
/// \brief Returns the index into the string pool with the given
/// string text.
unsigned getStringPoolIndex(StringRef Str);
/// \brief Returns the string pool.
StrPool *getStringPool() { return &StringPool; }
/// \brief Returns the index into the address pool with the given
/// label/symbol.
unsigned getAddrPoolIndex(const MCSymbol *Sym, bool TLS = false);
/// \brief Returns the address pool.
AddrPool *getAddrPool() { return &AddressPool; }
};
/// \brief Helper used to pair up a symbol and its DWARF compile unit. /// \brief Helper used to pair up a symbol and its DWARF compile unit.
struct SymbolCU { struct SymbolCU {

244
lib/CodeGen/AsmPrinter/DwarfFile.cpp Normal file
View File

@ -0,0 +1,244 @@
//===-- llvm/CodeGen/DwarfFile.cpp - Dwarf Debug Framework ----------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "DwarfFile.h"
#include "DwarfDebug.h"
#include "DwarfUnit.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/Support/LEB128.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Target/TargetLoweringObjectFile.h"
namespace llvm {
DwarfFile::DwarfFile(AsmPrinter *AP, const char *Pref, BumpPtrAllocator &DA)
: Asm(AP), StringPool(DA), NextStringPoolNumber(0), StringPref(Pref) {}
DwarfFile::~DwarfFile() {
}
MCSymbol *DwarfFile::getStringPoolSym() {
return Asm->GetTempSymbol(StringPref);
}
MCSymbol *DwarfFile::getStringPoolEntry(StringRef Str) {
std::pair<MCSymbol *, unsigned> &Entry =
StringPool.GetOrCreateValue(Str).getValue();
if (Entry.first)
return Entry.first;
Entry.second = NextStringPoolNumber++;
return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
}
unsigned DwarfFile::getStringPoolIndex(StringRef Str) {
std::pair<MCSymbol *, unsigned> &Entry =
StringPool.GetOrCreateValue(Str).getValue();
if (Entry.first)
return Entry.second;
Entry.second = NextStringPoolNumber++;
Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
return Entry.second;
}
unsigned DwarfFile::getAddrPoolIndex(const MCSymbol *Sym, bool TLS) {
std::pair<AddrPool::iterator, bool> P = AddressPool.insert(
std::make_pair(Sym, AddressPoolEntry(AddressPool.size(), TLS)));
return P.first->second.Number;
}
// Define a unique number for the abbreviation.
//
void DwarfFile::assignAbbrevNumber(DIEAbbrev &Abbrev) {
// Check the set for priors.
DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
// If it's newly added.
if (InSet == &Abbrev) {
// Add to abbreviation list.
Abbreviations.push_back(&Abbrev);
// Assign the vector position + 1 as its number.
Abbrev.setNumber(Abbreviations.size());
} else {
// Assign existing abbreviation number.
Abbrev.setNumber(InSet->getNumber());
}
}
void DwarfFile::addUnit(std::unique_ptr<DwarfUnit> U) {
CUs.push_back(std::move(U));
}
// Emit the various dwarf units to the unit section USection with
// the abbreviations going into ASection.
void DwarfFile::emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym) {
for (const auto &TheU : CUs) {
DIE *Die = TheU->getUnitDie();
const MCSection *USection = TheU->getSection();
Asm->OutStreamer.SwitchSection(USection);
// Emit the compile units header.
Asm->OutStreamer.EmitLabel(TheU->getLabelBegin());
// Emit size of content not including length itself
Asm->OutStreamer.AddComment("Length of Unit");
Asm->EmitInt32(TheU->getHeaderSize() + Die->getSize());
TheU->emitHeader(ASectionSym);
DD->emitDIE(*Die);
Asm->OutStreamer.EmitLabel(TheU->getLabelEnd());
}
}
// Compute the size and offset for each DIE.
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 (const auto &TheU : CUs) {
TheU->setDebugInfoOffset(SecOffset);
// CU-relative offset is reset to 0 here.
unsigned Offset = sizeof(int32_t) + // Length of Unit Info
TheU->getHeaderSize(); // Unit-specific headers
// EndOffset here is CU-relative, after laying out
// all of the CU DIE.
unsigned EndOffset = computeSizeAndOffset(*TheU->getUnitDie(), Offset);
SecOffset += EndOffset;
}
}
// 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 DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
// Record the abbreviation.
assignAbbrevNumber(Die.getAbbrev());
// Get the abbreviation for this DIE.
const DIEAbbrev &Abbrev = Die.getAbbrev();
// Set DIE offset
Die.setOffset(Offset);
// Start the size with the size of abbreviation code.
Offset += getULEB128Size(Die.getAbbrevNumber());
const SmallVectorImpl<DIEValue *> &Values = Die.getValues();
const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev.getData();
// Size the DIE attribute values.
for (unsigned i = 0, N = Values.size(); i < N; ++i)
// Size attribute value.
Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
// Get the children.
const auto &Children = Die.getChildren();
// Size the DIE children if any.
if (!Children.empty()) {
assert(Abbrev.hasChildren() && "Children flag not set");
for (auto &Child : Children)
Offset = computeSizeAndOffset(*Child, Offset);
// End of children marker.
Offset += sizeof(int8_t);
}
Die.setSize(Offset - Die.getOffset());
return Offset;
}
void DwarfFile::emitAbbrevs(const MCSection *Section) {
// Check to see if it is worth the effort.
if (!Abbreviations.empty()) {
// Start the debug abbrev section.
Asm->OutStreamer.SwitchSection(Section);
// For each abbrevation.
for (const DIEAbbrev *Abbrev : Abbreviations) {
// Emit the abbrevations code (base 1 index.)
Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
// Emit the abbreviations data.
Abbrev->Emit(Asm);
}
// Mark end of abbreviations.
Asm->EmitULEB128(0, "EOM(3)");
}
}
// Emit strings into a string section.
void DwarfFile::emitStrings(const MCSection *StrSection,
const MCSection *OffsetSection,
const MCSymbol *StrSecSym) {
if (StringPool.empty())
return;
// Start the dwarf str section.
Asm->OutStreamer.SwitchSection(StrSection);
// Get all of the string pool entries and put them in an array by their ID so
// we can sort them.
SmallVector<std::pair<unsigned, const StrPool::value_type *>, 64 > Entries;
for (const auto &I : StringPool)
Entries.push_back(std::make_pair(I.second.second, &I));
array_pod_sort(Entries.begin(), Entries.end());
for (const auto &Entry : Entries) {
// Emit a label for reference from debug information entries.
Asm->OutStreamer.EmitLabel(Entry.second->getValue().first);
// Emit the string itself with a terminating null byte.
Asm->OutStreamer.EmitBytes(StringRef(Entry.second->getKeyData(),
Entry.second->getKeyLength() + 1));
}
// If we've got an offset section go ahead and emit that now as well.
if (OffsetSection) {
Asm->OutStreamer.SwitchSection(OffsetSection);
unsigned offset = 0;
unsigned size = 4; // FIXME: DWARF64 is 8.
for (const auto &Entry : Entries) {
Asm->OutStreamer.EmitIntValue(offset, size);
offset += Entry.second->getKeyLength() + 1;
}
}
}
// Emit addresses into the section given.
void DwarfFile::emitAddresses(const MCSection *AddrSection) {
if (AddressPool.empty())
return;
// Start the dwarf addr section.
Asm->OutStreamer.SwitchSection(AddrSection);
// Order the address pool entries by ID
SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
for (const auto &I : AddressPool)
Entries[I.second.Number] =
I.second.TLS
? Asm->getObjFileLowering().getDebugThreadLocalSymbol(I.first)
: MCSymbolRefExpr::Create(I.first, Asm->OutContext);
for (const MCExpr *Entry : Entries)
Asm->OutStreamer.EmitValue(Entry, Asm->getDataLayout().getPointerSize());
}
}

121
lib/CodeGen/AsmPrinter/DwarfFile.h Normal file
View File

@ -0,0 +1,121 @@
//===-- llvm/CodeGen/DwarfFile.h - Dwarf Debug Framework -------*- C++ -*--===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef CODEGEN_ASMPRINTER_DWARFFILE_H__
#define CODEGEN_ASMPRINTER_DWARFFILE_H__
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Support/Allocator.h"
#include <vector>
#include <string>
#include <memory>
namespace llvm {
class AsmPrinter;
class DwarfUnit;
class DIEAbbrev;
class MCSymbol;
class DIE;
class StringRef;
class DwarfDebug;
class MCSection;
class DwarfFile {
// Target of Dwarf emission, used for sizing of abbreviations.
AsmPrinter *Asm;
// Used to uniquely define abbreviations.
FoldingSet<DIEAbbrev> AbbreviationsSet;
// A list of all the unique abbreviations in use.
std::vector<DIEAbbrev *> Abbreviations;
// A pointer to all units in the section.
SmallVector<std::unique_ptr<DwarfUnit>, 1> CUs;
// Collection of strings for this unit and assorted symbols.
// A String->Symbol mapping of strings used by indirect
// references.
typedef StringMap<std::pair<MCSymbol *, unsigned>, BumpPtrAllocator &>
StrPool;
StrPool StringPool;
unsigned NextStringPoolNumber;
std::string StringPref;
struct AddressPoolEntry {
unsigned Number;
bool TLS;
AddressPoolEntry(unsigned Number, bool TLS) : Number(Number), TLS(TLS) {}
};
// Collection of addresses for this unit and assorted labels.
// A Symbol->unsigned mapping of addresses used by indirect
// references.
typedef DenseMap<const MCSymbol *, AddressPoolEntry> AddrPool;
AddrPool AddressPool;
public:
DwarfFile(AsmPrinter *AP, const char *Pref, BumpPtrAllocator &DA);
~DwarfFile();
const SmallVectorImpl<std::unique_ptr<DwarfUnit>> &getUnits() { return CUs; }
/// \brief Compute the size and offset of a DIE given an incoming Offset.
unsigned computeSizeAndOffset(DIE &Die, unsigned Offset);
/// \brief Compute the size and offset of all the DIEs.
void computeSizeAndOffsets();
/// \brief Define a unique number for the abbreviation.
void assignAbbrevNumber(DIEAbbrev &Abbrev);
/// \brief Add a unit to the list of CUs.
void addUnit(std::unique_ptr<DwarfUnit> U);
/// \brief Emit all of the units to the section listed with the given
/// abbreviation section.
void emitUnits(DwarfDebug *DD, const MCSymbol *ASectionSym);
/// \brief Emit a set of abbreviations to the specific section.
void emitAbbrevs(const MCSection *);
/// \brief Emit all of the strings to the section given.
void emitStrings(const MCSection *StrSection,
const MCSection *OffsetSection = nullptr,
const MCSymbol *StrSecSym = nullptr);
/// \brief Emit all of the addresses to the section given.
void emitAddresses(const MCSection *AddrSection);
/// \brief Returns the entry into the start of the pool.
MCSymbol *getStringPoolSym();
/// \brief Returns an entry into the string pool with the given
/// string text.
MCSymbol *getStringPoolEntry(StringRef Str);
/// \brief Returns the index into the string pool with the given
/// string text.
unsigned getStringPoolIndex(StringRef Str);
/// \brief Returns the string pool.
StrPool *getStringPool() { return &StringPool; }
/// \brief Returns the index into the address pool with the given
/// label/symbol.
unsigned getAddrPoolIndex(const MCSymbol *Sym, bool TLS = false);
/// \brief Returns the address pool.
AddrPool *getAddrPool() { return &AddressPool; }
};
}
#endif