Add LBT_USE_RTLD_DEEPBIND capability

Certain tools such as sanitizers don't like us loading libraries with
`RTLD_DEEPBIND`, so since we already have the workarounds in place for
systems that don't have `RTLD_DEEPBIND` at all, let's change these from
using compile-time constants to instead use a runtime switch that can be
overridden through setting the environment variable
`LBT_USE_RTLD_DEEPBIND=0` before running our program.

Author: staticfloat

src/Make.inc

@@ -40,6 +40,10 @@ ifeq ($(OS),Linux)
 LDFLAGS += -ldl
 # We also want `-fvisibility=protected` on Linux, to match other platforms
 CFLAGS += -fvisibility=protected
+# There are bugs with `-fvisibility=protected` and certain versions of `ld`,
+# see https://sourceware.org/bugzilla/show_bug.cgi?id=26815 for more
+# We work around this by using `gold` on Linux
+LDFLAGS += -fuse-ld=gold
 endif
 
 ifeq ($(OS),WINNT)

src/Makefile

@@ -5,7 +5,7 @@ include $(LBT_ROOT)/src/Make.inc
 all: $(builddir)/libblastrampoline.$(SHLIB_EXT)
 
 # Objects we'll build
-MAIN_OBJS := libblastrampoline.o dl_utils.o config.o autodetection.o threading.o deepbindless_surrogates.o trampolines/trampolines_$(ARCH).o
+MAIN_OBJS := libblastrampoline.o dl_utils.o config.o autodetection.o threading.o deepbindless.o trampolines/trampolines_$(ARCH).o
 
 # Include win_utils.c on windws
 ifeq ($(OS),WINNT)

src/autodetection.c

@@ -46,13 +46,15 @@ int32_t autodetect_blas_interface(void * isamax_addr) {
     int64_t incx = 1;
 
     // Override `lsame_` to point to our `fake_lsame` if we're unable to `RTLD_DEEPBIND`
-#ifdef LBT_DEEPBINDLESS
-    push_fake_lsame();
-#endif
+    if (use_deepbind == 0) {
+        push_fake_lsame();
+    }
+
     int64_t max_idx = isamax(&n, X, &incx);
-#ifdef LBT_DEEPBINDLESS
-    pop_fake_lsame();
-#endif
+
+    if (use_deepbind == 0) {
+        pop_fake_lsame();
+    }
 
     // Although we declare that `isamax` returns an `int64_t`, it may not actually do so,
     // since if it's an LP64 binary it's probably returning an `int32_t`.  Depending on the

src/deepbindless_surrogates.c renamed to src/deepbindless.c

@@ -1,6 +1,20 @@
 #include "libblastrampoline_internal.h"
 
-#if defined(LBT_DEEPBINDLESS)
+/*
+ * Users can force an RTLD_DEEPBIND-capable system to avoid using RTLD_DEEPBIND
+ * by setting `LBT_USE_RTLD_DEEPBIND=0` in their environment.  This function
+ * returns `0x01` if it will use `RTLD_DEEPBIND` when loading a library, and
+ * `0x00` otherwise.
+ */
+#if defined(LBT_DEEPBINDLESS) || !defined(RTLD_DEEPBIND)
+uint8_t use_deepbind = 0x00;
+#else
+uint8_t use_deepbind = 0x01;
+#endif
+LBT_DLLEXPORT const uint8_t lbt_get_use_deepbind() {
+    return use_deepbind;
+}
+
 
 int lsame_idx = -1;
 const void *old_lsame32 = NULL, *old_lsame64 = NULL;
@@ -76,5 +90,3 @@ int fake_lsame(char * ca, char * cb) {
     }
     return inta == intb;
 }
-
-#endif // LBT_DEEPBINDLESS

src/dl_utils.c

