From 9a190cae9bd7213ff018e17a909efbab04a14a8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 29 Jan 2019 18:09:26 +0100
Subject: Optimize ssa_opt_sink when nothing can be sunk
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Compilation will be much faster if there are many blocks, but no
get_tuple_element instructions.

Reported-by: Michał Muskała
---
 lib/compiler/src/beam_ssa_opt.erl | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl
index e528bb4dfb..47b9ef28d8 100644
--- a/lib/compiler/src/beam_ssa_opt.erl
+++ b/lib/compiler/src/beam_ssa_opt.erl
@@ -2003,8 +2003,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, []),
@@ -2039,7 +2047,7 @@ ssa_opt_sink({#st{ssa=Blocks0}=St, FuncDb}) ->
                            From = maps: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));
-- 
cgit v1.2.3


From c86c4dd18da287e439770c47fa384d438c134f12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 29 Jan 2019 20:35:45 +0100
Subject: Speed up beam_ssa_dead when there are many sequential blocks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

beam_ssa_dead could be very slow if there were many blocks
connected with unconditional branches (for example, if a block
had contained many `call` instructions and been split by
ssa_opt_split_blocks).

It turns out that `comb_get_sw/3` does an unnecessary (and perhaps
incorrect) recursive call to itself when the terminator for the
block is an unconditional branch. Removing the recursive call does
not disable any optimizations, but will be much faster if there
are many blocks connected with unconditional branches.

Reported-by: Michał Muskała
---
 lib/compiler/src/beam_ssa_dead.erl | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/compiler/src/beam_ssa_dead.erl b/lib/compiler/src/beam_ssa_dead.erl
index 09b29025c6..db82aaa8e6 100644
--- a/lib/compiler/src/beam_ssa_dead.erl
+++ b/lib/compiler/src/beam_ssa_dead.erl
@@ -850,7 +850,7 @@ 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) ->
+comb_get_sw(L, Safe0, #st{bs=Blocks,skippable=Skippable}) ->
     #b_blk{is=Is,last=Last} = maps:get(L, Blocks),
     Safe1 = Safe0 andalso is_map_key(L, Skippable),
     case Last of
@@ -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}
-- 
cgit v1.2.3


From 7306c730fa3ce28ec47c31ab307e0d3d0105677a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 30 Jan 2019 06:25:41 +0100
Subject: Use gb_sets:delete/2 instead of gb_sets:delete_any/2

Save a little time by using gb_sets:delete/2 instead of
gb_sets:delete_any/2 when the key is known to be in the set.
---
 lib/compiler/src/beam_ssa_opt.erl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl
index 47b9ef28d8..70676de6fe 100644
--- a/lib/compiler/src/beam_ssa_opt.erl
+++ b/lib/compiler/src/beam_ssa_opt.erl
@@ -1218,7 +1218,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 +1229,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
-- 
cgit v1.2.3


From 855af19300720a8d0dbb588a4c145ad5ffe1453e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 30 Jan 2019 07:20:33 +0100
Subject: beam_ssa_type: Optimize calculation of variables that are only used
 once

---
 lib/compiler/src/beam_ssa_type.erl | 53 +++++++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 23 deletions(-)

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].
-- 
cgit v1.2.3


From e713179951d64d85450494d100caf0495ba9e104 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 30 Jan 2019 07:52:18 +0100
Subject: Prefer map syntax and guard BIFs over the maps modules

Avoiding calls usually reduces the size of the stack frame and reduces
register shuffling.
---
 lib/compiler/src/beam_ssa.erl             | 40 +++++++-------
 lib/compiler/src/beam_ssa_dead.erl        |  6 +--
 lib/compiler/src/beam_ssa_funs.erl        |  8 +--
 lib/compiler/src/beam_ssa_opt.erl         | 56 ++++++++++----------
 lib/compiler/src/beam_ssa_pre_codegen.erl | 86 +++++++++++++++----------------
 lib/compiler/src/beam_ssa_recv.erl        |  8 +--
 6 files changed, 102 insertions(+), 102 deletions(-)

diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl
index b491e340b7..e46fa1ab16 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,7 +323,7 @@ def(Ls, Blocks) ->
 
 def_used(Ls, Blocks) ->
     Top = rpo(Ls, Blocks),
-    Blks = [maps:get(L, Blocks) || L <- Top],
+    Blks = [map_get(L, Blocks) || L <- Top],
     Preds = gb_sets:from_list(Top),
     def_used_1(Blks, Preds, [], gb_sets:empty()).
 
@@ -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).
@@ -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 db82aaa8e6..57b16883ed 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},
@@ -851,7 +851,7 @@ comb_get_sw(L, Blocks) ->
     comb_get_sw(L, true, Blocks).
 
 comb_get_sw(L, Safe0, #st{bs=Blocks,skippable=Skippable}) ->
-    #b_blk{is=Is,last=Last} = maps:get(L, Blocks),
+    #b_blk{is=Is,last=Last} = map_get(L, Blocks),
     Safe1 = Safe0 andalso is_map_key(L, Skippable),
     case Last of
         #b_ret{} ->
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 70676de6fe..c83bd446d3 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.
@@ -1373,7 +1373,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 +1465,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 +1477,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 +1505,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 +1941,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 +1955,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.
 
@@ -2044,7 +2044,7 @@ do_ssa_opt_sink(Linear, Defs, #st{ssa=Blocks0}=St) ->
     %% 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}.
@@ -2114,11 +2114,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{} ->
@@ -2142,7 +2142,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);
@@ -2153,27 +2153,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);
-- 
cgit v1.2.3


From 939b7da053408682de888bd6423ff7e9cc6ea448 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 31 Jan 2019 06:42:35 +0100
Subject: Optimize beam_ssa:def_used/2

beam_ssa:def_used/2 is used by beam_ssa_pre_codegen when reserving
Y registers.

Do the following optimizations:

* Use an ordset instead of a gb_set. When the only operation performed
on a set is union/2, an ordset will usually be faster, especially when
the result is an ordset.

* Use a cerl_set instead of a gb_set for the set of all possible
predecessors. cerl_sets is usually faster than gb_sets.
---
 lib/compiler/src/beam_ssa.erl | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl
index e46fa1ab16..9c29c98064 100644
--- a/lib/compiler/src/beam_ssa.erl
+++ b/lib/compiler/src/beam_ssa.erl
@@ -324,8 +324,8 @@ def(Ls, Blocks) ->
 def_used(Ls, Blocks) ->
     Top = rpo(Ls, Blocks),
     Blks = [map_get(L, Blocks) || L <- Top],
-    Preds = gb_sets:from_list(Top),
-    def_used_1(Blks, Preds, [], gb_sets:empty()).
+    Preds = cerl_sets:from_list(Top),
+    def_used_1(Blks, Preds, [], []).
 
 -spec dominators(Blocks) -> Result when
       Blocks :: block_map(),
@@ -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}.
-- 
cgit v1.2.3


From 8c5edfebf22bb1e235989f4890cb729e82d9a885 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 31 Jan 2019 08:08:09 +0100
Subject: Make helper functions tail-recursive

Two helper functions in beam_ssa_opt and beam_ssa_dead
are body-recursive for no good reason.

While at it, add some clarifying comments to the functions.
---
 lib/compiler/src/beam_ssa_dead.erl | 21 ++++++++++++---------
 lib/compiler/src/beam_ssa_opt.erl  | 19 +++++++++++--------
 2 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/lib/compiler/src/beam_ssa_dead.erl b/lib/compiler/src/beam_ssa_dead.erl
index 57b16883ed..2cca9ebadf 100644
--- a/lib/compiler/src/beam_ssa_dead.erl
+++ b/lib/compiler/src/beam_ssa_dead.erl
@@ -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_opt.erl b/lib/compiler/src/beam_ssa_opt.erl
index c83bd446d3..ca5eefe4fc 100644
--- a/lib/compiler/src/beam_ssa_opt.erl
+++ b/lib/compiler/src/beam_ssa_opt.erl
@@ -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},
-- 
cgit v1.2.3