Take fail labels into account when determining liveness in block ops

2 files changed, 52 insertions, 26 deletions

diff --git a/lib/compiler/src/beam_utils.erl b/lib/compiler/src/beam_utils.erl
index 249d9395ca..e743abc773 100644
--- a/lib/compiler/src/beam_utils.erl
+++ b/lib/compiler/src/beam_utils.erl
@@ -783,37 +783,46 @@ live_opt([{recv_mark,_}=I|Is], Regs, D, Acc) ->
 
 live_opt([], _, _, Acc) -> Acc.
 
-live_opt_block([{set,Ds,Ss,Op}=I0|Is], Regs0, D, Acc) ->
+live_opt_block([{set,Ds,Ss,Op0}|Is], Regs0, D, Acc) ->
     Regs1 = x_live(Ss, x_dead(Ds, Regs0)),
-    {I,Regs} = case Op of
-		   {alloc,Live0,Alloc} ->
-		       %% The life-time analysis used by the code generator
-		       %% is sometimes too conservative, so it may be
-		       %% possible to lower the number of live registers
-		       %% based on the exact liveness information.
-		       %% The main benefit is that more optimizations that
-		       %% depend on liveness information (such as the
-		       %% beam_bool and beam_dead passes) may be applied.
-		       Live = live_regs(Regs1),
-		       true = Live =< Live0,	%Assertion.
-		       I1 = {set,Ds,Ss,{alloc,Live,Alloc}},
-		       {I1,live_call(Live)};
-		   _ ->
-		       {I0,Regs1}
-	       end,
+    {Op, Regs} = live_opt_block_op(Op0, Regs1, D),
+    I = {set, Ds, Ss, Op},
+
     case Ds of
-	[{x,X}] ->
-	    case (not is_live(X, Regs0)) andalso Op =:= move of
-		true ->
-		    live_opt_block(Is, Regs0, D, Acc);
-		false ->
-		    live_opt_block(Is, Regs, D, [I|Acc])
-	    end;
-	_ ->
-	    live_opt_block(Is, Regs, D, [I|Acc])
+        [{x,X}] ->
+            case (not is_live(X, Regs0)) andalso Op =:= move of
+                true ->
+                    live_opt_block(Is, Regs0, D, Acc);
+                false ->
+                    live_opt_block(Is, Regs, D, [I|Acc])
+            end;
+        _ ->
+            live_opt_block(Is, Regs, D, [I|Acc])
     end;
 live_opt_block([], Regs, _, Acc) -> {Acc,Regs}.
 
+live_opt_block_op({alloc,Live0,AllocOp}, Regs0, D) ->
+    Regs =
+        case AllocOp of
+            {Kind, _N, Fail} when Kind =:= gc_bif; Kind =:= put_map ->
+                live_join_label(Fail, D, Regs0);
+            _ ->
+                Regs0
+        end,
+
+    %% The life-time analysis used by the code generator is sometimes too
+    %% conservative, so it may be possible to lower the number of live
+    %% registers based on the exact liveness information. The main benefit is
+    %% that more optimizations that depend on liveness information (such as the
+    %% beam_bool and beam_dead passes) may be applied.
+    Live = live_regs(Regs),
+    true = Live =< Live0,
+    {{alloc,Live,AllocOp}, live_call(Live)};
+live_opt_block_op({bif,_N,Fail} = Op, Regs, D) ->
+    {Op, live_join_label(Fail, D, Regs)};
+live_opt_block_op(Op, Regs, _D) ->
+    {Op, Regs}.
+
 live_join_labels([{f,L}|T], D, Regs0) when L =/= 0 ->
     Regs = gb_trees:get(L, D) bor Regs0,
     live_join_labels(T, D, Regs);
diff --git a/lib/compiler/test/beam_utils_SUITE.erl b/lib/compiler/test/beam_utils_SUITE.erl
index b76b4d17df..ac734a70be 100644
--- a/lib/compiler/test/beam_utils_SUITE.erl
+++ b/lib/compiler/test/beam_utils_SUITE.erl
@@ -260,6 +260,14 @@ otp_8949_b(A, B) ->
 liveopt(_Config) ->
     F = liveopt_fun(42, pebkac, user),
     void = F(42, #alarmInfo{type=sctp,cause=pebkac,origin=user}),
+
+
+    A = {#alarmInfo{cause = {abc, def}}, ghi},
+    A = liveopt_guard_bif(A),
+
+    B = {#alarmInfo{cause = {abc}}, def},
+    {#alarmInfo{cause = {{abc}}}, def} = liveopt_guard_bif(B),
+
     ok.
 
 liveopt_fun(Peer, Cause, Origin) ->
@@ -271,6 +279,15 @@ liveopt_fun(Peer, Cause, Origin) ->
 	    void
     end.
 
+liveopt_guard_bif({#alarmInfo{cause=F}=R, X}=A) ->
+    %% ERIERL-48
+    if
+        is_tuple(F), tuple_size(F) == 2 -> A;
+        true ->
+            R2 = R#alarmInfo{cause={F}},
+            {R2,X}
+    end.
+
 %% Thanks to QuickCheck.
 coverage(_Config) ->
     42+7 = merchant([[],7,false]),