Reduce breakage (#404)

Author: maleadt

examples/kernel.jl

@@ -20,7 +20,7 @@ function main()
     target = NativeCompilerTarget()
     params = TestCompilerParams()
     config = CompilerConfig(target, params)
-    job = CompilerJob(config, source)
+    job = CompilerJob(source, config)
 
     println(GPUCompiler.compile(:asm, job)[1])
 end

src/cache.jl

@@ -170,7 +170,7 @@ end
                                       ft::Type, tt::Type, world,
                                       compiler::Function, linker::Function)
     src = FunctionSpec(ft, tt, world)
-    job = CompilerJob(cfg, src)
+    job = CompilerJob(src, cfg)
 
     asm = nothing
     # TODO: consider loading the assembly from an on-disk cache here

src/driver.jl

@@ -301,10 +301,10 @@ const __llvm_initialized = Ref(false)
                 # get a job in the appopriate world
                 dyn_job = if dyn_val isa CompilerJob
                     dyn_src = FunctionSpec(dyn_val.source; world=job.source.world)
-                    CompilerJob(dyn_val.config, dyn_src)
+                    CompilerJob(dyn_src, dyn_val.config)
                 elseif dyn_val isa FunctionSpec
                     dyn_src = FunctionSpec(dyn_val; world=job.source.world)
-                    CompilerJob(job.config, dyn_src)
+                    CompilerJob(dyn_src, job.config)
                 else
                     error("invalid deferred job type $(typeof(dyn_val))")
                 end

src/interface.jl

@@ -105,47 +105,57 @@ export CompilerConfig
 # the configuration of the compiler
 
 """
-    CompilerConfig(target, params; kernel=true, entry_abi=:specfunc, always_inline=false)
+    CompilerConfig(target, params; kernel=true, entry_abi=:specfunc, entry_name=nothing,
+                                   always_inline=false)
 
 Construct a `CompilerConfig` that will be used to drive compilation for the given `target`
 and `params`.
 
-The `entry_abi` can be either `:specfunc` the default, or `:func`. `:specfunc` expects the
-arguments to be passed in registers, simple return values are returned in registers as well,
-and complex return values are returned on the stack using `sret`, the calling convention is
-`fastcc`. The `:func` abi is simpler with a calling convention of the first argument being
-the function itself (to support closures), the second argument being a pointer to a vector
-of boxed Julia values and the third argument being the number of values, the return value
-will also be boxed. The `:func` abi will internally call the `:specfunc` abi, but is
-generally easier to invoke directly.
-
-`always_inline` specifies if the Julia front-end should inline all functions into one if
-possible.
+Several keyword arguments can be used to customize the compilation process:
+
+- `kernel`: specifies if the function should be compiled as a kernel, or as a regular
+   function. This is used to determine the calling convention and for validation purposes.
+- `entry_abi`: can be either `:specfunc` the default, or `:func`. `:specfunc` expects the
+  arguments to be passed in registers, simple return values are returned in registers as
+   well, and complex return values are returned on the stack using `sret`, the calling
+   convention is `fastcc`. The `:func` abi is simpler with a calling convention of the first
+   argument being the function itself (to support closures), the second argument being a
+   pointer to a vector of boxed Julia values and the third argument being the number of
+   values, the return value will also be boxed. The `:func` abi will internally call the
+   `:specfunc` abi, but is generally easier to invoke directly.
+- `entry_name`: the name that will be used for the entrypoint function. If `nothing` (the
+   default), the name will be generated automatically.
+- `always_inline` specifies if the Julia front-end should inline all functions into one if
+   possible.
 """
 struct CompilerConfig{T,P}
     target::T
     params::P
 
     kernel::Bool
+    name::Union{Nothing,String}
     entry_abi::Symbol
     always_inline::Bool
 
     function CompilerConfig(target::AbstractCompilerTarget,
                             params::AbstractCompilerParams;
-                            kernel::Bool=true,
-                            entry_abi::Symbol=:specfunc,
+                            kernel=true,
+                            name=nothing,
+                            entry_abi=:specfunc,
                             always_inline=false)
         if entry_abi ∉ (:specfunc, :func)
             error("Unknown entry_abi=$entry_abi")
         end
-        new{typeof(target), typeof(params)}(target, params, kernel, entry_abi, always_inline)
+        new{typeof(target), typeof(params)}(target, params, kernel, name, entry_abi,
+                                            always_inline)
     end
 end
 
 # copy constructor
 CompilerConfig(cfg::CompilerConfig; target=cfg.target, params=cfg.params,
-               kernel=cfg.kernel, entry_abi=cfg.entry_abi, always_inline=cfg.always_inline) =
-    CompilerConfig(target, params; kernel, entry_abi, always_inline)
+               kernel=cfg.kernel, name=cfg.name, entry_abi=cfg.entry_abi,
+               always_inline=cfg.always_inline) =
+    CompilerConfig(target, params; kernel, entry_abi, name, always_inline)
 
 function Base.show(io::IO, @nospecialize(cfg::CompilerConfig{T})) where {T}
     print(io, "CompilerConfig for ", T)
