Add Julia v0.7 support (#58)

* Update author information

* Change "--auto" into "--autodeps"

* Code tweaks

* Add Julia v0.7 support

Author: lucatrv

.mailmap

@@ -1,5 +1,5 @@
-lucatrv <lucatrv@users.noreply.github.com> <lucatrv@users.noreply.github.com>
-lucatrv <lucatrv@users.noreply.github.com> <lucatrv@hotmail.com>
+Luca Trevisani <lucatrv@users.noreply.github.com> <lucatrv@users.noreply.github.com>
+Luca Trevisani <lucatrv@users.noreply.github.com> <lucatrv@hotmail.com>
 
 Viral B. Shah <viral@mayin.org> <viral@mayin.org>
 Viral B. Shah <viral@mayin.org> <viral@juliacomputing.com>

README.md

@@ -1,6 +1,8 @@
-# Julia AOT compiler
+# Static Julia Compiler
 
-Helper script to build libraries and executables from Julia code.
+Building shared libraries and executables from Julia code.
+
+Run `juliac.jl -h` for help:
 
 ```
 usage: juliac.jl [-v] [-q] [-c] [-J <file>]
@@ -10,6 +12,8 @@ usage: juliac.jl [-v] [-q] [-c] [-J <file>]
                  [--depwarn {yes|no|error}] [-a] [-o] [-s] [-e] [-j]
                  [--version] [-h] juliaprog [cprog] [builddir]
 
+Static Julia Compiler
+
 positional arguments:
   juliaprog             Julia program to compile
   cprog                 C program to compile (required only when
@@ -40,7 +44,7 @@ optional arguments:
                         set floating point optimizations
   --depwarn {yes|no|error}
                         set syntax and method deprecation warnings
-  -a, --auto            automatically build required dependencies
+  -a, --autodeps        automatically build required dependencies
   -o, --object          build object file
   -s, --shared          build shared library
   -e, --executable      build executable file
@@ -49,10 +53,10 @@ optional arguments:
   -h, --help            show this help message and exit
 
 examples:
-  juliac.jl -vae hello.jl          # verbose, auto, build executable
-  juliac.jl -vae hello.jl myprog.c # embed into user defined C program
-  juliac.jl -qo hello.jl           # quiet, build object file only
-  juliac.jl -vosej hello.jl        # build all and sync Julia libs
+  juliac.jl -vae hello.jl        # verbose, build executable and deps
+  juliac.jl -vae hello.jl prog.c # embed into user defined C program
+  juliac.jl -qo hello.jl         # quiet, build object file only
+  juliac.jl -vosej hello.jl      # build all and sync Julia libs
 ```
 
 ### Notes
@@ -101,11 +105,16 @@ build a binary that runs the julia code.
 
 Instead of a driver script, the generated system image can be embedded
 into a larger program following the embedding examples and relevant
-sections in the Julia manual. Note that the name of the generated system image (`"libhello"` for `hello.jl`) is accessible from C in the preprocessor macro `JULIAC_PROGRAM_LIBNAME`.
+sections in the Julia manual. Note that the name of the generated system
+image (`"libhello"` for `hello.jl`) is accessible from C in the
+preprocessor macro `JULIAC_PROGRAM_LIBNAME`.
 
 With Julia 0.7, a single large binary can be created, which does not
 require the driver program to load the shared library. An example of
 that is in `program2.c`, where the image file is the binary itself.
 
+For more information on static Julia compilation see:\
+https://juliacomputing.com/blog/2016/02/09/static-julia.html
+
 For more information on embedding Julia see:\
 https://github.com/JuliaLang/julia/blob/master/doc/src/manual/embedding.md

juliac.jl

@@ -2,13 +2,16 @@
 ## 1. gcc / x86_64-w64-mingw32-gcc is available and is in path
 ## 2. Package ArgParse is installed
 
+# TODO: remove once Julia v0.7 is released
+julia_v07 = VERSION > v"0.7-"
+
 using ArgParse
+julia_v07 && using Libdl
 
 function main(args)
 
-    s = ArgParseSettings("Julia AOT compiler" *
-                         "\n\nhelper script to build libraries and executables from Julia code",
-                         version = "$(basename(@__FILE__)) version 0.6",
+    s = ArgParseSettings("Static Julia Compiler",
+                         version = "$(basename(@__FILE__)) version 0.7-DEV",
                          add_version = true)
 
     @add_arg_table s begin
@@ -19,7 +22,7 @@ function main(args)
         "cprog"
             arg_type = String
             default = nothing
-            help = "C program to compile (required only when building an executable; if not provided a minimal standard program is used)"
+            help = "C program to compile (required only when building an executable; if not provided a minimal driver program is used)"
         "builddir"
             arg_type = String
             default = "builddir"
@@ -86,7 +89,7 @@ function main(args)
             metavar = "{yes|no|error}"
             range_tester = (x -> x == "yes" || x == "no" || x == "error")
             help = "set syntax and method deprecation warnings"
-        "--auto", "-a"
+        "--autodeps", "-a"
             action = :store_true
             help = "automatically build required dependencies"
         "--object", "-o"
@@ -105,15 +108,16 @@ function main(args)
 
     s.epilog = """
         examples:\n
-        \ua0\ua0juliac.jl -vae hello.jl          # verbose, auto, build executable\n
-        \ua0\ua0juliac.jl -vae hello.jl myprog.c # embed into user defined C program\n
-        \ua0\ua0juliac.jl -qo hello.jl           # quiet, build object file only\n
-        \ua0\ua0juliac.jl -vosej hello.jl        # build all and sync Julia libs\n
+        \ua0\ua0juliac.jl -vae hello.jl        # verbose, build executable and deps\n
+        \ua0\ua0juliac.jl -vae hello.jl prog.c # embed into user defined C program\n
+        \ua0\ua0juliac.jl -qo hello.jl         # quiet, build object file only\n
+        \ua0\ua0juliac.jl -vosej hello.jl      # build all and sync Julia libs\n
         """
 
     parsed_args = parse_args(args, s)
 
-    if !any([parsed_args["clean"], parsed_args["object"], parsed_args["shared"], parsed_args["executable"], parsed_args["julialibs"]])
+    # TODO: in future it may be possible to broadcast dictionary indexing, see: https://discourse.julialang.org/t/accessing-multiple-values-of-a-dictionary/8648
+    if !any(getindex.(parsed_args, ["clean", "object", "shared", "executable", "julialibs"]))
         parsed_args["quiet"] || println("Nothing to do, exiting\nTry \"$(basename(@__FILE__)) -h\" for more information")
         exit(0)
     end
@@ -134,7 +138,7 @@ function main(args)
         parsed_args["check-bounds"],
         parsed_args["math-mode"],
         parsed_args["depwarn"],
-        parsed_args["auto"],
+        parsed_args["autodeps"],
         parsed_args["object"],
         parsed_args["shared"],
         parsed_args["executable"],
@@ -145,11 +149,11 @@ end
 function julia_compile(julia_program, c_program=nothing, build_dir="builddir", verbose=false, quiet=false,
                        clean=false, sysimage = nothing, compile=nothing, cpu_target=nothing, optimize=nothing,
                        debug=nothing, inline=nothing, check_bounds=nothing, math_mode=nothing, depwarn=nothing,
-                       auto=false, object=false, shared=false, executable=true, julialibs=true)
+                       autodeps=false, object=false, shared=false, executable=true, julialibs=true)
 
-    verbose && quiet && (verbose = false)
+    verbose && quiet && (quiet = false)
 
-    if auto
+    if autodeps
         executable && (shared = true)
         shared && (object = true)
     end
@@ -193,12 +197,21 @@ function julia_compile(julia_program, c_program=nothing, build_dir="builddir", v
     julia_program_basename = splitext(basename(julia_program))[1]
     o_file = julia_program_basename * ".o"
     s_file = "lib" * julia_program_basename * ".$(Libdl.dlext)"
-    e_file = julia_program_basename * (is_windows() ? ".exe" : "")
+    if julia_v07
+        e_file = julia_program_basename * (Sys.iswindows() ? ".exe" : "")
+    else
+        e_file = julia_program_basename * (is_windows() ? ".exe" : "")
+    end
     tmp_dir = "tmp_v$VERSION"
 
     # TODO: these should probably be emitted from julia-config also:
-    shlibdir = is_windows() ? JULIA_HOME : abspath(JULIA_HOME, Base.LIBDIR)
-    private_shlibdir = abspath(JULIA_HOME, Base.PRIVATE_LIBDIR)
+    if julia_v07
+        shlibdir = Sys.iswindows() ? Sys.BINDIR : abspath(Sys.BINDIR, Base.LIBDIR)
+        private_shlibdir = abspath(Sys.BINDIR, Base.PRIVATE_LIBDIR)
+    else
+        shlibdir = is_windows() ? JULIA_HOME : abspath(JULIA_HOME, Base.LIBDIR)
+        private_shlibdir = abspath(JULIA_HOME, Base.PRIVATE_LIBDIR)
+    end
 
     if object
         julia_cmd = `$(Base.julia_cmd())`
@@ -215,66 +228,111 @@ function julia_compile(julia_program, c_program=nothing, build_dir="builddir", v
         check_bounds == nothing || push!(julia_cmd.exec, "--check-bounds=$check_bounds")
         math_mode == nothing || push!(julia_cmd.exec, "--math-mode=$math_mode")
         depwarn == nothing || (julia_cmd.exec[5] = "--depwarn=$depwarn")
-        is_windows() && (julia_program = replace(julia_program, "\\", "\\\\"))
-        expr = "
-  VERSION >= v\"0.7+\" && Base.init_load_path($(repr(JULIA_HOME))) # initialize location of site-packages
+        if julia_v07
+            Sys.iswindows() && (julia_program = replace(julia_program, "\\", "\\\\"))
+            expr = "
+  Base.init_depot_path() # initialize package depots
+  Base.init_load_path() # initialize location of site-packages
   empty!(Base.LOAD_CACHE_PATH) # reset / remove any builtin paths
   push!(Base.LOAD_CACHE_PATH, abspath(\"$tmp_dir\")) # enable usage of precompiled files
-  include($(repr(julia_program))) # include \"julia_program\" file
+  include(\"$julia_program\") # include \"julia_program\" file
   empty!(Base.LOAD_CACHE_PATH) # reset / remove build-system-relative paths"
+        else
+            is_windows() && (julia_program = replace(julia_program, "\\", "\\\\"))
+            expr = "
+  empty!(Base.LOAD_CACHE_PATH) # reset / remove any builtin paths
+  push!(Base.LOAD_CACHE_PATH, abspath(\"$tmp_dir\")) # enable usage of precompiled files
+  include(\"$julia_program\") # include \"julia_program\" file
+  empty!(Base.LOAD_CACHE_PATH) # reset / remove build-system-relative paths"
+        end
+        isdir(tmp_dir) || mkpath(tmp_dir)
         command = `$julia_cmd -e $expr`
-        verbose && println("Build \".ji\" files:\n  $command")
+        verbose && println("Build module image files \".ji\" in subdirectory \"$tmp_dir\":\n  $command")
         run(command)
         command = `$julia_cmd --output-o $(joinpath(tmp_dir, o_file)) -e $expr`
-        verbose && println("Build object file \"$o_file\":\n  $command")
+        verbose && println("Build object file \"$o_file\" in subdirectory \"$tmp_dir\":\n  $command")
         run(command)
     end
 
     if shared || executable
-        command = `$(Base.julia_cmd()) --startup-file=no $(joinpath(dirname(JULIA_HOME), "share", "julia", "julia-config.jl"))`
-        cflags = Base.shell_split(readstring(`$command --cflags`))
-        ldflags = Base.shell_split(readstring(`$command --ldflags`))
-        ldlibs = Base.shell_split(readstring(`$command --ldlibs`))
-        cc = is_windows() ? "x86_64-w64-mingw32-gcc" : "gcc"
+        if julia_v07
+            cc = Sys.iswindows() ? "x86_64-w64-mingw32-gcc" : "gcc"
+            command = `$(Base.julia_cmd()) --startup-file=no $(joinpath(dirname(Sys.BINDIR), "share", "julia", "julia-config.jl"))`
+            flags = `$(Base.shell_split(read(\`$command --allflags\`, String)))`
+        else
+            cc = is_windows() ? "x86_64-w64-mingw32-gcc" : "gcc"
+            command = `$(Base.julia_cmd()) --startup-file=no $(joinpath(dirname(JULIA_HOME), "share", "julia", "julia-config.jl"))`
+            cflags = `$(Base.shell_split(readstring(\`$command --cflags\`)))`
+            ldflags = `$(Base.shell_split(readstring(\`$command --ldflags\`)))`
+            ldlibs = `$(Base.shell_split(readstring(\`$command --ldlibs\`)))`
+            flags = `$cflags $ldflags $ldlibs`
+        end
     end
 
     if shared
-        command = `$cc -m64 -shared -o $s_file $(joinpath(tmp_dir, o_file)) $cflags $ldflags $ldlibs`
-        if is_apple()
-            command = `$command -Wl,-install_name,@rpath/lib$julia_program_basename.dylib`
-        elseif is_windows()
-            command = `$command -Wl,--export-all-symbols`
+        command = `$cc -m64 -shared -o $s_file $(joinpath(tmp_dir, o_file)) $flags`
+        if julia_v07
+            if Sys.isapple()
+                command = `$command -Wl,-install_name,@rpath/\"$s_file\"`
+            elseif Sys.iswindows()
+                command = `$command -Wl,--export-all-symbols`
+            end
+        else
+            if is_apple()
+                command = `$command -Wl,-install_name,@rpath/\"$s_file\"`
+            elseif is_windows()
+                command = `$command -Wl,--export-all-symbols`
+            end
         end
-        verbose && println("Build shared library \"$s_file\":\n  $command")
+        verbose && println("Build shared library \"$s_file\" in build directory:\n  $command")
         run(command)
     end
 
     if executable
-        push!(cflags, "-DJULIAC_PROGRAM_LIBNAME=\"lib$julia_program_basename\"")
-        command = `$cc -m64 -o $e_file $c_program $s_file $cflags $ldflags $ldlibs`
-        if is_apple()
-            command = `$command -Wl,-rpath,@executable_path`
-        elseif is_unix()
-            command = `$command -Wl,-rpath,\$ORIGIN`
+        command = `$cc -m64 -DJULIAC_PROGRAM_LIBNAME=\"lib$julia_program_basename\" -o $e_file $c_program $s_file $flags`
+        if julia_v07
+            if Sys.isapple()
+                command = `$command -Wl,-rpath,@executable_path`
+            elseif Sys.isunix()
+                command = `$command -Wl,-rpath,\$ORIGIN`
+            end
+        else
+            if is_apple()
+                command = `$command -Wl,-rpath,@executable_path`
+            elseif is_unix()
+                command = `$command -Wl,-rpath,\$ORIGIN`
+            end
         end
-        verbose && println("Build executable file \"$e_file\":\n  $command")
+        verbose && println("Build executable file \"$e_file\" in build directory:\n  $command")
         run(command)
     end
 
     if julialibs
-        verbose && println("Sync Julia libraries:")
+        verbose && println("Sync Julia libraries to build directory:")
         libfiles = String[]
         dlext = "." * Libdl.dlext
         for dir in (shlibdir, private_shlibdir)
-            if is_windows() || is_apple()
-                append!(libfiles, joinpath.(dir, filter(x -> endswith(x, dlext), readdir(dir))))
+            if julia_v07
+                if Sys.iswindows() || Sys.isapple()
+                    append!(libfiles, joinpath.(dir, filter(x -> endswith(x, dlext), readdir(dir))))
+                else
+                    append!(libfiles, joinpath.(dir, filter(x -> contains(x, r"^lib.+\.so(?:\.\d+)*$"), readdir(dir))))
+                end
             else
-                append!(libfiles, joinpath.(dir, filter(x -> ismatch(r"^lib.+\.so(?:\.\d+)*$", x), readdir(dir))))
+                if is_windows() || is_apple()
+                    append!(libfiles, joinpath.(dir, filter(x -> endswith(x, dlext), readdir(dir))))
+                else
+                    append!(libfiles, joinpath.(dir, filter(x -> ismatch(r"^lib.+\.so(?:\.\d+)*$", x), readdir(dir))))
+                end
             end
         end
         sync = false
         for src in libfiles
-            ismatch(r"debug", src) && continue
+            if julia_v07
+                contains(src, r"debug") && continue
+            else
+                ismatch(r"debug", src) && continue
+            end
             dst = basename(src)
             if filesize(src) != filesize(dst) || ctime(src) > ctime(dst) || mtime(src) > mtime(dst)
                 verbose && println("  $dst")

program.c

@@ -8,7 +8,7 @@
 #include "uv.h"
 #include "julia.h"
 
-#ifdef JULIA_DEFINE_FAST_TLS // only available in Julia 0.7+
+#ifdef JULIA_DEFINE_FAST_TLS // only available in Julia v0.7 and above
 JULIA_DEFINE_FAST_TLS()
 #endif
 
@@ -22,7 +22,7 @@ int main(int argc, char *argv[])
     // Initialize Julia
     uv_setup_args(argc, argv); // no-op on Windows
     libsupport_init();
-    // JULIAC_PROGRAM_LIBNAME defined on command-line for compilation.
+    // JULIAC_PROGRAM_LIBNAME defined on command-line for compilation
     jl_options.image_file = JULIAC_PROGRAM_LIBNAME;
     julia_init(JL_IMAGE_JULIA_HOME);
 

program2.c

@@ -8,7 +8,7 @@
 #include "uv.h"
 #include "julia.h"
 
-#ifdef JULIA_DEFINE_FAST_TLS // only available in Julia 0.7+
+#ifdef JULIA_DEFINE_FAST_TLS // only available in Julia v0.7 and above
 JULIA_DEFINE_FAST_TLS()
 #endif
 
@@ -41,7 +41,7 @@ int wmain(int argc, wchar_t *wargv[], wchar_t *envp[])
     // initialization
     libsupport_init();
     // jl_options.compile_enabled = JL_OPTIONS_COMPILE_OFF;
-    // JULIAC_PROGRAM_LIBNAME defined on command-line for compilation.
+    // JULIAC_PROGRAM_LIBNAME defined on command-line for compilation
     jl_options.image_file = JULIAC_PROGRAM_LIBNAME;
     julia_init(JL_IMAGE_JULIA_HOME);