Reuse existing IRError infrastructure.

Author: maleadt

src/jlgen.jl

@@ -221,34 +221,53 @@ function InferenceState(result::InferenceResult, cached::Symbol, interp::GPUInte
     src === nothing && return nothing
     validate_code_in_debug_mode(result.linfo, src, "lowered")
     validate_globalrefs(interp, result.linfo, src)
+    validate_code_in_debug_mode(result.linfo, src, "validated")
+    errors = Core.Compiler.validate_code(result.linfo, src)
+    @safe_info "errors" errors src.code
     return InferenceState(result, src, cached, interp)
 end
 
+const UNDEFINED_GLOBAL = "use of an undefined global binding"
+const MUTABLE_GLOBAL   = "use of a mutable global binding"
+
 function validate_globalrefs(interp, mi, src)
-    function validate(x)
+    # pseudo (single-frame) backtrace pointing to a source code location
+    function backtrace(i)
+        loc = src.linetable[i]
+        [StackTraces.StackFrame(loc.method, loc.file, loc.line, mi, false, false, C_NULL)]
+    end
+
+    function validate(i, x, errors::Vector{IRError})
         if x isa Expr
-            return Expr(x.head, validate.(x.args))
+            for y in x.args
+                validate(i, y, errors)
+            end
         elseif x isa GlobalRef
             Base.isbindingresolved(x.mod, x.name) || return
             # XXX: when does this happen? do we miss any cases by bailing out early?
             #      why doesn't calling `Base.resolve(x, force=true)` work?
             if !Base.isdefined(x.mod, x.name)
-                throw(KernelError(interp.job, "using undefined global: $(x.mod).$(x.name)"))
+               push!(errors, (UNDEFINED_GLOBAL, backtrace(i), x))
             end
             if !Base.isconst(x.mod, x.name)
-                throw(KernelError(interp.job, "using mutable global: $(x.mod).$(x.name)"))
+                push!(errors, (MUTABLE_GLOBAL, backtrace(i), x))
             end
-            # XXX: can we use KernelError? and make the validation conditional? both are
-            #      complicated by the fact that we don't have the CompilerJob here,
-            #      and that inference results can be cached across jobs.
+
+            # TODO: make the validation conditional, but make sure we don't cache invalid IR
 
             # TODO: perform more validation? e.g. disallow Arrays and other CPU values?
-            #       probably requires an interface, so again access to the CompilerJob
-            #       (as a CPU-back-end would still support such values).
         end
+
+        return
     end
 
-    validate.(src.code)
+    errors = IRError[]
+    for (i, x) in enumerate(src.code)
+        validate(i, x, errors)
+    end
+    if !isempty(errors)
+        throw(InvalidIRError(interp.job, errors))
+    end
 
     return
 end

src/validation.jl

@@ -95,6 +95,8 @@ end
 
 ## IR validation
 
+# TODO: generalize for Julia and LLVM IR
+
 const IRError = Tuple{String, StackTraces.StackTrace, Any} # kind, bt, meta
 
 struct InvalidIRError <: Exception
@@ -117,6 +119,8 @@ function Base.showerror(io::IO, err::InvalidIRError)
                 print(io, " (call to ", meta, ")")
             elseif kind == DELAYED_BINDING
                 print(io, " (use of '", meta, "')")
+            else
+                print(io, " (", meta, ")")
             end
         end
         Base.show_backtrace(io, bt)