German Andryeyev
e0a4e0df0e
Use __stdcall decl to match the library defines Change-Id: Id4178443d5a9bb4e5401d80b3b5d15c7bbea0330
328 строки
19 KiB
C++
328 строки
19 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_;
|
|
};
|
|
|
|
}
|
|
#endif
|