[MC] [MCWin64EH] Try writing an ARM64 "packed epilog" even if the epilog doesn't share opcodes with the prolog

[mstorsjo]

Summary

The "packed epilog" form only implies that the epilog is located
exactly at the end of the function (so the location of the epilog
is implicit from the epilog opcodes), but it doesn't have to share
opcodes with the prolog - as long as the total number of opcode
bytes and the offset to the epilog fit within the bitfields.

This avoids writing a 4 byte epilog scope in many cases. (I haven't
measured how much this shrinks actual xdata sections in practice
though.)

[efriedma]

llvm/lib/MC/MCWin64EH.cpp

656

This call to EpilogMap.clear() tripped me up in trying to understand the reasoning behind the rest of the changes in this patch. There are three cases here:

1. Unpacked epilogues
2. Packed epilogue reusing the prologue
3. Packed epilogue not reusing the prologue.

In the "Packed epilogue reusing the prologue" case, we clear EpilogMap; in the other cases, we don't.

Maybe the logic here could be a bit more explicit? Like maybe instead of clearing EpilogMap(), add checks in the caller in the two places it matters.

990

Possible followup optimization: we could teach FindMatchingEpilog to look at the prologue. (Not sure how frequently that would trigger.)

1029

Is the fixme about sharing epilog codes fixed?

[mstorsjo]

llvm/lib/MC/MCWin64EH.cpp

656

Yep - this tripped up myself too, when trying to grasp how the existing state worked. In the original setup with only cases 1 and 2, this was a neat (but obscure) requiring very few modifications, but with all these three cases, making it more explicit probably is good.

But then again, given the code below for sharing code between epilogs (where we do EpilogInstrs.clear() if the epilog matched another one, in order not to emit it), I think clearing it here if we shouldn't emit it, is fairly consistent. Do you see any other alternative as clearer? We could do if (PackedEpilogOffset < || PackedEpilogOffset >= PrologCodeBytes) { // emit epilog opcodes } but I'm not sure if that's any clearer.

I guess I could add a comment here though, e.g. // Remove the epilog, as we shouldn't emit the epilog opcodes, and we could consider making it Epilog.clear() too (so we keep the epilogmap entry, but remove the opcodes). That'd probably be the most consistent?

990

Indeed, and I guess that's probably quite common - a function with two epilogs, both which match the prolog perfectly? I'll see if I can try to implement that too as a followup.

[mstorsjo]

llvm/lib/MC/MCWin64EH.cpp

1029

