[LLVM][AIX] Implement XCOFF exported visibility

[daltenty]

Summary

[LLVM] Add exported visibility style for XCOFF

For the AIX linker, under default options, global or weak symbols which
have no visibility bits set to zero (i.e. no visibility, similar to ELF
default) are only exported if specified on an export list provided to
the linker. So AIX has an additional visibility style called
"exported" which indicates to the linker that the symbol should
be explicitly globally exported.

This change maps "dllexport" in the LLVM IR to correspond to XCOFF
exported as we feel this best models the intended semantic (discussion
on the discourse RFC thread: https://discourse.llvm.org/t/rfc-adding-exported-visibility-style-to-the-ir-to-model-xcoff-exported-visibility/61853)
and allows us to enable writing this visibility for the AIX target
in the assembly path.

[DiggerLin]

we need to change the following functions to deal with MCSA_Exported

1. MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) too .
2. MCXCOFFStreamer::emitSymbolAttribute(MCSymbol *Sym, MCSymbolAttr Attribute)

llvm/lib/MC/MCAsmStreamer.cpp

767

change to
case MCSA_Cold:

// Assemblers currently do not support a .cold directive.

case MCSA_Exported:

 // Non-AIX assemblers currently do not support exported visibility.
return false;

?

[DiggerLin]

llvm/lib/IR/AsmWriter.cpp

3155

if I understand correct. this is for IR generate, if add it now, I do not think we can have a test case for it now ? It maybe better to add when implement the frontend.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1905

maybe better to change to
// TODO: "internal" Visibility needs to go here.
case GlobalValue::ExportedVisibility:

VisibilityAttr = MAI->getExportedVisibilityAttr();
break;

[daltenty]

llvm/lib/IR/AsmWriter.cpp

3155

Thanks for catching that, I've added a seperate unit test since none seems to exist currently.

[daltenty]

Address review comments

[DiggerLin]

we need to change the following functions to deal with MCSA_Exported

MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) too .
MCXCOFFStreamer::emitSymbolAttribute(MCSymbol *Sym, MCSymbolAttr Attribute)

It looks this two comments not be addressed.

[daltenty]

