Add way to set compiler for cross target and also bump major version

Author: gbaraldi

Project.toml

@@ -1,7 +1,7 @@
 name = "StaticCompiler"
 uuid = "81625895-6c0f-48fc-b932-11a18313743c"
 authors = ["Tom Short and contributors"]
-version = "0.6.2"
+version = "0.7.0"
 
 [deps]
 Clang_jll = "0ee61d77-7f21-5576-8119-9fcc46b10100"

src/StaticCompiler.jl

@@ -13,7 +13,7 @@ using StaticTools
 using StaticTools: @symbolcall, @c_str, println
 using Core: MethodTable
 using Base:BinaryPlatforms.Platform, BinaryPlatforms.HostPlatform, BinaryPlatforms.arch, BinaryPlatforms.os_str, BinaryPlatforms.libc_str
-
+using Base:BinaryPlatforms.platform_dlext
 export load_function, compile_shlib, compile_executable
 export static_code_llvm, static_code_typed, static_llvm_module, static_code_native
 export @device_override, @print_and_throw
@@ -294,7 +294,12 @@ function generate_executable(funcs::Union{Array,Tuple}, path=tempname(), name=fi
     exec_path = joinpath(path, filename)
     _, obj_path = generate_obj(funcs, path, filename; demangle, target, kwargs...)
     # Pick a compiler
-    cc = Sys.isapple() ? `cc` : clang()
+    if !isnothing(target.compiler)
+        cc = `$(target.compiler)`
+    else
+        cc = Sys.isapple() ? `cc` : clang()
+    end
+
     # Compile!
     if Sys.isapple()
         # Apple no longer uses _start, so we can just specify a custom entry
@@ -372,12 +377,19 @@ function generate_shlib(funcs::Union{Array,Tuple}, path::String=tempname(), file
         target::StaticTarget=StaticTarget(),
         kwargs...
     )
-
-    lib_path = joinpath(path, "$filename.$(Libdl.dlext)")
+    if !isnothing(target.platform)
+        lib_path = joinpath(path, "$filename.$(platform_dlext(target.platform))")
+    else
+        lib_path = joinpath(path, "$filename.$(Libdl.dlext)")
+    end
 
     _, obj_path = generate_obj(funcs, path, filename; target, demangle, kwargs...)
     # Pick a Clang
-    cc = Sys.isapple() ? `cc` : clang()
+    if !isnothing(target.compiler)
+        cc = `$(target.compiler)`
+    else
+        cc = Sys.isapple() ? `cc` : clang()
+    end
     # Compile!
     run(`$cc -shared $cflags $obj_path -o $lib_path `)
 

src/target.jl

@@ -18,18 +18,37 @@ Beware that currently the compilation assumes that the code is on the host so pl
 ```
 does not behave as expected.
 By default `StaticTarget()` is the native target.
+
+For cross-compilation of executables and shared libraries, one also needs to call `set_compiler!` with the path to a valid C compiler
+for the target platform. For example, to cross-compile for aarch64 using a compiler from homebrew, one can use:
+```julia
+    set_compiler!(StaticTarget(parse(Platform,"aarch64-gnu-linux")), "/opt/homebrew/bin/aarch64-unknown-linux-gnu-gcc")
+```
 """
-struct StaticTarget
+mutable struct StaticTarget
     platform::Union{Platform,Nothing}
     tm::LLVM.TargetMachine
+    compiler::Union{String,Nothing}
 end
 
 clean_triple(platform::Platform) = arch(platform) * os_str(platform) * libc_str(platform)
 StaticTarget() = StaticTarget(HostPlatform(), unsafe_string(LLVM.API.LLVMGetHostCPUName()), unsafe_string(LLVM.API.LLVMGetHostCPUFeatures()))
-StaticTarget(platform::Platform) = StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = clean_triple(platform)), clean_triple(platform)))
-StaticTarget(platform::Platform, cpu::String) = StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = clean_triple(platform)), clean_triple(platform), cpu))
-StaticTarget(platform::Platform, cpu::String, features::String) = StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = clean_triple(platform)), clean_triple(platform), cpu, features))
-StaticTarget(triple::String, cpu::String, features::String) = StaticTarget(nothing, LLVM.TargetMachine(LLVM.Target(triple = triple), triple, cpu, features))
+StaticTarget(platform::Platform) = StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = clean_triple(platform)), clean_triple(platform)), nothing)
+StaticTarget(platform::Platform, cpu::String) = StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = clean_triple(platform)), clean_triple(platform), cpu), nothing)
+StaticTarget(platform::Platform, cpu::String, features::String) = StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = clean_triple(platform)), clean_triple(platform), cpu, features), nothing)
+
+function StaticTarget(triple::String, cpu::String, features::String)
+    platform = tryparse(Platform, triple)
+    StaticTarget(platform, LLVM.TargetMachine(LLVM.Target(triple = triple), triple, cpu, features), nothing)
+end
+
+"""
+Set the compiler for cross compilation
+    ```julia
+    set_compiler!(StaticTarget(parse(Platform,"aarch64-gnu-linux")), "/opt/homebrew/bin/aarch64-elf-gcc")
+```
+"""
+set_compiler!(target::StaticTarget, compiler::String) = (target.compiler = compiler)
 
 """
 ```julia