Merge branch 'bjorn/compiler/misc'

* bjorn/compiler/misc:
  beam_utils: Correct break in conventions for split_even/1 and join_even/1
  beam_utils: Remove clause checking for illegal set/4 instruction
  beam_utils: Simplify the return value for check_liveness/3
  beam_utils: Remove unused code
  beam_utils: Let code_at/2 fail if the label does not exist
  beam_utils: Remove unused handling of try/3 in live_opt/4
  beam_utils: Correct translation of BIFs to tests
  core_pp: Remove uncovered clause in is_simple_term/1
  core_pp: Crash on unhandled Core Erlang forms
  core_pp: Remove unused clauses in unindent/3 to improve coverage
  core_pp: Remove useless try...catch
  core_pp: Simplify printing of map literals
  compile_SUITE: Cover numeric variable names in core_pp
  compile_SUITE: Eliminate clones when re-compiling test suites
  test_lib: Add is_cloned_mod/1
  trycatch_SUITE: Cover the only uncovered line in sys_core_fold
  test_lib: Correct calculation of number of processes

1 files changed, 42 insertions, 61 deletions

diff --git a/lib/compiler/src/beam_utils.erl b/lib/compiler/src/beam_utils.erl
index 37f89dd677..47703b4aa3 100644
--- a/lib/compiler/src/beam_utils.erl
+++ b/lib/compiler/src/beam_utils.erl
@@ -25,9 +25,8 @@
 	 is_not_used/3,is_not_used_at/3,
 	 empty_label_index/0,index_label/3,index_labels/1,
 	 code_at/2,bif_to_test/3,is_pure_test/1,
-	 live_opt/1,delete_live_annos/1,combine_heap_needs/2]).
-
--export([join_even/2,split_even/1]).
+	 live_opt/1,delete_live_annos/1,combine_heap_needs/2,
+	 join_even/2,split_even/1]).
 
 -import(lists, [member/2,sort/1,reverse/1,splitwith/2]).
 
@@ -67,8 +66,7 @@ is_killed(R, Is, D) ->
     St = #live{bl=check_killed_block_fun(),lbl=D,res=gb_trees:empty()},
     case check_liveness(R, Is, St) of
 	{killed,_} -> true;
-	{used,_} -> false;
-	{unknown,_} -> false
+	{used,_} -> false
     end.
 
 %% is_killed_at(Reg, Lbl, State) -> true|false
@@ -78,8 +76,7 @@ is_killed_at(R, Lbl, D) when is_integer(Lbl) ->
     St0 = #live{bl=check_killed_block_fun(),lbl=D,res=gb_trees:empty()},
     case check_liveness_at(R, Lbl, St0) of
 	{killed,_} -> true;
-	{used,_} -> false;
-	{unknown,_} -> false
+	{used,_} -> false
     end.
 
 %% is_not_used(Register, [Instruction], State) -> true|false
@@ -93,8 +90,7 @@ is_not_used(R, Is, D) ->
     St = #live{bl=fun check_used_block/3,lbl=D,res=gb_trees:empty()},
     case check_liveness(R, Is, St) of
 	{killed,_} -> true;
-	{used,_} -> false;
-	{unknown,_} -> false
+	{used,_} -> false
     end.
 
 %% is_not_used(Register, [Instruction], State) -> true|false
@@ -108,8 +104,7 @@ is_not_used_at(R, Lbl, D) ->
     St = #live{bl=fun check_used_block/3,lbl=D,res=gb_trees:empty()},
     case check_liveness_at(R, Lbl, St) of
 	{killed,_} -> true;
-	{used,_} -> false;
-	{unknown,_} -> false
+	{used,_} -> false
     end.
 
 %% index_labels(FunctionIs) -> State
@@ -137,10 +132,7 @@ index_label(Lbl, Is0, Acc) ->
 %%  Retrieve the code at the given label.
 
 code_at(L, Ll) ->
-    case gb_trees:lookup(L, Ll) of
-	{value,Code} -> Code;
-	none -> none
-    end.
+    gb_trees:get(L, Ll).
 
 %% bif_to_test(Bif, [Op], Fail) -> {test,Test,Fail,[Op]}
 %%  Convert a BIF to a test. Fail if not possible.
@@ -164,10 +156,10 @@ bif_to_test('=<', [A,B], Fail) -> {test,is_ge,Fail,[B,A]};
 bif_to_test('>', [A,B], Fail) -> {test,is_lt,Fail,[B,A]};
 bif_to_test('<', [_,_]=Ops, Fail) -> {test,is_lt,Fail,Ops};
 bif_to_test('>=', [_,_]=Ops, Fail) -> {test,is_ge,Fail,Ops};
