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
  ...

9 files changed, 613 insertions, 580 deletions

diff --git a/lib/debugger/src/Makefile b/lib/debugger/src/Makefile
index 8551fe887d..6dc7d0d783 100644
--- a/lib/debugger/src/Makefile
+++ b/lib/debugger/src/Makefile
@@ -44,6 +44,7 @@ MODULES= \
 	dbg_ieval \
 	dbg_iload \
 	dbg_iserver \
+	dbg_istk \
 	dbg_ui_break \
 	dbg_ui_break_win \
 	dbg_ui_edit \
diff --git a/lib/debugger/src/dbg_debugged.erl b/lib/debugger/src/dbg_debugged.erl
index 3732c40c73..18dcd92ff3 100644
--- a/lib/debugger/src/dbg_debugged.erl
+++ b/lib/debugger/src/dbg_debugged.erl
@@ -76,8 +76,8 @@ msg_loop(Meta, Mref, SaveStacktrace) ->
 	    msg_loop(Meta, Mref, SaveStacktrace);
 
 	%% Meta needs something evaluated within context of real process
-	{sys, Meta, {command, Command, Stacktrace}} ->
-	    Reply = handle_command(Command, Stacktrace),
+	{sys, Meta, {command,Command}} ->
+	    Reply = handle_command(Command),
 	    Meta ! {sys, self(), Reply},
 	    msg_loop(Meta, Mref, SaveStacktrace);
 
@@ -93,11 +93,12 @@ msg_loop(Meta, Mref, SaveStacktrace) ->
 	    end
     end.
 
-handle_command(Command, Stacktrace) ->
-    try reply(Command)
+handle_command(Command) ->
+    try
+	reply(Command)
     catch Class:Reason ->
-	    Stacktrace2 = stacktrace_f(erlang:get_stacktrace()),
-	    {exception, {Class,Reason,Stacktrace2++Stacktrace}}
+	    Stacktrace = stacktrace_f(erlang:get_stacktrace()),
+	    {exception,{Class,Reason,Stacktrace}}
     end.
 
 reply({apply,M,F,As}) ->
@@ -116,5 +117,5 @@ demonitor(Mref) ->
 %% Fix stacktrace - keep all above call to this module.
 %%
 stacktrace_f([]) -> [];
-stacktrace_f([{?MODULE,_,_}|_]) -> [];
+stacktrace_f([{?MODULE,_,_,_}|_]) -> [];
 stacktrace_f([F|S]) -> [F|stacktrace_f(S)].
