From c846bf3f57937da34589c9071291a3be5ad0c4bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 15 Feb 2011 10:09:50 +0100
Subject: compiler: Generate line instructions

---
 lib/compiler/src/beam_asm.erl       |  18 +++---
 lib/compiler/src/beam_block.erl     |  35 +++++++++---
 lib/compiler/src/beam_bsm.erl       |   9 ++-
 lib/compiler/src/beam_dead.erl      |  10 ++--
 lib/compiler/src/beam_jump.erl      |  49 ++++++++++------
 lib/compiler/src/beam_listing.erl   |   2 +-
 lib/compiler/src/beam_receive.erl   |   2 +
 lib/compiler/src/beam_trim.erl      |  13 +++--
 lib/compiler/src/beam_type.erl      |   1 +
 lib/compiler/src/beam_utils.erl     |  16 ++++--
 lib/compiler/src/beam_validator.erl |  15 ++++-
 lib/compiler/src/v3_codegen.erl     | 108 ++++++++++++++++++++++++++++--------
 lib/compiler/src/v3_life.erl        |   4 +-
 lib/compiler/test/misc_SUITE.erl    |   4 +-
 14 files changed, 210 insertions(+), 76 deletions(-)

(limited to 'lib/compiler')

diff --git a/lib/compiler/src/beam_asm.erl b/lib/compiler/src/beam_asm.erl
index 60824326bd..d56aeae524 100644
--- a/lib/compiler/src/beam_asm.erl
+++ b/lib/compiler/src/beam_asm.erl
@@ -23,7 +23,7 @@
 -export([module/4]).
 -export([encode/2]).
 
--import(lists, [map/2,member/2,keymember/3,duplicate/2]).
+-import(lists, [map/2,member/2,keymember/3,duplicate/2,splitwith/2]).
 -include("beam_opcodes.hrl").
 
 module(Code, Abst, SourceFile, Opts) ->
@@ -41,12 +41,9 @@ on_load(Fs0, Attr0) ->
 	undefined ->
 	    {Fs0,Attr0};
 	[{Name,0}] ->
