Merge pull request #2146 from bjorng/bjorn/compiler/set_tuple_element

Do the destructive setelement optimization in SSA

12 files changed, 201 insertions, 406 deletions

diff --git a/lib/compiler/src/Makefile b/lib/compiler/src/Makefile
index 97c73d0e07..c971e8844d 100644
--- a/lib/compiler/src/Makefile
+++ b/lib/compiler/src/Makefile
@@ -90,7 +90,6 @@ MODULES =  \
 	rec_env \
 	sys_core_alias \
 	sys_core_bsm \
-	sys_core_dsetel \
 	sys_core_fold \
 	sys_core_fold_lists \
 	sys_core_inline \
@@ -209,7 +208,6 @@ $(EBIN)/core_lint.beam: core_parse.hrl
 $(EBIN)/core_parse.beam: core_parse.hrl $(EGEN)/core_parse.erl
 $(EBIN)/core_pp.beam: core_parse.hrl
 $(EBIN)/sys_core_alias.beam: core_parse.hrl
-$(EBIN)/sys_core_dsetel.beam: core_parse.hrl
 $(EBIN)/sys_core_fold.beam: core_parse.hrl
 $(EBIN)/sys_core_fold_lists.beam: core_parse.hrl
 $(EBIN)/sys_core_inline.beam: core_parse.hrl
