[AsmPrinter] Split up .gcc_except_table

[MaskRay]

Summary

MC currently produces monolithic .gcc_except_table section. GCC can split up .gcc_except_table:

• if comdat: .section .gcc_except_table._Z6comdatv,"aG",@progbits,_Z6comdatv,comdat
• otherwise, if -ffunction-sections: .section .gcc_except_table._Z3fooi,"a",@progbits

This ensures that (a) non-prevailing copies are discarded and (b)
.gcc_except_table associated to discarded text sections can be discarded by a
.gcc_except_table-aware linker (GNU ld, but not gold or LLD)

This patches matches the GCC behavior. If -fno-unique-section-names is
specified, we don't append the suffix. If -ffunction-sections is additionally specified,
use .section ...,unique.

Note, if clang driver communicates that the linker is LLD and we know it
is new (11.0.0 or later) we can use SHF_LINK_ORDER to avoid string table
costs, at least in the -fno-unique-section-names case. We cannot use it on GNU
ld because as of binutils 2.35 it does not support mixed SHF_LINK_ORDER &
non-SHF_LINK_ORDER components in an output section
https://sourceware.org/bugzilla/show_bug.cgi?id=26256

For RISC-V -mrelax, this patch additionally fixes an assembler-linker
interaction problem: because a section is shrinkable, the length of a call-site
code range is not a constant. Relocations referencing the associated text
section (STT_SECTION) are needed. However, a STB_LOCAL relocation referencing a
discarded section group member from outside the group is disallowed by the ELF
specification (PR46675):

// a.cc
inline int comdat() { try { throw 1; } catch (int) { return 1; } return 0; }
int main() { return comdat(); }

// b.cc
inline int comdat() { try { throw 1; } catch (int) { return 1; } return 0; }
int foo() { return comdat(); }

clang++ -target riscv64-linux -c a.cc b.cc -fPIC -mno-relax
ld.lld -shared a.o b.o => ld.lld: error: relocation refers to a symbol in a discarded section:

-fbasic-block-sections= is similar to RISC-V -mrelax: there are outstanding relocations.

[MaskRay]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

471

Forgot to add comments. I'd write

// GNU as<2.35 does not support SHF_LINK_ORDER. If we are using the integrated assembler, use SHF_LINK_ORDER so that the linker can discard .gcc_except_table associated to a discarded text section.

[jhenderson]

Sounds reasonable in principle, but what is the compile/link-time performance cost of adding lots of extra section headers, especially when using -ffunction-sections on a link with many functions?

[MaskRay]

In D83655#2146716, @jhenderson wrote:

Sounds reasonable in principle, but what is the compile/link-time performance cost of adding lots of extra section headers, especially when using -ffunction-sections on a link with many functions?

Functions using try catch needs personality and .gcc_except_table. Such functions are not common and thus the increased number of section headers is not a concern.

[psmith]

What would happen if there was a single .text section containing multiple functions, would that produce multiple .gcc_except_table sections each with a SHF_LINK_ORDER dependency on the single .text section? I think that this is OK as there are no other sections that refer to .gcc_except_table and there doesn't need to be a total order. Ideally we could have one .gcc_except_table section per associated .text section.

[MaskRay]

In D83655#2148310, @psmith wrote:

What would happen if there was a single .text section containing multiple functions, would that produce multiple .gcc_except_table sections each with a SHF_LINK_ORDER dependency on the single .text section? I think that this is OK as there are no other sections that refer to .gcc_except_table and there doesn't need to be a total order. Ideally we could have one .gcc_except_table section per associated .text section.

For

.section .text.foo,"ax"
.globl foo, bar
foo: ret
bar: ret

.section .gcc_except_table,"ao",@progbits,foo; .quad 0
.section .gcc_except_table,"ao",@progbits,bar; .quad 0

There will be two .gcc_except_table with the same sh_link (llvm-mc & GNU as>=2.35). Linkers can handle the output correctly. .gcc_except_table doesn't have an order requirement.

[MaskRay]

