The R13B03 release.OTP_R13B03

1 files changed, 1259 insertions, 0 deletions

diff --git a/erts/emulator/test/trace_local_SUITE.erl b/erts/emulator/test/trace_local_SUITE.erl
new file mode 100644
index 0000000000..24005774ba
--- /dev/null
+++ b/erts/emulator/test/trace_local_SUITE.erl
@@ -0,0 +1,1259 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2000-2009. 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(trace_local_SUITE).
+-compile({nowarn_deprecated_function, {erlang,hash,2}}).
+
+-export([basic_test/0, bit_syntax_test/0, return_test/0,
+	 on_and_off_test/0, stack_grow_test/0,
+	 info_test/0, delete_test/1, exception_test/1,
+	 not_run/1]).
+
+-export([exported/1, exported_wrap/1, loop/4, apply_slave_async/5,
+	 match/2, clause/2, id/1, undef/1, lists_reverse/2]).
+
+%%
+%% Define to run outside of test server
+%%
+%% (rotten feature)
+%%
+%%-define(STANDALONE,1).
+ 
+%%
+%% Define for debug output
+%%
+%%-define(debug,1).
+ 
+-ifdef(STANDALONE).
+-define(config(A,B),config(A,B)).
+-export([config/2]).
+-define(DEFAULT_RECEIVE_TIMEOUT, 1000).
+-else.
+-include("test_server.hrl").
+-define(DEFAULT_RECEIVE_TIMEOUT, infinity).
+-endif.
+ 
+-ifdef(debug).
+-ifdef(STANDALONE).
+-define(line, erlang:display({?MODULE,?LINE}), ).
+-endif.
+-define(dbgformat(A,B),io:format(A,B)).
+-else.
+-ifdef(STANDALONE).
+-define(line, noop, ).
+-endif.
+-define(dbgformat(A,B),noop).
+-endif.
+ 
+-ifdef(STANDALONE).
+config(priv_dir,_) ->
+    ".".
+-else.
+
+%%% When run in test server %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-export([all/1, basic/1, bit_syntax/1,
+	 return/1, on_and_off/1, stack_grow/1,info/1, delete/1,
+	 exception/1, exception_apply/1,
+	 exception_function/1, exception_apply_function/1,
+	 exception_nocatch/1, exception_nocatch_apply/1,
+	 exception_nocatch_function/1, exception_nocatch_apply_function/1,
+	 exception_meta/1, exception_meta_apply/1,
+	 exception_meta_function/1, exception_meta_apply_function/1,
+	 exception_meta_nocatch/1, exception_meta_nocatch_apply/1,
+	 exception_meta_nocatch_function/1,
+	 exception_meta_nocatch_apply_function/1,
+	 init_per_testcase/2, fin_per_testcase/2]).
+init_per_testcase(_Case, Config) ->
+    ?line Dog=test_server:timetrap(test_server:minutes(2)),
+    [{watchdog, Dog}|Config].
+
+fin_per_testcase(_Case, Config) ->
+    shutdown(),
+    Dog=?config(watchdog, Config),
+    test_server:timetrap_cancel(Dog),
+    ok.
+all(doc) ->
+    ["Test tracing of local function calls and return traces."];
+all(suite) ->
+    case test_server:is_native(?MODULE) of
+	true -> [not_run];
+	false -> [basic, bit_syntax, return, on_and_off, stack_grow, info, delete,
+		  exception, exception_apply,
+		  exception_function, exception_apply_function,
+		  exception_nocatch, exception_nocatch_apply,
+		  exception_nocatch_function, 
+		  exception_nocatch_apply_function,
+		  exception_meta, exception_meta_apply,
+		  exception_meta_function, exception_meta_apply_function,
+		  exception_meta_nocatch, exception_meta_nocatch_apply,
+		  exception_meta_nocatch_function,
+		  exception_meta_nocatch_apply_function]
+    end.
+
+not_run(Config) when is_list(Config) -> 
+    {skipped,"Native code"}.
+
+basic(doc) ->
+    ["Tests basic local call-trace"];
+basic(Config) when is_list(Config) ->
+    basic_test().
+
+bit_syntax(doc) ->
+    "OTP-7399: Make sure that code that uses the optimized bit syntax matching "
+	"can be traced without crashing the emulator.";
+bit_syntax(Config) when is_list(Config) ->
+    bit_syntax_test().
+
+return(doc) ->
+    ["Tests the different types of return trace"];
+return(Config) when is_list(Config) ->
+    return_test().
+ 
+on_and_off(doc) ->
+    ["Tests turning trace parameters on and off, "
+     "both for trace and trace_pattern"];
+on_and_off(Config) when is_list(Config) ->
+    on_and_off_test().
+ 
+stack_grow(doc) ->
+    ["Tests the stack growth during return traces"];
+stack_grow(Config) when is_list(Config) ->
+    stack_grow_test().
+ 
+info(doc) ->
+    ["Tests the trace_info BIF"];
+info(Config) when is_list(Config) ->
+    info_test().
+ 
+delete(doc) ->
+    ["Tests putting trace on deleted modules"];
+delete(Config) when is_list(Config) ->
+    delete_test(Config).
+
+exception(doc) ->
+    ["Tests exception_trace"];
+exception(Config) when is_list(Config) ->
+    exception_test([]).
+
+exception_apply(doc) ->
+    ["Tests exception_trace"];
+exception_apply(Config) when is_list(Config) ->
+    exception_test([apply]).
+
+exception_function(doc) ->
+    ["Tests exception_trace"];
+exception_function(Config) when is_list(Config) ->
+    exception_test([function]).
+
+exception_apply_function(doc) ->
+    ["Tests exception_trace"];
+exception_apply_function(Config) when is_list(Config) ->
+    exception_test([apply,function]).
+
+exception_nocatch(doc) ->
+    ["Tests exception_trace"];
+exception_nocatch(Config) when is_list(Config) ->
+    exception_test([nocatch]).
+
+exception_nocatch_apply(doc) ->
+    ["Tests exception_trace"];
+exception_nocatch_apply(Config) when is_list(Config) ->
+    exception_test([nocatch,apply]).
+
+exception_nocatch_function(doc) ->
+    ["Tests exception_trace"];
+exception_nocatch_function(Config) when is_list(Config) ->
+    exception_test([nocatch,function]).
+
+exception_nocatch_apply_function(doc) ->
+    ["Tests exception_trace"];
+exception_nocatch_apply_function(Config) when is_list(Config) ->
+    exception_test([nocatch,apply,function]).
+
+exception_meta(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta(Config) when is_list(Config) ->
+    exception_test([meta]).
+
+exception_meta_apply(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_apply(Config) when is_list(Config) ->
+    exception_test([meta,apply]).
+
+exception_meta_function(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_function(Config) when is_list(Config) ->
+    exception_test([meta,function]).
+
+exception_meta_apply_function(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_apply_function(Config) when is_list(Config) ->
+    exception_test([meta,apply,function]).
+
+exception_meta_nocatch(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_nocatch(Config) when is_list(Config) ->
+    exception_test([meta,nocatch]).
+
+exception_meta_nocatch_apply(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_nocatch_apply(Config) when is_list(Config) ->
+    exception_test([meta,nocatch,apply]).
+
+exception_meta_nocatch_function(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_nocatch_function(Config) when is_list(Config) ->
+    exception_test([meta,nocatch,function]).
+
+exception_meta_nocatch_apply_function(doc) ->
+    ["Tests meta exception_trace"];
+exception_meta_nocatch_apply_function(Config) when is_list(Config) ->
+    exception_test([meta,nocatch,apply,function]).
+
+-endif.
+
+
+
+%%% Message patterns and expect functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+-define(pCT(P,M,F,A),   {trace,   P,call,{M,F,A}}).
+-define(pCTT(P,M,F,A),  {trace_ts,P,call,{M,F,A},{_,_,_}}).
+-define(pRF(P,M,F,A,V), {trace,   P,return_from,{M,F,A},V}).
+-define(pRFT(P,M,F,A,V),{trace_ts,P,return_from,{M,F,A},V,{_,_,_}}).
+-define(pEF(P,M,F,A,V), {trace,   P,exception_from,{M,F,A},V}).
+-define(pEFT(P,M,F,A,V),{trace_ts,P,exception_from,{M,F,A},V,{_,_,_}}).
+-define(pRT(P,M,F,A),   {trace,   P,return_to,{M,F,A}}).
+-define(pRTT(P,M,F,A),  {trace_ts,P,return_to,{M,F,A},{_,_,_}}).
+
+-define(CT(M,F,A),    ?pCT(_,M,F,A)    = receive_next()).
+-define(CTT(M,F,A),   ?pCTT(_,M,F,A)   = receive_next()).
+-define(RF(M,F,A,V),  ?pRF(_,M,F,A,V)  = receive_next()).
+-define(RFT(M,F,A,V), ?pRFT(_,M,F,A,V) = receive_next()).
+-define(EF(M,F,A,V),  ?pEF(_,M,F,A,V)  = receive_next()).
+-define(EFT(M,F,A,V), ?pEFT(_,M,F,A,V) = receive_next()).
+-define(RT(M,F,A),    ?pRT(_,M,F,A)    = receive_next()).
+-define(RTT(M,F,A),   ?pRTT(_,M,F,A)   = receive_next()).
+-define(NM, receive_no_next(100)).
+
+expect() ->
+    {Pid,_} = get(slave),
+    expect_receive(Pid).
+
+expect(Msg) ->
+    {Pid,_} = get(slave),
+    expect_pid(Pid, Msg).
+
+
+
+expect_pid(_Pid, []) ->
+    ok;
+expect_pid(Pid, [Line|T]) when is_integer(Line) ->
+    put(test_server_loc, {?MODULE,Line}),
+    expect_pid(Pid, T);
+expect_pid(Pid, [true|[_|_]=T]) ->
+    expect_pid(Pid, T);
+expect_pid(Pid, [false|[_|T]]) ->
+    expect_pid(Pid, T);
+expect_pid(Pid, [H|T]) ->
+    expect_pid(Pid, H),
+    expect_pid(Pid, T);
+expect_pid(Pid, Msg) when is_tuple(Msg) ->
+    same(Msg, expect_receive(Pid));
+expect_pid(Pid, Fun) when is_function(Fun, 1) ->
+    case Fun(expect_receive(Pid)) of
+	next ->
+	    expect_pid(Pid, Fun);
+	done ->
+	    ok;
+	Other ->
+	    expect_pid(Pid, Other)
+    end.
+
+expect_receive(Pid) when is_pid(Pid) ->
+    receive
+	Msg when is_tuple(Msg), 
+		 element(1, Msg) == trace, 
+		 element(2, Msg) =/= Pid;
+		 %%
+		 is_tuple(Msg), 
+		 element(1, Msg) == trace_ts, 
+		 element(2, Msg) =/= Pid ->
+	    expect_receive(Pid);
+	Msg ->
+	    expect_msg(Pid, Msg)
+    after 100 ->
+	    {nm}
+    end.
+
+expect_msg(P, ?pCT(P,M,F,Args))       -> {ct,{M,F},Args};
+expect_msg(P, ?pCTT(P,M,F,Args))      -> {ctt,{M,F},Args};
+expect_msg(P, ?pRF(P,M,F,Arity,V))    -> {rf,{M,F,Arity},V};
+expect_msg(P, ?pRFT(P,M,F,Arity,V))   -> {rft,{M,F,Arity},V};
+expect_msg(P, ?pEF(P,M,F,Arity,V))    -> {ef,{M,F,Arity},V};
+expect_msg(P, ?pEFT(P,M,F,Arity,V))   -> {eft,{M,F,Arity},V};
+expect_msg(P, ?pRT(P,M,F,Arity))      -> {rt,{M,F,Arity}};
+expect_msg(P, ?pRTT(P,M,F,Arity))     -> {rtt,{M,F,Arity}};
+expect_msg(P, Msg) when is_tuple(Msg) ->
+    case tuple_to_list(Msg) of
+	[trace,P|T] ->
+	    list_to_tuple([trace|T]);
+	[trace_ts,P|[_|_]=T] ->
+	    list_to_tuple([trace_ts|reverse(tl(reverse(T)))]);
+	_ ->
+	    Msg
+    end.
+
+same(A, B) ->
+    case [A|B] of
+	[X|X] ->
+	    ok
+    end.
+
+
+
+%%% tests %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+basic_test() ->
+    ?line setup([call]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[],[local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported,[1]),
+    ?line ?CT(?MODULE,local,[1]),
+    ?line ?CT(?MODULE,local2,[1]),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[],[]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line [1,1,1,1] = lambda_slave(fun() ->
+					   exported_wrap(1)
+				   end),
+    ?line ?NM, 
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[],[local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line [1,1,1,1] = lambda_slave(fun() ->
+					   exported_wrap(1)
+				   end),
+    ?line ?CT(?MODULE,_,_), %% The fun
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported,[1]),
+    ?line ?CT(?MODULE,local,[1]),
+    ?line ?CT(?MODULE,local2,[1]),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},false,[local]),
+    ?line shutdown(),
+    ?line ?NM,
+    ok.
+
+%% OTP-7399.
+bit_syntax_test() ->
+    ?line setup([call]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[],[local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+
+    ?line lambda_slave(fun() ->
+			       6 = bs_sum_a(<<1,2,3>>, 0),
+			       10 = bs_sum_b(0, <<1,2,3,4>>),
+			       26 = bs_sum_c(<<3:4,5:4,7:4,11:4>>, 0)
+		       end),
+    ?line ?CT(?MODULE,_,[]),		      %Ignore call to the fun.
+
+    ?line ?CT(?MODULE,bs_sum_a,[<<1,2,3>>,0]),
+    ?line ?CT(?MODULE,bs_sum_a,[<<2,3>>,1]),
+    ?line ?CT(?MODULE,bs_sum_a,[<<3>>,3]),
+    ?line ?CT(?MODULE,bs_sum_a,[<<>>,6]),
+
+    ?line ?CT(?MODULE,bs_sum_b,[0,<<1,2,3,4>>]),
+    ?line ?CT(?MODULE,bs_sum_b,[1,<<2,3,4>>]),
+    ?line ?CT(?MODULE,bs_sum_b,[3,<<3,4>>]),
+    ?line ?CT(?MODULE,bs_sum_b,[6,<<4>>]),
+    ?line ?CT(?MODULE,bs_sum_b,[10,<<>>]),
+
+    ?line ?CT(?MODULE,bs_sum_c,[<<3:4,5:4,7:4,11:4>>, 0]),
+    ?line ?CT(?MODULE,bs_sum_c,[<<5:4,7:4,11:4>>, 3]),
+    ?line ?CT(?MODULE,bs_sum_c,[<<7:4,11:4>>, 8]),
+    ?line ?CT(?MODULE,bs_sum_c,[<<11:4>>, 15]),
+    ?line ?CT(?MODULE,bs_sum_c,[<<>>, 26]),
+
+    ?line erlang:trace_pattern({?MODULE,'_','_'},false,[local]),
+    ?line shutdown(),
+    ?line ?NM,
+
+    ok.
+
+bs_sum_a(<<H,T/binary>>, Acc) -> bs_sum_a(T, H+Acc);
+bs_sum_a(<<>>, Acc) -> Acc.
+
+bs_sum_b(Acc, <<H,T/binary>>) -> bs_sum_b(H+Acc, T);
+bs_sum_b(Acc, <<>>) -> Acc.
+
+bs_sum_c(<<H:4,T/bits>>, Acc) -> bs_sum_c(T, H+Acc);
+bs_sum_c(<<>>, Acc) -> Acc.
+
+return_test() ->
+    ?line setup([call]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[{'_',[],[{return_trace}]}],
+			 [local]),
+    ?line erlang:trace_pattern({erlang,hash,'_'},[{'_',[],[{return_trace}]}],
+			 [local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]), 
+    ?line ?CT(?MODULE,exported,[1]),
+    ?line ?CT(?MODULE,local,[1]),
+    ?line ?CT(?MODULE,local2,[1]),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line ?RF(erlang,hash,2,1),
+    ?line ?RF(?MODULE,local_tail,1,[1,1]),
+    ?line ?RF(?MODULE,local2,1,[1,1]),
+    ?line ?RF(?MODULE,local,1,[1,1,1]),
+    ?line ?RF(?MODULE,exported,1,[1,1,1,1]),
+    ?line ?RF(?MODULE,exported_wrap,1,[1,1,1,1]),
+    ?line shutdown(),
+    ?line setup([call,return_to]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[],
+			       [local]),
+    ?line erlang:trace_pattern({erlang,hash,'_'},[],
+			       [local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]), 
+    ?line ?CT(?MODULE,exported,[1]),
+    ?line ?CT(?MODULE,local,[1]),
+    ?line ?CT(?MODULE,local2,[1]),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line ?RT(?MODULE,local_tail,1),
+    ?line ?RT(?MODULE,local,1),
+    ?line ?RT(?MODULE,exported,1),
+    ?line ?RT(?MODULE,slave,2),
+    ?line shutdown(),
+    ?line setup([call,return_to]),
+    ?line erlang:trace_pattern({?MODULE,'_','_'},[{'_',[],[{return_trace}]}],
+			       [local]),
+    ?line erlang:trace_pattern({erlang,hash,'_'},[{'_',[],[{return_trace}]}],
+			       [local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]), 
+    ?line ?CT(?MODULE,exported,[1]),
+    ?line ?CT(?MODULE,local,[1]),
+    ?line ?CT(?MODULE,local2,[1]),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line ?RF(erlang,hash,2,1),
+    ?line ?RT(?MODULE,local_tail,1),
+    ?line ?RF(?MODULE,local_tail,1,[1,1]),
+    ?line ?RF(?MODULE,local2,1,[1,1]),
+    ?line ?RT(?MODULE,local,1),
+    ?line ?RF(?MODULE,local,1,[1,1,1]),
+    ?line ?RT(?MODULE,exported,1),
+    ?line ?RF(?MODULE,exported,1,[1,1,1,1]),
+    ?line ?RF(?MODULE,exported_wrap,1,[1,1,1,1]),
+    ?line ?RT(?MODULE,slave,2),
+    ?line shutdown(),
+    ?line ?NM,
+    ok.
+
+on_and_off_test() ->
+    ?line Pid = setup([call]),
+    ?line 1 = erlang:trace_pattern({?MODULE,local_tail,1},[],[local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line LocalTail = fun() ->
+			      local_tail(1)
+		      end,
+    ?line [1,1] = lambda_slave(LocalTail),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line erlang:trace(Pid,true,[return_to]),
+    ?line [1,1] = lambda_slave(LocalTail),
+    ?line ?CT(?MODULE,local_tail,[1]),
+    ?line ?RT(?MODULE,_,_),
+    ?line 0 = erlang:trace_pattern({?MODULE,local_tail,1},[],[global]),
+    ?line [1,1] = lambda_slave(LocalTail),
+    ?line ?NM,
+    ?line 1 = erlang:trace_pattern({?MODULE,exported_wrap,1},[],[global]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line 1 = erlang:trace_pattern({?MODULE,exported_wrap,1},[],[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?RT(?MODULE,slave,2),
+    ?line 1 = erlang:trace_pattern({erlang,hash,2},[],[local]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line ?RT(?MODULE,local_tail,1),
+    ?line ?RT(?MODULE,slave,2),
+    ?line erlang:trace(Pid,true,[timestamp]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CTT(?MODULE,exported_wrap,[1]),
+    ?line ?CTT(erlang,hash,[1,1]),
+    ?line ?RTT(?MODULE,local_tail,1),
+    ?line ?RTT(?MODULE,slave,2),
+    ?line erlang:trace(Pid,false,[return_to,timestamp]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line erlang:trace(Pid,true,[return_to]),
+    ?line 1 = erlang:trace_pattern({erlang,hash,2},[],[]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line ?RT(?MODULE,slave,2),
+    ?line 1 = erlang:trace_pattern({?MODULE,exported_wrap,1},[],[]),
+    ?line [1,1,1,1] = apply_slave(?MODULE,exported_wrap,[1]),
+    ?line ?CT(?MODULE,exported_wrap,[1]),
+    ?line ?CT(erlang,hash,[1,1]),
+    ?line shutdown(),
+    ?line erlang:trace_pattern({'_','_','_'},false,[local]),
+    ?line N = erlang:trace_pattern({erlang,'_','_'},true,[local]),
+    ?line case erlang:trace_pattern({erlang,'_','_'},false,[local]) of
+	      N -> 
+		  ok;
+	      Else ->
+		  exit({number_mismatch, {expected, N}, {got, Else}})
+	  end,
+    ?line case erlang:trace_pattern({erlang,'_','_'},false,[local]) of
+	      N -> 
+		  ok;
+	      Else2 ->
+		  exit({number_mismatch, {expected, N}, {got, Else2}})
+	  end,
+    ?line M = erlang:trace_pattern({erlang,'_','_'},true,[]),
+    ?line case erlang:trace_pattern({erlang,'_','_'},false,[]) of
+	      M -> 
+		  ok;
+	      Else3 ->
+		  exit({number_mismatch, {expected, N}, {got, Else3}})
+	  end,
+    ?line case erlang:trace_pattern({erlang,'_','_'},false,[]) of
+	      M -> 
+		  ok;
+	      Else4 ->
+		  exit({number_mismatch, {expected, N}, {got, Else4}})
+	  end,
+    ?line ?NM,
+    ok.
+    
+    
+stack_grow_test() ->    
+    ?line setup([call,return_to]),
+    ?line 1 = erlang:trace_pattern({?MODULE,loop,4},
+				   [{'_',[],[{return_trace}]}],[local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line Num = 1 bsl 15,
+    ?line Fun = 
+	fun(_F,0) -> ok; 
+	   (F,N) -> 
+		receive _A -> 
+			receive _B -> 
+				receive _C ->
+					F(F,N-1) 
+				end
+			end 
+		end 
+	end, 
+    ?line apply_slave_async(?MODULE,loop,[{hej,hopp},[a,b,c],4.5,Num]),
+    ?line Fun(Fun,Num + 1),
+    ?line ?NM, 
+    ok.
+
+
+info_test() ->
+    ?line Flags1 = lists:sort([call,return_to]),
+    ?line Pid = setup(Flags1),
+    ?line Prog = [{['$1'],[{is_integer,'$1'}],[{message, false}]},
+		  {'_',[],[]}],
+    ?line erlang:trace_pattern({?MODULE,exported_wrap,1},Prog,[local]),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,[local]),
+    ?line Self = self(),
+    ?line {flags,L} = erlang:trace_info(Pid,flags),
+    ?line case lists:sort(L) of
+	      Flags1 ->
+		  ok;
+	      Wrong1 ->
+		  exit({bad_result, {erlang,trace_info,[Pid,flags]},
+			{expected, Flags1}, {got, Wrong1}})
+	  end,
+    ?line {tracer,Tracer} = erlang:trace_info(Pid,tracer),
+    ?line case Tracer of
+	      Self ->
+		  ok;
+	      Wrong2 ->
+		  exit({bad_result, {erlang,trace_info,[Pid,tracer]},
+			{expected, Self}, {got, Wrong2}})
+	  end,
+    ?line {traced,local} = erlang:trace_info({?MODULE,exported_wrap,1},traced),
+    ?line {match_spec, MS} = 
+	erlang:trace_info({?MODULE,exported_wrap,1},match_spec),
+    ?line case MS of
+	      Prog ->
+		  ok;
+	      Wrong3 ->
+		  exit({bad_result, {erlang,trace_info,
+				     [{?MODULE,exported_wrap,1},
+				      match_spec]},
+			{expected, Prog}, {got, Wrong3}})
+	  end,
+    ?line erlang:garbage_collect(self()),
+    ?line receive
+	  after 1 ->
+		  ok
+	  end,
+    ?line io:format("~p~n",[MS]),
+    ?line {match_spec,MS2} = 
+	erlang:trace_info({?MODULE,exported_wrap,1},match_spec),
+    ?line io:format("~p~n",[MS2]),
+    ?line erlang:trace_pattern({?MODULE,exported_wrap,1},[],[]),
+    ?line {traced,global} = 
+	erlang:trace_info({?MODULE,exported_wrap,1},traced),
+    ?line {match_spec,[]} = 
+	erlang:trace_info({?MODULE,exported_wrap,1},match_spec),
+    ?line {traced,undefined} = 
+	erlang:trace_info({?MODULE,exported_wrap,2},traced),
+    ?line {match_spec,undefined} = 
+	erlang:trace_info({?MODULE,exported_wrap,2},match_spec),
+    ?line {traced,false} = erlang:trace_info({?MODULE,exported,1},traced),
+    ?line {match_spec,false} = 
+	erlang:trace_info({?MODULE,exported,1},match_spec),
+    ?line shutdown(),
+    ok.
+
+delete_test(Config) ->
+    ?line Priv = ?config(priv_dir, Config),
+    ?line Data = ?config(data_dir, Config),
+    ?line File = filename:join(Data, "trace_local_dummy"),
+    ?line {ok,trace_local_dummy} = c:c(File, [{outdir,Priv}]),
+    ?line code:purge(trace_local_dummy),
+    ?line code:delete(trace_local_dummy),
+    ?line 0 = erlang:trace_pattern({trace_local_dummy,'_','_'},true,[local]),
+    ?line ?NM,
+    ok.
+
+
+
+%%% exception_test %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+exception_test(Opts) ->
+    ?line {ProcFlags,PatFlags} = 
+	case proplists:get_bool(meta, Opts) of
+	    true  -> {[timestamp],[meta]};
+	    false -> {[call,return_to,timestamp],[local]}
+	end,
+    ?line case proplists:get_bool(nocatch, Opts) of
+	      false ->
+		  ?line Exceptions = exceptions(),
+		  ?line exception_test_setup(ProcFlags, PatFlags),
+		  ?line lists:foreach(
+			  fun ({Func,Args}) ->
+				  ?line exception_test(Opts, Func, Args)
+			  end,
+			  Exceptions),
+		  ?line shutdown();
+	      true ->
+		  ?line Exceptions = exceptions(),
+		  ?line lists:foreach(
+			  fun ({Func,Args}) ->
+				  ?line exception_test_setup(
+					  [procs|ProcFlags],
+					  PatFlags),
+				  ?line exception_test(Opts, Func, Args),
+				  ?line shutdown()
+			  end,
+			  Exceptions)
+	  end,
+    ?line ok.
+
+exceptions() ->
+    ?line Ref = make_ref(),
+    ?line N = case os:type() of
+		  vxworks ->
+		      ?line 2000; % Limited memory on themachines, not actually
+		                  % VxWorks' fault /PaN
+		  _ ->
+		      ?line 200000
+	      end,
+    ?line LiL = seq(1, N-1, N),	% Long Improper List
+    ?line LL = seq(1, N, []),  	% Long List
+    [{{erlang,exit},  [done]},
+     {{erlang,error}, [1.0]},
+     {{erlang,error}, [Ref,[]]},
+     {{erlang,throw}, [4711]},
+     {{erlang,'++'},    [[17],seventeen]},
+     {{erlang,'++'},    [Ref,[125.125]]},
+     {{?MODULE,match},  [ref,Ref]},
+     {{?MODULE,match},  [Ref,Ref]},
+     {{?MODULE,clause}, [ref,Ref]},
+     {{?MODULE,clause}, [Ref,Ref]},
+     {{?MODULE,id},     [4711.0]},
+     {{?MODULE,undef},  [[Ref|Ref]]},
+     {{?MODULE,lists_reverse}, [LiL,[]]},
+     {{?MODULE,lists_reverse}, [LL,[]]}].
+
+exception_test_setup(ProcFlags, PatFlags) ->
+    ?line Pid = setup(ProcFlags),
+    ?line io:format("=== exception_test_setup(~p, ~p): ~p~n", 
+		    [ProcFlags,PatFlags,Pid]),
+    ?line Mprog = [{'_',[],[{exception_trace}]}],
+    ?line erlang:trace_pattern({?MODULE,'_','_'}, Mprog, PatFlags),
+    ?line erlang:trace_pattern({?MODULE,slave,'_'},false,PatFlags),
+    ?line [1,1,1,1,1] =
+	[erlang:trace_pattern({erlang,F,A}, Mprog, PatFlags)
+	 || {F,A} <- [{exit,1},{error,1},{error,2},{throw,1},{'++',2}]],
+    ?line 1 = erlang:trace_pattern({lists,reverse,2}, Mprog, PatFlags),
+    ?line ok.
+
+-record(exc_opts, {nocatch=false, meta=false}).
+
+exception_test(Opts, Func0, Args0) ->
+    ?line io:format("=== exception_test(~p, ~p, ~p)~n", 
+		    [Opts,Func0,abbr(Args0)]),
+    ?line Apply = proplists:get_bool(apply, Opts),
+    ?line Function = proplists:get_bool(function, Opts),
+    ?line Nocatch = proplists:get_bool(nocatch, Opts),
+    ?line Meta = proplists:get_bool(meta, Opts),
+    ?line ExcOpts = #exc_opts{nocatch=Nocatch,meta=Meta},
+    
+    %% Func0 and Args0 are for the innermost call, now we will
+    %% wrap them in wrappers...
+    ?line {Func1,Args1} =
+	case Function of
+	    true  -> {fun exc/2,[Func0,Args0]};
+	    false -> {Func0,Args0}
+	end,
+    
+    ?line {Func,Args} = 
+	case Apply of
+	    true  -> {{erlang,apply},[Func1,Args1]};
+	    false -> {Func1,Args1}
+	end,
+    
+    ?line R1 = exc_slave(ExcOpts, Func, Args),
+    ?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) ->
+		[R,
+		 {crash,{Reason,Stack++Stack2}},
+		 {crash,{Reason,Stack++Stack3}}];
+	    R ->
+		[R]
+	end,
+    ?line exception_validate(R1, Rs),
+    ?line case R1 of
+	      {crash,Crash} ->
+		  ?line expect({trace_ts,exit,Crash});
+	      _ when not Meta ->
+		  ?line expect({rtt,{?MODULE,slave,2}});
+	      _ ->
+		  ok
+	  end,
+    ?line expect({nm}).
+
+exception_validate(R1, [R2|Rs]) ->
+    case [R1|R2] of
+	[R|R] ->
+	    ok;
+	[{crash,{badarg,[{lists,reverse,[L1a,L1b]}|T]}}|
+	 {crash,{badarg,[{lists,reverse,[L2a,L2b]}|T]}}] ->
+	    same({crash,{badarg,[{lists,reverse,
+				  [lists:reverse(L1b, L1a),[]]}|T]}},
+		 {crash,{badarg,[{lists,reverse,
+				  [lists:reverse(L2b, L2a),[]]}|T]}});
+	_ when is_list(Rs), Rs =/= [] ->
+	    exception_validate(R1, Rs)
+    end.
+
+
+
+%%% Tracee target functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+loop(D1,D2,D3,0) ->
+    io:format("~p~n",[[D1,D2,D3]]),
+    0;
+loop(D1,D2,D3,N) ->
+    max(N,loop(D1,D2,D3,N-1)).
+
+max(A, B) when A > B -> A;
+max(_, B) -> B.
+
+exported_wrap(Val) ->
+    exported(Val).
+
+exported(Val) ->
+    [Val | local(Val)]. %% Non tail recursive local call
+
+local(Val) ->
+    [Val | local2(Val)]. %% Non tail recursive local call
+
+local2(Val) ->
+    local_tail(Val). %% Tail recursive call
+
+local_tail(Val) ->
+    [Val , erlang:hash(1,1)].
+
+
+
+%%% exc_slave/3 tracee target functions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+exc_top(ExcOpts, Func, Args) ->
+    case ExcOpts#exc_opts.nocatch of
+	false ->
+	    try exc_jump(Func, Args) of
+		Value ->
+		    {value,Value}
+	    catch
+		Class:Reason ->
+		    {Class,Reason}
+	    end;
+	true ->
+	    {value,exc_jump(Func, Args)}
+    end.
+
+%% x_* functions emulate the non-x_* ones.
+%% x_* functions below x_exc_top
+%% return {value,Value} or {Class,Reason}.
+%% The only possible place for exception
+%% is below exc/2.
+x_exc_top(ExcOpts, Func, Args) ->
+    ?line Rtt = not ExcOpts#exc_opts.meta,
+    ?line expect({ctt,{?MODULE,exc_top},[ExcOpts,Func,Args]}),
+    ?line case x_exc_jump(ExcOpts, Func, Args) of
+	      Result when not ExcOpts#exc_opts.nocatch ->
+		  ?line expect([Rtt,{rtt,{?MODULE,exc_top,3}},
+				?LINE,{rft,{?MODULE,exc_top,3},Result}]),
+		  ?line Result;
+	      {value,_}=Result ->
+		  
+		  ?line expect([Rtt,{rtt,{?MODULE,exc_top,3}},
+				?LINE,{rft,{?MODULE,exc_top,3},Result}]),
+		  ?line Result;
+	      {exit,Reason}=CR ->
+		  ?line expect({eft,{?MODULE,exc_top,3},CR}),
+		  ?line {crash,Reason};
+	      {error,Reason}=CR ->
+		  ?line expect({eft,{?MODULE,exc_top,3},CR}),
+		  ?line {crash,{Reason,x_exc_stacktrace()}};
+	      CR ->
+		  ?line expect({eft,{?MODULE,exc_top,3},CR}),
+		  ?line {crash,CR}
+	  end.
+
+exc_jump(Func, Args) ->
+    exc(Func, Args, jump).
+
+x_exc_jump(ExcOpts, Func, Args) ->
+    ?line expect({ctt,{?MODULE,exc_jump},[Func,Args]}),
+    ?line case x_exc(ExcOpts, Func, Args, jump) of
+	      {value,Value}=Result ->
+		  ?line expect({rft,{?MODULE,exc_jump,2},Value}),
+		  ?line Result;
+	      CR ->
+		  ?line expect({eft,{?MODULE,exc_jump,2},CR}),
+		  ?line CR
+	  end.
+
+exc(Func, Args, jump) ->
+    exc(Func, Args, do);
+exc(Func, Args, do) ->
+    exc(Func, Args).
+
+x_exc(ExcOpts, Func, Args, jump) ->
+    ?line expect({ctt,{?MODULE,exc},[Func,Args,jump]}),
+    ?line case x_exc(ExcOpts, Func, Args, do) of
+	      {value,Value}=Result ->
+		  ?line expect({rft,{?MODULE,exc,3},Value}),
+		  ?line Result;
+	      CR ->
+		  ?line expect({eft,{?MODULE,exc,3},CR}),
+		  ?line CR
+	  end;
+x_exc(ExcOpts, Func, Args, do) ->
+    ?line expect({ctt,{?MODULE,exc},[Func,Args,do]}),
+    ?line case x_exc(ExcOpts, Func, Args) of
+	      {value,Value}=Result ->
+		  ?line expect({rft,{?MODULE,exc,3},Value}),
+		  ?line Result;
+	      CR ->
+		  ?line expect({eft,{?MODULE,exc,3},CR}),
+		  ?line CR
+	  end.
+
+exc({erlang,apply}, [{M,F},A]) ->
+    erlang:apply(M, F, id(A));
+exc({erlang,apply}, [F,A]) ->
+    erlang:apply(F, id(A));
+exc({erlang,error}, [E]) ->
+    erlang:error(id(E));
+exc({erlang,error}, [E,S]) ->
+    erlang:error(E, id(S));
+exc({erlang,exit}, [E]) ->
+    erlang:exit(id(E));
+exc({erlang,throw}, [E]) ->
+    erlang:throw(id(E));
+exc({erlang,'++'}, [A,B]) ->
+    erlang:'++'(A, id(B));
+exc({?MODULE,match}, [A,B]) ->
+    match(A, id(B));
+exc({?MODULE,clause}, [A,B]) ->
+    clause(A, id(B));
+exc({?MODULE,id}, [E]) ->
+    id(id(E));
+exc({?MODULE,undef}, [E]) ->
+    undef(id(E));
+exc({?MODULE,lists_reverse}, [A,B]) ->
+    lists_reverse(A, id(B));
+exc(Func, [A,B]) when is_function(Func, 2) ->
+    Func(A, id(B)).
+
+x_exc(ExcOpts, {erlang,apply}=Func0, [{_,_}=Func,Args]=Args0) ->
+    ?line expect({ctt,{?MODULE,exc},[Func0,Args0]}),
+    ?line x_exc_body(ExcOpts, Func, Args, true);
+x_exc(ExcOpts, {erlang,apply}=Func0, [Func,Args]=Args0) 
+  when is_function(Func, 2)->
+    ?line expect({ctt,{?MODULE,exc},[Func0,Args0]}),
+    ?line x_exc_func(ExcOpts, Func, Args, Args);
+x_exc(ExcOpts, {_,_}=Func, Args) ->
+    ?line expect({ctt,{?MODULE,exc},[Func,Args]}),
+    ?line x_exc_body(ExcOpts, Func, Args, false);
+x_exc(ExcOpts, Func0, [_,Args]=Args0)
+  when is_function(Func0, 2) ->
+    ?line expect({ctt,{?MODULE,exc},[Func0,Args0]}),
+    ?line x_exc_func(ExcOpts, Func0, Args0, Args).
+
+x_exc_func(ExcOpts, Func, [Func1,Args1]=Args, Id) ->
+    %% Assumes the called fun =:= fun exc/2,
+    %% will utterly fail otherwise.
+    ?line Rtt = not ExcOpts#exc_opts.meta,
+    ?line {module,M} = erlang:fun_info(Func, module),
+    ?line {name,F} = erlang:fun_info(Func, name),
+    ?line expect([{ctt,{?MODULE,id},[Id]},
+		  ?LINE,{rft,{?MODULE,id,1},Id},
+		  ?LINE,Rtt,{rtt,{?MODULE,exc,2}},
+		  ?LINE,{ctt,{M,F},Args}]),
+    ?line case x_exc(ExcOpts, Func1, Args1) of
+	      {value,Value}=Result ->
+		  ?line expect([{rft,{M,F,2},Value},
+				?LINE,{rft,{?MODULE,exc,2},Value}]),
+		  ?line Result;
+	      CR ->
+		  ?line expect([{eft,{M,F,2},CR},
+				?LINE,{eft,{?MODULE,exc,2},CR}]),
+		  ?line CR
+	  end.
+
+x_exc_body(ExcOpts, {M,F}=Func, Args, Apply) ->
+    ?line Nocatch = ExcOpts#exc_opts.nocatch,
+    ?line Rtt = not ExcOpts#exc_opts.meta,
+    ?line Id = case Apply of
+		   true  -> Args;
+		   false -> lists:last(Args)
+	       end,
+    ?line expect([{ctt,{?MODULE,id},[Id]},
+		  ?LINE,{rft,{?MODULE,id,1},Id},
+		  ?LINE,Rtt,{rtt,{?MODULE,exc,2}},
+		  ?LINE,{ctt,{M,F},Args}]),
+    ?line Arity = length(Args),
+    ?line try exc(Func, Args) of
+	      Value ->
+		  ?line x_exc_value(Rtt, M, F, Args, Arity, Value),
+		  ?line case expect() of
+			    {rtt,{M,F,Arity}} when Rtt, Apply ->
+				%% We may get the above when
+				%% applying a BIF.
+				?line expect({rft,{?MODULE,exc,2},Value});
+			    {rtt,{?MODULE,exc,2}} when Rtt, not Apply ->
+				%% We may get the above when
+				%% calling a BIF.
+				?line expect({rft,{?MODULE,exc,2},Value});
+			    {rft,{?MODULE,exc,2},Value} ->
+				?line ok
+			end,
+		  ?line {value,Value}
+	  catch
+	      Thrown when Nocatch ->
+		  ?line CR = {error,{nocatch,Thrown}},
+		  ?line x_exc_exception(Rtt, M, F, Args, Arity, CR),
+		  ?line expect({eft,{?MODULE,exc,2},CR}),
+		  ?line CR;
+	      Class:Reason ->
+		  ?line CR = {Class,Reason},
+		  ?line x_exc_exception(Rtt, M, F, Args, Arity, CR),
+		  ?line expect({eft,{?MODULE,exc,2},CR}),
+		  ?line CR
+	  end.
+
+x_exc_value(Rtt, ?MODULE, lists_reverse, [La,Lb], 2, R) ->
+    ?line L = lists:reverse(Lb, La),
+    ?line expect([fun ({ctt,{lists,reverse},[L1,L2]}) ->
+			  ?line same(L, lists:reverse(L2, L1)),
+			  ?line next;
+		      (Msg) ->
+			  ?line same({rft,{lists,reverse,2},R}, Msg),
+			  ?line same(R, lists:reverse(L, [])),
+			  ?line done
+		  end,
+		  ?LINE,Rtt,{rtt,{?MODULE,lists_reverse,2}},
+		  ?LINE,{rft,{?MODULE,lists_reverse,2},R}]);
+x_exc_value(_Rtt, M, F, _, Arity, Value) ->
+    ?line expect({rft,{M,F,Arity},Value}).
+
+x_exc_exception(_Rtt, ?MODULE, lists_reverse, [La,Lb], 2, CR) ->
+    ?line L = lists:reverse(Lb, La),
+    ?line expect([fun ({ctt,{lists,reverse},[L1,L2]}) ->
+			  ?line same(L, lists:reverse(L2, L1)),
+			  ?line next;
+		      (Msg) ->
+			  ?line same({eft,{lists,reverse,2},CR}, Msg),
+			  ?line done
+		  end,
+		  ?LINE,{eft,{?MODULE,lists_reverse,2},CR}]);
+x_exc_exception(Rtt, ?MODULE, undef, [_], 1, {Class,Reason}=CR) ->
+    ?line expect([{ctt,{erlang,Class},[Reason]},
+		  ?LINE,{eft,{erlang,Class,1},CR},
+		  ?LINE,Rtt,{rtt,{error_handler,crash,1}},
+		  ?LINE,{eft,{?MODULE,undef,1},CR}]);
+x_exc_exception(_Rtt, M, F, _, Arity, CR) ->
+    ?line expect({eft,{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([H|T]) ->
+    [H|x_exc_stacktrace(T)].
+
+
+
+match(A, B) ->
+    A = B.
+
+clause(A, A) ->
+    A.
+
+id(Id) ->
+    Id.
+
+undef(X) ->
+    ?MODULE:undef(X, X). % undef
+
+lists_reverse(A, B) ->
+    lists:reverse(A, B).
+
+
+
+%%% Tracee (slave) handling %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+slave(Dest, Sync) ->
+    Dest ! Sync,
+    receive
+	{From,Tag,{apply,M,F,A}} when is_pid(From) ->
+	    ?line ?dbgformat("Apply: ~p:~p/~p (~p)~n",[M,F,length(A),A]),
+	    ?line Res = apply(M,F,A),
+	    ?line ?dbgformat("done Apply: ~p:~p/~p (~p)~n",[M,F,length(A),A]),
+	    From ! {Tag,Res},
+	    slave(From, Tag);
+	{From,Tag,{lambda,Fun}} when is_pid(From) ->
+	    Res = Fun(),
+	    From ! {Tag,Res},
+	    slave(From, Tag);
+	{From,Tag,{exc_top,Catch,Func,Args}} when is_pid(From) ->
+	    ?line ?dbgformat("Exc: ~p ~p~p ~n",[Catch,Func,Args]),
+	    ?line Res = exc_top(Catch, Func, Args),
+	    ?line ?dbgformat("done Exc: ~p ~p~p ~n",[Catch,Func,Args]),
+	    From ! {Tag,Res},
+	    slave(From,Tag);
+	die ->
+	    exit(normal)
+    end.
+
+setup(ProcFlags) ->
+    trace_off(),
+    flush(100),
+    Self = self(),
+    Sync = make_ref(),
+    Pid = spawn(fun () -> slave(Self, Sync) end),
+    Mref = erlang:monitor(process, Pid),
+    receive 
+	Sync ->
+	    put(slave, {Pid,Mref}),
+	    case ProcFlags of
+		[] -> ok;
+		_ ->
+		    erlang:trace(Pid, true, ProcFlags)
+	    end,
+	    Pid
+    end.
+
+shutdown() ->
+    trace_off(),
+    {Pid,Mref} = get(slave),
+    try erlang:is_process_alive(Pid) of
+	true ->
+	    Pid ! die,
+	    receive
+		{'DOWN',Mref,process,Pid,Reason} ->
+		    Reason
+	    end;
+	_ ->
+	    not_alive
+    catch _:_ ->
+	    undefined
+    end.
+
+trace_off() ->
+    erlang:trace_pattern({'_','_','_'},false,[]),
+    erlang:trace_pattern({'_','_','_'},false,[local]),
+    erlang:trace_pattern({'_','_','_'},false,[meta]),
+    erlang:trace(all, false, [all]).
+    
+
+apply_slave_async(M,F,A) ->
+    {Pid,Mref} = get(slave),
+    spawn(?MODULE,apply_slave_async,[M,F,A,Pid,Mref]),
+    Pid.
+
+apply_slave_async(M,F,A,Pid,Mref) ->
+    Tag = make_ref(),
+    Pid ! {self(),Tag,{apply,M,F,A}},
+    result(Tag, Mref).
+
+apply_slave(M,F,A) ->
+    request({apply,M,F,A}).
+
+lambda_slave(Fun) ->
+    request({lambda,Fun}).
+
+exc_slave(Opts, Func, Args) ->
+    try request({exc_top,Opts,Func,Args})
+    catch
+	Reason ->
+	    {crash,Reason}
+    end.
+
+request(Request) ->
+    Tag = make_ref(),
+    {Pid,Mref} = get(slave),
+    Pid ! {self(),Tag,Request},
+    result(Tag, Mref).
+
+result(Tag, Mref) ->
+    receive
+	{Tag,Result} ->
+	    receive
+		Tag ->
+		    Result
+	    end;
+	{'DOWN',Mref,process,_Pid,Reason} ->
+	    throw(Reason)
+    end.
+
+
+
+%%% Some receive helpers %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+receive_next() ->
+    receive_next(?DEFAULT_RECEIVE_TIMEOUT).
+
+receive_next(TO) ->
+    receive
+	M ->
+	    M
+    after TO ->
+	    ?t:fail(timeout)
+    end.
+
+receive_no_next(TO) ->
+    receive M ->
+	    ?t:fail({unexpected_message,[M|flush(TO)]})
+    after TO ->
+	    ok
+    end.
+
+flush(T) ->
+    receive
+	M ->
+	    [M|flush(T)]
+    after T ->
+	    []
+    end.
+
+
+
+%%% Helpers %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%
+
+%% Do not build garbage
+%%
+seq(M, N, R) when M =< N ->
+    seq(M, N-1, [N|R]);
+seq(_, _, R) -> R.
+
+%% Do not call traced lists:reverse
+reverse(L) ->
+    reverse(L, []).
+%%
+reverse([], R) -> R;
+reverse([H|T], R) ->
+    reverse(T, [H|R]).
+
+%% Abbreviate large complex terms to avoid croaking printout
+%%
+abbr(Term) ->
+    abbr(Term, 20).
+%%
+abbr(Tuple, N) when is_tuple(Tuple) ->
+    list_to_tuple(abbr_tuple(Tuple, N, 1));
+abbr(List, N) when is_list(List) ->
+    abbr_list(List, N, []);
+abbr(Term, _) -> Term.
+%%
+abbr_tuple(Tuple, N, J) when J =< size(Tuple) ->
+    if J > N; N =< 0 ->
+	    ['...'];
+       true ->
+	    [abbr(element(J, Tuple), N-1)|abbr_tuple(Tuple, J+1, N)]
+    end;
+abbr_tuple(_, _, _) ->
+    [].
+%%
+abbr_list(_, 0, R) ->
+    case io_lib:printable_list(R) of
+	true ->
+	    reverse(R, "...");
+	false ->
+	    reverse(R, '...')
+    end;
+abbr_list([H|T], N, R) ->
+    M = N-1,
+    abbr_list(T, M, [abbr(H, M)|R]);
+abbr_list(T, _, R) ->
+    reverse(R, T).