1//===- Win64EHDumper.cpp - Win64 EH Printer ---------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Win64EHDumper.h"
10#include "llvm-readobj.h"
11#include "llvm/Object/COFF.h"
12#include "llvm/Support/ErrorHandling.h"
13#include "llvm/Support/Format.h"
14
15using namespace llvm;
16using namespace llvm::object;
17using namespace llvm::Win64EH;
18
19const EnumEntry<unsigned> UnwindFlags[] = {
20 { "ExceptionHandler", UNW_ExceptionHandler },
21 { "TerminateHandler", UNW_TerminateHandler },
22 { "ChainInfo" , UNW_ChainInfo }
23};
24
25const EnumEntry<unsigned> UnwindOpInfo[] = {
26 { "RAX", 0 },
27 { "RCX", 1 },
28 { "RDX", 2 },
29 { "RBX", 3 },
30 { "RSP", 4 },
31 { "RBP", 5 },
32 { "RSI", 6 },
33 { "RDI", 7 },
34 { "R8", 8 },
35 { "R9", 9 },
36 { "R10", 10 },
37 { "R11", 11 },
38 { "R12", 12 },
39 { "R13", 13 },
40 { "R14", 14 },
41 { "R15", 15 }
42};
43
44static uint64_t getOffsetOfLSDA(const UnwindInfo& UI) {
45 return static_cast<const char*>(UI.getLanguageSpecificData())
46 - reinterpret_cast<const char*>(&UI);
47}
48
49static uint32_t getLargeSlotValue(ArrayRef<UnwindCode> UC) {
50 if (UC.size() < 3)
51 return 0;
52 return UC[1].FrameOffset + (static_cast<uint32_t>(UC[2].FrameOffset) << 16);
53}
54
55// Returns the name of the unwind code.
56static StringRef getUnwindCodeTypeName(uint8_t Code) {
57 switch (Code) {
58 default: llvm_unreachable("Invalid unwind code");
59 case UOP_PushNonVol: return "PUSH_NONVOL";
60 case UOP_AllocLarge: return "ALLOC_LARGE";
61 case UOP_AllocSmall: return "ALLOC_SMALL";
62 case UOP_SetFPReg: return "SET_FPREG";
63 case UOP_SaveNonVol: return "SAVE_NONVOL";
64 case UOP_SaveNonVolBig: return "SAVE_NONVOL_FAR";
65 case UOP_SaveXMM128: return "SAVE_XMM128";
66 case UOP_SaveXMM128Big: return "SAVE_XMM128_FAR";
67 case UOP_PushMachFrame: return "PUSH_MACHFRAME";
68 }
69}
70
71// Returns the name of a referenced register.
72static StringRef getUnwindRegisterName(uint8_t Reg) {
73 switch (Reg) {
74 default: llvm_unreachable("Invalid register");
75 case 0: return "RAX";
76 case 1: return "RCX";
77 case 2: return "RDX";
78 case 3: return "RBX";
79 case 4: return "RSP";
80 case 5: return "RBP";
81 case 6: return "RSI";
82 case 7: return "RDI";
83 case 8: return "R8";
84 case 9: return "R9";
85 case 10: return "R10";
86 case 11: return "R11";
87 case 12: return "R12";
88 case 13: return "R13";
89 case 14: return "R14";
90 case 15: return "R15";
91 }
92}
93
94// Calculates the number of array slots required for the unwind code.
95static unsigned getNumUsedSlots(const UnwindCode &UnwindCode) {
96 switch (UnwindCode.getUnwindOp()) {
97 default: llvm_unreachable("Invalid unwind code");
98 case UOP_PushNonVol:
99 case UOP_AllocSmall:
100 case UOP_SetFPReg:
101 case UOP_PushMachFrame:
102 return 1;
103 case UOP_SaveNonVol:
104 case UOP_SaveXMM128:
105 return 2;
106 case UOP_SaveNonVolBig:
107 case UOP_SaveXMM128Big:
108 return 3;
109 case UOP_AllocLarge:
110 return (UnwindCode.getOpInfo() == 0) ? 2 : 3;
111 }
112}
113
114static std::error_code getSymbol(const COFFObjectFile &COFF, uint64_t VA,
115 object::SymbolRef &Sym) {
116 for (const auto &Symbol : COFF.symbols()) {
117 Expected<uint64_t> Address = Symbol.getAddress();
118 if (!Address)
119 return errorToErrorCode(Err: Address.takeError());
120 if (*Address == VA) {
121 Sym = Symbol;
122 return std::error_code();
123 }
124 }
125 return inconvertibleErrorCode();
126}
127
128static object::SymbolRef getPreferredSymbol(const COFFObjectFile &COFF,
129 object::SymbolRef Sym,
130 uint32_t &SymbolOffset,
131 bool IsRangeEnd) {
132 // The symbol resolved by ResolveSymbol can be any internal
133 // nondescriptive symbol; try to resolve a more descriptive one.
134 COFFSymbolRef CoffSym = COFF.getCOFFSymbol(Symbol: Sym);
135 if (CoffSym.getStorageClass() != COFF::IMAGE_SYM_CLASS_LABEL &&
136 CoffSym.getSectionDefinition() == nullptr)
137 return Sym;
138 for (const auto &S : COFF.symbols()) {
139 COFFSymbolRef CS = COFF.getCOFFSymbol(Symbol: S);
140 if (CS.getSectionNumber() == CoffSym.getSectionNumber() &&
141 CS.getValue() <= CoffSym.getValue() + SymbolOffset &&
142 CS.getStorageClass() != COFF::IMAGE_SYM_CLASS_LABEL &&
143 CS.getSectionDefinition() == nullptr) {
144 uint32_t Offset = CoffSym.getValue() + SymbolOffset - CS.getValue();
145 // For the end of a range, don't pick a symbol with a zero offset;
146 // prefer a symbol with a small positive offset.
147 if (Offset <= SymbolOffset && (!IsRangeEnd || Offset > 0)) {
148 SymbolOffset = Offset;
149 Sym = S;
150 CoffSym = CS;
151 if (CS.isExternal() && SymbolOffset == 0)
152 return Sym;
153 }
154 }
155 }
156 return Sym;
157}
158
159static std::string formatSymbol(const Dumper::Context &Ctx,
160 const coff_section *Section, uint64_t Offset,
161 uint32_t Displacement,
162 bool IsRangeEnd = false) {
163 std::string Buffer;
164 raw_string_ostream OS(Buffer);
165
166 SymbolRef Symbol;
167 if (!Ctx.ResolveSymbol(Section, Offset, Symbol, Ctx.UserData)) {
168 // We found a relocation at the given offset in the section, pointing
169 // at a symbol.
170
171 // Try to resolve label/section symbols into function names.
172 Symbol = getPreferredSymbol(COFF: Ctx.COFF, Sym: Symbol, SymbolOffset&: Displacement, IsRangeEnd);
173
174 Expected<StringRef> Name = Symbol.getName();
175 if (Name) {
176 OS << *Name;
177 if (Displacement > 0)
178 OS << format(Fmt: " +0x%X (0x%" PRIX64 ")", Vals: Displacement, Vals: Offset);
179 else
180 OS << format(Fmt: " (0x%" PRIX64 ")", Vals: Offset);
181 return OS.str();
182 } else {
183 // TODO: Actually report errors helpfully.
184 consumeError(Err: Name.takeError());
185 }
186 } else if (!getSymbol(COFF: Ctx.COFF, VA: Ctx.COFF.getImageBase() + Displacement,
187 Sym&: Symbol)) {
188 Expected<StringRef> Name = Symbol.getName();
189 if (Name) {
190 OS << *Name;
191 OS << format(Fmt: " (0x%" PRIX64 ")", Vals: Ctx.COFF.getImageBase() + Displacement);
192 return OS.str();
193 } else {
194 consumeError(Err: Name.takeError());
195 }
196 }
197
198 if (Displacement > 0)
199 OS << format(Fmt: "(0x%" PRIX64 ")", Vals: Ctx.COFF.getImageBase() + Displacement);
200 else
201 OS << format(Fmt: "(0x%" PRIX64 ")", Vals: Offset);
202 return OS.str();
203}
204
205static std::error_code resolveRelocation(const Dumper::Context &Ctx,
206 const coff_section *Section,
207 uint64_t Offset,
208 const coff_section *&ResolvedSection,
209 uint64_t &ResolvedAddress) {
210 SymbolRef Symbol;
211 if (std::error_code EC =
212 Ctx.ResolveSymbol(Section, Offset, Symbol, Ctx.UserData))
213 return EC;
214
215 Expected<uint64_t> ResolvedAddressOrErr = Symbol.getAddress();
216 if (!ResolvedAddressOrErr)
217 return errorToErrorCode(Err: ResolvedAddressOrErr.takeError());
218 ResolvedAddress = *ResolvedAddressOrErr;
219
220 Expected<section_iterator> SI = Symbol.getSection();
221 if (!SI)
222 return errorToErrorCode(Err: SI.takeError());
223 ResolvedSection = Ctx.COFF.getCOFFSection(Section: **SI);
224 return std::error_code();
225}
226
227static const object::coff_section *
228getSectionContaining(const COFFObjectFile &COFF, uint64_t VA) {
229 for (const auto &Section : COFF.sections()) {
230 uint64_t Address = Section.getAddress();
231 uint64_t Size = Section.getSize();
232
233 if (VA >= Address && (VA - Address) <= Size)
234 return COFF.getCOFFSection(Section);
235 }
236 return nullptr;
237}
238
239namespace llvm {
240namespace Win64EH {
241void Dumper::printRuntimeFunctionEntry(const Context &Ctx,
242 const coff_section *Section,
243 uint64_t Offset,
244 const RuntimeFunction &RF) {
245 SW.printString(Label: "StartAddress",
246 Value: formatSymbol(Ctx, Section, Offset: Offset + 0, Displacement: RF.StartAddress));
247 SW.printString(Label: "EndAddress",
248 Value: formatSymbol(Ctx, Section, Offset: Offset + 4, Displacement: RF.EndAddress,
249 /*IsRangeEnd=*/true));
250 SW.printString(Label: "UnwindInfoAddress",
251 Value: formatSymbol(Ctx, Section, Offset: Offset + 8, Displacement: RF.UnwindInfoOffset));
252}
253
254// Prints one unwind code. Because an unwind code can occupy up to 3 slots in
255// the unwind codes array, this function requires that the correct number of
256// slots is provided.
257void Dumper::printUnwindCode(const UnwindInfo& UI, ArrayRef<UnwindCode> UC) {
258 assert(UC.size() >= getNumUsedSlots(UC[0]));
259
260 SW.startLine() << format(Fmt: "0x%02X: ", Vals: unsigned(UC[0].u.CodeOffset))
261 << getUnwindCodeTypeName(Code: UC[0].getUnwindOp());
262
263 switch (UC[0].getUnwindOp()) {
264 case UOP_PushNonVol:
265 OS << " reg=" << getUnwindRegisterName(Reg: UC[0].getOpInfo());
266 break;
267
268 case UOP_AllocLarge:
269 OS << " size="
270 << ((UC[0].getOpInfo() == 0) ? UC[1].FrameOffset * 8
271 : getLargeSlotValue(UC));
272 break;
273
274 case UOP_AllocSmall:
275 OS << " size=" << (UC[0].getOpInfo() + 1) * 8;
276 break;
277
278 case UOP_SetFPReg:
279 if (UI.getFrameRegister() == 0)
280 OS << " reg=<invalid>";
281 else
282 OS << " reg=" << getUnwindRegisterName(Reg: UI.getFrameRegister())
283 << format(Fmt: ", offset=0x%X", Vals: UI.getFrameOffset() * 16);
284 break;
285
286 case UOP_SaveNonVol:
287 OS << " reg=" << getUnwindRegisterName(Reg: UC[0].getOpInfo())
288 << format(Fmt: ", offset=0x%X", Vals: UC[1].FrameOffset * 8);
289 break;
290
291 case UOP_SaveNonVolBig:
292 OS << " reg=" << getUnwindRegisterName(Reg: UC[0].getOpInfo())
293 << format(Fmt: ", offset=0x%X", Vals: getLargeSlotValue(UC));
294 break;
295
296 case UOP_SaveXMM128:
297 OS << " reg=XMM" << static_cast<uint32_t>(UC[0].getOpInfo())
298 << format(Fmt: ", offset=0x%X", Vals: UC[1].FrameOffset * 16);
299 break;
300
301 case UOP_SaveXMM128Big:
302 OS << " reg=XMM" << static_cast<uint32_t>(UC[0].getOpInfo())
303 << format(Fmt: ", offset=0x%X", Vals: getLargeSlotValue(UC));
304 break;
305
306 case UOP_PushMachFrame:
307 OS << " errcode=" << (UC[0].getOpInfo() == 0 ? "no" : "yes");
308 break;
309 }
310
311 OS << "\n";
312}
313
314void Dumper::printUnwindInfo(const Context &Ctx, const coff_section *Section,
315 off_t Offset, const UnwindInfo &UI) {
316 DictScope UIS(SW, "UnwindInfo");
317 SW.printNumber(Label: "Version", Value: UI.getVersion());
318 SW.printFlags(Label: "Flags", Value: UI.getFlags(), Flags: ArrayRef(UnwindFlags));
319 SW.printNumber(Label: "PrologSize", Value: UI.PrologSize);
320 if (UI.getFrameRegister()) {
321 SW.printEnum(Label: "FrameRegister", Value: UI.getFrameRegister(),
322 EnumValues: ArrayRef(UnwindOpInfo));
323 SW.printHex(Label: "FrameOffset", Value: UI.getFrameOffset());
324 } else {
325 SW.printString(Label: "FrameRegister", Value: StringRef("-"));
326 SW.printString(Label: "FrameOffset", Value: StringRef("-"));
327 }
328
329 SW.printNumber(Label: "UnwindCodeCount", Value: UI.NumCodes);
330 {
331 ListScope UCS(SW, "UnwindCodes");
332 ArrayRef<UnwindCode> UC(&UI.UnwindCodes[0], UI.NumCodes);
333 for (const UnwindCode *UCI = UC.begin(), *UCE = UC.end(); UCI < UCE; ++UCI) {
334 unsigned UsedSlots = getNumUsedSlots(UnwindCode: *UCI);
335 if (UsedSlots > UC.size()) {
336 errs() << "corrupt unwind data";
337 return;
338 }
339
340 printUnwindCode(UI, UC: ArrayRef(UCI, UCE));
341 UCI = UCI + UsedSlots - 1;
342 }
343 }
344
345 uint64_t LSDAOffset = Offset + getOffsetOfLSDA(UI);
346 if (UI.getFlags() & (UNW_ExceptionHandler | UNW_TerminateHandler)) {
347 SW.printString(Label: "Handler",
348 Value: formatSymbol(Ctx, Section, Offset: LSDAOffset,
349 Displacement: UI.getLanguageSpecificHandlerOffset()));
350 } else if (UI.getFlags() & UNW_ChainInfo) {
351 if (const RuntimeFunction *Chained = UI.getChainedFunctionEntry()) {
352 DictScope CS(SW, "Chained");
353 printRuntimeFunctionEntry(Ctx, Section, Offset: LSDAOffset, RF: *Chained);
354 }
355 }
356}
357
358void Dumper::printRuntimeFunction(const Context &Ctx,
359 const coff_section *Section,
360 uint64_t SectionOffset,
361 const RuntimeFunction &RF) {
362 DictScope RFS(SW, "RuntimeFunction");
363 printRuntimeFunctionEntry(Ctx, Section, Offset: SectionOffset, RF);
364
365 const coff_section *XData = nullptr;
366 uint64_t Offset;
367 resolveRelocation(Ctx, Section, Offset: SectionOffset + 8, ResolvedSection&: XData, ResolvedAddress&: Offset);
368 Offset = Offset + RF.UnwindInfoOffset;
369
370 if (!XData) {
371 uint64_t Address = Ctx.COFF.getImageBase() + RF.UnwindInfoOffset;
372 XData = getSectionContaining(COFF: Ctx.COFF, VA: Address);
373 if (!XData)
374 return;
375 Offset = RF.UnwindInfoOffset - XData->VirtualAddress;
376 }
377
378 ArrayRef<uint8_t> Contents;
379 if (Error E = Ctx.COFF.getSectionContents(Sec: XData, Res&: Contents))
380 reportError(Err: std::move(E), Input: Ctx.COFF.getFileName());
381
382 if (Contents.empty())
383 return;
384
385 if (Offset > Contents.size())
386 return;
387
388 const auto UI = reinterpret_cast<const UnwindInfo*>(Contents.data() + Offset);
389 printUnwindInfo(Ctx, Section: XData, Offset, UI: *UI);
390}
391
392void Dumper::printData(const Context &Ctx) {
393 for (const auto &Section : Ctx.COFF.sections()) {
394 StringRef Name;
395 if (Expected<StringRef> NameOrErr = Section.getName())
396 Name = *NameOrErr;
397 else
398 consumeError(Err: NameOrErr.takeError());
399
400 if (Name != ".pdata" && !Name.starts_with(Prefix: ".pdata$"))
401 continue;
402
403 const coff_section *PData = Ctx.COFF.getCOFFSection(Section);
404 ArrayRef<uint8_t> Contents;
405
406 if (Error E = Ctx.COFF.getSectionContents(Sec: PData, Res&: Contents))
407 reportError(Err: std::move(E), Input: Ctx.COFF.getFileName());
408 if (Contents.empty())
409 continue;
410
411 const RuntimeFunction *Entries =
412 reinterpret_cast<const RuntimeFunction *>(Contents.data());
413 const size_t Count = Contents.size() / sizeof(RuntimeFunction);
414 ArrayRef<RuntimeFunction> RuntimeFunctions(Entries, Count);
415
416 size_t Index = 0;
417 for (const auto &RF : RuntimeFunctions) {
418 printRuntimeFunction(Ctx, Section: Ctx.COFF.getCOFFSection(Section),
419 SectionOffset: Index * sizeof(RuntimeFunction), RF);
420 ++Index;
421 }
422 }
423}
424}
425}
426
427

source code of llvm/tools/llvm-readobj/Win64EHDumper.cpp