Try giving some more informative errors for various malformed input (#54458)

I was playing with generating some code for OpaqueClosures. It's pretty
easy to generate IR that will pass the verifier, but cause assertion
errors in codegen. This tries to make the experience slightly nicer by
turning some of them into proper error messages (thus letting the
runtime discover, so that e.g. the code can be inspected at the REPL)
rather than assertions.

Author: Keno

src/codegen.cpp

@@ -5252,8 +5252,12 @@ static jl_cgval_t emit_invoke(jl_codectx_t &ctx, const jl_cgval_t &lival, ArrayR
         Value *r = emit_jlcall(ctx, jlinvoke_func, boxed(ctx, lival), argv, nargs, julia_call2);
         result = mark_julia_type(ctx, r, true, rt);
     }
-    if (result.typ == jl_bottom_type)
+    if (result.typ == jl_bottom_type) {
+#ifndef JL_NDEBUG
+        emit_error(ctx, "(Internal Error - IR Validity): Returned from function we expected not to.");
+#endif
         CreateTrap(ctx.builder);
+    }
     return result;
 }
 
@@ -6524,7 +6528,12 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaidx_
 
             SmallVector<jl_value_t *, 0> env_component_ts(nargs-4);
             for (size_t i = 0; i < nargs - 4; ++i) {
-                env_component_ts[i] = argv[4+i].typ;
+                jl_value_t *typ = argv[4+i].typ;
+                if (typ == jl_bottom_type) {
+                    JL_GC_POP();
+                    return jl_cgval_t();
+                }
+                env_component_ts[i] = typ;
             }
 
             env_t = jl_apply_tuple_type_v(env_component_ts.data(), nargs-4);
@@ -9751,9 +9760,6 @@ jl_llvm_functions_t jl_emit_code(
         jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception(jl_current_task));
         jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
         jlbacktrace(); // written to STDERR_FILENO
-#ifndef JL_NDEBUG
-        abort();
-#endif
     }
 
     return decls;

src/interpreter.c

@@ -805,7 +805,13 @@ jl_value_t *jl_interpret_opaque_closure(jl_opaque_closure_t *oc, jl_value_t **ar
         assert(jl_is_method_instance(specializations));
         jl_method_instance_t *mi = (jl_method_instance_t *)specializations;
         jl_code_instance_t *ci = jl_atomic_load_relaxed(&mi->cache);
-        code = jl_uncompress_ir(source, ci, jl_atomic_load_relaxed(&ci->inferred));
+        jl_value_t *src = jl_atomic_load_relaxed(&ci->inferred);
+        if (!src) {
+            // This can happen if somebody did :new_opaque_closure with broken IR. This is definitely bad
+            // and UB, but let's try to be slightly nicer than segfaulting here for people debugging.
+            jl_error("Internal Error: Opaque closure with no source at all");
+        }
+        code = jl_uncompress_ir(source, ci, src);
     }
     interpreter_state *s;
     unsigned nroots = jl_source_nslots(code) + jl_source_nssavalues(code) + 2;

src/opaque_closure.c

