[XCOFF][AIX] Alternative path in EHStreamer for platforms do not have uleb128 support

[jasonliu]

Summary

Not all system assembler supports .uleb128 label2 - label1 form.
When the target do not support this form, we have to take alternative manual calculation to get the offsets from them.

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCAsmInfo.h

190

This also covers/is used for checking support for .sleb128, no? Perhaps this should be HasLEB128Directives?

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

421

I agree that the MCAsmInfo is the correct place to encode the support of LEB128 directives or lack thereof; however, I'm not sure that the code here should be overriding the CallSiteEncoding as opposed to having TargetLoweringObjectFile::Initialize set it based on Ctx.getAsmInfo().

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

509

s/of/to/; to express the actual relationship.

511

Minor nit: grammar.

513

Minor nit: no comma for two-element list.

517

Minor nit: grammar.

520

Since AIX has a .uleb128 directive, just not one that is fully flexible:
s/.uleb128 directive/general LEB128 directive support/;

525

Minor nit: this is a comparison on an index, this < can be used.

527

Minor nit: grammar.

528

The DWARF specification is consistent in using all caps for the abbreviation of "little-endian base 128".

529

Consider implementing overflow checking here.

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

537–540

Range-based for should work here.

541

Minor nit: grammar, style.

551

Minor nit: style.

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

559

Use LPStartEncoding and TypeTableEncoding to match the comments or "LPStart Encoding" and "TType Encoding" to match the assembly annotation.

569

Minor nit: put "needs" in scare quotes because we are using potentially-overlong ULEB128 encodings.

570

Typo fix.

572

Minor nit: Use -- or -=.

[hubert.reinterpretcast]

llvm/lib/MC/MCAsmInfo.cpp

34

s/uleb128 directive/LEB128 directives/;

llvm/lib/MC/MCAsmInfoXCOFF.cpp

26

This makes it so that overriding the default with the option to enable use of LEB128 directives on AIX is not possible. Being able to enable such use is meaningful in the context of the integrated assembler or when using alternate or future AIX assemblers.

llvm/test/CodeGen/PowerPC/aix-exception.ll

101–102

Why the shift here? The labels were aligned before.

110–113

Be consistent on the use of physical tab characters (and space characters preceding such to maintain display alignment).

146–148

Same comment re: why the shift?

[hubert.reinterpretcast]

llvm/lib/MC/MCAsmInfo.cpp

31–32

Avoid option naming that only covers the "unsigned" case.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

421

TargetLoweringObjectFile get inheritance a lot, so setting it there means we need to override it in multiply places. And when a new TargetLoweringObjectFile derived class is created, and they might also messes the setting for CallSiteEncoding. I'm contemplating about overriding it in TargetLoweringObjectFile::getCallSiteEncoding() call instead. What do you think?

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

421

I think that's a reasonable choice.

[jasonliu]

Address comments.

[hubert.reinterpretcast]

LGTM with comments.

llvm/include/llvm/MC/MCAsmInfo.h

189

Minor nit: missing "the".

llvm/lib/MC/MCAsmInfo.cpp

32

Fix typo. Test uses use-leb128-directives as intended.

llvm/lib/MC/MCAsmInfoXCOFF.cpp

26–28

The value to use if not unset is already handled.

llvm/lib/Target/TargetLoweringObjectFile.cpp

60

Minor nit: style.

62

Same comment.

[jasonliu]

Address comments and rebase.

[hubert.reinterpretcast]

Confirming LGTM.

[jasonliu]

Manually closing this because I spelled the Differential Revision wrong.

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// ".data_region/.end_data_region" directives. If false, use "$d/$a" labels
   /// instead.
   bool UseDataRegionDirectives = false;
 
   /// True if .align is to be used for alignment. Only power-of-two
   /// alignment is supported.
   bool UseDotAlignForAlignment = false;
 
+  /// True if the target supports LEB128 directives.
+  bool HasLEB128Directives = true;
+
   //===--- Data Emission Directives -------------------------------------===//
 
   /// This should be set to the directive used to get some number of zero (and
   /// non-zero if supported by the directive) bytes emitted to the current
   /// section. Common cases are "\t.zero\t" and "\t.space\t". Defaults to
   /// "\t.zero\t"
   const char *ZeroDirective;
 
public:
   bool doesSupportDataRegionDirectives() const {
     return UseDataRegionDirectives;
   }
 
   bool useDotAlignForAlignment() const {
     return UseDotAlignForAlignment;
   }
 
