1 files changed, 35 insertions, 10 deletions

diff --git a/lib/compiler/src/beam_block.erl b/lib/compiler/src/beam_block.erl
index 9543aa1355..8cd271e1dc 100644
--- a/lib/compiler/src/beam_block.erl
+++ b/lib/compiler/src/beam_block.erl
@@ -36,13 +36,11 @@ module({Mod,Exp,Attr,Fs0,Lc}, Opts) ->
 function({function,Name,Arity,CLabel,Is0}, Blockify) ->
     try
 	%% Collect basic blocks and optimize them.
-        Is2 = case Blockify of
-                  true ->
-                      Is1 = blockify(Is0),
-                      embed_lines(Is1);
-                  false ->
-                      Is0
+        Is1 = case Blockify of
+                  false -> Is0;
+                  true -> blockify(Is0)
               end,
+        Is2 = embed_lines(Is1),
         Is3 = local_cse(Is2),
         Is4 = beam_utils:anno_defs(Is3),
         Is5 = move_allocates(Is4),
@@ -139,6 +137,11 @@ embed_lines([{block,B2},{line,_}=Line,{block,B1}|T], Acc) ->
 embed_lines([{block,B1},{line,_}=Line|T], Acc) ->
     B = {block,[{set,[],[],Line}|B1]},
     embed_lines([B|T], Acc);
+embed_lines([{block,B2},{block,B1}|T], Acc) ->
+    %% This can only happen when beam_block is run for
+    %% the second time.
+    B = {block,B1++B2},
+    embed_lines([B|T], Acc);
 embed_lines([I|Is], Acc) ->
     embed_lines(Is, [I|Acc]);
 embed_lines([], Acc) -> Acc.
@@ -206,7 +209,7 @@ move_allocates([]) -> [].
 
 move_allocates_1([{'%anno',_}|Is], Acc) ->
     move_allocates_1(Is, Acc);
-move_allocates_1([I|Is], [{set,[],[],{alloc,Live0,Info}}|Acc]=Acc0) ->
+move_allocates_1([I|Is], [{set,[],[],{alloc,Live0,Info0}}|Acc]=Acc0) ->
     case alloc_may_pass(I) of
         false ->
             move_allocates_1(Is, [I|Acc0]);
@@ -215,6 +218,7 @@ move_allocates_1([I|Is], [{set,[],[],{alloc,Live0,Info}}|Acc]=Acc0) ->
                 not_possible ->
                     move_allocates_1(Is, [I|Acc0]);
                 Live when is_integer(Live) ->
+                    Info = safe_info(Info0),
                     A = {set,[],[],{alloc,Live,Info}},
                     move_allocates_1(Is, [A,I|Acc])
             end
@@ -230,6 +234,13 @@ alloc_may_pass({set,_,_,put_list}) -> false;
 alloc_may_pass({set,_,_,put}) -> false;
 alloc_may_pass({set,_,_,_}) -> true.
 
+safe_info({nozero,Stack,Heap,_}) ->
+    %% nozero is not safe if the allocation instruction is moved
+    %% upwards past an instruction that may throw an exception
+    %% (such as element/2).
+    {zero,Stack,Heap,[]};
+safe_info(Info) -> Info.
+
 %% opt([Instruction]) -> [Instruction]
 %%  Optimize the instruction stream inside a basic block.
 
@@ -352,10 +363,18 @@ opt_tuple_element_1([{set,[D],[S],move}|Is0], I0, {_,S}, Acc) ->
     case eliminate_use_of_from_reg(Is0, S, D) of
 	no ->
 	    no;
-	{yes,Is} ->
+	{yes,Is1} ->
 	    {set,[S],Ss,Op} = I0,
 	    I = {set,[D],Ss,Op},
-	    {yes,reverse(Acc, [I|Is])}
+            case opt_move_rev(S, Acc, [I|Is1]) of
+                not_possible ->
+                    %% Not safe because the move of the
+                    %% get_tuple_element instruction would cause the
+                    %% result of a previous instruction to be ignored.
+                    no;
+                {_,Is} ->
+                    {yes,Is}
+            end
     end;
 opt_tuple_element_1([{set,Ds,Ss,_}=I|Is], MovedI, {S,D}=Regs, Acc) ->
     case member(S, Ds) orelse member(D, Ss) of
@@ -620,7 +639,13 @@ cse_find(Expr, Es) ->
     end.
 
 cse_expr({set,[D],Ss,{bif,N,_}}) ->
-    {ok,D,{{bif,N},Ss}};
+    case D of
+        {fr,_} ->
+            %% There are too many things that can go wrong.
+            none;
+        _ ->
+            {ok,D,{{bif,N},Ss}}
+    end;
 cse_expr({set,[D],Ss,{alloc,_,{gc_bif,N,_}}}) ->
     {ok,D,{{gc_bif,N},Ss}};
 cse_expr({set,[D],Ss,put_list}) ->