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