xref: /freebsd/contrib/llvm-project/llvm/tools/llvm-readobj/Win64EHDumper.cpp (revision cfd6422a5217410fbd66f7a7a8a64d9d85e61229)
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 
16 using namespace llvm;
17 using namespace llvm::object;
18 using namespace llvm::Win64EH;
19 
20 static const EnumEntry<unsigned> UnwindFlags[] = {
21   { "ExceptionHandler", UNW_ExceptionHandler },
22   { "TerminateHandler", UNW_TerminateHandler },
23   { "ChainInfo"       , UNW_ChainInfo        }
24 };
25 
26 static 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 
45 static uint64_t getOffsetOfLSDA(const UnwindInfo& UI) {
46   return static_cast<const char*>(UI.getLanguageSpecificData())
47          - reinterpret_cast<const char*>(&UI);
48 }
49 
50 static 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.
57 static 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.
73 static 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.
96 static 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 
115 static 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 
129 static 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 
168 static 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 
190 static const object::coff_section *
191 getSectionContaining(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 
202 namespace llvm {
203 namespace Win64EH {
204 void 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.
219 void 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 
276 void 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 
320 void 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 
354 void 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