[ARM64] [Windows] Add unwind support to llvm-readobj

[ssijaric]

Summary

This patch adds support for dumping the unwind info from ARM64 COFF object files. This is required so that we can add test cases to https://reviews.llvm.org/D50166 (MCLayer support for ARM64 exception handling). Only unpacked unwind data is supported, as that is what D50166 currently supports.

I tested this with objects produced by both cl.exe and clang that includes the Windows ARM64 exception handling patches. The output that is produced looks like:

Case 1: single epilogue
File: test.obj
Format: COFF-ARM64
Arch: aarch64
AddressSize: 64bit
UnwindInformation [

RuntimeFunction {
  Function: $LN6 (0x0)
  ExceptionRecord: $unwind$?func@@YAHH@Z (0x0)
  ExceptionData {
    FunctionLength: 340
    Version: 0
    ExceptionData: No
    EpiloguePacked: Yes
    EpilogueOffset: 15
    ByteCodeLength: 28
    Prologue [
      0xe002dac8          ; sub sp, #2993280
      0xe3                ; nop
      0xe3                ; nop
      0xe3                ; nop
      0xd885              ; stp d10, d11, [sp, #40]
      0xd803              ; stp d8, d9, [sp, #24]
      0xd2c2              ; str x30, [sp, #16]
      0x28                ; stp x19, x20, [sp, #-64]!
      0xe4                ; end
    ]
    Epilogue [
      0xe002dac8          ; add sp, #2993280
      0xd885              ; ldp d10, d11, [sp, #40]
      0xd803              ; ldp d8, d9, [sp, #24]
      0xd2c2              ; ldr x30, [sp, #16]
      0x28                ; ldp x19, x20, [sp], #64
      0xe4                ; end
    ]
  }
}

]

Case 2: multiple epilogues
File: test1.obj
Format: COFF-ARM64
Arch: aarch64
AddressSize: 64bit
UnwindInformation [

RuntimeFunction {
  Function: $LN6 (0x0)
  ExceptionRecord: $unwind$?func@@YAHH@Z (0x0)
  ExceptionData {
    FunctionLength: 72
    Version: 0
    ExceptionData: No
    EpiloguePacked: No
    EpilogueScopes: 2
    ByteCodeLength: 8
    Prologue [
      0x1f                ; sub sp, #496
      0xd600              ; stp x19, lr, [sp, #0]
      0x01                ; sub sp, #16
      0xe4                ; end
    ]
    EpilogueScopes [
      EpilogueScope {
        StartOffset: 8
        EpilogueStartIndex: 0
        Opcodes [
          0x1f                ; add sp, #496
          0xd600              ; ldp x19, lr, [sp, #0]
          0x01                ; add sp, #16
          0xe4                ; end
        ]
      }
      EpilogueScope {
        StartOffset: 14
        EpilogueStartIndex: 0
        Opcodes [
          0x1f                ; add sp, #496
          0xd600              ; ldp x19, lr, [sp, #0]
          0x01                ; add sp, #16
          0xe4                ; end
        ]
      }
    ]
  }
}

]

Testing uncovered an encoding issue for the large stack size unwind opcode in D50166. I will update that patch with the fix and test cases that rely on this patch.

[efriedma]

This probably needs at least a few testcases... not so much to duplicate the tests you're going to add for exception handling emission, but rather to make sure the error handling works correctly.

include/llvm/Support/ARMWinEH.h

343

Using a template here is not helping make the code more readable.

Maybe there should be one function for both ARM and AArch64 that takes a reference to the ExceptionDataRecord?

tools/llvm-readobj/ARMWinEHPrinter.cpp

798–799

Not new with your patch, but we need real error handling here, in case of an unknown opcode, or a multi-byte opcode which would run past the end of the opcode array.

814–821

Missing bounds check? There must be at least 8 bytes of data in the section after the offset, and you need to check the total number of bytes specified by the header vs. the remaining bytes in the section.

824

Probably makes sense to add ExceptionDataRecord::FunctionLengthInBytes(), or something like that.

843

Not really part of your patch, but I'm not sure why we're checking XData.F() here. Maybe just leave a FIXME.

852

"if (true)"?

1067

It's okay not to implement this for now, but it should probably do something other than crash (e.g. print a message that packed unwind is not yet implemented).

[ssijaric]

tools/llvm-readobj/ARMWinEHPrinter.cpp

798–799

I will change this to print something like "bad opcode" and continue scanning.

814–821

Will add a check that the .xdata must be at least 8 bytes.

843

The check for F() is applicable to ARM only, and indicates that there is no prologue (e.g. a function fragment) So !XData.F() indicates that there is a prologue, and we dump the opcodes for ARM. Not used for AArch64.

852

Yes, otherwise ListScope will not align the prologue printing with epilogue printing when there multiple epilogues.

1067

Ok, will do that.

[ssijaric]

Addressed Eli's comments.

Added two obj files produced by cl.exe for testing purposes.

Still need to add a test case or two to check the error handling that was added in this patch.

[efriedma]

tools/llvm-readobj/ARMWinEHPrinter.cpp

798–799

Ring64

800

80 columns

801

break;

842

I thought you implemented this...? At least at first glance, ExceptionDataRecord tries to do the right thing.

846

I think the subtraction here can overflow.

[ssijaric]

tools/llvm-readobj/ARMWinEHPrinter.cpp

842

I don't see that this is supported in the current implementation of llvm-readobj. I don't plan to add it right now.

It is supported in the MCLayer part, however. It needs testing, but is not part of this patch.

[ssijaric]

tools/llvm-readobj/ARMWinEHPrinter.cpp

842

It is actually supported, thanks for pointing it out.

[ssijaric]

Fix bugs and add two assembly test cases constructed by hand to test the error handling.

[efriedma]

I think this is looking good; hopefully Reid will get a chance to look briefly to make sure this matches what he was expecting.

tools/llvm-readobj/ARMWinEHPrinter.cpp

785

This can still read a few bytes past the end of the unwind data if, for example, the last byte is 0xe0.

837

Needs another 8 bytes if X() is set.

The literal "4" for the header should be 4 * HeaderWords().

[ssijaric]

Address Eli's latest feedback, and an add an additional test case.

[efriedma]

tools/llvm-readobj/ARMWinEHPrinter.cpp

789

It's wrong to read past the end of the section, and then print an error afterwards, rather than checking before you read the data; you can't print an error after llvm-readobj crashes. (You're only reading a few bytes past the end of the section, so you can get away with it sometimes, but not in general.)

Maybe the RingEntry should contain the opcode size.

[ssijaric]

tools/llvm-readobj/ARMWinEHPrinter.cpp

789

I will change it, but I also have to account for the ARM opcode length as well then. This can just introduce more problems if I get the unwind length wrong. Error handling in llvm-readobj is not the intent of this particular patch.

[efriedma]

tools/llvm-readobj/ARMWinEHPrinter.cpp

789

If you want to add a FIXME and leave it for a followup, that's okay, I think.

[ssijaric]

Better error handling. Fix alloc_m decoding.

[ssijaric]

Also fix a few unwind code hex dumps. Wasn't printing all the bytes.

[ssijaric]

Fix a few operator precedence bugs uncovered while writing test cases for the MCLayer patch (D50166).

[rnk]

I'm happy with this if @efriedma is happy with this, it looks like he thoroughly reviewed it. Sorry for the delay, I was at the dev meeting last week.

tools/llvm-readobj/ARMWinEHPrinter.cpp

119

Hah. Thanks for using symbolic names. :)

[efriedma]

LGTM, with a couple minor comments.

tools/llvm-readobj/ARMWinEHPrinter.cpp

745

Please remove this assertion; even if it isn't valid, it shouldn't crash. Same for addfp. (I guess you could add an error message to the output, but that doesn't seem too important.)

795

Please make sure this isn't reading past the end of the Ring64 array. (It looks like it might read one element past the end?)

[ssijaric]

Address Eli's latest comments.

[ssijaric]

Fix the printing of save_freg and save_freg_x that Eli just pointed out.

[efriedma]

LGTM

include/llvm/Support/ARMWinEH.h

 }
 
 /// SavedRegisterMask - Utility function to calculate the set of saved general
 /// purpose (r0-r15) and VFP (d0-d31) registers.
 std::pair<uint16_t, uint32_t> SavedRegisterMask(const RuntimeFunction &RF);
 
 /// ExceptionDataRecord - An entry in the table of exception data (.xdata)
 ///
+/// The format on ARM is:
+///
 ///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
 ///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 /// +-------+---------+-+-+-+---+-----------------------------------+
 /// | C Wrd | Epi Cnt |F|E|X|Ver|         Function Length           |
 /// +-------+--------+'-'-'-'---'---+-------------------------------+
 /// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
 /// +-------+--------+--------------+-------------------------------+
 ///
+/// The format on ARM64 is:
+///
+///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+/// +---------+---------+-+-+---+-----------------------------------+
+/// |  C Wrd  | Epi Cnt |E|X|Ver|         Function Length           |
+/// +---------+------+--'-'-'---'---+-------------------------------+
+/// |    Reserved    |Ex. Code Words|   (Extended Epilogue Count)   |
+/// +-------+--------+--------------+-------------------------------+
+///
 /// Function Length : 18-bit field indicating the total length of the function
 ///                   in bytes divided by 2.  If a function is larger than
 ///                   512KB, then multiple pdata and xdata records must be used.
 /// Vers : 2-bit field describing the version of the remaining structure.  Only
 ///        version 0 is currently defined (values 1-3 are not permitted).
 /// X : 1-bit field indicating the presence of exception data
 /// E : 1-bit field indicating that the single epilogue is packed into the
 ///     header
 /// F : 1-bit field indicating that the record describes a function fragment
 ///     (implies that no prologue is present, and prologue processing should be
-///     skipped)
+///     skipped) (ARM only)
 /// Epilogue Count : 5-bit field that differs in meaning based on the E field.
 ///
 ///                  If E is set, then this field specifies the index of the
 ///                  first unwind code describing the (only) epilogue.
 ///
 ///                  Otherwise, this field indicates the number of exception
 ///                  scopes.  If more than 31 scopes exist, then this field and
 ///                  the Code Words field must both be set to 0 to indicate that
 ///                  an extension word is required.
-/// Code Words : 4-bit field that species the number of 32-bit words needed to
-///              contain all the unwind codes.  If more than 15 words (63 code
-///              bytes) are required, then this field and the Epilogue Count
-///              field must both be set to 0 to indicate that an extension word
-///              is required.
+/// Code Words : 4-bit (5-bit on ARM64) field that specifies the number of
+///              32-bit words needed to contain all the unwind codes.  If more
+///              than 15 words (31 words on ARM64) are required, then this field
+///              and the Epilogue Count field must both be set to 0 to indicate
+///              that an extension word is required.
 /// Extended Epilogue Count, Extended Code Words :
 ///                          Valid only if Epilog Count and Code Words are both
 ///                          set to 0.  Provides an 8-bit extended code word
 ///                          count and 16-bits for epilogue count
 ///
+/// The epilogue scope format on ARM is:
+///
 ///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
 ///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 /// +----------------+------+---+---+-------------------------------+
 /// |  Ep Start Idx  | Cond |Res|       Epilogue Start Offset       |
 /// +----------------+------+---+-----------------------------------+
 ///
+/// The epilogue scope format on ARM64 is:
+///
+///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+/// +-------------------+-------+---+-------------------------------+
+/// |  Ep Start Idx     |  Res  |   Epilogue Start Offset           |
+/// +-------------------+-------+-----------------------------------+
+///
 /// If the E bit is unset in the header, the header is followed by a series of
 /// epilogue scopes, which are sorted by their offset.
 ///
 /// Epilogue Start Offset: 18-bit field encoding the offset of epilogue relative
 ///                        to the start of the function in bytes divided by two
 /// Res : 2-bit field reserved for future expansion (must be set to 0)
-/// Condition : 4-bit field providing the condition under which the epilogue is
-///             executed.  Unconditional epilogues should set this field to 0xe.
-///             Epilogues must be entirely conditional or unconditional, and in
-///             Thumb-2 mode.  The epilogue beings with the first instruction
-///             after the IT opcode.
+/// Condition : (ARM only) 4-bit field providing the condition under which the
+///             epilogue is executed.  Unconditional epilogues should set this
+///             field to 0xe. Epilogues must be entirely conditional or
+///             unconditional, and in Thumb-2 mode.  The epilogue begins with
+///             the first instruction after the IT opcode.
 /// Epilogue Start Index : 8-bit field indicating the byte index of the first
 ///                        unwind code describing the epilogue
 ///
 ///  3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
 ///  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 /// +---------------+---------------+---------------+---------------+
 /// | Unwind Code 3 | Unwind Code 2 | Unwind Code 1 | Unwind Code 0 |
 /// +---------------+---------------+---------------+---------------+

 /// which is the address to the exception handler, followed immediately by the
 /// variable length data associated with the exception handler.
 ///
 
 struct EpilogueScope {
   const support::ulittle32_t ES;
 
   EpilogueScope(const support::ulittle32_t Data) : ES(Data) {}
+  // Same for both ARM and AArch64.
   uint32_t EpilogueStartOffset() const {
     return (ES & 0x0003ffff);
   }
-  uint8_t Res() const {
+
+  // Different implementations for ARM and AArch64.
+  uint8_t ResARM() const {
     return ((ES & 0x000c0000) >> 18);
   }
+
+  uint8_t ResAArch64() const {
+    return ((ES & 0x000f0000) >> 18);
+  }
+
+  // Condition is only applicable to ARM.
   uint8_t Condition() const {
     return ((ES & 0x00f00000) >> 20);
   }
-  uint8_t EpilogueStartIndex() const {
+
+  // Different implementations for ARM and AArch64.
+  uint8_t EpilogueStartIndexARM() const {
     return ((ES & 0xff000000) >> 24);
   }
+
+  uint8_t EpilogueStartIndexAArch64() const {
+    return ((ES & 0xffc00000) >> 22);
+  }
 };
 
 struct ExceptionDataRecord;
 inline size_t HeaderWords(const ExceptionDataRecord &XR);
 
 struct ExceptionDataRecord {
   const support::ulittle32_t *Data;
+  bool isAArch64;
 
-  ExceptionDataRecord(const support::ulittle32_t *Data) : Data(Data) {}
+  ExceptionDataRecord(const support::ulittle32_t *Data, bool isAArch64) :
+    Data(Data), isAArch64(isAArch64) {}
 
   uint32_t FunctionLength() const {
     return (Data[0] & 0x0003ffff);
   }
 
+  uint32_t FunctionLengthInBytesARM() const {
+    return FunctionLength() << 1;
+  }
+
+  uint32_t FunctionLengthInBytesAArch64() const {
+    return FunctionLength() << 2;
+  }
+
   uint8_t Vers() const {
     return (Data[0] & 0x000C0000) >> 18;
   }
 
   bool X() const {
     return ((Data[0] & 0x00100000) >> 20);
   }
 
   bool E() const {
     return ((Data[0] & 0x00200000) >> 21);
   }
 
   bool F() const {
+    assert(!isAArch64 && "Fragments are only supported on ARMv7 WinEH");
     return ((Data[0] & 0x00400000) >> 22);
   }
 
   uint8_t EpilogueCount() const {
-    if (HeaderWords(*this) == 1)
+    if (HeaderWords(*this) == 1) {
+      if (isAArch64)
+        return (Data[0] & 0x07C00000) >> 22;
       return (Data[0] & 0x0f800000) >> 23;
+    }
     return Data[1] & 0x0000ffff;
   }
 
   uint8_t CodeWords() const {
-    if (HeaderWords(*this) == 1)
+    if (HeaderWords(*this) == 1) {
+      if (isAArch64)
+        return (Data[0] & 0xf8000000) >> 27;
       return (Data[0] & 0xf0000000) >> 28;
+    }
     return (Data[1] & 0x00ff0000) >> 16;
   }
 
   ArrayRef<support::ulittle32_t> EpilogueScopes() const {
     assert(E() == 0 && "epilogue scopes are only present when the E bit is 0");
     size_t Offset = HeaderWords(*this);
     return makeArrayRef(&Data[Offset], EpilogueCount());
   }
struct ExceptionDataRecord {
 
   uint32_t ExceptionHandlerParameter() const {
     assert(X() && "Exception Handler RVA is only valid if the X bit is set");
     return Data[HeaderWords(*this) + EpilogueCount() + CodeWords() + 1];
   }
 };
 
 inline size_t HeaderWords(const ExceptionDataRecord &XR) {
+  if (XR.isAArch64)
+    return (XR.Data[0] & 0xffc0000) ? 1 : 2;
   return (XR.Data[0] & 0xff800000) ? 1 : 2;
 }
 }
 }
 }
 
 #endif

test/tools/llvm-readobj/arm64-win-error1.s

+## Check that error handling for bad opcodes works.
+## .xdata below contains the bad opcode 0xdf in the 4th word of .xdata.
+
+// REQUIRES: aarch64-registered-target
+// RUN: llvm-mc -filetype=obj -triple aarch64-windows %s -o - \
+// RUN:   | llvm-readobj -unwind - | FileCheck %s
+
+// CHECK:     Prologue [
+// CHECK:        0xdf                ; Bad opcode!
+// CHECK:        0xd600              ; stp x19, lr, [sp, #0]
+// CHECK:        0x01                ; sub sp, #16
+// CHECK:        0xe4                ; end
+// CHECK:     ]
+
+  .text
+  .globl  "?func@@YAHXZ"
+  .p2align  3
+"?func@@YAHXZ":
+  sub     sp,sp,#0x10
+  stp     x19,lr,[sp]
+  sub     sp,sp,#0x1F0
+        mov     w19,w0
+  bl  "?func2@@YAXXZ"
+  cmp     w19,#2
+  ble     .LBB0_1
+  bl      "?func2@@YAHXZ"
+  add      sp,sp,#0x1F0
+  ldp      x19,lr,[sp]
+  add      sp,sp,#0x10
+  ret
+.LBB0_1:
+  mov      x0,sp
+  bl       "?func3@@YAHPEAH@Z"
+  add      sp,sp,#0x1F0
+  ldp      x19,lr,[sp]
+  add      sp,sp,#0x10
+  ret
+
+
+.section .pdata,"dr"
+  .long "?func@@YAHXZ"@IMGREL
+        .long "$unwind$func@@YAHXZ"@IMGREL
+
+
+.section  .xdata,"dr"
+"$unwind$func@@YAHXZ":
+        .p2align  3
+  .long   0x10800012
+  .long     0x8
+  .long     0xe
+  .long     0x100d6df
+  .long     0xe3e3e3e4
+

test/tools/llvm-readobj/arm64-win-error2.s

+## Check that the sanity check for an inconsistent header works.
+## The first word contains the bad value for CodeWords, 0xf, which indicates
+## that we need 0x11110 << 2 =  120 bytes of space for the unwind codes.
+## It follows that the .xdata section is badly formed as only 8 bytes are
+## allocated for the unwind codes.
+
+// REQUIRES: aarch64-registered-target
+// RUN: llvm-mc -filetype=obj -triple aarch64-windows %s -o - \
+// RUN:   | not llvm-readobj -unwind - 2>&1 | FileCheck %s
+
+// CHECK: LLVM ERROR: Malformed unwind data
+
+  .text
+  .globl  "?func@@YAHXZ"
+  .p2align  3
+"?func@@YAHXZ":
+  sub     sp,sp,#0x10
+  stp     x19,lr,[sp]
+  sub     sp,sp,#0x1F0
+        mov     w19,w0
+  bl  "?func2@@YAXXZ"
+  cmp     w19,#2
+  ble     .LBB0_1
+  bl      "?func2@@YAHXZ"
+  add      sp,sp,#0x1F0
+  ldp      x19,lr,[sp]
+  add      sp,sp,#0x10
+  ret
+.LBB0_1:
+  mov      x0,sp
+  bl       "?func3@@YAHPEAH@Z"
+  add      sp,sp,#0x1F0
+  ldp      x19,lr,[sp]
+  add      sp,sp,#0x10
+  ret
+
+.section .pdata,"dr"
+  .long "?func@@YAHXZ"@IMGREL
+        .long "$unwind$func@@YAHXZ"@IMGREL
+
+
+.section  .xdata,"dr"
+"$unwind$func@@YAHXZ":
+        .p2align  3
+  .long   0xf0800012
+  .long     0x8
+  .long     0xe
+  .long     0x100d61f
+  .long     0xe3e3e3e4
+

test/tools/llvm-readobj/arm64-win-error3.s

+## Check that error handling for going past the unwind data works.
+## .xdata below contains bad opcodes in the last word.  The last byte, 0xe0,
+## indicates that we have come across alloc_l, which requires 4 bytes. In this
+## case, unwind code processing will go past the allocated unwind data.
+
+// REQUIRES: aarch64-registered-target
+// RUN: llvm-mc -filetype=obj -triple aarch64-windows %s -o - \
+// RUN:   | llvm-readobj -unwind - | FileCheck %s
+
+// CHECK: Prologue [
+// CHECK:   The last opcode is likely bad, as we have gone past the unwind data
+
+  .text
+  .globl  "?func@@YAHXZ"
+  .p2align  3
+"?func@@YAHXZ":
+  sub     sp,sp,#0x10
+  stp     x19,lr,[sp]
+  sub     sp,sp,#0x1F0
+        mov     w19,w0
+  bl  "?func2@@YAXXZ"
+  cmp     w19,#2
+  ble     .LBB0_1
+  bl      "?func2@@YAHXZ"
+  add      sp,sp,#0x1F0
+  ldp      x19,lr,[sp]
+  add      sp,sp,#0x10
+  ret
+.LBB0_1:
+  mov      x0,sp
+  bl       "?func3@@YAHPEAH@Z"
+  add      sp,sp,#0x1F0
+  ldp      x19,lr,[sp]
+  add      sp,sp,#0x10
+  ret
+
+
+.section .pdata,"dr"
+  .long "?func@@YAHXZ"@IMGREL
+        .long "$unwind$func@@YAHXZ"@IMGREL
+
+
+.section  .xdata,"dr"
+"$unwind$func@@YAHXZ":
+        .p2align  3
+  .long   0x10800012
+  .long     0x8
+  .long     0xe
+  .long     0x100d61f
+  .long     0xe0000000
+

test/tools/llvm-readobj/unwind-arm64-windows.test

+RUN: llvm-readobj -unwind %p/Inputs/arm64-win1.obj | FileCheck %s -check-prefix=UNWIND1
+RUN: llvm-readobj -unwind %p/Inputs/arm64-win2.obj | FileCheck %s -check-prefix=UNWIND2
+
+UNWIND1:         ExceptionData {
+UNWIND1-NEXT:      FunctionLength: 340
+UNWIND1-NEXT:      Version: 0
+UNWIND1-NEXT:      ExceptionData: No
+UNWIND1-NEXT:      EpiloguePacked: Yes
+UNWIND1-NEXT:      EpilogueOffset: 15
+UNWIND1-NEXT:      ByteCodeLength: 28
+UNWIND1-NEXT:      Prologue [
+UNWIND1-NEXT:        0xe002dac8          ; sub sp, #2993280
+UNWIND1-NEXT:        0xe3                ; nop
+UNWIND1-NEXT:        0xe3                ; nop
+UNWIND1-NEXT:        0xe3                ; nop
+UNWIND1-NEXT:        0xd885              ; stp d10, d11, [sp, #40]
+UNWIND1-NEXT:        0xd803              ; stp d8, d9, [sp, #24]
+UNWIND1-NEXT:        0xd2c2              ; str x30, [sp, #16]
+UNWIND1-NEXT:        0x28                ; stp x19, x20, [sp, #-64]!
+UNWIND1-NEXT:        0xe4                ; end
+UNWIND1-NEXT:      ]
+UNWIND1-NEXT:      Epilogue [
+UNWIND1-NEXT:        0xe002dac8          ; add sp, #2993280
+UNWIND1-NEXT:        0xd885              ; ldp d10, d11, [sp, #40]
+UNWIND1-NEXT:        0xd803              ; ldp d8, d9, [sp, #24]
+UNWIND1-NEXT:        0xd2c2              ; ldr x30, [sp, #16]
+UNWIND1-NEXT:        0x28                ; ldp x19, x20, [sp], #64
+UNWIND1-NEXT:        0xe4                ; end
+UNWIND1-NEXT:      ]
+UNWIND1_NEXT:    }
+
+
+UNWIND2:         ExceptionData {
+UNWIND2-NEXT:      FunctionLength: 72
+UNWIND2-NEXT:      Version: 0
+UNWIND2-NEXT:      ExceptionData: No
+UNWIND2-NEXT:      EpiloguePacked: No
+UNWIND2-NEXT:      EpilogueScopes: 2
+UNWIND2-NEXT:      ByteCodeLength: 8
+UNWIND2-NEXT:      Prologue [
+UNWIND2-NEXT:        0x1f                ; sub sp, #496
+UNWIND2-NEXT:        0xd600              ; stp x19, lr, [sp, #0]
+UNWIND2-NEXT:        0x01                ; sub sp, #16
+UNWIND2-NEXT:        0xe4                ; end
+UNWIND2-NEXT:      ]
+UNWIND2-NEXT:      EpilogueScopes [
+UNWIND2-NEXT:        EpilogueScope {
+UNWIND2-NEXT:          StartOffset: 8
+UNWIND2-NEXT:          EpilogueStartIndex: 0
+UNWIND2-NEXT:          Opcodes [
+UNWIND2-NEXT:            0x1f                ; add sp, #496
+UNWIND2-NEXT:            0xd600              ; ldp x19, lr, [sp, #0]
+UNWIND2-NEXT:            0x01                ; add sp, #16
+UNWIND2-NEXT:            0xe4                ; end
+UNWIND2-NEXT:          ]
+UNWIND2-NEXT:        }
+UNWIND2-NEXT:        EpilogueScope {
+UNWIND2-NEXT:          StartOffset: 14
+UNWIND2-NEXT:          EpilogueStartIndex: 0
+UNWIND2-NEXT:          Opcodes [
+UNWIND2-NEXT:            0x1f                ; add sp, #496
+UNWIND2-NEXT:            0xd600              ; ldp x19, lr, [sp, #0]
+UNWIND2-NEXT:            0x01                ; add sp, #16
+UNWIND2-NEXT:            0xe4                ; end
+UNWIND2-NEXT:          ]
+UNWIND2-NEXT:        }
+UNWIND2-NEXT:      ]
+UNWIND2-NEXT:    }
+

tools/llvm-readobj/ARMWinEHPrinter.h

 namespace WinEH {
 class RuntimeFunction;
 
 class Decoder {
   static const size_t PDataEntrySize;
 
   ScopedPrinter &SW;
   raw_ostream &OS;
+  bool isAArch64;
 
   struct RingEntry {
     uint8_t Mask;
     uint8_t Value;
     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);
   bool opcode_10Lxxxxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
   bool opcode_1100xxxx(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
   bool opcode_11010Lxx(const uint8_t *Opcodes, unsigned &Offset,
bool opcode_11111100(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
   bool opcode_11111101(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
   bool opcode_11111110(const uint8_t *Opcodes, unsigned &Offset,
                        unsigned Length, bool Prologue);
   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);
 
   void printRegisters(const std::pair<uint16_t, uint32_t> &RegisterMask);
 
   ErrorOr<object::SectionRef>
   getSectionContaining(const object::COFFObjectFile &COFF, uint64_t Address);
 
bool dumpPackedEntry(const object::COFFObjectFile &COFF,
                        unsigned Index, const RuntimeFunction &Entry);
   bool dumpProcedureDataEntry(const object::COFFObjectFile &COFF,
                               const object::SectionRef Section, unsigned Entry,
                               ArrayRef<uint8_t> Contents);
   void dumpProcedureData(const object::COFFObjectFile &COFF,
                          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);
 };
 }
 }
 }
 
 #endif

tools/llvm-readobj/ARMWinEHPrinter.cpp

static std::string formatSymbol(StringRef Name, uint64_t Address,
   return OS.str();
 }
 
 namespace llvm {
 namespace ARM {
 namespace WinEH {
 const size_t Decoder::PDataEntrySize = sizeof(RuntimeFunction);
 
 // 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)
const Decoder::RingEntry Decoder::Ring[] = {
   { 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
 };
 
+// Unwind opcodes for ARM64.
+// https://docs.microsoft.com/en-us/cpp/build/arm64-exception-handling
+const Decoder::RingEntry Decoder::Ring64[] = {
+  { 0xe0, 0x00, &Decoder::opcode_alloc_s },
+  { 0xe0, 0x20, &Decoder::opcode_save_r19r20_x },
+  { 0xc0, 0x40, &Decoder::opcode_save_fplr },
+  { 0xc0, 0x80, &Decoder::opcode_save_fplr_x },
+  { 0xf8, 0xc0, &Decoder::opcode_alloc_m },
+  { 0xfc, 0xc8, &Decoder::opcode_save_regp },
+  { 0xfc, 0xcc, &Decoder::opcode_save_regp_x },
+  { 0xfc, 0xd0, &Decoder::opcode_save_reg },
+  { 0xfe, 0xd4, &Decoder::opcode_save_reg_x },
+  { 0xfe, 0xd6, &Decoder::opcode_save_lrpair },
+  { 0xfe, 0xd8, &Decoder::opcode_save_fregp, },
+  { 0xfe, 0xda, &Decoder::opcode_save_fregp_x },
+  { 0xfe, 0xdc, &Decoder::opcode_save_freg },
+  { 0xff, 0xde, &Decoder::opcode_save_freg_x },
+  { 0xff, 0xe0, &Decoder::opcode_alloc_l },
+  { 0xff, 0xe1, &Decoder::opcode_setfp },
+  { 0xff, 0xe2, &Decoder::opcode_addfp },
+  { 0xff, 0xe3, &Decoder::opcode_nop },
+  { 0xff, 0xe4, &Decoder::opcode_end },
+  { 0xff, 0xe5, &Decoder::opcode_end_c },
+};
+
 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);

 }
 
 bool Decoder::opcode_11111111(const uint8_t *OC, unsigned &Offset,
                               unsigned Length, bool Prologue) {
   ++Offset;
   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);
+  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_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                ; %s x%u, x%u, [sp, #%u]\n", OC[Offset],
+      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                ; stp x%u, x%u, [sp, #-%u]!\n", OC[Offset], Reg,
+        Reg + 1, Off);
+  else
+    SW.startLine() << format(
+        "0x%02x                ; ldp x%u, x%u, [sp], #%u\n", OC[Offset], 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 ? "stp" : "ldp"),
+                           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                ; stp d%u, d%u, [sp, #-%u]!\n", OC[Offset],
+        OC[Offset + 1], Reg, Off);
+  else
+    SW.startLine() << format(
+        "0x%02x%02x                ; ldp d%u, 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) {
+  assert(Prologue && "mov fp, sp only valid in a 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;
+  assert(Prologue && "add_fp only valid in prologue");
+  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 ((Opcodes[OI] & DecodeRing[DI].Mask) == DecodeRing[DI].Value) {
+        Terminated =
+            (this->*DecodeRing[DI].Routine)(Opcodes.data(), OI, 0, Prologue);
+        if (OI > OE)
+          SW.startLine() << format("The last opcode is likely bad, as we have "
+                                   "gone past the unwind data");
+        break;
+      }
+      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");
     }
   }
 }
 
 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 = Section.getAddress();
   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());
+  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);
     }
     if (XData.EpilogueCount()) {
       ListScope ES(SW, "Epilogue");
       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());
+      if (!isAArch64)
         SW.printNumber("Condition", ES.Condition());
-      SW.printNumber("EpilogueStartIndex", ES.EpilogueStartIndex());
+      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);
     }
   }
 
   if (XData.X()) {
     const uint32_t Address = XData.ExceptionHandlerRVA();
     const uint32_t Parameter = XData.ExceptionHandlerParameter();
     const size_t HandlerOffset = HeaderWords(XData)
bool Decoder::dumpPackedEntry(const object::COFFObjectFile &COFF,
   } else {
     const pe32_header *PEHeader;
     if (COFF.getPE32Header(PEHeader))
       return false;
     FunctionAddress = PEHeader->ImageBase + RF.BeginAddress;
   }
 
   SW.printString("Function", formatSymbol(FunctionName, FunctionAddress));
+  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());
   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);
+  if (isAArch64) {
+    llvm::errs() << "Packed unwind data not yet supported for ARM64\n";
+    return false;
+  }
   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;

tools/llvm-readobj/COFFDumper.cpp

Resolver = [](const object::coff_section *Section, uint64_t Offset,
                   SymbolRef &Symbol, void *user_data) -> std::error_code {
       COFFDumper *Dumper = reinterpret_cast<COFFDumper *>(user_data);
       return Dumper->resolveSymbol(Section, Offset, Symbol);
     };
     Win64EH::Dumper::Context Ctx(*Obj, Resolver, this);
     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;
   }
   default:
     W.printEnum("unsupported Image Machine", Obj->getMachine(),
                 makeArrayRef(ImageFileMachineType));
     break;
   }