Be more lenient about which LLVM library to use.

Author: maleadt

lib/libLLVM_extra.jl

@@ -92,7 +92,7 @@ function LLVMAddNVVMReflectPass(PM::LLVMPassManagerRef, smversion)
 end
 else
 
-if libllvm_version < v"8.0"
+if version() < v"8.0"
     function LLVMAddNVVMReflectPass(PM::LLVMPassManagerRef, smversion)
         @apicall(:LLVMExtraAddNVVMReflectPass,Cvoid,(LLVMPassManagerRef,), PM)
     end
@@ -180,7 +180,7 @@ function LLVMExtraAddGenericAnalysisPasses(PM)
 end
 end
 
-if libllvm_version >= v"8.0"
+if version() >= v"8.0"
     @cenum(LLVMDebugEmissionKind,
         LLVMDebugEmissionKindNoDebug = 0,
         LLVMDebugEmissionKindFullDebug = 1,

src/LLVM.jl

@@ -7,79 +7,23 @@ using Libdl
 
 ## discovery
 
-using Libdl
-
-VERSION >= v"0.7.0-DEV.2576" || error("This version of LLVM.jl requires Julia 0.7")
-
-let
-    # find LLVM library
-
-    libllvm_paths = filter(Libdl.dllist()) do lib
-        occursin(r"LLVM\b", basename(lib))
-    end
-    if isempty(libllvm_paths)
-        error("""
-            Cannot find the LLVM library loaded by Julia.
-            Please use a version of Julia that has been built with USE_LLVM_SHLIB=1 (like the official binaries).
-            If you are, please file an issue and attach the output of `Libdl.dllist()`.""")
-    end
-    if length(libllvm_paths) > 1
-        error("""
-            Multiple LLVM libraries loaded by Julia.
-            Please file an issue and attach the output of `Libdl.dllist()`.""")
+export version
+
+# make sure we precompile again when LLVM changes (some definitions are version-dependent)
+global const libllvm = Sys.iswindows() ? :LLVM : :libLLVM
+Base.include_dependency(Libdl.dlpath(libllvm))
+
+const libllvm_version = Ref{VersionNumber}()
+function version()
+    if !isassigned(libllvm_version)
+        # FIXME: add a proper C API to LLVM
+        version_str = unsafe_string(
+            ccall((:_ZN4llvm16LTOCodeGenerator16getVersionStringEv, libllvm), Cstring, ()))
+        m = match(r"LLVM version (?<version>.+)", version_str)
+        m === nothing && error("Unrecognized version string: '$version_str'")
+        libllvm_version[] =VersionNumber(m[:version])
     end
-    global const libllvm = first(libllvm_paths)
-    Base.include_dependency(libllvm)
-
-    global const libllvm_version = Base.libllvm_version::VersionNumber
-
-    # figure out the supported targets by looking at initialization routines
-    lib = Libdl.dlopen(libllvm)
-    llvm_targets = [:AArch64, :AMDGPU, :ARC, :ARM, :AVR, :BPF, :Hexagon, :Lanai, :MSP430,
-                    :Mips, :NVPTX, :PowerPC, :RISCV, :Sparc, :SystemZ, :WebAssembly, :X86,
-                    :XCore]
-    global const libllvm_targets = filter(llvm_targets) do target
-        sym = Libdl.dlsym_e(lib, Symbol("LLVMInitialize$(target)Target"))
-        sym !== nothing
-    end
-    # TODO: figure out the name of the native target
-
-    @debug "Found LLVM v$libllvm_version at $libllvm with support for $(join(libllvm_targets, ", "))"
-
-
-    # find appropriate LLVM.jl wrapper
-
-    vercmp_match(a,b)  = a.major==b.major &&  a.minor==b.minor
-    vercmp_compat(a,b) = a.major>b.major  || (a.major==b.major && a.minor>=b.minor)
-
-    llvmjl_wrappers_path = joinpath(@__DIR__, "..", "lib")
-
-    llvmjl_wrappers = filter(path->isdir(joinpath(llvmjl_wrappers_path, path)),
-                                   readdir(llvmjl_wrappers_path))
-    @assert !isempty(llvmjl_wrappers)
-
-    matching_wrappers = filter(wrapper->vercmp_match(libllvm_version,
-                                                     VersionNumber(wrapper)),
-                                    llvmjl_wrappers)
-    global const llvmjl_wrapper = if !isempty(matching_wrappers)
-        @assert length(matching_wrappers) == 1
-        matching_wrappers[1]
-    else
-        compatible_wrappers = filter(wrapper->vercmp_compat(libllvm_version,
-                                                            VersionNumber(wrapper)),
-                                    llvmjl_wrappers)
-        isempty(compatible_wrappers) && error("Could not find any compatible wrapper for LLVM $(libllvm_version)")
-        last(compatible_wrappers)
-    end
-
-    @debug "Using LLVM.jl wrapper for LLVM v$llvmjl_wrapper"
-
-
-    # backwards-compatible flags
-
-    global const libllvm_system = false
-
-    global const configured = true
+    return libllvm_version[]
 end
 
 
@@ -130,19 +74,12 @@ include("deprecated.jl")
 ## initialization
 
 function __init__()
-    libllvm_paths = filter(Libdl.dllist()) do lib
-        occursin(r"LLVM\b", basename(lib))
-    end
-    if length(libllvm_paths) > 1
-        # NOTE: this still allows switching to a non-USE_LLVM_SHLIB version, but
-        #       there's no way to detect that since the new libLLVM is loaded before this...
-        cachefile = if VERSION >= v"1.3-"
-            Base.compilecache_path(Base.PkgId(LLVM))
-        else
-            abspath(DEPOT_PATH[1], Base.cache_file_entry(Base.PkgId(LLVM)))
-        end
-        rm(cachefile)
-        error("Your set-up changed, and LLVM.jl needs to be reconfigured. Please load the package again.")
+    libllvm_version = version()
+    @debug "Using LLVM $libllvm_version at $(Libdl.dlpath(libllvm))"
+    if libllvm_version.major != Base.libllvm_version.major ||
+       libllvm_version.minor != Base.libllvm_version.minor ||
+       libllvm_version.patch != Base.libllvm_version.patch
+        @warn "Using a different version of LLVM ($libllvm_version) than the one shipped with Julia ($(Base.libllvm_version)); this is unsupported"
     end
 
     _install_handlers()

src/core/module.jl

@@ -194,7 +194,7 @@ end
 ## module flag iteration
 # TODO: doesn't actually iterate, since we can't list the available keys
 
-if libllvm_version >= v"8.0"
+if version() >= v"8.0"
 
 export flags
 

src/debuginfo.jl

@@ -4,7 +4,7 @@ DEBUG_METADATA_VERSION() = API.LLVMDebugMetadataVersion()
 
 strip_debuginfo!(mod::Module) = API.LLVMStripModuleDebugInfo(ref(mod))
 
-if libllvm_version >= v"8.0"
+if version() >= v"8.0"
 set_subprogram!(func::Function, sp::Metadata) = LLVM.API.LLVMSetSubprogram(ref(func), ref(sp))
 get_subprogram(func::Function) = Metadata(LLVM.API.LLVMGetSubprogram(ref(func)))
 end

src/init.jl

@@ -1,11 +1,6 @@
 ## subsystem initialization
 
-export version, Shutdown,
-       ismultithreaded
-
-function version()
-    return libllvm_version
-end
+export Shutdown, ismultithreaded
 
 ismultithreaded() = convert(Core.Bool, API.LLVMIsMultithreaded())
 
@@ -22,6 +17,19 @@ end
 
 ## target initialization
 
+# figure out the supported targets by looking at initialization routines
+# TODO: figure out the name of the native target
+let
+    lib = Libdl.dlopen(libllvm)
+    known_targets = [:AArch64, :AMDGPU, :ARC, :ARM, :AVR, :BPF, :Hexagon, :Lanai, :MSP430,
+                     :Mips, :NVPTX, :PowerPC, :RISCV, :Sparc, :SystemZ, :WebAssembly, :X86,
+                     :XCore]
+    global const libllvm_targets = filter(known_targets) do target
+        sym = Libdl.dlsym_e(lib, Symbol("LLVMInitialize$(target)Target"))
+        sym !== nothing
+    end
+end
+
 for component in [:TargetInfo, :Target, :TargetMC, :AsmPrinter, :AsmParser, :Disassembler]
     jl_fname = Symbol(:Initialize, :All, component, :s)
     api_fname = Symbol(:LLVM, jl_fname)