[AIX][XCOFF] Enable support for 64 bit symbol table writing

[MaryamBen]

Summary

Support 64 bit symbol table writing.
This patch is part of D103696 partition

[jhenderson]

Test case?

llvm/lib/MC/XCOFFObjectWriter.cpp

584

Please run clang-format.

603

[MaryamBen]

formatting the file

[MaryamBen]

In D104642#2832519, @jhenderson wrote:

Test case?

There is no way to run tests for 64-bit since the writeRelocation isn't implemented.

void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                        const ControlSection &CSection) {
  if (TargetObjectWriter->is64Bit())
    report_fatal_error("64-bit XCOFF object files are not supported yet.");

[jhenderson]

In D104642#2832572, @MaryamBen wrote:

In D104642#2832519, @jhenderson wrote:

Test case?

There is no way to run tests for 64-bit since the writeRelocation isn't implemented.

void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                        const ControlSection &CSection) {
  if (TargetObjectWriter->is64Bit())
    report_fatal_error("64-bit XCOFF object files are not supported yet.");

Surely you could have a test case without any relocations?

[Helflym]

Ok for the XCOFF part

llvm/lib/MC/XCOFFObjectWriter.cpp

class XCOFFObjectWriter : public MCObjectWriter {
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
                         const MCFixup &, MCValue, uint64_t &) override;
 
   uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
 
-  static bool nameShouldBeInStringTable(const StringRef &);
+  bool nameShouldBeInStringTable(const StringRef &);
   void writeSymbolName(const StringRef &);
   void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
                                                 const ControlSection &, int16_t,
                                                 uint64_t);
   void writeSymbolTableEntryForControlSection(const ControlSection &, int16_t,
                                               XCOFF::StorageClass);
   void writeFileHeader();
   void writeSectionHeaderTable();

 static MCSectionXCOFF *getContainingCsect(const MCSymbolXCOFF *XSym) {
   if (XSym->isDefined())
     return cast<MCSectionXCOFF>(XSym->getFragment()->getParent());
   return XSym->getRepresentedCsect();
 }
 
 void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                  const MCAsmLayout &Layout) {
+  // TODO: Add ".file" in the StringTableBuilder implicitly for XCOFF64.
   if (TargetObjectWriter->is64Bit())
-    report_fatal_error("64-bit XCOFF object files are not supported yet.");
+    Strings.add(".file");
 
   for (const auto &S : Asm) {
     const auto *MCSec = cast<const MCSectionXCOFF>(&S);
     assert(SectionMap.find(MCSec) == SectionMap.end() &&
            "Cannot add a csect twice.");
     assert(XCOFF::XTY_ER != MCSec->getCSectType() &&
            "An undefined csect should not get registered.");
 

 uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
                                         const MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
     report_fatal_error("Incremental linking not supported for XCOFF.");
 
-  if (TargetObjectWriter->is64Bit())
-    report_fatal_error("64-bit XCOFF object files are not supported yet.");
-
   finalizeSectionInfo();
   uint64_t StartOffset = W.OS.tell();
 
   writeFileHeader();
   writeSectionHeaderTable();
   writeSections(Asm, Layout);
   writeRelocations();
 
   writeSymbolTable(Layout);
   // Write the string table.
   Strings.write(W.OS);
 
   return W.OS.tell() - StartOffset;
 }
 
 bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
-  return SymbolName.size() > XCOFF::NameSize;
+  return SymbolName.size() > XCOFF::NameSize || TargetObjectWriter->is64Bit();
 }
 
 void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
+  if (TargetObjectWriter->is64Bit())
+     W.write<uint32_t>(Strings.getOffset(SymbolName));
+  else {
     if (nameShouldBeInStringTable(SymbolName)) {
       W.write<int32_t>(0);
       W.write<uint32_t>(Strings.getOffset(SymbolName));
     } else {
       char Name[XCOFF::NameSize+1];
       std::strncpy(Name, SymbolName.data(), XCOFF::NameSize);
       ArrayRef<char> NameRef(Name, XCOFF::NameSize);
       W.write(NameRef);
     }
   }
