1 //===-- DWARFContext.cpp --------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "DWARFContext.h"
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringSwitch.h"
14 #include "llvm/Support/Compression.h"
15 #include "llvm/Support/Dwarf.h"
16 #include "llvm/Support/Format.h"
17 #include "llvm/Support/Path.h"
18 #include "llvm/Support/raw_ostream.h"
21 using namespace dwarf;
22 using namespace object;
24 typedef DWARFDebugLine::LineTable DWARFLineTable;
26 DWARFContext::~DWARFContext() {
27 DeleteContainerPointers(CUs);
28 DeleteContainerPointers(TUs);
29 DeleteContainerPointers(DWOCUs);
30 DeleteContainerPointers(DWOTUs);
33 static void dumpPubSection(raw_ostream &OS, StringRef Name, StringRef Data,
34 bool LittleEndian, bool GnuStyle) {
35 OS << "\n." << Name << " contents:\n";
36 DataExtractor pubNames(Data, LittleEndian, 0);
38 while (pubNames.isValidOffset(offset)) {
39 OS << "length = " << format("0x%08x", pubNames.getU32(&offset));
40 OS << " version = " << format("0x%04x", pubNames.getU16(&offset));
41 OS << " unit_offset = " << format("0x%08x", pubNames.getU32(&offset));
42 OS << " unit_size = " << format("0x%08x", pubNames.getU32(&offset)) << '\n';
44 OS << "Offset Linkage Kind Name\n";
46 OS << "Offset Name\n";
48 while (offset < Data.size()) {
49 uint32_t dieRef = pubNames.getU32(&offset);
52 OS << format("0x%8.8x ", dieRef);
54 PubIndexEntryDescriptor desc(pubNames.getU8(&offset));
55 OS << format("%-8s", dwarf::GDBIndexEntryLinkageString(desc.Linkage))
56 << ' ' << format("%-8s", dwarf::GDBIndexEntryKindString(desc.Kind))
59 OS << '\"' << pubNames.getCStr(&offset) << "\"\n";
64 void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType) {
65 if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) {
66 OS << ".debug_abbrev contents:\n";
67 getDebugAbbrev()->dump(OS);
70 if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo)
71 if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) {
72 OS << "\n.debug_abbrev.dwo contents:\n";
76 if (DumpType == DIDT_All || DumpType == DIDT_Info) {
77 OS << "\n.debug_info contents:\n";
78 for (const auto &CU : compile_units())
82 if ((DumpType == DIDT_All || DumpType == DIDT_InfoDwo) &&
83 getNumDWOCompileUnits()) {
84 OS << "\n.debug_info.dwo contents:\n";
85 for (const auto &DWOCU : dwo_compile_units())
89 if ((DumpType == DIDT_All || DumpType == DIDT_Types) && getNumTypeUnits()) {
90 OS << "\n.debug_types contents:\n";
91 for (const auto &TU : type_units())
95 if ((DumpType == DIDT_All || DumpType == DIDT_TypesDwo) &&
96 getNumDWOTypeUnits()) {
97 OS << "\n.debug_types.dwo contents:\n";
98 for (const auto &DWOTU : dwo_type_units())
102 if (DumpType == DIDT_All || DumpType == DIDT_Loc) {
103 OS << "\n.debug_loc contents:\n";
104 getDebugLoc()->dump(OS);
107 if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
108 OS << "\n.debug_frame contents:\n";
109 getDebugFrame()->dump(OS);
113 if (DumpType == DIDT_All || DumpType == DIDT_Aranges) {
114 OS << "\n.debug_aranges contents:\n";
115 DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
116 DWARFDebugArangeSet set;
117 while (set.extract(arangesData, &offset))
121 uint8_t savedAddressByteSize = 0;
122 if (DumpType == DIDT_All || DumpType == DIDT_Line) {
123 OS << "\n.debug_line contents:\n";
124 for (const auto &CU : compile_units()) {
125 savedAddressByteSize = CU->getAddressByteSize();
126 unsigned stmtOffset =
127 CU->getCompileUnitDIE()->getAttributeValueAsSectionOffset(
128 CU, DW_AT_stmt_list, -1U);
129 if (stmtOffset != -1U) {
130 DataExtractor lineData(getLineSection().Data, isLittleEndian(),
131 savedAddressByteSize);
132 DWARFDebugLine::DumpingState state(OS);
133 DWARFDebugLine::parseStatementTable(lineData, &getLineSection().Relocs, &stmtOffset, state);
138 if (DumpType == DIDT_All || DumpType == DIDT_LineDwo) {
139 OS << "\n.debug_line.dwo contents:\n";
140 unsigned stmtOffset = 0;
141 DataExtractor lineData(getLineDWOSection().Data, isLittleEndian(),
142 savedAddressByteSize);
143 DWARFDebugLine::DumpingState state(OS);
144 while (DWARFDebugLine::parsePrologue(lineData, &stmtOffset, &state.Prologue))
148 if (DumpType == DIDT_All || DumpType == DIDT_Str) {
149 OS << "\n.debug_str contents:\n";
150 DataExtractor strData(getStringSection(), isLittleEndian(), 0);
152 uint32_t strOffset = 0;
153 while (const char *s = strData.getCStr(&offset)) {
154 OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
159 if ((DumpType == DIDT_All || DumpType == DIDT_StrDwo) &&
160 !getStringDWOSection().empty()) {
161 OS << "\n.debug_str.dwo contents:\n";
162 DataExtractor strDWOData(getStringDWOSection(), isLittleEndian(), 0);
164 uint32_t strDWOOffset = 0;
165 while (const char *s = strDWOData.getCStr(&offset)) {
166 OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s);
167 strDWOOffset = offset;
171 if (DumpType == DIDT_All || DumpType == DIDT_Ranges) {
172 OS << "\n.debug_ranges contents:\n";
173 // In fact, different compile units may have different address byte
174 // sizes, but for simplicity we just use the address byte size of the last
175 // compile unit (there is no easy and fast way to associate address range
176 // list and the compile unit it describes).
177 DataExtractor rangesData(getRangeSection(), isLittleEndian(),
178 savedAddressByteSize);
180 DWARFDebugRangeList rangeList;
181 while (rangeList.extract(rangesData, &offset))
185 if (DumpType == DIDT_All || DumpType == DIDT_Pubnames)
186 dumpPubSection(OS, "debug_pubnames", getPubNamesSection(),
187 isLittleEndian(), false);
189 if (DumpType == DIDT_All || DumpType == DIDT_Pubtypes)
190 dumpPubSection(OS, "debug_pubtypes", getPubTypesSection(),
191 isLittleEndian(), false);
193 if (DumpType == DIDT_All || DumpType == DIDT_GnuPubnames)
194 dumpPubSection(OS, "debug_gnu_pubnames", getGnuPubNamesSection(),
195 isLittleEndian(), true /* GnuStyle */);
197 if (DumpType == DIDT_All || DumpType == DIDT_GnuPubtypes)
198 dumpPubSection(OS, "debug_gnu_pubtypes", getGnuPubTypesSection(),
199 isLittleEndian(), true /* GnuStyle */);
201 if ((DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) &&
202 !getStringOffsetDWOSection().empty()) {
203 OS << "\n.debug_str_offsets.dwo contents:\n";
204 DataExtractor strOffsetExt(getStringOffsetDWOSection(), isLittleEndian(),
207 uint64_t size = getStringOffsetDWOSection().size();
208 while (offset < size) {
209 OS << format("0x%8.8x: ", offset);
210 OS << format("%8.8x\n", strOffsetExt.getU32(&offset));
215 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
219 DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
221 Abbrev.reset(new DWARFDebugAbbrev());
222 Abbrev->parse(abbrData);
226 const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
228 return AbbrevDWO.get();
230 DataExtractor abbrData(getAbbrevDWOSection(), isLittleEndian(), 0);
231 AbbrevDWO.reset(new DWARFDebugAbbrev());
232 AbbrevDWO->parse(abbrData);
233 return AbbrevDWO.get();
236 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
240 DataExtractor LocData(getLocSection().Data, isLittleEndian(), 0);
241 Loc.reset(new DWARFDebugLoc(getLocSection().Relocs));
242 // assume all compile units have the same address byte size
243 if (getNumCompileUnits())
244 Loc->parse(LocData, getCompileUnitAtIndex(0)->getAddressByteSize());
248 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
250 return Aranges.get();
252 Aranges.reset(new DWARFDebugAranges());
253 Aranges->generate(this);
254 return Aranges.get();
257 const DWARFDebugFrame *DWARFContext::getDebugFrame() {
259 return DebugFrame.get();
261 // There's a "bug" in the DWARFv3 standard with respect to the target address
262 // size within debug frame sections. While DWARF is supposed to be independent
263 // of its container, FDEs have fields with size being "target address size",
264 // which isn't specified in DWARF in general. It's only specified for CUs, but
265 // .eh_frame can appear without a .debug_info section. Follow the example of
266 // other tools (libdwarf) and extract this from the container (ObjectFile
267 // provides this information). This problem is fixed in DWARFv4
268 // See this dwarf-discuss discussion for more details:
269 // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
270 DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(),
272 DebugFrame.reset(new DWARFDebugFrame());
273 DebugFrame->parse(debugFrameData);
274 return DebugFrame.get();
277 const DWARFLineTable *
278 DWARFContext::getLineTableForCompileUnit(DWARFCompileUnit *cu) {
280 Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
282 unsigned stmtOffset =
283 cu->getCompileUnitDIE()->getAttributeValueAsSectionOffset(
284 cu, DW_AT_stmt_list, -1U);
285 if (stmtOffset == -1U)
286 return 0; // No line table for this compile unit.
288 // See if the line table is cached.
289 if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
292 // We have to parse it first.
293 DataExtractor lineData(getLineSection().Data, isLittleEndian(),
294 cu->getAddressByteSize());
295 return Line->getOrParseLineTable(lineData, stmtOffset);
298 void DWARFContext::parseCompileUnits() {
302 const DataExtractor &DIData = DataExtractor(getInfoSection().Data,
303 isLittleEndian(), 0);
304 while (DIData.isValidOffset(offset)) {
305 std::unique_ptr<DWARFCompileUnit> CU(new DWARFCompileUnit(
306 getDebugAbbrev(), getInfoSection().Data, getAbbrevSection(),
307 getRangeSection(), getStringSection(), StringRef(), getAddrSection(),
308 &getInfoSection().Relocs, isLittleEndian()));
309 if (!CU->extract(DIData, &offset)) {
312 CUs.push_back(CU.release());
313 offset = CUs.back()->getNextUnitOffset();
317 void DWARFContext::parseTypeUnits() {
320 for (const auto &I : getTypesSections()) {
322 const DataExtractor &DIData =
323 DataExtractor(I.second.Data, isLittleEndian(), 0);
324 while (DIData.isValidOffset(offset)) {
325 std::unique_ptr<DWARFTypeUnit> TU(new DWARFTypeUnit(
326 getDebugAbbrev(), I.second.Data, getAbbrevSection(),
327 getRangeSection(), getStringSection(), StringRef(), getAddrSection(),
328 &I.second.Relocs, isLittleEndian()));
329 if (!TU->extract(DIData, &offset))
331 TUs.push_back(TU.release());
332 offset = TUs.back()->getNextUnitOffset();
337 void DWARFContext::parseDWOCompileUnits() {
341 const DataExtractor &DIData =
342 DataExtractor(getInfoDWOSection().Data, isLittleEndian(), 0);
343 while (DIData.isValidOffset(offset)) {
344 std::unique_ptr<DWARFCompileUnit> DWOCU(new DWARFCompileUnit(
345 getDebugAbbrevDWO(), getInfoDWOSection().Data, getAbbrevDWOSection(),
346 getRangeDWOSection(), getStringDWOSection(),
347 getStringOffsetDWOSection(), getAddrSection(),
348 &getInfoDWOSection().Relocs, isLittleEndian()));
349 if (!DWOCU->extract(DIData, &offset)) {
352 DWOCUs.push_back(DWOCU.release());
353 offset = DWOCUs.back()->getNextUnitOffset();
357 void DWARFContext::parseDWOTypeUnits() {
360 for (const auto &I : getTypesDWOSections()) {
362 const DataExtractor &DIData =
363 DataExtractor(I.second.Data, isLittleEndian(), 0);
364 while (DIData.isValidOffset(offset)) {
365 std::unique_ptr<DWARFTypeUnit> TU(new DWARFTypeUnit(
366 getDebugAbbrevDWO(), I.second.Data, getAbbrevDWOSection(),
367 getRangeDWOSection(), getStringDWOSection(),
368 getStringOffsetDWOSection(), getAddrSection(), &I.second.Relocs,
370 if (!TU->extract(DIData, &offset))
372 DWOTUs.push_back(TU.release());
373 offset = DWOTUs.back()->getNextUnitOffset();
379 struct OffsetComparator {
380 bool operator()(const DWARFCompileUnit *LHS,
381 const DWARFCompileUnit *RHS) const {
382 return LHS->getOffset() < RHS->getOffset();
384 bool operator()(const DWARFCompileUnit *LHS, uint32_t RHS) const {
385 return LHS->getOffset() < RHS;
387 bool operator()(uint32_t LHS, const DWARFCompileUnit *RHS) const {
388 return LHS < RHS->getOffset();
393 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
396 DWARFCompileUnit **CU =
397 std::lower_bound(CUs.begin(), CUs.end(), Offset, OffsetComparator());
398 if (CU != CUs.end()) {
404 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
405 // First, get the offset of the compile unit.
406 uint32_t CUOffset = getDebugAranges()->findAddress(Address);
407 // Retrieve the compile unit.
408 return getCompileUnitForOffset(CUOffset);
411 static bool getFileNameForCompileUnit(DWARFCompileUnit *CU,
412 const DWARFLineTable *LineTable,
414 bool NeedsAbsoluteFilePath,
415 std::string &FileName) {
418 !LineTable->getFileNameByIndex(FileIndex, NeedsAbsoluteFilePath,
421 if (NeedsAbsoluteFilePath && sys::path::is_relative(FileName)) {
422 // We may still need to append compilation directory of compile unit.
423 SmallString<16> AbsolutePath;
424 if (const char *CompilationDir = CU->getCompilationDir()) {
425 sys::path::append(AbsolutePath, CompilationDir);
427 sys::path::append(AbsolutePath, FileName);
428 FileName = AbsolutePath.str();
433 static bool getFileLineInfoForCompileUnit(DWARFCompileUnit *CU,
434 const DWARFLineTable *LineTable,
436 bool NeedsAbsoluteFilePath,
437 std::string &FileName,
438 uint32_t &Line, uint32_t &Column) {
439 if (CU == 0 || LineTable == 0)
441 // Get the index of row we're looking for in the line table.
442 uint32_t RowIndex = LineTable->lookupAddress(Address);
445 // Take file number and line/column from the row.
446 const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
447 if (!getFileNameForCompileUnit(CU, LineTable, Row.File,
448 NeedsAbsoluteFilePath, FileName))
455 DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
456 DILineInfoSpecifier Specifier) {
457 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
460 std::string FileName = "<invalid>";
461 std::string FunctionName = "<invalid>";
464 if (Specifier.needs(DILineInfoSpecifier::FunctionName)) {
465 // The address may correspond to instruction in some inlined function,
466 // so we have to build the chain of inlined functions and take the
467 // name of the topmost function in it.
468 const DWARFDebugInfoEntryInlinedChain &InlinedChain =
469 CU->getInlinedChainForAddress(Address);
470 if (InlinedChain.DIEs.size() > 0) {
471 const DWARFDebugInfoEntryMinimal &TopFunctionDIE = InlinedChain.DIEs[0];
472 if (const char *Name = TopFunctionDIE.getSubroutineName(InlinedChain.U))
476 if (Specifier.needs(DILineInfoSpecifier::FileLineInfo)) {
477 const DWARFLineTable *LineTable = getLineTableForCompileUnit(CU);
478 const bool NeedsAbsoluteFilePath =
479 Specifier.needs(DILineInfoSpecifier::AbsoluteFilePath);
480 getFileLineInfoForCompileUnit(CU, LineTable, Address,
481 NeedsAbsoluteFilePath,
482 FileName, Line, Column);
484 return DILineInfo(StringRef(FileName), StringRef(FunctionName),
488 DILineInfoTable DWARFContext::getLineInfoForAddressRange(uint64_t Address,
490 DILineInfoSpecifier Specifier) {
491 DILineInfoTable Lines;
492 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
496 std::string FunctionName = "<invalid>";
497 if (Specifier.needs(DILineInfoSpecifier::FunctionName)) {
498 // The address may correspond to instruction in some inlined function,
499 // so we have to build the chain of inlined functions and take the
500 // name of the topmost function in it.
501 const DWARFDebugInfoEntryInlinedChain &InlinedChain =
502 CU->getInlinedChainForAddress(Address);
503 if (InlinedChain.DIEs.size() > 0) {
504 const DWARFDebugInfoEntryMinimal &TopFunctionDIE = InlinedChain.DIEs[0];
505 if (const char *Name = TopFunctionDIE.getSubroutineName(InlinedChain.U))
510 // If the Specifier says we don't need FileLineInfo, just
511 // return the top-most function at the starting address.
512 if (!Specifier.needs(DILineInfoSpecifier::FileLineInfo)) {
514 std::make_pair(Address, DILineInfo("<invalid>", FunctionName, 0, 0)));
518 const DWARFLineTable *LineTable = getLineTableForCompileUnit(CU);
519 const bool NeedsAbsoluteFilePath =
520 Specifier.needs(DILineInfoSpecifier::AbsoluteFilePath);
522 // Get the index of row we're looking for in the line table.
523 std::vector<uint32_t> RowVector;
524 if (!LineTable->lookupAddressRange(Address, Size, RowVector))
527 for (uint32_t RowIndex : RowVector) {
528 // Take file number and line/column from the row.
529 const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
530 std::string FileName = "<invalid>";
531 getFileNameForCompileUnit(CU, LineTable, Row.File,
532 NeedsAbsoluteFilePath, FileName);
533 Lines.push_back(std::make_pair(
534 Row.Address, DILineInfo(FileName, FunctionName, Row.Line, Row.Column)));
540 DIInliningInfo DWARFContext::getInliningInfoForAddress(uint64_t Address,
541 DILineInfoSpecifier Specifier) {
542 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
544 return DIInliningInfo();
546 const DWARFDebugInfoEntryInlinedChain &InlinedChain =
547 CU->getInlinedChainForAddress(Address);
548 if (InlinedChain.DIEs.size() == 0)
549 return DIInliningInfo();
551 DIInliningInfo InliningInfo;
552 uint32_t CallFile = 0, CallLine = 0, CallColumn = 0;
553 const DWARFLineTable *LineTable = 0;
554 for (uint32_t i = 0, n = InlinedChain.DIEs.size(); i != n; i++) {
555 const DWARFDebugInfoEntryMinimal &FunctionDIE = InlinedChain.DIEs[i];
556 std::string FileName = "<invalid>";
557 std::string FunctionName = "<invalid>";
560 // Get function name if necessary.
561 if (Specifier.needs(DILineInfoSpecifier::FunctionName)) {
562 if (const char *Name = FunctionDIE.getSubroutineName(InlinedChain.U))
565 if (Specifier.needs(DILineInfoSpecifier::FileLineInfo)) {
566 const bool NeedsAbsoluteFilePath =
567 Specifier.needs(DILineInfoSpecifier::AbsoluteFilePath);
569 // For the topmost frame, initialize the line table of this
570 // compile unit and fetch file/line info from it.
571 LineTable = getLineTableForCompileUnit(CU);
572 // For the topmost routine, get file/line info from line table.
573 getFileLineInfoForCompileUnit(CU, LineTable, Address,
574 NeedsAbsoluteFilePath,
575 FileName, Line, Column);
577 // Otherwise, use call file, call line and call column from
578 // previous DIE in inlined chain.
579 getFileNameForCompileUnit(CU, LineTable, CallFile,
580 NeedsAbsoluteFilePath, FileName);
584 // Get call file/line/column of a current DIE.
586 FunctionDIE.getCallerFrame(InlinedChain.U, CallFile, CallLine,
590 DILineInfo Frame(StringRef(FileName), StringRef(FunctionName),
592 InliningInfo.addFrame(Frame);
597 static bool consumeCompressedDebugSectionHeader(StringRef &data,
598 uint64_t &OriginalSize) {
599 // Consume "ZLIB" prefix.
600 if (!data.startswith("ZLIB"))
602 data = data.substr(4);
603 // Consume uncompressed section size (big-endian 8 bytes).
604 DataExtractor extractor(data, false, 8);
606 OriginalSize = extractor.getU64(&Offset);
609 data = data.substr(Offset);
613 DWARFContextInMemory::DWARFContextInMemory(object::ObjectFile *Obj) :
614 IsLittleEndian(Obj->isLittleEndian()),
615 AddressSize(Obj->getBytesInAddress()) {
616 for (object::section_iterator i = Obj->section_begin(),
617 e = Obj->section_end();
622 i->getContents(data);
624 name = name.substr(name.find_first_not_of("._")); // Skip . and _ prefixes.
626 // Check if debug info section is compressed with zlib.
627 if (name.startswith("zdebug_")) {
628 uint64_t OriginalSize;
629 if (!zlib::isAvailable() ||
630 !consumeCompressedDebugSectionHeader(data, OriginalSize))
632 std::unique_ptr<MemoryBuffer> UncompressedSection;
633 if (zlib::uncompress(data, UncompressedSection, OriginalSize) !=
636 // Make data point to uncompressed section contents and save its contents.
637 name = name.substr(1);
638 data = UncompressedSection->getBuffer();
639 UncompressedSections.push_back(UncompressedSection.release());
643 StringSwitch<StringRef *>(name)
644 .Case("debug_info", &InfoSection.Data)
645 .Case("debug_abbrev", &AbbrevSection)
646 .Case("debug_loc", &LocSection.Data)
647 .Case("debug_line", &LineSection.Data)
648 .Case("debug_aranges", &ARangeSection)
649 .Case("debug_frame", &DebugFrameSection)
650 .Case("debug_str", &StringSection)
651 .Case("debug_ranges", &RangeSection)
652 .Case("debug_pubnames", &PubNamesSection)
653 .Case("debug_pubtypes", &PubTypesSection)
654 .Case("debug_gnu_pubnames", &GnuPubNamesSection)
655 .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
656 .Case("debug_info.dwo", &InfoDWOSection.Data)
657 .Case("debug_abbrev.dwo", &AbbrevDWOSection)
658 .Case("debug_line.dwo", &LineDWOSection.Data)
659 .Case("debug_str.dwo", &StringDWOSection)
660 .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
661 .Case("debug_addr", &AddrSection)
662 // Any more debug info sections go here.
666 if (name == "debug_ranges") {
667 // FIXME: Use the other dwo range section when we emit it.
668 RangeDWOSection = data;
670 } else if (name == "debug_types") {
671 // Find debug_types data by section rather than name as there are
672 // multiple, comdat grouped, debug_types sections.
673 TypesSections[*i].Data = data;
674 } else if (name == "debug_types.dwo") {
675 TypesDWOSections[*i].Data = data;
678 section_iterator RelocatedSection = i->getRelocatedSection();
679 if (RelocatedSection == Obj->section_end())
682 StringRef RelSecName;
683 RelocatedSection->getName(RelSecName);
684 RelSecName = RelSecName.substr(
685 RelSecName.find_first_not_of("._")); // Skip . and _ prefixes.
687 // TODO: Add support for relocations in other sections as needed.
688 // Record relocations for the debug_info and debug_line sections.
689 RelocAddrMap *Map = StringSwitch<RelocAddrMap*>(RelSecName)
690 .Case("debug_info", &InfoSection.Relocs)
691 .Case("debug_loc", &LocSection.Relocs)
692 .Case("debug_info.dwo", &InfoDWOSection.Relocs)
693 .Case("debug_line", &LineSection.Relocs)
696 // Find debug_types relocs by section rather than name as there are
697 // multiple, comdat grouped, debug_types sections.
698 if (RelSecName == "debug_types")
699 Map = &TypesSections[*RelocatedSection].Relocs;
700 else if (RelSecName == "debug_types.dwo")
701 Map = &TypesDWOSections[*RelocatedSection].Relocs;
706 if (i->relocation_begin() != i->relocation_end()) {
707 uint64_t SectionSize;
708 RelocatedSection->getSize(SectionSize);
709 for (object::relocation_iterator reloc_i = i->relocation_begin(),
710 reloc_e = i->relocation_end();
711 reloc_i != reloc_e; ++reloc_i) {
713 reloc_i->getOffset(Address);
715 reloc_i->getType(Type);
716 uint64_t SymAddr = 0;
717 // ELF relocations may need the symbol address
719 object::symbol_iterator Sym = reloc_i->getSymbol();
720 Sym->getAddress(SymAddr);
723 object::RelocVisitor V(Obj->getFileFormatName());
724 // The section address is always 0 for debug sections.
725 object::RelocToApply R(V.visit(Type, *reloc_i, 0, SymAddr));
727 SmallString<32> Name;
728 error_code ec(reloc_i->getTypeName(Name));
730 errs() << "Aaaaaa! Nameless relocation! Aaaaaa!\n";
732 errs() << "error: failed to compute relocation: "
737 if (Address + R.Width > SectionSize) {
738 errs() << "error: " << R.Width << "-byte relocation starting "
739 << Address << " bytes into section " << name << " which is "
740 << SectionSize << " bytes long.\n";
744 errs() << "error: can't handle a relocation of more than 8 bytes at "
748 DEBUG(dbgs() << "Writing " << format("%p", R.Value)
749 << " at " << format("%p", Address)
750 << " with width " << format("%d", R.Width)
752 Map->insert(std::make_pair(Address, std::make_pair(R.Width, R.Value)));
758 DWARFContextInMemory::~DWARFContextInMemory() {
759 DeleteContainerPointers(UncompressedSections);
762 void DWARFContextInMemory::anchor() { }