From: daineAMD <daine.mcniven@amd.com>
Date: Wed, 7 Aug 2024 13:14:09 -0600
Subject: Load rocSOLVER with dlopen at runtime

This change allows hipBLAS to build without rocSOLVER available at
buildtime. By default, hipBLAS will try to find rocSOLVER at runtime
using dlopen().

Forwarded: https://github.com/ROCm/hipBLAS/pull/903
---
 CMakeLists.txt                                     |  16 +-
 clients/CMakeLists.txt                             |   3 +-
 clients/benchmarks/CMakeLists.txt                  |   5 +
 clients/common/cblas_interface.cpp                 |   2 +-
 clients/common/clients_common.cpp                  |   8 +-
 clients/common/hipblas_template_specialization.cpp |   2 +-
 clients/gtest/CMakeLists.txt                       |   9 +-
 clients/include/cblas_interface.h                  |   2 +-
 clients/include/hipblas.hpp                        |   2 +-
 library/src/CMakeLists.txt                         |   8 +-
 .../src/amd_detail/dlopen/load_function.hpp        |  27 +-
 library/src/amd_detail/dlopen/load_rocsolver.cpp   | 217 ++++++
 library/src/amd_detail/dlopen/load_rocsolver.hpp   | 806 +++++++++++++++++++++
 library/src/amd_detail/hipblas.cpp                 | 253 ++++++-
 library/src/nvidia_detail/hipblas.cpp              |   4 -
 15 files changed, 1324 insertions(+), 40 deletions(-)
 copy clients/include/arg_check.h => library/src/amd_detail/dlopen/load_function.hpp (74%)
 create mode 100644 library/src/amd_detail/dlopen/load_rocsolver.cpp
 create mode 100644 library/src/amd_detail/dlopen/load_rocsolver.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c63dfe1..745494c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,15 +71,19 @@ rocm_setup_version( VERSION ${VERSION_STRING} )
 
 option( BUILD_VERBOSE "Output additional build information" OFF )
 
-option( BUILD_WITH_SOLVER "Add additional functions from rocSOLVER" ON )
-
-if( BUILD_WITH_SOLVER )
-    add_definitions( -D__HIP_PLATFORM_SOLVER__ )
-endif( )
-
 # BUILD_SHARED_LIBS is a cmake built-in; we make it an explicit option such that it shows in cmake-gui
 option( BUILD_SHARED_LIBS "Build hipBLAS as a shared library" ON )
 
+if(BUILD_SHARED_LIBS)
+    set(BUILD_WITH_SOLVER_DEFAULT OFF)
+else()
+    set(BUILD_WITH_SOLVER_DEFAULT ON)
+endif()
+
+option( BUILD_WITH_SOLVER "Build hipBLAS with LAPACK functionality as provided by rocSOLVER available at build time (requires installed rocSOLVER dependency; only with AMD backend)" "${BUILD_WITH_SOLVER_DEFAULT}" )
+
+option(BUILD_SOLVER_TESTS "Build additional tests to cover LAPACK functionality provided by rocSOLVER with AMD backend" ON)
+
 # Deprecated USE_CUDA option
 if(DEFINED USE_CUDA)
   if(USE_CUDA)
diff --git a/clients/CMakeLists.txt b/clients/CMakeLists.txt
index 36dfceb..da87d38 100644
--- a/clients/CMakeLists.txt
+++ b/clients/CMakeLists.txt
@@ -94,8 +94,9 @@ endif()
 
 if( BUILD_CLIENTS_TESTS OR BUILD_CLIENTS_BENCHMARKS OR BUILD_CLIENTS_SAMPLES )
   if( NOT WIN32 )
-    if( BUILD_WITH_SOLVER )
+    if( BUILD_SOLVER_TESTS )
       add_library(hipblas_fortran_client STATIC ${hipblas_f90_source_clients_solver})
+
     else()
       add_library(hipblas_fortran_client STATIC ${hipblas_f90_source_clients_no_solver})
     endif()