@@ -22,6 +22,7 @@ void throw_dl_error(const char * path) {
 
 /*
  * Load the given `path`, using `RTLD_NOW | RTLD_LOCAL` and `RTLD_DEEPBIND`, if available
+ * If `use_deepbind` is set to `0`, don't use `RTLD_DEEPBIND` even if it's available.
  */
 void * load_library(const char * path) {
     void * new_handle = NULL;
@@ -34,13 +35,21 @@ void * load_library(const char * path) {
     }
     new_handle = (void *)LoadLibraryExW(wpath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
 #else
-    // If we have `RTLD_DEEPBIND`, use it!
+
+    // If `use_deepbind` is set to `0`, we voluntarily avoid using
+    // `RTLD_DEEPBIND` even if it's available.  This is primarily used
+    // in conjunction with sanitizer tools, which abhor the presence of
+    // deepbound libraries.
+    if (use_deepbind == 0) {
+        new_handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+    }
 #if defined(RTLD_DEEPBIND)
-    new_handle = dlopen(path, RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);
-#else
-    new_handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
-#endif
+    else {
+        new_handle = dlopen(path, RTLD_NOW | RTLD_LOCAL | RTLD_DEEPBIND);
+    }
 #endif
+#endif  // defined(_OS_WINDOWS_)
+
     if (new_handle == NULL) {
         throw_dl_error(path);
     }

src/libblastrampoline.c

@@ -52,7 +52,7 @@ int32_t set_forward_by_index(int32_t symbol_idx, const void * addr, int32_t inte
     } else {
         (*exported_func64_addrs[symbol_idx]) = addr;
 
-        // If we're on an RTLD_DEEPBINDless system and our workaround is activated,
+        // If we're on an RTLD_DEEPBIND-less system and our workaround is activated,
         // we take over our own 32-bit symbols as well.
         if (deepbindless_interfaces_loaded & DEEPBINDLESS_INTERFACE_ILP64_LOADED) {
             (*exported_func32_addrs[symbol_idx]) = addr;
@@ -230,7 +230,7 @@ LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t v
      * attempts to load another one without setting the `clear` flag, we refuse to
      * load it on a deepbindless system, printing out to `stderr` if we're verbose.
      */
-#if defined(LBT_DEEPBINDLESS)
+
     // If `clear` is set, we clear our tracking
     if (clear) {
         deepbindless_interfaces_loaded = 0x00;
@@ -240,13 +240,13 @@ LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t v
     // we bind to the suffix-"" names, so even if the names of that library
     // internally are suffixed to something else, we ourselves will interfere with
     // a future suffix-"" ILP64 BLAS.
-    if (interface == LBT_INTERFACE_LP64) {
+    if ((use_deepbind == 0x00) && (interface == LBT_INTERFACE_LP64)) {
         deepbindless_interfaces_loaded |= DEEPBINDLESS_INTERFACE_LP64_LOADED;
     }
 
     // We only mark a loaded ILP64 BLAS if it is a suffix-"" BLAS, since that is
     // the only case in which it will interfere with our LP64 BLAS symbols.
-    if (lib_suffix[0] == '\0' && interface == LBT_INTERFACE_ILP64) {
+    if ((use_deepbind == 0x00) && (lib_suffix[0] == '\0' && interface == LBT_INTERFACE_ILP64)) {
         deepbindless_interfaces_loaded |= DEEPBINDLESS_INTERFACE_ILP64_LOADED;
     }
 
@@ -257,7 +257,6 @@ LBT_DLLEXPORT int32_t lbt_forward(const char * libname, int32_t clear, int32_t v
         }
         return 0;
     }
-#endif
 
     // If `clear` is set, drop all information about previously-loaded libraries
     if (clear) {
@@ -307,6 +306,19 @@ __attribute__((constructor)) void init(void) {
         printf("libblastrampoline initializing\n");
     }
 
+#if !defined(LBT_DEEPBINDLESS)
+    // If LBT_USE_RTLD_DEEPBIND == "0", we avoid using RTLD_DEEPBIND on a
+    // deepbind-capable system.  This is mostly useful for sanitizers, which
+    // abhor such library loading shenanigans.
+    const char * deepbindless_str = getenv("LBT_USE_RTLD_DEEPBIND");
+    if (deepbindless_str != NULL && strcmp(deepbindless_str, "0") == 0) {
+        use_deepbind = 0x00;
+        if (verbose) {
+            printf("LBT_USE_RTLD_DEEPBIND=0 detected; avoiding usage of RTLD_DEEPBIND\n");
+        }
+    }
+#endif // !defined(LBT_DEEPBINDLESS)
+
     // LBT_DEFAULT_LIBS is a semicolon-separated list of paths that should be loaded as BLAS libraries
     const char * default_libs = getenv("LBT_DEFAULT_LIBS");
     if (default_libs != NULL) {

src/libblastrampoline.h

@@ -161,6 +161,13 @@ LBT_DLLEXPORT void lbt_default_func_print_error();
  */
 LBT_DLLEXPORT const void * lbt_get_default_func();
 
+/*
+ * Users can force an RTLD_DEEPBIND-capable system to avoid using RTLD_DEEPBIND by setting
+ * `LBT_USE_RTLD_DEEPBIND=0` in their environment.  This function returns `0x01` if it will
+ *  use `RTLD_DEEPBIND` when loading a library, and `0x00` otherwise.
+ */
+ LBT_DLLEXPORT const uint8_t lbt_get_use_deepbind();
+
 /*
  * Sets the default function that gets called if no mapping has been set for an exported symbol.
  * `NULL` is a valid address, if a segfault upon calling an uninitialized function is desirable.

src/libblastrampoline_internal.h

@@ -82,9 +82,8 @@ int32_t autodetect_interface(void * handle, const char * suffix);
 int autodetect_f2c(void * handle, const char * suffix);
 #endif
 
-#ifdef LBT_DEEPBINDLESS
 // Functions in deepbindless_surrogates.c
 void push_fake_lsame();
 void pop_fake_lsame();
 int fake_lsame(char * ca, char * cb);
-#endif
+extern uint8_t use_deepbind;