Danylo Lytovchenko
395 строки
22 KiB
C++
395 строки
22 KiB
C++
/* Copyright (c) 2021 - 2021 Advanced Micro Devices, Inc.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE. */
|
|
|
|
#pragma once
|
|
|
|
#include <mutex>
|
|
#if defined(WITH_COMPILER_LIB)
|
|
#include "top.hpp"
|
|
#include "acl.h"
|
|
|
|
#ifndef ACL_API_ENTRY
|
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
|
#define ACL_API_ENTRY __stdcall
|
|
#else
|
|
#define ACL_API_ENTRY
|
|
#endif
|
|
#endif
|
|
|
|
namespace amd {
|
|
typedef aclCompiler*(ACL_API_ENTRY* t_aclCompilerInit)(aclCompilerOptions* opts,
|
|
acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclCompilerFini)(aclCompiler* cl);
|
|
typedef aclCLVersion(ACL_API_ENTRY* t_aclCompilerVersion)(aclCompiler* cl, acl_error* error_code);
|
|
typedef uint32_t(ACL_API_ENTRY* t_aclVersionSize)(aclCLVersion num, acl_error* error_code);
|
|
typedef const char*(ACL_API_ENTRY* t_aclGetErrorString)(acl_error error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclGetArchInfo)(const char** arch_names, size_t* arch_size);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclGetDeviceInfo)(const char* arch, const char** names,
|
|
size_t* device_size);
|
|
typedef aclTargetInfo(ACL_API_ENTRY* t_aclGetTargetInfo)(const char* arch, const char* device,
|
|
acl_error* error_code);
|
|
typedef aclTargetInfo(ACL_API_ENTRY* t_aclGetTargetInfoFromChipID)(const char* arch,
|
|
const uint32_t chip_id,
|
|
acl_error* error_code);
|
|
typedef const char*(ACL_API_ENTRY* t_aclGetArchitecture)(const aclTargetInfo& target);
|
|
typedef const uint64_t(ACL_API_ENTRY* t_aclGetChipOptions)(const aclTargetInfo& target);
|
|
typedef const char*(ACL_API_ENTRY* t_aclGetFamily)(const aclTargetInfo& target);
|
|
typedef const char*(ACL_API_ENTRY* t_aclGetChip)(const aclTargetInfo& target);
|
|
typedef aclBinary*(ACL_API_ENTRY* t_aclBinaryInit)(size_t struct_version,
|
|
const aclTargetInfo* target,
|
|
const aclBinaryOptions* options,
|
|
acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclBinaryFini)(aclBinary* bin);
|
|
typedef aclBinary*(ACL_API_ENTRY* t_aclReadFromFile)(const char* str, acl_error* error_code);
|
|
typedef aclBinary*(ACL_API_ENTRY* t_aclReadFromMem)(const void* mem, size_t size,
|
|
acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclWriteToFile)(aclBinary* bin, const char* str);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclWriteToMem)(aclBinary* bin, void** mem, size_t* size);
|
|
typedef aclBinary*(ACL_API_ENTRY* t_aclCreateFromBinary)(const aclBinary* binary,
|
|
aclBIFVersion version);
|
|
typedef aclBIFVersion(ACL_API_ENTRY* t_aclBinaryVersion)(const aclBinary* binary);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclInsertSection)(aclCompiler* cl, aclBinary* binary,
|
|
const void* data, size_t data_size,
|
|
aclSections id);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclInsertSymbol)(aclCompiler* cl, aclBinary* binary,
|
|
const void* data, size_t data_size,
|
|
aclSections id, const char* symbol);
|
|
typedef const void*(ACL_API_ENTRY* t_aclExtractSection)(aclCompiler* cl, const aclBinary* binary,
|
|
size_t* size, aclSections id,
|
|
acl_error* error_code);
|
|
typedef const void*(ACL_API_ENTRY* t_aclExtractSymbol)(aclCompiler* cl, const aclBinary* binary,
|
|
size_t* size, aclSections id,
|
|
const char* symbol, acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclRemoveSection)(aclCompiler* cl, aclBinary* binary,
|
|
aclSections id);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclRemoveSymbol)(aclCompiler* cl, aclBinary* binary,
|
|
aclSections id, const char* symbol);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclQueryInfo)(aclCompiler* cl, const aclBinary* binary,
|
|
aclQueryType query, const char* kernel,
|
|
void* data_ptr, size_t* ptr_size);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclDbgAddArgument)(aclCompiler* cl, aclBinary* binary,
|
|
const char* kernel, const char* name,
|
|
bool byVal);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclDbgRemoveArgument)(aclCompiler* cl, aclBinary* binary,
|
|
const char* kernel, const char* name);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclCompile)(aclCompiler* cl, aclBinary* bin, const char* options,
|
|
aclType from, aclType to,
|
|
aclLogFunction compile_callback);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclLink)(aclCompiler* cl, aclBinary* src_bin,
|
|
unsigned int num_libs, aclBinary** libs,
|
|
aclType link_mode, const char* options,
|
|
aclLogFunction link_callback);
|
|
typedef const char*(ACL_API_ENTRY* t_aclGetCompilerLog)(aclCompiler* cl);
|
|
typedef const void*(ACL_API_ENTRY* t_aclRetrieveType)(aclCompiler* cl, const aclBinary* bin,
|
|
const char* name, size_t* data_size,
|
|
aclType type, acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclSetType)(aclCompiler* cl, aclBinary* bin, const char* name,
|
|
aclType type, const void* data, size_t size);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclConvertType)(aclCompiler* cl, aclBinary* bin,
|
|
const char* name, aclType type);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclDisassemble)(aclCompiler* cl, aclBinary* bin,
|
|
const char* kernel,
|
|
aclLogFunction disasm_callback);
|
|
typedef const void*(ACL_API_ENTRY* t_aclGetDeviceBinary)(aclCompiler* cl, const aclBinary* bin,
|
|
const char* kernel, size_t* size,
|
|
acl_error* error_code);
|
|
typedef bool(ACL_API_ENTRY* t_aclValidateBinaryImage)(const void* binary, size_t length,
|
|
unsigned type);
|
|
typedef aclJITObjectImage(ACL_API_ENTRY* t_aclJITObjectImageCreate)(aclCompiler* cl,
|
|
const void* buffer,
|
|
size_t length, aclBinary* bin,
|
|
acl_error* error_code);
|
|
typedef aclJITObjectImage(ACL_API_ENTRY* t_aclJITObjectImageCopy)(aclCompiler* cl,
|
|
const void* buffer, size_t length,
|
|
acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclJITObjectImageDestroy)(aclCompiler* cl,
|
|
aclJITObjectImage buffer);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclJITObjectImageFinalize)(aclCompiler* cl,
|
|
aclJITObjectImage image);
|
|
typedef size_t(ACL_API_ENTRY* t_aclJITObjectImageSize)(aclCompiler* cl, aclJITObjectImage image,
|
|
acl_error* error_code);
|
|
typedef const char*(ACL_API_ENTRY* t_aclJITObjectImageData)(aclCompiler* cl,
|
|
aclJITObjectImage image,
|
|
acl_error* error_code);
|
|
typedef size_t(ACL_API_ENTRY* t_aclJITObjectImageGetGlobalsSize)(aclCompiler* cl,
|
|
aclJITObjectImage image,
|
|
acl_error* error_code);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclJITObjectImageIterateSymbols)(aclCompiler* cl,
|
|
aclJITObjectImage image,
|
|
aclJITSymbolCallback callback,
|
|
void* data);
|
|
typedef void(ACL_API_ENTRY* t_aclDumpBinary)(const aclBinary* bin);
|
|
typedef void(ACL_API_ENTRY* t_aclGetKstatsSI)(const void* shader, aclKernelStats& kstats);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclInsertKernelStatistics)(aclCompiler* cl, aclBinary* bin);
|
|
typedef acl_error(ACL_API_ENTRY* t_aclFreeMem)(aclBinary* bin, void* mem);
|
|
|
|
struct HsailEntryPoints {
|
|
void* handle;
|
|
t_aclCompilerInit aclCompilerInit;
|
|
t_aclCompilerFini aclCompilerFini;
|
|
t_aclCompilerVersion aclCompilerVersion;
|
|
t_aclVersionSize aclVersionSize;
|
|
t_aclGetErrorString aclGetErrorString;
|
|
t_aclGetArchInfo aclGetArchInfo;
|
|
t_aclGetDeviceInfo aclGetDeviceInfo;
|
|
t_aclGetTargetInfo aclGetTargetInfo;
|
|
t_aclGetTargetInfoFromChipID aclGetTargetInfoFromChipID;
|
|
t_aclGetArchitecture aclGetArchitecture;
|
|
t_aclGetChipOptions aclGetChipOptions;
|
|
t_aclGetFamily aclGetFamily;
|
|
t_aclGetChip aclGetChip;
|
|
t_aclBinaryInit aclBinaryInit;
|
|
t_aclBinaryFini aclBinaryFini;
|
|
t_aclReadFromFile aclReadFromFile;
|
|
t_aclReadFromMem aclReadFromMem;
|
|
t_aclWriteToFile aclWriteToFile;
|
|
t_aclWriteToMem aclWriteToMem;
|
|
t_aclCreateFromBinary aclCreateFromBinary;
|
|
t_aclBinaryVersion aclBinaryVersion;
|
|
t_aclInsertSection aclInsertSection;
|
|
t_aclInsertSymbol aclInsertSymbol;
|
|
t_aclExtractSection aclExtractSection;
|
|
t_aclExtractSymbol aclExtractSymbol;
|
|
t_aclRemoveSection aclRemoveSection;
|
|
t_aclRemoveSymbol aclRemoveSymbol;
|
|
t_aclQueryInfo aclQueryInfo;
|
|
t_aclDbgAddArgument aclDbgAddArgument;
|
|
t_aclDbgRemoveArgument aclDbgRemoveArgument;
|
|
t_aclCompile aclCompile;
|
|
t_aclLink aclLink;
|
|
t_aclGetCompilerLog aclGetCompilerLog;
|
|
t_aclRetrieveType aclRetrieveType;
|
|
t_aclSetType aclSetType;
|
|
t_aclConvertType aclConvertType;
|
|
t_aclDisassemble aclDisassemble;
|
|
t_aclGetDeviceBinary aclGetDeviceBinary;
|
|
t_aclValidateBinaryImage aclValidateBinaryImage;
|
|
t_aclJITObjectImageCreate aclJITObjectImageCreate;
|
|
t_aclJITObjectImageCopy aclJITObjectImageCopy;
|
|
t_aclJITObjectImageDestroy aclJITObjectImageDestroy;
|
|
t_aclJITObjectImageFinalize aclJITObjectImageFinalize;
|
|
t_aclJITObjectImageSize aclJITObjectImageSize;
|
|
t_aclJITObjectImageData aclJITObjectImageData;
|
|
t_aclJITObjectImageGetGlobalsSize aclJITObjectImageGetGlobalsSize;
|
|
t_aclJITObjectImageIterateSymbols aclJITObjectImageIterateSymbols;
|
|
t_aclDumpBinary aclDumpBinary;
|
|
t_aclGetKstatsSI aclGetKstatsSI;
|
|
t_aclInsertKernelStatistics aclInsertKernelStatistics;
|
|
t_aclFreeMem aclFreeMem;
|
|
};
|
|
|
|
#ifdef HSAIL_DYN_DLL
|
|
#define HSAIL_DYN(NAME) cep_.NAME
|
|
#define GET_HSAIL_SYMBOL(NAME) \
|
|
cep_.NAME = reinterpret_cast<t_##NAME>(Os::getSymbol(cep_.handle, #NAME)); \
|
|
if (nullptr == cep_.NAME) { \
|
|
return false; \
|
|
}
|
|
#else
|
|
#define HSAIL_DYN(NAME) NAME
|
|
#define GET_HSAIL_SYMBOL(NAME)
|
|
#endif
|
|
|
|
class Hsail : public amd::AllStatic {
|
|
public:
|
|
static std::once_flag initialized;
|
|
|
|
static bool LoadLib();
|
|
|
|
static bool IsReady() { return is_ready_; }
|
|
|
|
static aclCompiler* CompilerInit(aclCompilerOptions* opts, acl_error* error_code) {
|
|
return HSAIL_DYN(aclCompilerInit)(opts, error_code);
|
|
}
|
|
static acl_error CompilerFini(aclCompiler* cl) { return HSAIL_DYN(aclCompilerFini)(cl); }
|
|
static aclCLVersion CompilerVersion(aclCompiler* cl, acl_error* error_code) {
|
|
return HSAIL_DYN(aclCompilerVersion)(cl, error_code);
|
|
}
|
|
static uint32_t VersionSize(aclCLVersion num, acl_error* error_code) {
|
|
return HSAIL_DYN(aclVersionSize)(num, error_code);
|
|
}
|
|
static const char* GetErrorString(acl_error error_code) {
|
|
return HSAIL_DYN(aclGetErrorString)(error_code);
|
|
}
|
|
static acl_error GetArchInfo(const char** arch_names, size_t* arch_size) {
|
|
return HSAIL_DYN(aclGetArchInfo)(arch_names, arch_size);
|
|
}
|
|
static acl_error GetDeviceInfo(const char* arch, const char** names, size_t* device_size) {
|
|
return HSAIL_DYN(aclGetDeviceInfo)(arch, names, device_size);
|
|
}
|
|
static aclTargetInfo GetTargetInfo(const char* arch, const char* device, acl_error* error_code) {
|
|
return HSAIL_DYN(aclGetTargetInfo)(arch, device, error_code);
|
|
}
|
|
static aclTargetInfo GetTargetInfoFromChipID(const char* arch, const uint32_t chip_id,
|
|
acl_error* error_code) {
|
|
return HSAIL_DYN(aclGetTargetInfoFromChipID)(arch, chip_id, error_code);
|
|
}
|
|
static const char* GetArchitecture(const aclTargetInfo& target) {
|
|
return HSAIL_DYN(aclGetArchitecture)(target);
|
|
}
|
|
static uint64_t GetChipOptions(const aclTargetInfo& target) {
|
|
return HSAIL_DYN(aclGetChipOptions)(target);
|
|
}
|
|
static const char* GetFamily(const aclTargetInfo& target) {
|
|
return HSAIL_DYN(aclGetFamily)(target);
|
|
}
|
|
static const char* GetChip(const aclTargetInfo& target) { return HSAIL_DYN(aclGetChip)(target); }
|
|
static aclBinary* BinaryInit(size_t struct_version, const aclTargetInfo* target,
|
|
const aclBinaryOptions* options, acl_error* error_code) {
|
|
return HSAIL_DYN(aclBinaryInit)(struct_version, target, options, error_code);
|
|
}
|
|
static acl_error BinaryFini(aclBinary* bin) { return HSAIL_DYN(aclBinaryFini)(bin); }
|
|
static aclBinary* ReadFromFile(const char* str, acl_error* error_code) {
|
|
return HSAIL_DYN(aclReadFromFile)(str, error_code);
|
|
}
|
|
static aclBinary* ReadFromMem(const void* mem, size_t size, acl_error* error_code) {
|
|
return HSAIL_DYN(aclReadFromMem)(mem, size, error_code);
|
|
}
|
|
static acl_error WriteToFile(aclBinary* bin, const char* str) {
|
|
return HSAIL_DYN(aclWriteToFile)(bin, str);
|
|
}
|
|
static acl_error WriteToMem(aclBinary* bin, void** mem, size_t* size) {
|
|
return HSAIL_DYN(aclWriteToMem)(bin, mem, size);
|
|
}
|
|
static aclBinary* CreateFromBinary(const aclBinary* binary, aclBIFVersion version) {
|
|
return HSAIL_DYN(aclCreateFromBinary)(binary, version);
|
|
}
|
|
static aclBIFVersion BinaryVersion(const aclBinary* binary) {
|
|
return HSAIL_DYN(aclBinaryVersion)(binary);
|
|
}
|
|
static acl_error InsertSection(aclCompiler* cl, aclBinary* binary, const void* data,
|
|
size_t data_size, aclSections id) {
|
|
return HSAIL_DYN(aclInsertSection)(cl, binary, data, data_size, id);
|
|
}
|
|
static const acl_error InsertSymbol(aclCompiler* cl, aclBinary* binary, const void* data,
|
|
size_t data_size, aclSections id, const char* symbol) {
|
|
return HSAIL_DYN(aclInsertSymbol)(cl, binary, data, data_size, id, symbol);
|
|
}
|
|
static const void* ExtractSection(aclCompiler* cl, const aclBinary* binary, size_t* size,
|
|
aclSections id, acl_error* error_code) {
|
|
return HSAIL_DYN(aclExtractSection)(cl, binary, size, id, error_code);
|
|
}
|
|
static const void* ExtractSymbol(aclCompiler* cl, const aclBinary* binary, size_t* size,
|
|
aclSections id, const char* symbol, acl_error* error_code) {
|
|
return HSAIL_DYN(aclExtractSymbol)(cl, binary, size, id, symbol, error_code);
|
|
}
|
|
static acl_error RemoveSection(aclCompiler* cl, aclBinary* binary, aclSections id) {
|
|
return HSAIL_DYN(aclRemoveSection)(cl, binary, id);
|
|
}
|
|
static acl_error RemoveSymbol(aclCompiler* cl, aclBinary* binary, aclSections id,
|
|
const char* symbol) {
|
|
return HSAIL_DYN(aclRemoveSymbol)(cl, binary, id, symbol);
|
|
}
|
|
static acl_error QueryInfo(aclCompiler* cl, const aclBinary* binary, aclQueryType query,
|
|
const char* kernel, void* data_ptr, size_t* ptr_size) {
|
|
return HSAIL_DYN(aclQueryInfo)(cl, binary, query, kernel, data_ptr, ptr_size);
|
|
}
|
|
static acl_error DbgAddArgument(aclCompiler* cl, aclBinary* binary, const char* kernel,
|
|
const char* name, bool byVal) {
|
|
return HSAIL_DYN(aclDbgAddArgument)(cl, binary, kernel, name, byVal);
|
|
}
|
|
static acl_error DbgRemoveArgument(aclCompiler* cl, aclBinary* binary, const char* kernel,
|
|
const char* name) {
|
|
return HSAIL_DYN(aclDbgRemoveArgument)(cl, binary, kernel, name);
|
|
}
|
|
static acl_error Compile(aclCompiler* cl, aclBinary* bin, const char* options, aclType from,
|
|
aclType to, aclLogFunction compile_callback) {
|
|
return HSAIL_DYN(aclCompile)(cl, bin, options, from, to, compile_callback);
|
|
}
|
|
static acl_error Link(aclCompiler* cl, aclBinary* src_bin, unsigned int num_libs,
|
|
aclBinary** libs, aclType link_mode, const char* options,
|
|
aclLogFunction link_callback) {
|
|
return HSAIL_DYN(aclLink)(cl, src_bin, num_libs, libs, link_mode, options, link_callback);
|
|
}
|
|
static const char* GetCompilerLog(aclCompiler* cl) { return HSAIL_DYN(aclGetCompilerLog)(cl); }
|
|
static const void* RetrieveType(aclCompiler* cl, const aclBinary* bin, const char* name,
|
|
size_t* data_size, aclType type, acl_error* error_code) {
|
|
return HSAIL_DYN(aclRetrieveType)(cl, bin, name, data_size, type, error_code);
|
|
}
|
|
static acl_error SetType(aclCompiler* cl, aclBinary* bin, const char* name, aclType type,
|
|
const void* data, size_t size) {
|
|
return HSAIL_DYN(aclSetType)(cl, bin, name, type, data, size);
|
|
}
|
|
static acl_error ConvertType(aclCompiler* cl, aclBinary* bin, const char* name, aclType type) {
|
|
return HSAIL_DYN(aclConvertType)(cl, bin, name, type);
|
|
}
|
|
static acl_error Disassemble(aclCompiler* cl, aclBinary* bin, const char* kernel,
|
|
aclLogFunction disasm_callback) {
|
|
return HSAIL_DYN(aclDisassemble)(cl, bin, kernel, disasm_callback);
|
|
}
|
|
static const void* GetDeviceBinary(aclCompiler* cl, const aclBinary* bin, const char* kernel,
|
|
size_t* size, acl_error* error_code) {
|
|
return HSAIL_DYN(aclGetDeviceBinary)(cl, bin, kernel, size, error_code);
|
|
}
|
|
static const bool ValidateBinaryImage(const void* binary, size_t length, unsigned type) {
|
|
#if defined(HSAIL_DYN_DLL)
|
|
if (cep_.aclValidateBinaryImage == nullptr) {
|
|
return false;
|
|
}
|
|
#endif // defined(HSAIL_DYN_DLL)
|
|
return HSAIL_DYN(aclValidateBinaryImage)(binary, length, type);
|
|
}
|
|
static aclJITObjectImage JITObjectImageCreate(aclCompiler* cl, const void* buffer, size_t length,
|
|
aclBinary* bin, acl_error* error_code) {
|
|
return HSAIL_DYN(aclJITObjectImageCreate)(cl, buffer, length, bin, error_code);
|
|
}
|
|
static aclJITObjectImage JITObjectImageCopy(aclCompiler* cl, const void* buffer, size_t length,
|
|
acl_error* error_code) {
|
|
return HSAIL_DYN(aclJITObjectImageCopy)(cl, buffer, length, error_code);
|
|
}
|
|
static acl_error JITObjectImageDestroy(aclCompiler* cl, aclJITObjectImage buffer) {
|
|
return HSAIL_DYN(aclJITObjectImageDestroy)(cl, buffer);
|
|
}
|
|
static acl_error JITObjectImageFinalize(aclCompiler* cl, aclJITObjectImage image) {
|
|
return HSAIL_DYN(aclJITObjectImageFinalize)(cl, image);
|
|
}
|
|
static size_t JITObjectImageSize(aclCompiler* cl, aclJITObjectImage image,
|
|
acl_error* error_code) {
|
|
return HSAIL_DYN(aclJITObjectImageSize)(cl, image, error_code);
|
|
}
|
|
static const char* JITObjectImageData(aclCompiler* cl, aclJITObjectImage image,
|
|
acl_error* error_code) {
|
|
return HSAIL_DYN(aclJITObjectImageData)(cl, image, error_code);
|
|
}
|
|
static size_t JITObjectImageGetGlobalsSize(aclCompiler* cl, aclJITObjectImage image,
|
|
acl_error* error_code) {
|
|
return HSAIL_DYN(aclJITObjectImageGetGlobalsSize)(cl, image, error_code);
|
|
}
|
|
static acl_error JITObjectImageIterateSymbols(aclCompiler* cl, aclJITObjectImage image,
|
|
aclJITSymbolCallback callback, void* data) {
|
|
return HSAIL_DYN(aclJITObjectImageIterateSymbols)(cl, image, callback, data);
|
|
}
|
|
static void DumpBinary(const aclBinary* bin) { HSAIL_DYN(aclDumpBinary)(bin); }
|
|
static void GetKstatsSI(const void* shader, aclKernelStats& kstats) {
|
|
return HSAIL_DYN(aclGetKstatsSI)(shader, kstats);
|
|
}
|
|
static acl_error InsertKernelStatistics(aclCompiler* cl, aclBinary* bin) {
|
|
return HSAIL_DYN(aclInsertKernelStatistics)(cl, bin);
|
|
}
|
|
static acl_error FreeMem(aclBinary* bin, void* mem) { return HSAIL_DYN(aclFreeMem)(bin, mem); }
|
|
|
|
private:
|
|
static HsailEntryPoints cep_;
|
|
static bool is_ready_;
|
|
};
|
|
|
|
} // namespace amd
|
|
#endif
|