inference,codegen: connect source directly to jit

This avoids unnecessary compression when running (not generating code).
While generating code, we continue the legacy behavior of storing
compressed code, since restarting from a ji without that is quite slow.
Eventually, we should also remove that code also once we have generated
the object file from it.

This replaces the defective SOURCE_MODE_FORCE_SOURCE option with a new
`typeinf_ext_toplevel` batch-mode interface for compilation which
returns all required source code. Only two options remain now:
SOURCE_MODE_NOT_REQUIRED :
    Require only that the IPO information (e.g. rettype and friends) is
    present.
SOURCE_MODE_FORCE_ABI :
    Require that the IPO information is present (for ABI computation)
    and that the returned CodeInstance can be invoked on the host target
    (preferably after inference, called directly, but perfectly
    acceptable for Base.Compiler to instead force the runtime to use a
    stub there or call into it with the interpreter instead by having
    failed to provide any code).

This replaces the awkward `jl_create_native` interface (which is now
just a shim for calling the new batch-mode `typeinf_ext_toplevel`) with
a simpler `jl_emit_native` API, which does not do any inference or other
callbacks, but simply is a batch-mode call to `jl_emit_codeinfo` and
the work to build the external wrapper around them for linkage.

Author: vtjnash

Compiler/src/bootstrap.jl

@@ -16,9 +16,9 @@ function activate_codegen!()
 end
 
 function bootstrap!()
+    global bootstrapping_compiler = true
     let time() = ccall(:jl_clock_now, Float64, ())
         println("Compiling the compiler. This may take several minutes ...")
-        interp = NativeInterpreter()
 
         ssa_inlining_pass!_tt = Tuple{typeof(ssa_inlining_pass!), IRCode, InliningState{NativeInterpreter}, Bool}
         optimize_tt = Tuple{typeof(optimize), NativeInterpreter, OptimizationState{NativeInterpreter}, InferenceResult}
@@ -45,13 +45,15 @@ function bootstrap!()
             end
         end
         starttime = time()
+        methods = Any[]
+        world = get_world_counter()
         for f in fs
             if isa(f, DataType) && f.name === typename(Tuple)
                 tt = f
             else
                 tt = Tuple{typeof(f), Vararg{Any}}
             end
-            matches = _methods_by_ftype(tt, 10, get_world_counter())::Vector
+            matches = _methods_by_ftype(tt, 10, world)::Vector
             if isempty(matches)
                 println(stderr, "WARNING: no matching method found for `", tt, "`")
             else
@@ -62,14 +64,25 @@ function bootstrap!()
                     for i = 1:length(params)
                         params[i] = unwraptv(params[i])
                     end
-                    typeinf_type(interp, m.method, Tuple{params...}, m.sparams)
+                    mi = specialize_method(m.method, Tuple{params...}, m.sparams)
+                    #isa_compileable_sig(mi) || println(stderr, "WARNING: inferring `", mi, "` which isn't expected to be called.")
+                    push!(methods, mi)
                 end
             end
         end
+        codeinfos = typeinf_ext_toplevel(methods, [world], false)
+        for i = 1:2:length(codeinfos)
+            ci = codeinfos[i]::CodeInstance
+            src = codeinfos[i + 1]::CodeInfo
+            isa_compileable_sig(ci.def) || continue # println(stderr, "WARNING: compiling `", ci.def, "` which isn't expected to be called.")
+            ccall(:jl_add_codeinst_to_jit, Cvoid, (Any, Any), ci, src)
+        end
         endtime = time()
         println("Base.Compiler ──── ", sub_float(endtime,starttime), " seconds")
     end
     activate_codegen!()
+    global bootstrapping_compiler = false
+    nothing
 end
 
 function activate!(; reflection=true, codegen=false)

Compiler/src/tfuncs.jl

@@ -42,11 +42,10 @@ macro nospecs(ex)
         push!(names, arg)
     end
     @assert isexpr(body, :block)
-    if !isempty(names)
-        lin = first(body.args)::LineNumberNode
-        nospec = Expr(:macrocall, Symbol("@nospecialize"), lin, names...)
-        insert!(body.args, 2, nospec)
-    end
+    isempty(names) && throw(ArgumentError("no arguments for @nospec"))
+    lin = first(body.args)::LineNumberNode
+    nospec = Expr(:macrocall, GlobalRef(@__MODULE__, :var"@nospecialize"), lin, names...)
+    insert!(body.args, 2, nospec)
     return esc(ex)
 end
 
@@ -2115,7 +2114,7 @@ add_tfunc(memoryrefoffset, 1, 1, memoryrefoffset_tfunc, 5)
     return true
 end
 
-@nospecs function memoryref_elemtype(@nospecialize mem)
+@nospecs function memoryref_elemtype(mem)
     m = widenconst(mem)
     if !has_free_typevars(m) && m <: GenericMemoryRef
         m0 = m
@@ -2131,7 +2130,7 @@ end
     return Any
 end
 
-@nospecs function _memoryref_elemtype(@nospecialize mem)
+@nospecs function _memoryref_elemtype(mem)
     m = widenconst(mem)
     if !has_free_typevars(m) && m <: GenericMemoryRef
         m0 = m
@@ -2166,7 +2165,7 @@ end
 end
 
 # whether getindex for the elements can potentially throw UndefRef
-function array_type_undefable(@nospecialize(arytype))
+@nospecs function array_type_undefable(arytype)
     arytype = unwrap_unionall(arytype)
     if isa(arytype, Union)
         return array_type_undefable(arytype.a) || array_type_undefable(arytype.b)
@@ -2247,7 +2246,7 @@ end
     return boundscheck ⊑ Bool && memtype ⊑ GenericMemoryRef && order ⊑ Symbol
 end
 
-@nospecs function memorynew_nothrow(argtypes::Vector{Any})
+function memorynew_nothrow(argtypes::Vector{Any})
     if !(argtypes[1] isa Const && argtypes[2] isa Const)
         return false
     end
@@ -2263,6 +2262,7 @@ end
     overflows = checked_smul_int(len, elsz)[2]
     return !overflows
 end
+
 # Query whether the given builtin is guaranteed not to throw given the `argtypes`.
 # `argtypes` can be assumed not to contain varargs.
 function _builtin_nothrow(𝕃::AbstractLattice, @nospecialize(f::Builtin), argtypes::Vector{Any},