diff --git a/projects/clr/rocclr/device/comgrctx.hpp b/projects/clr/rocclr/device/comgrctx.hpp
index 5d51e256c1..3399b4eeb9 100644
--- a/projects/clr/rocclr/device/comgrctx.hpp
+++ b/projects/clr/rocclr/device/comgrctx.hpp
@@ -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:
diff --git a/projects/clr/rocclr/device/hsailctx.hpp b/projects/clr/rocclr/device/hsailctx.hpp
index 0d2be2adcc..ced65c7da7 100644
--- a/projects/clr/rocclr/device/hsailctx.hpp
+++ b/projects/clr/rocclr/device/hsailctx.hpp
@@ -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: