Handle rare compiler crash in ssa_opt_destructive_update

Resolves #10077

Author: bjorng

lib/compiler/src/beam_ssa_codegen.erl

@@ -1177,6 +1177,27 @@ cg_block([#cg_set{op=bs_create_bin,dst=Dst0,args=Args0,anno=Anno}=I,
                end,
     Is = [Line,{bs_create_bin,Fail,Alloc,Live,Unit,Dst,{list,Args}}],
     {Is++TypeInfo,St};
+cg_block([#cg_set{op=bs_create_bin,
+                  anno=#{append_string_to_writable := true}=Anno,
+                  dst=Dst0,args=Args0}=I|Is0],
+         Context, St0) ->
+    %% This instruction originates from a literal patched by the
+    %% beam_ssa_destructive_update pass.
+    {Is1,St} = cg_block(Is0, Context, St0),
+    Args1 = typed_args(Args0, Anno, St0),
+    Fail = {f,0},
+    Line = line(Anno),
+    Alloc = map_get(alloc, Anno),
+    Live = get_live(I),
+    Dst = beam_arg(Dst0, St0),
+    Args = bs_args(Args1),
+    Unit = 256,
+    TypeInfo = [{'%',{var_info,Dst,
+                      [{type,#t_bitstring{size_unit=Unit,
+                                          appendable=true}}]}}],
+    Is2 = [Line,{bs_create_bin,Fail,Alloc,Live,Unit,Dst,{list,Args}}],
+    Is = Is2 ++ TypeInfo ++ Is1,
+    {Is,St};
 cg_block([#cg_set{op=bs_start_match,
                   dst=Ctx0,
                   args=[#b_literal{val=new},Bin0]}=I,

lib/compiler/src/beam_ssa_destructive_update.erl

@@ -906,6 +906,28 @@ patch_literal_term(<<>>, {self,init_writable}, Cnt0) ->
     {V,Cnt} = new_var(Cnt0),
     I = #b_set{op=bs_init_writable,dst=V,args=[#b_literal{val=256}]},
     {V,[I],Cnt};
+patch_literal_term(<<Bits/bits>>, {self,init_writable}, Cnt0) ->
+    {VWr,Cnt1} = new_var(Cnt0),
+    {VAppend,Cnt} = new_var(Cnt1),
+    I = #b_set{op=bs_init_writable,dst=VWr,args=[#b_literal{val=256}]},
+
+    %% Normally a `bs_create_bin` instruction must be followed by a
+    %% `succeeded` instruction and a `br` terminator. Currently,
+    %% without extensive refactoring, we are unable to generate such
+    %% instruction sequences here. Therefore, since we KNOW that this
+    %% instruction cannot be used in a guard and cannot fail, we can
+    %% cheat by omitting the `succeeded` instruction and instead
+    %% extend beam_ssa_codegen to handle this special case.
+    Segments = [#b_literal{val=private_append},
+                #b_literal{val=[1,{segment,1}]},VWr,
+                #b_literal{val=all},
+                #b_literal{val=binary},
+                #b_literal{val=[1,{segment,2}]},#b_literal{val=Bits},
+                #b_literal{val=all}],
+    Anno = #{append_string_to_writable => true,
+             arg_types => #{2 => #t_bitstring{size_unit=256,appendable=true}}},
+    Append = #b_set{op=bs_create_bin,anno=Anno,dst=VAppend,args=Segments},
+    {VAppend,[Append,I],Cnt};
 patch_literal_term(Lst, {hd,_,_}=E, Cnt0) ->
     patch_literal_list(Lst, E, Cnt0);
 patch_literal_term(Lit, [], Cnt) ->

lib/compiler/test/bs_construct_SUITE.erl

@@ -763,6 +763,9 @@ private_append(_Config) ->
     <<>> = private_append_2(false),
     {'EXIT', _} = catch private_append_2(true),
 
+    {ok,<<>>} = private_append_3(id(<<>>)),
+    {error,<<"wrong parity">>} = private_append_3(id(<<1>>)),
+
     ok.
 
 %% GH-7121: Alias analysis would not mark fun arguments as aliased,
@@ -777,3 +780,21 @@ private_append_1(M) when is_map(M) ->
 %% GH-7142: The private append pass crashed on oddly structured code.
 private_append_2(Boolean) ->
     <<<<(id(Boolean) orelse <<>>)/binary>>/binary>>.
+
+%% GH-10077. Would crash when attempting patch the
+%% {error, <<"wrong parity">>} tuple.
+private_append_3(Input) ->
+    private_append_3(Input, {ok, <<>>}).
+
+private_append_3(_, {error, Msg}) ->
+    {error, Msg};
+private_append_3(<<>>, {ok, Acc}) ->
+    {ok, Acc};
+private_append_3(<<B/bitstring>>, {ok, Acc}) ->
+    case B of
+        <<>> ->
+            private_append_3(<<>>, {ok, <<Acc/bitstring>>});
+        _ ->
+            %% The compiler would fail to patch this tuple.
+            private_append_3(<<>>, {error, <<"wrong parity">>})
+    end.