I failed to think about one problem. We can't use SHF_LINK_ORDER because mixing SHF_LINK_ORDER sections and non-SHF_LINK_ORDER sections are disallowed by linkers.

GNU ld: .gcc_except_table has both ordered [.gcc_except_table' in a.o] and unordered [.gcc_except_table' in b.o] sections
LLD: a.o:(.gcc_except_table): SHF_LINK_ORDER sections in .gcc_except_table are not contiguous I relaxed the restriction a bit (D77007) but non-contignuous SHF_LINK_ORDER sections are still not allowed.

It is a bit unfortunate that the original semantics (order requirement) of SHF_LINK_ORDER imposes an unnecessary restriction.

Created a generic-abi & binutils thread: https://groups.google.com/forum/#!topic/generic-abi/hgx_m1aXqUo

---

For .gcc_except_table, .gcc_except_table.suffix is cumbersome and wastes .strtab space. I want to avoid it. Unfortunately LLD cannot garbage collect .gcc_except_table even if .gcc_except_table is split up so .section .gcc_except_table,"a",@progbits,unique,1 (unique linkage) isn't ideal.

In LLD, --gc-sections happens before .eh_frame combination. During --gc-sections, LLD simply treats every .eh_frame live and thus the referenced .gcc_except_table will be kept live as well (the sole references to .gcc_except_table are from .eh_frame). If we could use SHF_LINK_ORDER, SHF_LINK_ORDER would make .gcc_except_table discardable.

