beam_dead: Improve optimization of literal binary matching

When the bit syntax is used to match a single binary literal, the bit
syntax instructions will be replaced with a comparison to a binary
literal. The only problem is that the bs_context_to_binary instruction
will not be eliminated.

Example:

f(<<"string">>) ->
   ok.

This function would be translated to:

{function, f, 1, 2}.
  {label,1}.
    {line,...}.
    {func_info,...}.
  {label,2}.
    {test,is_eq_exact,{f,3},[{x,0},{literal,<<"string">>}]}.
    {move,{atom,ok},{x,0}}.
    return.
  {label,3}.
    {bs_context_to_binary,{x,0}}.
    {jump,{f,1}}.

The bs_context_to_binary instruction serves no useful purpose,
since {x,0} can never be a match context. Eliminating the
instruction, the resulting code will be:

{function, f, 1, 2}.
  {label,1}.
    {line,...}.
    {func_info,...}.
  {label,2}.
    {test,is_eq_exact,{f,1},[{x,0},{literal,<<"string">>}]}.
    {move,{atom,ok},{x,0}}.
    return.

1 files changed, 5 insertions, 2 deletions

diff --git a/lib/compiler/src/beam_dead.erl b/lib/compiler/src/beam_dead.erl
index fcd108bd89..11129c39bc 100644
--- a/lib/compiler/src/beam_dead.erl
+++ b/lib/compiler/src/beam_dead.erl
@@ -272,14 +272,17 @@ backward([{jump,{f,To}}=J|[{bif,Op,_,Ops,Reg}|Is]=Is0], D, Acc) ->
     catch
 	throw:not_possible -> backward(Is0, D, [J|Acc])
     end;
-backward([{test,bs_start_match2,F,_,[R,_],Ctxt}=I|Is], D,
+backward([{test,bs_start_match2,F,Live,[R,_]=Args,Ctxt}|Is], D,
 	 [{test,bs_match_string,F,[Ctxt,Bs]},
 	  {test,bs_test_tail2,F,[Ctxt,0]}|Acc0]=Acc) ->
+    {f,To0} = F,
+    To = shortcut_bs_start_match(To0, R, D),
     case beam_utils:is_killed(Ctxt, Acc0, D) of
 	true ->
-	    Eq = {test,is_eq_exact,F,[R,{literal,Bs}]},
+	    Eq = {test,is_eq_exact,{f,To},[R,{literal,Bs}]},
 	    backward(Is, D, [Eq|Acc0]);
 	false ->
+	    I = {test,bs_start_match2,{f,To},Live,Args,Ctxt},
 	    backward(Is, D, [I|Acc])
     end;
 backward([{test,bs_start_match2,{f,To0},Live,[Src|_]=Info,Dst}|Is], D, Acc) ->