Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 1 | //===- DWARFContext.cpp ---------------------------------------------------===// |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 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 | |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 10 | #include "llvm/DebugInfo/DWARF/DWARFContext.h" |
| 11 | #include "llvm/ADT/STLExtras.h" |
Alexey Samsonov | e16e16a | 2012-07-19 07:03:58 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/SmallString.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 13 | #include "llvm/ADT/SmallVector.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 14 | #include "llvm/ADT/StringRef.h" |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 15 | #include "llvm/ADT/StringSwitch.h" |
Eugene Zelenko | 2db0cfa | 2017-06-23 21:57:40 +0000 | [diff] [blame] | 16 | #include "llvm/BinaryFormat/Dwarf.h" |
Zachary Turner | 82af943 | 2015-01-30 18:07:45 +0000 | [diff] [blame] | 17 | #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 18 | #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 19 | #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h" |
Zachary Turner | 82af943 | 2015-01-30 18:07:45 +0000 | [diff] [blame] | 20 | #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h" |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 21 | #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 22 | #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h" |
| 23 | #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h" |
| 24 | #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h" |
| 25 | #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h" |
George Rimar | e71e33f | 2016-12-17 09:10:32 +0000 | [diff] [blame] | 26 | #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 27 | #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h" |
| 28 | #include "llvm/DebugInfo/DWARF/DWARFDie.h" |
| 29 | #include "llvm/DebugInfo/DWARF/DWARFFormValue.h" |
| 30 | #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h" |
| 31 | #include "llvm/DebugInfo/DWARF/DWARFSection.h" |
David Blaikie | 65a8efe | 2015-11-11 19:28:21 +0000 | [diff] [blame] | 32 | #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h" |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 33 | #include "llvm/DebugInfo/DWARF/DWARFVerifier.h" |
George Rimar | 4bf3083 | 2017-01-11 15:26:41 +0000 | [diff] [blame] | 34 | #include "llvm/Object/Decompressor.h" |
Reid Kleckner | dafc5d7 | 2016-07-06 16:56:42 +0000 | [diff] [blame] | 35 | #include "llvm/Object/MachO.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 36 | #include "llvm/Object/ObjectFile.h" |
Reid Kleckner | dafc5d7 | 2016-07-06 16:56:42 +0000 | [diff] [blame] | 37 | #include "llvm/Object/RelocVisitor.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 38 | #include "llvm/Support/Casting.h" |
| 39 | #include "llvm/Support/DataExtractor.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 40 | #include "llvm/Support/Error.h" |
Benjamin Kramer | 07d4b1c | 2011-09-15 16:57:13 +0000 | [diff] [blame] | 41 | #include "llvm/Support/Format.h" |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 42 | #include "llvm/Support/MemoryBuffer.h" |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 43 | #include "llvm/Support/raw_ostream.h" |
Benjamin Kramer | 2602ca6 | 2011-09-15 20:43:22 +0000 | [diff] [blame] | 44 | #include <algorithm> |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 45 | #include <cstdint> |
Greg Clayton | c7695a8 | 2017-05-02 20:28:33 +0000 | [diff] [blame] | 46 | #include <map> |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 47 | #include <string> |
Eugene Zelenko | 2db0cfa | 2017-06-23 21:57:40 +0000 | [diff] [blame] | 48 | #include <tuple> |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 49 | #include <utility> |
| 50 | #include <vector> |
| 51 | |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 52 | using namespace llvm; |
Benjamin Kramer | 6dda032 | 2011-09-15 18:02:20 +0000 | [diff] [blame] | 53 | using namespace dwarf; |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 54 | using namespace object; |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 55 | |
Chandler Carruth | e96dd89 | 2014-04-21 22:55:11 +0000 | [diff] [blame] | 56 | #define DEBUG_TYPE "dwarf" |
| 57 | |
Eugene Zelenko | 2db0cfa | 2017-06-23 21:57:40 +0000 | [diff] [blame] | 58 | using DWARFLineTable = DWARFDebugLine::LineTable; |
| 59 | using FileLineInfoKind = DILineInfoSpecifier::FileLineInfoKind; |
| 60 | using FunctionNameKind = DILineInfoSpecifier::FunctionNameKind; |
Eric Christopher | 494109b | 2012-10-16 23:46:25 +0000 | [diff] [blame] | 61 | |
Frederic Riss | 7c50047 | 2014-11-14 19:30:08 +0000 | [diff] [blame] | 62 | static void dumpAccelSection(raw_ostream &OS, StringRef Name, |
| 63 | const DWARFSection& Section, StringRef StringSection, |
| 64 | bool LittleEndian) { |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 65 | DWARFDataExtractor AccelSection(Section, LittleEndian, 0); |
Frederic Riss | e837ec2 | 2014-11-14 16:15:53 +0000 | [diff] [blame] | 66 | DataExtractor StrData(StringSection, LittleEndian, 0); |
| 67 | OS << "\n." << Name << " contents:\n"; |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 68 | DWARFAcceleratorTable Accel(AccelSection, StrData); |
Frederic Riss | e837ec2 | 2014-11-14 16:15:53 +0000 | [diff] [blame] | 69 | if (!Accel.extract()) |
| 70 | return; |
| 71 | Accel.dump(OS); |
| 72 | } |
| 73 | |
Wolfgang Pieb | 77d3e93 | 2017-06-06 01:22:34 +0000 | [diff] [blame] | 74 | static void |
| 75 | dumpDWARFv5StringOffsetsSection(raw_ostream &OS, StringRef SectionName, |
| 76 | const DWARFSection &StringOffsetsSection, |
| 77 | StringRef StringSection, bool LittleEndian) { |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 78 | DWARFDataExtractor StrOffsetExt(StringOffsetsSection, LittleEndian, 0); |
Wolfgang Pieb | 77d3e93 | 2017-06-06 01:22:34 +0000 | [diff] [blame] | 79 | uint32_t Offset = 0; |
| 80 | uint64_t SectionSize = StringOffsetsSection.Data.size(); |
| 81 | |
| 82 | while (Offset < SectionSize) { |
| 83 | unsigned Version = 0; |
| 84 | DwarfFormat Format = DWARF32; |
| 85 | unsigned EntrySize = 4; |
| 86 | // Perform validation and extract the segment size from the header. |
| 87 | if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, 4)) { |
| 88 | OS << "error: invalid contribution to string offsets table in section ." |
| 89 | << SectionName << ".\n"; |
| 90 | return; |
| 91 | } |
| 92 | uint32_t ContributionStart = Offset; |
| 93 | uint64_t ContributionSize = StrOffsetExt.getU32(&Offset); |
| 94 | // A contribution size of 0xffffffff indicates DWARF64, with the actual size |
| 95 | // in the following 8 bytes. Otherwise, the DWARF standard mandates that |
| 96 | // the contribution size must be at most 0xfffffff0. |
| 97 | if (ContributionSize == 0xffffffff) { |
| 98 | if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, 8)) { |
| 99 | OS << "error: invalid contribution to string offsets table in section ." |
| 100 | << SectionName << ".\n"; |
| 101 | return; |
| 102 | } |
| 103 | Format = DWARF64; |
| 104 | EntrySize = 8; |
| 105 | ContributionSize = StrOffsetExt.getU64(&Offset); |
| 106 | } else if (ContributionSize > 0xfffffff0) { |
| 107 | OS << "error: invalid contribution to string offsets table in section ." |
| 108 | << SectionName << ".\n"; |
| 109 | return; |
| 110 | } |
| 111 | |
| 112 | // We must ensure that we don't read a partial record at the end, so we |
| 113 | // validate for a multiple of EntrySize. Also, we're expecting a version |
| 114 | // number and padding, which adds an additional 4 bytes. |
| 115 | uint64_t ValidationSize = |
| 116 | 4 + ((ContributionSize + EntrySize - 1) & (-(uint64_t)EntrySize)); |
| 117 | if (!StrOffsetExt.isValidOffsetForDataOfSize(Offset, ValidationSize)) { |
| 118 | OS << "error: contribution to string offsets table in section ." |
| 119 | << SectionName << " has invalid length.\n"; |
| 120 | return; |
| 121 | } |
| 122 | |
| 123 | Version = StrOffsetExt.getU16(&Offset); |
| 124 | Offset += 2; |
| 125 | OS << format("0x%8.8x: ", ContributionStart); |
| 126 | OS << "Contribution size = " << ContributionSize |
| 127 | << ", Version = " << Version << "\n"; |
| 128 | |
| 129 | uint32_t ContributionBase = Offset; |
| 130 | DataExtractor StrData(StringSection, LittleEndian, 0); |
| 131 | while (Offset - ContributionBase < ContributionSize) { |
| 132 | OS << format("0x%8.8x: ", Offset); |
| 133 | // FIXME: We can only extract strings in DWARF32 format at the moment. |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 134 | uint64_t StringOffset = |
| 135 | StrOffsetExt.getRelocatedValue(EntrySize, &Offset); |
Wolfgang Pieb | 77d3e93 | 2017-06-06 01:22:34 +0000 | [diff] [blame] | 136 | if (Format == DWARF32) { |
| 137 | OS << format("%8.8x ", StringOffset); |
| 138 | uint32_t StringOffset32 = (uint32_t)StringOffset; |
| 139 | const char *S = StrData.getCStr(&StringOffset32); |
| 140 | if (S) |
| 141 | OS << format("\"%s\"", S); |
| 142 | } else |
| 143 | OS << format("%16.16x ", StringOffset); |
| 144 | OS << "\n"; |
| 145 | } |
| 146 | } |
| 147 | } |
| 148 | |
| 149 | // Dump a DWARF string offsets section. This may be a DWARF v5 formatted |
| 150 | // string offsets section, where each compile or type unit contributes a |
| 151 | // number of entries (string offsets), with each contribution preceded by |
| 152 | // a header containing size and version number. Alternatively, it may be a |
| 153 | // monolithic series of string offsets, as generated by the pre-DWARF v5 |
| 154 | // implementation of split DWARF. |
| 155 | static void dumpStringOffsetsSection(raw_ostream &OS, StringRef SectionName, |
| 156 | const DWARFSection &StringOffsetsSection, |
| 157 | StringRef StringSection, bool LittleEndian, |
| 158 | unsigned MaxVersion) { |
| 159 | if (StringOffsetsSection.Data.empty()) |
| 160 | return; |
| 161 | OS << "\n." << SectionName << " contents:\n"; |
| 162 | // If we have at least one (compile or type) unit with DWARF v5 or greater, |
| 163 | // we assume that the section is formatted like a DWARF v5 string offsets |
| 164 | // section. |
| 165 | if (MaxVersion >= 5) |
| 166 | dumpDWARFv5StringOffsetsSection(OS, SectionName, StringOffsetsSection, |
| 167 | StringSection, LittleEndian); |
| 168 | else { |
| 169 | DataExtractor strOffsetExt(StringOffsetsSection.Data, LittleEndian, 0); |
| 170 | uint32_t offset = 0; |
| 171 | uint64_t size = StringOffsetsSection.Data.size(); |
| 172 | // Ensure that size is a multiple of the size of an entry. |
| 173 | if (size & ((uint64_t)(sizeof(uint32_t) - 1))) { |
| 174 | OS << "error: size of ." << SectionName << " is not a multiple of " |
| 175 | << sizeof(uint32_t) << ".\n"; |
| 176 | size &= -(uint64_t)sizeof(uint32_t); |
| 177 | } |
| 178 | DataExtractor StrData(StringSection, LittleEndian, 0); |
| 179 | while (offset < size) { |
| 180 | OS << format("0x%8.8x: ", offset); |
| 181 | uint32_t StringOffset = strOffsetExt.getU32(&offset); |
| 182 | OS << format("%8.8x ", StringOffset); |
| 183 | const char *S = StrData.getCStr(&StringOffset); |
| 184 | if (S) |
| 185 | OS << format("\"%s\"", S); |
| 186 | OS << "\n"; |
| 187 | } |
| 188 | } |
| 189 | } |
| 190 | |
Eugene Zelenko | 2db0cfa | 2017-06-23 21:57:40 +0000 | [diff] [blame] | 191 | void DWARFContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts) { |
Adrian Prantl | f4bc1f7 | 2017-06-01 18:18:23 +0000 | [diff] [blame] | 192 | DIDumpType DumpType = DumpOpts.DumpType; |
| 193 | bool DumpEH = DumpOpts.DumpEH; |
| 194 | bool SummarizeTypes = DumpOpts.SummarizeTypes; |
| 195 | |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 196 | if (DumpType == DIDT_All || DumpType == DIDT_Abbrev) { |
| 197 | OS << ".debug_abbrev contents:\n"; |
| 198 | getDebugAbbrev()->dump(OS); |
| 199 | } |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 200 | |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 201 | if (DumpType == DIDT_All || DumpType == DIDT_AbbrevDwo) |
| 202 | if (const DWARFDebugAbbrev *D = getDebugAbbrevDWO()) { |
David Blaikie | 622dce4 | 2014-01-08 23:29:59 +0000 | [diff] [blame] | 203 | OS << "\n.debug_abbrev.dwo contents:\n"; |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 204 | D->dump(OS); |
David Blaikie | 622dce4 | 2014-01-08 23:29:59 +0000 | [diff] [blame] | 205 | } |
David Blaikie | 622dce4 | 2014-01-08 23:29:59 +0000 | [diff] [blame] | 206 | |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 207 | if (DumpType == DIDT_All || DumpType == DIDT_Info) { |
| 208 | OS << "\n.debug_info contents:\n"; |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 209 | for (const auto &CU : compile_units()) |
Adrian Prantl | 318d119 | 2017-06-06 23:28:45 +0000 | [diff] [blame] | 210 | CU->dump(OS, DumpOpts); |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 211 | } |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 212 | |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 213 | if ((DumpType == DIDT_All || DumpType == DIDT_InfoDwo) && |
| 214 | getNumDWOCompileUnits()) { |
| 215 | OS << "\n.debug_info.dwo contents:\n"; |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 216 | for (const auto &DWOCU : dwo_compile_units()) |
Adrian Prantl | 318d119 | 2017-06-06 23:28:45 +0000 | [diff] [blame] | 217 | DWOCU->dump(OS, DumpOpts); |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 218 | } |
David Blaikie | 622dce4 | 2014-01-08 23:29:59 +0000 | [diff] [blame] | 219 | |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 220 | if ((DumpType == DIDT_All || DumpType == DIDT_Types) && getNumTypeUnits()) { |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 221 | OS << "\n.debug_types contents:\n"; |
Frederic Riss | 312a02e | 2014-09-29 13:56:39 +0000 | [diff] [blame] | 222 | for (const auto &TUS : type_unit_sections()) |
| 223 | for (const auto &TU : TUS) |
David Blaikie | 50cc27e | 2016-10-18 21:09:48 +0000 | [diff] [blame] | 224 | TU->dump(OS, SummarizeTypes); |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 225 | } |
| 226 | |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 227 | if ((DumpType == DIDT_All || DumpType == DIDT_TypesDwo) && |
| 228 | getNumDWOTypeUnits()) { |
| 229 | OS << "\n.debug_types.dwo contents:\n"; |
Frederic Riss | 312a02e | 2014-09-29 13:56:39 +0000 | [diff] [blame] | 230 | for (const auto &DWOTUS : dwo_type_unit_sections()) |
| 231 | for (const auto &DWOTU : DWOTUS) |
David Blaikie | 50cc27e | 2016-10-18 21:09:48 +0000 | [diff] [blame] | 232 | DWOTU->dump(OS, SummarizeTypes); |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 233 | } |
David Blaikie | 92d9d62 | 2014-01-09 05:08:24 +0000 | [diff] [blame] | 234 | |
David Blaikie | 18e7350 | 2013-06-19 21:37:13 +0000 | [diff] [blame] | 235 | if (DumpType == DIDT_All || DumpType == DIDT_Loc) { |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 236 | OS << "\n.debug_loc contents:\n"; |
David Blaikie | 18e7350 | 2013-06-19 21:37:13 +0000 | [diff] [blame] | 237 | getDebugLoc()->dump(OS); |
| 238 | } |
| 239 | |
David Blaikie | 9c550ac | 2014-03-25 01:44:02 +0000 | [diff] [blame] | 240 | if (DumpType == DIDT_All || DumpType == DIDT_LocDwo) { |
| 241 | OS << "\n.debug_loc.dwo contents:\n"; |
| 242 | getDebugLocDWO()->dump(OS); |
| 243 | } |
| 244 | |
Eli Bendersky | fd08bc1 | 2013-02-05 23:30:58 +0000 | [diff] [blame] | 245 | if (DumpType == DIDT_All || DumpType == DIDT_Frames) { |
| 246 | OS << "\n.debug_frame contents:\n"; |
| 247 | getDebugFrame()->dump(OS); |
Igor Laevsky | 03a670c | 2016-01-26 15:09:42 +0000 | [diff] [blame] | 248 | if (DumpEH) { |
| 249 | OS << "\n.eh_frame contents:\n"; |
| 250 | getEHFrame()->dump(OS); |
| 251 | } |
Eli Bendersky | fd08bc1 | 2013-02-05 23:30:58 +0000 | [diff] [blame] | 252 | } |
| 253 | |
Amjad Aboud | e59cc3e | 2015-11-12 09:38:54 +0000 | [diff] [blame] | 254 | if (DumpType == DIDT_All || DumpType == DIDT_Macro) { |
| 255 | OS << "\n.debug_macinfo contents:\n"; |
| 256 | getDebugMacro()->dump(OS); |
| 257 | } |
| 258 | |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 259 | uint32_t offset = 0; |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 260 | if (DumpType == DIDT_All || DumpType == DIDT_Aranges) { |
| 261 | OS << "\n.debug_aranges contents:\n"; |
| 262 | DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0); |
| 263 | DWARFDebugArangeSet set; |
| 264 | while (set.extract(arangesData, &offset)) |
| 265 | set.dump(OS); |
| 266 | } |
Benjamin Kramer | 5acab50 | 2011-09-15 02:12:05 +0000 | [diff] [blame] | 267 | |
Alexey Samsonov | 034e57a | 2012-08-27 07:17:47 +0000 | [diff] [blame] | 268 | uint8_t savedAddressByteSize = 0; |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 269 | if (DumpType == DIDT_All || DumpType == DIDT_Line) { |
| 270 | OS << "\n.debug_line contents:\n"; |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 271 | for (const auto &CU : compile_units()) { |
| 272 | savedAddressByteSize = CU->getAddressByteSize(); |
Greg Clayton | c8c1032 | 2016-12-13 18:25:19 +0000 | [diff] [blame] | 273 | auto CUDIE = CU->getUnitDIE(); |
| 274 | if (!CUDIE) |
Alexey Samsonov | 7a18c06 | 2015-05-19 21:54:32 +0000 | [diff] [blame] | 275 | continue; |
Greg Clayton | 97d2218 | 2017-01-13 21:08:18 +0000 | [diff] [blame] | 276 | if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list))) { |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 277 | DWARFDataExtractor lineData(getLineSection(), isLittleEndian(), |
| 278 | savedAddressByteSize); |
Alexey Samsonov | 110d595 | 2014-04-30 00:09:19 +0000 | [diff] [blame] | 279 | DWARFDebugLine::LineTable LineTable; |
Greg Clayton | 52fe1f6 | 2016-12-14 22:38:08 +0000 | [diff] [blame] | 280 | uint32_t Offset = *StmtOffset; |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 281 | LineTable.parse(lineData, &Offset); |
Alexey Samsonov | 110d595 | 2014-04-30 00:09:19 +0000 | [diff] [blame] | 282 | LineTable.dump(OS); |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 283 | } |
Benjamin Kramer | 6dda032 | 2011-09-15 18:02:20 +0000 | [diff] [blame] | 284 | } |
| 285 | } |
Benjamin Kramer | 07d4b1c | 2011-09-15 16:57:13 +0000 | [diff] [blame] | 286 | |
David Blaikie | 65a8efe | 2015-11-11 19:28:21 +0000 | [diff] [blame] | 287 | if (DumpType == DIDT_All || DumpType == DIDT_CUIndex) { |
| 288 | OS << "\n.debug_cu_index contents:\n"; |
David Blaikie | b073cb9 | 2015-12-02 06:21:34 +0000 | [diff] [blame] | 289 | getCUIndex().dump(OS); |
David Blaikie | 65a8efe | 2015-11-11 19:28:21 +0000 | [diff] [blame] | 290 | } |
| 291 | |
David Blaikie | 51c4028 | 2015-11-11 19:40:49 +0000 | [diff] [blame] | 292 | if (DumpType == DIDT_All || DumpType == DIDT_TUIndex) { |
| 293 | OS << "\n.debug_tu_index contents:\n"; |
David Blaikie | b073cb9 | 2015-12-02 06:21:34 +0000 | [diff] [blame] | 294 | getTUIndex().dump(OS); |
David Blaikie | 51c4028 | 2015-11-11 19:40:49 +0000 | [diff] [blame] | 295 | } |
| 296 | |
David Blaikie | 1d4736e | 2014-02-24 23:58:54 +0000 | [diff] [blame] | 297 | if (DumpType == DIDT_All || DumpType == DIDT_LineDwo) { |
| 298 | OS << "\n.debug_line.dwo contents:\n"; |
| 299 | unsigned stmtOffset = 0; |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 300 | DWARFDataExtractor lineData(getLineDWOSection(), isLittleEndian(), |
| 301 | savedAddressByteSize); |
Alexey Samsonov | 110d595 | 2014-04-30 00:09:19 +0000 | [diff] [blame] | 302 | DWARFDebugLine::LineTable LineTable; |
| 303 | while (LineTable.Prologue.parse(lineData, &stmtOffset)) { |
| 304 | LineTable.dump(OS); |
| 305 | LineTable.clear(); |
| 306 | } |
David Blaikie | 1d4736e | 2014-02-24 23:58:54 +0000 | [diff] [blame] | 307 | } |
| 308 | |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 309 | if (DumpType == DIDT_All || DumpType == DIDT_Str) { |
| 310 | OS << "\n.debug_str contents:\n"; |
| 311 | DataExtractor strData(getStringSection(), isLittleEndian(), 0); |
| 312 | offset = 0; |
| 313 | uint32_t strOffset = 0; |
| 314 | while (const char *s = strData.getCStr(&offset)) { |
| 315 | OS << format("0x%8.8x: \"%s\"\n", strOffset, s); |
| 316 | strOffset = offset; |
| 317 | } |
Benjamin Kramer | 07d4b1c | 2011-09-15 16:57:13 +0000 | [diff] [blame] | 318 | } |
Alexey Samsonov | 034e57a | 2012-08-27 07:17:47 +0000 | [diff] [blame] | 319 | |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 320 | if ((DumpType == DIDT_All || DumpType == DIDT_StrDwo) && |
| 321 | !getStringDWOSection().empty()) { |
| 322 | OS << "\n.debug_str.dwo contents:\n"; |
| 323 | DataExtractor strDWOData(getStringDWOSection(), isLittleEndian(), 0); |
| 324 | offset = 0; |
| 325 | uint32_t strDWOOffset = 0; |
| 326 | while (const char *s = strDWOData.getCStr(&offset)) { |
| 327 | OS << format("0x%8.8x: \"%s\"\n", strDWOOffset, s); |
| 328 | strDWOOffset = offset; |
David Blaikie | 622dce4 | 2014-01-08 23:29:59 +0000 | [diff] [blame] | 329 | } |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 330 | } |
David Blaikie | 622dce4 | 2014-01-08 23:29:59 +0000 | [diff] [blame] | 331 | |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 332 | if (DumpType == DIDT_All || DumpType == DIDT_Ranges) { |
| 333 | OS << "\n.debug_ranges contents:\n"; |
| 334 | // In fact, different compile units may have different address byte |
| 335 | // sizes, but for simplicity we just use the address byte size of the last |
| 336 | // compile unit (there is no easy and fast way to associate address range |
| 337 | // list and the compile unit it describes). |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 338 | DWARFDataExtractor rangesData(getRangeSection(), isLittleEndian(), |
| 339 | savedAddressByteSize); |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 340 | offset = 0; |
| 341 | DWARFDebugRangeList rangeList; |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 342 | while (rangeList.extract(rangesData, &offset)) |
Eli Bendersky | 7a94daa | 2013-01-25 20:26:43 +0000 | [diff] [blame] | 343 | rangeList.dump(OS); |
Eric Christopher | da4b219 | 2013-01-02 23:52:13 +0000 | [diff] [blame] | 344 | } |
Eric Christopher | 962c908 | 2013-01-15 23:56:56 +0000 | [diff] [blame] | 345 | |
Eric Christopher | 0de5359 | 2013-09-25 23:02:36 +0000 | [diff] [blame] | 346 | if (DumpType == DIDT_All || DumpType == DIDT_Pubnames) |
George Rimar | e71e33f | 2016-12-17 09:10:32 +0000 | [diff] [blame] | 347 | DWARFDebugPubTable(getPubNamesSection(), isLittleEndian(), false) |
| 348 | .dump("debug_pubnames", OS); |
Krzysztof Parzyszek | 97438dc | 2013-02-12 16:20:28 +0000 | [diff] [blame] | 349 | |
Eric Christopher | 4c7e6ba | 2013-09-25 23:02:41 +0000 | [diff] [blame] | 350 | if (DumpType == DIDT_All || DumpType == DIDT_Pubtypes) |
George Rimar | e71e33f | 2016-12-17 09:10:32 +0000 | [diff] [blame] | 351 | DWARFDebugPubTable(getPubTypesSection(), isLittleEndian(), false) |
| 352 | .dump("debug_pubtypes", OS); |
Eric Christopher | 4c7e6ba | 2013-09-25 23:02:41 +0000 | [diff] [blame] | 353 | |
David Blaikie | ecd21ff | 2013-09-24 19:50:00 +0000 | [diff] [blame] | 354 | if (DumpType == DIDT_All || DumpType == DIDT_GnuPubnames) |
George Rimar | e71e33f | 2016-12-17 09:10:32 +0000 | [diff] [blame] | 355 | DWARFDebugPubTable(getGnuPubNamesSection(), isLittleEndian(), |
| 356 | true /* GnuStyle */) |
| 357 | .dump("debug_gnu_pubnames", OS); |
David Blaikie | ecd21ff | 2013-09-24 19:50:00 +0000 | [diff] [blame] | 358 | |
| 359 | if (DumpType == DIDT_All || DumpType == DIDT_GnuPubtypes) |
George Rimar | e71e33f | 2016-12-17 09:10:32 +0000 | [diff] [blame] | 360 | DWARFDebugPubTable(getGnuPubTypesSection(), isLittleEndian(), |
| 361 | true /* GnuStyle */) |
| 362 | .dump("debug_gnu_pubtypes", OS); |
David Blaikie | 404d304 | 2013-09-19 23:01:29 +0000 | [diff] [blame] | 363 | |
Wolfgang Pieb | 77d3e93 | 2017-06-06 01:22:34 +0000 | [diff] [blame] | 364 | if (DumpType == DIDT_All || DumpType == DIDT_StrOffsets) |
| 365 | dumpStringOffsetsSection(OS, "debug_str_offsets", getStringOffsetSection(), |
| 366 | getStringSection(), isLittleEndian(), |
| 367 | getMaxVersion()); |
| 368 | |
| 369 | if (DumpType == DIDT_All || DumpType == DIDT_StrOffsetsDwo) { |
| 370 | dumpStringOffsetsSection(OS, "debug_str_offsets.dwo", |
| 371 | getStringOffsetDWOSection(), getStringDWOSection(), |
| 372 | isLittleEndian(), getMaxVersion()); |
David Blaikie | 66865d6 | 2014-01-09 00:13:35 +0000 | [diff] [blame] | 373 | } |
Frederic Riss | e837ec2 | 2014-11-14 16:15:53 +0000 | [diff] [blame] | 374 | |
George Rimar | 4f82df5 | 2016-09-23 11:01:53 +0000 | [diff] [blame] | 375 | if ((DumpType == DIDT_All || DumpType == DIDT_GdbIndex) && |
| 376 | !getGdbIndexSection().empty()) { |
| 377 | OS << "\n.gnu_index contents:\n"; |
| 378 | getGdbIndex().dump(OS); |
| 379 | } |
| 380 | |
Frederic Riss | e837ec2 | 2014-11-14 16:15:53 +0000 | [diff] [blame] | 381 | if (DumpType == DIDT_All || DumpType == DIDT_AppleNames) |
| 382 | dumpAccelSection(OS, "apple_names", getAppleNamesSection(), |
| 383 | getStringSection(), isLittleEndian()); |
| 384 | |
| 385 | if (DumpType == DIDT_All || DumpType == DIDT_AppleTypes) |
| 386 | dumpAccelSection(OS, "apple_types", getAppleTypesSection(), |
| 387 | getStringSection(), isLittleEndian()); |
| 388 | |
| 389 | if (DumpType == DIDT_All || DumpType == DIDT_AppleNamespaces) |
| 390 | dumpAccelSection(OS, "apple_namespaces", getAppleNamespacesSection(), |
| 391 | getStringSection(), isLittleEndian()); |
| 392 | |
| 393 | if (DumpType == DIDT_All || DumpType == DIDT_AppleObjC) |
| 394 | dumpAccelSection(OS, "apple_objc", getAppleObjCSection(), |
| 395 | getStringSection(), isLittleEndian()); |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 396 | } |
| 397 | |
David Blaikie | 15d85fc | 2017-05-23 06:48:53 +0000 | [diff] [blame] | 398 | DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) { |
| 399 | // FIXME: Improve this for the case where this DWO file is really a DWP file |
| 400 | // with an index - use the index for lookup instead of a linear search. |
| 401 | for (const auto &DWOCU : dwo_compile_units()) |
| 402 | if (DWOCU->getDWOId() == Hash) |
| 403 | return DWOCU.get(); |
| 404 | return nullptr; |
| 405 | } |
| 406 | |
Greg Clayton | c7695a8 | 2017-05-02 20:28:33 +0000 | [diff] [blame] | 407 | DWARFDie DWARFContext::getDIEForOffset(uint32_t Offset) { |
| 408 | parseCompileUnits(); |
| 409 | if (auto *CU = CUs.getUnitForOffset(Offset)) |
| 410 | return CU->getDIEForOffset(Offset); |
| 411 | return DWARFDie(); |
| 412 | } |
| 413 | |
Greg Clayton | c7695a8 | 2017-05-02 20:28:33 +0000 | [diff] [blame] | 414 | bool DWARFContext::verify(raw_ostream &OS, DIDumpType DumpType) { |
| 415 | bool Success = true; |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 416 | DWARFVerifier verifier(OS, *this); |
Greg Clayton | c7695a8 | 2017-05-02 20:28:33 +0000 | [diff] [blame] | 417 | if (DumpType == DIDT_All || DumpType == DIDT_Info) { |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 418 | if (!verifier.handleDebugInfo()) |
Greg Clayton | c7695a8 | 2017-05-02 20:28:33 +0000 | [diff] [blame] | 419 | Success = false; |
Greg Clayton | 48432cf | 2017-05-01 22:07:02 +0000 | [diff] [blame] | 420 | } |
Greg Clayton | 6707046 | 2017-05-02 22:48:52 +0000 | [diff] [blame] | 421 | if (DumpType == DIDT_All || DumpType == DIDT_Line) { |
Greg Clayton | b8c162b | 2017-05-03 16:02:29 +0000 | [diff] [blame] | 422 | if (!verifier.handleDebugLine()) |
Greg Clayton | 6707046 | 2017-05-02 22:48:52 +0000 | [diff] [blame] | 423 | Success = false; |
| 424 | } |
Spyridoula Gravani | e41823b | 2017-06-14 00:17:55 +0000 | [diff] [blame] | 425 | if (DumpType == DIDT_All || DumpType == DIDT_AppleNames) { |
| 426 | if (!verifier.handleAppleNames()) |
| 427 | Success = false; |
| 428 | } |
Greg Clayton | 48432cf | 2017-05-01 22:07:02 +0000 | [diff] [blame] | 429 | return Success; |
| 430 | } |
Spyridoula Gravani | e41823b | 2017-06-14 00:17:55 +0000 | [diff] [blame] | 431 | |
David Blaikie | 82641be | 2015-11-17 00:39:55 +0000 | [diff] [blame] | 432 | const DWARFUnitIndex &DWARFContext::getCUIndex() { |
| 433 | if (CUIndex) |
| 434 | return *CUIndex; |
| 435 | |
| 436 | DataExtractor CUIndexData(getCUIndexSection(), isLittleEndian(), 0); |
| 437 | |
David Blaikie | b073cb9 | 2015-12-02 06:21:34 +0000 | [diff] [blame] | 438 | CUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_INFO); |
David Blaikie | 82641be | 2015-11-17 00:39:55 +0000 | [diff] [blame] | 439 | CUIndex->parse(CUIndexData); |
| 440 | return *CUIndex; |
| 441 | } |
| 442 | |
| 443 | const DWARFUnitIndex &DWARFContext::getTUIndex() { |
| 444 | if (TUIndex) |
| 445 | return *TUIndex; |
| 446 | |
| 447 | DataExtractor TUIndexData(getTUIndexSection(), isLittleEndian(), 0); |
| 448 | |
David Blaikie | b073cb9 | 2015-12-02 06:21:34 +0000 | [diff] [blame] | 449 | TUIndex = llvm::make_unique<DWARFUnitIndex>(DW_SECT_TYPES); |
David Blaikie | 82641be | 2015-11-17 00:39:55 +0000 | [diff] [blame] | 450 | TUIndex->parse(TUIndexData); |
| 451 | return *TUIndex; |
| 452 | } |
| 453 | |
George Rimar | 4f82df5 | 2016-09-23 11:01:53 +0000 | [diff] [blame] | 454 | DWARFGdbIndex &DWARFContext::getGdbIndex() { |
| 455 | if (GdbIndex) |
| 456 | return *GdbIndex; |
| 457 | |
| 458 | DataExtractor GdbIndexData(getGdbIndexSection(), true /*LE*/, 0); |
| 459 | GdbIndex = llvm::make_unique<DWARFGdbIndex>(); |
| 460 | GdbIndex->parse(GdbIndexData); |
| 461 | return *GdbIndex; |
| 462 | } |
| 463 | |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 464 | const DWARFDebugAbbrev *DWARFContext::getDebugAbbrev() { |
| 465 | if (Abbrev) |
| 466 | return Abbrev.get(); |
| 467 | |
| 468 | DataExtractor abbrData(getAbbrevSection(), isLittleEndian(), 0); |
| 469 | |
| 470 | Abbrev.reset(new DWARFDebugAbbrev()); |
Alexey Samsonov | 4316df5 | 2014-04-25 21:10:56 +0000 | [diff] [blame] | 471 | Abbrev->extract(abbrData); |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 472 | return Abbrev.get(); |
| 473 | } |
| 474 | |
Eric Christopher | da4b219 | 2013-01-02 23:52:13 +0000 | [diff] [blame] | 475 | const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() { |
| 476 | if (AbbrevDWO) |
| 477 | return AbbrevDWO.get(); |
| 478 | |
| 479 | DataExtractor abbrData(getAbbrevDWOSection(), isLittleEndian(), 0); |
| 480 | AbbrevDWO.reset(new DWARFDebugAbbrev()); |
Alexey Samsonov | 4316df5 | 2014-04-25 21:10:56 +0000 | [diff] [blame] | 481 | AbbrevDWO->extract(abbrData); |
Eric Christopher | da4b219 | 2013-01-02 23:52:13 +0000 | [diff] [blame] | 482 | return AbbrevDWO.get(); |
| 483 | } |
| 484 | |
David Blaikie | 18e7350 | 2013-06-19 21:37:13 +0000 | [diff] [blame] | 485 | const DWARFDebugLoc *DWARFContext::getDebugLoc() { |
| 486 | if (Loc) |
| 487 | return Loc.get(); |
| 488 | |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 489 | Loc.reset(new DWARFDebugLoc); |
David Blaikie | 18e7350 | 2013-06-19 21:37:13 +0000 | [diff] [blame] | 490 | // assume all compile units have the same address byte size |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 491 | if (getNumCompileUnits()) { |
| 492 | DWARFDataExtractor LocData(getLocSection(), isLittleEndian(), |
| 493 | getCompileUnitAtIndex(0)->getAddressByteSize()); |
| 494 | Loc->parse(LocData); |
| 495 | } |
David Blaikie | 18e7350 | 2013-06-19 21:37:13 +0000 | [diff] [blame] | 496 | return Loc.get(); |
| 497 | } |
| 498 | |
David Blaikie | 9c550ac | 2014-03-25 01:44:02 +0000 | [diff] [blame] | 499 | const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() { |
| 500 | if (LocDWO) |
| 501 | return LocDWO.get(); |
| 502 | |
| 503 | DataExtractor LocData(getLocDWOSection().Data, isLittleEndian(), 0); |
| 504 | LocDWO.reset(new DWARFDebugLocDWO()); |
| 505 | LocDWO->parse(LocData); |
| 506 | return LocDWO.get(); |
| 507 | } |
| 508 | |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 509 | const DWARFDebugAranges *DWARFContext::getDebugAranges() { |
| 510 | if (Aranges) |
| 511 | return Aranges.get(); |
| 512 | |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 513 | Aranges.reset(new DWARFDebugAranges()); |
Alexey Samsonov | a1694c1 | 2012-11-16 08:36:25 +0000 | [diff] [blame] | 514 | Aranges->generate(this); |
Benjamin Kramer | a6002fd | 2011-09-14 01:09:52 +0000 | [diff] [blame] | 515 | return Aranges.get(); |
| 516 | } |
| 517 | |
Eli Bendersky | fd08bc1 | 2013-02-05 23:30:58 +0000 | [diff] [blame] | 518 | const DWARFDebugFrame *DWARFContext::getDebugFrame() { |
| 519 | if (DebugFrame) |
| 520 | return DebugFrame.get(); |
| 521 | |
| 522 | // There's a "bug" in the DWARFv3 standard with respect to the target address |
| 523 | // size within debug frame sections. While DWARF is supposed to be independent |
| 524 | // of its container, FDEs have fields with size being "target address size", |
| 525 | // which isn't specified in DWARF in general. It's only specified for CUs, but |
| 526 | // .eh_frame can appear without a .debug_info section. Follow the example of |
| 527 | // other tools (libdwarf) and extract this from the container (ObjectFile |
| 528 | // provides this information). This problem is fixed in DWARFv4 |
| 529 | // See this dwarf-discuss discussion for more details: |
| 530 | // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html |
| 531 | DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(), |
| 532 | getAddressSize()); |
Igor Laevsky | 03a670c | 2016-01-26 15:09:42 +0000 | [diff] [blame] | 533 | DebugFrame.reset(new DWARFDebugFrame(false /* IsEH */)); |
| 534 | DebugFrame->parse(debugFrameData); |
| 535 | return DebugFrame.get(); |
| 536 | } |
| 537 | |
| 538 | const DWARFDebugFrame *DWARFContext::getEHFrame() { |
| 539 | if (EHFrame) |
| 540 | return EHFrame.get(); |
| 541 | |
| 542 | DataExtractor debugFrameData(getEHFrameSection(), isLittleEndian(), |
| 543 | getAddressSize()); |
| 544 | DebugFrame.reset(new DWARFDebugFrame(true /* IsEH */)); |
Eli Bendersky | fd08bc1 | 2013-02-05 23:30:58 +0000 | [diff] [blame] | 545 | DebugFrame->parse(debugFrameData); |
| 546 | return DebugFrame.get(); |
| 547 | } |
| 548 | |
Amjad Aboud | e59cc3e | 2015-11-12 09:38:54 +0000 | [diff] [blame] | 549 | const DWARFDebugMacro *DWARFContext::getDebugMacro() { |
| 550 | if (Macro) |
| 551 | return Macro.get(); |
| 552 | |
| 553 | DataExtractor MacinfoData(getMacinfoSection(), isLittleEndian(), 0); |
| 554 | Macro.reset(new DWARFDebugMacro()); |
| 555 | Macro->parse(MacinfoData); |
| 556 | return Macro.get(); |
| 557 | } |
| 558 | |
Eric Christopher | 494109b | 2012-10-16 23:46:25 +0000 | [diff] [blame] | 559 | const DWARFLineTable * |
Alexey Samsonov | 7a18c06 | 2015-05-19 21:54:32 +0000 | [diff] [blame] | 560 | DWARFContext::getLineTableForUnit(DWARFUnit *U) { |
Benjamin Kramer | 679e175 | 2011-09-15 20:43:18 +0000 | [diff] [blame] | 561 | if (!Line) |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 562 | Line.reset(new DWARFDebugLine); |
David Blaikie | c4e2bed | 2015-11-17 21:08:05 +0000 | [diff] [blame] | 563 | |
Greg Clayton | c8c1032 | 2016-12-13 18:25:19 +0000 | [diff] [blame] | 564 | auto UnitDIE = U->getUnitDIE(); |
| 565 | if (!UnitDIE) |
Alexey Samsonov | 7a18c06 | 2015-05-19 21:54:32 +0000 | [diff] [blame] | 566 | return nullptr; |
David Blaikie | c4e2bed | 2015-11-17 21:08:05 +0000 | [diff] [blame] | 567 | |
Greg Clayton | 97d2218 | 2017-01-13 21:08:18 +0000 | [diff] [blame] | 568 | auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list)); |
Greg Clayton | 52fe1f6 | 2016-12-14 22:38:08 +0000 | [diff] [blame] | 569 | if (!Offset) |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 570 | return nullptr; // No line table for this compile unit. |
Benjamin Kramer | 5acab50 | 2011-09-15 02:12:05 +0000 | [diff] [blame] | 571 | |
Greg Clayton | 52fe1f6 | 2016-12-14 22:38:08 +0000 | [diff] [blame] | 572 | uint32_t stmtOffset = *Offset + U->getLineTableOffset(); |
Benjamin Kramer | 679e175 | 2011-09-15 20:43:18 +0000 | [diff] [blame] | 573 | // See if the line table is cached. |
Eric Christopher | 494109b | 2012-10-16 23:46:25 +0000 | [diff] [blame] | 574 | if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset)) |
Benjamin Kramer | 679e175 | 2011-09-15 20:43:18 +0000 | [diff] [blame] | 575 | return lt; |
| 576 | |
Greg Clayton | 48ff66a | 2017-05-04 18:29:44 +0000 | [diff] [blame] | 577 | // Make sure the offset is good before we try to parse. |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 578 | if (stmtOffset >= U->getLineSection().Data.size()) |
Greg Clayton | 48ff66a | 2017-05-04 18:29:44 +0000 | [diff] [blame] | 579 | return nullptr; |
| 580 | |
Benjamin Kramer | 679e175 | 2011-09-15 20:43:18 +0000 | [diff] [blame] | 581 | // We have to parse it first. |
Paul Robinson | 17536b9 | 2017-06-29 16:52:08 +0000 | [diff] [blame] | 582 | DWARFDataExtractor lineData(U->getLineSection(), isLittleEndian(), |
| 583 | U->getAddressByteSize()); |
Benjamin Kramer | 679e175 | 2011-09-15 20:43:18 +0000 | [diff] [blame] | 584 | return Line->getOrParseLineTable(lineData, stmtOffset); |
Benjamin Kramer | 5acab50 | 2011-09-15 02:12:05 +0000 | [diff] [blame] | 585 | } |
| 586 | |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 587 | void DWARFContext::parseCompileUnits() { |
Alexey Samsonov | 8cd4c9d | 2014-10-08 00:07:53 +0000 | [diff] [blame] | 588 | CUs.parse(*this, getInfoSection()); |
Benjamin Kramer | aa2f78f | 2011-09-13 19:42:23 +0000 | [diff] [blame] | 589 | } |
Benjamin Kramer | 2602ca6 | 2011-09-15 20:43:22 +0000 | [diff] [blame] | 590 | |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 591 | void DWARFContext::parseTypeUnits() { |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 592 | if (!TUs.empty()) |
| 593 | return; |
| 594 | for (const auto &I : getTypesSections()) { |
Benjamin Kramer | f5e2fc4 | 2015-05-29 19:43:39 +0000 | [diff] [blame] | 595 | TUs.emplace_back(); |
Alexey Samsonov | 8cd4c9d | 2014-10-08 00:07:53 +0000 | [diff] [blame] | 596 | TUs.back().parse(*this, I.second); |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 597 | } |
| 598 | } |
| 599 | |
Eric Christopher | da4b219 | 2013-01-02 23:52:13 +0000 | [diff] [blame] | 600 | void DWARFContext::parseDWOCompileUnits() { |
Alexey Samsonov | 8cd4c9d | 2014-10-08 00:07:53 +0000 | [diff] [blame] | 601 | DWOCUs.parseDWO(*this, getInfoDWOSection()); |
Eric Christopher | da4b219 | 2013-01-02 23:52:13 +0000 | [diff] [blame] | 602 | } |
| 603 | |
David Blaikie | 92d9d62 | 2014-01-09 05:08:24 +0000 | [diff] [blame] | 604 | void DWARFContext::parseDWOTypeUnits() { |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 605 | if (!DWOTUs.empty()) |
| 606 | return; |
| 607 | for (const auto &I : getTypesDWOSections()) { |
Benjamin Kramer | f5e2fc4 | 2015-05-29 19:43:39 +0000 | [diff] [blame] | 608 | DWOTUs.emplace_back(); |
Alexey Samsonov | 8cd4c9d | 2014-10-08 00:07:53 +0000 | [diff] [blame] | 609 | DWOTUs.back().parseDWO(*this, I.second); |
David Blaikie | 92d9d62 | 2014-01-09 05:08:24 +0000 | [diff] [blame] | 610 | } |
| 611 | } |
| 612 | |
Alexey Samsonov | 45be793 | 2012-08-30 07:49:50 +0000 | [diff] [blame] | 613 | DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) { |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 614 | parseCompileUnits(); |
Frederic Riss | 4e126a0 | 2014-09-15 07:50:27 +0000 | [diff] [blame] | 615 | return CUs.getUnitForOffset(Offset); |
Benjamin Kramer | 2602ca6 | 2011-09-15 20:43:22 +0000 | [diff] [blame] | 616 | } |
| 617 | |
Alexey Samsonov | 45be793 | 2012-08-30 07:49:50 +0000 | [diff] [blame] | 618 | DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) { |
Benjamin Kramer | 112ec17 | 2011-09-15 21:59:13 +0000 | [diff] [blame] | 619 | // First, get the offset of the compile unit. |
Alexey Samsonov | 45be793 | 2012-08-30 07:49:50 +0000 | [diff] [blame] | 620 | uint32_t CUOffset = getDebugAranges()->findAddress(Address); |
Benjamin Kramer | 2602ca6 | 2011-09-15 20:43:22 +0000 | [diff] [blame] | 621 | // Retrieve the compile unit. |
Alexey Samsonov | 45be793 | 2012-08-30 07:49:50 +0000 | [diff] [blame] | 622 | return getCompileUnitForOffset(CUOffset); |
| 623 | } |
| 624 | |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 625 | static bool getFunctionNameAndStartLineForAddress(DWARFCompileUnit *CU, |
| 626 | uint64_t Address, |
| 627 | FunctionNameKind Kind, |
| 628 | std::string &FunctionName, |
| 629 | uint32_t &StartLine) { |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 630 | // The address may correspond to instruction in some inlined function, |
| 631 | // so we have to build the chain of inlined functions and take the |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 632 | // name of the topmost function in it. |
Greg Clayton | c8c1032 | 2016-12-13 18:25:19 +0000 | [diff] [blame] | 633 | SmallVector<DWARFDie, 4> InlinedChain; |
| 634 | CU->getInlinedChainForAddress(Address, InlinedChain); |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 635 | if (InlinedChain.empty()) |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 636 | return false; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 637 | |
| 638 | const DWARFDie &DIE = InlinedChain[0]; |
| 639 | bool FoundResult = false; |
| 640 | const char *Name = nullptr; |
| 641 | if (Kind != FunctionNameKind::None && (Name = DIE.getSubroutineName(Kind))) { |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 642 | FunctionName = Name; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 643 | FoundResult = true; |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 644 | } |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 645 | if (auto DeclLineResult = DIE.getDeclLine()) { |
| 646 | StartLine = DeclLineResult; |
| 647 | FoundResult = true; |
| 648 | } |
| 649 | |
| 650 | return FoundResult; |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 651 | } |
| 652 | |
Alexey Samsonov | 45be793 | 2012-08-30 07:49:50 +0000 | [diff] [blame] | 653 | DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address, |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 654 | DILineInfoSpecifier Spec) { |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 655 | DILineInfo Result; |
| 656 | |
Alexey Samsonov | 45be793 | 2012-08-30 07:49:50 +0000 | [diff] [blame] | 657 | DWARFCompileUnit *CU = getCompileUnitForAddress(Address); |
| 658 | if (!CU) |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 659 | return Result; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 660 | getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind, |
| 661 | Result.FunctionName, |
| 662 | Result.StartLine); |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 663 | if (Spec.FLIKind != FileLineInfoKind::None) { |
Frederic Riss | 101b5e2 | 2014-09-19 15:11:51 +0000 | [diff] [blame] | 664 | if (const DWARFLineTable *LineTable = getLineTableForUnit(CU)) |
| 665 | LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(), |
| 666 | Spec.FLIKind, Result); |
Alexey Samsonov | f4462fa | 2012-07-02 05:54:45 +0000 | [diff] [blame] | 667 | } |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 668 | return Result; |
Benjamin Kramer | 2602ca6 | 2011-09-15 20:43:22 +0000 | [diff] [blame] | 669 | } |
David Blaikie | a379b181 | 2011-12-20 02:50:00 +0000 | [diff] [blame] | 670 | |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 671 | DILineInfoTable |
| 672 | DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size, |
| 673 | DILineInfoSpecifier Spec) { |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 674 | DILineInfoTable Lines; |
| 675 | DWARFCompileUnit *CU = getCompileUnitForAddress(Address); |
| 676 | if (!CU) |
| 677 | return Lines; |
| 678 | |
| 679 | std::string FunctionName = "<invalid>"; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 680 | uint32_t StartLine = 0; |
| 681 | getFunctionNameAndStartLineForAddress(CU, Address, Spec.FNKind, FunctionName, |
| 682 | StartLine); |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 683 | |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 684 | // If the Specifier says we don't need FileLineInfo, just |
| 685 | // return the top-most function at the starting address. |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 686 | if (Spec.FLIKind == FileLineInfoKind::None) { |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 687 | DILineInfo Result; |
| 688 | Result.FunctionName = FunctionName; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 689 | Result.StartLine = StartLine; |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 690 | Lines.push_back(std::make_pair(Address, Result)); |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 691 | return Lines; |
| 692 | } |
| 693 | |
Frederic Riss | ec8a5ba | 2014-09-04 06:14:40 +0000 | [diff] [blame] | 694 | const DWARFLineTable *LineTable = getLineTableForUnit(CU); |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 695 | |
| 696 | // Get the index of row we're looking for in the line table. |
| 697 | std::vector<uint32_t> RowVector; |
| 698 | if (!LineTable->lookupAddressRange(Address, Size, RowVector)) |
| 699 | return Lines; |
| 700 | |
Alexey Samsonov | 1eabf98 | 2014-03-13 07:52:54 +0000 | [diff] [blame] | 701 | for (uint32_t RowIndex : RowVector) { |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 702 | // Take file number and line/column from the row. |
| 703 | const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex]; |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 704 | DILineInfo Result; |
Frederic Riss | 101b5e2 | 2014-09-19 15:11:51 +0000 | [diff] [blame] | 705 | LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(), |
| 706 | Spec.FLIKind, Result.FileName); |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 707 | Result.FunctionName = FunctionName; |
| 708 | Result.Line = Row.Line; |
| 709 | Result.Column = Row.Column; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 710 | Result.StartLine = StartLine; |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 711 | Lines.push_back(std::make_pair(Row.Address, Result)); |
Andrew Kaylor | 9a8ff81 | 2013-01-26 00:28:05 +0000 | [diff] [blame] | 712 | } |
| 713 | |
| 714 | return Lines; |
| 715 | } |
| 716 | |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 717 | DIInliningInfo |
| 718 | DWARFContext::getInliningInfoForAddress(uint64_t Address, |
| 719 | DILineInfoSpecifier Spec) { |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 720 | DIInliningInfo InliningInfo; |
| 721 | |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 722 | DWARFCompileUnit *CU = getCompileUnitForAddress(Address); |
| 723 | if (!CU) |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 724 | return InliningInfo; |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 725 | |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 726 | const DWARFLineTable *LineTable = nullptr; |
Greg Clayton | c8c1032 | 2016-12-13 18:25:19 +0000 | [diff] [blame] | 727 | SmallVector<DWARFDie, 4> InlinedChain; |
| 728 | CU->getInlinedChainForAddress(Address, InlinedChain); |
| 729 | if (InlinedChain.size() == 0) { |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 730 | // If there is no DIE for address (e.g. it is in unavailable .dwo file), |
| 731 | // try to at least get file/line info from symbol table. |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 732 | if (Spec.FLIKind != FileLineInfoKind::None) { |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 733 | DILineInfo Frame; |
Frederic Riss | ec8a5ba | 2014-09-04 06:14:40 +0000 | [diff] [blame] | 734 | LineTable = getLineTableForUnit(CU); |
Frederic Riss | 101b5e2 | 2014-09-19 15:11:51 +0000 | [diff] [blame] | 735 | if (LineTable && |
| 736 | LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(), |
| 737 | Spec.FLIKind, Frame)) |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 738 | InliningInfo.addFrame(Frame); |
Alexey Samsonov | 5c39fdf | 2014-04-18 22:22:44 +0000 | [diff] [blame] | 739 | } |
| 740 | return InliningInfo; |
| 741 | } |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 742 | |
Dehao Chen | ef700d5 | 2017-04-17 20:10:39 +0000 | [diff] [blame] | 743 | uint32_t CallFile = 0, CallLine = 0, CallColumn = 0, CallDiscriminator = 0; |
Greg Clayton | c8c1032 | 2016-12-13 18:25:19 +0000 | [diff] [blame] | 744 | for (uint32_t i = 0, n = InlinedChain.size(); i != n; i++) { |
| 745 | DWARFDie &FunctionDIE = InlinedChain[i]; |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 746 | DILineInfo Frame; |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 747 | // Get function name if necessary. |
Greg Clayton | c8c1032 | 2016-12-13 18:25:19 +0000 | [diff] [blame] | 748 | if (const char *Name = FunctionDIE.getSubroutineName(Spec.FNKind)) |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 749 | Frame.FunctionName = Name; |
David Blaikie | efc4eba | 2017-02-06 20:19:02 +0000 | [diff] [blame] | 750 | if (auto DeclLineResult = FunctionDIE.getDeclLine()) |
| 751 | Frame.StartLine = DeclLineResult; |
Alexey Samsonov | dce6734 | 2014-05-15 21:24:32 +0000 | [diff] [blame] | 752 | if (Spec.FLIKind != FileLineInfoKind::None) { |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 753 | if (i == 0) { |
| 754 | // For the topmost frame, initialize the line table of this |
| 755 | // compile unit and fetch file/line info from it. |
Frederic Riss | ec8a5ba | 2014-09-04 06:14:40 +0000 | [diff] [blame] | 756 | LineTable = getLineTableForUnit(CU); |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 757 | // For the topmost routine, get file/line info from line table. |
Frederic Riss | 101b5e2 | 2014-09-19 15:11:51 +0000 | [diff] [blame] | 758 | if (LineTable) |
| 759 | LineTable->getFileLineInfoForAddress(Address, CU->getCompilationDir(), |
| 760 | Spec.FLIKind, Frame); |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 761 | } else { |
| 762 | // Otherwise, use call file, call line and call column from |
| 763 | // previous DIE in inlined chain. |
Frederic Riss | 101b5e2 | 2014-09-19 15:11:51 +0000 | [diff] [blame] | 764 | if (LineTable) |
| 765 | LineTable->getFileNameByIndex(CallFile, CU->getCompilationDir(), |
| 766 | Spec.FLIKind, Frame.FileName); |
Alexey Samsonov | d010999 | 2014-04-18 21:36:39 +0000 | [diff] [blame] | 767 | Frame.Line = CallLine; |
| 768 | Frame.Column = CallColumn; |
Dehao Chen | ef700d5 | 2017-04-17 20:10:39 +0000 | [diff] [blame] | 769 | Frame.Discriminator = CallDiscriminator; |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 770 | } |
| 771 | // Get call file/line/column of a current DIE. |
| 772 | if (i + 1 < n) { |
Dehao Chen | ef700d5 | 2017-04-17 20:10:39 +0000 | [diff] [blame] | 773 | FunctionDIE.getCallerFrame(CallFile, CallLine, CallColumn, |
| 774 | CallDiscriminator); |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 775 | } |
| 776 | } |
Alexey Samsonov | c942e6b | 2012-09-04 08:12:33 +0000 | [diff] [blame] | 777 | InliningInfo.addFrame(Frame); |
| 778 | } |
| 779 | return InliningInfo; |
| 780 | } |
| 781 | |
David Blaikie | f9803fb | 2017-05-23 00:30:42 +0000 | [diff] [blame] | 782 | std::shared_ptr<DWARFContext> |
| 783 | DWARFContext::getDWOContext(StringRef AbsolutePath) { |
David Blaikie | 15d85fc | 2017-05-23 06:48:53 +0000 | [diff] [blame] | 784 | if (auto S = DWP.lock()) { |
David Blaikie | f9803fb | 2017-05-23 00:30:42 +0000 | [diff] [blame] | 785 | DWARFContext *Ctxt = S->Context.get(); |
| 786 | return std::shared_ptr<DWARFContext>(std::move(S), Ctxt); |
| 787 | } |
| 788 | |
David Blaikie | 15d85fc | 2017-05-23 06:48:53 +0000 | [diff] [blame] | 789 | std::weak_ptr<DWOFile> *Entry = &DWOFiles[AbsolutePath]; |
| 790 | |
| 791 | if (auto S = Entry->lock()) { |
| 792 | DWARFContext *Ctxt = S->Context.get(); |
| 793 | return std::shared_ptr<DWARFContext>(std::move(S), Ctxt); |
| 794 | } |
| 795 | |
| 796 | SmallString<128> DWPName; |
| 797 | Expected<OwningBinary<ObjectFile>> Obj = [&] { |
| 798 | if (!CheckedForDWP) { |
| 799 | (getFileName() + ".dwp").toVector(DWPName); |
| 800 | auto Obj = object::ObjectFile::createObjectFile(DWPName); |
| 801 | if (Obj) { |
| 802 | Entry = &DWP; |
| 803 | return Obj; |
| 804 | } else { |
| 805 | CheckedForDWP = true; |
| 806 | // TODO: Should this error be handled (maybe in a high verbosity mode) |
| 807 | // before falling back to .dwo files? |
| 808 | consumeError(Obj.takeError()); |
| 809 | } |
| 810 | } |
| 811 | |
| 812 | return object::ObjectFile::createObjectFile(AbsolutePath); |
| 813 | }(); |
| 814 | |
David Blaikie | f9803fb | 2017-05-23 00:30:42 +0000 | [diff] [blame] | 815 | if (!Obj) { |
| 816 | // TODO: Actually report errors helpfully. |
| 817 | consumeError(Obj.takeError()); |
| 818 | return nullptr; |
| 819 | } |
David Blaikie | 15d85fc | 2017-05-23 06:48:53 +0000 | [diff] [blame] | 820 | |
| 821 | auto S = std::make_shared<DWOFile>(); |
David Blaikie | f9803fb | 2017-05-23 00:30:42 +0000 | [diff] [blame] | 822 | S->File = std::move(Obj.get()); |
| 823 | S->Context = llvm::make_unique<DWARFContextInMemory>(*S->File.getBinary()); |
David Blaikie | 15d85fc | 2017-05-23 06:48:53 +0000 | [diff] [blame] | 824 | *Entry = S; |
David Blaikie | f9803fb | 2017-05-23 00:30:42 +0000 | [diff] [blame] | 825 | auto *Ctxt = S->Context.get(); |
| 826 | return std::shared_ptr<DWARFContext>(std::move(S), Ctxt); |
| 827 | } |
| 828 | |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 829 | static Error createError(const Twine &Reason, llvm::Error E) { |
| 830 | return make_error<StringError>(Reason + toString(std::move(E)), |
| 831 | inconvertibleErrorCode()); |
| 832 | } |
| 833 | |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 834 | /// SymInfo contains information about symbol: it's address |
| 835 | /// and section index which is -1LL for absolute symbols. |
| 836 | struct SymInfo { |
| 837 | uint64_t Address; |
| 838 | uint64_t SectionIndex; |
| 839 | }; |
| 840 | |
| 841 | /// Returns the address of symbol relocation used against and a section index. |
| 842 | /// Used for futher relocations computation. Symbol's section load address is |
| 843 | static Expected<SymInfo> getSymbolInfo(const object::ObjectFile &Obj, |
| 844 | const RelocationRef &Reloc, |
| 845 | const LoadedObjectInfo *L, |
| 846 | std::map<SymbolRef, SymInfo> &Cache) { |
| 847 | SymInfo Ret = {0, (uint64_t)-1LL}; |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 848 | object::section_iterator RSec = Obj.section_end(); |
| 849 | object::symbol_iterator Sym = Reloc.getSymbol(); |
| 850 | |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 851 | std::map<SymbolRef, SymInfo>::iterator CacheIt = Cache.end(); |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 852 | // First calculate the address of the symbol or section as it appears |
| 853 | // in the object file |
| 854 | if (Sym != Obj.symbol_end()) { |
George Rimar | 958b01a | 2017-05-15 11:45:28 +0000 | [diff] [blame] | 855 | bool New; |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 856 | std::tie(CacheIt, New) = Cache.insert({*Sym, {0, 0}}); |
George Rimar | 958b01a | 2017-05-15 11:45:28 +0000 | [diff] [blame] | 857 | if (!New) |
| 858 | return CacheIt->second; |
| 859 | |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 860 | Expected<uint64_t> SymAddrOrErr = Sym->getAddress(); |
| 861 | if (!SymAddrOrErr) |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 862 | return createError("failed to compute symbol address: ", |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 863 | SymAddrOrErr.takeError()); |
| 864 | |
| 865 | // Also remember what section this symbol is in for later |
| 866 | auto SectOrErr = Sym->getSection(); |
| 867 | if (!SectOrErr) |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 868 | return createError("failed to get symbol section: ", |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 869 | SectOrErr.takeError()); |
| 870 | |
| 871 | RSec = *SectOrErr; |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 872 | Ret.Address = *SymAddrOrErr; |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 873 | } else if (auto *MObj = dyn_cast<MachOObjectFile>(&Obj)) { |
| 874 | RSec = MObj->getRelocationSection(Reloc.getRawDataRefImpl()); |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 875 | Ret.Address = RSec->getAddress(); |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 876 | } |
| 877 | |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 878 | if (RSec != Obj.section_end()) |
| 879 | Ret.SectionIndex = RSec->getIndex(); |
| 880 | |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 881 | // If we are given load addresses for the sections, we need to adjust: |
| 882 | // SymAddr = (Address of Symbol Or Section in File) - |
| 883 | // (Address of Section in File) + |
| 884 | // (Load Address of Section) |
| 885 | // RSec is now either the section being targeted or the section |
| 886 | // containing the symbol being targeted. In either case, |
| 887 | // we need to perform the same computation. |
| 888 | if (L && RSec != Obj.section_end()) |
| 889 | if (uint64_t SectionLoadAddress = L->getSectionLoadAddress(*RSec)) |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 890 | Ret.Address += SectionLoadAddress - RSec->getAddress(); |
George Rimar | 958b01a | 2017-05-15 11:45:28 +0000 | [diff] [blame] | 891 | |
| 892 | if (CacheIt != Cache.end()) |
| 893 | CacheIt->second = Ret; |
| 894 | |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 895 | return Ret; |
| 896 | } |
| 897 | |
| 898 | static bool isRelocScattered(const object::ObjectFile &Obj, |
| 899 | const RelocationRef &Reloc) { |
George Rimar | d4998b0 | 2017-04-13 09:52:50 +0000 | [diff] [blame] | 900 | const MachOObjectFile *MachObj = dyn_cast<MachOObjectFile>(&Obj); |
| 901 | if (!MachObj) |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 902 | return false; |
| 903 | // MachO also has relocations that point to sections and |
| 904 | // scattered relocations. |
George Rimar | 702dac6 | 2017-04-12 08:59:15 +0000 | [diff] [blame] | 905 | auto RelocInfo = MachObj->getRelocation(Reloc.getRawDataRefImpl()); |
| 906 | return MachObj->isRelocationScattered(RelocInfo); |
| 907 | } |
| 908 | |
George Rimar | 2122ff64 | 2017-05-05 10:52:39 +0000 | [diff] [blame] | 909 | Error DWARFContextInMemory::maybeDecompress(const SectionRef &Sec, |
| 910 | StringRef Name, StringRef &Data) { |
| 911 | if (!Decompressor::isCompressed(Sec)) |
| 912 | return Error::success(); |
| 913 | |
| 914 | Expected<Decompressor> Decompressor = |
| 915 | Decompressor::create(Name, Data, IsLittleEndian, AddressSize == 8); |
| 916 | if (!Decompressor) |
| 917 | return Decompressor.takeError(); |
| 918 | |
| 919 | SmallString<32> Out; |
George Rimar | f98b9ac | 2017-05-18 08:00:01 +0000 | [diff] [blame] | 920 | if (auto Err = Decompressor->resizeAndDecompress(Out)) |
George Rimar | 2122ff64 | 2017-05-05 10:52:39 +0000 | [diff] [blame] | 921 | return Err; |
| 922 | |
| 923 | UncompressedSections.emplace_back(std::move(Out)); |
| 924 | Data = UncompressedSections.back(); |
| 925 | |
| 926 | return Error::success(); |
| 927 | } |
| 928 | |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 929 | ErrorPolicy DWARFContextInMemory::defaultErrorHandler(Error E) { |
| 930 | errs() << "error: " + toString(std::move(E)) << '\n'; |
| 931 | return ErrorPolicy::Continue; |
| 932 | } |
| 933 | |
| 934 | DWARFContextInMemory::DWARFContextInMemory( |
| 935 | const object::ObjectFile &Obj, const LoadedObjectInfo *L, |
| 936 | function_ref<ErrorPolicy(Error)> HandleError) |
David Blaikie | 15d85fc | 2017-05-23 06:48:53 +0000 | [diff] [blame] | 937 | : FileName(Obj.getFileName()), IsLittleEndian(Obj.isLittleEndian()), |
Rafael Espindola | a04bb5b | 2014-07-31 20:19:36 +0000 | [diff] [blame] | 938 | AddressSize(Obj.getBytesInAddress()) { |
| 939 | for (const SectionRef &Section : Obj.sections()) { |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 940 | StringRef name; |
Alexey Samsonov | 063eb3f | 2014-03-13 13:52:54 +0000 | [diff] [blame] | 941 | Section.getName(name); |
David Majnemer | dac3985 | 2014-09-26 22:32:16 +0000 | [diff] [blame] | 942 | // Skip BSS and Virtual sections, they aren't interesting. |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 943 | bool IsBSS = Section.isBSS(); |
David Majnemer | dac3985 | 2014-09-26 22:32:16 +0000 | [diff] [blame] | 944 | if (IsBSS) |
| 945 | continue; |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 946 | bool IsVirtual = Section.isVirtual(); |
David Majnemer | dac3985 | 2014-09-26 22:32:16 +0000 | [diff] [blame] | 947 | if (IsVirtual) |
| 948 | continue; |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 949 | StringRef data; |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 950 | |
Lang Hames | 2e88f4f | 2015-07-28 17:52:11 +0000 | [diff] [blame] | 951 | section_iterator RelocatedSection = Section.getRelocatedSection(); |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 952 | // Try to obtain an already relocated version of this section. |
| 953 | // Else use the unrelocated section from the object file. We'll have to |
| 954 | // apply relocations ourselves later. |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 955 | if (!L || !L->getLoadedSectionContents(*RelocatedSection, data)) |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 956 | Section.getContents(data); |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 957 | |
George Rimar | 2122ff64 | 2017-05-05 10:52:39 +0000 | [diff] [blame] | 958 | if (auto Err = maybeDecompress(Section, name, data)) { |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 959 | ErrorPolicy EP = HandleError( |
| 960 | createError("failed to decompress '" + name + "', ", std::move(Err))); |
| 961 | if (EP == ErrorPolicy::Halt) |
| 962 | return; |
George Rimar | 2122ff64 | 2017-05-05 10:52:39 +0000 | [diff] [blame] | 963 | continue; |
Alexey Samsonov | 068fc8a | 2013-04-23 10:17:34 +0000 | [diff] [blame] | 964 | } |
| 965 | |
George Rimar | 4bf3083 | 2017-01-11 15:26:41 +0000 | [diff] [blame] | 966 | // Compressed sections names in GNU style starts from ".z", |
| 967 | // at this point section is decompressed and we drop compression prefix. |
| 968 | name = name.substr( |
| 969 | name.find_first_not_of("._z")); // Skip ".", "z" and "_" prefixes. |
| 970 | |
Rafael Espindola | 77e87b3 | 2017-07-07 05:36:53 +0000 | [diff] [blame^] | 971 | if (StringRef *SectionData = mapSectionToMember(name)) { |
Alexey Samsonov | 063eb3f | 2014-03-13 13:52:54 +0000 | [diff] [blame] | 972 | *SectionData = data; |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 973 | if (name == "debug_ranges") { |
| 974 | // FIXME: Use the other dwo range section when we emit it. |
George Rimar | ca53211 | 2017-04-24 10:19:45 +0000 | [diff] [blame] | 975 | RangeDWOSection.Data = data; |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 976 | } |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 977 | } else if (name == "debug_types") { |
David Blaikie | 427e435 | 2013-09-23 23:39:55 +0000 | [diff] [blame] | 978 | // Find debug_types data by section rather than name as there are |
| 979 | // multiple, comdat grouped, debug_types sections. |
Alexey Samsonov | 063eb3f | 2014-03-13 13:52:54 +0000 | [diff] [blame] | 980 | TypesSections[Section].Data = data; |
David Blaikie | 92d9d62 | 2014-01-09 05:08:24 +0000 | [diff] [blame] | 981 | } else if (name == "debug_types.dwo") { |
Alexey Samsonov | 063eb3f | 2014-03-13 13:52:54 +0000 | [diff] [blame] | 982 | TypesDWOSections[Section].Data = data; |
Eric Christopher | da4b219 | 2013-01-02 23:52:13 +0000 | [diff] [blame] | 983 | } |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 984 | |
Wolfgang Pieb | 77d3e93 | 2017-06-06 01:22:34 +0000 | [diff] [blame] | 985 | // Map platform specific debug section names to DWARF standard section |
| 986 | // names. |
| 987 | name = Obj.mapDebugSectionName(name); |
| 988 | |
Rafael Espindola | a04bb5b | 2014-07-31 20:19:36 +0000 | [diff] [blame] | 989 | if (RelocatedSection == Obj.section_end()) |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 990 | continue; |
| 991 | |
| 992 | StringRef RelSecName; |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 993 | StringRef RelSecData; |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 994 | RelocatedSection->getName(RelSecName); |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 995 | |
| 996 | // If the section we're relocating was relocated already by the JIT, |
| 997 | // then we used the relocated version above, so we do not need to process |
| 998 | // relocations for it now. |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 999 | if (L && L->getLoadedSectionContents(*RelocatedSection, RelSecData)) |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 1000 | continue; |
| 1001 | |
Frederic Riss | 7bb1226 | 2015-08-23 04:44:21 +0000 | [diff] [blame] | 1002 | // In Mach-o files, the relocations do not need to be applied if |
| 1003 | // there is no load offset to apply. The value read at the |
| 1004 | // relocation point already factors in the section address |
| 1005 | // (actually applying the relocations will produce wrong results |
| 1006 | // as the section address will be added twice). |
Craig Topper | 66059c9 | 2015-11-18 07:07:59 +0000 | [diff] [blame] | 1007 | if (!L && isa<MachOObjectFile>(&Obj)) |
Frederic Riss | 7bb1226 | 2015-08-23 04:44:21 +0000 | [diff] [blame] | 1008 | continue; |
| 1009 | |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 1010 | RelSecName = RelSecName.substr( |
David Blaikie | a91885a | 2017-06-10 19:32:50 +0000 | [diff] [blame] | 1011 | RelSecName.find_first_not_of("._z")); // Skip . and _ prefixes. |
Rafael Espindola | 4f60a38 | 2013-05-30 03:05:14 +0000 | [diff] [blame] | 1012 | |
Andrew Kaylor | d55d701 | 2013-01-25 22:50:58 +0000 | [diff] [blame] | 1013 | // TODO: Add support for relocations in other sections as needed. |
| 1014 | // Record relocations for the debug_info and debug_line sections. |
Rafael Espindola | 77e87b3 | 2017-07-07 05:36:53 +0000 | [diff] [blame^] | 1015 | DWARFSection *Sec = mapNameToDWARFSection(RelSecName); |
| 1016 | RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr; |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 1017 | if (!Map) { |
David Blaikie | 427e435 | 2013-09-23 23:39:55 +0000 | [diff] [blame] | 1018 | // Find debug_types relocs by section rather than name as there are |
| 1019 | // multiple, comdat grouped, debug_types sections. |
David Blaikie | 92d9d62 | 2014-01-09 05:08:24 +0000 | [diff] [blame] | 1020 | if (RelSecName == "debug_types") |
| 1021 | Map = &TypesSections[*RelocatedSection].Relocs; |
| 1022 | else if (RelSecName == "debug_types.dwo") |
| 1023 | Map = &TypesDWOSections[*RelocatedSection].Relocs; |
| 1024 | else |
| 1025 | continue; |
David Blaikie | 03c089c | 2013-09-23 22:44:47 +0000 | [diff] [blame] | 1026 | } |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 1027 | |
George Rimar | fed9f09 | 2017-05-17 12:10:51 +0000 | [diff] [blame] | 1028 | if (Section.relocation_begin() == Section.relocation_end()) |
| 1029 | continue; |
| 1030 | |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 1031 | // Symbol to [address, section index] cache mapping. |
| 1032 | std::map<SymbolRef, SymInfo> AddrCache; |
George Rimar | fed9f09 | 2017-05-17 12:10:51 +0000 | [diff] [blame] | 1033 | for (const RelocationRef &Reloc : Section.relocations()) { |
| 1034 | // FIXME: it's not clear how to correctly handle scattered |
| 1035 | // relocations. |
| 1036 | if (isRelocScattered(Obj, Reloc)) |
| 1037 | continue; |
Keno Fischer | c780e8e | 2015-05-21 21:24:32 +0000 | [diff] [blame] | 1038 | |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 1039 | Expected<SymInfo> SymInfoOrErr = getSymbolInfo(Obj, Reloc, L, AddrCache); |
| 1040 | if (!SymInfoOrErr) { |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 1041 | if (HandleError(SymInfoOrErr.takeError()) == ErrorPolicy::Halt) |
| 1042 | return; |
George Rimar | fed9f09 | 2017-05-17 12:10:51 +0000 | [diff] [blame] | 1043 | continue; |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 1044 | } |
George Rimar | fed9f09 | 2017-05-17 12:10:51 +0000 | [diff] [blame] | 1045 | |
| 1046 | object::RelocVisitor V(Obj); |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 1047 | uint64_t Val = V.visit(Reloc.getType(), Reloc, SymInfoOrErr->Address); |
George Rimar | fed9f09 | 2017-05-17 12:10:51 +0000 | [diff] [blame] | 1048 | if (V.error()) { |
| 1049 | SmallString<32> Name; |
| 1050 | Reloc.getTypeName(Name); |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 1051 | ErrorPolicy EP = HandleError( |
George Rimar | b25a09d0 | 2017-06-29 14:05:18 +0000 | [diff] [blame] | 1052 | createError("failed to compute relocation: " + Name + ", ", |
George Rimar | 1af3cb2 | 2017-06-28 08:21:19 +0000 | [diff] [blame] | 1053 | errorCodeToError(object_error::parse_failed))); |
| 1054 | if (EP == ErrorPolicy::Halt) |
| 1055 | return; |
George Rimar | fed9f09 | 2017-05-17 12:10:51 +0000 | [diff] [blame] | 1056 | continue; |
| 1057 | } |
Eugene Zelenko | 2db0cfa | 2017-06-23 21:57:40 +0000 | [diff] [blame] | 1058 | RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val}; |
George Rimar | a25d329 | 2017-05-27 18:10:23 +0000 | [diff] [blame] | 1059 | Map->insert({Reloc.getOffset(), Rel}); |
Eric Christopher | 7370b55 | 2012-11-12 21:40:38 +0000 | [diff] [blame] | 1060 | } |
| 1061 | } |
| 1062 | } |
| 1063 | |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1064 | DWARFContextInMemory::DWARFContextInMemory( |
| 1065 | const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, uint8_t AddrSize, |
| 1066 | bool isLittleEndian) |
| 1067 | : IsLittleEndian(isLittleEndian), AddressSize(AddrSize) { |
| 1068 | for (const auto &SecIt : Sections) { |
Rafael Espindola | 77e87b3 | 2017-07-07 05:36:53 +0000 | [diff] [blame^] | 1069 | if (StringRef *SectionData = mapSectionToMember(SecIt.first())) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1070 | *SectionData = SecIt.second->getBuffer(); |
| 1071 | } |
| 1072 | } |
| 1073 | |
Rafael Espindola | 77e87b3 | 2017-07-07 05:36:53 +0000 | [diff] [blame^] | 1074 | DWARFSection *DWARFContextInMemory::mapNameToDWARFSection(StringRef Name) { |
| 1075 | return StringSwitch<DWARFSection *>(Name) |
| 1076 | .Case("debug_info", &InfoSection) |
| 1077 | .Case("debug_loc", &LocSection) |
| 1078 | .Case("debug_line", &LineSection) |
| 1079 | .Case("debug_str_offsets", &StringOffsetSection) |
| 1080 | .Case("debug_ranges", &RangeSection) |
| 1081 | .Case("debug_info.dwo", &InfoDWOSection) |
| 1082 | .Case("debug_loc.dwo", &LocDWOSection) |
| 1083 | .Case("debug_line.dwo", &LineDWOSection) |
| 1084 | .Case("debug_str_offsets.dwo", &StringOffsetDWOSection) |
| 1085 | .Case("debug_addr", &AddrSection) |
| 1086 | .Case("apple_names", &AppleNamesSection) |
| 1087 | .Case("apple_types", &AppleTypesSection) |
| 1088 | .Case("apple_namespaces", &AppleNamespacesSection) |
| 1089 | .Case("apple_namespac", &AppleNamespacesSection) |
| 1090 | .Case("apple_objc", &AppleObjCSection) |
| 1091 | .Default(nullptr); |
| 1092 | } |
| 1093 | |
| 1094 | StringRef *DWARFContextInMemory::mapSectionToMember(StringRef Name) { |
| 1095 | if (DWARFSection *Sec = mapNameToDWARFSection(Name)) |
| 1096 | return &Sec->Data; |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1097 | return StringSwitch<StringRef *>(Name) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1098 | .Case("debug_abbrev", &AbbrevSection) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1099 | .Case("debug_aranges", &ARangeSection) |
| 1100 | .Case("debug_frame", &DebugFrameSection) |
| 1101 | .Case("eh_frame", &EHFrameSection) |
| 1102 | .Case("debug_str", &StringSection) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1103 | .Case("debug_macinfo", &MacinfoSection) |
| 1104 | .Case("debug_pubnames", &PubNamesSection) |
| 1105 | .Case("debug_pubtypes", &PubTypesSection) |
| 1106 | .Case("debug_gnu_pubnames", &GnuPubNamesSection) |
| 1107 | .Case("debug_gnu_pubtypes", &GnuPubTypesSection) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1108 | .Case("debug_abbrev.dwo", &AbbrevDWOSection) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1109 | .Case("debug_str.dwo", &StringDWOSection) |
Chris Bieneman | 2e752db | 2017-01-20 19:03:14 +0000 | [diff] [blame] | 1110 | .Case("debug_cu_index", &CUIndexSection) |
| 1111 | .Case("debug_tu_index", &TUIndexSection) |
| 1112 | .Case("gdb_index", &GdbIndexSection) |
| 1113 | // Any more debug info sections go here. |
| 1114 | .Default(nullptr); |
| 1115 | } |
| 1116 | |
Eugene Zelenko | 28db7e6 | 2017-03-01 01:14:23 +0000 | [diff] [blame] | 1117 | void DWARFContextInMemory::anchor() {} |