mirror of
https://github.com/intel/compute-runtime.git
synced 2025-12-29 09:03:14 +08:00
Revert "refactor(zeInfo): move zeinfo to seperate file"
This reverts commit e3ce887662.
Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
72ada8b41f
commit
84a7438ff2
@@ -23,23 +23,20 @@ set(NEO_DEVICE_BINARY_FORMAT
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/elf/elf_encoder.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/elf/elf_encoder.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/elf/ocl_elf.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/elf/zebin_elf.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/elf/zeinfo_enum_lookup.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/patchtokens_decoder.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/patchtokens_decoder.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/patchtokens_dumper.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/patchtokens_dumper.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/patchtokens_validator.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/patchtokens_validator.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin_decoder.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin_decoder.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/debug_zebin.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/debug_zebin.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/yaml/yaml_parser.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/yaml/yaml_parser.h
|
||||
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zebin_decoder.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zebin_decoder.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zebin_elf.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zeinfo.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zeinfo_decoder.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zeinfo_decoder.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/zebin/zeinfo_enum_lookup.h
|
||||
)
|
||||
|
||||
set_property(GLOBAL PROPERTY NEO_DEVICE_BINARY_FORMAT ${NEO_DEVICE_BINARY_FORMAT})
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
|
||||
#include "shared/source/device_binary_format/elf/elf_decoder.h"
|
||||
#include "shared/source/device_binary_format/elf/elf_encoder.h"
|
||||
#include "shared/source/device_binary_format/zebin/zebin_elf.h"
|
||||
#include "shared/source/device_binary_format/elf/zebin_elf.h"
|
||||
#include "shared/source/helpers/aligned_memory.h"
|
||||
#include "shared/source/memory_manager/graphics_allocation.h"
|
||||
|
||||
|
||||
@@ -10,8 +10,8 @@
|
||||
#include "shared/source/device_binary_format/device_binary_formats.h"
|
||||
#include "shared/source/device_binary_format/elf/elf_decoder.h"
|
||||
#include "shared/source/device_binary_format/elf/elf_encoder.h"
|
||||
#include "shared/source/device_binary_format/zebin/zebin_decoder.h"
|
||||
#include "shared/source/device_binary_format/zebin/zebin_elf.h"
|
||||
#include "shared/source/device_binary_format/elf/zebin_elf.h"
|
||||
#include "shared/source/device_binary_format/zebin_decoder.h"
|
||||
#include "shared/source/program/kernel_info.h"
|
||||
#include "shared/source/program/program_info.h"
|
||||
|
||||
|
||||
@@ -1,19 +1,121 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Intel Corporation
|
||||
* Copyright (C) 2020-2023 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "shared/source/utilities/arrayref.h"
|
||||
#include "shared/source/utilities/const_stringref.h"
|
||||
|
||||
#include <array>
|
||||
#include <optional>
|
||||
#include <vector>
|
||||
|
||||
namespace NEO::Zebin::ZeInfo {
|
||||
namespace NEO {
|
||||
|
||||
namespace Elf {
|
||||
|
||||
enum ELF_TYPE_ZEBIN : uint16_t {
|
||||
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
|
||||
};
|
||||
|
||||
enum SHT_ZEBIN : uint32_t {
|
||||
SHT_ZEBIN_SPIRV = 0xff000009, // .spv.kernel section, value the same as SHT_OPENCL_SPIRV
|
||||
SHT_ZEBIN_ZEINFO = 0xff000011, // .ze_info section
|
||||
SHT_ZEBIN_GTPIN_INFO = 0xff000012, // .gtpin_info section
|
||||
SHT_ZEBIN_VISA_ASM = 0xff000013, // .visaasm sections
|
||||
SHT_ZEBIN_MISC = 0xff000014 // .misc section
|
||||
};
|
||||
|
||||
enum RELOC_TYPE_ZEBIN : uint32_t {
|
||||
R_ZE_NONE,
|
||||
R_ZE_SYM_ADDR,
|
||||
R_ZE_SYM_ADDR_32,
|
||||
R_ZE_SYM_ADDR_32_HI,
|
||||
R_PER_THREAD_PAYLOAD_OFFSET
|
||||
};
|
||||
|
||||
namespace SectionsNamesZebin {
|
||||
inline constexpr ConstStringRef textPrefix = ".text.";
|
||||
inline constexpr ConstStringRef functions = ".text.Intel_Symbol_Table_Void_Program";
|
||||
inline constexpr ConstStringRef dataConst = ".data.const";
|
||||
inline constexpr ConstStringRef dataConstZeroInit = ".bss.const";
|
||||
inline constexpr ConstStringRef dataGlobalConst = ".data.global_const";
|
||||
inline constexpr ConstStringRef dataGlobal = ".data.global";
|
||||
inline constexpr ConstStringRef dataGlobalZeroInit = ".bss.global";
|
||||
inline constexpr ConstStringRef dataConstString = ".data.const.string";
|
||||
inline constexpr ConstStringRef symtab = ".symtab";
|
||||
inline constexpr ConstStringRef relTablePrefix = ".rel.";
|
||||
inline constexpr ConstStringRef relaTablePrefix = ".rela.";
|
||||
inline constexpr ConstStringRef spv = ".spv";
|
||||
inline constexpr ConstStringRef debugPrefix = ".debug_";
|
||||
inline constexpr ConstStringRef debugInfo = ".debug_info";
|
||||
inline constexpr ConstStringRef debugAbbrev = ".debug_abbrev";
|
||||
inline constexpr ConstStringRef zeInfo = ".ze_info";
|
||||
inline constexpr ConstStringRef gtpinInfo = ".gtpin_info.";
|
||||
inline constexpr ConstStringRef noteIntelGT = ".note.intelgt.compat";
|
||||
inline constexpr ConstStringRef buildOptions = ".misc.buildOptions";
|
||||
inline constexpr ConstStringRef vIsaAsmPrefix = ".visaasm.";
|
||||
inline constexpr ConstStringRef externalFunctions = "Intel_Symbol_Table_Void_Program";
|
||||
} // namespace SectionsNamesZebin
|
||||
|
||||
inline constexpr ConstStringRef IntelGtNoteOwnerName = "IntelGT";
|
||||
enum IntelGTSectionType : uint32_t {
|
||||
ProductFamily = 1,
|
||||
GfxCore = 2,
|
||||
TargetMetadata = 3,
|
||||
ZebinVersion = 4,
|
||||
ProductConfig = 5,
|
||||
LastSupported = ProductConfig
|
||||
};
|
||||
struct IntelGTNote {
|
||||
IntelGTSectionType type;
|
||||
ArrayRef<const uint8_t> data;
|
||||
};
|
||||
struct ZebinTargetFlags {
|
||||
union {
|
||||
struct {
|
||||
// bit[7:0]: dedicated for specific generator (meaning based on generatorId)
|
||||
uint8_t generatorSpecificFlags : 8;
|
||||
|
||||
// bit[12:8]: values [0-31], min compatbile device revision Id (stepping)
|
||||
uint8_t minHwRevisionId : 5;
|
||||
|
||||
// bit[13:13]:
|
||||
// 0 - full validation during decoding (safer decoding)
|
||||
// 1 - no validation (faster decoding - recommended for known generators)
|
||||
bool validateRevisionId : 1;
|
||||
|
||||
// bit[14:14]:
|
||||
// 0 - ignore minHwRevisionId and maxHwRevisionId
|
||||
// 1 - underlying device must match specified revisionId info
|
||||
bool disableExtendedValidation : 1;
|
||||
|
||||
// bit[15:15]:
|
||||
// 0 - elfFileHeader::machine is PRODUCT_FAMILY
|
||||
// 1 - elfFileHeader::machine is GFXCORE_FAMILY
|
||||
bool machineEntryUsesGfxCoreInsteadOfProductFamily : 1;
|
||||
|
||||
// bit[20:16]: max compatbile device revision Id (stepping)
|
||||
uint8_t maxHwRevisionId : 5;
|
||||
|
||||
// bit[23:21]: generator of this device binary
|
||||
// 0 - Unregistered
|
||||
// 1 - IGC
|
||||
uint8_t generatorId : 3;
|
||||
|
||||
// bit[31:24]: MBZ, reserved for future use
|
||||
};
|
||||
uint32_t packed = 0U;
|
||||
};
|
||||
};
|
||||
static_assert(sizeof(ZebinTargetFlags) == sizeof(uint32_t), "");
|
||||
|
||||
namespace ZebinKernelMetadata {
|
||||
namespace Tags {
|
||||
inline constexpr ConstStringRef kernels("kernels");
|
||||
inline constexpr ConstStringRef version("version");
|
||||
@@ -725,4 +827,8 @@ struct KernelArgMiscInfoT {
|
||||
|
||||
} // namespace Types
|
||||
|
||||
} // namespace NEO::Zebin::ZeInfo
|
||||
} // namespace ZebinKernelMetadata
|
||||
|
||||
} // namespace Elf
|
||||
|
||||
} // namespace NEO
|
||||
@@ -7,11 +7,11 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "shared/source/device_binary_format/zebin/zeinfo.h"
|
||||
#include "shared/source/device_binary_format/elf/zebin_elf.h"
|
||||
#include "shared/source/utilities/lookup_array.h"
|
||||
|
||||
namespace NEO::Zebin::ZeInfo::EnumLookup {
|
||||
using namespace NEO::Zebin::ZeInfo;
|
||||
using namespace Elf::ZebinKernelMetadata;
|
||||
|
||||
namespace ArgType {
|
||||
using namespace Tags::Kernel::PayloadArgument::ArgType;
|
||||
@@ -109,8 +109,8 @@ static_assert(lookup.size() == AllocType::AllocationTypeMax - 1, "Every enum fie
|
||||
} // namespace AllocationType
|
||||
|
||||
namespace MemoryUsage {
|
||||
using namespace Tags::Kernel::PerThreadMemoryBuffer::MemoryUsage;
|
||||
using MemoryUsage = Types::Kernel::PerThreadMemoryBuffer::MemoryUsage;
|
||||
using namespace NEO::Elf::ZebinKernelMetadata::Tags::Kernel::PerThreadMemoryBuffer::MemoryUsage;
|
||||
using MemoryUsage = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::MemoryUsage;
|
||||
inline constexpr ConstStringRef name = "memory usage";
|
||||
inline constexpr LookupArray<ConstStringRef, MemoryUsage, 3> lookup({{{privateSpace, MemoryUsage::MemoryUsagePrivateSpace},
|
||||
{spillFillSpace, MemoryUsage::MemoryUsageSpillFillSpace},
|
||||
@@ -1,452 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2022-2023 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/device_binary_format/zebin/zebin_decoder.h"
|
||||
|
||||
#include "shared/source/compiler_interface/intermediate_representations.h"
|
||||
#include "shared/source/debug_settings/debug_settings_manager.h"
|
||||
#include "shared/source/device_binary_format/device_binary_formats.h"
|
||||
#include "shared/source/device_binary_format/elf/elf_decoder.h"
|
||||
#include "shared/source/device_binary_format/zebin/zebin_elf.h"
|
||||
#include "shared/source/device_binary_format/zebin/zeinfo_decoder.h"
|
||||
#include "shared/source/helpers/aligned_memory.h"
|
||||
#include "shared/source/helpers/ptr_math.h"
|
||||
#include "shared/source/program/kernel_info.h"
|
||||
#include "shared/source/program/program_info.h"
|
||||
|
||||
#include "platforms.h"
|
||||
|
||||
namespace NEO {
|
||||
|
||||
void setKernelMiscInfoPosition(ConstStringRef metadata, NEO::ProgramInfo &dst) {
|
||||
dst.kernelMiscInfoPos = metadata.str().find(Zebin::ZeInfo::Tags::kernelMiscInfo.str());
|
||||
}
|
||||
|
||||
template bool isZebin<Elf::EI_CLASS_32>(ArrayRef<const uint8_t> binary);
|
||||
template bool isZebin<Elf::EI_CLASS_64>(ArrayRef<const uint8_t> binary);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
bool isZebin(ArrayRef<const uint8_t> binary) {
|
||||
auto fileHeader = Elf::decodeElfFileHeader<numBits>(binary);
|
||||
return fileHeader != nullptr &&
|
||||
(fileHeader->type == NEO::Elf::ET_REL ||
|
||||
fileHeader->type == NEO::Elf::ET_ZEBIN_EXE);
|
||||
}
|
||||
|
||||
template <>
|
||||
bool isDeviceBinaryFormat<NEO::DeviceBinaryFormat::Zebin>(const ArrayRef<const uint8_t> binary) {
|
||||
return isZebin<Elf::EI_CLASS_64>(binary) || isZebin<Elf::EI_CLASS_32>(binary);
|
||||
};
|
||||
|
||||
bool validateTargetDevice(const TargetDevice &targetDevice, Elf::ELF_IDENTIFIER_CLASS numBits, PRODUCT_FAMILY productFamily, GFXCORE_FAMILY gfxCore, AOT::PRODUCT_CONFIG productConfig, Elf::ZebinTargetFlags targetMetadata) {
|
||||
if (targetDevice.maxPointerSizeInBytes == 4 && static_cast<uint32_t>(numBits == Elf::EI_CLASS_64)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (productConfig != AOT::UNKNOWN_ISA) {
|
||||
return targetDevice.aotConfig.value == productConfig;
|
||||
}
|
||||
|
||||
if (gfxCore == IGFX_UNKNOWN_CORE && productFamily == IGFX_UNKNOWN) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (gfxCore != IGFX_UNKNOWN_CORE) {
|
||||
if (targetDevice.coreFamily != gfxCore) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (productFamily != IGFX_UNKNOWN) {
|
||||
if (targetDevice.productFamily != productFamily) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (targetMetadata.validateRevisionId) {
|
||||
bool isValidStepping = (targetDevice.stepping >= targetMetadata.minHwRevisionId) && (targetDevice.stepping <= targetMetadata.maxHwRevisionId);
|
||||
if (false == isValidStepping) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template bool validateTargetDevice<Elf::EI_CLASS_32>(const Elf::Elf<Elf::EI_CLASS_32> &elf, const TargetDevice &targetDevice, std::string &outErrReason, std::string &outWarning);
|
||||
template bool validateTargetDevice<Elf::EI_CLASS_64>(const Elf::Elf<Elf::EI_CLASS_64> &elf, const TargetDevice &targetDevice, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
bool validateTargetDevice(const Elf::Elf<numBits> &elf, const TargetDevice &targetDevice, std::string &outErrReason, std::string &outWarning) {
|
||||
GFXCORE_FAMILY gfxCore = IGFX_UNKNOWN_CORE;
|
||||
PRODUCT_FAMILY productFamily = IGFX_UNKNOWN;
|
||||
AOT::PRODUCT_CONFIG productConfig = AOT::UNKNOWN_ISA;
|
||||
Elf::ZebinTargetFlags targetMetadata = {};
|
||||
std::vector<Elf::IntelGTNote> intelGTNotes = {};
|
||||
auto decodeError = getIntelGTNotes(elf, intelGTNotes, outErrReason, outWarning);
|
||||
if (DecodeError::Success != decodeError) {
|
||||
return false;
|
||||
}
|
||||
for (const auto &intelGTNote : intelGTNotes) {
|
||||
switch (intelGTNote.type) {
|
||||
case Elf::IntelGTSectionType::ProductFamily: {
|
||||
DEBUG_BREAK_IF(sizeof(uint32_t) != intelGTNote.data.size());
|
||||
auto productFamilyData = reinterpret_cast<const uint32_t *>(intelGTNote.data.begin());
|
||||
productFamily = static_cast<PRODUCT_FAMILY>(*productFamilyData);
|
||||
break;
|
||||
}
|
||||
case Elf::IntelGTSectionType::GfxCore: {
|
||||
DEBUG_BREAK_IF(sizeof(uint32_t) != intelGTNote.data.size());
|
||||
auto gfxCoreData = reinterpret_cast<const uint32_t *>(intelGTNote.data.begin());
|
||||
gfxCore = static_cast<GFXCORE_FAMILY>(*gfxCoreData);
|
||||
break;
|
||||
}
|
||||
case Elf::IntelGTSectionType::TargetMetadata: {
|
||||
DEBUG_BREAK_IF(sizeof(uint32_t) != intelGTNote.data.size());
|
||||
auto targetMetadataPacked = reinterpret_cast<const uint32_t *>(intelGTNote.data.begin());
|
||||
targetMetadata.packed = static_cast<uint32_t>(*targetMetadataPacked);
|
||||
break;
|
||||
}
|
||||
case Elf::IntelGTSectionType::ZebinVersion: {
|
||||
auto zebinVersionData = reinterpret_cast<const char *>(intelGTNote.data.begin());
|
||||
ConstStringRef versionString(zebinVersionData);
|
||||
Zebin::ZeInfo::Types::Version receivedZeInfoVersion{0, 0};
|
||||
decodeError = Zebin::ZeInfo::populateZeInfoVersion(receivedZeInfoVersion, versionString, outErrReason);
|
||||
if (DecodeError::Success != decodeError) {
|
||||
return false;
|
||||
}
|
||||
decodeError = Zebin::ZeInfo::validateZeInfoVersion(receivedZeInfoVersion, outErrReason, outWarning);
|
||||
if (DecodeError::Success != decodeError) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Elf::IntelGTSectionType::ProductConfig: {
|
||||
DEBUG_BREAK_IF(sizeof(uint32_t) != intelGTNote.data.size());
|
||||
auto productConfigData = reinterpret_cast<const uint32_t *>(intelGTNote.data.begin());
|
||||
productConfig = static_cast<AOT::PRODUCT_CONFIG>(*productConfigData);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : Unrecognized IntelGTNote type: " + std::to_string(intelGTNote.type) + "\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
return validateTargetDevice(targetDevice, numBits, productFamily, gfxCore, productConfig, targetMetadata);
|
||||
}
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError decodeIntelGTNoteSection(ArrayRef<const uint8_t> intelGTNotesSection, std::vector<Elf::IntelGTNote> &intelGTNotes, std::string &outErrReason, std::string &outWarning) {
|
||||
uint64_t currentPos = 0;
|
||||
auto sectionSize = intelGTNotesSection.size();
|
||||
while (currentPos < sectionSize) {
|
||||
auto intelGTNote = reinterpret_cast<const Elf::ElfNoteSection *>(intelGTNotesSection.begin() + currentPos);
|
||||
auto nameSz = intelGTNote->nameSize;
|
||||
auto descSz = intelGTNote->descSize;
|
||||
|
||||
auto currOffset = sizeof(Elf::ElfNoteSection) + alignUp(nameSz, 4) + alignUp(descSz, 4);
|
||||
if (currentPos + currOffset > sectionSize) {
|
||||
intelGTNotes.clear();
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Offseting will cause out-of-bound memory read! Section size: " + std::to_string(sectionSize) +
|
||||
", current section data offset: " + std::to_string(currentPos) + ", next offset : " + std::to_string(currOffset) + "\n");
|
||||
return DecodeError::InvalidBinary;
|
||||
}
|
||||
currentPos += currOffset;
|
||||
|
||||
auto ownerName = reinterpret_cast<const char *>(ptrOffset(intelGTNote, sizeof(Elf::ElfNoteSection)));
|
||||
bool isValidGTNote = Elf::IntelGtNoteOwnerName.size() + 1 == nameSz;
|
||||
isValidGTNote &= Elf::IntelGtNoteOwnerName == ConstStringRef(ownerName, nameSz - 1);
|
||||
if (false == isValidGTNote) {
|
||||
if (0u == nameSz) {
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : Empty owner name.\n");
|
||||
} else {
|
||||
std::string invalidOwnerName{ownerName, nameSz};
|
||||
invalidOwnerName.erase(std::remove_if(invalidOwnerName.begin(),
|
||||
invalidOwnerName.end(),
|
||||
[](unsigned char c) { return '\0' == c; }));
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : Invalid owner name : " + invalidOwnerName + " for IntelGTNote - note will not be used.\n");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
auto notesData = ArrayRef<const uint8_t>(reinterpret_cast<const uint8_t *>(ptrOffset(ownerName, nameSz)), descSz);
|
||||
if (intelGTNote->type == Elf::IntelGTSectionType::ZebinVersion) {
|
||||
isValidGTNote &= notesData[descSz - 1] == '\0';
|
||||
if (false == isValidGTNote) {
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : Versioning string is not null-terminated: " + ConstStringRef(reinterpret_cast<const char *>(notesData.begin()), descSz).str() + " - note will not be used.\n");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
intelGTNotes.push_back(Elf::IntelGTNote{static_cast<Elf::IntelGTSectionType>(intelGTNote->type), notesData});
|
||||
}
|
||||
return DecodeError::Success;
|
||||
}
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError getIntelGTNotes(const Elf::Elf<numBits> &elf, std::vector<Elf::IntelGTNote> &intelGTNotes, std::string &outErrReason, std::string &outWarning) {
|
||||
for (size_t i = 0; i < elf.sectionHeaders.size(); i++) {
|
||||
auto section = elf.sectionHeaders[i];
|
||||
if (Elf::SHT_NOTE == section.header->type && Elf::SectionsNamesZebin::noteIntelGT == elf.getSectionName(static_cast<uint32_t>(i))) {
|
||||
return decodeIntelGTNoteSection<numBits>(section.data, intelGTNotes, outErrReason, outWarning);
|
||||
}
|
||||
}
|
||||
return DecodeError::Success;
|
||||
}
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError extractZebinSections(NEO::Elf::Elf<numBits> &elf, ZebinSections<numBits> &out, std::string &outErrReason, std::string &outWarning) {
|
||||
if ((elf.elfFileHeader->shStrNdx >= elf.sectionHeaders.size()) || (NEO::Elf::SHN_UNDEF == elf.elfFileHeader->shStrNdx)) {
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Invalid or missing shStrNdx in elf header\n");
|
||||
return DecodeError::InvalidBinary;
|
||||
}
|
||||
|
||||
auto sectionHeaderNamesData = elf.sectionHeaders[elf.elfFileHeader->shStrNdx].data;
|
||||
ConstStringRef sectionHeaderNamesString(reinterpret_cast<const char *>(sectionHeaderNamesData.begin()), sectionHeaderNamesData.size());
|
||||
|
||||
for (auto &elfSectionHeader : elf.sectionHeaders) {
|
||||
ConstStringRef sectionName = ConstStringRef(sectionHeaderNamesString.begin() + elfSectionHeader.header->name);
|
||||
switch (elfSectionHeader.header->type) {
|
||||
default:
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Unhandled ELF section header type : " + std::to_string(elfSectionHeader.header->type) + "\n");
|
||||
return DecodeError::InvalidBinary;
|
||||
case Elf::SHT_PROGBITS:
|
||||
if (sectionName.startsWith(NEO::Elf::SectionsNamesZebin::textPrefix.data())) {
|
||||
out.textKernelSections.push_back(&elfSectionHeader);
|
||||
} else if (sectionName == NEO::Elf::SectionsNamesZebin::dataConst) {
|
||||
out.constDataSections.push_back(&elfSectionHeader);
|
||||
} else if (sectionName == NEO::Elf::SectionsNamesZebin::dataGlobalConst) {
|
||||
outWarning.append("Misspelled section name : " + sectionName.str() + ", should be : " + NEO::Elf::SectionsNamesZebin::dataConst.str() + "\n");
|
||||
out.constDataSections.push_back(&elfSectionHeader);
|
||||
} else if (sectionName == NEO::Elf::SectionsNamesZebin::dataGlobal) {
|
||||
out.globalDataSections.push_back(&elfSectionHeader);
|
||||
} else if (sectionName == NEO::Elf::SectionsNamesZebin::dataConstString) {
|
||||
out.constDataStringSections.push_back(&elfSectionHeader);
|
||||
} else if (sectionName.startsWith(NEO::Elf::SectionsNamesZebin::debugPrefix.data())) {
|
||||
// ignoring intentionally
|
||||
} else {
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Unhandled SHT_PROGBITS section : " + sectionName.str() + " currently supports only : " + NEO::Elf::SectionsNamesZebin::textPrefix.str() + "KERNEL_NAME, " + NEO::Elf::SectionsNamesZebin::dataConst.str() + ", " + NEO::Elf::SectionsNamesZebin::dataGlobal.str() + " and " + NEO::Elf::SectionsNamesZebin::debugPrefix.str() + "* .\n");
|
||||
return DecodeError::InvalidBinary;
|
||||
}
|
||||
break;
|
||||
case NEO::Elf::SHT_ZEBIN_ZEINFO:
|
||||
out.zeInfoSections.push_back(&elfSectionHeader);
|
||||
break;
|
||||
case NEO::Elf::SHT_SYMTAB:
|
||||
out.symtabSections.push_back(&elfSectionHeader);
|
||||
break;
|
||||
case NEO::Elf::SHT_ZEBIN_SPIRV:
|
||||
out.spirvSections.push_back(&elfSectionHeader);
|
||||
break;
|
||||
case NEO::Elf::SHT_NOTE:
|
||||
if (sectionName == NEO::Elf::SectionsNamesZebin::noteIntelGT) {
|
||||
out.noteIntelGTSections.push_back(&elfSectionHeader);
|
||||
} else {
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : Unhandled SHT_NOTE section : " + sectionName.str() + " currently supports only : " + NEO::Elf::SectionsNamesZebin::noteIntelGT.str() + ".\n");
|
||||
}
|
||||
break;
|
||||
case NEO::Elf::SHT_ZEBIN_MISC:
|
||||
if (sectionName == NEO::Elf::SectionsNamesZebin::buildOptions) {
|
||||
out.buildOptionsSection.push_back(&elfSectionHeader);
|
||||
} else {
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : unhandled SHT_ZEBIN_MISC section : " + sectionName.str() + " currently supports only : " + NEO::Elf::SectionsNamesZebin::buildOptions.str() + ".\n");
|
||||
}
|
||||
break;
|
||||
case NEO::Elf::SHT_STRTAB:
|
||||
// ignoring intentionally - section header names
|
||||
continue;
|
||||
case NEO::Elf::SHT_REL:
|
||||
case NEO::Elf::SHT_RELA:
|
||||
// ignoring intentionally - rel/rela sections handled by Elf decoder
|
||||
continue;
|
||||
case NEO::Elf::SHT_ZEBIN_GTPIN_INFO:
|
||||
if (sectionName.startsWith(NEO::Elf::SectionsNamesZebin::gtpinInfo.data())) {
|
||||
out.gtpinInfoSections.push_back(&elfSectionHeader);
|
||||
} else {
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : Unhandled SHT_ZEBIN_GTPIN_INFO section : " + sectionName.str() + ", currently supports only : " + NEO::Elf::SectionsNamesZebin::gtpinInfo.str() + "KERNEL_NAME\n");
|
||||
}
|
||||
break;
|
||||
case NEO::Elf::SHT_ZEBIN_VISA_ASM:
|
||||
// ignoring intentionally - visa asm
|
||||
continue;
|
||||
case NEO::Elf::SHT_NULL:
|
||||
// ignoring intentionally, inactive section, probably UNDEF
|
||||
continue;
|
||||
case NEO::Elf::SHT_NOBITS:
|
||||
if (sectionName == NEO::Elf::SectionsNamesZebin::dataConstZeroInit) {
|
||||
out.constZeroInitDataSections.push_back(&elfSectionHeader);
|
||||
} else if (sectionName == NEO::Elf::SectionsNamesZebin::dataGlobalZeroInit) {
|
||||
out.globalZeroInitDataSections.push_back(&elfSectionHeader);
|
||||
} else {
|
||||
outWarning.append("DeviceBinaryFormat::Zebin : unhandled SHT_NOBITS section : " + sectionName.str() + " currently supports only : " + NEO::Elf::SectionsNamesZebin::dataConstZeroInit.str() + " and " + NEO::Elf::SectionsNamesZebin::dataGlobalZeroInit.str() + ".\n");
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return DecodeError::Success;
|
||||
}
|
||||
|
||||
template <typename ContainerT>
|
||||
bool validateZebinSectionsCountAtMost(const ContainerT §ionsContainer, ConstStringRef sectionName, uint32_t max, std::string &outErrReason, std::string &outWarning) {
|
||||
if (sectionsContainer.size() <= max) {
|
||||
return true;
|
||||
}
|
||||
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Expected at most " + std::to_string(max) + " of " + sectionName.str() + " section, got : " + std::to_string(sectionsContainer.size()) + "\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename ContainerT>
|
||||
bool validateZebinSectionsCountExactly(const ContainerT §ionsContainer, ConstStringRef sectionName, uint32_t num, std::string &outErrReason, std::string &outWarning) {
|
||||
if (sectionsContainer.size() == num) {
|
||||
return true;
|
||||
}
|
||||
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Expected exactly " + std::to_string(num) + " of " + sectionName.str() + " section, got : " + std::to_string(sectionsContainer.size()) + "\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
template DecodeError validateZebinSectionsCount<Elf::EI_CLASS_32>(const ZebinSections<Elf::EI_CLASS_32> §ions, std::string &outErrReason, std::string &outWarning);
|
||||
template DecodeError validateZebinSectionsCount<Elf::EI_CLASS_64>(const ZebinSections<Elf::EI_CLASS_64> §ions, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError validateZebinSectionsCount(const ZebinSections<numBits> §ions, std::string &outErrReason, std::string &outWarning) {
|
||||
bool valid = validateZebinSectionsCountExactly(sections.zeInfoSections, NEO::Elf::SectionsNamesZebin::zeInfo, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.globalDataSections, NEO::Elf::SectionsNamesZebin::dataGlobal, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.globalZeroInitDataSections, NEO::Elf::SectionsNamesZebin::dataGlobalZeroInit, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.constDataSections, NEO::Elf::SectionsNamesZebin::dataConst, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.constZeroInitDataSections, NEO::Elf::SectionsNamesZebin::dataConstZeroInit, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.constDataStringSections, NEO::Elf::SectionsNamesZebin::dataConstString, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.symtabSections, NEO::Elf::SectionsNamesZebin::symtab, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.spirvSections, NEO::Elf::SectionsNamesZebin::spv, 1U, outErrReason, outWarning);
|
||||
valid &= validateZebinSectionsCountAtMost(sections.noteIntelGTSections, NEO::Elf::SectionsNamesZebin::noteIntelGT, 1U, outErrReason, outWarning);
|
||||
return valid ? DecodeError::Success : DecodeError::InvalidBinary;
|
||||
}
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ConstStringRef extractZeInfoMetadataString(const ArrayRef<const uint8_t> zebin, std::string &outErrReason, std::string &outWarning) {
|
||||
auto decodedElf = NEO::Elf::decodeElf<numBits>(zebin, outErrReason, outWarning);
|
||||
for (const auto §ionHeader : decodedElf.sectionHeaders) {
|
||||
if (sectionHeader.header->type == NEO::Elf::SHT_ZEBIN_ZEINFO) {
|
||||
auto zeInfoData = sectionHeader.data;
|
||||
return ConstStringRef{reinterpret_cast<const char *>(zeInfoData.begin()), zeInfoData.size()};
|
||||
}
|
||||
}
|
||||
return ConstStringRef{};
|
||||
}
|
||||
|
||||
ConstStringRef getZeInfoFromZebin(const ArrayRef<const uint8_t> zebin, std::string &outErrReason, std::string &outWarning) {
|
||||
return Elf::isElf<Elf::EI_CLASS_32>(zebin)
|
||||
? extractZeInfoMetadataString<Elf::EI_CLASS_32>(zebin, outErrReason, outWarning)
|
||||
: extractZeInfoMetadataString<Elf::EI_CLASS_64>(zebin, outErrReason, outWarning);
|
||||
}
|
||||
|
||||
template DecodeError decodeZebin<Elf::EI_CLASS_32>(ProgramInfo &dst, NEO::Elf::Elf<Elf::EI_CLASS_32> &elf, std::string &outErrReason, std::string &outWarning);
|
||||
template DecodeError decodeZebin<Elf::EI_CLASS_64>(ProgramInfo &dst, NEO::Elf::Elf<Elf::EI_CLASS_64> &elf, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError decodeZebin(ProgramInfo &dst, NEO::Elf::Elf<numBits> &elf, std::string &outErrReason, std::string &outWarning) {
|
||||
ZebinSections<numBits> zebinSections;
|
||||
auto extractError = extractZebinSections(elf, zebinSections, outErrReason, outWarning);
|
||||
if (DecodeError::Success != extractError) {
|
||||
return extractError;
|
||||
}
|
||||
|
||||
extractError = validateZebinSectionsCount(zebinSections, outErrReason, outWarning);
|
||||
if (DecodeError::Success != extractError) {
|
||||
return extractError;
|
||||
}
|
||||
|
||||
if (false == zebinSections.globalDataSections.empty()) {
|
||||
dst.globalVariables.initData = zebinSections.globalDataSections[0]->data.begin();
|
||||
dst.globalVariables.size = zebinSections.globalDataSections[0]->data.size();
|
||||
}
|
||||
|
||||
if (false == zebinSections.globalZeroInitDataSections.empty()) {
|
||||
dst.globalVariables.zeroInitSize = static_cast<size_t>(zebinSections.globalZeroInitDataSections[0]->header->size);
|
||||
}
|
||||
|
||||
if (false == zebinSections.constDataSections.empty()) {
|
||||
dst.globalConstants.initData = zebinSections.constDataSections[0]->data.begin();
|
||||
dst.globalConstants.size = zebinSections.constDataSections[0]->data.size();
|
||||
}
|
||||
|
||||
if (false == zebinSections.constZeroInitDataSections.empty()) {
|
||||
dst.globalConstants.zeroInitSize = static_cast<size_t>(zebinSections.constZeroInitDataSections[0]->header->size);
|
||||
}
|
||||
|
||||
if (false == zebinSections.constDataStringSections.empty()) {
|
||||
dst.globalStrings.initData = zebinSections.constDataStringSections[0]->data.begin();
|
||||
dst.globalStrings.size = zebinSections.constDataStringSections[0]->data.size();
|
||||
}
|
||||
|
||||
auto metadataSectionData = zebinSections.zeInfoSections[0]->data;
|
||||
ConstStringRef zeinfo(reinterpret_cast<const char *>(metadataSectionData.begin()), metadataSectionData.size());
|
||||
setKernelMiscInfoPosition(zeinfo, dst);
|
||||
if (std::string::npos != dst.kernelMiscInfoPos) {
|
||||
zeinfo = zeinfo.substr(static_cast<size_t>(0), dst.kernelMiscInfoPos);
|
||||
}
|
||||
|
||||
auto decodeZeInfoError = Zebin::ZeInfo::decodeZeInfo(dst, zeinfo, outErrReason, outWarning);
|
||||
if (DecodeError::Success != decodeZeInfoError) {
|
||||
return decodeZeInfoError;
|
||||
}
|
||||
|
||||
for (auto &kernelInfo : dst.kernelInfos) {
|
||||
ConstStringRef kernelName(kernelInfo->kernelDescriptor.kernelMetadata.kernelName);
|
||||
auto kernelInstructions = getKernelHeap(kernelName, elf, zebinSections);
|
||||
if (kernelInstructions.empty()) {
|
||||
outErrReason.append("DeviceBinaryFormat::Zebin : Could not find text section for kernel " + kernelName.str() + "\n");
|
||||
return DecodeError::InvalidBinary;
|
||||
}
|
||||
|
||||
auto gtpinInfoForKernel = getKernelGtpinInfo(kernelName, elf, zebinSections);
|
||||
if (false == gtpinInfoForKernel.empty()) {
|
||||
kernelInfo->igcInfoForGtpin = reinterpret_cast<const gtpin::igc_info_t *>(gtpinInfoForKernel.begin());
|
||||
}
|
||||
|
||||
kernelInfo->heapInfo.pKernelHeap = kernelInstructions.begin();
|
||||
kernelInfo->heapInfo.KernelHeapSize = static_cast<uint32_t>(kernelInstructions.size());
|
||||
kernelInfo->heapInfo.KernelUnpaddedSize = static_cast<uint32_t>(kernelInstructions.size());
|
||||
|
||||
auto &kernelSSH = kernelInfo->kernelDescriptor.generatedSsh;
|
||||
kernelInfo->heapInfo.pSsh = kernelSSH.data();
|
||||
kernelInfo->heapInfo.SurfaceStateHeapSize = static_cast<uint32_t>(kernelSSH.size());
|
||||
|
||||
auto &kernelDSH = kernelInfo->kernelDescriptor.generatedDsh;
|
||||
kernelInfo->heapInfo.pDsh = kernelDSH.data();
|
||||
kernelInfo->heapInfo.DynamicStateHeapSize = static_cast<uint32_t>(kernelDSH.size());
|
||||
}
|
||||
|
||||
return DecodeError::Success;
|
||||
}
|
||||
|
||||
template ArrayRef<const uint8_t> getKernelHeap<Elf::EI_CLASS_32>(ConstStringRef &kernelName, Elf::Elf<Elf::EI_CLASS_32> &elf, const ZebinSections<Elf::EI_CLASS_32> &zebinSections);
|
||||
template ArrayRef<const uint8_t> getKernelHeap<Elf::EI_CLASS_64>(ConstStringRef &kernelName, Elf::Elf<Elf::EI_CLASS_64> &elf, const ZebinSections<Elf::EI_CLASS_64> &zebinSections);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ArrayRef<const uint8_t> getKernelHeap(ConstStringRef &kernelName, Elf::Elf<numBits> &elf, const ZebinSections<numBits> &zebinSections) {
|
||||
auto sectionHeaderNamesData = elf.sectionHeaders[elf.elfFileHeader->shStrNdx].data;
|
||||
ConstStringRef sectionHeaderNamesString(reinterpret_cast<const char *>(sectionHeaderNamesData.begin()), sectionHeaderNamesData.size());
|
||||
for (auto *textSection : zebinSections.textKernelSections) {
|
||||
ConstStringRef sectionName = ConstStringRef(sectionHeaderNamesString.begin() + textSection->header->name);
|
||||
auto sufix = sectionName.substr(static_cast<int>(NEO::Elf::SectionsNamesZebin::textPrefix.length()));
|
||||
if (sufix == kernelName) {
|
||||
return textSection->data;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
template ArrayRef<const uint8_t> getKernelGtpinInfo<Elf::EI_CLASS_32>(ConstStringRef &kernelName, Elf::Elf<Elf::EI_CLASS_32> &elf, const ZebinSections<Elf::EI_CLASS_32> &zebinSections);
|
||||
template ArrayRef<const uint8_t> getKernelGtpinInfo<Elf::EI_CLASS_64>(ConstStringRef &kernelName, Elf::Elf<Elf::EI_CLASS_64> &elf, const ZebinSections<Elf::EI_CLASS_64> &zebinSections);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ArrayRef<const uint8_t> getKernelGtpinInfo(ConstStringRef &kernelName, Elf::Elf<numBits> &elf, const ZebinSections<numBits> &zebinSections) {
|
||||
auto sectionHeaderNamesData = elf.sectionHeaders[elf.elfFileHeader->shStrNdx].data;
|
||||
ConstStringRef sectionHeaderNamesString(reinterpret_cast<const char *>(sectionHeaderNamesData.begin()), sectionHeaderNamesData.size());
|
||||
for (auto *gtpinInfoSection : zebinSections.gtpinInfoSections) {
|
||||
ConstStringRef sectionName = ConstStringRef(sectionHeaderNamesString.begin() + gtpinInfoSection->header->name);
|
||||
auto sufix = sectionName.substr(static_cast<int>(NEO::Elf::SectionsNamesZebin::gtpinInfo.length()));
|
||||
if (sufix == kernelName) {
|
||||
return gtpinInfoSection->data;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
} // namespace NEO
|
||||
@@ -1,72 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2023 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "shared/source/device_binary_format/device_binary_formats.h"
|
||||
#include "shared/source/device_binary_format/elf/elf_decoder.h"
|
||||
#include "shared/source/device_binary_format/zebin/zebin_elf.h"
|
||||
#include "shared/source/kernel/kernel_descriptor.h"
|
||||
#include "shared/source/program/kernel_info.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace AOT {
|
||||
enum PRODUCT_CONFIG : uint32_t;
|
||||
}
|
||||
|
||||
namespace NEO {
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits = Elf::EI_CLASS_64>
|
||||
struct ZebinSections {
|
||||
using SectionHeaderData = typename NEO::Elf::Elf<numBits>::SectionHeaderAndData;
|
||||
StackVec<SectionHeaderData *, 32> textKernelSections;
|
||||
StackVec<SectionHeaderData *, 32> gtpinInfoSections;
|
||||
StackVec<SectionHeaderData *, 1> zeInfoSections;
|
||||
StackVec<SectionHeaderData *, 1> globalDataSections;
|
||||
StackVec<SectionHeaderData *, 1> globalZeroInitDataSections;
|
||||
StackVec<SectionHeaderData *, 1> constDataSections;
|
||||
StackVec<SectionHeaderData *, 1> constZeroInitDataSections;
|
||||
StackVec<SectionHeaderData *, 1> constDataStringSections;
|
||||
StackVec<SectionHeaderData *, 1> symtabSections;
|
||||
StackVec<SectionHeaderData *, 1> spirvSections;
|
||||
StackVec<SectionHeaderData *, 1> noteIntelGTSections;
|
||||
StackVec<SectionHeaderData *, 1> buildOptionsSection;
|
||||
};
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
bool isZebin(ArrayRef<const uint8_t> binary);
|
||||
|
||||
bool validateTargetDevice(const TargetDevice &targetDevice, Elf::ELF_IDENTIFIER_CLASS numBits, PRODUCT_FAMILY productFamily, GFXCORE_FAMILY gfxCore, AOT::PRODUCT_CONFIG productConfig, Elf::ZebinTargetFlags targetMetadata);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
bool validateTargetDevice(const Elf::Elf<numBits> &elf, const TargetDevice &targetDevice, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError decodeIntelGTNoteSection(ArrayRef<const uint8_t> intelGTNotesSection, std::vector<Elf::IntelGTNote> &intelGTNotes, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError getIntelGTNotes(const Elf::Elf<numBits> &elf, std::vector<Elf::IntelGTNote> &intelGTNotes, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError extractZebinSections(NEO::Elf::Elf<numBits> &elf, ZebinSections<numBits> &out, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError validateZebinSectionsCount(const ZebinSections<numBits> §ions, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
NEO::DecodeError decodeZebin(ProgramInfo &dst, NEO::Elf::Elf<numBits> &elf, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ArrayRef<const uint8_t> getKernelHeap(ConstStringRef &kernelName, Elf::Elf<numBits> &elf, const ZebinSections<numBits> &zebinSections);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ArrayRef<const uint8_t> getKernelGtpinInfo(ConstStringRef &kernelName, Elf::Elf<numBits> &elf, const ZebinSections<numBits> &zebinSections);
|
||||
|
||||
void setKernelMiscInfoPosition(ConstStringRef metadata, NEO::ProgramInfo &dst);
|
||||
|
||||
ConstStringRef getZeInfoFromZebin(const ArrayRef<const uint8_t> zebin, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
} // namespace NEO
|
||||
@@ -1,120 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2020-2023 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/source/utilities/arrayref.h"
|
||||
#include "shared/source/utilities/const_stringref.h"
|
||||
|
||||
#include <array>
|
||||
#include <optional>
|
||||
#include <vector>
|
||||
|
||||
namespace NEO {
|
||||
|
||||
namespace Elf {
|
||||
|
||||
enum ELF_TYPE_ZEBIN : uint16_t {
|
||||
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
|
||||
};
|
||||
|
||||
enum SHT_ZEBIN : uint32_t {
|
||||
SHT_ZEBIN_SPIRV = 0xff000009, // .spv.kernel section, value the same as SHT_OPENCL_SPIRV
|
||||
SHT_ZEBIN_ZEINFO = 0xff000011, // .ze_info section
|
||||
SHT_ZEBIN_GTPIN_INFO = 0xff000012, // .gtpin_info section
|
||||
SHT_ZEBIN_VISA_ASM = 0xff000013, // .visaasm sections
|
||||
SHT_ZEBIN_MISC = 0xff000014 // .misc section
|
||||
};
|
||||
|
||||
enum RELOC_TYPE_ZEBIN : uint32_t {
|
||||
R_ZE_NONE,
|
||||
R_ZE_SYM_ADDR,
|
||||
R_ZE_SYM_ADDR_32,
|
||||
R_ZE_SYM_ADDR_32_HI,
|
||||
R_PER_THREAD_PAYLOAD_OFFSET
|
||||
};
|
||||
|
||||
namespace SectionsNamesZebin {
|
||||
inline constexpr ConstStringRef textPrefix = ".text.";
|
||||
inline constexpr ConstStringRef functions = ".text.Intel_Symbol_Table_Void_Program";
|
||||
inline constexpr ConstStringRef dataConst = ".data.const";
|
||||
inline constexpr ConstStringRef dataConstZeroInit = ".bss.const";
|
||||
inline constexpr ConstStringRef dataGlobalConst = ".data.global_const";
|
||||
inline constexpr ConstStringRef dataGlobal = ".data.global";
|
||||
inline constexpr ConstStringRef dataGlobalZeroInit = ".bss.global";
|
||||
inline constexpr ConstStringRef dataConstString = ".data.const.string";
|
||||
inline constexpr ConstStringRef symtab = ".symtab";
|
||||
inline constexpr ConstStringRef relTablePrefix = ".rel.";
|
||||
inline constexpr ConstStringRef relaTablePrefix = ".rela.";
|
||||
inline constexpr ConstStringRef spv = ".spv";
|
||||
inline constexpr ConstStringRef debugPrefix = ".debug_";
|
||||
inline constexpr ConstStringRef debugInfo = ".debug_info";
|
||||
inline constexpr ConstStringRef debugAbbrev = ".debug_abbrev";
|
||||
inline constexpr ConstStringRef zeInfo = ".ze_info";
|
||||
inline constexpr ConstStringRef gtpinInfo = ".gtpin_info.";
|
||||
inline constexpr ConstStringRef noteIntelGT = ".note.intelgt.compat";
|
||||
inline constexpr ConstStringRef buildOptions = ".misc.buildOptions";
|
||||
inline constexpr ConstStringRef vIsaAsmPrefix = ".visaasm.";
|
||||
inline constexpr ConstStringRef externalFunctions = "Intel_Symbol_Table_Void_Program";
|
||||
} // namespace SectionsNamesZebin
|
||||
|
||||
inline constexpr ConstStringRef IntelGtNoteOwnerName = "IntelGT";
|
||||
enum IntelGTSectionType : uint32_t {
|
||||
ProductFamily = 1,
|
||||
GfxCore = 2,
|
||||
TargetMetadata = 3,
|
||||
ZebinVersion = 4,
|
||||
ProductConfig = 5,
|
||||
LastSupported = ProductConfig
|
||||
};
|
||||
struct IntelGTNote {
|
||||
IntelGTSectionType type;
|
||||
ArrayRef<const uint8_t> data;
|
||||
};
|
||||
struct ZebinTargetFlags {
|
||||
union {
|
||||
struct {
|
||||
// bit[7:0]: dedicated for specific generator (meaning based on generatorId)
|
||||
uint8_t generatorSpecificFlags : 8;
|
||||
|
||||
// bit[12:8]: values [0-31], min compatbile device revision Id (stepping)
|
||||
uint8_t minHwRevisionId : 5;
|
||||
|
||||
// bit[13:13]:
|
||||
// 0 - full validation during decoding (safer decoding)
|
||||
// 1 - no validation (faster decoding - recommended for known generators)
|
||||
bool validateRevisionId : 1;
|
||||
|
||||
// bit[14:14]:
|
||||
// 0 - ignore minHwRevisionId and maxHwRevisionId
|
||||
// 1 - underlying device must match specified revisionId info
|
||||
bool disableExtendedValidation : 1;
|
||||
|
||||
// bit[15:15]:
|
||||
// 0 - elfFileHeader::machine is PRODUCT_FAMILY
|
||||
// 1 - elfFileHeader::machine is GFXCORE_FAMILY
|
||||
bool machineEntryUsesGfxCoreInsteadOfProductFamily : 1;
|
||||
|
||||
// bit[20:16]: max compatbile device revision Id (stepping)
|
||||
uint8_t maxHwRevisionId : 5;
|
||||
|
||||
// bit[23:21]: generator of this device binary
|
||||
// 0 - Unregistered
|
||||
// 1 - IGC
|
||||
uint8_t generatorId : 3;
|
||||
|
||||
// bit[31:24]: MBZ, reserved for future use
|
||||
};
|
||||
uint32_t packed = 0U;
|
||||
};
|
||||
};
|
||||
static_assert(sizeof(ZebinTargetFlags) == sizeof(uint32_t), "");
|
||||
|
||||
} // namespace Elf
|
||||
|
||||
} // namespace NEO
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,28 +1,45 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Intel Corporation
|
||||
* Copyright (C) 2020-2023 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "shared/source/device_binary_format/device_binary_formats.h"
|
||||
#include "shared/source/device_binary_format/elf/elf_decoder.h"
|
||||
#include "shared/source/device_binary_format/elf/zebin_elf.h"
|
||||
#include "shared/source/device_binary_format/yaml/yaml_parser.h"
|
||||
#include "shared/source/device_binary_format/zebin/zeinfo.h"
|
||||
#include "shared/source/utilities/stackvec.h"
|
||||
#include "shared/source/kernel/kernel_descriptor.h"
|
||||
#include "shared/source/program/kernel_info.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace AOT {
|
||||
enum PRODUCT_CONFIG : uint32_t;
|
||||
}
|
||||
|
||||
namespace NEO {
|
||||
|
||||
struct KernelDescriptor;
|
||||
struct KernelInfo;
|
||||
struct ProgramInfo;
|
||||
inline constexpr NEO::Elf::ZebinKernelMetadata::Types::Version zeInfoDecoderVersion{1, 26};
|
||||
|
||||
namespace Zebin::ZeInfo {
|
||||
inline constexpr NEO::Zebin::ZeInfo::Types::Version zeInfoDecoderVersion{1, 26};
|
||||
|
||||
template <typename T>
|
||||
bool readEnumChecked(ConstStringRef enumString, T &outValue, ConstStringRef kernelName, std::string &outErrReason);
|
||||
template <typename T>
|
||||
bool readZeInfoEnumChecked(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node, T &outValue, ConstStringRef kernelName, std::string &outErrReason);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits = Elf::EI_CLASS_64>
|
||||
struct ZebinSections {
|
||||
using SectionHeaderData = typename NEO::Elf::Elf<numBits>::SectionHeaderAndData;
|
||||
StackVec<SectionHeaderData *, 32> textKernelSections;
|
||||
StackVec<SectionHeaderData *, 32> gtpinInfoSections;
|
||||
StackVec<SectionHeaderData *, 1> zeInfoSections;
|
||||
StackVec<SectionHeaderData *, 1> globalDataSections;
|
||||
StackVec<SectionHeaderData *, 1> globalZeroInitDataSections;
|
||||
StackVec<SectionHeaderData *, 1> constDataSections;
|
||||
StackVec<SectionHeaderData *, 1> constZeroInitDataSections;
|
||||
StackVec<SectionHeaderData *, 1> constDataStringSections;
|
||||
StackVec<SectionHeaderData *, 1> symtabSections;
|
||||
StackVec<SectionHeaderData *, 1> spirvSections;
|
||||
StackVec<SectionHeaderData *, 1> noteIntelGTSections;
|
||||
StackVec<SectionHeaderData *, 1> buildOptionsSection;
|
||||
};
|
||||
|
||||
using UniqueNode = StackVec<const NEO::Yaml::Node *, 1>;
|
||||
struct ZeInfoSections {
|
||||
@@ -45,91 +62,126 @@ struct ZeInfoKernelSections {
|
||||
UniqueNode inlineSamplersNd;
|
||||
};
|
||||
|
||||
DecodeError decodeZeInfo(ProgramInfo &dst, ConstStringRef zeInfo, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError validateZeInfoVersion(const Elf::ZebinKernelMetadata::Types::Version &receivedZeInfoVersion, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError decodeAndPopulateKernelMiscInfo(size_t kernelMiscInfoOffset, std::vector<NEO::KernelInfo *> &kernelInfos, ConstStringRef metadataString, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
bool isZebin(ArrayRef<const uint8_t> binary);
|
||||
|
||||
bool validateTargetDevice(const TargetDevice &targetDevice, Elf::ELF_IDENTIFIER_CLASS numBits, PRODUCT_FAMILY productFamily, GFXCORE_FAMILY gfxCore, AOT::PRODUCT_CONFIG productConfig, Elf::ZebinTargetFlags targetMetadata);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
bool validateTargetDevice(const Elf::Elf<numBits> &elf, const TargetDevice &targetDevice, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError decodeIntelGTNoteSection(ArrayRef<const uint8_t> intelGTNotesSection, std::vector<Elf::IntelGTNote> &intelGTNotes, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError getIntelGTNotes(const Elf::Elf<numBits> &elf, std::vector<Elf::IntelGTNote> &intelGTNotes, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError extractZebinSections(NEO::Elf::Elf<numBits> &elf, ZebinSections<numBits> &out, std::string &outErrReason, std::string &outWarning);
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
DecodeError validateZebinSectionsCount(const ZebinSections<numBits> §ions, std::string &outErrReason, std::string &outWarning);
|
||||
void extractZeInfoKernelSections(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &kernelNd, ZeInfoKernelSections &outZeInfoKernelSections, ConstStringRef context, std::string &outWarning);
|
||||
DecodeError validateZeInfoKernelSectionsCount(const ZeInfoKernelSections &outZeInfoKernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
template <typename T>
|
||||
bool readEnumChecked(ConstStringRef enumString, T &outValue, ConstStringRef kernelName, std::string &outErrReason);
|
||||
template <typename T>
|
||||
bool readZeInfoEnumChecked(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node, T &outValue, ConstStringRef kernelName, std::string &outErrReason);
|
||||
|
||||
using ZeInfoGlobalHostAccessTables = StackVec<Types::GlobalHostAccessTable::globalHostAccessTableT, 32>;
|
||||
using ZeInfoGlobalHostAccessTables = StackVec<NEO::Elf::ZebinKernelMetadata::Types::GlobalHostAccessTable::globalHostAccessTableT, 32>;
|
||||
DecodeError readZeInfoGlobalHostAceessTable(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node,
|
||||
ZeInfoGlobalHostAccessTables &outDeviceNameToHostTable,
|
||||
ConstStringRef context,
|
||||
std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError populateZeInfoVersion(Types::Version &dst, ConstStringRef &versionStr, std::string &outErrReason);
|
||||
DecodeError validateZeInfoVersion(const Types::Version &receivedZeInfoVersion, std::string &outErrReason, std::string &outWarning);
|
||||
NEO::DecodeError readZeInfoVersionFromZeInfo(NEO::Elf::ZebinKernelMetadata::Types::Version &dst,
|
||||
NEO::Yaml::YamlParser &yamlParser, const NEO::Yaml::Node &versionNd, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError populateExternalFunctionsMetadata(NEO::ProgramInfo &dst, NEO::Yaml::YamlParser &yamlParser, const NEO::Yaml::Node &functionNd, std::string &outErrReason, std::string &outWarning);
|
||||
NEO::DecodeError populateZeInfoVersion(NEO::Elf::ZebinKernelMetadata::Types::Version &dst, ConstStringRef &versionStr, std::string &outErrReason);
|
||||
|
||||
NEO::DecodeError populateExternalFunctionsMetadata(NEO::ProgramInfo &dst, NEO::Yaml::YamlParser &yamlParser, const NEO::Yaml::Node &functionNd, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
NEO::DecodeError decodeZebin(ProgramInfo &dst, NEO::Elf::Elf<numBits> &elf, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ArrayRef<const uint8_t> getKernelHeap(ConstStringRef &kernelName, Elf::Elf<numBits> &elf, const ZebinSections<numBits> &zebinSections);
|
||||
|
||||
template <Elf::ELF_IDENTIFIER_CLASS numBits>
|
||||
ArrayRef<const uint8_t> getKernelGtpinInfo(ConstStringRef &kernelName, Elf::Elf<numBits> &elf, const ZebinSections<numBits> &zebinSections);
|
||||
|
||||
NEO::DecodeError decodeZeInfo(ProgramInfo &dst, ConstStringRef zeInfo, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
void setKernelMiscInfoPosition(ConstStringRef metadata, NEO::ProgramInfo &dst);
|
||||
|
||||
using KernelMiscArgInfos = StackVec<NEO::Elf::ZebinKernelMetadata::Types::Miscellaneous::KernelArgMiscInfoT, 32>;
|
||||
NEO::DecodeError readKernelMiscArgumentInfos(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node, KernelMiscArgInfos &kernelMiscArgInfosVec, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
void populateKernelMiscInfo(KernelDescriptor &dst, KernelMiscArgInfos &kernelMiscArgInfosVec, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
NEO::DecodeError decodeAndPopulateKernelMiscInfo(size_t kernelMiscInfoOffset, std::vector<NEO::KernelInfo *> &kernelInfos, ConstStringRef metadataString, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
ConstStringRef extractZeInfoMetadataStringFromZebin(const ArrayRef<const uint8_t> zebin, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError decodeZeInfoVersion(Yaml::YamlParser &parser, const ZeInfoSections &zeInfoSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoVersionFromZeInfo(Types::Version &dst,
|
||||
NEO::Yaml::YamlParser &yamlParser, const NEO::Yaml::Node &versionNd, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError decodeZeInfoGlobalHostAccessTable(ProgramInfo &dst, Yaml::YamlParser &parser, const ZeInfoSections &zeInfoSections, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError decodeZeInfoFunctions(ProgramInfo &dst, Yaml::YamlParser &parser, const ZeInfoSections &zeInfoSections, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError decodeZeInfoKernels(ProgramInfo &dst, Yaml::YamlParser &parser, const ZeInfoSections &zeInfoSections, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
DecodeError decodeZeInfoKernelEntry(KernelDescriptor &dst, Yaml::YamlParser &yamlParser, const Yaml::Node &kernelNd, uint32_t grfSize, uint32_t minScratchSpaceSize, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
using KernelExecutionEnvBaseT = Types::Kernel::ExecutionEnv::ExecutionEnvBaseT;
|
||||
using KernelExecutionEnvBaseT = Elf::ZebinKernelMetadata::Types::Kernel::ExecutionEnv::ExecutionEnvBaseT;
|
||||
DecodeError decodeZeInfoKernelExecutionEnvironment(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoExecutionEnvironment(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelExecutionEnvBaseT &outExecEnv, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
void populateKernelExecutionEnvironment(KernelDescriptor &dst, const KernelExecutionEnvBaseT &execEnv);
|
||||
|
||||
using KernelAttributesBaseT = Types::Kernel::Attributes::AttributesBaseT;
|
||||
using KernelAttributesBaseT = Elf::ZebinKernelMetadata::Types::Kernel::Attributes::AttributesBaseT;
|
||||
DecodeError decodeZeInfoKernelUserAttributes(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoAttributes(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelAttributesBaseT &outAttributes, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
void populateKernelSourceAttributes(NEO::KernelDescriptor &dst, const KernelAttributesBaseT &attributes);
|
||||
|
||||
using KernelDebugEnvBaseT = Types::Kernel::DebugEnv::DebugEnvBaseT;
|
||||
using KernelDebugEnvBaseT = Elf::ZebinKernelMetadata::Types::Kernel::DebugEnv::DebugEnvBaseT;
|
||||
DecodeError decodeZeInfoKernelDebugEnvironment(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoDebugEnvironment(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelDebugEnvBaseT &outDebugEnv, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
void populateKernelDebugEnvironment(NEO::KernelDescriptor &dst, const KernelDebugEnvBaseT &debugEnv);
|
||||
|
||||
using KernelPerThreadPayloadArgBaseT = Types::Kernel::PerThreadPayloadArgument::PerThreadPayloadArgumentBaseT;
|
||||
using KernelPerThreadPayloadArgBaseT = Elf::ZebinKernelMetadata::Types::Kernel::PerThreadPayloadArgument::PerThreadPayloadArgumentBaseT;
|
||||
using KernelPerThreadPayloadArguments = StackVec<KernelPerThreadPayloadArgBaseT, 1>;
|
||||
DecodeError decodeZeInfoKernelPerThreadPayloadArguments(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, const uint32_t grfSize, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoPerThreadPayloadArguments(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelPerThreadPayloadArguments &outPerThreadPayloadArguments, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError populateKernelPerThreadPayloadArgument(KernelDescriptor &dst, const KernelPerThreadPayloadArgBaseT &src, const uint32_t grfSize, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
using KernelPayloadArgBaseT = Types::Kernel::PayloadArgument::PayloadArgumentBaseT;
|
||||
using KernelPayloadArgBaseT = NEO::Elf::ZebinKernelMetadata::Types::Kernel::PayloadArgument::PayloadArgumentBaseT;
|
||||
using KernelPayloadArguments = StackVec<KernelPayloadArgBaseT, 32>;
|
||||
DecodeError decodeZeInfoKernelPayloadArguments(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoPayloadArguments(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelPayloadArguments &outPayloadArguments, int32_t &outMaxPayloadArgumentIndex, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError populateKernelPayloadArgument(NEO::KernelDescriptor &dst, const KernelPayloadArgBaseT &src, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
using KernelInlineSamplerBaseT = Types::Kernel::InlineSamplers::InlineSamplerBaseT;
|
||||
using KernelInlineSamplerBaseT = Elf::ZebinKernelMetadata::Types::Kernel::InlineSamplers::InlineSamplerBaseT;
|
||||
using KernelInlineSamplers = StackVec<KernelInlineSamplerBaseT, 4>;
|
||||
DecodeError decodeZeInfoKernelInlineSamplers(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoInlineSamplers(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelInlineSamplers &outInlineSamplers, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError populateKernelInlineSampler(KernelDescriptor &dst, const KernelInlineSamplerBaseT &src, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
using KernelPerThreadMemoryBufferBaseT = Types::Kernel::PerThreadMemoryBuffer::PerThreadMemoryBufferBaseT;
|
||||
using KernelPerThreadMemoryBufferBaseT = Elf::ZebinKernelMetadata::Types::Kernel::PerThreadMemoryBuffer::PerThreadMemoryBufferBaseT;
|
||||
using KernelPerThreadMemoryBuffers = StackVec<KernelPerThreadMemoryBufferBaseT, 8>;
|
||||
DecodeError decodeZeInfoKernelPerThreadMemoryBuffers(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, const uint32_t minScratchSpaceSize, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoPerThreadMemoryBuffers(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelPerThreadMemoryBuffers &outPerThreadMemoryBuffers, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError populateKernelPerThreadMemoryBuffer(KernelDescriptor &dst, const KernelPerThreadMemoryBufferBaseT &src, const uint32_t minScratchSpaceSize, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
using KernelExperimentalPropertiesBaseT = Types::Kernel::ExecutionEnv::ExperimentalPropertiesBaseT;
|
||||
using KernelExperimentalPropertiesBaseT = Elf::ZebinKernelMetadata::Types::Kernel::ExecutionEnv::ExperimentalPropertiesBaseT;
|
||||
DecodeError decodeZeInfoKernelExperimentalProperties(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoExperimentalProperties(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelExperimentalPropertiesBaseT &outExperimentalProperties, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
void populateKernelExperimentalProperties(KernelDescriptor &dst, const KernelExperimentalPropertiesBaseT &experimentalProperties);
|
||||
|
||||
using KernelBindingTableEntryBaseT = Types::Kernel::BindingTableEntry::BindingTableEntryBaseT;
|
||||
using KernelBindingTableEntryBaseT = Elf::ZebinKernelMetadata::Types::Kernel::BindingTableEntry::BindingTableEntryBaseT;
|
||||
using KernelBindingTableEntries = StackVec<KernelBindingTableEntryBaseT, 32>;
|
||||
DecodeError decodeZeInfoKernelBindingTableEntries(KernelDescriptor &dst, Yaml::YamlParser &parser, const ZeInfoKernelSections &kernelSections, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError readZeInfoBindingTableIndices(const Yaml::YamlParser &parser, const Yaml::Node &node, KernelBindingTableEntries &outBindingTableIndices, ConstStringRef context, std::string &outErrReason, std::string &outWarning);
|
||||
DecodeError populateKernelBindingTableIndicies(KernelDescriptor &dst, const KernelBindingTableEntries &btEntries, std::string &outErrReason);
|
||||
|
||||
using KernelMiscArgInfos = StackVec<Types::Miscellaneous::KernelArgMiscInfoT, 32>;
|
||||
DecodeError readKernelMiscArgumentInfos(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node, KernelMiscArgInfos &kernelMiscArgInfosVec, std::string &outErrReason, std::string &outWarning);
|
||||
void populateKernelMiscInfo(KernelDescriptor &dst, KernelMiscArgInfos &kernelMiscArgInfosVec, std::string &outErrReason, std::string &outWarning);
|
||||
|
||||
void generateSSHWithBindingTable(KernelDescriptor &dst);
|
||||
void generateDSH(KernelDescriptor &dst);
|
||||
} // namespace Zebin::ZeInfo
|
||||
|
||||
} // namespace NEO
|
||||
} // namespace NEO
|
||||
Reference in New Issue
Block a user