Merge branch 'bjorn/compiler/misc'

* bjorn/compiler/misc:
  Eliminate unsafe use of Y registers
  beam_validator: Add is_bitstring/1 as a safe BIF
  beam_validator: Remove uncovered line
  Teach beam_utils:is_pure_test/1 to handle is_bitstr and is_function2
  beam_utils: Simplify handling of 'return' to eliminate uncovered line
  beam_jump: Clean up handling of labels before func_info
  beam_expect: Correctly handle blocks with multiple allocs
  v3_codegen: Don't confuse beam_validator
  v3_codegen: Correct code generation for an error/1 call in a guard
  beam_receive: Don't crash when encountering nonsensical code

7 files changed, 90 insertions, 57 deletions

diff --git a/lib/compiler/src/beam_dead.erl b/lib/compiler/src/beam_dead.erl
index dd42add433..b01f58f683 100644
--- a/lib/compiler/src/beam_dead.erl
+++ b/lib/compiler/src/beam_dead.erl
@@ -262,7 +262,7 @@ backward([{select,select_val,Reg,{f,Fail0},List0}|Is], D, Acc) ->
 backward([{jump,{f,To0}},{move,Src,Reg}=Move|Is], D, Acc) ->
     To = shortcut_select_label(To0, Reg, Src, D),
     Jump = {jump,{f,To}},
-    case beam_utils:is_killed_at(Reg, To, D) of
+    case is_killed_at(Reg, To, D) of
 	false -> backward([Move|Is], D, [Jump|Acc]);
 	true -> backward([Jump|Is], D, Acc)
     end;
@@ -420,7 +420,7 @@ comp_op_find_shortcut(To0, Reg, Val, D) ->
 	To0 ->
 	    not_possible();
 	To ->
-	    case beam_utils:is_killed_at(Reg, To, D) of
+	    case is_killed_at(Reg, To, D) of
 		false -> not_possible();
 		true -> To
 	    end
@@ -863,3 +863,17 @@ get_literal(nil) ->
 get_literal({literal,_}=Lit) ->
     Lit;
 get_literal({_,_}) -> error.
+
+
+%%%
+%%% Removing stores to Y registers is not always safe
+%%% if there is an instruction that causes an exception
+%%% within a catch. In practice, there are few or no
+%%% opportunities for removing stores to Y registers anyway
+%%% if sys_core_fold has been run.
+%%%
+
+is_killed_at({x,_}=Reg, Lbl, D) ->
+    beam_utils:is_killed_at(Reg, Lbl, D);
+is_killed_at({y,_}, _, _) ->
+    false.
diff --git a/lib/compiler/src/beam_except.erl b/lib/compiler/src/beam_except.erl
index cb3a6b79de..4a181c1923 100644
--- a/lib/compiler/src/beam_except.erl
+++ b/lib/compiler/src/beam_except.erl
@@ -133,10 +133,12 @@ translate_exception(_, _, _, _) -> no.
 fix_block(Is, 0) ->
     reverse(Is);
 fix_block(Is, Words) ->
-    fix_block_1(reverse(Is), Words).
+    reverse(fix_block_1(Is, Words)).
 
-fix_block_1([{set,[],[],{alloc,Live,{F1,F2,Needed,F3}}}|Is], Words) ->
-    [{set,[],[],{alloc,Live,{F1,F2,Needed-Words,F3}}}|Is];
+fix_block_1([{set,[],[],{alloc,Live,{F1,F2,Needed0,F3}}}|Is], Words) ->
+    Needed = Needed0 - Words,
+    true = Needed >= 0,				%Assertion.
+    [{set,[],[],{alloc,Live,{F1,F2,Needed,F3}}}|Is];
 fix_block_1([I|Is], Words) ->
     [I|fix_block_1(Is, Words)].
 
diff --git a/lib/compiler/src/beam_jump.erl b/lib/compiler/src/beam_jump.erl
index 359248c6af..09cd3aa2d4 100644
--- a/lib/compiler/src/beam_jump.erl
+++ b/lib/compiler/src/beam_jump.erl
@@ -266,17 +266,17 @@ extract_seq_1(_, _) -> no.
 %%% (3) (4) (5) (6) Jump and unreachable code optimizations.
 %%%
 
