turn on linear IR, update codevalidation and get it passing

base/codevalidation.jl

@@ -24,14 +24,16 @@ const VALID_EXPR_HEADS = ObjectIdDict(
  :isdefined => 1:1,
  :simdloop => 0:0,
  :gc_preserve_begin => 0:typemax(Int),
- :gc_preserve_end => 0:typemax(Int)
+ :gc_preserve_end => 0:typemax(Int),
+ :thunk => 1:1
 )
 
 # @enum isn't defined yet, otherwise I'd use it for this
 const INVALID_EXPR_HEAD = "invalid expression head"
 const INVALID_EXPR_NARGS = "invalid number of expression args"
 const INVALID_LVALUE = "invalid LHS value"
 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)"
@@ -40,6 +42,7 @@ const SLOTTYPES_MISMATCH_UNINFERRED = "uninferred CodeInfo slottypes field is no
 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)"
+const NON_TOP_LEVEL_GLOBAL = "encountered `Expr` head `:global` in non-top-level code (i.e. `nargs` > 0)"
 const SIGNATURE_NARGS_MISMATCH = "method signature does not match number of method arguments"
 const SLOTNAMES_NARGS_MISMATCH = "CodeInfo for method contains fewer slotnames than the number of method arguments"
 
@@ -56,44 +59,89 @@ InvalidCodeError(kind::AbstractString) = InvalidCodeError(kind, nothing)
 Validate `c`, logging any violation by pushing an `InvalidCodeError` into `errors`.
 """
 function validate_code!(errors::Vector{>:InvalidCodeError}, c::CodeInfo, is_top_level::Bool = false)
+ function validate_val!(@nospecialize(x))
+ if isa(x, Expr)
+ if x.head === :call || x.head === :invoke
+ f = x.args[1]
+ if f isa GlobalRef && (f.name === :llvmcall || f.name === :cglobal) && x.head === :call
+ # TODO: these are not yet linearized
+ else
+ for arg in x.args
+ if !is_valid_argument(arg)
+ push!(errors, InvalidCodeError(INVALID_CALL_ARG, arg))
+ else
+ validate_val!(arg)
+ end
+ end
+ end
+ end
+ elseif isa(x, SSAValue)
+ id = x.id + 1 # ensures that id > 0 for use with BitSet
+ !in(id, ssavals) && push!(ssavals, id)
+ end
+ end
+
  ssavals = BitSet()
  lhs_slotnums = BitSet()
- walkast(c.code) do x
+ for x in c.code
  if isa(x, Expr)
- !is_top_level && x.head == :method && push!(errors, InvalidCodeError(NON_TOP_LEVEL_METHOD))
- narg_bounds = get(VALID_EXPR_HEADS, x.head, -1:-1)
+ head = x.head
+ if !is_top_level
+ head === :method && push!(errors, InvalidCodeError(NON_TOP_LEVEL_METHOD))
+ head === :global && push!(errors, InvalidCodeError(NON_TOP_LEVEL_GLOBAL))
+ end
+ narg_bounds = get(VALID_EXPR_HEADS, head, -1:-1)
  nargs = length(x.args)
  if narg_bounds == -1:-1
- push!(errors, InvalidCodeError(INVALID_EXPR_HEAD, (x.head, x)))
+ push!(errors, InvalidCodeError(INVALID_EXPR_HEAD, (head, x)))
  elseif !in(nargs, narg_bounds)
- push!(errors, InvalidCodeError(INVALID_EXPR_NARGS, (x.head, nargs, x)))
- elseif x.head == :(=)
+ push!(errors, InvalidCodeError(INVALID_EXPR_NARGS, (head, nargs, x)))
+ elseif head === :(=)
  lhs, rhs = x.args
  if !is_valid_lvalue(lhs)
  push!(errors, InvalidCodeError(INVALID_LVALUE, lhs))
  elseif isa(lhs, SlotNumber) && !in(lhs.id, lhs_slotnums)
  n = lhs.id
  push!(lhs_slotnums, n)
  end
- if !is_valid_rvalue(rhs)
+ if !is_valid_rvalue(lhs, rhs)
  push!(errors, InvalidCodeError(INVALID_RVALUE, rhs))
  end
- elseif x.head == :call || x.head == :invoke
- for arg in x.args
- if !is_valid_rvalue(arg)
- push!(errors, InvalidCodeError(INVALID_CALL_ARG, arg))
- end
+ validate_val!(lhs)
+ validate_val!(rhs)
+ elseif head === :gotoifnot
+ if !is_valid_argument(x.args[1])
+ push!(errors, InvalidCodeError(INVALID_CALL_ARG, x.args[1]))
+ end
+ validate_val!(x.args[1])
+ elseif head === :return
+ if !is_valid_return(x.args[1])
+ push!(errors, InvalidCodeError(INVALID_RETURN, x.args[1]))
  end
+ validate_val!(x.args[1])
+ elseif head === :call || head === :invoke || head == :gc_preserve_end || head === :meta ||
+ head === :inbounds || head === :foreigncall || head === :const || head === :enter ||
+ head === :leave || head === :method || head === :global || head === :static_parameter ||
+ head === :new || head === :thunk || head === :simdloop
+ validate_val!(x)
+ else
+ push!(errors, InvalidCodeError("invalid statement", x))
  end
- elseif isa(x, SSAValue)
- id = x.id + 1 # ensures that id > 0 for use with BitSet
- !in(id, ssavals) && push!(ssavals, id)
+ elseif isa(x, NewvarNode)
+ elseif isa(x, LabelNode)
+ elseif isa(x, GotoNode)
+ elseif x === nothing
+ elseif isa(x, SlotNumber)
+ elseif isa(x, GlobalRef)
+ elseif isa(x, LineNumberNode)
+ else
+ push!(errors, InvalidCodeError("invalid statement", x))
  end
  end
  nslotnames = length(c.slotnames)
  nslotflags = length(c.slotflags)
  nssavals = length(ssavals)
- nslotnames == 0 && push!(errors, InvalidCodeError(EMPTY_SLOTNAMES))
+ !is_top_level && nslotnames == 0 && push!(errors, InvalidCodeError(EMPTY_SLOTNAMES))
  nslotnames != nslotflags && push!(errors, InvalidCodeError(SLOTFLAGS_MISMATCH, (nslotnames, nslotflags)))
  if c.inferred
  nslottypes = length(c.slottypes)
@@ -118,32 +166,50 @@ the `CodeInfo` instance associated with `mi`.
 """
 function validate_code!(errors::Vector{>:InvalidCodeError}, mi::Core.MethodInstance,
  c::Union{Void,CodeInfo} = Core.Inference.retrieve_code_info(mi))
