Don't run unsafe compiler passes

As a preparation for replacing v3_codegen with a new code generator,
remove unsafe optimization passes. Especially the older compiler
passes have implicit assumptions about how the code is generated.

Remove the optimizations in beam_block (keep the code that creates
blocks) because they are unsafe. beam_block also calls
beam_utils:live_opt/1, which is unsafe.

Remove beam_type because it calls beam_utils:live_opt/1, and also
because it recalculates the number of heaps words and number of live
registers in allocation instructions, thus potentially hiding bugs in
other passes.

Remove beam_receive because it is unsafe.

Remove beam_record because it is the only remaining user
of beam_utils:anno_defs/1.

Remove beam_reorder because it makes much more sense to run it
as an early SSA-based optimization pass.

Remove the now unused functions in beam_utils:

    anno_def/1
    delete_annos/1
    is_killed_block/2
    live_opt/1
    usage/3

Note that the following test cases will fail because of the
removed optimizations:

    compile_SUITE:optimized_guards/1
    compile_SUITE:bc_options/1
    receive_SUITE:ref_opt/1

5 files changed, 10 insertions, 1153 deletions

diff --git a/lib/compiler/src/Makefile b/lib/compiler/src/Makefile
index 2408c76b48..08042aeba4 100644
--- a/lib/compiler/src/Makefile
+++ b/lib/compiler/src/Makefile
@@ -61,12 +61,8 @@ MODULES =  \
 	beam_listing \
 	beam_opcodes \
 	beam_peep \
-	beam_receive \
-	beam_reorder \
-	beam_record \
 	beam_split \
 	beam_trim \
-	beam_type \
 	beam_utils \
 	beam_validator \
         beam_z \
diff --git a/lib/compiler/src/beam_block.erl b/lib/compiler/src/beam_block.erl
index fe43163455..3e28ff2c01 100644
--- a/lib/compiler/src/beam_block.erl
+++ b/lib/compiler/src/beam_block.erl
@@ -23,31 +23,20 @@
 -module(beam_block).
 
 -export([module/2]).
--import(lists, [reverse/1,reverse/2,member/2]).
+-import(lists, [reverse/1]).
 
 -spec module(beam_utils:module_code(), [compile:option()]) ->
                     {'ok',beam_utils:module_code()}.
 
-module({Mod,Exp,Attr,Fs0,Lc}, Opts) ->
-    Blockify = not member(no_blockify, Opts),
-    Fs = [function(F, Blockify) || F <- Fs0],
+module({Mod,Exp,Attr,Fs0,Lc}, _Opts) ->
+    Fs = [function(F) || F <- Fs0],
     {ok,{Mod,Exp,Attr,Fs,Lc}}.
 
-function({function,Name,Arity,CLabel,Is0}, Blockify) ->
+function({function,Name,Arity,CLabel,Is0}) ->
     try
 	%% Collect basic blocks and optimize them.
-        Is1 = case Blockify of
-                  false -> Is0;
-                  true -> blockify(Is0)
-              end,
-        Is2 = embed_lines(Is1),
-        Is3 = local_cse(Is2),
-        Is4 = beam_utils:anno_defs(Is3),
-        Is5 = move_allocates(Is4),
-        Is6 = beam_utils:live_opt(Is5),
-        Is7 = opt_blocks(Is6),
-        Is8 = beam_utils:delete_annos(Is7),
-        Is = opt_allocs(Is8),
+        Is1 = blockify(Is0),
+        Is = embed_lines(Is1),
 
         %% Done.
         {function,Name,Arity,CLabel,Is}
@@ -137,557 +126,6 @@ embed_lines([{block,B2},{line,_}=Line,{block,B1}|T], Acc) ->
 embed_lines([{block,B1},{line,_}=Line|T], Acc) ->
     B = {block,[{set,[],[],Line}|B1]},
     embed_lines([B|T], Acc);
-embed_lines([{block,B2},{block,B1}|T], Acc) ->
-    %% This can only happen when beam_block is run for
-    %% the second time.
-    B = {block,B1++B2},
-    embed_lines([B|T], Acc);
 embed_lines([I|Is], Acc) ->
     embed_lines(Is, [I|Acc]);
 embed_lines([], Acc) -> Acc.
