1 //===- Win64EHDumper.cpp - Win64 EH Printer ---------------------*- 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 #include "Win64EHDumper.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
getOffsetOfLSDA(const UnwindInfo & UI)45 static uint64_t getOffsetOfLSDA(const UnwindInfo& UI) {
46 return static_cast<const char*>(UI.getLanguageSpecificData())
47 - reinterpret_cast<const char*>(&UI);
48 }
49
getLargeSlotValue(ArrayRef<UnwindCode> UC)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.
getUnwindCodeTypeName(uint8_t 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.
getUnwindRegisterName(uint8_t Reg)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.
getNumUsedSlots(const UnwindCode & UnwindCode)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
formatSymbol(const Dumper::Context & Ctx,const coff_section * Section,uint64_t Offset,uint32_t Displacement)115 static std::string formatSymbol(const Dumper::Context &Ctx,
116 const coff_section *Section, uint64_t Offset,
117 uint32_t Displacement) {
118 std::string Buffer;
119 raw_string_ostream OS(Buffer);
120
121 SymbolRef Symbol;
122 if (!Ctx.ResolveSymbol(Section, Offset, Symbol, Ctx.UserData)) {
123 if (ErrorOr<StringRef> Name = Symbol.getName()) {
124 OS << *Name;
125 if (Displacement > 0)
126 OS << format(" +0x%X (0x%" PRIX64 ")", Displacement, Offset);
127 else
128 OS << format(" (0x%" PRIX64 ")", Offset);
129 return OS.str();
130 }
131 }
132
133 OS << format(" (0x%" PRIX64 ")", Offset);
134 return OS.str();
135 }
136
resolveRelocation(const Dumper::Context & Ctx,const coff_section * Section,uint64_t Offset,const coff_section * & ResolvedSection,uint64_t & ResolvedAddress)137 static std::error_code resolveRelocation(const Dumper::Context &Ctx,
138 const coff_section *Section,
139 uint64_t Offset,
140 const coff_section *&ResolvedSection,
141 uint64_t &ResolvedAddress) {
142 SymbolRef Symbol;
143 if (std::error_code EC =
144 Ctx.ResolveSymbol(Section, Offset, Symbol, Ctx.UserData))
145 return EC;
146
147 ErrorOr<uint64_t> ResolvedAddressOrErr = Symbol.getAddress();
148 if (std::error_code EC = ResolvedAddressOrErr.getError())
149 return EC;
150 ResolvedAddress = *ResolvedAddressOrErr;
151
152 ErrorOr<section_iterator> SI = Symbol.getSection();
153 ResolvedSection = Ctx.COFF.getCOFFSection(**SI);
154 return std::error_code();
155 }
156
157 namespace llvm {
158 namespace Win64EH {
printRuntimeFunctionEntry(const Context & Ctx,const coff_section * Section,uint64_t Offset,const RuntimeFunction & RF)159 void Dumper::printRuntimeFunctionEntry(const Context &Ctx,
160 const coff_section *Section,
161 uint64_t Offset,
162 const RuntimeFunction &RF) {
163 SW.printString("StartAddress",
164 formatSymbol(Ctx, Section, Offset + 0, RF.StartAddress));
165 SW.printString("EndAddress",
166 formatSymbol(Ctx, Section, Offset + 4, RF.EndAddress));
167 SW.printString("UnwindInfoAddress",
168 formatSymbol(Ctx, Section, Offset + 8, RF.UnwindInfoOffset));
169 }
170
171 // Prints one unwind code. Because an unwind code can occupy up to 3 slots in
172 // the unwind codes array, this function requires that the correct number of
173 // slots is provided.
printUnwindCode(const UnwindInfo & UI,ArrayRef<UnwindCode> UC)174 void Dumper::printUnwindCode(const UnwindInfo& UI, ArrayRef<UnwindCode> UC) {
175 assert(UC.size() >= getNumUsedSlots(UC[0]));
176
177 SW.startLine() << format("0x%02X: ", unsigned(UC[0].u.CodeOffset))
178 << getUnwindCodeTypeName(UC[0].getUnwindOp());
179
180 switch (UC[0].getUnwindOp()) {
181 case UOP_PushNonVol:
182 OS << " reg=" << getUnwindRegisterName(UC[0].getOpInfo());
183 break;
184
185 case UOP_AllocLarge:
186 OS << " size="
187 << ((UC[0].getOpInfo() == 0) ? UC[1].FrameOffset * 8
188 : getLargeSlotValue(UC));
189 break;
190
191 case UOP_AllocSmall:
192 OS << " size=" << (UC[0].getOpInfo() + 1) * 8;
193 break;
194
195 case UOP_SetFPReg:
196 if (UI.getFrameRegister() == 0)
197 OS << " reg=<invalid>";
198 else
199 OS << " reg=" << getUnwindRegisterName(UI.getFrameRegister())
200 << format(", offset=0x%X", UI.getFrameOffset() * 16);
201 break;
202
203 case UOP_SaveNonVol:
204 OS << " reg=" << getUnwindRegisterName(UC[0].getOpInfo())
205 << format(", offset=0x%X", UC[1].FrameOffset * 8);
206 break;
207
208 case UOP_SaveNonVolBig:
209 OS << " reg=" << getUnwindRegisterName(UC[0].getOpInfo())
210 << format(", offset=0x%X", getLargeSlotValue(UC));
211 break;
212
213 case UOP_SaveXMM128:
214 OS << " reg=XMM" << static_cast<uint32_t>(UC[0].getOpInfo())
215 << format(", offset=0x%X", UC[1].FrameOffset * 16);
216 break;
217
218 case UOP_SaveXMM128Big:
219 OS << " reg=XMM" << static_cast<uint32_t>(UC[0].getOpInfo())
220 << format(", offset=0x%X", getLargeSlotValue(UC));
221 break;
222
223 case UOP_PushMachFrame:
224 OS << " errcode=" << (UC[0].getOpInfo() == 0 ? "no" : "yes");
225 break;
226 }
227
228 OS << "\n";
229 }
230
printUnwindInfo(const Context & Ctx,const coff_section * Section,off_t Offset,const UnwindInfo & UI)231 void Dumper::printUnwindInfo(const Context &Ctx, const coff_section *Section,
232 off_t Offset, const UnwindInfo &UI) {
233 DictScope UIS(SW, "UnwindInfo");
234 SW.printNumber("Version", UI.getVersion());
235 SW.printFlags("Flags", UI.getFlags(), makeArrayRef(UnwindFlags));
236 SW.printNumber("PrologSize", UI.PrologSize);
237 if (UI.getFrameRegister()) {
238 SW.printEnum("FrameRegister", UI.getFrameRegister(),
239 makeArrayRef(UnwindOpInfo));
240 SW.printHex("FrameOffset", UI.getFrameOffset());
241 } else {
242 SW.printString("FrameRegister", StringRef("-"));
243 SW.printString("FrameOffset", StringRef("-"));
244 }
245
246 SW.printNumber("UnwindCodeCount", UI.NumCodes);
247 {
248 ListScope UCS(SW, "UnwindCodes");
249 ArrayRef<UnwindCode> UC(&UI.UnwindCodes[0], UI.NumCodes);
250 for (const UnwindCode *UCI = UC.begin(), *UCE = UC.end(); UCI < UCE; ++UCI) {
251 unsigned UsedSlots = getNumUsedSlots(*UCI);
252 if (UsedSlots > UC.size()) {
253 errs() << "corrupt unwind data";
254 return;
255 }
256
257 printUnwindCode(UI, makeArrayRef(UCI, UCE));
258 UCI = UCI + UsedSlots - 1;
259 }
260 }
261
262 uint64_t LSDAOffset = Offset + getOffsetOfLSDA(UI);
263 if (UI.getFlags() & (UNW_ExceptionHandler | UNW_TerminateHandler)) {
264 SW.printString("Handler",
265 formatSymbol(Ctx, Section, LSDAOffset,
266 UI.getLanguageSpecificHandlerOffset()));
267 } else if (UI.getFlags() & UNW_ChainInfo) {
268 if (const RuntimeFunction *Chained = UI.getChainedFunctionEntry()) {
269 DictScope CS(SW, "Chained");
270 printRuntimeFunctionEntry(Ctx, Section, LSDAOffset, *Chained);
271 }
272 }
273 }
274
printRuntimeFunction(const Context & Ctx,const coff_section * Section,uint64_t SectionOffset,const RuntimeFunction & RF)275 void Dumper::printRuntimeFunction(const Context &Ctx,
276 const coff_section *Section,
277 uint64_t SectionOffset,
278 const RuntimeFunction &RF) {
279 DictScope RFS(SW, "RuntimeFunction");
280 printRuntimeFunctionEntry(Ctx, Section, SectionOffset, RF);
281
282 const coff_section *XData;
283 uint64_t Offset;
284 resolveRelocation(Ctx, Section, SectionOffset + 8, XData, Offset);
285
286 ArrayRef<uint8_t> Contents;
287 error(Ctx.COFF.getSectionContents(XData, Contents));
288 if (Contents.empty())
289 return;
290
291 Offset = Offset + RF.UnwindInfoOffset;
292 if (Offset > Contents.size())
293 return;
294
295 const auto UI = reinterpret_cast<const UnwindInfo*>(Contents.data() + Offset);
296 printUnwindInfo(Ctx, XData, Offset, *UI);
297 }
298
printData(const Context & Ctx)299 void Dumper::printData(const Context &Ctx) {
300 for (const auto &Section : Ctx.COFF.sections()) {
301 StringRef Name;
302 Section.getName(Name);
303
304 if (Name != ".pdata" && !Name.startswith(".pdata$"))
305 continue;
306
307 const coff_section *PData = Ctx.COFF.getCOFFSection(Section);
308 ArrayRef<uint8_t> Contents;
309 error(Ctx.COFF.getSectionContents(PData, Contents));
310 if (Contents.empty())
311 continue;
312
313 const RuntimeFunction *Entries =
314 reinterpret_cast<const RuntimeFunction *>(Contents.data());
315 const size_t Count = Contents.size() / sizeof(RuntimeFunction);
316 ArrayRef<RuntimeFunction> RuntimeFunctions(Entries, Count);
317
318 size_t Index = 0;
319 for (const auto &RF : RuntimeFunctions) {
320 printRuntimeFunction(Ctx, Ctx.COFF.getCOFFSection(Section),
321 Index * sizeof(RuntimeFunction), RF);
322 ++Index;
323 }
324 }
325 }
326 }
327 }
328
329