[AIX][XCOFF] implement available externally linkage .

[DiggerLin]

Summary

implement available externally linkage

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (MAI->hasWeakDefDirective()) {
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
       //NOTE: linkonce is handled by the section the symbol was assigned to.
     } else {
       // .weak _foo
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
     }
     return;
   case GlobalValue::ExternalLinkage:
-    if (MAI->hasDotExternDirective() && GV->isDeclaration())
+  case GlobalValue::AvailableExternallyLinkage:
+    if (MAI->hasDotExternDirective() && GV->isDeclarationForLinker())
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Extern);
     else
       OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
     return;
   case GlobalValue::PrivateLinkage:
     return;
   case GlobalValue::InternalLinkage:
     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:
     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/test/CodeGen/PowerPC/aix-available-extern.ll

+; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefixes=COMMON,BIT32 %s
+
+; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec < %s | \
+; RUN:   FileCheck --check-prefixes=COMMON,BIT64 %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=CHECKSYM %s
+
+; RUN: not --crash llc -verify-machineinstrs -mcpu=pwr4 -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:   -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.DoFHandler = type { [5 x i32] }
+
+@_ZN10DoFHandlerILi5EE17invalid_dof_indexE = available_externally constant i32 -1, align 4
+
+define i32 @_Z3fooRKi(i32* dereferenceable(4) %b) {
+entry:
+  %b.addr = alloca i32*, align 4
+  store i32* %b, i32** %b.addr, align 4
+  %0 = load i32*, i32** %b.addr, align 4
+  %1 = load i32, i32* %0, align 4
+  %add = add nsw i32 %1, 1
+  ret i32 %add
+}
+
+define float @_Z3barv() {
+entry:
+  %dof = alloca %class.DoFHandler, align 4
+  %a = getelementptr inbounds %class.DoFHandler, %class.DoFHandler* %dof, i32 0, i32 0
+  %arrayidx = getelementptr inbounds [5 x i32], [5 x i32]* %a, i32 0, i32 0
+  store i32 1, i32* %arrayidx, align 4
+  %call = call i32 @_Z3fooRKi(i32* dereferenceable(4) @_ZN10DoFHandlerILi5EE17invalid_dof_indexE)
+  %a1 = getelementptr inbounds %class.DoFHandler, %class.DoFHandler* %dof, i32 0, i32 0
+  %arrayidx2 = getelementptr inbounds [5 x i32], [5 x i32]* %a1, i32 0, i32 0
+  %0 = load i32, i32* %arrayidx2, align 4
+  %add = add nsw i32 %call, %0
+  %conv = sitofp i32 %add to float
+  ret float %conv
+}
+
+; COMMON:            .extern _ZN10DoFHandlerILi5EE17invalid_dof_indexE[UA] 
+; COMMON:            .tc _ZN10DoFHandlerILi5EE17invalid_dof_indexE[TC],_ZN10DoFHandlerILi5EE17invalid_dof_indexE[UA]
+
+; CHECKSYM:       Symbol {
+; CHECKSYM-NEXT:     Index: [[#Index:]]
+; CHECKSYM-NEXT:     Name: _ZN10DoFHandlerILi5EE17invalid_dof_indexE
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
+; CHECKSYM-NEXT:     Section: N_UNDEF
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_EXT (0x2)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+1]]
+; CHECKSYM-NEXT:       SectionLen: 0
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 0
+; CHECKSYM-NEXT:       SymbolType: XTY_ER (0x0)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_UA (0x4)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }
+
+; CHECKSYM:     Index: [[#Index:]]{{.*}}{{[[:space:]] *}}Name: _ZN10DoFHandlerILi5EE17invalid_dof_indexE
+; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x98
+; CHECKSYM-NEXT:     Section: .data
+; CHECKSYM-NEXT:     Type: 0x0
+; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
+; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
+; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
+; CHECKSYM-NEXT:       Index: [[#Index+1]]
+; CHECKSYM-NEXT:       SectionLen: 4
+; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
+; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 2
+; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
+; CHECKSYM-NEXT:       StorageMappingClass: XMC_TC (0x3)
+; CHECKSYM-NEXT:       StabInfoIndex: 0x0
+; CHECKSYM-NEXT:       StabSectNum: 0x0
+; CHECKSYM-NEXT:     }
+; CHECKSYM-NEXT:   }