Merge pull request #188 from maleadt/tb/simplify_init

Simplify library selection

Author: maleadt

lib/6.0/libLLVM_common.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,

lib/6.0/libLLVM_h.jl

@@ -7,79 +7,29 @@ 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()`.""")
-    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)
+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_print = unsafe_string(
+            ccall((:_ZN4llvm16LTOCodeGenerator16getVersionStringEv, libllvm), Cstring, ()))
+        m = match(r"LLVM version (?<version>.+)", version_print)
+        m === nothing && error("Unrecognized version string: '$version_print'")
+        libllvm_version[] = if endswith(m[:version], "jl")
+            # strip the "jl" SONAME suffix (JuliaLang/julia#33058)
+            # (LLVM does never report a prerelease version anyway)
+            VersionNumber(m[:version][1:end-2])
+        else
+            VersionNumber(m[:version])
+        end
     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
 
 
@@ -92,12 +42,12 @@ include("base.jl")
 module API
 using CEnum
 using ..LLVM
-using ..LLVM: @apicall, libllvm_version
+using ..LLVM: @apicall
 const off_t = Csize_t
-libdir = joinpath(@__DIR__, "..", "lib", LLVM.llvmjl_wrapper)
+libdir = joinpath(@__DIR__, "..", "lib")
 include(joinpath(libdir, "libLLVM_common.jl"))
 include(joinpath(libdir, "libLLVM_h.jl"))
-include(joinpath(libdir, "..", "libLLVM_extra.jl"))
+include(joinpath(libdir, "libLLVM_extra.jl"))
 end
 
 # LLVM API wrappers
@@ -130,19 +80,10 @@ 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 != Base.libllvm_version
+        @warn "Using a different version of LLVM ($libllvm_version) than the one shipped with Julia ($(Base.libllvm_version)); this is unsupported"
     end
 
     _install_handlers()

lib/8.0/libLLVM_common.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
 

lib/8.0/libLLVM_h.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