Merge pull request #2126 from bjorng/bjorn/compiler/compilation-speed

Reduce compilation times

7 files changed, 177 insertions, 156 deletions

diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl
index b491e340b7..9c29c98064 100644
--- a/lib/compiler/src/beam_ssa.erl
+++ b/lib/compiler/src/beam_ssa.erl
@@ -142,7 +142,7 @@ add_anno(Key, Val, #b_switch{anno=Anno}=Bl) ->
 -spec get_anno(atom(), construct()) -> any().
 
 get_anno(Key, Construct) ->
-    maps:get(Key, get_anno(Construct)).
+    map_get(Key, get_anno(Construct)).
 
 -spec get_anno(atom(), construct(),any()) -> any().
 
@@ -303,7 +303,7 @@ normalize(#b_ret{}=Ret) ->
 -spec successors(label(), block_map()) -> [label()].
 
 successors(L, Blocks) ->
-    successors(maps:get(L, Blocks)).
+    successors(map_get(L, Blocks)).
 
 -spec def(Ls, Blocks) -> Def when
       Ls :: [label()],
@@ -312,7 +312,7 @@ successors(L, Blocks) ->
 
 def(Ls, Blocks) ->
     Top = rpo(Ls, Blocks),
-    Blks = [maps:get(L, Blocks) || L <- Top],
+    Blks = [map_get(L, Blocks) || L <- Top],
     def_1(Blks, []).
 
 -spec def_used(Ls, Blocks) -> {Def,Used} when
@@ -323,9 +323,9 @@ def(Ls, Blocks) ->
 
 def_used(Ls, Blocks) ->
     Top = rpo(Ls, Blocks),
-    Blks = [maps:get(L, Blocks) || L <- Top],
-    Preds = gb_sets:from_list(Top),
-    def_used_1(Blks, Preds, [], gb_sets:empty()).
+    Blks = [map_get(L, Blocks) || L <- Top],
+    Preds = cerl_sets:from_list(Top),
+    def_used_1(Blks, Preds, [], []).
 
 -spec dominators(Blocks) -> Result when
       Blocks :: block_map(),
@@ -334,7 +334,7 @@ def_used(Ls, Blocks) ->
 dominators(Blocks) ->
     Preds = predecessors(Blocks),
     Top0 = rpo(Blocks),
-    Top = [{L,maps:get(L, Preds)} || L <- Top0],
+    Top = [{L,map_get(L, Preds)} || L <- Top0],
 
     %% The flow graph for an Erlang function is reducible, and
     %% therefore one traversal in reverse postorder is sufficient.
@@ -365,9 +365,9 @@ mapfold_blocks_rpo(Fun, From, Acc, Blocks) ->
           end, {Blocks, Acc}, Successors).
 
 mapfold_blocks_rpo_1(Fun, Lbl, {Blocks0, Acc0}) ->
-    Block0 = maps:get(Lbl, Blocks0),
+    Block0 = map_get(Lbl, Blocks0),
     {Block, Acc} = Fun(Lbl, Block0, Acc0),
-    Blocks = maps:put(Lbl, Block, Blocks0),
+    Blocks = Blocks0#{Lbl:=Block},
     {Blocks, Acc}.
 
 -spec mapfold_instrs_rpo(Fun, From, Acc0, Blocks0) -> {Blocks,Acc} when
@@ -581,7 +581,7 @@ used(_) -> [].
 -spec definitions(Blocks :: block_map()) -> definition_map().
 definitions(Blocks) ->
     fold_instrs_rpo(fun(#b_set{ dst = Var }=I, Acc) ->
-                            maps:put(Var, I, Acc);
+                            Acc#{Var => I};
                        (_Terminator, Acc) ->
                             Acc
                     end, [0], #{}, Blocks).
@@ -626,10 +626,10 @@ is_commutative(_) -> false.
 
 def_used_1([#b_blk{is=Is,last=Last}|Bs], Preds, Def0, Used0) ->
     {Def,Used1} = def_used_is(Is, Preds, Def0, Used0),
-    Used = gb_sets:union(gb_sets:from_list(used(Last)), Used1),
+    Used = ordsets:union(used(Last), Used1),
     def_used_1(Bs, Preds, Def, Used);
 def_used_1([], _Preds, Def, Used) ->
-    {ordsets:from_list(Def),gb_sets:to_list(Used)}.
+    {ordsets:from_list(Def),Used}.
 
 def_used_is([#b_set{op=phi,dst=Dst,args=Args}|Is],
             Preds, Def0, Used0) ->
@@ -637,12 +637,12 @@ def_used_is([#b_set{op=phi,dst=Dst,args=Args}|Is],
     %% We must be careful to only include variables that will
     %% be used when arriving from one of the predecessor blocks
     %% in Preds.
-    Used1 = [V || {#b_var{}=V,L} <- Args, gb_sets:is_member(L, Preds)],
-    Used = gb_sets:union(gb_sets:from_list(Used1), Used0),
+    Used1 = [V || {#b_var{}=V,L} <- Args, cerl_sets:is_element(L, Preds)],
+    Used = ordsets:union(ordsets:from_list(Used1), Used0),
     def_used_is(Is, Preds, Def, Used);
 def_used_is([#b_set{dst=Dst}=I|Is], Preds, Def0, Used0) ->
     Def = [Dst|Def0],
-    Used = gb_sets:union(gb_sets:from_list(used(I)), Used0),
+    Used = ordsets:union(used(I), Used0),
     def_used_is(Is, Preds, Def, Used);
 def_used_is([], _Preds, Def, Used) ->
     {Def,Used}.
@@ -661,40 +661,40 @@ iter_dominators([{0,[]}|Ls], _Doms) ->
     Dom = [0],
     iter_dominators(Ls, #{0=>Dom});
 iter_dominators([{L,Preds}|Ls], Doms) ->
-    DomPreds = [maps:get(P, Doms) || P <- Preds, maps:is_key(P, Doms)],
+    DomPreds = [map_get(P, Doms) || P <- Preds, is_map_key(P, Doms)],
     Dom = ordsets:add_element(L, ordsets:intersection(DomPreds)),
     iter_dominators(Ls, Doms#{L=>Dom});
 iter_dominators([], Doms) -> Doms.
 
 fold_rpo_1([L|Ls], Fun, Blocks, Acc0) ->
-    Block = maps:get(L, Blocks),
+    Block = map_get(L, Blocks),
     Acc = Fun(L, Block, Acc0),
     fold_rpo_1(Ls, Fun, Blocks, Acc);
 fold_rpo_1([], _, _, Acc) -> Acc.
 
 fold_instrs_rpo_1([L|Ls], Fun, Blocks, Acc0) ->
-    #b_blk{is=Is,last=Last} = maps:get(L, Blocks),
+    #b_blk{is=Is,last=Last} = map_get(L, Blocks),
     Acc1 = foldl(Fun, Acc0, Is),
     Acc = Fun(Last, Acc1),
     fold_instrs_rpo_1(Ls, Fun, Blocks, Acc);
 fold_instrs_rpo_1([], _, _, Acc) -> Acc.
 
 mapfold_instrs_rpo_1([L|Ls], Fun, Blocks0, Acc0) ->
-    #b_blk{is=Is0,last=Last0} = Block0 = maps:get(L, Blocks0),
+    #b_blk{is=Is0,last=Last0} = Block0 = map_get(L, Blocks0),
     {Is,Acc1} = mapfoldl(Fun, Acc0, Is0),
     {Last,Acc} = Fun(Last0, Acc1),
     Block = Block0#b_blk{is=Is,last=Last},
-    Blocks = maps:put(L, Block, Blocks0),
+    Blocks = Blocks0#{L:=Block},
     mapfold_instrs_rpo_1(Ls, Fun, Blocks, Acc);
 mapfold_instrs_rpo_1([], _, Blocks, Acc) ->
     {Blocks,Acc}.
 
 flatmapfold_instrs_rpo_1([L|Ls], Fun, Blocks0, Acc0) ->
-    #b_blk{is=Is0,last=Last0} = Block0 = maps:get(L, Blocks0),
+    #b_blk{is=Is0,last=Last0} = Block0 = map_get(L, Blocks0),
     {Is,Acc1} = flatmapfoldl(Fun, Acc0, Is0),
     {[Last],Acc} = Fun(Last0, Acc1),
     Block = Block0#b_blk{is=Is,last=Last},
-    Blocks = maps:put(L, Block, Blocks0),
+    Blocks = Blocks0#{L:=Block},
     flatmapfold_instrs_rpo_1(Ls, Fun, Blocks, Acc);
 flatmapfold_instrs_rpo_1([], _, Blocks, Acc) ->
     {Blocks,Acc}.
@@ -705,7 +705,7 @@ linearize_1([L|Ls], Blocks, Seen0, Acc0) ->
             linearize_1(Ls, Blocks, Seen0, Acc0);
         false ->
             Seen1 = cerl_sets:add_element(L, Seen0),
-            Block = maps:get(L, Blocks),
+            Block = map_get(L, Blocks),
             Successors = successors(Block),
             {Acc,Seen} = linearize_1(Successors, Blocks, Seen1, Acc0),
             linearize_1(Ls, Blocks, Seen, [{L,Block}|Acc])
@@ -745,7 +745,7 @@ rpo_1([L|Ls], Blocks, Seen0, Acc0) ->
         true ->
             rpo_1(Ls, Blocks, Seen0, Acc0);
         false ->
-            Block = maps:get(L, Blocks),
+            Block = map_get(L, Blocks),
             Seen1 = cerl_sets:add_element(L, Seen0),
             Successors = successors(Block),
             {Acc,Seen} = rpo_1(Successors, Blocks, Seen1, Acc0),
@@ -775,11 +775,11 @@ rename_phi_vars([{Var,L}|As], Preds, Ren) ->
 rename_phi_vars([], _, _) -> [].
 
 map_instrs_1([L|Ls], Fun, Blocks0) ->
-    #b_blk{is=Is0,last=Last0} = Blk0 = maps:get(L, Blocks0),
+    #b_blk{is=Is0,last=Last0} = Blk0 = map_get(L, Blocks0),
     Is = [Fun(I) || I <- Is0],
     Last = Fun(Last0),
     Blk = Blk0#b_blk{is=Is,last=Last},
-    Blocks = maps:put(L, Blk, Blocks0),
+    Blocks = Blocks0#{L:=Blk},
     map_instrs_1(Ls, Fun, Blocks);
 map_instrs_1([], _, Blocks) -> Blocks.
 
@@ -790,7 +790,7 @@ flatmapfoldl(F, Accu0, [Hd|Tail]) ->
 flatmapfoldl(_, Accu, []) -> {[],Accu}.
 
 split_blocks_1([L|Ls], P, Blocks0, Count0) ->
-    #b_blk{is=Is0} = Blk = maps:get(L, Blocks0),
+    #b_blk{is=Is0} = Blk = map_get(L, Blocks0),
     case split_blocks_is(Is0, P, []) of
         {yes,Bef,Aft} ->
             NewLbl = Count0,
diff --git a/lib/compiler/src/beam_ssa_dead.erl b/lib/compiler/src/beam_ssa_dead.erl
index 09b29025c6..2cca9ebadf 100644
--- a/lib/compiler/src/beam_ssa_dead.erl
+++ b/lib/compiler/src/beam_ssa_dead.erl
@@ -375,7 +375,7 @@ is_forbidden(L, St) ->
 %% any instruction with potential side effects.
 
 eval_is([#b_set{op=phi,dst=Dst,args=Args}|Is], Bs0, St) ->
-    From = maps:get(from, Bs0),
+    From = map_get(from, Bs0),
     [Val] = [Val || {Val,Pred} <- Args, Pred =:= From],
     Bs = bind_var(Dst, Val, Bs0),
     eval_is(Is, Bs, St);
@@ -826,7 +826,7 @@ combine_eqs_1([L|Ls], #st{bs=Blocks0}=St0) ->
                             %% Everything OK! Combine the lists.
                             Sw0 = #b_switch{arg=Arg,fail=Fail,list=List},
                             Sw = beam_ssa:normalize(Sw0),
-                            Blk0 = maps:get(L, Blocks0),
+                            Blk0 = map_get(L, Blocks0),
                             Blk = Blk0#b_blk{last=Sw},
                             Blocks = Blocks0#{L:=Blk},
                             St = St0#st{bs=Blocks},
@@ -850,8 +850,8 @@ combine_eqs_1([], St) -> St.
 comb_get_sw(L, Blocks) ->
     comb_get_sw(L, true, Blocks).
 
-comb_get_sw(L, Safe0, #st{bs=Blocks,skippable=Skippable}=St) ->
-    #b_blk{is=Is,last=Last} = maps:get(L, Blocks),
+comb_get_sw(L, Safe0, #st{bs=Blocks,skippable=Skippable}) ->
+    #b_blk{is=Is,last=Last} = map_get(L, Blocks),
     Safe1 = Safe0 andalso is_map_key(L, Skippable),
     case Last of
         #b_ret{} ->
@@ -865,8 +865,8 @@ comb_get_sw(L, Safe0, #st{bs=Blocks,skippable=Skippable}=St) ->
                 {#b_set{},_} ->
                     none
             end;
-        #b_br{bool=#b_literal{val=true},succ=Succ} ->
-            comb_get_sw(Succ, Safe1, St);
+        #b_br{} ->
+            none;
         #b_switch{arg=#b_var{}=Arg,fail=Fail,list=List} ->
             {none,Safe} = comb_is(Is, none, Safe1),
             {Safe,Arg,L,Fail,List}
@@ -946,7 +946,7 @@ used_vars([{L,#b_blk{is=Is}=Blk}|Bs], UsedVars0, Skip0) ->
     %% shortcut_opt/1.
 
     Successors = beam_ssa:successors(Blk),
-    Used0 = used_vars_succ(Successors, L, UsedVars0),
+    Used0 = used_vars_succ(Successors, L, UsedVars0, []),
     Used = used_vars_blk(Blk, Used0),
     UsedVars = used_vars_phis(Is, L, Used, UsedVars0),
 
@@ -969,19 +969,22 @@ used_vars([{L,#b_blk{is=Is}=Blk}|Bs], UsedVars0, Skip0) ->
 used_vars([], UsedVars, Skip) ->
     {UsedVars,Skip}.
 
-used_vars_succ([S|Ss], L, UsedVars) ->
-    Live0 = used_vars_succ(Ss, L, UsedVars),
+used_vars_succ([S|Ss], L, LiveMap, Live0) ->
     Key = {S,L},
-    case UsedVars of
+    case LiveMap of
         #{Key:=Live} ->
-            ordsets:union(Live, Live0);
+            %% The successor has a phi node, and the value for
+            %% this block in the phi node is a variable.
+            used_vars_succ(Ss, L, LiveMap, ordsets:union(Live, Live0));
         #{S:=Live} ->
-            ordsets:union(Live, Live0);
+            %% No phi node in the successor, or the value for
+            %% this block in the phi node is a literal.
+            used_vars_succ(Ss, L, LiveMap, ordsets:union(Live, Live0));
         #{} ->
-            Live0
+            %% A peek_message block which has not been processed yet.
+            used_vars_succ(Ss, L, LiveMap, Live0)
     end;
-used_vars_succ([], _, _) ->
-    ordsets:new().
+used_vars_succ([], _, _, Acc) -> Acc.
 
 used_vars_phis(Is, L, Live0, UsedVars0) ->
     UsedVars = UsedVars0#{L=>Live0},
diff --git a/lib/compiler/src/beam_ssa_funs.erl b/lib/compiler/src/beam_ssa_funs.erl
index 38df50fd74..e77c00fa89 100644
--- a/lib/compiler/src/beam_ssa_funs.erl
+++ b/lib/compiler/src/beam_ssa_funs.erl
@@ -47,14 +47,14 @@ module(#b_module{body=Fs0}=Module, _Opts) ->
 %% the same arguments in the same order, we can shave off a call by short-
 %% circuiting it.
 find_trampolines(#b_function{args=Args,bs=Blocks}=F, Trampolines) ->
-    case maps:get(0, Blocks) of
+    case map_get(0, Blocks) of
         #b_blk{is=[#b_set{op=call,
                           args=[#b_local{}=Actual | Args],
                           dst=Dst}],
                last=#b_ret{arg=Dst}} ->
             {_, Name, Arity} = beam_ssa:get_anno(func_info, F),
             Trampoline = #b_local{name=#b_literal{val=Name},arity=Arity},
-            maps:put(Trampoline, Actual, Trampolines);
+            Trampolines#{Trampoline => Actual};
         _ ->
             Trampolines
     end.
@@ -80,7 +80,7 @@ lfo_analyze_is([#b_set{op=make_fun,
 lfo_analyze_is([#b_set{op=call,
                        args=[Fun | CallArgs]} | Is],
                LFuns) when is_map_key(Fun, LFuns) ->
-    #b_set{args=[#b_local{arity=Arity} | FreeVars]} = maps:get(Fun, LFuns),
+    #b_set{args=[#b_local{arity=Arity} | FreeVars]} = map_get(Fun, LFuns),
     case length(CallArgs) + length(FreeVars) of
         Arity ->
             lfo_analyze_is(Is, maps:without(CallArgs, LFuns));
@@ -133,7 +133,7 @@ lfo_optimize_1([], _LFuns, _Trampolines) ->
 lfo_optimize_is([#b_set{op=call,
                         args=[Fun | CallArgs]}=Call0 | Is],
                 LFuns, Trampolines) when is_map_key(Fun, LFuns) ->
-    #b_set{args=[Local | FreeVars]} = maps:get(Fun, LFuns),
+    #b_set{args=[Local | FreeVars]} = map_get(Fun, LFuns),
     Args = [lfo_short_circuit(Local, Trampolines) | CallArgs ++ FreeVars],
     Call = beam_ssa:add_anno(local_fun_opt, Fun, Call0#b_set{args=Args}),
     [Call | lfo_optimize_is(Is, LFuns, Trampolines)];
diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl
index e528bb4dfb..ca5eefe4fc 100644
--- a/lib/compiler/src/beam_ssa_opt.erl
+++ b/lib/compiler/src/beam_ssa_opt.erl
@@ -362,7 +362,7 @@ ssa_opt_coalesce_phis({#st{ssa=Blocks0}=St, FuncDb}) ->
     {St#st{ssa=Blocks}, FuncDb}.
 
 c_phis_1([L|Ls], Blocks0) ->
-    case maps:get(L, Blocks0) of
+    case map_get(L, Blocks0) of
         #b_blk{is=[#b_set{op=phi}|_]}=Blk ->
             Blocks = c_phis_2(L, Blk, Blocks0),
             c_phis_1(Ls, Blocks);
@@ -401,7 +401,7 @@ c_phis_args_1([{Var,Pred}|As], Blocks) ->
 c_phis_args_1([], _Blocks) -> none.
 
 c_get_pred_vars(Var, Pred, Blocks) ->
-    case maps:get(Pred, Blocks) of
+    case map_get(Pred, Blocks) of
         #b_blk{is=[#b_set{op=phi,dst=Var,args=Args}]} ->
             {Var,Pred,Args};
         #b_blk{} ->
@@ -422,7 +422,7 @@ c_rewrite_phi([A|As], Info) ->
 c_rewrite_phi([], _Info) -> [].
 
 c_fix_branches([{_,Pred}|As], L, Blocks0) ->
-    #b_blk{last=Last0} = Blk0 = maps:get(Pred, Blocks0),
+    #b_blk{last=Last0} = Blk0 = map_get(Pred, Blocks0),
     #b_br{bool=#b_literal{val=true}} = Last0,   %Assertion.
     Last = Last0#b_br{bool=#b_literal{val=true},succ=L,fail=L},
     Blk = Blk0#b_blk{last=Last},
@@ -692,7 +692,7 @@ record_opt_is([], _Last, _Blocks) -> [].
 is_tagged_tuple(#b_var{}=Tuple, Bool,
                 #b_br{bool=Bool,succ=Succ,fail=Fail},
                 Blocks) ->
-    SuccBlk = maps:get(Succ, Blocks),
+    SuccBlk = map_get(Succ, Blocks),
     is_tagged_tuple_1(SuccBlk, Tuple, Fail, Blocks);
 is_tagged_tuple(_, _, _, _) -> no.
 
@@ -706,7 +706,7 @@ is_tagged_tuple_1(#b_blk{is=Is,last=Last}, Tuple, Fail, Blocks) ->
         when is_integer(ArityVal) ->
             case Last of
                 #b_br{bool=Bool,succ=Succ,fail=Fail} ->
-                    SuccBlk = maps:get(Succ, Blocks),
+                    SuccBlk = map_get(Succ, Blocks),
                     case is_tagged_tuple_2(SuccBlk, Tuple, Fail) of
                         no ->
                             no;
@@ -757,7 +757,7 @@ ssa_opt_cse({#st{ssa=Linear}=St, FuncDb}) ->
     {St#st{ssa=cse(Linear, #{}, M)}, FuncDb}.
 
 cse([{L,#b_blk{is=Is0,last=Last0}=Blk}|Bs], Sub0, M0) ->
-    Es0 = maps:get(L, M0),
+    Es0 = map_get(L, M0),
     {Is1,Es,Sub} = cse_is(Is0, Es0, Sub0, []),
     Last = sub(Last0, Sub),
     M = cse_successors(Is1, Blk, Es, M0),
@@ -1002,7 +1002,7 @@ float_conv([{L,#b_blk{is=Is0}=Blk0}|Bs0], Fail, Count0) ->
 
 float_maybe_flush(Blk0, #fs{s=cleared,fail=Fail,bs=Blocks}=Fs0, Count0) ->
     #b_blk{last=#b_br{bool=#b_var{},succ=Succ}=Br} = Blk0,
-    #b_blk{is=Is} = maps:get(Succ, Blocks),
+    #b_blk{is=Is} = map_get(Succ, Blocks),
     case Is of
         [#b_set{anno=#{float_op:=_}}|_] ->
             %% The next operation is also a floating point operation.
@@ -1149,25 +1149,28 @@ ssa_opt_live({#st{ssa=Linear0}=St, FuncDb}) ->
 live_opt([{L,Blk0}|Bs], LiveMap0, Blocks) ->
     Blk1 = beam_ssa_share:block(Blk0, Blocks),
     Successors = beam_ssa:successors(Blk1),
-    Live0 = live_opt_succ(Successors, L, LiveMap0),
+    Live0 = live_opt_succ(Successors, L, LiveMap0, gb_sets:empty()),
     {Blk,Live} = live_opt_blk(Blk1, Live0),
     LiveMap = live_opt_phis(Blk#b_blk.is, L, Live, LiveMap0),
     live_opt(Bs, LiveMap, Blocks#{L:=Blk});
 live_opt([], _, Acc) -> Acc.
 
-live_opt_succ([S|Ss], L, LiveMap) ->
-    Live0 = live_opt_succ(Ss, L, LiveMap),
+live_opt_succ([S|Ss], L, LiveMap, Live0) ->
     Key = {S,L},
     case LiveMap of
         #{Key:=Live} ->
-            gb_sets:union(Live, Live0);
+            %% The successor has a phi node, and the value for
+            %% this block in the phi node is a variable.
+            live_opt_succ(Ss, L, LiveMap, gb_sets:union(Live, Live0));
         #{S:=Live} ->
-            gb_sets:union(Live, Live0);
+            %% No phi node in the successor, or the value for
+            %% this block in the phi node is a literal.
+            live_opt_succ(Ss, L, LiveMap, gb_sets:union(Live, Live0));
         #{} ->
-            Live0
+            %% A peek_message block which has not been processed yet.
+            live_opt_succ(Ss, L, LiveMap, Live0)
     end;
-live_opt_succ([], _, _) ->
-    gb_sets:empty().
+live_opt_succ([], _, _, Acc) -> Acc.
 
 live_opt_phis(Is, L, Live0, LiveMap0) ->
     LiveMap = LiveMap0#{L=>Live0},
@@ -1218,7 +1221,7 @@ live_opt_is([#b_set{op=succeeded,dst=SuccDst=SuccDstVar,
                     case gb_sets:is_member(SuccDst, Live0) of
                         true ->
                             Live1 = gb_sets:add(Dst, Live0),
-                            Live = gb_sets:delete_any(SuccDst, Live1),
+                            Live = gb_sets:delete(SuccDst, Live1),
                             live_opt_is([I|Is], Live, [SuccI|Acc]);
                         false ->
                             live_opt_is([I|Is], Live0, Acc)
@@ -1229,7 +1232,7 @@ live_opt_is([#b_set{dst=Dst}=I|Is], Live0, Acc) ->
     case gb_sets:is_member(Dst, Live0) of
         true ->
             Live1 = gb_sets:union(Live0, gb_sets:from_ordset(beam_ssa:used(I))),
-            Live = gb_sets:delete_any(Dst, Live1),
+            Live = gb_sets:delete(Dst, Live1),
             live_opt_is(Is, Live, [I|Acc]);
         false ->
             case beam_ssa:no_side_effect(I) of
@@ -1373,7 +1376,7 @@ bsm_positions([{L,#b_blk{is=Is,last=Last}}|Bs], PosMap0) ->
     case {Is,Last} of
         {[#b_set{op=bs_test_tail,dst=Bool,args=[Ctx,#b_literal{val=Bits0}]}],
          #b_br{bool=Bool,fail=Fail}} ->
-            Bits = Bits0 + maps:get(Ctx, PosMap0),
+            Bits = Bits0 + map_get(Ctx, PosMap0),
             bsm_positions(Bs, PosMap#{L=>{Bits,Fail}});
         {_,_} ->
             bsm_positions(Bs, PosMap)
@@ -1465,7 +1468,7 @@ bsm_units_skip_1([#b_set{op=bs_match,
                  Block0, Units) ->
     [#b_set{op=succeeded,dst=Bool,args=[New]}] = Test, %Assertion.
     #b_br{bool=Bool} = Last0 = Block0#b_blk.last, %Assertion.
-    CtxUnit = maps:get(Ctx, Units),
+    CtxUnit = map_get(Ctx, Units),
     if
         CtxUnit rem OpUnit =:= 0 ->
             Is = takewhile(fun(I) -> I =/= Skip end, Block0#b_blk.is),
@@ -1477,7 +1480,7 @@ bsm_units_skip_1([#b_set{op=bs_match,
     end;
 bsm_units_skip_1([#b_set{op=bs_match,dst=New,args=Args}|_], Block, Units) ->
     [_,Ctx|_] = Args,
-    CtxUnit = maps:get(Ctx, Units),
+    CtxUnit = map_get(Ctx, Units),
     OpUnit = bsm_op_unit(Args),
     {Block, Units#{ New => gcd(OpUnit, CtxUnit) }};
 bsm_units_skip_1([_I | Is], Block, Units) ->
@@ -1505,23 +1508,23 @@ bsm_op_unit(_) ->
 %% may differ between them, so we can only keep the information that is common
 %% to all paths.
 bsm_units_join(Lbl, MapA, UnitMaps0) when is_map_key(Lbl, UnitMaps0) ->
-    MapB = maps:get(Lbl, UnitMaps0),
+    MapB = map_get(Lbl, UnitMaps0),
     Merged = if
                  map_size(MapB) =< map_size(MapA) ->
                      bsm_units_join_1(maps:keys(MapB), MapA, MapB);
                  map_size(MapB) > map_size(MapA) ->
                      bsm_units_join_1(maps:keys(MapA), MapB, MapA)
              end,
-    maps:put(Lbl, Merged, UnitMaps0);
+    UnitMaps0#{Lbl := Merged};
 bsm_units_join(Lbl, MapA, UnitMaps0) when MapA =/= #{} ->
-    maps:put(Lbl, MapA, UnitMaps0);
+    UnitMaps0#{Lbl => MapA};
 bsm_units_join(_Lbl, _MapA, UnitMaps0) ->
     UnitMaps0.
 
 bsm_units_join_1([Key | Keys], Left, Right) when is_map_key(Key, Left) ->
-    UnitA = maps:get(Key, Left),
-    UnitB = maps:get(Key, Right),
-    bsm_units_join_1(Keys, Left, maps:put(Key, gcd(UnitA, UnitB), Right));
+    UnitA = map_get(Key, Left),
+    UnitB = map_get(Key, Right),
+    bsm_units_join_1(Keys, Left, Right#{Key := gcd(UnitA, UnitB)});
 bsm_units_join_1([Key | Keys], Left, Right) ->
     bsm_units_join_1(Keys, Left, maps:remove(Key, Right));
 bsm_units_join_1([], _MapA, Right) ->
@@ -1941,7 +1944,7 @@ merge_blocks_1([L|Ls], Preds0, Blocks0) ->
                     Is = Is0 ++ Is1,
                     Blk = Blk1#b_blk{is=Is},
                     Blocks1 = maps:remove(L, Blocks0),
-                    Blocks2 = maps:put(P, Blk, Blocks1),
+                    Blocks2 = Blocks1#{P:=Blk},
                     Successors = beam_ssa:successors(Blk),
                     Blocks = beam_ssa:update_phi_labels(Successors, L, P, Blocks2),
                     Preds = merge_update_preds(Successors, L, P, Preds0),
@@ -1955,8 +1958,8 @@ merge_blocks_1([L|Ls], Preds0, Blocks0) ->
 merge_blocks_1([], _Preds, Blocks) -> Blocks.
 
 merge_update_preds([L|Ls], From, To, Preds0) ->
-    Ps = [rename_label(P, From, To) || P <- maps:get(L, Preds0)],
-    Preds = maps:put(L, Ps, Preds0),
+    Ps = [rename_label(P, From, To) || P <- map_get(L, Preds0)],
+    Preds = Preds0#{L:=Ps},
     merge_update_preds(Ls, From, To, Preds);
 merge_update_preds([], _, _, Preds) -> Preds.
 
@@ -2003,8 +2006,16 @@ ssa_opt_sink({#st{ssa=Blocks0}=St, FuncDb}) ->
 
     %% Create a map with all variables that define get_tuple_element
     %% instructions. The variable name map to the block it is defined in.
-    Defs = maps:from_list(def_blocks(Linear)),
+    case def_blocks(Linear) of
+        [] ->
+            %% No get_tuple_element instructions, so there is nothing to do.
+            {St, FuncDb};
+        [_|_]=Defs0 ->
+            Defs = maps:from_list(Defs0),
+            {do_ssa_opt_sink(Linear, Defs, St), FuncDb}
+    end.
 
+do_ssa_opt_sink(Linear, Defs, #st{ssa=Blocks0}=St) ->
     %% Now find all the blocks that use variables defined by get_tuple_element
     %% instructions.
     Used = used_blocks(Linear, Defs, []),
@@ -2036,10 +2047,10 @@ ssa_opt_sink({#st{ssa=Blocks0}=St, FuncDb}) ->
     %% Now move all suitable get_tuple_element instructions to their
     %% new blocks.
     Blocks = foldl(fun({V,To}, A) ->
-                           From = maps:get(V, Defs),
+                           From = map_get(V, Defs),
                            move_defs(V, From, To, A)
                    end, Blocks0, DefLoc),
-    {St#st{ssa=Blocks}, FuncDb}.
+    St#st{ssa=Blocks}.
 
 def_blocks([{L,#b_blk{is=Is}}|Bs]) ->
     def_blocks_is(Is, L, def_blocks(Bs));
@@ -2106,11 +2117,11 @@ unsuitable_loop(L, Blocks, Predecessors) ->
     unsuitable_loop(L, Blocks, Predecessors, []).
 
 unsuitable_loop(L, Blocks, Predecessors, Acc) ->
-    Ps = maps:get(L, Predecessors),
+    Ps = map_get(L, Predecessors),
     unsuitable_loop_1(Ps, Blocks, Predecessors, Acc).
 
 unsuitable_loop_1([P|Ps], Blocks, Predecessors, Acc0) ->
-    case maps:get(P, Blocks) of
+    case map_get(P, Blocks) of
         #b_blk{is=[#b_set{op=peek_message}|_]} ->
             unsuitable_loop_1(Ps, Blocks, Predecessors, Acc0);
         #b_blk{} ->
@@ -2134,7 +2145,7 @@ unsuitable_loop_1([], _, _, Acc) -> Acc.
 %%  variable will not be included in the result list.
 
 new_def_locations([{V,UsedIn}|Vs], Defs, Dom) ->
-    DefIn = maps:get(V, Defs),
+    DefIn = map_get(V, Defs),
     case common_dom(UsedIn, DefIn, Dom) of
         [] ->
             new_def_locations(Vs, Defs, Dom);
@@ -2145,27 +2156,27 @@ new_def_locations([{V,UsedIn}|Vs], Defs, Dom) ->
 new_def_locations([], _, _) -> [].
 
 common_dom([L|Ls], DefIn, Dom) ->
-    DomBy0 = maps:get(L, Dom),
-    DomBy = ordsets:subtract(DomBy0, maps:get(DefIn, Dom)),
+    DomBy0 = map_get(L, Dom),
+    DomBy = ordsets:subtract(DomBy0, map_get(DefIn, Dom)),
     common_dom_1(Ls, Dom, DomBy).
 
 common_dom_1(_, _, []) ->
     [];
 common_dom_1([L|Ls], Dom, [_|_]=DomBy0) ->
-    DomBy1 = maps:get(L, Dom),
+    DomBy1 = map_get(L, Dom),
     DomBy = ordsets:intersection(DomBy0, DomBy1),
     common_dom_1(Ls, Dom, DomBy);
 common_dom_1([], _, DomBy) -> DomBy.
 
 most_dominated([L|Ls], Dom) ->
-    most_dominated(Ls, L, maps:get(L, Dom), Dom).
+    most_dominated(Ls, L, map_get(L, Dom), Dom).
 
 most_dominated([L|Ls], L0, DomBy, Dom) ->
     case member(L, DomBy) of
         true ->
             most_dominated(Ls, L0, DomBy, Dom);
         false ->
-            most_dominated(Ls, L, maps:get(L, Dom), Dom)
+            most_dominated(Ls, L, map_get(L, Dom), Dom)
     end;
 most_dominated([], L, _, _) -> L.
 
diff --git a/lib/compiler/src/beam_ssa_pre_codegen.erl b/lib/compiler/src/beam_ssa_pre_codegen.erl
index fde1118c29..274f78052d 100644
--- a/lib/compiler/src/beam_ssa_pre_codegen.erl
+++ b/lib/compiler/src/beam_ssa_pre_codegen.erl
@@ -272,7 +272,7 @@ make_bs_getpos_map([], _, Count, Acc) ->
     {maps:from_list(Acc),Count}.
 
 get_savepoint({_,_}=Ps, SavePoints) ->
-    Name = {'@ssa_bs_position', maps:get(Ps, SavePoints)},
+    Name = {'@ssa_bs_position', map_get(Ps, SavePoints)},
     #b_var{name=Name}.
 
 make_bs_pos_dict([{Ctx,Pts}|T], Count0, Acc0) ->
@@ -323,7 +323,7 @@ make_restore_map([], _, Count, Acc) ->
 make_slot({Same,Same}, _Slots) ->
     #b_literal{val=start};
 make_slot({_,_}=Ps, Slots) ->
-    #b_literal{val=maps:get(Ps, Slots)}.
+    #b_literal{val=map_get(Ps, Slots)}.
 
 make_save_point_dict([{Ctx,Pts}|T], Acc0) ->
     Acc = make_save_point_dict_1(Pts, Ctx, 0, Acc0),
@@ -684,7 +684,7 @@ sanitize(#st{ssa=Blocks0,cnt=Count0}=St) ->
     St#st{ssa=Blocks,cnt=Count}.
 
 sanitize([L|Ls], Count0, Blocks0, Values0) ->
-    #b_blk{is=Is0} = Blk0 = maps:get(L, Blocks0),
+    #b_blk{is=Is0} = Blk0 = map_get(L, Blocks0),
     case sanitize_is(Is0, Count0, Values0, false, []) of
         no_change ->
             sanitize(Ls, Count0, Blocks0, Values0);
@@ -817,7 +817,7 @@ sanitize_badarg(I) ->
     I#b_set{op=call,args=[Func,#b_literal{val=badarg}]}.
 
 remove_unreachable([L|Ls], Blocks, Reachable, Acc) ->
-    #b_blk{is=Is0} = Blk0 = maps:get(L, Blocks),
+    #b_blk{is=Is0} = Blk0 = map_get(L, Blocks),
     case split_phis(Is0) of
         {[_|_]=Phis,Rest} ->
             Is = [prune_phi(Phi, Reachable) || Phi <- Phis] ++ Rest,
@@ -882,7 +882,7 @@ place_frames(#st{ssa=Blocks}=St) ->
     St#st{frames=Frames}.
 
 place_frames_1([L|Ls], Blocks, Doms, Tried0, Frames0) ->
-    Blk = maps:get(L, Blocks),
+    Blk = map_get(L, Blocks),
     case need_frame(Blk) of
         true ->
             %% This block needs a frame. Try to place it here.
@@ -993,14 +993,14 @@ place_frame_here(L, Blocks, Doms, Frames) ->
 %%  Return all predecessors referenced in phi nodes.
 
 phi_predecessors(L, Blocks) ->
-    #b_blk{is=Is} = maps:get(L, Blocks),
+    #b_blk{is=Is} = map_get(L, Blocks),
     [P || #b_set{op=phi,args=Args} <- Is, {_,P} <- Args].
 
 %% is_dominated_by(Label, DominatedBy, Dominators) -> true|false.
 %%  Test whether block Label is dominated by block DominatedBy.
 
 is_dominated_by(L, DomBy, Doms) ->
-    DominatedBy = maps:get(L, Doms),
+    DominatedBy = map_get(L, Doms),
     ordsets:is_element(DomBy, DominatedBy).
 
 %% need_frame(#b_blk{}) -> true|false.
@@ -1137,7 +1137,7 @@ recv_fix_common([Msg0|T], Exit, Rm, Blocks0, Count0) ->
     {MsgVars,Count} = new_vars(duplicate(N, '@recv'), Count1),
     PhiArgs = fix_exit_phi_args(MsgVars, Rm, Exit, Blocks1),
     Phi = #b_set{op=phi,dst=Msg,args=PhiArgs},
-    ExitBlk0 = maps:get(Exit, Blocks1),
+    ExitBlk0 = map_get(Exit, Blocks1),
     ExitBlk = ExitBlk0#b_blk{is=[Phi|ExitBlk0#b_blk.is]},
     Blocks2 = Blocks1#{Exit:=ExitBlk},
     Blocks = recv_fix_common_1(MsgVars, Rm, Msg0, Blocks2),
@@ -1148,7 +1148,7 @@ recv_fix_common([], _, _, Blocks, Count) ->
 recv_fix_common_1([V|Vs], [Rm|Rms], Msg, Blocks0) ->
     Ren = #{Msg=>V},
     Blocks1 = beam_ssa:rename_vars(Ren, [Rm], Blocks0),
-    #b_blk{is=Is0} = Blk0 = maps:get(Rm, Blocks1),
+    #b_blk{is=Is0} = Blk0 = map_get(Rm, Blocks1),
     Copy = #b_set{op=copy,dst=V,args=[Msg]},
     Is = insert_after_phis(Is0, [Copy]),
     Blk = Blk0#b_blk{is=Is},
@@ -1183,11 +1183,11 @@ fix_receive([L|Ls], Defs, Blocks0, Count0) ->
     {NewVars,Count} = new_vars([Base || #b_var{name=Base} <- Used], Count0),
     Ren = zip(Used, NewVars),
     Blocks1 = beam_ssa:rename_vars(Ren, [L], Blocks0),
-    #b_blk{is=Is0} = Blk1 = maps:get(L, Blocks1),
+    #b_blk{is=Is0} = Blk1 = map_get(L, Blocks1),
     CopyIs = [#b_set{op=copy,dst=New,args=[Old]} || {Old,New} <- Ren],
     Is = insert_after_phis(Is0, CopyIs),
     Blk = Blk1#b_blk{is=Is},
-    Blocks = maps:put(L, Blk, Blocks1),
+    Blocks = Blocks1#{L:=Blk},
     fix_receive(Ls, Defs, Blocks, Count);
 fix_receive([], _Defs, Blocks, Count) ->
     {Blocks,Count}.
@@ -1212,7 +1212,7 @@ find_loop_exit_1(_, _, Exit) -> Exit.
 
 find_rm_blocks(L, Blocks) ->
     Seen = gb_sets:singleton(L),
-    Blk = maps:get(L, Blocks),
+    Blk = map_get(L, Blocks),
     Succ = beam_ssa:successors(Blk),
     find_rm_blocks_1(Succ, Seen, Blocks).
 
@@ -1222,7 +1222,7 @@ find_rm_blocks_1([L|Ls], Seen0, Blocks) ->
             find_rm_blocks_1(Ls, Seen0, Blocks);
         false ->
             Seen = gb_sets:insert(L, Seen0),
-            Blk = maps:get(L, Blocks),
+            Blk = map_get(L, Blocks),
             case find_rm_act(Blk#b_blk.is) of
                 prune ->
                     %% Looping back. Don't look at any successors.
@@ -1284,16 +1284,16 @@ find_yregs_1([{F,Defs}|Fs], Blocks0) ->
     Ls = beam_ssa:rpo([F], Blocks0),
     Yregs0 = [],
     Yregs = find_yregs_2(Ls, Blocks0, D0, Yregs0),
-    Blk0 = maps:get(F, Blocks0),
+    Blk0 = map_get(F, Blocks0),
     Blk = beam_ssa:add_anno(yregs, Yregs, Blk0),
     Blocks = Blocks0#{F:=Blk},
     find_yregs_1(Fs, Blocks);
 find_yregs_1([], Blocks) -> Blocks.
 
 find_yregs_2([L|Ls], Blocks0, D0, Yregs0) ->
-    Blk0 = maps:get(L, Blocks0),
+    Blk0 = map_get(L, Blocks0),
     #b_blk{is=Is,last=Last} = Blk0,
-    Ys0 = maps:get(L, D0),
+    Ys0 = map_get(L, D0),
     {Yregs1,Ys} = find_yregs_is(Is, Ys0, Yregs0),
     Yregs = find_yregs_terminator(Last, Ys, Yregs1),
     Successors = beam_ssa:successors(Blk0),
@@ -1320,7 +1320,7 @@ find_defs_1([L|Ls], Blocks, Frames, Seen0, Defs0, Acc0) ->
                 false ->
                     Seen1 = gb_sets:insert(L, Seen0),
                     {Acc,Seen} = find_defs_1(Ls, Blocks, Frames, Seen1, Defs0, Acc0),
-                    #b_blk{is=Is} = Blk = maps:get(L, Blocks),
+                    #b_blk{is=Is} = Blk = map_get(L, Blocks),
                     Defs = find_defs_is(Is, Defs0),
                     Successors = beam_ssa:successors(Blk),
                     find_defs_1(Successors, Blocks, Frames, Seen, Defs, Acc)
@@ -1339,10 +1339,10 @@ find_update_succ([S|Ss], #dk{d=Defs0,k=Killed0}=DK0, D0) ->
             Defs = ordsets:intersection(Defs0, Defs1),
             Killed = ordsets:union(Killed0, Killed1),
             DK = #dk{d=Defs,k=Killed},
-            D = maps:put(S, DK, D0),
+            D = D0#{S:=DK},
             find_update_succ(Ss, DK0, D);
         #{} ->
-            D = maps:put(S, DK0, D0),
+            D = D0#{S=>DK0},
             find_update_succ(Ss, DK0, D)
     end;
 find_update_succ([], _, D) -> D.
@@ -1432,7 +1432,7 @@ copy_retval(#st{frames=Frames,ssa=Blocks0,cnt=Count0}=St) ->
     St#st{ssa=Blocks,cnt=Count}.
 
 copy_retval_1([F|Fs], Blocks0, Count0) ->
-    #b_blk{anno=#{yregs:=Yregs0},is=Is} = maps:get(F, Blocks0),
+    #b_blk{anno=#{yregs:=Yregs0},is=Is} = map_get(F, Blocks0),
     Yregs1 = gb_sets:from_list(Yregs0),
     Yregs = collect_yregs(Is, Yregs1),
     Ls = beam_ssa:rpo([F], Blocks0),
@@ -1451,7 +1451,7 @@ collect_yregs([#b_set{}|Is], Yregs) ->
 collect_yregs([], Yregs) -> Yregs.
 
 copy_retval_2([L|Ls], Yregs, Copy0, Blocks0, Count0) ->
-    #b_blk{is=Is0,last=Last} = Blk = maps:get(L, Blocks0),
+    #b_blk{is=Is0,last=Last} = Blk = map_get(L, Blocks0),
     RC = case {Last,Ls} of
              {#b_br{succ=Succ,fail=?BADARG_BLOCK},[Succ|_]} ->
                  true;
@@ -1593,7 +1593,7 @@ opt_get_list(#st{ssa=Blocks,res=Res}=St) ->
     St#st{ssa=opt_get_list_1(Ls, ResMap, Blocks)}.
 
 opt_get_list_1([L|Ls], Res, Blocks0) ->
-    #b_blk{is=Is0} = Blk = maps:get(L, Blocks0),
+    #b_blk{is=Is0} = Blk = map_get(L, Blocks0),
     case opt_get_list_is(Is0, Res, [], false) of
         no ->
             opt_get_list_1(Ls, Res, Blocks0);
@@ -1647,12 +1647,12 @@ number_instructions(#st{ssa=Blocks0}=St) ->
     St#st{ssa=number_is_1(Ls, 1, Blocks0)}.
 
 number_is_1([L|Ls], N0, Blocks0) ->
-    #b_blk{is=Is0,last=Last0} = Bl0 = maps:get(L, Blocks0),
+    #b_blk{is=Is0,last=Last0} = Bl0 = map_get(L, Blocks0),
     {Is,N1} = number_is_2(Is0, N0, []),
     Last = beam_ssa:add_anno(n, N1, Last0),
     N = N1 + 2,
     Bl = Bl0#b_blk{is=Is,last=Last},
-    Blocks = maps:put(L, Bl, Blocks0),
+    Blocks = Blocks0#{L:=Bl},
     number_is_1(Ls, N, Blocks);
 number_is_1([], _, Blocks) -> Blocks.
 
@@ -1693,7 +1693,7 @@ live_interval_blk(L, Blocks, {Vars0,LiveMap0}) ->
     Live1 = update_successors(Successors, L, Blocks, LiveMap0, Live0),
 
     %% Add ranges for all variables that are live in the successors.
-    #b_blk{is=Is,last=Last} = maps:get(L, Blocks),
+    #b_blk{is=Is,last=Last} = map_get(L, Blocks),
     End = beam_ssa:get_anno(n, Last),
     Use = [{V,{use,End+1}} || V <- Live1],
 
@@ -1762,7 +1762,7 @@ first_number([], Last) ->
 
 update_successors([L|Ls], Pred, Blocks, LiveMap, Live0) ->
     Live1 = ordsets:union(Live0, get_live(L, LiveMap)),
-    #b_blk{is=Is} = maps:get(L, Blocks),
+    #b_blk{is=Is} = map_get(L, Blocks),
     Live = update_live_phis(Is, Pred, Live1),
     update_successors(Ls, Pred, Blocks, LiveMap, Live);
 update_successors([], _, _, _, Live) -> Live.
@@ -1800,7 +1800,7 @@ reserve_yregs(#st{frames=Frames}=St0) ->
     foldl(fun reserve_yregs_1/2, St0, Frames).
 
 reserve_yregs_1(L, #st{ssa=Blocks0,cnt=Count0,res=Res0}=St) ->
-    Blk = maps:get(L, Blocks0),
+    Blk = map_get(L, Blocks0),
     Yregs = beam_ssa:get_anno(yregs, Blk),
     {Def,Used} = beam_ssa:def_used([L], Blocks0),
     UsedYregs = ordsets:intersection(Yregs, Used),
@@ -1826,7 +1826,7 @@ reserve_try_tags_1([L|Ls], Blocks, Seen0, ActMap0) ->
             reserve_try_tags_1(Ls, Blocks, Seen0, ActMap0);
         false ->
             Seen1 = gb_sets:insert(L, Seen0),
-            #b_blk{is=Is} = Blk = maps:get(L, Blocks),
+            #b_blk{is=Is} = Blk = map_get(L, Blocks),
             Active0 = get_active(L, ActMap0),
             Active = reserve_try_tags_is(Is, Active0),
             Successors = beam_ssa:successors(Blk),
@@ -1869,11 +1869,11 @@ rename_vars(Vs, L, Blocks0, Count0) ->
     {NewVars,Count} = new_vars([Base || #b_var{name=Base} <- Vs], Count0),
     Ren = zip(Vs, NewVars),
     Blocks1 = beam_ssa:rename_vars(Ren, [L], Blocks0),
-    #b_blk{is=Is0} = Blk0 = maps:get(L, Blocks1),
+    #b_blk{is=Is0} = Blk0 = map_get(L, Blocks1),
     CopyIs = [#b_set{op=copy,dst=New,args=[Old]} || {Old,New} <- Ren],
     Is = insert_after_phis(Is0, CopyIs),
     Blk = Blk0#b_blk{is=Is},
-    Blocks = maps:put(L, Blk, Blocks1),
+    Blocks = Blocks1#{L:=Blk},
     {NewVars,Blocks,Count}.
 
 insert_after_phis([#b_set{op=phi}=I|Is], InsertIs) ->
@@ -1895,7 +1895,7 @@ frame_size(#st{frames=Frames,regs=Regs,ssa=Blocks0}=St) ->
 
 frame_size_1(L, Regs, Blocks0) ->
     Def = beam_ssa:def([L], Blocks0),
-    Yregs0 = [maps:get(V, Regs) || V <- Def, is_yreg(maps:get(V, Regs))],
+    Yregs0 = [map_get(V, Regs) || V <- Def, is_yreg(map_get(V, Regs))],
     Yregs = ordsets:from_list(Yregs0),
     FrameSize = length(ordsets:from_list(Yregs)),
     if
@@ -1907,17 +1907,17 @@ frame_size_1(L, Regs, Blocks0) ->
         true ->
             ok
     end,
-    Blk0 = maps:get(L, Blocks0),
+    Blk0 = map_get(L, Blocks0),
     Blk = beam_ssa:add_anno(frame_size, FrameSize, Blk0),
 
     %% Insert an annotation for frame deallocation on
     %% each #b_ret{}.
-    Blocks = maps:put(L, Blk, Blocks0),
+    Blocks = Blocks0#{L:=Blk},
     Reachable = beam_ssa:rpo([L], Blocks),
     frame_deallocate(Reachable, FrameSize, Blocks).
 
 frame_deallocate([L|Ls], Size, Blocks0) ->
-    Blk0 = maps:get(L, Blocks0),
+    Blk0 = map_get(L, Blocks0),
     Blk = case Blk0 of
               #b_blk{last=#b_ret{}=Ret0} ->
                   Ret = beam_ssa:add_anno(deallocate, Size, Ret0),
@@ -1925,7 +1925,7 @@ frame_deallocate([L|Ls], Size, Blocks0) ->
               #b_blk{} ->
                   Blk0
           end,
-    Blocks = maps:put(L, Blk, Blocks0),
+    Blocks = Blocks0#{L:=Blk},
     frame_deallocate(Ls, Size, Blocks);
 frame_deallocate([], _, Blocks) -> Blocks.
 
@@ -1938,7 +1938,7 @@ frame_deallocate([], _, Blocks) -> Blocks.
 
 turn_yregs(#st{frames=Frames,regs=Regs0,ssa=Blocks}=St) ->
     Regs1 = foldl(fun(L, A) ->
-                          Blk = maps:get(L, Blocks),
+                          Blk = map_get(L, Blocks),
                           FrameSize = beam_ssa:get_anno(frame_size, Blk),
                           Def = beam_ssa:def([L], Blocks),
                           [turn_yregs_1(Def, FrameSize, Regs0)|A]
@@ -1947,7 +1947,7 @@ turn_yregs(#st{frames=Frames,regs=Regs0,ssa=Blocks}=St) ->
     St#st{regs=Regs}.
 
 turn_yregs_1(Def, FrameSize, Regs) ->
-    Yregs0 = [{maps:get(V, Regs),V} || V <- Def, is_yreg(maps:get(V, Regs))],
+    Yregs0 = [{map_get(V, Regs),V} || V <- Def, is_yreg(map_get(V, Regs))],
     Yregs1 = rel2fam(Yregs0),
     FrameSize = length(Yregs1),
     Yregs2 = [{{y,FrameSize-Y-1},Vs} || {{y,Y},Vs} <- Yregs1],
@@ -2356,7 +2356,7 @@ linear_scan(#st{intervals=Intervals0,res=Res}=St0) ->
     St#st{regs=maps:from_list(Regs)}.
 
 init_interval({V,[{Start,_}|_]=Rs}, Res) ->
-    Info = maps:get(V, Res),
+    Info = map_get(V, Res),
     Pool = case Info of
                {prefer,{x,_}} -> x;
                x -> x;
@@ -2557,16 +2557,16 @@ free_reg(#i{reg={_,_}=Reg}=I, L) ->
     update_pool(I, FreeRegs, L).
 
 get_pool(#i{pool=Pool}, #l{free=Free}) ->
-    maps:get(Pool, Free).
+    map_get(Pool, Free).
 
 update_pool(#i{pool=Pool}, New, #l{free=Free0}=L) ->
-    Free = maps:put(Pool, New, Free0),
+    Free = Free0#{Pool:=New},
     L#l{free=Free}.
 
 get_next_free(#i{pool=Pool}, #l{free=Free0}=L0) ->
     K = {next,Pool},
-    N = maps:get(K, Free0),
-    Free = maps:put(K, N+1, Free0),
+    N = map_get(K, Free0),
+    Free = Free0#{K:=N+1},
     L = L0#l{free=Free},
     if
         is_integer(Pool) -> {{y,N},L};
@@ -2602,7 +2602,7 @@ are_overlapping_1({_,_}, []) -> false.
 is_loop_header(L, Blocks) ->
     %% We KNOW that a loop header must start with a peek_message
     %% instruction.
-    case maps:get(L, Blocks) of
+    case map_get(L, Blocks) of
         #b_blk{is=[#b_set{op=peek_message}|_]} -> true;
         _ -> false
     end.
diff --git a/lib/compiler/src/beam_ssa_recv.erl b/lib/compiler/src/beam_ssa_recv.erl
index 6e49b128da..1e0e1ecac2 100644
--- a/lib/compiler/src/beam_ssa_recv.erl
+++ b/lib/compiler/src/beam_ssa_recv.erl
@@ -101,7 +101,7 @@ opt([{L,#b_blk{is=[#b_set{op=peek_message}|_]}=Blk0}|Bs], Blocks0, Preds) ->
     case recv_opt(Preds, L, Blocks0) of
         {yes,Blocks1} ->
             Blk = beam_ssa:add_anno(recv_set, L, Blk0),
-            Blocks = maps:put(L, Blk, Blocks1),
+            Blocks = Blocks1#{L:=Blk},
             opt(Bs, Blocks, []);
         no ->
             opt(Bs, Blocks0, [])
@@ -111,11 +111,11 @@ opt([{L,_}|Bs], Blocks, Preds) ->
 opt([], Blocks, _) -> Blocks.
 
 recv_opt([L|Ls], RecvLbl, Blocks) ->
-    #b_blk{is=Is0} = Blk0 = maps:get(L, Blocks),
+    #b_blk{is=Is0} = Blk0 = map_get(L, Blocks),
     case recv_opt_is(Is0, RecvLbl, Blocks, []) of
         {yes,Is} ->
             Blk = Blk0#b_blk{is=Is},
-            {yes,maps:put(L, Blk, Blocks)};
+            {yes,Blocks#{L:=Blk}};
         no ->
             recv_opt(Ls, RecvLbl, Blocks)
     end;
@@ -174,7 +174,7 @@ opt_ref_used(RecvLbl, Ref, Blocks) ->
     end.
 
 opt_ref_used_1(L, Vs0, Blocks) ->
-    #b_blk{is=Is} = Blk = maps:get(L, Blocks),
+    #b_blk{is=Is} = Blk = map_get(L, Blocks),
     case opt_ref_used_is(Is, Vs0) of
         #{}=Vs ->
             opt_ref_used_last(Blk, Vs, Blocks);
diff --git a/lib/compiler/src/beam_ssa_type.erl b/lib/compiler/src/beam_ssa_type.erl
index 8bd6772ac5..32583f5abf 100644
--- a/lib/compiler/src/beam_ssa_type.erl
+++ b/lib/compiler/src/beam_ssa_type.erl
@@ -1081,44 +1081,51 @@ simplify_not(#b_br{bool=#b_var{}=V,succ=Succ,fail=Fail}=Br0, Ts, Ds) ->
 used_once(Linear, Args) ->
     Map0 = used_once_1(reverse(Linear), #{}),
     Map = maps:without(Args, Map0),
-    Used0 = cerl_sets:from_list(maps:keys(Map)),
-    Used1 = used_in_terminators(Linear, []),
-    cerl_sets:intersection(Used0, Used1).
-
-used_in_terminators([{_,#b_blk{last=Last}}|Bs], Acc) ->
-    used_in_terminators(Bs, beam_ssa:used(Last) ++ Acc);
-used_in_terminators([], Acc) ->
-    cerl_sets:from_list(Acc).
+    cerl_sets:from_list(maps:keys(Map)).
 
 used_once_1([{L,#b_blk{is=Is,last=Last}}|Bs], Uses0) ->
-    Uses = used_once_2([Last|reverse(Is)], L, Uses0),
+    Uses1 = used_once_last_uses(beam_ssa:used(Last), L, Uses0),
+    Uses = used_once_2(reverse(Is), L, Uses1),
     used_once_1(Bs, Uses);
 used_once_1([], Uses) -> Uses.
 
-used_once_2([I|Is], L, Uses0) ->
+used_once_2([#b_set{dst=Dst}=I|Is], L, Uses0) ->
     Uses = used_once_uses(beam_ssa:used(I), L, Uses0),
-    case I of
-        #b_set{dst=Dst} ->
-            case Uses of
-                #{Dst:=[L]} ->
-                    used_once_2(Is, L, Uses);
-                #{} ->
-                    used_once_2(Is, L, maps:remove(Dst, Uses))
-            end;
-        _ ->
-            used_once_2(Is, L, Uses)
+    case Uses of
+        #{Dst:=[L]} ->
+            used_once_2(Is, L, Uses);
+        #{} ->
+            %% Used more than once or used once in
+            %% in another block.
+            used_once_2(Is, L, maps:remove(Dst, Uses))
     end;
 used_once_2([], _, Uses) -> Uses.
 
 used_once_uses([V|Vs], L, Uses) ->
     case Uses of
-        #{V:=Us} ->
-            used_once_uses(Vs, L, Uses#{V:=[L|Us]});
+        #{V:=more_than_once} ->
+            used_once_uses(Vs, L, Uses);
         #{} ->
-            used_once_uses(Vs, L, Uses#{V=>[L]})
+            %% Already used or first use is not in
+            %% a terminator.
+            used_once_uses(Vs, L, Uses#{V=>more_than_once})
     end;
 used_once_uses([], _, Uses) -> Uses.
 
+used_once_last_uses([V|Vs], L, Uses) ->
+    case Uses of
+        #{V:=[_]} ->
+            %% Second time this variable is used.
+            used_once_last_uses(Vs, L, Uses#{V:=more_than_once});
+        #{V:=more_than_once} ->
+            %% Used at least twice before.
+            used_once_last_uses(Vs, L, Uses);
+        #{} ->
+            %% First time this variable is used.
+            used_once_last_uses(Vs, L, Uses#{V=>[L]})
+    end;
+used_once_last_uses([], _, Uses) -> Uses.
+
 
 get_types(Values, Ts) ->
     [get_type(Val, Ts) || Val <- Values].