[Autobackout][FuncReg]Revert of change: c471836

 ZEBIN ELF spec update.

Clean up the e_type, e_machine and e_flags fields in ELF header, and put
the product family, the gfxcore family, and the target metadata into ELF
notes.

Author: petechou

IGC/AdaptorOCL/OCL/sp/zebin_builder.cpp

@@ -27,25 +27,31 @@ ZEBinaryBuilder::ZEBinaryBuilder(
 {
     G6HWC::InitializeCapsGen8(&mHWCaps);
 
-    mBuilder.setProductFamily(plat.eProductFamily);
+    // IGC only generates executable
+    mBuilder.setFileType(ELF_TYPE_ZEBIN::ET_ZEBIN_EXE);
+
+    mBuilder.setMachine(plat.eProductFamily);
 
     // FIXME: Most fields leaves as 0
-    TargetMetadata metadata;
-    metadata.generatorSpecificFlags = TargetMetadata::GeneratorSpecificFlags::NONE;
-    metadata.minHwRevisionId = plat.usRevId;
-    metadata.maxHwRevisionId = plat.usRevId;
-    metadata.generatorId = TargetMetadata::GeneratorId::IGC;
-    mBuilder.setTargetMetadata(metadata);
+    TargetFlags tf;
+    tf.generatorSpecificFlags = TargetFlags::GeneratorSpecificFlags::NONE;
+    tf.minHwRevisionId = plat.usRevId;
+    tf.maxHwRevisionId = plat.usRevId;
+    tf.generatorId = TargetFlags::GeneratorId::IGC;
+    mBuilder.setTargetFlag(tf);
 
     addProgramScopeInfo(programInfo);
 
     if (spvData != nullptr)
         addSPIRV(spvData, spvSize);
 }
 
-void ZEBinaryBuilder::setGfxCoreFamily(uint32_t value)
+void ZEBinaryBuilder::setGfxCoreFamilyToELFMachine(uint32_t value)
 {
-    mBuilder.setGfxCoreFamily(value);
+    TargetFlags tf = mBuilder.getTargetFlag();
+    tf.machineEntryUsesGfxCoreInsteadOfProductFamily = true;
+    mBuilder.setTargetFlag(tf);
+    mBuilder.setMachine(value);
 }
 
 void ZEBinaryBuilder::createKernel(

IGC/AdaptorOCL/OCL/sp/zebin_builder.hpp

@@ -40,10 +40,13 @@ class ZEBinaryBuilder : DisallowCopy
     ZEBinaryBuilder(const PLATFORM plat, bool is64BitPointer,
         const IGC::SOpenCLProgramInfo& programInfo, const uint8_t* spvData, uint32_t spvSize);
 
-    // Set the given GfxCoreFamily as the specified value.
-    void setGfxCoreFamily(uint32_t value);
+    // Set the given GfxCoreFamily value to elfFileHeader::e_machine. Also set the flag
+    // TargetFlags::machineEntryUsesGfxCoreInsteadOfProductFamily.
+    // The default value of e_machine is ProductFamily. This API will set e_machine to
+    // given value which is supposed to be GfxCoreFamily.
+    void setGfxCoreFamilyToELFMachine(uint32_t value);
 
-    /// add kernel information. Also create kernel metadata information for .ze_info
+    /// add kernel information. Also create kernel metadata inforamtion for .ze_info
     /// This function can be called several times for adding different kernel information
     /// into this ZEObject
     /// The given rawIsaBinary must be lived through the entire ZEBinaryBuilder life

IGC/VectorCompiler/igcdeps/src/PatchTokens.cpp

@@ -180,7 +180,7 @@ void CGen8CMProgram::GetZEBinary(llvm::raw_pwrite_stream &programBinary,
   llvm::raw_string_ostream ErrLog{m_ErrorLog};
   iOpenCL::ZEBinaryBuilder zebuilder{m_Platform, pointerSizeInBytes == 8,
                                      *m_programInfo, nullptr, 0};
-  zebuilder.setGfxCoreFamily(m_Platform.eRenderCoreFamily);
+  zebuilder.setGfxCoreFamilyToELFMachine(m_Platform.eRenderCoreFamily);
 
   for (const auto &kernel : m_kernels) {
     zebuilder.createKernel(

IGC/ZEBinWriter/zebin/source/ZEELF.h

@@ -20,9 +20,14 @@ SPDX-License-Identifier: MIT
 
 namespace zebin {
 
-// ELF machine architecture
-enum {
-    EM_INTELGT = 205,
+// ELF file type for ELF32_Ehdr::e_type
+enum ELF_TYPE_ZEBIN
+{
+    ET_ZEBIN_NONE = 0x0,
+
+    ET_ZEBIN_REL  = 0xff11,     // A relocatable ZE binary file
+    ET_ZEBIN_EXE  = 0xff12,     // An executable ZE binary file
+    ET_ZEBIN_DYN  = 0xff13,     // A shared object ZE binary file
 };
 
 // ELF section type for ELF32_Shdr::sh_type
@@ -44,14 +49,9 @@ enum R_TYPE_ZEBIN
     R_ZE_SYM_ADDR_32_HI = 3  // higher 32bits of 64-bit address
 };
 
-// ELF note type for INTELGT
-enum {
-    NT_INTELGT_PRODUCT_FAMILY = 1,
-    NT_INTELGT_GFXCORE_FAMILY = 2,
-    NT_INTELGT_TARGET_METADATA = 3,
-};
+// ELF32_Ehdr::e_flags
+struct TargetFlags {
 
-struct TargetMetadata {
     // bit[7:0]: dedicated for specific generator (meaning based on generatorId)
     enum GeneratorSpecificFlags : uint8_t {
         NONE = 0
@@ -76,8 +76,10 @@ struct TargetMetadata {
             // 0 - ignore minHwRevisionId and maxHwRevisionId
             // 1 - underlying device must match specified revisionId info
             bool disableExtendedValidation : 1;
-            // bit[15:15]: reserved bit for future use
-            bool reservedBit : 1;
+            // bit[15:15]:
+            // 0 - elfFileHeader::machine is PRODUCT_FAMILY
+            // 1 - elfFileHeader::machine is GFXCORE_FAMILY
+            bool machineEntryUsesGfxCoreInsteadOfProductFamily : 1;
             // bit[20:16]:  max compatible device revision Id (stepping)
             uint8_t maxHwRevisionId : 5;
             // bit[23:21]: generator of this device binary. Value defined in above GeneratorId
@@ -89,8 +91,6 @@ struct TargetMetadata {
     };
 };
 
-static_assert(sizeof(TargetMetadata) == sizeof(uint32_t), "TargetMetadata should be packed");
-
 } // namespace zebin
 
 #endif // ZE_ELF_H

IGC/ZEBinWriter/zebin/source/ZEELFObjectBuilder.cpp

@@ -16,15 +16,13 @@ SPDX-License-Identifier: MIT
 
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/EndianStream.h"
-#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 #ifndef ZEBinStandAloneBuild
 #include "common/LLVMWarningsPop.hpp"
 #endif
 
 #include <iostream>
-#include <tuple>
 #include "Probe/Assertion.h"
 
 namespace zebin {
@@ -78,19 +76,15 @@ class ELFWriter {
     uint64_t writeRelocTab(const RelocationListTy& relocs, bool isRelFormat);
     // write ze info section
     uint64_t writeZEInfo();
-    // write .note.intelgt.compat section
-    std::pair<uint64_t, uint64_t> writeCompatibilityNote();
     // write string table
     uint64_t writeStrTab();
     // write section header
     void writeSectionHeader();
     // write the section header's offset into ELF header
     void writeSectionHdrOffset(uint64_t offset);
-    // write number of zero bytes
+    // wirite number of zero bytes
     void writePadding(uint32_t size);
 
-    // The name writeWord seems confusing. Both ELF32 and ELF64 words are
-    // uint32_t.
     void writeWord(uint64_t Word) {
         if (is64Bit())
             m_W.write<uint64_t>(Word);
@@ -153,7 +147,7 @@ ZEELFObjectBuilder::addStandardSection(
 {
     IGC_ASSERT(type != ELF::SHT_NULL);
     // calculate the required padding to satisfy alignment requirement
-    // The original data size is (size + padding)
+    // The origanl data size is (size + padding)
     uint32_t need_padding_for_align = (align == 0) ?
         0 : align - ((size + padding) % align);
     if (need_padding_for_align == align)
@@ -543,50 +537,6 @@ uint64_t ELFWriter::writeZEInfo()
     return m_W.OS.tell() - start_off;
 }
 
-std::pair<uint64_t, uint64_t> ELFWriter::writeCompatibilityNote() {
-    auto padToRequiredAlign = [&]() {
-        // The alignment of the Elf word, name and descriptor is 4.
-        // Implementations differ from the specification here: in practice all
-        // variants align both the name and descriptor to 4-bytes.
-        uint64_t cur = m_W.OS.tell();
-        uint64_t next = llvm::alignTo(cur, 4);
-        writePadding(next - cur);
-    };
-
-    auto writeOneNote = [&](StringRef owner, auto desc, uint32_t type) {
-        // It's easier to use uint32_t directly now because both Elf32_Word and
-        // Elf64_Word are uint32_t.
-        // TODO: Use template implementation to handle ELF32 and ELF64 cases.
-        m_W.write<uint32_t>(owner.size() + 1);
-        m_W.write<uint32_t>(sizeof(desc));
-        m_W.write<uint32_t>(type);
-        m_W.OS << owner << '\0';
-        padToRequiredAlign();
-        m_W.write(desc);
-        padToRequiredAlign();
-    };
-
-    // Align the section offset to the required alignment first.
-    // TODO: Handle the section alignment in a more generic place..
-    padToRequiredAlign();
-    uint64_t start_off = m_W.OS.tell();
-    // write NT_INTELGT_PRODUCT_FAMILY
-    writeOneNote("IntelGT",
-                 m_ObjBuilder.m_productFamily,
-                 NT_INTELGT_PRODUCT_FAMILY);
-
-    // write NT_INTELGT_GFXCORE_FAMILY_
-    writeOneNote("IntelGT",
-                 m_ObjBuilder.m_gfxCoreFamily,
-                 NT_INTELGT_GFXCORE_FAMILY);
-
-    // write NT_INTELGT_TARGET_METADATA
-    writeOneNote("IntelGT",
-                 m_ObjBuilder.m_metadata.packed,
-                 NT_INTELGT_TARGET_METADATA);
-    return std::make_pair(start_off, m_W.OS.tell() - start_off);
-}
-
 uint64_t ELFWriter::writeStrTab()
 {
     uint64_t start_off = m_W.OS.tell();
@@ -689,21 +639,6 @@ void ELFWriter::writeSections()
                 (m_SectionHdrEntries.size() + 1) : 0;
             break;
 
-        case ELF::SHT_NOTE: {
-            // Currently we don't seem to reorder strings in the .strtab, and
-            // the offset returned by LLVM StringTableBuilder::add() will still
-            // be valid, so the section name can be checked in this way. Other
-            // possibilities are creating a new section kind and set the
-            // appropriate section pointer, or emitting .strtab before the note
-            // section.
-            auto strtabSize = m_StrTabBuilder.getSize();
-            if (entry.name == m_StrTabBuilder.add(m_ObjBuilder.m_CompatNoteName)) {
-                IGC_ASSERT(entry.name < strtabSize);
-                std::tie(entry.offset, entry.size) = writeCompatibilityNote();
-                break;
-            }
-        }
-
         default:
             IGC_ASSERT(0);
             break;
@@ -747,11 +682,11 @@ void ELFWriter::writeHeader()
     // e_ident padding
     m_W.OS.write_zeros(ELF::EI_NIDENT - ELF::EI_OSABI);
 
-    // e_type: Currently IGC always emits a relocatable file
-    m_W.write<uint16_t>(ELF::ET_REL);
+    // e_type
+    m_W.write<uint16_t>(m_ObjBuilder.m_fileType);
 
     // e_machine
-    m_W.write<uint16_t>(EM_INTELGT);
+    m_W.write<uint16_t>(m_ObjBuilder.m_machineType);
 
     // e_version
     m_W.write<uint32_t>(0);
@@ -766,7 +701,7 @@ void ELFWriter::writeHeader()
     writeWord(0);
 
     // e_flags
-    m_W.write<uint32_t>(0);
+    m_W.write<uint32_t>(m_ObjBuilder.m_flags.packed);
 
     // e_ehsize = ELF header size
     m_W.write<uint16_t>(is64Bit() ?
@@ -896,16 +831,11 @@ void ELFWriter::createSectionHdrEntries()
     }
 
     // .ze_info
-    // every object must have exactly one ze_info section
-    IGC_ASSERT(m_ObjBuilder.m_zeInfoSection);
-    createSectionHdrEntry(m_ObjBuilder.m_ZEInfoName, SHT_ZEBIN_ZEINFO,
-        m_ObjBuilder.m_zeInfoSection.get());
-    ++index;
-
-    // .note.intelgt.compat
-    // Create the compatibility note section
-    createSectionHdrEntry(m_ObjBuilder.m_CompatNoteName, ELF::SHT_NOTE);
-    ++index;
+    if (m_ObjBuilder.m_zeInfoSection) {
+        createSectionHdrEntry(m_ObjBuilder.m_ZEInfoName, SHT_ZEBIN_ZEINFO,
+            m_ObjBuilder.m_zeInfoSection.get());
+        ++index;
+    }
 
     // .strtab
     m_StringTableIndex = index;

IGC/ZEBinWriter/zebin/source/ZEELFObjectBuilder.hpp

@@ -48,21 +48,41 @@ class ZEELFObjectBuilder {
     typedef int32_t SectionID;
 
 public:
-    ZEELFObjectBuilder(bool is64Bit) : m_is64Bit(is64Bit)
+    // Each ZEELFObjectBuilder creates one ELF Object
+    ZEELFObjectBuilder(bool is64Bit,
+                       ELF_TYPE_ZEBIN fileType,
+                       uint32_t machine,
+                       TargetFlags flags)
+        : m_is64Bit(is64Bit),
+          m_fileType(fileType),
+          m_machineType(machine),
+          m_flags(flags) {}
+
+    ZEELFObjectBuilder(bool is64Bit)
+        : m_is64Bit(is64Bit)
     {
-        m_metadata.packed = 0;
+        m_fileType = ET_ZEBIN_NONE;
+        m_machineType = 0;
+        m_flags.packed = 0;
     }
 
     ~ZEELFObjectBuilder() {}
 
-    void setProductFamily(uint32_t family) { m_productFamily = family; }
-    uint32_t getProductFamily() const { return m_productFamily; }
+    /// Set elfFileHeader::e_type value
+    void setFileType(ELF_TYPE_ZEBIN fileType)
+    { m_fileType = fileType; }
 
-    void setGfxCoreFamily(uint32_t family) { m_gfxCoreFamily = family; }
-    uint32_t getGfxCoreFamily() const { return m_gfxCoreFamily; }
+    /// Set elfFileHeader::e_machine value
+    void setMachine(uint32_t machine)
+    { m_machineType = machine; }
 
-    void setTargetMetadata(TargetMetadata metadata) { m_metadata = metadata; }
-    TargetMetadata getTargetMetadata() const { return m_metadata; }
+    /// Set elfFileHeader::e_flags
+    void setTargetFlag(TargetFlags flags)
+    { m_flags = flags; }
+
+    /// Get elfFileHeader::e_flags
+    TargetFlags getTargetFlag() const
+    { return m_flags; }
 
     // add a text section contains gen binary
     // - name: section name. This is usually the kernel or function name of
@@ -336,29 +356,28 @@ class ZEELFObjectBuilder {
 
 private:
     // place holder for section default name
-    const std::string m_TextName       = ".text";
-    const std::string m_DataName       = ".data";
-    const std::string m_BssName        = ".bss";
-    const std::string m_SymTabName     = ".symtab";
-    const std::string m_RelName        = ".rel";
-    const std::string m_RelaName       = ".rela";
-    const std::string m_SpvName        = ".spv";
-    const std::string m_VISAAsmName    = ".visaasm";
-    const std::string m_DebugName      = ".debug_info";
-    const std::string m_ZEInfoName     = ".ze_info";
-    const std::string m_GTPinInfoName  = ".gtpin_info";
-    const std::string m_MiscName       = ".misc";
-    const std::string m_CompatNoteName = ".note.intelgt.compat";
-    const std::string m_StrTabName     = ".strtab";
+    const std::string m_TextName      = ".text";
+    const std::string m_DataName      = ".data";
+    const std::string m_BssName       = ".bss";
+    const std::string m_SymTabName    = ".symtab";
+    const std::string m_RelName       = ".rel";
+    const std::string m_RelaName      = ".rela";
+    const std::string m_SpvName       = ".spv";
+    const std::string m_VISAAsmName   = ".visaasm";
+    const std::string m_DebugName     = ".debug_info";
+    const std::string m_ZEInfoName    = ".ze_info";
+    const std::string m_GTPinInfoName = ".gtpin_info";
+    const std::string m_MiscName      = ".misc";
+    const std::string m_StrTabName    = ".strtab";
 
 private:
     // 32 or 64 bit object
     bool m_is64Bit;
 
-    // information used to generate .note.intelgt.compat
-    uint32_t m_productFamily = 0;
-    uint32_t m_gfxCoreFamily = 0;
-    TargetMetadata m_metadata;
+    // information for ELF header
+    ELF_TYPE_ZEBIN m_fileType; // e_type
+    uint32_t m_machineType;    // e_machine
+    TargetFlags m_flags;       // e_flags
 
     StandardSectionListTy m_textSections;
     StandardSectionListTy m_dataAndbssSections; // data and bss sections