--record(st, {fc,				%Label for function class errors.
-	     entry,				%Entry label (must not be moved).
-	     mlbl,				%Moved labels.
-             labels :: cerl_sets:set()          %Set of referenced labels.
-	    }).
-
-opt([{label,Fc}|_]=Is0, CLabel) ->
-    Lbls = initial_labels(Is0),
+-record(st,
+	{
+	  entry,		     %Entry label (must not be moved).
+	  mlbl,			     %Moved labels.
+	  labels :: cerl_sets:set()  %Set of referenced labels.
+	}).
+
+opt(Is0, CLabel) ->
     find_fixpoint(fun(Is) ->
-			  St = #st{fc=Fc,entry=CLabel,mlbl=#{},
-				   labels=Lbls},
+			  Lbls = initial_labels(Is),
+			  St = #st{entry=CLabel,mlbl=#{},labels=Lbls},
 			  opt(Is, [], St)
 		  end, Is0).
 
@@ -327,7 +327,8 @@ opt([{label,Lbl}=I|Is], Acc, #st{mlbl=Mlbl}=St0) ->
 	    %% since we will rescan the inserted labels.  We MUST rescan.
 	    St = St0#st{mlbl=maps:remove(Lbl, Mlbl)},
 	    insert_labels([Lbl|Lbls], Is, Acc, St);
-	error -> opt(Is, [I|Acc], St0)
+	error ->
+	    opt(Is, [I|Acc], St0)
     end;
 opt([{jump,{f,_}=X}|[{label,_},{jump,X}|_]=Is], Acc, St) ->
     opt(Is, Acc, St);
@@ -362,12 +363,19 @@ opt([I|Is], Acc, #st{labels=Used0}=St0) ->
 	true  -> skip_unreachable(Is, [I|Acc], St);
 	false -> opt(Is, [I|Acc], St)
     end;
-opt([], Acc, #st{fc=Fc,mlbl=Mlbl}) ->
+opt([], Acc, #st{mlbl=Mlbl}) ->
     Code = reverse(Acc),
-    case maps:find(Fc, Mlbl) of
- 	{ok,Lbls} -> insert_fc_labels(Lbls, Mlbl, Code);
- 	error -> Code
-    end.
+    insert_fc_labels(Code, Mlbl).
+
+insert_fc_labels([{label,L}=I|Is0], Mlbl) ->
+    case maps:find(L, Mlbl) of
+	error ->
+	    [I|insert_fc_labels(Is0, Mlbl)];
+	{ok,Lbls} ->
+	    Is = [{label,Lb} || Lb <- Lbls] ++ Is0,
+	    [I|insert_fc_labels(Is, maps:remove(L, Mlbl))]
+    end;
+insert_fc_labels([_|_]=Is, _) -> Is.
 
 maps_append_list(K,Vs,M) ->
     case M of
@@ -375,16 +383,6 @@ maps_append_list(K,Vs,M) ->
         _ -> M#{K => Vs}
     end.
 
-insert_fc_labels([L|Ls], Mlbl, Acc0) ->
-    Acc = [{label,L}|Acc0],
-    case maps:find(L, Mlbl) of
-	error ->
-	    insert_fc_labels(Ls, Mlbl, Acc);
-	{ok,Lbls} ->
-	    insert_fc_labels(Lbls++Ls, Mlbl, Acc)
-    end;
-insert_fc_labels([], _, Acc) -> Acc.
-
 collect_labels(Is, #st{entry=Entry}) ->
     collect_labels_1(Is, Entry, []).
 
diff --git a/lib/compiler/src/beam_receive.erl b/lib/compiler/src/beam_receive.erl
index c593184746..89cafe27ce 100644
--- a/lib/compiler/src/beam_receive.erl
+++ b/lib/compiler/src/beam_receive.erl
@@ -177,7 +177,8 @@ opt_recv([I|Is], D, R0, L0, Acc) ->
 	    no;
 	false ->
 	    opt_recv(Is, D, R, L, [I|Acc])
-    end.
+    end;
+opt_recv([], _, _, _, _) -> no.
 
 opt_update_regs({block,Bl}, R, L) ->
     {opt_update_regs_bl(Bl, R),L};
diff --git a/lib/compiler/src/beam_utils.erl b/lib/compiler/src/beam_utils.erl
index 47703b4aa3..a15ecf633e 100644
--- a/lib/compiler/src/beam_utils.erl
+++ b/lib/compiler/src/beam_utils.erl
@@ -167,8 +167,7 @@ bif_to_test(is_record, [_,_,_]=Ops, Fail) -> {test,is_record,Fail,Ops}.
 
 %% is_pure_test({test,Op,Fail,Ops}) -> true|false.
 %%  Return 'true' if the test instruction does not modify any
-%%  registers and/or bit syntax matching state, nor modifies
-%%  any bit syntax matching state.
+%%  registers and/or bit syntax matching state.
 %%
 is_pure_test({test,is_eq,_,[_,_]}) -> true;
 is_pure_test({test,is_ne,_,[_,_]}) -> true;
@@ -180,6 +179,8 @@ is_pure_test({test,is_nil,_,[_]}) -> true;
 is_pure_test({test,is_nonempty_list,_,[_]}) -> true;
 is_pure_test({test,test_arity,_,[_,_]}) -> true;
 is_pure_test({test,has_map_fields,_,[_|_]}) -> true;
+is_pure_test({test,is_bitstr,_,[_]}) -> true;
+is_pure_test({test,is_function2,_,[_,_]}) -> true;
 is_pure_test({test,Op,_,Ops}) -> 
     erl_internal:new_type_test(Op, length(Ops)).
 
@@ -324,8 +325,11 @@ check_liveness(R, [{deallocate,_}|Is], St) ->
 	{y,_} -> {killed,St};
 	_ -> check_liveness(R, Is, St)
     end;
-check_liveness(R, [return|_], St) ->
-    check_liveness_live_ret(R, 1, St);
+check_liveness({x,_}=R, [return|_], St) ->
+    case R of
+	{x,0} -> {used,St};
+	{x,_} -> {killed,St}
+    end;
 check_liveness(R, [{call,Live,_}|Is], St) ->
     case R of
 	{x,X} when X < Live -> {used,St};
@@ -534,14 +538,6 @@ check_liveness_at(R, Lbl, #live{lbl=Ll,res=ResMemorized}=St0) ->
 check_liveness_ret(R, R, St) -> {used,St};
 check_liveness_ret(_, _, St) -> {killed,St}.
 
-check_liveness_live_ret({x,R}, Live, St) ->
-    if
-	R < Live -> {used,St};
-	true -> {killed,St}
-    end;
-check_liveness_live_ret({y,_}, _, St) ->
-    {killed,St}.
-
 check_liveness_fail(_, _, _, 0, St) ->
     {killed,St};
 check_liveness_fail(R, Op, Args, Fail, St) ->
diff --git a/lib/compiler/src/beam_validator.erl b/lib/compiler/src/beam_validator.erl
index faff9940ec..1af17dc641 100644
--- a/lib/compiler/src/beam_validator.erl
+++ b/lib/compiler/src/beam_validator.erl
@@ -1510,7 +1510,6 @@ bif_type(node, [_], _) -> {atom,[]};
 bif_type(hd, [_], _) -> term;
 bif_type(tl, [_], _) -> term;
 bif_type(get, [_], _) -> term;
-bif_type(raise, [_,_], _) -> exception;
 bif_type(Bif, _, _) when is_atom(Bif) -> term.
 
 is_bif_safe('/=', 2) -> true;
@@ -1524,6 +1523,7 @@ is_bif_safe('>=', 2) -> true;
 is_bif_safe(is_atom, 1) -> true;
 is_bif_safe(is_boolean, 1) -> true;
 is_bif_safe(is_binary, 1) -> true;
+is_bif_safe(is_bitstring, 1) -> true;
 is_bif_safe(is_float, 1) -> true;
 is_bif_safe(is_function, 1) -> true;
 is_bif_safe(is_integer, 1) -> true;
diff --git a/lib/compiler/src/v3_codegen.erl b/lib/compiler/src/v3_codegen.erl
index f531056591..f5f3c73793 100644
--- a/lib/compiler/src/v3_codegen.erl
+++ b/lib/compiler/src/v3_codegen.erl
@@ -1089,6 +1089,23 @@ protected_cg(Ts, Rs, _Fail, I, Vdb, Bef, St0) ->
 %% test_cg(TestName, Args, Fail, I, Vdb, Bef, St) -> {[Ainstr],Aft,St}.
 %%  Generate test instruction.  Use explicit fail label here.
 
+test_cg(is_map, [A], Fail, I, Vdb, Bef, St) ->
+    %% We must avoid creating code like this:
+    %%
+    %%   move x(0) y(0)
+    %%   is_map Fail [x(0)]
+    %%   make_fun => x(0)  %% Overwrite x(0)
+    %%   put_map_assoc y(0) ...
+    %%
+    %% The code is safe, but beam_validator does not understand that.
+    %% Extending beam_validator to handle such (rare) code as the
+    %% above would make it slower for all programs. Instead, change
+    %% the code generator to always prefer the Y register for is_map()
+    %% and put_map_assoc() instructions, ensuring that they use the
+    %% same register.
+    Arg = cg_reg_arg_prefer_y(A, Bef),
+    Aft = clear_dead(Bef, I, Vdb),
+    {[{test,is_map,{f,Fail},[Arg]}],Aft,St};
 test_cg(Test, As, Fail, I, Vdb, Bef, St) ->
     Args = cg_reg_args(As, Bef),
     Aft = clear_dead(Bef, I, Vdb),
@@ -1155,19 +1172,15 @@ call_cg(Func, As, Rs, Le, Vdb, Bef, St0) ->
 	    %% Inside a guard. The only allowed function call is to
 	    %% erlang:error/1,2. We will generate the following code:
 	    %%
-	    %%     jump FailureLabel
 	    %%     move {atom,ok} DestReg
-	    %%
-	    %% The 'move' instruction will never be executed, but we
-	    %% generate it anyway in case the beam_validator is run
-	    %% on unoptimized code.
+	    %%     jump FailureLabel
 	    {remote,{atom,erlang},{atom,error}} = Func,	%Assertion.
 	    [{var,DestVar}] = Rs,
 	    Int0 = clear_dead(Bef, Le#l.i, Vdb),
 	    Reg = put_reg(DestVar, Int0#sr.reg),
 	    Int = Int0#sr{reg=Reg},
 	    Dst = fetch_reg(DestVar, Reg),
-	    {[{jump,{f,Fail}},{move,{atom,ok},Dst}],
+	    {[{move,{atom,ok},Dst},{jump,{f,Fail}}],
 	     clear_dead(Int, Le#l.i, Vdb),St0};
 	#cg{} ->
 	    %% Ordinary function call in a function body.
@@ -1545,7 +1558,7 @@ set_cg([{var,R}], {map,Op,Map,[{map_pair,{var,_}=K,V}]}, Le, Vdb, Bef,
     Fail = {f,Bfail},
     {Sis,Int0} = maybe_adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb, St),
 
-    SrcReg = cg_reg_arg(Map,Int0),
+    SrcReg = cg_reg_arg_prefer_y(Map, Int0),
     Line = line(Le#l.a),
 
     List = [cg_reg_arg(K,Int0),cg_reg_arg(V,Int0)],
@@ -1572,7 +1585,7 @@ set_cg([{var,R}], {map,Op,Map,Es}, Le, Vdb, Bef,
 
     Fail = {f,Bfail},
     {Sis,Int0} = maybe_adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb, St),
-    SrcReg = cg_reg_arg(Map,Int0),
+    SrcReg = cg_reg_arg_prefer_y(Map, Int0),
     Line = line(Le#l.a),
 
     %% fetch registers for values to be put into the map
@@ -1845,6 +1858,9 @@ cg_reg_args(As, Bef) -> [cg_reg_arg(A, Bef) || A <- As].
 cg_reg_arg({var,V}, Bef) -> fetch_var(V, Bef);
 cg_reg_arg(Literal, _) -> Literal.
 
+cg_reg_arg_prefer_y({var,V}, Bef) -> fetch_var_prefer_y(V, Bef);
+cg_reg_arg_prefer_y(Literal, _) -> Literal.
+
 %% cg_setup_call([Arg], Bef, Cur, Vdb) -> {[Instr],Aft}.
 %%  Do the complete setup for a call/enter.
 
@@ -2086,6 +2102,12 @@ fetch_var(V, Sr) ->
 	error -> fetch_stack(V, Sr#sr.stk)
     end.
 
+fetch_var_prefer_y(V, #sr{reg=Reg,stk=Stk}) ->
+    case find_stack(V, Stk) of
+	{ok,R} -> R;
+	error -> fetch_reg(V, Reg)
+    end.
+
 load_vars(Vs, Regs) ->
     foldl(fun ({var,V}, Rs) -> put_reg(V, Rs) end, Regs, Vs).
 
@@ -2159,11 +2181,11 @@ fetch_stack(Var, Stk) -> fetch_stack(Var, Stk, 0).
 fetch_stack(V, [{V}|_], I) -> {yy,I};
 fetch_stack(V, [_|Stk], I) -> fetch_stack(V, Stk, I+1).
 
-% find_stack(Var, Stk) -> find_stack(Var, Stk, 0).
+find_stack(Var, Stk) -> find_stack(Var, Stk, 0).
 
-% find_stack(V, [{V}|Stk], I) -> {ok,{yy,I}};
-% find_stack(V, [O|Stk], I) -> find_stack(V, Stk, I+1);
-% find_stack(V, [], I) -> error.
+find_stack(V, [{V}|_], I) -> {ok,{yy,I}};
+find_stack(V, [_|Stk], I) -> find_stack(V, Stk, I+1);
+find_stack(_, [], _) -> error.
 
 on_stack(V, Stk) -> keymember(V, 1, Stk).