[ARM64][Windows] Add unwind support to llvm-readobj
This patch adds support for dumping the unwind info from ARM64 COFF object
files.
Differential Revision: https://reviews.llvm.org/D53264
llvm-svn: 345108
diff --git a/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp b/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp
index a90840b..56dd6c0 100644
--- a/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp
+++ b/llvm/tools/llvm-readobj/ARMWinEHPrinter.cpp
@@ -118,31 +118,57 @@
// TODO name the uops more appropriately
const Decoder::RingEntry Decoder::Ring[] = {
- { 0x80, 0x00, &Decoder::opcode_0xxxxxxx }, // UOP_STACK_FREE (16-bit)
- { 0xc0, 0x80, &Decoder::opcode_10Lxxxxx }, // UOP_POP (32-bit)
- { 0xf0, 0xc0, &Decoder::opcode_1100xxxx }, // UOP_STACK_SAVE (16-bit)
- { 0xf8, 0xd0, &Decoder::opcode_11010Lxx }, // UOP_POP (16-bit)
- { 0xf8, 0xd8, &Decoder::opcode_11011Lxx }, // UOP_POP (32-bit)
- { 0xf8, 0xe0, &Decoder::opcode_11100xxx }, // UOP_VPOP (32-bit)
- { 0xfc, 0xe8, &Decoder::opcode_111010xx }, // UOP_STACK_FREE (32-bit)
- { 0xfe, 0xec, &Decoder::opcode_1110110L }, // UOP_POP (16-bit)
- { 0xff, 0xee, &Decoder::opcode_11101110 }, // UOP_MICROSOFT_SPECIFIC (16-bit)
+ { 0x80, 0x00, 1, &Decoder::opcode_0xxxxxxx }, // UOP_STACK_FREE (16-bit)
+ { 0xc0, 0x80, 2, &Decoder::opcode_10Lxxxxx }, // UOP_POP (32-bit)
+ { 0xf0, 0xc0, 1, &Decoder::opcode_1100xxxx }, // UOP_STACK_SAVE (16-bit)
+ { 0xf8, 0xd0, 1, &Decoder::opcode_11010Lxx }, // UOP_POP (16-bit)
+ { 0xf8, 0xd8, 1, &Decoder::opcode_11011Lxx }, // UOP_POP (32-bit)
+ { 0xf8, 0xe0, 1, &Decoder::opcode_11100xxx }, // UOP_VPOP (32-bit)
+ { 0xfc, 0xe8, 2, &Decoder::opcode_111010xx }, // UOP_STACK_FREE (32-bit)
+ { 0xfe, 0xec, 2, &Decoder::opcode_1110110L }, // UOP_POP (16-bit)
+ { 0xff, 0xee, 2, &Decoder::opcode_11101110 }, // UOP_MICROSOFT_SPECIFIC (16-bit)
// UOP_PUSH_MACHINE_FRAME
// UOP_PUSH_CONTEXT
// UOP_PUSH_TRAP_FRAME
// UOP_REDZONE_RESTORE_LR
- { 0xff, 0xef, &Decoder::opcode_11101111 }, // UOP_LDRPC_POSTINC (32-bit)
- { 0xff, 0xf5, &Decoder::opcode_11110101 }, // UOP_VPOP (32-bit)
- { 0xff, 0xf6, &Decoder::opcode_11110110 }, // UOP_VPOP (32-bit)
- { 0xff, 0xf7, &Decoder::opcode_11110111 }, // UOP_STACK_RESTORE (16-bit)
- { 0xff, 0xf8, &Decoder::opcode_11111000 }, // UOP_STACK_RESTORE (16-bit)
- { 0xff, 0xf9, &Decoder::opcode_11111001 }, // UOP_STACK_RESTORE (32-bit)
- { 0xff, 0xfa, &Decoder::opcode_11111010 }, // UOP_STACK_RESTORE (32-bit)
- { 0xff, 0xfb, &Decoder::opcode_11111011 }, // UOP_NOP (16-bit)
- { 0xff, 0xfc, &Decoder::opcode_11111100 }, // UOP_NOP (32-bit)
- { 0xff, 0xfd, &Decoder::opcode_11111101 }, // UOP_NOP (16-bit) / END
- { 0xff, 0xfe, &Decoder::opcode_11111110 }, // UOP_NOP (32-bit) / END
- { 0xff, 0xff, &Decoder::opcode_11111111 }, // UOP_END
+ { 0xff, 0xef, 2, &Decoder::opcode_11101111 }, // UOP_LDRPC_POSTINC (32-bit)
+ { 0xff, 0xf5, 2, &Decoder::opcode_11110101 }, // UOP_VPOP (32-bit)
+ { 0xff, 0xf6, 2, &Decoder::opcode_11110110 }, // UOP_VPOP (32-bit)
+ { 0xff, 0xf7, 3, &Decoder::opcode_11110111 }, // UOP_STACK_RESTORE (16-bit)
+ { 0xff, 0xf8, 4, &Decoder::opcode_11111000 }, // UOP_STACK_RESTORE (16-bit)
+ { 0xff, 0xf9, 3, &Decoder::opcode_11111001 }, // UOP_STACK_RESTORE (32-bit)
+ { 0xff, 0xfa, 4, &Decoder::opcode_11111010 }, // UOP_STACK_RESTORE (32-bit)
+ { 0xff, 0xfb, 1, &Decoder::opcode_11111011 }, // UOP_NOP (16-bit)
+ { 0xff, 0xfc, 1, &Decoder::opcode_11111100 }, // UOP_NOP (32-bit)
+ { 0xff, 0xfd, 1, &Decoder::opcode_11111101 }, // UOP_NOP (16-bit) / END
+ { 0xff, 0xfe, 1, &Decoder::opcode_11111110 }, // UOP_NOP (32-bit) / END
+ { 0xff, 0xff, 1, &Decoder::opcode_11111111 }, // UOP_END
+};
+
+
+// Unwind opcodes for ARM64.
+// https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
+const Decoder::RingEntry Decoder::Ring64[] = {
+ { 0xe0, 0x00, 1, &Decoder::opcode_alloc_s },
+ { 0xe0, 0x20, 1, &Decoder::opcode_save_r19r20_x },
+ { 0xc0, 0x40, 1, &Decoder::opcode_save_fplr },
+ { 0xc0, 0x80, 1, &Decoder::opcode_save_fplr_x },
+ { 0xf8, 0xc0, 2, &Decoder::opcode_alloc_m },
+ { 0xfc, 0xc8, 2, &Decoder::opcode_save_regp },
+ { 0xfc, 0xcc, 2, &Decoder::opcode_save_regp_x },
+ { 0xfc, 0xd0, 2, &Decoder::opcode_save_reg },
+ { 0xfe, 0xd4, 2, &Decoder::opcode_save_reg_x },
+ { 0xfe, 0xd6, 2, &Decoder::opcode_save_lrpair },
+ { 0xfe, 0xd8, 2, &Decoder::opcode_save_fregp },
+ { 0xfe, 0xda, 2, &Decoder::opcode_save_fregp_x },
+ { 0xfe, 0xdc, 2, &Decoder::opcode_save_freg },
+ { 0xff, 0xde, 2, &Decoder::opcode_save_freg_x },
+ { 0xff, 0xe0, 4, &Decoder::opcode_alloc_l },
+ { 0xff, 0xe1, 1, &Decoder::opcode_setfp },
+ { 0xff, 0xe2, 2, &Decoder::opcode_addfp },
+ { 0xff, 0xe3, 1, &Decoder::opcode_nop },
+ { 0xff, 0xe4, 1, &Decoder::opcode_end },
+ { 0xff, 0xe5, 1, &Decoder::opcode_end_c },
};
void Decoder::printRegisters(const std::pair<uint16_t, uint32_t> &RegisterMask) {
@@ -493,18 +519,291 @@
return true;
}
+// ARM64 unwind codes start here.
+bool Decoder::opcode_alloc_s(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t NumBytes = (OC[Offset] & 0x1F) << 4;
+ SW.startLine() << format("0x%02x ; %s sp, #%u\n", OC[Offset],
+ static_cast<const char *>(Prologue ? "sub" : "add"),
+ NumBytes);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_save_r19r20_x(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Off = (OC[Offset] & 0x1F) << 3;
+ if (Prologue)
+ SW.startLine() << format(
+ "0x%02x ; stp x19, x20, [sp, #-%u]!\n", OC[Offset], Off);
+ else
+ SW.startLine() << format(
+ "0x%02x ; ldp x19, x20, [sp], #%u\n", OC[Offset], Off);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_save_fplr(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Off = (OC[Offset] & 0x3F) << 3;
+ SW.startLine() << format(
+ "0x%02x ; %s x29, x30, [sp, #%u]\n", OC[Offset],
+ static_cast<const char *>(Prologue ? "stp" : "ldp"), Off);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_save_fplr_x(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Off = ((OC[Offset] & 0x3F) + 1) << 3;
+ if (Prologue)
+ SW.startLine() << format(
+ "0x%02x ; stp x29, x30, [sp, #-%u]!\n", OC[Offset], Off);
+ else
+ SW.startLine() << format(
+ "0x%02x ; ldp x29, x30, [sp], #%u\n", OC[Offset], Off);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_alloc_m(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t NumBytes = ((OC[Offset] & 0x07) << 8);
+ NumBytes |= (OC[Offset + 1] & 0xFF);
+ NumBytes <<= 4;
+ SW.startLine() << format("0x%02x%02x ; %s sp, #%u\n",
+ OC[Offset], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "sub" : "add"),
+ NumBytes);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_regp(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = ((OC[Offset] & 0x03) << 8);
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg += 19;
+ uint32_t Off = (OC[Offset + 1] & 0x3F) << 3;
+ SW.startLine() << format(
+ "0x%02x%02x ; %s x%u, x%u, [sp, #%u]\n",
+ OC[Offset], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "stp" : "ldp"), Reg, Reg + 1, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_regp_x(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = ((OC[Offset] & 0x03) << 8);
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg += 19;
+ uint32_t Off = ((OC[Offset + 1] & 0x3F) + 1) << 3;
+ if (Prologue)
+ SW.startLine() << format(
+ "0x%02x%02x ; stp x%u, x%u, [sp, #-%u]!\n",
+ OC[Offset], OC[Offset + 1], Reg,
+ Reg + 1, Off);
+ else
+ SW.startLine() << format(
+ "0x%02x%02x ; ldp x%u, x%u, [sp], #%u\n",
+ OC[Offset], OC[Offset + 1], Reg,
+ Reg + 1, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_reg(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = (OC[Offset] & 0x03) << 8;
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg += 19;
+ uint32_t Off = (OC[Offset + 1] & 0x3F) << 3;
+ SW.startLine() << format("0x%02x%02x ; %s x%u, [sp, #%u]\n",
+ OC[Offset], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "str" : "ldr"),
+ Reg, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_reg_x(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = (OC[Offset] & 0x01) << 8;
+ Reg |= (OC[Offset + 1] & 0xE0);
+ Reg >>= 5;
+ Reg += 19;
+ uint32_t Off = ((OC[Offset + 1] & 0x1F) + 1) << 3;
+ if (Prologue)
+ SW.startLine() << format("0x%02x%02x ; str x%u, [sp, #%u]!\n",
+ OC[Offset], OC[Offset + 1], Reg, Off);
+ else
+ SW.startLine() << format("0x%02x%02x ; ldr x%u, [sp], #%u\n",
+ OC[Offset], OC[Offset + 1], Reg, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_lrpair(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = (OC[Offset] & 0x01) << 8;
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg *= 2;
+ Reg += 19;
+ uint32_t Off = (OC[Offset + 1] & 0x3F) << 3;
+ SW.startLine() << format("0x%02x%02x ; %s x%u, lr, [sp, #%u]\n",
+ OC[Offset], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "stp" : "ldp"),
+ Reg, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_fregp(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = (OC[Offset] & 0x01) << 8;
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg += 8;
+ uint32_t Off = (OC[Offset + 1] & 0x3F) << 3;
+ SW.startLine() << format("0x%02x%02x ; %s d%u, d%u, [sp, #%u]\n",
+ OC[Offset], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "stp" : "ldp"),
+ Reg, Reg + 1, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_fregp_x(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = (OC[Offset] & 0x01) << 8;
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg += 8;
+ uint32_t Off = ((OC[Offset + 1] & 0x3F) + 1) << 3;
+ if (Prologue)
+ SW.startLine() << format(
+ "0x%02x%02x ; stp d%u, d%u, [sp, #-%u]!\n", OC[Offset],
+ OC[Offset + 1], Reg, Reg + 1, Off);
+ else
+ SW.startLine() << format(
+ "0x%02x%02x ; ldp d%u, d%u, [sp], #%u\n", OC[Offset],
+ OC[Offset + 1], Reg, Reg + 1, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_freg(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = (OC[Offset] & 0x01) << 8;
+ Reg |= (OC[Offset + 1] & 0xC0);
+ Reg >>= 6;
+ Reg += 8;
+ uint32_t Off = (OC[Offset + 1] & 0x3F) << 3;
+ SW.startLine() << format("0x%02x%02x ; %s d%u, [sp, #%u]\n",
+ OC[Offset], OC[Offset + 1],
+ static_cast<const char *>(Prologue ? "str" : "ldr"),
+ Reg, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_save_freg_x(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ uint32_t Reg = ((OC[Offset + 1] & 0xE0) >> 5) + 8;
+ uint32_t Off = ((OC[Offset + 1] & 0x1F) + 1) << 3;
+ if (Prologue)
+ SW.startLine() << format(
+ "0x%02x%02x ; str d%u, [sp, #-%u]!\n", OC[Offset],
+ OC[Offset + 1], Reg, Off);
+ else
+ SW.startLine() << format(
+ "0x%02x%02x ; ldr d%u, [sp], #%u\n", OC[Offset],
+ OC[Offset + 1], Reg, Off);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_alloc_l(const uint8_t *OC, unsigned &Offset,
+ unsigned Length, bool Prologue) {
+ unsigned Off =
+ (OC[Offset + 1] << 16) | (OC[Offset + 2] << 8) | (OC[Offset + 3] << 0);
+ Off <<= 4;
+ SW.startLine() << format(
+ "0x%02x%02x%02x%02x ; %s sp, #%u\n", OC[Offset], OC[Offset + 1],
+ OC[Offset + 2], OC[Offset + 3],
+ static_cast<const char *>(Prologue ? "sub" : "add"), Off);
+ Offset += 4;
+ return false;
+}
+
+bool Decoder::opcode_setfp(const uint8_t *OC, unsigned &Offset, unsigned Length,
+ bool Prologue) {
+ SW.startLine() << format("0x%02x ; mov fp, sp\n", OC[Offset]);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_addfp(const uint8_t *OC, unsigned &Offset, unsigned Length,
+ bool Prologue) {
+ unsigned NumBytes = OC[Offset + 1] << 3;
+ SW.startLine() << format("0x%02x%02x ; add fp, sp, #%u\n",
+ OC[Offset], OC[Offset + 1], NumBytes);
+ Offset += 2;
+ return false;
+}
+
+bool Decoder::opcode_nop(const uint8_t *OC, unsigned &Offset, unsigned Length,
+ bool Prologue) {
+ SW.startLine() << format("0x%02x ; nop\n", OC[Offset]);
+ ++Offset;
+ return false;
+}
+
+bool Decoder::opcode_end(const uint8_t *OC, unsigned &Offset, unsigned Length,
+ bool Prologue) {
+ SW.startLine() << format("0x%02x ; end\n", OC[Offset]);
+ ++Offset;
+ return true;
+}
+
+bool Decoder::opcode_end_c(const uint8_t *OC, unsigned &Offset, unsigned Length,
+ bool Prologue) {
+ SW.startLine() << format("0x%02x ; end_c\n", OC[Offset]);
+ ++Offset;
+ return true;
+}
+
void Decoder::decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
bool Prologue) {
assert((!Prologue || Offset == 0) && "prologue should always use offset 0");
-
+ const RingEntry* DecodeRing = isAArch64 ? Ring64 : Ring;
bool Terminated = false;
for (unsigned OI = Offset, OE = Opcodes.size(); !Terminated && OI < OE; ) {
for (unsigned DI = 0;; ++DI) {
- if ((Opcodes[OI] & Ring[DI].Mask) == Ring[DI].Value) {
- Terminated = (this->*Ring[DI].Routine)(Opcodes.data(), OI, 0, Prologue);
+ if ((isAArch64 && (DI >= array_lengthof(Ring64))) ||
+ (!isAArch64 && (DI >= array_lengthof(Ring)))) {
+ SW.startLine() << format("0x%02x ; Bad opcode!\n",
+ Opcodes.data()[Offset]);
+ ++OI;
break;
}
- assert(DI < array_lengthof(Ring) && "unhandled opcode");
+
+ if ((Opcodes[OI] & DecodeRing[DI].Mask) == DecodeRing[DI].Value) {
+ if (OI + DecodeRing[DI].Length > OE) {
+ SW.startLine() << format("Opcode 0x%02x goes past the unwind data\n",
+ Opcodes[OI]);
+ OI += DecodeRing[DI].Length;
+ break;
+ }
+ Terminated =
+ (this->*DecodeRing[DI].Routine)(Opcodes.data(), OI, 0, Prologue);
+ break;
+ }
}
}
}
@@ -520,22 +819,36 @@
uint64_t Offset = VA - SectionVA;
const ulittle32_t *Data =
reinterpret_cast<const ulittle32_t *>(Contents.data() + Offset);
- const ExceptionDataRecord XData(Data);
+ // Sanity check to ensure that the .xdata header is present.
+ // A header is one or two words, followed by at least one word to describe
+ // the unwind codes. Applicable to both ARM and AArch64.
+ if (Contents.size() - Offset < 8)
+ report_fatal_error(".xdata must be at least 8 bytes in size");
+
+ const ExceptionDataRecord XData(Data, isAArch64);
DictScope XRS(SW, "ExceptionData");
- SW.printNumber("FunctionLength", XData.FunctionLength() << 1);
+ SW.printNumber("FunctionLength",
+ isAArch64 ? XData.FunctionLengthInBytesAArch64() :
+ XData.FunctionLengthInBytesARM());
SW.printNumber("Version", XData.Vers());
SW.printBoolean("ExceptionData", XData.X());
SW.printBoolean("EpiloguePacked", XData.E());
- SW.printBoolean("Fragment", XData.F());
+ if (!isAArch64)
+ 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)));
+ uint64_t ByteCodeLength = XData.CodeWords() * sizeof(uint32_t);
+ SW.printNumber("ByteCodeLength", ByteCodeLength);
+
+ if ((int64_t)(Contents.size() - Offset - 4 * HeaderWords(XData) -
+ (XData.E() ? 0 : XData.EpilogueCount() * 4) -
+ (XData.X() ? 8 : 0)) < (int64_t)ByteCodeLength)
+ report_fatal_error("Malformed unwind data");
if (XData.E()) {
ArrayRef<uint8_t> UC = XData.UnwindByteCode();
- if (!XData.F()) {
+ if (isAArch64 || !XData.F()) {
ListScope PS(SW, "Prologue");
decodeOpcodes(UC, 0, /*Prologue=*/true);
}
@@ -544,16 +857,25 @@
decodeOpcodes(UC, XData.EpilogueCount(), /*Prologue=*/false);
}
} else {
+ {
+ ListScope PS(SW, "Prologue");
+ decodeOpcodes(XData.UnwindByteCode(), 0, /*Prologue=*/true);
+ }
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());
+ if (!isAArch64)
+ SW.printNumber("Condition", ES.Condition());
+ SW.printNumber("EpilogueStartIndex",
+ isAArch64 ? ES.EpilogueStartIndexAArch64()
+ : ES.EpilogueStartIndexARM());
ListScope Opcodes(SW, "Opcodes");
- decodeOpcodes(XData.UnwindByteCode(), ES.EpilogueStartIndex(),
+ decodeOpcodes(XData.UnwindByteCode(),
+ isAArch64 ? ES.EpilogueStartIndexAArch64()
+ : ES.EpilogueStartIndexARM(),
/*Prologue=*/false);
}
}
@@ -725,8 +1047,9 @@
}
SW.printString("Function", formatSymbol(FunctionName, FunctionAddress));
- SW.printBoolean("Fragment",
- RF.Flag() == RuntimeFunctionFlag::RFF_PackedFragment);
+ if (!isAArch64)
+ SW.printBoolean("Fragment",
+ RF.Flag() == RuntimeFunctionFlag::RFF_PackedFragment);
SW.printNumber("FunctionLength", RF.FunctionLength());
SW.startLine() << "ReturnType: " << RF.Ret() << '\n';
SW.printBoolean("HomedParameters", RF.H());
@@ -749,6 +1072,10 @@
DictScope RFS(SW, "RuntimeFunction");
if (Entry.Flag() == RuntimeFunctionFlag::RFF_Unpacked)
return dumpUnpackedEntry(COFF, Section, Offset, Index, Entry);
+ if (isAArch64) {
+ llvm::errs() << "Packed unwind data not yet supported for ARM64\n";
+ return false;
+ }
return dumpPackedEntry(COFF, Section, Offset, Index, Entry);
}
diff --git a/llvm/tools/llvm-readobj/ARMWinEHPrinter.h b/llvm/tools/llvm-readobj/ARMWinEHPrinter.h
index 95f5217..e271a1e 100644
--- a/llvm/tools/llvm-readobj/ARMWinEHPrinter.h
+++ b/llvm/tools/llvm-readobj/ARMWinEHPrinter.h
@@ -24,13 +24,16 @@
ScopedPrinter &SW;
raw_ostream &OS;
+ bool isAArch64;
struct RingEntry {
uint8_t Mask;
uint8_t Value;
+ uint8_t Length;
bool (Decoder::*Routine)(const uint8_t *, unsigned &, unsigned, bool);
};
static const RingEntry Ring[];
+ static const RingEntry Ring64[];
bool opcode_0xxxxxxx(const uint8_t *Opcodes, unsigned &Offset,
unsigned Length, bool Prologue);
@@ -75,6 +78,50 @@
bool opcode_11111111(const uint8_t *Opcodes, unsigned &Offset,
unsigned Length, bool Prologue);
+ // ARM64 unwind codes start here.
+ bool opcode_alloc_s(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_save_r19r20_x(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_fplr(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_fplr_x(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_alloc_m(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_save_regp(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_regp_x(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_reg(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_reg_x(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_lrpair(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_fregp(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_fregp_x(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_freg(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_save_freg_x(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+ bool opcode_alloc_l(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_setfp(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_addfp(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_nop(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_end(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_end_c(const uint8_t *Opcodes, unsigned &Offset, unsigned Length,
+ bool Prologue);
+ bool opcode_save_next(const uint8_t *Opcodes, unsigned &Offset,
+ unsigned Length, bool Prologue);
+
void decodeOpcodes(ArrayRef<uint8_t> Opcodes, unsigned Offset,
bool Prologue);
@@ -107,7 +154,9 @@
const object::SectionRef Section);
public:
- Decoder(ScopedPrinter &SW) : SW(SW), OS(SW.getOStream()) {}
+ Decoder(ScopedPrinter &SW, bool isAArch64) : SW(SW),
+ OS(SW.getOStream()),
+ isAArch64(isAArch64) {}
std::error_code dumpProcedureData(const object::COFFObjectFile &COFF);
};
}
diff --git a/llvm/tools/llvm-readobj/COFFDumper.cpp b/llvm/tools/llvm-readobj/COFFDumper.cpp
index fe31c36..26fe1aa 100644
--- a/llvm/tools/llvm-readobj/COFFDumper.cpp
+++ b/llvm/tools/llvm-readobj/COFFDumper.cpp
@@ -1549,8 +1549,10 @@
Dumper.printData(Ctx);
break;
}
+ case COFF::IMAGE_FILE_MACHINE_ARM64:
case COFF::IMAGE_FILE_MACHINE_ARMNT: {
- ARM::WinEH::Decoder Decoder(W);
+ ARM::WinEH::Decoder Decoder(W, Obj->getMachine() ==
+ COFF::IMAGE_FILE_MACHINE_ARM64);
Decoder.dumpProcedureData(*Obj);
break;
}