Don't depend on CompilerSupportLibraries_jll from OpenBLAS_jll

This is important because CSL_jll loads in many other libraries that we
may or may not care that much about, such as `libstdc++` and
`libgomp`.

We load `libstdc++` eagerly on Linux, so that will already be loaded in
all cases that we care about, however on macOS we don't generally want
that loaded, and this suppresses that.

`libgomp` is needed by BB-provided software that uses OpenMP during
compilation, however it can conflict with software compiled by the Intel
compilers, such as `MKL`.  It's best to allow MKL to load its OpenMP
libraries first, so delaying loading `libgomp` until someone actually
calls `using CompilerSupportLibraries_jll` is the right thing to do.

In the future, we want to rework JLLs such that libraries aren't eagerly
loaded at JLL `__init__()` time, but rather they should be JIT loaded
upon first usage of the library handle itself.  This would allow BB to
emit much more fine-grained dependency structures, so that the
distribution of a set of libraries can happen together, but the loading
of said libraries would be independent.

Author: staticfloat

stdlib/OpenBLAS_jll/Project.toml

@@ -3,6 +3,7 @@ uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
 version = "0.3.23+0"
 
 [deps]
+# See note in `src/OpenBLAS_jll.jl` about this dependency.
 CompilerSupportLibraries_jll = "e66e0078-7015-5450-92f7-15fbd957f2ae"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Artifacts = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

stdlib/OpenBLAS_jll/src/OpenBLAS_jll.jl

@@ -2,7 +2,17 @@
 
 ## dummy stub for https://github.com/JuliaBinaryWrappers/OpenBLAS_jll.jl
 baremodule OpenBLAS_jll
-using Base, Libdl, CompilerSupportLibraries_jll, Base.BinaryPlatforms
+using Base, Libdl, Base.BinaryPlatforms
+
+# We are explicitly NOT loading this at runtime, as it contains `libgomp`
+# which conflicts with `libiomp5`, breaking things like MKL.  In the future,
+# we hope to transition to a JLL interface that provides a more granular
+# interface than eagerly dlopen'ing all libraries provided in the JLL
+# which will eliminate issues like this, where we avoid loading a JLL
+# because we don't want to load a library that we don't even use yet.
+# using CompilerSupportLibraries_jll
+# Because of this however, we have to manually load the libraries we
+# _do_ care about, namely libgfortran
 Base.Experimental.@compiler_options compile=min optimize=0 infer=false
 
 const PATH_list = String[]
@@ -25,10 +35,13 @@ end
 
 if Sys.iswindows()
     const libopenblas = "libopenblas$(libsuffix).dll"
+    const _libgfortran = string("libgfortran-", libgfortran_version(HostPlatform()).major, ".dll")
 elseif Sys.isapple()
     const libopenblas = "@rpath/libopenblas$(libsuffix).dylib"
+    const _libgfortran = string("@rpath/", "libgfortran.", libgfortran_version(HostPlatform()).major, ".dylib")
 else
     const libopenblas = "libopenblas$(libsuffix).so"
+    const _libgfortran = string("libgfortran.so.", libgfortran_version(HostPlatform()).major)
 end
 
 function __init__()
@@ -50,6 +63,10 @@ function __init__()
         ENV["OPENBLAS_DEFAULT_NUM_THREADS"] = "1"
     end
 
+    # As mentioned above, we are sneaking this in here so that we don't have to
+    # depend on CSL_jll and load _all_ of its libraries.
+    dlopen(_libgfortran)
+
     global libopenblas_handle = dlopen(libopenblas)
     global libopenblas_path = dlpath(libopenblas_handle)
     global artifact_dir = dirname(Sys.BINDIR)