[AIX][XCOFF] error on emit symbol visibility for XCOFF object file

[daltenty]

Summary

This is a follow on to the revert of D84265 to add an error if we'd need to write a non-zero visibility type in the XCOFF object file. We can't currently do that because we lack the auxiliary header to interpret the bits in XCOFF32. This is important because we are currently working on visibility in the assembly writing path, and without this error the visibility could be silently ignored.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

681

minor. I am not sure whether it is better to "Emitting non-zero visibility are not supported yet" or not.

llvm/include/llvm/MC/MCSectionXCOFF.h

public:
 
   XCOFF::StorageMappingClass getMappingClass() const {
     assert(isCsect() && "Only csect section has mapping class property!");
     return CsectProp->MappingClass;
   }
   XCOFF::StorageClass getStorageClass() const {
     return QualName->getStorageClass();
   }
+  XCOFF::VisibilityType getVisibilityType() const {
+    return QualName->getVisibilityType();
+  }
   XCOFF::SymbolType getCSectType() const {
     assert(isCsect() && "Only csect section has symbol type property!");
     return CsectProp->Type;
   }
   MCSymbolXCOFF *getQualNameSymbol() const { return QualName; }
 
   void printSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,

llvm/lib/MC/XCOFFObjectWriter.cpp

struct XCOFFRelocation {
   uint8_t Type;
 };
 
 // Wrapper around an MCSymbolXCOFF.
 struct Symbol {
   const MCSymbolXCOFF *const MCSym;
   uint32_t SymbolTableIndex;
 
+  XCOFF::VisibilityType getVisibilityType() const {
+    return MCSym->getVisibilityType();
+  }
+
   XCOFF::StorageClass getStorageClass() const {
     return MCSym->getStorageClass();
   }
   StringRef getSymbolTableName() const { return MCSym->getSymbolTableName(); }
   Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
 };
 
 // Wrapper for an MCSectionXCOFF.
 // It can be a Csect or debug section or DWARF section and so on.
 struct XCOFFSection {
   const MCSectionXCOFF *const MCSec;
   uint32_t SymbolTableIndex;
   uint64_t Address;
   uint64_t Size;
 
   SmallVector<Symbol, 1> Syms;
   SmallVector<XCOFFRelocation, 1> Relocations;
   StringRef getSymbolTableName() const { return MCSec->getSymbolTableName(); }
+  XCOFF::VisibilityType getVisibilityType() const {
+    return MCSec->getVisibilityType();
+  }
   XCOFFSection(const MCSectionXCOFF *MCSec)
       : MCSec(MCSec), SymbolTableIndex(-1), Address(-1), Size(0) {}
 };
 
 // Type to be used for a container representing a set of csects with
 // (approximately) the same storage mapping class. For example all the csects
 // with a storage mapping class of `xmc_pr` will get placed into the same
 // container.
void XCOFFObjectWriter::writeSymbolEntry(StringRef SymbolName, uint32_t Value,
                                          uint8_t NumberOfAuxEntries) {
   writeSymbolName(SymbolName);
   W.write<uint32_t>(Value);
   W.write<int16_t>(SectionNumber);
   // Basic/Derived type. See the description of the n_type field for symbol
   // table entries for a detailed description. Since we don't yet support
   // visibility, and all other bits are either optionally set or reserved, this
   // is always zero.
-  // TODO FIXME How to assert a symbol's visibilty is default?
+  if (SymbolType != 0)
+    report_fatal_error("Emitting non-zero visibilities is not supported yet.");
   // TODO Set the function indicator (bit 10, 0x0020) for functions
   // when debugging is enabled.
   W.write<uint16_t>(SymbolType);
   W.write<uint8_t>(StorageClass);
   W.write<uint8_t>(NumberOfAuxEntries);
 }
 
 void XCOFFObjectWriter::writeSymbolAuxCsectEntry(uint32_t SectionOrLength,

 void XCOFFObjectWriter::writeSymbolEntryForCsectMemberLabel(
     const Symbol &SymbolRef, const XCOFFSection &CSectionRef,
     int16_t SectionIndex, uint64_t SymbolOffset) {
   assert(SymbolOffset <= MaxRawDataSize - CSectionRef.Address &&
          "Symbol address overflowed.");
 
   writeSymbolEntry(SymbolRef.getSymbolTableName(),
                    CSectionRef.Address + SymbolOffset, SectionIndex,
-                   /*SymbolType=*/0, SymbolRef.getStorageClass());
+                   SymbolRef.getVisibilityType(), SymbolRef.getStorageClass());
 
   writeSymbolAuxCsectEntry(CSectionRef.SymbolTableIndex, XCOFF::XTY_LD,
                            CSectionRef.MCSec->getMappingClass());
 }
 
 void XCOFFObjectWriter::writeSymbolEntryForDwarfSection(
     const XCOFFSection &DwarfSectionRef, int16_t SectionIndex) {
   assert(DwarfSectionRef.MCSec->isDwarfSect() && "Not a DWARF section!");
 
   writeSymbolEntry(DwarfSectionRef.getSymbolTableName(), /*Value=*/0,
                    SectionIndex, /*SymbolType=*/0, XCOFF::C_DWARF);
 
   writeSymbolAuxDwarfEntry(DwarfSectionRef.Size);
 }
 
 void XCOFFObjectWriter::writeSymbolEntryForControlSection(
     const XCOFFSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
   writeSymbolEntry(CSectionRef.getSymbolTableName(), CSectionRef.Address,
-                   SectionIndex, /*SymbolType=*/0, StorageClass);
+                   SectionIndex, CSectionRef.getVisibilityType(), StorageClass);
 
   writeSymbolAuxCsectEntry(CSectionRef.Size, getEncodedType(CSectionRef.MCSec),
                            CSectionRef.MCSec->getMappingClass());
 }
 
 void XCOFFObjectWriter::writeFileHeader() {
   W.write<uint16_t>(is64Bit() ? XCOFF::XCOFF64 : XCOFF::XCOFF32);
   W.write<uint16_t>(SectionCount);

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
 
+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff \
+; RUN:     -filetype=obj -o %t.o < %s 2>&1 | \
+; RUN:   FileCheck --check-prefix=XCOFF32 %s
+; XCOFF32: LLVM ERROR: Emitting non-zero visibilities is not supported yet.
+
+; RUN: not --crash llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff \
+; 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
 
 define void @foo() {
 entry:
   ret void
 }