+}
 
 void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
     const Symbol &SymbolRef, const ControlSection &CSectionRef,
     int16_t SectionIndex, uint64_t SymbolOffset) {
-  // Name or Zeros and string table offset
+  if (TargetObjectWriter->is64Bit())
+    W.write<uint64_t>(CSectionRef.Address + SymbolOffset);
+  // Name or string table offset
   writeSymbolName(SymbolRef.getSymbolTableName());
+  if (!TargetObjectWriter->is64Bit()) {
     assert(SymbolOffset <= UINT32_MAX - CSectionRef.Address &&
            "Symbol address overflows.");
     W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
+  }
   W.write<int16_t>(SectionIndex);
   // 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?
   // TODO Set the function indicator (bit 10, 0x0020) for functions
   // when debugging is enabled.
   W.write<uint16_t>(0);
   W.write<uint8_t>(SymbolRef.getStorageClass());
   // Always 1 aux entry for now.
   W.write<uint8_t>(1);
 
   // Now output the auxiliary entry.
   W.write<uint32_t>(CSectionRef.SymbolTableIndex);
   // Parameter typecheck hash. Not supported.
   W.write<uint32_t>(0);
   // Typecheck section number. Not supported.
   W.write<uint16_t>(0);
   // Symbol type: Label
   W.write<uint8_t>(XCOFF::XTY_LD);
   // Storage mapping class.
   W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  if (TargetObjectWriter->is64Bit()) {
+    // High 4 bytes length.
+    W.write<uint32_t>((CSectionRef.SymbolTableIndex & 0xFFFFFFFF00000000) >>
+                      32);
+    // Reserved (pad).
+    W.write<uint8_t>(0);
+    // Auxiliary type entry.
+    W.write<uint8_t>(XCOFF::SymbolAuxType::AUX_CSECT);
+  } else {
     // Reserved (x_stab).
     W.write<uint32_t>(0);
     // Reserved (x_snstab).
     W.write<uint16_t>(0);
   }
+}
 
 void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
     const ControlSection &CSectionRef, int16_t SectionIndex,
     XCOFF::StorageClass StorageClass) {
+  if (TargetObjectWriter->is64Bit()) {
+    // n_value
+    W.write<uint64_t>(CSectionRef.Address);
+    // n_offset
+    writeSymbolName(CSectionRef.getSymbolTableName());
+  } else {
     // n_name, n_zeros, n_offset
     writeSymbolName(CSectionRef.getSymbolTableName());
     // n_value
     W.write<uint32_t>(CSectionRef.Address);
+  }
   // n_scnum
   W.write<int16_t>(SectionIndex);
   // 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?
   // TODO Set the function indicator (bit 10, 0x0020) for functions
void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
   // Parameter typecheck hash. Not supported.
   W.write<uint32_t>(0);
   // Typecheck section number. Not supported.
   W.write<uint16_t>(0);
   // Symbol type.
   W.write<uint8_t>(getEncodedType(CSectionRef.MCCsect));
   // Storage mapping class.
   W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  if (TargetObjectWriter->is64Bit()) {
+    // High 4 bytes length.
+    W.write<uint32_t>((CSectionRef.Size & 0xFFFFFFFF00000000) >> 32);
+    // Reserved (pad).
+    W.write<uint8_t>(0);
+    // Auxiliary type entry.
+    W.write<uint8_t>(XCOFF::SymbolAuxType::AUX_CSECT);
+  } else {
     // Reserved (x_stab).
     W.write<uint32_t>(0);
     // Reserved (x_snstab).
     W.write<uint16_t>(0);
   }
+}
 
 void XCOFFObjectWriter::writeFileHeader() {
   // Magic.
   if (TargetObjectWriter->is64Bit())
     W.write<uint16_t>(0x01f7);
   else
     W.write<uint16_t>(0x01df);
   // Number of sections.
if (TargetObjectWriter->is64Bit()) {
 
       W.write<int32_t>(Sec->Flags);
     }
   }
 }
 
 void XCOFFObjectWriter::writeRelocation(XCOFFRelocation Reloc,
                                         const ControlSection &CSection) {
+  if (TargetObjectWriter->is64Bit())
+    report_fatal_error("64-bit XCOFF object files are not supported yet.");
+
   W.write<uint32_t>(CSection.Address + Reloc.FixupOffsetInCsect);
   W.write<uint32_t>(Reloc.SymbolTableIndex);
   W.write<uint8_t>(Reloc.SignAndSize);
   W.write<uint8_t>(Reloc.Type);
 }
 
 void XCOFFObjectWriter::writeRelocations() {
   for (const auto *Section : Sections) {
void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
   // Write symbol 0 as C_FILE.
   // FIXME: support 64-bit C_FILE symbol.
   //
   // n_name. The n_name of a C_FILE symbol is the source filename when no
   // auxiliary entries are present. The source filename is alternatively
   // provided by an auxiliary entry, in which case the n_name of the C_FILE
   // symbol is `.file`.
   // FIXME: add the real source filename.
-  writeSymbolName(".file");
+  if (TargetObjectWriter->is64Bit()) {
     // n_value. The n_value of a C_FILE symbol is its symbol table index.
+    W.write<uint64_t>(0);
+    writeSymbolName(".file");
+  } else {
+    writeSymbolName(".file");
+    // n_value.
     W.write<uint32_t>(0);
+  }
   // n_scnum. N_DEBUG is a reserved section number for indicating a special
   // symbolic debugging symbol.
   W.write<int16_t>(XCOFF::ReservedSectionNum::N_DEBUG);
   // n_type. The n_type field of a C_FILE symbol encodes the source language and
   // CPU version info; zero indicates no info.
   W.write<uint16_t>(0);
   // n_sclass. The C_FILE symbol provides source file-name information,
   // source-language ID and CPU-version ID information and some other optional