Introduce parameters to control optimization.

Author: maleadt

src/interface.jl

@@ -189,9 +189,6 @@ function process_entry!(@nospecialize(job::CompilerJob), mod::LLVM.Module,
     return entry
 end
 
-# post-Julia optimization processing of the module
-optimize_module!(@nospecialize(job::CompilerJob), mod::LLVM.Module) = return
-
 # final processing of the IR module, right before validation and machine-code generation
 finish_module!(@nospecialize(job::CompilerJob), mod::LLVM.Module) = return
 
@@ -219,3 +216,7 @@ function llvm_debug_info(@nospecialize(job::CompilerJob))
         LLVM.API.LLVMDebugEmissionKindFullDebug
     end
 end
+
+# optimization
+optimization_params(@nospecialize(job::CompilerJob)) = GPUOptimizationParams()
+optimize_module!(@nospecialize(job::CompilerJob), mod::LLVM.Module) = return

src/optim.jl

@@ -1,30 +1,48 @@
 # LLVM IR optimization
 
+Base.@kwdef struct GPUOptimizationParams
+    julia::Bool = true
+    intrinsics::Bool = true
+    ipo::Bool = true
+
+    optlevel::Int = Base.JLOptions().opt_level
+end
+
 function optimize!(@nospecialize(job::CompilerJob), mod::LLVM.Module)
+    triple = llvm_triple(job.target)
     tm = llvm_machine(job.target)
 
     function initialize!(pm)
-        add_library_info!(pm, triple(mod))
+        add_library_info!(pm, triple)
         add_transform_info!(pm, tm)
     end
 
     global current_job
     current_job = job
 
+    params = optimization_params(job)
+
     # Julia-specific optimizations
     #
     # NOTE: we need to use multiple distinct pass managers to force pass ordering;
     #       intrinsics should never get lowered before Julia has optimized them.
 
     ModulePassManager() do pm
         initialize!(pm)
-        ccall(:jl_add_optimization_passes, Cvoid,
-                (LLVM.API.LLVMPassManagerRef, Cint, Cint),
-                pm, Base.JLOptions().opt_level, #=lower_intrinsics=# 0)
+        if params.julia
+            ccall(:jl_add_optimization_passes, Cvoid,
+                    (LLVM.API.LLVMPassManagerRef, Cint, Cint),
+                    pm, params.optlevel, #=lower_intrinsics=# 0)
+        end
+        if params.optlevel < 2
+            # Julia doesn't run the alloc optimizer on lower optimization levels,
+            # but the pass is crucial to remove possibly unsupported malloc calls.
+            alloc_opt!(pm)
+        end
         run!(pm, mod)
     end
 
-    ModulePassManager() do pm
+    params.intrinsics && ModulePassManager() do pm
         initialize!(pm)
 
         # lower intrinsics
@@ -55,7 +73,7 @@ function optimize!(@nospecialize(job::CompilerJob), mod::LLVM.Module)
     # part of the LateLowerGCFrame pass) aren't collected properly.
     #
     # these might not always be safe, as Julia's IR metadata isn't designed for IPO.
-    ModulePassManager() do pm
+    params.ipo && ModulePassManager() do pm
         initialize!(pm)
 
         dead_arg_elimination!(pm)   # parent doesn't use return value --> ret void

src/spirv.jl

@@ -62,6 +62,14 @@ function finish_module!(job::CompilerJob{SPIRVCompilerTarget}, mod::LLVM.Module)
     end
 end
 
+# the LLVM to SPIRV translator does not support optimized LLVM IR
+# (KhronosGroup/SPIRV-LLVM-Translator#203). however, not optimizing at all
+# doesn't work either, as we then don't even run the alloc optimizer (resulting
+# in many calls to gpu_alloc that spirv-opt cannot remove) or even 'invalid IR'
+# like casts to addrspace-less pointers (which aren't allowed in SPIR-V).
+optimization_params(@nospecialize(job::CompilerJob{SPIRVCompilerTarget})) =
+    GPUOptimizationParams(; optlevel=1)
+
 @unlocked function mcgen(job::CompilerJob{SPIRVCompilerTarget}, mod::LLVM.Module,
                          format=LLVM.API.LLVMAssemblyFile)
     # The SPIRV Tools don't handle Julia's debug info, rejecting DW_LANG_Julia...