Use Enzyme's optimization and late lowering mechanisms (#63)

* Use Enzyme's optimization and late lowering mechanisms

* BLAS calls work again

* update README

* add another test case

* re-enable the `@test_skip` on remotely calling BLAS

Author: MasonProtter

README.md

@@ -1,12 +1,9 @@
 # StaticCompiler
 
-[![Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://tshort.github.io/StaticCompiler.jl/dev)
-[![Build Status](https://travis-ci.com/tshort/StaticCompiler.jl.svg?branch=master)](https://travis-ci.com/tshort/StaticCompiler.jl)
-[![Build Status](https://ci.appveyor.com/api/projects/status/github/tshort/StaticCompiler.jl?svg=true)](https://ci.appveyor.com/project/tshort/StaticCompiler-jl)
+[![CI](https://github.com/tshort/StaticCompiler.jl/actions/workflows/ci.yml/badge.svg)](https://github.com/tshort/StaticCompiler.jl/actions/workflows/ci.yml)
 [![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.
 
 ## Installation and Usage
 
@@ -41,6 +38,9 @@ julia> fib_compiled(10)
 55
 ```
 
+See the file `tests/runtests.jl` for some examples of functions that work with static compilation (and some that don't,
+marked with `@test_skip`)
+
 ## Approach
 
 This package uses the [GPUCompiler package](https://github.com/JuliaGPU/GPUCompiler.jl) to generate code.

src/StaticCompiler.jl

@@ -15,6 +15,8 @@ export native_code_llvm, native_code_typed, native_llvm_module, native_code_nati
 include("target.jl")
 include("pointer_patching.jl")
 include("code_loading.jl")
+include("optimize.jl")
+
 
 """
     compile(f, types, path::String = tempname()) --> (compiled_f, path)
@@ -148,20 +150,27 @@ function generate_shlib(f, tt, path::String = tempname(), name = GPUCompiler.saf
     mkpath(path)
     obj_path = joinpath(path, "$filenamebase.o")
     lib_path = joinpath(path, "$filenamebase.$(Libdl.dlext)")
-
+    tm = GPUCompiler.llvm_machine(NativeCompilerTarget())
     job, kwargs = native_job(f, tt; name, kwargs...)
     #Get LLVM to generated a module of code for us. We don't want GPUCompiler's optimization passes.
     mod, meta = GPUCompiler.codegen(:llvm, job; strip=strip_llvm, only_entry=false, validate=false, optimize=false)
-    #use Julia's optimization pass on the LLVM code, but leave intrinsics alone
-    julia_opt_passes(mod, job; opt_level, lower_intrinsics=0)
+    
+    # Use Enzyme's annotation and optimization pipeline
+    annotate!(mod)
+    optimize!(mod, tm)
+    
     # Scoop up all the pointers in the optimized module, and replace them with unitialized global variables.
-    # table is a dictionary where the keys are julia objects that are needed by the function, and the values
+    # `table` is a dictionary where the keys are julia objects that are needed by the function, and the values
     # of the dictionary are the names of their associated LLVM GlobalVariable names.
     table = relocation_table!(mod)
+    
     # Now that we've removed all the pointers from the code, we can (hopefully) safely lower all the instrinsics
-    julia_opt_passes(mod, job; opt_level, lower_intrinsics=1)
+    # (again, using Enzyme's pipeline)
+    post_optimize!(mod, tm)
+    
     # Make sure we didn't make any glaring errors
     LLVM.verify(mod)
+    
     # Compile the LLVM module to native code and save it to disk
     obj, _ = GPUCompiler.emit_asm(job, mod; strip=strip_asm, validate=false, format=LLVM.API.LLVMObjectFile)
     open(obj_path, "w") do io
@@ -170,25 +179,6 @@ function generate_shlib(f, tt, path::String = tempname(), name = GPUCompiler.saf
     path, name, table
 end
 
-function julia_opt_passes(mod, job; opt_level, lower_intrinsics)
-    triple = GPUCompiler.llvm_triple(job.target)
-    tm = GPUCompiler.llvm_machine(job.target)
-
-    lib_path = VERSION > v"1.8.0-DEV" ? "libjulia-codegen" :  "libjulia"
-    
-    dlopen(lib_path) do lib
-        opt_func = dlsym(lib, "jl_add_optimization_passes")
-        ModulePassManager() do pm
-            add_library_info!(pm, triple)
-            add_transform_info!(pm, tm)
-            ccall(opt_func, Cvoid,
-                  (LLVM.API.LLVMPassManagerRef, Cint, Cint),
-                  pm, opt_level, lower_intrinsics)
-            run!(pm, mod)
-        end
-    end
-end
-
 """
 ```julia
 compile_executable(f, types::Tuple, path::String, name::String=repr(f); filename::String=name, kwargs...)