[XCOFF][AIX] Use unique section names for LSDA and EH info sections with -ffunction-sections

[xingxue]

Summary

When -ffunction-sections is on, this patch makes the compiler to generate unique LSDA and EH info sections for functions on AIX by appending the function name to the section name as a suffix. This will allow the AIX linker to garbage-collect unused function.

[hubert.reinterpretcast]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

291

Fix typo.

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

43

Should we also try to use the explicit section name if the function has one?

44

Fix option name.

53

I think the cast is not necessary.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2571

Should we also try to use the explicit section name if the function has one?

[xingxue]

Addressed comments:

• Fixed typos in comments;
• Removed unnecessary cast.

[xingxue]

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

291

Fixed, thanks!

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

43

I am inclined to use the function name because this is consistent with the behavior on Linux.

44

Fixed, thanks!

53

Removed the unnecessary cast, thanks!

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2571

I am inclined to use the function name because this is consistent with the behavior on Linux.

[hubert.reinterpretcast]

LGTM; however, might want to wait a bit to see if other reviewers have comments.

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

43

Yes, it does seem that the explicit section name is not used by Linux (with and without -ffunction-sections).

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2571

Yes, it does seem that the explicit section name is not used by Linux (with and without -ffunction-sections).

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

getSectionForExternalReference(const GlobalObject *GO,
                                  const TargetMachine &TM) const override;
 
   /// For functions, this will always return a function descriptor symbol.
   MCSymbol *getTargetSymbol(const GlobalValue *GV,
                             const TargetMachine &TM) const override;
 
   MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func,
                                         const TargetMachine &TM) const override;