diff --git a/clients/benchmarks/CMakeLists.txt b/clients/benchmarks/CMakeLists.txt
index d04d28e..535aff9 100644
--- a/clients/benchmarks/CMakeLists.txt
+++ b/clients/benchmarks/CMakeLists.txt
@@ -100,6 +100,11 @@ target_compile_options(hipblas_v2-bench PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${COMM
 target_compile_definitions( hipblas-bench PRIVATE HIPBLAS_BENCH ${COMMON_DEFINES} ${BLIS_DEFINES} )
 target_compile_definitions( hipblas_v2-bench PRIVATE HIPBLAS_BENCH ${COMMON_DEFINES} ${BLIS_DEFINES} HIPBLAS_V2 )
 
+if(BUILD_SOLVER_TESTS)
+  target_compile_definitions(hipblas-bench PRIVATE -DBUILD_SOLVER_TESTS)
+  target_compile_definitions(hipblas_v2-bench PRIVATE -DBUILD_SOLVER_TESTS)
+endif()
+
 target_link_libraries( hipblas-bench PRIVATE ${BLAS_LIBRARY} ${COMMON_LINK_LIBS} )
 target_link_libraries( hipblas_v2-bench PRIVATE ${BLAS_LIBRARY} ${COMMON_LINK_LIBS} )
 if (NOT WIN32)
diff --git a/clients/common/cblas_interface.cpp b/clients/common/cblas_interface.cpp
index 2ccc666..dc67c72 100644
--- a/clients/common/cblas_interface.cpp
+++ b/clients/common/cblas_interface.cpp
@@ -3957,7 +3957,7 @@ void ref_trmm<hipblasDoubleComplex>(hipblasSideMode_t           side,
  * ===========================================================================
  */
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
 
 // potrf
 template <>
diff --git a/clients/common/clients_common.cpp b/clients/common/clients_common.cpp
index bc84584..e42e86f 100644
--- a/clients/common/clients_common.cpp
+++ b/clients/common/clients_common.cpp
@@ -221,7 +221,7 @@
 #include "blas_ex/testing_trsm_ex.hpp"
 #include "blas_ex/testing_trsm_strided_batched_ex.hpp"
 // solver functions
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
 #include "solver/testing_gels.hpp"
 #include "solver/testing_gels_batched.hpp"
 #include "solver/testing_gels_strided_batched.hpp"
@@ -459,7 +459,7 @@ void get_test_name(const Arguments& arg, std::string& name)
         {"trtri_batched", testname_trtri_batched},
         {"trtri_strided_batched", testname_trtri_strided_batched},
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
         {"geqrf", testname_geqrf},
         {"geqrf_batched", testname_geqrf_batched},
         {"geqrf_strided_batched", testname_geqrf_strided_batched},
@@ -677,7 +677,7 @@ struct perf_blas<T, U, std::enable_if_t<std::is_same<T, float>{} || std::is_same
             {"trsm_strided_batched", testing_trsm_strided_batched<T>},
             {"trsm_strided_batched_ex", testing_trsm_strided_batched_ex<T>},
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
             {"geqrf", testing_geqrf<T>},
             {"geqrf_batched", testing_geqrf_batched<T>},
             {"geqrf_strided_batched", testing_geqrf_strided_batched<T>},
@@ -899,7 +899,7 @@ struct perf_blas<
             {"trmm_batched", testing_trmm_batched<T>},
             {"trmm_strided_batched", testing_trmm_strided_batched<T>},
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
             {"geqrf", testing_geqrf<T>},
             {"geqrf_batched", testing_geqrf_batched<T>},
             {"geqrf_strided_batched", testing_geqrf_strided_batched<T>},
diff --git a/clients/common/hipblas_template_specialization.cpp b/clients/common/hipblas_template_specialization.cpp
index b073cdc..6a17d2b 100644
--- a/clients/common/hipblas_template_specialization.cpp
+++ b/clients/common/hipblas_template_specialization.cpp
@@ -13798,7 +13798,7 @@ hipblasStatus_t hipblasZgeamStridedBatchedCast_64(hipblasHandle_t             ha
                                          batchCount);
 }
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
 
 // getrf
 hipblasStatus_t hipblasCgetrfCast(
diff --git a/clients/gtest/CMakeLists.txt b/clients/gtest/CMakeLists.txt
index 9858291..ab6eaa5 100644
--- a/clients/gtest/CMakeLists.txt
+++ b/clients/gtest/CMakeLists.txt
@@ -97,7 +97,7 @@ set(hipblas_test_source
   blas_ex/gemm_ex_gtest.cpp
 )
 
-if( BUILD_WITH_SOLVER )
+if( BUILD_SOLVER_TESTS )
   set( hipblas_solver_test_source
     solver/getrf_gtest.cpp
     solver/getrs_gtest.cpp
@@ -179,6 +179,11 @@ target_compile_options(hipblas_v2-test PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${COMMO
 target_compile_definitions( hipblas-test PRIVATE ${COMMON_DEFINES} )
 target_compile_definitions( hipblas_v2-test PRIVATE ${COMMON_DEFINES} HIPBLAS_V2 )
 
+if(BUILD_SOLVER_TESTS)
+  target_compile_definitions(hipblas-test PRIVATE -DBUILD_SOLVER_TESTS)
+  target_compile_definitions(hipblas_v2-test PRIVATE -DBUILD_SOLVER_TESTS)
+endif()
+
 target_link_libraries( hipblas-test PRIVATE ${BLAS_LIBRARY} ${COMMON_LINK_LIBS} )
 target_link_libraries( hipblas_v2-test PRIVATE ${BLAS_LIBRARY} ${COMMON_LINK_LIBS} )
 if (NOT WIN32)
@@ -275,7 +280,7 @@ set( HIPBLAS_L3_YAML_DATA blas3/dgmm_gtest.yaml blas3/geam_gtest.yaml blas3/gemm
 set( HIPBLAS_EX_YAML_DATA blas_ex/axpy_ex_gtest.yaml blas_ex/dot_ex_gtest.yaml blas_ex/nrm2_ex_gtest.yaml
                           blas_ex/rot_ex_gtest.yaml blas_ex/scal_ex_gtest.yaml blas_ex/gemm_ex_gtest.yaml blas_ex/trsm_ex_gtest.yaml )
 
-if( BUILD_WITH_SOLVER )
+if( BUILD_SOLVER_TESTS )
   set( HIPBLAS_SOLVER_YAML_DATA solver/gels_gtest.yaml solver/geqrf_gtest.yaml solver/getrf_gtest.yaml solver/getri_gtest.yaml solver/getrs_gtest.yaml )
 endif()
 
diff --git a/clients/include/cblas_interface.h b/clients/include/cblas_interface.h
index d167a5d..1750022 100644
--- a/clients/include/cblas_interface.h
+++ b/clients/include/cblas_interface.h
@@ -798,7 +798,7 @@ void ref_trmm(hipblasSideMode_t  side,
  * ===========================================================================
  */
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
 
 // potrf
 template <typename T>
diff --git a/clients/include/hipblas.hpp b/clients/include/hipblas.hpp
index 0175dd7..92556d7 100644
--- a/clients/include/hipblas.hpp
+++ b/clients/include/hipblas.hpp
@@ -11884,7 +11884,7 @@ namespace
     MAP2CF_V2(hipblasTrtriStridedBatched, hipblasComplex, hipblasCtrtriStridedBatched);
     MAP2CF_V2(hipblasTrtriStridedBatched, hipblasDoubleComplex, hipblasZtrtriStridedBatched);
 
-#ifdef __HIP_PLATFORM_SOLVER__
+#ifdef BUILD_SOLVER_TESTS
 
     // getrf
     template <typename T, bool FORTRAN = false>
diff --git a/library/src/CMakeLists.txt b/library/src/CMakeLists.txt
index 083e8eb..b9d8ca6 100755
--- a/library/src/CMakeLists.txt
+++ b/library/src/CMakeLists.txt
@@ -39,7 +39,7 @@ endfunction( )
 prepend_path( ".." hipblas_headers_public relative_hipblas_headers_public )
 
 if(HIP_PLATFORM STREQUAL amd)
-  set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/amd_detail/hipblas.cpp" )
+  set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/amd_detail/hipblas.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/amd_detail/dlopen/load_rocsolver.cpp" )
 else( )
   set( hipblas_source "${CMAKE_CURRENT_SOURCE_DIR}/nvidia_detail/hipblas.cpp" )
 endif( )
@@ -83,6 +83,10 @@ if(HIP_PLATFORM STREQUAL amd)
     endif( )
   endif( )
 
+  if(NOT BUILD_WITH_SOLVER)
+    target_link_libraries(hipblas PRIVATE $<$<PLATFORM_ID:Linux>:${CMAKE_DL_LIBS}>)
+  endif()
+
   list(APPEND static_depends PACKAGE rocblas)
   target_link_libraries( hipblas PRIVATE roc::rocblas )
   target_link_libraries( hipblas PUBLIC hip::host )
@@ -94,6 +98,8 @@ if(HIP_PLATFORM STREQUAL amd)
         set ( ENV{rocsolver_DIR} ${CUSTOM_ROCSOLVER})
         find_package( rocsolver REQUIRED CONFIG NO_CMAKE_PATH )
 
+        target_compile_definitions(hipblas PRIVATE -DBUILD_WITH_SOLVER)
+
         # in case of using custom rocsolver and not custom rocblas, we need to have
         # custom rocsolver include directories before rocblas/hip include directories
         # in case there is a rocsolver installed on the system.
diff --git a/clients/include/arg_check.h b/library/src/amd_detail/dlopen/load_function.hpp
similarity index 74%
copy from clients/include/arg_check.h
copy to library/src/amd_detail/dlopen/load_function.hpp
index 3571b6f..8e0defb 100644
--- a/clients/include/arg_check.h
+++ b/library/src/amd_detail/dlopen/load_function.hpp
@@ -1,5 +1,5 @@
 /* ************************************************************************
- * Copyright (C) 2016-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (C) 2024 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -21,16 +21,21 @@
  *
  * ************************************************************************ */
 
-#pragma once
-#ifndef _ARG_CHECK_H
-#define _ARG_CHECK_H
-
-#include "hipblas.h"
-
-#ifdef GOOGLE_TEST
-#include "gtest/gtest.h"
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
 #endif
 
-void verify_hipblas_status_invalid_value(hipblasStatus_t status, const char* message);
-
+template <typename Fn>
+bool load_function(void* handle, const char* symbol, Fn& fn)
+{
+#ifdef WIN32
+    fn       = (Fn)(GetProcAddress)((HMODULE)handle, symbol);
+    bool err = !fn;
+#else
+    fn        = (Fn)(dlsym(handle, symbol));
+    char* err = dlerror(); // clear errors
 #endif
+    return !err;
+}
diff --git a/library/src/amd_detail/dlopen/load_rocsolver.cpp b/library/src/amd_detail/dlopen/load_rocsolver.cpp
new file mode 100644
index 0000000..70aff81
--- /dev/null
+++ b/library/src/amd_detail/dlopen/load_rocsolver.cpp
@@ -0,0 +1,217 @@
+/* ************************************************************************
+ * Copyright (C) 2024 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ************************************************************************ */
+
+#include "load_rocsolver.hpp"
+#include "load_function.hpp"
+
+#ifndef BUILD_WITH_SOLVER
+
+#define LOAD_FN(FN_)                              \
+    do                                            \
+    {                                             \
+        if(!load_function(handle, #FN_, g_##FN_)) \
+            return false;                         \
+    } while(0)
+
+/**
+ * function pointer variables to rocsolver functions used within hipBLAS
+ */
+fp_rocsolver_sgetrf                 g_rocsolver_sgetrf;
+fp_rocsolver_dgetrf                 g_rocsolver_dgetrf;
+fp_rocsolver_cgetrf                 g_rocsolver_cgetrf;
+fp_rocsolver_zgetrf                 g_rocsolver_zgetrf;
+fp_rocsolver_sgetrf_batched         g_rocsolver_sgetrf_batched;
+fp_rocsolver_dgetrf_batched         g_rocsolver_dgetrf_batched;
+fp_rocsolver_cgetrf_batched         g_rocsolver_cgetrf_batched;
+fp_rocsolver_zgetrf_batched         g_rocsolver_zgetrf_batched;
+fp_rocsolver_sgetrf_strided_batched g_rocsolver_sgetrf_strided_batched;
+fp_rocsolver_dgetrf_strided_batched g_rocsolver_dgetrf_strided_batched;
+fp_rocsolver_cgetrf_strided_batched g_rocsolver_cgetrf_strided_batched;
+fp_rocsolver_zgetrf_strided_batched g_rocsolver_zgetrf_strided_batched;
+
+fp_rocsolver_sgetrf_npvt                 g_rocsolver_sgetrf_npvt;
+fp_rocsolver_dgetrf_npvt                 g_rocsolver_dgetrf_npvt;
+fp_rocsolver_cgetrf_npvt                 g_rocsolver_cgetrf_npvt;
+fp_rocsolver_zgetrf_npvt                 g_rocsolver_zgetrf_npvt;
+fp_rocsolver_sgetrf_npvt_batched         g_rocsolver_sgetrf_npvt_batched;
+fp_rocsolver_dgetrf_npvt_batched         g_rocsolver_dgetrf_npvt_batched;
+fp_rocsolver_cgetrf_npvt_batched         g_rocsolver_cgetrf_npvt_batched;
+fp_rocsolver_zgetrf_npvt_batched         g_rocsolver_zgetrf_npvt_batched;
+fp_rocsolver_sgetrf_npvt_strided_batched g_rocsolver_sgetrf_npvt_strided_batched;
+fp_rocsolver_dgetrf_npvt_strided_batched g_rocsolver_dgetrf_npvt_strided_batched;
+fp_rocsolver_cgetrf_npvt_strided_batched g_rocsolver_cgetrf_npvt_strided_batched;
+fp_rocsolver_zgetrf_npvt_strided_batched g_rocsolver_zgetrf_npvt_strided_batched;
+
+fp_rocsolver_sgetrs                 g_rocsolver_sgetrs;
+fp_rocsolver_dgetrs                 g_rocsolver_dgetrs;
+fp_rocsolver_cgetrs                 g_rocsolver_cgetrs;
+fp_rocsolver_zgetrs                 g_rocsolver_zgetrs;
+fp_rocsolver_sgetrs_batched         g_rocsolver_sgetrs_batched;
+fp_rocsolver_dgetrs_batched         g_rocsolver_dgetrs_batched;
+fp_rocsolver_cgetrs_batched         g_rocsolver_cgetrs_batched;
+fp_rocsolver_zgetrs_batched         g_rocsolver_zgetrs_batched;
+fp_rocsolver_sgetrs_strided_batched g_rocsolver_sgetrs_strided_batched;
+fp_rocsolver_dgetrs_strided_batched g_rocsolver_dgetrs_strided_batched;
+fp_rocsolver_cgetrs_strided_batched g_rocsolver_cgetrs_strided_batched;
+fp_rocsolver_zgetrs_strided_batched g_rocsolver_zgetrs_strided_batched;
+
+fp_rocsolver_sgetri_outofplace_batched      g_rocsolver_sgetri_outofplace_batched;
+fp_rocsolver_dgetri_outofplace_batched      g_rocsolver_dgetri_outofplace_batched;
+fp_rocsolver_cgetri_outofplace_batched      g_rocsolver_cgetri_outofplace_batched;
+fp_rocsolver_zgetri_outofplace_batched      g_rocsolver_zgetri_outofplace_batched;
+fp_rocsolver_sgetri_npvt_outofplace_batched g_rocsolver_sgetri_npvt_outofplace_batched;
+fp_rocsolver_dgetri_npvt_outofplace_batched g_rocsolver_dgetri_npvt_outofplace_batched;
+fp_rocsolver_cgetri_npvt_outofplace_batched g_rocsolver_cgetri_npvt_outofplace_batched;
+fp_rocsolver_zgetri_npvt_outofplace_batched g_rocsolver_zgetri_npvt_outofplace_batched;
+
+fp_rocsolver_sgeqrf                 g_rocsolver_sgeqrf;
+fp_rocsolver_dgeqrf                 g_rocsolver_dgeqrf;
+fp_rocsolver_cgeqrf                 g_rocsolver_cgeqrf;
+fp_rocsolver_zgeqrf                 g_rocsolver_zgeqrf;
+fp_rocsolver_sgeqrf_ptr_batched     g_rocsolver_sgeqrf_ptr_batched;
+fp_rocsolver_dgeqrf_ptr_batched     g_rocsolver_dgeqrf_ptr_batched;
+fp_rocsolver_cgeqrf_ptr_batched     g_rocsolver_cgeqrf_ptr_batched;
+fp_rocsolver_zgeqrf_ptr_batched     g_rocsolver_zgeqrf_ptr_batched;
+fp_rocsolver_sgeqrf_strided_batched g_rocsolver_sgeqrf_strided_batched;
+fp_rocsolver_dgeqrf_strided_batched g_rocsolver_dgeqrf_strided_batched;
+fp_rocsolver_cgeqrf_strided_batched g_rocsolver_cgeqrf_strided_batched;
+fp_rocsolver_zgeqrf_strided_batched g_rocsolver_zgeqrf_strided_batched;
+
+fp_rocsolver_sgels                 g_rocsolver_sgels;
+fp_rocsolver_dgels                 g_rocsolver_dgels;
+fp_rocsolver_cgels                 g_rocsolver_cgels;
+fp_rocsolver_zgels                 g_rocsolver_zgels;
+fp_rocsolver_sgels_batched         g_rocsolver_sgels_batched;
+fp_rocsolver_dgels_batched         g_rocsolver_dgels_batched;
+fp_rocsolver_cgels_batched         g_rocsolver_cgels_batched;
+fp_rocsolver_zgels_batched         g_rocsolver_zgels_batched;
+fp_rocsolver_sgels_strided_batched g_rocsolver_sgels_strided_batched;
+fp_rocsolver_dgels_strided_batched g_rocsolver_dgels_strided_batched;
+fp_rocsolver_cgels_strided_batched g_rocsolver_cgels_strided_batched;
+fp_rocsolver_zgels_strided_batched g_rocsolver_zgels_strided_batched;
+
+static bool load_rocsolver()
+{
+#ifdef WIN32
+    void* handle = LoadLibraryW(L"rocsolver.dll");
+#else
+
+    // RTLD_NOW to load symbols now to avoid performance hit later
+    // RTLD_GLOBAL to load geqrf_ptr_batched declared symbols in hipblas.cpp
+    void* handle = dlopen("librocsolver.so.0", RTLD_NOW | RTLD_GLOBAL);
+    char* err    = dlerror();
+#endif
+
+    if(!handle)
+        return false;
+
+    LOAD_FN(rocsolver_sgetrf);
+    LOAD_FN(rocsolver_dgetrf);
+    LOAD_FN(rocsolver_cgetrf);
+    LOAD_FN(rocsolver_zgetrf);
+    LOAD_FN(rocsolver_sgetrf_batched);
+    LOAD_FN(rocsolver_dgetrf_batched);
+    LOAD_FN(rocsolver_cgetrf_batched);
+    LOAD_FN(rocsolver_zgetrf_batched);
+    LOAD_FN(rocsolver_sgetrf_strided_batched);
+    LOAD_FN(rocsolver_dgetrf_strided_batched);
+    LOAD_FN(rocsolver_cgetrf_strided_batched);
+    LOAD_FN(rocsolver_zgetrf_strided_batched);
+
+    LOAD_FN(rocsolver_sgetrf_npvt);
+    LOAD_FN(rocsolver_dgetrf_npvt);
+    LOAD_FN(rocsolver_cgetrf_npvt);
+    LOAD_FN(rocsolver_zgetrf_npvt);
+    LOAD_FN(rocsolver_sgetrf_npvt_batched);
+    LOAD_FN(rocsolver_dgetrf_npvt_batched);
+    LOAD_FN(rocsolver_cgetrf_npvt_batched);
+    LOAD_FN(rocsolver_zgetrf_npvt_batched);
+    LOAD_FN(rocsolver_sgetrf_npvt_strided_batched);
+    LOAD_FN(rocsolver_dgetrf_npvt_strided_batched);
+    LOAD_FN(rocsolver_cgetrf_npvt_strided_batched);
+    LOAD_FN(rocsolver_zgetrf_npvt_strided_batched);
+
+    LOAD_FN(rocsolver_sgetrs);
+    LOAD_FN(rocsolver_dgetrs);
+    LOAD_FN(rocsolver_cgetrs);
+    LOAD_FN(rocsolver_zgetrs);
+    LOAD_FN(rocsolver_sgetrs_batched);
+    LOAD_FN(rocsolver_dgetrs_batched);
+    LOAD_FN(rocsolver_cgetrs_batched);
+    LOAD_FN(rocsolver_zgetrs_batched);
+    LOAD_FN(rocsolver_sgetrs_strided_batched);
+    LOAD_FN(rocsolver_dgetrs_strided_batched);
+    LOAD_FN(rocsolver_cgetrs_strided_batched);
+    LOAD_FN(rocsolver_zgetrs_strided_batched);
+
+    LOAD_FN(rocsolver_sgetri_outofplace_batched);
+    LOAD_FN(rocsolver_dgetri_outofplace_batched);
+    LOAD_FN(rocsolver_cgetri_outofplace_batched);
+    LOAD_FN(rocsolver_zgetri_outofplace_batched);
+    LOAD_FN(rocsolver_sgetri_npvt_outofplace_batched);
+    LOAD_FN(rocsolver_dgetri_npvt_outofplace_batched);
+    LOAD_FN(rocsolver_cgetri_npvt_outofplace_batched);
+    LOAD_FN(rocsolver_zgetri_npvt_outofplace_batched);
+
+    LOAD_FN(rocsolver_sgeqrf);
+    LOAD_FN(rocsolver_dgeqrf);
+    LOAD_FN(rocsolver_cgeqrf);
+    LOAD_FN(rocsolver_zgeqrf);
+    LOAD_FN(rocsolver_sgeqrf_ptr_batched);
+    LOAD_FN(rocsolver_dgeqrf_ptr_batched);
+    LOAD_FN(rocsolver_cgeqrf_ptr_batched);
+    LOAD_FN(rocsolver_zgeqrf_ptr_batched);
+    LOAD_FN(rocsolver_sgeqrf_strided_batched);
+    LOAD_FN(rocsolver_dgeqrf_strided_batched);
+    LOAD_FN(rocsolver_cgeqrf_strided_batched);
+    LOAD_FN(rocsolver_zgeqrf_strided_batched);
+
+    LOAD_FN(rocsolver_sgels);
+    LOAD_FN(rocsolver_dgels);
+    LOAD_FN(rocsolver_cgels);
+    LOAD_FN(rocsolver_zgels);
+    LOAD_FN(rocsolver_sgels_batched);
+    LOAD_FN(rocsolver_dgels_batched);
+    LOAD_FN(rocsolver_cgels_batched);
+    LOAD_FN(rocsolver_zgels_batched);
+    LOAD_FN(rocsolver_sgels_strided_batched);
+    LOAD_FN(rocsolver_dgels_strided_batched);
+    LOAD_FN(rocsolver_cgels_strided_batched);
+    LOAD_FN(rocsolver_zgels_strided_batched);
+
+    return true;
+}
+
+#undef LOAD_FN
+
+#endif // BUILD_WITH_SOLVER
+
+bool try_load_rocsolver()
+{
+#ifndef BUILD_WITH_SOLVER
+    static bool result = load_rocsolver();
+    return result;
+#else
+    return true;
+#endif
+}
diff --git a/library/src/amd_detail/dlopen/load_rocsolver.hpp b/library/src/amd_detail/dlopen/load_rocsolver.hpp
new file mode 100644
index 0000000..bb548b3
--- /dev/null
+++ b/library/src/amd_detail/dlopen/load_rocsolver.hpp
@@ -0,0 +1,806 @@
+/* ************************************************************************
+ * Copyright (C) 2024 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * ************************************************************************ */
+
+#if BUILD_WITH_SOLVER
+
+#include <rocsolver/rocsolver.h>
+
+#else
+
+#include "rocblas/rocblas.h"
+// function pointer declarations
+
+// getrf
+using fp_rocsolver_sgetrf      = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               float*,
+                                               const rocblas_int,
+                                               rocblas_int*,
+                                               rocblas_int*);
+using fp_rocsolver_dgetrf      = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               double*,
+                                               const rocblas_int,
+                                               rocblas_int*,
+                                               rocblas_int*);
+using fp_rocsolver_cgetrf      = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               rocblas_float_complex*,
+                                               const rocblas_int,
+                                               rocblas_int*,
+                                               rocblas_int*);
+using fp_rocsolver_zgetrf      = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               rocblas_double_complex*,
+                                               const rocblas_int,
+                                               rocblas_int*,
+                                               rocblas_int*);
+using fp_rocsolver_sgetrf_npvt = rocblas_status (*)(
+    rocblas_handle, const rocblas_int, const rocblas_int, float*, rocblas_int, rocblas_int*);
+using fp_rocsolver_dgetrf_npvt = rocblas_status (*)(
+    rocblas_handle, const rocblas_int, const rocblas_int, double*, rocblas_int, rocblas_int*);
+using fp_rocsolver_cgetrf_npvt = rocblas_status (*)(rocblas_handle,
+                                                    const rocblas_int,
+                                                    const rocblas_int,
+                                                    rocblas_float_complex*,
+                                                    rocblas_int,
+                                                    rocblas_int*);
+using fp_rocsolver_zgetrf_npvt = rocblas_status (*)(rocblas_handle,
+                                                    const rocblas_int,
+                                                    const rocblas_int,
+                                                    rocblas_double_complex*,
+                                                    rocblas_int,
+                                                    rocblas_int*);
+
+// getrf_batched
+using fp_rocsolver_sgetrf_batched      = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       float* const*,
+                                                       const rocblas_int,
+                                                       rocblas_int*,
+                                                       const rocblas_stride,
+                                                       rocblas_int*,
+                                                       const rocblas_int);
+using fp_rocsolver_dgetrf_batched      = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       double* const*,
+                                                       const rocblas_int,
+                                                       rocblas_int*,
+                                                       const rocblas_stride,
+                                                       rocblas_int*,
+                                                       const rocblas_int);
+using fp_rocsolver_cgetrf_batched      = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       rocblas_float_complex* const*,
+                                                       const rocblas_int,
+                                                       rocblas_int*,
+                                                       const rocblas_stride,
+                                                       rocblas_int*,
+                                                       const rocblas_int);
+using fp_rocsolver_zgetrf_batched      = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       rocblas_double_complex* const*,
+                                                       const rocblas_int,
+                                                       rocblas_int*,
+                                                       const rocblas_stride,
+                                                       rocblas_int*,
+                                                       const rocblas_int);
+using fp_rocsolver_sgetrf_npvt_batched = rocblas_status (*)(rocblas_handle,
+                                                            const rocblas_int,
+                                                            const rocblas_int,
+                                                            float* const*,
+                                                            const rocblas_int,
+                                                            rocblas_int*,
+                                                            const rocblas_int);
+using fp_rocsolver_dgetrf_npvt_batched = rocblas_status (*)(rocblas_handle,
+                                                            const rocblas_int,
+                                                            const rocblas_int,
+                                                            double* const*,
+                                                            const rocblas_int,
+                                                            rocblas_int*,
+                                                            const rocblas_int);
+using fp_rocsolver_cgetrf_npvt_batched = rocblas_status (*)(rocblas_handle,
+                                                            const rocblas_int,
+                                                            const rocblas_int,
+                                                            rocblas_float_complex* const*,
+                                                            const rocblas_int,
+                                                            rocblas_int*,
+                                                            const rocblas_int);
+using fp_rocsolver_zgetrf_npvt_batched = rocblas_status (*)(rocblas_handle,
+                                                            const rocblas_int,
+                                                            const rocblas_int,
+                                                            rocblas_double_complex* const*,
+                                                            const rocblas_int,
+                                                            rocblas_int*,
+                                                            const rocblas_int);
+
+// getrf_strided_batched
+using fp_rocsolver_sgetrf_strided_batched      = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               float*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_int);
+using fp_rocsolver_dgetrf_strided_batched      = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               double*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_int);
+using fp_rocsolver_cgetrf_strided_batched      = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               rocblas_float_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_int);
+using fp_rocsolver_zgetrf_strided_batched      = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               rocblas_double_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_stride,
+                                                               rocblas_int*,
+                                                               const rocblas_int);
+using fp_rocsolver_sgetrf_npvt_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                                    const rocblas_int,
+                                                                    const rocblas_int,
+                                                                    float*,
+                                                                    const rocblas_int,
+                                                                    const rocblas_stride,
+                                                                    rocblas_int*,
+                                                                    const rocblas_int);
+using fp_rocsolver_dgetrf_npvt_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                                    const rocblas_int,
+                                                                    const rocblas_int,
+                                                                    double*,
+                                                                    const rocblas_int,
+                                                                    const rocblas_stride,
+                                                                    rocblas_int*,
+                                                                    const rocblas_int);
+using fp_rocsolver_cgetrf_npvt_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                                    const rocblas_int,
+                                                                    const rocblas_int,
+                                                                    rocblas_float_complex*,
+                                                                    const rocblas_int,
+                                                                    const rocblas_stride,
+                                                                    rocblas_int*,
+                                                                    const rocblas_int);
+using fp_rocsolver_zgetrf_npvt_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                                    const rocblas_int,
+                                                                    const rocblas_int,
+                                                                    rocblas_double_complex*,
+                                                                    const rocblas_int,
+                                                                    const rocblas_stride,
+                                                                    rocblas_int*,
+                                                                    const rocblas_int);
+
+// getrs
+using fp_rocsolver_sgetrs = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_operation,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               float*,
+                                               const rocblas_int,
+                                               const rocblas_int*,
+                                               float*,
+                                               const rocblas_int);
+using fp_rocsolver_dgetrs = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_operation,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               double*,
+                                               const rocblas_int,
+                                               const rocblas_int*,
+                                               double*,
+                                               const rocblas_int);
+using fp_rocsolver_cgetrs = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_operation,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               rocblas_float_complex*,
+                                               const rocblas_int,
+                                               const rocblas_int*,
+                                               rocblas_float_complex*,
+                                               const rocblas_int);
+using fp_rocsolver_zgetrs = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_operation,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               rocblas_double_complex*,
+                                               const rocblas_int,
+                                               const rocblas_int*,
+                                               rocblas_double_complex*,
+                                               const rocblas_int);
+
+using fp_rocsolver_sgetrs_batched = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_operation,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       float* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int*,
+                                                       const rocblas_stride,
+                                                       float* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int);
+using fp_rocsolver_dgetrs_batched = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_operation,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       double* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int*,
+                                                       const rocblas_stride,
+                                                       double* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int);
+using fp_rocsolver_cgetrs_batched = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_operation,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       rocblas_float_complex* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int*,
+                                                       const rocblas_stride,
+                                                       rocblas_float_complex* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int);
+using fp_rocsolver_zgetrs_batched = rocblas_status (*)(rocblas_handle,
+                                                       const rocblas_operation,
+                                                       const rocblas_int,
+                                                       const rocblas_int,
+                                                       rocblas_double_complex* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int*,
+                                                       const rocblas_stride,
+                                                       rocblas_double_complex* const*,
+                                                       const rocblas_int,
+                                                       const rocblas_int);
+
+using fp_rocsolver_sgetrs_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_operation,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               float*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int*,
+                                                               const rocblas_stride,
+                                                               float*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+using fp_rocsolver_dgetrs_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_operation,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               double*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int*,
+                                                               const rocblas_stride,
+                                                               double*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+using fp_rocsolver_cgetrs_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_operation,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               rocblas_float_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int*,
+                                                               const rocblas_stride,
+                                                               rocblas_float_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+using fp_rocsolver_zgetrs_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_operation,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               rocblas_double_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int*,
+                                                               const rocblas_stride,
+                                                               rocblas_double_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+
+// getri_batched
+using fp_rocsolver_sgetri_outofplace_batched = rocblas_status (*)(rocblas_handle,
+                                                                  const rocblas_int,
+                                                                  float* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_stride,
+                                                                  float* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_int);
+using fp_rocsolver_dgetri_outofplace_batched = rocblas_status (*)(rocblas_handle,
+                                                                  const rocblas_int,
+                                                                  double* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_stride,
+                                                                  double* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_int);
+using fp_rocsolver_cgetri_outofplace_batched = rocblas_status (*)(rocblas_handle,
+                                                                  const rocblas_int,
+                                                                  rocblas_float_complex* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_stride,
+                                                                  rocblas_float_complex* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_int);
+using fp_rocsolver_zgetri_outofplace_batched = rocblas_status (*)(rocblas_handle,
+                                                                  const rocblas_int,
+                                                                  rocblas_double_complex* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_stride,
+                                                                  rocblas_double_complex* const*,
+                                                                  const rocblas_int,
+                                                                  rocblas_int*,
+                                                                  const rocblas_int);
+
+using fp_rocsolver_sgetri_npvt_outofplace_batched = rocblas_status (*)(rocblas_handle,
+                                                                       const rocblas_int,
+                                                                       float* const*,
+                                                                       const rocblas_int,
+                                                                       float* const*,
+                                                                       const rocblas_int,
+                                                                       rocblas_int*,
+                                                                       const rocblas_int);
+using fp_rocsolver_dgetri_npvt_outofplace_batched = rocblas_status (*)(rocblas_handle,
+                                                                       const rocblas_int,
+                                                                       double* const*,
+                                                                       const rocblas_int,
+                                                                       double* const*,
+                                                                       const rocblas_int,
+                                                                       rocblas_int*,
+                                                                       const rocblas_int);
+using fp_rocsolver_cgetri_npvt_outofplace_batched
+    = rocblas_status (*)(rocblas_handle,
+                         const rocblas_int,
+                         rocblas_float_complex* const*,
+                         const rocblas_int,
+                         rocblas_float_complex* const*,
+                         const rocblas_int,
+                         rocblas_int*,
+                         const rocblas_int);
+using fp_rocsolver_zgetri_npvt_outofplace_batched
+    = rocblas_status (*)(rocblas_handle,
+                         const rocblas_int,
+                         rocblas_double_complex* const*,
+                         const rocblas_int,
+                         rocblas_double_complex* const*,
+                         const rocblas_int,
+                         rocblas_int*,
+                         const rocblas_int);
+
+// geqrf
+using fp_rocsolver_sgeqrf = rocblas_status (*)(
+    rocblas_handle, const rocblas_int, const rocblas_int, float*, const rocblas_int, float*);
+using fp_rocsolver_dgeqrf = rocblas_status (*)(
+    rocblas_handle, const rocblas_int, const rocblas_int, double*, const rocblas_int, double*);
+using fp_rocsolver_cgeqrf = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               rocblas_float_complex*,
+                                               const rocblas_int,
+                                               rocblas_float_complex*);
+using fp_rocsolver_zgeqrf = rocblas_status (*)(rocblas_handle,
+                                               const rocblas_int,
+                                               const rocblas_int,
+                                               rocblas_double_complex*,
+                                               const rocblas_int,
+                                               rocblas_double_complex*);
+
+using fp_rocsolver_sgeqrf_ptr_batched = rocblas_status (*)(rocblas_handle,
+                                                           const rocblas_int,
+                                                           const rocblas_int,
+                                                           float* const*,
+                                                           const rocblas_int,
+                                                           float* const*,
+                                                           const rocblas_int);
+using fp_rocsolver_dgeqrf_ptr_batched = rocblas_status (*)(rocblas_handle,
+                                                           const rocblas_int,
+                                                           const rocblas_int,
+                                                           double* const*,
+                                                           const rocblas_int,
+                                                           double* const*,
+                                                           const rocblas_int);
+using fp_rocsolver_cgeqrf_ptr_batched = rocblas_status (*)(rocblas_handle,
+                                                           const rocblas_int,
+                                                           const rocblas_int,
+                                                           rocblas_float_complex* const*,
+                                                           const rocblas_int,
+                                                           rocblas_float_complex* const*,
+                                                           const rocblas_int);
+using fp_rocsolver_zgeqrf_ptr_batched = rocblas_status (*)(rocblas_handle,
+                                                           const rocblas_int,
+                                                           const rocblas_int,
+                                                           rocblas_double_complex* const*,
+                                                           const rocblas_int,
+                                                           rocblas_double_complex* const*,
+                                                           const rocblas_int);
+
+using fp_rocsolver_sgeqrf_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               float*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               float*,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+using fp_rocsolver_dgeqrf_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               double*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               double*,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+using fp_rocsolver_cgeqrf_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               rocblas_float_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               rocblas_float_complex*,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+using fp_rocsolver_zgeqrf_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                               const rocblas_int,
+                                                               const rocblas_int,
+                                                               rocblas_double_complex*,
+                                                               const rocblas_int,
+                                                               const rocblas_stride,
+                                                               rocblas_double_complex*,
+                                                               const rocblas_stride,
+                                                               const rocblas_int);
+
+// gels
+using fp_rocsolver_sgels = rocblas_status (*)(rocblas_handle,
+                                              rocblas_operation,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              float*,
+                                              const rocblas_int,
+                                              float*,
+                                              const rocblas_int,
+                                              rocblas_int*);
+using fp_rocsolver_dgels = rocblas_status (*)(rocblas_handle,
+                                              rocblas_operation,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              double*,
+                                              const rocblas_int,
+                                              double*,
+                                              const rocblas_int,
+                                              rocblas_int*);
+using fp_rocsolver_cgels = rocblas_status (*)(rocblas_handle,
+                                              rocblas_operation,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              rocblas_float_complex*,
+                                              const rocblas_int,
+                                              rocblas_float_complex*,
+                                              const rocblas_int,
+                                              rocblas_int*);
+using fp_rocsolver_zgels = rocblas_status (*)(rocblas_handle,
+                                              rocblas_operation,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              const rocblas_int,
+                                              rocblas_double_complex*,
+                                              const rocblas_int,
+                                              rocblas_double_complex*,
+                                              const rocblas_int,
+                                              rocblas_int*);
+
+using fp_rocsolver_sgels_batched = rocblas_status (*)(rocblas_handle,
+                                                      rocblas_operation,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      float* const*,
+                                                      const rocblas_int,
+                                                      float* const*,
+                                                      const rocblas_int,
+                                                      rocblas_int*,
+                                                      const rocblas_int);
+using fp_rocsolver_dgels_batched = rocblas_status (*)(rocblas_handle,
+                                                      rocblas_operation,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      double* const*,
+                                                      const rocblas_int,
+                                                      double* const*,
+                                                      const rocblas_int,
+                                                      rocblas_int*,
+                                                      const rocblas_int);
+using fp_rocsolver_cgels_batched = rocblas_status (*)(rocblas_handle,
+                                                      rocblas_operation,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      rocblas_float_complex* const*,
+                                                      const rocblas_int,
+                                                      rocblas_float_complex* const*,
+                                                      const rocblas_int,
+                                                      rocblas_int*,
+                                                      const rocblas_int);
+using fp_rocsolver_zgels_batched = rocblas_status (*)(rocblas_handle,
+                                                      rocblas_operation,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      const rocblas_int,
+                                                      rocblas_double_complex* const*,
+                                                      const rocblas_int,
+                                                      rocblas_double_complex* const*,
+                                                      const rocblas_int,
+                                                      rocblas_int*,
+                                                      const rocblas_int);
+
+using fp_rocsolver_sgels_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                              rocblas_operation,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              float*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              float*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              rocblas_int*,
+                                                              const rocblas_int);
+using fp_rocsolver_dgels_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                              rocblas_operation,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              double*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              double*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              rocblas_int*,
+                                                              const rocblas_int);
+using fp_rocsolver_cgels_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                              rocblas_operation,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              rocblas_float_complex*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              rocblas_float_complex*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              rocblas_int*,
+                                                              const rocblas_int);
+using fp_rocsolver_zgels_strided_batched = rocblas_status (*)(rocblas_handle,
+                                                              rocblas_operation,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              const rocblas_int,
+                                                              rocblas_double_complex*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              rocblas_double_complex*,
+                                                              const rocblas_int,
+                                                              const rocblas_stride,
+                                                              rocblas_int*,
+                                                              const rocblas_int);
+
+extern fp_rocsolver_sgetrf                 g_rocsolver_sgetrf; // our global function pointer
+extern fp_rocsolver_dgetrf                 g_rocsolver_dgetrf;
+extern fp_rocsolver_cgetrf                 g_rocsolver_cgetrf;
+extern fp_rocsolver_zgetrf                 g_rocsolver_zgetrf;
+extern fp_rocsolver_sgetrf_batched         g_rocsolver_sgetrf_batched;
+extern fp_rocsolver_dgetrf_batched         g_rocsolver_dgetrf_batched;
+extern fp_rocsolver_cgetrf_batched         g_rocsolver_cgetrf_batched;
+extern fp_rocsolver_zgetrf_batched         g_rocsolver_zgetrf_batched;
+extern fp_rocsolver_sgetrf_strided_batched g_rocsolver_sgetrf_strided_batched;
+extern fp_rocsolver_dgetrf_strided_batched g_rocsolver_dgetrf_strided_batched;
+extern fp_rocsolver_cgetrf_strided_batched g_rocsolver_cgetrf_strided_batched;
+extern fp_rocsolver_zgetrf_strided_batched g_rocsolver_zgetrf_strided_batched;
+
+extern fp_rocsolver_sgetrf_npvt                 g_rocsolver_sgetrf_npvt;
+extern fp_rocsolver_dgetrf_npvt                 g_rocsolver_dgetrf_npvt;
+extern fp_rocsolver_cgetrf_npvt                 g_rocsolver_cgetrf_npvt;
+extern fp_rocsolver_zgetrf_npvt                 g_rocsolver_zgetrf_npvt;
+extern fp_rocsolver_sgetrf_npvt_batched         g_rocsolver_sgetrf_npvt_batched;
+extern fp_rocsolver_dgetrf_npvt_batched         g_rocsolver_dgetrf_npvt_batched;
+extern fp_rocsolver_cgetrf_npvt_batched         g_rocsolver_cgetrf_npvt_batched;
+extern fp_rocsolver_zgetrf_npvt_batched         g_rocsolver_zgetrf_npvt_batched;
+extern fp_rocsolver_sgetrf_npvt_strided_batched g_rocsolver_sgetrf_npvt_strided_batched;
+extern fp_rocsolver_dgetrf_npvt_strided_batched g_rocsolver_dgetrf_npvt_strided_batched;
+extern fp_rocsolver_cgetrf_npvt_strided_batched g_rocsolver_cgetrf_npvt_strided_batched;
+extern fp_rocsolver_zgetrf_npvt_strided_batched g_rocsolver_zgetrf_npvt_strided_batched;
+
+extern fp_rocsolver_sgetrs                 g_rocsolver_sgetrs;
+extern fp_rocsolver_dgetrs                 g_rocsolver_dgetrs;
+extern fp_rocsolver_cgetrs                 g_rocsolver_cgetrs;
+extern fp_rocsolver_zgetrs                 g_rocsolver_zgetrs;
+extern fp_rocsolver_sgetrs_batched         g_rocsolver_sgetrs_batched;
+extern fp_rocsolver_dgetrs_batched         g_rocsolver_dgetrs_batched;
+extern fp_rocsolver_cgetrs_batched         g_rocsolver_cgetrs_batched;
+extern fp_rocsolver_zgetrs_batched         g_rocsolver_zgetrs_batched;
+extern fp_rocsolver_sgetrs_strided_batched g_rocsolver_sgetrs_strided_batched;
+extern fp_rocsolver_dgetrs_strided_batched g_rocsolver_dgetrs_strided_batched;
+extern fp_rocsolver_cgetrs_strided_batched g_rocsolver_cgetrs_strided_batched;
+extern fp_rocsolver_zgetrs_strided_batched g_rocsolver_zgetrs_strided_batched;
+
+extern fp_rocsolver_sgetri_outofplace_batched      g_rocsolver_sgetri_outofplace_batched;
+extern fp_rocsolver_dgetri_outofplace_batched      g_rocsolver_dgetri_outofplace_batched;
+extern fp_rocsolver_cgetri_outofplace_batched      g_rocsolver_cgetri_outofplace_batched;
+extern fp_rocsolver_zgetri_outofplace_batched      g_rocsolver_zgetri_outofplace_batched;
+extern fp_rocsolver_sgetri_npvt_outofplace_batched g_rocsolver_sgetri_npvt_outofplace_batched;
+extern fp_rocsolver_dgetri_npvt_outofplace_batched g_rocsolver_dgetri_npvt_outofplace_batched;
+extern fp_rocsolver_cgetri_npvt_outofplace_batched g_rocsolver_cgetri_npvt_outofplace_batched;
+extern fp_rocsolver_zgetri_npvt_outofplace_batched g_rocsolver_zgetri_npvt_outofplace_batched;
+
+extern fp_rocsolver_sgeqrf                 g_rocsolver_sgeqrf;
+extern fp_rocsolver_dgeqrf                 g_rocsolver_dgeqrf;
+extern fp_rocsolver_cgeqrf                 g_rocsolver_cgeqrf;
+extern fp_rocsolver_zgeqrf                 g_rocsolver_zgeqrf;
+extern fp_rocsolver_sgeqrf_ptr_batched     g_rocsolver_sgeqrf_ptr_batched;
+extern fp_rocsolver_dgeqrf_ptr_batched     g_rocsolver_dgeqrf_ptr_batched;
+extern fp_rocsolver_cgeqrf_ptr_batched     g_rocsolver_cgeqrf_ptr_batched;
+extern fp_rocsolver_zgeqrf_ptr_batched     g_rocsolver_zgeqrf_ptr_batched;
+extern fp_rocsolver_sgeqrf_strided_batched g_rocsolver_sgeqrf_strided_batched;
+extern fp_rocsolver_dgeqrf_strided_batched g_rocsolver_dgeqrf_strided_batched;
+extern fp_rocsolver_cgeqrf_strided_batched g_rocsolver_cgeqrf_strided_batched;
+extern fp_rocsolver_zgeqrf_strided_batched g_rocsolver_zgeqrf_strided_batched;
+
+extern fp_rocsolver_sgels                 g_rocsolver_sgels;
+extern fp_rocsolver_dgels                 g_rocsolver_dgels;
+extern fp_rocsolver_cgels                 g_rocsolver_cgels;
+extern fp_rocsolver_zgels                 g_rocsolver_zgels;
+extern fp_rocsolver_sgels_batched         g_rocsolver_sgels_batched;
+extern fp_rocsolver_dgels_batched         g_rocsolver_dgels_batched;
+extern fp_rocsolver_cgels_batched         g_rocsolver_cgels_batched;
+extern fp_rocsolver_zgels_batched         g_rocsolver_zgels_batched;
+extern fp_rocsolver_sgels_strided_batched g_rocsolver_sgels_strided_batched;
+extern fp_rocsolver_dgels_strided_batched g_rocsolver_dgels_strided_batched;
+extern fp_rocsolver_cgels_strided_batched g_rocsolver_cgels_strided_batched;
+extern fp_rocsolver_zgels_strided_batched g_rocsolver_zgels_strided_batched;
+
+#define rocsolver_sgetrf g_rocsolver_sgetrf
+#define rocsolver_dgetrf g_rocsolver_dgetrf
+#define rocsolver_cgetrf g_rocsolver_cgetrf
+#define rocsolver_zgetrf g_rocsolver_zgetrf
+#define rocsolver_sgetrf_batched g_rocsolver_sgetrf_batched
+#define rocsolver_dgetrf_batched g_rocsolver_dgetrf_batched
+#define rocsolver_cgetrf_batched g_rocsolver_cgetrf_batched
+#define rocsolver_zgetrf_batched g_rocsolver_zgetrf_batched
+#define rocsolver_sgetrf_strided_batched g_rocsolver_sgetrf_strided_batched
+#define rocsolver_dgetrf_strided_batched g_rocsolver_dgetrf_strided_batched
+#define rocsolver_cgetrf_strided_batched g_rocsolver_cgetrf_strided_batched
+#define rocsolver_zgetrf_strided_batched g_rocsolver_zgetrf_strided_batched
+
+#define rocsolver_sgetrf_npvt g_rocsolver_sgetrf_npvt
+#define rocsolver_dgetrf_npvt g_rocsolver_dgetrf_npvt
+#define rocsolver_cgetrf_npvt g_rocsolver_cgetrf_npvt
+#define rocsolver_zgetrf_npvt g_rocsolver_zgetrf_npvt
+#define rocsolver_sgetrf_npvt_batched g_rocsolver_sgetrf_npvt_batched
+#define rocsolver_dgetrf_npvt_batched g_rocsolver_dgetrf_npvt_batched
+#define rocsolver_cgetrf_npvt_batched g_rocsolver_cgetrf_npvt_batched
+#define rocsolver_zgetrf_npvt_batched g_rocsolver_zgetrf_npvt_batched
+#define rocsolver_sgetrf_npvt_strided_batched g_rocsolver_sgetrf_npvt_strided_batched
+#define rocsolver_dgetrf_npvt_strided_batched g_rocsolver_dgetrf_npvt_strided_batched
+#define rocsolver_cgetrf_npvt_strided_batched g_rocsolver_cgetrf_npvt_strided_batched
+#define rocsolver_zgetrf_npvt_strided_batched g_rocsolver_zgetrf_npvt_strided_batched
+
+#define rocsolver_sgetrs g_rocsolver_sgetrs
+#define rocsolver_dgetrs g_rocsolver_dgetrs
+#define rocsolver_cgetrs g_rocsolver_cgetrs
+#define rocsolver_zgetrs g_rocsolver_zgetrs
+#define rocsolver_sgetrs_batched g_rocsolver_sgetrs_batched
+#define rocsolver_dgetrs_batched g_rocsolver_dgetrs_batched
+#define rocsolver_cgetrs_batched g_rocsolver_cgetrs_batched
+#define rocsolver_zgetrs_batched g_rocsolver_zgetrs_batched
+#define rocsolver_sgetrs_strided_batched g_rocsolver_sgetrs_strided_batched
+#define rocsolver_dgetrs_strided_batched g_rocsolver_dgetrs_strided_batched
+#define rocsolver_cgetrs_strided_batched g_rocsolver_cgetrs_strided_batched
+#define rocsolver_zgetrs_strided_batched g_rocsolver_zgetrs_strided_batched
+
+#define rocsolver_sgetri_outofplace_batched g_rocsolver_sgetri_outofplace_batched
+#define rocsolver_dgetri_outofplace_batched g_rocsolver_dgetri_outofplace_batched
+#define rocsolver_cgetri_outofplace_batched g_rocsolver_cgetri_outofplace_batched
+#define rocsolver_zgetri_outofplace_batched g_rocsolver_zgetri_outofplace_batched
+#define rocsolver_sgetri_npvt_outofplace_batched g_rocsolver_sgetri_npvt_outofplace_batched
+#define rocsolver_dgetri_npvt_outofplace_batched g_rocsolver_dgetri_npvt_outofplace_batched
+#define rocsolver_cgetri_npvt_outofplace_batched g_rocsolver_cgetri_npvt_outofplace_batched
+#define rocsolver_zgetri_npvt_outofplace_batched g_rocsolver_zgetri_npvt_outofplace_batched
+
+#define rocsolver_sgeqrf g_rocsolver_sgeqrf
+#define rocsolver_dgeqrf g_rocsolver_dgeqrf
+#define rocsolver_cgeqrf g_rocsolver_cgeqrf
+#define rocsolver_zgeqrf g_rocsolver_zgeqrf
+#define rocsolver_sgeqrf_ptr_batched g_rocsolver_sgeqrf_ptr_batched
+#define rocsolver_dgeqrf_ptr_batched g_rocsolver_dgeqrf_ptr_batched
+#define rocsolver_cgeqrf_ptr_batched g_rocsolver_cgeqrf_ptr_batched
+#define rocsolver_zgeqrf_ptr_batched g_rocsolver_zgeqrf_ptr_batched
+#define rocsolver_sgeqrf_strided_batched g_rocsolver_sgeqrf_strided_batched
+#define rocsolver_dgeqrf_strided_batched g_rocsolver_dgeqrf_strided_batched
+#define rocsolver_cgeqrf_strided_batched g_rocsolver_cgeqrf_strided_batched
+#define rocsolver_zgeqrf_strided_batched g_rocsolver_zgeqrf_strided_batched
+
+#define rocsolver_sgels g_rocsolver_sgels
+#define rocsolver_dgels g_rocsolver_dgels
+#define rocsolver_cgels g_rocsolver_cgels
+#define rocsolver_zgels g_rocsolver_zgels
+#define rocsolver_sgels_batched g_rocsolver_sgels_batched
+#define rocsolver_dgels_batched g_rocsolver_dgels_batched
+#define rocsolver_cgels_batched g_rocsolver_cgels_batched
+#define rocsolver_zgels_batched g_rocsolver_zgels_batched
+#define rocsolver_sgels_strided_batched g_rocsolver_sgels_strided_batched
+#define rocsolver_dgels_strided_batched g_rocsolver_dgels_strided_batched
+#define rocsolver_cgels_strided_batched g_rocsolver_cgels_strided_batched
+#define rocsolver_zgels_strided_batched g_rocsolver_zgels_strided_batched
+
+#endif
+
+bool try_load_rocsolver();
diff --git a/library/src/amd_detail/hipblas.cpp b/library/src/amd_detail/hipblas.cpp
index ee05f2a..ee2b630 100644
--- a/library/src/amd_detail/hipblas.cpp
+++ b/library/src/amd_detail/hipblas.cpp
@@ -22,12 +22,10 @@
  * ************************************************************************ */
 #define ROCBLAS_NO_DEPRECATED_WARNINGS
 #include "hipblas.h"