(
Gold and GNU ld relax the "STB_LOCAL relocation referencing a discarded section group member from
outside the group is disallowed " rule by special casing .gcc_except_table (gold: Default_comdat_behavior; GNU ld: _bfd_elf_default_action_discarded))

[jhenderson]

In D83655#2154937, @MaskRay wrote:

I failed to think about one problem. We can't use SHF_LINK_ORDER because mixing SHF_LINK_ORDER sections and non-SHF_LINK_ORDER sections are disallowed by linkers.

GNU ld: .gcc_except_table has both ordered [.gcc_except_table' in a.o] and unordered [.gcc_except_table' in b.o] sections
LLD: a.o:(.gcc_except_table): SHF_LINK_ORDER sections in .gcc_except_table are not contiguous I relaxed the restriction a bit (D77007) but non-contignuous SHF_LINK_ORDER sections are still not allowed.

It is a bit unfortunate that the original semantics (order requirement) of SHF_LINK_ORDER imposes an unnecessary restriction.

Created a generic-abi & binutils thread: https://groups.google.com/forum/#!topic/generic-abi/hgx_m1aXqUo

I've just posted on there too, as I have a similar problem with fragmenting DWARF sections (which would require a mix of interleaved common and SHF_LINK_ORDER (but not actually ordered) sections. I think SHF_LINK_ORDER is maybe not the right tool for the job in this context, because of the ordering requirement as you mention.

[MaskRay]

Play safe and just use the GCC approach.

[MaskRay]

@psmith @jhenderson @jrtc27 This is ready. I simply switched to the safe GCC approach.

[rahmanl]

+1,
Maybe worth mentioning in the description that the issue with -fbasic-block-sections is the revocations associated with @LPStart (Relocations are needed both in PIC and non-PIC mode). The no-basic-block-sections case is not affected since LPStart is omitted.

[jrtc27]

I wonder if it'd be nicer to push this logic into getLSDASection by passing an (optional?) Function given that's where the normal LSDASection gets created? Having the check for ELF here seems to indicate that the logic isn't quite in the right place and belongs in the MCOFI subclass.

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

466

Should this instead inherit the (base) flags from LSDASection? For CHERI we have to add SHF_WRITE (we make it a relro section) so it'd be nice to inherit that automatically here rather than needing to have the logic duplicated between here and initELFMCObjectFileInfo.

[MaskRay]

Reuse flags
Check function sections

[MaskRay]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

466

Changed to the base flags to make CHERI convenient.

[rahmanl]

In D83655#2366091, @jrtc27 wrote:

I wonder if it'd be nicer to push this logic into getLSDASection by passing an (optional?) Function given that's where the normal LSDASection gets created? Having the check for ELF here seems to indicate that the logic isn't quite in the right place and belongs in the MCOFI subclass.

I agree with @jrtc27 here. How about we implement this like MCObjectFileInfo::getStackSizeSection(const MCSection&) or MCObjectFileInfo::getBBAddrMapSection(const MCSection&). The intended logic seems quite similar.

[MaskRay]

In D83655#2366206, @rahmanl wrote:

In D83655#2366091, @jrtc27 wrote:

I wonder if it'd be nicer to push this logic into getLSDASection by passing an (optional?) Function given that's where the normal LSDASection gets created? Having the check for ELF here seems to indicate that the logic isn't quite in the right place and belongs in the MCOFI subclass.

I agree with @jrtc27 here. How about we implement this like MCObjectFileInfo::getStackSizeSection(const MCSection&) or MCObjectFileInfo::getBBAddrMapSection(const MCSection&). The intended logic seems quite similar.

It would be inconvenient.

1. getStackSizeSection and getBBAddrMapSection do not use different section names. They will need to know the suffix
2. MCObjectFileInfo does not know whether function sections is enabled

MCObjectFileInfo is a good place for getStackSizeSection and getBBAddrMapSection because they need just information from MCObjectFileInfo. However, it is different for .gcc_except_table

[rahmanl]

In D83655#2366222, @MaskRay wrote:

In D83655#2366206, @rahmanl wrote:

In D83655#2366091, @jrtc27 wrote:

I wonder if it'd be nicer to push this logic into getLSDASection by passing an (optional?) Function given that's where the normal LSDASection gets created? Having the check for ELF here seems to indicate that the logic isn't quite in the right place and belongs in the MCOFI subclass.

I agree with @jrtc27 here. How about we implement this like MCObjectFileInfo::getStackSizeSection(const MCSection&) or MCObjectFileInfo::getBBAddrMapSection(const MCSection&). The intended logic seems quite similar.

It would be inconvenient.

1. getStackSizeSection and getBBAddrMapSection do not use different section names. They will need to know the suffix
2. MCObjectFileInfo does not know whether function sections is enabled

MCObjectFileInfo is a good place for getStackSizeSection and getBBAddrMapSection because they need just information from MCObjectFileInfo. However, it is different for .gcc_except_table

Sorry for the misunderstanding. I am fine with your logic, but prefer if the code is better organized: I had a stab at it D90523.

[MaskRay]

Move section creation logic to TargetLoweringObjectFileImpl.cpp and add a virtual function getSectionForLSDA there

[MaskRay]

In D83655#2366269, @rahmanl wrote:

In D83655#2366222, @MaskRay wrote:

In D83655#2366206, @rahmanl wrote:

In D83655#2366091, @jrtc27 wrote:

I wonder if it'd be nicer to push this logic into getLSDASection by passing an (optional?) Function given that's where the normal LSDASection gets created? Having the check for ELF here seems to indicate that the logic isn't quite in the right place and belongs in the MCOFI subclass.

I agree with @jrtc27 here. How about we implement this like MCObjectFileInfo::getStackSizeSection(const MCSection&) or MCObjectFileInfo::getBBAddrMapSection(const MCSection&). The intended logic seems quite similar.

It would be inconvenient.

1. getStackSizeSection and getBBAddrMapSection do not use different section names. They will need to know the suffix
2. MCObjectFileInfo does not know whether function sections is enabled

MCObjectFileInfo is a good place for getStackSizeSection and getBBAddrMapSection because they need just information from MCObjectFileInfo. However, it is different for .gcc_except_table

Sorry for the misunderstanding. I am fine with your logic, but prefer if the code is better organized: I had a stab at it D90523.

Thanks! This does look cleaner, moreoever, EHStreamer.cpp does not have to include 3 additional headers. Tweaked a bit.

[jrtc27]

:)

[rahmanl]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

858

I have a question here: Why can't we use a unique ID and use the same section name ('gcc_except_table')?

[MaskRay]

Add fullblown support

