[AIX] Emit AvailableExternally Linkage on AIX

[Xiangling_L]

Summary

There are two usages of AvailableExternally Linkage.

The first one is used for inlining of thunks under the Itanium ABI. However, this linkage set on thunks is a temporary presence and is never ended up in the final IR. So we don't need to take care of it in the backend.

The second one is where we have a const declaration with an initializer, we may be able to emit it as available_externally to expose its value to the optimizer. Since on AIX, our strategy is to not use -u to suppress any undefined symbols, we need to emit .extern for the symbol.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

442

I think we look AvailableExternallyLinkage as AvailableExternallyLinkage

you can change as

case GlobalValue::ExternalLinkage:
case GlobalValue::AvailableExternallyLinkage:
    if (MAI->hasDotExternDirective() && GV->isDeclarationForLinker()) {
}

and we do not need code

`
case GlobalValue::AvailableExternallyLinkage:
    if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
   ....
}
`

here.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

442

sorry it should be "I think we look AvailableExternallyLinkage as ExternalLinkage"

[Xiangling_L]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

442

Thank you for your suggestion. I agree that it would give the query more semantic meaning. But since if a GV falls under the AvailableExternallyLinkage category, then GV->isDeclarationForLinker()is always true. So it seems we only need MAI->hasDotExternDirective() here?

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

442

but for ExternalLinkage, it need GV->isDeclarationForLinker(). otherwise it will emit .globl symbolName.

[Xiangling_L]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

442

Sorry, I don't make it clear. But I don't think we should combine ExternalLinkage and AvailableExternallyLinkage. Because for other targets, we still want to fall throught to llvm_unreachable.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

442

o, yes, you are correct, for other target, we still want to fa ll throught to llvm_unreachable. we maybe to change
if (TM.getTargetTriple().isOSBinFormatXCOFF()) to
if (MAI->hasDotExternDirective())

[Xiangling_L]

Change the query to give it more semantic meaning

[jasonliu]

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

32

Test IR could be simplify to:

@_ZN1A1aE = available_externally constant i32 -1, align 4
@b = constant i32* @_ZN1A1aE, align 4

[jasonliu]

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

2

https://reviews.llvm.org/D78929#inline-740137
suggested how to format the command if needs split.

[Xiangling_L]

Adjust the format of the testcase;
Simplify the testcase;

[jasonliu]

LGTM with minor nit.

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

16

nit: It's a bit weird to split between '-mtriple' and 'powerpc64-ibm-aix-xcoff'.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

16

Also, the other cases have the triple before the processor level selection.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (MAI->hasDotLGloblDirective())
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_LGlobal);
     return;
   case GlobalValue::ExternalWeakLinkage:
     if (TM.getTargetTriple().isOSBinFormatXCOFF()) {
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
       return;
     }
     LLVM_FALLTHROUGH;
-  case GlobalValue::AppendingLinkage:
   case GlobalValue::AvailableExternallyLinkage:
