Specialized isempty functions.

Prevents having to iterate values if size is unknown.

Author: maleadt

src/core/basicblock.jl

@@ -61,4 +61,7 @@ end
 Base.last(iter::BasicBlockInstructionSet) =
     Instruction(API.LLVMGetLastInstruction(blockref(iter.bb)))
 
+Base.isempty(iter::BasicBlockInstructionSet) =
+    API.LLVMGetLastInstruction(blockref(iter.bb)) == C_NULL
+
 Base.IteratorSize(::BasicBlockInstructionSet) = Base.SizeUnknown()

src/core/function.jl

@@ -94,6 +94,9 @@ end
 Base.last(iter::FunctionParameterSet) =
     Argument(API.LLVMGetLastParam(ref(iter.f)))
 
+Base.isempty(iter::FunctionParameterSet) =
+    API.LLVMGetLastParam(ref(iter.f)) == C_NULL
+
 Base.length(iter::FunctionParameterSet) = API.LLVMCountParams(ref(iter.f))
 
 # NOTE: optimized `collect`
@@ -122,6 +125,9 @@ end
 Base.last(iter::FunctionBlockSet) =
     BasicBlock(API.LLVMGetLastBasicBlock(ref(iter.f)))
 
+Base.isempty(iter::FunctionBlockSet) =
+    API.LLVMGetLastBasicBlock(ref(iter.f)) == C_NULL
+
 Base.length(iter::FunctionBlockSet) = API.LLVMCountBasicBlocks(ref(iter.f))
 
 # NOTE: optimized `collect`

src/core/module.jl

@@ -123,6 +123,9 @@ end
 Base.last(iter::ModuleGlobalSet) =
     GlobalVariable(API.LLVMGetLastGlobal(ref(iter.mod)))
 
+Base.isempty(iter::ModuleGlobalSet) =
+    API.LLVMGetLastGlobal(ref(iter.mod)) == C_NULL
+
 Base.IteratorSize(::ModuleGlobalSet) = Base.SizeUnknown()
 
 # partial associative interface
@@ -157,6 +160,9 @@ end
 Base.last(iter::ModuleFunctionSet) =
     Function(API.LLVMGetLastFunction(ref(iter.mod)))
 
+Base.isempty(iter::ModuleFunctionSet) =
+    API.LLVMGetLastFunction(ref(iter.mod)) == C_NULL
+
 Base.IteratorSize(::ModuleFunctionSet) = Base.SizeUnknown()
 
 # partial associative interface

test/core.jl

@@ -411,7 +411,9 @@ end
 # global variables
 Context() do ctx
 LLVM.Module("SomeModule", ctx) do mod
+    @test isempty(globals(mod))
     gv = GlobalVariable(mod, LLVM.Int32Type(ctx), "SomeGlobal")
+    @test !isempty(globals(mod))
 
     show(devnull, gv)
 
@@ -600,11 +602,14 @@ Context() do ctx
 LLVM.Module("SomeModule", ctx) do mod
     st = LLVM.StructType("SomeType", ctx)
     ft = LLVM.FunctionType(st, [st])
+    @test isempty(functions(mod))
 
     dummyfn = LLVM.Function(mod, "SomeFunction", ft)
     let fns = functions(mod)
         @test eltype(fns) == LLVM.Function
 
+        @test !isempty(fns)
+
         @test first(fns) == dummyfn
         @test last(fns) == dummyfn
 
@@ -738,12 +743,14 @@ Context() do ctx
 LLVM.Module("SomeModule", ctx) do mod
     ft = LLVM.FunctionType(LLVM.VoidType(ctx))
     fn = LLVM.Function(mod, "SomeFunction", ft)
+    @test isempty(blocks(fn))
 
     entrybb = BasicBlock(fn, "SomeBasicBlock")
     @test entry(fn) == entrybb
     let bbs = blocks(fn)
         @test eltype(bbs) == BasicBlock
 
+        @test !isempty(bbs)
         @test length(bbs) == 1
 
         @test first(bbs) == entrybb
@@ -799,13 +806,15 @@ LLVM.Module("SomeModule", ctx) do mod
 
     bb2 = BasicBlock(fn, "SomeOtherBasicBlock", ctx)
     @test LLVM.parent(bb2) == fn
+    @test isempty(instructions(bb2))
 
     bb1 = BasicBlock(bb2, "SomeBasicBlock", ctx)
     @test LLVM.parent(bb2) == fn
     position!(builder, bb1)
     brinst = br!(builder, bb2)
     position!(builder, bb2)
     retinst = ret!(builder)
+    @test !isempty(instructions(bb2))
 
     @test terminator(bb1) == brinst
     @test terminator(bb2) == retinst
@@ -835,8 +844,13 @@ end
 Context() do ctx
 Builder(ctx) do builder
 LLVM.Module("SomeModule", ctx) do mod
-    ft = LLVM.FunctionType(LLVM.VoidType(ctx), [LLVM.Int1Type(ctx), LLVM.Int1Type(ctx)])
+    ft = LLVM.FunctionType(LLVM.VoidType(ctx))
     fn = LLVM.Function(mod, "SomeFunction", ft)
+    @test isempty(parameters(fn))
+
+    ft = LLVM.FunctionType(LLVM.VoidType(ctx), [LLVM.Int1Type(ctx), LLVM.Int1Type(ctx)])
+    fn = LLVM.Function(mod, "SomeOtherFunction", ft)
+    @test !isempty(parameters(fn))
 
     bb1 = BasicBlock(fn, "entry", ctx)
     bb2 = BasicBlock(fn, "then", ctx)