File: | tools/llvm-objdump/COFFDump.cpp |
Warning: | line 201, column 28 1st function call argument is an uninitialized value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- COFFDump.cpp - COFF-specific dumper ---------------------*- C++ -*-===// | |||
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 | /// | |||
10 | /// \file | |||
11 | /// This file implements the COFF-specific dumper for llvm-objdump. | |||
12 | /// It outputs the Win64 EH data structures as plain text. | |||
13 | /// The encoding of the unwind codes is described in MSDN: | |||
14 | /// http://msdn.microsoft.com/en-us/library/ck9asaa9.aspx | |||
15 | /// | |||
16 | //===----------------------------------------------------------------------===// | |||
17 | ||||
18 | #include "llvm-objdump.h" | |||
19 | #include "llvm/Demangle/Demangle.h" | |||
20 | #include "llvm/Object/COFF.h" | |||
21 | #include "llvm/Object/COFFImportFile.h" | |||
22 | #include "llvm/Object/ObjectFile.h" | |||
23 | #include "llvm/Support/Format.h" | |||
24 | #include "llvm/Support/Win64EH.h" | |||
25 | #include "llvm/Support/raw_ostream.h" | |||
26 | ||||
27 | using namespace llvm; | |||
28 | using namespace object; | |||
29 | using namespace llvm::Win64EH; | |||
30 | ||||
31 | // Returns the name of the unwind code. | |||
32 | static StringRef getUnwindCodeTypeName(uint8_t Code) { | |||
33 | switch(Code) { | |||
34 | default: llvm_unreachable("Invalid unwind code")::llvm::llvm_unreachable_internal("Invalid unwind code", "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-objdump/COFFDump.cpp" , 34); | |||
35 | case UOP_PushNonVol: return "UOP_PushNonVol"; | |||
36 | case UOP_AllocLarge: return "UOP_AllocLarge"; | |||
37 | case UOP_AllocSmall: return "UOP_AllocSmall"; | |||
38 | case UOP_SetFPReg: return "UOP_SetFPReg"; | |||
39 | case UOP_SaveNonVol: return "UOP_SaveNonVol"; | |||
40 | case UOP_SaveNonVolBig: return "UOP_SaveNonVolBig"; | |||
41 | case UOP_SaveXMM128: return "UOP_SaveXMM128"; | |||
42 | case UOP_SaveXMM128Big: return "UOP_SaveXMM128Big"; | |||
43 | case UOP_PushMachFrame: return "UOP_PushMachFrame"; | |||
44 | } | |||
45 | } | |||
46 | ||||
47 | // Returns the name of a referenced register. | |||
48 | static StringRef getUnwindRegisterName(uint8_t Reg) { | |||
49 | switch(Reg) { | |||
50 | default: llvm_unreachable("Invalid register")::llvm::llvm_unreachable_internal("Invalid register", "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-objdump/COFFDump.cpp" , 50); | |||
51 | case 0: return "RAX"; | |||
52 | case 1: return "RCX"; | |||
53 | case 2: return "RDX"; | |||
54 | case 3: return "RBX"; | |||
55 | case 4: return "RSP"; | |||
56 | case 5: return "RBP"; | |||
57 | case 6: return "RSI"; | |||
58 | case 7: return "RDI"; | |||
59 | case 8: return "R8"; | |||
60 | case 9: return "R9"; | |||
61 | case 10: return "R10"; | |||
62 | case 11: return "R11"; | |||
63 | case 12: return "R12"; | |||
64 | case 13: return "R13"; | |||
65 | case 14: return "R14"; | |||
66 | case 15: return "R15"; | |||
67 | } | |||
68 | } | |||
69 | ||||
70 | // Calculates the number of array slots required for the unwind code. | |||
71 | static unsigned getNumUsedSlots(const UnwindCode &UnwindCode) { | |||
72 | switch (UnwindCode.getUnwindOp()) { | |||
73 | default: llvm_unreachable("Invalid unwind code")::llvm::llvm_unreachable_internal("Invalid unwind code", "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-objdump/COFFDump.cpp" , 73); | |||
74 | case UOP_PushNonVol: | |||
75 | case UOP_AllocSmall: | |||
76 | case UOP_SetFPReg: | |||
77 | case UOP_PushMachFrame: | |||
78 | return 1; | |||
79 | case UOP_SaveNonVol: | |||
80 | case UOP_SaveXMM128: | |||
81 | return 2; | |||
82 | case UOP_SaveNonVolBig: | |||
83 | case UOP_SaveXMM128Big: | |||
84 | return 3; | |||
85 | case UOP_AllocLarge: | |||
86 | return (UnwindCode.getOpInfo() == 0) ? 2 : 3; | |||
87 | } | |||
88 | } | |||
89 | ||||
90 | // Prints one unwind code. Because an unwind code can occupy up to 3 slots in | |||
91 | // the unwind codes array, this function requires that the correct number of | |||
92 | // slots is provided. | |||
93 | static void printUnwindCode(ArrayRef<UnwindCode> UCs) { | |||
94 | assert(UCs.size() >= getNumUsedSlots(UCs[0]))((UCs.size() >= getNumUsedSlots(UCs[0])) ? static_cast< void> (0) : __assert_fail ("UCs.size() >= getNumUsedSlots(UCs[0])" , "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-objdump/COFFDump.cpp" , 94, __PRETTY_FUNCTION__)); | |||
95 | outs() << format(" 0x%02x: ", unsigned(UCs[0].u.CodeOffset)) | |||
96 | << getUnwindCodeTypeName(UCs[0].getUnwindOp()); | |||
97 | switch (UCs[0].getUnwindOp()) { | |||
98 | case UOP_PushNonVol: | |||
99 | outs() << " " << getUnwindRegisterName(UCs[0].getOpInfo()); | |||
100 | break; | |||
101 | case UOP_AllocLarge: | |||
102 | if (UCs[0].getOpInfo() == 0) { | |||
103 | outs() << " " << UCs[1].FrameOffset; | |||
104 | } else { | |||
105 | outs() << " " << UCs[1].FrameOffset | |||
106 | + (static_cast<uint32_t>(UCs[2].FrameOffset) << 16); | |||
107 | } | |||
108 | break; | |||
109 | case UOP_AllocSmall: | |||
110 | outs() << " " << ((UCs[0].getOpInfo() + 1) * 8); | |||
111 | break; | |||
112 | case UOP_SetFPReg: | |||
113 | outs() << " "; | |||
114 | break; | |||
115 | case UOP_SaveNonVol: | |||
116 | outs() << " " << getUnwindRegisterName(UCs[0].getOpInfo()) | |||
117 | << format(" [0x%04x]", 8 * UCs[1].FrameOffset); | |||
118 | break; | |||
119 | case UOP_SaveNonVolBig: | |||
120 | outs() << " " << getUnwindRegisterName(UCs[0].getOpInfo()) | |||
121 | << format(" [0x%08x]", UCs[1].FrameOffset | |||
122 | + (static_cast<uint32_t>(UCs[2].FrameOffset) << 16)); | |||
123 | break; | |||
124 | case UOP_SaveXMM128: | |||
125 | outs() << " XMM" << static_cast<uint32_t>(UCs[0].getOpInfo()) | |||
126 | << format(" [0x%04x]", 16 * UCs[1].FrameOffset); | |||
127 | break; | |||
128 | case UOP_SaveXMM128Big: | |||
129 | outs() << " XMM" << UCs[0].getOpInfo() | |||
130 | << format(" [0x%08x]", UCs[1].FrameOffset | |||
131 | + (static_cast<uint32_t>(UCs[2].FrameOffset) << 16)); | |||
132 | break; | |||
133 | case UOP_PushMachFrame: | |||
134 | outs() << " " << (UCs[0].getOpInfo() ? "w/o" : "w") | |||
135 | << " error code"; | |||
136 | break; | |||
137 | } | |||
138 | outs() << "\n"; | |||
139 | } | |||
140 | ||||
141 | static void printAllUnwindCodes(ArrayRef<UnwindCode> UCs) { | |||
142 | for (const UnwindCode *I = UCs.begin(), *E = UCs.end(); I < E; ) { | |||
143 | unsigned UsedSlots = getNumUsedSlots(*I); | |||
144 | if (UsedSlots > UCs.size()) { | |||
145 | outs() << "Unwind data corrupted: Encountered unwind op " | |||
146 | << getUnwindCodeTypeName((*I).getUnwindOp()) | |||
147 | << " which requires " << UsedSlots | |||
148 | << " slots, but only " << UCs.size() | |||
149 | << " remaining in buffer"; | |||
150 | return ; | |||
151 | } | |||
152 | printUnwindCode(makeArrayRef(I, E)); | |||
153 | I += UsedSlots; | |||
154 | } | |||
155 | } | |||
156 | ||||
157 | // Given a symbol sym this functions returns the address and section of it. | |||
158 | static std::error_code | |||
159 | resolveSectionAndAddress(const COFFObjectFile *Obj, const SymbolRef &Sym, | |||
160 | const coff_section *&ResolvedSection, | |||
161 | uint64_t &ResolvedAddr) { | |||
162 | Expected<uint64_t> ResolvedAddrOrErr = Sym.getAddress(); | |||
163 | if (!ResolvedAddrOrErr) | |||
164 | return errorToErrorCode(ResolvedAddrOrErr.takeError()); | |||
165 | ResolvedAddr = *ResolvedAddrOrErr; | |||
166 | Expected<section_iterator> Iter = Sym.getSection(); | |||
167 | if (!Iter) | |||
168 | return errorToErrorCode(Iter.takeError()); | |||
169 | ResolvedSection = Obj->getCOFFSection(**Iter); | |||
170 | return std::error_code(); | |||
171 | } | |||
172 | ||||
173 | // Given a vector of relocations for a section and an offset into this section | |||
174 | // the function returns the symbol used for the relocation at the offset. | |||
175 | static std::error_code resolveSymbol(const std::vector<RelocationRef> &Rels, | |||
176 | uint64_t Offset, SymbolRef &Sym) { | |||
177 | for (auto &R : Rels) { | |||
178 | uint64_t Ofs = R.getOffset(); | |||
179 | if (Ofs == Offset) { | |||
180 | Sym = *R.getSymbol(); | |||
181 | return std::error_code(); | |||
182 | } | |||
183 | } | |||
184 | return object_error::parse_failed; | |||
185 | } | |||
186 | ||||
187 | // Given a vector of relocations for a section and an offset into this section | |||
188 | // the function resolves the symbol used for the relocation at the offset and | |||
189 | // returns the section content and the address inside the content pointed to | |||
190 | // by the symbol. | |||
191 | static std::error_code | |||
192 | getSectionContents(const COFFObjectFile *Obj, | |||
193 | const std::vector<RelocationRef> &Rels, uint64_t Offset, | |||
194 | ArrayRef<uint8_t> &Contents, uint64_t &Addr) { | |||
195 | SymbolRef Sym; | |||
196 | if (std::error_code EC = resolveSymbol(Rels, Offset, Sym)) | |||
197 | return EC; | |||
198 | const coff_section *Section; | |||
199 | if (std::error_code EC = resolveSectionAndAddress(Obj, Sym, Section, Addr)) | |||
200 | return EC; | |||
201 | if (std::error_code EC = Obj->getSectionContents(Section, Contents)) | |||
| ||||
202 | return EC; | |||
203 | return std::error_code(); | |||
204 | } | |||
205 | ||||
206 | // Given a vector of relocations for a section and an offset into this section | |||
207 | // the function returns the name of the symbol used for the relocation at the | |||
208 | // offset. | |||
209 | static std::error_code resolveSymbolName(const std::vector<RelocationRef> &Rels, | |||
210 | uint64_t Offset, StringRef &Name) { | |||
211 | SymbolRef Sym; | |||
212 | if (std::error_code EC = resolveSymbol(Rels, Offset, Sym)) | |||
213 | return EC; | |||
214 | Expected<StringRef> NameOrErr = Sym.getName(); | |||
215 | if (!NameOrErr) | |||
216 | return errorToErrorCode(NameOrErr.takeError()); | |||
217 | Name = *NameOrErr; | |||
218 | return std::error_code(); | |||
219 | } | |||
220 | ||||
221 | static void printCOFFSymbolAddress(llvm::raw_ostream &Out, | |||
222 | const std::vector<RelocationRef> &Rels, | |||
223 | uint64_t Offset, uint32_t Disp) { | |||
224 | StringRef Sym; | |||
225 | if (!resolveSymbolName(Rels, Offset, Sym)) { | |||
226 | Out << Sym; | |||
227 | if (Disp > 0) | |||
228 | Out << format(" + 0x%04x", Disp); | |||
229 | } else { | |||
230 | Out << format("0x%04x", Disp); | |||
231 | } | |||
232 | } | |||
233 | ||||
234 | static void | |||
235 | printSEHTable(const COFFObjectFile *Obj, uint32_t TableVA, int Count) { | |||
236 | if (Count == 0) | |||
237 | return; | |||
238 | ||||
239 | const pe32_header *PE32Header; | |||
240 | error(Obj->getPE32Header(PE32Header)); | |||
241 | uint32_t ImageBase = PE32Header->ImageBase; | |||
242 | uintptr_t IntPtr = 0; | |||
243 | error(Obj->getVaPtr(TableVA, IntPtr)); | |||
244 | const support::ulittle32_t *P = (const support::ulittle32_t *)IntPtr; | |||
245 | outs() << "SEH Table:"; | |||
246 | for (int I = 0; I < Count; ++I) | |||
247 | outs() << format(" 0x%x", P[I] + ImageBase); | |||
248 | outs() << "\n\n"; | |||
249 | } | |||
250 | ||||
251 | template <typename T> | |||
252 | static void printTLSDirectoryT(const coff_tls_directory<T> *TLSDir) { | |||
253 | size_t FormatWidth = sizeof(T) * 2; | |||
254 | outs() << "TLS directory:" | |||
255 | << "\n StartAddressOfRawData: " | |||
256 | << format_hex(TLSDir->StartAddressOfRawData, FormatWidth) | |||
257 | << "\n EndAddressOfRawData: " | |||
258 | << format_hex(TLSDir->EndAddressOfRawData, FormatWidth) | |||
259 | << "\n AddressOfIndex: " | |||
260 | << format_hex(TLSDir->AddressOfIndex, FormatWidth) | |||
261 | << "\n AddressOfCallBacks: " | |||
262 | << format_hex(TLSDir->AddressOfCallBacks, FormatWidth) | |||
263 | << "\n SizeOfZeroFill: " | |||
264 | << TLSDir->SizeOfZeroFill | |||
265 | << "\n Characteristics: " | |||
266 | << TLSDir->Characteristics | |||
267 | << "\n Alignment: " | |||
268 | << TLSDir->getAlignment() | |||
269 | << "\n\n"; | |||
270 | } | |||
271 | ||||
272 | static void printTLSDirectory(const COFFObjectFile *Obj) { | |||
273 | const pe32_header *PE32Header; | |||
274 | error(Obj->getPE32Header(PE32Header)); | |||
275 | ||||
276 | const pe32plus_header *PE32PlusHeader; | |||
277 | error(Obj->getPE32PlusHeader(PE32PlusHeader)); | |||
278 | ||||
279 | // Skip if it's not executable. | |||
280 | if (!PE32Header && !PE32PlusHeader) | |||
281 | return; | |||
282 | ||||
283 | const data_directory *DataDir; | |||
284 | error(Obj->getDataDirectory(COFF::TLS_TABLE, DataDir)); | |||
285 | uintptr_t IntPtr = 0; | |||
286 | if (DataDir->RelativeVirtualAddress == 0) | |||
287 | return; | |||
288 | error(Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr)); | |||
289 | ||||
290 | if (PE32Header) { | |||
291 | auto *TLSDir = reinterpret_cast<const coff_tls_directory32 *>(IntPtr); | |||
292 | printTLSDirectoryT(TLSDir); | |||
293 | } else { | |||
294 | auto *TLSDir = reinterpret_cast<const coff_tls_directory64 *>(IntPtr); | |||
295 | printTLSDirectoryT(TLSDir); | |||
296 | } | |||
297 | ||||
298 | outs() << "\n"; | |||
299 | } | |||
300 | ||||
301 | static void printLoadConfiguration(const COFFObjectFile *Obj) { | |||
302 | // Skip if it's not executable. | |||
303 | const pe32_header *PE32Header; | |||
304 | error(Obj->getPE32Header(PE32Header)); | |||
305 | if (!PE32Header) | |||
306 | return; | |||
307 | ||||
308 | // Currently only x86 is supported | |||
309 | if (Obj->getMachine() != COFF::IMAGE_FILE_MACHINE_I386) | |||
310 | return; | |||
311 | ||||
312 | const data_directory *DataDir; | |||
313 | error(Obj->getDataDirectory(COFF::LOAD_CONFIG_TABLE, DataDir)); | |||
314 | uintptr_t IntPtr = 0; | |||
315 | if (DataDir->RelativeVirtualAddress == 0) | |||
316 | return; | |||
317 | error(Obj->getRvaPtr(DataDir->RelativeVirtualAddress, IntPtr)); | |||
318 | ||||
319 | auto *LoadConf = reinterpret_cast<const coff_load_configuration32 *>(IntPtr); | |||
320 | outs() << "Load configuration:" | |||
321 | << "\n Timestamp: " << LoadConf->TimeDateStamp | |||
322 | << "\n Major Version: " << LoadConf->MajorVersion | |||
323 | << "\n Minor Version: " << LoadConf->MinorVersion | |||
324 | << "\n GlobalFlags Clear: " << LoadConf->GlobalFlagsClear | |||
325 | << "\n GlobalFlags Set: " << LoadConf->GlobalFlagsSet | |||
326 | << "\n Critical Section Default Timeout: " << LoadConf->CriticalSectionDefaultTimeout | |||
327 | << "\n Decommit Free Block Threshold: " << LoadConf->DeCommitFreeBlockThreshold | |||
328 | << "\n Decommit Total Free Threshold: " << LoadConf->DeCommitTotalFreeThreshold | |||
329 | << "\n Lock Prefix Table: " << LoadConf->LockPrefixTable | |||
330 | << "\n Maximum Allocation Size: " << LoadConf->MaximumAllocationSize | |||
331 | << "\n Virtual Memory Threshold: " << LoadConf->VirtualMemoryThreshold | |||
332 | << "\n Process Affinity Mask: " << LoadConf->ProcessAffinityMask | |||
333 | << "\n Process Heap Flags: " << LoadConf->ProcessHeapFlags | |||
334 | << "\n CSD Version: " << LoadConf->CSDVersion | |||
335 | << "\n Security Cookie: " << LoadConf->SecurityCookie | |||
336 | << "\n SEH Table: " << LoadConf->SEHandlerTable | |||
337 | << "\n SEH Count: " << LoadConf->SEHandlerCount | |||
338 | << "\n\n"; | |||
339 | printSEHTable(Obj, LoadConf->SEHandlerTable, LoadConf->SEHandlerCount); | |||
340 | outs() << "\n"; | |||
341 | } | |||
342 | ||||
343 | // Prints import tables. The import table is a table containing the list of | |||
344 | // DLL name and symbol names which will be linked by the loader. | |||
345 | static void printImportTables(const COFFObjectFile *Obj) { | |||
346 | import_directory_iterator I = Obj->import_directory_begin(); | |||
347 | import_directory_iterator E = Obj->import_directory_end(); | |||
348 | if (I == E) | |||
349 | return; | |||
350 | outs() << "The Import Tables:\n"; | |||
351 | for (const ImportDirectoryEntryRef &DirRef : Obj->import_directories()) { | |||
352 | const coff_import_directory_table_entry *Dir; | |||
353 | StringRef Name; | |||
354 | if (DirRef.getImportTableEntry(Dir)) return; | |||
355 | if (DirRef.getName(Name)) return; | |||
356 | ||||
357 | outs() << format(" lookup %08x time %08x fwd %08x name %08x addr %08x\n\n", | |||
358 | static_cast<uint32_t>(Dir->ImportLookupTableRVA), | |||
359 | static_cast<uint32_t>(Dir->TimeDateStamp), | |||
360 | static_cast<uint32_t>(Dir->ForwarderChain), | |||
361 | static_cast<uint32_t>(Dir->NameRVA), | |||
362 | static_cast<uint32_t>(Dir->ImportAddressTableRVA)); | |||
363 | outs() << " DLL Name: " << Name << "\n"; | |||
364 | outs() << " Hint/Ord Name\n"; | |||
365 | for (const ImportedSymbolRef &Entry : DirRef.imported_symbols()) { | |||
366 | bool IsOrdinal; | |||
367 | if (Entry.isOrdinal(IsOrdinal)) | |||
368 | return; | |||
369 | if (IsOrdinal) { | |||
370 | uint16_t Ordinal; | |||
371 | if (Entry.getOrdinal(Ordinal)) | |||
372 | return; | |||
373 | outs() << format(" % 6d\n", Ordinal); | |||
374 | continue; | |||
375 | } | |||
376 | uint32_t HintNameRVA; | |||
377 | if (Entry.getHintNameRVA(HintNameRVA)) | |||
378 | return; | |||
379 | uint16_t Hint; | |||
380 | StringRef Name; | |||
381 | if (Obj->getHintName(HintNameRVA, Hint, Name)) | |||
382 | return; | |||
383 | outs() << format(" % 6d ", Hint) << Name << "\n"; | |||
384 | } | |||
385 | outs() << "\n"; | |||
386 | } | |||
387 | } | |||
388 | ||||
389 | // Prints export tables. The export table is a table containing the list of | |||
390 | // exported symbol from the DLL. | |||
391 | static void printExportTable(const COFFObjectFile *Obj) { | |||
392 | outs() << "Export Table:\n"; | |||
393 | export_directory_iterator I = Obj->export_directory_begin(); | |||
394 | export_directory_iterator E = Obj->export_directory_end(); | |||
395 | if (I == E) | |||
396 | return; | |||
397 | StringRef DllName; | |||
398 | uint32_t OrdinalBase; | |||
399 | if (I->getDllName(DllName)) | |||
400 | return; | |||
401 | if (I->getOrdinalBase(OrdinalBase)) | |||
402 | return; | |||
403 | outs() << " DLL name: " << DllName << "\n"; | |||
404 | outs() << " Ordinal base: " << OrdinalBase << "\n"; | |||
405 | outs() << " Ordinal RVA Name\n"; | |||
406 | for (; I != E; I = ++I) { | |||
407 | uint32_t Ordinal; | |||
408 | if (I->getOrdinal(Ordinal)) | |||
409 | return; | |||
410 | uint32_t RVA; | |||
411 | if (I->getExportRVA(RVA)) | |||
412 | return; | |||
413 | bool IsForwarder; | |||
414 | if (I->isForwarder(IsForwarder)) | |||
415 | return; | |||
416 | ||||
417 | if (IsForwarder) { | |||
418 | // Export table entries can be used to re-export symbols that | |||
419 | // this COFF file is imported from some DLLs. This is rare. | |||
420 | // In most cases IsForwarder is false. | |||
421 | outs() << format(" % 4d ", Ordinal); | |||
422 | } else { | |||
423 | outs() << format(" % 4d %# 8x", Ordinal, RVA); | |||
424 | } | |||
425 | ||||
426 | StringRef Name; | |||
427 | if (I->getSymbolName(Name)) | |||
428 | continue; | |||
429 | if (!Name.empty()) | |||
430 | outs() << " " << Name; | |||
431 | if (IsForwarder) { | |||
432 | StringRef S; | |||
433 | if (I->getForwardTo(S)) | |||
434 | return; | |||
435 | outs() << " (forwarded to " << S << ")"; | |||
436 | } | |||
437 | outs() << "\n"; | |||
438 | } | |||
439 | } | |||
440 | ||||
441 | // Given the COFF object file, this function returns the relocations for .pdata | |||
442 | // and the pointer to "runtime function" structs. | |||
443 | static bool getPDataSection(const COFFObjectFile *Obj, | |||
444 | std::vector<RelocationRef> &Rels, | |||
445 | const RuntimeFunction *&RFStart, int &NumRFs) { | |||
446 | for (const SectionRef &Section : Obj->sections()) { | |||
447 | StringRef Name; | |||
448 | error(Section.getName(Name)); | |||
449 | if (Name != ".pdata") | |||
450 | continue; | |||
451 | ||||
452 | const coff_section *Pdata = Obj->getCOFFSection(Section); | |||
453 | for (const RelocationRef &Reloc : Section.relocations()) | |||
454 | Rels.push_back(Reloc); | |||
455 | ||||
456 | // Sort relocations by address. | |||
457 | llvm::sort(Rels, RelocAddressLess); | |||
458 | ||||
459 | ArrayRef<uint8_t> Contents; | |||
460 | error(Obj->getSectionContents(Pdata, Contents)); | |||
461 | if (Contents.empty()) | |||
462 | continue; | |||
463 | ||||
464 | RFStart = reinterpret_cast<const RuntimeFunction *>(Contents.data()); | |||
465 | NumRFs = Contents.size() / sizeof(RuntimeFunction); | |||
466 | return true; | |||
467 | } | |||
468 | return false; | |||
469 | } | |||
470 | ||||
471 | static void printWin64EHUnwindInfo(const Win64EH::UnwindInfo *UI) { | |||
472 | // The casts to int are required in order to output the value as number. | |||
473 | // Without the casts the value would be interpreted as char data (which | |||
474 | // results in garbage output). | |||
475 | outs() << " Version: " << static_cast<int>(UI->getVersion()) << "\n"; | |||
476 | outs() << " Flags: " << static_cast<int>(UI->getFlags()); | |||
477 | if (UI->getFlags()) { | |||
478 | if (UI->getFlags() & UNW_ExceptionHandler) | |||
479 | outs() << " UNW_ExceptionHandler"; | |||
480 | if (UI->getFlags() & UNW_TerminateHandler) | |||
481 | outs() << " UNW_TerminateHandler"; | |||
482 | if (UI->getFlags() & UNW_ChainInfo) | |||
483 | outs() << " UNW_ChainInfo"; | |||
484 | } | |||
485 | outs() << "\n"; | |||
486 | outs() << " Size of prolog: " << static_cast<int>(UI->PrologSize) << "\n"; | |||
487 | outs() << " Number of Codes: " << static_cast<int>(UI->NumCodes) << "\n"; | |||
488 | // Maybe this should move to output of UOP_SetFPReg? | |||
489 | if (UI->getFrameRegister()) { | |||
490 | outs() << " Frame register: " | |||
491 | << getUnwindRegisterName(UI->getFrameRegister()) << "\n"; | |||
492 | outs() << " Frame offset: " << 16 * UI->getFrameOffset() << "\n"; | |||
493 | } else { | |||
494 | outs() << " No frame pointer used\n"; | |||
495 | } | |||
496 | if (UI->getFlags() & (UNW_ExceptionHandler | UNW_TerminateHandler)) { | |||
497 | // FIXME: Output exception handler data | |||
498 | } else if (UI->getFlags() & UNW_ChainInfo) { | |||
499 | // FIXME: Output chained unwind info | |||
500 | } | |||
501 | ||||
502 | if (UI->NumCodes) | |||
503 | outs() << " Unwind Codes:\n"; | |||
504 | ||||
505 | printAllUnwindCodes(makeArrayRef(&UI->UnwindCodes[0], UI->NumCodes)); | |||
506 | ||||
507 | outs() << "\n"; | |||
508 | outs().flush(); | |||
509 | } | |||
510 | ||||
511 | /// Prints out the given RuntimeFunction struct for x64, assuming that Obj is | |||
512 | /// pointing to an executable file. | |||
513 | static void printRuntimeFunction(const COFFObjectFile *Obj, | |||
514 | const RuntimeFunction &RF) { | |||
515 | if (!RF.StartAddress) | |||
516 | return; | |||
517 | outs() << "Function Table:\n" | |||
518 | << format(" Start Address: 0x%04x\n", | |||
519 | static_cast<uint32_t>(RF.StartAddress)) | |||
520 | << format(" End Address: 0x%04x\n", | |||
521 | static_cast<uint32_t>(RF.EndAddress)) | |||
522 | << format(" Unwind Info Address: 0x%04x\n", | |||
523 | static_cast<uint32_t>(RF.UnwindInfoOffset)); | |||
524 | uintptr_t addr; | |||
525 | if (Obj->getRvaPtr(RF.UnwindInfoOffset, addr)) | |||
526 | return; | |||
527 | printWin64EHUnwindInfo(reinterpret_cast<const Win64EH::UnwindInfo *>(addr)); | |||
528 | } | |||
529 | ||||
530 | /// Prints out the given RuntimeFunction struct for x64, assuming that Obj is | |||
531 | /// pointing to an object file. Unlike executable, fields in RuntimeFunction | |||
532 | /// struct are filled with zeros, but instead there are relocations pointing to | |||
533 | /// them so that the linker will fill targets' RVAs to the fields at link | |||
534 | /// time. This function interprets the relocations to find the data to be used | |||
535 | /// in the resulting executable. | |||
536 | static void printRuntimeFunctionRels(const COFFObjectFile *Obj, | |||
537 | const RuntimeFunction &RF, | |||
538 | uint64_t SectionOffset, | |||
539 | const std::vector<RelocationRef> &Rels) { | |||
540 | outs() << "Function Table:\n"; | |||
541 | outs() << " Start Address: "; | |||
542 | printCOFFSymbolAddress(outs(), Rels, | |||
543 | SectionOffset + | |||
544 | /*offsetof(RuntimeFunction, StartAddress)*/ 0, | |||
545 | RF.StartAddress); | |||
546 | outs() << "\n"; | |||
547 | ||||
548 | outs() << " End Address: "; | |||
549 | printCOFFSymbolAddress(outs(), Rels, | |||
550 | SectionOffset + | |||
551 | /*offsetof(RuntimeFunction, EndAddress)*/ 4, | |||
552 | RF.EndAddress); | |||
553 | outs() << "\n"; | |||
554 | ||||
555 | outs() << " Unwind Info Address: "; | |||
556 | printCOFFSymbolAddress(outs(), Rels, | |||
557 | SectionOffset + | |||
558 | /*offsetof(RuntimeFunction, UnwindInfoOffset)*/ 8, | |||
559 | RF.UnwindInfoOffset); | |||
560 | outs() << "\n"; | |||
561 | ||||
562 | ArrayRef<uint8_t> XContents; | |||
563 | uint64_t UnwindInfoOffset = 0; | |||
564 | error(getSectionContents( | |||
565 | Obj, Rels, SectionOffset + | |||
566 | /*offsetof(RuntimeFunction, UnwindInfoOffset)*/ 8, | |||
567 | XContents, UnwindInfoOffset)); | |||
568 | if (XContents.empty()) | |||
569 | return; | |||
570 | ||||
571 | UnwindInfoOffset += RF.UnwindInfoOffset; | |||
572 | if (UnwindInfoOffset > XContents.size()) | |||
573 | return; | |||
574 | ||||
575 | auto *UI = reinterpret_cast<const Win64EH::UnwindInfo *>(XContents.data() + | |||
576 | UnwindInfoOffset); | |||
577 | printWin64EHUnwindInfo(UI); | |||
578 | } | |||
579 | ||||
580 | void llvm::printCOFFUnwindInfo(const COFFObjectFile *Obj) { | |||
581 | if (Obj->getMachine() != COFF::IMAGE_FILE_MACHINE_AMD64) { | |||
| ||||
582 | errs() << "Unsupported image machine type " | |||
583 | "(currently only AMD64 is supported).\n"; | |||
584 | return; | |||
585 | } | |||
586 | ||||
587 | std::vector<RelocationRef> Rels; | |||
588 | const RuntimeFunction *RFStart; | |||
589 | int NumRFs; | |||
590 | if (!getPDataSection(Obj, Rels, RFStart, NumRFs)) | |||
591 | return; | |||
592 | ArrayRef<RuntimeFunction> RFs(RFStart, NumRFs); | |||
593 | ||||
594 | bool IsExecutable = Rels.empty(); | |||
595 | if (IsExecutable) { | |||
596 | for (const RuntimeFunction &RF : RFs) | |||
597 | printRuntimeFunction(Obj, RF); | |||
598 | return; | |||
599 | } | |||
600 | ||||
601 | for (const RuntimeFunction &RF : RFs) { | |||
602 | uint64_t SectionOffset = | |||
603 | std::distance(RFs.begin(), &RF) * sizeof(RuntimeFunction); | |||
604 | printRuntimeFunctionRels(Obj, RF, SectionOffset, Rels); | |||
605 | } | |||
606 | } | |||
607 | ||||
608 | void llvm::printCOFFFileHeader(const object::ObjectFile *Obj) { | |||
609 | const COFFObjectFile *file = dyn_cast<const COFFObjectFile>(Obj); | |||
610 | printTLSDirectory(file); | |||
611 | printLoadConfiguration(file); | |||
612 | printImportTables(file); | |||
613 | printExportTable(file); | |||
614 | } | |||
615 | ||||
616 | void llvm::printCOFFSymbolTable(const object::COFFImportFile *i) { | |||
617 | unsigned Index = 0; | |||
618 | bool IsCode = i->getCOFFImportHeader()->getType() == COFF::IMPORT_CODE; | |||
619 | ||||
620 | for (const object::BasicSymbolRef &Sym : i->symbols()) { | |||
621 | std::string Name; | |||
622 | raw_string_ostream NS(Name); | |||
623 | ||||
624 | Sym.printName(NS); | |||
625 | NS.flush(); | |||
626 | ||||
627 | outs() << "[" << format("%2d", Index) << "]" | |||
628 | << "(sec " << format("%2d", 0) << ")" | |||
629 | << "(fl 0x00)" // Flag bits, which COFF doesn't have. | |||
630 | << "(ty " << format("%3x", (IsCode && Index) ? 32 : 0) << ")" | |||
631 | << "(scl " << format("%3x", 0) << ") " | |||
632 | << "(nx " << 0 << ") " | |||
633 | << "0x" << format("%08x", 0) << " " << Name << '\n'; | |||
634 | ||||
635 | ++Index; | |||
636 | } | |||
637 | } | |||
638 | ||||
639 | void llvm::printCOFFSymbolTable(const COFFObjectFile *coff) { | |||
640 | for (unsigned SI = 0, SE = coff->getNumberOfSymbols(); SI != SE; ++SI) { | |||
641 | Expected<COFFSymbolRef> Symbol = coff->getSymbol(SI); | |||
642 | StringRef Name; | |||
643 | error(errorToErrorCode(Symbol.takeError())); | |||
644 | error(coff->getSymbolName(*Symbol, Name)); | |||
645 | ||||
646 | outs() << "[" << format("%2d", SI) << "]" | |||
647 | << "(sec " << format("%2d", int(Symbol->getSectionNumber())) << ")" | |||
648 | << "(fl 0x00)" // Flag bits, which COFF doesn't have. | |||
649 | << "(ty " << format("%3x", unsigned(Symbol->getType())) << ")" | |||
650 | << "(scl " << format("%3x", unsigned(Symbol->getStorageClass())) | |||
651 | << ") " | |||
652 | << "(nx " << unsigned(Symbol->getNumberOfAuxSymbols()) << ") " | |||
653 | << "0x" << format("%08x", unsigned(Symbol->getValue())) << " " | |||
654 | << Name; | |||
655 | if (Demangle && Name.startswith("?")) { | |||
656 | char *DemangledSymbol = nullptr; | |||
657 | size_t Size = 0; | |||
658 | int Status = -1; | |||
659 | DemangledSymbol = | |||
660 | microsoftDemangle(Name.data(), DemangledSymbol, &Size, &Status); | |||
661 | ||||
662 | if (Status == 0 && DemangledSymbol) { | |||
663 | outs() << " (" << StringRef(DemangledSymbol) << ")"; | |||
664 | std::free(DemangledSymbol); | |||
665 | } else { | |||
666 | outs() << " (invalid mangled name)"; | |||
667 | } | |||
668 | } | |||
669 | outs() << "\n"; | |||
670 | ||||
671 | for (unsigned AI = 0, AE = Symbol->getNumberOfAuxSymbols(); AI < AE; ++AI, ++SI) { | |||
672 | if (Symbol->isSectionDefinition()) { | |||
673 | const coff_aux_section_definition *asd; | |||
674 | error(coff->getAuxSymbol<coff_aux_section_definition>(SI + 1, asd)); | |||
675 | ||||
676 | int32_t AuxNumber = asd->getNumber(Symbol->isBigObj()); | |||
677 | ||||
678 | outs() << "AUX " | |||
679 | << format("scnlen 0x%x nreloc %d nlnno %d checksum 0x%x " | |||
680 | , unsigned(asd->Length) | |||
681 | , unsigned(asd->NumberOfRelocations) | |||
682 | , unsigned(asd->NumberOfLinenumbers) | |||
683 | , unsigned(asd->CheckSum)) | |||
684 | << format("assoc %d comdat %d\n" | |||
685 | , unsigned(AuxNumber) | |||
686 | , unsigned(asd->Selection)); | |||
687 | } else if (Symbol->isFileRecord()) { | |||
688 | const char *FileName; | |||
689 | error(coff->getAuxSymbol<char>(SI + 1, FileName)); | |||
690 | ||||
691 | StringRef Name(FileName, Symbol->getNumberOfAuxSymbols() * | |||
692 | coff->getSymbolTableEntrySize()); | |||
693 | outs() << "AUX " << Name.rtrim(StringRef("\0", 1)) << '\n'; | |||
694 | ||||
695 | SI = SI + Symbol->getNumberOfAuxSymbols(); | |||
696 | break; | |||
697 | } else if (Symbol->isWeakExternal()) { | |||
698 | const coff_aux_weak_external *awe; | |||
699 | error(coff->getAuxSymbol<coff_aux_weak_external>(SI + 1, awe)); | |||
700 | ||||
701 | outs() << "AUX " << format("indx %d srch %d\n", | |||
702 | static_cast<uint32_t>(awe->TagIndex), | |||
703 | static_cast<uint32_t>(awe->Characteristics)); | |||
704 | } else { | |||
705 | outs() << "AUX Unknown\n"; | |||
706 | } | |||
707 | } | |||
708 | } | |||
709 | } |