Refactor D83655.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

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 *getLSDASection(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/Target/TargetLoweringObjectFile.h

virtual MCSection *getStaticCtorSection(unsigned Priority,
     return StaticCtorSection;
   }
 
   virtual MCSection *getStaticDtorSection(unsigned Priority,
                                           const MCSymbol *KeySym) const {
     return StaticDtorSection;
   }
 
+  virtual MCSection *getLSDASection(const Function &F,
+                                    const TargetMachine &TM) const {
+    return LSDASection;
+  }
+
   /// Create a symbol reference to describe the given TLS variable when
   /// emitting the address in debug info.
   virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const;
 
   virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
                                                const GlobalValue *RHS,
                                                const TargetMachine &TM) const {
     return nullptr;

llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "EHStreamer.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/IR/Comdat.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
+#include "llvm/Target/TargetMachine.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 
 EHStreamer::EHStreamer(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
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().getLSDASection(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

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (Kind.isMergeableConst32() && MergeableConst32Section)
     return MergeableConst32Section;
   if (Kind.isReadOnly())
     return ReadOnlySection;
 
   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
   return DataRelROSection;
 }
 
+MCSection *
+TargetLoweringObjectFileELF::getLSDASection(const Function &F,
+                                            const TargetMachine &TM) const {
+  if (!F.hasComdat() && !TM.getFunctionSections())
+    return LSDASection;
+
+  const MCSymbolELF *LinkedToSym = nullptr;
+  unsigned Flags = cast<MCSectionELF>(LSDASection)->getFlags();
+  StringRef Group;
+  if (F.hasComdat()) {
+    Group = F.getComdat()->getName();
+    Flags |= ELF::SHF_GROUP;
+  }
+  // Append the function name as the suffix like GCC. Note in the
+  // -fno-unique-section-names case we could use SHF_LINK_ORDER but that
+  // would require that we know the linker is a modern LLD (11.0 or
+  // later).
+  return getContext().getELFSection(LSDASection->getName(), ELF::SHT_PROGBITS,
+                                    Flags, 0, Group, MCSection::NonUniqueID,
+                                    LinkedToSym);
+}
+
 /// Returns a unique section for the given machine basic block.
 MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock(
     const Function &F, const MachineBasicBlock &MBB,
     const TargetMachine &TM) const {
   assert(MBB.isBeginSection() && "Basic block does not start a section!");
   unsigned UniqueID = MCContext::GenericSectionID;
 
   // For cold sections use the .text.split. prefix along with the parent

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

+; RUN: llc < %s -mtriple=x86_64 | FileCheck %s --check-prefixes=CHECK,NOSEPARATE
+; RUN: llc < %s -mtriple=x86_64 -function-sections | FileCheck %s --check-prefixes=CHECK,SEPARATE
+@_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.
+$group = comdat any
+define i32 @group() uwtable comdat personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-LABEL: group:
+; CHECK:       .cfi_endproc
+; CHECK-NEXT:    .section .gcc_except_table.group,"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, use the monolithic .gcc_except_table
+;; if function sections are not enabled. Otherwise, append the function name to
+;; get a unique section name like GCC. This allows --gc-sections and STB_LOCAL
+;; relocations referencing text sections if call-site code ranges are not
+;; compile-time constant (RISC-V -mrelax or -fbasic-block-sections=).
+define i32 @foo() uwtable personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
+; CHECK-LABEL:     foo:
+; CHECK:             .cfi_endproc
+; NOSEPARATE-NEXT: .section .gcc_except_table,"a",@progbits
+; SEPARATE-NEXT:   .section .gcc_except_table.foo,"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(...)