summaryrefslogtreecommitdiff
path: root/tools/llvm-readobj/ARMWinEHPrinter.cpp
diff options
context:
space:
mode:
authorSaleem Abdulrasool <compnerd@compnerd.org>2014-06-04 15:47:15 +0000
committerSaleem Abdulrasool <compnerd@compnerd.org>2014-06-04 15:47:15 +0000
commitfe3b74ec7132033f15bbf4be74e745ce48baa0bf (patch)
tree5afb1f78896e6f8788d7f5941c39fad2432994a3 /tools/llvm-readobj/ARMWinEHPrinter.cpp
parentb35de82adcae131730d4af5d1d8b72b14ef16225 (diff)
downloadllvm-fe3b74ec7132033f15bbf4be74e745ce48baa0bf.tar.gz
llvm-fe3b74ec7132033f15bbf4be74e745ce48baa0bf.tar.bz2
llvm-fe3b74ec7132033f15bbf4be74e745ce48baa0bf.tar.xz
tools: initial implementation of WoA EH decoding
Add support to llvm-readobj to decode Windows ARM Exception Handling data. This uses the previously added datastructures to decode the information into a format that can be used by tests. This is a necessary step to add support for emitting Windows on ARM exception handling information. A fair amount of formatting inspiration is drawn from the Win64 EH printer as well as the ARM EHABI printer. This allows for a reasonably thorough look into the encoded data. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210192 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'tools/llvm-readobj/ARMWinEHPrinter.cpp')
-rw-r--r--tools/llvm-readobj/ARMWinEHPrinter.cpp686
1 files changed, 686 insertions, 0 deletions
diff --git a/tools/llvm-readobj/ARMWinEHPrinter.cpp b/tools/llvm-readobj/ARMWinEHPrinter.cpp
new file mode 100644
index 0000000000..4971f2d8de
--- /dev/null
+++ b/tools/llvm-readobj/ARMWinEHPrinter.cpp
@@ -0,0 +1,686 @@
+//===-- ARMWinEHPrinter.cpp - Windows on ARM EH Data Printer ----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ARMWinEHPrinter.h"
+#include "Error.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/ARMWinEH.h"
+#include "llvm/Support/Format.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::support;
+
+namespace llvm {
+raw_ostream &operator<<(raw_ostream &OS, const ARM::WinEH::ReturnType &RT) {
+ switch (RT) {
+ case ARM::WinEH::ReturnType::RT_POP:
+ OS << "pop {pc}";
+ break;
+ case ARM::WinEH::ReturnType::RT_B:
+ OS << "b target";
+ break;
+ case ARM::WinEH::ReturnType::RT_BW:
+ OS << "b.w target";
+ break;
+ case ARM::WinEH::ReturnType::RT_NoEpilogue:
+ OS << "(no epilogue)";
+ break;
+ }
+ return OS;
+}
+}
+
+static std::string formatSymbol(StringRef Name, uint64_t Address,
+ uint64_t Offset = 0) {
+ std::string Buffer;
+ raw_string_ostream OS(Buffer);
+
+ if (!Name.empty())
+ OS << Name << " ";
+
+ if (Offset)
+ OS << format("+0x%X (0x%" PRIX64 ")", Offset, Address);
+ else if (!Name.empty())
+ OS << format("(0x%" PRIX64 ")", Address);
+ else
+ OS << format("0x%" PRIX64, Address);
+
+ return OS.str();
+}
+
+namespace llvm {
+namespace ARM {
+namespace WinEH {
+const size_t Decoder::PDataEntrySize = sizeof(RuntimeFunction);
+
+const Decoder::RingEntry Decoder::Ring[] = {
+ { 0x80, 0x00, &Decoder::opcode_0xxxxxxx },
+ { 0xc0, 0x80, &Decoder::opcode_10Lxxxxx },
+ { 0xf0, 0xc0, &Decoder::opcode_1100xxxx },
+ { 0xf8, 0xd0, &Decoder::opcode_11010Lxx },
+ { 0xf8, 0xd8, &Decoder::opcode_11011Lxx },
+ { 0xf8, 0xe0, &Decoder::opcode_11100xxx },
+ { 0xfc, 0xe8, &Decoder::opcode_111010xx },
+ { 0xfe, 0xec, &Decoder::opcode_1110110L },
+ { 0xff, 0xee, &Decoder::opcode_11101110 },
+ { 0xff, 0xef, &Decoder::opcode_11101111 },
+ { 0xff, 0xf5, &Decoder::opcode_11110101 },
+ { 0xff, 0xf6, &Decoder::opcode_11110110 },
+ { 0xff, 0xf7, &Decoder::opcode_11110111 },
+ { 0xff, 0xf8, &Decoder::opcode_11111000 },
+ { 0xff, 0xf9, &Decoder::opcode_11111001 },
+ { 0xff, 0xfa, &Decoder::opcode_11111010 },
+ { 0xff, 0xfb, &Decoder::opcode_11111011 },
+ { 0xff, 0xfc, &Decoder::opcode_11111100 },
+ { 0xff, 0xfd, &Decoder::opcode_11111101 },
+ { 0xff, 0xfe, &Decoder::opcode_11111110 },
+ { 0xff, 0xff, &Decoder::opcode_11111111 },
+};
+
+void Decoder::printRegisters(const std::pair<uint16_t, uint32_t> &RegisterMask) {
+ static const char * const GPRRegisterNames[16] = {
+ "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
+ "r11", "ip", "sp", "lr", "pc",
+ };
+
+ const uint16_t GPRMask = std::get<0>(RegisterMask);
+ const uint16_t VFPMask = std::get<1>(RegisterMask);
+
+ OS << '{';
+ bool Comma = false;
+ for (unsigned RI = 0, RE = 11; RI < RE; ++RI) {
+ if (GPRMask & (1 << RI)) {
+ if (Comma)
+ OS << ", ";
+ OS << GPRRegisterNames[RI];
+ Comma = true;
+ }
+ }
+ for (unsigned RI = 0, RE = 32; RI < RE; ++RI) {
+ if (VFPMask & (1 << RI)) {
+ if (Comma)
+ OS << ", ";
+ OS << "d" << unsigned(RI);
+ Comma = true;
+ }
+ }
+ for (unsigned RI = 11, RE = 16; RI < RE; ++RI) {
+ if (GPRMask & (1 << RI)) {
+ if (Comma)
+ OS << ", ";
+ OS << GPRRegisterNames[RI];
+ Comma = true;
+ }
+ }
+ OS << '}';
+}
+
+ErrorOr<object::SectionRef>
+Decoder::getSectionContaining(const COFFObjectFile &COFF, uint64_t VA) {
+ for (const auto &Section : COFF.sections()) {
+ uint64_t Address;
+ uint64_t Size;
+
+ if (error_code EC = Section.getAddress(Address))
+ return EC;
+ if (error_code EC = Section.getSize(Size))
+ return EC;
+
+ if (VA >= Address && (VA - Address) <= Size)
+ return Section;
+ }
+ return readobj_error::unknown_symbol;
+}
+
+ErrorOr<object::SymbolRef> Decoder::getSymbol(const COFFObjectFile &COFF,
+ uint64_t VA, bool FunctionOnly) {
+ for (const auto &Symbol : COFF.symbols()) {
+ if (FunctionOnly) {
+ SymbolRef::Type Type;
+ if (error_code EC = Symbol.getType(Type))
+ return EC;
+ if (Type != SymbolRef::ST_Function)
+ continue;
+ }
+
+ uint64_t Address;
+ if (error_code EC = Symbol.getAddress(Address))
+ return EC;
+ if (Address == VA)
+ return Symbol;
+ }
+ return readobj_error::unknown_symbol;
+}
+
+ErrorOr<SymbolRef> Decoder::getRelocatedSymbol(const COFFObjectFile &,
+ const SectionRef &Section,
+ uint64_t Offset) {
+ for (const auto &Relocation : Section.relocations()) {
+ uint64_t RelocationOffset;
+ if (auto Error = Relocation.getOffset(RelocationOffset))
+ return Error;
+ if (RelocationOffset == Offset)
+ return *Relocation.getSymbol();
+ }
+ return readobj_error::unknown_symbol;
+}
+
+bool Decoder::opcode_0xxxxxxx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint8_t Imm = OC[Offset] & 0x7f;
+ SW.startLine() << format("0x%02x ; %s sp, #(%u * 4)\n",
+ OC[Offset],
+ static_cast<const char *>(Prologue ? "sub" : "add"),
+ Imm);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_10Lxxxxx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned Link = (OC[Offset] & 0x20) >> 5;
+ uint16_t RegisterMask = (Link << (Prologue ? 14 : 15))
+ | ((OC[Offset + 0] & 0x1f) << 8)
+ | ((OC[Offset + 1] & 0xff) << 0);
+ assert((~RegisterMask & (1 << 13)) && "sp must not be set");
+ assert((~RegisterMask & (1 << (Prologue ? 15 : 14))) && "pc must not be set");
+
+ SW.startLine() << format("0x%02x 0x%02x ; %s.w ",
+ OC[Offset + 0], OC[Offset + 1],
+ Prologue ? "push" : "pop");
+ printRegisters(std::make_pair(RegisterMask, 0));
+ OS << '\n';
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_1100xxxx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ if (Prologue)
+ SW.startLine() << format("0x%02x ; mov r%u, sp\n",
+ OC[Offset], OC[Offset] & 0xf);
+ else
+ SW.startLine() << format("0x%02x ; mov sp, r%u\n",
+ OC[Offset], OC[Offset] & 0xf);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11010Lxx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned Link = (OC[Offset] & 0x4) >> 3;
+ unsigned Count = (OC[Offset] & 0x3);
+
+ uint16_t GPRMask = (Link << (Prologue ? 14 : 15))
+ | (((1 << (Count + 1)) - 1) << 4);
+
+ SW.startLine() << format("0x%02x ; %s ", OC[Offset],
+ Prologue ? "push" : "pop");
+ printRegisters(std::make_pair(GPRMask, 0));
+ OS << '\n';
+
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11011Lxx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned Link = (OC[Offset] & 0x4) >> 2;
+ unsigned Count = (OC[Offset] & 0x3) + 4;
+
+ uint16_t GPRMask = (Link << (Prologue ? 14 : 15))
+ | (((1 << (Count + 1)) - 1) << 4);
+
+ SW.startLine() << format("0x%02x ; %s.w ", OC[Offset],
+ Prologue ? "push" : "pop");
+ printRegisters(std::make_pair(GPRMask, 0));
+ OS << '\n';
+
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11100xxx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned High = (OC[Offset] & 0x7);
+ uint32_t VFPMask = (((1 << (High + 1)) - 1) << 8);
+
+ SW.startLine() << format("0x%02x ; %s ", OC[Offset],
+ Prologue ? "vpush" : "vpop");
+ printRegisters(std::make_pair(0, VFPMask));
+ OS << '\n';
+
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_111010xx(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint16_t Imm = ((OC[Offset + 0] & 0x03) << 8) | ((OC[Offset + 1] & 0xff) << 0);
+
+ SW.startLine() << format("0x%02x 0x%02x ; %s.w sp, #(%u * 4)\n",
+ OC[Offset + 0], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "sub" : "add"),
+ Imm);
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_1110110L(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint8_t GPRMask = ((OC[Offset + 0] & 0x01) << (Prologue ? 14 : 15))
+ | ((OC[Offset + 1] & 0xff) << 0);
+
+ SW.startLine() << format("0x%02x 0x%02x ; %s ", OC[Offset + 0],
+ OC[Offset + 1], Prologue ? "push" : "pop");
+ printRegisters(std::make_pair(GPRMask, 0));
+ OS << '\n';
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11101110(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ assert(!Prologue && "may not be used in prologue");
+
+ if (OC[Offset + 1] & 0xf0)
+ SW.startLine() << format("0x%02x 0x%02x ; reserved\n",
+ OC[Offset + 0], OC[Offset + 1]);
+ else
+ SW.startLine()
+ << format("0x%02x 0x%02x ; microsoft-specific (type: %u)\n",
+ OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] & 0x0f);
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11101111(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ assert(!Prologue && "may not be used in prologue");
+
+ if (OC[Offset + 1] & 0xf0)
+ SW.startLine() << format("0x%02x 0x%02x ; reserved\n",
+ OC[Offset + 0], OC[Offset + 1]);
+ else
+ SW.startLine()
+ << format("0x%02x 0x%02x ; ldr.w lr, [sp], #%u\n",
+ OC[Offset + 0], OC[Offset + 1], OC[Offset + 1] << 2);
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11110101(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned Start = (OC[Offset + 1] & 0xf0) >> 4;
+ unsigned End = (OC[Offset + 1] & 0x0f) >> 0;
+ uint32_t VFPMask = ((1 << (End - Start)) - 1) << Start;
+
+ SW.startLine() << format("0x%02x 0x%02x ; %s ", OC[Offset + 0],
+ OC[Offset + 1], Prologue ? "vpush" : "vpop");
+ printRegisters(std::make_pair(0, VFPMask));
+ OS << '\n';
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11110110(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned Start = (OC[Offset + 1] & 0xf0) >> 4;
+ unsigned End = (OC[Offset + 1] & 0x0f) >> 0;
+ uint32_t VFPMask = ((1 << (End - Start)) - 1) << 16;
+
+ SW.startLine() << format("0x%02x 0x%02x ; %s ", OC[Offset + 0],
+ OC[Offset + 1], Prologue ? "vpush" : "vpop");
+ printRegisters(std::make_pair(0, VFPMask));
+ OS << '\n';
+
+ ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11110111(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Imm = (OC[Offset + 1] << 8) | (OC[Offset + 2] << 0);
+
+ SW.startLine() << format("0x%02x 0x%02x 0x%02x ; %s sp, sp, #(%u * 4)\n",
+ OC[Offset + 0], OC[Offset + 1], OC[Offset + 2],
+ static_cast<const char *>(Prologue ? "sub" : "add"),
+ Imm);
+
+ ++Offset, ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11111000(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Imm = (OC[Offset + 1] << 16)
+ | (OC[Offset + 2] << 8)
+ | (OC[Offset + 3] << 0);
+
+ SW.startLine()
+ << format("0x%02x 0x%02x 0x%02x 0x%02x ; %s sp, sp, #(%u * 4)\n",
+ OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
+ static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
+
+ ++Offset, ++Offset, ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11111001(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Imm = (OC[Offset + 1] << 8) | (OC[Offset + 2] << 0);
+
+ SW.startLine()
+ << format("0x%02x 0x%02x 0x%02x ; %s.w sp, sp, #(%u * 4)\n",
+ OC[Offset + 0], OC[Offset + 1], OC[Offset + 2],
+ static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
+
+ ++Offset, ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11111010(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Imm = (OC[Offset + 1] << 16)
+ | (OC[Offset + 2] << 8)
+ | (OC[Offset + 3] << 0);
+
+ SW.startLine()
+ << format("0x%02x 0x%02x 0x%02x 0x%02x ; %s.w sp, sp, #(%u * 4)\n",
+ OC[Offset + 0], OC[Offset + 1], OC[Offset + 2], OC[Offset + 3],
+ static_cast<const char *>(Prologue ? "sub" : "add"), Imm);
+
+ ++Offset, ++Offset, ++Offset, ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11111011(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ SW.startLine() << format("0x%02x ; nop\n", OC[Offset]);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11111100(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ SW.startLine() << format("0x%02x ; nop.w\n", OC[Offset]);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_11111101(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ SW.startLine() << format("0x%02x ; b\n", OC[Offset]);
+ ++Offset;
+ return true;
+}
+
+bool Decoder::opcode_11111110(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ SW.startLine() << format("0x%02x ; b.w\n", OC[Offset]);
+ ++Offset;
+ return true;
+}
+
+bool Decoder::opcode_11111111(const ulittle8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ ++Offset;
+ return true;
+}
+
+void Decoder::decodeOpcodes(ArrayRef<ulittle8_t> Opcodes, unsigned Offset,
+ bool Prologue) {
+ assert(!Prologue || Offset == 0 && "prologue should always use offset 0");
+
+ bool Terminated = false;
+ for (unsigned OI = Offset, OE = Opcodes.size(); !Terminated && OI < OE; ) {
+ bool Decoded = false;
+ for (unsigned DI = 0, DE = array_lengthof(Ring); DI < DE; ++DI) {
+ if ((Opcodes[OI] & Ring[DI].Mask) == Ring[DI].Value) {
+ Terminated = (this->*Ring[DI].Routine)(Opcodes.data(), OI, 0, Prologue);
+ Decoded = true;
+ break;
+ }
+ }
+ assert(Decoded && "unhandled opcode");
+ }
+}
+
+bool Decoder::dumpXDataRecord(const COFFObjectFile &COFF,
+ const SectionRef &Section,
+ uint64_t FunctionAddress, uint64_t VA) {
+ ArrayRef<uint8_t> Contents;
+ if (COFF.getSectionContents(COFF.getCOFFSection(Section), Contents))
+ return false;
+
+ uint64_t SectionVA;
+ if (Section.getAddress(SectionVA))
+ return false;
+
+ uint64_t Offset = VA - SectionVA;
+ const ulittle32_t *Data =
+ reinterpret_cast<const ulittle32_t *>(Contents.data() + Offset);
+ const ExceptionDataRecord XData(Data);
+
+ DictScope XRS(SW, "ExceptionData");
+ SW.printNumber("FunctionLength", XData.FunctionLength() << 1);
+ SW.printNumber("Version", XData.Vers());
+ SW.printBoolean("ExceptionData", XData.X());
+ SW.printBoolean("EpiloguePacked", XData.E());
+ SW.printBoolean("Fragment", XData.F());
+ SW.printNumber(XData.E() ? "EpilogueOffset" : "EpilogueScopes",
+ XData.EpilogueCount());
+ SW.printNumber("ByteCodeLength",
+ static_cast<uint64_t>(XData.CodeWords() * sizeof(uint32_t)));
+
+ if (XData.E()) {
+ ArrayRef<ulittle8_t> UC = XData.UnwindByteCode();
+ if (!XData.F()) {
+ ListScope PS(SW, "Prologue");
+ decodeOpcodes(UC, 0, /*Prologue=*/true);
+ }
+ if (XData.EpilogueCount()) {
+ ListScope ES(SW, "Epilogue");
+ decodeOpcodes(UC, XData.EpilogueCount(), /*Prologue=*/false);
+ }
+ } else {
+ ArrayRef<ulittle32_t> EpilogueScopes = XData.EpilogueScopes();
+ ListScope ESS(SW, "EpilogueScopes");
+ for (const EpilogueScope ES : EpilogueScopes) {
+ DictScope ESES(SW, "EpilogueScope");
+ SW.printNumber("StartOffset", ES.EpilogueStartOffset());
+ SW.printNumber("Condition", ES.Condition());
+ SW.printNumber("EpilogueStartIndex", ES.EpilogueStartIndex());
+
+ ListScope Opcodes(SW, "Opcodes");
+ decodeOpcodes(XData.UnwindByteCode(), ES.EpilogueStartIndex(),
+ /*Prologue=*/false);
+ }
+ }
+
+ if (XData.X()) {
+ const uint32_t Address = XData.ExceptionHandlerRVA();
+ const uint32_t Parameter = XData.ExceptionHandlerParameter();
+ const size_t HandlerOffset = HeaderWords(XData)
+ + (XData.E() ? 0 : XData.EpilogueCount())
+ + XData.CodeWords();
+
+ ErrorOr<SymbolRef> Symbol =
+ getRelocatedSymbol(COFF, Section, HandlerOffset * sizeof(uint32_t));
+ if (!Symbol)
+ Symbol = getSymbol(COFF, Address, /*FunctionOnly=*/true);
+
+ StringRef Name;
+ if (Symbol)
+ Symbol->getName(Name);
+
+ ListScope EHS(SW, "ExceptionHandler");
+ SW.printString("Routine", formatSymbol(Name, Address));
+ SW.printHex("Parameter", Parameter);
+ }
+
+ return true;
+}
+
+bool Decoder::dumpUnpackedEntry(const COFFObjectFile &COFF,
+ const SectionRef Section, uint64_t Offset,
+ unsigned Index, const RuntimeFunction &RF) {
+ assert(RF.Flag() == RuntimeFunctionFlag::RFF_Unpacked &&
+ "packed entry cannot be treated as an unpacked entry");
+
+ ErrorOr<SymbolRef> Function = getRelocatedSymbol(COFF, Section, Offset);
+ if (!Function)
+ Function = getSymbol(COFF, RF.BeginAddress, /*FunctionOnly=*/true);
+
+ ErrorOr<SymbolRef> XDataRecord = getRelocatedSymbol(COFF, Section, Offset + 4);
+ if (!XDataRecord)
+ XDataRecord = getSymbol(COFF, RF.ExceptionInformationRVA());
+
+ if (!RF.BeginAddress && !Function)
+ return false;
+ if (!RF.UnwindData && !XDataRecord)
+ return false;
+
+ StringRef FunctionName;
+ uint64_t FunctionAddress;
+ if (Function) {
+ Function->getName(FunctionName);
+ Function->getAddress(FunctionAddress);
+ } else {
+ const pe32_header *PEHeader;
+ if (COFF.getPE32Header(PEHeader))
+ return false;
+ FunctionAddress = PEHeader->ImageBase + RF.BeginAddress;
+ }
+
+ SW.printString("Function", formatSymbol(FunctionName, FunctionAddress));
+
+ if (XDataRecord) {
+ StringRef Name;
+ uint64_t Address;
+
+ XDataRecord->getName(Name);
+ XDataRecord->getAddress(Address);
+
+ SW.printString("ExceptionRecord", formatSymbol(Name, Address));
+
+ section_iterator SI = COFF.section_end();
+ if (XDataRecord->getSection(SI))
+ return false;
+
+ return dumpXDataRecord(COFF, *SI, FunctionAddress, Address);
+ } else {
+ const pe32_header *PEHeader;
+ if (COFF.getPE32Header(PEHeader))
+ return false;
+
+ uint64_t Address = PEHeader->ImageBase + RF.ExceptionInformationRVA();
+ SW.printString("ExceptionRecord", formatSymbol("", Address));
+
+ ErrorOr<SectionRef> Section =
+ getSectionContaining(COFF, RF.ExceptionInformationRVA());
+ if (!Section)
+ return false;
+
+ return dumpXDataRecord(COFF, *Section, FunctionAddress,
+ RF.ExceptionInformationRVA());
+ }
+}
+
+bool Decoder::dumpPackedEntry(const object::COFFObjectFile &COFF,
+ const SectionRef Section, uint64_t Offset,
+ unsigned Index, const RuntimeFunction &RF) {
+ assert((RF.Flag() == RuntimeFunctionFlag::RFF_Packed ||
+ RF.Flag() == RuntimeFunctionFlag::RFF_PackedFragment) &&
+ "unpacked entry cannot be treated as a packed entry");
+
+ ErrorOr<SymbolRef> Function = getRelocatedSymbol(COFF, Section, Offset);
+ if (!Function)
+ Function = getSymbol(COFF, RF.BeginAddress, /*FunctionOnly=*/true);
+
+ StringRef FunctionName;
+ uint64_t FunctionAddress;
+ if (Function) {
+ Function->getName(FunctionName);
+ Function->getAddress(FunctionAddress);
+ } else {
+ const pe32_header *PEHeader;
+ if (COFF.getPE32Header(PEHeader))
+ return false;
+ FunctionAddress = PEHeader->ImageBase + RF.BeginAddress;
+ }
+
+ SW.printString("Function", formatSymbol(FunctionName, FunctionAddress));
+ SW.printBoolean("Fragment",
+ RF.Flag() == RuntimeFunctionFlag::RFF_PackedFragment);
+ SW.printNumber("FunctionLength", RF.FunctionLength());
+ SW.startLine() << "ReturnType: " << RF.Ret() << '\n';
+ SW.printBoolean("HomedParameters", RF.H());
+ SW.startLine() << "SavedRegisters: ";
+ printRegisters(SavedRegisterMask(RF));
+ OS << '\n';
+ SW.printNumber("StackAdjustment", StackAdjustment(RF) << 2);
+
+ return true;
+}
+
+bool Decoder::dumpProcedureDataEntry(const COFFObjectFile &COFF,
+ const SectionRef Section, unsigned Index,
+ ArrayRef<uint8_t> Contents) {
+ uint64_t Offset = PDataEntrySize * Index;
+ const ulittle32_t *Data =
+ reinterpret_cast<const ulittle32_t *>(Contents.data() + Offset);
+
+ const RuntimeFunction Entry(Data);
+ DictScope RFS(SW, "RuntimeFunction");
+ if (Entry.Flag() == RuntimeFunctionFlag::RFF_Unpacked)
+ return dumpUnpackedEntry(COFF, Section, Offset, Index, Entry);
+ return dumpPackedEntry(COFF, Section, Offset, Index, Entry);
+}
+
+void Decoder::dumpProcedureData(const COFFObjectFile &COFF,
+ const SectionRef Section) {
+ ArrayRef<uint8_t> Contents;
+ if (COFF.getSectionContents(COFF.getCOFFSection(Section), Contents))
+ return;
+
+ if (Contents.size() % PDataEntrySize) {
+ errs() << ".pdata content is not " << PDataEntrySize << "-byte aligned\n";
+ return;
+ }
+
+ for (unsigned EI = 0, EE = Contents.size() / PDataEntrySize; EI < EE; ++EI)
+ if (!dumpProcedureDataEntry(COFF, Section, EI, Contents))
+ break;
+}
+
+error_code Decoder::dumpProcedureData(const COFFObjectFile &COFF) {
+ for (const auto &Section : COFF.sections()) {
+ StringRef SectionName;
+ if (error_code EC = COFF.getSectionName(COFF.getCOFFSection(Section),
+ SectionName))
+ return EC;
+
+ if (SectionName.startswith(".pdata"))
+ dumpProcedureData(COFF, Section);
+ }
+ return error_code();
+}
+}
+}
+}
+