[CodeGen] Emit smaller exception tables for non-SJLJ mode

[rprichard]

Summary

• Use uleb128 for code offsets in the LSDA call site table.
• Omit the TTBase offset if the type table is empty.

This change can reduce the size of the DWARF/Itanium LSDA by about half.

[• espindola]

LGTM. Taking a look at the other one.

[• espindola]

r324750.

lib/CodeGen/AsmPrinter/EHStreamer.cpp

void EHStreamer::emitExceptionTable() {
   SmallVector<unsigned, 64> FirstActions;
   computeActionsTable(LandingPads, Actions, FirstActions);
 
   // Compute the call-site table.
   SmallVector<CallSiteEntry, 64> CallSites;
   computeCallSiteTable(CallSites, LandingPads, FirstActions);
 
   bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj;
-  bool HaveTTData = IsSJLJ ? (!TypeInfos.empty() || !FilterIds.empty()) : true;
+  unsigned CallSiteEncoding = IsSJLJ ? dwarf::DW_EH_PE_udata4
+                                     : dwarf::DW_EH_PE_uleb128;
+  bool HaveTTData = !TypeInfos.empty() || !FilterIds.empty();
 
   // Type infos.
   MCSection *LSDASection = Asm->getObjFileLowering().getLSDASection();
   unsigned TTypeEncoding;
 
   if (!HaveTTData) {
-    // For SjLj exceptions, if there is no TypeInfo, then we just explicitly say
-    // that we're omitting that bit.
+    // If there is no TypeInfo, then we just explicitly say that we're omitting
+    // that bit.
     TTypeEncoding = dwarf::DW_EH_PE_omit;
   } else {
     // Okay, we have actual filters or typeinfos to emit.  As such, we need to
     // pick a type encoding for them.  We're about to emit a list of pointers to
     // typeinfo objects at the end of the LSDA.  However, unless we're in static
     // mode, this reference will require a relocation by the dynamic linker.
     //
     // Because of this, we have a couple of options:
if (HaveTTData) {
     Asm->OutStreamer->EmitLabel(TTBaseRefLabel);
   }
 
   bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
 
   // Emit the landing pad call site table.
   MCSymbol *CstBeginLabel = Asm->createTempSymbol("cst_begin");
   MCSymbol *CstEndLabel = Asm->createTempSymbol("cst_end");
-  Asm->EmitEncodingByte(dwarf::DW_EH_PE_udata4, "Call site");
+  Asm->EmitEncodingByte(CallSiteEncoding, "Call site");
   Asm->EmitLabelDifferenceAsULEB128(CstEndLabel, CstBeginLabel);
   Asm->OutStreamer->EmitLabel(CstBeginLabel);
 
   // SjLj Exception handling
   if (IsSJLJ) {
     unsigned idx = 0;
     for (SmallVectorImpl<CallSiteEntry>::const_iterator
          I = CallSites.begin(), E = CallSites.end(); I != E; ++I, ++idx) {
for (SmallVectorImpl<CallSiteEntry>::const_iterator
         BeginLabel = EHFuncBeginSym;
       MCSymbol *EndLabel = S.EndLabel;
       if (!EndLabel)
         EndLabel = Asm->getFunctionEnd();
 
       // Offset of the call site relative to the start of the procedure.
       if (VerboseAsm)
         Asm->OutStreamer->AddComment(">> Call Site " + Twine(++Entry) + " <<");
-      Asm->EmitLabelDifference(BeginLabel, EHFuncBeginSym, 4);
+      Asm->EmitLabelDifferenceAsULEB128(BeginLabel, EHFuncBeginSym);
       if (VerboseAsm)
         Asm->OutStreamer->AddComment(Twine("  Call between ") +
                                      BeginLabel->getName() + " and " +
                                      EndLabel->getName());
-      Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
+      Asm->EmitLabelDifferenceAsULEB128(EndLabel, BeginLabel);
 
       // Offset of the landing pad relative to the start of the procedure.
       if (!S.LPad) {
         if (VerboseAsm)
           Asm->OutStreamer->AddComment("    has no landing pad");
-        Asm->OutStreamer->EmitIntValue(0, 4/*size*/);
+        Asm->EmitULEB128(0);
       } else {
         if (VerboseAsm)
           Asm->OutStreamer->AddComment(Twine("    jumps to ") +
                                        S.LPad->LandingPadLabel->getName());
-        Asm->EmitLabelDifference(S.LPad->LandingPadLabel, EHFuncBeginSym, 4);
+        Asm->EmitLabelDifferenceAsULEB128(S.LPad->LandingPadLabel,
+                                          EHFuncBeginSym);
       }
 
       // Offset of the first associated action record, relative to the start of
       // the action table. This value is biased by 1 (1 indicates the start of
       // the action table), and 0 indicates that there are no actions.
       if (VerboseAsm) {
         if (S.Action == 0)
           Asm->OutStreamer->AddComment("  On action: cleanup");

test/CodeGen/ARM/dwarf-eh.ll

 
 declare i8* @__cxa_begin_catch(i8*)
 
 declare void @__cxa_end_catch()
 
 ; CHECK: .cfi_personality 0,
 ; CHECK: .cfi_lsda 0,
 ; CHECK: @TType Encoding = absptr
-; CHECK: @ Call site Encoding = udata4
+; CHECK: @ Call site Encoding = uleb128
 ; CHECK-PIC: .cfi_personality 155,
 ; CHECK-PIC: .cfi_lsda 27,
 ; CHECK-PIC: @TType Encoding = indirect pcrel sdata4
-; CHECK-PIC: @ Call site Encoding = udata4
+; CHECK-PIC: @ Call site Encoding = uleb128

test/CodeGen/ARM/ehabi-handlerdata-nounwind.ll

 ; CHECK:   .personality __gxx_personality_v0
 ; CHECK:   .handlerdata
 ; CHECK:   .p2align 2
 ; CHECK-LABEL: GCC_except_table0:
 ; CHECK-LABEL: .Lexception0:
 ; CHECK:   .byte 255                     @ @LPStart Encoding = omit
 ; CHECK:   .byte 0                       @ @TType Encoding = absptr
 ; CHECK:   .uleb128 .Lttbase
-; CHECK:   .byte 3                       @ Call site Encoding = udata4
+; CHECK:   .byte 1                       @ Call site Encoding = uleb128
 ; CHECK:   .fnend

test/CodeGen/ARM/ehabi-handlerdata.ll

 ; CHECK:   .personality __gxx_personality_v0
 ; CHECK:   .handlerdata
 ; CHECK:   .p2align 2
 ; CHECK-LABEL: GCC_except_table0:
 ; CHECK-LABEL: .Lexception0:
 ; CHECK:   .byte 255                     @ @LPStart Encoding = omit
 ; CHECK:   .byte 0                       @ @TType Encoding = absptr
 ; CHECK:   .uleb128 .Lttbase
-; CHECK:   .byte 3                       @ Call site Encoding = udata4
+; CHECK:   .byte 1                       @ Call site Encoding = uleb128
 ; CHECK:   .uleb128 .Lcst_end
-; CHECK:   .long
-; CHECK:   .long
-; CHECK:   .long
+; CHECK:   .uleb128
+; CHECK:   .uleb128
+; CHECK:   .uleb128
 ; CHECK:   .fnend

test/CodeGen/X86/eh-label.ll

bb1:
   landingpad { i8*, i32 }
           catch i8* null
   call void @g()
   ret void
 bb2:
   ret void
 
 ; CHECK: [[END:.Lfunc_end.*]]:
-; CHECK: .long  [[END]]-
+; CHECK: .uleb128 [[END]]-
 }

test/CodeGen/X86/eh-unknown.ll

 ; CHECK-LABEL: use_unknown_ehpersonality:
 ; CHECK: .Lfunc_begin0:
 ; CHECK: .seh_handler __unknown_ehpersonality, @unwind, @except
 ; CHECK: callq throwit
 ; CHECK: .Lfunc_end0:
 ; CHECK: .seh_handlerdata
 ; CHECK: .Lexception0:
 ; CHECK:  .byte   255                     # @LPStart Encoding = omit
-; CHECK:  .byte   0                       # @TType Encoding = absptr
-; CHECK:  .uleb128 .Lttbase0-.Lttbaseref0
-; CHECK:  .Lttbaseref0:
-; CHECK:  .byte   3                       # Call site Encoding = udata4
+; CHECK:  .byte   255                     # @TType Encoding = omit
+; CHECK:  .byte   1                       # Call site Encoding = uleb128
 ; CHECK:  .uleb128 .Lcst_end0-.Lcst_begin0
 ; CHECK:  .Lcst_begin0:
-; CHECK:  .long .Lfunc_begin0-.Lfunc_begin0 # >> Call Site 1 <<
-; CHECK:  .long .Lfunc_end0-.Lfunc_begin0 #   Call between .Lfunc_begin0 and .Lfunc_end0
-; CHECK:  .long   0                       #     has no landing pad
+; CHECK:  .uleb128 .Lfunc_begin0-.Lfunc_begin0 # >> Call Site 1 <<
+; CHECK:  .uleb128 .Lfunc_end0-.Lfunc_begin0 #   Call between .Lfunc_begin0 and .Lfunc_end0
+; CHECK:  .byte   0                       #     has no landing pad
 ; CHECK:  .byte   0                       #   On action: cleanup
 ; CHECK:  .Lcst_end0:

test/CodeGen/X86/patchpoint-invoke.ll

 }
 
 ; Verify that the exception table was emitted:
 ; CHECK:      [[EXCEPTION_LABEL]]:
 ; CHECK-NEXT: .byte 255
 ; CHECK-NEXT: .byte 3
 ; CHECK-NEXT: .uleb128 .Lttbase{{[0-9]+}}-[[TTBASEREF:.Lttbaseref[0-9]+]]
 ; CHECK-NEXT: [[TTBASEREF]]:
-; CHECK-NEXT: .byte 3
+; CHECK-NEXT: .byte 1
 ; CHECK-NEXT: .uleb128 .Lcst_end{{[0-9]+}}-[[CST_BEGIN:.Lcst_begin[0-9]+]]
 ; CHECK-NEXT: [[CST_BEGIN]]:
 ; Verify that the unwind data covers the entire patchpoint region:
-; CHECK-NEXT: .long .Ltmp0-[[FUNC_BEGIN]]
-; CHECK-NEXT: .long [[PP_END]]-.Ltmp0
+; CHECK-NEXT: .uleb128 .Ltmp0-[[FUNC_BEGIN]]
+; CHECK-NEXT: .uleb128 [[PP_END]]-.Ltmp0
 
 
 ; Verify that the stackmap section got emitted:
 ; CHECK-LABEL: __LLVM_StackMaps:
 ; Header
 ; CHECK-NEXT:   .byte 3
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0

test/CodeGen/X86/push-cfi-obj.ll

 ; RUN: llc < %s -mtriple=i686-pc-linux -filetype=obj | llvm-readobj -s -sr -sd | FileCheck %s -check-prefix=LINUX
 ; RUN: llc < %s -mtriple=i686-darwin-macosx10.7 -filetype=obj | llvm-readobj -sections | FileCheck -check-prefix=DARWIN %s
 
 ; On darwin, check that we manage to generate the compact unwind section
 ; DARWIN: Name: __compact_unwind
 ; DARWIN: Segment: __LD
 
 ; LINUX:         Name: .eh_frame
 ; LINUX-NEXT:    Type: SHT_PROGBITS (0x1)
 ; LINUX-NEXT:    Flags [ (0x2)
 ; LINUX-NEXT:      SHF_ALLOC (0x2)
 ; LINUX-NEXT:    ]
 ; LINUX-NEXT:    Address: 0x0
-; LINUX-NEXT:    Offset: 0x68
+; LINUX-NEXT:    Offset: 0x5C
 ; LINUX-NEXT:    Size: 64
 ; LINUX-NEXT:    Link: 0
 ; LINUX-NEXT:    Info: 0
 ; LINUX-NEXT:    AddressAlignment: 4
 ; LINUX-NEXT:    EntrySize: 0
 ; LINUX-NEXT:    Relocations [
 ; LINUX-NEXT:    ]
 ; LINUX-NEXT:    SectionData (

test/CodeGen/X86/statepoint-invoke.ll

exceptional_return:
   ; CHECK: retq
   %landing_pad = landingpad token
           cleanup
   %obj.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %landing_pad, i32 13, i32 13)
   %obj1.relocated1 = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %landing_pad, i32 14, i32 14)
   ret i64 addrspace(1)* %obj1.relocated1
 }
 ; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
-; CHECK: .long  .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
-; CHECK: .long  .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
+; CHECK: .uleb128  .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
+; CHECK: .uleb128  .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
 ; CHECK: .byte  0
 ; CHECK: .p2align 4
 
 define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj,
                                       i64 addrspace(1)* %obj1)
   gc "statepoint-example" personality i32 ()* @personality_function {
 entry:
   ; CHECK: .Ltmp{{[0-9]+}}:
exceptional_return:
   ; CHECK: .Ltmp{{[0-9]+}}:
   ; CHECK: movq
   %landing_pad = landingpad token
           cleanup
   %obj.relocated = call coldcc i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token %landing_pad, i32 13, i32 13)
   ret i64 addrspace(1)* %obj.relocated
 }
 ; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
-; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
-; CHECK: .long .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
+; CHECK: .uleb128 .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
+; CHECK: .uleb128 .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
 ; CHECK: .byte 0
 ; CHECK: .p2align 4
 
 define i64 addrspace(1)* @test_same_val(i1 %cond, i64 addrspace(1)* %val1, i64 addrspace(1)* %val2, i64 addrspace(1)* %val3)
   gc "statepoint-example" personality i32 ()* @"personality_function" {
 entry:
   br i1 %cond, label %left, label %right
 

test/CodeGen/XCore/exception.ll

Exit:
   ret void
 }
 
 ; CHECK: [[LSDA]]:
 ; CHECK: .byte  255
 ; CHECK: .byte  0
 ; CHECK: .uleb128 [[TTBASE:.Lttbase[0-9]+]]-[[TTBASEREF:.Lttbaseref[0-9]+]]
 ; CHECK: [[TTBASEREF]]:
-; CHECK: .byte  3
+; CHECK: .byte  1
 ; CHECK: .uleb128 [[CST_END:.Lcst_end[0-9]+]]-[[CST_BEGIN:.Lcst_begin[0-9]+]]
 ; CHECK: [[CST_BEGIN]]:
-; CHECK: .long [[PRE_G]]-[[START]]
-; CHECK: .long [[POST_G]]-[[PRE_G]]
-; CHECK: .long [[LANDING]]-[[START]]
+; CHECK: .uleb128 [[PRE_G]]-[[START]]
+; CHECK: .uleb128 [[POST_G]]-[[PRE_G]]
+; CHECK: .uleb128 [[LANDING]]-[[START]]
 ; CHECK: .byte 5
-; CHECK: .long [[POST_G]]-[[START]]
-; CHECK: .long [[END]]-[[POST_G]]
-; CHECK: .long 0
+; CHECK: .uleb128 [[POST_G]]-[[START]]
+; CHECK: .uleb128 [[END]]-[[POST_G]]
+; CHECK: .byte 0
 ; CHECK: .byte 0
 ; CHECK: [[CST_END]]:
 ; CHECK: .byte 0
 ; CHECK: .byte 0
 ; CHECK: .byte 1
 ; CHECK: .byte 125
 ; CHECK: .byte 2
 ; CHECK: .byte 125
 ; CHECK: .p2align 2
 ; CHECK: .long _ZTIi
 ; CHECK: .long _ZTId
 ; CHECK: [[TTBASE]]: