Merge branch 'bjorn/line-numbers-in-exceptions/OTP-9468' into major

* bjorn/line-numbers-in-exceptions/OTP-9468: (51 commits)
  debugger: By default, only save non-tail-recursive calls
  debugger: Add line_number_SUITE
  debugger: Include line numbers in exceptions
  Update examples in the documentation to include line numbers
  Update documentation for erlang:raise/3 and erlang:get_stacktrace/0
  beam_lib: Retain the "Line" chunk when stripping BEAM files
  erl: Add +L to suppress loading of line number information
  compiler: Add no_line_info for suppressing line/1 instructions
  exception_SUITE: Test line numbers in exceptions
  common_test: Use line numbers in exceptions
  common_test tests: Don't do detailed testing of the stack backtrace
  test_server: Refactor init_per_testcase/3 into two functions
  Implement process_info(Pid, current_{location,stacktrace})
  beam_emu: Factor out saving of stack trace from save_stacktrace()
  compiler: Don't create filenames starting with "./"
  ops.tab: Remove line instructions before tail-recursive calls
  Lookup and include filenames and line numbers in exceptions
  Fix decrement of continuation pointers
  Refactor building of the exception stacktrace
  BEAM loader: Load the line table
  ...

6 files changed, 365 insertions, 60 deletions

diff --git a/erts/emulator/test/bs_match_misc_SUITE.erl b/erts/emulator/test/bs_match_misc_SUITE.erl
index b022f96740..15427661f3 100644
--- a/erts/emulator/test/bs_match_misc_SUITE.erl
+++ b/erts/emulator/test/bs_match_misc_SUITE.erl
@@ -23,7 +23,7 @@
 	 bound_var/1,bound_tail/1,t_float/1,little_float/1,sean/1,
 	 kenneth/1,encode_binary/1,native/1,happi/1,
 	 size_var/1,wiger/1,x0_context/1,huge_float_field/1,
-	 writable_binary_matched/1,otp_7198/1]).
+	 writable_binary_matched/1,otp_7198/1,unordered_bindings/1]).
 
 -include_lib("test_server/include/test_server.hrl").
 
@@ -33,7 +33,7 @@ all() ->
     [bound_var, bound_tail, t_float, little_float, sean,
      kenneth, encode_binary, native, happi, size_var, wiger,
      x0_context, huge_float_field, writable_binary_matched,
-     otp_7198].
+     otp_7198, unordered_bindings].
 
 groups() -> 
     [].
@@ -553,5 +553,15 @@ otp_7198_scan(<<C, Rest/binary>>, TokAcc) when
                         otp_7198_scan(Rest, [{'KEYWORD', C} | TokAcc])
         end.
 
+unordered_bindings(Config) when is_list(Config) ->
+    {<<1,2,3,4>>,<<42,42>>,<<3,3,3>>} =
+	unordered_bindings(4, 2, 3, <<1,2,3,4, 42,42, 3,3,3, 3>>),
+    ok.
+
+unordered_bindings(CompressedLength, HashSize, PadLength, T) ->
+    <<Content:CompressedLength/binary,Mac:HashSize/binary,
+     Padding:PadLength/binary,PadLength>> = T,
+    {Content,Mac,Padding}.
+
 
 id(I) -> I.
diff --git a/erts/emulator/test/call_trace_SUITE.erl b/erts/emulator/test/call_trace_SUITE.erl
index 93fdc157f7..3e2bee06d1 100644
--- a/erts/emulator/test/call_trace_SUITE.erl
+++ b/erts/emulator/test/call_trace_SUITE.erl
@@ -934,6 +934,10 @@ exception_nocatch(Config) when is_list(Config) ->
     exception_nocatch().
 
 exception_nocatch() ->
+    Deep4LocThrow = get_deep_4_loc({throw,[42]}),
+    Deep4LocError = get_deep_4_loc({error,[42]}),
+    Deep4LocBadmatch = get_deep_4_loc({'=',[a,b]}),
+
     Prog = [{'_',[],[{exception_trace}]}],
     ?line 1 = erlang:trace_pattern({?MODULE,deep_1,'_'}, Prog),
     ?line 1 = erlang:trace_pattern({?MODULE,deep_2,'_'}, Prog),
@@ -959,8 +963,9 @@ exception_nocatch() ->
 			   {trace,t2,exception_from,{erlang,throw,1},
 			    {error,{nocatch,Q2}}}],
 			  exception_from, {error,{nocatch,Q2}}),
-    ?line expect({trace,T2,exit,{{nocatch,Q2},[{erlang,throw,[Q2]},
-					       {?MODULE,deep_4,1}]}}),
+    ?line expect({trace,T2,exit,{{nocatch,Q2},[{erlang,throw,[Q2],[]},
+					       {?MODULE,deep_4,1,
+						Deep4LocThrow}]}}),
     ?line Q3 = {dump,[dump,{dump}]},
     ?line T3 = 
 	exception_nocatch(?LINE, error, [Q3], 4, 
@@ -968,18 +973,29 @@ exception_nocatch() ->
 			   {trace,t3,exception_from,{erlang,error,1},
 			    {error,Q3}}],
 			  exception_from, {error,Q3}),
-    ?line expect({trace,T3,exit,{Q3,[{erlang,error,[Q3]},
-				     {?MODULE,deep_4,1}]}}),
+    ?line expect({trace,T3,exit,{Q3,[{erlang,error,[Q3],[]},
+				     {?MODULE,deep_4,1,Deep4LocError}]}}),
     ?line T4 = 
 	exception_nocatch(?LINE, '=', [17,4711], 5, [], 
 			  exception_from, {error,{badmatch,4711}}),
-    ?line expect({trace,T4,exit,{{badmatch,4711},[{?MODULE,deep_4,1}]}}),
+    ?line expect({trace,T4,exit,{{badmatch,4711},
+				 [{?MODULE,deep_4,1,Deep4LocBadmatch}]}}),
     %%
     ?line erlang:trace_pattern({?MODULE,'_','_'}, false),
     ?line erlang:trace_pattern({erlang,'_','_'}, false),
     ?line expect(),
     ?line ok.
 
+get_deep_4_loc(Arg) ->
+    try
+	deep_4(Arg),
+	?t:fail(should_not_return_to_here)
+    catch
+	_:_ ->
+	    [{?MODULE,deep_4,1,Loc0}|_] = erlang:get_stacktrace(),
+	    Loc0
+    end.
+
 exception_nocatch(Line, B, Q, N, Extra, Tag, R) ->
     ?line io:format("== Subtest: ~w", [Line]),
     ?line Go = make_ref(),
diff --git a/erts/emulator/test/exception_SUITE.erl b/erts/emulator/test/exception_SUITE.erl
index 9d6fc9521d..109cec25cb 100644
--- a/erts/emulator/test/exception_SUITE.erl
+++ b/erts/emulator/test/exception_SUITE.erl
@@ -23,9 +23,10 @@
 	 init_per_group/2,end_per_group/2, 
 	 badmatch/1, pending_errors/1, nil_arith/1,
          stacktrace/1, nested_stacktrace/1, raise/1, gunilla/1, per/1,
-	 exception_with_heap_frag/1]).
+	 exception_with_heap_frag/1, line_numbers/1]).
 
 -export([bad_guy/2]).
+-export([crash/1]).
 
 -include_lib("test_server/include/test_server.hrl").
 -import(lists, [foreach/2]).
@@ -35,7 +36,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}].
 all() -> 
     [badmatch, pending_errors, nil_arith, stacktrace,
      nested_stacktrace, raise, gunilla, per,
-     exception_with_heap_frag].
+     exception_with_heap_frag, line_numbers].
 
 groups() -> 
     [].
@@ -141,14 +142,20 @@ pending_exit_message(Args, Expected) ->
     end,
     process_flag(trap_exit, false).
 
-pending({badarg, [{erlang,Bif,BifArgs},{?MODULE,Func,Arity}|_]}, Func, Args, _Code)
-  when is_atom(Bif), is_list(BifArgs), length(Args) == Arity ->
+pending({badarg,[{erlang,Bif,BifArgs,Loc1},
+		 {?MODULE,Func,Arity,Loc2}|_]},
+	Func, Args, _Code)
+  when is_atom(Bif), is_list(BifArgs), length(Args) =:= Arity,
+       is_list(Loc1), is_list(Loc2) ->
     ok;
-pending({undef,[{non_existing_module,foo,[]}|_]}, _, _, _) ->
+pending({undef,[{non_existing_module,foo,[],Loc}|_]}, _, _, _)
+  when is_list(Loc) ->
     ok;
-pending({function_clause,[{?MODULE,Func,Args}|_]}, Func, Args, _Code) ->
+pending({function_clause,[{?MODULE,Func,Args,Loc}|_]}, Func, Args, _Code)
+  when is_list(Loc) ->
     ok;
-pending({Code,[{?MODULE,Func,Arity}|_]}, Func, Args, Code) when length(Args) == Arity ->
+pending({Code,[{?MODULE,Func,Arity,Loc}|_]}, Func, Args, Code)
+  when length(Args) =:= Arity, is_list(Loc) ->
     ok;
 pending(Reason, _Function, _Args, _Code) ->
     test_server:fail({bad_exit_reason,Reason}).
@@ -255,24 +262,24 @@ stacktrace(Conf) when is_list(Conf) ->
     ?line {_,Mref} = spawn_monitor(fun() -> exit({Tag,erlang:get_stacktrace()}) end),
     ?line {Tag,[]} = receive {'DOWN',Mref,_,_,Info} -> Info end,
     V = [make_ref()|self()],
-    ?line {value2,{caught1,badarg,[{erlang,abs,[V]}|_]=St1}} =
+    ?line {value2,{caught1,badarg,[{erlang,abs,[V],_}|_]=St1}} =
 	stacktrace_1({'abs',V}, error, {value,V}),
     ?line St1 = erase(stacktrace1),
     ?line St1 = erase(stacktrace2),
     ?line St1 = erlang:get_stacktrace(),
-    ?line {caught2,{error,badarith},[{?MODULE,my_add,2}|_]=St2} =
+    ?line {caught2,{error,badarith},[{?MODULE,my_add,2,_}|_]=St2} =
 	stacktrace_1({'div',{1,0}}, error, {'add',{0,a}}),
-    ?line [{?MODULE,my_div,2}|_] = erase(stacktrace1),
+    ?line [{?MODULE,my_div,2,_}|_] = erase(stacktrace1),
     ?line St2 = erase(stacktrace2),
     ?line St2 = erlang:get_stacktrace(),
-    ?line {caught2,{error,{try_clause,V}},[{?MODULE,stacktrace_1,3}|_]=St3} =
+    ?line {caught2,{error,{try_clause,V}},[{?MODULE,stacktrace_1,3,_}|_]=St3} =
 	stacktrace_1({value,V}, error, {value,V}),
     ?line St3 = erase(stacktrace1),
     ?line St3 = erase(stacktrace2),
     ?line St3 = erlang:get_stacktrace(),
-    ?line {caught2,{throw,V},[{?MODULE,foo,1}|_]=St4} =
+    ?line {caught2,{throw,V},[{?MODULE,foo,1,_}|_]=St4} =
 	stacktrace_1({value,V}, error, {throw,V}),
-    ?line [{?MODULE,stacktrace_1,3}|_] = erase(stacktrace1),
+    ?line [{?MODULE,stacktrace_1,3,_}|_] = erase(stacktrace1),
     ?line St4 = erase(stacktrace2),
     ?line St4 = erlang:get_stacktrace(),
 
@@ -280,8 +287,8 @@ stacktrace(Conf) when is_list(Conf) ->
 	?line stacktrace_2()
     catch
 	error:{badmatch,_} ->
-	    [{?MODULE,stacktrace_2,0},
-	     {?MODULE,stacktrace,1}|_] =
+	    [{?MODULE,stacktrace_2,0,_},
+	     {?MODULE,stacktrace,1,_}|_] =
 		erlang:get_stacktrace(),
 	    ok
     end.
@@ -315,15 +322,15 @@ nested_stacktrace(Conf) when is_list(Conf) ->
 	nested_stacktrace_1({{value,{V,x1}},void,{V,x1}},
 			    {void,void,void}),
     ?line {caught1,
-	   [{?MODULE,my_add,2}|_],
+	   [{?MODULE,my_add,2,_}|_],
 	   value2,
-	   [{?MODULE,my_add,2}|_]} =
+	   [{?MODULE,my_add,2,_}|_]} =
 	nested_stacktrace_1({{'add',{V,x1}},error,badarith},
 			    {{value,{V,x2}},void,{V,x2}}),
     ?line {caught1,
-	   [{?MODULE,my_add,2}|_],
-	   {caught2,[{erlang,abs,[V]}|_]},
-	   [{erlang,abs,[V]}|_]} =
+	   [{?MODULE,my_add,2,_}|_],
+	   {caught2,[{erlang,abs,[V],_}|_]},
+	   [{erlang,abs,[V],_}|_]} =
 	nested_stacktrace_1({{'add',{V,x1}},error,badarith},
 			    {{'abs',V},error,badarg}),
     ok.
