Add suffix_hint parameter to lbt_forward()

If a dual-interface library is being loaded, any heuristic will always
choose the first interface it finds, so we add `suffix_hint` to allow
biasing the interface detection toward a known-good suffix.  This allows
for loading dual-interface MKL (If using v2022+) by first loading one
interface, then the other without clearing in between.

Author: staticfloat

src/autodetection.c

@@ -5,7 +5,7 @@
  * We are primarily concerned with the FORTRAN names, so we automatically append
  * an underscore to the end, as is standard.
  */
-const char * autodetect_symbol_suffix(void * handle) {
+const char * autodetect_symbol_suffix(void * handle, const char * suffix_hint) {
     // We auto-detect the symbol suffix of the given library by searching for common
     // BLAS and LAPACK symbols, combined with various suffixes that we know of.
     const char * symbol_names[] = {
@@ -15,14 +15,26 @@ const char * autodetect_symbol_suffix(void * handle) {
         "dpotrf_",
     };
     const char * suffixes[] = {
-        // First, LP64-mangling suffixes: No underscore, single underscore, double underscore
+        // Possibly-NULL suffix that we should search over
+        suffix_hint,
+
+        // Search for ILP64-mangling suffixes first, as in the rare case that we want to
+        // load a library that exports both, we prefer to bind to the namespaced symbols first
+        "64", "64_", "_64__", "__64___",
+
+        // Next, LP64-mangling suffixes
         "", "_", "__",
-        // Next, ILP64-mangling suffixes: the same, but with the suffix prepended as well:
-        "64_", "_64__", "__64___",
     };
+
+    // If the suffix hint is NULL, just skip it when calling `lookup_symbol()`.
+    int suffix_start_idx = 0;
+    if (suffix_hint == NULL) {
+        suffix_start_idx = 1;
+    }
+
     char symbol_name[MAX_SYMBOL_LEN];
     for (int symbol_idx=0; symbol_idx<sizeof(symbol_names)/sizeof(const char *); symbol_idx++) {
-        for (int suffix_idx=0; suffix_idx<sizeof(suffixes)/sizeof(const char *); suffix_idx++) {
+        for (int suffix_idx=suffix_start_idx; suffix_idx<sizeof(suffixes)/sizeof(const char *); suffix_idx++) {
             sprintf(symbol_name, "%s%s", symbol_names[symbol_idx], suffixes[suffix_idx]);
             if (lookup_symbol(handle, symbol_name) != NULL) {
                 return suffixes[suffix_idx];

src/libblastrampoline.c

@@ -147,7 +147,7 @@ LBT_DLLEXPORT int32_t lbt_set_forward(const char * symbol_name, const void * add
 /*
  * Load `libname`, clearing previous mappings if `clear` is set.
  */
-LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t verbose) {
+LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t verbose, const char * suffix_hint) {
     if (verbose) {
         printf("Generating forwards to %s\n", libname);
     }
@@ -161,7 +161,7 @@ LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t v
 
     // Once we have the BLAS/LAPACK library loaded, we need to autodetect a few things about it.
     // First, we are going to figure out its name-mangling suffix:
-    const char * lib_suffix = autodetect_symbol_suffix(handle);
+    const char * lib_suffix = autodetect_symbol_suffix(handle, suffix_hint);
     if (lib_suffix == NULL) {
         fprintf(stderr, "Unable to autodetect symbol suffix of \"%s\"\n", libname);
         return 0;
@@ -340,7 +340,7 @@ __attribute__((constructor)) void init(void) {
                 curr_lib_start++;
 
             // Load functions from this library, clearing only the first time.
-            lbt_forward(curr_lib, clear, verbose);
+            lbt_forward(curr_lib, clear, verbose, NULL);
             clear = 0;
         }
     }

src/libblastrampoline.h

@@ -106,8 +106,12 @@ typedef struct {
  * support in the system libc for more details.
  *
  * If `verbose` is set to a non-zero value, it will print out debugging information.
+ *
+ * If `suffix_hint` is set to a non-NULL value, it is the first suffix that is used to search for
+ * BLAS/LAPACK symbols within the library.  This is useful in case a library contains within it both
+ * LP64 and ILP64 symbols, and you want to prefer one set of symbols over the other.
  */
-LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t verbose);
+LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t verbose, const char * suffix_hint);
 
 /*
  * Returns a structure describing the currently-loaded libraries as well as the build configuration

src/libblastrampoline_internal.h

@@ -73,7 +73,7 @@ void * lookup_symbol(const void * lib_handle, const char * symbol_name);
 void close_library(void * handle);
 
 // Functions in `autodetection.c`
-const char * autodetect_symbol_suffix(void * handle);
+const char * autodetect_symbol_suffix(void * handle, const char * suffix_hint);
 int32_t autodetect_blas_interface(void * isamax_addr);
 int32_t autodetect_lapack_interface(void * dpotrf_addr);
 int32_t autodetect_interface(void * handle, const char * suffix);

test/utils.jl

@@ -102,8 +102,8 @@ struct lbt_config_t
 end
 const LBT_BUILDFLAGS_F2C_CAPABLE = 0x02
 
-function lbt_forward(handle, path; clear::Bool = false, verbose::Bool = false)
-    ccall(dlsym(handle, :lbt_forward), Int32, (Cstring, Int32, Int32), path, clear ? 1 : 0, verbose ? 1 : 0)
+function lbt_forward(handle, path; clear::Bool = false, verbose::Bool = false, suffix_hint::Union{Nothing,String} = nothing)
+    ccall(dlsym(handle, :lbt_forward), Int32, (Cstring, Int32, Int32, Cstring), path, clear ? 1 : 0, verbose ? 1 : 0, something(suffix_hint, C_NULL))
 end
 
 function lbt_get_config(handle)