+    if (MAI->hasDotExternDirective()) {
+      OutStreamer->emitSymbolAttribute(GVSym, MCSA_Extern);
+      return;
+    }
+    LLVM_FALLTHROUGH;
+  case GlobalValue::AppendingLinkage:
     llvm_unreachable("Should never emit this");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
 void AsmPrinter::getNameWithPrefix(SmallVectorImpl<char> &Name,
                                    const GlobalValue *GV) const {
   TM.getNameWithPrefix(Name, GV, getObjFileLowering().getMangler());

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

TargetLoweringObjectFileXCOFF::getTargetSymbol(const GlobalValue *GV,
 
   // We always use a qualname symbol for a GV that represents
   // a declaration, a function descriptor, or a common symbol.
   // It is inherently ambiguous when the GO represents the address of a
   // function, as the GO could either represent a function descriptor or a
   // function entry point. We choose to always return a function descriptor
   // here.
   if (const GlobalObject *GO = dyn_cast<GlobalObject>(GV)) {
-    if (GO->isDeclaration())
+    if (GO->isDeclarationForLinker())
       return cast<MCSectionXCOFF>(getSectionForExternalReference(GO, TM))
           ->getQualNameSymbol();
 
     SectionKind GOKind = getKindForGlobal(GO, TM);
     if (GOKind.isText())
       return cast<MCSectionXCOFF>(
                  getSectionForFunctionDescriptor(cast<Function>(GO), TM))
           ->getQualNameSymbol();

 
 MCSection *TargetLoweringObjectFileXCOFF::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   report_fatal_error("XCOFF explicit sections not yet implemented.");
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForExternalReference(
     const GlobalObject *GO, const TargetMachine &TM) const {
-  assert(GO->isDeclaration() &&
+  assert(GO->isDeclarationForLinker() &&
          "Tried to get ER section for a defined global.");
 
   SmallString<128> Name;
   getNameWithPrefix(Name, GO, TM);
   XCOFF::StorageClass SC =
       TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
 
   // Externals go into a csect of type ER.

 XCOFF::StorageClass TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(
     const GlobalObject *GO) {
   switch (GO->getLinkage()) {
   case GlobalValue::InternalLinkage:
   case GlobalValue::PrivateLinkage:
     return XCOFF::C_HIDEXT;
   case GlobalValue::ExternalLinkage:
   case GlobalValue::CommonLinkage:
+  case GlobalValue::AvailableExternallyLinkage:
     return XCOFF::C_EXT;
   case GlobalValue::ExternalWeakLinkage:
   case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::LinkOnceODRLinkage:
   case GlobalValue::WeakAnyLinkage:
   case GlobalValue::WeakODRLinkage:
     return XCOFF::C_WEAKEXT;
   case GlobalValue::AppendingLinkage:
     report_fatal_error(
         "There is no mapping that implements AppendingLinkage for XCOFF.");
-  case GlobalValue::AvailableExternallyLinkage:
-    report_fatal_error("unhandled AvailableExternallyLinkage when mapping "
-                       "linkage to StorageClass");
   }
   llvm_unreachable("Unknown linkage type!");
 }
 
 MCSection *TargetLoweringObjectFileXCOFF::getSectionForFunctionDescriptor(
     const Function *F, const TargetMachine &TM) const {
   SmallString<128> NameStr;
   getNameWithPrefix(NameStr, F, TM);

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

bool PPCAIXAsmPrinter::doInitialization(Module &M) {
   if (M.alias_size() > 0u)
     report_fatal_error(
         "module has aliases, which LLVM does not yet support for AIX");
 
   const bool Result = PPCAsmPrinter::doInitialization(M);
 
   auto setCsectAlignment = [this](const GlobalObject *GO) {
     // Declarations have 0 alignment which is set by default.
-    if (GO->isDeclaration())
+    if (GO->isDeclarationForLinker())
       return;
 
     SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO, TM);
     MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
         getObjFileLowering().SectionForGlobal(GO, GOKind, TM));
 
     Align GOAlign = getGVAlignment(GO, GO->getParent()->getDataLayout());
     if (GOAlign > Csect->getAlignment())

llvm/lib/Target/TargetLoweringObjectFile.cpp

 
 
 /// getKindForGlobal - This is a top-level target-independent classifier for
 /// a global object.  Given a global variable and information from the TM, this
 /// function classifies the global in a target independent manner. This function
 /// may be overridden by the target implementation.
 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO,
                                                        const TargetMachine &TM){
-  assert(!GO->isDeclaration() && !GO->hasAvailableExternallyLinkage() &&
+  assert(!GO->isDeclarationForLinker() &&
          "Can only be used for global definitions");
 
   // Functions are classified as text sections.
   if (isa<Function>(GO))
     return SectionKind::getText();
 
   // Basic blocks are classified as text sections.
   if (isa<BasicBlock>(GO))

llvm/test/CodeGen/PowerPC/aix-available-externally-linkage.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec < %s | FileCheck %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
+; RUN: -mattr=-altivec -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --symbols %t.o | FileCheck --check-prefix=XCOFF32 %s
+
+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple \
+; RUN: powerpc64-ibm-aix-xcoff -mattr=-altivec -filetype=obj -o %t.o 2>&1 < %s \
+; RUN: | FileCheck --check-prefix=XCOFF64 %s
+; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
+
+%class.Foo = type { i8 }
+
+@_ZN3Foo1aE = available_externally constant i32 -1
+
+define i32 @_Z3barRKi(i32* nonnull dereferenceable(4) %a) {
+entry:
+  %0 = load i32, i32* %a
+  %add = add nsw i32 %0, 3
+  ret i32 %add
+}
+
+define i32 @main() {
+entry:
+  %f = alloca %class.Foo
+  %call = call i32 @_Z3barRKi(i32* nonnull dereferenceable(4) @_ZN3Foo1aE)
+  ret i32 %call
+}
+
+; CHECK: .extern  _ZN3Foo1aE[UA]
+; CHECK: .tc _ZN3Foo1aE[TC],_ZN3Foo1aE[UA]
+
+; XCOFF32:          Index: [[#Index:]]{{.*}}{{[[:space:]] *}}Name: _ZN3Foo1aE
+; XCOFF32-NEXT:     Value (RelocatableAddress): 0x0
+; XCOFF32-NEXT:     Section: N_UNDEF
+; XCOFF32-NEXT:     Type: 0x0
+; XCOFF32-NEXT:     StorageClass: C_EXT (0x2)
+; XCOFF32-NEXT:     NumberOfAuxEntries: 1
+; XCOFF32-NEXT:     CSECT Auxiliary Entry {
+; XCOFF32-NEXT:       Index: [[#Index+1]]
+; XCOFF32-NEXT:       SectionLen: 0
+; XCOFF32-NEXT:       ParameterHashIndex: 0x0
+; XCOFF32-NEXT:       TypeChkSectNum: 0x0
+; XCOFF32-NEXT:       SymbolAlignmentLog2: 0
+; XCOFF32-NEXT:       SymbolType: XTY_ER (0x0)
+; XCOFF32-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; XCOFF32-NEXT:       StabInfoIndex: 0x0
+; XCOFF32-NEXT:       StabSectNum: 0x0
+; XCOFF32-NEXT:     }
+
+; XCOFF32:          Index: [[#Index:]]{{.*}}{{[[:space:]] *}}Name: _ZN3Foo1aE
+; XCOFF32-NEXT:     Value (RelocatableAddress): 0x50
+; XCOFF32-NEXT:     Section: .data
+; XCOFF32-NEXT:     Type: 0x0
+; XCOFF32-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; XCOFF32-NEXT:     NumberOfAuxEntries: 1
+; XCOFF32-NEXT:     CSECT Auxiliary Entry {
+; XCOFF32-NEXT:       Index: 15
+; XCOFF32-NEXT:       SectionLen: 4
+; XCOFF32-NEXT:       ParameterHashIndex: 0x0
+; XCOFF32-NEXT:       TypeChkSectNum: 0x0
+; XCOFF32-NEXT:       SymbolAlignmentLog2: 2
+; XCOFF32-NEXT:       SymbolType: XTY_SD (0x1)
+; XCOFF32-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; XCOFF32-NEXT:       StabInfoIndex: 0x0
+; XCOFF32-NEXT:       StabSectNum: 0x0
+; XCOFF32-NEXT:     }