From b1615cb1159cc1c9a5fa67992fa92a6d0da36b3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Sun, 31 Dec 2017 17:01:58 +0100
Subject: Improve code generation for a 'case' with exported variables

Consider a 'case' that exports variables and whose return
value is ignored:

foo(N) ->
    case N of
        1 ->
            Res = one;
        2 ->
            Res = two
    end,
    {ok,Res}.

That code will be translated to the following Core Erlang code:

'foo'/1 =
    fun (_@c0) ->
        let <_@c5,Res> =
           case _@c0 of
	      <1> when 'true' ->
                  <'one','one'>
	      <2> when 'true' ->
                  <'two','two'>
	      <_@c3> when 'true' ->
                  primop 'match_fail'({'case_clause',_@c3})
           end
	in
           {'ok',Res}

The exported variables has been rewritten to explicit return
values. Note that the original return value from the 'case' is bound to
the variable _@c5, which is unused.

The corresponding BEAM assembly code looks like this:

{function, foo, 1, 2}.
  {label,1}.
    {line,[...]}.
    {func_info,{atom,t},{atom,foo},1}.
  {label,2}.
    {test,is_integer,{f,6},[{x,0}]}.
    {select_val,{x,0},{f,6},{list,[{integer,2},{f,3},{integer,1},{f,4}]}}.
  {label,3}.
    {move,{atom,two},{x,1}}.
    {move,{atom,two},{x,0}}.
    {jump,{f,5}}.
  {label,4}.
    {move,{atom,one},{x,1}}.
    {move,{atom,one},{x,0}}.
  {label,5}.
    {test_heap,3,2}.
    {put_tuple,2,{x,0}}.
    {put,{atom,ok}}.
    {put,{x,1}}.
    return.
  {label,6}.
    {line,[...]}.
    {case_end,{x,0}}.

Because of the test_heap instruction following label 5, the assignment
to {x,0} cannot be optimized away by the passes that optimize BEAM assembly
code.

Refactor the optimizations of 'let' in sys_core_fold to eliminate the
unused variable. Thus:

'foo'/1 =
    fun (_@c0) ->
       let <Res> =
           case _@c0 of
              <1> when 'true' ->
                 'one'
              <2> when 'true' ->
                 'two'
              <_@c3> when 'true' ->
                  primop 'match_fail'({'case_clause',_@c3})
           end
       in
           {'ok',Res}

The resulting BEAM code will look like:

{function, foo, 1, 2}.
  {label,1}.
    {line,[...]}.
    {func_info,{atom,t},{atom,foo},1}.
  {label,2}.
    {test,is_integer,{f,6},[{x,0}]}.
    {select_val,{x,0},{f,6},{list,[{integer,2},{f,3},{integer,1},{f,4}]}}.
  {label,3}.
    {move,{atom,two},{x,0}}.
    {jump,{f,5}}.
  {label,4}.
    {move,{atom,one},{x,0}}.
  {label,5}.
    {test_heap,3,1}.
    {put_tuple,2,{x,1}}.
    {put,{atom,ok}}.
    {put,{x,0}}.
    {move,{x,1},{x,0}}.
    return.
  {label,6}.
    {line,[...]}.
    {case_end,{x,0}}.
---
 lib/compiler/test/core_fold_SUITE.erl | 38 +++++++++++++++++++++++++++++++++--
 1 file changed, 36 insertions(+), 2 deletions(-)

(limited to 'lib/compiler/test')

diff --git a/lib/compiler/test/core_fold_SUITE.erl b/lib/compiler/test/core_fold_SUITE.erl
index 262967d03d..4fd1f84569 100644
--- a/lib/compiler/test/core_fold_SUITE.erl
+++ b/lib/compiler/test/core_fold_SUITE.erl
@@ -27,7 +27,7 @@
 	 multiple_aliases/1,redundant_boolean_clauses/1,
 	 mixed_matching_clauses/1,unnecessary_building/1,
 	 no_no_file/1,configuration/1,supplies/1,
-         redundant_stack_frame/1]).
+         redundant_stack_frame/1,export_from_case/1]).
 
 -export([foo/0,foo/1,foo/2,foo/3]).
 
@@ -47,7 +47,7 @@ groups() ->
        multiple_aliases,redundant_boolean_clauses,
        mixed_matching_clauses,unnecessary_building,
        no_no_file,configuration,supplies,
-       redundant_stack_frame]}].
+       redundant_stack_frame,export_from_case]}].
 
 
 init_per_suite(Config) ->
@@ -551,4 +551,38 @@ do_redundant_stack_frame(Map) ->
         end,
     {X, Y}.
 
+%% Cover some clauses in sys_core_fold:remove_first_value/2.
+
+-record(export_from_case, {val}).
+
+export_from_case(_Config) ->
+    a = export_from_case_1(true),
+    b = export_from_case_1(false),
+
+    R = #export_from_case{val=0},
+    {ok,R} = export_from_case_2(false, R),
+    {ok,#export_from_case{val=42}} = export_from_case_2(true, R),
+
+    ok.
+
+export_from_case_1(Bool) ->
+    case Bool of
+        true ->
+            id(42),
+            Result = a;
+        false ->
+            Result = b
+    end,
+    id(Result).
+
+export_from_case_2(Bool, Rec) ->
+    case Bool of
+        false ->
+            Result = Rec;
+        true ->
+            Result = Rec#export_from_case{val=42}
+    end,
+    {ok,Result}.
+
+
 id(I) -> I.
-- 
cgit v1.2.3