[MaskRay]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

858

We can... the logic will become more complicated. I'm going to do this.

[MaskRay]

@rahmanl Does this look good to you now? :)

[rahmanl]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

852

You have a point here. Currently the help line for -funique-section-names says:
-funique-section-names Use unique names for text and data sections (ELF Only).

And I couldn't find a case where getUniqueSectionNames() is used for non-globals.

One thing I can suggest is not to gate on this flag and instead use the suffix whenever we can't use a unique ID. WDYT?

[MaskRay]

Don't condition on -funique-section-names

[MaskRay]

Simplify

[dblaikie]

(FWIW, I'd personally be in favor of -funique-section-names applying here - the specific textual description of the flag in documentation I don't think should necessarily be held as definitive, but possibly descriptive (perhaps it describes correctly the behavior as it exists/was implemented, and could be updated to include this new behavior) - seems like if someone's passing that flag it's probably because they don't want or may not have toolchain support for non-unique section names. It'd be pretty quirky/odd situation where they didn't want unique section names only for some sections and not for others.

But I don't feel super strongly about it if folks have other ideas)

[MaskRay]

Switch back to GCC compatible behavior (if -funique-section-names, use a suffix)

[MaskRay]

@rahmanl: @dblaikie and @jrtc27 prefer having a suffix to be consistent with .text.foo and .rodata.foo . On a second thought I think this indeed makes more sense. People who want to save .strtab space can use -fno-unique-section-names. Are you fine with the resolution?

[rahmanl]

In D83655#2369636, @MaskRay wrote:

@rahmanl: @dblaikie and @jrtc27 prefer having a suffix to be consistent with .text.foo and .rodata.foo . On a second thought I think this indeed makes more sense. People who want to save .strtab space can use -fno-unique-section-names. Are you fine with the resolution?

Agreed.
In this case`-funique-section-names` is mandatory to ensure LSDA sections are separated when unique IDs cannot be used, and that is fine because unique-section-names=true is the default.

Thanks for making this patch a priority.

[vitalybuka]

It crashes here http://lab.llvm.org:8011/#/builders/77/builds/623/steps/10/logs/stdio

[jrtc27]

In D83655#2370248, @vitalybuka wrote:

It crashes here http://lab.llvm.org:8011/#/builders/77/builds/623/steps/10/logs/stdio

Thanks, we all managed to miss that annoying case. Build is now green.

[MaskRay]

In D83655#2370283, @jrtc27 wrote:

In D83655#2370248, @vitalybuka wrote:

It crashes here http://lab.llvm.org:8011/#/builders/77/builds/623/steps/10/logs/stdio

Thanks, we all managed to miss that annoying case. Build is now green.

Thanks for fixing it! We need an ARM EH test case to prevent regression.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

public:
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
 
   MCSection *getSectionForJumpTable(const Function &F,
                                     const TargetMachine &TM) const override;
+  MCSection *getSectionForLSDA(const Function &F,
+                               const TargetMachine &TM) const override;
 
   MCSection *
   getSectionForMachineBasicBlock(const Function &F,
                                  const MachineBasicBlock &MBB,
                                  const TargetMachine &TM) const override;
 
   bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
                                            const Function &F) const override;

llvm/include/llvm/MC/MCObjectFileInfo.h

public:
   unsigned getCompactUnwindDwarfEHFrameOnly() const {
     return CompactUnwindDwarfEHFrameOnly;
   }
 
   MCSection *getTextSection() const { return TextSection; }
   MCSection *getDataSection() const { return DataSection; }
   MCSection *getBSSSection() const { return BSSSection; }
   MCSection *getReadOnlySection() const { return ReadOnlySection; }
-  MCSection *getLSDASection() const { return LSDASection; }
   MCSection *getCompactUnwindSection() const { return CompactUnwindSection; }
   MCSection *getDwarfAbbrevSection() const { return DwarfAbbrevSection; }
   MCSection *getDwarfInfoSection() const { return DwarfInfoSection; }
   MCSection *getDwarfInfoSection(uint64_t Hash) const {
     return getDwarfComdatSection(".debug_info", Hash);
   }
   MCSection *getDwarfLineSection() const { return DwarfLineSection; }
   MCSection *getDwarfLineStrSection() const { return DwarfLineStrSection; }

