Merge pull request #177 from maleadt/tb/bounds_checking

Add bounds checking to iterators.

Author: maleadt

src/core/function.jl

@@ -84,8 +84,10 @@ parameters(f::Function) = FunctionParameterSet(f)
 
 Base.eltype(::FunctionParameterSet) = Argument
 
-Base.getindex(iter::FunctionParameterSet, i) =
-  Argument(API.LLVMGetParam(ref(iter.f), i-1))
+function Base.getindex(iter::FunctionParameterSet, i)
+    @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
+    return Argument(API.LLVMGetParam(ref(iter.f), i-1))
+end
 
 function Base.iterate(iter::FunctionParameterSet, state=API.LLVMGetFirstParam(ref(iter.f)))
     state == C_NULL ? nothing : (Argument(state), API.LLVMGetNextParam(state))

src/core/instructions.jl

@@ -167,8 +167,10 @@ successors(term::Instruction) = TerminatorSuccessorSet(term)
 
 Base.eltype(::TerminatorSuccessorSet) = BasicBlock
 
-Base.getindex(iter::TerminatorSuccessorSet, i) =
-    BasicBlock(API.LLVMGetSuccessor(ref(iter.term), i-1))
+function Base.getindex(iter::TerminatorSuccessorSet, i)
+    @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
+    return BasicBlock(API.LLVMGetSuccessor(ref(iter.term), i-1))
+end
 
 Base.setindex!(iter::TerminatorSuccessorSet, bb::BasicBlock, i) =
     API.LLVMSetSuccessor(ref(iter.term), i-1, blockref(bb))
@@ -196,9 +198,11 @@ incoming(phi::Instruction) = PhiIncomingSet(phi)
 
 Base.eltype(::PhiIncomingSet) = Tuple{Value,BasicBlock}
 
-Base.getindex(iter::PhiIncomingSet, i) =
-    tuple(Value(API.LLVMGetIncomingValue(ref(iter.phi), i-1)),
-                BasicBlock(API.LLVMGetIncomingBlock(ref(iter.phi), i-1)))
+function Base.getindex(iter::PhiIncomingSet, i)
+    @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
+    return tuple(Value(API.LLVMGetIncomingValue(ref(iter.phi), i-1)),
+                       BasicBlock(API.LLVMGetIncomingBlock(ref(iter.phi), i-1)))
+end
 
 function Base.append!(iter::PhiIncomingSet, args::Vector{Tuple{V, BasicBlock}} where V <: Value)
     vals, blocks = zip(args...)

src/core/type.jl

@@ -217,8 +217,10 @@ elements(typ::StructType) = StructTypeElementSet(typ)
 
 Base.eltype(::StructTypeElementSet) = LLVMType
 
-Base.getindex(iter::StructTypeElementSet, i) =
-    LLVMType(API.LLVMStructGetTypeAtIndex(ref(iter.typ), i-1))
+function Base.getindex(iter::StructTypeElementSet, i)
+    @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
+    return LLVMType(API.LLVMStructGetTypeAtIndex(ref(iter.typ), i-1))
+end
 
 function Base.iterate(iter::StructTypeElementSet, i=1)
     i >= length(iter) + 1 ? nothing : (iter[i], i+1)

src/core/value/user.jl

@@ -14,8 +14,10 @@ operands(user::User) = UserOperandSet(user)
 
 Base.eltype(::UserOperandSet) = Value
 
-Base.getindex(iter::UserOperandSet, i::Integer) =   # TODO: otherwise unitrange indexing errors
-    Value(API.LLVMGetOperand(ref(iter.user), i-1))
+function Base.getindex(iter::UserOperandSet, i::Integer)   # TODO: otherwise unitrange indexing errors
+    @boundscheck 1 <= i <= length(iter) || throw(BoundsError(iter, i))
+    return Value(API.LLVMGetOperand(ref(iter.user), i-1))
+end
 
 Base.setindex!(iter::UserOperandSet, val::Value, i) =
     API.LLVMSetOperand(ref(iter.user), i-1, ref(val))

test/core.jl

@@ -68,6 +68,7 @@ Context() do ctx
     @test !isvararg(ft)
     @test return_type(ft) == x
     @test parameters(ft) == y
+    @test_throws BoundsError parameters(ft)[3]
 end
 
 # sequential
@@ -134,6 +135,7 @@ Context() do ctx
 
             @test first(elem_it) == elem[1]
             @test last(elem_it) == elem[end]
+            @test_throws BoundsError elem_it[3]
 
             i = 1
             for el in elem_it
@@ -284,6 +286,7 @@ Context() do ctx
             @test length(ops) == 2
             @test ops[1] == first(parameters(fun))
             @test ops[2] == ConstantInt(LLVM.Int32Type(ctx), 1)
+            @test_throws BoundsError ops[3]
         elseif i == 2
             @test length(ops) == 0
             @test collect(ops) == []
@@ -895,6 +898,7 @@ LLVM.Module("SomeModule", ctx) do mod
 
         @test succ[1] == bb2
         @test succ[2] == bb3
+        @test_throws BoundsError succ[3]
 
         @test collect(succ) == [bb2, bb3]
         @test first(succ) == bb2

test/execution.jl

@@ -123,6 +123,7 @@ function emit_phi(ctx::Context)
         append!(LLVM.incoming(phi), [(thencg, then), (elsecg, elsee)])
 
         @test length(LLVM.incoming(phi)) == 2
+        @test_throws BoundsError LLVM.incoming(phi)[3]
 
         ret!(builder, phi)
     end
@@ -184,7 +185,7 @@ Context() do ctx
         end
         dispose.(args)
     end
-    
+
     let mod1 = emit_sum(ctx), mod2 = emit_retint(ctx, 42)
         Interpreter(mod1) do engine
             @test_throws ErrorException collect(functions(engine))