Merge pull request #189 from maleadt/tb/target_iterator

Rework target lookup and iteration.

Author: maleadt

examples/Kaleidoscope/run.jl

@@ -43,7 +43,7 @@ end
 
 function write_objectfile(mod::LLVM.Module, path::String)
     host_triple = Sys.MACHINE # LLVM.triple() might be wrong (see LLVM.jl#108)
-    host_t = LLVM.Target(host_triple)
+    host_t = LLVM.Target(triple=host_triple)
     LLVM.TargetMachine(host_t, host_triple) do tm
         LLVM.emit(tm, mod, LLVM.API.LLVMObjectFile, path)
     end

src/deprecated.jl

@@ -1,7 +1,13 @@
 # deprecated methods
 
-import Base: get
+@deprecate FunctionType(rettyp, params, vararg) FunctionType(rettyp, params; vararg=vararg)
 
-@deprecate get(set::TargetSet, name::String) getindex(set, name)
+# Target non-kwarg constructor
+@deprecate Target(triple::String) Target(; triple=triple)
 
-@deprecate FunctionType(rettyp, params, vararg) FunctionType(rettyp, params; vararg=vararg)
+# TargetIterator dict-like behavior
+import Base: haskey, getindex, get
+@deprecate get(set::TargetIterator, name::String) getindex(set, name)
+@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

src/target.jl

@@ -9,17 +9,29 @@ export Target,
 end
 reftype(::Type{Target}) = API.LLVMTargetRef
 
-function Target(triple::String)
-    out_ref = Ref{API.LLVMTargetRef}()
-    out_error = Ref{Cstring}()
-    status = convert(Core.Bool, API.LLVMGetTargetFromTriple(triple, out_ref, out_error))
-
-    if status
-        error = unsafe_message(out_error[])
-        throw(LLVMException(error))
+function Target(; name=nothing, triple=nothing)
+    (name !== nothing) ⊻ (triple !== nothing) ||
+        throw(ArgumentError("Specify either name or triple."))
+
+    if triple !== nothing
+        target_ref = Ref{API.LLVMTargetRef}(0)
+        error_ref = Ref{Cstring}(C_NULL)
+        status = convert(Core.Bool, API.LLVMGetTargetFromTriple(triple, target_ref, error_ref))
+        if status && error_ref[] !== C_NULL
+            error = unsafe_message(error_ref[])
+            throw(ArgumentError(error))
+        elseif status
+            throw(ArgumentError("Cannot find a target for triple '$triple'"))
+        end
+        @assert target_ref[] != C_NULL
+        return Target(target_ref[])
+    elseif name !== nothing
+        target = API.LLVMGetTargetFromName(name)
+        if target == C_NULL
+            throw(ArgumentError("Cannot find target '$triple'"))
+        end
+        return Target(target)
     end
-
-    return Target(out_ref[])
 end
 
 name(t::Target) = unsafe_string(API.LLVMGetTargetName(ref(t)))
@@ -30,32 +42,23 @@ hasjit(t::Target) = convert(Core.Bool, API.LLVMTargetHasJIT(ref(t)))
 hastargetmachine(t::Target) = convert(Core.Bool, API.LLVMTargetHasTargetMachine(ref(t)))
 hasasmparser(t::Target) = convert(Core.Bool, API.LLVMTargetHasAsmBackend(ref(t)))
 
-# target iteration
-
-export targets
+function Base.show(io::IO, ::MIME"text/plain", target::Target)
+  print(io, "LLVM.Target($(name(target))): $(description(target))")
+end
 
-struct TargetSet end
 
-targets() = TargetSet()
+## target iteration
 
-Base.eltype(::TargetSet) = Target
+export targets
 
-function Base.haskey(::TargetSet, name::String)
-    return API.LLVMGetTargetFromName(name) != C_NULL
-end
+struct TargetIterator end
 
-function Base.get(::TargetSet, name::String, default)
-    objref = API.LLVMGetTargetFromName(name)
-    return objref == C_NULL ? default : Target(objref)
-end
+targets() = TargetIterator()
 
-function Base.getindex(targetset::TargetSet, name::String)
-    f = get(targetset, name, nothing)
-    return f == nothing ? throw(KeyError(name)) : f
-end
+Base.eltype(::TargetIterator) = Target
 
-function Base.iterate(iter::TargetSet, state=API.LLVMGetFirstTarget())
+function Base.iterate(iter::TargetIterator, state=API.LLVMGetFirstTarget())
     state == C_NULL ? nothing : (Target(state), API.LLVMGetNextTarget(state))
 end
 
-Base.IteratorSize(::TargetSet) = Base.SizeUnknown()
+Base.IteratorSize(::TargetIterator) = Base.SizeUnknown()

test/target.jl

@@ -1,8 +1,9 @@
 @testset "target" begin
-    @test_throws LLVMException Target("invalid")
+    @test_throws ArgumentError Target(triple="invalid")
+    @test_throws ArgumentError Target(name="invalid")
 
     host_triple = triple()
-    host_t = Target(host_triple)
+    host_t = Target(triple=host_triple)
 
     host_name = name(host_t)
     description(host_t)
@@ -13,12 +14,8 @@
 
     # target iteration
     let ts = targets()
-        @test haskey(ts, host_name)
-        @test ts[host_name] == host_t
-
-        @test !haskey(ts, "invalid")
-        @test get(ts, "invalid", "dummy") == "dummy"
-        @test_throws KeyError ts["invalid"]
+        @test !isempty(ts)
+        @test host_t in ts
 
         @test eltype(ts) == Target
 

test/targetmachine.jl

@@ -1,7 +1,7 @@
 @testset "targetmachine" begin
 
 host_triple = triple()
-host_t = Target(host_triple)
+host_t = Target(triple=host_triple)
 
 let
     tm = TargetMachine(host_t, host_triple)