llvm/include/llvm/Target/TargetLoweringObjectFile.h

MCSection *SectionForGlobal(const GlobalObject *GO,
                               const TargetMachine &TM) const;
 
   virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName,
                                  const GlobalValue *GV,
                                  const TargetMachine &TM) const;
 
   virtual MCSection *getSectionForJumpTable(const Function &F,
                                             const TargetMachine &TM) const;
+  virtual MCSection *getSectionForLSDA(const Function &F,
+                                       const TargetMachine &TM) const {
+    return LSDASection;
+  }
 
   virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
                                                    const Function &F) const;
 
   /// Targets should implement this method to assign a section to globals with
   /// an explicit section specfied. The implementation of this method can
   /// assume that GO->hasSection() is true.
   virtual MCSection *

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

MCSymbol *EHStreamer::emitExceptionTable() {
   bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj;
   bool IsWasm = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::Wasm;
   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().getLSDASection();
+  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.
     TTypeEncoding = dwarf::DW_EH_PE_omit;
   } else {
     // Okay, we have actual filters or typeinfos to emit.  As such, we need to
MCSymbol *EHStreamer::emitExceptionTable() {
 
   // Begin the exception table.
   // Sometimes we want not to emit the data into separate section (e.g. ARM
   // EHABI). In this case LSDASection will be NULL.
   if (LSDASection)
     Asm->OutStreamer->SwitchSection(LSDASection);
   Asm->emitAlignment(Align(4));
 
   // Emit the LSDA.
   MCSymbol *GCCETSym =
     Asm->OutContext.getOrCreateSymbol(Twine("GCC_except_table")+
                                       Twine(Asm->getFunctionNumber()));
   Asm->OutStreamer->emitLabel(GCCETSym);
   MCSymbol *CstEndLabel = Asm->createTempSymbol(
       CallSiteRanges.size() > 1 ? "action_table_base" : "cst_end");
 
   MCSymbol *TTBaseLabel = nullptr;
   if (HaveTTData)
     TTBaseLabel = Asm->createTempSymbol("ttbase");
 
   const bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
 

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (!EmitUniqueSection)
     return ReadOnlySection;
 
   return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
                                    getMangler(), TM, EmitUniqueSection,
                                    ELF::SHF_ALLOC, &NextUniqueID,
                                    /* AssociatedSymbol */ nullptr);
 }
 
+MCSection *
+TargetLoweringObjectFileELF::getSectionForLSDA(const Function &F,
+                                               const TargetMachine &TM) const {
+  // If neither COMDAT nor function sections, use the monolithic LSDA section.
+  if (!F.hasComdat() && !TM.getFunctionSections())
+    return LSDASection;
+
+  const auto *LSDA = cast<MCSectionELF>(LSDASection);
+  unsigned Flags = LSDA->getFlags();
+  StringRef Group;
+  if (F.hasComdat()) {
+    Group = F.getComdat()->getName();
+    Flags |= ELF::SHF_GROUP;
+  }
+
+  // Append the function name as the suffix like GCC, assuming
+  // -funique-section-names applies to .gcc_except_table sections.
+  if (TM.getUniqueSectionNames())
+    return getContext().getELFSection(LSDA->getName() + "." + F.getName(),
+                                      LSDA->getType(), Flags, 0, Group,
+                                      MCSection::NonUniqueID, nullptr);
+
+  // Allocate a unique ID if function sections && (integrated assembler or GNU
+  // as>=2.35). Note we could use SHF_LINK_ORDER to facilitate --gc-sections but
+  // that would require that we know the linker is a modern LLD (12.0 or later).
+  // GNU ld as of 2.35 does not support mixed SHF_LINK_ORDER &
+  // non-SHF_LINK_ORDER components in an output section
+  // https://sourceware.org/bugzilla/show_bug.cgi?id=26256
+  unsigned ID = TM.getFunctionSections() &&
+                        getContext().getAsmInfo()->useIntegratedAssembler()
+                    ? NextUniqueID++
+                    : MCSection::NonUniqueID;
+  return getContext().getELFSection(LSDA->getName(), LSDA->getType(), Flags, 0,
+                                    Group, ID, nullptr);
+}
+
 bool TargetLoweringObjectFileELF::shouldPutJumpTableInFunctionSection(
     bool UsesLabelDifference, const Function &F) const {
   // We can always create relative relocations, so use another section
   // that can be marked non-executable.
   return false;
 }
 
 /// Given a mergeable constant with the specified size and relocation