+  bool hasLEB128Directives() const { return HasLEB128Directives; }
+
   const char *getZeroDirective() const { return ZeroDirective; }
   bool doesZeroDirectiveSupportNonZeroValue() const {
     return ZeroDirectiveSupportsNonZeroValue;
   }
   const char *getAsciiDirective() const { return AsciiDirective; }
   const char *getAscizDirective() const { return AscizDirective; }
   const char *getByteListDirective() const { return ByteListDirective; }
   AsmCharLiteralSyntax characterLiteralSyntax() const {

llvm/include/llvm/Target/TargetLoweringObjectFile.h

public:
   // The symbol that gets passed to .cfi_personality.
   virtual MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
                                             const TargetMachine &TM,
                                             MachineModuleInfo *MMI) const;
 
   unsigned getPersonalityEncoding() const { return PersonalityEncoding; }
   unsigned getLSDAEncoding() const { return LSDAEncoding; }
   unsigned getTTypeEncoding() const { return TTypeEncoding; }
-  unsigned getCallSiteEncoding() const { return CallSiteEncoding; }
+  unsigned getCallSiteEncoding() const;
 
   const MCExpr *getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
                                   MCStreamer &Streamer) const;
 
   virtual MCSection *getStaticCtorSection(unsigned Priority,
                                           const MCSymbol *KeySym) const {
     return StaticCtorSection;
   }

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

