1 files changed, 63 insertions, 25 deletions

diff --git a/lib/compiler/src/beam_except.erl b/lib/compiler/src/beam_except.erl
index 49bfb5606f..28c89782c9 100644
--- a/lib/compiler/src/beam_except.erl
+++ b/lib/compiler/src/beam_except.erl
@@ -31,7 +31,7 @@
 %%% erlang:error(function_clause, Args)  => jump FuncInfoLabel
 %%%
 
--import(lists, [reverse/1,seq/2,splitwith/2]).
+-import(lists, [reverse/1,reverse/2,seq/2,splitwith/2]).
 
 -spec module(beam_utils:module_code(), [compile:option()]) ->
                     {'ok',beam_utils:module_code()}.
@@ -53,7 +53,7 @@ function({function,Name,Arity,CLabel,Is0}) ->
 -record(st,
 	{lbl :: beam_asm:label(),              %func_info label
 	 loc :: [_],                           %location for func_info
-	 arity :: arity()                       %arity for function
+	 arity :: arity()                      %arity for function
 	 }).
 
 function_1(Is0) ->
@@ -79,13 +79,15 @@ translate_1(Ar, I, Is, #st{arity=Arity}=St, [{line,_}=Line|Acc1]=Acc0) ->
 	no ->
 	    translate(Is, St, [I|Acc0]);
 	{yes,function_clause,Acc2} ->
-	    case {Line,St} of
-		{{line,Loc},#st{lbl=Fi,loc=Loc}} ->
+	    case {Is,Line,St} of
+		{[return|_],{line,Loc},#st{lbl=Fi,loc=Loc}} ->
 		    Instr = {jump,{f,Fi}},
 		    translate(Is, St, [Instr|Acc2]);
-		{_,_} ->
-		    %% This must be "error(function_clause, Args)" in
-		    %% the Erlang source code or a fun. Don't translate.
+		{_,_,_} ->
+                    %% Not a call_only instruction, or not the same
+                    %% location information as in in the line instruction
+                    %% before the func_info instruction. Not safe
+                    %% to translate to a jump.
 		    translate(Is, St, [I|Acc0])
 	    end;
 	{yes,Instr,Acc2} ->
@@ -148,10 +150,15 @@ dig_out_fc(Arity, Is0) ->
                              (_) -> true
                           end, Is0),
     {Regs,Acc} = dig_out_fc_1(reverse(Is), Regs0, Acc0),
-    case is_fc(Arity, Regs) of
-        true ->
-            {yes,function_clause,Acc};
-        false ->
+    case Regs of
+        #{{x,0}:={atom,function_clause},{x,1}:=Args} ->
+            case moves_from_stack(Args, 0, []) of
+                {Moves,Arity} ->
+                    {yes,function_clause,reverse(Moves, Acc)};
+                {_,_} ->
+                    no
+            end;
+        #{} ->
             no
     end.
 
@@ -160,8 +167,10 @@ dig_out_fc_1([{block,Bl}|Is], Regs0, Acc) ->
     dig_out_fc_1(Is, Regs, Acc);
 dig_out_fc_1([{bs_set_position,_,_}=I|Is], Regs, Acc) ->
     dig_out_fc_1(Is, Regs, [I|Acc]);
-dig_out_fc_1([{bs_get_tail,_,_,Live}=I|Is], Regs0, Acc) ->
-    Regs = prune_xregs(Live, Regs0),
+dig_out_fc_1([{bs_get_tail,Src,Dst,Live0}|Is], Regs0, Acc) ->
+    Regs = prune_xregs(Live0, Regs0),
+    Live = dig_out_stack_live(Regs, Live0),
+    I = {bs_get_tail,Src,Dst,Live},
     dig_out_fc_1(Is, Regs, [I|Acc]);
 dig_out_fc_1([_|_], _Regs, _Acc) ->
     {#{},[]};
@@ -182,25 +191,54 @@ dig_out_fc_block([{set,_,_,_}|_], _Regs) ->
     #{};
 dig_out_fc_block([], Regs) -> Regs.
 
-prune_xregs(Live, Regs) ->
-    maps:filter(fun({x,X}, _) -> X < Live end, Regs).
-
-is_fc(Arity, Regs) ->
+dig_out_stack_live(Regs, Default) ->
+    Reg = {x,2},
     case Regs of
-        #{{x,0}:={atom,function_clause},{x,1}:=Args} ->
-            is_fc_1(Args, 0) =:= Arity;
+        #{Reg:=List} ->
+            dig_out_stack_live_1(List, Default);
         #{} ->
-            false
+            Default
     end.
 
-is_fc_1({cons,{arg,I},T}, I) ->
-    is_fc_1(T, I+1);
-is_fc_1(nil, I) ->
-    I;
-is_fc_1(_, _) -> -1.
+dig_out_stack_live_1({cons,{arg,N},T}, Live) ->
+    dig_out_stack_live_1(T, max(N + 1, Live));
+dig_out_stack_live_1({cons,_,T}, Live) ->
+    dig_out_stack_live_1(T, Live);
+dig_out_stack_live_1(nil, Live) ->
+    Live;
+dig_out_stack_live_1(_, Live) -> Live.
+
+prune_xregs(Live, Regs) ->
+    maps:filter(fun({x,X}, _) -> X < Live end, Regs).
+
+moves_from_stack({cons,{arg,N},_}, I, _Acc) when N =/= I ->
+    %% Wrong argument. Give up.
+    {[],-1};
+moves_from_stack({cons,H,T}, I, Acc) ->
+    case H of
+        {arg,I} ->
+            moves_from_stack(T, I+1, Acc);
+        _ ->
+            moves_from_stack(T, I+1, [{move,H,{x,I}}|Acc])
+    end;
+moves_from_stack(nil, I, Acc) ->
+    {reverse(Acc),I};
+moves_from_stack({literal,[H|T]}, I, Acc) ->
+    Cons = {cons,tag_literal(H),tag_literal(T)},
+    moves_from_stack(Cons, I, Acc);
+moves_from_stack(_, _, _) ->
+    %% Not understood. Give up.
+    {[],-1}.
+
 
 get_reg(R, Regs) ->
     case Regs of
         #{R:=Val} -> Val;
         #{} -> R
     end.
+
+tag_literal([]) -> nil;
+tag_literal(T) when is_atom(T) -> {atom,T};
+tag_literal(T) when is_float(T) -> {float,T};
+tag_literal(T) when is_integer(T) -> {integer,T};
+tag_literal(T) -> {literal,T}.