Allow compilation to other target triples (#109)

Author: tshort

README.md

@@ -65,6 +65,8 @@ Hello, world!
 ```
 This latter approach comes with substantially more limitations, as you cannot rely on `libjulia` (see, e.g., [StaticTools.jl](https://github.com/brenhinkeller/StaticTools.jl) for some ways to work around these limitations).
 
+The low-level function `StaticCompiler.generate_obj` (not exported) generates object files. This can be used for more control of compilation. This can be used to cross-compile to other targets.
+
 ### Mixtape
 
 This feature allows one to change functionality when statically compiling. This uses code and API from [Mixtape](https://github.com/JuliaCompilerPlugins/Mixtape.jl) to transform lowered code much like [Cassette](https://github.com/JuliaLabs/Cassette.jl).

src/StaticCompiler.jl

@@ -115,15 +115,24 @@ end
 """
 ```julia
 generate_obj(f, tt, path::String = tempname(), name = GPUCompiler.safe_name(repr(f)), filenamebase::String="obj";
+            \tmixtape = NoContext(),
             \tstrip_llvm = false,
             \tstrip_asm  = true,
+            \ttarget = (),
             \topt_level=3,
             \tkwargs...)
 ```
 Low level interface for compiling object code (`.o`) for for function `f` given
 a tuple type `tt` characterizing the types of the arguments for which the
 function will be compiled.
 
+`mixtape` defines a context that can be used to transform IR prior to compilation using 
+[Mixtape](https://github.com/JuliaCompilerPlugins/Mixtape.jl) features.
+
+`target` can be used to change the output target. This is useful for compiling to WebAssembly and embedded targets.
+This is a named tuple with fields `triple`, `cpu`, and `features` (each of these are strings). 
+The defaults compile to the native target.
+
 ### Examples
 ```julia
 julia> fib(n) = n <= 1 ? n : fib(n - 1) + fib(n - 2)
@@ -144,12 +153,12 @@ function generate_obj(f, tt, external = true, path::String = tempname(), name =
                         strip_llvm = false,
                         strip_asm  = true,
                         opt_level=3,
+                        target = (),
                         kwargs...)
     mkpath(path)
     obj_path = joinpath(path, "$filenamebase.o")
-    tm = GPUCompiler.llvm_machine(external ? ExternalNativeCompilerTarget() : NativeCompilerTarget())
     #Get LLVM to generated a module of code for us. We don't want GPUCompiler's optimization passes.
-    job = CompilerJob(NativeCompilerTarget(), 
+    job = CompilerJob(NativeCompilerTarget(target...), 
                       FunctionSpec(f, tt, false, name), 
                       StaticCompilerParams(; 
                                             opt = true, 
@@ -162,6 +171,7 @@ function generate_obj(f, tt, external = true, path::String = tempname(), name =
 
     # Use Enzyme's annotation and optimization pipeline
     annotate!(mod)
+    tm = GPUCompiler.llvm_machine(external ? ExternalNativeCompilerTarget(target...) : NativeCompilerTarget(target...))
     optimize!(mod, tm)
 
     # Scoop up all the pointers in the optimized module, and replace them with unitialized global variables.

src/target.jl

@@ -36,11 +36,13 @@ macro device_override(ex)
 end
 
 Base.@kwdef struct NativeCompilerTarget <: GPUCompiler.AbstractCompilerTarget
+    triple::String=Sys.MACHINE
     cpu::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUName())
     features::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUFeatures())
 end
 
 Base.@kwdef struct ExternalNativeCompilerTarget <: GPUCompiler.AbstractCompilerTarget
+    triple::String=Sys.MACHINE
     cpu::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUName())
     features::String=(LLVM.version() < v"8") ? "" : unsafe_string(LLVM.API.LLVMGetHostCPUFeatures())
 end
@@ -57,7 +59,7 @@ end
 
 for target in (:NativeCompilerTarget, :ExternalNativeCompilerTarget)
     @eval begin
-        GPUCompiler.llvm_triple(::$target) = Sys.MACHINE
+        GPUCompiler.llvm_triple(target::$target) = target.triple
 
         function GPUCompiler.llvm_machine(target::$target)
             triple = GPUCompiler.llvm_triple(target)
@@ -94,17 +96,18 @@ function native_job(@nospecialize(func::Function), @nospecialize(types::Type), e
         mixtape = NoContext(),
         name = GPUCompiler.safe_name(repr(func)),
         kernel::Bool = false,
+        target = (),
         kwargs...
     )
     source = GPUCompiler.FunctionSpec(func, types, kernel, name)
-    target = external ? ExternalNativeCompilerTarget() : NativeCompilerTarget()
+    target = external ? ExternalNativeCompilerTarget(;target...) : NativeCompilerTarget(;target...)
     params = StaticCompilerParams(mixtape = mixtape)
     StaticCompiler.CompilerJob(target, source, params), kwargs
 end
 
-function native_job(@nospecialize(func), @nospecialize(types), external; mixtape = NoContext(), kernel::Bool=false, name=GPUCompiler.safe_name(repr(func)), kwargs...)
+function native_job(@nospecialize(func), @nospecialize(types), external; mixtape = NoContext(), kernel::Bool=false, name=GPUCompiler.safe_name(repr(func)), target = (), kwargs...)
     source = GPUCompiler.FunctionSpec(func, Base.to_tuple_type(types), kernel, name)
-    target = external ? ExternalNativeCompilerTarget() : NativeCompilerTarget()
+    target = external ? ExternalNativeCompilerTarget(;target...) : NativeCompilerTarget(;target...)
     params = StaticCompilerParams(mixtape = mixtape)
     GPUCompiler.CompilerJob(target, source, params), kwargs
 end

test/testintegration.jl

@@ -383,3 +383,9 @@ struct MyMix <: CompilationContext end
 
 end
 
+@testset "Cross compiling" begin
+
+    x, obj_path = StaticCompiler.generate_obj(x -> 2x, Tuple{Float64}, true, tempname(); target = (triple = "wasm32-unknown-wasi", cpu = "", features = ""))
+
+end
+