internals: share slotnames table via Method

Also store a few other unnecessary properties in CodeInfo,
which some users might be interested in having.

base/compiler/inferencestate.jl

@@ -58,7 +58,7 @@ mutable struct InferenceState
  s_types = Any[ nothing for i = 1:n ]
 
  # initial types
- nslots = length(src.slotnames)
+ nslots = length(src.slotflags)
  argtypes = result.argtypes
  nargs = length(argtypes)
  s_argtypes = VarTable(undef, nslots)
@@ -122,7 +122,7 @@ end
 
 function sptypes_from_meth_instance(linfo::MethodInstance)
  toplevel = !isa(linfo.def, Method)
- if !toplevel && isempty(linfo.sparam_vals) && !isempty(linfo.def.sparam_syms)
+ if !toplevel && isempty(linfo.sparam_vals) && isa(linfo.def.sig, UnionAll)
  # linfo is unspecialized
  sp = Any[]
  sig = linfo.def.sig

base/compiler/optimize.jl

@@ -37,8 +37,11 @@ mutable struct OptimizationState
  if nssavalues isa Int
  src.ssavaluetypes = Any[ Any for i = 1:nssavalues ]
  end
- nslots = length(src.slotnames)
- slottypes = Any[ Any for i = 1:nslots ]
+ nslots = length(src.slotflags)
+ slottypes = src.slottypes
+ if slottypes === nothing
+ slottypes = Any[ Any for i = 1:nslots ]
+ end
  s_edges = []
  # cache some useful state computations
  toplevel = !isa(linfo.def, Method)
@@ -73,7 +76,7 @@ end
 # This is implied by `SLOT_USEDUNDEF`.
 # If this is not set, all the uses are (statically) dominated by the defs.
 # In particular, if a slot has `AssignedOnce && !StaticUndef`, it is an SSA.
-const SLOT_STATICUNDEF = 1
+const SLOT_STATICUNDEF = 1 # slot might be used before it is defined (structurally)
 const SLOT_ASSIGNEDONCE = 16 # slot is assigned to only once
 const SLOT_USEDUNDEF = 32 # slot has uses that might raise UndefVarError
 # const SLOT_CALLED = 64

base/compiler/ssair/legacy.jl

@@ -1,13 +1,11 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-inflate_ir(ci::CodeInfo) = inflate_ir(ci, Any[], Any[ Any for i = 1:length(ci.slotnames) ])
-
 function inflate_ir(ci::CodeInfo, linfo::MethodInstance)
  sptypes = sptypes_from_meth_instance(linfo)
  if ci.inferred
  argtypes, _ = matching_cache_argtypes(linfo, nothing)
  else
- argtypes = Any[ Any for i = 1:length(ci.slotnames) ]
+ argtypes = Any[ Any for i = 1:length(ci.slotflags) ]
  end
  return inflate_ir(ci, sptypes, argtypes)
 end
@@ -92,3 +90,6 @@ function replace_code_newstyle!(ci::CodeInfo, ir::IRCode, nargs::Int)
  end
  end
 end
+
+# used by some tests
+inflate_ir(ci::CodeInfo) = inflate_ir(ci, Any[], Any[ Any for i = 1:length(ci.slotflags) ])

base/compiler/ssair/slot2ssa.jl

@@ -45,7 +45,7 @@ end
 
 @inline slot_id(s) = isa(s, SlotNumber) ? (s::SlotNumber).id : (s::TypedSlot).id
 function scan_slot_def_use(nargs::Int, ci::CodeInfo, code::Vector{Any})
- nslots = length(ci.slotnames)
+ nslots = length(ci.slotflags)
  result = SlotInfo[SlotInfo() for i = 1:nslots]
  # Set defs for arguments
  for var in result[1:(1+nargs)]
@@ -654,7 +654,7 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do
  undef_token
  else
  SSAValue(-1)
- end for x in 1:length(ci.slotnames)
+ end for x in 1:length(ci.slotflags)
  ]
  worklist = Tuple{Int, Int, Vector{Any}}[(1, 0, initial_incoming_vals)]
  visited = BitSet()

base/compiler/typeinfer.jl