MCSymbol *EHStreamer::emitExceptionTable() {
   // -basic-block-sections, there is one call-site-range per basic block
   // section.
   SmallVector<CallSiteEntry, 64> CallSites;
   SmallVector<CallSiteRange, 4> CallSiteRanges;
   computeCallSiteTable(CallSites, CallSiteRanges, LandingPads, FirstActions);
 
   bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj;
   bool IsWasm = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::Wasm;
+  bool HasLEB128Directives = Asm->MAI->hasLEB128Directives();
   unsigned CallSiteEncoding =
       IsSJLJ ? static_cast<unsigned>(dwarf::DW_EH_PE_udata4) :
                Asm->getObjFileLowering().getCallSiteEncoding();
   bool HaveTTData = !TypeInfos.empty() || !FilterIds.empty();
 
   // Type infos.
   MCSection *LSDASection =
       Asm->getObjFileLowering().getSectionForLSDA(MF->getFunction(), Asm->TM);
   unsigned TTypeEncoding;
 
   if (!HaveTTData) {
     // If there is no TypeInfo, then we just explicitly say that we're omitting
     // that bit.
auto EmitTypeTableRefAndCallSiteTableEndRef = [&]() {
     // Wasm, and start of a call-site range for Itanium) to the end of the
     // whole call-site table (end of the last call-site range for Itanium).
     MCSymbol *CstBeginLabel = Asm->createTempSymbol("cst_begin");
     Asm->emitEncodingByte(CallSiteEncoding, "Call site");
     Asm->emitLabelDifferenceAsULEB128(CstEndLabel, CstBeginLabel);
     Asm->OutStreamer->emitLabel(CstBeginLabel);
   };
 
+  // An alternative path to EmitTypeTableRefAndCallSiteTableEndRef.
+  // For some platforms, the system assembler does not accept the form of
+  // `.uleb128 label2 - label1`. In those situations, we would need to calculate
+  // the size between label1 and label2 manually.
+  // In this case, we would need to calculate the LSDA size and the call
+  // site table size.
+  auto EmitTypeTableOffsetAndCallSiteTableOffset = [&]() {
+    assert(CallSiteEncoding == dwarf::DW_EH_PE_udata4 && !HasLEB128Directives &&
+           "Targets supporting .uleb128 do not need to take this path.");
+    if (CallSiteRanges.size() > 1)
+      report_fatal_error(
+          "-fbasic-block-sections is not yet supported on "
+          "platforms that do not have general LEB128 directive support.");
+
+    uint64_t CallSiteTableSize = 0;
+    const CallSiteRange &CSRange = CallSiteRanges.back();
+    for (size_t CallSiteIdx = CSRange.CallSiteBeginIdx;
+         CallSiteIdx < CSRange.CallSiteEndIdx; ++CallSiteIdx) {
+      const CallSiteEntry &S = CallSites[CallSiteIdx];
+      // Each call site entry consists of 3 udata4 fields (12 bytes) and
+      // 1 ULEB128 field.
+      CallSiteTableSize += 12 + getULEB128Size(S.Action);
+      assert(isUInt<32>(CallSiteTableSize) && "CallSiteTableSize overflows.");
+    }
+
+    Asm->emitEncodingByte(TTypeEncoding, "@TType");
+    if (HaveTTData) {
+      const unsigned ByteSizeOfCallSiteOffset =
+          getULEB128Size(CallSiteTableSize);
+      uint64_t ActionTableSize = 0;
+      for (const ActionEntry &Action : Actions) {
+        // Each action entry consists of two SLEB128 fields.
+        ActionTableSize += getSLEB128Size(Action.ValueForTypeID) +
+                           getSLEB128Size(Action.NextAction);
+        assert(isUInt<32>(ActionTableSize) && "ActionTableSize overflows.");
+      }
+
+      const unsigned TypeInfoSize =
+          Asm->GetSizeOfEncodedValue(TTypeEncoding) * MF->getTypeInfos().size();
+
+      const uint64_t LSDASizeBeforeAlign =
+          1                          // Call site encoding byte.
+          + ByteSizeOfCallSiteOffset // ULEB128 encoding of CallSiteTableSize.
+          + CallSiteTableSize        // Call site table content.
+          + ActionTableSize;         // Action table content.
+
+      const uint64_t LSDASizeWithoutAlign = LSDASizeBeforeAlign + TypeInfoSize;
+      const unsigned ByteSizeOfLSDAWithoutAlign =
+          getULEB128Size(LSDASizeWithoutAlign);
+      const uint64_t DisplacementBeforeAlign =
+          2 // LPStartEncoding and TypeTableEncoding.
+          + ByteSizeOfLSDAWithoutAlign + LSDASizeBeforeAlign;
+
+      // The type info area starts with 4 byte alignment.
+      const unsigned NeedAlignVal = (4 - DisplacementBeforeAlign % 4) % 4;
+      uint64_t LSDASizeWithAlign = LSDASizeWithoutAlign + NeedAlignVal;
+      const unsigned ByteSizeOfLSDAWithAlign =
+          getULEB128Size(LSDASizeWithAlign);
+
+      // The LSDASizeWithAlign could use 1 byte less padding for alignment
+      // when the data we use to represent the LSDA Size "needs" to be 1 byte
+      // larger than the one previously calculated without alignment.
+      if (ByteSizeOfLSDAWithAlign > ByteSizeOfLSDAWithoutAlign)
+        LSDASizeWithAlign -= 1;
+
+      Asm->OutStreamer->emitULEB128IntValue(LSDASizeWithAlign,
+                                            ByteSizeOfLSDAWithAlign);
+    }
+
+    Asm->emitEncodingByte(CallSiteEncoding, "Call site");
+    Asm->OutStreamer->emitULEB128IntValue(CallSiteTableSize);
+  };
+
   // SjLj / Wasm Exception handling
   if (IsSJLJ || IsWasm) {
     Asm->OutStreamer->emitLabel(Asm->getMBBExceptionSym(Asm->MF->front()));
 
     // emit the LSDA header.
     Asm->emitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart");
     EmitTypeTableRefAndCallSiteTableEndRef();
 
for (const CallSiteRange &CSRange : CallSiteRanges) {
         Asm->OutStreamer->emitValue(
             MCBinaryExpr::createSub(
                 MCSymbolRefExpr::create(LandingPadRange->FragmentBeginLabel,
                                         Context),
                 MCSymbolRefExpr::create(Dot, Context), Context),
             Asm->MAI->getCodePointerSize());
       }
 
+      if (HasLEB128Directives)
         EmitTypeTableRefAndCallSiteTableEndRef();
+      else
+        EmitTypeTableOffsetAndCallSiteTableOffset();
 
       for (size_t CallSiteIdx = CSRange.CallSiteBeginIdx;
            CallSiteIdx != CSRange.CallSiteEndIdx; ++CallSiteIdx) {
         const CallSiteEntry &S = CallSites[CallSiteIdx];
 
         MCSymbol *EHFuncBeginSym = CSRange.FragmentBeginLabel;
         MCSymbol *EHFuncEndSym = CSRange.FragmentEndLabel;
 

llvm/lib/MC/MCAsmInfo.cpp

 enum DefaultOnOff { Default, Enable, Disable };
 static cl::opt<DefaultOnOff> DwarfExtendedLoc(
     "dwarf-extended-loc", cl::Hidden,
     cl::desc("Disable emission of the extended flags in .loc directives."),
     cl::values(clEnumVal(Default, "Default for platform"),
                clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
     cl::init(Default));
 
+cl::opt<cl::boolOrDefault> UseLEB128Directives(
+    "use-leb128-directives", cl::Hidden,
+    cl::desc(
+        "Disable the usage of LEB128 directives, and generate .byte instead."),
+    cl::init(cl::BOU_UNSET));
+
 MCAsmInfo::MCAsmInfo() {
   SeparatorString = ";";
   CommentString = "#";
   LabelSuffix = ":";
   PrivateGlobalPrefix = "L";
   PrivateLabelPrefix = PrivateGlobalPrefix;
   LinkerPrivateGlobalPrefix = "";
   InlineAsmStart = "APP";
   InlineAsmEnd = "NO_APP";
   Code16Directive = ".code16";
   Code32Directive = ".code32";
   Code64Directive = ".code64";
   ZeroDirective = "\t.zero\t";
   AsciiDirective = "\t.ascii\t";
   AscizDirective = "\t.asciz\t";
   Data8bitsDirective = "\t.byte\t";
   Data16bitsDirective = "\t.short\t";
   Data32bitsDirective = "\t.long\t";
   Data64bitsDirective = "\t.quad\t";
   GlobalDirective = "\t.globl\t";
   WeakDirective = "\t.weak\t";
   if (DwarfExtendedLoc != Default)
     SupportsExtendedDwarfLocDirective = DwarfExtendedLoc == Enable;
+  if (UseLEB128Directives != cl::BOU_UNSET)
+    HasLEB128Directives = UseLEB128Directives == cl::BOU_TRUE;
 
   // FIXME: Clang's logic should be synced with the logic used to initialize
   //        this member and the two implementations should be merged.
   // For reference:
   // - Solaris always enables the integrated assembler by default
   //   - SparcELFMCAsmInfo and X86ELFMCAsmInfo are handling this case
   // - Windows always enables the integrated assembler by default
   //   - MCAsmInfoCOFF is handling this case, should it be MCAsmInfoMicrosoft?

llvm/lib/MC/MCAsmInfoXCOFF.cpp

 //===- MC/MCAsmInfoXCOFF.cpp - XCOFF asm properties ------------ *- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCAsmInfoXCOFF.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
+extern cl::opt<cl::boolOrDefault> UseLEB128Directives;
+
 void MCAsmInfoXCOFF::anchor() {}
 
 MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   IsLittleEndian = false;
   HasVisibilityOnlyWithLinkage = true;
   PrivateGlobalPrefix = "L..";
   PrivateLabelPrefix = "L..";
   SupportsQuotedNames = false;
   UseDotAlignForAlignment = true;
+  if (UseLEB128Directives == cl::BOU_UNSET)
+    HasLEB128Directives = false;
   ZeroDirective = "\t.space\t";
   ZeroDirectiveSupportsNonZeroValue = false;
   AsciiDirective = nullptr; // not supported
   AscizDirective = nullptr; // not supported
   ByteListDirective = "\t.byte\t";
   CharacterLiteralSyntax = ACLS_SingleQuotePrefix;
 
   // Use .vbyte for data definition to avoid directives that apply an implicit
   // alignment.

llvm/lib/Target/TargetLoweringObjectFile.cpp

 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
void TargetLoweringObjectFile::Initialize(MCContext &ctx,
   PersonalityEncoding = LSDAEncoding = TTypeEncoding = dwarf::DW_EH_PE_absptr;
   CallSiteEncoding = dwarf::DW_EH_PE_uleb128;
 }
 
 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
   delete Mang;
 }
 
+unsigned TargetLoweringObjectFile::getCallSiteEncoding() const {
+  // If target does not have LEB128 directives, we would need the
+  // call site encoding to be udata4 so that the alternative path
+  // for not having LEB128 directives could work.
+  if (!getContext().getAsmInfo()->hasLEB128Directives())
+    return dwarf::DW_EH_PE_udata4;
+  return CallSiteEncoding;
+}
+
 static bool isNullOrUndef(const Constant *C) {
   // Check that the constant isn't all zeros or undefs.
   if (C->isNullValue() || isa<UndefValue>(C))
     return true;
   if (!isa<ConstantAggregate>(C))
     return false;
   for (auto Operand : C->operand_values()) {
     if (!isNullOrUndef(cast<Constant>(Operand)))

llvm/test/CodeGen/PowerPC/aix-exception.ll

 ; ASM:    blr
 ; ASM:  L..BB1_3:                               # %lpad
 ; ASM:  L..tmp2:
 ; ASM:    bl .__cxa_begin_catch[PR]
 ; ASM:    nop
 ; ASM:    bl .__cxa_end_catch[PR]
 ; ASM:    nop
 ; ASM:    b L..BB1_2
 ; ASM:  L..func_end0:
 
 ; ASM:    .csect .gcc_except_table[RO],2
 ; ASM:    .align  2
 ; ASM:  GCC_except_table1:
 ; ASM:  L..exception0:
 ; ASM:    .byte 255                             # @LPStart Encoding = omit
 ; ASM32:  .byte 187                             # @TType Encoding = indirect datarel sdata4
 ; ASM64:  .byte 188                             # @TType Encoding = indirect datarel sdata8
-; ASM:    .uleb128 L..ttbase0-L..ttbaseref0
-; ASM:  L..ttbaseref0:
+; ASM32:  .byte 37
+; ASM64:  .byte 41
 ; ASM:    .byte 3                               # Call site Encoding = udata4
-; ASM:    .uleb128 L..cst_end0-L..cst_begin0
-; ASM:  L..cst_begin0:
+; ASM:    .byte 26
 ; ASM:    .vbyte  4, L..tmp0-L..func_begin0       # >> Call Site 1 <<
 ; ASM:    .vbyte  4, L..tmp1-L..tmp0              #   Call between L..tmp0 and L..tmp1
 ; ASM:    .vbyte  4, L..tmp2-L..func_begin0       #     jumps to L..tmp2
 ; ASM:    .byte 1                               #   On action: 1
 ; ASM:    .vbyte  4, L..tmp1-L..func_begin0       # >> Call Site 2 <<
 ; ASM:    .vbyte  4, L..func_end0-L..tmp1         #   Call between L..tmp1 and L..func_end0
 ; ASM:    .vbyte  4, 0                            #     has no landing pad
 ; ASM:    .byte 0                               #   On action: cleanup

 ; ASM:    .vbyte  4, 0
 ; ASM32:  .align  2
 ; ASM32:  .vbyte  4, GCC_except_table1
 ; ASM32:  .vbyte  4, __xlcxx_personality_v1[DS]
 ; ASM64:  .align  3
 ; ASM64:  .vbyte  8, GCC_except_table1
 ; ASM64:  .vbyte  8, __xlcxx_personality_v1[DS]
 
-; ASM:    .toc
+; ASM:    .toc
 ; ASM:  L..C0:
-; ASM:    .tc _ZTIi[TC],_ZTIi[UA]
+; ASM:    .tc _ZTIi[TC],_ZTIi[UA]
 
 declare i8* @__cxa_allocate_exception(i32)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__xlcxx_personality_v1(...)
 declare i32 @llvm.eh.typeid.for(i8*)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()

llvm/test/CodeGen/X86/gnu-eh-alternative.ll

+; RUN: llc -verify-machineinstrs -mtriple x86_64-pc-linux-gnu -filetype=asm < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,ULEB128 %s
+; RUN: llc -verify-machineinstrs -mtriple x86_64-pc-linux-gnu -use-leb128-directives=true -filetype=asm < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,ULEB128 %s
+; RUN: llc -verify-machineinstrs -mtriple x86_64-pc-linux-gnu -use-leb128-directives=false -filetype=asm < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,NO128 %s
+
+@_ZTIi = external dso_local constant i8*
+
+define dso_local i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+entry:
+  %retval = alloca i32, align 4
+  %exn.slot = alloca i8*, align 8
+  %ehselector.slot = alloca i32, align 4
+  store i32 0, i32* %retval, align 4
+  %exception = call i8* @__cxa_allocate_exception(i64 4) #1
+  %0 = bitcast i8* %exception to i32*
+  store i32 1, i32* %0, align 16
+  invoke void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #2
+          to label %unreachable unwind label %lpad
+
+lpad:                                             ; preds = %entry
+  %1 = landingpad { i8*, i32 }
+          catch i8* null
+  %2 = extractvalue { i8*, i32 } %1, 0
+  store i8* %2, i8** %exn.slot, align 8
+  %3 = extractvalue { i8*, i32 } %1, 1
+  store i32 %3, i32* %ehselector.slot, align 4
+  br label %catch
+
+catch:                                            ; preds = %lpad
+  %exn = load i8*, i8** %exn.slot, align 8
+  %4 = call i8* @__cxa_begin_catch(i8* %exn) #1
+  store i32 2, i32* %retval, align 4
+  call void @__cxa_end_catch()
+  br label %return
+
+try.cont:                                         ; No predecessors!
+  store i32 1, i32* %retval, align 4
+  br label %return
+
+return:                                           ; preds = %try.cont, %catch
+  %5 = load i32, i32* %retval, align 4
+  ret i32 %5
+
+unreachable:                                      ; preds = %entry
+  unreachable
+}
+
+; ASM:     GCC_except_table0:
+; ASM:     .Lexception0:
+; ASM:      .byte 255                             # @LPStart Encoding = omit
+; ASM:      .byte 3                               # @TType Encoding = udata4
+
+; NO128:    .byte 49
+; NO128:    .byte 3                               # Call site Encoding = udata4
+; NO128:    .byte 39
+; NO128:    .long .Lfunc_begin0-.Lfunc_begin0     # >> Call Site 1 <<
+; NO128:    .long .Ltmp0-.Lfunc_begin0            #   Call between .Lfunc_begin0 and .Ltmp0
+; NO128:    .long 0                               #     has no landing pad
+; NO128:    .byte 0                               #   On action: cleanup
+; NO128:    .long .Ltmp0-.Lfunc_begin0            # >> Call Site 2 <<
+; NO128:    .long .Ltmp1-.Ltmp0                   #   Call between .Ltmp0 and .Ltmp1
+; NO128:    .long .Ltmp2-.Lfunc_begin0            #     jumps to .Ltmp2
+; NO128:    .byte 1                               #   On action: 1
+; NO128:    .long .Ltmp1-.Lfunc_begin0            # >> Call Site 3 <<
+; NO128:    .long .Lfunc_end0-.Ltmp1              #   Call between .Ltmp1 and .Lfunc_end0
+; NO128:    .long 0                               #     has no landing pad
+; NO128:    .byte 0                               #   On action: cleanup
+
+; ULEB128:  .uleb128 .Lttbase0-.Lttbaseref0
+; ULEB128: .Lttbaseref0:
+; ULEB128:  .byte 1                               # Call site Encoding = uleb128
+; ULEB128:  .uleb128 .Lcst_end0-.Lcst_begin0
+; ULEB128: .Lcst_begin0:
+; ULEB128:  .uleb128 .Lfunc_begin0-.Lfunc_begin0    # >> Call Site 1 <<
+; ULEB128:  .uleb128 .Ltmp0-.Lfunc_begin0           #   Call between .Lfunc_begin0 and .Ltmp0
+; ULEB128:  .byte 0                               #     has no landing pad
+; ULEB128:  .byte 0                               #   On action: cleanup
+; ULEB128:  .uleb128 .Ltmp0-.Lfunc_begin0           # >> Call Site 2 <<
+; ULEB128:  .uleb128 .Ltmp1-.Ltmp0                  #   Call between .Ltmp0 and .Ltmp1
+; ULEB128:  .uleb128 .Ltmp2-.Lfunc_begin0           #     jumps to .Ltmp2
+; ULEB128:  .byte 1                               #   On action: 1
+; ULEB128:  .uleb128 .Ltmp1-.Lfunc_begin0           # >> Call Site 3 <<
+; ULEB128:  .uleb128 .Lfunc_end0-.Ltmp1             #   Call between .Ltmp1 and .Lfunc_end0
+; ULEB128:  .byte 0                               #     has no landing pad
+; ULEB128:  .byte 0                               #   On action: cleanup
+
+; ASM:     .Lcst_end0:
+; ASM:      .byte 1                               # >> Action Record 1 <<
+; ASM:                                             #   Catch TypeInfo 1
+; ASM:      .byte 0                               #   No further actions
+; ASM:      .p2align  2
+; ASM:                                             # >> Catch TypeInfos <<
+; ASM:      .long 0                               # TypeInfo 1
+; ASM:     .Lttbase0:
+; ASM:      .p2align  2
+
+declare dso_local i8* @__cxa_allocate_exception(i64)
+declare dso_local void @__cxa_throw(i8*, i8*, i8*)
+declare dso_local i32 @__gxx_personality_v0(...)
+declare dso_local i8* @__cxa_begin_catch(i8*)
+declare dso_local void @__cxa_end_catch()
+