Update the patch based on feedback on the RFC (https://discourse.llvm.org/t/rfc-adding-exported-visibility-style-to-the-ir-to-model-xcoff-exported-visibility/61853/8). There seem to be limited visibility bits, and the implementation has kind of reserved space for internal, so adding exported may cause problems. On the other hand dllexport appears to match the semantic and currently only be used as a marker to indicate to some passes that we should preserve the symbol since it will be exported from shared objects (which is exactly what we want too), so I've updated the implementation as suggested to use dllexport instead.

[daltenty]

Make MCWasmStreamer ignore MCSA_Exported

[DiggerLin]

LGTM.

[daltenty]

Make assert for mixed non-export visibility and dllexport a fatal error

llvm/docs/BitCodeFormat.rst

 
 .. _visibility:
 
 * *visibility*: If present, an encoding of the visibility of this variable:
 
   * ``default``: code 0
   * ``hidden``: code 1
   * ``protected``: code 2
+  * ``exported``: code 3
 
 .. _bcthreadlocal:
 
 * *threadlocal*: If present, an encoding of the thread local storage mode of the
   variable:
 
   * ``not thread local``: code 0
   * ``thread local; default TLS model``: code 1

llvm/docs/LangRef.rst

 All Global Variables and Functions have one of the following visibility
 styles:
 
 "``default``" - Default style
     On targets that use the ELF object file format, default visibility
     means that the declaration is visible to other modules and, in
     shared libraries, means that the declared entity may be overridden.
     On Darwin, default visibility means that the declaration is visible
-    to other modules. Default visibility corresponds to "external
+    to other modules. On XCOFF, default visibility means no explicit
+    visibility bit will be set and whether the symbol is visible
+    (i.e "exported") to other modules depends primarily on export lists
+    provided to the linker. Default visibility corresponds to "external
     linkage" in the language.
 "``hidden``" - Hidden style
     Two declarations of an object with hidden visibility refer to the
     same object if they are in the same shared object. Usually, hidden
     visibility indicates that the symbol will not be placed into the
     dynamic symbol table, so no other module (executable or shared
     library) can reference it directly.
 "``protected``" - Protected style
     On ELF, protected visibility indicates that the symbol will be
     placed in the dynamic symbol table, but that references within the
     defining module will bind to the local symbol. That is, the symbol
     cannot be overridden by another module.
+"``exported``" - Exported style
+    On XCOFF, exported visibility indicates that the symbol will be
+    made visible to other modules (i.e. "exported") by the linker and
+    thus placed in the loader section symbol table.
 
 A symbol with ``internal`` or ``private`` linkage must have ``default``
 visibility.
 
 .. _dllstorageclass:
 
 DLL Storage Classes
 -------------------

llvm/include/llvm/AsmParser/LLToken.h

enum Kind {
   kw_appending,
   kw_dllimport,
   kw_dllexport,
   kw_common,
   kw_available_externally,
   kw_default,
   kw_hidden,
   kw_protected,
+  kw_exported,
   kw_unnamed_addr,
   kw_local_unnamed_addr,
   kw_externally_initialized,
   kw_extern_weak,
   kw_external,
   kw_thread_local,
   kw_localdynamic,
   kw_initialexec,

llvm/include/llvm/IR/GlobalValue.h

enum LinkageTypes {
     ExternalWeakLinkage,///< ExternalWeak linkage description.
     CommonLinkage       ///< Tentative definitions.
   };
 
   /// An enumeration for the kinds of visibility of global values.
   enum VisibilityTypes {
     DefaultVisibility = 0,  ///< The GV is visible
     HiddenVisibility,       ///< The GV is hidden
-    ProtectedVisibility     ///< The GV is protected
+    ProtectedVisibility,    ///< The GV is protected
+    ExportedVisibility      ///< The GV is exported
   };
 
   /// Storage classes of global values for PE targets.
   enum DLLStorageClassTypes {
     DefaultStorageClass   = 0,
     DLLImportStorageClass = 1, ///< Function to be imported from DLL
     DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
   };
public:
   }
 
   VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
   bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
   bool hasProtectedVisibility() const {
     return Visibility == ProtectedVisibility;
   }
+  bool hasExportedVisibility() const {
+    return Visibility == ExportedVisibility;
+  }
   void setVisibility(VisibilityTypes V) {
     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
            "local linkage requires default visibility");
     Visibility = V;
     if (isImplicitDSOLocal())
       setDSOLocal(true);
   }
 

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// weak*/linkonce*, if the symbol has a comdat.
   /// Defaults to false.
   bool AvoidWeakIfComdat = false;
 
   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
   /// hidden visibility.  Defaults to MCSA_Hidden.
   MCSymbolAttr HiddenVisibilityAttr = MCSA_Hidden;
 
+  /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
+  /// exported visibility.  Defaults to MCSA_Exported.
+  MCSymbolAttr ExportedVisibilityAttr = MCSA_Exported;
+
   /// This attribute, if not MCSA_Invalid, is used to declare an undefined
   /// symbol as having hidden visibility. Defaults to MCSA_Hidden.
   MCSymbolAttr HiddenDeclarationVisibilityAttr = MCSA_Hidden;
 
   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
   /// protected visibility.  Defaults to MCSA_Protected
   MCSymbolAttr ProtectedVisibilityAttr = MCSA_Protected;
 
public:
   bool hasWeakDefCanBeHiddenDirective() const {
     return HasWeakDefCanBeHiddenDirective;
   }
 
   bool avoidWeakIfComdat() const { return AvoidWeakIfComdat; }
 
   MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; }
 
+  MCSymbolAttr getExportedVisibilityAttr() const { return ExportedVisibilityAttr; }
+
   MCSymbolAttr getHiddenDeclarationVisibilityAttr() const {
     return HiddenDeclarationVisibilityAttr;
   }
 
   MCSymbolAttr getProtectedVisibilityAttr() const {
     return ProtectedVisibilityAttr;
   }
 

llvm/include/llvm/MC/MCDirectives.h