diff --git a/lib/debugger/src/dbg_icmd.erl b/lib/debugger/src/dbg_icmd.erl
index e9502eaa2b..b230efaa7a 100644
--- a/lib/debugger/src/dbg_icmd.erl
+++ b/lib/debugger/src/dbg_icmd.erl
@@ -273,7 +273,7 @@ handle_int_msg({old_code,Mod}, Status, Bs,
 	    erase([Mod|db]),
 	    put(cache, []);
 	true ->
-	    case dbg_ieval:in_use_p(Mod, M) of
+	    case dbg_istk:in_use_p(Mod, M) of
 		true ->
 		    %% A call to Mod is on the stack (or might be),
 		    %% so we must terminate.
@@ -342,11 +342,11 @@ handle_user_msg({set,stack_trace,Flag}, _Status, _Bs, _Ieval) ->
 handle_user_msg({get,bindings,From,SP}, _Status, Bs, _Ieval) ->
     reply(From, bindings, bindings(Bs, SP));
 handle_user_msg({get,stack_frame,From,{Dir,SP}}, _Status, _Bs,_Ieval) ->
-    reply(From, stack_frame, dbg_ieval:stack_frame(Dir, SP));
+    reply(From, stack_frame, dbg_istk:stack_frame(Dir, SP));
 handle_user_msg({get,messages,From,_}, _Status, _Bs, _Ieval) ->
     reply(From, messages, messages());
-handle_user_msg({get,backtrace,From,N}, _Status, _Bs, _Ieval) ->
-    reply(From, backtrace, dbg_ieval:backtrace(N)).
+handle_user_msg({get,backtrace,From,N}, _Status, _Bs, Ieval) ->
+    reply(From, backtrace, dbg_istk:backtrace(N, Ieval)).
 
 set_stack_trace(true) ->
     set_stack_trace(all);
@@ -366,11 +366,11 @@ reply(From, Tag, Reply) ->
 bindings(Bs, nostack) ->
     Bs;
 bindings(Bs, SP) ->
-    case dbg_ieval:stack_level() of
+    case dbg_istk:stack_level() of
 	Le when SP > Le ->
 	    Bs;
 	_ ->
-	    dbg_ieval:bindings(SP)
+	    dbg_istk:bindings(SP)
     end.
 
 messages() ->
@@ -422,7 +422,7 @@ eval_nonrestricted({From, _Mod, Cmd, _SP}, Bs,
 
 eval_nonrestricted_1({match,_,{var,_,Var},Expr}, Bs, Ieval) ->
     {value,Res,Bs2} = 
-	dbg_ieval:eval_expr(Expr, Bs, Ieval#ieval{last_call=false}),
+	dbg_ieval:eval_expr(Expr, Bs, Ieval#ieval{top=false}),
     Bs3 = case lists:keyfind(Var, 1, Bs) of
 	      {Var,_Value} ->
 		  lists:keyreplace(Var, 1, Bs2, {Var,Res});
@@ -437,7 +437,7 @@ eval_nonrestricted_1({var,_,Var}, Bs, _Ieval) ->
     {Res,Bs};
 eval_nonrestricted_1(Expr, Bs, Ieval) ->
     {value,Res,Bs2} = 
-	dbg_ieval:eval_expr(Expr, Bs, Ieval#ieval{last_call=false}),
+	dbg_ieval:eval_expr(Expr, Bs, Ieval#ieval{top=false}),
     {Res,Bs2}.
 
 mark_running(LineNo, Le) ->
diff --git a/lib/debugger/src/dbg_ieval.erl b/lib/debugger/src/dbg_ieval.erl
index 306323f8ea..df725ed9e5 100644
--- a/lib/debugger/src/dbg_ieval.erl
+++ b/lib/debugger/src/dbg_ieval.erl
@@ -20,8 +20,7 @@
 
 -export([eval/3,exit_info/5]).
 -export([eval_expr/3]).
--export([check_exit_msg/3,exception/4,in_use_p/2]).
--export([stack_level/0, bindings/1, stack_frame/2, backtrace/1]).
+-export([check_exit_msg/3,exception/4]).
 
 -include("dbg_ieval.hrl").
 
@@ -71,13 +70,12 @@ exit_info(Int, AttPid, OrigPid, Reason, ExitInfo) ->
     
     case ExitInfo of
 	{{Mod,Line},Bs,S} ->
-	    Stack = binary_to_term(S),
-	    put(stack, Stack),
-	    Le = stack_level(Stack),
+	    dbg_istk:from_external(S),
+	    Le = dbg_istk:stack_level(),
 	    dbg_icmd:tell_attached({exit_at, {Mod, Line}, Reason, Le}),
 	    exit_loop(OrigPid, Reason, Bs,#ieval{module=Mod,line=Line});
 	{} ->
-	    put(stack, []),
+	    dbg_istk:init(),
 	    dbg_icmd:tell_attached({exit_at, null, Reason, 1}),
 	    exit_loop(OrigPid, Reason, erl_eval:new_bindings(),#ieval{})
     end.
@@ -142,12 +140,12 @@ check_exit_msg({'DOWN',_,_,_,Reason}, Bs,
 	    undefined when Le =:= 1 -> % died outside interpreted code
 		{};
 	    undefined when Le > 1 ->
-		StackBin = term_to_binary(get(stack)),
-		{{Mod, Li}, Bs, StackBin};
+		StackExternal = (dbg_istk:delayed_to_external())(),
+		{{Mod, Li}, Bs, StackExternal};
 
 	    %% Debugged has terminated due to an exception
-	    ExitInfo0 ->
-		ExitInfo0
+	    ExitInfo0 when is_function(ExitInfo0, 0) ->
+		ExitInfo0()
 	end,
     dbg_iserver:cast(get(int), {set_exit_info,self(),ExitInfo}),
 
@@ -170,30 +168,26 @@ check_exit_msg(_Msg, _Bs, _Ieval) ->
 %% and then raise the exception.
 %%--------------------------------------------------------------------
 exception(Class, Reason, Bs, Ieval) ->
-    exception(Class, Reason, fix_stacktrace(1), Bs, Ieval).
-
-exception(Class, Reason, Stacktrace, Bs, #ieval{module=M, line=Line}) ->
-    ExitInfo = {{M,Line}, Bs, term_to_binary(get(stack))},
+    exception(Class, Reason, Bs, Ieval, false).
+
+exception(Class, Reason, Bs, Ieval, false) ->
+    do_exception(Class, Reason,
+		 dbg_istk:delayed_stacktrace(no_args, Ieval),
+		 Bs, Ieval);
+exception(Class, Reason, Bs, Ieval, true) ->
+    do_exception(Class, Reason,
+		 dbg_istk:delayed_stacktrace(include_args, Ieval),
+		 Bs, Ieval).
+
+do_exception(Class, Reason, Stacktrace, Bs, #ieval{module=M, line=Line}) ->
+    StackFun = dbg_istk:delayed_to_external(),
+    ExitInfo = fun() ->
+		       {{M,Line},Bs,StackFun()}
+	       end,
     put(exit_info, ExitInfo),
     put(stacktrace, Stacktrace),
     erlang:Class(Reason).
 
-%%--------------------------------------------------------------------
-%% in_use_p(Mod, Cm) -> boolean()
-%%   Mod = Cm = atom()
-%% Returns true if Mod is found on the stack, otherwise false.
-%%--------------------------------------------------------------------
-in_use_p(Mod, Mod) -> true;
-in_use_p(Mod, _Cm) ->
-    case get(trace_stack) of
-	false -> true;
-	_ -> %  all | no_tail
-	    lists:any(fun({_,{M,_,_,_}}) when M =:= Mod -> true;
-			 (_) -> false
-		      end,
-		      get(stack))
-    end.
-
 %%====================================================================
 %% Internal functions
 %%====================================================================
@@ -225,7 +219,7 @@ meta(Int, Debugged, M, F, As) ->
     put(cache, []),
     put(next_break, Status), % break | running (other values later)
     put(self, Debugged),     % pid() interpreted process
-    put(stack, []),
+    dbg_istk:init(),
     put(stacktrace, []),
     put(trace_stack, dbg_iserver:call(Int, get_stack_trace)),
     put(trace, false),       % bool() Trace on/off
@@ -243,8 +237,7 @@ meta(Int, Debugged, M, F, As) ->
 
 debugged_cmd(Cmd, Bs, Ieval) ->
     Debugged = get(self),
-    Stacktrace = fix_stacktrace(2),
-    Debugged ! {sys, self(), {command,Cmd,Stacktrace}},
+    Debugged ! {sys, self(), {command,Cmd}},
     meta_loop(Debugged, Bs, Ieval).
 
 meta_loop(Debugged, Bs, #ieval{level=Le} = Ieval) ->
@@ -257,12 +250,17 @@ meta_loop(Debugged, Bs, #ieval{level=Le} = Ieval) ->
 	    {value, Val, Bs};
 	{sys, Debugged, {value,Val,Bs2}} ->
 	    {value, Val, Bs2};
-	{sys, Debugged, {exception,{Class,Reason,Stacktrace}}} ->
+	{sys, Debugged, {exception,{Class,Reason,Stk}}} ->
 	    case get(exit_info) of
 
-		%% Error occured outside interpreted code
+		%% Error occurred outside of interpreted code.
 		undefined ->
-		    exception(Class,Reason,Stacktrace,Bs,Ieval);
+		    MakeStk0 = dbg_istk:delayed_stacktrace(),
+		    MakeStk = fun(Depth0) ->
+				      Depth = max(0, Depth0 - length(Stk)),
+				      Stk ++ MakeStk0(Depth)
+			      end,
+		    do_exception(Class, Reason, MakeStk, Bs, Ieval);
 
 		%% Error must have occured within a re-entry to
 		%% interpreted code, simply raise the exception
@@ -275,7 +273,7 @@ meta_loop(Debugged, Bs, #ieval{level=Le} = Ieval) ->
 	    %% Reset process dictionary
 	    %% This is really only necessary if the process left
 	    %% interpreted code at a call level > 1
-	    put(stack, []),
+	    dbg_istk:init(),
 	    put(stacktrace, []),
 	    put(exit_info, undefined),
 	    
@@ -313,177 +311,6 @@ exit_loop(OrigPid, Reason, Bs, Ieval) ->
 	    exit_loop(OrigPid, Reason, Bs, Ieval)
     end.
 
-%%--Stack emulation---------------------------------------------------
-
-%% We keep track of a call stack that is used for
-%%  1) saving stack frames that can be inspected from an Attached
-%%     Process GUI (using dbg_icmd:get(Meta, stack_frame, {Dir, SP})
-%%  2) generate an approximation of regular stacktrace -- sent to
-%%     Debugged when it should raise an exception or evaluate a
-%%     function (since it might possible raise an exception)
-%%
-%% Stack = [Entry]
-%%   Entry = {Le, {MFA, Where, Bs}}
-%%     Le = int()         % current call level
-%%     MFA = {M,F,Args}   % called function (or fun)
-%%         | {Fun,Args}   %
-%%     Where = {M,Li}     % from where (module+line) function is called
-%%     Bs = bindings()    % current variable bindings
-%%
-%% How to push depends on the "Stack Trace" option (value saved in
-%% process dictionary item 'trace_stack').
-%%   all - everything is pushed
-%%   no_tail - tail recursive push
-%%   false - nothing is pushed
-%% Whenever a function returns, the corresponding call frame is popped.
-
-push(MFA, Bs, #ieval{level=Le,module=Cm,line=Li,last_call=Lc}) ->
-    Entry = {Le, {MFA, {Cm,Li}, Bs}},
-    case get(trace_stack) of
-	false -> ignore;
-	no_tail when Lc ->
-	    case get(stack) of
-		[] -> put(stack, [Entry]);
-		[_Entry|Entries] -> put(stack, [Entry|Entries])
-	    end;
-	_ -> % all | no_tail when Lc =:= false
-	    put(stack, [Entry|get(stack)])
-    end.
-
-pop() ->
-    case get(trace_stack) of
-	false -> ignore;
-	_ -> % all � no_tail
-	    case get(stack) of
-		[_Entry|Entries] ->
-		    put(stack, Entries);
-		[] ->
-		    ignore
-	    end
-    end.
-
-pop(Le) ->
-    case get(trace_stack) of
-	false -> ignore;
-	_ -> % all | no_tail
-	    put(stack, pop(Le, get(stack)))
-    end.
-
-pop(Level, [{Le, _}|Stack]) when Level=<Le ->
-    pop(Level, Stack);
-pop(_Level, Stack) ->
-    Stack.
-
-
-%% stack_level() -> Le
-%% stack_level(Stack) -> Le
-%% Top call level
-stack_level() ->
-    stack_level(get(stack)).
-
-stack_level([]) -> 1;
-stack_level([{Le,_}|_]) -> Le.
-
-%% fix_stacktrace(Start) -> Stacktrace
-%%   Start = 1|2
-%%   Stacktrace = [{M,F,Args|Arity} | {Fun,Args}]
-%% Convert internal stack format to imitation of regular stacktrace.
-%% Max three elements, no repeated (recursive) calls to the same
-%% function and convert argument lists to arity for all but topmost
-%% entry (and funs).
-%% 'Start' indicates where at get(stack) to start. This somewhat ugly
-%% solution is because fix_stacktrace has two uses: 1) to imitate
-%% the stacktrace in the case of an exception in the interpreted code,
-%% in which case the current call (top of the stack = first of the list)
-%% should be included, and 2) to send a current stacktrace to Debugged
-%% when evaluation passes into non-interpreted code, in which case
-%% the current call should NOT be included (as it is Debugged which
-%% will make the actual function call).
-fix_stacktrace(Start) ->
-    case fix_stacktrace2(sublist(get(stack), Start, 3)) of
-	[] ->
-	    [];
-	[H|T] ->
-	    [H|args2arity(T)]
-    end.
-
-sublist([], _Start, _Length) ->
-    []; % workaround, lists:sublist([],2,3) fails
-sublist(L, Start, Length) ->
-    lists:sublist(L, Start, Length).
-
-fix_stacktrace2([{_,{{M,F,As1},_,_}}, {_,{{M,F,As2},_,_}}|_])
-  when length(As1) =:= length(As2) ->
-    [{M,F,As1}];
-fix_stacktrace2([{_,{{Fun,As1},_,_}}, {_,{{Fun,As2},_,_}}|_])
-  when length(As1) =:= length(As2) ->
-    [{Fun,As1}];
-fix_stacktrace2([{_,{MFA,_,_}}|Entries]) ->
-    [MFA|fix_stacktrace2(Entries)];
-fix_stacktrace2([]) ->
-    [].
-
-args2arity([{M,F,As}|Entries]) when is_list(As) ->
-    [{M,F,length(As)}|args2arity(Entries)];
-args2arity([Entry|Entries]) ->
-    [Entry|args2arity(Entries)];
-args2arity([]) ->
-    [].
-
-%% bindings(SP) -> Bs
-%%   SP = Le  % stack pointer
-%% Return the bindings for the specified call level
-bindings(SP) ->
-    bindings(SP, get(stack)).
-
-bindings(SP, [{SP,{_MFA,_Wh,Bs}}|_]) ->
-    Bs;
-bindings(SP, [_Entry|Entries]) ->
-    bindings(SP, Entries);
-bindings(_SP, []) ->
-    erl_eval:new_bindings().
-
-%% stack_frame(Dir, SP) -> {Le, Where, Bs} | top | bottom
-%%   Dir = up | down
-%%   Where = {Cm, Li}
-%%     Cm = Module | undefined  % module
-%%     Li = int()  | -1         % line number
-%%     Bs = bindings()
-%% Return stack frame info one step up/down from given stack pointer
-%%  up = to lower call levels
-%%  down = to higher call levels
-stack_frame(up, SP) ->
-    stack_frame(SP, up, get(stack));
-stack_frame(down, SP) ->
-    stack_frame(SP, down, lists:reverse(get(stack))).
-
-stack_frame(SP, up, [{Le, {_MFA,Where,Bs}}|_]) when Le<SP ->
-    {Le, Where, Bs};
-stack_frame(SP, down, [{Le, {_MFA,Where,Bs}}|_]) when Le>SP ->
-    {Le, Where, Bs};
-stack_frame(SP, Dir, [{SP, _}|Stack]) ->
-    case Stack of
-	[{Le, {_MFA,Where,Bs}}|_] ->
-	    {Le, Where, Bs};
-	[] when Dir =:= up ->
-	    top;
-	[] when Dir =:= down ->
-	    bottom
-    end;
-stack_frame(SP, Dir, [_Entry|Stack]) ->
-    stack_frame(SP, Dir, Stack).
-
-%% backtrace(HowMany) -> Backtrace
-%%   HowMany = all | int()
-%%   Backtrace = {Le, MFA}
-%% Return all/the last N called functions, in reversed call order
-backtrace(HowMany) ->
-    Stack = case HowMany of
-		all -> get(stack);
-		N -> lists:sublist(get(stack), N)
-	    end,
-    [{Le, MFA} || {Le,{MFA,_Wh,_Bs}} <- Stack].
-
 %%--Trace function----------------------------------------------------
 
 %%--------------------------------------------------------------------
@@ -558,7 +385,7 @@ format_args1([]) ->
 
 %% Mimic catch behaviour
 catch_value(error, Reason) ->
-    {'EXIT',{Reason,get(stacktrace)}};
+    {'EXIT',{Reason,get_stacktrace()}};
 catch_value(exit, Reason) ->
     {'EXIT',Reason};
 catch_value(throw, Reason) ->
@@ -570,11 +397,13 @@ catch_value(throw, Reason) ->
 %% Top level function of meta evaluator. 
 %% Return message to be replied to the target process.
 %%--------------------------------------------------------------------
-eval_mfa(Debugged, M, F, As, Ieval) ->
+eval_mfa(Debugged, M, F, As, #ieval{level=Le}=Ieval0) ->
     Int = get(int),
     Bs = erl_eval:new_bindings(),
-    try eval_function(M,F,As,Bs,extern,Ieval#ieval{last_call=true}) of
+    Ieval = Ieval0#ieval{level=Le+1,top=true},
+    try do_eval_function(M, F, As, Bs, extern, Ieval) of
 	{value, Val, _Bs} ->
+	    trace(return, {Le,Val}),
 	    {ready, Val}
     catch
 	exit:{Debugged, Reason} ->
@@ -582,76 +411,68 @@ eval_mfa(Debugged, M, F, As, Ieval) ->
 	exit:{Int, Reason} ->
 	    exit(Reason);
 	Class:Reason ->
-	    {exception, {Class, Reason, get(stacktrace)}}
+	    {exception, {Class, Reason, get_stacktrace()}}
+    end.
+
+eval_function(Mod, Name, As, Bs, Called, Ieval0, Lc) ->
+    Tail = Lc andalso get(trace_stack) =:= no_tail,
+    case Tail of
+	false ->
+	    Ieval = dbg_istk:push(Bs, Ieval0, Lc),
+	    {value,Val,_} = do_eval_function(Mod, Name, As, Bs, Called, Ieval),
+	    dbg_istk:pop(),
+	    trace(return, {Ieval#ieval.level,Val}),
+	    {value,Val,Bs};
+	true ->
+	    do_eval_function(Mod, Name, As, Bs, Called, Ieval0)
     end.
 
-eval_function(Mod, Fun, As0, Bs0, _Called, Ieval) when is_function(Fun);
-						       Mod =:= ?MODULE,
-						       Fun =:= eval_fun ->
-    #ieval{level=Le, line=Li, last_call=Lc} = Ieval,
+do_eval_function(Mod, Fun, As0, Bs0, _, Ieval0) when is_function(Fun);
+						    Mod =:= ?MODULE,
+						    Fun =:= eval_fun ->
+    #ieval{level=Le,line=Li,top=Top} = Ieval0,
     case lambda(Fun, As0) of
-	{Cs,Module,Name,As,Bs} ->
-	    push({Module,Name,As}, Bs0, Ieval),
+	{[{clause,Fc,_,_,_}|_]=Cs,Module,Name,As,Bs} ->
+	    Ieval = Ieval0#ieval{module=Module,function=Name,
+				 arguments=As0,line=Fc},
 	    trace(call_fun, {Le,Li,Name,As}),
-	    {value, Val, _Bs} =
-		fnk_clauses(Cs, Module, Name, As, Bs,
-			    Ieval#ieval{level=Le+1}),
-	    pop(),
-	    trace(return, {Le,Val}),
-	    {value, Val, Bs0};
+	    fnk_clauses(Cs, As, Bs, Ieval);
 
-	not_interpreted when Lc -> % We are leaving interpreted code
+	not_interpreted when Top -> % We are leaving interpreted code
 	    trace(call_fun, {Le,Li,Fun,As0}),
 	    {value, {dbg_apply,erlang,apply,[Fun,As0]}, Bs0};
 	not_interpreted ->
-	    push({Fun,As0}, Bs0, Ieval),
 	    trace(call_fun, {Le,Li,Fun,As0}),
-	    {value, Val, _Bs} =
-		debugged_cmd({apply,erlang,apply,[Fun,As0]},Bs0,
-			     Ieval#ieval{level=Le+1}),
-	    pop(),
-	    trace(return, {Le,Val}),
-	    {value, Val, Bs0};
+	    debugged_cmd({apply,erlang,apply,[Fun,As0]}, Bs0, Ieval0);
 
 	{error,Reason} ->
 	    %% It's ok not to push anything in this case, the error
 	    %% reason contains information about the culprit
 	    %% ({badarity,{{Mod,Name},As}})
-	    exception(error, Reason, Bs0, Ieval)
+	    exception(error, Reason, Bs0, Ieval0)
     end;
 
 %% Common Test adaptation
-eval_function(ct_line, line, As, Bs, extern, #ieval{level=Le}=Ieval) ->
+do_eval_function(ct_line, line, As, Bs, extern, #ieval{level=Le}=Ieval) ->
     debugged_cmd({apply,ct_line,line,As}, Bs, Ieval#ieval{level=Le+1}),
     {value, ignore, Bs};
 
-eval_function(Mod, Name, As0, Bs0, Called, Ieval) ->
-    #ieval{level=Le, line=Li, last_call=Lc} = Ieval,
-
-    push({Mod,Name,As0}, Bs0, Ieval),
+do_eval_function(Mod, Name, As0, Bs0, Called, Ieval0) ->
+    #ieval{level=Le,line=Li,top=Top} = Ieval0,
     trace(call, {Called, {Le,Li,Mod,Name,As0}}),
-
+    Ieval = Ieval0#ieval{module=Mod,function=Name,arguments=As0},
     case get_function(Mod, Name, As0, Called) of
-	Cs when is_list(Cs) ->
-	    {value, Val, _Bs} =
-		fnk_clauses(Cs, Mod, Name, As0, erl_eval:new_bindings(),
-			    Ieval#ieval{level=Le+1}),
-	    pop(),
-	    trace(return, {Le,Val}),
-	    {value, Val, Bs0};
+	[{clause,FcLine,_,_,_}|_]=Cs ->
+	    fnk_clauses(Cs, As0, erl_eval:new_bindings(),
+			Ieval#ieval{line=FcLine});
 
-	not_interpreted when Lc -> % We are leaving interpreted code
+	not_interpreted when Top -> % We are leaving interpreted code
 	    {value, {dbg_apply,Mod,Name,As0}, Bs0};
 	not_interpreted ->
-	    {value, Val, _Bs} =
-		debugged_cmd({apply,Mod,Name,As0}, Bs0,
-			     Ieval#ieval{level=Le+1}),
-	    pop(),
-	    trace(return, {Le,Val}),
-	    {value, Val, Bs0};
+	    debugged_cmd({apply,Mod,Name,As0}, Bs0, Ieval);
 
 	undef ->
-	    exception(error, undef, Bs0, Ieval)
+	    exception(error, undef, Bs0, Ieval, true)
     end.
 
 lambda(eval_fun, [Cs,As,Bs,{Mod,Name}=F]) ->
@@ -752,23 +573,21 @@ cached(Key) ->
 
 %% Try to find a matching function clause
 %% #ieval.level is set, the other fields must be set in this function
-fnk_clauses([{clause,Line,Pars,Gs,Body}|Cs], M, F, As, Bs0, Ieval) ->
+fnk_clauses([{clause,Line,Pars,Gs,Body}|Cs], As, Bs0, Ieval) ->
     case head_match(Pars, As, [], Bs0) of
 	{match,Bs1} ->
 	    Bs = add_bindings(Bs1, Bs0),
 	    case guard(Gs, Bs) of
 		true ->
-		    seq(Body, Bs,
-			Ieval#ieval{line=Line,
-				    module=M,function=F,arguments=As});
+		    seq(Body, Bs, Ieval#ieval{line=Line});
 		false ->
-		    fnk_clauses(Cs, M, F, As, Bs0, Ieval)
+		    fnk_clauses(Cs, As, Bs0, Ieval)
 	    end;
 	nomatch ->
-	    fnk_clauses(Cs, M, F, As, Bs0, Ieval)
+	    fnk_clauses(Cs, As, Bs0, Ieval)
     end;
-fnk_clauses([], _M, _F, _As, Bs, Ieval) ->
-    exception(error, function_clause, Bs, Ieval).
+fnk_clauses([], _As, Bs, Ieval) ->
+    exception(error, function_clause, Bs, Ieval, true).
 
 seq([E], Bs0, Ieval) ->
     case dbg_icmd:cmd(E, Bs0, Ieval) of
@@ -782,7 +601,7 @@ seq([E|Es], Bs0, Ieval) ->
 	{skip,Bs} ->
 	    seq(Es, Bs, Ieval);
 	Bs1 ->
-	    {value,_,Bs} = expr(E, Bs1, Ieval#ieval{last_call=false}),
+	    {value,_,Bs} = expr(E, Bs1, Ieval#ieval{top=false}),
 	    seq(Es, Bs, Ieval)
     end;
 seq([], Bs, _) ->
@@ -804,10 +623,9 @@ expr({value,Val}, Bs, _Ieval) -> % Special case straight values
 
 %% List
 expr({cons,Line,H0,T0}, Bs0, Ieval0) ->
-    Ieval = Ieval0#ieval{line=Line},
-    Ieval1 = Ieval#ieval{last_call=false},
-    {value,H,Bs1} = expr(H0,Bs0,Ieval1),
-    {value,T,Bs2} = expr(T0,Bs0,Ieval1),
+    Ieval = Ieval0#ieval{line=Line,top=false},
+    {value,H,Bs1} = expr(H0, Bs0, Ieval),
+    {value,T,Bs2} = expr(T0, Bs0, Ieval),
     {value,[H|T],merge_bindings(Bs2, Bs1, Ieval)};
 
 %% Tuple
@@ -821,12 +639,12 @@ expr({block,Line,Es},Bs,Ieval) ->
 
 %% Catch statement
 expr({'catch',Line,Expr}, Bs0, Ieval) ->
-    try expr(Expr, Bs0, Ieval#ieval{line=Line, last_call=false})
+    try expr(Expr, Bs0, Ieval#ieval{line=Line, top=false})
     catch
 	Class:Reason ->
 	    %% Exception caught, reset exit info
 	    put(exit_info, undefined),
-	    pop(Ieval#ieval.level),
+	    dbg_istk:pop(Ieval#ieval.level),
 	    Value = catch_value(Class, Reason),
 	    trace(return, {Ieval#ieval.level,Value}),
 	    {value, Value, Bs0}
@@ -835,7 +653,7 @@ expr({'catch',Line,Expr}, Bs0, Ieval) ->
 %% Try-catch statement
 expr({'try',Line,Es,CaseCs,CatchCs,[]}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    try seq(Es, Bs0, Ieval#ieval{last_call=false}) of
+    try seq(Es, Bs0, Ieval#ieval{top=false}) of
 	{value,Val,Bs} = Value ->
 	    case CaseCs of
 		[] -> Value;
@@ -848,7 +666,7 @@ expr({'try',Line,Es,CaseCs,CatchCs,[]}, Bs0, Ieval0) ->
     end;
 expr({'try',Line,Es,CaseCs,CatchCs,As}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    try seq(Es, Bs0, Ieval#ieval{last_call=false}) of
+    try seq(Es, Bs0, Ieval#ieval{top=false}) of
 	{value,Val,Bs} = Value ->
 	    case CaseCs of
 		[] -> Value;
@@ -859,13 +677,13 @@ expr({'try',Line,Es,CaseCs,CatchCs,As}, Bs0, Ieval0) ->
 	Class:Reason when CatchCs =/= [] ->
 	    catch_clauses({Class,Reason,[]}, CatchCs, Bs0, Ieval)
     after
-            seq(As, Bs0, Ieval#ieval{last_call=false})
+            seq(As, Bs0, Ieval#ieval{top=false})
     end;
 
 %% Case statement
 expr({'case',Line,E,Cs}, Bs0, Ieval) ->
     {value,Val,Bs} =
-	expr(E, Bs0, Ieval#ieval{line=Line, last_call=false}),
+	expr(E, Bs0, Ieval#ieval{line=Line, top=false}),
     case_clauses(Val, Cs, Bs, case_clause, Ieval#ieval{line=Line});
 
 %% If statement
@@ -874,20 +692,20 @@ expr({'if',Line,Cs}, Bs, Ieval) ->
 
 %% Andalso/orelse
 expr({'andalso',Line,E1,E2}, Bs, Ieval) ->
-    case expr(E1, Bs, Ieval#ieval{line=Line, last_call=false}) of
+    case expr(E1, Bs, Ieval#ieval{line=Line, top=false}) of
 	{value,false,_}=Res ->
 	    Res;
 	{value,true,_} -> 
-	    expr(E2, Bs, Ieval#ieval{line=Line, last_call=false});
+	    expr(E2, Bs, Ieval#ieval{line=Line, top=false});
 	{value,Val,Bs} ->
 	    exception(error, {badarg,Val}, Bs, Ieval)
     end;
 expr({'orelse',Line,E1,E2}, Bs, Ieval) ->
-    case expr(E1, Bs, Ieval#ieval{line=Line, last_call=false}) of
+    case expr(E1, Bs, Ieval#ieval{line=Line, top=false}) of
 	{value,true,_}=Res ->
 	    Res;
 	{value,false,_} ->
-	    expr(E2, Bs, Ieval#ieval{line=Line, last_call=false});
+	    expr(E2, Bs, Ieval#ieval{line=Line, top=false});
 	{value,Val,_} ->
 	    exception(error, {badarg,Val}, Bs, Ieval)
     end;
@@ -895,7 +713,7 @@ expr({'orelse',Line,E1,E2}, Bs, Ieval) ->
 %% Matching expression
 expr({match,Line,Lhs,Rhs0}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    {value,Rhs,Bs1} = expr(Rhs0, Bs0, Ieval#ieval{last_call=false}),
+    {value,Rhs,Bs1} = expr(Rhs0, Bs0, Ieval#ieval{top=false}),
     case match(Lhs, Rhs, Bs1) of
 	{match,Bs} ->
 	    {value,Rhs,Bs};
@@ -951,21 +769,21 @@ expr({make_fun,Line,Name,Cs}, Bs, #ieval{module=Module}=Ieval) ->
     {value,Fun,Bs};
 
 %% Common test adaptation
-expr({call_remote,0,ct_line,line,As0}, Bs0, Ieval0) ->
+expr({call_remote,0,ct_line,line,As0,Lc}, Bs0, Ieval0) ->
     {As,_Bs} = eval_list(As0, Bs0, Ieval0),
-    eval_function(ct_line, line, As, Bs0, extern, Ieval0);
+    eval_function(ct_line, line, As, Bs0, extern, Ieval0, Lc);
 
 %% Local function call
-expr({local_call,Line,F,As0}, Bs0, #ieval{module=M} = Ieval0) ->
+expr({local_call,Line,F,As0,Lc}, Bs0, #ieval{module=M} = Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
     {As,Bs} = eval_list(As0, Bs0, Ieval),
-    eval_function(M, F, As, Bs, local, Ieval);
+    eval_function(M, F, As, Bs, local, Ieval, Lc);
 
 %% Remote function call
-expr({call_remote,Line,M,F,As0}, Bs0, Ieval0) ->
+expr({call_remote,Line,M,F,As0,Lc}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
     {As,Bs} = eval_list(As0, Bs0, Ieval),
-    eval_function(M, F, As, Bs, extern, Ieval);
+    eval_function(M, F, As, Bs, extern, Ieval, Lc);
 
 %% Emulated semantics of some BIFs
 expr({dbg,Line,self,[]}, Bs, #ieval{level=Le}) ->
@@ -975,9 +793,28 @@ expr({dbg,Line,self,[]}, Bs, #ieval{level=Le}) ->
     {value,Self,Bs};
 expr({dbg,Line,get_stacktrace,[]}, Bs, #ieval{level=Le}) ->
     trace(bif, {Le,Line,erlang,get_stacktrace,[]}),
-    Stacktrace = get(stacktrace),
+    Stacktrace = get_stacktrace(),
     trace(return, {Le,Stacktrace}),
     {value,Stacktrace,Bs};
+expr({dbg,Line,raise,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
+    %% Since erlang:get_stacktrace/0 is emulated, we will
+    %% need to emulate erlang:raise/3 too so that we can
+    %% capture the stacktrace.
+    Ieval = Ieval0#ieval{line=Line},
+    {[Class,Reason,Stk0]=As,Bs} = eval_list(As0, Bs0, Ieval),
+    trace(bif, {Le,Line,erlang,raise,As}),
+    try
+	%% Evaluate raise/3 for error checking and
+	%% truncating of the stacktrace to the correct depth.
+	Error = erlang:raise(Class, Reason, Stk0),
+	trace(return, {Le,Error}),
+	{value,Error,Bs}
+    catch
+	_:_ ->
+	    Stk = erlang:get_stacktrace(),	%Possibly truncated.
+	    StkFun = fun(_) -> Stk end,
+	    do_exception(Class, Reason, StkFun, Bs, Ieval)
+    end;
 expr({dbg,Line,throw,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
     {[Term],Bs} = eval_list(As0, Bs0, Ieval),
@@ -988,11 +825,6 @@ expr({dbg,Line,error,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
     {[Term],Bs} = eval_list(As0, Bs0, Ieval),
     trace(bif, {Le,Line,erlang,error,[Term]}),
     exception(error, Term, Bs, Ieval);
-expr({dbg,Line,fault,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
-    Ieval = Ieval0#ieval{line=Line},
-    {[Term],Bs} = eval_list(As0, Bs0, Ieval),
-    trace(bif, {Le,Line,erlang,fault,[Term]}),
-    exception(fault, Term, Bs, Ieval);
 expr({dbg,Line,exit,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
     {[Term],Bs} = eval_list(As0, Bs0, Ieval),
@@ -1001,36 +833,26 @@ expr({dbg,Line,exit,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
 
 %% Call to "safe" BIF, ie a BIF that can be executed in Meta process
 expr({safe_bif,Line,M,F,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
-    Ieval = Ieval0#ieval{line=Line},
-    {As,Bs} = eval_list(As0, Bs0, Ieval),
+    Ieval1 = Ieval0#ieval{line=Line},
+    {As,Bs} = eval_list(As0, Bs0, Ieval1),
     trace(bif, {Le,Line,M,F,As}),
-    push({M,F,As}, Bs0, Ieval),
+    Ieval2 = dbg_istk:push(Bs0, Ieval1, false),
+    Ieval = Ieval2#ieval{module=M,function=F,arguments=As,line=-1},
     {_,Value,_} = Res = safe_bif(M, F, As, Bs, Ieval),
     trace(return, {Le,Value}),
-    pop(),
+    dbg_istk:pop(),
     Res;
 
 %% Call to a BIF that must be evaluated in the correct process
 expr({bif,Line,M,F,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
-    Ieval = Ieval0#ieval{line=Line},
-    {As,Bs} = eval_list(As0, Bs0, Ieval),
+    Ieval1 = Ieval0#ieval{line=Line},
+    {As,Bs} = eval_list(As0, Bs0, Ieval1),
     trace(bif, {Le,Line,M,F,As}),
-    push({M,F,As}, Bs0, Ieval),
-    {_,Value,_} =
-	Res = debugged_cmd({apply,M,F,As}, Bs, Ieval#ieval{level=Le+1}),
+    Ieval2 = dbg_istk:push(Bs0, Ieval1, false),
+    Ieval = Ieval2#ieval{module=M,function=F,arguments=As,line=-1},
+    {_,Value,_} = Res = debugged_cmd({apply,M,F,As}, Bs, Ieval),
     trace(return, {Le,Value}),
-    pop(),
-    Res;
-
-%% Call to a BIF that spawns a new process
-expr({spawn_bif,Line,M,F,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
-    Ieval = Ieval0#ieval{line=Line},
-    {As,Bs} = eval_list(As0, Bs0, Ieval),
-    trace(bif, {Le,Line,M,F,As}),
-    push({M,F,As}, Bs0, Ieval),
-    Res = debugged_cmd({apply,M,F,As}, Bs,Ieval#ieval{level=Le+1}),
-    trace(return, {Le,Res}),
-    pop(),
+    dbg_istk:pop(),
     Res;
 
 %% Call to an operation
@@ -1046,7 +868,7 @@ expr({op,Line,Op,As0}, Bs0, Ieval0) ->
     end;
 
 %% apply/2 (fun)
-expr({apply_fun,Line,Fun0,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
+expr({apply_fun,Line,Fun0,As0,Lc}, Bs0, #ieval{level=Le}=Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
     FunValue = case expr(Fun0, Bs0, Ieval) of
 		   {value,{dbg_apply,Mx,Fx,Asx},Bsx} ->
@@ -1058,31 +880,20 @@ expr({apply_fun,Line,Fun0,As0}, Bs0, #ieval{level=Le}=Ieval0) ->
     case FunValue of
 	{value,Fun,Bs1} when is_function(Fun) ->
 	    {As,Bs} = eval_list(As0, Bs1, Ieval),
-	    eval_function(undefined, Fun, As, Bs, extern, Ieval);
+	    eval_function(undefined, Fun, As, Bs, extern, Ieval, Lc);
 	{value,{M,F},Bs1} when is_atom(M), is_atom(F) ->
 	    {As,Bs} = eval_list(As0, Bs1, Ieval),
-	    eval_function(M, F, As, Bs, extern, Ieval);
+	    eval_function(M, F, As, Bs, extern, Ieval, Lc);
 	{value,BadFun,Bs1} ->
 	    exception(error, {badfun,BadFun}, Bs1, Ieval)
     end;
 
 %% apply/3
-expr({apply,Line,As0}, Bs0, Ieval0) ->
+expr({apply,Line,As0,Lc}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
     {[M,F,As],Bs} = eval_list(As0, Bs0, Ieval),
-    eval_function(M, F, As, Bs, extern, Ieval);
+    eval_function(M, F, As, Bs, extern, Ieval, Lc);
     
-%% Mod:module_info/0,1
-expr({module_info_0,_,Mod}, Bs, _Ieval) ->
-    {value,[{compile,module_info(Mod,compile)},
-	    {attributes,module_info(Mod,attributes)},
-	    {imports,module_info(Mod,imports)},
-	    {exports,module_info(Mod,exports)}],Bs};
-expr({module_info_1,Line,Mod,[As0]}, Bs0, Ieval0) ->
-    Ieval = Ieval0#ieval{line=Line},
-    {value,What,Bs} = expr(As0, Bs0, Ieval),
-    {value,module_info(Mod, What),Bs};
-
 %% Receive statement
 expr({'receive',Line,Cs}, Bs0, #ieval{level=Le}=Ieval) ->
     trace(receivex, {Le,false}),
@@ -1091,7 +902,7 @@ expr({'receive',Line,Cs}, Bs0, #ieval{level=Le}=Ieval) ->
 %% Receive..after statement
 expr({'receive',Line,Cs,To,ToExprs}, Bs0, #ieval{level=Le}=Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    {value,ToVal,ToBs} = expr(To, Bs0, Ieval#ieval{last_call=false}),
+    {value,ToVal,ToBs} = expr(To, Bs0, Ieval#ieval{top=false}),
     trace(receivex, {Le,true}),
     check_timeoutvalue(ToVal, ToBs, To, Ieval),
     {Stamp,_} = statistics(wall_clock),
@@ -1101,7 +912,7 @@ expr({'receive',Line,Cs,To,ToExprs}, Bs0, #ieval{level=Le}=Ieval0) ->
 %% Send (!)
 expr({send,Line,To0,Msg0}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    Ieval1 = Ieval#ieval{last_call=false},
+    Ieval1 = Ieval#ieval{top=false},
     {value,To,Bs1} = expr(To0, Bs0, Ieval1),
     {value,Msg,Bs2} = expr(Msg0, Bs0, Ieval1),
     Bs = merge_bindings(Bs2, Bs1, Ieval),
@@ -1110,10 +921,15 @@ expr({send,Line,To0,Msg0}, Bs0, Ieval0) ->
 %% Binary
 expr({bin,Line,Fs}, Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    eval_bits:expr_grp(Fs, Bs0,
-		       fun (E, B) -> expr(E, B, Ieval) end,
-		       [],
-		       false);
+    try
+	eval_bits:expr_grp(Fs, Bs0,
+			   fun (E, B) -> expr(E, B, Ieval) end,
+			   [],
+			   false)
+    catch
+	Class:Reason ->
+	    exception(Class, Reason, Bs0, Ieval)
+    end;
 
 %% List comprehension
 expr({lc,_Line,E,Qs}, Bs, Ieval) ->
@@ -1138,12 +954,12 @@ eval_lc(E, Qs, Bs, Ieval) ->
 
 eval_lc1(E, [{generate,Line,P,L0}|Qs], Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    {value,L1,Bs1} = expr(L0, Bs0, Ieval#ieval{last_call=false}),
+    {value,L1,Bs1} = expr(L0, Bs0, Ieval#ieval{top=false}),
     CompFun = fun(NewBs) -> eval_lc1(E, Qs, NewBs, Ieval) end,
     eval_generate(L1, P, Bs1, CompFun, Ieval);
 eval_lc1(E, [{b_generate,Line,P,L0}|Qs], Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    {value,Bin,_} = expr(L0, Bs0, Ieval#ieval{last_call=false}),
+    {value,Bin,_} = expr(L0, Bs0, Ieval#ieval{top=false}),
     CompFun = fun(NewBs) -> eval_lc1(E, Qs, NewBs, Ieval) end,
     eval_b_generate(Bin, P, Bs0, CompFun, Ieval);
 eval_lc1(E, [{guard,Q}|Qs], Bs0, Ieval) ->
@@ -1152,13 +968,13 @@ eval_lc1(E, [{guard,Q}|Qs], Bs0, Ieval) ->
 	false -> []
     end;
 eval_lc1(E, [Q|Qs], Bs0, Ieval) ->
-    case expr(Q, Bs0, Ieval#ieval{last_call=false}) of
+    case expr(Q, Bs0, Ieval#ieval{top=false}) of
 	{value,true,Bs} -> eval_lc1(E, Qs, Bs, Ieval);
 	{value,false,_Bs} -> [];
 	{value,V,Bs} -> exception(error, {bad_filter,V}, Bs, Ieval)
     end;
 eval_lc1(E, [], Bs, Ieval) ->
-    {value,V,_} = expr(E, Bs, Ieval#ieval{last_call=false}),
+    {value,V,_} = expr(E, Bs, Ieval#ieval{top=false}),
     [V].
 
 %% eval_bc(Expr,[Qualifier],Bindings,IevalState) ->
@@ -1171,12 +987,12 @@ eval_bc(E, Qs, Bs, Ieval) ->
 
 eval_bc1(E, [{generate,Line,P,L0}|Qs], Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    {value,L1,Bs1} = expr(L0, Bs0, Ieval#ieval{last_call=false}),
+    {value,L1,Bs1} = expr(L0, Bs0, Ieval#ieval{top=false}),
     CompFun = fun(NewBs) -> eval_bc1(E, Qs, NewBs, Ieval) end,
     eval_generate(L1, P, Bs1, CompFun, Ieval);
 eval_bc1(E, [{b_generate,Line,P,L0}|Qs], Bs0, Ieval0) ->
     Ieval = Ieval0#ieval{line=Line},
-    {value,Bin,_} = expr(L0, Bs0, Ieval#ieval{last_call=false}),
+    {value,Bin,_} = expr(L0, Bs0, Ieval#ieval{top=false}),
     CompFun = fun(NewBs) -> eval_bc1(E, Qs, NewBs, Ieval) end,
     eval_b_generate(Bin, P, Bs0, CompFun, Ieval);
 eval_bc1(E, [{guard,Q}|Qs], Bs0, Ieval) ->
@@ -1185,13 +1001,13 @@ eval_bc1(E, [{guard,Q}|Qs], Bs0, Ieval) ->
 	false -> []
     end;
 eval_bc1(E, [Q|Qs], Bs0, Ieval) ->
-    case expr(Q, Bs0, Ieval#ieval{last_call=false}) of
+    case expr(Q, Bs0, Ieval#ieval{top=false}) of
 	{value,true,Bs} -> eval_bc1(E, Qs, Bs, Ieval);
 	{value,false,_Bs} -> [];
 	{value,V,Bs} -> exception(error, {bad_filter,V}, Bs, Ieval)
     end;
 eval_bc1(E, [], Bs, Ieval) ->
-    {value,V,_} = expr(E, Bs, Ieval#ieval{last_call=false}),
+    {value,V,_} = expr(E, Bs, Ieval#ieval{top=false}),
     [V].
 
 eval_generate([V|Rest], P, Bs0, CompFun, Ieval) ->
@@ -1208,7 +1024,7 @@ eval_generate(Term, _P, Bs, _CompFun, Ieval) ->
     exception(error, {bad_generator,Term}, Bs, Ieval).
 
 eval_b_generate(<<_/bitstring>>=Bin, P, Bs0, CompFun, Ieval) ->
-    Mfun = fun(L, R, Bs) -> match1(L, R, Bs, Bs0) end,
+    Mfun = match_fun(Bs0),
     Efun = fun(Exp, Bs) -> expr(Exp, Bs, #ieval{}) end,
     case eval_bits:bin_gen(P, Bin, erl_eval:new_bindings(), Bs0, Mfun, Efun) of
 	{match,Rest,Bs1} ->
@@ -1222,24 +1038,13 @@ eval_b_generate(<<_/bitstring>>=Bin, P, Bs0, CompFun, Ieval) ->
 eval_b_generate(Term, _P, Bs, _CompFun, Ieval) ->
     exception(error, {bad_generator,Term}, Bs, Ieval).
 
-module_info(Mod, module) -> Mod;
-module_info(_Mod, compile) -> [];
-module_info(Mod, attributes) ->
-    {ok, Attr} = dbg_iserver:call(get(int), {lookup, Mod, attributes}),
-    Attr;
-module_info(_Mod, imports) -> [];
-module_info(Mod, exports) ->
-    {ok, Exp} = dbg_iserver:call(get(int), {lookup, Mod, exports}),
-    Exp;
-module_info(_Mod, functions) -> [].
-
 safe_bif(M, F, As, Bs, Ieval) ->
     try apply(M, F, As) of
        	Value ->
 	    {value,Value,Bs}
     catch
 	Class:Reason ->
-	    exception(Class, Reason, Bs, Ieval)
+	    exception(Class, Reason, Bs, Ieval, true)
     end.
 
 eval_send(To, Msg, Bs, Ieval) ->
@@ -1408,12 +1213,12 @@ flush_traces(Debugged) ->
 %% eval_list(ExpressionList, Bindings, Ieval)
 %%  Evaluate a list of expressions "in parallel" at the same level.
 eval_list(Es, Bs, Ieval) ->
-    eval_list(Es, [], Bs, Bs, Ieval).
+    eval_list_1(Es, [], Bs, Bs, Ieval#ieval{top=false}).
 
-eval_list([E|Es], Vs, BsOrig, Bs0, Ieval) ->
-    {value,V,Bs1} = expr(E, BsOrig, Ieval#ieval{last_call=false}),
-    eval_list(Es, [V|Vs], BsOrig, merge_bindings(Bs1,Bs0,Ieval), Ieval);
-eval_list([], Vs, _, Bs, _Ieval) ->
+eval_list_1([E|Es], Vs, BsOrig, Bs0, Ieval) ->
+    {value,V,Bs1} = expr(E, BsOrig, Ieval),
+    eval_list_1(Es, [V|Vs], BsOrig, merge_bindings(Bs1, Bs0, Ieval), Ieval);
+eval_list_1([], Vs, _, Bs, _Ieval) ->
     {lists:reverse(Vs,[]),Bs}.
 
 %% if_clauses(Clauses, Bindings, Ieval)
@@ -1453,7 +1258,7 @@ catch_clauses(Exception, [{clause,_,[P],G,B}|CatchCs], Bs0, Ieval) ->
 		true ->
 		    %% Exception caught, reset exit info
 		    put(exit_info, undefined),
-		    pop(Ieval#ieval.level),
+		    dbg_istk:pop(Ieval#ieval.level),
 		    seq(B, Bs, Ieval);
 		false ->
 		    catch_clauses(Exception, CatchCs, Bs0, Ieval)
@@ -1588,11 +1393,9 @@ match1({cons,_,H,T}, [H1|T1], Bs0, BBs) ->
 match1({tuple,_,Elts}, Tuple, Bs, BBs) 
   when length(Elts) =:= tuple_size(Tuple) ->
     match_tuple(Elts, Tuple, 1, Bs, BBs);
-match1({bin,_,Fs}, B, Bs0, BBs0) when is_bitstring(B) ->
-    Bs1 = lists:sort(Bs0),  %Kludge.
-    BBs = lists:sort(BBs0),
-    try eval_bits:match_bits(Fs, B, Bs1, BBs,
-			     fun(L, R, Bs) -> match1(L, R, Bs, BBs) end,
+match1({bin,_,Fs}, B, Bs0, BBs) when is_bitstring(B) ->
+    try eval_bits:match_bits(Fs, B, Bs0, BBs,
+			     match_fun(BBs),
 			     fun(E, Bs) -> expr(E, Bs, #ieval{}) end,
 			     false)
     catch
@@ -1601,6 +1404,12 @@ match1({bin,_,Fs}, B, Bs0, BBs0) when is_bitstring(B) ->
 match1(_,_,_,_) ->
     throw(nomatch).
 
+match_fun(BBs) ->
+    fun(match, {L,R,Bs}) -> match1(L, R, Bs, BBs);
+       (binding, {Name,Bs}) -> binding(Name, Bs);
+       (add_binding, {Name,Val,Bs}) -> add_binding(Name, Val, Bs)
+    end.
+
 match_tuple([E|Es], Tuple, I, Bs0, BBs) ->
     {match,Bs} = match1(E, element(I, Tuple), Bs0, BBs),
     match_tuple(Es, Tuple, I+1, Bs, BBs);
@@ -1731,3 +1540,19 @@ add_binding(N,Val,[B1|Bs]) ->
     [B1|add_binding(N,Val,Bs)];
 add_binding(N,Val,[]) ->
     [{N,Val}].
+
+%% get_stacktrace() -> Stacktrace
+%%  Return the latest stacktrace for the process.
+get_stacktrace() ->
+    case get(stacktrace) of
+	MakeStk when is_function(MakeStk, 1) ->
+	    %% The stacktrace has not been constructed before.
+	    %% Construct it and remember the result.
+	    Depth = erlang:system_flag(backtrace_depth, 8),
+	    erlang:system_flag(backtrace_depth, Depth),
+	    Stk = MakeStk(Depth),
+	    put(stacktrace, Stk),
+	    Stk;
+	Stk when is_list(Stk) ->
+	    Stk
+    end.
diff --git a/lib/debugger/src/dbg_ieval.hrl b/lib/debugger/src/dbg_ieval.hrl
index a344748f48..ea6189ad02 100644
--- a/lib/debugger/src/dbg_ieval.hrl
+++ b/lib/debugger/src/dbg_ieval.hrl
@@ -21,6 +21,8 @@
 		module,           % MFA which called the currently
 		function,         %  interpreted function
 		arguments,        %
-		last_call = false % True if current expression is
-	       }).                % the VERY last to be evaluated
-                                  % (ie at all, not only in a clause)
+
+		%% True if the current expression is at the top level
+		%% (i.e. the next call will leave interpreted code).
+		top = false
+	       }).
diff --git a/lib/debugger/src/dbg_iload.erl b/lib/debugger/src/dbg_iload.erl
index db5a17ad2e..ce5631e45f 100644
--- a/lib/debugger/src/dbg_iload.erl
+++ b/lib/debugger/src/dbg_iload.erl
@@ -62,22 +62,23 @@ load_mod1(Mod, File, Binary, Db) ->
 store_module(Mod, File, Binary, Db) ->
     {interpreter_module, Exp, Abst, Src, MD5} = binary_to_term(Binary),
     Forms = case abstr(Abst) of
-		{abstract_v1,Forms0} -> Forms0;
-		{abstract_v2,Forms0} -> Forms0;
+		{abstract_v1,_} ->
+		    exit({Mod,too_old_beam_file});
+		{abstract_v2,_} ->
+		    exit({Mod,too_old_beam_file});
 		{raw_abstract_v1,Code0} ->
                     Code = interpret_file_attribute(Code0),
 		    {_,_,Forms0,_} = sys_pre_expand:module(Code, []),
 		    Forms0
 	    end,
     dbg_idb:insert(Db, mod_file, File),
-    dbg_idb:insert(Db, exports, Exp),
     dbg_idb:insert(Db, defs, []),
 
     put(vcount, 0),
     put(fun_count, 0),
     put(funs, []),
     put(mod_md5, MD5),
-    Attr = store_forms(Forms, Mod, Db, Exp, []),
+    store_forms(Forms, Mod, Db, Exp),
     erase(mod_md5),
     erase(current_function),
     %% store_funs(Db, Mod),
@@ -85,11 +86,10 @@ store_module(Mod, File, Binary, Db) ->
     erase(funs),
     erase(fun_count),
     
-    dbg_idb:insert(Db, attributes, Attr),
     NewBinary = store_mod_line_no(Mod, Db, binary_to_list(Src)),
     dbg_idb:insert(Db, mod_bin, NewBinary),
-    dbg_idb:insert(Db, mod_raw, <<Src/binary,0:8>>), %% Add eos
-    dbg_idb:insert(Db, module, Mod).
+    dbg_idb:insert(Db, mod_raw, <<Src/binary,0:8>>). %% Add eos
+
 %% Adjust line numbers using the file/2 attribute. 
 %% Also take the absolute value of line numbers.
 %% This simple fix will make the marker point at the correct line
@@ -111,27 +111,19 @@ abstr(Term) -> Term.
 %     store_funs_1(Fs, Db, Mod);
 % store_funs_1([], _, _) -> ok.
 
-store_forms([{function,_,module_info,0,_}|Fs], Mod, Db, Exp, Attr) ->
-    Cs = [{clause,0,[],[], [{module_info_0,0,Mod}]}],
-    dbg_idb:insert(Db, {Mod,module_info,0,true}, Cs),
-    store_forms(Fs, Mod, Db, Exp, Attr);
-store_forms([{function,_,module_info,1,_}|Fs], Mod, Db, Exp, Attr) ->
-    Cs = [{clause,0,[{var,0,'What'}],[], [{module_info_1,0,Mod,[{var,0,'What'}]}]}],
-    dbg_idb:insert(Db, {Mod,module_info,1,true}, Cs),
-    store_forms(Fs, Mod, Db, Exp, Attr);
-store_forms([{function,_,Name,Arity,Cs0}|Fs], Mod, Db, Exp, Attr) ->
+store_forms([{function,_,Name,Arity,Cs0}|Fs], Mod, Db, Exp) ->
     FA = {Name,Arity},
     put(current_function, FA),
     Cs = clauses(Cs0),
     Exported = lists:member(FA, Exp),
     dbg_idb:insert(Db, {Mod,Name,Arity,Exported}, Cs),
-    store_forms(Fs, Mod, Db, Exp, Attr);
-store_forms([{attribute,_,Name,Val}|Fs], Mod, Db, Exp, Attr) ->
-    store_forms(Fs, Mod, Db, Exp, [{Name,Val}|Attr]);
-store_forms([F|_], _Mod, _Db, _Exp, _Attr) ->
+    store_forms(Fs, Mod, Db, Exp);
+store_forms([{attribute,_,_Name,_Val}|Fs], Mod, Db, Exp) ->
+    store_forms(Fs, Mod, Db, Exp);
+store_forms([F|_], _Mod, _Db, _Exp) ->
     exit({unknown_form,F});
-store_forms([], _, _, _, Attr) ->
-    lists:reverse(Attr).
+store_forms([], _, _, _) ->
+    ok.
 
 store_mod_line_no(Mod, Db, Contents) ->
     store_mod_line_no(Mod, Db, Contents, 1, 0, []).
@@ -164,14 +156,14 @@ get_nl([],Pos,Head) -> {lists:reverse(Head),[],Pos}.
 %%% to interpret.
 
 clauses([C0|Cs]) ->
-    C1 = clause(C0),
+    C1 = clause(C0, true),
     [C1|clauses(Cs)];
 clauses([]) -> [].
 
-clause({clause,Line,H0,G0,B0}) ->
+clause({clause,Line,H0,G0,B0}, Lc) ->
     H1 = head(H0),
     G1 = guard(G0),
-    B1 = exprs(B0),
+    B1 = exprs(B0, Lc),
     {clause,Line,H1,G1,B1}.
 
 head(Ps) -> patterns(Ps).
@@ -219,7 +211,7 @@ pattern({bin,Line,Grp}) ->
     {bin,Line,Grp1};
 pattern({bin_element,Line,Expr,Size,Type}) ->
     Expr1 = pattern(Expr),
-    Size1 = expr(Size),
+    Size1 = expr(Size, false),
     {bin_element,Line,Expr1,Size1,Type}.
 
 %%  These patterns are processed "in parallel" for purposes of variable
@@ -235,8 +227,6 @@ guard([G0|Gs]) ->
     [G1|guard(Gs)];
 guard([]) -> [].
 
-and_guard([{atom,_,true}|Gs]) ->
-    and_guard(Gs);
 and_guard([G0|Gs]) ->
     G1 = guard_test(G0),
     [G1|and_guard(Gs)];
@@ -244,12 +234,7 @@ and_guard([]) -> [].
 
 guard_test({call,Line,{remote,_,{atom,_,erlang},{atom,_,F}},As0}) ->
     As = gexpr_list(As0),
-    case map_guard_bif(F, length(As0)) of
-	{ok,Name} ->
-	    {safe_bif,Line,erlang,Name,As};
-	error ->
-	    {safe_bif,Line,erlang,F,As}
-    end;
+    {safe_bif,Line,erlang,F,As};
 guard_test({op,Line,Op,L0}) ->
     true = erl_internal:arith_op(Op, 1) orelse %Assertion.
 	erl_internal:bool_op(Op, 1),
@@ -266,25 +251,18 @@ guard_test({op,Line,Op,L0,R0}) ->
     L1 = gexpr(L0),
     R1 = gexpr(R0),				%They see the same variables
     {safe_bif,Line,erlang,Op,[L1,R1]};
-guard_test({integer,_,_}=I) -> I;
-guard_test({char,_,_}=C) -> C;
-guard_test({float,_,_}=F) -> F;
-guard_test({atom,_,_}=A) -> A;
-guard_test({nil,_}=N) -> N;
-guard_test({var,_,_}=V) ->V.    % Boolean var
-
-map_guard_bif(integer, 1) -> {ok,is_integer};
-map_guard_bif(float, 1) -> {ok,is_float};
-map_guard_bif(number, 1) -> {ok,is_number};
-map_guard_bif(atom, 1) -> {ok,is_atom};
-map_guard_bif(list, 1) -> {ok,is_list};
-map_guard_bif(tuple, 1) -> {ok,is_tuple};
-map_guard_bif(pid, 1) -> {ok,is_pid};
-map_guard_bif(reference, 1) -> {ok,is_reference};
-map_guard_bif(port, 1) -> {ok,is_port};
-map_guard_bif(binary, 1) -> {ok,is_binary};
-map_guard_bif(function, 1) -> {ok,is_function};
-map_guard_bif(_, _) -> error.
+guard_test({var,_,_}=V) ->V;    % Boolean var
+guard_test({atom,Line,true}) -> {value,Line,true};
+%% All other constants at this level means false.
+guard_test({atom,Line,_}) -> {value,Line,false};
+guard_test({integer,Line,_}) -> {value,Line,false};
+guard_test({char,Line,_}) -> {value,Line,false};
+guard_test({float,Line,_}) -> {value,Line,false};
+guard_test({string,Line,_}) -> {value,Line,false};
+guard_test({nil,Line}) -> {value,Line,false};
+guard_test({cons,Line,_,_}) -> {value,Line,false};
+guard_test({tuple,Line,_}) -> {value,Line,false};
+guard_test({bin,Line,_}) ->  {value,Line,false}.
 
 gexpr({var,Line,V}) -> {var,Line,V};
 gexpr({integer,Line,I}) -> {value,Line,I};
@@ -341,186 +319,179 @@ gexpr_list([]) -> [].
 %%  These expressions are processed "sequentially" for purposes of variable
 %%  definition etc.
 
-exprs([E0|Es]) ->
-    E1 = expr(E0),
-    [E1|exprs(Es)];
-exprs([]) -> [].
-
-expr({var,Line,V}) -> {var,Line,V};
-expr({integer,Line,I}) -> {value,Line,I};
-expr({char,Line,I}) -> {value,Line,I};
-expr({float,Line,F}) -> {value,Line,F};
-expr({atom,Line,A}) -> {value,Line,A};
-expr({string,Line,S}) -> {value,Line,S};
-expr({nil,Line}) -> {value,Line,[]};
-expr({cons,Line,H0,T0}) ->
-    case {expr(H0),expr(T0)} of
+exprs([E], Lc) ->
+    [expr(E, Lc)];
+exprs([E0|Es], Lc) ->
+    E1 = expr(E0, false),
+    [E1|exprs(Es, Lc)];
+exprs([], _Lc) -> [].
+
+expr({var,Line,V}, _Lc) -> {var,Line,V};
+expr({integer,Line,I}, _Lc) -> {value,Line,I};
+expr({char,Line,I}, _Lc) -> {value,Line,I};
+expr({float,Line,F}, _Lc) -> {value,Line,F};
+expr({atom,Line,A}, _Lc) -> {value,Line,A};
+expr({string,Line,S}, _Lc) -> {value,Line,S};
+expr({nil,Line}, _Lc) -> {value,Line,[]};
+expr({cons,Line,H0,T0}, _Lc) ->
+    case {expr(H0, false),expr(T0, false)} of
 	{{value,Line,H1},{value,Line,T1}} -> {value,Line,[H1|T1]};
 	{H1,T1} -> {cons,Line,H1,T1}
     end;
-expr({tuple,Line,Es0}) ->
+expr({tuple,Line,Es0}, _Lc) ->
     Es1 = expr_list(Es0),
     {tuple,Line,Es1};
-expr({block,Line,Es0}) ->
+expr({block,Line,Es0}, Lc) ->
     %% Unfold block into a sequence.
-    Es1 = exprs(Es0),
+    Es1 = exprs(Es0, Lc),
     {block,Line,Es1};
-expr({'if',Line,Cs0}) ->
-    Cs1 = icr_clauses(Cs0),
+expr({'if',Line,Cs0}, Lc) ->
+    Cs1 = icr_clauses(Cs0, Lc),
     {'if',Line,Cs1};
-expr({'case',Line,E0,Cs0}) ->
-    E1 = expr(E0),
-    Cs1 = icr_clauses(Cs0),
+expr({'case',Line,E0,Cs0}, Lc) ->
+    E1 = expr(E0, false),
+    Cs1 = icr_clauses(Cs0, Lc),
     {'case',Line,E1,Cs1};
-expr({'receive',Line,Cs0}) ->
-    Cs1 = icr_clauses(Cs0),
+expr({'receive',Line,Cs0}, Lc) ->
+    Cs1 = icr_clauses(Cs0, Lc),
     {'receive',Line,Cs1};
-expr({'receive',Line,Cs0,To0,ToEs0}) ->
-    To1 = expr(To0),
-    ToEs1 = exprs(ToEs0),
-    Cs1 = icr_clauses(Cs0),
+expr({'receive',Line,Cs0,To0,ToEs0}, Lc) ->
+    To1 = expr(To0, false),
+    ToEs1 = exprs(ToEs0, Lc),
+    Cs1 = icr_clauses(Cs0, Lc),
     {'receive',Line,Cs1,To1,ToEs1};
-expr({'fun',Line,{clauses,Cs0},{_,_,Name}}) when is_atom(Name) ->
+expr({'fun',Line,{clauses,Cs0},{_,_,Name}}, _Lc) when is_atom(Name) ->
     %% New R10B-2 format (abstract_v2).
     Cs = fun_clauses(Cs0),
     {make_fun,Line,Name,Cs};
-expr({'fun',Line,{clauses,Cs0},{_,_,_,_,Name}}) when is_atom(Name) ->
-    %% New R8 format (abstract_v2).
-    Cs = fun_clauses(Cs0),
-    {make_fun,Line,Name,Cs};
-expr({'fun',Line,{function,F,A},{_Index,_OldUniq,Name}}) ->
+expr({'fun',Line,{function,F,A},{_Index,_OldUniq,Name}}, _Lc) ->
     %% New R8 format (abstract_v2).
     As = new_vars(A, Line),
-    Cs = [{clause,Line,As,[],[{local_call,Line,F,As}]}],
+    Cs = [{clause,Line,As,[],[{local_call,Line,F,As,true}]}],
     {make_fun,Line,Name,Cs};
-expr({'fun',_,{clauses,_},{_OldUniq,_Hvss,_Free}}) ->
-    %% Old format (abstract_v1).
-    exit({?MODULE,old_funs});
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,self}},[]}) ->
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,self}},[]}, _Lc) ->
     {dbg,Line,self,[]};
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,get_stacktrace}},[]}) ->
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,get_stacktrace}},[]}, _Lc) ->
     {dbg,Line,get_stacktrace,[]};
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,throw}},[_]=As}) ->
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,throw}},[_]=As}, _Lc) ->
     {dbg,Line,throw,expr_list(As)};
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,error}},[_]=As}) ->
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,error}},[_]=As}, _Lc) ->
     {dbg,Line,error,expr_list(As)};
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,fault}},[_]=As}) ->
-    {dbg,Line,fault,expr_list(As)};
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,exit}},[_]=As}) ->
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,exit}},[_]=As}, _Lc) ->
     {dbg,Line,exit,expr_list(As)};
-expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,apply}},[_,_,_]=As0}) ->
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,raise}},[_,_,_]=As}, _Lc) ->
+    {dbg,Line,raise,expr_list(As)};
+expr({call,Line,{remote,_,{atom,_,erlang},{atom,_,apply}},[_,_,_]=As0}, Lc) ->
     As = expr_list(As0),
-    {apply,Line,As};
-expr({call,Line,{remote,_,{atom,_,Mod},{atom,_,Func}},As0}) ->
+    {apply,Line,As,Lc};
+expr({call,Line,{remote,_,{atom,_,Mod},{atom,_,Func}},As0}, Lc) ->
     As = expr_list(As0),
     case erlang:is_builtin(Mod, Func, length(As)) of
 	false ->
-	    {call_remote,Line,Mod,Func,As};
+	    {call_remote,Line,Mod,Func,As,Lc};
 	true ->
-	    case bif_type(Mod, Func) of
+	    case bif_type(Mod, Func, length(As0)) of
 		safe -> {safe_bif,Line,Mod,Func,As};
-		spawn -> {spawn_bif,Line,Mod,Func,As};
 		unsafe ->{bif,Line,Mod,Func,As}
 	    end
     end;
-expr({call,Line,{remote,_,Mod0,Func0},As0}) ->
+expr({call,Line,{remote,_,Mod0,Func0},As0}, Lc) ->
     %% New R8 format (abstract_v2).
-    Mod = expr(Mod0),
-    Func = expr(Func0),
+    Mod = expr(Mod0, false),
+    Func = expr(Func0, false),
     As = consify(expr_list(As0)),
-    {apply,Line,[Mod,Func,As]};
-expr({call,Line,{atom,_,Func},As0}) ->
+    {apply,Line,[Mod,Func,As],Lc};
+expr({call,Line,{atom,_,Func},As0}, Lc) ->
     As = expr_list(As0),
-    {local_call,Line,Func,As};
-expr({call,Line,Fun0,As0}) ->
-    Fun = expr(Fun0),
+    {local_call,Line,Func,As,Lc};
+expr({call,Line,Fun0,As0}, Lc) ->
+    Fun = expr(Fun0, false),
     As = expr_list(As0),
-    {apply_fun,Line,Fun,As};
-expr({'catch',Line,E0}) ->
+    {apply_fun,Line,Fun,As,Lc};
+expr({'catch',Line,E0}, _Lc) ->
     %% No new variables added.
-    E1 = expr(E0),
+    E1 = expr(E0, false),
     {'catch',Line,E1};
-expr({'try',Line,Es0,CaseCs0,CatchCs0,As0}) ->
+expr({'try',Line,Es0,CaseCs0,CatchCs0,As0}, Lc) ->
     %% No new variables added.
     Es = expr_list(Es0),
-    CaseCs = icr_clauses(CaseCs0),
-    CatchCs = icr_clauses(CatchCs0),
+    CaseCs = icr_clauses(CaseCs0, Lc),
+    CatchCs = icr_clauses(CatchCs0, Lc),
     As = expr_list(As0),
     {'try',Line,Es,CaseCs,CatchCs,As};
-expr({'query', Line, E0}) ->
-    E = expr(E0),
-    {'query', Line, E};
-expr({lc,Line,E0,Gs0}) ->			%R8.
+expr({lc,Line,E0,Gs0}, _Lc) ->			%R8.
     Gs = lists:map(fun ({generate,L,P0,Qs}) ->
-			   {generate,L,expr(P0),expr(Qs)};
+			   {generate,L,expr(P0, false),expr(Qs, false)};
 		       ({b_generate,L,P0,Qs}) -> %R12.
-			   {b_generate,L,expr(P0),expr(Qs)};
+			   {b_generate,L,expr(P0, false),expr(Qs, false)};
 		       (Expr) ->
-			   case is_guard_test(Expr) of
-			       true -> {guard,[[guard_test(Expr)]]};
-			       false -> expr(Expr)
+			   case is_guard(Expr) of
+			       true -> {guard,guard([[Expr]])};
+			       false -> expr(Expr, false)
 			   end
 		   end, Gs0),
-    {lc,Line,expr(E0),Gs};
-expr({bc,Line,E0,Gs0}) ->			%R12.
+    {lc,Line,expr(E0, false),Gs};
+expr({bc,Line,E0,Gs0}, _Lc) ->			%R12.
     Gs = lists:map(fun ({generate,L,P0,Qs}) ->
-			   {generate,L,expr(P0),expr(Qs)};
+			   {generate,L,expr(P0, false),expr(Qs, false)};
 		       ({b_generate,L,P0,Qs}) -> %R12.
-			   {b_generate,L,expr(P0),expr(Qs)};
+			   {b_generate,L,expr(P0, false),expr(Qs, false)};
 		       (Expr) ->
-			   case is_guard_test(Expr) of
-			       true -> {guard,[[guard_test(Expr)]]};
-			       false -> expr(Expr)
+			   case is_guard(Expr) of
+			       true -> {guard,guard([[Expr]])};
+			       false -> expr(Expr, false)
 			   end
 		   end, Gs0),
-    {bc,Line,expr(E0),Gs};
-expr({match,Line,P0,E0}) ->
-    E1 = expr(E0),
+    {bc,Line,expr(E0, false),Gs};
+expr({match,Line,P0,E0}, _Lc) ->
+    E1 = expr(E0, false),
     P1 = pattern(P0),
     {match,Line,P1,E1};
-expr({op,Line,Op,A0}) ->
-    A1 = expr(A0),
+expr({op,Line,Op,A0}, _Lc) ->
+    A1 = expr(A0, false),
     {op,Line,Op,[A1]};
-expr({op,Line,'++',L0,R0}) ->
-    L1 = expr(L0),
-    R1 = expr(R0),				%They see the same variables
+expr({op,Line,'++',L0,R0}, _Lc) ->
+    L1 = expr(L0, false),
+    R1 = expr(R0, false),		  %They see the same variables
     {op,Line,append,[L1,R1]};
-expr({op,Line,'--',L0,R0}) ->
-    L1 = expr(L0),
-    R1 = expr(R0),				%They see the same variables
+expr({op,Line,'--',L0,R0}, _Lc) ->
+    L1 = expr(L0, false),
+    R1 = expr(R0, false),		  %They see the same variables
     {op,Line,subtract,[L1,R1]};
-expr({op,Line,'!',L0,R0}) ->
-    L1 = expr(L0),
-    R1 = expr(R0),				%They see the same variables
+expr({op,Line,'!',L0,R0}, _Lc) ->
+    L1 = expr(L0, false),
+    R1 = expr(R0, false),		  %They see the same variables
     {send,Line,L1,R1};
-expr({op,Line,Op,L0,R0}) when Op =:= 'andalso'; Op =:= 'orelse' ->
-    L1 = expr(L0),
-    R1 = expr(R0),				%They see the same variables
+expr({op,Line,Op,L0,R0}, _Lc) when Op =:= 'andalso'; Op =:= 'orelse' ->
+    L1 = expr(L0, false),
+    R1 = expr(R0, false),		  %They see the same variables
     {Op,Line,L1,R1};
-expr({op,Line,Op,L0,R0}) ->
-    L1 = expr(L0),
-    R1 = expr(R0),				%They see the same variables
+expr({op,Line,Op,L0,R0}, _Lc) ->
+    L1 = expr(L0, false),
+    R1 = expr(R0, false),		  %They see the same variables
     {op,Line,Op,[L1,R1]};
-expr({bin,Line,Grp}) ->
+expr({bin,Line,Grp}, _Lc) ->
     Grp1 = expr_list(Grp),
     {bin,Line,Grp1};
-expr({bin_element,Line,Expr,Size,Type}) ->
-    Expr1 = expr(Expr),
-    Size1 = expr(Size),
+expr({bin_element,Line,Expr,Size,Type}, _Lc) ->
+    Expr1 = expr(Expr, false),
+    Size1 = expr(Size, false),
     {bin_element,Line,Expr1,Size1,Type};
-expr(Other) ->
+expr(Other, _Lc) ->
     exit({?MODULE,{unknown_expr,Other}}).
 
-%% is_guard_test(Expression) -> true | false.
-%%  Test if a general expression is a guard test.  Cannot use erl_lint
-%%  here as sys_pre_expand has transformed source.
+%% is_guard(Expression) -> true | false.
+%%  Test if a general expression is a guard test or guard BIF.
+%%  Cannot use erl_lint here as sys_pre_expand has transformed source.
 
-is_guard_test({op,_,Op,L,R}) ->
+is_guard({op,_,Op,L,R}) ->
     erl_internal:comp_op(Op, 2) andalso is_gexpr_list([L,R]);
-is_guard_test({call,_,{remote,_,{atom,_,erlang},{atom,_,Test}},As}) ->
-    erl_internal:type_test(Test, length(As)) andalso is_gexpr_list(As);
-is_guard_test({atom,_,true}) -> true;
-is_guard_test(_) -> false.
+is_guard({call,_,{remote,_,{atom,_,erlang},{atom,_,Test}},As}) ->
+    Arity = length(As),
+    (erl_internal:guard_bif(Test, Arity) orelse
+     erl_internal:old_type_test(Test, Arity)) andalso is_gexpr_list(As);
+is_guard({atom,_,true}) -> true;
+is_guard(_) -> false.
 
 is_gexpr({var,_,_}) -> true;
 is_gexpr({atom,_,_}) -> true;
@@ -555,17 +526,17 @@ consify([]) -> {value,0,[]}.
 %%  definition etc.
 
 expr_list([E0|Es]) ->
-    E1 = expr(E0),
+    E1 = expr(E0, false),
     [E1|expr_list(Es)];
 expr_list([]) -> [].
 
-icr_clauses([C0|Cs]) ->
-    C1 = clause(C0),
-    [C1|icr_clauses(Cs)];
-icr_clauses([]) -> [].
+icr_clauses([C0|Cs], Lc) ->
+    C1 = clause(C0, Lc),
+    [C1|icr_clauses(Cs, Lc)];
+icr_clauses([], _) -> [].
 
 fun_clauses([{clause,L,H,G,B}|Cs]) ->
-    [{clause,L,head(H),guard(G),exprs(B)}|fun_clauses(Cs)];
+    [{clause,L,head(H),guard(G),exprs(B, true)}|fun_clauses(Cs)];
 fun_clauses([]) -> [].
 
 %% new_var_name() -> VarName.
@@ -585,24 +556,21 @@ new_vars(N, L, Vs) when N > 0 ->
     new_vars(N-1, L, [V|Vs]);
 new_vars(0, _, Vs) -> Vs.
 
-bif_type(erlang, Name) -> bif_type(Name);
-bif_type(_, _) -> unsafe.
+bif_type(erlang, Name, Arity) ->
+    case erl_internal:guard_bif(Name, Arity) of
+	true ->
+	    %% Guard BIFs are safe (except for self/0, but it is
+	    %% handled with a special instruction anyway).
+	    safe;
+	false ->
+	    bif_type(Name)
+    end;
+bif_type(_, _, _) -> unsafe.
 
 bif_type(register)           -> safe;
 bif_type(unregister)         -> safe;
 bif_type(whereis)            -> safe;
 bif_type(registered)         -> safe;
-bif_type(abs)                -> safe;
-bif_type(float)              -> safe;
-bif_type(trunc)              -> safe;
-bif_type(round)              -> safe;
-bif_type(math)               -> safe;
-bif_type(node)               -> safe;
-bif_type(length)             -> safe;
-bif_type(hd)                 -> safe;
-bif_type(tl)                 -> safe;
-bif_type(size)               -> safe;
-bif_type(element)            -> safe;
 bif_type(setelement)         -> safe;
 bif_type(atom_to_list)       -> safe;
 bif_type(list_to_atom)       -> safe;
@@ -627,21 +595,14 @@ bif_type(list_to_pid)        -> safe;
 bif_type(module_loaded)      -> safe;
 bif_type(binary_to_term)     -> safe;
 bif_type(term_to_binary)     -> safe;
-bif_type(alive)              -> safe;
-bif_type(notalive)           -> safe;
 bif_type(nodes)              -> safe;
 bif_type(is_alive)           -> safe;
 bif_type(disconnect_node)    -> safe;
 bif_type(binary_to_list)     -> safe;
 bif_type(list_to_binary)     -> safe;
 bif_type(split_binary)       -> safe;
-bif_type(term_to_atom)       -> safe;
 bif_type(hash)               -> safe;
 bif_type(pre_loaded)         -> safe;
-bif_type(info)               -> safe;
 bif_type(set_cookie)         -> safe;
 bif_type(get_cookie)         -> safe;
-bif_type(spawn)              -> spawn;
-bif_type(spawn_link)         -> spawn;
-bif_type(spawn_opt)          -> spawn;
 bif_type(_)                  -> unsafe.
diff --git a/lib/debugger/src/dbg_iserver.erl b/lib/debugger/src/dbg_iserver.erl
index 212bc2b8ab..1bb73a43b9 100644
--- a/lib/debugger/src/dbg_iserver.erl
+++ b/lib/debugger/src/dbg_iserver.erl
@@ -97,13 +97,10 @@ ensure_started() ->
 %%
 %% Key                        Value
 %% ---                        -----
-%% attributes                 Attr
-%% exports                    Exp
 %% defs                       []
 %% mod_bin                    Binary
 %% mod_raw                    Raw Binary
 %% mod_file                   File
-%% module                     Mod
 %% {Mod,Name,Arity,Exported}  Cs
 %% {'fun',Mod,Index,Uniq}     {Name,Arity,Cs}
 %% Line                       {Pos,PosNL}
@@ -117,7 +114,7 @@ init([]) ->
     process_flag(trap_exit, true),
     global:register_name(?MODULE, self()),
     Db = ets:new(?MODULE, [ordered_set, protected]),
-    {ok, #state{db=Db, auto=false, stack=all}}.
+    {ok, #state{db=Db, auto=false, stack=no_tail}}.
 
 %% Attaching to a process
 handle_call({attached, AttPid, Pid}, _From, State) ->
diff --git a/lib/debugger/src/dbg_istk.erl b/lib/debugger/src/dbg_istk.erl
new file mode 100644
index 0000000000..c6922a80e4
--- /dev/null
+++ b/lib/debugger/src/dbg_istk.erl
@@ -0,0 +1,245 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2011. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+-module(dbg_istk).
+-export([init/0,delayed_to_external/0,from_external/1,
+	 push/3,pop/0,pop/1,stack_level/0,
+	 delayed_stacktrace/0,delayed_stacktrace/2,
+	 bindings/1,stack_frame/2,backtrace/2,
+	 in_use_p/2]).
+
+-include("dbg_ieval.hrl").
+
+-define(STACK, ?MODULE).
+
+-record(e,
+	{level,					%Level
+	 mfa,					%{Mod,Func,Args|Arity}|{Fun,Args}
+	 line,					%Line called from
+	 bindings,
+	 lc					%Last call (true|false)
+	 }).
+
+init() ->
+    init([]).
+
+delayed_to_external() ->
+    Stack = get(?STACK),
+    fun() -> {stack,term_to_binary(Stack)} end.
+
+from_external({stack,Stk}) ->
+    put(?STACK, binary_to_term(Stk)).
+
+init(Stack) ->
+    put(?STACK, Stack).
+
+%% We keep track of a call stack that is used for
+%%  1) saving stack frames that can be inspected from an Attached
+%%     Process GUI (using dbg_icmd:get(Meta, stack_frame, {Dir, SP})
+%%  2) generate an approximation of regular stacktrace -- sent to
+%%     Debugged when it should raise an exception or evaluate a
+%%     function (since it might possible raise an exception)
+%%
+%% How to push depends on the "Stack Trace" option (value saved in
+%% process dictionary item 'trace_stack').
+%%   all - everything is pushed
+%%   no_tail - tail recursive push
+%%   false - nothing is pushed
+%% Whenever a function returns, the corresponding call frame is popped.
+
+push(Bs, #ieval{level=Le,module=Mod,function=Name,
+		arguments=As,line=Li}=Ieval, Lc) ->
+    Entry = #e{level=Le,mfa={Mod,Name,As},line=Li,bindings=Bs,lc=Lc},
+    case get(trace_stack) of
+	false ->
+	    Ieval#ieval{level=Le+1};
+	no_tail when Lc ->
+	    Ieval;
+	_ -> % all | no_tail when Lc =:= false
+	    put(?STACK, [Entry|get(?STACK)]),
+	    Ieval#ieval{level=Le+1}
+    end.
+
+pop() ->
+    case get(trace_stack) of
+	false -> ignore;
+	_ -> % all ¦ no_tail
+	    case get(?STACK) of
+		[_Entry|Entries] ->
+		    put(?STACK, Entries);
+		[] ->
+		    ignore
+	    end
+    end.
+
+pop(Le) ->
+    case get(trace_stack) of
+	false -> ignore;
+	_ -> % all | no_tail
+	    put(?STACK, pop(Le, get(?STACK)))
+    end.
+
+pop(Level, [#e{level=Le}|Stack]) when Level =< Le ->
+    pop(Level, Stack);
+pop(_Level, Stack) ->
+    Stack.
+
+%% stack_level() -> Le
+%% stack_level(Stack) -> Le
+%% Top call level
+stack_level() ->
+    stack_level(get(?STACK)).
+
+stack_level([]) -> 1;
+stack_level([#e{level=Le}|_]) -> Le.
+
+%% delayed_stacktrace() -> CreateStacktraceFun
+%% delayed_stacktrace(ArgFlag, #ieval{}) -> CreateStacktraceFun
+%%   ArgFlag = no_args | include_args
+%%   CreateStacktraceFun = fun(NumberOfEntries)
+%%
+%% Return a fun that can convert the internal stack format to
+%% an imitation of the regular stacktrace.
+
+delayed_stacktrace() ->
+    Stack0 = get(?STACK),
+    fun(NumEntries) ->
+	    Stack = stacktrace(NumEntries, Stack0, []),
+	    [finalize(ArityOnly) || {ArityOnly,_} <- Stack]
+    end.
+
+delayed_stacktrace(include_args, Ieval) ->
+    #ieval{module=Mod,function=Name,arguments=As,line=Li} = Ieval,
+    Stack0 = [#e{mfa={Mod,Name,As},line=Li}|get(?STACK)],
+    fun(NumEntries) ->
+	    case stacktrace(NumEntries, Stack0, []) of
+		[] ->
+		    [];
+		[{_,WithArgs}|Stack] ->
+		    [finalize(WithArgs) |
+		     [finalize(ArityOnly) || {ArityOnly,_} <- Stack]]
+	    end
+    end;
+delayed_stacktrace(no_args, Ieval) ->
+    #ieval{module=Mod,function=Name,arguments=As,line=Li} = Ieval,
+    Stack0 = [#e{mfa={Mod,Name,As},line=Li}|get(?STACK)],
+    fun(NumEntries) ->
+	    Stack = stacktrace(NumEntries, Stack0, []),
+	    [finalize(ArityOnly) || {ArityOnly,_} <- Stack]
+    end.
+
+stacktrace(N, [#e{lc=true}|T], Acc) ->
+    stacktrace(N, T, Acc);
+stacktrace(N, [E|T], []) ->
+    stacktrace(N-1, T, [normalize(E)]);
+stacktrace(N, [E|T], [{P,_}|_]=Acc) when N > 0 ->
+    case normalize(E) of
+	{P,_} ->
+	    stacktrace(N, T, Acc);
+	New ->
+	    stacktrace(N-1, T, [New|Acc])
+    end;
+stacktrace(_, _, Acc) ->
+    lists:reverse(Acc).
+
+normalize(#e{mfa={M,Fun,As},line=Li}) when is_function(Fun) ->
+    Loc = {M,Li},
+    {{Fun,length(As),Loc},{Fun,As,Loc}};
+normalize(#e{mfa={M,F,As},line=Li}) ->
+    Loc = {M,Li},
+    {{M,F,length(As),Loc},{M,F,As,Loc}}.
+
+finalize({M,F,A,Loc}) -> {M,F,A,line(Loc)};
+finalize({Fun,A,Loc}) -> {Fun,A,line(Loc)}.
+
+line({Mod,Line}) when Line > 0 ->
+    [{file,atom_to_list(Mod)++".erl"},{line,Line}];
+line(_) -> [].
+
+%% bindings(SP) -> Bs
+%%   SP = Le  % stack pointer
+%% Return the bindings for the specified call level
+bindings(SP) ->
+    bindings(SP, get(?STACK)).
+
+bindings(SP, [#e{level=SP,bindings=Bs}|_]) ->
+    Bs;
+bindings(SP, [_Entry|Entries]) ->
+    bindings(SP, Entries);
+bindings(_SP, []) ->
+    erl_eval:new_bindings().
+
+%% stack_frame(Dir, SP) -> {Le, Where, Bs} | top | bottom
+%%   Dir = up | down
+%%   Where = {Cm, Li}
+%%     Cm = Module | undefined  % module
+%%     Li = int()  | -1         % line number
+%%     Bs = bindings()
+%% Return stack frame info one step up/down from given stack pointer
+%%  up = to lower call levels
+%%  down = to higher call levels
+stack_frame(up, SP) ->
+    stack_frame(SP, up, get(?STACK));
+stack_frame(down, SP) ->
+    stack_frame(SP, down, lists:reverse(get(?STACK))).
+
+stack_frame(SP, up, [#e{level=Le,mfa={Cm,_,_},line=Li,bindings=Bs}|_])
+  when Le < SP ->
+    {Le,{Cm,Li},Bs};
+stack_frame(SP, down, [#e{level=Le,mfa={Cm,_,_},line=Li,bindings=Bs}|_])
+  when Le > SP ->
+    {Le,{Cm,Li},Bs};
+stack_frame(SP, Dir, [#e{level=SP}|Stack]) ->
+    case Stack of
+	[#e{level=Le,mfa={Cm,_,_},line=Li,bindings=Bs}|_] ->
+	    {Le,{Cm,Li},Bs};
+	[] when Dir =:= up ->
+	    top;
+	[] when Dir =:= down ->
+	    bottom
+    end;
+stack_frame(SP, Dir, [_Entry|Stack]) ->
+    stack_frame(SP, Dir, Stack).
+
+%% backtrace(HowMany) -> Backtrace
+%%   HowMany = all | int()
+%%   Backtrace = {Le, MFA}
+%% Return all/the last N called functions, in reversed call order
+backtrace(HowMany, Ieval) ->
+    #ieval{level=Level,module=Mod,function=Name,arguments=As} = Ieval,
+    Stack0 = [#e{level=Level,mfa={Mod,Name,As}}|get(?STACK)],
+    Stack = case HowMany of
+		all -> Stack0;
+		N -> lists:sublist(Stack0, N)
+	    end,
+    [{Le,MFA} || #e{level=Le,mfa=MFA} <- Stack].
+
+%%--------------------------------------------------------------------
+%% in_use_p(Mod, Cm) -> boolean()
+%%   Mod = Cm = atom()
+%% Returns true if Mod is found on the stack, otherwise false.
+%%--------------------------------------------------------------------
+in_use_p(Mod, Mod) -> true;
+in_use_p(Mod, _Cm) ->
+    case get(trace_stack) of
+	false -> true;
+	_ -> %  all | no_tail
+	    lists:any(fun(#e{mfa={M,_,_}}) when M =:= Mod -> true;
+			 (_) -> false
+		      end, get(?STACK))
+    end.
diff --git a/lib/debugger/src/debugger.app.src b/lib/debugger/src/debugger.app.src
index 21cf59a2e1..5538f66260 100644
--- a/lib/debugger/src/debugger.app.src
+++ b/lib/debugger/src/debugger.app.src
@@ -26,6 +26,7 @@
 	     dbg_ieval,
 	     dbg_iload,
 	     dbg_iserver,
+	     dbg_istk,
 	     dbg_ui_break,
 	     dbg_ui_break_win,
 	     dbg_ui_edit,