compiler: Simplify set_tuple_element optimization

By removing 'succeeded' tests on setelement/3 when we know it
succeeds, all sequences that are eligible for set_tuple_element
will be nicely bundled in the same block, so we won't need to
bother with special try/catch handling.

The new version is slightly worse in the case where the first
setelement/3 is used to infer the tuple size as that call will
remain in its own block, but in practice this only occurs when
the user manually spells them out and I couldn't find any
examples of this in OTP or Elixir. It's equivalent for record
updates.

3 files changed, 23 insertions, 88 deletions

diff --git a/lib/compiler/src/beam_call_types.erl b/lib/compiler/src/beam_call_types.erl
index 4cda2f2610..904d82a62d 100644
--- a/lib/compiler/src/beam_call_types.erl
+++ b/lib/compiler/src/beam_call_types.erl
@@ -57,6 +57,13 @@ will_succeed(erlang, map_size, [Arg]) ->
     succeeds_if_type(Arg, #t_map{});
 will_succeed(erlang, 'not', [Arg]) ->
     succeeds_if_type(Arg, beam_types:make_boolean());
+will_succeed(erlang, setelement, [#t_integer{elements={Min,Max}},
+                                  #t_tuple{exact=Exact,size=Size}, _]) ->
+    case Min >= 1 andalso Max =< Size of
+        true -> yes;
+        false when Exact -> no;
+        false -> maybe
+    end;
 will_succeed(erlang, size, [Arg]) ->
     succeeds_if_type(Arg, #t_bitstring{});
 will_succeed(erlang, tuple_size, [Arg]) ->
diff --git a/lib/compiler/src/beam_ssa_pre_codegen.erl b/lib/compiler/src/beam_ssa_pre_codegen.erl
index 89053c7b9f..9847b87b18 100644
--- a/lib/compiler/src/beam_ssa_pre_codegen.erl
+++ b/lib/compiler/src/beam_ssa_pre_codegen.erl
@@ -1062,9 +1062,8 @@ use_set_tuple_element(#st{ssa=Blocks0}=St) ->
     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,
+use_ste_1([L|Ls], Uses, Blocks) ->
+    #b_blk{is=Is0} = Blk0 = map_get(L, Blocks),
     case use_ste_is(Is0, Uses) of
         Is0 ->
             use_ste_1(Ls, Uses, Blocks);
@@ -1127,69 +1126,6 @@ extract_ste(#b_set{op=call,dst=Dst,
     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) ->
@@ -1199,7 +1135,7 @@ 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:=2} -> Acc;
                                   #{Var:=C} -> Acc#{Var:=C+1};
                                   #{} ->       Acc#{Var=>1}
                               end
@@ -1209,16 +1145,6 @@ count_uses_blk([#b_blk{is=Is,last=Last}|Bs], CountMap0) ->
     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;
diff --git a/lib/compiler/src/beam_validator.erl b/lib/compiler/src/beam_validator.erl
index 0fc3593265..f3c1ccc53f 100644
--- a/lib/compiler/src/beam_validator.erl
+++ b/lib/compiler/src/beam_validator.erl
@@ -463,6 +463,19 @@ valfun_1({put,Src}, Vst0) ->
             St = St0#st{puts_left={PutsLeft-1,{Dst,Sz,Es}}},
             Vst#vst{current=St}
     end;
+%% This instruction never fails, though it may be invalid in some contexts; see
+%% val_dsetel/2
+valfun_1({set_tuple_element,Src,Tuple,N}, Vst) ->
+    I = N + 1,
+    assert_term(Src, Vst),
+    assert_type(#t_tuple{size=I}, Tuple, Vst),
+    %% Manually update the tuple type; we can't rely on the ordinary update
+    %% helpers as we must support overwriting (rather than just widening or
+    %% narrowing) known elements, and we can't use extract_term either since
+    %% the source tuple may be aliased.
+    #t_tuple{elements=Es0}=Type = normalize(get_term_type(Tuple, Vst)),
+    Es = beam_types:set_element_type(I, get_term_type(Src, Vst), Es0),
+    override_type(Type#t_tuple{elements=Es}, Tuple, Vst);
 %% Instructions for optimization of selective receives.
 valfun_1({recv_mark,{f,Fail}}, Vst) when is_integer(Fail) ->
     Vst;
@@ -765,17 +778,6 @@ valfun_4(timeout, Vst) ->
     prune_x_regs(0, Vst);
 valfun_4(send, Vst) ->
     call(send, 2, Vst);
-valfun_4({set_tuple_element,Src,Tuple,N}, Vst) ->
-    I = N + 1,
-    assert_term(Src, Vst),
-    assert_type(#t_tuple{size=I}, Tuple, Vst),
-    %% Manually update the tuple type; we can't rely on the ordinary update
-    %% helpers as we must support overwriting (rather than just widening or
-    %% narrowing) known elements, and we can't use extract_term either since
-    %% the source tuple may be aliased.
-    #t_tuple{elements=Es0}=Type = normalize(get_term_type(Tuple, Vst)),
-    Es = beam_types:set_element_type(I, get_term_type(Src, Vst), Es0),
-    override_type(Type#t_tuple{elements=Es}, Tuple, Vst);
 %% Match instructions.
 valfun_4({select_val,Src,{f,Fail},{list,Choices}}, Vst) ->
     assert_term(Src, Vst),