Merge pull request #194 from maleadt/tb/cleanup

Clean-ups

Author: maleadt

examples/sum.jl

@@ -1,5 +1,7 @@
 # https://pauladamsmith.com/blog/2015/01/how-to-get-started-with-llvm-c-api.html
 
+using Test
+
 using LLVM
 
 if length(ARGS) == 2
@@ -35,7 +37,7 @@ Interpreter(mod) do engine
             GenericValue(LLVM.Int32Type(), y)]
 
     res = LLVM.run(engine, sum, args)
-    println(convert(Int, res))
+    @test convert(Int, res) == x + y
 
     dispose.(args)
     dispose(res)

examples/sum_integrated.jl

@@ -1,5 +1,7 @@
 # same as `sum.jl`, but reusing the Julia compiler to compile and execute the IR
 
+using Test
+
 using LLVM
 using LLVM.Interop
 
@@ -25,6 +27,5 @@ end
 
 # make Julia compile and execute the function
 push!(function_attributes(sum), EnumAttribute("alwaysinline"))
-ptr = LLVM.ref(sum)
-call_sum(x, y) = Base.llvmcall(ptr, Int32, Tuple{Int32, Int32}, x, y)
-@show call_sum(x, y)
+@eval call_sum(x, y) = $(call_function(sum, Int32, Tuple{Int32, Int32}, :(x, y)))
+@test call_sum(x, y) == x + y

lib/libLLVM_extra.jl

@@ -51,7 +51,7 @@ end
 
 const LLVMPassRef = Ptr{LLVMOpaquePass}
 
-function LLVMAddPass(PM::LLVMPassManagerRef, P::LLVMPassRef)
+function LLVMAddPass(PM, P)
     ccall(:LLVMExtraAddPass,Cvoid,
         (LLVMPassManagerRef, LLVMPassRef),
         PM, P)
@@ -78,100 +78,100 @@ end
 
 # various missing functions
 
-function LLVMAddInternalizePassWithExportList(PM::LLVMPassManagerRef, ExportList, Length)
+function LLVMAddInternalizePassWithExportList(PM, ExportList, Length)
     ccall(:LLVMExtraAddInternalizePassWithExportList,Cvoid,(LLVMPassManagerRef,Ptr{Cstring},Csize_t), PM, ExportList, Length)
 end
 
-function LLVMAddTargetLibraryInfoByTriple(Triple, PM::LLVMPassManagerRef)
+function LLVMAddTargetLibraryInfoByTriple(Triple, PM)
     ccall(:LLVMExtraAddTargetLibraryInfoByTiple,Cvoid,(Cstring, LLVMPassManagerRef), Triple, PM)
 end
 
 if VERSION < v"1.2.0-DEV.531"