+#include "dlopen/load_rocsolver.hpp"
 #include "exceptions.hpp"
 #include "limits.h"
 #include "rocblas/rocblas.h"
-#ifdef __HIP_PLATFORM_SOLVER__
-#include "rocsolver/rocsolver.h"
-#endif
 #include <algorithm>
 #include <functional>
 #include <hip/library_types.h>
@@ -363,6 +361,10 @@ try
     if(!handle)
         return HIPBLAS_STATUS_HANDLE_IS_NULLPTR;
 
+    // if we don't have solver at build-time, we will be using
+    // dlopen to load it at runtime here
+    try_load_rocsolver();
+
     // Create the rocBLAS handle
     return hipblasConvertStatus(rocblas_create_handle((rocblas_handle*)handle));
 }
@@ -46029,14 +46031,14 @@ catch(...)
     return hipblas_exception_to_status();
 }
 
-#ifdef __HIP_PLATFORM_SOLVER__
-
 //--------------------------------------------------------------------------------------
 //rocSOLVER functions
 //--------------------------------------------------------------------------------------
 
 // The following functions are not included in the public API and must be declared
 
+#ifdef BUILD_WITH_SOLVER
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -46077,11 +46079,18 @@ rocblas_status rocsolver_zgeqrf_ptr_batched(rocblas_handle                handle
 }
 #endif
 
