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