File 1781-Tracing-Add-new-option-caller_line-for-fun... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1781-Tracing-Add-new-option-caller_line-for-fun-match-spe.patch of Package erlang (Revision e3704281f725978c5a26174cd59024d0)

Currently displaying revision e3704281f725978c5a26174cd59024d0 , Show latest

From 34659f0d2bbd05641dc72e41b8338d528bc75751 Mon Sep 17 00:00:00 2001
From: Sidharth Kshatriya <sid.kshatriya@gmail.com>
Date: Mon, 25 Oct 2021 14:08:13 +0530
Subject: [PATCH] Tracing: Add new option `caller_line` for fun match spec body

This is similar to `caller`. `caller` gives you {M, F, Arity} while
`caller_line` gives you {M, F, Arity, {File, Line}} where
File:Line is the source location of the function call site.

If the location cannot be found you will get {M, F, Arity, undefined}.

Also:
- Add documentation for `caller_line` in match specifications
- Add `caller_line` tests to match spec suite
---
 erts/doc/src/match_spec.xml             | 19 ++++++
 erts/emulator/beam/atom.names           |  1 +
 erts/emulator/beam/erl_db_util.c        | 77 +++++++++++++++++++++-
 erts/emulator/test/match_spec_SUITE.erl | 86 ++++++++++++++++++++++++-
 4 files changed, 178 insertions(+), 5 deletions(-)

diff --git a/erts/doc/src/match_spec.xml b/erts/doc/src/match_spec.xml
index ca8a1146b3..45969f3b7c 100644
--- a/erts/doc/src/match_spec.xml
+++ b/erts/doc/src/match_spec.xml
@@ -140,6 +140,7 @@
 <c><![CDATA[process_dump]]></c> | <c><![CDATA[enable_trace]]></c> |
 <c><![CDATA[disable_trace]]></c> | <c><![CDATA[trace]]></c> |
 <c><![CDATA[display]]></c> | <c><![CDATA[caller]]></c> |
+ <c><![CDATA[caller_line]]></c> |
 <c><![CDATA[set_tcw]]></c> | <c><![CDATA[silent]]></c>
 </item>
 </list>
@@ -438,6 +439,24 @@
 <c><![CDATA[undefined]]></c>. The calling
 Erlang function is not available during such calls.
 </item>
+ <tag><c>caller_line</c></tag>
+ <item>
+ Similar to <c>caller</c> but returns additional information about
+ the source code location of the function call-site within the
+ caller function. Returns the calling function as a tuple
+ <c>{Module, Function, Arity, {File, Line}}</c>. <c>File</c> is the
+ <seeguide marker="system/reference_manual:data_types#string">string</seeguide>
+ file name while <c>Line</c> is source line number. If the <c>File</c>
+ and <c>Line</c> cannot be determined, <c>{Module, Function, Arity, undefined}</c>
+ is returned. If the calling function cannot be determined, the atom
+ <c><![CDATA[undefined]]></c> is returned. Can only be used in the
+ <c><![CDATA[MatchBody]]></c> part when tracing.
+ Notice that if a "technically built in function" (that is, a
+ function not written in Erlang) is traced, the
+ <c><![CDATA[caller_line]]></c> function sometimes returns the atom
+ <c><![CDATA[undefined]]></c>. The calling
+ Erlang function is not available during such calls.
+ </item>
 <tag><c>display</c></tag>
 <item>
 For debugging purposes only. Displays the single argument as an
diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 8bb1717337..22076db963 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -159,6 +159,7 @@ atom call_count
 atom call_error_handler
 atom call_time
 atom caller
+atom caller_line
 atom capture
 atom case_clause
 atom caseless
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index d3a0a153e5..840228e854 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -293,7 +293,8 @@ typedef enum {
 matchSilent,
 matchSetSeqTokenFake,
 matchTrace2,
- matchTrace3
+ matchTrace3,
+ matchCallerLine,
 } MatchOps;
 
 /*
@@ -2041,6 +2042,7 @@ Eterm db_prog_match(Process *c_p,
 Eterm *esp;
 MatchVariable* variables;
 const ErtsCodeMFA *cp;
+ FunctionInfo fi;
 const UWord *pc = prog->text;
 Eterm *ehp;
 Eterm ret;
@@ -2749,6 +2751,47 @@ restart:
 		ehp[3] = make_small((Uint) cp->arity);
 	 }
 	 break;
+ case matchCallerLine:
+ ASSERT(c_p == self);
+
+ /* Note that we can't use `erts_inspect_frame` here as the top of
+ * the stack could point at something other than a frame. */
+ if (erts_frame_layout == ERTS_FRAME_LAYOUT_RA) {
+ t = c_p->stop[0];
+ } else {
+ ASSERT(erts_frame_layout == ERTS_FRAME_LAYOUT_FP_RA);
+ t = c_p->stop[1];
+ }
+
+ if (is_not_CP(t)) {
+ *esp++ = am_undefined;
+ break;
+ }
+
+ erts_lookup_function_info(&fi, cp_val(t), 1);
+ if (!fi.mfa) {
+ *esp++ = am_undefined;
+ } else {
+ if (fi.loc == LINE_INVALID_LOCATION) {
+ ehp = HAllocX(build_proc, 5, HEAP_XTRA);
+ } else {
+ ehp = HAllocX(build_proc, 8, HEAP_XTRA);
+ }
+ *esp++ = make_tuple(ehp);
+ ehp[0] = make_arityval(4);
+ ehp[1] = fi.mfa->module;
+ ehp[2] = fi.mfa->function;
+ ehp[3] = make_small((Uint) fi.mfa->arity);
+ if (fi.loc == LINE_INVALID_LOCATION) {
+ ehp[4] = am_undefined;
+ } else {
+ ehp[4] = make_tuple(&ehp[5]);
+ ehp[5] = make_arityval(2);
+ ehp[6] = fi.fname_ptr[LOC_FILE(fi.loc)];
+ ehp[7] = make_small(LOC_LINE(fi.loc));
+ }
+ }
+ break;
 case matchSilent:
 ASSERT(c_p == self);
 	 --esp;
