[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

2167

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

2169

SC only use once.

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2167

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?

2169

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

[Xiangling_L]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2167

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

[jasonliu]

Rebase with latest master.

[DiggerLin]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2167

thanks for clarification.

[DiggerLin]

LGTM

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

5381

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

[Xiangling_L]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2088

Should we also handle this in this patch?

2164

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

5338–5339

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

5338–5339

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

16

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

16

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 {
TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(const GlobalValue *GV) {
   case GlobalValue::AppendingLinkage:
     report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
 MCSymbol *TargetLoweringObjectFileXCOFF::getFunctionEntryPointSymbol(
-    const GlobalValue *Function, const TargetMachine &TM) const {
+    const GlobalValue *Func, const TargetMachine &TM) const {
   SmallString<128> NameStr;
   NameStr.push_back('.');
-  getNameWithPrefix(NameStr, Function, TM);
+  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/lib/Target/PowerPC/PPCISelLowering.cpp

 #include "llvm/IR/IntrinsicsPowerPC.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Use.h"
 #include "llvm/IR/Value.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
static SDValue transformCallee(const SDValue &Callee, SelectionDAG &DAG,
   bool UsePlt =
       Subtarget.is32BitELFABI() && !isLocalCallee() &&
       Subtarget.getTargetMachine().getRelocationModel() == Reloc::PIC_;
 
   // On AIX, direct function calls reference the symbol for the function's
   // entry point, which is named by prepending a "." before the function's
   // C-linkage name.
   const auto getAIXFuncEntryPointSymbolSDNode =
-      [&](StringRef FuncName, bool IsDeclaration,
+      [&](StringRef FuncName, bool IsDeclaration, bool IsAlias,
           const XCOFF::StorageClass &SC) {
         auto &Context = DAG.getMachineFunction().getMMI().getContext();
-
         MCSymbolXCOFF *S = cast<MCSymbolXCOFF>(
             Context.getOrCreateSymbol(Twine(".") + Twine(FuncName)));
 
         if (IsDeclaration && !S->hasRepresentedCsectSet()) {
           // On AIX, an undefined symbol needs to be associated with a
           // MCSectionXCOFF to get the correct storage mapping class.
           // In this case, XCOFF::XMC_PR.
           MCSectionXCOFF *Sec = Context.getXCOFFSection(
               S->getSymbolTableName(), XCOFF::XMC_PR, XCOFF::XTY_ER, SC,
               SectionKind::getMetadata());
           S->setRepresentedCsect(Sec);
+        } else if (!IsAlias &&
+                   Subtarget.getTargetMachine().getFunctionSections()) {
+          MCSectionXCOFF *Sec = Context.getXCOFFSection(
+              S->getSymbolTableName(), XCOFF::XMC_PR, XCOFF::XTY_SD, SC,
+              SectionKind::getText());
+          S = Sec->getQualNameSymbol();
         }
 
         MVT PtrVT =
             DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
         return DAG.getMCSymbol(S, PtrVT);
       };
 
   if (isFunctionGlobalAddress(Callee)) {
     const GlobalAddressSDNode *G = cast<GlobalAddressSDNode>(Callee);
     const GlobalValue *GV = G->getGlobal();
 
     if (!Subtarget.isAIXABI())
       return DAG.getTargetGlobalAddress(GV, dl, Callee.getValueType(), 0,
                                         UsePlt ? PPCII::MO_PLT : 0);
 
     assert(!isa<GlobalIFunc>(GV) && "IFunc is not supported on AIX.");
     const XCOFF::StorageClass SC =
         TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV);
     return getAIXFuncEntryPointSymbolSDNode(GV->getName(), GV->isDeclaration(),
-                                            SC);
+                                            isa<GlobalAlias>(GV), SC);
   }
 
   if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
     const char *SymName = S->getSymbol();
     if (!Subtarget.isAIXABI())
       return DAG.getTargetExternalSymbol(SymName, Callee.getValueType(),
                                          UsePlt ? PPCII::MO_PLT : 0);
 
     // If there exists a user-declared function whose name is the same as the
     // ExternalSymbol's, then we pick up the user-declared version.
     const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
     if (const Function *F =
             dyn_cast_or_null<Function>(Mod->getNamedValue(SymName))) {
       const XCOFF::StorageClass SC =
           TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(F);
       return getAIXFuncEntryPointSymbolSDNode(F->getName(), F->isDeclaration(),
-                                              SC);
+                                              /* IsAlias= */ false, SC);
     }
 
-    return getAIXFuncEntryPointSymbolSDNode(SymName, true, XCOFF::C_EXT);
+    return getAIXFuncEntryPointSymbolSDNode(SymName, /* IsDeclaration= */ true,
+                                            /* IsAlias= */ false, XCOFF::C_EXT);
   }
 
   // No transformation needed.
   assert(Callee.getNode() && "What no callee?");
   return Callee;
 }
 
 static SDValue getOutputChainFromCallSeq(SDValue CallSeqStart) {

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