Merge branch 'maint'

Conflicts:
	erts/emulator/beam/beam_bp.c
	erts/emulator/beam/erl_process.c

4 files changed, 131 insertions, 43 deletions

diff --git a/erts/emulator/beam/beam_bp.c b/erts/emulator/beam/beam_bp.c
index 871670e8c3..fe1e15701b 100644
--- a/erts/emulator/beam/beam_bp.c
+++ b/erts/emulator/beam/beam_bp.c
@@ -641,6 +641,49 @@ erts_clear_export_break(Module* modp, ErtsCodeInfo *ci)
     ASSERT(ci->u.gen_bp == NULL);
 }
 
+/*
+ * If c_p->cp is a trace return instruction, we set cp
+ * to be the place where we again start to execute code.
+ *
+ * cp is used by match spec {caller} to get the calling
+ * function, and if we don't do this fixup it will be
+ * 'undefined'. This has the odd side effect of {caller}
+ * not really being which function is the caller, but
+ * rather which function we are about to return to.
+ */
+static void fixup_cp_before_trace(Process *c_p, int *return_to_trace)
+{
+    Eterm *cpp, *E = c_p->stop;
+    BeamInstr w = *c_p->cp;
+    if (BeamIsOpCode(w, op_return_trace)) {
+        cpp = &E[2];
+    } else if (BeamIsOpCode(w, op_i_return_to_trace)) {
+        *return_to_trace = 1;
+        cpp = &E[0];
+    } else if (BeamIsOpCode(w, op_i_return_time_trace)) {
+        cpp = &E[0];
+    } else {
+        cpp = NULL;
+    }
+    if (cpp) {
+        for (;;) {
+            BeamInstr w = *cp_val(*cpp);
+            if (BeamIsOpCode(w, op_return_trace)) {
+                cpp += 3;
+            } else if (BeamIsOpCode(w, op_i_return_to_trace)) {
+                *return_to_trace = 1;
+                cpp += 1;
+            } else if (BeamIsOpCode(w, op_i_return_time_trace)) {
+                cpp += 2;
+            } else {
+                break;
+            }
+        }
+        c_p->cp = (BeamInstr *) cp_val(*cpp);
+        ASSERT(is_CP(*cpp));
+    }
+}
+
 BeamInstr
 erts_generic_breakpoint(Process* c_p, ErtsCodeInfo *info, Eterm* reg)
 {
@@ -751,6 +794,7 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
     GenericBp* g;
     GenericBpData* bp = NULL;
     Uint bp_flags = 0;
+    int return_to_trace = 0;
 
     ERTS_CHK_HAVE_ONLY_MAIN_PROC_LOCK(p);
 
@@ -766,6 +810,8 @@ erts_bif_trace(int bif_index, Process* p, Eterm* args, BeamInstr* I)
      */
     if (!applying) {
 	p->cp = I;
+    } else {
+        fixup_cp_before_trace(p, &return_to_trace);
     }
     if (bp_flags & (ERTS_BPF_LOCAL_TRACE|ERTS_BPF_GLOBAL_TRACE) &&
 	IS_TRACED_FL(p, F_TRACE_CALLS)) {
@@ -944,49 +990,18 @@ static ErtsTracer
 do_call_trace(Process* c_p, ErtsCodeInfo* info, Eterm* reg,
 	      int local, Binary* ms, ErtsTracer tracer)
 {
-    Eterm* cpp;
     int return_to_trace = 0;
-    BeamInstr w;
     BeamInstr *cp_save = c_p->cp;
     Uint32 flags;
     Uint need = 0;
     Eterm* E = c_p->stop;
 
-    w = *c_p->cp;
-    if (BeamIsOpCode(w, op_return_trace)) {
-	cpp = &E[2];
-    } else if (BeamIsOpCode(w, op_i_return_to_trace)) {
-	return_to_trace = 1;
-	cpp = &E[0];
-    } else if (BeamIsOpCode(w, op_i_return_time_trace)) {
-	cpp = &E[0];
-    } else {
-	cpp = NULL;
-    }
-    if (cpp) {
-	for (;;) {
-	    BeamInstr w = *cp_val(*cpp);
-	    if (BeamIsOpCode(w, op_return_trace)) {
-		cpp += 3;
-	    } else if (BeamIsOpCode(w, op_i_return_to_trace)) {
-		return_to_trace = 1;
-		cpp += 1;
-            } else if (BeamIsOpCode(w, op_i_return_time_trace)) {
-		cpp += 2;
-	    } else {
-		break;
-	    }
-	}
-	cp_save = c_p->cp;
-	c_p->cp = (BeamInstr *) cp_val(*cpp);
-	ASSERT(is_CP(*cpp));
-    }
-    ERTS_UNREQ_PROC_MAIN_LOCK(c_p);
+    fixup_cp_before_trace(c_p, &return_to_trace);
+
     flags = erts_call_trace(c_p, info, ms, reg, local, &tracer);
-    ERTS_REQ_PROC_MAIN_LOCK(c_p);
-    if (cpp) {
-	c_p->cp = cp_save;
-    }
+
+    /* restore cp after potential fixup */
+    c_p->cp = cp_save;
 
     ASSERT(!ERTS_PROC_IS_EXITING(c_p));
     if ((flags & MATCH_SET_RETURN_TO_TRACE) && !return_to_trace) {
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 61fdf86a56..3d12b3bc21 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -12476,9 +12476,9 @@ send_exit_signal(Process *c_p,		/* current process if and only
 
     if ((state & ERTS_PSFLG_TRAP_EXIT)
 	&& (reason != am_kill || (flags & ERTS_XSIG_FLG_IGN_KILL))) {
-        /* have to release the status lock in order to send the exit message */
-        erts_proc_unlock(rp, *rp_locks & ERTS_PROC_LOCKS_XSIG_SEND);
-        *rp_locks &= ~ERTS_PROC_LOCKS_XSIG_SEND;
+        /* have to release the status and trace lock in order to send the exit message */
+        erts_proc_unlock(rp, *rp_locks & (ERTS_PROC_LOCKS_XSIG_SEND|ERTS_PROC_LOCK_TRACE));
+        *rp_locks &= ~(ERTS_PROC_LOCKS_XSIG_SEND|ERTS_PROC_LOCK_TRACE);
         if (have_seqtrace(token) && token_update)
 	    seq_trace_update_send(token_update);
 	if (is_value(exit_tuple))
diff --git a/erts/emulator/test/match_spec_SUITE.erl b/erts/emulator/test/match_spec_SUITE.erl
index 92ddc23592..08a7b4560c 100644
--- a/erts/emulator/test/match_spec_SUITE.erl
+++ b/erts/emulator/test/match_spec_SUITE.erl
@@ -21,7 +21,7 @@
 -module(match_spec_SUITE).
 
 -export([all/0, suite/0, not_run/1]).
--export([test_1/1, test_2/1, test_3/1, bad_match_spec_bin/1,
+-export([test_1/1, test_2/1, test_3/1, caller_and_return_to/1, bad_match_spec_bin/1,
 	 trace_control_word/1, silent/1, silent_no_ms/1, silent_test/1,
 	 ms_trace2/1, ms_trace3/1, ms_trace_dead/1, boxed_and_small/1,
 	 destructive_in_test_bif/1, guard_exceptions/1,
@@ -47,7 +47,7 @@ suite() ->
 all() -> 
     case test_server:is_native(match_spec_SUITE) of
 	false ->
-	    [test_1, test_2, test_3, bad_match_spec_bin,
+	    [test_1, test_2, test_3, caller_and_return_to, bad_match_spec_bin,
 	     trace_control_word, silent, silent_no_ms, silent_test, ms_trace2,
 	     ms_trace3, ms_trace_dead, boxed_and_small, destructive_in_test_bif,
 	     guard_exceptions, unary_plus, unary_minus, fpe,
@@ -180,6 +180,50 @@ test_3(Config) when is_list(Config) ->
     collect(P1, [{trace, P1, call, {?MODULE, f2, [a, b]}, [true]}]),
     ok.
 
+%% Test that caller and return to work as they should
+%% There was a bug where caller would be undefined when return_to was set
+%% for r the bif erlang:put().
+caller_and_return_to(Config) ->
+    tr(
+      fun do_put_wrapper/0,
+      fun (Tracee) ->
+              MsgCaller = [{'_',[],[{message,{caller}}]}],
+              1 = erlang:trace(Tracee, true, [call,return_to]),
+              1 = erlang:trace_pattern( {?MODULE,do_put,1}, MsgCaller, [local]),
+              1 = erlang:trace_pattern( {?MODULE,do_the_put,1}, MsgCaller, [local]),
+              1 = erlang:trace_pattern( {erlang,integer_to_list,1}, MsgCaller, [local]),
+              1 = erlang:trace_pattern( {erlang,put,2}, MsgCaller, [local]),
+
+              [{trace,Tracee,call,{?MODULE,do_put,[test]},{?MODULE,do_put_wrapper,0}},
+               {trace,Tracee,call,{?MODULE,do_the_put,[test]},{?MODULE,do_put,1}},
+               {trace,Tracee,call,{erlang,integer_to_list,[1]},{?MODULE,do_the_put,1}},
+               {trace,Tracee,return_to,{?MODULE,do_the_put,1}},
+               {trace,Tracee,call,{erlang,put,[test,"1"]},{?MODULE,do_put,1}},
+               {trace,Tracee,return_to,{?MODULE,do_put,1}},
+
+               %% These last trace messages are a bit strange...
+               %% if call tracing had been enabled for do_put_wrapper
+               %% then caller and return_to would have been {?MODULE,do_put_wrapper,1}
+               %% but since it is not, they are set to do_put instead, but we still
+               %% get the do_put_wrapper return_to message...
+               {trace,Tracee,call,{erlang,integer_to_list,[2]},{?MODULE,do_put,1}},
+               {trace,Tracee,return_to,{?MODULE,do_put,1}},
+               {trace,Tracee,return_to,{?MODULE,do_put_wrapper,0}}
+              ]
+      end),
+    ok.
+
+do_put_wrapper() ->
+    do_put(test),
+    ok.
+
+do_put(Var) ->
+    do_the_put(Var),
+    erlang:integer_to_list(id(2)).
+do_the_put(Var) ->
+    Lst = erlang:integer_to_list(id(1)),
+    erlang:put(Var, Lst).
+
 otp_9422(Config) when is_list(Config) ->
     Laps = 10000,
     Fun1 = fun() -> otp_9422_tracee() end,
diff --git a/erts/emulator/test/trace_SUITE.erl b/erts/emulator/test/trace_SUITE.erl
index 72acd33033..a81aa64057 100644
--- a/erts/emulator/test/trace_SUITE.erl
+++ b/erts/emulator/test/trace_SUITE.erl
@@ -38,7 +38,7 @@
 	 system_monitor_long_gc_1/1, system_monitor_long_gc_2/1, 
 	 system_monitor_large_heap_1/1, system_monitor_large_heap_2/1,
 	 system_monitor_long_schedule/1,
-	 bad_flag/1, trace_delivered/1]).
+	 bad_flag/1, trace_delivered/1, trap_exit_self_receive/1]).
 
 -include_lib("common_test/include/ct.hrl").
 
@@ -61,7 +61,8 @@ all() ->
      more_system_monitor_args, system_monitor_long_gc_1,
      system_monitor_long_gc_2, system_monitor_large_heap_1,
      system_monitor_long_schedule,
-     system_monitor_large_heap_2, bad_flag, trace_delivered].
+     system_monitor_large_heap_2, bad_flag, trace_delivered,
+     trap_exit_self_receive].
 
 init_per_testcase(_Case, Config) ->
     [{receiver,spawn(fun receiver/0)}|Config].
@@ -1709,6 +1710,31 @@ trace_delivered(Config) when is_list(Config) ->
               ok
     end.
 
+%% This testcase checks that receive trace works on exit signal messages
+%% when the sender of the exit signal is the process itself.
+trap_exit_self_receive(Config) ->
+    Parent = self(),
+    Proc = spawn_link(fun() -> process(Parent) end),
+
+    1 = erlang:trace(Proc, true, ['receive']),
+    Proc ! {trap_exit_please, true},
+    {trace, Proc, 'receive', {trap_exit_please, true}} = receive_first_trace(),
+
+    %% Make the process call exit(self(), signal)
+    Reason1 = make_ref(),
+    Proc ! {exit_signal_please, Reason1},
+    {trace, Proc, 'receive', {exit_signal_please, Reason1}} = receive_first_trace(),
+    {trace, Proc, 'receive', {'EXIT', Proc, Reason1}} = receive_first_trace(),
+    receive {Proc, {'EXIT', Proc, Reason1}} -> ok end,
+    receive_nothing(),
+
+    unlink(Proc),
+    Reason2 = make_ref(),
+    Proc ! {exit_please, Reason2},
+    {trace, Proc, 'receive', {exit_please, Reason2}} = receive_first_trace(),
+    receive_nothing(),
+    ok.
+
 drop_trace_until_down(Proc, Mon) ->
     drop_trace_until_down(Proc, Mon, false, 0, 0).
 
@@ -1791,6 +1817,9 @@ process(Dest) ->
             process(Dest);
         {exit_please, Reason} ->
             exit(Reason);
+        {exit_signal_please, Reason} ->
+            exit(self(), Reason),
+            process(Dest);
         {trap_exit_please, State} ->
             process_flag(trap_exit, State),
             process(Dest);