[NewOptimizer] Domsort basic blocks

This sorts basic blocks into dominance order right after SSA construction.
Doing so has the benefit that linear traversals of the function
automatically become reverse post order traversals, or in other words,
we're guaranteed that during a linear traversal, we see any SSA
definitions before uses of those SSA values. This property is a prerequisite
for the incremental compactor to work correctly without back tracking.
It should also allow for simplifying codegen later, though not until
the new IR is the only thing supported by codegen.

Fixes core/asyncmap tests with the new optimizer enabled. I believe
those were the last tests that caused invalid IR generation (there's
still a few test failures due to the disabled alloc elim pass).

base/compiler/optimize.jl

@@ -4194,8 +4194,7 @@ function copy_duplicated_expr_pass!(sv::OptimizationState)
 end
 
 # fix label numbers to always equal the statement index of the label
-function reindex_labels!(sv::OptimizationState)
- body = sv.src.code
+function reindex_labels!(body::Vector{Any})
  mapping = get_label_map(body)
  for i = 1:length(body)
  el = body[i]
@@ -4235,6 +4234,11 @@ function reindex_labels!(sv::OptimizationState)
  end
 end
 
+
+function reindex_labels!(sv::OptimizationState)
+ reindex_labels!(sv.src.code)
+end
+
 function return_type(@nospecialize(f), @nospecialize(t))
  params = Params(ccall(:jl_get_tls_world_age, UInt, ()))
  rt = Union{}

base/compiler/ssair/domtree.jl

@@ -94,4 +94,4 @@ function construct_domtree(cfg)
  # Recursively set level
  update_level!(domtree, 1, 1)
  DomTree(idoms, domtree)
-end
+end

base/compiler/ssair/driver.jl

