AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SWDEV-280473 - Fix warnings in combined LC/HSAIL build

Browse Source 
Enabling both LC and HSAIL will cause the DYN macro to be redefined.
Rename it for each compiler to avoid name clashing.

Change-Id: I607f022f37c4d05bef4e3a8070d19bd3659d7bc2


[ROCm/clr commit: b771377665]
This commit is contained in:
Vladislav Sytchenko
2021-04-14 13:24:43 -04:00
parent c585ae92a7
commit 1ec25599c7
2 changed files with 102 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
projects/clr/rocclr/device/comgrctx.hpp
+48 -48
View File
@@ -121,13 +121,13 @@ struct ComgrEntryPoints {
t_amd_comgr_symbol_get_info amd_comgr_symbol_get_info;
};
#ifdef COMGR_DYN_DLL
#define DYN(NAME) cep_.NAME
#ifdef COMGR_DYN_DLL
#define COMGR_DYN(NAME) cep_.NAME
#define GET_COMGR_SYMBOL(NAME) cep_.NAME = \
reinterpret_cast<t_##NAME>(Os::getSymbol(cep_.handle, #NAME)); \
if (nullptr == cep_.NAME) { return false; }
#else
#define DYN(NAME) NAME
#define COMGR_DYN(NAME) NAME
#define GET_COMGR_SYMBOL(NAME)
#endif
@@ -140,139 +140,139 @@ public:
static bool IsReady() { return is_ready_; }
static void get_version(size_t *major, size_t *minor) {
DYN(amd_comgr_get_version)(major, minor);
COMGR_DYN(amd_comgr_get_version)(major, minor);
}
static amd_comgr_status_t status_string(amd_comgr_status_t status, const char ** status_string) {
return DYN(amd_comgr_status_string)(status, status_string);
return COMGR_DYN(amd_comgr_status_string)(status, status_string);
}
static amd_comgr_status_t get_isa_count(size_t *count) {
return DYN(amd_comgr_get_isa_count)(count);
return COMGR_DYN(amd_comgr_get_isa_count)(count);
}
static amd_comgr_status_t get_isa_name(size_t index, const char **isa_name) {
return DYN(amd_comgr_get_isa_name)(index, isa_name);
return COMGR_DYN(amd_comgr_get_isa_name)(index, isa_name);
}
static amd_comgr_status_t get_isa_metadata(const char *isa_name, amd_comgr_metadata_node_t *metadata) {
return DYN(amd_comgr_get_isa_metadata)(isa_name, metadata);
return COMGR_DYN(amd_comgr_get_isa_metadata)(isa_name, metadata);
}
static amd_comgr_status_t create_data(amd_comgr_data_kind_t kind, amd_comgr_data_t *data) {
return DYN(amd_comgr_create_data)(kind, data);
return COMGR_DYN(amd_comgr_create_data)(kind, data);
}
static amd_comgr_status_t release_data(amd_comgr_data_t data) {
return DYN(amd_comgr_release_data)(data);
return COMGR_DYN(amd_comgr_release_data)(data);
}
static amd_comgr_status_t get_data_kind(amd_comgr_data_t data, amd_comgr_data_kind_t *kind) {
return DYN(amd_comgr_get_data_kind)(data, kind);
return COMGR_DYN(amd_comgr_get_data_kind)(data, kind);
}
static amd_comgr_status_t set_data(amd_comgr_data_t data, size_t size, const char* bytes) {
return DYN(amd_comgr_set_data)(data, size, bytes);
return COMGR_DYN(amd_comgr_set_data)(data, size, bytes);
}
static amd_comgr_status_t set_data_name(amd_comgr_data_t data, const char* name) {
return DYN(amd_comgr_set_data_name)(data, name);
return COMGR_DYN(amd_comgr_set_data_name)(data, name);
}
static amd_comgr_status_t get_data(amd_comgr_data_t data, size_t *size, char *bytes) {
return DYN(amd_comgr_get_data)(data, size, bytes);
return COMGR_DYN(amd_comgr_get_data)(data, size, bytes);
}
static amd_comgr_status_t get_data_name(amd_comgr_data_t data, size_t *size, char *name) {
return DYN(amd_comgr_get_data_name)(data, size, name);
return COMGR_DYN(amd_comgr_get_data_name)(data, size, name);
}
static amd_comgr_status_t get_data_isa_name(amd_comgr_data_t data, size_t *size, char *isa_name) {
return DYN(amd_comgr_get_data_isa_name)(data, size, isa_name);
return COMGR_DYN(amd_comgr_get_data_isa_name)(data, size, isa_name);
}
static amd_comgr_status_t get_data_metadata(amd_comgr_data_t data, amd_comgr_metadata_node_t *metadata) {
return DYN(amd_comgr_get_data_metadata)(data, metadata);
return COMGR_DYN(amd_comgr_get_data_metadata)(data, metadata);
}
static amd_comgr_status_t destroy_metadata(amd_comgr_metadata_node_t metadata) {
return DYN(amd_comgr_destroy_metadata)(metadata);
return COMGR_DYN(amd_comgr_destroy_metadata)(metadata);
}
static amd_comgr_status_t create_data_set(amd_comgr_data_set_t *data_set) {
return DYN(amd_comgr_create_data_set)(data_set);
return COMGR_DYN(amd_comgr_create_data_set)(data_set);
}
static amd_comgr_status_t destroy_data_set(amd_comgr_data_set_t data_set) {
return DYN(amd_comgr_destroy_data_set)(data_set);
return COMGR_DYN(amd_comgr_destroy_data_set)(data_set);
}
static amd_comgr_status_t data_set_add(amd_comgr_data_set_t data_set, amd_comgr_data_t data) {
return DYN(amd_comgr_data_set_add)(data_set, data);
return COMGR_DYN(amd_comgr_data_set_add)(data_set, data);
}
static amd_comgr_status_t data_set_remove(amd_comgr_data_set_t data_set, amd_comgr_data_kind_t data_kind) {
return DYN(amd_comgr_data_set_remove)(data_set, data_kind);
return COMGR_DYN(amd_comgr_data_set_remove)(data_set, data_kind);
}
static amd_comgr_status_t action_data_count(amd_comgr_data_set_t data_set, amd_comgr_data_kind_t data_kind, size_t *count) {
return DYN(amd_comgr_action_data_count)(data_set, data_kind, count);
return COMGR_DYN(amd_comgr_action_data_count)(data_set, data_kind, count);
}
static amd_comgr_status_t action_data_get_data(amd_comgr_data_set_t data_set, amd_comgr_data_kind_t data_kind, size_t index, amd_comgr_data_t *data) {
return DYN(amd_comgr_action_data_get_data)(data_set, data_kind, index, data);
return COMGR_DYN(amd_comgr_action_data_get_data)(data_set, data_kind, index, data);
}
static amd_comgr_status_t create_action_info(amd_comgr_action_info_t *action_info) {
return DYN(amd_comgr_create_action_info)(action_info);
return COMGR_DYN(amd_comgr_create_action_info)(action_info);
}
static amd_comgr_status_t destroy_action_info(amd_comgr_action_info_t action_info) {
return DYN(amd_comgr_destroy_action_info)(action_info);
return COMGR_DYN(amd_comgr_destroy_action_info)(action_info);
}
static amd_comgr_status_t action_info_set_isa_name(amd_comgr_action_info_t action_info, const char *isa_name) {
return DYN(amd_comgr_action_info_set_isa_name)(action_info, isa_name);
return COMGR_DYN(amd_comgr_action_info_set_isa_name)(action_info, isa_name);
}
static amd_comgr_status_t action_info_get_isa_name(amd_comgr_action_info_t action_info, size_t *size, char *isa_name) {
return DYN(amd_comgr_action_info_get_isa_name)(action_info, size, isa_name);
return COMGR_DYN(amd_comgr_action_info_get_isa_name)(action_info, size, isa_name);
}
static amd_comgr_status_t action_info_set_language(amd_comgr_action_info_t action_info, amd_comgr_language_t language) {
return DYN(amd_comgr_action_info_set_language)(action_info, language);
return COMGR_DYN(amd_comgr_action_info_set_language)(action_info, language);
}
static amd_comgr_status_t action_info_get_language(amd_comgr_action_info_t action_info, amd_comgr_language_t *language) {
return DYN(amd_comgr_action_info_get_language)(action_info, language);
return COMGR_DYN(amd_comgr_action_info_get_language)(action_info, language);
}
static amd_comgr_status_t action_info_set_option_list(amd_comgr_action_info_t action_info, const char *options[], size_t count) {
return DYN(amd_comgr_action_info_set_option_list)(action_info, options, count);
return COMGR_DYN(amd_comgr_action_info_set_option_list)(action_info, options, count);
}
static amd_comgr_status_t action_info_get_option_list_count(amd_comgr_action_info_t action_info, size_t *count) {
return DYN(amd_comgr_action_info_get_option_list_count)(action_info, count);
return COMGR_DYN(amd_comgr_action_info_get_option_list_count)(action_info, count);
}
static amd_comgr_status_t action_info_get_option_list_item(amd_comgr_action_info_t action_info, size_t index, size_t *size, char *option) {
return DYN(amd_comgr_action_info_get_option_list_item)(action_info, index, size, option);
return COMGR_DYN(amd_comgr_action_info_get_option_list_item)(action_info, index, size, option);
}
static amd_comgr_status_t action_info_set_working_directory_path(amd_comgr_action_info_t action_info, const char *path) {
return DYN(amd_comgr_action_info_set_working_directory_path)(action_info, path);
return COMGR_DYN(amd_comgr_action_info_set_working_directory_path)(action_info, path);
}
static amd_comgr_status_t action_info_get_working_directory_path(amd_comgr_action_info_t action_info, size_t *size, char *path) {
return DYN(amd_comgr_action_info_get_working_directory_path)(action_info, size, path);
return COMGR_DYN(amd_comgr_action_info_get_working_directory_path)(action_info, size, path);
}
static amd_comgr_status_t action_info_set_logging(amd_comgr_action_info_t action_info, bool logging) {
return DYN(amd_comgr_action_info_set_logging)(action_info, logging);
return COMGR_DYN(amd_comgr_action_info_set_logging)(action_info, logging);
}
static amd_comgr_status_t action_info_get_logging(amd_comgr_action_info_t action_info, bool *logging) {
return DYN(amd_comgr_action_info_get_logging)(action_info, logging);
return COMGR_DYN(amd_comgr_action_info_get_logging)(action_info, logging);
}
static amd_comgr_status_t do_action(amd_comgr_action_kind_t kind, amd_comgr_action_info_t info, amd_comgr_data_set_t input, amd_comgr_data_set_t result) {
return DYN(amd_comgr_do_action)(kind, info, input, result);
return COMGR_DYN(amd_comgr_do_action)(kind, info, input, result);
}
static amd_comgr_status_t get_metadata_kind(amd_comgr_metadata_node_t metadata, amd_comgr_metadata_kind_t *kind) {
return DYN(amd_comgr_get_metadata_kind)(metadata, kind);
return COMGR_DYN(amd_comgr_get_metadata_kind)(metadata, kind);
}
static amd_comgr_status_t get_metadata_string(amd_comgr_metadata_node_t metadata, size_t *size, char *string) {
return DYN(amd_comgr_get_metadata_string)(metadata, size, string);
return COMGR_DYN(amd_comgr_get_metadata_string)(metadata, size, string);
}
static amd_comgr_status_t get_metadata_map_size(amd_comgr_metadata_node_t metadata, size_t *size) {
return DYN(amd_comgr_get_metadata_map_size)(metadata, size);
return COMGR_DYN(amd_comgr_get_metadata_map_size)(metadata, size);
}
static amd_comgr_status_t iterate_map_metadata(amd_comgr_metadata_node_t metadata, amd_comgr_status_t(*callback)(amd_comgr_metadata_node_t key, amd_comgr_metadata_node_t value, void *user_data), void *user_data) {
return DYN(amd_comgr_iterate_map_metadata)(metadata, callback, user_data);
return COMGR_DYN(amd_comgr_iterate_map_metadata)(metadata, callback, user_data);
}
static amd_comgr_status_t metadata_lookup(amd_comgr_metadata_node_t metadata, const char *key, amd_comgr_metadata_node_t *value) {
return DYN(amd_comgr_metadata_lookup)(metadata, key, value);
return COMGR_DYN(amd_comgr_metadata_lookup)(metadata, key, value);
}
static amd_comgr_status_t get_metadata_list_size(amd_comgr_metadata_node_t metadata, size_t *size) {
return DYN(amd_comgr_get_metadata_list_size)(metadata, size);
return COMGR_DYN(amd_comgr_get_metadata_list_size)(metadata, size);
}
static amd_comgr_status_t index_list_metadata(amd_comgr_metadata_node_t metadata, size_t index, amd_comgr_metadata_node_t *value) {
return DYN(amd_comgr_index_list_metadata)(metadata, index, value);
return COMGR_DYN(amd_comgr_index_list_metadata)(metadata, index, value);
}
static amd_comgr_status_t iterate_symbols(amd_comgr_data_t data, amd_comgr_status_t(*callback)(amd_comgr_symbol_t symbol, void *user_data), void *user_data) {
return DYN(amd_comgr_iterate_symbols)(data, callback, user_data);
return COMGR_DYN(amd_comgr_iterate_symbols)(data, callback, user_data);
}
static amd_comgr_status_t symbol_lookup(amd_comgr_data_t data, const char *name, amd_comgr_symbol_t *symbol) {
return DYN(amd_comgr_symbol_lookup)(data, name, symbol);
return COMGR_DYN(amd_comgr_symbol_lookup)(data, name, symbol);
}
static amd_comgr_status_t symbol_get_info(amd_comgr_symbol_t symbol, amd_comgr_symbol_info_t attribute, void *value) {
return DYN(amd_comgr_symbol_get_info)(symbol, attribute, value);
return COMGR_DYN(amd_comgr_symbol_get_info)(symbol, attribute, value);
}
private:
projects/clr/rocclr/device/hsailctx.hpp
+54 -54
View File
@@ -133,13 +133,13 @@ struct HsailEntryPoints {
t_aclFreeMem aclFreeMem;
};
#ifdef HSAIL_DYN_DLL
#define DYN(NAME) cep_.NAME
#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 DYN(NAME) NAME
#define HSAIL_DYN(NAME) NAME
#define GET_HSAIL_SYMBOL(NAME)
#endif
@@ -152,157 +152,157 @@ public:
static bool IsReady() { return is_ready_; }
static aclCompiler* CompilerInit(aclCompilerOptions *opts, acl_error *error_code) {
return DYN(aclCompilerInit)(opts, error_code);
return HSAIL_DYN(aclCompilerInit)(opts, error_code);
}
static acl_error CompilerFini(aclCompiler *cl) {
return DYN(aclCompilerFini)(cl);
return HSAIL_DYN(aclCompilerFini)(cl);
}
static aclCLVersion CompilerVersion(aclCompiler *cl, acl_error *error_code) {
return DYN(aclCompilerVersion)(cl, error_code);
return HSAIL_DYN(aclCompilerVersion)(cl, error_code);
}
static uint32_t VersionSize(aclCLVersion num, acl_error *error_code) {
return DYN(aclVersionSize)(num, error_code);
return HSAIL_DYN(aclVersionSize)(num, error_code);
}
static const char* GetErrorString(acl_error error_code) {
return DYN(aclGetErrorString)(error_code);
return HSAIL_DYN(aclGetErrorString)(error_code);
}
static acl_error GetArchInfo(const char** arch_names, size_t *arch_size) {
return DYN(aclGetArchInfo)(arch_names, 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 DYN(aclGetDeviceInfo)(arch, names, device_size);
return HSAIL_DYN(aclGetDeviceInfo)(arch, names, device_size);
}
static aclTargetInfo GetTargetInfo(const char *arch, const char *device, acl_error *error_code) {
return DYN(aclGetTargetInfo)(arch, device, 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 DYN(aclGetTargetInfoFromChipID)(arch, chip_id, error_code);
return HSAIL_DYN(aclGetTargetInfoFromChipID)(arch, chip_id, error_code);
}
static const char* GetArchitecture(const aclTargetInfo &target) {
return DYN(aclGetArchitecture)(target);
return HSAIL_DYN(aclGetArchitecture)(target);
}
static uint64_t GetChipOptions(const aclTargetInfo &target) {
return DYN(aclGetChipOptions)(target);
return HSAIL_DYN(aclGetChipOptions)(target);
}
static const char* GetFamily(const aclTargetInfo &target) {
return DYN(aclGetFamily)(target);
return HSAIL_DYN(aclGetFamily)(target);
}
static const char* GetChip(const aclTargetInfo &target) {
return DYN(aclGetChip)(target);
return HSAIL_DYN(aclGetChip)(target);
}
static aclBinary* BinaryInit(size_t struct_version, const aclTargetInfo *target, const aclBinaryOptions *options, acl_error *error_code) {
return DYN(aclBinaryInit)(struct_version, target, options, error_code);
return HSAIL_DYN(aclBinaryInit)(struct_version, target, options, error_code);
}
static acl_error BinaryFini(aclBinary *bin) {
return DYN(aclBinaryFini)(bin);
return HSAIL_DYN(aclBinaryFini)(bin);
}
static aclBinary* ReadFromFile(const char *str, acl_error *error_code) {
return DYN(aclReadFromFile)(str, error_code);
return HSAIL_DYN(aclReadFromFile)(str, error_code);
}
static aclBinary* ReadFromMem(const void *mem, size_t size, acl_error *error_code) {
return DYN(aclReadFromMem)(mem, size, error_code);
return HSAIL_DYN(aclReadFromMem)(mem, size, error_code);
}
static acl_error WriteToFile(aclBinary *bin, const char *str) {
return DYN(aclWriteToFile)(bin, str);
return HSAIL_DYN(aclWriteToFile)(bin, str);
}
static acl_error WriteToMem(aclBinary *bin, void **mem, size_t *size) {
return DYN(aclWriteToMem)(bin, mem, size);
return HSAIL_DYN(aclWriteToMem)(bin, mem, size);
}
static aclBinary* CreateFromBinary(const aclBinary *binary, aclBIFVersion version) {
return DYN(aclCreateFromBinary)(binary, version);
return HSAIL_DYN(aclCreateFromBinary)(binary, version);
}
static aclBIFVersion BinaryVersion(const aclBinary *binary) {
return DYN(aclBinaryVersion)(binary);
return HSAIL_DYN(aclBinaryVersion)(binary);
}
static acl_error InsertSection(aclCompiler *cl, aclBinary *binary, const void *data, size_t data_size, aclSections id) {
return DYN(aclInsertSection)(cl, binary, data, data_size, 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 DYN(aclInsertSymbol)(cl, binary, data, data_size, id, 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 DYN(aclExtractSection)(cl, binary, size, id, 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 DYN(aclExtractSymbol)(cl, binary, size, id, symbol, error_code);
return HSAIL_DYN(aclExtractSymbol)(cl, binary, size, id, symbol, error_code);
}
static acl_error RemoveSection(aclCompiler *cl, aclBinary *binary, aclSections id) {
return DYN(aclRemoveSection)(cl, binary, id);
return HSAIL_DYN(aclRemoveSection)(cl, binary, id);
}
static acl_error RemoveSymbol(aclCompiler *cl, aclBinary *binary, aclSections id, const char *symbol) {
return DYN(aclRemoveSymbol)(cl, binary, id, 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 DYN(aclQueryInfo)(cl, binary, query, kernel, data_ptr, 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 DYN(aclDbgAddArgument)(cl, binary, kernel, name, 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 DYN(aclDbgRemoveArgument)(cl, binary, kernel, 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 DYN(aclCompile)(cl, bin, options, from, to, 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 DYN(aclLink)(cl, src_bin, num_libs, libs, link_mode, options, link_callback);
return HSAIL_DYN(aclLink)(cl, src_bin, num_libs, libs, link_mode, options, link_callback);
}
static const char* GetCompilerLog(aclCompiler *cl) {
return DYN(aclGetCompilerLog)(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 DYN(aclRetrieveType)(cl, bin, name, data_size, type, 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 DYN(aclSetType)(cl, bin, name, type, data, 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 DYN(aclConvertType)(cl, bin, name, type);
return HSAIL_DYN(aclConvertType)(cl, bin, name, type);
}
static acl_error Disassemble(aclCompiler *cl, aclBinary *bin, const char *kernel, aclLogFunction disasm_callback) {
return DYN(aclDisassemble)(cl, bin, kernel, 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 DYN(aclGetDeviceBinary)(cl, bin, kernel, size, error_code);
return HSAIL_DYN(aclGetDeviceBinary)(cl, bin, kernel, size, error_code);
}
static const bool ValidateBinaryImage(const void* binary, size_t length, unsigned type) {
return DYN(aclValidateBinaryImage)(binary, length, type);
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 DYN(aclJITObjectImageCreate)(cl, buffer, length, bin, 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 DYN(aclJITObjectImageCopy)(cl, buffer, length, error_code);
return HSAIL_DYN(aclJITObjectImageCopy)(cl, buffer, length, error_code);
}
static acl_error JITObjectImageDestroy(aclCompiler *cl, aclJITObjectImage buffer) {
return DYN(aclJITObjectImageDestroy)(cl, buffer);
return HSAIL_DYN(aclJITObjectImageDestroy)(cl, buffer);
}
static acl_error JITObjectImageFinalize(aclCompiler *cl, aclJITObjectImage image) {
return DYN(aclJITObjectImageFinalize)(cl, image);
return HSAIL_DYN(aclJITObjectImageFinalize)(cl, image);
}
static size_t JITObjectImageSize(aclCompiler *cl, aclJITObjectImage image, acl_error* error_code) {
return DYN(aclJITObjectImageSize)(cl, image, error_code);
return HSAIL_DYN(aclJITObjectImageSize)(cl, image, error_code);
}
static const char* JITObjectImageData(aclCompiler *cl, aclJITObjectImage image, acl_error* error_code) {
return DYN(aclJITObjectImageData)(cl, image, error_code);
return HSAIL_DYN(aclJITObjectImageData)(cl, image, error_code);
}
static size_t JITObjectImageGetGlobalsSize(aclCompiler *cl, aclJITObjectImage image, acl_error* error_code) {
return DYN(aclJITObjectImageGetGlobalsSize)(cl, image, error_code);
return HSAIL_DYN(aclJITObjectImageGetGlobalsSize)(cl, image, error_code);
}
static acl_error JITObjectImageIterateSymbols(aclCompiler *cl, aclJITObjectImage image, aclJITSymbolCallback callback, void* data) {
return DYN(aclJITObjectImageIterateSymbols)(cl, image, callback, data);
return HSAIL_DYN(aclJITObjectImageIterateSymbols)(cl, image, callback, data);
}
static void DumpBinary(const aclBinary *bin) {
DYN(aclDumpBinary)(bin);
HSAIL_DYN(aclDumpBinary)(bin);
}
static void GetKstatsSI(const void* shader, aclKernelStats &kstats) {
return DYN(aclGetKstatsSI)(shader, kstats);
return HSAIL_DYN(aclGetKstatsSI)(shader, kstats);
}
static acl_error InsertKernelStatistics(aclCompiler *cl, aclBinary *bin) {
return DYN(aclInsertKernelStatistics)(cl, bin);
return HSAIL_DYN(aclInsertKernelStatistics)(cl, bin);
}
static acl_error FreeMem(aclBinary *bin, void *mem) {
return DYN(aclFreeMem)(bin, mem);
return HSAIL_DYN(aclFreeMem)(bin, mem);
}
private: