blob: 18c4e8e4cafdbf44635f5dae65db454251fcc436 [file] [log] [blame]
Benjamin Krameraa2f78f2011-09-13 19:42:23 +00001//===-- DWARFContext.cpp --------------------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Zachary Turner82af9432015-01-30 18:07:45 +000010#include "llvm/DebugInfo/DWARF/DWARFContext.h"
Alexey Samsonove16e16a2012-07-19 07:03:58 +000011#include "llvm/ADT/SmallString.h"
Alexey Samsonov3d0e3ed2013-04-17 14:27:04 +000012#include "llvm/ADT/StringSwitch.h"
Zachary Turner82af9432015-01-30 18:07:45 +000013#include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
14#include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
David Blaikie65a8efe2015-11-11 19:28:21 +000015#include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
Alexey Samsonov068fc8a2013-04-23 10:17:34 +000016#include "llvm/Support/Compression.h"
Benjamin Kramer6dda0322011-09-15 18:02:20 +000017#include "llvm/Support/Dwarf.h"
Benjamin Kramer07d4b1c2011-09-15 16:57:13 +000018#include "llvm/Support/Format.h"
Alexey Samsonove16e16a2012-07-19 07:03:58 +000019#include "llvm/Support/Path.h"
Benjamin Kramera6002fd2011-09-14 01:09:52 +000020#include "llvm/Support/raw_ostream.h"
Benjamin Kramer2602ca62011-09-15 20:43:22 +000021#include <algorithm>
Benjamin Krameraa2f78f2011-09-13 19:42:23 +000022using namespace llvm;
Benjamin Kramer6dda0322011-09-15 18:02:20 +000023using namespace dwarf;
Rafael Espindola4f60a382013-05-30 03:05:14 +000024using namespace object;
Benjamin Krameraa2f78f2011-09-13 19:42:23 +000025
Chandler Carruthe96dd892014-04-21 22:55:11 +000026#define DEBUG_TYPE "dwarf"
27
Eric Christopher494109b2012-10-16 23:46:25 +000028typedef DWARFDebugLine::LineTable DWARFLineTable;
Alexey Samsonovdce67342014-05-15 21:24:32 +000029typedef DILineInfoSpecifier::FileLineInfoKind FileLineInfoKind;
30typedef DILineInfoSpecifier::FunctionNameKind FunctionNameKind;
Eric Christopher494109b2012-10-16 23:46:25 +000031
David Blaikieecd21ff2013-09-24 19:50:00 +000032static void dumpPubSection(raw_ostream &OS, StringRef Name, StringRef Data,
Eric Christopher0de53592013-09-25 23:02:36 +000033 bool LittleEndian, bool GnuStyle) {
David Blaikieecd21ff2013-09-24 19:50:00 +000034 OS << "\n." << Name << " contents:\n";
35 DataExtractor pubNames(Data, LittleEndian, 0);
36 uint32_t offset = 0;
David Blaikie8a263cb2013-11-26 00:22:37 +000037 while (pubNames.isValidOffset(offset)) {
38 OS << "length = " << format("0x%08x", pubNames.getU32(&offset));
39 OS << " version = " << format("0x%04x", pubNames.getU16(&offset));
40 OS << " unit_offset = " << format("0x%08x", pubNames.getU32(&offset));
41 OS << " unit_size = " << format("0x%08x", pubNames.getU32(&offset)) << '\n';
42 if (GnuStyle)
43 OS << "Offset Linkage Kind Name\n";
44 else
45 OS << "Offset Name\n";
Eric Christopher0de53592013-09-25 23:02:36 +000046
David Blaikie8a263cb2013-11-26 00:22:37 +000047 while (offset < Data.size()) {
48 uint32_t dieRef = pubNames.getU32(&offset);
49 if (dieRef == 0)
50 break;
51 OS << format("0x%8.8x ", dieRef);
52 if (GnuStyle) {
53 PubIndexEntryDescriptor desc(pubNames.getU8(&offset));
54 OS << format("%-8s", dwarf::GDBIndexEntryLinkageString(desc.Linkage))
55 << ' ' << format("%-8s", dwarf::GDBIndexEntryKindString(desc.Kind))
56 << ' ';
57 }
58 OS << '\"' << pubNames.getCStr(&offset) << "\"\n";
Eric Christopher0de53592013-09-25 23:02:36 +000059 }
David Blaikieecd21ff2013-09-24 19:50:00 +000060 }
61}
62
Frederic Riss7c500472014-11-14 19:30:08 +000063static void dumpAccelSection(raw_ostream &OS, StringRef Name,
64 const DWARFSection& Section, StringRef StringSection,
65 bool LittleEndian) {
66 DataExtractor AccelSection(Section.Data, LittleEndian, 0);
Frederic Risse837ec22014-11-14 16:15:53 +000067 DataExtractor StrData(StringSection, LittleEndian, 0);
68 OS << "\n." << Name << " contents:\n";
Frederic Riss7c500472014-11-14 19:30:08 +000069 DWARFAcceleratorTable Accel(AccelSection, StrData, Section.Relocs);
Frederic Risse837ec22014-11-14 16:15:53 +000070 if (!Accel.extract())
71 return;
72 Accel.dump(OS);
73}
74
Eli Bendersky7a94daa2013-01-25 20:26:43 +000075void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType) {
76 if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) {
77 OS << ".debug_abbrev contents:\n";
78 getDebugAbbrev()->dump(OS);
79 }
Benjamin Kramera6002fd2011-09-14 01:09:52 +000080
David Blaikie66865d62014-01-09 00:13:35 +000081 if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo)
82 if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) {
David Blaikie622dce42014-01-08 23:29:59 +000083 OS << "\n.debug_abbrev.dwo contents:\n";
David Blaikie66865d62014-01-09 00:13:35 +000084 D->dump(OS);
David Blaikie622dce42014-01-08 23:29:59 +000085 }
David Blaikie622dce42014-01-08 23:29:59 +000086
Eli Bendersky7a94daa2013-01-25 20:26:43 +000087 if (DumpType == DIDT_All || DumpType == DIDT_Info) {
88 OS << "\n.debug_info contents:\n";
Alexey Samsonov1eabf982014-03-13 07:52:54 +000089 for (const auto &CU : compile_units())
90 CU->dump(OS);
Eli Bendersky7a94daa2013-01-25 20:26:43 +000091 }
Benjamin Kramera6002fd2011-09-14 01:09:52 +000092
David Blaikie66865d62014-01-09 00:13:35 +000093 if ((DumpType == DIDT_All || DumpType == DIDT_InfoDwo) &&
94 getNumDWOCompileUnits()) {
95 OS << "\n.debug_info.dwo contents:\n";
Alexey Samsonov1eabf982014-03-13 07:52:54 +000096 for (const auto &DWOCU : dwo_compile_units())
97 DWOCU->dump(OS);
David Blaikie66865d62014-01-09 00:13:35 +000098 }
David Blaikie622dce42014-01-08 23:29:59 +000099
David Blaikie66865d62014-01-09 00:13:35 +0000100 if ((DumpType == DIDT_All || DumpType == DIDT_Types) && getNumTypeUnits()) {
David Blaikie03c089c2013-09-23 22:44:47 +0000101 OS << "\n.debug_types contents:\n";
Frederic Riss312a02e2014-09-29 13:56:39 +0000102 for (const auto &TUS : type_unit_sections())
103 for (const auto &TU : TUS)
104 TU->dump(OS);
David Blaikie03c089c2013-09-23 22:44:47 +0000105 }
106
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000107 if ((DumpType == DIDT_All || DumpType == DIDT_TypesDwo) &&
108 getNumDWOTypeUnits()) {
109 OS << "\n.debug_types.dwo contents:\n";
Frederic Riss312a02e2014-09-29 13:56:39 +0000110 for (const auto &DWOTUS : dwo_type_unit_sections())
111 for (const auto &DWOTU : DWOTUS)
112 DWOTU->dump(OS);
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000113 }
David Blaikie92d9d622014-01-09 05:08:24 +0000114
David Blaikie18e73502013-06-19 21:37:13 +0000115 if (DumpType == DIDT_All || DumpType == DIDT_Loc) {
David Blaikie03c089c2013-09-23 22:44:47 +0000116 OS << "\n.debug_loc contents:\n";
David Blaikie18e73502013-06-19 21:37:13 +0000117 getDebugLoc()->dump(OS);
118 }
119
David Blaikie9c550ac2014-03-25 01:44:02 +0000120 if (DumpType == DIDT_All || DumpType == DIDT_LocDwo) {
121 OS << "\n.debug_loc.dwo contents:\n";
122 getDebugLocDWO()->dump(OS);
123 }
124
Eli Benderskyfd08bc12013-02-05 23:30:58 +0000125 if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
126 OS << "\n.debug_frame contents:\n";
127 getDebugFrame()->dump(OS);
128 }
129
Amjad Aboude59cc3e2015-11-12 09:38:54 +0000130 if (DumpType == DIDT_All || DumpType == DIDT_Macro) {
131 OS << "\n.debug_macinfo contents:\n";
132 getDebugMacro()->dump(OS);
133 }
134
Benjamin Kramera6002fd2011-09-14 01:09:52 +0000135 uint32_t offset = 0;
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000136 if (DumpType == DIDT_All || DumpType == DIDT_Aranges) {
137 OS << "\n.debug_aranges contents:\n";
138 DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
139 DWARFDebugArangeSet set;
140 while (set.extract(arangesData, &offset))
141 set.dump(OS);
142 }
Benjamin Kramer5acab502011-09-15 02:12:05 +0000143
Alexey Samsonov034e57a2012-08-27 07:17:47 +0000144 uint8_t savedAddressByteSize = 0;
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000145 if (DumpType == DIDT_All || DumpType == DIDT_Line) {
146 OS << "\n.debug_line contents:\n";
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000147 for (const auto &CU : compile_units()) {
148 savedAddressByteSize = CU->getAddressByteSize();
Alexey Samsonov7a18c062015-05-19 21:54:32 +0000149 const auto *CUDIE = CU->getUnitDIE();
150 if (CUDIE == nullptr)
151 continue;
152 unsigned stmtOffset = CUDIE->getAttributeValueAsSectionOffset(
153 CU.get(), DW_AT_stmt_list, -1U);
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000154 if (stmtOffset != -1U) {
David Blaikie1b5ee5d2013-09-23 17:42:01 +0000155 DataExtractor lineData(getLineSection().Data, isLittleEndian(),
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000156 savedAddressByteSize);
Alexey Samsonov110d5952014-04-30 00:09:19 +0000157 DWARFDebugLine::LineTable LineTable;
158 LineTable.parse(lineData, &getLineSection().Relocs, &stmtOffset);
159 LineTable.dump(OS);
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000160 }
Benjamin Kramer6dda0322011-09-15 18:02:20 +0000161 }
162 }
Benjamin Kramer07d4b1c2011-09-15 16:57:13 +0000163
David Blaikie65a8efe2015-11-11 19:28:21 +0000164 if (DumpType == DIDT_All || DumpType == DIDT_CUIndex) {
165 OS << "\n.debug_cu_index contents:\n";
David Blaikie0b44dcc2015-11-11 19:30:47 +0000166 DataExtractor CUIndexData(getCUIndexSection(), isLittleEndian(),
167 savedAddressByteSize);
David Blaikie65a8efe2015-11-11 19:28:21 +0000168 DWARFUnitIndex CUIndex;
David Blaikieee293c02015-11-12 01:57:33 +0000169 if (CUIndex.parse(CUIndexData))
170 CUIndex.dump(OS);
David Blaikie65a8efe2015-11-11 19:28:21 +0000171 }
172
David Blaikie51c40282015-11-11 19:40:49 +0000173 if (DumpType == DIDT_All || DumpType == DIDT_TUIndex) {
174 OS << "\n.debug_tu_index contents:\n";
175 DataExtractor TUIndexData(getTUIndexSection(), isLittleEndian(),
176 savedAddressByteSize);
177 DWARFUnitIndex TUIndex;
David Blaikieee293c02015-11-12 01:57:33 +0000178 if (TUIndex.parse(TUIndexData))
179 TUIndex.dump(OS);
David Blaikie51c40282015-11-11 19:40:49 +0000180 }
181
David Blaikie1d4736e2014-02-24 23:58:54 +0000182 if (DumpType == DIDT_All || DumpType == DIDT_LineDwo) {
183 OS << "\n.debug_line.dwo contents:\n";
184 unsigned stmtOffset = 0;
185 DataExtractor lineData(getLineDWOSection().Data, isLittleEndian(),
186 savedAddressByteSize);
Alexey Samsonov110d5952014-04-30 00:09:19 +0000187 DWARFDebugLine::LineTable LineTable;
188 while (LineTable.Prologue.parse(lineData, &stmtOffset)) {
189 LineTable.dump(OS);
190 LineTable.clear();
191 }
David Blaikie1d4736e2014-02-24 23:58:54 +0000192 }
193
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000194 if (DumpType == DIDT_All || DumpType == DIDT_Str) {
195 OS << "\n.debug_str contents:\n";
196 DataExtractor strData(getStringSection(), isLittleEndian(), 0);
197 offset = 0;
198 uint32_t strOffset = 0;
199 while (const char *s = strData.getCStr(&offset)) {
200 OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
201 strOffset = offset;
202 }
Benjamin Kramer07d4b1c2011-09-15 16:57:13 +0000203 }
Alexey Samsonov034e57a2012-08-27 07:17:47 +0000204
David Blaikie66865d62014-01-09 00:13:35 +0000205 if ((DumpType == DIDT_All || DumpType == DIDT_StrDwo) &&
206 !getStringDWOSection().empty()) {
207 OS << "\n.debug_str.dwo contents:\n";
208 DataExtractor strDWOData(getStringDWOSection(), isLittleEndian(), 0);
209 offset = 0;
210 uint32_t strDWOOffset = 0;
211 while (const char *s = strDWOData.getCStr(&offset)) {
212 OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s);
213 strDWOOffset = offset;
David Blaikie622dce42014-01-08 23:29:59 +0000214 }
David Blaikie66865d62014-01-09 00:13:35 +0000215 }
David Blaikie622dce42014-01-08 23:29:59 +0000216
Eli Bendersky7a94daa2013-01-25 20:26:43 +0000217 if (DumpType == DIDT_All || DumpType == DIDT_Ranges) {
218 OS << "\n.debug_ranges contents:\n";
219 // In fact, different compile units may have different address byte
220 // sizes, but for simplicity we just use the address byte size of the last
221 // compile unit (there is no easy and fast way to associate address range
222 // list and the compile unit it describes).
223 DataExtractor rangesData(getRangeSection(), isLittleEndian(),
224 savedAddressByteSize);
225 offset = 0;
226 DWARFDebugRangeList rangeList;
227 while (rangeList.extract(rangesData, &offset))
228 rangeList.dump(OS);
Eric Christopherda4b2192013-01-02 23:52:13 +0000229 }
Eric Christopher962c9082013-01-15 23:56:56 +0000230
Eric Christopher0de53592013-09-25 23:02:36 +0000231 if (DumpType == DIDT_All || DumpType == DIDT_Pubnames)
232 dumpPubSection(OS, "debug_pubnames", getPubNamesSection(),
233 isLittleEndian(), false);
Krzysztof Parzyszek97438dc2013-02-12 16:20:28 +0000234
Eric Christopher4c7e6ba2013-09-25 23:02:41 +0000235 if (DumpType == DIDT_All || DumpType == DIDT_Pubtypes)
236 dumpPubSection(OS, "debug_pubtypes", getPubTypesSection(),
237 isLittleEndian(), false);
238
David Blaikieecd21ff2013-09-24 19:50:00 +0000239 if (DumpType == DIDT_All || DumpType == DIDT_GnuPubnames)
240 dumpPubSection(OS, "debug_gnu_pubnames", getGnuPubNamesSection(),
Eric Christopher0de53592013-09-25 23:02:36 +0000241 isLittleEndian(), true /* GnuStyle */);
David Blaikieecd21ff2013-09-24 19:50:00 +0000242
243 if (DumpType == DIDT_All || DumpType == DIDT_GnuPubtypes)
244 dumpPubSection(OS, "debug_gnu_pubtypes", getGnuPubTypesSection(),
Eric Christopher0de53592013-09-25 23:02:36 +0000245 isLittleEndian(), true /* GnuStyle */);
David Blaikie404d3042013-09-19 23:01:29 +0000246
David Blaikie66865d62014-01-09 00:13:35 +0000247 if ((DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) &&
248 !getStringOffsetDWOSection().empty()) {
249 OS << "\n.debug_str_offsets.dwo contents:\n";
250 DataExtractor strOffsetExt(getStringOffsetDWOSection(), isLittleEndian(),
251 0);
252 offset = 0;
253 uint64_t size = getStringOffsetDWOSection().size();
254 while (offset < size) {
255 OS << format("0x%8.8x: ", offset);
256 OS << format("%8.8x\n", strOffsetExt.getU32(&offset));
Eric Christopher92f3c0b2013-05-06 17:50:42 +0000257 }
David Blaikie66865d62014-01-09 00:13:35 +0000258 }
Frederic Risse837ec22014-11-14 16:15:53 +0000259
260 if (DumpType == DIDT_All || DumpType == DIDT_AppleNames)
261 dumpAccelSection(OS, "apple_names", getAppleNamesSection(),
262 getStringSection(), isLittleEndian());
263
264 if (DumpType == DIDT_All || DumpType == DIDT_AppleTypes)
265 dumpAccelSection(OS, "apple_types", getAppleTypesSection(),
266 getStringSection(), isLittleEndian());
267
268 if (DumpType == DIDT_All || DumpType == DIDT_AppleNamespaces)
269 dumpAccelSection(OS, "apple_namespaces", getAppleNamespacesSection(),
270 getStringSection(), isLittleEndian());
271
272 if (DumpType == DIDT_All || DumpType == DIDT_AppleObjC)
273 dumpAccelSection(OS, "apple_objc", getAppleObjCSection(),
274 getStringSection(), isLittleEndian());
Benjamin Krameraa2f78f2011-09-13 19:42:23 +0000275}
276
David Blaikie82641be2015-11-17 00:39:55 +0000277const DWARFUnitIndex &DWARFContext::getCUIndex() {
278 if (CUIndex)
279 return *CUIndex;
280
281 DataExtractor CUIndexData(getCUIndexSection(), isLittleEndian(), 0);
282
283 CUIndex = llvm::make_unique<DWARFUnitIndex>();
284 CUIndex->parse(CUIndexData);
285 return *CUIndex;
286}
287
288const DWARFUnitIndex &DWARFContext::getTUIndex() {
289 if (TUIndex)
290 return *TUIndex;
291
292 DataExtractor TUIndexData(getTUIndexSection(), isLittleEndian(), 0);
293
294 TUIndex = llvm::make_unique<DWARFUnitIndex>();
295 TUIndex->parse(TUIndexData);
296 return *TUIndex;
297}
298
Benjamin Krameraa2f78f2011-09-13 19:42:23 +0000299const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() {
300 if (Abbrev)
301 return Abbrev.get();
302
303 DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0);
304
305 Abbrev.reset(new DWARFDebugAbbrev());
Alexey Samsonov4316df52014-04-25 21:10:56 +0000306 Abbrev->extract(abbrData);
Benjamin Krameraa2f78f2011-09-13 19:42:23 +0000307 return Abbrev.get();
308}
309
Eric Christopherda4b2192013-01-02 23:52:13 +0000310const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
311 if (AbbrevDWO)
312 return AbbrevDWO.get();
313
314 DataExtractor abbrData(getAbbrevDWOSection(), isLittleEndian(), 0);
315 AbbrevDWO.reset(new DWARFDebugAbbrev());
Alexey Samsonov4316df52014-04-25 21:10:56 +0000316 AbbrevDWO->extract(abbrData);
Eric Christopherda4b2192013-01-02 23:52:13 +0000317 return AbbrevDWO.get();
318}
319
David Blaikie18e73502013-06-19 21:37:13 +0000320const DWARFDebugLoc *DWARFContext::getDebugLoc() {
321 if (Loc)
322 return Loc.get();
323
David Blaikie1b5ee5d2013-09-23 17:42:01 +0000324 DataExtractor LocData(getLocSection().Data, isLittleEndian(), 0);
325 Loc.reset(new DWARFDebugLoc(getLocSection().Relocs));
David Blaikie18e73502013-06-19 21:37:13 +0000326 // assume all compile units have the same address byte size
327 if (getNumCompileUnits())
328 Loc->parse(LocData, getCompileUnitAtIndex(0)->getAddressByteSize());
329 return Loc.get();
330}
331
David Blaikie9c550ac2014-03-25 01:44:02 +0000332const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() {
333 if (LocDWO)
334 return LocDWO.get();
335
336 DataExtractor LocData(getLocDWOSection().Data, isLittleEndian(), 0);
337 LocDWO.reset(new DWARFDebugLocDWO());
338 LocDWO->parse(LocData);
339 return LocDWO.get();
340}
341
Benjamin Kramera6002fd2011-09-14 01:09:52 +0000342const DWARFDebugAranges *DWARFContext::getDebugAranges() {
343 if (Aranges)
344 return Aranges.get();
345
Benjamin Kramera6002fd2011-09-14 01:09:52 +0000346 Aranges.reset(new DWARFDebugAranges());
Alexey Samsonova1694c12012-11-16 08:36:25 +0000347 Aranges->generate(this);
Benjamin Kramera6002fd2011-09-14 01:09:52 +0000348 return Aranges.get();
349}
350
Eli Benderskyfd08bc12013-02-05 23:30:58 +0000351const DWARFDebugFrame *DWARFContext::getDebugFrame() {
352 if (DebugFrame)
353 return DebugFrame.get();
354
355 // There's a "bug" in the DWARFv3 standard with respect to the target address
356 // size within debug frame sections. While DWARF is supposed to be independent
357 // of its container, FDEs have fields with size being "target address size",
358 // which isn't specified in DWARF in general. It's only specified for CUs, but
359 // .eh_frame can appear without a .debug_info section. Follow the example of
360 // other tools (libdwarf) and extract this from the container (ObjectFile
361 // provides this information). This problem is fixed in DWARFv4
362 // See this dwarf-discuss discussion for more details:
363 // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
364 DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(),
365 getAddressSize());
366 DebugFrame.reset(new DWARFDebugFrame());
367 DebugFrame->parse(debugFrameData);
368 return DebugFrame.get();
369}
370
Amjad Aboude59cc3e2015-11-12 09:38:54 +0000371const DWARFDebugMacro *DWARFContext::getDebugMacro() {
372 if (Macro)
373 return Macro.get();
374
375 DataExtractor MacinfoData(getMacinfoSection(), isLittleEndian(), 0);
376 Macro.reset(new DWARFDebugMacro());
377 Macro->parse(MacinfoData);
378 return Macro.get();
379}
380
Eric Christopher494109b2012-10-16 23:46:25 +0000381const DWARFLineTable *
Alexey Samsonov7a18c062015-05-19 21:54:32 +0000382DWARFContext::getLineTableForUnit(DWARFUnit *U) {
Benjamin Kramer679e1752011-09-15 20:43:18 +0000383 if (!Line)
David Blaikie1b5ee5d2013-09-23 17:42:01 +0000384 Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
David Blaikiec4e2bed2015-11-17 21:08:05 +0000385
Alexey Samsonov7a18c062015-05-19 21:54:32 +0000386 const auto *UnitDIE = U->getUnitDIE();
387 if (UnitDIE == nullptr)
388 return nullptr;
David Blaikiec4e2bed2015-11-17 21:08:05 +0000389
Benjamin Kramer679e1752011-09-15 20:43:18 +0000390 unsigned stmtOffset =
Alexey Samsonov7a18c062015-05-19 21:54:32 +0000391 UnitDIE->getAttributeValueAsSectionOffset(U, DW_AT_stmt_list, -1U);
Benjamin Kramer679e1752011-09-15 20:43:18 +0000392 if (stmtOffset == -1U)
Craig Topper2617dcc2014-04-15 06:32:26 +0000393 return nullptr; // No line table for this compile unit.
Benjamin Kramer5acab502011-09-15 02:12:05 +0000394
David Blaikiec4e2bed2015-11-17 21:08:05 +0000395 stmtOffset += U->getLineTableOffset();
Benjamin Kramer679e1752011-09-15 20:43:18 +0000396 // See if the line table is cached.
Eric Christopher494109b2012-10-16 23:46:25 +0000397 if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
Benjamin Kramer679e1752011-09-15 20:43:18 +0000398 return lt;
399
400 // We have to parse it first.
David Blaikiec4e2bed2015-11-17 21:08:05 +0000401 DataExtractor lineData(U->getLineSection(), isLittleEndian(),
Alexey Samsonov7a18c062015-05-19 21:54:32 +0000402 U->getAddressByteSize());
Benjamin Kramer679e1752011-09-15 20:43:18 +0000403 return Line->getOrParseLineTable(lineData, stmtOffset);
Benjamin Kramer5acab502011-09-15 02:12:05 +0000404}
405
Benjamin Krameraa2f78f2011-09-13 19:42:23 +0000406void DWARFContext::parseCompileUnits() {
Alexey Samsonov8cd4c9d2014-10-08 00:07:53 +0000407 CUs.parse(*this, getInfoSection());
Benjamin Krameraa2f78f2011-09-13 19:42:23 +0000408}
Benjamin Kramer2602ca62011-09-15 20:43:22 +0000409
David Blaikie03c089c2013-09-23 22:44:47 +0000410void DWARFContext::parseTypeUnits() {
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000411 if (!TUs.empty())
412 return;
413 for (const auto &I : getTypesSections()) {
Benjamin Kramerf5e2fc42015-05-29 19:43:39 +0000414 TUs.emplace_back();
Alexey Samsonov8cd4c9d2014-10-08 00:07:53 +0000415 TUs.back().parse(*this, I.second);
David Blaikie03c089c2013-09-23 22:44:47 +0000416 }
417}
418
Eric Christopherda4b2192013-01-02 23:52:13 +0000419void DWARFContext::parseDWOCompileUnits() {
Alexey Samsonov8cd4c9d2014-10-08 00:07:53 +0000420 DWOCUs.parseDWO(*this, getInfoDWOSection());
Eric Christopherda4b2192013-01-02 23:52:13 +0000421}
422
David Blaikie92d9d622014-01-09 05:08:24 +0000423void DWARFContext::parseDWOTypeUnits() {
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000424 if (!DWOTUs.empty())
425 return;
426 for (const auto &I : getTypesDWOSections()) {
Benjamin Kramerf5e2fc42015-05-29 19:43:39 +0000427 DWOTUs.emplace_back();
Alexey Samsonov8cd4c9d2014-10-08 00:07:53 +0000428 DWOTUs.back().parseDWO(*this, I.second);
David Blaikie92d9d622014-01-09 05:08:24 +0000429 }
430}
431
Alexey Samsonov45be7932012-08-30 07:49:50 +0000432DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000433 parseCompileUnits();
Frederic Riss4e126a02014-09-15 07:50:27 +0000434 return CUs.getUnitForOffset(Offset);
Benjamin Kramer2602ca62011-09-15 20:43:22 +0000435}
436
Alexey Samsonov45be7932012-08-30 07:49:50 +0000437DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
Benjamin Kramer112ec172011-09-15 21:59:13 +0000438 // First, get the offset of the compile unit.
Alexey Samsonov45be7932012-08-30 07:49:50 +0000439 uint32_t CUOffset = getDebugAranges()->findAddress(Address);
Benjamin Kramer2602ca62011-09-15 20:43:22 +0000440 // Retrieve the compile unit.
Alexey Samsonov45be7932012-08-30 07:49:50 +0000441 return getCompileUnitForOffset(CUOffset);
442}
443
Alexey Samsonovd0109992014-04-18 21:36:39 +0000444static bool getFunctionNameForAddress(DWARFCompileUnit *CU, uint64_t Address,
Alexey Samsonovdce67342014-05-15 21:24:32 +0000445 FunctionNameKind Kind,
Alexey Samsonovd0109992014-04-18 21:36:39 +0000446 std::string &FunctionName) {
Alexey Samsonovdce67342014-05-15 21:24:32 +0000447 if (Kind == FunctionNameKind::None)
448 return false;
Alexey Samsonovd0109992014-04-18 21:36:39 +0000449 // The address may correspond to instruction in some inlined function,
450 // so we have to build the chain of inlined functions and take the
451 // name of the topmost function in it.
452 const DWARFDebugInfoEntryInlinedChain &InlinedChain =
453 CU->getInlinedChainForAddress(Address);
454 if (InlinedChain.DIEs.size() == 0)
455 return false;
456 const DWARFDebugInfoEntryMinimal &TopFunctionDIE = InlinedChain.DIEs[0];
Alexey Samsonovdce67342014-05-15 21:24:32 +0000457 if (const char *Name =
458 TopFunctionDIE.getSubroutineName(InlinedChain.U, Kind)) {
Alexey Samsonovd0109992014-04-18 21:36:39 +0000459 FunctionName = Name;
460 return true;
461 }
462 return false;
463}
464
Alexey Samsonov45be7932012-08-30 07:49:50 +0000465DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
Alexey Samsonovdce67342014-05-15 21:24:32 +0000466 DILineInfoSpecifier Spec) {
Alexey Samsonovd0109992014-04-18 21:36:39 +0000467 DILineInfo Result;
468
Alexey Samsonov45be7932012-08-30 07:49:50 +0000469 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
470 if (!CU)
Alexey Samsonovd0109992014-04-18 21:36:39 +0000471 return Result;
Alexey Samsonovdce67342014-05-15 21:24:32 +0000472 getFunctionNameForAddress(CU, Address, Spec.FNKind, Result.FunctionName);
473 if (Spec.FLIKind != FileLineInfoKind::None) {
Frederic Riss101b5e22014-09-19 15:11:51 +0000474 if (const DWARFLineTable *LineTable = getLineTableForUnit(CU))
475 LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
476 Spec.FLIKind, Result);
Alexey Samsonovf4462fa2012-07-02 05:54:45 +0000477 }
Alexey Samsonovd0109992014-04-18 21:36:39 +0000478 return Result;
Benjamin Kramer2602ca62011-09-15 20:43:22 +0000479}
David Blaikiea379b1812011-12-20 02:50:00 +0000480
Alexey Samsonovdce67342014-05-15 21:24:32 +0000481DILineInfoTable
482DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
483 DILineInfoSpecifier Spec) {
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000484 DILineInfoTable Lines;
485 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
486 if (!CU)
487 return Lines;
488
489 std::string FunctionName = "<invalid>";
Alexey Samsonovdce67342014-05-15 21:24:32 +0000490 getFunctionNameForAddress(CU, Address, Spec.FNKind, FunctionName);
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000491
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000492 // If the Specifier says we don't need FileLineInfo, just
493 // return the top-most function at the starting address.
Alexey Samsonovdce67342014-05-15 21:24:32 +0000494 if (Spec.FLIKind == FileLineInfoKind::None) {
Alexey Samsonovd0109992014-04-18 21:36:39 +0000495 DILineInfo Result;
496 Result.FunctionName = FunctionName;
497 Lines.push_back(std::make_pair(Address, Result));
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000498 return Lines;
499 }
500
Frederic Rissec8a5ba2014-09-04 06:14:40 +0000501 const DWARFLineTable *LineTable = getLineTableForUnit(CU);
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000502
503 // Get the index of row we're looking for in the line table.
504 std::vector<uint32_t> RowVector;
505 if (!LineTable->lookupAddressRange(Address, Size, RowVector))
506 return Lines;
507
Alexey Samsonov1eabf982014-03-13 07:52:54 +0000508 for (uint32_t RowIndex : RowVector) {
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000509 // Take file number and line/column from the row.
510 const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
Alexey Samsonovd0109992014-04-18 21:36:39 +0000511 DILineInfo Result;
Frederic Riss101b5e22014-09-19 15:11:51 +0000512 LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
513 Spec.FLIKind, Result.FileName);
Alexey Samsonovd0109992014-04-18 21:36:39 +0000514 Result.FunctionName = FunctionName;
515 Result.Line = Row.Line;
516 Result.Column = Row.Column;
517 Lines.push_back(std::make_pair(Row.Address, Result));
Andrew Kaylor9a8ff812013-01-26 00:28:05 +0000518 }
519
520 return Lines;
521}
522
Alexey Samsonovdce67342014-05-15 21:24:32 +0000523DIInliningInfo
524DWARFContext::getInliningInfoForAddress(uint64_t Address,
525 DILineInfoSpecifier Spec) {
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000526 DIInliningInfo InliningInfo;
527
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000528 DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
529 if (!CU)
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000530 return InliningInfo;
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000531
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000532 const DWARFLineTable *LineTable = nullptr;
Alexey Samsonov3211e612013-08-06 10:49:15 +0000533 const DWARFDebugInfoEntryInlinedChain &InlinedChain =
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000534 CU->getInlinedChainForAddress(Address);
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000535 if (InlinedChain.DIEs.size() == 0) {
536 // If there is no DIE for address (e.g. it is in unavailable .dwo file),
537 // try to at least get file/line info from symbol table.
Alexey Samsonovdce67342014-05-15 21:24:32 +0000538 if (Spec.FLIKind != FileLineInfoKind::None) {
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000539 DILineInfo Frame;
Frederic Rissec8a5ba2014-09-04 06:14:40 +0000540 LineTable = getLineTableForUnit(CU);
Frederic Riss101b5e22014-09-19 15:11:51 +0000541 if (LineTable &&
542 LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
543 Spec.FLIKind, Frame))
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000544 InliningInfo.addFrame(Frame);
Alexey Samsonov5c39fdf2014-04-18 22:22:44 +0000545 }
546 return InliningInfo;
547 }
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000548
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000549 uint32_t CallFile = 0, CallLine = 0, CallColumn = 0;
Alexey Samsonov3211e612013-08-06 10:49:15 +0000550 for (uint32_t i = 0, n = InlinedChain.DIEs.size(); i != n; i++) {
551 const DWARFDebugInfoEntryMinimal &FunctionDIE = InlinedChain.DIEs[i];
Alexey Samsonovd0109992014-04-18 21:36:39 +0000552 DILineInfo Frame;
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000553 // Get function name if necessary.
Alexey Samsonovdce67342014-05-15 21:24:32 +0000554 if (const char *Name =
555 FunctionDIE.getSubroutineName(InlinedChain.U, Spec.FNKind))
556 Frame.FunctionName = Name;
557 if (Spec.FLIKind != FileLineInfoKind::None) {
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000558 if (i == 0) {
559 // For the topmost frame, initialize the line table of this
560 // compile unit and fetch file/line info from it.
Frederic Rissec8a5ba2014-09-04 06:14:40 +0000561 LineTable = getLineTableForUnit(CU);
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000562 // For the topmost routine, get file/line info from line table.
Frederic Riss101b5e22014-09-19 15:11:51 +0000563 if (LineTable)
564 LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(),
565 Spec.FLIKind, Frame);
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000566 } else {
567 // Otherwise, use call file, call line and call column from
568 // previous DIE in inlined chain.
Frederic Riss101b5e22014-09-19 15:11:51 +0000569 if (LineTable)
570 LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(),
571 Spec.FLIKind, Frame.FileName);
Alexey Samsonovd0109992014-04-18 21:36:39 +0000572 Frame.Line = CallLine;
573 Frame.Column = CallColumn;
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000574 }
575 // Get call file/line/column of a current DIE.
576 if (i + 1 < n) {
David Blaikie07e22442013-09-23 22:44:40 +0000577 FunctionDIE.getCallerFrame(InlinedChain.U, CallFile, CallLine,
Alexey Samsonov3211e612013-08-06 10:49:15 +0000578 CallColumn);
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000579 }
580 }
Alexey Samsonovc942e6b2012-09-04 08:12:33 +0000581 InliningInfo.addFrame(Frame);
582 }
583 return InliningInfo;
584}
585
Alexey Samsonov068fc8a2013-04-23 10:17:34 +0000586static bool consumeCompressedDebugSectionHeader(StringRef &data,
587 uint64_t &OriginalSize) {
588 // Consume "ZLIB" prefix.
589 if (!data.startswith("ZLIB"))
590 return false;
591 data = data.substr(4);
592 // Consume uncompressed section size (big-endian 8 bytes).
593 DataExtractor extractor(data, false, 8);
594 uint32_t Offset = 0;
595 OriginalSize = extractor.getU64(&Offset);
596 if (Offset == 0)
597 return false;
598 data = data.substr(Offset);
599 return true;
600}
601
Keno Fischerc780e8e2015-05-21 21:24:32 +0000602DWARFContextInMemory::DWARFContextInMemory(const object::ObjectFile &Obj,
603 const LoadedObjectInfo *L)
Rafael Espindolaa04bb5b2014-07-31 20:19:36 +0000604 : IsLittleEndian(Obj.isLittleEndian()),
605 AddressSize(Obj.getBytesInAddress()) {
606 for (const SectionRef &Section : Obj.sections()) {
Eric Christopher7370b552012-11-12 21:40:38 +0000607 StringRef name;
Alexey Samsonov063eb3f2014-03-13 13:52:54 +0000608 Section.getName(name);
David Majnemerdac39852014-09-26 22:32:16 +0000609 // Skip BSS and Virtual sections, they aren't interesting.
Rafael Espindola80291272014-10-08 15:28:58 +0000610 bool IsBSS = Section.isBSS();
David Majnemerdac39852014-09-26 22:32:16 +0000611 if (IsBSS)
612 continue;
Rafael Espindola80291272014-10-08 15:28:58 +0000613 bool IsVirtual = Section.isVirtual();
David Majnemerdac39852014-09-26 22:32:16 +0000614 if (IsVirtual)
615 continue;
Eric Christopher7370b552012-11-12 21:40:38 +0000616 StringRef data;
Keno Fischerc780e8e2015-05-21 21:24:32 +0000617
Lang Hames2e88f4f2015-07-28 17:52:11 +0000618 section_iterator RelocatedSection = Section.getRelocatedSection();
Keno Fischerc780e8e2015-05-21 21:24:32 +0000619 // Try to obtain an already relocated version of this section.
620 // Else use the unrelocated section from the object file. We'll have to
621 // apply relocations ourselves later.
Lang Hames2e88f4f2015-07-28 17:52:11 +0000622 if (!L || !L->getLoadedSectionContents(*RelocatedSection,data))
Keno Fischerc780e8e2015-05-21 21:24:32 +0000623 Section.getContents(data);
Eric Christopher7370b552012-11-12 21:40:38 +0000624
Eric Christopher7370b552012-11-12 21:40:38 +0000625 name = name.substr(name.find_first_not_of("._")); // Skip . and _ prefixes.
Alexey Samsonov3d0e3ed2013-04-17 14:27:04 +0000626
Alexey Samsonov068fc8a2013-04-23 10:17:34 +0000627 // Check if debug info section is compressed with zlib.
628 if (name.startswith("zdebug_")) {
629 uint64_t OriginalSize;
630 if (!zlib::isAvailable() ||
631 !consumeCompressedDebugSectionHeader(data, OriginalSize))
632 continue;
David Blaikiea505f242014-04-05 21:26:44 +0000633 UncompressedSections.resize(UncompressedSections.size() + 1);
634 if (zlib::uncompress(data, UncompressedSections.back(), OriginalSize) !=
635 zlib::StatusOK) {
636 UncompressedSections.pop_back();
Alexey Samsonov068fc8a2013-04-23 10:17:34 +0000637 continue;
David Blaikiea505f242014-04-05 21:26:44 +0000638 }
Alexey Samsonov068fc8a2013-04-23 10:17:34 +0000639 // Make data point to uncompressed section contents and save its contents.
640 name = name.substr(1);
David Blaikiea505f242014-04-05 21:26:44 +0000641 data = UncompressedSections.back();
Alexey Samsonov068fc8a2013-04-23 10:17:34 +0000642 }
643
Alexey Samsonov063eb3f2014-03-13 13:52:54 +0000644 StringRef *SectionData =
Eric Christopher4c7e6ba2013-09-25 23:02:41 +0000645 StringSwitch<StringRef *>(name)
646 .Case("debug_info", &InfoSection.Data)
647 .Case("debug_abbrev", &AbbrevSection)
648 .Case("debug_loc", &LocSection.Data)
649 .Case("debug_line", &LineSection.Data)
650 .Case("debug_aranges", &ARangeSection)
651 .Case("debug_frame", &DebugFrameSection)
652 .Case("debug_str", &StringSection)
653 .Case("debug_ranges", &RangeSection)
Amjad Aboude59cc3e2015-11-12 09:38:54 +0000654 .Case("debug_macinfo", &MacinfoSection)
Eric Christopher4c7e6ba2013-09-25 23:02:41 +0000655 .Case("debug_pubnames", &PubNamesSection)
656 .Case("debug_pubtypes", &PubTypesSection)
657 .Case("debug_gnu_pubnames", &GnuPubNamesSection)
658 .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
659 .Case("debug_info.dwo", &InfoDWOSection.Data)
660 .Case("debug_abbrev.dwo", &AbbrevDWOSection)
David Blaikie9c550ac2014-03-25 01:44:02 +0000661 .Case("debug_loc.dwo", &LocDWOSection.Data)
David Blaikie1d4736e2014-02-24 23:58:54 +0000662 .Case("debug_line.dwo", &LineDWOSection.Data)
Eric Christopher4c7e6ba2013-09-25 23:02:41 +0000663 .Case("debug_str.dwo", &StringDWOSection)
664 .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
665 .Case("debug_addr", &AddrSection)
Frederic Riss7c500472014-11-14 19:30:08 +0000666 .Case("apple_names", &AppleNamesSection.Data)
667 .Case("apple_types", &AppleTypesSection.Data)
668 .Case("apple_namespaces", &AppleNamespacesSection.Data)
669 .Case("apple_namespac", &AppleNamespacesSection.Data)
670 .Case("apple_objc", &AppleObjCSection.Data)
David Blaikie65a8efe2015-11-11 19:28:21 +0000671 .Case("debug_cu_index", &CUIndexSection)
David Blaikie51c40282015-11-11 19:40:49 +0000672 .Case("debug_tu_index", &TUIndexSection)
Eric Christopher4c7e6ba2013-09-25 23:02:41 +0000673 // Any more debug info sections go here.
Craig Topper2617dcc2014-04-15 06:32:26 +0000674 .Default(nullptr);
Alexey Samsonov063eb3f2014-03-13 13:52:54 +0000675 if (SectionData) {
676 *SectionData = data;
Rafael Espindola4f60a382013-05-30 03:05:14 +0000677 if (name == "debug_ranges") {
678 // FIXME: Use the other dwo range section when we emit it.
679 RangeDWOSection = data;
680 }
David Blaikie03c089c2013-09-23 22:44:47 +0000681 } else if (name == "debug_types") {
David Blaikie427e4352013-09-23 23:39:55 +0000682 // Find debug_types data by section rather than name as there are
683 // multiple, comdat grouped, debug_types sections.
Alexey Samsonov063eb3f2014-03-13 13:52:54 +0000684 TypesSections[Section].Data = data;
David Blaikie92d9d622014-01-09 05:08:24 +0000685 } else if (name == "debug_types.dwo") {
Alexey Samsonov063eb3f2014-03-13 13:52:54 +0000686 TypesDWOSections[Section].Data = data;
Eric Christopherda4b2192013-01-02 23:52:13 +0000687 }
Eric Christopher7370b552012-11-12 21:40:38 +0000688
Rafael Espindolaa04bb5b2014-07-31 20:19:36 +0000689 if (RelocatedSection == Obj.section_end())
Rafael Espindola4f60a382013-05-30 03:05:14 +0000690 continue;
691
692 StringRef RelSecName;
Keno Fischerc780e8e2015-05-21 21:24:32 +0000693 StringRef RelSecData;
Rafael Espindola4f60a382013-05-30 03:05:14 +0000694 RelocatedSection->getName(RelSecName);
Keno Fischerc780e8e2015-05-21 21:24:32 +0000695
696 // If the section we're relocating was relocated already by the JIT,
697 // then we used the relocated version above, so we do not need to process
698 // relocations for it now.
Lang Hames2e88f4f2015-07-28 17:52:11 +0000699 if (L && L->getLoadedSectionContents(*RelocatedSection,RelSecData))
Keno Fischerc780e8e2015-05-21 21:24:32 +0000700 continue;
701
Frederic Riss7bb12262015-08-23 04:44:21 +0000702 // In Mach-o files, the relocations do not need to be applied if
703 // there is no load offset to apply. The value read at the
704 // relocation point already factors in the section address
705 // (actually applying the relocations will produce wrong results
706 // as the section address will be added twice).
707 if (!L && dyn_cast<MachOObjectFile>(&Obj))
708 continue;
709
Rafael Espindola4f60a382013-05-30 03:05:14 +0000710 RelSecName = RelSecName.substr(
711 RelSecName.find_first_not_of("._")); // Skip . and _ prefixes.
712
Andrew Kaylord55d7012013-01-25 22:50:58 +0000713 // TODO: Add support for relocations in other sections as needed.
714 // Record relocations for the debug_info and debug_line sections.
Rafael Espindola4f60a382013-05-30 03:05:14 +0000715 RelocAddrMap *Map = StringSwitch<RelocAddrMap*>(RelSecName)
David Blaikie1b5ee5d2013-09-23 17:42:01 +0000716 .Case("debug_info", &InfoSection.Relocs)
717 .Case("debug_loc", &LocSection.Relocs)
718 .Case("debug_info.dwo", &InfoDWOSection.Relocs)
719 .Case("debug_line", &LineSection.Relocs)
Frederic Riss7c500472014-11-14 19:30:08 +0000720 .Case("apple_names", &AppleNamesSection.Relocs)
721 .Case("apple_types", &AppleTypesSection.Relocs)
722 .Case("apple_namespaces", &AppleNamespacesSection.Relocs)
723 .Case("apple_namespac", &AppleNamespacesSection.Relocs)
724 .Case("apple_objc", &AppleObjCSection.Relocs)
Craig Topper2617dcc2014-04-15 06:32:26 +0000725 .Default(nullptr);
David Blaikie03c089c2013-09-23 22:44:47 +0000726 if (!Map) {
David Blaikie427e4352013-09-23 23:39:55 +0000727 // Find debug_types relocs by section rather than name as there are
728 // multiple, comdat grouped, debug_types sections.
David Blaikie92d9d622014-01-09 05:08:24 +0000729 if (RelSecName == "debug_types")
730 Map = &TypesSections[*RelocatedSection].Relocs;
731 else if (RelSecName == "debug_types.dwo")
732 Map = &TypesDWOSections[*RelocatedSection].Relocs;
733 else
734 continue;
David Blaikie03c089c2013-09-23 22:44:47 +0000735 }
Eric Christopher7370b552012-11-12 21:40:38 +0000736
Alexey Samsonov063eb3f2014-03-13 13:52:54 +0000737 if (Section.relocation_begin() != Section.relocation_end()) {
Rafael Espindola80291272014-10-08 15:28:58 +0000738 uint64_t SectionSize = RelocatedSection->getSize();
Alexey Samsonovaa4d2952014-03-14 14:22:49 +0000739 for (const RelocationRef &Reloc : Section.relocations()) {
Rafael Espindola96d071c2015-06-29 23:29:12 +0000740 uint64_t Address = Reloc.getOffset();
Rafael Espindola99c041b2015-06-30 01:53:01 +0000741 uint64_t Type = Reloc.getType();
Andrew Kaylord55d7012013-01-25 22:50:58 +0000742 uint64_t SymAddr = 0;
Keno Fischerc780e8e2015-05-21 21:24:32 +0000743 uint64_t SectionLoadAddress = 0;
David Majnemer5fbe3242014-10-08 06:38:50 +0000744 object::symbol_iterator Sym = Reloc.getSymbol();
Rafael Espindola63a88ce2015-06-19 17:54:28 +0000745 object::section_iterator RSec = Obj.section_end();
Keno Fischerc780e8e2015-05-21 21:24:32 +0000746
747 // First calculate the address of the symbol or section as it appears
748 // in the objct file
749 if (Sym != Obj.symbol_end()) {
Rafael Espindolaed067c42015-07-03 18:19:00 +0000750 ErrorOr<uint64_t> SymAddrOrErr = Sym->getAddress();
751 if (std::error_code EC = SymAddrOrErr.getError()) {
752 errs() << "error: failed to compute symbol address: "
753 << EC.message() << '\n';
754 continue;
755 }
756 SymAddr = *SymAddrOrErr;
Keno Fischerc780e8e2015-05-21 21:24:32 +0000757 // Also remember what section this symbol is in for later
Rafael Espindola8bab8892015-08-07 23:27:14 +0000758 RSec = *Sym->getSection();
Rafael Espindola63a88ce2015-06-19 17:54:28 +0000759 } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) {
760 // MachO also has relocations that point to sections and
761 // scattered relocations.
Frederic Rissf6402bf2015-07-31 20:22:50 +0000762 auto RelocInfo = MObj->getRelocation(Reloc.getRawDataRefImpl());
763 if (MObj->isRelocationScattered(RelocInfo)) {
764 // FIXME: it's not clear how to correctly handle scattered
765 // relocations.
766 continue;
767 } else {
768 RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl());
769 SymAddr = RSec->getAddress();
770 }
Rafael Espindola63a88ce2015-06-19 17:54:28 +0000771 }
Keno Fischerc780e8e2015-05-21 21:24:32 +0000772
773 // If we are given load addresses for the sections, we need to adjust:
774 // SymAddr = (Address of Symbol Or Section in File) -
775 // (Address of Section in File) +
776 // (Load Address of Section)
777 if (L != nullptr && RSec != Obj.section_end()) {
Benjamin Kramerdf005cb2015-08-08 18:27:36 +0000778 // RSec is now either the section being targeted or the section
779 // containing the symbol being targeted. In either case,
Keno Fischerc780e8e2015-05-21 21:24:32 +0000780 // we need to perform the same computation.
781 StringRef SecName;
782 RSec->getName(SecName);
Lang Hames2e88f4f2015-07-28 17:52:11 +0000783// llvm::dbgs() << "Name: '" << SecName
784// << "', RSec: " << RSec->getRawDataRefImpl()
785// << ", Section: " << Section.getRawDataRefImpl() << "\n";
786 SectionLoadAddress = L->getSectionLoadAddress(*RSec);
Keno Fischerc780e8e2015-05-21 21:24:32 +0000787 if (SectionLoadAddress != 0)
788 SymAddr += SectionLoadAddress - RSec->getAddress();
789 }
Eric Christopher7370b552012-11-12 21:40:38 +0000790
Eric Christopher47e079d2014-10-06 06:55:55 +0000791 object::RelocVisitor V(Obj);
David Majnemer5fbe3242014-10-08 06:38:50 +0000792 object::RelocToApply R(V.visit(Type, Reloc, SymAddr));
Eric Christopher7370b552012-11-12 21:40:38 +0000793 if (V.error()) {
794 SmallString<32> Name;
Rafael Espindola41bb4322015-06-30 04:08:37 +0000795 Reloc.getTypeName(Name);
Eric Christopher7370b552012-11-12 21:40:38 +0000796 errs() << "error: failed to compute relocation: "
797 << Name << "\n";
798 continue;
799 }
800
801 if (Address + R.Width > SectionSize) {
802 errs() << "error: " << R.Width << "-byte relocation starting "
803 << Address << " bytes into section " << name << " which is "
804 << SectionSize << " bytes long.\n";
805 continue;
806 }
807 if (R.Width > 8) {
808 errs() << "error: can't handle a relocation of more than 8 bytes at "
809 "a time.\n";
810 continue;
811 }
812 DEBUG(dbgs() << "Writing " << format("%p", R.Value)
813 << " at " << format("%p", Address)
814 << " with width " << format("%d", R.Width)
815 << "\n");
Eric Christopherda4b2192013-01-02 23:52:13 +0000816 Map->insert(std::make_pair(Address, std::make_pair(R.Width, R.Value)));
Eric Christopher7370b552012-11-12 21:40:38 +0000817 }
818 }
819 }
820}
821
David Blaikiea379b1812011-12-20 02:50:00 +0000822void DWARFContextInMemory::anchor() { }