@@ -362,14 +369,14 @@ raise(Conf) when is_list(Conf) ->
 	end,
     ?line A = erlang:get_stacktrace(),
     ?line A = get(raise),
-    ?line [{?MODULE,my_div,2}|_] = A,
+    ?line [{?MODULE,my_div,2,_}|_] = A,
     %%
     N = 8, % Must be even
     ?line N = erlang:system_flag(backtrace_depth, N),
+    ?line B = odd_even(N, []),
     ?line try even(N) 
 	  catch error:function_clause -> ok
 	  end,
-    ?line B = odd_even(N, []),
     ?line B = erlang:get_stacktrace(),
     %%
     ?line C0 = odd_even(N+1, []),
@@ -387,19 +394,12 @@ raise(Conf) when is_list(Conf) ->
 odd_even(N, R) when is_integer(N), N > 1 ->
     odd_even(N-1, 
 	     [if (N rem 2) == 0 ->
-		      {?MODULE,even,1};
+		      {?MODULE,even,1,[{file,"odd_even.erl"},{line,3}]};
 		 true ->
-		      {?MODULE,odd,1}
+		      {?MODULE,odd,1,[{file,"odd_even.erl"},{line,6}]}
 	      end|R]);
 odd_even(1, R) ->
-    [{?MODULE,odd,[1]}|R].
-
-even(N) when is_integer(N), N > 1, (N rem 2) == 0 ->
-    odd(N-1)++[N].
-
-odd(N) when is_integer(N), N > 1, (N rem 2) == 1 ->
-    even(N-1)++[N].
-    
+    [{?MODULE,odd,[1],[{file,"odd_even.erl"},{line,5}]}|R].
 
 foo({value,Value}) -> Value;
 foo({'div',{A,B}}) ->
@@ -526,4 +526,186 @@ do_exception_with_heap_frag(Bin, [Sz|Sizes]) ->
     do_exception_with_heap_frag(Bin, Sizes);
 do_exception_with_heap_frag(_, []) -> ok.
 
