Merge pull request #193 from maleadt/tb/intrinsics

Wrap intrinsics API.

Author: maleadt

src/core/function.jl

@@ -1,7 +1,7 @@
 export unsafe_delete!,
        personality, personality!,
        callconv, callconv!,
-       gc, gc!, intrinsic_id,
+       gc, gc!,
        entry
 
 # forward declaration of Function in src/core/basicblock.jl
@@ -19,8 +19,6 @@ end
 personality!(f::Function, persfn::Union{Nothing,Function}) =
     API.LLVMSetPersonalityFn(ref(f), persfn===nothing ? C_NULL : ref(persfn))
 
-intrinsic_id(f::Function) = API.LLVMGetIntrinsicID(ref(f))
-
 callconv(f::Function) = API.LLVMGetFunctionCallConv(ref(f))
 callconv!(f::Function, cc) = API.LLVMSetFunctionCallConv(ref(f), cc)
 
@@ -142,3 +140,66 @@ function Base.collect(iter::FunctionBlockSet)
     API.LLVMGetBasicBlocks(ref(iter.f), elems)
     return BasicBlock[BasicBlock(elem) for elem in elems]
 end
+
+# intrinsics
+
+export isintrinsic, Intrinsic, isoverloaded, declaration
+
+isintrinsic(f::Function) = API.LLVMGetIntrinsicID(ref(f)) != 0
+
+struct Intrinsic
+    id::UInt32
+
+    function Intrinsic(f::Function)
+        id = API.LLVMGetIntrinsicID(ref(f))
+        id == 0 && throw(ArgumentError("Function is not an intrinsic"))
+        new(id)
+    end
+
+    function Intrinsic(name::String)
+        @assert version() >= v"9"
+        new(API.LLVMLookupIntrinsicID(name, length(name)))
+    end
+end
+
+Base.convert(::Type{UInt32}, intr::Intrinsic) = intr.id
+
+function name(intr::Intrinsic)
+    @assert version() >= v"8"
+    len = Ref{Csize_t}()
+    str = API.LLVMIntrinsicGetName(intr, len)
+    unsafe_string(convert(Ptr{Cchar}, str), len[])
+end
+
+function name(intr::Intrinsic, params::Vector{<:LLVMType})
+    @assert version() >= v"8"
+    len = Ref{Csize_t}()
+    str = API.LLVMIntrinsicCopyOverloadedName(intr, ref.(params), length(params), len)
+    unsafe_message(convert(Ptr{Cchar}, str), len[])
+end
+
+function isoverloaded(intr::Intrinsic)
+    @assert version() >= v"8"
+    convert(Core.Bool, API.LLVMIntrinsicIsOverloaded(intr))
+end
+
+function Function(mod::Module, intr::Intrinsic, params::Vector{<:LLVMType}=LLVMType[])
+    @assert version() >= v"8"
+    Value(API.LLVMGetIntrinsicDeclaration(ref(mod), intr, ref.(params), length(params)))
+end
+
+function FunctionType(intr::Intrinsic, params::Vector{<:LLVMType}=LLVMType[];
+                  ctx::Context=GlobalContext())
+    @assert version() >= v"8"
+    LLVMType(API.LLVMIntrinsicGetType(ref(ctx), intr, ref.(params), length(params)))
+end
+
+function Base.show(io::IO, intr::Intrinsic)
+    print(io, "Intrinsic($(intr.id))")
+    if version() >= v"8"
+        print(io, ": \"$(name(intr))\"")
+        if isoverloaded(intr)
+            print(io, " (overloaded)")
+        end
+    end
+end

src/deprecated.jl

@@ -11,3 +11,5 @@ import Base: haskey, getindex, get
 @deprecate haskey(::TargetIterator, name::String) Target(;name=name) !== nothing
 @deprecate getindex(iter::TargetIterator, name::String) Target(;name=name)
 @deprecate get(::TargetIterator, name::String, default) try Target(;name=name) catch; default end
+
+@deprecate intrinsic_id(f::Function) isintrinsic(f) ? Intrinsic(f) : 0

src/intrinsics.jl

@@ -1,7 +1,7 @@
 # utilities
 
-function unsafe_message(ptr)
-    str = unsafe_string(ptr)
+function unsafe_message(ptr, args...)
+    str = unsafe_string(ptr, args...)
     API.LLVMDisposeMessage(ptr)
     str
 end

src/util.jl

@@ -680,7 +680,7 @@ LLVM.Module("SomeModule", ctx) do mod
     @test personality(fn) === nothing
     unsafe_delete!(mod, pers_fn)
 
-    @test intrinsic_id(fn) == 0
+    @test !isintrinsic(fn)
 
     @test callconv(fn) == LLVM.API.LLVMCCallConv
     callconv!(fn, LLVM.API.LLVMFastCallConv)
@@ -698,6 +698,37 @@ LLVM.Module("SomeModule", ctx) do mod
 end
 end
 
+Context() do ctx
+LLVM.Module("SomeModule", ctx) do mod
+    intr_ft = LLVM.FunctionType(LLVM.DoubleType(ctx), [LLVM.DoubleType(ctx)])
+    intr_fn = LLVM.Function(mod, "llvm.sin.f64", intr_ft)
+    @test isintrinsic(intr_fn)
+
+    intr = Intrinsic(intr_fn)
+    show(devnull, intr)
+
+    if LLVM.version() >= v"8"
+        @test isoverloaded(intr)
+
+        @test name(intr) == "llvm.sin"
+        @test name(intr, [LLVM.DoubleType(ctx)]) == "llvm.sin.f64"
+
+        ft = FunctionType(intr, [LLVM.DoubleType(ctx)])
+        @test ft isa FunctionType
+        @test return_type(ft) == LLVM.DoubleType(ctx)
+
+        fn = LLVM.Function(mod, intr, [LLVM.DoubleType(ctx)])
+        @test fn isa LLVM.Function
+        @test eltype(llvmtype(fn)) == ft
+        @test isintrinsic(fn)
+    end
+
+    if LLVM.version() >= v"9"
+        @test intr == Intrinsic("llvm.sin")
+    end
+end
+end
+
 # attributes
 Context() do ctx
 LLVM.Module("SomeModule", ctx) do mod