[XCOFF][AIX] Enable -ffunction-sections

[jasonliu]

Summary

This patch implements -ffunction-sections on AIX.
This patch focuses on assembly generation.
Follow-on patch needs to handle:

1. -ffunction-sections implication for jump table.
2. Object file generation path and associated testing.

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2175

change Func->isDeclaration() to Func->isDeclarationForLinker() ?

2177

SC only use once.

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2175

Sometimes I would get confused myself which query should be used.
As far as I understand, isDelcarationForLinker includes linkage that's "AvailableExternally". But when does it actually matter for a function? In other words, what would go wrong if isDeclaration() is used here?

2177

Yes, but without this named variable, the return below would get extremely long, and harder to read.

[Xiangling_L]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2175

AFAIK, this linkage only matters for global variables not for functions.

[jasonliu]

Rebase with latest master.

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2175

thanks for clarification.

[DiggerLin]

LGTM

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

5399 ↗

(On Diff #279916)

nit: delete the space in the /* IsAlias= */.

[Xiangling_L]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088

Should we also handle this in this patch?

2172

s/Okay/okay?

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088

I think this is fairly orthogonal and we could handle it with a follow up patch.
Noted that without handling this, we might run into asserts when using function sections with jump table.

[Xiangling_L]

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

5348 ↗

(On Diff #279916)

I am wondering why we don't just use Subtarget.getTargetMachine().getObjFileLowering().getFunctionEntryPointSymbol instead? And all the logic below about how we get the MCSymbolXCOFF should be simplified by doing this?

[Xiangling_L]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088

I am okay with handling this with a separate patch, but I think you may want to edit the patch description or title to indicate the limited scope of this patch.

[jasonliu]

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

5348 ↗

(On Diff #279916)

Good point. I created NFC patch to address this issue: D84693.

[jasonliu]

Rebase on D84693.

[Xiangling_L]

llvm/test/CodeGen/PowerPC/aix-xcoff-funcsect.ll

15

Just a question here, why would we want to test hidden_foo and static_overalign_foo? I didn't see anything special about them when handling -ffunction-sections options.

[jasonliu]

llvm/test/CodeGen/PowerPC/aix-xcoff-funcsect.ll

15

I want to make sure emitLinkage and setCsectAlignment in doInitialization still works with function-sections. As some of them were accepting labels before, and setCsectAlignment was only doing csect alignment for the whole .text section.

[Xiangling_L]

LGTM. Thanks.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileXCOFF::getSectionForExternalReference(
   // Externals go into a csect of type ER.
   return getContext().getXCOFFSection(
       Name, isa<Function>(GO) ? XCOFF::XMC_DS : XCOFF::XMC_UA, XCOFF::XTY_ER,
       SC, SectionKind::getMetadata());
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
-  assert(!TM.getFunctionSections() && !TM.getDataSections() &&
-         "XCOFF unique sections not yet implemented.");
+  assert(!TM.getDataSections() &&
+         "XCOFF unique data sections not yet implemented.");
 
   // Common symbols go into a csect with matching name which will get mapped
   // into the .bss section.
   if (Kind.isBSSLocal() || Kind.isCommon()) {
     SmallString<128> Name;
     getNameWithPrefix(Name, GO, TM);
     XCOFF::StorageClass SC =
         TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
if (Kind.isMergeableCString()) {
     Name = SizeSpec + utostr(Alignment.value());
 
     return getContext().getXCOFFSection(
         Name, XCOFF::XMC_RO, XCOFF::XTY_SD,
         TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO),
         Kind, /* BeginSymbolName */ nullptr);
   }
 
-  if (Kind.isText())
+  if (Kind.isText()) {
+    if (TM.getFunctionSections()) {
+      return cast<MCSymbolXCOFF>(getFunctionEntryPointSymbol(GO, TM))
+          ->getRepresentedCsect();
+    }
     return TextSection;
+  }
 
   if (Kind.isData() || Kind.isReadOnlyWithRel())
     // TODO: We may put this under option control, because user may want to
     // have read-only data with relocations placed into a read-only section by
     // the compiler.
     return DataSection;
 
   // Zero initialized data must be emitted to the .data section because external
   // linkage control sections that get mapped to the .bss section will be linked
   // as tentative defintions, which is only appropriate for SectionKind::Common.
   if (Kind.isBSS())
     return DataSection;
 
   if (Kind.isReadOnly())
     return ReadOnlySection;
 
   report_fatal_error("XCOFF other section types not yet implemented.");
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForJumpTable(
     const Function &F, const TargetMachine &TM) const {
   assert (!TM.getFunctionSections() && "Unique sections not supported on XCOFF"
           " yet.");
   assert (!F.getComdat() && "Comdat not supported on XCOFF.");
   //TODO: Enable emiting jump table to unique sections when we support it.
   return ReadOnlySection;
 }
 
 bool TargetLoweringObjectFileXCOFF::shouldPutJumpTableInFunctionSection(
     bool UsesLabelDifference, const Function &F) const {
assert(
       (isa<Function>(Func) ||
        (isa<GlobalAlias>(Func) &&
         isa_and_nonnull<Function>(cast<GlobalAlias>(Func)->getBaseObject()))) &&
       "Func must be a function or an alias which has a function as base "
       "object.");
   SmallString<128> NameStr;
   NameStr.push_back('.');
   getNameWithPrefix(NameStr, Func, TM);
+
+  // When -function-sections is enabled, it's not necessary to emit
+  // function entry point label any more. We will use function entry
+  // point csect instead. For function delcarations, it's okay to continue
+  // using label semantic because undefined symbols gets treated as csect with
+  // XTY_ER property anyway.
+  if (TM.getFunctionSections() && !Func->isDeclaration() &&
+      isa<Function>(Func)) {
+    XCOFF::StorageClass SC =
+        TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(Func);
+    return cast<MCSectionXCOFF>(getContext().getXCOFFSection(
+                                    NameStr, XCOFF::XMC_PR, XCOFF::XTY_SD, SC,
+                                    SectionKind::getText()))
+        ->getQualNameSymbol();
+  }
+
   return getContext().getOrCreateSymbol(NameStr);
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
     const Function *F, const TargetMachine &TM) const {
   SmallString<128> NameStr;
   getNameWithPrefix(NameStr, F, TM);
   return getContext().getXCOFFSection(NameStr, XCOFF::XMC_DS, XCOFF::XTY_SD,

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

OutStreamer->emitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
                          PointerSize);
   // Emit a null environment pointer.
   OutStreamer->emitIntValue(0, PointerSize);
 
   OutStreamer->SwitchSection(Current.first, Current.second);
 }
 
 void PPCAIXAsmPrinter::emitFunctionEntryLabel() {
+  // It's not necessary to emit the label when we have individual
+  // function in its own csect.
+  if (!TM.getFunctionSections())
     PPCAsmPrinter::emitFunctionEntryLabel();
+
   // Emit aliasing label for function entry point label.
   llvm::for_each(
       GOAliasMap[&MF->getFunction()], [this](const GlobalAlias *Alias) {
         OutStreamer->emitLabel(
             getObjFileLowering().getFunctionEntryPointSymbol(Alias, TM));
       });
 }
 

llvm/test/CodeGen/PowerPC/aix-xcoff-funcsect.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -function-sections < %s | \
+; RUN:   FileCheck --check-prefix=ASM %s
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN:     -mattr=-altivec -function-sections < %s | \
+; RUN:   FileCheck --check-prefix=ASM %s
+
+@alias_foo = alias void (...), bitcast (void ()* @foo to void (...)*)
+
+define void @foo() {
+entry:
+  ret void
+}
+
+define hidden void @hidden_foo() {
+entry:
+  ret void
+}
+
+define void @bar() {
+entry:
+  call void @foo()
+  call void @static_overalign_foo()
+  call void bitcast (void (...)* @alias_foo to void ()*)()
+  call void bitcast (void (...)* @extern_foo to void ()*)()
+  call void @hidden_foo()
+  ret void
+}
+
+declare void @extern_foo(...)
+
+define internal void @static_overalign_foo() align 64 {
+entry:
+  ret void
+}
+  
+; ASM:        .csect .foo[PR],2
+; ASM-NEXT:   .globl  foo[DS]                         # -- Begin function foo
+; ASM-NEXT:   .globl  .foo[PR]
+; ASM-NEXT:   .align  4
+; ASM-NEXT:   .csect foo[DS]
+; ASM-NEXT:  alias_foo:                                # @foo
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, .foo[PR]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
+; ASM-NEXT:   .csect .foo[PR],2
+; ASM-NEXT:  .alias_foo:
+; ASM-NEXT:  # %bb.0:                                # %entry
+; ASM-NEXT:   blr
+; ASM:        .csect .hidden_foo[PR],2
+; ASM-NEXT:   .globl  hidden_foo[DS],hidden           # -- Begin function hidden_foo
+; ASM-NEXT:   .globl  .hidden_foo[PR],hidden
+; ASM-NEXT:   .align  4
+; ASM-NEXT:   .csect hidden_foo[DS]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, .hidden_foo[PR]              # @hidden_foo
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
+; ASM-NEXT:   .csect .hidden_foo[PR]
+; ASM-NEXT:  # %bb.0:                                # %entry
+; ASM-NEXT:   blr
+; ASM:        .csect .bar[PR],2
+; ASM-NEXT:   .globl  bar[DS]                         # -- Begin function bar
+; ASM-NEXT:   .globl  .bar[PR]
+; ASM-NEXT:   .align  4
+; ASM-NEXT:   .csect bar[DS]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, .bar[PR]                     # @bar
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
+; ASM-NEXT:   .csect .bar[PR],2
+; ASM-NEXT:  # %bb.0:                                # %entry
+; ASM:        bl .foo[PR]
+; ASM-NEXT:   nop
+; ASM-NEXT:   bl .static_overalign_foo[PR]
+; ASM-NEXT:   nop
+; ASM-NEXT:   bl .alias_foo
+; ASM-NEXT:   nop
+; ASM-NEXT:   bl .extern_foo
+; ASM-NEXT:   nop
+; ASM-NEXT:   bl .hidden_foo[PR]
+; ASM-NEXT:   nop
+; ASM:        .csect .static_overalign_foo[PR],6
+; ASM-NEXT:   .lglobl static_overalign_foo[DS]                  # -- Begin function static_overalign_foo
+; ASM-NEXT:   .lglobl .static_overalign_foo[PR]
+; ASM-NEXT:   .align  6
+; ASM-NEXT:   .csect static_overalign_foo[DS]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, .static_overalign_foo[PR]              # @static_overalign_foo
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
+; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
+; ASM-NEXT:   .csect .static_overalign_foo[PR],6
+; ASM-NEXT:  # %bb.0:                                # %entry
+; ASM-NEXT:   blr
+; ASM:        .extern .extern_foo
+; ASM-NEXT:   .extern extern_foo[DS]
+; ASM-NEXT:   .globl  alias_foo
+; ASM-NEXT:   .globl  .alias_foo