diff --git a/rocclr/runtime/device/devprogram.cpp b/rocclr/runtime/device/devprogram.cpp
index 27875b0cd0..f7e5d06c59 100644
--- a/rocclr/runtime/device/devprogram.cpp
+++ b/rocclr/runtime/device/devprogram.cpp
@@ -804,8 +804,8 @@ std::string Program::ProcessOptions(amd::option::Options* options) {
 #ifndef WITH_LIGHTNING_COMPILER
   optionsStr.append(" -D__AMD__=1");
 
-  optionsStr.append(" -D__").append(device().info().name_).append("__=1");
-  optionsStr.append(" -D__").append(device().info().name_).append("=1");
+  optionsStr.append(" -D__").append(machineTarget_).append("__=1");
+  optionsStr.append(" -D__").append(machineTarget_).append("=1");
 #endif
 
 #ifdef WITH_LIGHTNING_COMPILER
@@ -1085,4 +1085,289 @@ bool Program::setBinary(const char* binaryIn, size_t size) {
   return true;
 }
 
+// ================================================================================================
+aclType Program::getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
+  bool& needOptionsCheck) {
+  aclType from = ACL_TYPE_DEFAULT;
+  if (isLC()) {
+#if defined(WITH_LIGHTNING_COMPILER)
+    completeStages.clear();
+    aclType from = ACL_TYPE_DEFAULT;
+    needOptionsCheck = true;
+    //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
+    // Checking llvmir in .llvmir section
+    bool containsLlvmirText = (type() == TYPE_COMPILED);
+    bool containsShaderIsa = (type() == TYPE_EXECUTABLE);
+    bool containsOpts = !(compileOptions_.empty() && linkOptions_.empty());
+
+    if (containsLlvmirText && containsOpts) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_LLVMIR_BINARY;
+    }
+    if (containsShaderIsa) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_ISA;
+    }
+    std::string sCurOptions = compileOptions_ + linkOptions_;
+    amd::option::Options curOptions;
+    if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
+      buildLog_ += curOptions.optionsLog();
+      LogError("Parsing compile options failed.");
+      return ACL_TYPE_DEFAULT;
+    }
+    switch (from) {
+    case ACL_TYPE_CG:
+    case ACL_TYPE_ISA:
+      // do not check options, if LLVMIR is absent or might be absent or options are absent
+      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
+        needOptionsCheck = false;
+      }
+      break;
+      // recompilation might be needed
+    case ACL_TYPE_LLVMIR_BINARY:
+    case ACL_TYPE_DEFAULT:
+    default:
+      break;
+    }
+#endif   // !defined(WITH_LIGHTNING_COMPILER)
+  } else {
+#if defined(WITH_COMPILER_LIB) || !defined(WITH_LIGHTNING_COMPILER)
+    acl_error errorCode;
+    size_t secSize = 0;
+    completeStages.clear();
+    needOptionsCheck = true;
+    size_t boolSize = sizeof(bool);
+    // Checking llvmir in .llvmir section
+    bool containsSpirv = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_SPIRV, nullptr,
+      &containsSpirv, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsSpirv = false;
+    }
+    if (containsSpirv) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_SPIRV_BINARY;
+    }
+    bool containsSpirText = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_SPIR, nullptr,
+      &containsSpirText, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsSpirText = false;
+    }
+    if (containsSpirText) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_SPIR_BINARY;
+    }
+    bool containsLlvmirText = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_LLVMIR, nullptr,
+      &containsLlvmirText, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsLlvmirText = false;
+    }
+    // Checking compile & link options in .comment section
+    bool containsOpts = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_OPTIONS, nullptr,
+      &containsOpts, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsOpts = false;
+    }
+    if (containsLlvmirText && containsOpts) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_LLVMIR_BINARY;
+    }
+    // Checking HSAIL in .cg section
+    bool containsHsailText = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_HSAIL, nullptr,
+      &containsHsailText, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsHsailText = false;
+    }
+    // Checking BRIG sections
+    bool containsBrig = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_BRIG, nullptr,
+      &containsBrig, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsBrig = false;
+    }
+    if (containsBrig) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_HSAIL_BINARY;
+    }
+    else if (containsHsailText) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_HSAIL_TEXT;
+    }
+    // Checking Loader Map symbol from CG section
+    bool containsLoaderMap = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_LOADER_MAP, nullptr,
+      &containsLoaderMap, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsLoaderMap = false;
+    }
+    if (containsLoaderMap) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_CG;
+    }
+    // Checking ISA in .text section
+    bool containsShaderIsa = true;
+    errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_ISA, nullptr,
+      &containsShaderIsa, &boolSize);
+    if (errorCode != ACL_SUCCESS) {
+      containsShaderIsa = false;
+    }
+    if (containsShaderIsa) {
+      completeStages.push_back(from);
+      from = ACL_TYPE_ISA;
+    }
+    std::string sCurOptions = compileOptions_ + linkOptions_;
+    amd::option::Options curOptions;
+    if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
+      buildLog_ += curOptions.optionsLog();
+      LogError("Parsing compile options failed.");
+      return ACL_TYPE_DEFAULT;
+    }
+    switch (from) {
+      // compile from HSAIL text, no matter prev. stages and options
+    case ACL_TYPE_HSAIL_TEXT:
+      needOptionsCheck = false;
+      break;
+    case ACL_TYPE_HSAIL_BINARY:
+      // do not check options, if LLVMIR is absent or might be absent or options are absent
+      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
+        needOptionsCheck = false;
+      }
+      break;
+    case ACL_TYPE_CG:
+    case ACL_TYPE_ISA:
+      // do not check options, if LLVMIR is absent or might be absent or options are absent
+      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
+        needOptionsCheck = false;
+      }
+      // do not check options, if BRIG is absent or might be absent or LoaderMap is absent
+      if (!curOptions.oVariables->BinCG || !containsBrig || !containsLoaderMap) {
+        needOptionsCheck = false;
+      }
+      break;
+      // recompilation might be needed
+    case ACL_TYPE_LLVMIR_BINARY:
+    case ACL_TYPE_DEFAULT:
+    default:
+      break;
+    }
+#endif  // #if defined(WITH_COMPILER_LIB) || !defined(WITH_LIGHTNING_COMPILER)
+  }
+  return from; 
+}
+
+// ================================================================================================
+aclType Program::getNextCompilationStageFromBinary(amd::option::Options* options) {
+  aclType continueCompileFrom = ACL_TYPE_DEFAULT;
+  binary_t binary = this->binary();
+  // If the binary already exists
+  if ((binary.first != nullptr) && (binary.second > 0)) {
+#if defined(WITH_COMPILER_LIB) || !defined(WITH_LIGHTNING_COMPILER)
+    if (aclValidateBinaryImage(binary.first, binary.second, BINARY_TYPE_ELF)) {
+      acl_error errorCode;
+      binaryElf_ = aclReadFromMem(binary.first, binary.second, &errorCode);
+      if (errorCode != ACL_SUCCESS) {
+        buildLog_ += "Error while BRIG Codegen phase: aclReadFromMem failure \n";
+        return continueCompileFrom;
+      }
+    }
+#endif // defined(WITH_COMPILER_LIB) || !defined(WITH_LIGHTNING_COMPILER)
+
+    // save the current options
+    std::string sCurCompileOptions = compileOptions_;
+    std::string sCurLinkOptions = linkOptions_;
+    std::string sCurOptions = compileOptions_ + linkOptions_;
+
+    // Saving binary in the interface class,
+    // which also load compile & link options from binary
+    setBinary(static_cast<const char*>(binary.first), binary.second);
+
+    // Calculate the next stage to compile from, based on sections in binaryElf_;
+    // No any validity checks here
+    std::vector<aclType> completeStages;
+    bool needOptionsCheck = true;
+    continueCompileFrom = getCompilationStagesFromBinary(completeStages, needOptionsCheck);
+    if (!options || !needOptionsCheck) {
+      return continueCompileFrom;
+    }
+    bool recompile = false;
+    //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
+    switch (continueCompileFrom) {
+    case ACL_TYPE_HSAIL_BINARY:
+    case ACL_TYPE_CG:
+    case ACL_TYPE_ISA: {
+      // Compare options loaded from binary with current ones, recompile if differ;
+      // If compile options are absent in binary, do not compare and recompile
+      if (compileOptions_.empty()) break;
+
+      std::string sBinOptions;
+#if defined(WITH_COMPILER_LIB) || !defined(WITH_LIGHTNING_COMPILER)
+      if (binaryElf_ != nullptr) {
+        const oclBIFSymbolStruct* symbol = findBIF30SymStruct(symOpenclCompilerOptions);
+        assert(symbol && "symbol not found");
+        std::string symName =
+          std::string(symbol->str[bif::PRE]) + std::string(symbol->str[bif::POST]);
+        size_t symSize = 0;
+        acl_error errorCode;
+
+        const void* opts = aclExtractSymbol(device().compiler(), binaryElf_, &symSize,
+          aclCOMMENT, symName.c_str(), &errorCode);
+        if (errorCode != ACL_SUCCESS) {
+          recompile = true;
+          break;
+        }
+        sBinOptions = std::string((char*)opts, symSize);
+      }
+      else
+#endif // defined(WITH_COMPILER_LIB) || !defined(WITH_LIGHTNING_COMPILER)
+      {
+        sBinOptions = sCurOptions;
+      }
+
+      compileOptions_ = sCurCompileOptions;
+      linkOptions_ = sCurLinkOptions;
+
+      amd::option::Options curOptions, binOptions;
+      if (!amd::option::parseAllOptions(sBinOptions, binOptions)) {
+        buildLog_ += binOptions.optionsLog();
+        LogError("Parsing compile options from binary failed.");
+        return ACL_TYPE_DEFAULT;
+      }
+      if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
+        buildLog_ += curOptions.optionsLog();
+        LogError("Parsing compile options failed.");
+        return ACL_TYPE_DEFAULT;
+      }
+      if (!curOptions.equals(binOptions)) {
+        recompile = true;
+      }
+      break;
+    }
+    default:
+      break;
+    }
+    if (recompile) {
+      while (!completeStages.empty()) {
+        continueCompileFrom = completeStages.back();
+        if (continueCompileFrom == ACL_TYPE_SPIRV_BINARY ||
+            continueCompileFrom == ACL_TYPE_LLVMIR_BINARY ||
+            continueCompileFrom == ACL_TYPE_SPIR_BINARY ||
+            continueCompileFrom == ACL_TYPE_DEFAULT) {
+          break;
+        }
+        completeStages.pop_back();
+      }
+    }
+  }
+  else {
+    const char* xLang = options->oVariables->XLang;
+    if (xLang != nullptr && strcmp(xLang, "asm") == 0) {
+      continueCompileFrom = ACL_TYPE_ASM_TEXT;
+    }
+  }
+  return continueCompileFrom;
+}
 }