@@ -156,6 +166,7 @@ function Base.hash(cfg::CompilerConfig, h::UInt)
     h = hash(cfg.params, h)
 
     h = hash(cfg.kernel, h)
+    h = hash(cfg.name, h)
     h = hash(cfg.entry_abi, h)
     h = hash(cfg.always_inline, h)
 
@@ -170,11 +181,11 @@ export CompilerJob
 # a specific invocation of the compiler, bundling everything needed to generate code
 
 struct CompilerJob{T,P}
-    config::CompilerConfig{T,P}
     source::FunctionSpec
+    config::CompilerConfig{T,P}
 
-    CompilerJob(cfg::CompilerConfig{T,P}, src::FunctionSpec) where {T,P} =
-        new{T,P}(cfg, src)
+    CompilerJob(src::FunctionSpec, cfg::CompilerConfig{T,P}) where {T,P} =
+        new{T,P}(src, cfg)
 end
 
 

src/irgen.jl

@@ -60,6 +60,9 @@ function irgen(@nospecialize(job::CompilerJob), method_instance::Core.MethodInst
     end
 
     # rename and process the entry point
+    if job.config.name !== nothing
+        LLVM.name!(entry, safe_name(string("julia_", job.config.name)))
+    end
     if job.config.kernel
         LLVM.name!(entry, mangle_call(entry, job.source.tt))
     end

src/rtlib.jl

@@ -66,7 +66,7 @@ end
 function emit_function!(mod, config::CompilerConfig, f, method, world; ctx::JuliaContextType)
     tt = Base.to_tuple_type(method.types)
     source = FunctionSpec(f, tt, world)
-    new_mod, meta = codegen(:llvm, CompilerJob(config, source);
+    new_mod, meta = codegen(:llvm, CompilerJob(source, config);
                             optimize=false, libraries=false, validate=false, ctx)
     ft = eltype(llvmtype(meta.entry))
     expected_ft = convert(LLVM.FunctionType, method; ctx=context(new_mod))

test/definitions/bpf.jl

@@ -13,7 +13,7 @@ function bpf_job(@nospecialize(func), @nospecialize(types);
     target = BPFCompilerTarget()
     params = TestCompilerParams()
     config = CompilerConfig(target, params; kernel, always_inline)
-    CompilerJob(config, source), kwargs
+    CompilerJob(source, config), kwargs
 end
 
 function bpf_code_llvm(@nospecialize(func), @nospecialize(types); kwargs...)

test/definitions/gcn.jl

@@ -13,7 +13,7 @@ function gcn_job(@nospecialize(func), @nospecialize(types);
     target = GCNCompilerTarget(dev_isa="gfx900")
     params = TestCompilerParams()
     config = CompilerConfig(target, params; kernel, always_inline)
-    CompilerJob(config, source), kwargs
+    CompilerJob(source, config), kwargs
 end
 
 function gcn_code_typed(@nospecialize(func), @nospecialize(types); kwargs...)

test/definitions/metal.jl

@@ -13,7 +13,7 @@ function metal_job(@nospecialize(func), @nospecialize(types);
     target = MetalCompilerTarget(; macos=v"12.2")
     params = TestCompilerParams()
     config = CompilerConfig(target, params; kernel, always_inline)
-    CompilerJob(config, source), kwargs
+    CompilerJob(source, config), kwargs
 end
 
 function metal_code_typed(@nospecialize(func), @nospecialize(types); kwargs...)

test/definitions/native.jl

@@ -35,7 +35,7 @@ function native_job(@nospecialize(func), @nospecialize(types); kernel::Bool=fals
     target = NativeCompilerTarget()
     params = NativeCompilerParams(entry_safepoint, method_table)
     config = CompilerConfig(target, params; kernel, entry_abi, always_inline)
-    CompilerJob(config, source), kwargs
+    CompilerJob(source, config), kwargs
 end
 
 function native_code_typed(@nospecialize(func), @nospecialize(types); kwargs...)
@@ -271,7 +271,7 @@ module LazyCodegen
         #      with jlruntime=false, we reach an unreachable.
         params = NativeCompilerParams()
         config = CompilerConfig(target, params; kernel=false)
-        job = CompilerJob(config, source)
+        job = CompilerJob(source, config)
 
         addr = get_trampoline(job)
         trampoline = pointer(addr)