@@ -4893,8 +4936,30 @@ static DMCRet dmc_caller(DMCContext *context,
 return retOk;
 }
 
+static DMCRet dmc_caller_line(DMCContext *context,
+ DMCHeap *heap,
+ DMC_STACK_TYPE(UWord) *text,
+ Eterm t,
+ int *constant)
+{
+ Eterm *p = tuple_val(t);
+ DMCRet ret;
+
+ if (!check_trace("caller_line", context, constant,
+ (DCOMP_CALL_TRACE|DCOMP_ALLOW_TRACE_OPS), 0, &ret))
+ return ret;
+
+ if (p[0] != make_arityval(1)) {
+ RETURN_TERM_ERROR("Special form 'caller_line' called with "
+ "arguments in %T.", t, context, *constant);
+ }
+ *constant = 0;
+ DMC_PUSH(*text, matchCallerLine); /* Creates binary */
+ if (++context->stack_used > context->stack_need)
+ context->stack_need = context->stack_used;
+ return retOk;
+}
 
- 
 static DMCRet dmc_silent(DMCContext *context,
 			 DMCHeap *heap,
 			 DMC_STACK_TYPE(UWord) *text,
@@ -4980,7 +5045,9 @@ static DMCRet dmc_fun(DMCContext *context,
 case am_trace:
 	return dmc_trace(context, heap, text, t, constant);
 case am_caller:
- 	return dmc_caller(context, heap, text, t, constant);
+	return dmc_caller(context, heap, text, t, constant);
+ case am_caller_line:
+	return dmc_caller_line(context, heap, text, t, constant);
 case am_silent:
 	return dmc_silent(context, heap, text, t, constant);
 case am_set_tcw:
@@ -6045,6 +6112,10 @@ void db_match_dis(Binary *bp)
 	 ++t;
 	 erts_printf("Caller\n");
 	 break;
+	case matchCallerLine:
+	 ++t;
+	 erts_printf("CallerLine\n");
+	 break;
 	default:
 	 erts_printf("??? (0x%bpx)\n", *t);
 	 ++t;
diff --git a/erts/emulator/test/match_spec_SUITE.erl b/erts/emulator/test/match_spec_SUITE.erl
index 75aae473bd..913bf3736e 100644
--- a/erts/emulator/test/match_spec_SUITE.erl
+++ b/erts/emulator/test/match_spec_SUITE.erl
@@ -21,7 +21,8 @@
 -module(match_spec_SUITE).
 
 -export([all/0, suite/0]).
--export([test_1/1, test_2/1, test_3/1, caller_and_return_to/1, bad_match_spec_bin/1,
+-export([test_1/1, test_2/1, test_3/1, test_4a/1, test_4b/1, test_5a/1,
+ test_5b/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,
@@ -34,6 +35,7 @@
 -export([runner/2, loop_runner/3]).
 -export([f1/1, f2/2, f3/2, fn/1, fn/2, fn/3]).
 -export([do_boxed_and_small/0]).
+-export([f1_test4/1, f2_test4/2, f3_test4/2]).
 
 % This test suite assumes that tracing in general works. What we test is
 % the match spec functionality.
@@ -45,7 +47,7 @@ suite() ->
 {timetrap, {minutes, 1}}].
 
 all() ->
- [test_1, test_2, test_3, caller_and_return_to, bad_match_spec_bin,
+ [test_1, test_2, test_3, test_4a, test_4b, test_5a, test_5b, 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,
@@ -173,6 +175,64 @@ test_3(Config) when is_list(Config) ->
 collect(P1, [{trace, P1, call, {?MODULE, f2, [a, b]}, [true]}]),
 ok.
 
+%% Test `caller_line` trace with `call` and `global`
+test_4a(Config) when is_list(Config) ->
+ Fun = fun() -> ?MODULE:f3_test4(a, b) end,
+ Pat = [{'_', [],[{message, {caller_line}}]}],
+ P = spawn(?MODULE, runner, [self(), Fun]),
+ erlang:trace(P, true, [call]),
+ %% `global` is implied but we still mention explictly
+ erlang:trace_pattern({?MODULE, f2_test4, 2}, Pat, [global]),
+ erlang:trace_pattern({?MODULE, f1_test4, 1}, Pat, [global]),
+ collect(P, [{trace, P, call, {?MODULE, f2_test4, [a, b]}, {?MODULE, f3_test4, 2, {"test4.erl", 3}}},
+ {trace, P, call, {?MODULE, f1_test4, [a]}, {?MODULE, f3_test4, 2, {"test4.erl", 3}}}]),
+ ok.
+
+%% Test `caller_line` trace with `return_trace`, `call` and `global`
+test_4b(Config) when is_list(Config) ->
+ Fun = fun() -> ?MODULE:f3_test4(a, b) end,
+ P = spawn(?MODULE, runner, [self(), Fun]),
+ Pat = [{'_', [], [{return_trace}, {message, {caller_line}}]}],
+ erlang:trace(P, true, [call]),
+ %% `global` is implied but we still mention explictly
+ erlang:trace_pattern({?MODULE, f2_test4, 2}, Pat, [global]),
+ erlang:trace_pattern({?MODULE, f1_test4, 1}, Pat, [global]),
+ collect(P, [{trace, P, call, {?MODULE, f2_test4, [a, b]}, {?MODULE, f3_test4, 2, {"test4.erl", 3}}},
+ {trace, P, call, {?MODULE, f1_test4, [a]}, {?MODULE, f3_test4, 2, {"test4.erl", 3}}},
+ {trace, P, return_from, {?MODULE, f1_test4, 1}, {a}},
+ {trace, P, return_from, {?MODULE, f2_test4, 2}, {a}}
+ ]),
+ ok.
+
+%% Test `caller_line` trace with `call` and `local`
+test_5a(Config) when is_list(Config) ->
+ Fun = fun() -> f3_test5(a, b) end,
+ Pat = [{'_', [],[{message, {caller_line}}]}],
+ P = spawn(?MODULE, runner, [self(), Fun]),
+ erlang:trace(P, true, [call]),
+ %% Notice `local` function tracing
+ erlang:trace_pattern({?MODULE, f2_test5, 2}, Pat, [local]),
+ erlang:trace_pattern({?MODULE, f1_test5, 1}, Pat, [local]),
+ collect(P, [{trace, P, call, {?MODULE, f2_test5, [a, b]}, {?MODULE, f3_test5, 2, {"test5.erl", 3}}},
+ {trace, P, call, {?MODULE, f1_test5, [a]}, {?MODULE, f3_test5, 2, {"test5.erl", 3}}}]),
+ ok.
+
+%% Test `caller_line` trace with `return_trace`, `call` and `local`
+test_5b(Config) when is_list(Config) ->
+ Fun = fun() -> f3_test5(a, b) end,
+ P = spawn(?MODULE, runner, [self(), Fun]),
+ Pat = [{'_', [], [{return_trace}, {message, {caller_line}}]}],
+ erlang:trace(P, true, [call]),
+ %% Notice `local` function tracing
+ erlang:trace_pattern({?MODULE, f2_test5, 2}, Pat, [local]),
+ erlang:trace_pattern({?MODULE, f1_test5, 1}, Pat, [local]),
+ collect(P, [{trace, P, call, {?MODULE, f2_test5, [a, b]}, {?MODULE, f3_test5, 2, {"test5.erl", 3}}},
+ {trace, P, call, {?MODULE, f1_test5, [a]}, {?MODULE, f3_test5, 2, {"test5.erl", 3}}},
+ {trace, P, return_from, {?MODULE, f1_test5, 1}, {a}},
+ {trace, P, return_from, {?MODULE, f2_test5, 2}, {a}}
+ ]),
+ 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().
@@ -1152,3 +1212,25 @@ start_node(Name) ->
 
 id(X) ->
 X.
+
+-file("test4.erl", 1).
+f3_test4(X,Y) ->
+ ?MODULE:f2_test4(X,Y), % Line 3 - This line number should remain stable
+ ok.
+
+f2_test4(X, _) ->
+ ?MODULE:f1_test4(X).
+
+f1_test4(X) ->
+ {X}.
+
+-file("test5.erl", 1).
+f3_test5(X,Y) ->
+ f2_test5(X,Y), % Line 3 - This line number should remain stable
+ ok.
+
+f2_test5(X, _) ->
+ f1_test5(X).
+
+f1_test5(X) ->
+ {X}.
-- 
2.31.1

Places

File 1781-Tracing-Add-new-option-caller_line-for-fun-match-spe.patch of Package erlang (Revision e3704281f725978c5a26174cd59024d0)

Places