1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
/*
* Copyright (C) 2020 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/program_info.h"
#include "opencl/source/program/kernel_info.h"
#include "opencl/source/program/kernel_info_from_patchtokens.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);
}
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);
}
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);
}
for (const auto &globalConstantPointerToken : src.programScopeTokens.constantPointer) {
NEO::LinkerInput::RelocationInfo relocInfo = {};
relocInfo.relocationSegment = NEO::SegmentType::GlobalConstants;
relocInfo.offset = readMisalignedUint64(&globalConstantPointerToken->ConstantPointerOffset);
relocInfo.symbolSegment = NEO::SegmentType::GlobalConstants;
if (globalConstantPointerToken->BufferType != iOpenCL::PROGRAM_SCOPE_CONSTANT_BUFFER) {
UNRECOVERABLE_IF(globalConstantPointerToken->BufferType != iOpenCL::PROGRAM_SCOPE_GLOBAL_BUFFER);
relocInfo.symbolSegment = NEO::SegmentType::GlobalVariables;
}
relocInfo.type = NEO::LinkerInput::RelocationInfo::Type::Address;
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.symbolSegment = NEO::SegmentType::GlobalVariables;
if (globalVariablePointerToken->BufferType != iOpenCL::PROGRAM_SCOPE_GLOBAL_BUFFER) {
UNRECOVERABLE_IF(globalVariablePointerToken->BufferType != iOpenCL::PROGRAM_SCOPE_CONSTANT_BUFFER);
relocInfo.symbolSegment = NEO::SegmentType::GlobalConstants;
}
relocInfo.type = NEO::LinkerInput::RelocationInfo::Type::Address;
dst.linkerInput->addDataRelocationInfo(relocInfo);
}
if (src.programScopeTokens.symbolTable != nullptr) {
const auto patch = src.programScopeTokens.symbolTable;
dst.linkerInput->decodeGlobalVariablesSymbolTable(patch + 1, patch->NumEntries);
}
}
} // namespace NEO
|
