Merge pull request #694 from JuliaLLVM/tb/host-perf-4

Inline the remaining C API wrappers of non-specialized builders

Author: maleadt

src/LLVM.jl

@@ -41,12 +41,19 @@ end
 # for every combination of, e.g., value types). that makes calls with abstractly-typed
 # arguments resolve statically, and inlining them makes the argument conversions do so too.
 function inline_wrapper(ex)
-    if Meta.isexpr(ex, :function) && Meta.isexpr(ex.args[2], :block)
-        pushfirst!(ex.args[2].args, Expr(:meta, :inline))
+    def = undocumented(ex)
+    if Meta.isexpr(def, :function) && Meta.isexpr(def.args[2], :block)
+        pushfirst!(def.args[2].args, Expr(:meta, :inline))
     end
     return ex
 end
 
+# the definition in a top-level expression of the wrappers, which is wrapped in a call to
+# `@doc` if it is documented
+undocumented(ex) =
+    Meta.isexpr(ex, :macrocall) && ex.args[1] == GlobalRef(Core, Symbol("@doc")) ?
+        ex.args[end] : ex
+
 # enum members that the C API lacks, at least on older versions of LLVM, numbered as in newer
 # C APIs or as their next values, so that they can be named and enumerated on every LLVM
 # version. they are added to the definitions of the enums in the generated wrappers, so that
@@ -64,9 +71,8 @@ const backfilled_enum_members = (
 )
 const backfilled_enum_definitions = Dict{Symbol,Int}()
 function backfill_enum_members(ex)
-    # the definition is `@cenum Name::UInt32 begin ... end`, documented
-    def = Meta.isexpr(ex, :macrocall) && ex.args[1] == GlobalRef(Core, Symbol("@doc")) ?
-          ex.args[end] : ex
+    # the definition is `@cenum Name::UInt32 begin ... end`
+    def = undocumented(ex)
     Meta.isexpr(def, :macrocall) && def.args[1] === Symbol("@cenum") &&
         Meta.isexpr(def.args[3], :(::)) || return ex
     enum = def.args[3].args[1]

src/core/value/constant.jl

@@ -1543,8 +1543,7 @@ Create a global variable in the given module with the given type, name, and opti
 address space.
 """
 GlobalVariable(mod::Module, typ::LLVMType, name::AbstractString, addrspace::Integer=0) =
-    GlobalVariable(API.LLVMAddGlobalInAddressSpace(mod, typ,
-                                                   name, addrspace))
+    GlobalVariable(API.LLVMAddGlobalInAddressSpace(mod, typ, name, Cuint(addrspace)))
 
 """
     erase!(gv::GlobalVariable)

src/irbuilder.jl

@@ -407,7 +407,7 @@ function extract_value!(builder::IRBuilder, AggVal::Value,
                         Indices::AbstractVector{<:Integer}, Name::AbstractString="")
     check_aggregate_indices(value_type(AggVal), Indices)
     isempty(Indices) && return AggVal
-    idxs = Vector{Cuint}(Indices)
+    idxs = convert(Vector{Cuint}, Indices)
     Value(API.LLVMExtraBuildExtractValue(builder, AggVal, idxs, length(idxs), Name))
 end
 
@@ -432,18 +432,18 @@ function insert_value!(builder::IRBuilder, AggVal::Value, EltVal::Value,
                        Indices::AbstractVector{<:Integer}, Name::AbstractString="")
     check_inserted_value(AggVal, EltVal, Indices)
     isempty(Indices) && return EltVal
-    idxs = Vector{Cuint}(Indices)
+    idxs = convert(Vector{Cuint}, Indices)
     Value(API.LLVMExtraBuildInsertValue(builder, AggVal, EltVal, idxs, length(idxs), Name))
 end
 
 
 # memory access and addressing operations
 
 # address spaces are 24-bit numbers
-function check_addrspace(addrspace)
+function check_addrspace(addrspace)::Cuint
     addrspace isa Integer && 0 <= addrspace < 2^24 ||
         throw(ArgumentError("Address spaces must be integers between 0 and 2^24-1, got $addrspace"))
-    return Cuint(addrspace)
+    return addrspace
 end
 
 """

test/instructions.jl

@@ -743,6 +743,30 @@ let calls_wrapper(f, types) = any(only(code_typed(f, types))[1].code) do stmt
         @test !calls_wrapper(memmove!,
                              Tuple{IRBuilder, Value, Integer, Value, Integer, Value})
     end
+    indices = AbstractVector{<:Integer}
+    @test !calls_wrapper(extract_value!, Tuple{IRBuilder, Value, indices, AbstractString})
+    @test !calls_wrapper(insert_value!,
+                         Tuple{IRBuilder, Value, Value, indices, AbstractString})
+
+    # methods with keyword arguments are compiled for the keyword arguments' declared types
+    kwbody(f, types) = Base.bodyfunction(which(f, types))
+    @test !calls_wrapper(kwbody(alloca!, Tuple{IRBuilder, LLVMType, AbstractString}),
+                         Tuple{Any, Any, typeof(alloca!), IRBuilder, LLVMType,
+                               AbstractString})
+    @test !calls_wrapper(kwbody(array_alloca!,
+                                Tuple{IRBuilder, LLVMType, Value, AbstractString}),
+                         Tuple{Any, Any, typeof(array_alloca!), IRBuilder, LLVMType,
+                               Value, AbstractString})
+    @test !calls_wrapper(kwbody(globalstring!,
+                                Tuple{LLVM.Module, AbstractString, AbstractString}),
+                         Tuple{Union{Nothing, Integer}, Bool, typeof(globalstring!),
+                               LLVM.Module, AbstractString, AbstractString})
+
+    # documented wrappers are inlined too
+    @test !calls_wrapper(intcast!, Tuple{IRBuilder, Value, LLVMType, AbstractString})
+    @test !calls_wrapper(LLVM.Interop._generate_llvmcall,
+                         Tuple{Any, Any, Any, Vector{Any}, String,
+                               Union{Nothing, Vector{Any}}})
 end
 
 end