+
+  /// For functions, this will return the LSDA section. If option
+  /// -ffunction-sections is on, this will return a unique csect with the
+  /// function name appended to .gcc_except_table as a suffix of the LSDA
+  /// section name.
+  MCSection *getSectionForLSDA(const Function &F, const MCSymbol &FnSym,
+                               const TargetMachine &TM) const override;
 };
 
 class TargetLoweringObjectFileGOFF : public TargetLoweringObjectFile {
 public:
   TargetLoweringObjectFileGOFF();
   ~TargetLoweringObjectFileGOFF() override = default;
 
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/MC/MCSectionXCOFF.h

public:
   bool isVirtualSection() const override;
   StringRef getSymbolTableName() const { return SymbolTableName; }
   bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
   bool isCsect() const { return CsectProp.hasValue(); }
   bool isDwarfSect() const { return DwarfSubtypeFlags.hasValue(); }
   Optional<XCOFF::DwarfSectionSubtypeFlags> getDwarfSubtypeFlags() const {
     return DwarfSubtypeFlags;
   }
+  Optional<XCOFF::CsectProperties> getCsectProp() const { return CsectProp; }
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

 //===-- CodeGen/AsmPrinter/AIXException.cpp - AIX Exception Impl ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing AIX exception info into asm files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfException.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
+#include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 
 AIXException::AIXException(AsmPrinter *A) : DwarfCFIExceptionBase(A) {}
 
 void AIXException::markFunctionEnd() { endFragment(); }
 
 void AIXException::emitExceptionInfoTable(const MCSymbol *LSDA,
                                           const MCSymbol *PerSym) {
   // Generate EH Info Table.
   // The EH Info Table, aka, 'compat unwind section' on AIX, have the following
   // format: struct eh_info_t {
   //   unsigned version;           /* EH info verion 0 */
   // #if defined(__64BIT__)
   //   char _pad[4];               /* padding */
   // #endif
   //   unsigned long lsda;         /* Pointer to LSDA */
   //   unsigned long personality;  /* Pointer to the personality routine */
   //   }
 
-  Asm->OutStreamer->SwitchSection(
-      Asm->getObjFileLowering().getCompactUnwindSection());
+  auto *EHInfo =
+      cast<MCSectionXCOFF>(Asm->getObjFileLowering().getCompactUnwindSection());
+  if (Asm->TM.getFunctionSections()) {
+    // If option -ffunction-sections is on, append the function name to the
+    // name of EH Info Table csect so that each function has its own EH Info
+    // Table csect. This helps the linker to garbage-collect EH info of unused
+    // functions.
+    SmallString<128> NameStr = EHInfo->getName();
+    raw_svector_ostream(NameStr) << '.' << Asm->MF->getFunction().getName();
+    EHInfo = Asm->OutContext.getXCOFFSection(NameStr, EHInfo->getKind(),
+                                             EHInfo->getCsectProp());
+  }
+  Asm->OutStreamer->SwitchSection(EHInfo);
   MCSymbol *EHInfoLabel =
       TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(Asm->MF);
   Asm->OutStreamer->emitLabel(EHInfoLabel);
 
   // Version number.
   Asm->emitInt32(0);
 
   const DataLayout &DL = MMI->getModule()->getDataLayout();

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileXCOFF::getSectionForTOCEntry(
   // the chance of needing -bbigtoc is decreased.
   return getContext().getXCOFFSection(
       cast<MCSymbolXCOFF>(Sym)->getSymbolTableName(), SectionKind::getData(),
       XCOFF::CsectProperties(
           TM.getCodeModel() == CodeModel::Large ? XCOFF::XMC_TE : XCOFF::XMC_TC,
           XCOFF::XTY_SD));
 }
 
+MCSection *TargetLoweringObjectFileXCOFF::getSectionForLSDA(
+    const Function &F, const MCSymbol &FnSym, const TargetMachine &TM) const {
+  auto *LSDA = cast<MCSectionXCOFF>(LSDASection);
+  if (TM.getFunctionSections()) {
+    // If option -ffunction-sections is on, append the function name to the
+    // name of the LSDA csect so that each function has its own LSDA csect.
+    // This helps the linker to garbage-collect EH info of unused functions.
+    SmallString<128> NameStr = LSDA->getName();
+    raw_svector_ostream(NameStr) << '.' << F.getName();
+    LSDA = getContext().getXCOFFSection(NameStr, LSDA->getKind(),
+                                        LSDA->getCsectProp());
+  }
+  return LSDA;
+}
 //===----------------------------------------------------------------------===//
 //                                  GOFF
 //===----------------------------------------------------------------------===//
 TargetLoweringObjectFileGOFF::TargetLoweringObjectFileGOFF() = default;
 
 MCSection *TargetLoweringObjectFileGOFF::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   return SelectSectionForGlobal(GO, Kind, TM);

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

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec -simplifycfg-require-and-preserve-domtree=1 < %s | \
-; RUN:   FileCheck --check-prefixes=ASM,ASM32 %s
+; RUN:   FileCheck --check-prefixes=ASM,ASMNFS,ASM32 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec -simplifycfg-require-and-preserve-domtree=1 < %s | \
-; RUN:   FileCheck --check-prefixes=ASM,ASM64 %s
+; RUN:   FileCheck --check-prefixes=ASM,ASMNFS,ASM64 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -simplifycfg-require-and-preserve-domtree=1 \
+; RUN:     -function-sections < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,ASMFS,ASM32 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -simplifycfg-require-and-preserve-domtree=1 \
+; RUN:     -function-sections < %s | \
+; RUN:   FileCheck --check-prefixes=ASM,ASMFS,ASM64 %s
 
 @_ZTIi = external constant i8*
 
 define void @_Z9throwFuncv() {
 entry:
   %exception = call i8* @__cxa_allocate_exception(i32 4) #2
   %0 = bitcast i8* %exception to i32*
   store i32 1, i32* %0, align 16
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #3
   unreachable
 }
 
-; ASM:    ._Z9throwFuncv:
+; ASMNFS: ._Z9throwFuncv:
+; ASMFS:    .csect ._Z9throwFuncv[PR],2
 ; ASM:      bl .__cxa_allocate_exception[PR]
 ; ASM:      nop
 ; ASM32:    lwz 4, L..C0(2)
 ; ASM64:    ld 4, L..C0(2)
 ; ASM:      bl .__cxa_throw[PR]
 ; ASM:      nop
 
 define i32 @_Z9catchFuncv() personality i8* bitcast (i32 (...)* @__xlcxx_personality_v1 to i8*) {

 eh.resume:                                        ; preds = %catch.dispatch
   %exn1 = load i8*, i8** %exn.slot, align 4
   %sel2 = load i32, i32* %ehselector.slot, align 4
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn1, 0
   %lpad.val3 = insertvalue { i8*, i32 } %lpad.val, i32 %sel2, 1
   resume { i8*, i32 } %lpad.val3
 }
 
-; ASM:  ._Z9catchFuncv:
+; ASMNFS: ._Z9catchFuncv:
+; ASMFS:        .csect ._Z9catchFuncv[PR],2
 ; ASM:  L..func_begin0:
 ; ASM:  # %bb.0:                                # %entry
 ; ASM:    mflr 0
 ; ASM:  L..tmp0:
 ; ASM:    bl ._Z9throwFuncv
 ; ASM:    nop
 ; ASM:  L..tmp1:
 ; ASM:  # %bb.1:                                # %invoke.cont

 ; ASM:                                    # -IsFloatingPointPresent
 ; ASM:                                    # -IsFloatingPointOperationLogOrAbortEnabled
 ; ASM:    .byte   0x41                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; ASM:                                    # OnConditionDirective = 0, -IsCRSaved, +IsLRSaved
 ; ASM:    .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; ASM:    .byte   0x80                            # +HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; ASM:    .byte   0x00                            # NumberOfFixedParms = 0
 ; ASM:    .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
-; ASM:    .vbyte  4, L.._Z9catchFuncv0-._Z9catchFuncv # Function size
+; ASMNFS: .vbyte  4, L.._Z9catchFuncv0-._Z9catchFuncv # Function size
+; ASMFS:  .vbyte  4, L.._Z9catchFuncv0-._Z9catchFuncv[PR] # Function size
 ; ASM:    .vbyte  2, 0x000d                       # Function name len = 13
 ; ASM:    .byte   "_Z9catchFuncv"                 # Function Name
 ; ASM:    .byte   0x08                            # ExtensionTableFlag = TB_EH_INFO
 ; ASM:    .align  2
 ; ASM32:  .vbyte  4, L..C1-TOC[TC0]               # EHInfo Table
 ; ASM64:  .vbyte  8, L..C1-TOC[TC0]               # EHInfo Table
 ; ASM:  L..func_end0:
 
-; ASM:    .csect .gcc_except_table[RO],2
+; ASMNFS:   .csect .gcc_except_table[RO],2
+; ASMFS:    .csect .gcc_except_table._Z9catchFuncv[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
 ; ASM32:  .byte 37
 ; ASM64:  .byte 41

 ; ASM:    .byte 0                               #   No further actions
 ; ASM:    .align  2
 ; ASM:                                          # >> Catch TypeInfos <<
 ; ASM32:  .vbyte  4, L..C0-TOC[TC0]               # TypeInfo 1
 ; ASM64:  .vbyte  8, L..C0-TOC[TC0]               # TypeInfo 1
 ; ASM:  L..ttbase0:
 ; ASM:    .align  2
 
-; ASM:    .csect .eh_info_table[RW],2
+; ASMNFS:   .csect .eh_info_table[RW],2
+; ASMFS:    .csect .eh_info_table._Z9catchFuncv[RW],2
 ; ASM:  __ehinfo.1:
 ; 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]