diff --git a/lib/compiler/src/beam_kernel_to_ssa.erl b/lib/compiler/src/beam_kernel_to_ssa.erl
index d6e675ae72..410bafe0bb 100644
--- a/lib/compiler/src/beam_kernel_to_ssa.erl
+++ b/lib/compiler/src/beam_kernel_to_ssa.erl
@@ -707,11 +707,6 @@ bif_cg(#k_bif{op=#k_remote{mod=#k_atom{val=erlang},name=#k_atom{val=Name}},
 %% internal_cg(Bif, [Arg], [Ret], Le, State) ->
 %%      {[Ainstr],State}.
 
-internal_cg(dsetelement, [Index0,Tuple0,New0], _Rs, _Le, St) ->
-    [New,Tuple,#b_literal{val=Index1}] = ssa_args([New0,Tuple0,Index0], St),
-    Index = #b_literal{val=Index1-1},
-    Set = #b_set{op=set_tuple_element,args=[New,Tuple,Index]},
-    {[Set],St};
 internal_cg(make_fun, [Name0,Arity0|As], Rs, _Le, St0) ->
     #k_atom{val=Name} = Name0,
     #k_int{val=Arity} = Arity0,
diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl
index 0f662d851d..a9977b0b1d 100644
--- a/lib/compiler/src/beam_ssa.erl
+++ b/lib/compiler/src/beam_ssa.erl
@@ -109,7 +109,7 @@
                    'make_fun' | 'new_try_tag' |
                    'peek_message' | 'phi' | 'put_list' | 'put_map' | 'put_tuple' |
                    'raw_raise' | 'recv_next' | 'remove_message' | 'resume' |
-                   'set_tuple_element' | 'succeeded' |
+                   'succeeded' |
                    'timeout' |
                    'wait' | 'wait_timeout'.
 
@@ -118,7 +118,8 @@
 
 %% Primops only used internally during code generation.
 -type cg_prim_op() :: 'bs_get' | 'bs_match_string' | 'bs_restore' | 'bs_skip' |
-                      'copy' | 'put_tuple_arity' | 'put_tuple_element'.
+                      'copy' | 'put_tuple_arity' | 'put_tuple_element' |
+                      'set_tuple_element'.
 
 -import(lists, [foldl/3,keyfind/3,mapfoldl/3,member/2,reverse/1]).
 
diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl
index 355d2d060d..0f03d0e736 100644
--- a/lib/compiler/src/beam_ssa_opt.erl
+++ b/lib/compiler/src/beam_ssa_opt.erl
@@ -2196,7 +2196,6 @@ insert_def_is([#b_set{op=Op}=I|Is]=Is0, V, Def) ->
     Action0 = case Op of
                   call -> beyond;
                   'catch_end' -> beyond;
-                  set_tuple_element -> beyond;
                   timeout -> beyond;
                   _ -> here
               end,
diff --git a/lib/compiler/src/beam_ssa_pre_codegen.erl b/lib/compiler/src/beam_ssa_pre_codegen.erl
index df4de8d7bd..bad43a9c4e 100644
--- a/lib/compiler/src/beam_ssa_pre_codegen.erl
+++ b/lib/compiler/src/beam_ssa_pre_codegen.erl
@@ -124,6 +124,7 @@ passes(Opts) ->
               false -> ignore;
               true -> ?PASS(fix_tuples)
           end,
+          ?PASS(use_set_tuple_element),
           ?PASS(place_frames),
           ?PASS(fix_receives),
 
@@ -857,6 +858,202 @@ fix_tuples(#st{ssa=Blocks0,cnt=Count0}=St) ->
     St#st{ssa=Blocks,cnt=Count}.
 
 %%%
+%%% Introduce the set_tuple_element instructions to make
+%%% multiple-field record updates faster.
+%%%
+%%% The expansion of record field updates, when more than one field is
+%%% updated, but not a majority of the fields, will create a sequence of
+%%% calls to `erlang:setelement(Index, Value, Tuple)` where Tuple in the
+%%% first call is the original record tuple, and in the subsequent calls
+%%% Tuple is the result of the previous call. Furthermore, all Index
+%%% values are constant positive integers, and the first call to
+%%% `setelement` will have the greatest index. Thus all the following
+%%% calls do not actually need to test at run-time whether Tuple has type
+%%% tuple, nor that the index is within the tuple bounds.
+%%%
+%%% Since this optimization introduces destructive updates, it used to
+%%% be done as the very last Core Erlang pass before going to
+%%% lower-level code. However, it turns out that this kind of destructive
+%%% updates are awkward also in SSA code and can prevent or complicate
+%%% type analysis and aggressive optimizations.
+%%%
+%%% NOTE: Because there no write barriers in the system, this kind of
+%%% optimization can only be done when we are sure that garbage
+%%% collection will not be triggered between the creation of the tuple
+%%% and the destructive updates - otherwise we might insert pointers
+%%% from an older generation to a newer.
+%%%
+
+use_set_tuple_element(#st{ssa=Blocks0}=St) ->
+    Uses = count_uses(Blocks0),
+    RPO = reverse(beam_ssa:rpo(Blocks0)),
+    Blocks = use_ste_1(RPO, Uses, Blocks0),
+    St#st{ssa=Blocks}.
+
+use_ste_1([L|Ls], Uses, Blocks0) ->
+    {Blk0,Blocks} = use_ste_across(L, Uses, Blocks0),
+    #b_blk{is=Is0} = Blk0,
+    case use_ste_is(Is0, Uses) of
+        Is0 ->
+            use_ste_1(Ls, Uses, Blocks);
+        Is ->
+            Blk = Blk0#b_blk{is=Is},
+            use_ste_1(Ls, Uses, Blocks#{L:=Blk})
+    end;
+use_ste_1([], _, Blocks) -> Blocks.
+
+%%% Optimize within a single block.
+
+use_ste_is([#b_set{}=I|Is0], Uses) ->
+    Is = use_ste_is(Is0, Uses),
+    case extract_ste(I) of
+        none ->
+            [I|Is];
+        Extracted ->
+            use_ste_call(Extracted, I, Is, Uses)
+    end;
+use_ste_is([], _Uses) -> [].
+
+use_ste_call({Dst0,Pos0,_Var0,_Val0}, Call1, Is0, Uses) ->
+    case get_ste_call(Is0, []) of
+        {Prefix,{Dst1,Pos1,Dst0,Val1},Call2,Is}
+          when Pos1 > 0, Pos0 > Pos1 ->
+            case is_single_use(Dst0, Uses) of
+                true ->
+                    Call = Call1#b_set{dst=Dst1},
+                    Args = [Val1,Dst1,#b_literal{val=Pos1-1}],
+                    Dsetel = Call2#b_set{op=set_tuple_element,
+                                         dst=Dst0,
+                                         args=Args},
+                    [Call|Prefix] ++ [Dsetel|Is];
+                false ->
+                    [Call1|Is0]
+            end;
+        _ ->
+            [Call1|Is0]
+    end.
+
+get_ste_call([#b_set{op=get_tuple_element}=I|Is], Acc) ->
+    get_ste_call(Is, [I|Acc]);
+get_ste_call([#b_set{op=call}=I|Is], Acc) ->
+    case extract_ste(I) of
+        none ->
+            none;
+        Extracted ->
+            {reverse(Acc),Extracted,I,Is}
+    end;
+get_ste_call(_, _) -> none.
+
+extract_ste(#b_set{op=call,dst=Dst,
+                   args=[#b_remote{mod=#b_literal{val=M},
+                                  name=#b_literal{val=F}}|Args]}) ->
+    case {M,F,Args} of
+        {erlang,setelement,[#b_literal{val=Pos},Tuple,Val]} ->
+            {Dst,Pos,Tuple,Val};
+        {_,_,_} ->
+            none
+    end;
+extract_ste(#b_set{}) -> none.
+
+%%% Optimize accross blocks within a try/catch block.
+
+use_ste_across(L, Uses, Blocks) ->
+    case map_get(L, Blocks) of
+        #b_blk{last=#b_br{bool=#b_var{}}}=Blk ->
+            try
+                use_ste_across_1(L, Blk, Uses, Blocks)
+            catch
+                throw:not_possible ->
+                    {Blk,Blocks}
+            end;
+        #b_blk{}=Blk ->
+            {Blk,Blocks}
+    end.
+
+use_ste_across_1(L, Blk0, Uses, Blocks0) ->
+    #b_blk{is=IsThis,last=#b_br{bool=Bool,succ=Next}} = Blk0,
+    case reverse(IsThis) of
+        [#b_set{op=succeeded,dst=Bool,args=[Result]}=Succ0,
+         #b_set{op=call,args=[#b_remote{}|_],dst=Result}=Call1|Prefix] ->
+            case is_single_use(Bool, Uses) andalso
+                is_n_uses(2, Result, Uses) of
+                true -> ok;
+                false -> throw(not_possible)
+            end,
+            Call2 = use_ste_across_next(Next, Uses, Blocks0),
+            Is = [Call1,Call2],
+            case use_ste_is(Is, decrement_uses(Result, Uses)) of
+                [#b_set{}=Call,#b_set{op=set_tuple_element}=Ste] ->
+                    Blocks1 = use_ste_fix_next(Ste, Next, Blocks0),
+                    Succ = Succ0#b_set{args=[Call#b_set.dst]},
+                    Blk = Blk0#b_blk{is=reverse(Prefix, [Call,Succ])},
+                    Blocks = Blocks1#{L:=Blk},
+                    {Blk,Blocks};
+                _ ->
+                    throw(not_possible)
+            end;
+        _ ->
+            throw(not_possible)
+    end.
+
+use_ste_across_next(Next, Uses, Blocks) ->
+    case map_get(Next, Blocks) of
+        #b_blk{is=[#b_set{op=call,dst=Result,args=[#b_remote{}|_]}=Call,
+                   #b_set{op=succeeded,dst=Bool,args=[Result]}],
+               last=#b_br{bool=Bool}} ->
+            case is_single_use(Bool, Uses) andalso
+                is_n_uses(2, Result, Uses) of
+                true -> ok;
+                false -> throw(not_possible)
+            end,
+            Call;
+        #b_blk{} ->
+            throw(not_possible)
+    end.
+
+use_ste_fix_next(Ste, Next, Blocks) ->
+    Blk0 = map_get(Next, Blocks),
+    #b_blk{is=[#b_set{op=call},#b_set{op=succeeded}],last=Br0} = Blk0,
+    Br = beam_ssa:normalize(Br0#b_br{bool=#b_literal{val=true}}),
+    Blk = Blk0#b_blk{is=[Ste],last=Br},
+    Blocks#{Next:=Blk}.
+
+%% Count how many times each variable is used.
+
+count_uses(Blocks) ->
+    count_uses_blk(maps:values(Blocks), #{}).
+
+count_uses_blk([#b_blk{is=Is,last=Last}|Bs], CountMap0) ->
+    F = fun(I, CountMap) ->
+                foldl(fun(Var, Acc) ->
+                              case Acc of
+                                  #{Var:=3} -> Acc;
+                                  #{Var:=C} -> Acc#{Var:=C+1};
+                                  #{} ->       Acc#{Var=>1}
+                              end
+                      end, CountMap, beam_ssa:used(I))
+        end,
+    CountMap = F(Last, foldl(F, CountMap0, Is)),
+    count_uses_blk(Bs, CountMap);
+count_uses_blk([], CountMap) -> CountMap.
+
+decrement_uses(V, Uses) ->
+    #{V:=C} = Uses,
+    Uses#{V:=C-1}.
+
+is_n_uses(N, V, Uses) ->
+    case Uses of
+        #{V:=N} -> true;
+        #{} -> false
+    end.
+
+is_single_use(V, Uses) ->
+    case Uses of
+        #{V:=1} -> true;
+        #{} -> false
+    end.
+
+%%%
 %%% Find out where frames should be placed.
 %%%
 
diff --git a/lib/compiler/src/beam_ssa_type.erl b/lib/compiler/src/beam_ssa_type.erl
index 6fa02da89d..3b5d25efce 100644
--- a/lib/compiler/src/beam_ssa_type.erl
+++ b/lib/compiler/src/beam_ssa_type.erl
@@ -277,12 +277,6 @@ opt_is([#b_set{op=call,args=Args0,dst=Dst}=I0|Is],
         _ ->
             opt_is(Is, Ts, Ds, Fdb, D, Sub, [I|Acc])
     end;
-opt_is([#b_set{op=set_tuple_element}=I0|Is],
-       Ts0, Ds0, Fdb, D, Sub, Acc) ->
-    %% This instruction lacks a return value and destructively updates its
-    %% source, so it needs special handling to update the source type.
-    {Ts, Ds, I} = opt_set_tuple_element(I0, Ts0, Ds0, Sub),
-    opt_is(Is, Ts, Ds, Fdb, D, Sub, [I|Acc]);
 opt_is([#b_set{op=succeeded,args=[Arg],dst=Dst}=I],
        Ts0, Ds0, Fdb, D, Sub0, Acc) ->
     case Ds0 of
@@ -381,28 +375,6 @@ update_arg_types([Arg | Args], [TypeMap0 | TypeMaps], CallId, Ts) ->
 update_arg_types([], [], _CallId, _Ts) ->
     [].
 
-opt_set_tuple_element(#b_set{op=set_tuple_element,args=Args0,dst=Dst}=I0,
-                      Ts0, Ds0, Sub) ->
-    Args = simplify_args(Args0, Sub, Ts0),
-    [Val,#b_var{}=Src,#b_literal{val=N}] = Args,
-
-    SrcType0 = get_type(Src, Ts0),
-    ValType = get_type(Val, Ts0),
-    Index = N + 1,
-
-    #t_tuple{size=Size,elements=Es0} = SrcType0,
-    true = Index =< Size,                     %Assertion.
-
-    Es = set_element_type(Index, ValType, Es0),
-    SrcType = SrcType0#t_tuple{elements=Es},
-
-    I = beam_ssa:normalize(I0#b_set{args=Args}),
-
-    Ts = Ts0#{ Dst => any, Src => SrcType },
-    Ds = Ds0#{ Dst => I },
-
-    {Ts, Ds, I}.
-
 simplify(#b_set{op={bif,'and'},args=Args}=I, Ts) ->
     case is_safe_bool_op(Args, Ts) of
         true ->
diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index c281af57a1..11dea9524b 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -814,8 +814,6 @@ kernel_passes() ->
     %% Optimizations that must be done after all other optimizations.
     [{pass,sys_core_bsm},
      {iff,dcbsm,{listing,"core_bsm"}},
-     {pass,sys_core_dsetel},
-     {iff,dsetel,{listing,"dsetel"}},
 
      {iff,clint,?pass(core_lint_module)},
      {iff,core,?pass(save_core_code)},
@@ -2122,7 +2120,6 @@ pre_load() ->
 	 erl_scan,
 	 sys_core_alias,
 	 sys_core_bsm,
-	 sys_core_dsetel,
 	 sys_core_fold,
 	 v3_core,
 	 v3_kernel],
diff --git a/lib/compiler/src/compiler.app.src b/lib/compiler/src/compiler.app.src
index 108a0ca100..a086a3a8d3 100644
--- a/lib/compiler/src/compiler.app.src
+++ b/lib/compiler/src/compiler.app.src
@@ -65,7 +65,6 @@
 	     rec_env,
 	     sys_core_alias,
 	     sys_core_bsm,
-	     sys_core_dsetel,
 	     sys_core_fold,
 	     sys_core_fold_lists,
 	     sys_core_inline,
diff --git a/lib/compiler/src/sys_core_dsetel.erl b/lib/compiler/src/sys_core_dsetel.erl
deleted file mode 100644
index 9ab83c210f..0000000000
--- a/lib/compiler/src/sys_core_dsetel.erl
+++ /dev/null
@@ -1,360 +0,0 @@
-%%
-%% %CopyrightBegin%
-%%
-%% Copyright Ericsson AB 2002-2018. All Rights Reserved.
-%%
-%% Licensed under the Apache License, Version 2.0 (the "License");
-%% you may not use this file except in compliance with the License.
-%% You may obtain a copy of the License at
-%%
-%%     http://www.apache.org/licenses/LICENSE-2.0
-%%
-%% Unless required by applicable law or agreed to in writing, software
-%% distributed under the License is distributed on an "AS IS" BASIS,
-%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-%% See the License for the specific language governing permissions and
-%% limitations under the License.
-%%
-%% %CopyrightEnd%
-%%
-%% Purpose : Using dsetelement to make multiple-field record updates
-%% faster.
-
-%% The expansion of record field updates, when more than one field is
-%% updated, but not a majority of the fields, will create a sequence of
-%% calls to 'erlang:setelement(Index, Value, Tuple)' where Tuple in the
-%% first call is the original record tuple, and in the subsequent calls
-%% Tuple is the result of the previous call. Furthermore, all Index
-%% values are constant positive integers, and the first call to
-%% 'setelement' will have the greatest index. Thus all the following
-%% calls do not actually need to test at run-time whether Tuple has type
-%% tuple, nor that the index is within the tuple bounds.
-%%
-%% Since this introduces destructive updates in the Core Erlang code, it
-%% must be done as a last stage before going to lower-level code.
-%%
-%% NOTE: Because there are currently no write barriers in the system,
-%% this kind of optimization can only be done when we are sure that
-%% garbage collection will not be triggered between the creation of the
-%% tuple and the destructive updates - otherwise we might insert
-%% pointers from an older generation to a newer.
-%%
-%% The rewriting is done as follows:
-%%
-%%    let X1 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in call 'erlang':'setelement(3, X1, Value2)
-%%  =>
-%%    let X1 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in do primop dsetelement(3, X1, Value2)
-%%       X1
-%% and
-%%    let X1 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in let X2 = call 'erlang':'setelement(3, X1, Value2)
-%%    in ...
-%%  =>
-%%    let X2 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in do primop 'dsetelement(3, X2, Value2)
-%%       ...
-%% if X1 is used exactly once.
-%% Thus, we need to track variable usage.
-%%
-
--module(sys_core_dsetel).
-
--export([module/2]).
-
--include("core_parse.hrl").
-
--spec module(cerl:c_module(), [compile:option()]) -> {'ok', cerl:c_module()}.
-
-module(M0, _Options) ->
-    M = visit_module(M0),
-    {ok,M}.
-
-visit_module(#c_module{defs=Ds0}=R) ->
-    Env = #{},
-    Ds = visit_module_1(Ds0, Env, []),
-    R#c_module{defs=Ds}.
-
-visit_module_1([{Name,F0}|Fs], Env, Acc) ->
-    try visit(Env, F0) of
-	{F,_} ->
-	    visit_module_1(Fs, Env, [{Name,F}|Acc])
-    catch
-        Class:Error:Stack ->
-	    #c_var{name={Func,Arity}} = Name,
-	    io:fwrite("Function: ~w/~w\n", [Func,Arity]),
-	    erlang:raise(Class, Error, Stack)
-    end;
-visit_module_1([], _, Acc) ->
-    lists:reverse(Acc).
-
-visit(Env, #c_var{name={_,_}}=R) ->
-    %% Ignore local function name.
-    {R, Env};
-visit(Env0, #c_var{name=X}=R) ->
-    %% There should not be any free variables. If there are,
-    %% the case will fail with an exception.
-    case Env0 of
-	#{X:=N} ->
-	    {R, Env0#{X:=N+1}}
-    end;
-visit(Env, #c_literal{}=R) ->
-    {R, Env};
-visit(Env0, #c_tuple{es=Es0}=R) ->
-    {Es1,Env1} = visit_list(Env0, Es0),
-    {R#c_tuple{es=Es1}, Env1};
-visit(Env0, #c_map{es=Es0}=R) ->
-    {Es1,Env1} = visit_list(Env0, Es0),
-    {R#c_map{es=Es1}, Env1};
-visit(Env0, #c_map_pair{key=K0,val=V0}=R) ->
-    {K,Env1} = visit(Env0, K0),
-    {V,Env2} = visit(Env1, V0),
-    {R#c_map_pair{key=K,val=V}, Env2};
-visit(Env0, #c_cons{hd=H0,tl=T0}=R) ->
-    {H1,Env1} = visit(Env0, H0),
-    {T1,Env2} = visit(Env1, T0),
-    {R#c_cons{hd=H1,tl=T1}, Env2};
-visit(Env0, #c_binary{segments=Segs}=R) ->
-    Env = visit_bin_segs(Env0, Segs),
-    {R, Env};
-visit(Env0, #c_values{es=Es0}=R) ->
-    {Es1,Env1} = visit_list(Env0, Es0),
-    {R#c_values{es=Es1}, Env1};
-visit(Env0, #c_fun{vars=Vs, body=B0}=R) ->
-    {Xs, Env1} = bind_vars(Vs, Env0),
-    {B1,Env2} = visit(Env1, B0),
-    {R#c_fun{body=B1}, restore_vars(Xs, Env0, Env2)};
-visit(Env0, #c_let{vars=Vs, arg=A0, body=B0}=R) ->
-    {A1,Env1} = visit(Env0, A0),
-    {Xs,Env2} = bind_vars(Vs, Env1),
-    {B1,Env3} = visit(Env2, B0),
-    rewrite(R#c_let{arg=A1,body=B1}, Env3, restore_vars(Xs, Env1, Env3));
-visit(Env0, #c_seq{arg=A0, body=B0}=R) ->
-    {A1,Env1} = visit(Env0, A0),
-    {B1,Env2} = visit(Env1, B0),
-    {R#c_seq{arg=A1,body=B1}, Env2};
-visit(Env0, #c_case{arg=A0,clauses=Cs0}=R) ->
-    {A1,Env1} = visit(Env0, A0),
-    {Cs1,Env2} = visit_list(Env1, Cs0),
-    {R#c_case{arg=A1,clauses=Cs1}, Env2};
-visit(Env0, #c_clause{pats=Ps,guard=G0,body=B0}=R) ->
-    {Vs, Env1} = visit_pats(Ps, Env0),
-    {G1,Env2} = visit(Env1, G0),
-    {B1,Env3} = visit(Env2, B0),
-    {R#c_clause{guard=G1,body=B1}, restore_vars(Vs, Env0, Env3)};
-visit(Env0, #c_receive{clauses=Cs0,timeout=T0,action=A0}=R) ->
-    {T1,Env1} = visit(Env0, T0),
-    {Cs1,Env2} = visit_list(Env1, Cs0),
-    {A1,Env3} = visit(Env2, A0),
-    {R#c_receive{clauses=Cs1,timeout=T1,action=A1}, Env3};
-visit(Env0, #c_apply{op=Op0, args=As0}=R) ->
-    {Op1,Env1} = visit(Env0, Op0),
-    {As1,Env2} = visit_list(Env1, As0),
-    {R#c_apply{op=Op1,args=As1}, Env2};
-visit(Env0, #c_call{module=M0,name=N0,args=As0}=R) ->
-    {M1,Env1} = visit(Env0, M0),
-    {N1,Env2} = visit(Env1, N0),
-    {As1,Env3} = visit_list(Env2, As0),
-    {R#c_call{module=M1,name=N1,args=As1}, Env3};
-visit(Env0, #c_primop{name=N0, args=As0}=R) ->
-    {N1,Env1} = visit(Env0, N0),
-    {As1,Env2} = visit_list(Env1, As0),
-    {R#c_primop{name=N1,args=As1}, Env2};
-visit(Env0, #c_try{arg=E0, vars=Vs, body=B0, evars=Evs, handler=H0}=R) ->
-    {E1,Env1} = visit(Env0, E0),
-    {Xs, Env2} = bind_vars(Vs, Env1),
-    {B1,Env3} = visit(Env2, B0),
-    Env4 = restore_vars(Xs, Env1, Env3),
-    {Ys, Env5} = bind_vars(Evs, Env4),
-    {H1,Env6} = visit(Env5, H0),
-    {R#c_try{arg=E1,body=B1,handler=H1}, restore_vars(Ys, Env4, Env6)};
-visit(Env0, #c_catch{body=B0}=R) ->
-    {B1,Env1} = visit(Env0, B0),
-    {R#c_catch{body=B1}, Env1};
-visit(Env0, #c_letrec{defs=Ds0,body=B0}=R) ->
-    {Xs, Env1} = bind_vars([V || {V,_} <- Ds0], Env0),
-    {Ds1,Env2} = visit_def_list(Env1, Ds0),
-    {B1,Env3} = visit(Env2, B0),
-    {R#c_letrec{defs=Ds1,body=B1}, restore_vars(Xs, Env0, Env3)}.
-%% The following general code for handling modules is slow if a module
-%% contains very many functions. There is special code in visit_module/1
-%% which is much faster.
-%% visit(Env0, #c_module{defs=D0}=R) ->
-%%     {R1,Env1} = visit(Env0, #c_letrec{defs=D0,body=#c_nil{}}),
-%%     {R#c_module{defs=R1#c_letrec.defs}, Env1};
-
-visit_list(Env, L) ->
-    lists:mapfoldl(fun (E, A) -> visit(A, E) end, Env, L).
-
-visit_def_list(Env, L) ->
-    lists:mapfoldl(fun ({Name,V0}, E0) ->
-			   {V1,E1} = visit(E0, V0),
-			   {{Name,V1}, E1}
-		   end, Env, L).
-
-visit_bin_segs(Env, Segs) ->
-    lists:foldl(fun (#c_bitstr{val=Val,size=Sz}, E0) ->
-			{_, E1} = visit(E0, Val),
-			{_, E2} = visit(E1, Sz),
-			E2
-		end, Env, Segs).
-    
-bind_vars(Vs, Env) ->
-    bind_vars(Vs, Env, []).
-
-bind_vars([#c_var{name=X}|Vs], Env0, Xs)->
-    bind_vars(Vs, Env0#{X=>0}, [X|Xs]);
-bind_vars([], Env,Xs) ->
-    {Xs, Env}.
-
-visit_pats(Ps, Env) ->
-    visit_pats(Ps, Env, []).
-
-visit_pats([P|Ps], Env0, Vs0) ->
-    {Vs1, Env1} = visit_pat(Env0, P, Vs0),
-    visit_pats(Ps, Env1, Vs1);
-visit_pats([], Env, Vs) ->
-    {Vs, Env}.
-
-visit_pat(Env0, #c_var{name=V}, Vs) ->
-    {[V|Vs], Env0#{V=>0}};
-visit_pat(Env0, #c_tuple{es=Es}, Vs) ->
-    visit_pats(Es, Env0, Vs);
-visit_pat(Env0, #c_map{es=Es}, Vs) ->
-    visit_pats(Es, Env0, Vs);
-visit_pat(Env0, #c_map_pair{op=#c_literal{val=exact},key=V,val=K}, Vs0) ->
-    {Vs1, Env1} = visit_pat(Env0, V, Vs0),
-    visit_pat(Env1, K, Vs1);
-visit_pat(Env0, #c_cons{hd=H,tl=T}, Vs0) ->
-    {Vs1, Env1} = visit_pat(Env0, H, Vs0),
-    visit_pat(Env1, T, Vs1);
-visit_pat(Env0, #c_binary{segments=Segs}, Vs) ->
-    visit_pats(Segs, Env0, Vs);
-visit_pat(Env0, #c_bitstr{val=Val,size=Sz}, Vs0) ->
-    {Vs1, Env1} =
-	case Sz of
-	    #c_var{name=V} ->
-		%% We don't tolerate free variables.
-		case Env0 of
-		    #{V:=N} ->
-			{Vs0, Env0#{V:=N+1}}
-		end;
-	    _ ->
-		visit_pat(Env0, Sz, Vs0)
-	end,
-    visit_pat(Env1, Val, Vs1);
-visit_pat(Env0, #c_alias{pat=P,var=#c_var{name=V}}, Vs) ->
-    visit_pat(Env0#{V=>0}, P, [V|Vs]);
-visit_pat(Env, #c_literal{}, Vs) ->
-    {Vs, Env}.
-
-restore_vars([V|Vs], Env0, Env1) ->
-    case Env0 of
-	#{V:=N} ->
-	    restore_vars(Vs, Env0, Env1#{V=>N});
-	_ ->
-	    restore_vars(Vs, Env0, maps:remove(V, Env1))
-    end;
-restore_vars([], _, Env1) ->
-    Env1.
-
-
-%%    let X1 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in call 'erlang':'setelement(3, X1, Value2)
-%%  =>
-%%    let X1 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in do primop dsetelement(3, X1, Value2)
-%%       X1
-
-rewrite(#c_let{vars=[#c_var{name=X}=V]=Vs,
-	       arg=#c_call{module=#c_literal{val='erlang'},
-			   name=#c_literal{val='setelement'},
-			   args=[#c_literal{val=Index1}, _Tuple, _Val1]
-			  }=A,
- 	       body=#c_call{anno=Banno,module=#c_literal{val='erlang'},
- 			    name=#c_literal{val='setelement'},
-  			    args=[#c_literal{val=Index2},
-				  #c_var{name=X},
-				  Val2]
-  			   }
-	      }=R,
-	_BodyEnv, FinalEnv)
-  when is_integer(Index1), is_integer(Index2), Index2 > 0, Index1 > Index2 ->
-    case is_safe(Val2) of
-	true ->
-	    {R#c_let{vars=Vs,
-		     arg=A,
-		     body=#c_seq{arg=#c_primop{
-				   anno=Banno,
-				   name=#c_literal{val='dsetelement'},
-				   args=[#c_literal{val=Index2},
-					 V,
-					 Val2]},
-				 body=V}
-		    },
-	     FinalEnv};
-	false ->
-	    {R, FinalEnv}
-    end;
-
-%%    let X1 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in let X2 = 'erlang':'setelement(3, X1, Value2)
-%%    in ...
-%%  =>
-%%    let X2 = call 'erlang':'setelement(5, Tuple, Value1)
-%%    in do primop dsetelement(3, X2, Value2)
-%%       ...
-%% if X1 is used exactly once.
-
-rewrite(#c_let{vars=[#c_var{name=X1}],
-	       arg=#c_call{module=#c_literal{val='erlang'},
-			   name=#c_literal{val='setelement'},
-			   args=[#c_literal{val=Index1}, _Tuple, _Val1]
-			  }=A,
-	       body=#c_let{vars=[#c_var{}=V]=Vs,
-			   arg=#c_call{anno=Banno,
-				       module=#c_literal{val='erlang'},
-				       name=#c_literal{val='setelement'},
-				       args=[#c_literal{val=Index2},
-					     #c_var{name=X1},
-					     Val2]},
-			   body=B}
-	      }=R,
-	BodyEnv, FinalEnv)
-  when is_integer(Index1), is_integer(Index2), Index2 > 0, Index1 > Index2 ->
-    case is_single_use(X1, BodyEnv) andalso is_safe(Val2) of
-	true ->
-	    {R#c_let{vars=Vs,
-		     arg=A,
-		     body=#c_seq{arg=#c_primop{
-				   anno=Banno,
-				   name=#c_literal{val='dsetelement'},
-				   args=[#c_literal{val=Index2},
-					 V,
-					 Val2]},
-				 body=B}
-		    },
-	     FinalEnv};
-	false ->
-	    {R, FinalEnv}
-    end;
-
-rewrite(R, _, FinalEnv) ->
-    {R, FinalEnv}.
-
-%% is_safe(CoreExpr) -> true|false
-%%  Determines whether the Core expression can cause a GC collection at run-time.
-%%  Note: Assumes that the constant pool is turned on.
-
-is_safe(#c_var{}) -> true;
-is_safe(#c_literal{}) -> true;
-is_safe(_) -> false.
-
-is_single_use(V, Env) ->
-    case Env of
-	#{V:=1} ->
-	    true;
-	_ ->
-	    false
-    end.
diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index f7ca66b1da..86351bc0c5 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1414,7 +1414,6 @@ is_remote_bif(_, _, _) -> false.
 %%  return multiple values.  Only used in bodies where a BIF may be
 %%  called for effect only.
 
-bif_vals(dsetelement, 3) -> 0;
 bif_vals(_, _) -> 1.
 
 bif_vals(_, _, _) -> 1.
diff --git a/lib/compiler/test/compile_SUITE.erl b/lib/compiler/test/compile_SUITE.erl
index 78c4bbe9c0..408af80dd9 100644
--- a/lib/compiler/test/compile_SUITE.erl
+++ b/lib/compiler/test/compile_SUITE.erl
@@ -372,7 +372,6 @@ do_file_listings(DataDir, PrivDir, [File|Files]) ->
             {dcore, ".core"},
             {dcopt, ".copt"},
             {dcbsm, ".core_bsm"},
-            {dsetel, ".dsetel"},
             {dkern, ".kernel"},
             {dssa, ".ssa"},
             {dssaopt, ".ssaopt"},
diff --git a/lib/compiler/test/misc_SUITE.erl b/lib/compiler/test/misc_SUITE.erl
index 0f9b2dd21f..a0b415ceaa 100644
--- a/lib/compiler/test/misc_SUITE.erl
+++ b/lib/compiler/test/misc_SUITE.erl
@@ -161,14 +161,13 @@ md5_1(Beam) ->
 %% Cover some code that handles internal errors.
 
 silly_coverage(Config) when is_list(Config) ->
-    %% sys_core_fold, sys_core_alias, sys_core_bsm, sys_core_setel, v3_kernel
+    %% sys_core_fold, sys_core_alias, sys_core_bsm, v3_kernel
     BadCoreErlang = {c_module,[],
 		     name,[],[],
 		     [{{c_var,[],{foo,2}},seriously_bad_body}]},
     expect_error(fun() -> sys_core_fold:module(BadCoreErlang, []) end),
     expect_error(fun() -> sys_core_alias:module(BadCoreErlang, []) end),
     expect_error(fun() -> sys_core_bsm:module(BadCoreErlang, []) end),
-    expect_error(fun() -> sys_core_dsetel:module(BadCoreErlang, []) end),
     expect_error(fun() -> v3_kernel:module(BadCoreErlang, []) end),
 
     %% beam_kernel_to_ssa