Windows support + Stability

.appveyor.yml

@@ -1,7 +1,7 @@
 # Documentation: https://github.com/JuliaCI/Appveyor.jl
 environment:
   matrix:
-  - julia_version: 1.2
+  - julia_version: 1.3
   - julia_version: nightly
 platform:
   - x86

.gitignore

@@ -6,4 +6,9 @@
 /dev/
 /test/standalone
 /test/Manifest.toml
-/test/test.*
+/test/test.*
+
+test.o
+test.so
+test.bc
+/standalone/*

.travis.yml

@@ -3,8 +3,9 @@ language: julia
 os:
   - linux
   - osx
+  - windows
 julia:
-  - 1.2
+  - 1.3
   - nightly
 matrix:
   allow_failures:

Project.toml

@@ -5,6 +5,7 @@ version = "0.1.0"
 
 [deps]
 Cassette = "7057c7e9-c182-5462-911a-8362d720325c"
+Formatting = "59287772-0a20-5a39-b81b-1366585eb4c0"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"

README.md

@@ -5,9 +5,9 @@
 [![Codecov](https://codecov.io/gh/tshort/StaticCompiler.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/tshort/StaticCompiler.jl)
 [![Coveralls](https://coveralls.io/repos/github/tshort/StaticCompiler.jl/badge.svg?branch=master)](https://coveralls.io/github/tshort/StaticCompiler.jl?branch=master)
 
-This is an experimental package to compile Julia code to standalone libraries. A system image is not needed. It is also meant for cross compilation, so Julia code can be compiled for other targets, including WebAssembly and embedded targets. 
+This is an experimental package to compile Julia code to standalone libraries. A system image is not needed. It is also meant for cross compilation, so Julia code can be compiled for other targets, including WebAssembly and embedded targets.
 
-Long term, a better approach may be to use Julia's standard compilation techniques with "tree shaking" to generate a reduced system image (see [here](https://github.com/JuliaLang/julia/issues/33670)). 
+Long term, a better approach may be to use Julia's standard compilation techniques with "tree shaking" to generate a reduced system image (see [here](https://github.com/JuliaLang/julia/issues/33670)).
 
 This package uses the [LLVM package](https://github.com/maleadt/LLVM.jl) to generate code in the same fashion as [CUDAnative](https://github.com/JuliaGPU/CUDAnative.jl).
 
@@ -30,7 +30,7 @@ write(m, "cos.bc")
 write_object(m, "cos.o")
 ```
 
-`cos.o` should contain a function called `cos`. From there, you need to convert to link as needed with `libjulia`. 
+`cos.o` should contain a function called `cos`. From there, you need to convert to link as needed with `libjulia`.
 
 See the `test` directory for more information and types of code that currently run. The most advanced example that works is a call to an ODE solution using modified code from [ODE.jl](https://github.com/JuliaDiffEq/ODE.jl). For information on compiling and linking to an executable, see [test/standalone-exe.jl](./blob/master/test/standalone-exe.jl).
 
@@ -44,6 +44,6 @@ See the `test` directory for more information and types of code that currently r
 
 * The use of Cassette makes it more difficult for Julia to infer some things, and only type-stable code can be statically compiled with this approach.
 
-* It's only been tested on Linux.
+* It's only been tested on Linux and Windows.
 
 Finally, this whole approach is young and likely brittle. Do not expect it to work for your code.

src/ccalls.jl

@@ -44,7 +44,7 @@ iscglobal(x) = x == cglobal || x isa GlobalRef && x.name == :cglobal
 """
     fix_ccalls!(mod::LLVM.Module, d)
 
-Replace function addresses with symbol names in `mod`. The symbol names are 
+Replace function addresses with symbol names in `mod`. The symbol names are
 meant to be linked to `libjulia` or other libraries.
 `d` is a `Dict` mapping a function address to symbol name for `ccall`s.
 """
@@ -70,7 +70,7 @@ function fix_ccalls!(mod::LLVM.Module, d)
             # dest = called_value(instr)
             for op in operands(instr)
                 lastop = op
-                if occursin("inttoptr", string(op)) 
+                if occursin("inttoptr", string(op))
                     # @show instr
                     if occursin("addrspacecast", string(op)) || occursin("getelementptr", string(op))
                         op = first(operands(op))

src/globals.jl

@@ -15,7 +15,7 @@ For each global variable, two LLVM global objects are created:
 
 The `inttopt` with the function address is replaced by `jl.global`.
 
-A function `jl_init_globals` is added to `mod`. This function deserializes the data in 
+A function `jl_init_globals` is added to `mod`. This function deserializes the data in
 `jl.global.data` and updates `jl.global`.
 """
 
@@ -83,7 +83,7 @@ function fix_globals!(mod::LLVM.Module)
                 unsafe_delete!(mod, fun)
                 continue
             end
-                    
+
             for blk in blocks(fun), instr in instructions(blk)
                 # Set up functions to walk the operands of the instruction
                 # and convert appropriate ConstantExpr's to instructions.
@@ -129,7 +129,7 @@ function fix_globals!(mod::LLVM.Module)
     data = LLVM.GlobalVariable(mod, gv_typ, "jl.global.data")
     linkage!(data, LLVM.API.LLVMExternalLinkage)
     constant!(data, true)
-    LLVM.API.LLVMSetInitializer(LLVM.ref(data), 
+    LLVM.API.LLVMSetInitializer(LLVM.ref(data),
                                 LLVM.API.LLVMConstArray(LLVM.ref(uint8_t),
                                                         [LLVM.ref(ConstantInt(uint8_t, x)) for x in v],
                                                         UInt32(length(v))))
@@ -138,7 +138,7 @@ function fix_globals!(mod::LLVM.Module)
 
         # Create the Julia object from `data` and include that in `init_fun`.
         position!(builder, jl_init_global_entry)
-        gfunc_type = LLVM.FunctionType(julia_to_llvm(Cvoid), 
+        gfunc_type = LLVM.FunctionType(julia_to_llvm(Cvoid),
                                        LLVMType[LLVM.PointerType(julia_to_llvm(Int8)),
                                                 Iterators.repeated(LLVM.FunctionType(julia_to_llvm(Any)), nglobals)...])
         deserialize_globals_func = LLVM.Function(mod, "_deserialize_globals", gfunc_type)
@@ -151,7 +151,7 @@ function fix_globals!(mod::LLVM.Module)
         ret!(builder)
     end
     tt = Tuple{Ptr{UInt8}, Iterators.repeated(Ptr{Any}, nglobals)...}
-    deser_mod = irgen(deser_fun, tt, overdub = false) 
+    deser_mod = irgen(deser_fun, tt, overdub = false)
     d = find_ccalls(deser_fun, tt)
     fix_ccalls!(deser_mod, d)
     # rename deserialization function to "_deserialize_globals"
@@ -162,4 +162,3 @@ function fix_globals!(mod::LLVM.Module)
     LLVM.link!(mod, deser_mod)
     return
 end
-

src/irgen.jl

@@ -11,7 +11,13 @@ function xlinfo(f, tt)
     sig_tt = Tuple{typeof(g), tt.parameters...}
     (ti, env) = ccall(:jl_type_intersection_with_env, Any,
                       (Any, Any), sig_tt, meth.sig)::Core.SimpleVector
-    meth = Base.func_for_method_checked(meth, ti)
+
+    if VERSION >= v"1.2.0-DEV.320"
+        meth = Base.func_for_method_checked(meth, ti, env)
+    else
+        meth = Base.func_for_method_checked(meth, ti)
+    end
+
     return ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance},
                  (Any, Any, Any, UInt), meth, ti, env, world)
 end
@@ -35,7 +41,7 @@ end
 Generates Julia IR targeted for static compilation.
 `ccall` and `cglobal` uses have pointer references changed to symbols
 meant to be linked with libjulia and other libraries.
-If `overdub == true` (the default), Cassette is used to swap out 
+If `overdub == true` (the default), Cassette is used to swap out
 `ccall`s with a tuple of library and symbol.
 """
 function irgen(@nospecialize(func), @nospecialize(tt); optimize = true, overdub = true)
@@ -47,7 +53,13 @@ function irgen(@nospecialize(func), @nospecialize(tt); optimize = true, overdub
     sig_tt = Tuple{typeof(gfunc), tt.parameters...}
     (ti, env) = ccall(:jl_type_intersection_with_env, Any,
                       (Any, Any), sig_tt, meth.sig)::Core.SimpleVector
-    meth = Base.func_for_method_checked(meth, ti)
+
+    if VERSION >= v"1.2.0-DEV.320"
+        meth = Base.func_for_method_checked(meth, ti, env)
+    else
+        meth = Base.func_for_method_checked(meth, ti)
+    end
+
     linfo = ccall(:jl_specializations_get_linfo, Ref{Core.MethodInstance},
                   (Any, Any, Any, UInt), meth, ti, env, world)
 
@@ -192,4 +204,3 @@ function write_object(mod::LLVM.Module, path)
         emit(tm, mod, LLVM.API.LLVMObjectFile, path)
     end
 end
-

src/overdub.jl

@@ -8,7 +8,7 @@ using Cassette
 function transform(ctx, ref)
     CI = ref.code_info
     ismatch = x -> begin
-        Base.Meta.isexpr(x, :foreigncall) && 
+        Base.Meta.isexpr(x, :foreigncall) &&
         Base.Meta.isexpr(x.args[1], :call)
     end
     replace = x -> begin
@@ -31,4 +31,3 @@ const ctx = Cassette.disablehooks(Ctx(pass = Pass))
 #@inline Cassette.overdub(ctx::Ctx, ::typeof(+), a::T, b::T) where T<:Union{Float32, Float64} = add_float_contract(a, b)
 
 contextualize(f::F) where F = (args...) -> Cassette.overdub(ctx, f, args...)
-

src/serialize.jl

@@ -1,7 +1,7 @@
 
 """
 A context structure for holding state related to serializing Julia
-objects. A key component is an `IOBuffer` used to hold the serialized 
+objects. A key component is an `IOBuffer` used to hold the serialized
 result.
 """
 struct SerializeContext
@@ -61,7 +61,7 @@ end
 """
     serialize(ctx::SerializeContext, x)
 
-Serialize `x` into the context object `ctx`. `ctx.io` is the `IOBuffer` where the 
+Serialize `x` into the context object `ctx`. `ctx.io` is the `IOBuffer` where the
 serialized results are stored. Get the result with `take!(ctx.io)`.
 
 This function returns an expression that will deserialize the object. Several `serialize`
@@ -72,9 +72,9 @@ to do the serialization.
 The deserialization code should be pretty low-level code that can be compiled
 relatively easily. It especially shouldn't use global variables.
 
-Serialization / deserialization code can use `ctx` to hold state information. 
+Serialization / deserialization code can use `ctx` to hold state information.
 
-Some simple types like boxed variables do not need to write anything to `ctx.io`. 
+Some simple types like boxed variables do not need to write anything to `ctx.io`.
 They can return an expression that directly creates the object.
 """
 function serialize(ctx::SerializeContext, @nospecialize(x))
@@ -102,7 +102,7 @@ function serialize(ctx::SerializeContext, @nospecialize(t::DataType))
                 local super = $(serialize(ctx, t.super))
                 local parameters = $(serialize(ctx, t.parameters))
                 local types = $(serialize(ctx, t.types))
-                local ndt = ccall(:jl_new_datatype, Any, 
+                local ndt = ccall(:jl_new_datatype, Any,
                             (Any, Any, Any, Any, Any, Any, Cint, Cint, Cint),
                             tn, tn.module, super, parameters, #=names=# unsafe_load(cglobal(:jl_any_type, Any)), types,
                             $(t.abstract), $(t.mutable), $(t.ninitialized))
@@ -196,7 +196,7 @@ function serialize(ctx::SerializeContext, a::Array{T,N}) where {T,N}
         advance!(ctx.io)
         ioptr = ctx.io.ptr
         write(ctx.io, a)
-        if N == 1 
+        if N == 1
             advance!(ctx.io)
             ioptr = ctx.io.ptr
             write(ctx.io, a)

src/utils.jl

@@ -16,7 +16,7 @@ const jl_value_t = eltype(jl_value_t_ptr)
 # const jl_svec_t_ptr = jl_value_t_ptr
 # const jl_module_t_ptr = jl_value_t_ptr
 # const jl_array_t_ptr = jl_value_t_ptr
-# 
+#
 # const bool_t  = julia_to_llvm(Bool)
 # const int8_t  = julia_to_llvm(Int8)
 # const int16_t = julia_to_llvm(Int16)
@@ -32,7 +32,7 @@ const jl_value_t = eltype(jl_value_t_ptr)
 # const float64_t = julia_to_llvm(Float64)
 # const void_t    = julia_to_llvm(Nothing)
 # const size_t    = julia_to_llvm(Int)
-# 
+#
 # const int8_t_ptr  = LLVM.PointerType(int8_t)
 # const void_t_ptr  = LLVM.PointerType(void_t)
 
@@ -54,4 +54,3 @@ walk(f, x) = true
 # walk(f, x::Instruction) = foreach(c->walk(f,c), operands(x))
 # walk(f, x::Instruction) = f(x) || foreach(c->walk(f,c), operands(x))
 walk(f, x::ConstantExpr) = f(x) || foreach(c->walk(f,c), operands(x))
-

test/ccalls.jl

@@ -5,16 +5,20 @@ include("jlrun.jl")
 # d = find_ccalls(time, Tuple{})
 # d = find_ccalls(muladd, Tuple{Array{Float64,2},Array{Float64,2},Array{Float64,2}})
 
+f1() = ccall(:jl_errno, Int, (Int,), 11)
+f2() = ccall(:jl_errno, Int, (Int, Int), 21, 22)
+f3() = ccall(:jl_errno, Int, (Int, Int, Int), 31, 32, 33)
+
 @testset "ccalls" begin
-    f1() = ccall(:usleep, Int, (Int,), 11)
-    f2() = ccall(:usleep, Int, (Int, Int), 21, 22)
-    f3() = ccall(:usleep, Int, (Int, Int, Int), 31, 32, 33)
     m1 = irgen(f1, Tuple{})
     m2 = irgen(f2, Tuple{})
     m3 = irgen(f3, Tuple{})
     LLVM.verify(m1)
     LLVM.verify(m2)
     LLVM.verify(m3)
+    @test f1() == @jlrun f1()
+    @test f2() == @jlrun f2()
+    @test f3() == @jlrun f3()
 end
 
 
@@ -25,5 +29,6 @@ end
 
 @testset "cglobal" begin
     m = irgen(f, Tuple{})
+    LLVM.verify(m)
     @test f() == @jlrun f()
 end

test/globals.jl

@@ -33,6 +33,6 @@ f() = Complex{Float64}
 g(@nospecialize(x)) = isa(x, Number) ? 1 : 0
 
 @testset "type" begin
-    @test string(@jlrun f()) == "Complex{Float64}" 
+    @test string(@jlrun f()) == "Complex{Float64}"
     res = g(4.0im)
 end

test/jlrun.jl

@@ -2,7 +2,10 @@ using Test, StaticCompiler, Libdl
 using LLVM
 
 function show_inttoptr(mod)
-    for fun in LLVM.functions(mod), blk in LLVM.blocks(fun), instr in LLVM.instructions(blk)
+    for fun in LLVM.functions(mod),
+        blk in LLVM.blocks(fun),
+        instr in LLVM.instructions(blk)
+
         s = string(instr)
         if occursin("inttoptr", s) && occursin(r"[0-9]{8,30}", s)
             println(LLVM.name(fun), "  ---------------------------")
@@ -16,6 +19,18 @@ end
 Compiles function call provided and calls it with `ccall` using the shared library that was created.
 """
 macro jlrun(e)
+
+# Checking gcc installation
+    try
+        if Sys.isunix()
+            run(`gcc -v`)
+        elseif Sys.iswindows()
+            run(`cmd /c gcc -v`)
+        end
+    catch
+        error("make sure gcc compiler is installed: https://gcc.gnu.org/install/binaries.html")
+    end
+
     fun = e.args[1]
     efun = esc(fun)
     args = length(e.args) > 1 ? e.args[2:end] : Any[]
@@ -29,8 +44,24 @@ macro jlrun(e)
     end
     rettype = ct[1][2]
     pkgdir = @__DIR__
-    bindir = string(Sys.BINDIR, "/../tools")
-    libdir = string(Sys.BINDIR, "/../lib")
+    bindir = joinpath(dirname(Sys.BINDIR), "tools")
+    libdir = joinpath(dirname(Sys.BINDIR), "lib")
+
+    # shellcmd and julia library linking
+    if Sys.isunix()
+        shellcmd = "gcc"
+    elseif Sys.iswindows()
+        shellcmd = ["cmd", "/c", "gcc"]
+    else
+        error("run command not defined")
+    end
+
+    runCommand = :(run(
+        $(`$shellcmd -shared -fPIC -o test.so -L$libdir test.o -ljulia`),
+        wait = true,
+    ))
+
+
     quote
         m = irgen($efun, $tt)
         # m = irgen($efun, $tt, overdub = false)
@@ -41,12 +72,16 @@ macro jlrun(e)
         LLVM.verify(m)
         # show_inttoptr(m)
         write(m, "test.bc")
-	write_object(m, "test.o")
-        run($(`gcc -shared -fPIC -o test.so -L$libdir -ljulia test.o`), wait = true)
+        write_object(m, "test.o")
+        $runCommand
         dylib = Libdl.dlopen($dylibpath)
-        ccall(Libdl.dlsym(dylib, "jl_init_globals"), Cvoid, ()) 
-        res = ccall(Libdl.dlsym(dylib, $(Meta.quot(fun))),
-                    $rettype, ($((typeof(eval(a)) for a in args)...),), $(eval.(args)...))
+        ccall(Libdl.dlsym(dylib, "jl_init_globals"), Cvoid, ())
+        res = ccall(
+            Libdl.dlsym(dylib, $(Meta.quot(fun))),
+            $rettype,
+            ($((typeof(eval(a)) for a in args)...),),
+            $(eval.(args)...),
+        )
         Libdl.dlclose(dylib)
         res
     end

test/ode.jl

@@ -2,7 +2,7 @@
 # MIT license
 # Copyright (c) 2009-2015: various contributors: https://github.com/JuliaLang/ODE.jl/contributors
 
-using LinearAlgebra 
+using LinearAlgebra
 
 function hinit(F, x0, t0::T, tend, p, reltol, abstol) where T
     # Returns first step, direction of integration and F evaluated at t0