[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

769

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 ↗

(On Diff #423410)

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 ↗

(On Diff #423410)

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/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

 DLL storage class:
 
 ``dllimport``
     "``dllimport``" causes the compiler to reference a function or variable via
     a global pointer to a pointer that is set up by the DLL exporting the
     symbol. On Microsoft Windows targets, the pointer name is formed by
     combining ``__imp_`` and the function or variable name.
 ``dllexport``
-    "``dllexport``" causes the compiler to provide a global pointer to a pointer
-    in a DLL, so that it can be referenced with the ``dllimport`` attribute. On
-    Microsoft Windows targets, the pointer name is formed by combining
-    ``__imp_`` and the function or variable name. Since this storage class
-    exists for defining a dll interface, the compiler, assembler and linker know
-    it is externally referenced and must refrain from deleting the symbol.
+    On Microsoft Windows targets, "``dllexport``" causes the compiler to provide
+    a global pointer to a pointer in a DLL, so that it can be referenced with the
+    ``dllimport`` attribute. the pointer name is formed by combining ``__imp_``
+    and the function or variable name. On XCOFF targets, ``dllexport`` indicates
+    that the symbol will be made visible to other modules using "exported"
+    visibility and thus placed by the linker in the loader section symbol table.
+    Since this storage class exists for defining a dll interface, the compiler,
+    assembler and linker know it is externally referenced and must refrain from
+    deleting the symbol.
 
 .. _tls_model:
 
 Thread Local Storage Models
 ---------------------------
 
 A variable may be defined as ``thread_local``, which means that it will
 not be shared by threads (each thread will have a separated copy of the

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/MC/MCAsmStreamer.cpp

bool MCAsmStreamer::emitSymbolAttribute(MCSymbol *Symbol,
   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.
+  case MCSA_Exported:
+    // Non-AIX assemblers currently do not support exported visibility.
     return false;
   }
 
   Symbol->print(OS, MAI);
   EmitEOL();
 
   return true;
 }
 
 void MCAsmStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
   OS << ".desc" << ' ';
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/MC/MCWasmStreamer.cpp

bool MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_Reference:
   case MCSA_SymbolResolver:
   case MCSA_PrivateExtern:
   case MCSA_WeakDefinition:
   case MCSA_WeakDefAutoPrivate:
   case MCSA_Invalid:
   case MCSA_IndirectSymbol:
   case MCSA_Protected:
+  case MCSA_Exported:
     return false;
 
   case MCSA_Hidden:
     Symbol->setHidden(true);
     break;
 
   case MCSA_Weak:
   case MCSA_WeakReference:

llvm/lib/MC/MCXCOFFStreamer.cpp

case llvm::MCSA_Weak:
     Symbol->setExternal(true);
     break;
   case llvm::MCSA_Hidden:
     Symbol->setVisibilityType(XCOFF::SYM_V_HIDDEN);
     break;
   case llvm::MCSA_Protected:
     Symbol->setVisibilityType(XCOFF::SYM_V_PROTECTED);
     break;
+  case llvm::MCSA_Exported:
+    Symbol->setVisibilityType(XCOFF::SYM_V_EXPORTED);
+    break;
   default:
     report_fatal_error("Not implemented yet.");
   }
   return true;
 }
 
 void MCXCOFFStreamer::emitXCOFFSymbolLinkageWithVisibility(
     MCSymbol *Symbol, MCSymbolAttr Linkage, MCSymbolAttr Visibility) {

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

   case GlobalValue::CommonLinkage:
     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()) {
+    if (GV->hasDLLExportStorageClass() && !GV->hasDefaultVisibility())
+      report_fatal_error(
+          "Cannot not be both dllexport and non-default visibility");
     switch (GV->getVisibility()) {
 
-    // TODO: "exported" and "internal" Visibility needs to go here.
+    // TODO: "internal" Visibility needs to go here.
     case GlobalValue::DefaultVisibility:
+      if (GV->hasDLLExportStorageClass())
+        VisibilityAttr = MAI->getExportedVisibilityAttr();
       break;
     case GlobalValue::HiddenVisibility:
       VisibilityAttr = MAI->getHiddenVisibilityAttr();
       break;
     case GlobalValue::ProtectedVisibility:
       VisibilityAttr = MAI->getProtectedVisibilityAttr();
       break;
     }

llvm/test/CodeGen/PowerPC/aix-xcoff-exported-nondefault.ll

+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff 2>&1 < %s | \
+; RUN:   FileCheck %s
+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff 2>&1 < %s |\
+; RUN:   FileCheck %s
+
+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
+; RUN:     -filetype=obj -o %t.o < %s 2>&1 | \
+; RUN:   FileCheck %s
+
+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
+; RUN:     -filetype=obj -o %t.o 2>&1 < %s 2>&1 | \
+; RUN:   FileCheck %s
+
+; CHECK: LLVM ERROR: Cannot not be both dllexport and non-default visibility
+@b_e = hidden dllexport global i32 0, align 4

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

 ; RUN:     -filetype=obj -o %t.o 2>&1 < %s 2>&1 | \
 ; RUN:   FileCheck --check-prefix=XCOFF64 %s
 ; FIXME: This should check for the visibility error, but we actually fail before
 ; that due to unimplemented relocations.
 ; XCOFF64: LLVM ERROR: Unimplemented fixup kind.
 
 @b =  global i32 0, align 4
 @b_h = hidden global i32 0, align 4
+@b_e = dllexport global i32 0, align 4
 
 define void @foo() {
 entry:
   ret void
 }
 
 define hidden void @foo_h(i32* %ip) {
 entry:
   ret void
 }
 
+define dllexport 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 dllexport 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 dllexport 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 dllexport 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