enum MCSymbolAttr {
   MCSA_ELF_TypeTLS,             ///< .type _foo, STT_TLS     # aka @tls_object
   MCSA_ELF_TypeCommon,          ///< .type _foo, STT_COMMON  # aka @common
   MCSA_ELF_TypeNoType,          ///< .type _foo, STT_NOTYPE  # aka @notype
   MCSA_ELF_TypeGnuUniqueObject, /// .type _foo, @gnu_unique_object
   MCSA_Global,                  ///< .globl
   MCSA_LGlobal,                 ///< .lglobl (XCOFF)
   MCSA_Extern,                  ///< .extern (XCOFF)
   MCSA_Hidden,                  ///< .hidden (ELF)
+  MCSA_Exported,                ///< .globl _foo, exported (XCOFF)
   MCSA_IndirectSymbol,          ///< .indirect_symbol (MachO)
   MCSA_Internal,                ///< .internal (ELF)
   MCSA_LazyReference,           ///< .lazy_reference (MachO)
   MCSA_Local,                   ///< .local (ELF)
   MCSA_NoDeadStrip,             ///< .no_dead_strip (MachO)
   MCSA_SymbolResolver,          ///< .symbol_resolver (MachO)
   MCSA_AltEntry,                ///< .alt_entry (MachO)
   MCSA_PrivateExtern,           ///< .private_extern (MachO)

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(weak_odr);
   KEYWORD(appending);
   KEYWORD(dllimport);
   KEYWORD(dllexport);
   KEYWORD(common);
   KEYWORD(default);
   KEYWORD(hidden);
   KEYWORD(protected);
+  KEYWORD(exported);
   KEYWORD(unnamed_addr);
   KEYWORD(local_unnamed_addr);
   KEYWORD(externally_initialized);
   KEYWORD(extern_weak);
   KEYWORD(external);
   KEYWORD(thread_local);
   KEYWORD(localdynamic);
   KEYWORD(initialexec);

llvm/lib/AsmParser/LLParser.cpp

     Res = GlobalValue::DefaultVisibility;
     break;
   case lltok::kw_hidden:
     Res = GlobalValue::HiddenVisibility;
     break;
   case lltok::kw_protected:
     Res = GlobalValue::ProtectedVisibility;
     break;
+  case lltok::kw_exported:
+    Res = GlobalValue::ExportedVisibility;
+    break;
   }
   Lex.Lex();
 }
 
 /// parseOptionalDLLStorageClass
 ///   ::= /*empty*/
 ///   ::= 'dllimport'
 ///   ::= 'dllexport'

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

   return RawFlags;
 }
 
 static unsigned getEncodedVisibility(const GlobalValue &GV) {
   switch (GV.getVisibility()) {
   case GlobalValue::DefaultVisibility:   return 0;
   case GlobalValue::HiddenVisibility:    return 1;
   case GlobalValue::ProtectedVisibility: return 2;
+  case GlobalValue::ExportedVisibility:  return 3;
   }
   llvm_unreachable("Invalid visibility");
 }
 
 static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {
   switch (GV.getDLLStorageClass()) {
   case GlobalValue::DefaultStorageClass:   return 0;
   case GlobalValue::DLLImportStorageClass: return 1;

llvm/lib/IR/AsmWriter.cpp

 static const char *getVisibilityName(GlobalValue::VisibilityTypes Vis) {
   switch (Vis) {
   case GlobalValue::DefaultVisibility:
     return "default";
   case GlobalValue::HiddenVisibility:
     return "hidden";
   case GlobalValue::ProtectedVisibility:
     return "protected";
+  case GlobalValue::ExportedVisibility:
+    return "exported";
   }
   llvm_unreachable("invalid visibility");
 }
 
 void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
   Out << ", insts: " << FS->instCount();
   if (FS->fflags().anyFlagSet())
     Out << ", " << FS->fflags();

 }
 
 static void PrintVisibility(GlobalValue::VisibilityTypes Vis,
                             formatted_raw_ostream &Out) {
   switch (Vis) {
   case GlobalValue::DefaultVisibility: break;
   case GlobalValue::HiddenVisibility:    Out << "hidden "; break;
   case GlobalValue::ProtectedVisibility: Out << "protected "; break;
+  case GlobalValue::ExportedVisibility:  Out << "exported "; break;
   }
 }
 
 static void PrintDSOLocation(const GlobalValue &GV,
                              formatted_raw_ostream &Out) {
   if (GV.isDSOLocal() && !GV.isImplicitDSOLocal())
     Out << "dso_local ";
 }

llvm/lib/MC/MCAsmStreamer.cpp

case MCSA_WeakDefinition:
     OS << "\t.weak_definition\t";
     break;
       // .weak_reference
   case MCSA_WeakReference:  OS << MAI->getWeakRefDirective(); break;
   case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break;
   case MCSA_Cold:
     // Assemblers currently do not support a .cold directive.
     return false;
+  case MCSA_Exported:
+    // Non-AIX assemblers currently do not support exported visibility.
+    return false;
   }
 
   Symbol->print(OS, MAI);
   EmitEOL();
 
   return true;
 }
 