Yeah, I think so. (We only share epilogs if they're a perfect match, while we should be able to share them if one is a subset of the other one. But I think the potential benefit from that is rather small.)

[mstorsjo]

After thinking more, I don't think other ways of handling the original case of packed+shared epilogs really are any clearer, but I added a comment to the existing info->EpilogMap.clear() call at least.

[mstorsjo]

The other change (use packed form to specify the epilog opcode offset) doesn't seem to have almost any effect on the real world size - but this patch clearly has. For a 5.8 MB DLL, this patch shrinks it by 0.7%, shrinking the 412 KB xdata section to 372 KB.

[efriedma]

LGTM

llvm/lib/MC/MCWin64EH.cpp

static int checkPackedEpilog(MCStreamer &streamer, WinEH::FrameInfo *info,
                              int PrologCodeBytes) {
   // Can only pack if there's one single epilog
   if (info->EpilogMap.size() != 1)
     return -1;
 
   const std::vector<WinEH::Instruction> &Epilog =
       info->EpilogMap.begin()->second;
 
+  // Check that the epilog actually is at the very end of the function,
+  // otherwise it can't be packed.
+  uint32_t DistanceFromEnd = (uint32_t)GetAbsDifference(
+      streamer, info->FuncletOrFuncEnd, info->EpilogMap.begin()->first);
+  if (DistanceFromEnd / 4 != Epilog.size())
+    return -1;
+
+  int RetVal = -1;
+  // Even if we don't end up sharing opcodes with the prolog, we can still
+  // write the offset as a packed offset, if the single epilog is located at
+  // the end of the function and the offset (pointing after the prolog) fits
+  // as a packed offset.
+  if (PrologCodeBytes <= 31 &&
+      PrologCodeBytes + ARM64CountOfUnwindCodes(Epilog) <= 124)
+    RetVal = PrologCodeBytes;
+
   // Can pack if the epilog is a subset of the prolog but not vice versa
   if (Epilog.size() > info->Instructions.size())
-    return -1;
+    return RetVal;
 
   // Check that the epilog actually is a perfect match for the end (backwrds)
   // of the prolog.
   for (int I = Epilog.size() - 1; I >= 0; I--) {
     if (info->Instructions[I] != Epilog[Epilog.size() - 1 - I])
-      return -1;
+      return RetVal;
   }
 
-  // Check that the epilog actually is at the very end of the function,
-  // otherwise it can't be packed.
-  uint32_t DistanceFromEnd = (uint32_t)GetAbsDifference(
-      streamer, info->FuncletOrFuncEnd, info->EpilogMap.begin()->first);
-  if (DistanceFromEnd / 4 != Epilog.size())
-    return -1;
-
   int Offset = Epilog.size() == info->Instructions.size()
                    ? 0
                    : ARM64CountOfUnwindCodes(ArrayRef<WinEH::Instruction>(
                          &info->Instructions[Epilog.size()],
                          info->Instructions.size() - Epilog.size()));
 
   // Check that the offset and prolog size fits in the first word; it's
   // unclear whether the epilog count in the extension word can be taken
   // as packed epilog offset.
   if (Offset > 31 || PrologCodeBytes > 124)
-    return -1;
+    return RetVal;
 
   info->EpilogMap.clear();
   return Offset;
 }
 
 static bool tryPackedUnwind(WinEH::FrameInfo *info, uint32_t FuncLength,
                             int PackedEpilogOffset) {
   if (PackedEpilogOffset == 0) {
     // Fully symmetric prolog and epilog, should be ok for packed format.
     // For CR=3, the corresponding synthesized epilog actually lacks the
static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info,
   if (RawFuncLength > 0xFFFFF)
     report_fatal_error("SEH unwind data splitting not yet implemented");
   uint32_t FuncLength = (uint32_t)RawFuncLength / 4;
   uint32_t PrologCodeBytes = ARM64CountOfUnwindCodes(info->Instructions);
   uint32_t TotalCodeBytes = PrologCodeBytes;
 
   int PackedEpilogOffset = checkPackedEpilog(streamer, info, PrologCodeBytes);
 
-  if (PackedEpilogOffset >= 0 && !info->HandlesExceptions &&
-      FuncLength <= 0x7ff && TryPacked) {
+  if (PackedEpilogOffset >= 0 &&
+      uint32_t(PackedEpilogOffset) < PrologCodeBytes &&
+      !info->HandlesExceptions && FuncLength <= 0x7ff && TryPacked) {
     // Matching prolog/epilog and no exception handlers; check if the
     // prolog matches the patterns that can be described by the packed
     // format.
 
     // info->Symbol was already set even if we didn't actually write any
     // unwind info there. Keep using that as indicator that this unwind
     // info has been generated already.
 
     if (tryPackedUnwind(info, FuncLength, PackedEpilogOffset))
       return;
   }
 
   // Process epilogs.
   MapVector<MCSymbol *, uint32_t> EpilogInfo;
   // Epilogs processed so far.
   std::vector<MCSymbol *> AddedEpilogs;
 
   for (auto &I : info->EpilogMap) {
     MCSymbol *EpilogStart = I.first;
     auto &EpilogInstrs = I.second;
     uint32_t CodeBytes = ARM64CountOfUnwindCodes(EpilogInstrs);
 
     MCSymbol* MatchingEpilog =
       FindMatchingEpilog(EpilogInstrs, AddedEpilogs, info);
     if (MatchingEpilog) {
       assert(EpilogInfo.find(MatchingEpilog) != EpilogInfo.end() &&
              "Duplicate epilog not found");
       EpilogInfo[EpilogStart] = EpilogInfo.lookup(MatchingEpilog);
       // Clear the unwind codes in the EpilogMap, so that they don't get output
       // in the logic below.
       EpilogInstrs.clear();
     } else {
if (PackedEpilogOffset >= 0) // E
     row1 |= 1 << 21;
   row1 |= FuncLength & 0x3FFFF;
   streamer.emitInt32(row1);
 
   // Extended Code Words, Extended Epilog Count
   if (ExtensionWord) {
     // FIXME: We should be able to split unwind info into multiple sections.
     // FIXME: We should share epilog codes across epilogs, where possible,
     // which would make this issue show up less frequently.
     if (CodeWords > 0xFF || EpilogCount > 0xFFFF)
       report_fatal_error("SEH unwind data splitting not yet implemented");
     uint32_t row2 = 0x0;
     row2 |= (CodeWords & 0xFF) << 16;
     row2 |= (EpilogCount & 0xFFFF);
     streamer.emitInt32(row2);
   }
 
+  if (PackedEpilogOffset < 0) {
     // Epilog Start Index, Epilog Start Offset
     for (auto &I : EpilogInfo) {
       MCSymbol *EpilogStart = I.first;
       uint32_t EpilogIndex = I.second;
       uint32_t EpilogOffset =
           (uint32_t)GetAbsDifference(streamer, EpilogStart, info->Begin);
       if (EpilogOffset)
         EpilogOffset /= 4;
       uint32_t row3 = EpilogOffset;
       row3 |= (EpilogIndex & 0x3FF) << 22;
       streamer.emitInt32(row3);
     }
+  }
 
   // Emit prolog unwind instructions (in reverse order).
   uint8_t numInst = info->Instructions.size();
   for (uint8_t c = 0; c < numInst; ++c) {
     WinEH::Instruction inst = info->Instructions.back();
     info->Instructions.pop_back();
     ARM64EmitUnwindCode(streamer, info->Begin, inst);
   }

llvm/test/CodeGen/AArch64/wineh1.mir

 # RUN:   | FileCheck %s --check-prefix=ASM
 
 # We expect to see the following in the .xdata section:
 
 # CHECK:   ExceptionData {
 # CHECK-NEXT:      FunctionLength: 96
 # CHECK-NEXT:      Version: 0
 # CHECK-NEXT:      ExceptionData: No
-# CHECK-NEXT:      EpiloguePacked: No
-# CHECK-NEXT:      EpilogueScopes: 1
+# CHECK-NEXT:      EpiloguePacked: Yes
+# CHECK-NEXT:      EpilogueOffset: 13
 # CHECK-NEXT:      ByteCodeLength: 28
 # CHECK-NEXT:      Prologue [
 # CHECK-NEXT:        0xc808              ; stp x19, x20, [sp, #64]
 # CHECK-NEXT:        0xd0c7              ; str x22, [sp, #56]
 # CHECK-NEXT:        0xd086              ; str x21, [sp, #48]
 # CHECK-NEXT:        0xc904              ; stp x23, x24, [sp, #32]
 # CHECK-NEXT:        0xc982              ; stp x25, x26, [sp, #16]
 # CHECK-NEXT:        0xce09              ; stp x27, x28, [sp, #-80]!
 # CHECK-NEXT:        0xe4                ; end
 # CHECK-NEXT:      ]
-# CHECK-NEXT:      EpilogueScopes [
-# CHECK-NEXT:        EpilogueScope {
-# CHECK-NEXT:          StartOffset: 16
-# CHECK-NEXT:          EpilogueStartIndex: 13
-# CHECK-NEXT:          Opcodes [
-# CHECK-NEXT:            0xc808              ; ldp x19, x20, [sp, #64]
-# CHECK-NEXT:            0xd086              ; ldr x21, [sp, #48]
-# CHECK-NEXT:            0xe3                ; nop
-# CHECK-NEXT:            0xd0c7              ; ldr x22, [sp, #56]
-# CHECK-NEXT:            0xc904              ; ldp x23, x24, [sp, #32]
-# CHECK-NEXT:            0xc982              ; ldp x25, x26, [sp, #16]
-# CHECK-NEXT:            0xce09              ; ldp x27, x28, [sp], #80
-# CHECK-NEXT:            0xe4                ; end
-# CHECK-NEXT:          ]
-# CHECK-NEXT:        }
-# CHECK-NEXT:      ]
-# CHECK-NEXT:    }
+# CHECK-NEXT:      Epilogue [
+# CHECK-NEXT:        0xc808              ; ldp x19, x20, [sp, #64]
+# CHECK-NEXT:        0xd086              ; ldr x21, [sp, #48]
+# CHECK-NEXT:        0xe3                ; nop
+# CHECK-NEXT:        0xd0c7              ; ldr x22, [sp, #56]
+# CHECK-NEXT:        0xc904              ; ldp x23, x24, [sp, #32]
+# CHECK-NEXT:        0xc982              ; ldp x25, x26, [sp, #16]
+# CHECK-NEXT:        0xce09              ; ldp x27, x28, [sp], #80
+# CHECK-NEXT:        0xe4                ; end
+# CHECK-NEXT:      ]
+# CHECK-NEXT:    }
 
 # Check that the load-store optimizer does not merge the two
 # callee-saved stores in the prologue.
 # CHECK-LDSTOPT: name: test
 # CHECK-LDSTOPT: frame-setup STRXui killed $x21, $sp, 6
 # CHECK-LDSTOPT: frame-setup STRXui killed $x22, $sp, 7
 
 # ASM-LABEL: test:

llvm/test/CodeGen/AArch64/wineh2.mir

 # RUN: llc -o - %s -mtriple=aarch64-windows -start-after=prologepilog \
 # RUN:    -filetype=obj | llvm-readobj --unwind - | FileCheck %s
 # Test that the pre/post increment save of a flating point register is correct.
 
 # CHECK:        ExceptionData {
 # CHECK-NEXT:      FunctionLength: 144
 # CHECK-NEXT:      Version: 0
 # CHECK-NEXT:      ExceptionData: No
-# CHECK-NEXT:      EpiloguePacked: No
-# CHECK-NEXT:      EpilogueScopes: 1
+# CHECK-NEXT:      EpiloguePacked: Yes
+# CHECK-NEXT:      EpilogueOffset: 19
 # CHECK-NEXT:      ByteCodeLength: 40
 # CHECK-NEXT:      Prologue [
 # CHECK-NEXT:        0xc80e              ; stp x19, x20, [sp, #112]
 # CHECK-NEXT:        0xc88c              ; stp x21, x22, [sp, #96]
 # CHECK-NEXT:        0xc90a              ; stp x23, x24, [sp, #80]
 # CHECK-NEXT:        0xc988              ; stp x25, x26, [sp, #64]
 # CHECK-NEXT:        0xca06              ; stp x27, x28, [sp, #48]
 # CHECK-NEXT:        0xdc45              ; str d9, [sp, #40]
 # CHECK-NEXT:        0xdc04              ; str d8, [sp, #32]
 # CHECK-NEXT:        0xd882              ; stp d10, d11, [sp, #16]
 # CHECK-NEXT:        0xde8f              ; str d12, [sp, #-128]!
 # CHECK-NEXT:        0xe4                ; end
 # CHECK-NEXT:      ]
-# CHECK-NEXT:      EpilogueScopes [
-# CHECK-NEXT:        EpilogueScope {
-# CHECK-NEXT:          StartOffset: 26
-# CHECK-NEXT:          EpilogueStartIndex: 19
-# CHECK-NEXT:          Opcodes [
-# CHECK-NEXT:            0xc80e              ; ldp x19, x20, [sp, #112]
-# CHECK-NEXT:            0xc88c              ; ldp x21, x22, [sp, #96]
-# CHECK-NEXT:            0xc90a              ; ldp x23, x24, [sp, #80]
-# CHECK-NEXT:            0xc988              ; ldp x25, x26, [sp, #64]
-# CHECK-NEXT:            0xca06              ; ldp x27, x28, [sp, #48]
-# CHECK-NEXT:            0xdc04              ; ldr d8, [sp, #32]
-# CHECK-NEXT:            0xdc45              ; ldr d9, [sp, #40]
-# CHECK-NEXT:            0xd882              ; ldp d10, d11, [sp, #16]
-# CHECK-NEXT:            0xde8f              ; ldr d12, [sp], #128
-# CHECK-NEXT:            0xe4                ; end
-# CHECK-NEXT:          ]
-# CHECK-NEXT:        }
-# CHECK-NEXT:      ]
-# CHECK-NEXT:    }
+# CHECK-NEXT:      Epilogue [
+# CHECK-NEXT:        0xc80e              ; ldp x19, x20, [sp, #112]
+# CHECK-NEXT:        0xc88c              ; ldp x21, x22, [sp, #96]
+# CHECK-NEXT:        0xc90a              ; ldp x23, x24, [sp, #80]
+# CHECK-NEXT:        0xc988              ; ldp x25, x26, [sp, #64]
+# CHECK-NEXT:        0xca06              ; ldp x27, x28, [sp, #48]
+# CHECK-NEXT:        0xdc04              ; ldr d8, [sp, #32]
+# CHECK-NEXT:        0xdc45              ; ldr d9, [sp, #40]
+# CHECK-NEXT:        0xd882              ; ldp d10, d11, [sp, #16]
+# CHECK-NEXT:        0xde8f              ; ldr d12, [sp], #128
+# CHECK-NEXT:        0xe4                ; end
+# CHECK-NEXT:      ]
+# CHECK-NEXT:    }
 ...
 ---
 name:            test
 alignment:       4
 exposesReturnsTwice: false
 legalized:       false
 regBankSelected: false
 selected:        false

llvm/test/CodeGen/AArch64/wineh5.mir

 # RUN: llc -o - %s -mtriple=aarch64-windows -start-after=prologepilog \
 # RUN:    -filetype=obj | llvm-readobj --unwind - | FileCheck %s
 
 # Check that that the large stack allocation is correctly represented in .xdata.
 
 # CHECK:        ExceptionData {
 # CHECK-NEXT:     FunctionLength: 156
 # CHECK-NEXT:     Version: 0
 # CHECK-NEXT:     ExceptionData: No
-# CHECK-NEXT:     EpiloguePacked: No
-# CHECK-NEXT:     EpilogueScopes: 1
+# CHECK-NEXT:     EpiloguePacked: Yes
+# CHECK-NEXT:     EpilogueOffset: 10
 # CHECK-NEXT:     ByteCodeLength: 20
 # CHECK-NEXT:     Prologue [
 # CHECK-NEXT:       0xe002dac9          ; sub sp, #2993296
 # CHECK-NEXT:       0xe3                ; nop
 # CHECK-NEXT:       0xe3                ; nop
 # CHECK-NEXT:       0x42                ; stp x29, x30, [sp, #16]
 # CHECK-NEXT:       0xd53f              ; str x28, [sp, #-256]!
 # CHECK-NEXT:       0xe4                ; end
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     EpilogueScopes [
-# CHECK-NEXT:       EpilogueScope {
-# CHECK-NEXT:         StartOffset: 34
-# CHECK-NEXT:         EpilogueStartIndex: 10
-# CHECK-NEXT:         Opcodes [
-# CHECK-NEXT:           0xe002da00          ; add sp, #2990080
-# CHECK-NEXT:           0xc0c9              ; add sp, #3216
-# CHECK-NEXT:           0x42                ; ldp x29, x30, [sp, #16]
-# CHECK-NEXT:           0xd53f              ; ldr x28, [sp], #256
-# CHECK-NEXT:           0xe4                ; end
-# CHECK-NEXT:         ]
-# CHECK-NEXT:       }
-# CHECK-NEXT:     ]
-# CHECK-NEXT:   }
+# CHECK-NEXT:     Epilogue [
+# CHECK-NEXT:       0xe002da00          ; add sp, #2990080
+# CHECK-NEXT:       0xc0c9              ; add sp, #3216
+# CHECK-NEXT:       0x42                ; ldp x29, x30, [sp, #16]
+# CHECK-NEXT:       0xd53f              ; ldr x28, [sp], #256
+# CHECK-NEXT:       0xe4                ; end
+# CHECK-NEXT:     ]
+# CHECK-NEXT:   }
 
 
 --- |
   target datalayout = "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128"
   target triple = "aarch64-unknown-windows-msvc19.11.0"
 
   ; Function Attrs: noinline optnone
   define dso_local i32 @"?func@@YAHH@Z"(i32 %i) #0 {

llvm/test/MC/AArch64/seh-optimize.s

 // CHECK-NEXT:         0x42                ; stp x29, x30, [sp, #16]
 // CHECK-NEXT:         0xca02              ; stp x27, x28, [sp, #16]
 // CHECK-NEXT:         0x83                ; stp x29, x30, [sp, #-32]!
 // CHECK-NEXT:         0xce03              ; stp x27, x28, [sp, #-32]!
 // CHECK-NEXT:         0xe1                ; mov fp, sp
 // CHECK-NEXT:         0xe201              ; add fp, sp, #8
 // CHECK-NEXT:         0xe4                ; end
 // CHECK-NEXT:       ]
-// CHECK-NEXT:       EpilogueScopes [
-// CHECK-NEXT:         EpilogueScope {
-// CHECK:                Opcodes [
-// CHECK-NEXT:             0xc904              ; ldp x23, x24, [sp, #32]
-// CHECK-NEXT:             0xe6                ; restore next
-// CHECK-NEXT:             0xcc83              ; ldp x21, x22, [sp], #32
-// CHECK-NEXT:             0x24                ; ldp x19, x20, [sp], #32
-// CHECK-NEXT:             0xcc1f              ; ldp x19, x20, [sp], #256
-// CHECK-NEXT:             0xe4                ; end
-// CHECK-NEXT:           ]
-// CHECK-NEXT:         }
-// CHECK-NEXT:       ]
-// CHECK-NEXT:     }
+// CHECK-NEXT:       Epilogue [
+// CHECK-NEXT:         0xc904              ; ldp x23, x24, [sp, #32]
+// CHECK-NEXT:         0xe6                ; restore next
+// CHECK-NEXT:         0xcc83              ; ldp x21, x22, [sp], #32
+// CHECK-NEXT:         0x24                ; ldp x19, x20, [sp], #32
+// CHECK-NEXT:         0xcc1f              ; ldp x19, x20, [sp], #256
+// CHECK-NEXT:         0xe4                ; end
+// CHECK-NEXT:       ]
+// CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 
     .text
     .globl func
     .seh_proc func
 func:

llvm/test/MC/AArch64/seh-packed-epilog.s

 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK:        RuntimeFunction {
 // CHECK-NEXT:     Function: packed2
 // CHECK-NEXT:     ExceptionRecord:
 // CHECK-NEXT:     ExceptionData {
 // CHECK:            ExceptionData:
 // CHECK-NEXT:       EpiloguePacked: Yes
+// CHECK-NEXT:       EpilogueOffset: 0
+// CHECK-NEXT:       ByteCodeLength: 4
+// CHECK-NEXT:       Prologue [
+// CHECK-NEXT:         0x83                ; stp x29, x30, [sp, #-32]!
+// CHECK-NEXT:         0x03                ; sub sp, #48
+// CHECK-NEXT:         0xe4                ; end
+// CHECK-NEXT:       ]
 // CHECK:        RuntimeFunction {
 // CHECK-NEXT:     Function: nonpacked1
 // CHECK-NEXT:     ExceptionRecord:
 // CHECK-NEXT:     ExceptionData {
 // CHECK:            ExceptionData:
 // CHECK-NEXT:       EpiloguePacked: No
 // CHECK:        RuntimeFunction {
-// CHECK-NEXT:     Function: nonpacked2
+// CHECK-NEXT:     Function: nonshared2
 // CHECK-NEXT:     ExceptionRecord:
 // CHECK-NEXT:     ExceptionData {
 // CHECK:            ExceptionData:
-// CHECK-NEXT:       EpiloguePacked: No
+// CHECK-NEXT:       EpiloguePacked: Yes
+// CHECK-NEXT:       EpilogueOffset: 3
+// CHECK-NEXT:       ByteCodeLength: 8
+// CHECK-NEXT:       Prologue [
+// CHECK-NEXT:         0x02                ; sub sp, #32
+// CHECK-NEXT:         0x03                ; sub sp, #48
+// CHECK-NEXT:         0xe4                ; end
+// CHECK-NEXT:       ]
+// CHECK-NEXT:       Epilogue [
+// CHECK-NEXT:         0x01                ; add sp, #16
+// CHECK-NEXT:         0x03                ; add sp, #48
+// CHECK-NEXT:         0xe4                ; end
+// CHECK-NEXT:       ]
 // CHECK:        RuntimeFunction {
-// CHECK-NEXT:     Function: nonpacked3
+// CHECK-NEXT:     Function: nonshared3
 // CHECK-NEXT:     ExceptionRecord:
 // CHECK-NEXT:     ExceptionData {
 // CHECK:            ExceptionData:
-// CHECK-NEXT:       EpiloguePacked: No
+// CHECK-NEXT:       EpiloguePacked: Yes
+// CHECK-NEXT:       EpilogueOffset: 3
+// CHECK-NEXT:       ByteCodeLength: 8
+// CHECK-NEXT:       Prologue [
+// CHECK-NEXT:         0x02                ; sub sp, #32
+// CHECK-NEXT:         0x03                ; sub sp, #48
+// CHECK-NEXT:         0xe4                ; end
+// CHECK-NEXT:       ]
+// CHECK-NEXT:       Epilogue [
+// CHECK-NEXT:         0xe1                ; mov sp, fp
+// CHECK-NEXT:         0x02                ; add sp, #32
+// CHECK-NEXT:         0x03                ; add sp, #48
+// CHECK-NEXT:         0xe4                ; end
+// CHECK-NEXT:       ]
 
     .text
     .globl func
     .seh_proc func
 func:
     sub sp, sp, #48
     .seh_stackalloc 48
     // Check that canonical opcode forms (r19r20_x, fplr, fplr_x, save_next,
nonpacked1:
     .seh_endepilogue
     // This epilogue isn't packed with the prologue, as it doesn't align with
     // the end of the function (one extra nop before the ret).
     nop
     ret
     .seh_endproc
 
 
-    .seh_proc nonpacked2
-nonpacked2:
+    .seh_proc nonshared2
+nonshared2:
     sub sp, sp, #48
     .seh_stackalloc 48
     sub sp, sp, #32
     .seh_stackalloc 32
     .seh_endprologue
 
     nop
     .seh_startepilogue
-    // Not packed; the epilogue mismatches at the second opcode.
+    // Not shared; the epilogue mismatches at the second opcode.
     add sp, sp, #16
     .seh_stackalloc 16
     add sp, sp, #48
     .seh_stackalloc 48
     .seh_endepilogue
     ret
     .seh_endproc
 
-    .seh_proc nonpacked3
-nonpacked3:
+    .seh_proc nonshared3
+nonshared3:
     sub sp, sp, #48
     .seh_stackalloc 48
     sub sp, sp, #32
     .seh_stackalloc 32
     .seh_endprologue
 
     nop
     .seh_startepilogue
-    // Not packed; the epilogue is longer than the prologue.
+    // Not shared; the epilogue is longer than the prologue.
     mov sp, x29
     .seh_set_fp
     add sp, sp, #32
     .seh_stackalloc 32
     add sp, sp, #48
     .seh_stackalloc 48
     .seh_endepilogue
     ret
     .seh_endproc