Updates for LLVM 5. (#416)

Author: maleadt

Manifest.toml

@@ -39,17 +39,15 @@ version = "1.4.1"
 
 [[LLVM]]
 deps = ["CEnum", "LLVMExtra_jll", "Libdl", "Printf", "Unicode"]
-git-tree-sha1 = "ee3374fcbdcd90fb10b27f1d847af7ade3a3213b"
-repo-rev = "master"
-repo-url = "https://github.com/maleadt/LLVM.jl.git"
+git-tree-sha1 = "a8960cae30b42b66dd41808beb76490519f6f9e2"
 uuid = "929cbde3-209d-540e-8aea-75f648917ca0"
 version = "5.0.0"
 
 [[LLVMExtra_jll]]
 deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"]
-git-tree-sha1 = "e46e3a40daddcbe851f86db0ec4a4a3d4badf800"
+git-tree-sha1 = "09b7505cc0b1cee87e5d4a26eea61d2e1b0dcd35"
 uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab"
-version = "0.0.19+0"
+version = "0.0.21+0"
 
 [[LazyArtifacts]]
 deps = ["Artifacts", "Pkg"]

src/driver.jl

@@ -302,7 +302,7 @@ const __llvm_initialized = Ref(false)
                 # insert a pointer to the function everywhere the entry is used
                 T_ptr = convert(LLVMType, Ptr{Cvoid}; ctx=unwrap_context(ctx))
                 for call in worklist[dyn_job]
-                    @dispose builder=Builder(unwrap_context(ctx)) begin
+                    @dispose builder=IRBuilder(unwrap_context(ctx)) begin
                         position!(builder, call)
                         fptr = ptrtoint!(builder, dyn_entry, T_ptr)
                         replace_uses!(call, fptr)

src/gcn.jl

@@ -124,7 +124,7 @@ function lower_throw_extra!(mod::LLVM.Module)
                     call = user(use)::LLVM.CallInst
 
                     # replace the throw with a trap
-                    @dispose builder=Builder(ctx) begin
+                    @dispose builder=IRBuilder(ctx) begin
                         position!(builder, call)
                         emit_exception!(builder, f_name, call)
                     end
@@ -168,12 +168,12 @@ function fix_alloca_addrspace!(fn::LLVM.Function)
     for bb in blocks(fn)
         for insn in instructions(bb)
             if isa(insn, LLVM.AllocaInst)
-                ty = llvmtype(insn)
+                ty = value_type(insn)
                 ety = eltype(ty)
                 addrspace(ty) == alloca_as && continue
 
                 new_insn = nothing
-                @dispose builder=Builder(ctx) begin
+                @dispose builder=IRBuilder(ctx) begin
                     position!(builder, insn)
                     _alloca = alloca!(builder, ety, name(insn))
                     new_insn = addrspacecast!(builder, _alloca, ty)
@@ -189,10 +189,11 @@ end
 
 function emit_trap!(job::CompilerJob{GCNCompilerTarget}, builder, mod, inst)
     ctx = context(mod)
+    trap_ft = LLVM.FunctionType(LLVM.VoidType(ctx))
     trap = if haskey(functions(mod), "llvm.trap")
         functions(mod)["llvm.trap"]
     else
-        LLVM.Function(mod, "llvm.trap", LLVM.FunctionType(LLVM.VoidType(ctx)))
+        LLVM.Function(mod, "llvm.trap", trap_ft)
     end
     if Base.libllvm_version < v"9"
         rl_ft = LLVM.FunctionType(LLVM.Int32Type(ctx),
@@ -209,9 +210,9 @@ function emit_trap!(job::CompilerJob{GCNCompilerTarget}, builder, mod, inst)
         # this, the target will only attempt to do a "masked branch", which
         # only works on vector instructions (trap is a scalar instruction, and
         # therefore it is executed even when EXEC==0).
-        rl_val = call!(builder, rl, [ConstantInt(Int32(32); ctx)])
+        rl_val = call!(builder, rl_ft, rl, [ConstantInt(Int32(32); ctx)])
         rl_bc = inttoptr!(builder, rl_val, LLVM.PointerType(LLVM.Int32Type(ctx)))
         store!(builder, rl_val, rl_bc)
     end
-    call!(builder, trap)
+    call!(builder, trap_ft, trap)
 end

src/interface.jl

@@ -214,7 +214,7 @@ function process_entry!(@nospecialize(job::CompilerJob), mod::LLVM.Module,
     if job.config.kernel && needs_byval(job)
         # pass all bitstypes by value; by default Julia passes aggregates by reference
         # (this improves performance, and is mandated by certain back-ends like SPIR-V).
-        args = classify_arguments(job, eltype(llvmtype(entry)))
+        args = classify_arguments(job, function_type(entry))
         for arg in args
             if arg.cc == BITS_REF
                 attr = if LLVM.version() >= v"12"

src/irgen.jl

@@ -250,7 +250,7 @@ function lower_throw!(mod::LLVM.Module)
                 call = user(use)::LLVM.CallInst
 
                 # replace the throw with a PTX-compatible exception
-                @dispose builder=Builder(ctx) begin
+                @dispose builder=IRBuilder(ctx) begin
                     position!(builder, call)
                     emit_exception!(builder, name, call)
                 end
@@ -330,12 +330,13 @@ end
 
 function emit_trap!(@nospecialize(job::CompilerJob), builder, mod, inst)
     ctx = context(mod)
+    trap_ft = LLVM.FunctionType(LLVM.VoidType(ctx))
     trap = if haskey(functions(mod), "llvm.trap")
         functions(mod)["llvm.trap"]
     else
-        LLVM.Function(mod, "llvm.trap", LLVM.FunctionType(LLVM.VoidType(ctx)))
+        LLVM.Function(mod, "llvm.trap", trap_ft)
     end
-    call!(builder, trap)
+    call!(builder, trap_ft, trap)
 end
 
 
@@ -435,8 +436,8 @@ end
 # https://reviews.llvm.org/D79744
 function lower_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.Function)
     ctx = context(mod)
-    ft = eltype(llvmtype(f))
-    @compiler_assert LLVM.return_type(ft) == LLVM.VoidType(ctx) job
+    ft = function_type(f)
+    @compiler_assert return_type(ft) == LLVM.VoidType(ctx) job
     @timeit_debug to "lower byval" begin
 
     # find the byval parameters
@@ -500,7 +501,7 @@ function lower_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.
             push!(new_types, param)
         end
     end
-    new_ft = LLVM.FunctionType(LLVM.return_type(ft), new_types)
+    new_ft = LLVM.FunctionType(return_type(ft), new_types)
     new_f = LLVM.Function(mod, "", new_ft)
     linkage!(new_f, linkage(f))
     for (arg, new_arg) in zip(parameters(f), parameters(new_f))
@@ -509,7 +510,7 @@ function lower_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.
 
     # emit IR performing the "conversions"
     new_args = LLVM.Value[]
-    @dispose builder=Builder(ctx) begin
+    @dispose builder=IRBuilder(ctx) begin
         entry = BasicBlock(new_f, "conversion"; ctx)
         position!(builder, entry)
 
@@ -591,6 +592,7 @@ function add_kernel_state!(mod::LLVM.Module)
     # intrinsic returning an opaque pointer to the kernel state.
     # this is both for extern uses, and to make this transformation a two-step process.
     state_intr = kernel_state_intr(mod, T_state)
+    state_intr_ft = LLVM.FunctionType(T_state)
 
     kernels = []
     kernels_md = metadata(mod)["julia.kernel"]
@@ -636,12 +638,12 @@ function add_kernel_state!(mod::LLVM.Module)
     workmap = Dict{LLVM.Function, LLVM.Function}()
     for f in worklist
         fn = LLVM.name(f)
-        ft = eltype(llvmtype(f))
+        ft = function_type(f)
         LLVM.name!(f, fn * ".stateless")
 
         # create a new function
         new_param_types = [T_state, parameters(ft)...]
-        new_ft = LLVM.FunctionType(LLVM.return_type(ft), new_param_types)
+        new_ft = LLVM.FunctionType(return_type(ft), new_param_types)
         new_f = LLVM.Function(mod, fn, new_ft)
         LLVM.name!(parameters(new_f)[1], "state")
         linkage!(new_f, linkage(f))
@@ -671,15 +673,15 @@ function add_kernel_state!(mod::LLVM.Module)
                     #
                     # XXX: ptrtoint/inttoptr pairs can also lose the state argument...
                     #      is all this even sound?
-                    typ = llvmtype(val)::LLVM.PointerType
+                    typ = value_type(val)::LLVM.PointerType
                     ft = eltype(typ)::LLVM.FunctionType
-                    new_ft = LLVM.FunctionType(LLVM.return_type(ft), [T_state, parameters(ft)...])
+                    new_ft = LLVM.FunctionType(return_type(ft), [T_state, parameters(ft)...])
                     return const_bitcast(workmap[target], LLVM.PointerType(new_ft, addrspace(typ)))
                 end
             elseif opcode(val) == LLVM.API.LLVMPtrToInt
                 target = operands(val)[1]
                 if target isa LLVM.Function && haskey(workmap, target)
-                    return const_ptrtoint(workmap[target], llvmtype(val))
+                    return const_ptrtoint(workmap[target], value_type(val))
                 end
             end
         end
@@ -720,9 +722,9 @@ function add_kernel_state!(mod::LLVM.Module)
     end
 
     # update uses of the new function, modifying call sites to include the kernel state
-    function rewrite_uses!(f)
+    function rewrite_uses!(f, ft)
         # update uses
-        @dispose builder=Builder(ctx) begin
+        @dispose builder=IRBuilder(ctx) begin
             for use in uses(f)
                 val = user(use)
                 if val isa LLVM.CallBase && called_value(val) == f
@@ -739,9 +741,9 @@ function add_kernel_state!(mod::LLVM.Module)
 
                     # forward the state argument
                     position!(builder, val)
-                    state = call!(builder, state_intr, Value[], "state")
+                    state = call!(builder, state_intr_ft, state_intr, Value[], "state")
                     new_val = if val isa LLVM.CallInst
-                        call!(builder, f, [state, arguments(val)...], operand_bundles(val))
+                        call!(builder, ft, f, [state, arguments(val)...], operand_bundles(val))
                     else
                         # TODO: invoke and callbr
                         error("Rewrite of $(typeof(val))-based calls is not implemented: $val")
@@ -757,15 +759,16 @@ function add_kernel_state!(mod::LLVM.Module)
                 elseif val isa LLVM.StoreInst
                     # the function is being stored, which again we'll permit like before.
                 elseif val isa ConstantExpr
-                    rewrite_uses!(val)
+                    rewrite_uses!(val, ft)
                 else
                     error("Cannot rewrite $(typeof(val)) use of function: $val")
                 end
             end
         end
     end
     for f in values(workmap)
-        rewrite_uses!(f)
+        ft = function_type(f)
+        rewrite_uses!(f, ft)
     end
 
     return true
@@ -791,7 +794,7 @@ function lower_kernel_state!(fun::LLVM.Function)
         state_intr = functions(mod)["julia.gpu.state_getter"]
         state_arg = nothing # only look-up when needed
 
-        @dispose builder=Builder(ctx) begin
+        @dispose builder=IRBuilder(ctx) begin
             for use in uses(state_intr)
                 inst = user(use)
                 @assert inst isa LLVM.CallInst
@@ -807,7 +810,7 @@ function lower_kernel_state!(fun::LLVM.Function)
                     # the function, but only when this function needs the state!
                     state_arg = parameters(fun)[1]
                     T_state = convert(LLVMType, state; ctx)
-                    @assert llvmtype(state_arg) == T_state
+                    @assert value_type(state_arg) == T_state
                 end
 
                 replace_uses!(inst, state_arg)
@@ -865,13 +868,14 @@ function kernel_state_value(state)
 
         # get intrinsic
         state_intr = kernel_state_intr(mod, T_state)
+        state_intr_ft = function_type(state_intr)
 
         # generate IR
-        @dispose builder=Builder(ctx) begin
+        @dispose builder=IRBuilder(ctx) begin
             entry = BasicBlock(llvm_f, "entry"; ctx)
             position!(builder, entry)
 
-            val = call!(builder, state_intr, Value[], "state")
+            val = call!(builder, state_intr_ft, state_intr, Value[], "state")
 
             ret!(builder, val)
         end