@@ -56,10 +56,12 @@ function typeinf(frame::InferenceState)
  end
  end
  end
+ end
+ for caller in frames
+ caller.src.min_world = min_valid % Int
+ caller.src.max_world = max_valid % Int
  if cached
- for caller in results
- cache_result(caller, min_valid, max_valid)
- end
+ cache_result(caller.result, min_valid, max_valid)
  end
  end
  # if we aren't cached, we don't need this edge
@@ -308,6 +310,8 @@ function type_annotate!(sv::InferenceState)
  # compute the required type for each slot
  # to hold all of the items assigned into it
  record_slot_assign!(sv)
+ sv.src.slottypes = sv.slottypes
+ sv.src.rettype = sv.bestguess
 
  # annotate variables load types
  # remove dead code optimization
@@ -544,16 +548,20 @@ function typeinf_ext(linfo::MethodInstance, params::Params)
  if invoke_api(linfo) == 2
  tree = ccall(:jl_new_code_info_uninit, Ref{CodeInfo}, ())
  tree.code = Any[ Expr(:return, quoted(linfo.inferred_const)) ]
- tree.method_for_inference_limit_heuristics = nothing
- tree.slotnames = Any[ COMPILER_TEMP_SYM for i = 1:method.nargs ]
- tree.slotflags = fill(0x00, Int(method.nargs))
- tree.ssavaluetypes = 0
+ nargs = Int(method.nargs)
+ tree.slotnames = ccall(:jl_uncompress_argnames, Any, (Any,), method.slot_syms)
+ tree.slotflags = fill(0x00, nargs)
+ tree.ssavaluetypes = 1
  tree.codelocs = Int32[1]
  tree.linetable = [LineInfoNode(method.module, method.name, method.file, Int(method.line), 0)]
  tree.inferred = true
- tree.ssaflags = UInt8[]
+ tree.ssaflags = UInt8[0]
  tree.pure = true
  tree.inlineable = true
+ tree.parent = linfo
+ tree.rettype = typeof(linfo.inferred_const)
+ tree.min_world = li.min_world
+ tree.max_world = li.max_world
  i == 2 && ccall(:jl_typeinf_end, Cvoid, ())
  return svec(linfo, tree)
  elseif isa(inf, CodeInfo)

base/compiler/utilities.jl

@@ -96,19 +96,23 @@ end
 
 function retrieve_code_info(linfo::MethodInstance)
  m = linfo.def::Method
+ c = nothing
  if isdefined(m, :generator)
  # user code might throw errors – ignore them
- return get_staged(linfo)
- else
-  # TODO: post-inference see if we can swap back to the original arrays?
+ c = get_staged(linfo)
+ end
+ if c === nothing && isdefined(m, :source)
  src = m.source
  if isa(src, Array{UInt8,1})
  c = ccall(:jl_uncompress_ast, Any, (Any, Any), m, src)
  else
  c = copy(src::CodeInfo)
  end
  end
- return c::CodeInfo
+ if c isa CodeInfo
+ c.parent = linfo
+ return c
+ end
 end
 
 function code_for_method(method::Method, @nospecialize(atypes), sparams::SimpleVector, world::UInt, preexisting::Bool=false)

base/compiler/validation.jl

@@ -41,7 +41,7 @@ const INVALID_RVALUE = "invalid RHS value"
 const INVALID_RETURN = "invalid argument to :return"
 const INVALID_CALL_ARG = "invalid :call argument"
 const EMPTY_SLOTNAMES = "slotnames field is empty"
-const SLOTFLAGS_MISMATCH = "length(slotnames) != length(slotflags)"
+const SLOTFLAGS_MISMATCH = "length(slotnames) < length(slotflags)"
 const SSAVALUETYPES_MISMATCH = "not all SSAValues in AST have a type in ssavaluetypes"
 const SSAVALUETYPES_MISMATCH_UNINFERRED = "uninferred CodeInfo ssavaluetypes field does not equal the number of present SSAValues"
 const NON_TOP_LEVEL_METHOD = "encountered `Expr` head `:method` in non-top-level code (i.e. `nargs` > 0)"