case MCSA_Invalid:
     // Nothing to do.
     break;
   case MCSA_Hidden:
     OS << ",hidden";
     break;
   case MCSA_Protected:
     OS << ",protected";
     break;
+  case MCSA_Exported:
+    OS << ",exported";
+    break;
   default:
     report_fatal_error("unexpected value for Visibility type");
   }
   EmitEOL();
 
   // Print symbol's rename (original name contains invalid character(s)) if
   // there is one.
   if (cast<MCSymbolXCOFF>(Symbol)->hasRename())

llvm/lib/MC/MCELFStreamer.cpp

bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_LazyReference:
   case MCSA_Reference:
   case MCSA_SymbolResolver:
   case MCSA_PrivateExtern:
   case MCSA_WeakDefinition:
   case MCSA_WeakDefAutoPrivate:
   case MCSA_Invalid:
   case MCSA_IndirectSymbol:
+  case MCSA_Exported:
     return false;
 
   case MCSA_NoDeadStrip:
     // Ignore for now.
     break;
 
   case MCSA_ELF_TypeGnuUniqueObject:
     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT));

llvm/lib/MC/MCMachOStreamer.cpp

bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
   case MCSA_Extern:
   case MCSA_Hidden:
   case MCSA_IndirectSymbol:
   case MCSA_Internal:
   case MCSA_Protected:
   case MCSA_Weak:
   case MCSA_Local:
   case MCSA_LGlobal:
+  case MCSA_Exported:
     return false;
 
   case MCSA_Global:
     Symbol->setExternal(true);
     // This effectively clears the undefined lazy bit, in Darwin 'as', although
     // it isn't very consistent because it implements this as part of symbol
     // lookup.
     //

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

     llvm_unreachable("CommonLinkage of XCOFF should not come to this path");
   }
 
   assert(LinkageAttr != MCSA_Invalid && "LinkageAttr should not MCSA_Invalid.");
 
   MCSymbolAttr VisibilityAttr = MCSA_Invalid;
   if (!TM.getIgnoreXCOFFVisibility()) {
     switch (GV->getVisibility()) {
-
-    // TODO: "exported" and "internal" Visibility needs to go here.
+    case GlobalValue::ExportedVisibility:
+      VisibilityAttr = MAI->getExportedVisibilityAttr();
+      break;
+    // TODO: "internal" Visibility needs to go here.
     case GlobalValue::DefaultVisibility:
       break;
     case GlobalValue::HiddenVisibility:
       VisibilityAttr = MAI->getHiddenVisibilityAttr();
       break;
     case GlobalValue::ProtectedVisibility:
       VisibilityAttr = MAI->getProtectedVisibilityAttr();
       break;

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

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec -data-sections=false < %s | \
 ; RUN:   FileCheck %s
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 -mattr=-altivec -data-sections=false < %s |\
 ; RUN:   FileCheck %s
 
 @b =  global i32 0, align 4
 @b_h = hidden global i32 0, align 4
+@b_e = exported global i32 0, align 4
 
 define void @foo() {
 entry:
   ret void
 }
 
 define hidden void @foo_h(i32* %ip) {
 entry:
   ret void
 }
 
+define exported void @foo_e(i32* %ip) {
+entry:
+  ret void
+}
+
 define protected void @foo_protected(i32* %ip) {
 entry:
   ret void
 }
 
 define weak hidden void @foo_weak_h() {
 entry:
   ret void
 }
 
+define weak exported void @foo_weak_e() {
+entry:
+  ret void
+}
+
 @foo_p = global void ()* @zoo_weak_extern_h, align 4
 declare extern_weak hidden void @zoo_weak_extern_h()
+declare extern_weak exported void @zoo_weak_extern_e()
 
 define i32 @main() {
 entry:
   %call1= call i32 @bar_h(i32* @b_h)
   call void @foo_weak_h()
   %0 = load void ()*, void ()** @foo_p, align 4
   call void %0()
   ret i32 0
 }
 
 declare hidden i32 @bar_h(i32*)
+declare exported i32 @bar_e(i32*)
 
 ; CHECK:        .globl  foo[DS]{{[[:space:]]*([#].*)?$}}
 ; CHECK:        .globl  .foo{{[[:space:]]*([#].*)?$}}
 ; CHECK:        .globl  foo_h[DS],hidden
 ; CHECK:        .globl  .foo_h,hidden
+; CHECK:        .globl  foo_e[DS],exported
+; CHECK:        .globl  .foo_e,exported
 ; CHECK:        .globl  foo_protected[DS],protected
 ; CHECK:        .globl  .foo_protected,protected
 ; CHECK:        .weak   foo_weak_h[DS],hidden
 ; CHECK:        .weak   .foo_weak_h,hidden
+; CHECK:        .weak   foo_weak_e[DS],exported
+; CHECK:        .weak   .foo_weak_e,exported
 
 ; CHECK:        .globl  b{{[[:space:]]*([#].*)?$}}
 ; CHECK:        .globl  b_h,hidden
+; CHECK:        .globl  b_e,exported
 
 ; CHECK:        .weak   .zoo_weak_extern_h[PR],hidden
 ; CHECK:        .weak   zoo_weak_extern_h[DS],hidden
+; CHECK:        .weak   .zoo_weak_extern_e[PR],exported
+; CHECK:        .weak   zoo_weak_extern_e[DS],exported
 ; CHECK:        .extern .bar_h[PR],hidden
 ; CHECK:        .extern bar_h[DS],hidden
+; CHECK:        .extern .bar_e[PR],exported
+; CHECK:        .extern bar_e[DS],exported

llvm/test/LTO/Resolution/X86/symtab.ll

 ; CHECK-NEXT: comdat any @fun2@8
 $fun2 = comdat any
 define x86_fastcallcc i32 @fun2(i32 inreg %a, i32 inreg %b) comdat {
 entry:
   %add = add nsw i32 %b, %a
   ret i32 %add
 }
 
+; CHECK: E------- _g0
+@g0 = exported global i32 0
+
 ; CHECK: H------- _g1
 @g1 = hidden global i32 0
 
 ; CHECK: P------- _g2
 @g2 = protected global i32 0
 
 ; CHECK: D------- _g3
 @g3 = global i32 0

llvm/tools/llvm-lto2/llvm-lto2.cpp

for (const InputFile::Symbol &Sym : Input->symbols()) {
         outs() << 'H';
         break;
       case GlobalValue::ProtectedVisibility:
         outs() << 'P';
         break;
       case GlobalValue::DefaultVisibility:
         outs() << 'D';
         break;
+      case GlobalValue::ExportedVisibility:
+        outs() << 'E';
+        break;
       }
 
       auto PrintBool = [&](char C, bool B) { outs() << (B ? C : '-'); };
       PrintBool('U', Sym.isUndefined());
       PrintBool('C', Sym.isCommon());
       PrintBool('W', Sym.isWeak());
       PrintBool('I', Sym.isIndirect());
       PrintBool('O', Sym.canBeOmittedFromSymbolTable());