llvm/test/CodeGen/X86/gcc_except_table-multi.ll

+; RUN: llc < %s -mtriple=x86_64 | FileCheck %s --check-prefixes=CHECK,NORMAL
+; RUN: llc < %s -mtriple=x86_64 -unique-section-names=false | FileCheck %s --check-prefixes=CHECK,NOUNIQUE
+; RUN: llc < %s -mtriple=x86_64 -function-sections | FileCheck %s --check-prefixes=CHECK,SEP
+; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=false | FileCheck %s --check-prefixes=CHECK,SEP_NOUNIQUE
+
+;; Don't use `,unique` if GNU as<2.35.
+; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=false -no-integrated-as | FileCheck %s --check-prefixes=CHECK,SEP_NOUNIQUE_GAS
+
+@_ZTIi = external constant i8*
+
+;; If the function is in a comdat group, the generated .gcc_except_table should
+;; be placed in the same group, so that .gcc_except_table can be discarded if
+;; the comdat is not prevailing. If -funique-section-names, append the function name.
+$group = comdat any
+define i32 @group() uwtable comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-LABEL:       group:
+; CHECK:             .cfi_endproc
+; NORMAL-NEXT:       .section .gcc_except_table.group,"aG",@progbits,group,comdat{{$}}
+; NOUNIQUE-NEXT:     .section .gcc_except_table,"aG",@progbits,group,comdat{{$}}
+; SEP-NEXT:          .section .gcc_except_table.group,"aG",@progbits,group,comdat{{$}}
+; SEP_NOUNIQUE-NEXT: .section .gcc_except_table,"aG",@progbits,group,comdat,unique,2
+; SEP_NOUNIQUE_GAS-NEXT: .section .gcc_except_table,"aG",@progbits,group,comdat{{$}}
+entry:
+  invoke void @ext() to label %try.cont unwind label %lpad
+lpad:
+  %0 = landingpad { i8*, i32 } catch i8* bitcast (i8** @_ZTIi to i8*)
+  br label %eh.resume
+try.cont:
+  ret i32 0
+eh.resume:
+  resume { i8*, i32 } %0
+}
+
+;; If the function is not in a comdat group, but function sections is enabled,
+;; use a separate section by either using a unique ID (integrated assembler) or
+;; a suffix (GNU as<2.35).
+define i32 @foo() uwtable personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-LABEL:       foo:
+; CHECK:             .cfi_endproc
+; NORMAL-NEXT:       .section .gcc_except_table,"a",@progbits{{$}}
+; NOUNIQUE-NEXT:     .section .gcc_except_table,"a",@progbits{{$}}
+; SEP-NEXT:          .section .gcc_except_table.foo,"a",@progbits{{$}}
+; SEP_NOUNIQUE-NEXT: .section .gcc_except_table,"a",@progbits,unique,4
+; SEP_NOUNIQUE_GAS-NEXT: .section .gcc_except_table,"a",@progbits{{$}}
+entry:
+  invoke void @ext() to label %try.cont unwind label %lpad
+lpad:
+  %0 = landingpad { i8*, i32 } catch i8* bitcast (i8** @_ZTIi to i8*)
+  br label %eh.resume
+try.cont:
+  ret i32 0
+eh.resume:
+  resume { i8*, i32 } %0
+}
+
+declare void @ext()
+
+declare i32 @__gxx_personality_v0(...)