+line_numbers(Config) when is_list(Config) ->
+    {'EXIT',{{case_clause,bad_tag},
+	     [{?MODULE,line1,2,
+	       [{file,"fake_file.erl"},{line,3}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch line1(bad_tag, 0)),
+    {'EXIT',{badarith,
+	     [{?MODULE,line1,2,
+	       [{file,"fake_file.erl"},{line,5}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch line1(a, not_an_integer)),
+    {'EXIT',{{badmatch,{ok,1}},
+	     [{?MODULE,line1,2,
+	       [{file,"fake_file.erl"},{line,7}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch line1(a, 0)),
+    {'EXIT',{crash,
+	     [{?MODULE,crash,1,
+	       [{file,"fake_file.erl"},{line,14}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch line1(a, 41)),
+
+    ModFile = ?MODULE_STRING++".erl",
+    [{?MODULE,maybe_crash,1,[{file,"call.erl"},{line,28}]},
+     {?MODULE,call1,0,[{file,"call.erl"},{line,14}]},
+     {?MODULE,close_calls,1,[{file,"call.erl"},{line,5}]},
+     {?MODULE,line_numbers,1,[{file,ModFile},{line,_}]}|_] =
+	close_calls(call1),
+    [{?MODULE,maybe_crash,1,[{file,"call.erl"},{line,28}]},
+     {?MODULE,call2,0,[{file,"call.erl"},{line,18}]},
+     {?MODULE,close_calls,1,[{file,"call.erl"},{line,6}]},
+     {?MODULE,line_numbers,1,[{file,ModFile},{line,_}]}|_] =
+	close_calls(call2),
+    [{?MODULE,maybe_crash,1,[{file,"call.erl"},{line,28}]},
+     {?MODULE,call3,0,[{file,"call.erl"},{line,22}]},
+     {?MODULE,close_calls,1,[{file,"call.erl"},{line,7}]},
+     {?MODULE,line_numbers,1,[{file,ModFile},{line,_}]}|_] =
+	close_calls(call3),
+    no_crash = close_calls(other),
+
+    <<0,0>> = build_binary1(16),
+    {'EXIT',{badarg,
+	     [{?MODULE,build_binary1,1,
+	       [{file,"bit_syntax.erl"},{line,72503}]},
+	      {?MODULE,line_numbers,1,
+	       [{file,ModFile},{line,_}]}|_]}} =
+	(catch build_binary1(bad_size)),
+
+    <<7,1,2,3>> = build_binary2(8, <<1,2,3>>),
+    {'EXIT',{badarg,
+	     [{?MODULE,build_binary2,2,
+	       [{file,"bit_syntax.erl"},{line,72507}]},
+	      {?MODULE,line_numbers,1,
+	       [{file,ModFile},{line,_}]}|_]}} =
+	(catch build_binary2(bad_size, <<>>)),
+    {'EXIT',{badarg,
+	     [{erlang,bit_size,[bad_binary],[]},
+	      {?MODULE,build_binary2,2,
+	       [{file,"bit_syntax.erl"},{line,72507}]},
+	      {?MODULE,line_numbers,1,
+	       [{file,ModFile},{line,_}]}|_]}} =
+	(catch build_binary2(8, bad_binary)),
+
+    {'EXIT',{function_clause,
+	     [{?MODULE,do_call_abs,[y,y],
+	       [{file,"gc_bif.erl"},{line,18}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch do_call_abs(y, y)),
+    {'EXIT',{badarg,
+	     [{erlang,abs,[[]],[]},
+	      {?MODULE,do_call_abs,2,
+	       [{file,"gc_bif.erl"},{line,19}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch do_call_abs(x, [])),
+
+    {'EXIT',{{badmatch,"42"},
+	     [{MODULE,applied_bif_1,1,[{file,"applied_bif.erl"},{line,5}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch applied_bif_1(42)),
+
+    {'EXIT',{{badmatch,{current_location,
+			{?MODULE,applied_bif_2,0,
+			 [{file,"applied_bif.erl"},{line,9}]}}},
+	     [{MODULE,applied_bif_2,0,[{file,"applied_bif.erl"},{line,10}]},
+	      {?MODULE,line_numbers,1,_}|_]}} =
+	(catch applied_bif_2()),
+
+    ok.
+
 id(I) -> I.
+
+-file("odd_even.erl", 1).			%Line 1
+even(N) when is_integer(N), N > 1, (N rem 2) == 0 ->
+    odd(N-1)++[N].				%Line 3
+
+odd(N) when is_integer(N), N > 1, (N rem 2) == 1 ->
+    even(N-1)++[N].				%Line 6
+
+%%
+%% If the compiler removes redundant line instructions (any
+%% line instruction with the same location as the previous),
+%% and the loader also removes line instructions before
+%% tail-recursive calls to external functions, then the
+%% badmatch exception in line 7 below will be reported as
+%% occurring in line 6.
+%%
+%% That means that any removal of redundant line instructions
+%% must all be done in the compiler OR in the loader.
+%%
+-file("fake_file.erl", 1).			%Line 1
+line1(Tag, X) ->				%Line 2
+    case Tag of					%Line 3
+	a ->
+	    Y = X + 1,				%Line 5
+	    Res = id({ok,Y}),			%Line 6
+	    ?MODULE:crash({ok,42} = Res);	%Line 7
+	b ->
+	    x = id(x),				%Line 9
+	    ok					%Line 10
+    end.					%Line 11
+
+crash(_) ->					%Line 13
+    erlang:error(crash).			%Line 14
+
+-file("call.erl", 1).				%Line 1
+close_calls(Where) ->				%Line 2
+    put(where_to_crash, Where),			%Line 3
+    try
+	call1(),				%Line 5
+	call2(),				%Line 6
+	call3(),				%Line 7
+	no_crash				%Line 8
+    catch error:crash ->
+	    erlang:get_stacktrace()		%Line 10
+    end.					%Line 11
+
+call1() ->					%Line 13
+    maybe_crash(call1),				%Line 14
+    ok.						%Line 15
+
+call2() ->					%Line 17
+    maybe_crash(call2),				%Line 18
+    ok.						%Line 19
+
+call3() ->					%Line 21
+    maybe_crash(call3),				%Line 22
+    ok.						%Line 23
+
+maybe_crash(Name) ->				%Line 25
+    case get(where_to_crash) of			%Line 26
+	Name ->
+	    erlang:error(crash);		%Line 28
+	_ ->
+	    ok					%Line 30
+    end.
+
+-file("bit_syntax.erl", 72500).			%Line 72500
+build_binary1(Size) ->				%Line 72501
+    id(42),					%Line 72502
+    <<0:Size>>.					%Line 72503
+
+build_binary2(Size, Bin) ->			%Line 72505
+    id(0),					%Line 72506
+    <<7:Size,Bin/binary>>.			%Line 72507
+
+-file("gc_bif.erl", 17).
+do_call_abs(x, Arg) ->				%Line 18
+    abs(Arg).					%Line 19
+
+%% Make sure a BIF that is applied does not leave the p->cp
+%% set (and thus generating an extra entry on the stack).
+
+-file("applied_bif.erl", 1).
+%% Explicit apply.
+applied_bif_1(I) ->				%Line 3
+    L = apply(erlang, integer_to_list, [I]),	%Line 4
+    fail = L,					%Line 5
+    ok.						%Line 6
+%% Implicit apply.
+applied_bif_2() ->				%Line 8
+    R = process_info(self(), current_location),	%Line 9
+    fail = R,					%Line 10
+    ok.						%Line 11
diff --git a/erts/emulator/test/guard_SUITE.erl b/erts/emulator/test/guard_SUITE.erl
index f41324c2cc..a5df9b59a0 100644
--- a/erts/emulator/test/guard_SUITE.erl
+++ b/erts/emulator/test/guard_SUITE.erl
@@ -421,7 +421,7 @@ try_gbif(Id, X, Y) ->
 
 try_fail_gbif(Id, X, Y) ->
     case catch guard_bif(Id, X, Y) of
-	{'EXIT', {function_clause,[{?MODULE,guard_bif,[Id,X,Y]}|_]}} ->
+	{'EXIT',{function_clause,[{?MODULE,guard_bif,[Id,X,Y],_}|_]}} ->
 	    io:format("guard_bif(~p, ~p, ~p) -- ok", [Id,X,Y]);
 	Other ->
 	    ?line ok = io:format("guard_bif(~p, ~p, ~p) -- bad result: ~p\n",
@@ -493,9 +493,9 @@ type_tests(Test, [Type|T], Allowed) ->
 	    end;
 	false ->
 	    case catch type_test(Test, Value) of
-		{'EXIT', {function_clause, {?MODULE,type_test,[Test,Value]}}} ->
-		    ok;
-		{'EXIT', {function_clause,[{?MODULE,type_test,[Test,Value]}|_]}} ->
+		{'EXIT',{function_clause,
+			 [{?MODULE,type_test,[Test,Value],Loc}|_]}}
+		when is_list(Loc) ->
 		    ok;
 		{'EXIT',Other} ->
 		    ?line test_server:fail({unexpected_error_reason,Other});
diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index f68e712268..fdc55a4cc5 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -35,7 +35,7 @@
 	 self_exit/1, normal_suicide_exit/1, abnormal_suicide_exit/1,
 	 t_exit_2_catch/1, trap_exit_badarg/1, trap_exit_badarg_in_bif/1,
 	 exit_and_timeout/1, exit_twice/1,
-	 t_process_info/1, process_info_other_msg/1,
+	 t_process_info/1, process_info_other/1, process_info_other_msg/1,
 	 process_info_other_dist_msg/1,
 	 process_info_2_list/1, process_info_lock_reschedule/1,
 	 process_info_lock_reschedule2/1,
@@ -64,7 +64,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}].
 all() -> 
     [spawn_with_binaries, t_exit_1, {group, t_exit_2},
      trap_exit_badarg, trap_exit_badarg_in_bif,
-     t_process_info, process_info_other_msg,
+     t_process_info, process_info_other, process_info_other_msg,
      process_info_other_dist_msg, process_info_2_list,
      process_info_lock_reschedule,
      process_info_lock_reschedule2,
@@ -258,7 +258,9 @@ trap_exit_badarg() ->
     ?line Pid = fun_spawn(fun() -> bad_guy(kb_128()) end),
     ?line Garbage = kb_128(),
     ?line receive
-	      {'EXIT', Pid, {badarg,[{erlang,abs,[Garbage]},{?MODULE,bad_guy,1}|_]}} ->
+	      {'EXIT',Pid,{badarg,[{erlang,abs,[Garbage],Loc1},
+				   {?MODULE,bad_guy,1,Loc2}|_]}}
+	      when is_list(Loc1), is_list(Loc2) ->
 		  ok;
 	      Other ->
 		  ?line ok = io:format("Bad EXIT message: ~P", [Other, 30]),
@@ -410,7 +412,7 @@ etwice_high(Low) ->
     exit(Low, first),
     exit(Low, second).
 
-%% Tests the process_info/1 BIF.
+%% Tests the process_info/2 BIF.
 t_process_info(Config) when is_list(Config) ->
     ?line [] = process_info(self(), registered_name),
     ?line register(my_name, self()),
@@ -418,13 +420,100 @@ t_process_info(Config) when is_list(Config) ->
     ?line {status, running} = process_info(self(), status),
     ?line {min_heap_size, 233} = process_info(self(), min_heap_size),
     ?line {min_bin_vheap_size, 46368} = process_info(self(), min_bin_vheap_size),
-    ?line {current_function, {?MODULE, t_process_info, 1}} =
+    ?line {current_function,{?MODULE,t_process_info,1}} =
 	process_info(self(), current_function),
+    ?line {current_function,{?MODULE,t_process_info,1}} =
+	apply(erlang, process_info, [self(),current_function]),
+
+    %% current_location and current_stacktrace
+    {Line1,Res1} = {?LINE,process_info(self(), current_location)},
+    verify_loc(Line1, Res1),
+    {Line2,Res2} = {?LINE,apply(erlang, process_info,
+				[self(),current_location])},
+    verify_loc(Line2, Res2),
+    pi_stacktrace([{?MODULE,t_process_info,1,?LINE}]),
+
     ?line Gleader = group_leader(),
     ?line {group_leader, Gleader} = process_info(self(), group_leader),
     ?line {'EXIT',{badarg,_Info}} = (catch process_info('not_a_pid')),
     ok.
 
+pi_stacktrace(Expected0) ->
+    {Line,Res} = {?LINE,erlang:process_info(self(), current_stacktrace)},
+    {current_stacktrace,Stack} = Res,
+    Expected = [{?MODULE,pi_stacktrace,1,Line}|Expected0],
+    pi_stacktrace_1(Stack, Expected).
+
+pi_stacktrace_1([{M,F,A,Loc}|Stk], [{M,F,A,Line}|Exp]) ->
+    case Loc of
+	[] ->
+	    %% No location info for some reason (+L, native code).
+	    io:format("Missing location information for ~w:~w/~w",
+		      [M,F,A]),
+	    ok;
+	[_|_] ->
+	    Line = proplists:get_value(line, Loc),
+	    File = proplists:get_value(file, Loc),
+	    File = ?MODULE_STRING ++ ".erl"
+    end,
+    pi_stacktrace_1(Stk, Exp);
+pi_stacktrace_1([_|_], []) -> ok.
+
+verify_loc(Line, {current_location,{?MODULE,t_process_info=F,1=A,Loc}}) ->
+    case Loc of
+	[] ->
+	    %% No location info for some reason (+L, native code).
+	    io:format("Missing location information for ~w:~w/~w",
+		      [?MODULE,F,A]),
+	    ok;
+	[_|_] ->
+	    Line = proplists:get_value(line, Loc),
+	    File = proplists:get_value(file, Loc),
+	    File = ?MODULE_STRING ++ ".erl"
+    end.
+
+process_info_other(Config) when is_list(Config) ->
+    Self = self(),
+    Pid = spawn_link(fun() -> process_info_looper(Self) end),
+    receive after 1 -> ok end,
+    pio_current_location(10000, Pid, 0, 0),
+    pio_current_stacktrace().
+
+pio_current_location(0, _, Pi, Looper) ->
+    io:format("~w call(s) to erlang:process_info/2", [Pi]),
+    io:format("~w call(s) to ~w:process_info_looper/1", [Looper,?MODULE]);
+pio_current_location(N, Pid, Pi, Looper) ->
+    erlang:yield(),
+    {current_location,Where} = process_info(Pid, current_location),
+    case Where of
+	{erlang,process_info,2,[]} ->
+	    pio_current_location(N-1, Pid, Pi+1, Looper);
+	{?MODULE,process_info_looper,1,Loc} when is_list(Loc) ->
+	    pio_current_location(N-1, Pid, Pi, Looper+1)
+    end.
+
+pio_current_stacktrace() ->
+    L = [begin
+	     {current_stacktrace,Stk} = process_info(P, current_stacktrace),
+	     {P,Stk}
+	 end || P <- processes()],
+    [erlang:garbage_collect(P) || {P,_} <- L],
+    erlang:garbage_collect(),
+    [verify_stacktrace(Stk) || {_,Stk} <- L],
+    ok.
+
+verify_stacktrace([{M,F,A,Loc}|T])
+  when is_atom(M),
+       is_atom(F),
+       is_integer(A),
+       is_list(Loc) ->
+    verify_stacktrace(T);
+verify_stacktrace([]) -> ok.
+
+process_info_looper(Parent) ->
+    process_info(Parent, current_location),
+    process_info_looper(Parent).
+
 %% Tests the process_info/1 BIF on another process with messages.
 process_info_other_msg(Config) when is_list(Config) ->
     Self = self(),
diff --git a/erts/emulator/test/trace_local_SUITE.erl b/erts/emulator/test/trace_local_SUITE.erl
index 091e960610..32e2a98e3c 100644
--- a/erts/emulator/test/trace_local_SUITE.erl
+++ b/erts/emulator/test/trace_local_SUITE.erl
@@ -767,8 +767,8 @@ exception_test(Opts, Func0, Args0) ->
 	end,
     
     ?line R1 = exc_slave(ExcOpts, Func, Args),
-    ?line Stack2 = [{?MODULE,exc_top,3},{?MODULE,slave,2}],
-    ?line Stack3 = [{?MODULE,exc,2}|Stack2],
+    ?line Stack2 = [{?MODULE,exc_top,3,[]},{?MODULE,slave,2,[]}],
+    ?line Stack3 = [{?MODULE,exc,2,[]}|Stack2],
     ?line Rs = 
 	case x_exc_top(ExcOpts, Func, Args) of % Emulation
 	    {crash,{Reason,Stack}}=R when is_list(Stack) ->
@@ -789,21 +789,29 @@ exception_test(Opts, Func0, Args0) ->
 	  end,
     ?line expect({nm}).
 
-exception_validate(R1, [R2|Rs]) ->
+exception_validate(R0, Rs0) ->
+    R = clean_location(R0),
+    Rs = [clean_location(E) || E <- Rs0],
+    exception_validate_1(R, Rs).
+
+exception_validate_1(R1, [R2|Rs]) ->
     case [R1|R2] of
 	[R|R] ->
 	    ok;
-	[{crash,{badarg,[{lists,reverse,[L1a,L1b]}|T]}}|
-	 {crash,{badarg,[{lists,reverse,[L2a,L2b]}|T]}}] ->
+	[{crash,{badarg,[{lists,reverse,[L1a,L1b],_}|T]}}|
+	 {crash,{badarg,[{lists,reverse,[L2a,L2b],_}|T]}}] ->
 	    same({crash,{badarg,[{lists,reverse,
-				  [lists:reverse(L1b, L1a),[]]}|T]}},
+				  [lists:reverse(L1b, L1a),[]],[]}|T]}},
 		 {crash,{badarg,[{lists,reverse,
-				  [lists:reverse(L2b, L2a),[]]}|T]}});
+				  [lists:reverse(L2b, L2a),[]],[]}|T]}});
 	_ when is_list(Rs), Rs =/= [] ->
 	    exception_validate(R1, Rs)
     end.
 
-
+clean_location({crash,{Reason,Stk0}}) ->
+    Stk = [{M,F,A,[]} || {M,F,A,_} <- Stk0],
+    {crash,{Reason,Stk}};
+clean_location(Term) -> Term.
 
 %%% Tracee target functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%
@@ -1057,10 +1065,10 @@ x_exc_exception(_Rtt, M, F, _, Arity, CR) ->
 x_exc_stacktrace() ->
     x_exc_stacktrace(erlang:get_stacktrace()).
 %% Truncate stacktrace to below exc/2
-x_exc_stacktrace([{?MODULE,x_exc,4}|_]) -> [];
-x_exc_stacktrace([{?MODULE,x_exc_func,4}|_]) -> [];
-x_exc_stacktrace([{?MODULE,x_exc_body,4}|_]) -> [];
-x_exc_stacktrace([{?MODULE,exc,2}|_]) -> [];
+x_exc_stacktrace([{?MODULE,x_exc,4,_}|_]) -> [];
+x_exc_stacktrace([{?MODULE,x_exc_func,4,_}|_]) -> [];
+x_exc_stacktrace([{?MODULE,x_exc_body,4,_}|_]) -> [];
+x_exc_stacktrace([{?MODULE,exc,2,_}|_]) -> [];
 x_exc_stacktrace([H|T]) ->
     [H|x_exc_stacktrace(T)].