-function LLVMAddNVVMReflectPass(PM::LLVMPassManagerRef, smversion)
+function LLVMAddNVVMReflectPass(PM, smversion)
     ccall(:LLVMExtraAddMVVMReflectPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 else
 
 if version() < v"8.0"
-    function LLVMAddNVVMReflectPass(PM::LLVMPassManagerRef, smversion)
+    function LLVMAddNVVMReflectPass(PM, smversion)
         ccall(:LLVMExtraAddNVVMReflectPass,Cvoid,(LLVMPassManagerRef,), PM)
     end
 else
-    function LLVMAddNVVMReflectPass(PM::LLVMPassManagerRef, smversion)
+    function LLVMAddNVVMReflectPass(PM, smversion)
         ccall(:LLVMExtraAddNVVMReflectFunctionPass,Cvoid,(LLVMPassManagerRef, Cuint), PM, smversion)
     end
 end
 
-function LLVMAddAllocOptPass(PM::LLVMPassManagerRef)
+function LLVMAddAllocOptPass(PM)
     ccall(:LLVMExtraAddAllocOptPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddBarrierNoopPass(PM::LLVMPassManagerRef)
+function LLVMAddBarrierNoopPass(PM)
     ccall(:LLVMExtraAddBarrierNoopPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddGCInvariantVerifierPass(PM::LLVMPassManagerRef, Strong)
+function LLVMAddGCInvariantVerifierPass(PM, Strong)
     ccall(:LLVMExtraAddGCInvariantVerifierPass,Cvoid,(LLVMPassManagerRef,LLVMBool), PM, Strong)
 end
 
-function LLVMAddLowerExcHandlersPass(PM::LLVMPassManagerRef)
+function LLVMAddLowerExcHandlersPass(PM)
     ccall(:LLVMExtraAddLowerExcHandlersPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddCombineMulAddPass(PM::LLVMPassManagerRef)
+function LLVMAddCombineMulAddPass(PM)
     ccall(:LLVMExtraAddCombineMulAddPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddMultiVersioningPass(PM::LLVMPassManagerRef)
+function LLVMAddMultiVersioningPass(PM)
     ccall(:LLVMExtraAddMultiVersioningPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddPropagateJuliaAddrspaces(PM::LLVMPassManagerRef)
+function LLVMAddPropagateJuliaAddrspaces(PM)
     ccall(:LLVMExtraAddPropagateJuliaAddrspaces,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddLowerPTLSPass(PM::LLVMPassManagerRef, imaging_mode)
+function LLVMAddLowerPTLSPass(PM, imaging_mode)
     ccall(:LLVMExtraAddLowerPTLSPass,Cvoid,(LLVMPassManagerRef,LLVMBool), PM, imaging_mode)
 end
 
-function LLVMAddLowerSimdLoopPass(PM::LLVMPassManagerRef)
+function LLVMAddLowerSimdLoopPass(PM)
     ccall(:LLVMExtraAddLowerSimdLoopPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
-function LLVMAddLateLowerGCFramePass(PM::LLVMPassManagerRef)
+function LLVMAddLateLowerGCFramePass(PM)
     ccall(:LLVMExtraAddLateLowerGCFramePass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 
 end
 
 if VERSION >= v"1.3.0-DEV.95"
-function LLVMAddFinalLowerGCPass(PM::LLVMPassManagerRef)
+function LLVMAddFinalLowerGCPass(PM)
     ccall(:LLVMExtraAddFinalLowerGCPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 end
 
 if VERSION >= v"1.5.0-DEV.802"
-function LLVMAddRemoveJuliaAddrspacesPass(PM::LLVMPassManagerRef)
+function LLVMAddRemoveJuliaAddrspacesPass(PM)
     ccall(:LLVMExtraAddRemoveJuliaAddrspacesPass,Cvoid,(LLVMPassManagerRef,), PM)
 end
 end
 
-function LLVMGetValueContext(V::LLVMValueRef)
+function LLVMGetValueContext(V)
     ccall(:LLVMExtraGetValueContext,LLVMContextRef,(LLVMValueRef,),V)
 end
 
 if VERSION >= v"0.7.0-alpha.37"
-function LLVMGetSourceLocation(V::LLVMValueRef, index, Name, Filename, Line, Column)
+function LLVMGetSourceLocation(V, index, Name, Filename, Line, Column)
     ccall(:LLVMExtraGetSourceLocation,Cint,(LLVMValueRef,Cint,Ptr{Cstring},Ptr{Cstring},Ptr{Cuint},Ptr{Cuint}), V, index, Name, Filename, Line, Column)
 end
 end
 
 if VERSION >= v"1.5" && !(v"1.6-" <= VERSION < v"1.6.0-DEV.90")
-function LLVMExtraAppendToUsed(Mod::LLVMModuleRef, Values, Count)
+function LLVMExtraAppendToUsed(Mod, Values, Count)
     ccall(:LLVMExtraAppendToUsed,Cvoid,(LLVMModuleRef,Ptr{LLVMValueRef},Csize_t), Mod, Values, Count)
 end
 
-function LLVMExtraAppendToCompilerUsed(Mod::LLVMModuleRef, Values, Count)
+function LLVMExtraAppendToCompilerUsed(Mod, Values, Count)
     ccall(:LLVMExtraAppendToCompilerUsed,Cvoid,(LLVMModuleRef,Ptr{LLVMValueRef},Csize_t), Mod, Values, Count)
 end
 

src/analysis.jl

@@ -3,17 +3,16 @@ export verify
 function verify(mod::Module)
     out_error = Ref{Cstring}()
     status =
-        convert(Core.Bool, API.LLVMVerifyModule(ref(mod), API.LLVMReturnStatusAction, out_error))
+        convert(Core.Bool, API.LLVMVerifyModule(mod, API.LLVMReturnStatusAction, out_error))
 
     if status
-        error = unsafe_string(out_error[])
-        API.LLVMDisposeMessage(out_error[])
+        error = unsafe_message(out_error[])
         throw(LLVMException(error))
     end
 end
 
 function verify(f::Function)
-    status = convert(Core.Bool, API.LLVMVerifyFunction(ref(f), API.LLVMReturnStatusAction))
+    status = convert(Core.Bool, API.LLVMVerifyFunction(f, API.LLVMReturnStatusAction))
 
     if status
         throw(LLVMException("broken function"))

src/bitcode.jl

@@ -4,7 +4,7 @@ function Base.parse(::Type{Module}, data::Vector{T}) where T<:Union{UInt8,Int8}
     membuf = MemoryBuffer(data, "", false)
     out_ref = Ref{API.LLVMModuleRef}()
 
-    status = convert(Core.Bool, API.LLVMParseBitcode2(ref(membuf), out_ref))
+    status = convert(Core.Bool, API.LLVMParseBitcode2(membuf, out_ref))
     @assert !status # caught by diagnostics handler
 
     Module(out_ref[])
@@ -14,7 +14,7 @@ function Base.parse(::Type{Module}, data::Vector{T}, ctx::Context) where T<:Unio
     membuf = MemoryBuffer(data, "", false)
     out_ref = Ref{API.LLVMModuleRef}()
 
-    status = convert(Core.Bool, API.LLVMParseBitcodeInContext2(ref(ctx), ref(membuf), out_ref))
+    status = convert(Core.Bool, API.LLVMParseBitcodeInContext2(ctx, membuf, out_ref))
     @assert !status # caught by diagnostics handler
 
     Module(out_ref[])
@@ -24,10 +24,10 @@ end
 ## writer
 
 Base.write(io::IOStream, mod::Module) =
-    API.LLVMWriteBitcodeToFD(ref(mod), Cint(fd(io)), convert(Bool, false), convert(Bool, true))
+    API.LLVMWriteBitcodeToFD(mod, Cint(fd(io)), convert(Bool, false), convert(Bool, true))
 
 Base.convert(::Type{MemoryBuffer}, mod::Module) = MemoryBuffer(
-    API.LLVMWriteBitcodeToMemoryBuffer(ref(mod)))
+    API.LLVMWriteBitcodeToMemoryBuffer(mod))
 
 Base.convert(::Type{Vector{T}}, mod::Module) where {T<:Union{UInt8,Int8}} =
     convert(Vector{T}, convert(MemoryBuffer, mod))

src/buffer.jl

@@ -3,7 +3,8 @@ export MemoryBuffer, MemoryBufferFile, dispose
 @checked struct MemoryBuffer
     ref::API.LLVMMemoryBufferRef
 end
-reftype(::Type{MemoryBuffer}) = API.LLVMMemoryBufferRef
+
+Base.unsafe_convert(::Type{API.LLVMMemoryBufferRef}, membuf::MemoryBuffer) = membuf.ref
 
 function MemoryBuffer(data::Vector{T}, name::String="", copy::Core.Bool=true) where T<:Union{UInt8,Int8}
     ptr = pointer(data)
@@ -33,8 +34,7 @@ function MemoryBufferFile(path::String)
         convert(Core.Bool, API.LLVMCreateMemoryBufferWithContentsOfFile(path, out_ref, out_error))
 
     if status
-        error = unsafe_string(out_error[])
-        API.LLVMDisposeMessage(out_error[])
+        error = unsafe_message(out_error[])
         throw(LLVMException(error))
     end
 
@@ -50,11 +50,11 @@ function MemoryBufferFile(f::Core.Function, args...)
     end
 end
 
-dispose(membuf::MemoryBuffer) = API.LLVMDisposeMemoryBuffer(ref(membuf))
+dispose(membuf::MemoryBuffer) = API.LLVMDisposeMemoryBuffer(membuf)
 
-Base.length(membuf::MemoryBuffer) = API.LLVMGetBufferSize(ref(membuf))
+Base.length(membuf::MemoryBuffer) = API.LLVMGetBufferSize(membuf)
 
-Base.pointer(membuf::MemoryBuffer) = convert(Ptr{UInt8}, API.LLVMGetBufferStart(ref(membuf)))
+Base.pointer(membuf::MemoryBuffer) = convert(Ptr{UInt8}, API.LLVMGetBufferStart(membuf))
 
 Base.convert(::Type{Vector{UInt8}}, membuf::MemoryBuffer) =
     unsafe_wrap(Array, pointer(membuf), length(membuf))

src/core/attributes.jl

@@ -6,17 +6,18 @@ export Attribute,
        kind, value
 
 abstract type Attribute end
-reftype(::Type{T}) where {T<:Attribute} = API.LLVMAttributeRef
+
+Base.unsafe_convert(::Type{API.LLVMAttributeRef}, attr::Attribute) = attr.ref
 
 @checked struct EnumAttribute <: Attribute
-    ref::reftype(Attribute)
+    ref::API.LLVMAttributeRef
 end
 
 @checked struct StringAttribute <: Attribute
-    ref::reftype(Attribute)
+    ref::API.LLVMAttributeRef
 end
 
-# TODO: make @reftype's identify mechanism flexible enough to cover cases like this one,
+# TODO: make the identify mechanism flexible enough to cover cases like this one,
 #       and not only Value and Type
 
 function Attribute(ref::API.LLVMAttributeRef)
@@ -42,28 +43,28 @@ end
 #       (which also would conflict with the inner ref constructor)
 function EnumAttribute(kind::String, value::Integer=0, ctx::Context=GlobalContext())
     enum_kind = API.LLVMGetEnumAttributeKindForName(kind, Csize_t(length(kind)))
-    return EnumAttribute(API.LLVMCreateEnumAttribute(ref(ctx), enum_kind, UInt64(value)))
+    return EnumAttribute(API.LLVMCreateEnumAttribute(ctx, enum_kind, UInt64(value)))
 end
 
-kind(attr::EnumAttribute) = API.LLVMGetEnumAttributeKind(ref(attr))
+kind(attr::EnumAttribute) = API.LLVMGetEnumAttributeKind(attr)
 
-value(attr::EnumAttribute) = API.LLVMGetEnumAttributeValue(ref(attr))
+value(attr::EnumAttribute) = API.LLVMGetEnumAttributeValue(attr)
 
 
 ## string attribute
 
 StringAttribute(kind::String, value::String="", ctx::Context=GlobalContext()) =
-    StringAttribute(API.LLVMCreateStringAttribute(ref(ctx), kind, length(kind),
+    StringAttribute(API.LLVMCreateStringAttribute(ctx, kind, length(kind),
                                                   value, length(value)))
 
 function kind(attr::StringAttribute)
     len = Ref{Cuint}()
-    data = API.LLVMGetStringAttributeKind(ref(attr), len)
+    data = API.LLVMGetStringAttributeKind(attr, len)
     return unsafe_string(convert(Ptr{Int8}, data), len[])
 end
 
 function value(attr::StringAttribute)
     len = Ref{Cuint}()
-    data = API.LLVMGetStringAttributeValue(ref(attr), len)
+    data = API.LLVMGetStringAttributeValue(attr, len)
     return unsafe_string(convert(Ptr{Int8}, data), len[])
 end

src/core/basicblock.jl

@@ -3,42 +3,42 @@ export BasicBlock, unsafe_delete!,
        move_before, move_after
 
 @checked struct BasicBlock <: Value
-    ref::reftype(Value)
+    ref::API.LLVMValueRef
 end
 identify(::Type{Value}, ::Val{API.LLVMBasicBlockValueKind}) = BasicBlock
 
+BasicBlock(ref::API.LLVMBasicBlockRef) = BasicBlock(API.LLVMBasicBlockAsValue(ref))
+Base.unsafe_convert(::Type{API.LLVMBasicBlockRef}, bb::BasicBlock) = API.LLVMValueAsBasicBlock(bb)
+
 # forward declarations
 @checked struct Function <: GlobalObject
-    ref::reftype(GlobalObject)
+    ref::API.LLVMValueRef
 end
 
-BasicBlock(ref::API.LLVMBasicBlockRef) = BasicBlock(API.LLVMBasicBlockAsValue(ref))
-blockref(bb::BasicBlock) = API.LLVMValueAsBasicBlock(ref(bb))
-
-BasicBlock(f::Function, name::String) = 
-    BasicBlock(API.LLVMAppendBasicBlock(ref(f), name))
-BasicBlock(f::Function, name::String, ctx::Context) = 
-    BasicBlock(API.LLVMAppendBasicBlockInContext(ref(ctx), ref(f), name))
-BasicBlock(bb::BasicBlock, name::String) = 
-    BasicBlock(API.LLVMInsertBasicBlock(blockref(bb), name))
-BasicBlock(bb::BasicBlock, name::String, ctx::Context) = 
-    BasicBlock(API.LLVMInsertBasicBlockInContext(ref(ctx), blockref(bb), name))
-
-unsafe_delete!(::Function, bb::BasicBlock) = API.LLVMDeleteBasicBlock(blockref(bb))
+BasicBlock(f::Function, name::String) =
+    BasicBlock(API.LLVMAppendBasicBlock(f, name))
+BasicBlock(f::Function, name::String, ctx::Context) =
+    BasicBlock(API.LLVMAppendBasicBlockInContext(ctx, f, name))
+BasicBlock(bb::BasicBlock, name::String) =
+    BasicBlock(API.LLVMInsertBasicBlock(bb, name))
+BasicBlock(bb::BasicBlock, name::String, ctx::Context) =
+    BasicBlock(API.LLVMInsertBasicBlockInContext(ctx, bb, name))
+
+unsafe_delete!(::Function, bb::BasicBlock) = API.LLVMDeleteBasicBlock(bb)
 Base.delete!(::Function, bb::BasicBlock) =
-    API.LLVMRemoveBasicBlockFromParent(blockref(bb))
+    API.LLVMRemoveBasicBlockFromParent(bb)
 
-parent(bb::BasicBlock) = Function(API.LLVMGetBasicBlockParent(blockref(bb)))
+parent(bb::BasicBlock) = Function(API.LLVMGetBasicBlockParent(bb))
 
-terminator(bb::BasicBlock) = Instruction(API.LLVMGetBasicBlockTerminator(blockref(bb)))
+terminator(bb::BasicBlock) = Instruction(API.LLVMGetBasicBlockTerminator(bb))
 
 name(bb::BasicBlock) =
-    unsafe_string(API.LLVMGetBasicBlockName(blockref(bb)))
+    unsafe_string(API.LLVMGetBasicBlockName(bb))
 
 move_before(bb::BasicBlock, pos::BasicBlock) =
-    API.LLVMMoveBasicBlockBefore(blockref(bb), blockref(pos))
+    API.LLVMMoveBasicBlockBefore(bb, pos)
 move_after(bb::BasicBlock, pos::BasicBlock) =
-    API.LLVMMoveBasicBlockAfter(blockref(bb), blockref(pos))
+    API.LLVMMoveBasicBlockAfter(bb, pos)
 
 
 ## instruction iteration
@@ -54,14 +54,14 @@ instructions(bb::BasicBlock) = BasicBlockInstructionSet(bb)
 Base.eltype(::BasicBlockInstructionSet) = Instruction
 
 function Base.iterate(iter::BasicBlockInstructionSet,
-                      state=API.LLVMGetFirstInstruction(blockref(iter.bb)))
+                      state=API.LLVMGetFirstInstruction(iter.bb))
     state == C_NULL ? nothing : (Instruction(state), API.LLVMGetNextInstruction(state))
 end
 
 Base.last(iter::BasicBlockInstructionSet) =
-    Instruction(API.LLVMGetLastInstruction(blockref(iter.bb)))
+    Instruction(API.LLVMGetLastInstruction(iter.bb))
 
 Base.isempty(iter::BasicBlockInstructionSet) =
-    API.LLVMGetLastInstruction(blockref(iter.bb)) == C_NULL
+    API.LLVMGetLastInstruction(iter.bb) == C_NULL
 
 Base.IteratorSize(::BasicBlockInstructionSet) = Base.SizeUnknown()