diff --git a/rocclr/runtime/device/devprogram.hpp b/rocclr/runtime/device/devprogram.hpp
index 1da4767553..4088bf037c 100644
--- a/rocclr/runtime/device/devprogram.hpp
+++ b/rocclr/runtime/device/devprogram.hpp
@@ -254,6 +254,18 @@ class Program : public amd::HeapObject {
   static std::unique_ptr<amd::opencl_driver::Compiler> newCompilerInstance();
 #endif // defined(WITH_LIGHTNING_COMPILER)
 
+  /* \brief Returns the next stage to compile from, based on sections in binary,
+  *  also returns completeStages in a vector, which contains at least ACL_TYPE_DEFAULT,
+  *  sets needOptionsCheck to true if options check is needed to decide whether or not to recompile
+  */
+  aclType getCompilationStagesFromBinary(
+    std::vector<aclType>& completeStages,
+    bool& needOptionsCheck);
+
+  /* \brief Returns the next stage to compile from, based on sections and options in binary
+  */
+  aclType getNextCompilationStageFromBinary(amd::option::Options* options);
+
  private:
   //! Disable default copy constructor
   Program(const Program&);
diff --git a/rocclr/runtime/device/gpu/gpuprogram.cpp b/rocclr/runtime/device/gpu/gpuprogram.cpp
index 407afe8440..9469d1b416 100644
--- a/rocclr/runtime/device/gpu/gpuprogram.cpp
+++ b/rocclr/runtime/device/gpu/gpuprogram.cpp
@@ -1698,214 +1698,6 @@ bool HSAILProgram::linkImpl(const std::vector<device::Program*>& inputPrograms,
   return linkImpl(options);
 }
 
-aclType HSAILProgram::getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                     bool& needOptionsCheck) {
-  acl_error errorCode;
-  size_t secSize = 0;
-  completeStages.clear();
-  aclType from = ACL_TYPE_DEFAULT;
-  needOptionsCheck = true;
-  size_t boolSize = sizeof(bool);
-  //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
-  // Checking llvmir in .llvmir section
-  bool containsSpirv = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_SPIRV, NULL, &containsSpirv,
-                           &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsSpirv = false;
-  }
-  if (containsSpirv) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_SPIRV_BINARY;
-  }
-  bool containsSpirText = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_SPIR, NULL,
-                           &containsSpirText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsSpirText = false;
-  }
-  if (containsSpirText) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_SPIR_BINARY;
-  }
-  bool containsLlvmirText = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_LLVMIR, NULL,
-                           &containsLlvmirText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsLlvmirText = false;
-  }
-  // Checking compile & link options in .comment section
-  bool containsOpts = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_OPTIONS, NULL,
-                           &containsOpts, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsOpts = false;
-  }
-  if (containsLlvmirText && containsOpts) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_LLVMIR_BINARY;
-  }
-  // Checking HSAIL in .cg section
-  bool containsHsailText = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_HSAIL, NULL,
-                           &containsHsailText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsHsailText = false;
-  }
-  // Checking BRIG sections
-  bool containsBrig = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_BRIG, NULL, &containsBrig,
-                           &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsBrig = false;
-  }
-  if (containsBrig) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_HSAIL_BINARY;
-  } else if (containsHsailText) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_HSAIL_TEXT;
-  }
-  // Checking Loader Map symbol from CG section
-  bool containsLoaderMap = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_LOADER_MAP, NULL,
-                           &containsLoaderMap, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsLoaderMap = false;
-  }
-  if (containsLoaderMap) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_CG;
-  }
-  // Checking ISA in .text section
-  bool containsShaderIsa = true;
-  errorCode = aclQueryInfo(dev().hsaCompiler(), binaryElf_, RT_CONTAINS_ISA, NULL,
-                           &containsShaderIsa, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsShaderIsa = false;
-  }
-  if (containsShaderIsa) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_ISA;
-  }
-  std::string sCurOptions = compileOptions_ + linkOptions_;
-  amd::option::Options curOptions;
-  if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-    buildLog_ += curOptions.optionsLog();
-    LogError("Parsing compile options failed.");
-    return ACL_TYPE_DEFAULT;
-  }
-  switch (from) {
-    // compile from HSAIL text, no matter prev. stages and options
-    case ACL_TYPE_HSAIL_TEXT:
-      needOptionsCheck = false;
-      break;
-    case ACL_TYPE_HSAIL_BINARY:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      break;
-    case ACL_TYPE_CG:
-    case ACL_TYPE_ISA:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      // do not check options, if BRIG is absent or might be absent or LoaderMap is absent
-      if (!curOptions.oVariables->BinCG || !containsBrig || !containsLoaderMap) {
-        needOptionsCheck = false;
-      }
-      break;
-    // recompilation might be needed
-    case ACL_TYPE_LLVMIR_BINARY:
-    case ACL_TYPE_DEFAULT:
-    default:
-      break;
-  }
-  return from;
-}
-
-aclType HSAILProgram::getNextCompilationStageFromBinary(amd::option::Options* options) {
-  aclType continueCompileFrom = ACL_TYPE_DEFAULT;
-  binary_t binary = this->binary();
-  // If the binary already exists
-  if ((binary.first != NULL) && (binary.second > 0)) {
-    void* mem = const_cast<void*>(binary.first);
-    acl_error errorCode;
-    binaryElf_ = aclReadFromMem(mem, binary.second, &errorCode);
-    if (errorCode != ACL_SUCCESS) {
-      buildLog_ += "Error: Reading the binary from memory failed.\n";
-      return continueCompileFrom;
-    }
-    // Calculate the next stage to compile from, based on sections in binaryElf_;
-    // No any validity checks here
-    std::vector<aclType> completeStages;
-    bool needOptionsCheck = true;
-    continueCompileFrom = getCompilationStagesFromBinary(completeStages, needOptionsCheck);
-    // Saving binary in the interface class,
-    // which also load compile & link options from binary
-    setBinary(static_cast<char*>(mem), binary.second);
-    if (!options || !needOptionsCheck) {
-      return continueCompileFrom;
-    }
-    bool recompile = false;
-    //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
-    switch (continueCompileFrom) {
-      case ACL_TYPE_HSAIL_BINARY:
-      case ACL_TYPE_CG:
-      case ACL_TYPE_ISA: {
-        // Compare options loaded from binary with current ones, recompile if differ;
-        // If compile options are absent in binary, do not compare and recompile
-        if (compileOptions_.empty()) break;
-        const oclBIFSymbolStruct* symbol = findBIF30SymStruct(symOpenclCompilerOptions);
-        assert(symbol && "symbol not found");
-        std::string symName =
-            std::string(symbol->str[bif::PRE]) + std::string(symbol->str[bif::POST]);
-        size_t symSize = 0;
-        const void* opts = aclExtractSymbol(dev().hsaCompiler(), binaryElf_, &symSize, aclCOMMENT,
-                                            symName.c_str(), &errorCode);
-        if (errorCode != ACL_SUCCESS) {
-          recompile = true;
-          break;
-        }
-        std::string sBinOptions = std::string((char*)opts, symSize);
-        std::string sCurOptions = compileOptions_ + linkOptions_;
-        amd::option::Options curOptions, binOptions;
-        if (!amd::option::parseAllOptions(sBinOptions, binOptions)) {
-          buildLog_ += binOptions.optionsLog();
-          LogError("Parsing compile options from binary failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-          buildLog_ += curOptions.optionsLog();
-          LogError("Parsing compile options failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!curOptions.equals(binOptions)) {
-          recompile = true;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    if (recompile) {
-      while (!completeStages.empty()) {
-        continueCompileFrom = completeStages.back();
-        if (continueCompileFrom == ACL_TYPE_SPIRV_BINARY ||
-            continueCompileFrom == ACL_TYPE_LLVMIR_BINARY ||
-            continueCompileFrom == ACL_TYPE_SPIR_BINARY ||
-            continueCompileFrom == ACL_TYPE_DEFAULT) {
-          break;
-        }
-        completeStages.pop_back();
-      }
-    }
-  }
-  return continueCompileFrom;
-}
-
 inline static std::vector<std::string> splitSpaceSeparatedString(char* str) {
   std::string s(str);
   std::stringstream ss(s);
diff --git a/rocclr/runtime/device/gpu/gpuprogram.hpp b/rocclr/runtime/device/gpu/gpuprogram.hpp
index 85ed58c715..ddfe406ddf 100644
--- a/rocclr/runtime/device/gpu/gpuprogram.hpp
+++ b/rocclr/runtime/device/gpu/gpuprogram.hpp
@@ -483,17 +483,6 @@ class HSAILProgram : public device::Program {
   //! post-compile setup for GPU
   virtual bool finiBuild(bool isBuildGood);
 
-  /* \brief Returns the next stage to compile from, based on sections in binary,
-  *  also returns completeStages in a vector, which contains at least ACL_TYPE_DEFAULT,
-  *  sets needOptionsCheck to true if options check is needed to decide whether or not to recompile
-  */
-  aclType getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                         bool& needOptionsCheck);
-
-  /* \brief Returns the next stage to compile from, based on sections and options in binary
-  */
-  aclType getNextCompilationStageFromBinary(amd::option::Options* options);
-
   bool saveBinaryAndSetType(type_t type);
 
   virtual bool linkImpl(amd::option::Options* options);
diff --git a/rocclr/runtime/device/pal/paldefs.hpp b/rocclr/runtime/device/pal/paldefs.hpp
index ac6d5e3ddb..52e7ac723f 100644
--- a/rocclr/runtime/device/pal/paldefs.hpp
+++ b/rocclr/runtime/device/pal/paldefs.hpp
@@ -152,7 +152,7 @@ static const AMDDeviceInfo DeviceInfo[] = {
     /* Fiji */ {"Fiji", "fiji", 4, 16, 1, 256, 64 * Ki, 32, LIGHTNING_SWITCH(803, 804), false},
     /* Ellesmere */ {"Ellesmere", "ellesmere", 4, 16, 1, 256, 64 * Ki, 32, LIGHTNING_SWITCH(803, 804), false},
     /* Baffin */ {"Baffin", "baffin", 4, 16, 1, 256, 64 * Ki, 32, LIGHTNING_SWITCH(803, 804), false},
-    /* Lexa */ {"gfx803", "gfx803", 4, 16, 1, 256, 64 * Ki, 32, LIGHTNING_SWITCH(803, 804), false},
+    /* Lexa */ {"gfx804", "gfx804", 4, 16, 1, 256, 64 * Ki, 32, LIGHTNING_SWITCH(804, 804), false},
 };
 
 // Ordering as per AsicRevision# in //depot/stg/pal/inc/core/palDevice.h and
diff --git a/rocclr/runtime/device/pal/palprogram.cpp b/rocclr/runtime/device/pal/palprogram.cpp
index a48939df9d..014a635d71 100644
--- a/rocclr/runtime/device/pal/palprogram.cpp
+++ b/rocclr/runtime/device/pal/palprogram.cpp
@@ -145,7 +145,7 @@ HSAILProgram::HSAILProgram(Device& device)
       executable_(nullptr),
       loaderContext_(this) {
   xnackEnabled_ = dev().hwInfo()->xnackEnabled_;
-  if (dev().properties().revision == Pal::AsicRevision::Bristol) {
+  if (dev().asicRevision() == Pal::AsicRevision::Bristol) {
     machineTarget_ = Carrizo;
   } else {
     machineTarget_ = dev().hwInfo()->targetName_;
@@ -164,7 +164,7 @@ HSAILProgram::HSAILProgram(NullDevice& device)
       loaderContext_(this) {
   isNull_ = true;
   xnackEnabled_ = dev().hwInfo()->xnackEnabled_;
-  if (dev().properties().revision == Pal::AsicRevision::Bristol) {
+  if (dev().asicRevision() == Pal::AsicRevision::Bristol) {
     machineTarget_ = Carrizo;
   } else {
     machineTarget_ = dev().hwInfo()->targetName_;
@@ -329,222 +329,6 @@ bool HSAILProgram::linkImpl(const std::vector<device::Program*>& inputPrograms,
 #endif  // !defined(WITH_LIGHTNING_COMPILER)
 }
 
-aclType HSAILProgram::getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                     bool& needOptionsCheck) {
-#if defined(WITH_LIGHTNING_COMPILER)
-  assert(!"Should not reach here");
-  return ACL_TYPE_DEFAULT;
-#else   // !defined(WITH_LIGHTNING_COMPILER)
-  acl_error errorCode;
-  size_t secSize = 0;
-  completeStages.clear();
-  aclType from = ACL_TYPE_DEFAULT;
-  needOptionsCheck = true;
-  size_t boolSize = sizeof(bool);
-  // Checking llvmir in .llvmir section
-  bool containsSpirv = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_SPIRV, nullptr, &containsSpirv,
-                           &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsSpirv = false;
-  }
-  if (containsSpirv) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_SPIRV_BINARY;
-  }
-  bool containsSpirText = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_SPIR, nullptr,
-                           &containsSpirText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsSpirText = false;
-  }
-  if (containsSpirText) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_SPIR_BINARY;
-  }
-  bool containsLlvmirText = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_LLVMIR, nullptr,
-                           &containsLlvmirText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsLlvmirText = false;
-  }
-  // Checking compile & link options in .comment section
-  bool containsOpts = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_OPTIONS, nullptr,
-                           &containsOpts, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsOpts = false;
-  }
-  if (containsLlvmirText && containsOpts) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_LLVMIR_BINARY;
-  }
-  // Checking HSAIL in .cg section
-  bool containsHsailText = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_HSAIL, nullptr,
-                           &containsHsailText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsHsailText = false;
-  }
-  // Checking BRIG sections
-  bool containsBrig = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_BRIG, nullptr, &containsBrig,
-                           &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsBrig = false;
-  }
-  if (containsBrig) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_HSAIL_BINARY;
-  } else if (containsHsailText) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_HSAIL_TEXT;
-  }
-  // Checking Loader Map symbol from CG section
-  bool containsLoaderMap = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_LOADER_MAP, nullptr,
-                           &containsLoaderMap, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsLoaderMap = false;
-  }
-  if (containsLoaderMap) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_CG;
-  }
-  // Checking ISA in .text section
-  bool containsShaderIsa = true;
-  errorCode = aclQueryInfo(dev().compiler(), binaryElf_, RT_CONTAINS_ISA, nullptr,
-                           &containsShaderIsa, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsShaderIsa = false;
-  }
-  if (containsShaderIsa) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_ISA;
-  }
-  std::string sCurOptions = compileOptions_ + linkOptions_;
-  amd::option::Options curOptions;
-  if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-    buildLog_ += curOptions.optionsLog();
-    LogError("Parsing compile options failed.");
-    return ACL_TYPE_DEFAULT;
-  }
-  switch (from) {
-    // compile from HSAIL text, no matter prev. stages and options
-    case ACL_TYPE_HSAIL_TEXT:
-      needOptionsCheck = false;
-      break;
-    case ACL_TYPE_HSAIL_BINARY:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      break;
-    case ACL_TYPE_CG:
-    case ACL_TYPE_ISA:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      // do not check options, if BRIG is absent or might be absent or LoaderMap is absent
-      if (!curOptions.oVariables->BinCG || !containsBrig || !containsLoaderMap) {
-        needOptionsCheck = false;
-      }
-      break;
-    // recompilation might be needed
-    case ACL_TYPE_LLVMIR_BINARY:
-    case ACL_TYPE_DEFAULT:
-    default:
-      break;
-  }
-  return from;
-#endif  // !defined(WITH_LIGHTNING_COMPILER)
-}
-
-aclType HSAILProgram::getNextCompilationStageFromBinary(amd::option::Options* options) {
-#if defined(WITH_LIGHTNING_COMPILER)
-  assert(!"Should not reach here");
-  return ACL_TYPE_DEFAULT;
-#else   // !defined(WITH_LIGHTNING_COMPILER)
-  aclType continueCompileFrom = ACL_TYPE_DEFAULT;
-  binary_t binary = this->binary();
-  // If the binary already exists
-  if ((binary.first != nullptr) && (binary.second > 0)) {
-    void* mem = const_cast<void*>(binary.first);
-    acl_error errorCode;
-    binaryElf_ = aclReadFromMem(mem, binary.second, &errorCode);
-    if (errorCode != ACL_SUCCESS) {
-      buildLog_ += "Error: Reading the binary from memory failed.\n";
-      return continueCompileFrom;
-    }
-    // Calculate the next stage to compile from, based on sections in binaryElf_;
-    // No any validity checks here
-    std::vector<aclType> completeStages;
-    bool needOptionsCheck = true;
-    continueCompileFrom = getCompilationStagesFromBinary(completeStages, needOptionsCheck);
-    // Saving binary in the interface class,
-    // which also load compile & link options from binary
-    setBinary(static_cast<char*>(mem), binary.second);
-    if (!options || !needOptionsCheck) {
-      return continueCompileFrom;
-    }
-    bool recompile = false;
-    switch (continueCompileFrom) {
-      case ACL_TYPE_HSAIL_BINARY:
-      case ACL_TYPE_CG:
-      case ACL_TYPE_ISA: {
-        // Compare options loaded from binary with current ones, recompile if differ;
-        // If compile options are absent in binary, do not compare and recompile
-        if (compileOptions_.empty()) break;
-        const oclBIFSymbolStruct* symbol = findBIF30SymStruct(symOpenclCompilerOptions);
-        assert(symbol && "symbol not found");
-        std::string symName =
-            std::string(symbol->str[bif::PRE]) + std::string(symbol->str[bif::POST]);
-        size_t symSize = 0;
-        const void* opts = aclExtractSymbol(dev().compiler(), binaryElf_, &symSize, aclCOMMENT,
-                                            symName.c_str(), &errorCode);
-        if (errorCode != ACL_SUCCESS) {
-          recompile = true;
-          break;
-        }
-        std::string sBinOptions = std::string((char*)opts, symSize);
-        std::string sCurOptions = compileOptions_ + linkOptions_;
-        amd::option::Options curOptions, binOptions;
-        if (!amd::option::parseAllOptions(sBinOptions, binOptions)) {
-          buildLog_ += binOptions.optionsLog();
-          LogError("Parsing compile options from binary failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-          buildLog_ += curOptions.optionsLog();
-          LogError("Parsing compile options failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!curOptions.equals(binOptions)) {
-          recompile = true;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    if (recompile) {
-      while (!completeStages.empty()) {
-        continueCompileFrom = completeStages.back();
-        if (continueCompileFrom == ACL_TYPE_SPIRV_BINARY ||
-            continueCompileFrom == ACL_TYPE_LLVMIR_BINARY ||
-            continueCompileFrom == ACL_TYPE_SPIR_BINARY ||
-            continueCompileFrom == ACL_TYPE_DEFAULT) {
-          break;
-        }
-        completeStages.pop_back();
-      }
-    }
-  }
-  return continueCompileFrom;
-#endif  // !defined(WITH_LIGHTNING_COMPILER)
-}
-
 inline static std::vector<std::string> splitSpaceSeparatedString(char* str) {
   std::string s(str);
   std::stringstream ss(s);
@@ -1034,119 +818,6 @@ static hsa_status_t GetGlobalVarNamesCallback(
   return HSA_STATUS_SUCCESS;
 }
 
-aclType LightningProgram::getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                         bool& needOptionsCheck) {
-  completeStages.clear();
-  aclType from = ACL_TYPE_DEFAULT;
-  needOptionsCheck = true;
-
-  bool containsLlvmirText = (type() == TYPE_COMPILED);
-  bool containsShaderIsa = (type() == TYPE_EXECUTABLE);
-  bool containsOpts = !(compileOptions_.empty() && linkOptions_.empty());
-
-  if (containsLlvmirText && containsOpts) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_LLVMIR_BINARY;
-  }
-  if (containsShaderIsa) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_ISA;
-  }
-  std::string sCurOptions = compileOptions_ + linkOptions_;
-  amd::option::Options curOptions;
-  if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-    buildLog_ += curOptions.optionsLog();
-    LogError("Parsing compile options failed.");
-    return ACL_TYPE_DEFAULT;
-  }
-  switch (from) {
-    case ACL_TYPE_ISA:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      break;
-    // recompilation might be needed
-    case ACL_TYPE_LLVMIR_BINARY:
-    case ACL_TYPE_DEFAULT:
-    default:
-      break;
-  }
-  return from;
-}
-
-
-aclType LightningProgram::getNextCompilationStageFromBinary(amd::option::Options* options) {
-  aclType continueCompileFrom = ACL_TYPE_DEFAULT;
-  binary_t binary = this->binary();
-
-  // If the binary already exists
-  if ((binary.first != NULL) && (binary.second > 0)) {
-    void* mem = const_cast<void*>(binary.first);
-
-    // save the current options
-    std::string sCurCompileOptions = compileOptions_;
-    std::string sCurLinkOptions = linkOptions_;
-    std::string sCurOptions = compileOptions_ + linkOptions_;
-
-    // Saving binary in the interface class,
-    // which also load compile & link options from binary
-    setBinary(static_cast<char*>(mem), binary.second);
-
-    // Calculate the next stage to compile from, based on sections in binaryElf_;
-    // No any validity checks here
-    std::vector<aclType> completeStages;
-    bool needOptionsCheck = true;
-    continueCompileFrom = getCompilationStagesFromBinary(completeStages, needOptionsCheck);
-    if (!options || !needOptionsCheck) {
-      return continueCompileFrom;
-    }
-    bool recompile = false;
-    //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
-    switch (continueCompileFrom) {
-      case ACL_TYPE_ISA: {
-        // Compare options loaded from binary with current ones, recompile if differ;
-        // If compile options are absent in binary, do not compare and recompile
-        if (compileOptions_.empty()) break;
-
-        std::string sBinOptions = compileOptions_ + linkOptions_;
-
-        compileOptions_ = sCurCompileOptions;
-        linkOptions_ = sCurLinkOptions;
-
-        amd::option::Options curOptions, binOptions;
-        if (!amd::option::parseAllOptions(sBinOptions, binOptions)) {
-          buildLog_ += binOptions.optionsLog();
-          LogError("Parsing compile options from binary failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-          buildLog_ += curOptions.optionsLog();
-          LogError("Parsing compile options failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!curOptions.equals(binOptions)) {
-          recompile = true;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    if (recompile) {
-      while (!completeStages.empty()) {
-        continueCompileFrom = completeStages.back();
-        if (continueCompileFrom == ACL_TYPE_LLVMIR_BINARY ||
-            continueCompileFrom == ACL_TYPE_DEFAULT) {
-          break;
-        }
-        completeStages.pop_back();
-      }
-    }
-  }
-  return continueCompileFrom;
-}
-
 bool LightningProgram::createBinary(amd::option::Options* options) {
   if (!clBinary()->createElfBinary(options->oVariables->BinEncrypt, type())) {
     LogError("Failed to create ELF binary image!");
diff --git a/rocclr/runtime/device/pal/palprogram.hpp b/rocclr/runtime/device/pal/palprogram.hpp
index 582385a6d6..7a0abc5626 100644
--- a/rocclr/runtime/device/pal/palprogram.hpp
+++ b/rocclr/runtime/device/pal/palprogram.hpp
@@ -181,17 +181,6 @@ class HSAILProgram : public device::Program {
   //! post-compile setup for GPU
   virtual bool finiBuild(bool isBuildGood);
 
-  /* \brief Returns the next stage to compile from, based on sections in binary,
-  *  also returns completeStages in a vector, which contains at least ACL_TYPE_DEFAULT,
-  *  sets needOptionsCheck to true if options check is needed to decide whether or not to recompile
-  */
-  aclType getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                         bool& needOptionsCheck);
-
-  /* \brief Returns the next stage to compile from, based on sections and options in binary
-  */
-  aclType getNextCompilationStageFromBinary(amd::option::Options* options);
-
   bool saveBinaryAndSetType(type_t type);
 
   virtual bool linkImpl(amd::option::Options* options);
@@ -262,17 +251,6 @@ class LightningProgram : public HSAILProgram {
  private:
   virtual ~LightningProgram();
 
-  /* \brief Returns the next stage to compile from, based on sections in binary,
-  *  also returns completeStages in a vector, which contains at least ACL_TYPE_DEFAULT,
-  *  sets needOptionsCheck to true if options check is needed to decide whether or not to recompile
-  */
-  aclType getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                         bool& needOptionsCheck);
-
-  /* \brief Returns the next stage to compile from, based on sections and options in binary
-  */
-  aclType getNextCompilationStageFromBinary(amd::option::Options* options);
-
  protected:
   virtual bool linkImpl(amd::option::Options* options) override;
 
diff --git a/rocclr/runtime/device/rocm/rocprogram.cpp b/rocclr/runtime/device/rocm/rocprogram.cpp
index 526b25ce52..089138acdc 100644
--- a/rocclr/runtime/device/rocm/rocprogram.cpp
+++ b/rocclr/runtime/device/rocm/rocprogram.cpp
@@ -156,113 +156,6 @@ bool Program::finiBuild(bool isBuildGood) {
   return device::Program::finiBuild(isBuildGood);
 }
 
-aclType Program::getNextCompilationStageFromBinary(amd::option::Options* options) {
-  aclType continueCompileFrom = ACL_TYPE_DEFAULT;
-  binary_t binary = this->binary();
-  // If the binary already exists
-  if ((binary.first != nullptr) && (binary.second > 0)) {
-#if defined(WITH_COMPILER_LIB)
-    if (aclValidateBinaryImage(binary.first, binary.second, BINARY_TYPE_ELF)) {
-      acl_error errorCode;
-      binaryElf_ = aclReadFromMem(binary.first, binary.second, &errorCode);
-      if (errorCode != ACL_SUCCESS) {
-        buildLog_ += "Error while BRIG Codegen phase: aclReadFromMem failure \n";
-        return continueCompileFrom;
-      }
-    }
-#endif // defined(WITH_COMPILER_LIB)
-
-    // save the current options
-    std::string sCurCompileOptions = compileOptions_;
-    std::string sCurLinkOptions = linkOptions_;
-    std::string sCurOptions = compileOptions_ + linkOptions_;
-
-    // Saving binary in the interface class,
-    // which also load compile & link options from binary
-    setBinary(static_cast<const char*>(binary.first), binary.second);
-
-    // Calculate the next stage to compile from, based on sections in binaryElf_;
-    // No any validity checks here
-    std::vector<aclType> completeStages;
-    bool needOptionsCheck = true;
-    continueCompileFrom = getCompilationStagesFromBinary(completeStages, needOptionsCheck);
-    if (!options || !needOptionsCheck) {
-      return continueCompileFrom;
-    }
-    bool recompile = false;
-    //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
-    switch (continueCompileFrom) {
-      case ACL_TYPE_HSAIL_BINARY:
-      case ACL_TYPE_CG:
-      case ACL_TYPE_ISA: {
-        // Compare options loaded from binary with current ones, recompile if differ;
-        // If compile options are absent in binary, do not compare and recompile
-        if (compileOptions_.empty()) break;
-
-        std::string sBinOptions;
-#if defined(WITH_COMPILER_LIB)
-        if (binaryElf_ != nullptr) {
-          const oclBIFSymbolStruct* symbol = findBIF30SymStruct(symOpenclCompilerOptions);
-          assert(symbol && "symbol not found");
-          std::string symName =
-              std::string(symbol->str[bif::PRE]) + std::string(symbol->str[bif::POST]);
-          size_t symSize = 0;
-          acl_error errorCode;
-
-          const void* opts = aclExtractSymbol(device().compiler(), binaryElf_, &symSize,
-                                              aclCOMMENT, symName.c_str(), &errorCode);
-          if (errorCode != ACL_SUCCESS) {
-            recompile = true;
-            break;
-          }
-          sBinOptions = std::string((char*)opts, symSize);
-        } else
-#endif // defined(WITH_COMPILER_LIB)
-        {
-          sBinOptions = sCurOptions;
-        }
-
-        compileOptions_ = sCurCompileOptions;
-        linkOptions_ = sCurLinkOptions;
-
-        amd::option::Options curOptions, binOptions;
-        if (!amd::option::parseAllOptions(sBinOptions, binOptions)) {
-          buildLog_ += binOptions.optionsLog();
-          LogError("Parsing compile options from binary failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-          buildLog_ += curOptions.optionsLog();
-          LogError("Parsing compile options failed.");
-          return ACL_TYPE_DEFAULT;
-        }
-        if (!curOptions.equals(binOptions)) {
-          recompile = true;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    if (recompile) {
-      while (!completeStages.empty()) {
-        continueCompileFrom = completeStages.back();
-        if (continueCompileFrom == ACL_TYPE_LLVMIR_BINARY ||
-            continueCompileFrom == ACL_TYPE_DEFAULT) {
-          break;
-        }
-        completeStages.pop_back();
-      }
-    }
-  } else {
-    const char* xLang = options->oVariables->XLang;
-    if (xLang != nullptr && strcmp(xLang, "asm") == 0) {
-      continueCompileFrom = ACL_TYPE_ASM_TEXT;
-    }
-  }
-  return continueCompileFrom;
-}
-
 #if defined(WITH_COMPILER_LIB)
 HSAILProgram::HSAILProgram(roc::NullDevice& device) : roc::Program(device) {
   xnackEnabled_ = dev().deviceInfo().xnackEnabled_;
@@ -302,118 +195,6 @@ bool HSAILProgram::saveBinaryAndSetType(type_t type) {
   return true;
 }
 
-aclType HSAILProgram::getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                     bool& needOptionsCheck) {
-  acl_error errorCode;
-  size_t secSize = 0;
-  completeStages.clear();
-  aclType from = ACL_TYPE_DEFAULT;
-  needOptionsCheck = true;
-  size_t boolSize = sizeof(bool);
-  //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
-  // Checking llvmir in .llvmir section
-  bool containsHsailText = false;
-  bool containsBrig = false;
-  bool containsLoaderMap = false;
-  bool containsLlvmirText = (type() == TYPE_COMPILED);
-  bool containsShaderIsa = (type() == TYPE_EXECUTABLE);
-  bool containsOpts = !(compileOptions_.empty() && linkOptions_.empty());
-
-  errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_LLVMIR,
-                           nullptr, &containsLlvmirText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsLlvmirText = false;
-  }
-  // Checking compile & link options in .comment section
-  errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_OPTIONS,
-                           nullptr, &containsOpts, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsOpts = false;
-  }
-  // Checking HSAIL in .cg section
-  containsHsailText = true;
-  errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_HSAIL,
-                           nullptr, &containsHsailText, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsHsailText = false;
-  }
-  // Checking BRIG sections
-  containsBrig = true;
-  errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_BRIG, nullptr,
-                           &containsBrig, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsBrig = false;
-  }
-  // Checking Loader Map symbol from CG section
-  containsLoaderMap = true;
-  errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_LOADER_MAP,
-                           NULL, &containsLoaderMap, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsLoaderMap = false;
-  }
-  if (containsBrig) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_HSAIL_BINARY;
-  } else if (containsHsailText) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_HSAIL_TEXT;
-  }
-  if (containsLoaderMap) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_CG;
-  }
-  errorCode = aclQueryInfo(device().compiler(), binaryElf_, RT_CONTAINS_ISA, nullptr,
-                           &containsShaderIsa, &boolSize);
-  if (errorCode != ACL_SUCCESS) {
-    containsShaderIsa = false;
-  }
-
-  if (containsLlvmirText && containsOpts) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_LLVMIR_BINARY;
-  }
-  if (containsShaderIsa) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_ISA;
-  }
-  std::string sCurOptions = compileOptions_ + linkOptions_;
-  amd::option::Options curOptions;
-  if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-    buildLog_ += curOptions.optionsLog();
-    LogError("Parsing compile options failed.");
-    return ACL_TYPE_DEFAULT;
-  }
-  switch (from) {
-    // compile from HSAIL text, no matter prev. stages and options
-    case ACL_TYPE_HSAIL_TEXT:
-      needOptionsCheck = false;
-      break;
-    case ACL_TYPE_HSAIL_BINARY:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      break;
-    case ACL_TYPE_CG:
-    case ACL_TYPE_ISA:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      // do not check options, if BRIG is absent or might be absent or LoaderMap is absent
-      if (!curOptions.oVariables->BinCG || !containsBrig || !containsLoaderMap) {
-        needOptionsCheck = false;
-      }
-      break;
-    // recompilation might be needed
-    case ACL_TYPE_LLVMIR_BINARY:
-    case ACL_TYPE_DEFAULT:
-    default:
-      break;
-  }
-  return from;
-}
-
 bool HSAILProgram::linkImpl(const std::vector<device::Program*>& inputPrograms,
                             amd::option::Options* options, bool createLibrary) {
   auto it = inputPrograms.cbegin();
@@ -757,49 +538,6 @@ bool LightningProgram::saveBinaryAndSetType(type_t type, void* rawBinary, size_t
   return true;
 }
 
-aclType LightningProgram::getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                     bool& needOptionsCheck) {
-  completeStages.clear();
-  aclType from = ACL_TYPE_DEFAULT;
-  needOptionsCheck = true;
-  //! @todo Should we also check for ACL_TYPE_OPENCL & ACL_TYPE_LLVMIR_TEXT?
-  // Checking llvmir in .llvmir section
-  bool containsLlvmirText = (type() == TYPE_COMPILED);
-  bool containsShaderIsa = (type() == TYPE_EXECUTABLE);
-  bool containsOpts = !(compileOptions_.empty() && linkOptions_.empty());
-
-  if (containsLlvmirText && containsOpts) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_LLVMIR_BINARY;
-  }
-  if (containsShaderIsa) {
-    completeStages.push_back(from);
-    from = ACL_TYPE_ISA;
-  }
-  std::string sCurOptions = compileOptions_ + linkOptions_;
-  amd::option::Options curOptions;
-  if (!amd::option::parseAllOptions(sCurOptions, curOptions)) {
-    buildLog_ += curOptions.optionsLog();
-    LogError("Parsing compile options failed.");
-    return ACL_TYPE_DEFAULT;
-  }
-  switch (from) {
-    case ACL_TYPE_CG:
-    case ACL_TYPE_ISA:
-      // do not check options, if LLVMIR is absent or might be absent or options are absent
-      if (!curOptions.oVariables->BinLLVMIR || !containsLlvmirText || !containsOpts) {
-        needOptionsCheck = false;
-      }
-      break;
-    // recompilation might be needed
-    case ACL_TYPE_LLVMIR_BINARY:
-    case ACL_TYPE_DEFAULT:
-    default:
-      break;
-  }
-  return from;
-}
-
 bool LightningProgram::linkImpl(const std::vector<device::Program*>& inputPrograms,
                                 amd::option::Options* options, bool createLibrary) {
   using namespace amd::opencl_driver;
diff --git a/rocclr/runtime/device/rocm/rocprogram.hpp b/rocclr/runtime/device/rocm/rocprogram.hpp
index 182258c532..dac67241dc 100644
--- a/rocclr/runtime/device/rocm/rocprogram.hpp
+++ b/rocclr/runtime/device/rocm/rocprogram.hpp
@@ -72,17 +72,6 @@ class Program : public device::Program {
   }
 
  protected:
-  /* \brief Returns the next stage to compile from, based on sections in binary,
-   *  also returns completeStages in a vector, which contains at least ACL_TYPE_DEFAULT,
-   *  sets needOptionsCheck to true if options check is needed to decide whether or not to recompile
-   */
-  virtual aclType getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                         bool& needOptionsCheck) = 0;
-
-  /* \brief Returns the next stage to compile from, based on sections and options in binary
-   */
-  aclType getNextCompilationStageFromBinary(amd::option::Options* options);
-
   //! Disable default copy constructor
   Program(const Program&) = delete;
   //! Disable operator=
@@ -111,9 +100,6 @@ class HSAILProgram : public roc::Program {
 private:
   std::string codegenOptions(amd::option::Options* options);
 
-  virtual aclType getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                 bool& needOptionsCheck) final;
-
   bool saveBinaryAndSetType(type_t type);
 };
 #endif // defined(WITH_COMPILER_LIB)
@@ -140,9 +126,6 @@ protected:
 private:
   bool saveBinaryAndSetType(type_t type, void* rawBinary, size_t size);
 
-  virtual aclType getCompilationStagesFromBinary(std::vector<aclType>& completeStages,
-                                                 bool& needOptionsCheck) final;
-
   bool setKernels(amd::option::Options* options, void* binary, size_t binSize);
 
   CodeObjectMD* metadata_;  //!< Runtime metadata