-
-opt_blocks([{block,Bl0}|Is]) ->
-    %% The live annotation at the beginning is not useful.
-    [{'%anno',_}|Bl] = Bl0,
-    [{block,opt_block(Bl)}|opt_blocks(Is)];
-opt_blocks([I|Is]) ->
-    [I|opt_blocks(Is)];
-opt_blocks([]) -> [].
-
-opt_block(Is0) ->
-    find_fixpoint(fun(Is) ->
-                          opt_tuple_element(opt(Is))
-                  end, Is0).
-
-find_fixpoint(OptFun, Is0) ->
-    case OptFun(Is0) of
-	Is0 -> Is0;
-	Is1 -> find_fixpoint(OptFun, Is1)
-    end.
-
-%% move_allocates(Is0) -> Is
-%%  Move allocate instructions upwards in the instruction stream
-%%  (within the same block), in the hope of getting more possibilities
-%%  for optimizing away moves later.
-%%
-%%  For example, we can transform the following instructions:
-%%
-%%     get_tuple_element x(1) Element => x(2)
-%%     allocate_zero StackSize 3    %% x(0), x(1), x(2) are live
-%%
-%%  to the following instructions:
-%%
-%%     allocate_zero StackSize 2    %% x(0) and x(1) are live
-%%     get_tuple_element x(1) Element => x(2)
-%%
-%%  NOTE: Since the beam_reorder pass has been run, it is no longer
-%%  safe to assume that if x(N) is initialized, then all lower-numbered
-%%  x registers are also initialized.
-%%
-%%  For example, we must be careful when transforming the following
-%%  instructions:
-%%
-%%     get_tuple_element x(0) Element => x(1)
-%%     allocate_zero StackSize 3    %x(0), x(1), x(2) are live
-%%
-%%  to the following instructions:
-%%
-%%     allocate_zero StackSize 3
-%%     get_tuple_element x(0) Element => x(1)
-%%
-%%  The transformation is safe if and only if x(1) has been
-%%  initialized previously.  We will use the annotations added by
-%%  beam_utils:anno_defs/1 to determine whether x(a) has been
-%%  initialized.
-
-move_allocates([{block,Bl0}|Is]) ->
-    Bl = move_allocates_1(reverse(Bl0), []),
-    [{block,Bl}|move_allocates(Is)];
-move_allocates([I|Is]) ->
-    [I|move_allocates(Is)];
-move_allocates([]) -> [].
-
-move_allocates_1([{'%anno',_}|Is], Acc) ->
-    move_allocates_1(Is, Acc);
-move_allocates_1([I|Is], [{set,[],[],{alloc,Live0,Info0}}|Acc]=Acc0) ->
-    case alloc_may_pass(I) of
-        false ->
-            move_allocates_1(Is, [I|Acc0]);
-        true ->
-            case alloc_live_regs(I, Is, Live0) of
-                not_possible ->
-                    move_allocates_1(Is, [I|Acc0]);
-                Live when is_integer(Live) ->
-                    Info = safe_info(Info0),
-                    A = {set,[],[],{alloc,Live,Info}},
-                    move_allocates_1(Is, [A,I|Acc])
-            end
-    end;
-move_allocates_1([I|Is], Acc) ->
-    move_allocates_1(Is, [I|Acc]);
-move_allocates_1([], Acc) -> Acc.
-
-alloc_may_pass({set,_,[{fr,_}],fmove}) -> false;
-alloc_may_pass({set,_,_,{alloc,_,_}}) -> false;
-alloc_may_pass({set,_,_,{set_tuple_element,_}}) -> false;
-alloc_may_pass({set,_,_,put_list}) -> false;
-alloc_may_pass({set,_,_,put}) -> false;
-alloc_may_pass({set,_,_,_}) -> true.
-
-safe_info({nozero,Stack,Heap,_}) ->
-    %% nozero is not safe if the allocation instruction is moved
-    %% upwards past an instruction that may throw an exception
-    %% (such as element/2).
-    {zero,Stack,Heap,[]};
-safe_info(Info) -> Info.
-
-%% opt([Instruction]) -> [Instruction]
-%%  Optimize the instruction stream inside a basic block.
-
-opt([{set,[X],[X],move}|Is]) -> opt(Is);
-opt([{set,[Dst],_,move},{set,[Dst],[Src],move}=I|Is]) when Dst =/= Src ->
-    opt([I|Is]);
-opt([{set,[{x,0}],[S1],move}=I1,{set,[D2],[{x,0}],move}|Is]) ->
-    opt([I1,{set,[D2],[S1],move}|Is]);
-opt([{set,[{x,0}],[S1],move}=I1,{set,[D2],[S2],move}|Is0]) when S1 =/= D2 ->
-    %% Place move S x0 at the end of move sequences so that
-    %% loader can merge with the following instruction
-    {Ds,Is} = opt_moves([D2], Is0),
-    [{set,Ds,[S2],move}|opt([I1|Is])];
-opt([{set,_,_,{line,_}}=Line1,
-     {set,[D1],[{integer,Idx1},Reg],{bif,element,{f,0}}}=I1,
-     {set,_,_,{line,_}}=Line2,
-     {set,[D2],[{integer,Idx2},Reg],{bif,element,{f,0}}}=I2|Is])
-  when Idx1 < Idx2, D1 =/= D2, D1 =/= Reg, D2 =/= Reg ->
-    opt([Line2,I2,Line1,I1|Is]);
-opt([{set,[D1],[{integer,Idx1},Reg],{bif,element,{f,L}}}=I1,
-     {set,[D2],[{integer,Idx2},Reg],{bif,element,{f,L}}}=I2|Is])
-  when Idx1 < Idx2, D1 =/= D2, D1 =/= Reg, D2 =/= Reg ->
-    opt([I2,I1|Is]);
-opt([{set,Hd0,Cons,get_hd}=GetHd,
-     {set,Tl0,Cons,get_tl}=GetTl|Is0]) ->
-    case {opt_moves(Hd0, [GetTl|Is0]),opt_moves(Tl0, [GetHd|Is0])} of
-        {{Hd0,Is},{Tl0,_}} ->
-            [GetHd|opt(Is)];
-        {{Hd,Is},{Tl0,_}} ->
-            [{set,Hd,Cons,get_hd}|opt(Is)];
-        {{_,_},{Tl,Is}} ->
-            [{set,Tl,Cons,get_tl}|opt(Is)]
-    end;
-opt([{set,Ds0,Ss,Op}|Is0]) ->
-    {Ds,Is} = opt_moves(Ds0, Is0),
-    [{set,Ds,Ss,Op}|opt(Is)];
-opt([{'%anno',_}=I|Is]) ->
-    [I|opt(Is)];
-opt([]) -> [].
-
-%% opt_moves([Dest], [Instruction]) -> {[Dest],[Instruction]}
-%%  For each Dest, does the optimization described in opt_move/2.
-
-opt_moves([], Is0) -> {[],Is0};
-opt_moves([D0]=Ds, Is0) ->
-    case opt_move(D0, Is0) of
-	not_possible -> {Ds,Is0};
-	{D1,Is} -> {[D1],Is}
-    end.
-
-%% opt_move(Dest, [Instruction]) -> {UpdatedDest,[Instruction]} | not_possible
-%%  If there is a {move,Dest,FinalDest} instruction
-%%  in the instruction stream, remove the move instruction
-%%  and let FinalDest be the destination.
-
-opt_move(Dest, Is) ->
-    opt_move_1(Dest, Is, []).
-
-opt_move_1(R, [{set,[D],[R],move}|Is0], Acc) ->
-    %% Provided that the source register is killed by instructions
-    %% that follow, the optimization is safe.
-    case eliminate_use_of_from_reg(Is0, R, D) of
-	{yes,Is} -> opt_move_rev(D, Acc, Is);
-	no -> not_possible
-    end;
-opt_move_1(_R, [{set,_,_,{alloc,_,_}}|_], _) ->
-    %% The optimization is either not possible or not safe.
-    %%
-    %% If R is an X register killed by allocation, the optimization is
-    %% not safe. On the other hand, if the X register is killed, there
-    %% will not follow a 'move' instruction with this X register as
-    %% the source.
-    %%
-    %% If R is a Y register, the optimization is still not safe
-    %% because the new target register is an X register that cannot
-    %% safely pass the alloc instruction.
-    not_possible;
-opt_move_1(R, [{set,_,_,_}=I|Is], Acc) ->
-    %% If the source register is either killed or used by this
-    %% instruction, the optimimization is not possible.
-    case is_killed_or_used(R, I) of
-	true -> not_possible;
-	false -> opt_move_1(R, Is, [I|Acc])
-    end;
-opt_move_1(_, _, _) ->
-    not_possible.
-
-%% opt_tuple_element([Instruction]) -> [Instruction]
-%%  If possible, move get_tuple_element instructions forward
-%%  in the instruction stream to a move instruction, eliminating
-%%  the move instruction. Example:
-%%
-%%    get_tuple_element Tuple Pos Dst1
-%%    ...
-%%    move Dst1 Dst2
-%%
-%%  This code may be possible to rewrite to:
-%%
-%%    %%(Moved get_tuple_element instruction)
-%%    ...
-%%    get_tuple_element Tuple Pos Dst2
-%%
-
-opt_tuple_element([{set,[D],[S],{get_tuple_element,_}}=I|Is0]) ->
-    case opt_tuple_element_1(Is0, I, {S,D}, []) of
-	no ->
-	    [I|opt_tuple_element(Is0)];
-	{yes,Is} ->
-	    opt_tuple_element(Is)
-    end;
-opt_tuple_element([I|Is]) ->
-    [I|opt_tuple_element(Is)];
-opt_tuple_element([]) -> [].
-
-opt_tuple_element_1([{set,_,_,{alloc,_,_}}|_], _, _, _) ->
-    no;
-opt_tuple_element_1([{set,_,_,{try_catch,_,_}}|_], _, _, _) ->
-    no;
-opt_tuple_element_1([{set,[D],[S],move}|Is0], I0, {_,S}, Acc) ->
-    case eliminate_use_of_from_reg(Is0, S, D) of
-	no ->
-	    no;
-	{yes,Is1} ->
-	    {set,[S],Ss,Op} = I0,
-	    I = {set,[D],Ss,Op},
-            case opt_move_rev(S, Acc, [I|Is1]) of
-                not_possible ->
-                    %% Not safe because the move of the
-                    %% get_tuple_element instruction would cause the
-                    %% result of a previous instruction to be ignored.
-                    no;
-                {_,Is} ->
-                    {yes,Is}
-            end
-    end;
-opt_tuple_element_1([{set,Ds,Ss,_}=I|Is], MovedI, {S,D}=Regs, Acc) ->
-    case member(S, Ds) orelse member(D, Ss) of
-	true ->
-	    no;
-	false ->
-	    opt_tuple_element_1(Is, MovedI, Regs, [I|Acc])
-    end;
-opt_tuple_element_1(_, _, _, _) -> no.
-
-%% Reverse the instructions, while checking that there are no
-%% instructions that would interfere with using the new destination
-%% register (D).
-
-opt_move_rev(D, [I|Is], Acc) ->
-    case is_killed_or_used(D, I) of
-	true -> not_possible;
-	false -> opt_move_rev(D, Is, [I|Acc])
-    end;
-opt_move_rev(D, [], Acc) -> {D,Acc}.
-
-%% is_killed_or_used(Register, {set,_,_,_}) -> bool()
-%%  Test whether the register is used by the instruction.
-
-is_killed_or_used(R, {set,Ss,Ds,_}) ->
-    member(R, Ds) orelse member(R, Ss).
-
-%% eliminate_use_of_from_reg([Instruction], FromRegister, ToRegister, Acc) ->
-%%       {yes,Is} | no
-%%  Eliminate any use of FromRegister in the instruction sequence
-%%  by replacing uses of FromRegister with ToRegister. If FromRegister
-%%  is referenced by an allocation instruction, return 'no' to indicate
-%%  that FromRegister is still used and that the optimization is not
-%%  possible.
-
-eliminate_use_of_from_reg(Is, From, To) ->
-    try
-        eliminate_use_of_from_reg(Is, From, To, [])
-    catch
-        throw:not_possible ->
-            no
-    end.
-
-eliminate_use_of_from_reg([{set,_,_,{alloc,Live,_}}|_]=Is0, {x,X}, _, Acc) ->
-    if
-	X < Live ->
-	    no;
-	true ->
-	    {yes,reverse(Acc, Is0)}
-    end;
-eliminate_use_of_from_reg([{set,Ds,Ss0,Op}=I0|Is], From, To, Acc) ->
-    ensure_safe_tuple(I0, To),
-    I = case member(From, Ss0) of
-            true ->
-                Ss = [case S of
-                          From -> To;
-                          _ -> S
-                      end || S <- Ss0],
-                {set,Ds,Ss,Op};
-            false ->
-                I0
-        end,
-    case member(From, Ds) of
-        true ->
-            {yes,reverse(Acc, [I|Is])};
-        false ->
-            case member(To, Ds) of
-                true ->
-                    case beam_utils:is_killed_block(From, Is) of
-                        true ->
-                            {yes,reverse(Acc, [I|Is])};
-                        false ->
-                            no
-                    end;
-                false ->
-                    eliminate_use_of_from_reg(Is, From, To, [I|Acc])
-            end
-    end;
-eliminate_use_of_from_reg([I]=Is, From, _To, Acc) ->
-    case beam_utils:is_killed_block(From, [I]) of
-	true ->
-	    {yes,reverse(Acc, Is)};
-	false ->
-	    no
-    end.
-
-ensure_safe_tuple({set,[To],[],{put_tuple,_}}, To) ->
-    throw(not_possible);
-ensure_safe_tuple(_, _) -> ok.
-
-%% opt_allocs(Instructions) -> Instructions.  Optimize allocate
-%%  instructions inside blocks. If safe, replace an allocate_zero
-%%  instruction with the slightly cheaper allocate instruction.
-
-opt_allocs(Is) ->
-    D = beam_utils:index_labels(Is),
-    opt_allocs_1(Is, D).
-
-opt_allocs_1([{block,Bl0}|Is], D) ->
-    Bl = opt_alloc(Bl0, {D,Is}),
-    [{block,Bl}|opt_allocs_1(Is, D)];
-opt_allocs_1([I|Is], D) ->
-    [I|opt_allocs_1(Is, D)];
-opt_allocs_1([], _) -> [].
-
-%% opt_alloc(Instructions) -> Instructions'
-%%  Optimises all allocate instructions.
-
-opt_alloc([{set,[],[],{alloc,Live0,Info0}},
-           {set,[],[],{alloc,Live,Info}}|Is], D) ->
-    Live = Live0,				%Assertion.
-    Alloc = combine_alloc(Info0, Info),
-    I = {set,[],[],{alloc,Live,Alloc}},
-    opt_alloc([I|Is], D);
-opt_alloc([{set,[],[],{alloc,R,{_,Ns,Nh,[]}}}|Is], D) ->
-    [{set,[],[],opt_alloc(Is, D, Ns, Nh, R)}|Is];
-opt_alloc([I|Is], D) -> [I|opt_alloc(Is, D)];
-opt_alloc([], _) -> [].
-
-combine_alloc({_,Ns,Nh1,Init}, {_,nostack,Nh2,[]})  ->
-    {zero,Ns,beam_utils:combine_heap_needs(Nh1, Nh2),Init}.
-
-%% opt_alloc(Instructions, FrameSize, HeapNeed, LivingRegs) -> [Instr]
-%%  Generates the optimal sequence of instructions for
-%%  allocating and initalizing the stack frame and needed heap.
-
-opt_alloc(_Is, _D, nostack, Nh, LivingRegs) ->
-    {alloc,LivingRegs,{nozero,nostack,Nh,[]}};
-opt_alloc(Bl, {D,OuterIs}, Ns, Nh, LivingRegs) ->
-    Is = [{block,Bl}|OuterIs],
-    InitRegs = init_yregs(Ns, Is, D),
-    case count_ones(InitRegs) of
-	N when N*2 > Ns ->
-	    {alloc,LivingRegs,{nozero,Ns,Nh,gen_init(Ns, InitRegs)}};
-	_ ->
-	    {alloc,LivingRegs,{zero,Ns,Nh,[]}}
-    end.
-
-gen_init(Fs, Regs) -> gen_init(Fs, Regs, 0, []).
-
-gen_init(SameFs, _Regs, SameFs, Acc) -> reverse(Acc);
-gen_init(Fs, Regs, Y, Acc) when Regs band 1 =:= 0 ->
-    gen_init(Fs, Regs bsr 1, Y+1, [{init,{y,Y}}|Acc]);
-gen_init(Fs, Regs, Y, Acc) ->
-    gen_init(Fs, Regs bsr 1, Y+1, Acc).
-
-init_yregs(Y, Is, D) when Y >= 0 ->
-    case beam_utils:is_killed({y,Y}, Is, D) of
-        true ->
-            (1 bsl Y) bor init_yregs(Y-1, Is, D);
-        false ->
-            init_yregs(Y-1, Is, D)
-    end;
-init_yregs(_, _, _) -> 0.
-
-count_ones(Bits) -> count_ones(Bits, 0).
-count_ones(0, Acc) -> Acc;
-count_ones(Bits, Acc) ->
-    count_ones(Bits bsr 1, Acc + (Bits band 1)).
-
-%% Calculate the new number of live registers when we move an allocate
-%% instruction upwards, passing a 'set' instruction.
-
-alloc_live_regs({set,Ds,Ss,_}, Is, Regs0) ->
-    Rset = x_live(Ss, x_dead(Ds, (1 bsl Regs0)-1)),
-    Live = live_regs(0, Rset),
-    case ensure_contiguous(Rset, Live) of
-        not_possible ->
-            %% Liveness information (looking forward in the
-            %% instruction stream) can't prove that moving this
-            %% allocation instruction is safe. Now use the annotation
-            %% of defined registers at the beginning of the current
-            %% block to see whether moving would be safe.
-            Def0 = defined_regs(Is, 0),
-            Def = Def0 band ((1 bsl Live) - 1),
-            ensure_contiguous(Rset bor Def, Live);
-        Live ->
-            %% Safe based on liveness information.
-            Live
-    end.
-
-live_regs(N, 0) ->
-    N;
-live_regs(N, Regs) ->
-    live_regs(N+1, Regs bsr 1).
-
-ensure_contiguous(Regs, Live) ->
-    case (1 bsl Live) - 1 of
-        Regs -> Live;
-        _ -> not_possible
-    end.
-
-x_dead([{x,N}|Rs], Regs) -> x_dead(Rs, Regs band (bnot (1 bsl N)));
-x_dead([_|Rs], Regs) -> x_dead(Rs, Regs);
-x_dead([], Regs) -> Regs.
-
-x_live([{x,N}|Rs], Regs) -> x_live(Rs, Regs bor (1 bsl N));
-x_live([_|Rs], Regs) -> x_live(Rs, Regs);
-x_live([], Regs) -> Regs.
-
-%% defined_regs(ReversedInstructions) -> RegBitmap.
-%%  Given a reversed instruction stream, determine the
-%%  the registers that are defined.
-
-defined_regs([{'%anno',{def,Def}}|_], Regs) ->
-    Def bor Regs;
-defined_regs([{set,Ds,_,{alloc,Live,_}}|_], Regs) ->
-    x_live(Ds, Regs bor ((1 bsl Live) - 1));
-defined_regs([{set,Ds,_,_}|Is], Regs) ->
-    defined_regs(Is, x_live(Ds, Regs)).
-
-%%%
-%%% Do local common sub expression elimination (CSE) in each block.
-%%%
-
-local_cse([{block,Bl0}|Is]) ->
-    Bl = cse_block(Bl0, orddict:new(), []),
-    [{block,Bl}|local_cse(Is)];
-local_cse([I|Is]) ->
-    [I|local_cse(Is)];
-local_cse([]) -> [].
-
-cse_block([I|Is], Es0, Acc0) ->
-    Es1 = cse_clear(I, Es0),
-    case cse_expr(I) of
-        none ->
-            %% Instruction is not suitable for CSE.
-            cse_block(Is, Es1, [I|Acc0]);
-        {ok,D,Expr} ->
-            %% Suitable instruction. First update the dictionary of
-            %% suitable expressions for the next iteration.
-            Es = cse_add(D, Expr, Es1),
-
-            %% Search for a previous identical expression.
-            case cse_find(Expr, Es0) of
-                error ->
-                    %% Nothing found
-                    cse_block(Is, Es, [I|Acc0]);
-                Src ->
-                    %% Use the previously calculated result.
-                    %% Also eliminate any line instruction.
-                    Move = {set,[D],[Src],move},
-                    case Acc0 of
-                        [{set,_,_,{line,_}}|Acc] ->
-                            cse_block(Is, Es, [Move|Acc]);
-                        [_|_] ->
-                            cse_block(Is, Es, [Move|Acc0])
-                    end
-            end
-    end;
-cse_block([], _, Acc) ->
-    reverse(Acc).
-
-%% cse_find(Expr, Expressions) -> error | Register.
-%%  Find a previously evaluated expression whose result can be reused,
-%%  or return 'error' if no such expression is found.
-
-cse_find(Expr, Es) ->
-    case orddict:find(Expr, Es) of
-        {ok,{Src,_}} -> Src;
-        error -> error
-    end.
-
-cse_expr({set,[D],Ss,{bif,N,_}}) ->
-    case D of
-        {fr,_} ->
-            %% There are too many things that can go wrong.
-            none;
-        _ ->
-            {ok,D,{{bif,N},Ss}}
-    end;
-cse_expr({set,[D],Ss,{alloc,_,{gc_bif,N,_}}}) ->
-    {ok,D,{{gc_bif,N},Ss}};
-cse_expr({set,[D],Ss,put_list}) ->
-    {ok,D,{put_list,Ss}};
-cse_expr(_) -> none.
-
-%% cse_clear(Instr, Expressions0) -> Expressions.
-%%  Remove all previous expressions that will become
-%%  invalid when this instruction is executed. Basically,
-%%  an expression is no longer safe to reuse when the
-%%  register it has been stored to has been modified, killed,
-%%  or if any of the source operands have changed.
-
-cse_clear({set,Ds,_,{alloc,Live,_}}, Es) ->
-    cse_clear_1(Es, Live, Ds);
-cse_clear({set,Ds,_,_}, Es) ->
-    cse_clear_1(Es, all, Ds).
-
-cse_clear_1(Es, Live, Ds0) ->
-    Ds = ordsets:from_list(Ds0),
-    [E || E <- Es, cse_is_safe(E, Live, Ds)].
-
-cse_is_safe({_,{Dst,Interfering}}, Live, Ds) ->
-    ordsets:is_disjoint(Interfering, Ds) andalso
-        case Dst of
-            {x,X} ->
-                X < Live;
-            _ ->
-                true
-        end.
-
-%% cse_add(Dest, Expr, Expressions0) -> Expressions.
-%%  Provided that it is safe, add a new expression to the dictionary
-%%  of already evaluated expressions.
-
-cse_add(D, {_,Ss}=Expr, Es) ->
-    case member(D, Ss) of
-        false ->
-            Interfering = ordsets:from_list([D|Ss]),
-            orddict:store(Expr, {D,Interfering}, Es);
-        true ->
-            %% Unsafe because the instruction overwrites one of
-            %% source operands.
-            Es
-    end.
diff --git a/lib/compiler/src/beam_utils.erl b/lib/compiler/src/beam_utils.erl
index 317252e87a..af1e719206 100644
--- a/lib/compiler/src/beam_utils.erl
+++ b/lib/compiler/src/beam_utils.erl
@@ -21,18 +21,16 @@
 %% 
 
 -module(beam_utils).