@@ -50,7 +50,15 @@ static jl_opaque_closure_t *new_opaque_closure(jl_tupletype_t *argt, jl_value_t
     JL_GC_PUSH2(&sigtype, &selected_rt);
     sigtype = jl_argtype_with_function(captures, (jl_value_t*)argt);
 
-    jl_method_instance_t *mi = jl_specializations_get_linfo(source, sigtype, jl_emptysvec);
+    jl_method_instance_t *mi = NULL;
+    if (source->source) {
+        mi = jl_specializations_get_linfo(source, sigtype, jl_emptysvec);
+    } else {
+        mi = (jl_method_instance_t *)jl_atomic_load_relaxed(&source->specializations);
+        if (!jl_subtype(sigtype, mi->specTypes)) {
+            jl_error("sigtype mismatch in optimized opaque closure");
+        }
+    }
     jl_task_t *ct = jl_current_task;
     size_t world = ct->world_age;
     jl_code_instance_t *ci = NULL;
@@ -147,7 +155,8 @@ JL_DLLEXPORT jl_opaque_closure_t *jl_new_opaque_closure_from_code_info(jl_tuplet
     jl_atomic_store_release(&meth->deleted_world, world);
 
     if (isinferred) {
-        sigtype = jl_argtype_with_function(env, (jl_value_t*)argt);
+        jl_value_t *argslotty = jl_array_ptr_ref(ci->slottypes, 0);
+        sigtype = jl_argtype_with_function_type(argslotty, (jl_value_t*)argt);
         jl_method_instance_t *mi = jl_specializations_get_linfo((jl_method_t*)root, sigtype, jl_emptysvec);
         inst = jl_new_codeinst(mi, jl_nothing, rt_ub, (jl_value_t*)jl_any_type, NULL, (jl_value_t*)ci,
             0, world, world, 0, 0, jl_nothing, 0, ci->debuginfo);

stdlib/InteractiveUtils/test/runtests.jl

@@ -748,6 +748,7 @@ end
 @testset "code_llvm on opaque_closure" begin
     let ci = code_typed(+, (Int, Int))[1][1]
         ir = Core.Compiler.inflate_ir(ci)
+        ir.argtypes[1] = Tuple{}
         @test ir.debuginfo.def === nothing
         ir.debuginfo.def = Symbol(@__FILE__)
         oc = Core.OpaqueClosure(ir)

test/compiler/AbstractInterpreter.jl

@@ -163,24 +163,30 @@ CC.method_table(interp::OverlaySinInterp) = CC.OverlayMethodTable(CC.get_inferen
 overlay_sin1(x) = error("Not supposed to be called.")
 @overlay OverlaySinMT overlay_sin1(x) = cos(x)
 @overlay OverlaySinMT Base.sin(x::Union{Float32,Float64}) = overlay_sin1(x)
-let oc = Base.code_ircode(; interp=OverlaySinInterp()) do
+let ir = Base.code_ircode(; interp=OverlaySinInterp()) do
         sin(0.)
-    end |> only |> first |> Core.OpaqueClosure
+    end |> only |> first
+    ir.argtypes[1] = Tuple{}
+    oc = Core.OpaqueClosure(ir)
     @test oc() == cos(0.)
 end
 @overlay OverlaySinMT Base.sin(x::Union{Float32,Float64}) = @noinline overlay_sin1(x)
-let oc = Base.code_ircode(; interp=OverlaySinInterp()) do
+let ir = Base.code_ircode(; interp=OverlaySinInterp()) do
         sin(0.)
-    end |> only |> first |> Core.OpaqueClosure
+    end |> only |> first
+    ir.argtypes[1] = Tuple{}
+    oc = Core.OpaqueClosure(ir)
     @test oc() == cos(0.)
 end
 _overlay_sin2(x) = error("Not supposed to be called.")
 @overlay OverlaySinMT _overlay_sin2(x) = cos(x)
 overlay_sin2(x) = _overlay_sin2(x)
 @overlay OverlaySinMT Base.sin(x::Union{Float32,Float64}) = @noinline overlay_sin2(x)
-let oc = Base.code_ircode(; interp=OverlaySinInterp()) do
+let ir = Base.code_ircode(; interp=OverlaySinInterp()) do
         sin(0.)
-    end |> only |> first |> Core.OpaqueClosure
+    end |> only |> first
+    ir.argtypes[1] = Tuple{}
+    oc = Core.OpaqueClosure(ir)
     @test oc() == cos(0.)
 end
 

test/compiler/inline.jl

@@ -2200,6 +2200,7 @@ issue52644(::UnionAll) = :UnionAll
 let ir = Base.code_ircode((Issue52644,); optimize_until="Inlining") do t
         issue52644(t.tuple)
     end |> only |> first
+    ir.argtypes[1] = Tuple{}
     irfunc = Core.OpaqueClosure(ir)
     @test irfunc(Issue52644(Tuple{})) === :DataType
     @test irfunc(Issue52644(Tuple{<:Integer})) === :UnionAll
@@ -2208,6 +2209,7 @@ issue52644_single(x::DataType) = :DataType
 let ir = Base.code_ircode((Issue52644,); optimize_until="Inlining") do t
         issue52644_single(t.tuple)
     end |> only |> first
+    ir.argtypes[1] = Tuple{}
     irfunc = Core.OpaqueClosure(ir)
     @test irfunc(Issue52644(Tuple{})) === :DataType
     @test_throws MethodError irfunc(Issue52644(Tuple{<:Integer}))

test/opaque_closure.jl

@@ -253,6 +253,7 @@ end
 # constructing an opaque closure from IRCode
 let src = first(only(code_typed(+, (Int, Int))))
     ir = Core.Compiler.inflate_ir(src, Core.Compiler.VarState[], src.slottypes)
+    ir.argtypes[1] = Tuple{}
     @test ir.debuginfo.def === nothing
     ir.debuginfo.def = Symbol(@__FILE__)
     @test OpaqueClosure(src; sig=Tuple{Int, Int}, rettype=Int, nargs=2)(40, 2) == 42
@@ -263,10 +264,12 @@ let src = first(only(code_typed(+, (Int, Int))))
     @test OpaqueClosure(ir)(40, 2) == 42 # the `OpaqueClosure(::IRCode)` constructor should be non-destructive
 end
 let ir = first(only(Base.code_ircode(sin, (Int,))))
+    ir.argtypes[1] = Tuple{}
     @test OpaqueClosure(ir)(42) == sin(42)
     @test OpaqueClosure(ir)(42) == sin(42) # the `OpaqueClosure(::IRCode)` constructor should be non-destructive
     @test length(code_typed(OpaqueClosure(ir))) == 1
     ir = first(only(Base.code_ircode(sin, (Float64,))))
+    ir.argtypes[1] = Tuple{}
     @test OpaqueClosure(ir)(42.) == sin(42.)
     @test OpaqueClosure(ir)(42.) == sin(42.) # the `OpaqueClosure(::IRCode)` constructor should be non-destructive
 end
@@ -275,6 +278,7 @@ end
 let src = code_typed((Int,Int)) do x, y...
         return (x, y)
     end |> only |> first
+    src.slottypes[1] = Tuple{}
     let oc = OpaqueClosure(src; rettype=Tuple{Int, Tuple{Int}}, sig=Tuple{Int, Int}, nargs=2, isva=true)
         @test oc(1,2) === (1,(2,))
         @test_throws MethodError oc(1,2,3)
@@ -315,6 +319,7 @@ f_oc_throws() = error("oops")
 @noinline function make_oc_and_collect_bt()
     did_gc = Ref{Bool}(false)
     bt = let ir = first(only(Base.code_ircode(f_oc_throws, ())))
+        ir.argtypes[1] = Tuple
         sentinel = Ref{Any}(nothing)
         oc = OpaqueClosure(ir, sentinel)
         finalizer(sentinel) do x
@@ -351,6 +356,7 @@ ccall_op_arg_restrict2_bad_args() = op_arg_restrict2((1.,), 2)
 let ir = Base.code_ircode((Int,Int)) do x, y
         @noinline x * y
     end |> only |> first
+    ir.argtypes[1] = Tuple{}
     oc = Core.OpaqueClosure(ir)
     io = IOBuffer()
     code_llvm(io, oc, Tuple{Int,Int})
@@ -364,11 +370,13 @@ foopaque() = Base.Experimental.@opaque(@noinline x::Int->println(x))(1)
 code_llvm(devnull,foopaque,()) #shouldn't crash
 
 let ir = first(only(Base.code_ircode(sin, (Int,))))
+    ir.argtypes[1] = Tuple{}
     oc = Core.OpaqueClosure(ir)
     @test (Base.show_method(IOBuffer(), oc.source::Method); true)
 end
 
 let ir = first(only(Base.code_ircode(sin, (Int,))))
+    ir.argtypes[1] = Tuple{}
     oc = Core.OpaqueClosure(ir; do_compile=false)
     @test oc(1) == sin(1)
 end