@@ -168,7 +168,7 @@ function validate_code!(errors::Vector{>:InvalidCodeError}, c::CodeInfo, is_top_
  nslotflags = length(c.slotflags)
  nssavals = length(c.code)
  !is_top_level && nslotnames == 0 && push!(errors, InvalidCodeError(EMPTY_SLOTNAMES))
- nslotnames != nslotflags && push!(errors, InvalidCodeError(SLOTFLAGS_MISMATCH, (nslotnames, nslotflags)))
+ nslotnames < nslotflags && push!(errors, InvalidCodeError(SLOTFLAGS_MISMATCH, (nslotnames, nslotflags)))
  if c.inferred
  nssavaluetypes = length(c.ssavaluetypes)
  nssavaluetypes < nssavals && push!(errors, InvalidCodeError(SSAVALUETYPES_MISMATCH, (nssavals, nssavaluetypes)))

base/methodshow.jl

@@ -43,12 +43,9 @@ function argtype_decl(env, n, sig::DataType, i::Int, nargs, isva::Bool) # -> (ar
 end
 
 function method_argnames(m::Method)
- if !isdefined(m, :source) && isdefined(m, :generator)
- return m.generator.argnames
- end
- argnames = Vector{Any}(undef, m.nargs)
- ccall(:jl_fill_argnames, Cvoid, (Any, Any), m.source, argnames)
- return argnames
+ argnames = ccall(:jl_uncompress_argnames, Vector{Any}, (Any,), m.slot_syms)
+ isempty(argnames) && return argnames
+ return argnames[1:m.nargs]
 end
 
 function arg_decl_parts(m::Method)
@@ -60,8 +57,8 @@ function arg_decl_parts(m::Method)
  end
  file = m.file
  line = m.line
- if isdefined(m, :source) || isdefined(m, :generator)
-  argnames = method_argnames(m)
+ argnames = method_argnames(m)
+ if length(argnames) >= m.nargs
  show_env = ImmutableDict{Symbol, Any}()
  for t in tv
  show_env = ImmutableDict(show_env, :unionall_env => t)
@@ -74,26 +71,23 @@ function arg_decl_parts(m::Method)
  return tv, decls, file, line
 end
 
+const empty_sym = Symbol("")
+
 function kwarg_decl(m::Method, kwtype::DataType)
  sig = rewrap_unionall(Tuple{kwtype, Any, unwrap_unionall(m.sig).parameters...}, m.sig)
  kwli = ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), kwtype.name.mt, sig, max_world(m))
  if kwli !== nothing
  kwli = kwli::Method
- if isdefined(kwli, :source)
- src = kwli.source
- nslots = ccall(:jl_ast_nslots, Int, (Any,), src)
- slotnames = Vector{Any}(undef, nslots)
- ccall(:jl_fill_argnames, Cvoid, (Any, Any), src, slotnames)
- kws = filter(x -> !('#' in string(x)), slotnames[(kwli.nargs + 1):end])
- # ensure the kwarg... is always printed last. The order of the arguments are not
- # necessarily the same as defined in the function
- i = findfirst(x -> endswith(string(x), "..."), kws)
- if i !== nothing
- push!(kws, kws[i])
- deleteat!(kws, i)
- end
- return kws
+ slotnames = ccall(:jl_uncompress_argnames, Vector{Any}, (Any,), kwli.slot_syms)
+ kws = filter(x -> !(x === empty_sym || '#' in string(x)), slotnames[(kwli.nargs + 1):end])
+ # ensure the kwarg... is always printed last. The order of the arguments are not
+ # necessarily the same as defined in the function
+ i = findfirst(x -> endswith(string(x), "..."), kws)
+ if i !== nothing
+ push!(kws, kws[i])
+ deleteat!(kws, i)
  end
+ return kws
  end
  return ()
 end

src/array.c

