138 lines
6.5 KiB
C++
138 lines
6.5 KiB
C++
/*
|
|
* Copyright (C) 2020-2023 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
*/
|
|
|
|
#include "shared/source/program/program_info_from_patchtokens.h"
|
|
|
|
#include "shared/source/compiler_interface/linker.h"
|
|
#include "shared/source/debug_settings/debug_settings_manager.h"
|
|
#include "shared/source/device_binary_format/patchtokens_decoder.h"
|
|
#include "shared/source/program/kernel_info.h"
|
|
#include "shared/source/program/kernel_info_from_patchtokens.h"
|
|
#include "shared/source/program/program_info.h"
|
|
|
|
#include <RelocationInfo.h>
|
|
|
|
namespace NEO {
|
|
|
|
bool requiresLocalMemoryWindowVA(const PatchTokenBinary::ProgramFromPatchtokens &src) {
|
|
for (const auto &kernel : src.kernels) {
|
|
if (kernel.tokens.crossThreadPayloadArgs.localMemoryStatelessWindowStartAddress) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void populateSingleKernelInfo(ProgramInfo &dst, const PatchTokenBinary::ProgramFromPatchtokens &decodedProgram, uint32_t kernelNum) {
|
|
auto kernelInfo = std::make_unique<KernelInfo>();
|
|
const PatchTokenBinary::KernelFromPatchtokens &decodedKernel = decodedProgram.kernels[kernelNum];
|
|
|
|
NEO::populateKernelInfo(*kernelInfo, decodedKernel, decodedProgram.header->GPUPointerSizeInBytes);
|
|
|
|
if (decodedKernel.tokens.programSymbolTable) {
|
|
dst.prepareLinkerInputStorage();
|
|
dst.linkerInput->decodeExportedFunctionsSymbolTable(decodedKernel.tokens.programSymbolTable + 1, decodedKernel.tokens.programSymbolTable->NumEntries, kernelNum);
|
|
}
|
|
|
|
if (decodedKernel.tokens.programRelocationTable) {
|
|
dst.prepareLinkerInputStorage();
|
|
dst.linkerInput->decodeRelocationTable(decodedKernel.tokens.programRelocationTable + 1, decodedKernel.tokens.programRelocationTable->NumEntries, kernelNum);
|
|
}
|
|
|
|
if (decodedKernel.tokens.hostAccessTable) {
|
|
parseHostAccessTable(dst, decodedKernel.tokens.hostAccessTable);
|
|
}
|
|
|
|
dst.kernelInfos.push_back(kernelInfo.release());
|
|
}
|
|
|
|
void populateProgramInfo(ProgramInfo &dst, const PatchTokenBinary::ProgramFromPatchtokens &src) {
|
|
for (uint32_t i = 0; i < src.kernels.size(); ++i) {
|
|
populateSingleKernelInfo(dst, src, i);
|
|
}
|
|
|
|
if (src.programScopeTokens.allocateConstantMemorySurface.empty() == false) {
|
|
auto surface = src.programScopeTokens.allocateConstantMemorySurface[0];
|
|
dst.globalConstants.size = surface->InlineDataSize;
|
|
dst.globalConstants.initData = NEO::PatchTokenBinary::getInlineData(surface);
|
|
}
|
|
|
|
if (src.programScopeTokens.allocateGlobalMemorySurface.empty() == false) {
|
|
auto surface = src.programScopeTokens.allocateGlobalMemorySurface[0];
|
|
dst.globalVariables.size = surface->InlineDataSize;
|
|
dst.globalVariables.initData = NEO::PatchTokenBinary::getInlineData(surface);
|
|
}
|
|
|
|
constexpr ConstStringRef globalConstantsSymbolName = "globalConstants";
|
|
constexpr ConstStringRef globalVariablesSymbolName = "globalVariables";
|
|
|
|
if (false == (src.programScopeTokens.constantPointer.empty() && src.programScopeTokens.globalPointer.empty() && (src.programScopeTokens.symbolTable == nullptr))) {
|
|
UNRECOVERABLE_IF((src.header->GPUPointerSizeInBytes != 4) && (src.header->GPUPointerSizeInBytes != 8));
|
|
dst.prepareLinkerInputStorage();
|
|
dst.linkerInput->setPointerSize((src.header->GPUPointerSizeInBytes == 4) ? LinkerInput::Traits::PointerSize::Ptr32bit : LinkerInput::Traits::PointerSize::Ptr64bit);
|
|
|
|
if (false == src.programScopeTokens.allocateConstantMemorySurface.empty()) {
|
|
dst.linkerInput->addSymbol(globalConstantsSymbolName.data(), {0U, 8U, SegmentType::globalConstants});
|
|
}
|
|
if (false == src.programScopeTokens.allocateGlobalMemorySurface.empty()) {
|
|
dst.linkerInput->addSymbol(globalVariablesSymbolName.data(), {0U, 8U, SegmentType::globalVariables});
|
|
}
|
|
}
|
|
|
|
for (const auto &globalConstantPointerToken : src.programScopeTokens.constantPointer) {
|
|
NEO::LinkerInput::RelocationInfo relocInfo = {};
|
|
relocInfo.relocationSegment = NEO::SegmentType::globalConstants;
|
|
relocInfo.offset = readMisalignedUint64(&globalConstantPointerToken->ConstantPointerOffset);
|
|
relocInfo.type = NEO::LinkerInput::RelocationInfo::Type::address;
|
|
relocInfo.symbolName = std::string(globalConstantsSymbolName);
|
|
if (iOpenCL::PROGRAM_SCOPE_CONSTANT_BUFFER != globalConstantPointerToken->BufferType) {
|
|
UNRECOVERABLE_IF(iOpenCL::PROGRAM_SCOPE_GLOBAL_BUFFER != globalConstantPointerToken->BufferType);
|
|
relocInfo.symbolName = std::string(globalVariablesSymbolName);
|
|
}
|
|
|
|
dst.linkerInput->addDataRelocationInfo(relocInfo);
|
|
}
|
|
|
|
for (const auto &globalVariablePointerToken : src.programScopeTokens.globalPointer) {
|
|
NEO::LinkerInput::RelocationInfo relocInfo = {};
|
|
relocInfo.relocationSegment = NEO::SegmentType::globalVariables;
|
|
relocInfo.offset = readMisalignedUint64(&globalVariablePointerToken->GlobalPointerOffset);
|
|
relocInfo.type = NEO::LinkerInput::RelocationInfo::Type::address;
|
|
relocInfo.symbolName = std::string(globalVariablesSymbolName);
|
|
if (iOpenCL::PROGRAM_SCOPE_GLOBAL_BUFFER != globalVariablePointerToken->BufferType) {
|
|
UNRECOVERABLE_IF(iOpenCL::PROGRAM_SCOPE_CONSTANT_BUFFER != globalVariablePointerToken->BufferType);
|
|
relocInfo.symbolName = std::string(globalConstantsSymbolName);
|
|
}
|
|
|
|
dst.linkerInput->addDataRelocationInfo(relocInfo);
|
|
}
|
|
|
|
if (src.programScopeTokens.symbolTable != nullptr) {
|
|
const auto patch = src.programScopeTokens.symbolTable;
|
|
dst.linkerInput->decodeGlobalVariablesSymbolTable(patch + 1, patch->NumEntries);
|
|
}
|
|
}
|
|
|
|
void parseHostAccessTable(ProgramInfo &dst, const void *hostAccessTable) {
|
|
hostAccessTable = ptrOffset(hostAccessTable, sizeof(iOpenCL::SPatchItemHeader));
|
|
const uint32_t numEntries = *reinterpret_cast<const uint32_t *>(hostAccessTable);
|
|
hostAccessTable = ptrOffset(hostAccessTable, sizeof(uint32_t));
|
|
auto &deviceToHostNameMap = dst.globalsDeviceToHostNameMap;
|
|
|
|
struct HostAccessTableEntry {
|
|
const char deviceName[vISA::MAX_SYMBOL_NAME_LENGTH];
|
|
const char hostName[vISA::MAX_SYMBOL_NAME_LENGTH];
|
|
};
|
|
ArrayRef<const HostAccessTableEntry> hostAccessTableEntries = {reinterpret_cast<const HostAccessTableEntry *>(hostAccessTable),
|
|
numEntries};
|
|
for (size_t i = 0; i < hostAccessTableEntries.size(); i++) {
|
|
auto &entry = hostAccessTableEntries[i];
|
|
deviceToHostNameMap[entry.deviceName] = entry.hostName;
|
|
}
|
|
}
|
|
} // namespace NEO
|