@@ -65,7 +65,9 @@ function normalize(@nospecialize(stmt), meta::Vector{Any}, table::Vector{LineInf
  elseif stmt.head === :gotoifnot
  return GotoIfNot(stmt.args...)
  elseif stmt.head === :return
- return ReturnNode{Any}(stmt.args...)
+ return ReturnNode((length(stmt.args) == 0 ? (nothing,) : stmt.args)...)
+ elseif stmt.head === :unreachable
+ return ReturnNode()
  end
  elseif isa(stmt, LabelNode)
  return nothing
@@ -89,6 +91,23 @@ end
 function run_passes(ci::CodeInfo, nargs::Int, linetable::Vector{LineInfoNode})
  mod = linetable[1].mod
  ci.code = copy(ci.code)
+ # Go through and add an unreachable node after every
+ # Union{} call. Then reindex labels.
+ idx = 1
+ while idx <= length(ci.code)
+ stmt = ci.code[idx]
+ if isexpr(stmt, :(=))
+ stmt = stmt.args[2]
+ end
+ if isa(stmt, Expr) && stmt.typ === Union{}
+ if !(idx < length(ci.code) && isexpr(ci.code[idx+1], :unreachable))
+ insert!(ci.code, idx + 1, ReturnNode())
+ idx += 1
+ end
+ end
+ idx += 1
+ end
+ reindex_labels!(ci.code)
  meta = Any[]
  lines = fill(0, length(ci.code))
  let loc = RefValue(1)
@@ -110,6 +129,7 @@ function run_passes(ci::CodeInfo, nargs::Int, linetable::Vector{LineInfoNode})
  IRCode(code, lines, cfg, argtypes, mod, meta)
  end
  ir = construct_ssa!(ci, ir, domtree, defuse_insts, nargs)
+ domtree = construct_domtree(ir.cfg)
  ir = compact!(ir)
  verify_ir(ir)
  ir = type_lift_pass!(ir)

base/compiler/ssair/ir.jl

@@ -11,10 +11,11 @@ struct GotoIfNot
  GotoIfNot(@nospecialize(cond), dest::Int) = new(cond, dest)
 end
 
-struct ReturnNode{T}
- val::T
- ReturnNode{T}(@nospecialize(val)) where {T} = new{T}(val::T)
- ReturnNode{T}() where {T} = new{T}()
+struct ReturnNode
+ val
+ ReturnNode(@nospecialize(val)) = new(val)
+ # unassigned val indicates unreachable
+ ReturnNode() = new()
 end
 
 """
@@ -31,6 +32,8 @@ start(r::StmtRange) = 0
 done(r::StmtRange, state) = r.last - r.first < state
 next(r::StmtRange, state) = (r.first + state, state + 1)
 
+StmtRange(range::UnitRange{Int}) = StmtRange(first(range), last(range))
+
 struct BasicBlock
  stmts::StmtRange
  preds::Vector{Int}
@@ -264,7 +267,7 @@ function done(it::UseRefIterator, use)
  false
 end
 
-function scan_ssa_use!(used::IdSet{Int64}, @nospecialize(stmt))
+function scan_ssa_use!(used, @nospecialize(stmt))
  if isa(stmt, SSAValue)
  push!(used, stmt.id)
  end
@@ -340,9 +343,9 @@ mutable struct IncrementalCompact
 end
 
 struct TypesView
- compact::IncrementalCompact
+ ir::Union{IRCode, IncrementalCompact}
 end
-types(compact::IncrementalCompact) = TypesView(compact)
+types(ir::Union{IRCode, IncrementalCompact}) = TypesView(ir)
 
 function getindex(compact::IncrementalCompact, idx)
  if idx < compact.result_idx
@@ -368,10 +371,16 @@ function setindex!(compact::IncrementalCompact, v, idx)
 end
 
 function getindex(view::TypesView, idx)
- if idx < view.compact.result_idx
+ isa(idx, SSAValue) && (idx = idx.id)
+ if isa(view.ir, IncrementalCompact) && idx < view.compact.result_idx
  return view.compact.result_types[idx]
  else
- return view.compact.ir.types[idx]
+ ir = isa(view.ir, IncrementalCompact) ? view.ir.ir : view.ir
+ if idx <= length(ir.types)
+ return ir.types[idx]
+ else
+ return ir.new_nodes[idx - length(ir.types)][2]
+ end
  end
 end
 
@@ -457,7 +466,7 @@ function next(compact::IncrementalCompact, (idx, active_bb, old_result_idx)::Tup
  compact.result_types[old_result_idx] = typ
  compact.result_lines[old_result_idx] = new_line
  result_idx = process_node!(compact, old_result_idx, new_node, new_idx, idx)
- (old_result_idx == result_idx) && return next(compact, (idx, result_idx))
+ (old_result_idx == result_idx) && return next(compact, (idx, active_bb, result_idx))
  compact.result_idx = result_idx
  return (old_result_idx, compact.result[old_result_idx]), (compact.idx, active_bb, compact.result_idx)
  end

base/compiler/ssair/legacy.jl

@@ -159,7 +159,7 @@ function replace_code!(ci::CodeInfo, code::IRCode, nargs::Int, linetable::Vector
  new_stmt = Expr(:return, rename(stmt.val))
  else
  # Unreachable, so no issue with this
- new_stmt = nothing
+ new_stmt = Expr(:unreachable)
  end
  elseif isa(stmt, SSAValue)
  new_stmt = rename(stmt)

base/compiler/ssair/passes.jl

@@ -35,7 +35,7 @@ function type_lift_pass!(ir::IRCode)
  def = ir.stmts[item]
  edges = copy(def.edges)
  values = Vector{Any}(uninitialized, length(edges))
- new_phi = insert_node!(ir, item, Bool, PhiNode(edges, values))
+ new_phi = length(values) == 0 ? false : insert_node!(ir, item, Bool, PhiNode(edges, values))
  processed[item] = new_phi
  if first
  lifted_undef[stmt_id] = new_phi

base/compiler/ssair/show.jl

@@ -80,9 +80,10 @@ function Base.show(io::IO, code::IRCode)
  bbrange = cfg.blocks[bb_idx].stmts
  bbrange = bbrange.first:bbrange.last
  bb_pad = max_bb_idx_size - length(string(bb_idx))
+ bb_start_str = string("$(bb_idx) ",length(cfg.blocks[bb_idx].preds) <= 1 ? "─" : "┄", "─"^(bb_pad)," ")
  if idx != last(bbrange)
  if idx == first(bbrange)
- print(io, "$(bb_idx) ","─"^(1+bb_pad)," ")
+ print(io, bb_start_str)
  else
  print(io, "│ "," "^max_bb_idx_size)
  end
@@ -98,7 +99,7 @@ function Base.show(io::IO, code::IRCode)
  node_idx += length(code.stmts)
  if print_sep
  if floop
- print(io, "$(bb_idx) ","─"^(1+bb_pad)," ")
+ print(io, bb_start_str)
  else
  print(io, "│ "," "^max_bb_idx_size)
  end
@@ -117,7 +118,7 @@ function Base.show(io::IO, code::IRCode)
  end
  if print_sep
  if idx == first(bbrange) && floop
- print(io, "$(bb_idx) ","─"^(1+bb_pad)," ")
+ print(io, bb_start_str)
  else
  print(io, idx == last(bbrange) ? string("└", "─"^(1+max_bb_idx_size), " ") :
  string("│ ", " "^max_bb_idx_size))