-	    Fs = map(fun({function,N,0,Entry,Asm0}) when N =:= Name ->
-			     [{label,_}=L,
-			      {func_info,_,_,_}=Fi,
-			      {label,_}=E|Asm1] = Asm0,
-			     Asm = [L,Fi,E,on_load|Asm1],
-			     {function,N,0,Entry,Asm};
+	    Fs = map(fun({function,N,0,Entry,Is0}) when N =:= Name ->
+			     Is = insert_on_load_instruction(Is0, Entry),
+			     {function,N,0,Entry,Is};
 			(F) ->
 			     F
 		     end, Fs0),
@@ -54,6 +51,13 @@ on_load(Fs0, Attr0) ->
 	    {Fs,Attr}
     end.
 
+insert_on_load_instruction(Is0, Entry) ->
+    {Bef,[{label,Entry}=El|Is]} =
+	splitwith(fun({label,L}) when L =:= Entry -> false;
+		     (_) -> true
+		  end, Is0),
+    Bef ++ [El,on_load|Is].
+
 assemble_1([{function,Name,Arity,Entry,Asm}|T], Exp, Dict0, Acc) ->
     Dict1 = case member({Name,Arity}, Exp) of
 		true ->
diff --git a/lib/compiler/src/beam_block.erl b/lib/compiler/src/beam_block.erl
index c45874597a..432d1e7eea 100644
--- a/lib/compiler/src/beam_block.erl
+++ b/lib/compiler/src/beam_block.erl
@@ -36,13 +36,14 @@ function({function,Name,Arity,CLabel,Is0}, Lc0) ->
 
 	%% Collect basic blocks and optimize them.
 	Is2 = blockify(Is1),
-	Is3 = move_allocates(Is2),
-	Is4 = beam_utils:live_opt(Is3),
-	Is5 = opt_blocks(Is4),
-	Is6 = beam_utils:delete_live_annos(Is5),
+	Is3 = embed_lines(Is2),
+	Is4 = move_allocates(Is3),
+	Is5 = beam_utils:live_opt(Is4),
+	Is6 = opt_blocks(Is5),
+	Is7 = beam_utils:delete_live_annos(Is6),
 
 	%% Optimize bit syntax.
-	{Is,Lc} = bsm_opt(Is6, Lc0),
+	{Is,Lc} = bsm_opt(Is7, Lc0),
 
 	%% Done.
 	{{function,Name,Arity,CLabel,Is},Lc}
@@ -148,6 +149,24 @@ collect(remove_message)      -> {set,[],[],remove_message};
 collect({'catch',R,L})       -> {set,[R],[],{'catch',L}};
 collect(_)                   -> error.
 
+%% embed_lines([Instruction]) -> [Instruction]
+%%  Combine blocks that would be split by line/1 instructions.
+%%  Also move a line instruction before a block into the block,
+%%  but leave the line/1 instruction after a block outside.
+
+embed_lines(Is) ->
+    embed_lines(reverse(Is), []).
+
+embed_lines([{block,B2},{line,_}=Line,{block,B1}|T], Acc) ->
+    B = {block,B1++[{set,[],[],Line}]++B2},
+    embed_lines([B|T], Acc);
+embed_lines([{block,B1},{line,_}=Line|T], Acc) ->
+    B = {block,[{set,[],[],Line}|B1]},
+    embed_lines([B|T], Acc);
+embed_lines([I|Is], Acc) ->
+    embed_lines(Is, [I|Acc]);
+embed_lines([], Acc) -> Acc.
+
 opt_blocks([{block,Bl0}|Is]) ->
     %% The live annotation at the beginning is not useful.
     [{'%live',_}|Bl] = Bl0,
@@ -225,10 +244,12 @@ opt([{set,[Dst],As,{bif,Bif,Fail}}=I1,
  	RevBif -> [{set,[Dst],As,{bif,RevBif,Fail}}|opt(Is)]
     end;
 opt([{set,[X],[X],move}|Is]) -> opt(Is);
-opt([{set,[D1],[{integer,Idx1},Reg],{bif,element,{f,0}}}=I1,
+opt([{set,_,_,{line,_}}=Line1,
+     {set,[D1],[{integer,Idx1},Reg],{bif,element,{f,0}}}=I1,
+     {set,_,_,{line,_}}=Line2,
      {set,[D2],[{integer,Idx2},Reg],{bif,element,{f,0}}}=I2|Is])
   when Idx1 < Idx2, D1 =/= D2, D1 =/= Reg, D2 =/= Reg ->
-    opt([I2,I1|Is]);
+    opt([Line2,I2,Line1,I1|Is]);
 opt([{set,Ds0,Ss,Op}|Is0]) ->	
     {Ds,Is} = opt_moves(Ds0, Is0),
     [{set,Ds,Ss,Op}|opt(Is)];
diff --git a/lib/compiler/src/beam_bsm.erl b/lib/compiler/src/beam_bsm.erl
index 415864b8e9..1217f7f777 100644
--- a/lib/compiler/src/beam_bsm.erl
+++ b/lib/compiler/src/beam_bsm.erl
@@ -20,7 +20,7 @@
 -module(beam_bsm).
 -export([module/2,format_error/1]).
 
--import(lists, [member/2,foldl/3,reverse/1,sort/1,all/2]).
+-import(lists, [member/2,foldl/3,reverse/1,sort/1,all/2,dropwhile/2]).
 
 %%%
 %%% We optimize bit syntax matching where the tail end of a binary is
@@ -376,6 +376,8 @@ btb_reaches_match_2([{func_info,_,_,Arity}=I|_], Regs0, D) ->
 	[] -> D;
 	_ -> {binary_used_in,I}
     end;
+btb_reaches_match_2([{line,_}|Is], Regs, D) ->
+    btb_reaches_match_1(Is, Regs, D);
 btb_reaches_match_2([I|_], Regs, _) ->
     btb_error({btb_context_regs(Regs),I,not_handled}).
 
@@ -580,7 +582,10 @@ btb_index(Fs) ->
     btb_index_1(Fs, []).
 
 btb_index_1([{function,_,_,Entry,Is0}|Fs], Acc0) ->
-    [{label,_},{func_info,_,_,_},{label,Entry}|Is] = Is0,
+    [{label,Entry}|Is] =
+	dropwhile(fun({label,L}) when L =:= Entry -> false;
+		     (_) -> true
+		  end, Is0),
     Acc = btb_index_2(Is, Entry, false, Acc0),
     btb_index_1(Fs, Acc);
 btb_index_1([], Acc) -> gb_trees:from_orddict(sort(Acc)).
diff --git a/lib/compiler/src/beam_dead.erl b/lib/compiler/src/beam_dead.erl
index 1365f3d20a..9f81a6ab43 100644
--- a/lib/compiler/src/beam_dead.erl
+++ b/lib/compiler/src/beam_dead.erl
@@ -144,9 +144,9 @@ function({function,Name,Arity,CLabel,Is0}, Lc0) ->
 	%% Initialize label information with the code
 	%% for the func_info label. Without it, a register
 	%% may seem to be live when it is not.
-	[{label,L},{func_info,_,_,_}=FI|_] = Is1,
+	[{label,L}|FiIs] = Is1,
 	D0 = beam_utils:empty_label_index(),
-	D = beam_utils:index_label(L, [FI], D0),
+	D = beam_utils:index_label(L, FiIs, D0),
 
 	%% Optimize away dead code.
 	{Is2,Lc} = forward(Is1, Lc0),
@@ -185,6 +185,8 @@ split_block([{set,[R],As,{alloc,Live,{gc_bif,N,{f,Lbl}=Fail}}}|Is], Bl, Acc)
     split_block(Is, [], [{gc_bif,N,Fail,Live,As,R}|make_block(Bl, Acc)]);
 split_block([{set,[R],[],{'catch',L}}|Is], Bl, Acc) ->
     split_block(Is, [], [{'catch',R,L}|make_block(Bl, Acc)]);
+split_block([{set,[],[],{line,_}=Line}|Is], Bl, Acc) ->
+    split_block(Is, [], [Line|make_block(Bl, Acc)]);
 split_block([I|Is], Bl, Acc) ->
     split_block(Is, [I|Bl], Acc);
 split_block([], Bl, Acc) -> make_block(Bl, Acc).
@@ -406,7 +408,7 @@ backward([{test,Op,{f,To0},Live,Ops0,Dst}|Is], D, Acc) ->
 	 end,
     I = {test,Op,{f,To},Live,Ops0,Dst},
     backward(Is, D, [I|Acc]);
-backward([{kill,_}=I|Is], D, [Exit|_]=Acc) ->
+backward([{kill,_}=I|Is], D, [{line,_},Exit|_]=Acc) ->
     case beam_jump:is_exit_instruction(Exit) of
 	false -> backward(Is, D, [I|Acc]);
 	true -> backward(Is, D, Acc)
@@ -471,7 +473,7 @@ shortcut_fail_label(To0, Reg, Val, D) ->
 
 shortcut_boolean_label(To0, Reg, Bool0, D) when is_boolean(Bool0) ->
     case beam_utils:code_at(To0, D) of
-	[{bif,'not',_,[Reg],Reg},{jump,{f,To}}|_] ->
+	[{line,_},{bif,'not',_,[Reg],Reg},{jump,{f,To}}|_] ->
 	    Bool = not Bool0,
 	    {shortcut_select_label(To, Reg, Bool, D),Bool};
 	_ ->
diff --git a/lib/compiler/src/beam_jump.erl b/lib/compiler/src/beam_jump.erl
index 3cab55c4cb..537f8ca81b 100644
--- a/lib/compiler/src/beam_jump.erl
+++ b/lib/compiler/src/beam_jump.erl
@@ -169,7 +169,7 @@ share_1([{label,L}=Lbl|Is], Dict0, Seq, Acc) ->
 	    share_1(Is, Dict0, [], [Lbl,{jump,{f,Label}}|Acc])
     end;
 share_1([{func_info,_,_,_}=I|Is], _, [], Acc) ->
-    Is++[I|Acc];
+    reverse(Is, [I|Acc]);
 share_1([I|Is], Dict, Seq, Acc) ->
     case is_unreachable_after(I) of
 	false ->
@@ -206,25 +206,35 @@ is_label(_) -> false.
 move(Is) ->
     move_1(Is, [], []).
 
-move_1([I|Is], End, Acc) ->
+move_1([I|Is], End0, Acc0) ->
     case is_exit_instruction(I) of
-	false -> move_1(Is, End, [I|Acc]);
-	true -> move_2(I, Is, End, Acc)
+	false ->
+	    move_1(Is, End0, [I|Acc0]);
+	true ->
+	    case extract_seq(Acc0, [I|End0]) of
+		no ->
+		    move_1(Is, End0, [I|Acc0]);
+		{yes,End,Acc} ->
+		    move_1(Is, End, Acc)
+	    end
     end;
-move_1([], End, Acc) ->
-    reverse(Acc, reverse(End)).
-
-move_2(Exit, Is, End, [{block,_},{label,_},{func_info,_,_,_}|_]=Acc) ->
-    move_1(Is, End, [Exit|Acc]);
-move_2(Exit, Is, End, [{block,_}=Blk,{label,_}=Lbl,Unreachable|More]) ->
-    move_1([Unreachable|Is], [Exit,Blk,Lbl|End], More);
-move_2(Exit, Is, End, [{bs_context_to_binary,_}=Bs,{label,_}=Lbl,
-		       Unreachable|More]) ->
-    move_1([Unreachable|Is], [Exit,Bs,Lbl|End], More);
-move_2(Exit, Is, End, [{label,_}=Lbl,Unreachable|More]) ->
-    move_1([Unreachable|Is], [Exit,Lbl|End], More);
-move_2(Exit, Is, End, Acc) ->
-    move_1(Is, End, [Exit|Acc]).
+move_1([], End, Acc) -> reverse(Acc, End).
+
+extract_seq([{line,_}=Line|Is], Acc) ->
+    extract_seq(Is, [Line|Acc]);
+extract_seq([{block,_}=Bl|Is], Acc) ->
+    extract_seq_1(Is, [Bl|Acc]);
+extract_seq([{label,_}|_]=Is, Acc) ->
+    extract_seq_1(Is, Acc);
+extract_seq(_, _) -> no.
+
+extract_seq_1([{line,_}=Line|Is], Acc) ->
+    extract_seq_1(Is, [Line|Acc]);
+extract_seq_1([{label,_},{func_info,_,_,_}|_], _) ->
+    no;
+extract_seq_1([{label,_}=Lbl|Is], Acc) ->
+    {yes,[Lbl|Acc],Is};
+extract_seq_1(_, _) -> no.
 
 %%%
 %%% (3) (4) (5) (6) Jump and unreachable code optimizations.
@@ -454,6 +464,7 @@ is_label_used_in_2({set,_,_,Info}, Lbl) ->
 	{put_tuple,_} -> false;
 	{get_tuple_element,_} -> false;
 	{set_tuple_element,_} -> false;
+	{line,_} -> false;
 	_ when is_atom(Info) -> false
     end.
 
@@ -487,6 +498,8 @@ rem_unused([], _, Acc) -> reverse(Acc).
 initial_labels(Is) ->
     initial_labels(Is, []).
 
+initial_labels([{line,_}|Is], Acc) ->
+    initial_labels(Is, Acc);
 initial_labels([{label,Lbl}|Is], Acc) ->
     initial_labels(Is, [Lbl|Acc]);
 initial_labels([{func_info,_,_,_},{label,Lbl}|_], Acc) ->
diff --git a/lib/compiler/src/beam_listing.erl b/lib/compiler/src/beam_listing.erl
index be7b14c3dd..2941f6135c 100644
--- a/lib/compiler/src/beam_listing.erl
+++ b/lib/compiler/src/beam_listing.erl
@@ -61,7 +61,7 @@ print_op(Stream, Label) when element(1, Label) == label ->
 print_op(Stream, Op) ->
     io:format(Stream, "    ~p.\n", [Op]).
 
-function(File, {function,Name,Arity,Args,Body,Vdb}) ->
+function(File, {function,Name,Arity,Args,Body,Vdb,_Anno}) ->
     io:nl(File),
     io:format(File, "function ~p/~p.\n", [Name,Arity]),
     io:format(File, " ~p.\n", [Args]),
diff --git a/lib/compiler/src/beam_receive.erl b/lib/compiler/src/beam_receive.erl
index 9ed44ad5d7..c483d85a97 100644
--- a/lib/compiler/src/beam_receive.erl
+++ b/lib/compiler/src/beam_receive.erl
@@ -175,6 +175,8 @@ opt_update_regs({label,Lbl}, R, L) ->
     end;
 opt_update_regs({try_end,_}, R, L) ->
     {R,L};
+opt_update_regs({line,_}, R, L) ->
+    {R,L};
 opt_update_regs(_I, _R, L) ->
     %% Unrecognized instruction. Abort the search.
     {regs_init(),L}.
diff --git a/lib/compiler/src/beam_trim.erl b/lib/compiler/src/beam_trim.erl
index 790aba0a9a..25e6ffbb73 100644
--- a/lib/compiler/src/beam_trim.erl
+++ b/lib/compiler/src/beam_trim.erl
@@ -222,7 +222,9 @@ remap([{call_last,Ar,Name,N}|Is], Map, Acc) ->
     reverse(Acc, [I|Is]);
 remap([{call_ext_last,Ar,Name,N}|Is], Map, Acc) ->
     I = {call_ext_last,Ar,Name,Map({frame_size,N})},
-    reverse(Acc, [I|Is]).
+    reverse(Acc, [I|Is]);
+remap([{line,_}=I|Is], Map, Acc) ->
+    remap(Is, Map, [I|Acc]).
     
 remap_block([{set,Ds0,Ss0,Info}|Is], Map, Acc) ->
     Ds = [Map(D) || D <- Ds0],
@@ -230,14 +232,15 @@ remap_block([{set,Ds0,Ss0,Info}|Is], Map, Acc) ->
     remap_block(Is, Map, [{set,Ds,Ss,Info}|Acc]);
 remap_block([], _, Acc) -> reverse(Acc).
     
-safe_labels([{label,L},{badmatch,{Tag,_}}|Is], Acc) when Tag =/= y ->
+safe_labels([{label,L},{line,_},{badmatch,{Tag,_}}|Is], Acc) when Tag =/= y ->
     safe_labels(Is, [L|Acc]);
-safe_labels([{label,L},{case_end,{Tag,_}}|Is], Acc) when Tag =/= y ->
+safe_labels([{label,L},{line,_},{case_end,{Tag,_}}|Is], Acc) when Tag =/= y ->
     safe_labels(Is, [L|Acc]);
-safe_labels([{label,L},if_end|Is], Acc) ->
+safe_labels([{label,L},{line,_},if_end|Is], Acc) ->
     safe_labels(Is, [L|Acc]);
 safe_labels([{label,L},
 	     {block,[{set,[{x,0}],[{Tag,_}],move}]},
+	     {line,_},
 	     {call_ext,1,{extfunc,erlang,error,1}}|Is], Acc) when Tag =/= y ->
     safe_labels(Is, [L|Acc]);
 safe_labels([_|Is], Acc) ->
@@ -321,6 +324,8 @@ frame_size([{make_fun2,_,_,_,_}|Is], Safe) ->
 frame_size([{deallocate,N}|_], _) -> N;
 frame_size([{call_last,_,_,N}|_], _) -> N;
 frame_size([{call_ext_last,_,_,N}|_], _) -> N;
+frame_size([{line,_}|Is], Safe) ->
+    frame_size(Is, Safe);
 frame_size([_|_], _) -> throw(not_possible).
 
 frame_size_branch(0, Is, Safe) ->
diff --git a/lib/compiler/src/beam_type.erl b/lib/compiler/src/beam_type.erl
index f83f73b224..7fdb8d072a 100644
--- a/lib/compiler/src/beam_type.erl
+++ b/lib/compiler/src/beam_type.erl
@@ -400,6 +400,7 @@ update({call_ext,3,{extfunc,erlang,setelement,3}}, Ts0) ->
 update({call,_Arity,_Func}, Ts) -> tdb_kill_xregs(Ts);
 update({call_ext,_Arity,_Func}, Ts) -> tdb_kill_xregs(Ts);
 update({make_fun2,_,_,_,_}, Ts) -> tdb_kill_xregs(Ts);
+update({line,_}, Ts) -> Ts;
 
 %% The instruction is unknown.  Kill all information.
 update(_I, _Ts) -> tdb_new().
diff --git a/lib/compiler/src/beam_utils.erl b/lib/compiler/src/beam_utils.erl
index 45cdf8a659..f281ad5eac 100644
--- a/lib/compiler/src/beam_utils.erl
+++ b/lib/compiler/src/beam_utils.erl
@@ -26,7 +26,7 @@
 	 code_at/2,bif_to_test/3,is_pure_test/1,
 	 live_opt/1,delete_live_annos/1,combine_heap_needs/2]).
 
--import(lists, [member/2,sort/1,reverse/1]).
+-import(lists, [member/2,sort/1,reverse/1,splitwith/2]).
 
 -record(live,
 	{bl,					%Block check fun.
@@ -195,10 +195,14 @@ is_pure_test({test,Op,_,Ops}) ->
 %%  Also insert {'%live',Live} annotations at the beginning
 %%  and end of each block.
 %%
-live_opt([{label,Fail}=I1,
-	  {func_info,_,_,Live}=I2|Is]) ->
+live_opt(Is0) ->
+    {[{label,Fail}|_]=Bef,[Fi|Is]} =
+	splitwith(fun({func_info,_,_,_}) -> false;
+		     (_) -> true
+		  end, Is0),
+    {func_info,_,_,Live} = Fi,
     D = gb_trees:insert(Fail, live_call(Live), gb_trees:empty()),
-    [I1,I2|live_opt(reverse(Is), 0, D, [])].
+    Bef ++ [Fi|live_opt(reverse(Is), 0, D, [])].
 
 
 %% delete_live_annos([Instruction]) -> [Instruction].
@@ -499,6 +503,8 @@ check_liveness(R, [{loop_rec,{f,_},{x,0}}|_], St) ->
     end;
 check_liveness(R, [{loop_rec_end,{f,Fail}}|_], St) ->
     check_liveness_at(R, Fail, St);
+check_liveness(R, [{line,_}|Is], St) ->
+    check_liveness(R, Is, St);
 check_liveness(_R, Is, St) when is_list(Is) ->
 %%     case Is of
 %% 	[I|_] ->
@@ -799,6 +805,8 @@ live_opt([{wait,_}=I|Is], Regs, D, Acc) ->
     live_opt(Is, Regs, D, [I|Acc]);
 live_opt([{wait_timeout,_,{Tag,_}}=I|Is], Regs, D, Acc) when Tag =/= x ->
     live_opt(Is, Regs, D, [I|Acc]);
+live_opt([{line,_}=I|Is], Regs, D, Acc) ->
+    live_opt(Is, Regs, D, [I|Acc]);
 
 %% The following instructions can occur if the "compilation" has been
 %% started from a .S file using the 'asm' option.
diff --git a/lib/compiler/src/beam_validator.erl b/lib/compiler/src/beam_validator.erl
index fb267b35b6..fe3b1680d9 100644
--- a/lib/compiler/src/beam_validator.erl
+++ b/lib/compiler/src/beam_validator.erl
@@ -166,12 +166,17 @@ validate(Module, Fs) ->
     Ft = index_bs_start_match(Fs, []),
     validate_0(Module, Fs, Ft).
 
-index_bs_start_match([{function,_,_,Entry,Code}|Fs], Acc0) ->
+index_bs_start_match([{function,_,_,Entry,Code0}|Fs], Acc0) ->
+    Code = dropwhile(fun({label,L}) when L =:= Entry -> false;
+			(_) -> true
+		     end, Code0),
     case Code of
-	[_,_,{label,Entry}|Is] ->
+	[{label,Entry}|Is] ->
 	    Acc = index_bs_start_match_1(Is, Entry, Acc0),
 	    index_bs_start_match(Fs, Acc);
 	_ ->
+	    %% Something serious is wrong. Ignore it for now.
+	    %% It will be detected and diagnosed later.
 	    index_bs_start_match(Fs, Acc0)
     end;
 index_bs_start_match([], Acc) ->
@@ -292,6 +297,8 @@ labels(Is) ->
 
 labels_1([{label,L}|Is], R) ->
     labels_1(Is, [L|R]);
+labels_1([{line,_}|Is], R) ->
+    labels_1(Is, R);
 labels_1(Is, R) ->
     {lists:reverse(R),Is}.
 
@@ -433,6 +440,8 @@ valfun_1(remove_message, Vst) ->
     Vst;
 valfun_1({'%',_}, Vst) ->
     Vst;
+valfun_1({line,_}, Vst) ->
+    Vst;
 %% Exception generating calls
 valfun_1({call_ext,Live,Func}=I, Vst) ->
     case return_type(Func, Vst) of
@@ -870,6 +879,8 @@ val_dsetel({set_tuple_element,_,_,_}, #vst{current=#st{setelem=false}}) ->
     error(illegal_context_for_set_tuple_element);
 val_dsetel({set_tuple_element,_,_,_}, #vst{current=#st{setelem=true}}=Vst) ->
     Vst;
+val_dsetel({line,_}, Vst) ->
+    Vst;
 val_dsetel(_, #vst{current=#st{setelem=true}=St}=Vst) ->
     Vst#vst{current=St#st{setelem=false}};
 val_dsetel(_, Vst) -> Vst.
diff --git a/lib/compiler/src/v3_codegen.erl b/lib/compiler/src/v3_codegen.erl
index 55e3c58d2a..e7dae67085 100644
--- a/lib/compiler/src/v3_codegen.erl
+++ b/lib/compiler/src/v3_codegen.erl
@@ -79,9 +79,10 @@ module({Mod,Exp,Attr,Forms}, Options) ->
 functions(Forms, AtomMod) ->
     mapfoldl(fun (F, St) -> function(F, AtomMod, St) end, #cg{lcount=1}, Forms).
 
-function({function,Name,Arity,Asm0,Vb,Vdb}, AtomMod, St0) ->
+function({function,Name,Arity,Asm0,Vb,Vdb,Anno}, AtomMod, St0) ->
     try
-	{Asm,EntryLabel,St} = cg_fun(Vb, Asm0, Vdb, AtomMod, {Name,Arity}, St0),
+	{Asm,EntryLabel,St} = cg_fun(Vb, Asm0, Vdb, AtomMod,
+				     {Name,Arity}, Anno, St0),
 	Func = {function,Name,Arity,EntryLabel,Asm},
 	{Func,St}
     catch
@@ -93,7 +94,7 @@ function({function,Name,Arity,Asm0,Vb,Vdb}, AtomMod, St0) ->
 
 %% cg_fun([Lkexpr], [HeadVar], Vdb, State) -> {[Ainstr],State}
 
-cg_fun(Les, Hvs, Vdb, AtomMod, NameArity, St0) ->
+cg_fun(Les, Hvs, Vdb, AtomMod, NameArity, Anno, St0) ->
     {Fi,St1} = new_label(St0),			%FuncInfo label
     {Fl,St2} = local_func_label(NameArity, St1),
 
@@ -129,7 +130,7 @@ cg_fun(Les, Hvs, Vdb, AtomMod, NameArity, St0) ->
 				 ultimate_failure=UltimateMatchFail,
 				 is_top_block=true}),
     {Name,Arity} = NameArity,
-    Asm = [{label,Fi},{func_info,AtomMod,{atom,Name},Arity},
+    Asm = [{label,Fi},line(Anno),{func_info,AtomMod,{atom,Name},Arity},
 	   {label,Fl}|B++[{label,UltimateMatchFail},if_end]],
     {Asm,Fl,St}.
 
@@ -307,23 +308,23 @@ match_fail_cg({badmatch,Term}, Le, Vdb, Bef, St) ->
     R = cg_reg_arg(Term, Bef),
     Int0 = clear_dead(Bef, Le#l.i, Vdb),
     {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
-    {Sis ++ [{badmatch,R}],
+    {Sis ++ [line(Le),{badmatch,R}],
      Int#sr{reg=clear_regs(Int0#sr.reg)},St};
 match_fail_cg({case_clause,Reason}, Le, Vdb, Bef, St) ->
     R = cg_reg_arg(Reason, Bef),
     Int0 = clear_dead(Bef, Le#l.i, Vdb),
     {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
-    {Sis++[{case_end,R}],
+    {Sis++[line(Le),{case_end,R}],
      Int#sr{reg=clear_regs(Bef#sr.reg)},St};
 match_fail_cg(if_clause, Le, Vdb, Bef, St) ->
     Int0 = clear_dead(Bef, Le#l.i, Vdb),
     {Sis,Int1} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
-    {Sis++[if_end],Int1#sr{reg=clear_regs(Int1#sr.reg)},St};
+    {Sis++[line(Le),if_end],Int1#sr{reg=clear_regs(Int1#sr.reg)},St};
 match_fail_cg({try_clause,Reason}, Le, Vdb, Bef, St) ->
     R = cg_reg_arg(Reason, Bef),
     Int0 = clear_dead(Bef, Le#l.i, Vdb),
     {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
-    {Sis ++ [{try_case_end,R}],
+    {Sis ++ [line(Le),{try_case_end,R}],
      Int#sr{reg=clear_regs(Int0#sr.reg)},St}.
 
 %% bsm_rename_ctx([Clause], Var) -> [Clause]
@@ -1047,7 +1048,7 @@ call_cg({var,_V} = Var, As, Rs, Le, Vdb, Bef, St0) ->
     %% Build complete code and final stack/register state.
     Arity = length(As),
     {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
-    {Sis ++ Frees ++ [{call_fun,Arity}],Aft,
+    {Sis ++ Frees ++ [line(Le),{call_fun,Arity}],Aft,
      need_stack_frame(St0)};
 call_cg({remote,Mod,Name}, As, Rs, Le, Vdb, Bef, St0)
   when element(1, Mod) =:= var;
@@ -1057,11 +1058,10 @@ call_cg({remote,Mod,Name}, As, Rs, Le, Vdb, Bef, St0)
     Reg = load_vars(Rs, clear_regs(Int#sr.reg)),
     %% Build complete code and final stack/register state.
     Arity = length(As),
-    Call = {apply,Arity},
     St = need_stack_frame(St0),
     %%{Call,St1} = build_call(Func, Arity, St0),
     {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
-    {Sis ++ Frees ++ [Call],Aft,St};
+    {Sis ++ Frees ++ [line(Le),{apply,Arity}],Aft,St};
 call_cg(Func, As, Rs, Le, Vdb, Bef, St0) ->
     case St0 of
 	#cg{bfail=Fail} when Fail =/= 0 ->
@@ -1091,7 +1091,7 @@ call_cg(Func, As, Rs, Le, Vdb, Bef, St0) ->
 	    Arity = length(As),
 	    {Call,St1} = build_call(Func, Arity, St0),
 	    {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
-	    {Sis ++ Frees ++ Call,Aft,St1}
+	    {Sis ++ Frees ++ [line(Le)|Call],Aft,St1}
     end.
 
 build_call({remote,{atom,erlang},{atom,'!'}}, 2, St0) ->
@@ -1118,7 +1118,7 @@ enter_cg({var,_V} = Var, As, Le, Vdb, Bef, St0) ->
     {Sis,Int} = cg_setup_call(As++[Var], Bef, Le#l.i, Vdb),
     %% Build complete code and final stack/register state.
     Arity = length(As),
-    {Sis ++ [{call_fun,Arity},return],
+    {Sis ++ [line(Le),{call_fun,Arity},return],
      clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
      need_stack_frame(St0)};
 enter_cg({remote,Mod,Name}, As, Le, Vdb, Bef, St0)
@@ -1127,9 +1127,8 @@ enter_cg({remote,Mod,Name}, As, Le, Vdb, Bef, St0)
     {Sis,Int} = cg_setup_call(As++[Mod,Name], Bef, Le#l.i, Vdb),
     %% Build complete code and final stack/register state.
     Arity = length(As),
-    Call = {apply_only,Arity},
     St = need_stack_frame(St0),
-    {Sis ++ [Call],
+    {Sis ++ [line(Le),{apply_only,Arity}],
      clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
      St};
 enter_cg(Func, As, Le, Vdb, Bef, St0) ->
@@ -1137,7 +1136,8 @@ enter_cg(Func, As, Le, Vdb, Bef, St0) ->
     %% Build complete code and final stack/register state.
     Arity = length(As),
     {Call,St1} = build_enter(Func, Arity, St0),
-    {Sis ++ Call,
+    Line = enter_line(Func, Arity, Le),
+    {Sis ++ Line ++ Call,
      clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
      St1}.
 
@@ -1153,6 +1153,23 @@ build_enter(Name, Arity, St0) when is_atom(Name) ->
     {Lbl,St1} = local_func_label(Name, Arity, St0),
     {[{call_only,Arity,{f,Lbl}}],St1}.
 
+enter_line({remote,{atom,Mod},{atom,Name}}, Arity, Le) ->
+    case erl_bifs:is_safe(Mod, Name, Arity) of
+	false ->
+	    %% Tail-recursive call, possibly to a BIF.
+	    %% We'll need a line instruction in case the
+	    %% BIF call fails.
+	    [line(Le)];
+	true ->
+	    %% Call to a safe BIF. Since it cannot fail,
+	    %% we don't need any line instruction here.
+	    []
+    end;
+enter_line(_, _, _) ->
+    %% Tail-recursive call to a local function. A line
+    %% instruction will not be useful.
+    [].
+
 %% local_func_label(Name, Arity, State) -> {Label,State'}
 %% local_func_label({Name,Arity}, State) -> {Label,State'}
 %%  Get the function entry label for a local function.
@@ -1226,9 +1243,10 @@ bif_cg(Bif, As, [{var,V}], Le, Vdb, Bef, St0) ->
     %%   Currently, we are somewhat pessimistic in
     %% that we save any variable that will be live after this BIF call.
 
+    MayFail = not erl_bifs:is_safe(erlang, Bif, length(As)),
     {Sis,Int0} = case St0#cg.in_catch andalso
 		     St0#cg.bfail =:= 0 andalso
-		     not erl_bifs:is_safe(erlang, Bif, length(As)) of
+		     MayFail of
 		     true -> adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb);
 		     false -> {[],Bef}
 		 end,
@@ -1237,7 +1255,14 @@ bif_cg(Bif, As, [{var,V}], Le, Vdb, Bef, St0) ->
     Int = Int1#sr{reg=Reg},
     Dst = fetch_reg(V, Reg),
     BifFail = {f,St0#cg.bfail},
-    {Sis++[{bif,Bif,BifFail,Ars,Dst}],
+    %% We need a line instructions for BIFs that may fail in a body.
+    Line = case BifFail of
+	       {f,0} when MayFail ->
+		   [line(Le)];
+	       _ ->
+		   []
+	   end,
+    {Sis++Line++[{bif,Bif,BifFail,Ars,Dst}],
      clear_dead(Int, Le#l.i, Vdb), St0}.
 
 
@@ -1266,7 +1291,11 @@ gc_bif_cg(Bif, As, [{var,V}], Le, Vdb, Bef, St0) ->
     Int = Int1#sr{reg=Reg},
     Dst = fetch_reg(V, Reg),
     BifFail = {f,St0#cg.bfail},
-    {Sis++[{gc_bif,Bif,BifFail,max_reg(Bef#sr.reg),Ars,Dst}],
+    Line = case BifFail of
+	       {f,0} -> [line(Le)];
+	       {f,_} -> []
+	   end,
+    {Sis++Line++[{gc_bif,Bif,BifFail,max_reg(Bef#sr.reg),Ars,Dst}],
      clear_dead(Int, Le#l.i, Vdb), St0}.
 
 %% recv_loop_cg(TimeOut, ReceiveVar, ReceiveMatch, TimeOutExprs,
@@ -1284,7 +1313,7 @@ recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St0) ->
     {Wis,Taft,St6} = cg_recv_wait(Te, Tes, Le#l.i, Int1, St5),
     Int2 = sr_merge(Raft, Taft),		%Merge stack/registers
     Reg = load_vars(Rs, Int2#sr.reg),
-    {Sis ++ Ris ++ [{label,Tl}] ++ Wis ++ [{label,Bl}],
+    {Sis ++ [line(Le)] ++ Ris ++ [{label,Tl}] ++ Wis ++ [{label,Bl}],
      clear_dead(Int2#sr{reg=Reg}, Le#l.i, Vdb),
      St6#cg{break=St0#cg.break,recv=St0#cg.recv}}.
 
@@ -1463,12 +1492,13 @@ cg_binary([{bs_put_binary,Fail,{atom,all},U,_Flags,Src}|PutCode],
 		 {bs_append,Fail,Target,0,MaxRegs,U,Src,BinFlags,Target}
 	 end] ++ PutCode,
     cg_bin_opt(Code);
-cg_binary(PutCode, Target, Temp, Fail, MaxRegs, _Anno) ->
+cg_binary(PutCode, Target, Temp, Fail, MaxRegs, Anno) ->
+    Line = line(Anno),
     Live = cg_live(Target, MaxRegs),
     {InitOp,SzCode} = cg_binary_size(PutCode, Target, Temp, Fail, Live),
 
-    Code = SzCode ++ [{InitOp,Fail,Target,0,MaxRegs,
-		       {field_flags,[]},Target}|PutCode],
+    Code = [Line|SzCode] ++ [{InitOp,Fail,Target,0,MaxRegs,
+			      {field_flags,[]},Target}|PutCode],
     cg_bin_opt(Code).
 
 cg_live({x,X}, MaxRegs) when X =:= MaxRegs -> MaxRegs+1;
@@ -2052,6 +2082,38 @@ drop_catch(Tag, [Other|Stk]) -> [Other|drop_catch(Tag, Stk)].
 new_label(#cg{lcount=Next}=St) ->
     {Next,St#cg{lcount=Next+1}}.
 
+%% line(Le) -> {line,[] | {location,File,Line}}
+%%  Create a line instruction, containing information about
+%%  the current filename and line number. A line information
+%%  instruction should be placed before any operation that could
+%%  cause an exception.
+
+line(#l{a=Anno}) ->
+    line(Anno);
+line([Line,{file,Name}]) when is_integer(Line) ->
+    line_1(Name, Line);
+line([_|_]=A) ->
+    {Name,Line} = find_loc(A, no_file, 0),
+    line_1(Name, Line);
+line([]) ->
+    {line,[]}.
+
+line_1(no_file, _) ->
+    {line,[]};
+line_1(_, 0) ->
+    %% Missing line number or line number 0.
+    {line,[]};
+line_1(Name, Line) ->
+    {line,[{location,Name,abs(Line)}]}.
+
+find_loc([Line|T], File, _) when is_integer(Line) ->
+    find_loc(T, File, Line);
+find_loc([{file,File}|T], _, Line) ->
+    find_loc(T, File, Line);
+find_loc([_|T], File, Line) ->
+    find_loc(T, File, Line);
+find_loc([], File, Line) -> {File,Line}.
+
 flatmapfoldl(F, Accu0, [Hd|Tail]) ->
     {R,Accu1} = F(Hd, Accu0),
     {Rs,Accu2} = flatmapfoldl(F, Accu1, Tail),
diff --git a/lib/compiler/src/v3_life.erl b/lib/compiler/src/v3_life.erl
index a7a4d4dc91..a1d92af9f8 100644
--- a/lib/compiler/src/v3_life.erl
+++ b/lib/compiler/src/v3_life.erl
@@ -65,7 +65,7 @@ functions([], Acc) -> reverse(Acc).
 
 %% function(Kfunc) -> Func.
 
-function(#k_fdef{func=F,arity=Ar,vars=Vs,body=Kb}) ->
+function(#k_fdef{anno=#k{a=Anno},func=F,arity=Ar,vars=Vs,body=Kb}) ->
     try
 	As = var_list(Vs),
 	Vdb0 = foldl(fun ({var,N}, Vdb) -> new_var(N, 0, Vdb) end, [], As),
@@ -80,7 +80,7 @@ function(#k_fdef{func=F,arity=Ar,vars=Vs,body=Kb}) ->
 	put(guard_refc, 0),
 	{B1,_,Vdb1} = body(B0, 1, Vdb0),
 	erase(guard_refc),
-	{function,F,Ar,As,B1,Vdb1}
+	{function,F,Ar,As,B1,Vdb1,Anno}
     catch
 	Class:Error ->
 	    Stack = erlang:get_stacktrace(),
diff --git a/lib/compiler/test/misc_SUITE.erl b/lib/compiler/test/misc_SUITE.erl
index c941a80e61..9b414cade6 100644
--- a/lib/compiler/test/misc_SUITE.erl
+++ b/lib/compiler/test/misc_SUITE.erl
@@ -179,7 +179,7 @@ silly_coverage(Config) when is_list(Config) ->
     ?line expect_error(fun() -> v3_life:module(BadKernel, []) end),
 
     %% v3_codegen
-    CodegenInput = {?MODULE,[{foo,0}],[],[{function,foo,0,[a|b],a,b}]},
+    CodegenInput = {?MODULE,[{foo,0}],[],[{function,foo,0,[a|b],a,b,[]}]},
     ?line expect_error(fun() -> v3_codegen:module(CodegenInput, []) end),
 
     %% beam_block
@@ -187,7 +187,7 @@ silly_coverage(Config) when is_list(Config) ->
 		  [{function,foo,0,2,
 		    [{label,1},
 		     {func_info,{atom,?MODULE},{atom,foo},0},
-		     {label,2}|non_proper_list],99}]},
+		     {label,2}|non_proper_list]}],99},
     ?line expect_error(fun() -> beam_block:module(BlockInput, []) end),
 
     %% beam_bool
-- 
cgit v1.2.3