1 files changed, 192 insertions, 8 deletions

diff --git a/lib/compiler/test/match_SUITE.erl b/lib/compiler/test/match_SUITE.erl
index 72e5356a8d..bc74ec4984 100644
--- a/lib/compiler/test/match_SUITE.erl
+++ b/lib/compiler/test/match_SUITE.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2004-2018. All Rights Reserved.
+%% Copyright Ericsson AB 2004-2019. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -25,7 +25,8 @@
 	 match_in_call/1,untuplify/1,shortcut_boolean/1,letify_guard/1,
 	 selectify/1,deselectify/1,underscore/1,match_map/1,map_vars_used/1,
 	 coverage/1,grab_bag/1,literal_binary/1,
-         unary_op/1]).
+         unary_op/1,eq_types/1,match_after_return/1,match_right_tuple/1,
+         tuple_size_in_try/1]).
 	 
 -include_lib("common_test/include/ct.hrl").
 
@@ -40,7 +41,9 @@ groups() ->
        match_in_call,untuplify,
        shortcut_boolean,letify_guard,selectify,deselectify,
        underscore,match_map,map_vars_used,coverage,
-       grab_bag,literal_binary,unary_op]}].
+       grab_bag,literal_binary,unary_op,eq_types,
+       match_after_return,match_right_tuple,
+       tuple_size_in_try]}].
 
 
 init_per_suite(Config) ->
@@ -254,6 +257,8 @@ non_matching_aliases(_Config) ->
     none = mixed_aliases([d]),
     none = mixed_aliases({a,42}),
     none = mixed_aliases(42),
+    none = mixed_aliases(<<6789:16>>),
+    none = mixed_aliases(#{key=>value}),
 
     {'EXIT',{{badmatch,42},_}} = (catch nomatch_alias(42)),
     {'EXIT',{{badmatch,job},_}} = (catch entirely()),
@@ -279,6 +284,16 @@ mixed_aliases(<<X:8>> = x) -> {a,X};
 mixed_aliases([b] = <<X:8>>) -> {b,X};
 mixed_aliases(<<X:8>> = {a,X}) -> {c,X};
 mixed_aliases([X] = <<X:8>>) -> {d,X};
+mixed_aliases(<<X:16>> = X) -> {e,X};
+mixed_aliases(X = <<X:16>>) -> {f,X};
+mixed_aliases(<<X:16,_/binary>> = X) -> {g,X};
+mixed_aliases(X = <<X:16,_/binary>>) -> {h,X};
+mixed_aliases(X = #{key:=X}) -> {i,X};
+mixed_aliases(#{key:=X} = X) -> {j,X};
+mixed_aliases([X] = #{key:=X}) -> {k,X};
+mixed_aliases(#{key:=X} = [X]) -> {l,X};
+mixed_aliases({a,X} = #{key:=X}) -> {m,X};
+mixed_aliases(#{key:=X} = {a,X}) -> {n,X};
 mixed_aliases(_) -> none.
 
 nomatch_alias(I) ->
@@ -456,6 +471,7 @@ letify_guard(A, B) ->
 selectify(Config) when is_list(Config) ->
     integer = sel_different_types({r,42}),
     atom = sel_different_types({r,forty_two}),
+    float = sel_different_types({r,100.0}),
     none = sel_different_types({r,18}),
     {'EXIT',_} = (catch sel_different_types([a,b,c])),
 
@@ -466,12 +482,15 @@ selectify(Config) when is_list(Config) ->
     integer42 = sel_same_value2(42),
     integer43 = sel_same_value2(43),
     error = sel_same_value2(44),
+
     ok.
 
 sel_different_types({r,_}=T) when element(2, T) =:= forty_two ->
     atom;
 sel_different_types({r,_}=T) when element(2, T) =:= 42 ->
     integer;
+sel_different_types({r,_}=T) when element(2, T) =:= 100.0 ->
+    float;
 sel_different_types({r,_}) ->
     none.
 
@@ -489,9 +508,8 @@ sel_same_value2(V) when V =:= 42; V =:= 43 ->
 sel_same_value2(_) ->
     error.
 
-%% Test deconstruction of select_val instructions in beam_peep into
-%% regular tests with just one possible value left. Hitting proper cases
-%% in beam_peep relies on unification of labels by beam_jump.
+%% Test deconstruction of select_val instructions to regular tests
+%% with zero or one values left.
 
 deselectify(Config) when is_list(Config) ->
     one_or_other = desel_tuple_arity({1}),
@@ -512,7 +530,31 @@ deselectify(Config) when is_list(Config) ->
 
     one_or_other = dsel_atom_typecheck(one),
     two = dsel_atom_typecheck(two),
-    one_or_other = dsel_atom_typecheck(three).
+    one_or_other = dsel_atom_typecheck(three),
+
+    %% Cover deconstruction of select_val instructions in
+    %% beam_peep.
+
+    stop = dsel_peek_0(stop),
+    ignore = dsel_peek_0(ignore),
+    Config = dsel_peek_0(Config),
+
+    stop = dsel_peek_1(stop, any),
+    Config = dsel_peek_1(ignore, Config),
+    other = dsel_peek_1(other, ignored),
+
+    0 = dsel_peek_2(0, any),
+    Config = dsel_peek_2(1, Config),
+    2 = dsel_peek_2(2, ignored),
+
+    true = dsel_peek_3(true),
+    false = dsel_peek_3(false),
+    {error,Config} = dsel_peek_3(Config),
+
+    ok.
+
+%% The following will be optimized by the sharing optimizations
+%% in beam_ssa_opt.
 
 desel_tuple_arity(Tuple) when is_tuple(Tuple) ->
     case Tuple of
@@ -549,6 +591,39 @@ dsel_atom_typecheck(Val) when is_atom(Val) ->
         _ -> one_or_other
     end.
 
+%% The following functions are carefully crafted so that the sharing
+%% optimizations in beam_ssa_opt can't be applied. After applying the
+%% beam_jump:eliminate_moves/1 optimization and beam_clean:clean_labels/1
+%% has unified labels, beam_peep is able to optimize these functions.
+
+dsel_peek_0(A0) ->
+    case id(A0) of
+        stop ->   stop;
+        ignore -> ignore;
+        A ->      A
+    end.
+
+dsel_peek_1(A0, B) ->
+    case id(A0) of
+        stop ->   stop;
+        ignore -> B;
+        A ->      A
+    end.
+
+dsel_peek_2(A0, B) ->
+    case id(A0) of
+        0 -> 0;
+        1 -> B;
+        A -> A
+    end.
+
+dsel_peek_3(A0) ->
+    case id(A0) of
+        true ->  true;
+        false -> false;
+        Other -> {error,Other}
+    end.
+
 underscore(Config) when is_list(Config) ->
     case Config of
 	[] ->
@@ -591,13 +666,26 @@ do_map_vars_used(X, Y, Map) ->
 	    Val
     end.
 
+-record(coverage_id, {bool=false,id}).
 coverage(Config) when is_list(Config) ->
     %% Cover beam_dead.
     ok = coverage_1(x, a),
     ok = coverage_1(x, b),
 
     %% Cover sys_pre_expand.
-    ok = coverage_3("abc").
+    ok = coverage_3("abc"),
+
+    %% Cover beam_ssa_dead.
+    {expr,key} = coverage_4([literal,get], [[expr,key]]),
+    {expr,key} = coverage_4([expr,key], []),
+
+    a = coverage_5([8,8,8], #coverage_id{bool=true}),
+    b = coverage_5([], #coverage_id{bool=true}),
+
+    %% Cover beam_ssa_opt.
+    ok = coverage_6(),
+
+    ok.
 
 coverage_1(B, Tag) ->
     case Tag of
@@ -610,6 +698,37 @@ coverage_2(2, b, x) -> ok.
 
 coverage_3([$a]++[]++"bc") -> ok.
 
+%% Cover beam_ssa_dead:eval_type_test_1(is_nonempty_list, Arg).
+coverage_4([literal,get], [Expr]) ->
+    coverage_4(Expr, []);
+coverage_4([Expr,Key], []) ->
+    {Expr,Key}.
+
+%% Cover beam_ssa_dead:eval_type_test_1(is_tagged_tuple, Arg).
+coverage_5(Config, TermId)
+  when TermId =:= #coverage_id{bool=true},
+       Config =:= [8,8,8] ->
+    a;
+coverage_5(_Config, #coverage_id{bool=true}) ->
+    b.
+
+coverage_6() ->
+    X = 17,
+    case
+        case id(1) > 0 of
+            true ->
+                17;
+            false ->
+                42
+        end
+    of
+        X ->
+            ok;
+        V ->
+            %% Cover beam_ssa_opt:make_literal/2.
+            error([error,X,V])
+    end.
+
 grab_bag(_Config) ->
     [_|T] = id([a,b,c]),
     [b,c] = id(T),
@@ -754,5 +873,70 @@ unary_op_1(Vop@1) ->
             end
     end.
 
+eq_types(_Config) ->
+    Ref = make_ref(),
+    Ref = eq_types(Ref, any),
+    ok.
+
+eq_types(A, B) ->
+    %% {put_tuple2,{y,0},{list,[{x,0},{x,1}]}}.
+    Term0 = {A, B},
+    Term = id(Term0),
+
+    %% {test,is_eq_exact,{f,3},[{y,0},{x,0}]}.
+    %% Here beam_validator must infer that {x,0} has the
+    %% same type as {y,0}.
+    Term = Term0,
+
+    %% {get_tuple_element,{x,0},0,{x,0}}.
+    {Ref22,_} = Term,
+
+    Ref22.
+
+match_after_return(Config) when is_list(Config) ->
+    %% The return type of the following call will never match the 'wont_happen'
+    %% clauses below, and the beam_ssa_type was clever enough to see that but
+    %% didn't remove the blocks, so it crashed when trying to extract A.
+    ok = case mar_test_tuple(erlang:unique_integer()) of
+            {gurka, never_matches, A} -> {wont_happen, A};
+            _ -> ok
+         end.
+
+mar_test_tuple(I) -> {gurka, I}.
+
+match_right_tuple(Config) when is_list(Config) ->
+    %% The loader wrongly coalesced certain get_tuple_element sequences, fusing
+    %% the code below into a single i_get_tuple_element2 operating on {x,0}
+    %% even though the first one overwrites it.
+    %%
+    %%    {get_tuple_element,{x,0},0,{x,0}}.
+    %%    {get_tuple_element,{x,0},1,{x,1}}.
+
+    Inner = {id(wrong_element), id(ok)},
+    Outer = {Inner, id(wrong_tuple)},
+    ok = match_right_tuple_1(Outer).
+
+match_right_tuple_1(T) ->
+    {A, _} = T,
+    {_, B} = A,
+    %% The call ensures that A is in {x,0} and B is in {x,1}
+    id(force_succ_regs(A, B)).
+
+force_succ_regs(_A, B) -> B.
+
+tuple_size_in_try(Config) when is_list(Config) ->
+    %% The tuple_size optimization was applied outside of guards, causing
+    %% either the emulator or compiler to crash.
+    ok = tsit(gurka),
+    ok = tsit(gaffel).
+
+tsit(A) ->
+    try
+        id(ignored),
+        1 = tuple_size(A),
+        error
+    catch
+        _:_ -> ok
+    end.
 
 id(I) -> I.