Successful unaryop compilation on macOS

Author: rayegun

src/SuiteSparseGraphBLAS.jl

@@ -193,11 +193,12 @@ function __init__()
     global irscratch = @get_scratch!("irscratch")
     gbset!(:jit_cache, gbscratch)
     llvmdir = joinpath(LLVM_jll.artifact_dir, "lib")
-    gbset!(:jit_compilername, "DYLD_FALLBACK_LIBRARY_PATH=$(llvmdir):$(Clang_jll.LIBPATH[]) $(Clang_jll.get_clang_path()) -v")
+    gbset!(:jit_compilername, "DYLD_FALLBACK_LIBRARY_PATH=$(llvmdir):$(Clang_jll.LIBPATH[]) $(Clang_jll.get_clang_path())")
     gbset!(:jit_cmake, CMake_jll.get_cmake_path())
-    gbset!(:jit_compilerflags, "-O3 -DNDEBUG -fopenmp -fPIC -flto -arch arm64 -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk")
+    gbset!(:jit_compilerflags, "-O3 -DNDEBUG -fopenmp -fPIC -flto -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX13.3.sdk")
     gbset!(:jit_linkerflags, "-lto_library $(llvmdir)/libLTO.dylib -lm -ldl -dynamiclib -fuse-ld=lld")
     gbset!(:jit_cmakelibraries, "m;dl;$(CompilerSupportLibraries_jll.get_libgomp_path())")
+    gbset!(:jit_errorlog, "/dev/null")
     # gbset!(:nthreads, BLAS.get_num_threads())
 
     # Set printing done by SuiteSparse:GraphBLAS to base-1 rather than base-0.

src/operators/compiler.jl

@@ -1,17 +1,20 @@
 module OperatorCompiler
 using GPUCompiler, LLVM, StaticTools
 using StaticTools: @c_str
+import Clang_jll
 
 fixname(f::Function) = fixname(string(nameof(f)))
 fixname(s) = String(GPUCompiler.safe_name(s))
 
 function llvmmodule(@nospecialize(f), @nospecialize(tt), name = "jl" * fixname(f))
-    job = operatorjob(f, tt; name)
-    return compiler(job)
+    job = operatorjob(f, f, tt; name)
+    GPUCompiler.JuliaContext() do ctx
+        GPUCompiler.codegen(:llvm, job; strip=true, validate=false)
+    end
 end
 
 function compiler(job)
-    mod, _ = GPUCompiler.JuliaContext() do ctx
+    return GPUCompiler.JuliaContext() do ctx
         GPUCompiler.codegen(:llvm, job; strip=true, validate=false)
     end
     return mod
@@ -67,7 +70,7 @@ Base.Experimental.@overlay operatortable (@noinline Base.Math.cos_domain_error(x
 #####################
 
 Base.@kwdef struct BitcodeCompilerTarget <: GPUCompiler.AbstractCompilerTarget
-    triple::String = Sys.MACHINE
+    triple::String = readchomp(`$(Clang_jll.clang) --print-effective-triple`)
     cpu::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUName())
     features::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUFeatures())
 end
@@ -95,7 +98,7 @@ struct OperatorCompilerParams{F, F2} <: AbstractCompilerParams
 end
 
 
-function operatorjob(@nospecialize(f), @nospecialize(f2), @nospecialize(tt); target=BitcodeCompilerTarget(), name = "jl" * fixname(f))
+function operatorjob(@nospecialize(f), @nospecialize(f2), @nospecialize(tt); target=BitcodeCompilerTarget(), name = nothing)
     T = Base.to_tuple_type(tt)
     source = GPUCompiler.methodinstance(typeof(f2), T)
     config = CompilerConfig(

src/operators/unaryops.jl

@@ -6,6 +6,7 @@ using ..SuiteSparseGraphBLAS: isGxB, isGrB, GBType,
     GBArrayOrTranspose, AbstractTypedOp, @wraperror, load_global, OperatorCompiler, gbset!, irscratch
 using ..LibGraphBLAS
 using GPUCompiler
+import LLVM
 export unaryop, @unop
 
 export rowindex, colindex, frexpx, frexpe
@@ -79,21 +80,17 @@ const COMPILEDUNARYOPS = Dict()
 const BUILTINUNARYOPS = Dict{<:Any, <:Any}() # (f) -> name, inputtypes
 
 function linker(job, compiled)
-    ir = compiled
+    ir, meta = compiled
     (; fn, c_fn, intypes) = job.config.params
     write(joinpath(irscratch, "$(hash(ir)).o"), ir)
     return TypedUnaryOperator{typeof(fn), eltype(intypes[2]), eltype(intypes[1])}(
-        false, false, job.config.name, LibGraphBLAS.GrB_UnaryOp(), fn, c_fn; docompilation = true, ir = joinpath(irscratch, "$(hash(ir)).o")
+        false, false, LLVM.name(meta[:entry]), LibGraphBLAS.GrB_UnaryOp(), fn, c_fn; docompilation = true, ir = joinpath(irscratch, "$(hash(ir)).o")
     )
 end
 
-function unarycachecompile(f, ::Type{T}) where T
-    function unaryopfn(z, x)
-        Base.unsafe_store!(z, f(Base.unsafe_load(x)))
-        return nothing
-    end
+function unarycachecompile(f, ptrfunction, ::Type{T}) where T
     O = Base.Broadcast.combine_eltypes(f, (T,))
-    job = OperatorCompiler.operatorjob(f, unaryopfn, (Ptr{O}, Ptr{T},))
+    job = OperatorCompiler.operatorjob(f, ptrfunction, (Ptr{O}, Ptr{T},))
     return GPUCompiler.cached_compilation(
         COMPILEDUNARYOPS, job.source, job.config,
         OperatorCompiler.compiler, linker
@@ -120,10 +117,17 @@ function unaryop(f, ::Type{T}) where T
             return nothing
         end
     end
-    if maybeop !== nothing
+    if maybeop isa TypedUnaryOperator
         return maybeop
+    elseif maybeop === nothing
+        function unaryopfn(z, x)
+            Base.unsafe_store!(z, f(Base.unsafe_load(x)))
+            return nothing
+        end
+        UNARYOPS[(f, t)] = unaryopfn
+        return unarycachecompile(f, unaryopfn, T)
     else
-        return unarycachecompile(f, T)
+        return unarycachecompile(f, maybeop, T)
     end
 end