@@ -470,6 +470,8 @@ JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a)
 JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len)
 {
  size_t sz = sizeof(size_t) + len + 1; // add space for trailing \nul protector and size
+ if (len == 0)
+ return jl_an_empty_string;
  jl_value_t *s = jl_gc_alloc_(jl_get_ptls_states(), sz, jl_string_type); // force inlining
  *(size_t*)s = len;
  memcpy((char*)s + sizeof(size_t), str, len);
@@ -480,6 +482,8 @@ JL_DLLEXPORT jl_value_t *jl_pchar_to_string(const char *str, size_t len)
 JL_DLLEXPORT jl_value_t *jl_alloc_string(size_t len)
 {
  size_t sz = sizeof(size_t) + len + 1; // add space for trailing \nul protector and size
+ if (len == 0)
+ return jl_an_empty_string;
  jl_value_t *s = jl_gc_alloc_(jl_get_ptls_states(), sz, jl_string_type); // force inlining
  *(size_t*)s = len;
  ((char*)s + sizeof(size_t))[len] = 0;

src/ast.c

@@ -50,17 +50,17 @@ jl_sym_t *dot_sym; jl_sym_t *newvar_sym;
 jl_sym_t *boundscheck_sym; jl_sym_t *inbounds_sym;
 jl_sym_t *copyast_sym; jl_sym_t *cfunction_sym;
 jl_sym_t *pure_sym; jl_sym_t *simdloop_sym;
-jl_sym_t *meta_sym; jl_sym_t *compiler_temp_sym;
-jl_sym_t *inert_sym; jl_sym_t *polly_sym;
-jl_sym_t *unused_sym; jl_sym_t *static_parameter_sym;
-jl_sym_t *inline_sym; jl_sym_t *noinline_sym;
-jl_sym_t *generated_sym; jl_sym_t *generated_only_sym;
-jl_sym_t *isdefined_sym; jl_sym_t *propagate_inbounds_sym;
-jl_sym_t *specialize_sym; jl_sym_t *nospecialize_sym;
-jl_sym_t *macrocall_sym; jl_sym_t *colon_sym;
-jl_sym_t *hygienicscope_sym; jl_sym_t *escape_sym;
-jl_sym_t *gc_preserve_begin_sym; jl_sym_t *gc_preserve_end_sym;
+jl_sym_t *meta_sym; jl_sym_t *inert_sym;
+jl_sym_t *polly_sym; jl_sym_t *unused_sym;
+jl_sym_t *static_parameter_sym; jl_sym_t *inline_sym;
+jl_sym_t *noinline_sym; jl_sym_t *generated_sym;
+jl_sym_t *generated_only_sym; jl_sym_t *isdefined_sym;
+jl_sym_t *propagate_inbounds_sym; jl_sym_t *specialize_sym;
+jl_sym_t *nospecialize_sym; jl_sym_t *macrocall_sym;
+jl_sym_t *colon_sym; jl_sym_t *hygienicscope_sym;
 jl_sym_t *throw_undef_if_not_sym; jl_sym_t *getfield_undefref_sym;
+jl_sym_t *gc_preserve_begin_sym; jl_sym_t *gc_preserve_end_sym;
+jl_sym_t *escape_sym;
 
 static uint8_t flisp_system_image[] = {
 #include <julia_flisp.boot.inc>
@@ -347,7 +347,6 @@ void jl_init_frontend(void)
  unused_sym = jl_symbol("#unused#");
  slot_sym = jl_symbol("slot");
  static_parameter_sym = jl_symbol("static_parameter");
- compiler_temp_sym = jl_symbol("#temp#");
  inline_sym = jl_symbol("inline");
  noinline_sym = jl_symbol("noinline");
  polly_sym = jl_symbol("polly");

src/codegen.cpp

@@ -3315,8 +3315,12 @@ static jl_cgval_t emit_sparam(jl_codectx_t &ctx, size_t i)
  Value *sp = tbaa_decorate(tbaa_const, ctx.builder.CreateLoad(bp));
  Value *isnull = ctx.builder.CreateICmpNE(emit_typeof(ctx, sp),
  maybe_decay_untracked(literal_pointer_val(ctx, (jl_value_t*)jl_tvar_type)));
- jl_sym_t *name = (jl_sym_t*)jl_svecref(ctx.linfo->def.method->sparam_syms, i);
- undef_var_error_ifnot(ctx, isnull, name);
+ jl_unionall_t *sparam = (jl_unionall_t*)ctx.linfo->def.method->sig;
+ for (size_t j = 0; j < i; j++) {
+ sparam = (jl_unionall_t*)sparam->body;
+ assert(jl_is_unionall(sparam));
+ }
+ undef_var_error_ifnot(ctx, isnull, sparam->var->name);
  return mark_julia_type(ctx, sp, true, jl_any_type);
 }
 
@@ -5375,7 +5379,7 @@ static std::unique_ptr<Module> emit_function(
 
  // step 2. process var-info lists to see what vars need boxing
  int n_ssavalues = jl_is_long(src->ssavaluetypes) ? jl_unbox_long(src->ssavaluetypes) : jl_array_len(src->ssavaluetypes);
- size_t vinfoslen = jl_array_dim0(src->slotnames);
+ size_t vinfoslen = jl_array_dim0(src->slotflags);
  ctx.slots.resize(vinfoslen);
  size_t nreq = ctx.nargs;
  int va = 0;
@@ -5397,7 +5401,7 @@ static std::unique_ptr<Module> emit_function(
 
  bool needsparams = false;
  if (jl_is_method(lam->def.method)) {
- if (jl_svec_len(lam->def.method->sparam_syms) != jl_svec_len(lam->sparam_vals))
+ if ((size_t)jl_subtype_env_size(lam->def.method->sig) != jl_svec_len(lam->sparam_vals))
  needsparams = true;
  for (size_t i = 0; i < jl_svec_len(lam->sparam_vals); ++i) {
  if (jl_is_typevar(jl_svecref(lam->sparam_vals, i)))
@@ -5597,7 +5601,7 @@ static std::unique_ptr<Module> emit_function(
  for (i = 0; i < vinfoslen; i++) {
  jl_sym_t *s = (jl_sym_t*)jl_array_ptr_ref(src->slotnames, i);
  jl_varinfo_t &varinfo = ctx.slots[i];
- if (varinfo.isArgument || s == compiler_temp_sym || s == unused_sym)
+ if (varinfo.isArgument || s == empty_sym || s == unused_sym)
  continue;
  // LLVM 4.0: Assume the variable has default alignment
  varinfo.dinfo = dbuilder.createAutoVariable(
@@ -6027,14 +6031,14 @@ static std::unique_ptr<Module> emit_function(
  return;
  while (dbg) {
  new_lineinfo.push_back(dbg);
- dbg = linetable[dbg].inlined_at;
+ dbg = linetable.at(dbg).inlined_at;
  }
  current_lineinfo.resize(new_lineinfo.size(), 0);
  for (dbg = 0; dbg < new_lineinfo.size(); dbg++) {
  unsigned newdbg = new_lineinfo[new_lineinfo.size() - dbg - 1];
  if (newdbg != current_lineinfo[dbg]) {
  current_lineinfo[dbg] = newdbg;
- const auto &info = linetable[newdbg];
+ const auto &info = linetable.at(newdbg);
  if (do_coverage(info.is_user_code))
  coverageVisitLine(ctx, info.file, info.line);
  }
@@ -6044,9 +6048,9 @@ static std::unique_ptr<Module> emit_function(
  auto mallocVisitStmt = [&] (unsigned dbg) {
  if (!do_malloc_log(mod_is_user_mod) || dbg == 0)
  return;
- while (linetable[dbg].inlined_at)
- dbg = linetable[dbg].inlined_at;
- mallocVisitLine(ctx, ctx.file, linetable[dbg].line);
+ while (linetable.at(dbg).inlined_at)
+ dbg = linetable.at(dbg).inlined_at;
+ mallocVisitLine(ctx, ctx.file, linetable.at(dbg).line);
  };
 
  come_from_bb[0] = ctx.builder.GetInsertBlock();
@@ -6111,7 +6115,7 @@ static std::unique_ptr<Module> emit_function(
  int32_t debuginfoloc = ((int32_t*)jl_array_data(src->codelocs))[cursor];
  if (debuginfoloc > 0) {
  if (ctx.debug_enabled)
- ctx.builder.SetCurrentDebugLocation(linetable[debuginfoloc].loc);
+ ctx.builder.SetCurrentDebugLocation(linetable.at(debuginfoloc).loc);
  coverageVisitStmt(debuginfoloc);
  }
  jl_value_t *stmt = jl_array_ptr_ref(stmts, cursor);