-bif_to_test('==', [A,[]], Fail) -> {test,is_nil,Fail,[A]};
+bif_to_test('==', [A,nil], Fail) -> {test,is_nil,Fail,[A]};
 bif_to_test('==', [_,_]=Ops, Fail) -> {test,is_eq,Fail,Ops};
 bif_to_test('/=', [_,_]=Ops, Fail) -> {test,is_ne,Fail,Ops};
-bif_to_test('=:=', [A,[]], Fail) -> {test,is_nil,Fail,[A]};
+bif_to_test('=:=', [A,nil], Fail) -> {test,is_nil,Fail,[A]};
 bif_to_test('=:=', [_,_]=Ops, Fail) -> {test,is_eq_exact,Fail,Ops};
 bif_to_test('=/=', [_,_]=Ops, Fail) -> {test,is_ne_exact,Fail,Ops};
 bif_to_test(is_record, [_,_,_]=Ops, Fail) -> {test,is_record,Fail,Ops}.
@@ -235,21 +227,28 @@ combine_heap_needs(Words, {alloc,Alloc}) when is_integer(Words) ->
 combine_heap_needs(H1, H2) when is_integer(H1), is_integer(H2) ->
     H1+H2.
 
+%% split_even/1
+%% [1,2,3,4,5,6] -> {[1,3,5],[2,4,6]}
+
+split_even(Rs) -> split_even(Rs, [], []).
+
+%% join_even/1
+%% {[1,3,5],[2,4,6]} -> [1,2,3,4,5,6]
+
+join_even([], []) -> [];
+join_even([S|Ss], [D|Ds]) -> [S,D|join_even(Ss, Ds)].
+
 %%%
 %%% Local functions.
 %%%
 
 
-%% check_liveness(Reg, [Instruction], {State,BlockCheckFun}) ->
-%%                      {killed | used | unknown,UpdateState}
-%%  Finds out how Reg is used in the instruction sequence. Returns one of:
-%%    killed - Reg is assigned a new value or killed by an allocation instruction
-%%    used - Reg is used (or possibly referenced by an allocation instruction)
-%%    unknown - not possible to determine (perhaps because of an instruction
-%%              that we don't recognize)
+%% check_liveness(Reg, [Instruction], #live{}) ->
+%%                      {killed | used, #live{}}
+%%  Find out whether Reg is used or killed in instruction sequence.
+%%  'killed' means that Reg is assigned a new value or killed by an
+%%  allocation instruction. 'used' means that Reg is used in some way.
 
-check_liveness(R, [{set,_,_,_}=I|_], St) ->
-    erlang:error(only_allowed_in_blocks, [R,I,St]);
 check_liveness(R, [{block,Blk}|Is], #live{bl=BlockCheck}=St0) ->
     case BlockCheck(R, Blk, St0) of
 	{transparent,St} -> check_liveness(R, Is, St);
@@ -461,8 +460,9 @@ check_liveness(R, [{loop_rec,{f,_},{x,0}}|_], St) ->
 	{x,_} ->
 	    {killed,St};
 	_ ->
-	    %% y register. Rarely happens. Be very conversative.
-	    {unknown,St}
+	    %% y register. Rarely happens. Be very conversative and
+	    %% assume it's used.
+	    {used,St}
     end;
 check_liveness(R, [{loop_rec_end,{f,Fail}}|_], St) ->
     check_liveness_at(R, Fail, St);
@@ -493,7 +493,8 @@ check_liveness(R, [{put_map,{f,_},_,Src,_D,Live,{list,_}}|_], St0) ->
 	{x,_} ->
 	    {killed,St0};
 	{y,_} ->
-	    {unknown,St0}
+	    %% Conservatively mark it as used.
+	    {used,St0}
     end;
 check_liveness(R, [{test_heap,N,Live}|Is], St) ->
     I = {block,[{set,[],[],{alloc,Live,{nozero,nostack,N,[]}}}]},
@@ -505,12 +506,8 @@ check_liveness(R, [{get_list,S,D1,D2}|Is], St) ->
     I = {block,[{set,[D1,D2],[S],get_list}]},
     check_liveness(R, [I|Is], St);
 check_liveness(_R, Is, St) when is_list(Is) ->
-%%     case Is of
-%% 	[I|_] ->
-%% 	    io:format("~p ~p\n", [_R,I]);
-%% 	_ -> ok
-%%     end,
-    {unknown,St}.
+    %% Not implemented. Conservatively assume that the register is used.
+    {used,St}.
     
 check_liveness_everywhere(R, [{f,Lbl}|T], St0) ->
     case check_liveness_at(R, Lbl, St0) of
@@ -529,7 +526,7 @@ check_liveness_at(R, Lbl, #live{lbl=Ll,res=ResMemorized}=St0) ->
 	none ->
 	    {Res,St} = case gb_trees:lookup(Lbl, Ll) of
 			   {value,Is} -> check_liveness(R, Is, St0);
-			   none -> {unknown,St0}
+			   none -> {used,St0}
 		       end,
 	    {Res,St#live{res=gb_trees:insert(Lbl, Res, St#live.res)}}
     end.
@@ -594,8 +591,10 @@ check_killed_block(_, []) -> transparent.
 %%    killed - Reg is assigned a new value or killed by an allocation instruction
 %%    transparent - Reg is neither used nor killed
 %%    used - Reg is explicitly used by an instruction
-%%  
-%%    (Unknown instructions will cause an exception.)
+%%
+%%  '%live' annotations are not allowed.
+%%
+%%  (Unknown instructions will cause an exception.)
 
 check_used_block({x,X}=R, [{set,Ds,Ss,{alloc,Live,Op}}|Is], St) ->
     if 
@@ -604,11 +603,6 @@ check_used_block({x,X}=R, [{set,Ds,Ss,{alloc,Live,Op}}|Is], St) ->
     end;
 check_used_block(R, [{set,Ds,Ss,Op}|Is], St) ->
     check_used_block_1(R, Ss, Ds, Op, Is, St);
-check_used_block(R, [{'%live',Live,_}|Is], St) ->
-    case R of
-	{x,X} when X >= Live -> {killed,St};
-	_ -> check_used_block(R, Is, St)
-    end;
 check_used_block(_, [], St) -> {transparent,St}.
 
 check_used_block_1(R, Ss, Ds, Op, Is, St0) ->
@@ -639,8 +633,7 @@ is_reg_used_at_1(_, 0, St) ->
 is_reg_used_at_1(R, Lbl, St0) ->
     case check_liveness_at(R, Lbl, St0) of
 	{killed,St} -> {false,St};
-	{used,St} -> {true,St};
-	{unknown,St} -> {true,St}
+	{used,St} -> {true,St}
     end.
 
 index_labels_1([{label,Lbl}|Is0], Acc) ->
@@ -756,11 +749,6 @@ live_opt([{select,_,Src,Fail,List}=I|Is], Regs0, D, Acc) ->
     Regs1 = x_live([Src], Regs0),
     Regs = live_join_labels([Fail|List], D, Regs1),
     live_opt(Is, Regs, D, [I|Acc]);
-live_opt([{'try',_,_}=I|Is], Regs, D, Acc) ->
-    %% If an exeption happens, all x registers will be killed.
-    %% Therefore, we should only base liveness of the code inside
-    %% the try.
-    live_opt(Is, Regs, D, [I|Acc]);
 live_opt([{try_case,_}=I|Is], _, D, Acc) ->
     live_opt(Is, live_call(1), D, [I|Acc]);
 live_opt([{loop_rec,_Fail,_Dst}=I|Is], _, D, Acc) ->
@@ -860,14 +848,7 @@ x_live([], Regs) -> Regs.
 
 is_live(X, Regs) -> ((Regs bsr X) band 1) =:= 1.
 
-%% split_even/1
-%% [1,2,3,4,5,6] -> {[1,3,5],[2,4,6]}
-split_even(Rs) -> split_even(Rs,[],[]).
-split_even([],Ss,Ds) -> {reverse(Ss),reverse(Ds)};
-split_even([S,D|Rs],Ss,Ds) ->
-    split_even(Rs,[S|Ss],[D|Ds]).
-
-%% join_even/1
-%% {[1,3,5],[2,4,6]} -> [1,2,3,4,5,6]
-join_even([],[]) -> [];
-join_even([S|Ss],[D|Ds]) -> [S,D|join_even(Ss,Ds)].
+split_even([], Ss, Ds) ->
+    {reverse(Ss),reverse(Ds)};
+split_even([S,D|Rs], Ss, Ds) ->
+    split_even(Rs, [S|Ss], [D|Ds]).