--export([is_killed_block/2,is_killed/3,is_killed_at/3,
-	 is_not_used/3,usage/3,
+-export([is_killed/3,is_killed_at/3,is_not_used/3,
 	 empty_label_index/0,index_label/3,index_labels/1,replace_labels/4,
 	 code_at/2,bif_to_test/3,is_pure_test/1,
-	 live_opt/1,delete_annos/1,combine_heap_needs/2,
-         anno_defs/1,
+	 combine_heap_needs/2,
 	 split_even/1
         ]).
 
 -export_type([code_index/0,module_code/0,instruction/0]).
 
--import(lists, [flatmap/2,map/2,member/2,sort/1,reverse/1,splitwith/2]).
+-import(lists, [flatmap/2,map/2,member/2,sort/1,reverse/1]).
 
 -define(is_const(Val), (Val =:= nil orelse
                         element(1, Val) =:= integer orelse
@@ -62,46 +60,6 @@
 	{lbl :: code_index(),            %Label to code index.
 	 res :: result_cache()}).        %Result cache for each label.
 
-%% usage(Register, [Instruction], State) -> killed|not_used|used.
-%%  Determine the usage of Register in the instruction sequence.
-%%  The return value is one of:
-%%
-%%  killed   - The register is not used in any way.
-%%  not_used - The register is referenced only by an allocating instruction
-%%             (the actual value does not matter).
-%%  used     - The register is used (its value do matter).
-
--spec usage(beam_asm:reg(), [instruction()], code_index()) ->
-  'killed' | 'not_used' | 'used'.
-
-usage(R, Is, D) ->
-    St = #live{lbl=D,res=gb_trees:empty()},
-    {Usage,_} = check_liveness(R, Is, St),
-    Usage.
-
-
-%% is_killed_block(Register, [Instruction]) -> true|false
-%%  Determine whether a register is killed by the instruction sequence inside
-%%  a block.
-%%
-%%  If true is returned, it means that the register will not be
-%%  referenced in ANY way (not even indirectly by an allocate instruction);
-%%  i.e. it is OK to enter the instruction sequence with Register
-%%  containing garbage.
-
--spec is_killed_block(beam_asm:reg(), [instruction()]) -> boolean().
-
-is_killed_block({x,X}, [{set,_,_,{alloc,Live,_}}|_]) ->
-    X >= Live;
-is_killed_block(R, [{set,Ds,Ss,_Op}|Is]) ->
-    not member(R, Ss) andalso (member(R, Ds) orelse is_killed_block(R, Is));
-is_killed_block(R, [{'%anno',{used,Regs}}|Is]) ->
-    case R of
-	{x,X} when (Regs bsr X) band 1 =:= 0 -> true;
-	_ -> is_killed_block(R, Is)
-    end;
-is_killed_block(_, []) -> false.
-
 %% is_killed(Register, [Instruction], State) -> true|false
 %%  Determine whether a register is killed by the instruction sequence.
 %%  If true is returned, it means that the register will not be
@@ -261,42 +219,6 @@ is_pure_test({test,is_function2,_,[_,_]}) -> true;
 is_pure_test({test,Op,_,Ops}) -> 
     erl_internal:new_type_test(Op, length(Ops)).
 
-    
-%% live_opt([Instruction]) -> [Instruction].
-%%  Go through the instruction sequence in reverse execution
-%%  order, keep track of liveness and remove 'move' instructions
-%%  whose destination is a register that will not be used.
-%%  Also insert {used,Regs} annotations at the beginning
-%%  and end of each block.
-
--spec live_opt([instruction()]) -> [instruction()].
-
-live_opt(Is0) ->
-    {[{label,Fail}|_]=Bef,[Fi|Is]} =
-	splitwith(fun({func_info,_,_,_}) -> false;
-		     (_) -> true
-		  end, Is0),
-    {func_info,_,_,Live} = Fi,
-    D = gb_trees:insert(Fail, live_call(Live), gb_trees:empty()),
-    Bef ++ [Fi|live_opt(reverse(Is), 0, D, [])].
-
-
-%% delete_annos([Instruction]) -> [Instruction].
-%%  Delete all annotations.
-
--spec delete_annos([instruction()]) -> [instruction()].
-
-delete_annos([{block,Bl0}|Is]) ->
-    case delete_annos(Bl0) of
-	[] -> delete_annos(Is);
-	[_|_]=Bl -> [{block,Bl}|delete_annos(Is)]
-    end;
-delete_annos([{'%anno',_}|Is]) ->
-    delete_annos(Is);
-delete_annos([I|Is]) ->
-    [I|delete_annos(Is)];
-delete_annos([]) -> [].
-
 %% combine_heap_needs(HeapNeed1, HeapNeed2) -> HeapNeed
 %%  Combine the heap need for two allocation instructions.
 
@@ -310,24 +232,6 @@ combine_heap_needs(H1, H2) when is_integer(H1), is_integer(H2) ->
 combine_heap_needs(H1, H2) ->
     {alloc,combine_alloc_lists([H1,H2])}.
 
-
-%% anno_defs(Instructions) -> Instructions'
-%%  Add {def,RegisterBitmap} annotations to the beginning of
-%%  each block.  Iff bit X is set in the the bitmap, it means
-%%  that {x,X} is defined when the block is entered.
-
--spec anno_defs([instruction()]) -> [instruction()].
-
-anno_defs(Is0) ->
-    {Bef,[Fi|Is1]} =
-	splitwith(fun({func_info,_,_,_}) -> false;
-		     (_) -> true
-		  end, Is0),
-    {func_info,_,_,Arity} = Fi,
-    Regs = init_def_regs(Arity),
-    Is = defs(Is1, Regs, #{}),
-    Bef ++ [Fi|Is].
-
 %% split_even/1
 %% [1,2,3,4,5,6] -> {[1,3,5],[2,4,6]}
 
@@ -846,466 +750,7 @@ combine_alloc_lists(Al0) ->
 
 %% live_opt/4.
 
-%% Bit syntax instructions.
-live_opt([{bs_context_to_binary,Src}=I|Is], Regs0, D, Acc) ->
-    Regs = x_live([Src], Regs0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{bs_init,Fail,_,none,Ss,Dst}=I|Is], Regs0, D, Acc) ->
-    Regs1 = x_live(Ss, x_dead([Dst], Regs0)),
-    Regs = live_join_label(Fail, D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{bs_init,Fail,Info,Live0,Ss,Dst}|Is], Regs0, D, Acc) ->
-    Regs1 = x_dead([Dst], Regs0),
-    Live = live_regs(Regs1),
-    true = Live =< Live0,	%Assertion.
-    Regs2 = live_call(Live),
-    Regs3 = x_live(Ss, Regs2),
-    Regs = live_join_label(Fail, D, Regs3),
-    I = {bs_init,Fail,Info,Live,Ss,Dst},
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{bs_put,Fail,_,Ss}=I|Is], Regs0, D, Acc) ->
-    Regs1 = x_live(Ss, Regs0),
-    Regs = live_join_label(Fail, D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{bs_restore2,Src,_}=I|Is], Regs0, D, Acc) ->
-    Regs = x_live([Src], Regs0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{bs_save2,Src,_}=I|Is], Regs0, D, Acc) ->
-    Regs = x_live([Src], Regs0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{test,bs_start_match2,Fail,Live,[Src,_],_}=I|Is], _, D, Acc) ->
-    Regs0 = live_call(Live),
-    Regs1 = x_live([Src], Regs0),
-    Regs = live_join_label(Fail, D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-
-%% Other instructions.
-live_opt([{block,Bl0}|Is], Regs0, D, Acc) ->
-    Live0 = make_anno({used,Regs0}),
-    {Bl,Regs} = live_opt_block(reverse(Bl0), Regs0, D, [Live0]),
-    Live = make_anno({used,Regs}),
-    live_opt(Is, Regs, D, [{block,[Live|Bl]}|Acc]);
-live_opt([build_stacktrace=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(1), D, [I|Acc]);
-live_opt([raw_raise=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(3), D, [I|Acc]);
-live_opt([{label,L}=I|Is], Regs, D0, Acc) ->
-    D = gb_trees:insert(L, Regs, D0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{jump,{f,L}}=I|Is], _, D, Acc) ->
-    Regs = gb_trees:get(L, D),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([return=I|Is], _, D, Acc) ->
-    live_opt(Is, 1, D, [I|Acc]);
-live_opt([{catch_end,_}=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(1), D, [I|Acc]);
-live_opt([{badmatch,Src}=I|Is], _, D, Acc) ->
-    Regs = x_live([Src], 0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{case_end,Src}=I|Is], _, D, Acc) ->
-    Regs = x_live([Src], 0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{try_case_end,Src}=I|Is], _, D, Acc) ->
-    Regs = x_live([Src], 0),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([if_end=I|Is], _, D, Acc) ->
-    Regs = 0,
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{call,Arity,_}=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(Arity), D, [I|Acc]);
-live_opt([{call_ext,Arity,_}=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(Arity), D, [I|Acc]);
-live_opt([{call_fun,Arity}=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(Arity+1), D, [I|Acc]);
-live_opt([{apply,Arity}=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(Arity+2), D, [I|Acc]);
-live_opt([{make_fun2,_,_,_,Arity}=I|Is], _, D, Acc) ->
-    live_opt(Is, live_call(Arity), D, [I|Acc]);
-live_opt([{test,_,Fail,Ss}=I|Is], Regs0, D, Acc) ->
-    Regs1 = x_live(Ss, Regs0),
-    Regs = live_join_label(Fail, D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{test,_,Fail,Live,Ss,_}=I|Is], _, D, Acc) ->
-    Regs0 = live_call(Live),
-    Regs1 = x_live(Ss, Regs0),
-    Regs = live_join_label(Fail, D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{select,_,Src,Fail,List}=I|Is], _, D, Acc) ->
-    Regs0 = 0,
-    Regs1 = x_live([Src], Regs0),
-    Regs = live_join_labels([Fail|List], D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{try_case,Y}=I|Is], Regs0, D, Acc) ->
-    Regs = live_call(1),
-    case Regs0 of
-        0 ->
-            live_opt(Is, Regs, D, [{try_end,Y}|Acc]);
-        _ ->
-            live_opt(Is, live_call(1), D, [I|Acc])
-    end;
-live_opt([{loop_rec,_Fail,_Dst}=I|Is], _, D, Acc) ->
-    live_opt(Is, 0, D, [I|Acc]);
-live_opt([timeout=I|Is], _, D, Acc) ->
-    live_opt(Is, 0, D, [I|Acc]);
-live_opt([{wait,_}=I|Is], _, D, Acc) ->
-    live_opt(Is, 0, D, [I|Acc]);
-live_opt([{get_map_elements,Fail,Src,{list,List}}=I|Is], Regs0, D, Acc) ->
-    {Ss,Ds} = split_even(List),
-    Regs1 = x_live([Src|Ss], x_dead(Ds, Regs0)),
-    Regs = live_join_label(Fail, D, Regs1),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{gc_bif,N,F,R,As,Dst}=I|Is], Regs0, D, Acc) ->
-    Bl = [{set,[Dst],As,{alloc,R,{gc_bif,N,F}}}],
-    {_,Regs} = live_opt_block(Bl, Regs0, D, []),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{bif,N,F,As,Dst}=I|Is], Regs0, D, Acc) ->
-    Bl = [{set,[Dst],As,{bif,N,F}}],
-    {_,Regs} = live_opt_block(Bl, Regs0, D, []),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{get_tuple_element,Src,Idx,Dst}=I|Is], Regs0, D, Acc) ->
-    Bl = [{set,[Dst],[Src],{get_tuple_element,Idx}}],
-    {_,Regs} = live_opt_block(Bl, Regs0, D, []),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{move,Src,Dst}=I|Is], Regs0, D, Acc) ->
-    Regs = x_live([Src], x_dead([Dst], Regs0)),
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{put_map,F,Op,S,Dst,R,{list,Puts}}=I|Is], Regs0, D, Acc) ->
-    Bl = [{set,[Dst],[S|Puts],{alloc,R,{put_map,Op,F}}}],
-    {_,Regs} = live_opt_block(Bl, Regs0, D, []),
-    live_opt(Is, Regs, D, [I|Acc]);
-
-%% Transparent instructions - they neither use nor modify x registers.
-live_opt([{deallocate,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{kill,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{try_end,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{loop_rec_end,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{wait_timeout,_,nil}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{wait_timeout,_,{Tag,_}}=I|Is], Regs, D, Acc) when Tag =/= x ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{line,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{'catch',_,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{'try',_,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-
-%% The following instructions can occur if the "compilation" has been
-%% started from a .S file using the 'from_asm' option.
-live_opt([{trim,_,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{'%',_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{recv_set,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{recv_mark,_}=I|Is], Regs, D, Acc) ->
-    live_opt(Is, Regs, D, [I|Acc]);
-
-live_opt([], _, _, Acc) -> Acc.
-
-live_opt_block([{set,[{x,X}]=Ds,Ss,move}=I|Is], Regs0, D, Acc) ->
-    Regs = x_live(Ss, x_dead(Ds, Regs0)),
-    case is_live(X, Regs0) of
-        true ->
-            live_opt_block(Is, Regs, D, [I|Acc]);
-        false ->
-            %% Useless move, will never be used.
-            live_opt_block(Is, Regs, D, Acc)
-    end;
-live_opt_block([{set,Ds,Ss,{alloc,Live0,AllocOp}}|Is], Regs0, D, Acc) ->
-    %% Calculate liveness from the point of view of the GC.
-    %% There will never be a GC if the instruction fails, so we should
-    %% ignore the failure branch.
-    GcRegs1 = x_dead(Ds, Regs0),
-    GcRegs = x_live(Ss, GcRegs1),
-    Live = live_regs(GcRegs),
-
-    %% The life-time analysis used by the code generator is sometimes too
-    %% conservative, so it may be possible to lower the number of live
-    %% registers based on the exact liveness information. The main benefit is
-    %% that more optimizations that depend on liveness information (such as the
-    %% beam_dead pass) may be applied.
-    true = Live =< Live0,                       %Assertion.
-    I = {set,Ds,Ss,{alloc,Live,AllocOp}},
-
-    %% Calculate liveness from the point of view of the preceding instruction.
-    %% The liveness is the union of live registers in the GC and the live
-    %% registers at the failure label.
-    Regs1 = live_call(Live),
-    Regs = live_join_alloc(AllocOp, D, Regs1),
-    live_opt_block(Is, Regs, D, [I|Acc]);
-live_opt_block([{set,Ds,Ss,{bif,_,Fail}}=I|Is], Regs0, D, Acc) ->
-    Regs1 = x_dead(Ds, Regs0),
-    Regs2 = x_live(Ss, Regs1),
-    Regs = live_join_label(Fail, D, Regs2),
-    live_opt_block(Is, Regs, D, [I|Acc]);
-live_opt_block([{set,Ds,Ss,_}=I|Is], Regs0, D, Acc) ->
-    Regs = x_live(Ss, x_dead(Ds, Regs0)),
-    live_opt_block(Is, Regs, D, [I|Acc]);
-live_opt_block([{'%anno',_}|Is], Regs, D, Acc) ->
-    live_opt_block(Is, Regs, D, Acc);
-live_opt_block([], Regs, _, Acc) -> {Acc,Regs}.
-
-live_join_alloc({Kind,_Name,Fail}, D, Regs) when Kind =:= gc_bif; Kind =:= put_map ->
-    live_join_label(Fail, D, Regs);
-live_join_alloc(_, _, Regs) -> Regs.
-
-live_join_labels([{f,L}|T], D, Regs0) when L =/= 0 ->
-    Regs = gb_trees:get(L, D) bor Regs0,
-    live_join_labels(T, D, Regs);
-live_join_labels([_|T], D, Regs) ->
-    live_join_labels(T, D, Regs);
-live_join_labels([], _, Regs) -> Regs.
-
-live_join_label({f,0}, _, Regs) ->
-    Regs;
-live_join_label({f,L}, D, Regs) ->
-    gb_trees:get(L, D) bor Regs.
-
-live_call(Live) -> (1 bsl Live) - 1.
-
-live_regs(Regs) ->
-    live_regs_1(0, Regs).
-
-live_regs_1(N, 0) -> N;
-live_regs_1(N, Regs) -> live_regs_1(N+1, Regs bsr 1).
-
-x_dead([{x,N}|Rs], Regs) -> x_dead(Rs, Regs band (bnot (1 bsl N)));
-x_dead([_|Rs], Regs) -> x_dead(Rs, Regs);
-x_dead([], Regs) -> Regs.
-
-x_live([{x,N}|Rs], Regs) -> x_live(Rs, Regs bor (1 bsl N));
-x_live([_|Rs], Regs) -> x_live(Rs, Regs);
-x_live([], Regs) -> Regs.
-
-is_live(X, Regs) -> ((Regs bsr X) band 1) =:= 1.
-
 split_even([], Ss, Ds) ->
     {reverse(Ss),reverse(Ds)};
 split_even([S,D|Rs], Ss, Ds) ->
     split_even(Rs, [S|Ss], [D|Ds]).
-
-%%%
-%%% Add annotations for defined registers.
-%%%
-%%% This analysis is done by scanning the instructions in
-%%% execution order.
-%%%
-
-defs([{apply,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([{bif,_,{f,Fail},_Src,Dst}=I|Is], Regs0, D) ->
-    Regs = def_regs([Dst], Regs0),
-    [I|defs(Is, Regs, update_regs(Fail, Regs0, D))];
-defs([{block,Block0}|Is], Regs0, D0) ->
-    {Block,Regs,D} = defs_list(Block0, Regs0, D0),
-    [{block,[make_anno({def,Regs0})|Block]}|defs(Is, Regs, D)];
-defs([{bs_init,{f,L},_,Live,_,Dst}=I|Is], Regs0, D) ->
-    Regs1 = case Live of
-                none -> Regs0;
-                _ -> init_def_regs(Live)
-            end,
-    Regs = def_regs([Dst], Regs1),
-    [I|defs(Is, Regs, update_regs(L, Regs, D))];
-defs([{bs_put,{f,L},_,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, update_regs(L, Regs, D))];
-defs([build_stacktrace=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([{call,_,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([{call_ext,_,{extfunc,M,F,A}}=I|Is], _Regs, D) ->
-    case erl_bifs:is_exit_bif(M, F, A) of
-        false ->
-            [I|defs(Is, 1, D)];
-        true ->
-            [I|defs_unreachable(Is, D)]
-    end;
-defs([{call_ext,_,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([{call_fun,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([{'catch',_,{f,L}}=I|Is], Regs, D) ->
-    RegsAtLabel = init_def_regs(1),
-    [I|defs(Is, Regs, update_regs(L, RegsAtLabel, D))];
-defs([{catch_end,_}=I|Is], _Regs, D) ->
-    Regs = init_def_regs(1),
-    [I|defs(Is, Regs, D)];
-defs([{gc_bif,_,{f,Fail},Live,_Src,Dst}=I|Is], Regs0, D) ->
-    true = all_defined(Live, Regs0),            %Assertion.
-    Regs = def_regs([Dst], init_def_regs(Live)),
-    [I|defs(Is, Regs, update_regs(Fail, Regs0, D))];
-defs([{get_map_elements,{f,L},_Src,{list,DstList}}=I|Is], Regs0, D) ->
-    {_,Ds} = beam_utils:split_even(DstList),
-    Regs = def_regs(Ds, Regs0),
-    [I|defs(Is, Regs, update_regs(L, Regs0, D))];
-defs([{get_tuple_element,_,_,Dst}=I|Is], Regs0, D) ->
-    Regs = def_regs([Dst], Regs0),
-    [I|defs(Is, Regs, D)];
-defs([{jump,{f,L}}=I|Is], Regs, D) ->
-    [I|defs_unreachable(Is, update_regs(L, Regs, D))];
-defs([{label,L}=I|Is], Regs0, D) ->
-    case D of
-        #{L:=Regs1} ->
-            Regs = Regs0 band Regs1,
-            [I|defs(Is, Regs, D)];
-        #{} ->
-            [I|defs(Is, Regs0, D)]
-    end;
-defs([{loop_rec,{f,L},{x,0}}=I|Is], _Regs, D0) ->
-    RegsAtLabel = init_def_regs(0),
-    D = update_regs(L, RegsAtLabel, D0),
-    [I|defs(Is, init_def_regs(1), D)];
-defs([{loop_rec_end,_}=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-defs([{make_fun2,_,_,_,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([{move,_,Dst}=I|Is], Regs0, D) ->
-    Regs = def_regs([Dst], Regs0),
-    [I|defs(Is, Regs, D)];
-defs([{put_map,{f,Fail},_,_,Dst,_,_}=I|Is], Regs0, D) ->
-    Regs = def_regs([Dst], Regs0),
-    [I|defs(Is, Regs, update_regs(Fail, Regs0, D))];
-defs([raw_raise=I|Is], _Regs, D) ->
-    [I|defs(Is, 1, D)];
-defs([return=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-defs([{select,_,_Src,Fail,List}=I|Is], Regs, D0) ->
-    D = update_list([Fail|List], Regs, D0),
-    [I|defs_unreachable(Is, D)];
-defs([{test,_,{f,L},_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, update_regs(L, Regs, D))];
-defs([{test,_,{f,L},Live,_,Dst}=I|Is], Regs0, D) ->
-    true = all_defined(Live, Regs0),             %Assertion.
-    Regs = def_regs([Dst], init_def_regs(Live)),
-    [I|defs(Is, Regs, update_regs(L, Regs0, D))];
-defs([{'try',_,{f,L}}=I|Is], Regs, D) ->
-    RegsAtLabel = init_def_regs(3),
-    [I|defs(Is, Regs, update_regs(L, RegsAtLabel, D))];
-defs([{try_case,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, init_def_regs(3), D)];
-defs([{wait,_}=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-defs([{wait_timeout,_,_}=I|Is], _Regs, D) ->
-    [I|defs(Is, 0, D)];
-
-%% Exceptions.
-defs([{badmatch,_}=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-defs([{case_end,_}=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-defs([if_end=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-defs([{try_case_end,_}=I|Is], _Regs, D) ->
-    [I|defs_unreachable(Is, D)];
-
-%% Neutral instructions
-defs([{bs_context_to_binary,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{bs_restore2,_,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{bs_save2,_,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{deallocate,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{kill,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{line,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{recv_mark,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{recv_set,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([timeout=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{trim,_,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{try_end,_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([{'%',_}=I|Is], Regs, D) ->
-    [I|defs(Is, Regs, D)];
-defs([], _, _) -> [].
-
-defs_unreachable([{label,L}=I|Is], D) ->
-    case D of
-        #{L:=Regs} ->
-            [I|defs(Is, Regs, D)];
-        #{} ->
-            defs_unreachable(Is, D)
-    end;
-defs_unreachable([_|Is], D) ->
-    defs_unreachable(Is, D);
-defs_unreachable([], _D) -> [].
-
-defs_list(Is, Regs, D) ->
-    defs_list(Is, Regs, D, []).
-
-defs_list([{set,Ds,_,{alloc,Live,Info}}=I|Is], Regs0, D0, Acc) ->
-    true = all_defined(Live, Regs0),             %Assertion.
-    D = case Info of
-            {gc_bif,_,{f,Fail}} ->
-                update_regs(Fail, Regs0, D0);
-            {put_map,_,{f,Fail}} ->
-                update_regs(Fail, Regs0, D0);
-            _ ->
-                D0
-        end,
-    Regs = def_regs(Ds, init_def_regs(Live)),
-    defs_list(Is, Regs, D, [I|Acc]);
-defs_list([{set,Ds,_,Info}=I|Is], Regs0, D0, Acc) ->
-    D = case Info of
-            {bif,_,{f,Fail}} ->
-                update_regs(Fail, Regs0, D0);
-            {try_catch,'catch',{f,Fail}} ->
-                update_regs(Fail, init_def_regs(1), D0);
-            {try_catch,'try',{f,Fail}} ->
-                update_regs(Fail, init_def_regs(3), D0);
-            _ ->
-                D0
-        end,
-    Regs = def_regs(Ds, Regs0),
-    defs_list(Is, Regs, D, [I|Acc]);
-defs_list([], Regs, D, Acc) ->
-    {reverse(Acc),Regs,D}.
-
-init_def_regs(Arity) ->
-    (1 bsl Arity) - 1.
-
-def_regs([{x,X}|T], Regs) ->
-    def_regs(T, Regs bor (1 bsl X));
-def_regs([_|T], Regs) ->
-    def_regs(T, Regs);
-def_regs([], Regs) -> Regs.
-
-update_list([{f,L}|T], Regs, D0) ->
-    D = update_regs(L, Regs, D0),
-    update_list(T, Regs, D);
-update_list([_|T], Regs, D) ->
-    update_list(T, Regs, D);
-update_list([], _Regs, D) -> D.
-
-update_regs(L, Regs0, D) ->
-    case D of
-        #{L:=Regs1} ->
-            Regs = Regs0 band Regs1,
-            D#{L:=Regs};
-        #{} ->
-            D#{L=>Regs0}
-    end.
-
-all_defined(Live, Regs) ->
-    All = (1 bsl Live) - 1,
-    Regs band All =:= All.
-
-%%%
-%%% Utilities.
-%%%
-
-%% make_anno(Anno) -> WrappedAnno.
-%%  Wrap an annotation term.
-
-make_anno(Anno) ->
-    {'%anno',Anno}.
diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index e1c1f7338e..5fdea23a26 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -751,16 +751,12 @@ asm_passes() ->
       [{pass,beam_a},
        {iff,da,{listing,"a"}},
        {unless,no_postopt,
-	[{unless,no_reorder,{pass,beam_reorder}},
-	 {iff,dre,{listing,"reorder"}},
-	 {pass,beam_block},
+	[{pass,beam_block},
 	 {iff,dblk,{listing,"block"}},
 	 {unless,no_except,{pass,beam_except}},
 	 {iff,dexcept,{listing,"except"}},
 	 {unless,no_bs_opt,{pass,beam_bs}},
 	 {iff,dbs,{listing,"bs"}},
-	 {unless,no_topt,{pass,beam_type}},
-	 {iff,dtype,{listing,"type"}},
 	 {pass,beam_split},
 	 {iff,dsplit,{listing,"split"}},
 	 {unless,no_dead,{pass,beam_dead}},
@@ -773,12 +769,6 @@ asm_passes() ->
 	 {iff,dclean,{listing,"clean"}},
 	 {unless,no_bsm_opt,{pass,beam_bsm}},
 	 {iff,dbsm,{listing,"bsm"}},
-	 {unless,no_recv_opt,{pass,beam_receive}},
-	 {iff,drecv,{listing,"recv"}},
-	 {unless,no_record_opt,{pass,beam_record}},
-	 {iff,drecord,{listing,"record"}},
-         {unless,no_blk2,?pass(block2)},
-	 {iff,dblk2,{listing,"block2"}},
 	 {unless,no_stack_trimming,{pass,beam_trim}},
 	 {iff,dtrim,{listing,"trim"}},
 	 {pass,beam_flatten}]},
@@ -1354,10 +1344,6 @@ v3_kernel(Code0, #compile{options=Opts,warnings=Ws0}=St) ->
 	    {ok,Code,St}
     end.
 
-block2(Code0, #compile{options=Opts}=St) ->
-    {ok,Code} = beam_block:module(Code0, [no_blockify|Opts]),
-    {ok,Code,St}.
-
 test_old_inliner(#compile{options=Opts}) ->
     %% The point of this test is to avoid loading the old inliner
     %% if we know that it will not be used.
@@ -1974,12 +1960,8 @@ pre_load() ->
 	 beam_jump,
 	 beam_opcodes,
 	 beam_peep,
-	 beam_receive,
-         beam_record,
-	 beam_reorder,
 	 beam_split,
 	 beam_trim,
-	 beam_type,
 	 beam_utils,
 	 beam_validator,
 	 beam_z,
diff --git a/lib/compiler/src/compiler.app.src b/lib/compiler/src/compiler.app.src
index cf32fd251c..9fa5a1c6ea 100644
--- a/lib/compiler/src/compiler.app.src
+++ b/lib/compiler/src/compiler.app.src
@@ -36,12 +36,8 @@
 	     beam_listing,
 	     beam_opcodes,
 	     beam_peep,
-	     beam_receive,
-	     beam_reorder,
-	     beam_record,
 	     beam_split,
 	     beam_trim,
-	     beam_type,
 	     beam_utils,
 	     beam_validator,
 	     beam_z,