adaption to Windows

src/StaticCompiler.jl

@@ -98,13 +98,13 @@ shell> ./hello
 Hello, world!
 ```
 """
-function compile_executable(f::Function, types=(), path::String="./", name=fix_name(f);
+function compile_executable(f::Function, types=(), path::String=pwd(), name=fix_name(f);
                             also_expose=Tuple{Function, Tuple{DataType}}[], target::StaticTarget=StaticTarget(),
                             kwargs...)
     compile_executable(vcat([(f, types)], also_expose), path, name; target, kwargs...)
 end
 
-function compile_executable(funcs::Union{Array,Tuple}, path::String="./", name=fix_name(first(first(funcs)));
+function compile_executable(funcs::Union{Array,Tuple}, path::String=pwd(), name=fix_name(first(first(funcs)));
         filename = name,
         demangle = true,
         cflags = ``,
@@ -128,14 +128,14 @@ end
 
 """
 ```julia
-compile_shlib(f::Function, types::Tuple, [path::String="./"], [name::String=string(nameof(f))];
+compile_shlib(f::Function, types::Tuple, [path::String=pwd()], [name::String=string(nameof(f))];
     filename::String=name,
     cflags=``,
     method_table=StaticCompiler.method_table,
     target::StaticTarget=StaticTarget(),
     kwargs...)
 
-compile_shlib(funcs::Array, [path::String="./"];
+compile_shlib(funcs::Array, [path::String=pwd()];
     filename="libfoo",
     demangle=true,
     cflags=``,
@@ -172,15 +172,15 @@ julia> ccall(("test", "test.dylib"), Float64, (Int64,), 100_000)
 5.2564961094956075
 ```
 """
-function compile_shlib(f::Function, types=(), path::String="./", name=fix_name(f);
+function compile_shlib(f::Function, types=(), path::String=pwd(), name=fix_name(f);
         filename=name,
         target::StaticTarget=StaticTarget(),
         kwargs...
     )
     compile_shlib(((f, types),), path; filename, target, kwargs...)
 end
 # As above, but taking an array of functions and returning a single shlib
-function compile_shlib(funcs::Union{Array,Tuple}, path::String="./";
+function compile_shlib(funcs::Union{Array,Tuple}, path::String=pwd();
         filename = "libfoo",
         demangle = true,
         cflags = ``,
@@ -289,10 +289,11 @@ function generate_executable(funcs::Union{Array,Tuple}, path=tempname(), name=fi
                              demangle = true,
                              cflags = ``,
                              target::StaticTarget=StaticTarget(),
+                             llvm_to_clang = Sys.iswindows(),
                              kwargs...
                              )
     exec_path = joinpath(path, filename)
-    _, obj_path = generate_obj(funcs, path, filename; demangle, target, kwargs...)
+    _, obj_or_ir_path = generate_obj(funcs, path, filename; emit_llvm_only=llvm_to_clang, demangle, target, kwargs...)
     # Pick a compiler
     if !isnothing(target.compiler)
         cc = `$(target.compiler)`
@@ -301,10 +302,10 @@ function generate_executable(funcs::Union{Array,Tuple}, path=tempname(), name=fi
     end
 
     # Compile!
-    if Sys.isapple()
+    if Sys.isapple() && !llvm_to_clang
         # Apple no longer uses _start, so we can just specify a custom entry
         entry = demangle ? "_$name" : "_julia_$name"
-        run(`$cc -e $entry $cflags $obj_path -o $exec_path`)
+        run(`$cc -e $entry $cflags $obj_or_ir_path -o $exec_path`)
     else
         fn = demangle ? "$name" : "julia_$name"
         # Write a minimal wrapper to avoid having to specify a custom entry
@@ -319,9 +320,19 @@ function generate_executable(funcs::Union{Array,Tuple}, path=tempname(), name=fi
             return 0;
         }""")
         close(f)
-        run(`$cc $wrapper_path $cflags $obj_path -o $exec_path`)
+        if llvm_to_clang # (required on Windows)
+            # Use clang (llc) to generate an executable from the LLVM IR
+            if Sys.iswindows()
+              run(`cmd \c clang -Wno-override-module $wrapper_path $obj_or_ir_path -o $exec_path`)      
+            else
+              run(`$(clang()) -Wno-override-module $wrapper_path $obj_or_ir_path -o $exec_path`)      
+            end
+        else
+            run(`$cc $wrapper_path $cflags $obj_or_ir_path -o $exec_path`)
+        end
+
         # Clean up
-        run(`rm $wrapper_path`)
+        rm(wrapper_path)
     end
     path, name
 end
@@ -539,20 +550,30 @@ function generate_obj(funcs::Union{Array,Tuple}, path::String = tempname(), file
                         strip_asm = true,
                         opt_level = 3,
                         target::StaticTarget=StaticTarget(),
+                        emit_llvm_only = Sys.iswindows(),
                         kwargs...)
     f, tt = funcs[1]
     mkpath(path)
-    obj_path = joinpath(path, "$filenamebase.o")
     mod = static_llvm_module(funcs; demangle, kwargs...)
-    obj = GPUCompiler.JuliaContext() do ctx
-        fakejob, _ = static_job(f, tt; target, kwargs...)
-        obj, _ = GPUCompiler.emit_asm(fakejob, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
-        obj
-    end
-    open(obj_path, "w") do io
-        write(io, obj)
+
+    if emit_llvm_only # (Required on Windows)
+      ir_path = joinpath(path, "$filenamebase.ll")
+      open(ir_path, "w") do io
+        write(io, string(mod))
+      end
+      return path, ir_path
+    else
+      obj_path = joinpath(path, "$filenamebase.o")
+      obj = GPUCompiler.JuliaContext() do ctx
+          fakejob, _ = static_job(f, tt; target, kwargs...)
+          obj, _ = GPUCompiler.emit_asm(fakejob, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
+          obj
+      end
+      open(obj_path, "w") do io
+          write(io, obj)
+      end
+      return path, obj_path
     end
-    path, obj_path
 end
 
 end # module

test/simple_test.jl

@@ -0,0 +1,8 @@
+using StaticCompiler
+using StaticTools
+
+hello() = println(c"Hello world!")
+hello()
+
+# Attempt to compile
+compile_executable(hello, (), pwd())