+#endif
+
 // getrf
 hipblasStatus_t hipblasSgetrf(
     hipblasHandle_t handle, const int n, float* A, const int lda, int* ipiv, int* info)
 try
 {
+    // should only try to load on first invocation,
+    // otherwise return static result
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(
             rocsolver_sgetrf((rocblas_handle)handle, n, n, A, lda, ipiv, info)));
@@ -46098,6 +46107,9 @@ hipblasStatus_t hipblasDgetrf(
     hipblasHandle_t handle, const int n, double* A, const int lda, int* ipiv, int* info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(
             rocsolver_dgetrf((rocblas_handle)handle, n, n, A, lda, ipiv, info)));
@@ -46114,6 +46126,9 @@ hipblasStatus_t hipblasCgetrf(
     hipblasHandle_t handle, const int n, hipblasComplex* A, const int lda, int* ipiv, int* info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_cgetrf(
             (rocblas_handle)handle, n, n, (rocblas_float_complex*)A, lda, ipiv, info)));
@@ -46134,6 +46149,9 @@ hipblasStatus_t hipblasZgetrf(hipblasHandle_t       handle,
                               int*                  info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_zgetrf(
             (rocblas_handle)handle, n, n, (rocblas_double_complex*)A, lda, ipiv, info)));
@@ -46150,6 +46168,9 @@ hipblasStatus_t hipblasCgetrf_v2(
     hipblasHandle_t handle, const int n, hipComplex* A, const int lda, int* ipiv, int* info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_cgetrf(
             (rocblas_handle)handle, n, n, (rocblas_float_complex*)A, lda, ipiv, info)));