- m = mi.def::Method
- n_sig_params = length(Core.Inference.unwrap_unionall(m.sig).parameters)
- if (m.isva ? (n_sig_params < (m.nargs - 1)) : (n_sig_params != m.nargs))
- push!(errors, InvalidCodeError(SIGNATURE_NARGS_MISMATCH, (m.isva, n_sig_params, m.nargs)))
+ is_top_level = mi.def isa Module
+ if is_top_level
+ mnargs = 0
+ else
+ m = mi.def::Method
+ mnargs = m.nargs
+ n_sig_params = length(Core.Inference.unwrap_unionall(m.sig).parameters)
+ if (m.isva ? (n_sig_params < (mnargs - 1)) : (n_sig_params != mnargs))
+ push!(errors, InvalidCodeError(SIGNATURE_NARGS_MISMATCH, (m.isva, n_sig_params, mnargs)))
+ end
  end
  if isa(c, CodeInfo)
- m.nargs > length(c.slotnames) && push!(errors, InvalidCodeError(SLOTNAMES_NARGS_MISMATCH))
- validate_code!(errors, c, m.nargs == 0)
+ mnargs > length(c.slotnames) && push!(errors, InvalidCodeError(SLOTNAMES_NARGS_MISMATCH))
+ validate_code!(errors, c, is_top_level)
  end
  return errors
 end
 
 validate_code(args...) = validate_code!(Vector{InvalidCodeError}(), args...)
 
-function walkast(f, stmts::Array)
- for stmt in stmts
- f(stmt)
- isa(stmt, Expr) && walkast(f, stmt.args)
+is_valid_lvalue(x) = isa(x, Slot) || isa(x, SSAValue) || isa(x, GlobalRef)
+
+function is_valid_argument(x)
+ if isa(x, Slot) || isa(x, SSAValue) || isa(x, GlobalRef) || isa(x, QuoteNode) ||
+ (isa(x,Expr) && (x.head in (:static_parameter, :boundscheck, :copyast))) ||
+ isa(x, Number) || isa(x, AbstractString) || isa(x, Char) || isa(x, Tuple) ||
+ isa(x, Type) || isa(x, Core.Box) || isa(x, Module) || x === nothing
+ return true
  end
+ # TODO: consider being stricter about what needs to be wrapped with QuoteNode
+ return !(isa(x,Expr) || isa(x,Symbol) || isa(x,GotoNode) || isa(x,LabelNode) ||
+ isa(x,LineNumberNode) || isa(x,NewvarNode))
 end
 
-is_valid_lvalue(x) = isa(x, SlotNumber) || isa(x, SSAValue) || isa(x, GlobalRef)
-
-function is_valid_rvalue(x)
- isa(x, Expr) && return !in(x.head, (:gotoifnot, :line, :const, :meta))
- return !isa(x, GotoNode) && !isa(x, LabelNode) && !isa(x, LineNumberNode)
+function is_valid_rvalue(lhs, x)
+ is_valid_argument(x) && return true
+ if isa(x, Expr) && x.head in (:new, :the_exception, :isdefined, :call, :invoke, :foreigncall, :gc_preserve_begin)
+ return true
+ # TODO: disallow `globalref = call` when .typ field is removed
+ #return isa(lhs, SSAValue) || isa(lhs, Slot)
+ end
+ return false
 end
 
+is_valid_return(x) = is_valid_argument(x) || (isa(x,Expr) && x.head in (:new, :lambda))
+
 is_flag_set(byte::UInt8, flag::UInt8) = (byte & flag) == flag