fixup! s/Lambda/NativeCode/g

Author: vtjnash

base/boot.jl

@@ -442,11 +442,11 @@ Symbol(s::Symbol) = s
 
 # module providing the IR object model
 module IR
-export CodeInfo, MethodInstance, Lambda, GotoNode,
+export CodeInfo, MethodInstance, NativeCode, GotoNode,
     NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
     PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode
 
-import Core: CodeInfo, MethodInstance, GotoNode,
+import Core: CodeInfo, MethodInstance, NativeCode, GotoNode,
     NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
     PiNode, PhiNode, PhiCNode, UpsilonNode, LineInfoNode
 

base/compiler/compiler.jl

@@ -5,7 +5,7 @@ getfield(getfield(Main, :Core), :eval)(getfield(Main, :Core), :(baremodule Compi
 using Core.Intrinsics, Core.IR
 
 import Core: print, println, show, write, unsafe_write, stdout, stderr,
-             _apply, svec, apply_type, Builtin, IntrinsicFunction, MethodInstance, Lambda
+             _apply, svec, apply_type, Builtin, IntrinsicFunction, MethodInstance, NativeCode
 
 const getproperty = getfield
 const setproperty! = setfield!

base/compiler/optimize.jl

@@ -116,7 +116,7 @@ function add_backedge!(li::MethodInstance, caller::OptimizationState)
     nothing
 end
 
-function add_backedge!(li::Lambda, caller::OptimizationState)
+function add_backedge!(li::NativeCode, caller::OptimizationState)
     update_valid_age!(min_world(li), max_world(li), caller)
     add_backedge!(li.def, caller)
     nothing

base/compiler/ssair/inlining.jl

@@ -1225,7 +1225,7 @@ function find_inferred(mi::MethodInstance, @nospecialize(atypes), sv::Optimizati
     end
 
     linfo = inf_for_methodinstance(mi, sv.params.world)
-    if linfo isa Lambda
+    if linfo isa NativeCode
         if invoke_api(linfo) == 2
             # in this case function can be inlined to a constant
             return svec(true, quoted(linfo.rettype_const))

base/compiler/typeinfer.jl

@@ -92,7 +92,7 @@ function cache_result(result::InferenceResult, min_valid::UInt, max_valid::UInt)
     # check if the existing linfo metadata is also sufficient to describe the current inference result
     # to decide if it is worth caching this
     already_inferred = !result.linfo.inInference
-    if inf_for_methodinstance(result.linfo, min_valid, max_valid) isa Lambda
+    if inf_for_methodinstance(result.linfo, min_valid, max_valid) isa NativeCode
         already_inferred = true
     end
 
@@ -132,7 +132,7 @@ function cache_result(result::InferenceResult, min_valid::UInt, max_valid::UInt)
         if !isa(inferred_result, Union{CodeInfo, Vector{UInt8}})
             inferred_result = nothing
         end
-        ccall(:jl_set_method_inferred, Ref{Lambda}, (Any, Any, Any, Any, Int32, UInt, UInt),
+        ccall(:jl_set_method_inferred, Ref{NativeCode}, (Any, Any, Any, Any, Int32, UInt, UInt),
             result.linfo, widenconst(result.result), rettype_const, inferred_result,
             const_flags, min_valid, max_valid)
     end
@@ -451,7 +451,7 @@ end
 function typeinf_edge(method::Method, @nospecialize(atypes), sparams::SimpleVector, caller::InferenceState)
     mi = specialize_method(method, atypes, sparams)::MethodInstance
     code = inf_for_methodinstance(mi, caller.params.world)
-    if code isa Lambda # return existing rettype if the code is already inferred
+    if code isa NativeCode # return existing rettype if the code is already inferred
         update_valid_age!(min_world(code), max_world(code), caller)
         if isdefined(code, :rettype_const)
             return Const(code.rettype_const), mi
@@ -522,10 +522,11 @@ function typeinf_ext(mi::MethodInstance, params::Params)
     for i = 1:2 # test-and-lock-and-test
         i == 2 && ccall(:jl_typeinf_begin, Cvoid, ())
         code = inf_for_methodinstance(mi, params.world)
-        if code isa Lambda
+        if code isa NativeCode
             # see if this code already exists in the cache
             inf = code.inferred
             if invoke_api(code) == 2
+                i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
                 tree = ccall(:jl_new_code_info_uninit, Ref{CodeInfo}, ())
                 tree.code = Any[ Expr(:return, quoted(code.rettype_const)) ]
                 nargs = Int(method.nargs)
@@ -542,20 +543,21 @@ function typeinf_ext(mi::MethodInstance, params::Params)
                 tree.rettype = typeof(code.rettype_const)
                 tree.min_world = code.min_world
                 tree.max_world = code.max_world
-                i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
                 return tree
             elseif isa(inf, CodeInfo)
                 i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
-                inf.min_world = code.min_world
-                inf.min_world = code.min_world
-                inf.rettype = code.rettype
+                if !(inf.min_world == code.min_world &&
+                     inf.max_world == code.max_world &&
+                     inf.rettype === code.rettype)
+                    inf = copy(inf)
+                    inf.min_world = code.min_world
+                    inf.max_world = code.max_world
+                    inf.rettype = code.rettype
+                end
                 return inf
             elseif isa(inf, Vector{UInt8})
-                inf = _uncompressed_ast(code, inf)
                 i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
-                inf.min_world = code.min_world
-                inf.min_world = code.min_world
-                inf.rettype = code.rettype
+                inf = _uncompressed_ast(code, inf)
                 return inf
             end
         end
@@ -578,7 +580,7 @@ function typeinf_type(method::Method, @nospecialize(atypes), sparams::SimpleVect
     for i = 1:2 # test-and-lock-and-test
         i == 2 && ccall(:jl_typeinf_begin, Cvoid, ())
         code = inf_for_methodinstance(mi, params.world)
-        if code isa Lambda
+        if code isa NativeCode
             # see if this rettype already exists in the cache
             i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
             return code.rettype

base/compiler/utilities.jl

@@ -81,7 +81,7 @@ end
 # MethodInstance/CodeInfo #
 ###########################
 
-function invoke_api(li::Lambda)
+function invoke_api(li::NativeCode)
     return ccall(:jl_invoke_api, Cint, (Any,), li)
 end
 
@@ -119,7 +119,7 @@ end
 function inf_for_methodinstance(mi::MethodInstance, min_world::UInt, max_world::UInt=min_world)
     inf = ccall(:jl_is_rettype_inferred, Ptr{Nothing}, (Any, UInt, UInt), mi, min_world, max_world)
     inf == C_NULL && return nothing
-    return unsafe_pointer_to_objref(inf)::Lambda
+    return unsafe_pointer_to_objref(inf)::NativeCode
 end
 
 

base/reflection.jl

@@ -903,7 +903,7 @@ uncompressed_ast(m::Method) = isdefined(m, :source) ? _uncompressed_ast(m, m.sou
                               error("Code for this Method is not available.")
 _uncompressed_ast(m::Method, s::CodeInfo) = copy(s)
 _uncompressed_ast(m::Method, s::Array{UInt8,1}) = ccall(:jl_uncompress_ast, Any, (Any, Ptr{Cvoid}, Any), m, C_NULL, s)::CodeInfo
-_uncompressed_ast(m::Core.Lambda, s::Array{UInt8,1}) = ccall(:jl_uncompress_ast, Any, (Any, Ptr{Cvoid}, Any), li.def.def::Method, li, s)::CodeInfo
+_uncompressed_ast(m::Core.NativeCode, s::Array{UInt8,1}) = ccall(:jl_uncompress_ast, Any, (Any, Ptr{Cvoid}, Any), li.def.def::Method, li, s)::CodeInfo
 
 function method_instances(@nospecialize(f), @nospecialize(t), world::UInt = typemax(UInt))
     tt = signature_type(f, t)
@@ -1309,8 +1309,8 @@ has_bottom_parameter(t::Union) = has_bottom_parameter(t.a) & has_bottom_paramete
 has_bottom_parameter(t::TypeVar) = t.ub == Bottom || has_bottom_parameter(t.ub)
 has_bottom_parameter(::Any) = false
 
-min_world(m::Core.Lambda) = reinterpret(UInt, m.min_world)
-max_world(m::Core.Lambda) = reinterpret(UInt, m.max_world)
+min_world(m::Core.NativeCode) = reinterpret(UInt, m.min_world)
+max_world(m::Core.NativeCode) = reinterpret(UInt, m.max_world)
 min_world(m::Core.CodeInfo) = reinterpret(UInt, m.min_world)
 max_world(m::Core.CodeInfo) = reinterpret(UInt, m.max_world)
 get_world_counter() = ccall(:jl_get_world_counter, UInt, ())

doc/src/devdocs/ast.md

@@ -260,7 +260,7 @@ types exist in lowered form:
 
   * `CodeInfo`
 
-    Wraps the IR of a method. Its `code` field is an array of expressions to execute.
+    Wraps the IR of a group of statements. Its `code` field is an array of expressions to execute.
 
   * `GotoNode`
 
@@ -489,7 +489,11 @@ A unique'd container describing the shared metadata for a single method.
 
   * `source`
 
-    The original source code (usually compressed).
+    The original source code (if available, usually compressed).
+
+  * `generator`
+
+    A callable object which can be executed to get specialized source for a specific method signature.
 
   * `roots`
 
@@ -500,9 +504,9 @@ A unique'd container describing the shared metadata for a single method.
 
     Descriptive bit-fields for the source code of this Method.
 
-  * `min_world` / `max_world`
+  * `primary_world`
 
-    The range of world ages for which this method is visible to dispatch.
+    The world age that "owns" this Method.
 
 
 ### MethodInstance
@@ -527,16 +531,38 @@ for important details on how to modify these fields safely.
     runtime `MethodInstance` from the `MethodTable` cache, this will always be defined and
     indexable.
 
-  * `rettype`
+  * `uninferred`
+
+    The uncompressed source code for a toplevel thunk. Additionally, for a generated function,
+    this is one of many places that the source code might be found.
+
+  * `backedges`
+
+    We store the reverse-list of cache dependencies for efficient tracking of incremental reanalysis/recompilation work that may be needed after a new method definitions.
+    This works by keeping a list of the other `MethodInstance` that have been inferred or optimized to contain a possible call to this `MethodInstance`.
+    Those optimization results might be stored somewhere in the `cache`, or it might have been the result of something we didn't want to cache, such as constant propagation.
+    Thus we merge all of those backedges to various cache entries here (there's almost always only the one applicable cache entry with a sentinal value for max_world anyways).
+
+  * `cache`
+
+    Cache of `NativeCode` objects that share this template instantiation.
+
+### MethodInstance
+
+  * `def`
+
+    The `MethodInstance` that this cache entry is derived from.
+
+
+  * `rettype`/`rettype_const`
 
     The inferred return type for the `specFunctionObject` field, which (in most cases) is
     also the computed return type for the function in general.
 
   * `inferred`
 
-    May contain a cache of the inferred source for this function, or other information about
-    the inference result such as a constant return value may be put here (if `jlcall_api ==
-    2`), or it could be set to `nothing` to just indicate `rettype` is inferred.
+    May contain a cache of the inferred source for this function,
+    or it could be set to `nothing` to just indicate `rettype` is inferred.
 
   * `ftpr`
 
@@ -548,30 +574,32 @@ for important details on how to modify these fields safely.
 
       * 0 - Not compiled yet
       * 1 - JL_CALLABLE `jl_value_t *(*)(jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)`
-      * 2 - Constant (value stored in `inferred`)
+      * 2 - Constant (value stored in `rettype_const`)
       * 3 - With Static-parameters forwarded `jl_value_t *(*)(jl_svec_t *sparams, jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)`
       * 4 - Run in interpreter `jl_value_t *(*)(jl_method_instance_t *meth, jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)`
 
   * `min_world` / `max_world`
 
     The range of world ages for which this method instance is valid to be called.
+    If max_world is the special token value `-1`, the value is not yet known.
+    It may continue to be used until we encounter a backedge that requires us to reconsider.
 
 
 ### CodeInfo
 
-A temporary container for holding lowered source code.
+A (usually temporary) container for holding lowered source code.
 
   * `code`
 
     An `Any` array of statements
 
   * `slotnames`
 
-    An array of symbols giving the name of each slot (argument or local variable).
+    An array of symbols giving names for each slot (argument or local variable).
 
   * `slottypes`
 
-    An array of types for the slots.
+    An array of types for the slots (e.g. variables).
 
   * `slotflags`
 
@@ -587,7 +615,17 @@ A temporary container for holding lowered source code.
     Either an array or an `Int`.
 
     If an `Int`, it gives the number of compiler-inserted temporary locations in the
-    function. If an array, specifies a type for each location.
+    function (the length of `code` array). If an array, specifies a type for each location.
+
+  * `ssaflags`
+
+    Statement-level flags for each expression in the function. Many of these are reserved, but not yet implemented:
+
+    * 0 = inbounds
+    * 1,2 = <reserved> inlinehint,always-inline,noinline
+    * 3 = <reserved> strict-ieee (strictfp)
+    * 4-6 = <unused>
+    * 7 = <reserved> has out-of-band info
 
   * `linetable`
 
@@ -598,6 +636,14 @@ A temporary container for holding lowered source code.
     An array of integer indices into the `linetable`, giving the location associated
     with each statement.
 
+  * `parent`
+
+    The `MethodInstance` that "owns" this object (if applicable).
+
+  * `min_world`/`max_world`
+
+    The range of world ages for which this code was valid at the time when it had been inferred.
+
 Boolean properties:
 
   * `inferred`
@@ -606,11 +652,11 @@ Boolean properties:
 
   * `inlineable`
 
-    Whether this should be inlined.
+    Whether this should be eligable for inlining.
 
   * `propagate_inbounds`
 
-    Whether this should should propagate `@inbounds` when inlined for the purpose of eliding
+    Whether this should should propagate `@inbounds` when inlined, for the purpose of eliding
     `@boundscheck` blocks.
 
   * `pure`

src/builtins.c

@@ -1256,7 +1256,7 @@ void jl_init_primitives(void) JL_GC_DISABLED
     add_builtin("Module", (jl_value_t*)jl_module_type);
     add_builtin("MethodTable", (jl_value_t*)jl_methtable_type);
     add_builtin("Method", (jl_value_t*)jl_method_type);
-    add_builtin("Lambda", (jl_value_t*)jl_lambda_type);
+    add_builtin("NativeCode", (jl_value_t*)jl_nativecode_type);
     add_builtin("TypeMapEntry", (jl_value_t*)jl_typemap_entry_type);
     add_builtin("TypeMapLevel", (jl_value_t*)jl_typemap_level_type);
     add_builtin("Symbol", (jl_value_t*)jl_sym_type);