@@ -46166,6 +46187,9 @@ hipblasStatus_t hipblasZgetrf_v2(
     hipblasHandle_t handle, const int n, hipDoubleComplex* A, const int lda, int* ipiv, int* info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_zgetrf(
             (rocblas_handle)handle, n, n, (rocblas_double_complex*)A, lda, ipiv, info)));
@@ -46188,6 +46212,9 @@ hipblasStatus_t hipblasSgetrfBatched(hipblasHandle_t handle,
                                      const int       batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_sgetrf_batched(
             (rocblas_handle)handle, n, n, A, lda, ipiv, n, info, batch_count)));
@@ -46209,6 +46236,9 @@ hipblasStatus_t hipblasDgetrfBatched(hipblasHandle_t handle,
                                      const int       batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_dgetrf_batched(
             (rocblas_handle)handle, n, n, A, lda, ipiv, n, info, batch_count)));
@@ -46230,6 +46260,9 @@ hipblasStatus_t hipblasCgetrfBatched(hipblasHandle_t       handle,
                                      const int             batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_cgetrf_batched((rocblas_handle)handle,
@@ -46259,6 +46292,9 @@ hipblasStatus_t hipblasZgetrfBatched(hipblasHandle_t             handle,
                                      const int                   batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_zgetrf_batched((rocblas_handle)handle,
@@ -46288,6 +46324,9 @@ hipblasStatus_t hipblasCgetrfBatched_v2(hipblasHandle_t   handle,
                                         const int         batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_cgetrf_batched((rocblas_handle)handle,
@@ -46317,6 +46356,9 @@ hipblasStatus_t hipblasZgetrfBatched_v2(hipblasHandle_t         handle,
                                         const int               batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_zgetrf_batched((rocblas_handle)handle,
@@ -46349,6 +46391,9 @@ hipblasStatus_t hipblasSgetrfStridedBatched(hipblasHandle_t     handle,
                                             const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_sgetrf_strided_batched(
             (rocblas_handle)handle, n, n, A, lda, strideA, ipiv, strideP, info, batch_count)));
@@ -46372,6 +46417,9 @@ hipblasStatus_t hipblasDgetrfStridedBatched(hipblasHandle_t     handle,
                                             const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_dgetrf_strided_batched(
             (rocblas_handle)handle, n, n, A, lda, strideA, ipiv, strideP, info, batch_count)));
@@ -46395,6 +46443,9 @@ hipblasStatus_t hipblasCgetrfStridedBatched(hipblasHandle_t     handle,
                                             const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_cgetrf_strided_batched((rocblas_handle)handle,
@@ -46434,6 +46485,9 @@ hipblasStatus_t hipblasZgetrfStridedBatched(hipblasHandle_t       handle,
                                             const int             batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_zgetrf_strided_batched((rocblas_handle)handle,
@@ -46473,6 +46527,9 @@ hipblasStatus_t hipblasCgetrfStridedBatched_v2(hipblasHandle_t     handle,
                                                const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_cgetrf_strided_batched((rocblas_handle)handle,
@@ -46512,6 +46569,9 @@ hipblasStatus_t hipblasZgetrfStridedBatched_v2(hipblasHandle_t     handle,
                                                const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_zgetrf_strided_batched((rocblas_handle)handle,
@@ -46553,6 +46613,9 @@ hipblasStatus_t hipblasSgetrs(hipblasHandle_t          handle,
                               int*                     info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46594,6 +46657,9 @@ hipblasStatus_t hipblasDgetrs(hipblasHandle_t          handle,
                               int*                     info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46635,6 +46701,9 @@ hipblasStatus_t hipblasCgetrs(hipblasHandle_t          handle,
                               int*                     info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46684,6 +46753,9 @@ hipblasStatus_t hipblasZgetrs(hipblasHandle_t          handle,
                               int*                     info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46733,6 +46805,9 @@ hipblasStatus_t hipblasCgetrs_v2(hipblasHandle_t          handle,
                                  int*                     info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46782,6 +46857,9 @@ hipblasStatus_t hipblasZgetrs_v2(hipblasHandle_t          handle,
                                  int*                     info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46833,6 +46911,9 @@ hipblasStatus_t hipblasSgetrsBatched(hipblasHandle_t          handle,
                                      const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46887,6 +46968,9 @@ hipblasStatus_t hipblasDgetrsBatched(hipblasHandle_t          handle,
                                      const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46941,6 +47025,9 @@ hipblasStatus_t hipblasCgetrsBatched(hipblasHandle_t          handle,
                                      const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -46995,6 +47082,9 @@ hipblasStatus_t hipblasZgetrsBatched(hipblasHandle_t             handle,
                                      const int                   batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47049,6 +47139,9 @@ hipblasStatus_t hipblasCgetrsBatched_v2(hipblasHandle_t          handle,
                                         const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47103,6 +47196,9 @@ hipblasStatus_t hipblasZgetrsBatched_v2(hipblasHandle_t          handle,
                                         const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47161,6 +47257,9 @@ hipblasStatus_t hipblasSgetrsStridedBatched(hipblasHandle_t          handle,
                                             const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47220,6 +47319,9 @@ hipblasStatus_t hipblasDgetrsStridedBatched(hipblasHandle_t          handle,
                                             const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47279,6 +47381,9 @@ hipblasStatus_t hipblasCgetrsStridedBatched(hipblasHandle_t          handle,
                                             const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47338,6 +47443,9 @@ hipblasStatus_t hipblasZgetrsStridedBatched(hipblasHandle_t          handle,
                                             const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47397,6 +47505,9 @@ hipblasStatus_t hipblasCgetrsStridedBatched_v2(hipblasHandle_t          handle,
                                                const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47456,6 +47567,9 @@ hipblasStatus_t hipblasZgetrsStridedBatched_v2(hipblasHandle_t          handle,
                                                const int                batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T && trans != HIPBLAS_OP_C)
@@ -47511,6 +47625,9 @@ hipblasStatus_t hipblasSgetriBatched(hipblasHandle_t handle,
                                      const int       batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_sgetri_outofplace_batched(
             (rocblas_handle)handle, n, A, lda, ipiv, n, C, ldc, info, batch_count)));
@@ -47534,6 +47651,9 @@ hipblasStatus_t hipblasDgetriBatched(hipblasHandle_t handle,
                                      const int       batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(hipblasConvertStatus(rocsolver_dgetri_outofplace_batched(
             (rocblas_handle)handle, n, A, lda, ipiv, n, C, ldc, info, batch_count)));
@@ -47557,6 +47677,9 @@ hipblasStatus_t hipblasCgetriBatched(hipblasHandle_t       handle,
                                      const int             batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_cgetri_outofplace_batched((rocblas_handle)handle,
@@ -47596,6 +47719,9 @@ hipblasStatus_t hipblasZgetriBatched(hipblasHandle_t             handle,
                                      const int                   batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_zgetri_outofplace_batched((rocblas_handle)handle,
@@ -47635,6 +47761,9 @@ hipblasStatus_t hipblasCgetriBatched_v2(hipblasHandle_t   handle,
                                         const int         batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_cgetri_outofplace_batched((rocblas_handle)handle,
@@ -47674,6 +47803,9 @@ hipblasStatus_t hipblasZgetriBatched_v2(hipblasHandle_t         handle,
                                         const int               batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(ipiv != nullptr)
         return HIPBLAS_DEMAND_ALLOC(
             hipblasConvertStatus(rocsolver_zgetri_outofplace_batched((rocblas_handle)handle,
@@ -47712,6 +47844,10 @@ hipblasStatus_t hipblasSgeqrf(hipblasHandle_t handle,
                               int*            info)
 try
 {
+
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47744,6 +47880,9 @@ hipblasStatus_t hipblasDgeqrf(hipblasHandle_t handle,
                               int*            info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47776,6 +47915,9 @@ hipblasStatus_t hipblasCgeqrf(hipblasHandle_t handle,
                               int*            info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47813,6 +47955,9 @@ hipblasStatus_t hipblasZgeqrf(hipblasHandle_t       handle,
                               int*                  info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47850,6 +47995,9 @@ hipblasStatus_t hipblasCgeqrf_v2(hipblasHandle_t handle,
                                  int*            info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47887,6 +48035,9 @@ hipblasStatus_t hipblasZgeqrf_v2(hipblasHandle_t   handle,
                                  int*              info)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47926,6 +48077,9 @@ hipblasStatus_t hipblasSgeqrfBatched(hipblasHandle_t handle,
                                      const int       batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47961,6 +48115,9 @@ hipblasStatus_t hipblasDgeqrfBatched(hipblasHandle_t handle,
                                      const int       batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -47996,6 +48153,9 @@ hipblasStatus_t hipblasCgeqrfBatched(hipblasHandle_t       handle,
                                      const int             batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48037,6 +48197,9 @@ hipblasStatus_t hipblasZgeqrfBatched(hipblasHandle_t             handle,
                                      const int                   batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48078,6 +48241,9 @@ hipblasStatus_t hipblasCgeqrfBatched_v2(hipblasHandle_t   handle,
                                         const int         batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48119,6 +48285,9 @@ hipblasStatus_t hipblasZgeqrfBatched_v2(hipblasHandle_t         handle,
                                         const int               batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48163,6 +48332,9 @@ hipblasStatus_t hipblasSgeqrfStridedBatched(hipblasHandle_t     handle,
                                             const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48200,6 +48372,9 @@ hipblasStatus_t hipblasDgeqrfStridedBatched(hipblasHandle_t     handle,
                                             const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48237,6 +48412,9 @@ hipblasStatus_t hipblasCgeqrfStridedBatched(hipblasHandle_t     handle,
                                             const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48282,6 +48460,9 @@ hipblasStatus_t hipblasZgeqrfStridedBatched(hipblasHandle_t       handle,
                                             const int             batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48327,6 +48508,9 @@ hipblasStatus_t hipblasCgeqrfStridedBatched_v2(hipblasHandle_t     handle,
                                                const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48372,6 +48556,9 @@ hipblasStatus_t hipblasZgeqrfStridedBatched_v2(hipblasHandle_t     handle,
                                                const int           batch_count)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(m < 0)
@@ -48419,6 +48606,9 @@ hipblasStatus_t hipblasSgels(hipblasHandle_t    handle,
                              int*               deviceInfo)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T)
@@ -48471,6 +48661,9 @@ hipblasStatus_t hipblasDgels(hipblasHandle_t    handle,
                              int*               deviceInfo)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T)
@@ -48523,6 +48716,9 @@ hipblasStatus_t hipblasCgels(hipblasHandle_t    handle,
                              int*               deviceInfo)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -48575,6 +48771,9 @@ hipblasStatus_t hipblasZgels(hipblasHandle_t       handle,
                              int*                  deviceInfo)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -48627,6 +48826,9 @@ hipblasStatus_t hipblasCgels_v2(hipblasHandle_t    handle,
                                 int*               deviceInfo)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -48679,6 +48881,9 @@ hipblasStatus_t hipblasZgels_v2(hipblasHandle_t    handle,
                                 int*               deviceInfo)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -48733,6 +48938,9 @@ hipblasStatus_t hipblasSgelsBatched(hipblasHandle_t    handle,
                                     const int          batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T)
@@ -48790,6 +48998,9 @@ hipblasStatus_t hipblasDgelsBatched(hipblasHandle_t    handle,
                                     const int          batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T)
@@ -48847,6 +49058,9 @@ hipblasStatus_t hipblasCgelsBatched(hipblasHandle_t       handle,
                                     const int             batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -48904,6 +49118,9 @@ hipblasStatus_t hipblasZgelsBatched(hipblasHandle_t             handle,
                                     const int                   batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -48961,6 +49178,9 @@ hipblasStatus_t hipblasCgelsBatched_v2(hipblasHandle_t    handle,
                                        const int          batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -49018,6 +49238,9 @@ hipblasStatus_t hipblasZgelsBatched_v2(hipblasHandle_t         handle,
                                        const int               batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -49078,6 +49301,9 @@ hipblasStatus_t hipblasSgelsStridedBatched(hipblasHandle_t     handle,
                                            const int           batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T)
@@ -49139,6 +49365,9 @@ hipblasStatus_t hipblasDgelsStridedBatched(hipblasHandle_t     handle,
                                            const int           batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_T)
@@ -49200,6 +49429,9 @@ hipblasStatus_t hipblasCgelsStridedBatched(hipblasHandle_t     handle,
                                            const int           batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -49261,6 +49493,9 @@ hipblasStatus_t hipblasZgelsStridedBatched(hipblasHandle_t       handle,
                                            const int             batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -49322,6 +49557,9 @@ hipblasStatus_t hipblasCgelsStridedBatched_v2(hipblasHandle_t     handle,
                                               const int           batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -49383,6 +49621,9 @@ hipblasStatus_t hipblasZgelsStridedBatched_v2(hipblasHandle_t     handle,
                                               const int           batchCount)
 try
 {
+    if(!try_load_rocsolver())
+        return HIPBLAS_STATUS_NOT_SUPPORTED;
+
     if(info == NULL)
         return HIPBLAS_STATUS_INVALID_VALUE;
     else if(trans != HIPBLAS_OP_N && trans != HIPBLAS_OP_C)
@@ -49428,8 +49669,6 @@ catch(...)
     return hipblas_exception_to_status();
 }
 
-#endif
-
 // gemm
 hipblasStatus_t hipblasHgemm(hipblasHandle_t    handle,
                              hipblasOperation_t transa,
diff --git a/library/src/nvidia_detail/hipblas.cpp b/library/src/nvidia_detail/hipblas.cpp
index 319c15d..e5c9b1d 100644
--- a/library/src/nvidia_detail/hipblas.cpp
+++ b/library/src/nvidia_detail/hipblas.cpp
@@ -31819,8 +31819,6 @@ hipblasStatus_t hipblasZdgmmStridedBatched_v2_64(hipblasHandle_t         handle,
     return HIPBLAS_STATUS_NOT_SUPPORTED;
 }
 
-#ifdef __HIP_PLATFORM_SOLVER__
-
 // getrf
 hipblasStatus_t hipblasSgetrf(
     hipblasHandle_t handle, const int n, float* A, const int lda, int* ipiv, int* info)
@@ -33235,8 +33233,6 @@ hipblasStatus_t hipblasZgelsStridedBatched_v2(hipblasHandle_t     handle,
     return HIPBLAS_STATUS_NOT_SUPPORTED;
 }
 
-#endif
-
 // gemm
 hipblasStatus_t hipblasHgemm(hipblasHandle_t    handle,
                              hipblasOperation_t transa,