Merge pull request #1760 from jhogberg/john/erts/any-term-as-seq_trace-label/OTP-14899

Lift the type restrictions on seq_trace token labels

10 files changed, 116 insertions, 77 deletions

diff --git a/erts/emulator/beam/dist.c b/erts/emulator/beam/dist.c
index fdf307da1b..f203d85ca9 100644
--- a/erts/emulator/beam/dist.c
+++ b/erts/emulator/beam/dist.c
@@ -937,6 +937,24 @@ erts_dsig_send_demonitor(ErtsDSigData *dsdp, Eterm watcher,
     return res;
 }
 
+static int can_send_seqtrace_token(ErtsSendContext* ctx, Eterm token) {
+    Eterm label;
+
+    if (ctx->dep->flags & DFLAG_BIG_SEQTRACE_LABELS) {
+        /* The other end is capable of handling arbitrary seq_trace labels. */
+        return 1;
+    }
+
+    /* The other end only tolerates smalls, but since we could potentially be
+     * talking to an old 32-bit emulator from a 64-bit one, we have to check
+     * whether the label is small on any emulator. */
+    label = SEQ_TRACE_T_LABEL(token);
+
+    return is_small(label) &&
+        signed_val(label) <= (ERTS_SINT32_MAX >> _TAG_IMMED1_SIZE) &&
+        signed_val(label) >= (ERTS_SINT32_MIN >> _TAG_IMMED1_SIZE);
+}
+
 int
 erts_dsig_send_msg(Eterm remote, Eterm message, ErtsSendContext* ctx)
 {
@@ -970,37 +988,38 @@ erts_dsig_send_msg(Eterm remote, Eterm message, ErtsSendContext* ctx)
                       "%T", remote);
         msize = size_object(message);
         if (have_seqtrace(token)) {
-            tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
+            tok_label = SEQ_TRACE_T_DTRACE_LABEL(token);
             tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
         }
     }
 #endif
 
-    if (token != NIL) {
-        Eterm el1, el2;
-        if (ctx->dep->flags & DFLAG_SEND_SENDER) {
-            el1 = make_small(DOP_SEND_SENDER_TT);
-            el2 = sender->common.id;
-        }
-        else {
-            el1 = make_small(DOP_SEND_TT);
-            el2 = am_Empty;
-        }
-	ctl = TUPLE4(&ctx->ctl_heap[0], el1, el2, remote, token);
-    }
-    else {
-        Eterm el1, el2;
+    {
+        Eterm dist_op, sender_id;
+        int send_token;
+
+        send_token = (token != NIL && can_send_seqtrace_token(ctx, token));
+
         if (ctx->dep->flags & DFLAG_SEND_SENDER) {
-            el1 = make_small(DOP_SEND_SENDER);
-            el2 = sender->common.id;
+            dist_op = make_small(send_token ?
+                                 DOP_SEND_SENDER_TT :
+                                 DOP_SEND_SENDER);
+            sender_id = sender->common.id;
+        } else {
+            dist_op = make_small(send_token ?
+                                 DOP_SEND_TT :
+                                 DOP_SEND);
+            sender_id = am_Empty;
         }
-        else {
-            el1 = make_small(DOP_SEND);
-            el2 = am_Empty;
+
+        if (send_token) {
+            ctl = TUPLE4(&ctx->ctl_heap[0], dist_op, sender_id, remote, token);
+        } else {
+            ctl = TUPLE3(&ctx->ctl_heap[0], dist_op, sender_id, remote);
         }
-	ctl = TUPLE3(&ctx->ctl_heap[0], el1, el2, remote);
     }
+
     DTRACE6(message_send, sender_name, receiver_name,
             msize, tok_label, tok_lastcnt, tok_serial);
     DTRACE7(message_send_remote, sender_name, node_name, receiver_name,
@@ -1046,19 +1065,20 @@ erts_dsig_send_reg_msg(Eterm remote_name, Eterm message,
                       "{%T,%s}", remote_name, node_name);
         msize = size_object(message);
         if (have_seqtrace(token)) {
-            tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
+            tok_label = SEQ_TRACE_T_DTRACE_LABEL(token);
             tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
         }
     }
 #endif
 
-    if (token != NIL)
+    if (token != NIL && can_send_seqtrace_token(ctx, token))
 	ctl = TUPLE5(&ctx->ctl_heap[0], make_small(DOP_REG_SEND_TT),
 		     sender->common.id, am_Empty, remote_name, token);
     else
 	ctl = TUPLE4(&ctx->ctl_heap[0], make_small(DOP_REG_SEND),
 		     sender->common.id, am_Empty, remote_name);
+
     DTRACE6(message_send, sender_name, receiver_name,
             msize, tok_label, tok_lastcnt, tok_serial);
     DTRACE7(message_send_remote, sender_name, node_name, receiver_name,
@@ -1110,7 +1130,7 @@ erts_dsig_send_exit_tt(ErtsDSigData *dsdp, Eterm local, Eterm remote,
         erts_snprintf(reason_str, sizeof(DTRACE_CHARBUF_NAME(reason_str)),
                       "%T", reason);
         if (have_seqtrace(token)) {
-            tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
+            tok_label = SEQ_TRACE_T_DTRACE_LABEL(token);
             tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
         }
diff --git a/erts/emulator/beam/dist.h b/erts/emulator/beam/dist.h
index c608fef816..dda2029a4c 100644
--- a/erts/emulator/beam/dist.h
+++ b/erts/emulator/beam/dist.h
@@ -45,7 +45,8 @@
 #define DFLAG_MAP_TAG             0x20000
 #define DFLAG_BIG_CREATION        0x40000
 #define DFLAG_SEND_SENDER         0x80000
-#define DFLAG_NO_MAGIC            0x100000 /* internal for pending connection */
+#define DFLAG_BIG_SEQTRACE_LABELS 0x100000
+#define DFLAG_NO_MAGIC            0x200000 /* internal for pending connection */
 
 /* Mandatory flags for distribution */
 #define DFLAG_DIST_MANDATORY (DFLAG_EXTENDED_REFERENCES         \
@@ -73,7 +74,8 @@
                             | DFLAG_UTF8_ATOMS                \
                             | DFLAG_MAP_TAG                   \
                             | DFLAG_BIG_CREATION              \
-                            | DFLAG_SEND_SENDER)
+                            | DFLAG_SEND_SENDER               \
+                            | DFLAG_BIG_SEQTRACE_LABELS)
 
 /* Flags addable by local distr implementations */
 #define DFLAG_DIST_ADDABLE    DFLAG_DIST_DEFAULT
diff --git a/erts/emulator/beam/erl_bif_trace.c b/erts/emulator/beam/erl_bif_trace.c
index a076f0bf54..1953f79d79 100644
--- a/erts/emulator/beam/erl_bif_trace.c
+++ b/erts/emulator/beam/erl_bif_trace.c
@@ -1807,9 +1807,6 @@ Eterm erts_seq_trace(Process *p, Eterm arg1, Eterm arg2,
 	return old_value;
     }
     else if (arg1 == am_label) {
-	if (! is_small(arg2)) {
-	    return THE_NON_VALUE;
-	}
         new_seq_trace_token(p);
 	if (build_result) {
 	    old_value = SEQ_TRACE_TOKEN_LABEL(p);
diff --git a/erts/emulator/beam/erl_db_util.c b/erts/emulator/beam/erl_db_util.c
index 1e8e9e5e94..3836f28aa4 100644
--- a/erts/emulator/beam/erl_db_util.c
+++ b/erts/emulator/beam/erl_db_util.c
@@ -2508,25 +2508,20 @@ restart:
             if (have_no_seqtrace(SEQ_TRACE_TOKEN(c_p)))
 		*esp++ = NIL;
 	    else {
-		Eterm sender = SEQ_TRACE_TOKEN_SENDER(c_p);
-		Uint sender_sz = is_immed(sender) ? 0 : size_object(sender);
-		ehp = HAllocX(build_proc, 6 + sender_sz, HEAP_XTRA);
-		if (sender_sz) {
-		    sender = copy_struct(sender, sender_sz, &ehp, &MSO(build_proc));
-		}
- 		*esp++ = make_tuple(ehp);
- 		ehp[0] = make_arityval(5);
- 		ehp[1] = SEQ_TRACE_TOKEN_FLAGS(c_p);
- 		ehp[2] = SEQ_TRACE_TOKEN_LABEL(c_p);
- 		ehp[3] = SEQ_TRACE_TOKEN_SERIAL(c_p);
-		ehp[4] = sender;
- 		ehp[5] = SEQ_TRACE_TOKEN_LASTCNT(c_p);
-		ASSERT(SEQ_TRACE_TOKEN_ARITY(c_p) == 5);
-		ASSERT(is_immed(ehp[1]));
-		ASSERT(is_immed(ehp[2]));
-		ASSERT(is_immed(ehp[3]));
-		ASSERT(is_immed(ehp[5]));
-	    } 
+                Eterm token;
+                Uint token_sz;
+
+                ASSERT(SEQ_TRACE_TOKEN_ARITY(c_p) == 5);
+                ASSERT(is_immed(SEQ_TRACE_TOKEN_FLAGS(c_p)));
+                ASSERT(is_immed(SEQ_TRACE_TOKEN_SERIAL(c_p)));
+                ASSERT(is_immed(SEQ_TRACE_TOKEN_LASTCNT(c_p)));
+
+                token = SEQ_TRACE_TOKEN(c_p);
+                token_sz = size_object(token);
+
+                ehp = HAllocX(build_proc, token_sz, HEAP_XTRA);
+                *esp++ = copy_struct(token, token_sz, &ehp, &MSO(build_proc));
+	    }
 	    break;
         case matchEnableTrace:
             ASSERT(c_p == self);
diff --git a/erts/emulator/beam/erl_message.c b/erts/emulator/beam/erl_message.c
index 98feb95d99..51b7865c0b 100644
--- a/erts/emulator/beam/erl_message.c
+++ b/erts/emulator/beam/erl_message.c
@@ -315,7 +315,7 @@ erts_queue_dist_message(Process *rcvr,
 
             dtrace_proc_str(rcvr, receiver_name);
             if (have_seqtrace(token)) {
-                tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
+                tok_label = SEQ_TRACE_T_DTRACE_LABEL(token);
                 tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
                 tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
             }
@@ -640,7 +640,8 @@ erts_send_message(Process* sender,
 	    seq_trace_update_send(sender);
 	    seq_trace_output(stoken, message, SEQ_TRACE_SEND,
 			     receiver->common.id, sender);
-	    seq_trace_size = 6; /* TUPLE5 */
+
+	    seq_trace_size = size_object(stoken);
 	}
 #ifdef USE_VM_PROBES
         if (DT_UTAG_FLAGS(sender) & DT_UTAG_SPREADING) {
@@ -689,7 +690,7 @@ erts_send_message(Process* sender,
 	}
         if (DTRACE_ENABLED(message_send)) {
             if (have_seqtrace(stoken)) {
-		tok_label = signed_val(SEQ_TRACE_T_LABEL(stoken));
+                tok_label = SEQ_TRACE_T_DTRACE_LABEL(stoken);
 		tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(stoken));
 		tok_serial = signed_val(SEQ_TRACE_T_SERIAL(stoken));
 	    }
diff --git a/erts/emulator/beam/erl_proc_sig_queue.c b/erts/emulator/beam/erl_proc_sig_queue.c
index 99d20e9242..1ba0b789ec 100644
--- a/erts/emulator/beam/erl_proc_sig_queue.c
+++ b/erts/emulator/beam/erl_proc_sig_queue.c
@@ -3223,7 +3223,7 @@ handle_message_enqueued_tracing(Process *c_p,
         Eterm seq_trace_token = ERL_MESSAGE_TOKEN(msg);
 
         if (seq_trace_token != NIL && is_tuple(seq_trace_token)) {
-            tok_label = signed_val(SEQ_TRACE_T_LABEL(seq_trace_token));
+            tok_label = SEQ_TRACE_T_DTRACE_LABEL(seq_trace_token);
             tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(seq_trace_token));
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(seq_trace_token));
         }
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index 0550fb05b5..256b8b7d16 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -1250,7 +1250,24 @@ void erts_check_for_holes(Process* p);
 #define SEQ_TRACE_T_SENDER(token)   (*(tuple_val(token) + 4))
 #define SEQ_TRACE_T_LASTCNT(token)  (*(tuple_val(token) + 5))
 
+#ifdef USE_VM_PROBES
+/* The dtrace probe for seq_trace only supports 'int' labels, so we represent
+ * all values that won't fit into a 32-bit signed integer as ERTS_SINT32_MIN
+ * (bigints, tuples, etc). */
+
+#define SEQ_TRACE_T_DTRACE_LABEL(token) \
+    DTRACE_SEQ_TRACE_LABEL__(SEQ_TRACE_T_LABEL(token))
+
+#define DTRACE_SEQ_TRACE_LABEL__(label_term) \
+    (is_small((label_term)) ? \
+        ((signed_val((label_term)) <= ERTS_SINT32_MAX && \
+          signed_val((label_term)) >= ERTS_SINT32_MIN) ? \
+             signed_val((label_term)) : ERTS_SINT32_MIN) \
+        : ERTS_SINT32_MIN)
+#endif
+
 /*
+
  * Possible flags for the flags field in ErlSpawnOpts below.
  */
 
diff --git a/erts/emulator/beam/erlang_dtrace.d b/erts/emulator/beam/erlang_dtrace.d
index d0b10e0306..c47a37eb62 100644
--- a/erts/emulator/beam/erlang_dtrace.d
+++ b/erts/emulator/beam/erlang_dtrace.d
@@ -55,7 +55,8 @@ provider erlang {
      * @param sender the PID (string form) of the sender
      * @param receiver the PID (string form) of the receiver
      * @param size the size of the message being delivered (words)
-     * @param token_label for the sender's sequential trace token
+     * @param token_label for the sender's sequential trace token. This will be
+     *        INT_MIN if the label does not fit into a 32-bit integer.
      * @param token_previous count for the sender's sequential trace token
      * @param token_current count for the sender's sequential trace token
      */
@@ -73,7 +74,8 @@ provider erlang {
      * @param node_name the Erlang node name (string form) of the receiver
      * @param receiver the PID/name (string form) of the receiver
      * @param size the size of the message being delivered (words)
-     * @param token_label for the sender's sequential trace token
+     * @param token_label for the sender's sequential trace token. This will be
+     *        INT_MIN if the label does not fit into a 32-bit integer.
      * @param token_previous count for the sender's sequential trace token
      * @param token_current count for the sender's sequential trace token
      */
@@ -98,7 +100,8 @@ provider erlang {
      * @param receiver the PID (string form) of the receiver
      * @param size the size of the message being delivered (words)
      * @param queue_len length of the queue of the receiving process
-     * @param token_label for the sender's sequential trace token
+     * @param token_label for the sender's sequential trace token. This will be
+     *        INT_MIN if the label does not fit into a 32-bit integer.
      * @param token_previous count for the sender's sequential trace token
      * @param token_current count for the sender's sequential trace token
      */
@@ -122,7 +125,8 @@ provider erlang {
      * @param receiver the PID (string form) of the receiver
      * @param size the size of the message being delivered (words)
      * @param queue_len length of the queue of the receiving process
-     * @param token_label for the sender's sequential trace token
+     * @param token_label for the sender's sequential trace token. This will be
+     *        INT_MIN if the label does not fit into a 32-bit integer.
      * @param token_previous count for the sender's sequential trace token
      * @param token_current count for the sender's sequential trace token
      */
@@ -273,7 +277,8 @@ provider erlang {
      * @param node_name the Erlang node name (string form) of the receiver
      * @param receiver the PID (string form) of the process receiving EXIT signal
      * @param reason the reason for the exit (may be truncated)
-     * @param token_label for the sender's sequential trace token
+     * @param token_label for the sender's sequential trace token. This will be
+     *        INT_MIN if the label does not fit into a 32-bit integer.
      * @param token_previous count for the sender's sequential trace token
      * @param token_current count for the sender's sequential trace token
      */
diff --git a/erts/emulator/beam/msg_instrs.tab b/erts/emulator/beam/msg_instrs.tab
index 6055e35717..289436da6f 100644
--- a/erts/emulator/beam/msg_instrs.tab
+++ b/erts/emulator/beam/msg_instrs.tab
@@ -229,7 +229,7 @@ remove_message() {
         dtrace_proc_str(c_p, receiver_name);
         token2 = SEQ_TRACE_TOKEN(c_p);
         if (have_seqtrace(token2)) {
-            tok_label = signed_val(SEQ_TRACE_T_LABEL(token2));
+            tok_label = SEQ_TRACE_T_DTRACE_LABEL(token2);
             tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token2));
             tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token2));
         }
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index c21acadd8d..be6ab57eeb 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -366,29 +366,11 @@ typedef UWord BeamInstr;
 #    define HAVE_INT64 1
 typedef unsigned long Uint64;
 typedef long          Sint64;
-#    ifdef ULONG_MAX
-#      define ERTS_UINT64_MAX ULONG_MAX
-#    endif
-#    ifdef LONG_MAX
-#      define ERTS_SINT64_MAX LONG_MAX
-#    endif
-#    ifdef LONG_MIN
-#      define ERTS_SINT64_MIN LONG_MIN
-#    endif
 #    define ErtsStrToSint64 strtol
 #  elif SIZEOF_LONG_LONG == 8
 #    define HAVE_INT64 1
 typedef unsigned long long Uint64;
 typedef long long          Sint64;
-#    ifdef ULLONG_MAX
-#      define ERTS_UINT64_MAX ULLONG_MAX
-#    endif
-#    ifdef LLONG_MAX
-#      define ERTS_SINT64_MAX LLONG_MAX
-#    endif
-#    ifdef LLONG_MIN
-#      define ERTS_SINT64_MIN LLONG_MIN
-#    endif
 #    define ErtsStrToSint64 strtoll
 #  else
 #    error "No 64-bit integer type found"
@@ -402,7 +384,7 @@ typedef long long          Sint64;
 #  define ERTS_SINT64_MAX ((Sint64) ((((Uint64) 1) << 63)-1))
 #endif
 #ifndef ERTS_SINT64_MIN
-#  define ERTS_SINT64_MIN (-1*(((Sint64) 1) << 63))
+#  define ERTS_SINT64_MIN ((Sint64) ((((Uint64) 1) << 63)))
 #endif
 
 #if SIZEOF_LONG == 4
@@ -415,6 +397,16 @@ typedef int          Sint32;
 #error Found no appropriate type to use for 'Uint32' and 'Sint32'
 #endif
 
+#ifndef ERTS_UINT32_MAX
+#  define ERTS_UINT32_MAX (~((Uint32) 0))
+#endif
+#ifndef ERTS_SINT32_MAX
+#  define ERTS_SINT32_MAX ((Sint32) ((((Uint32) 1) << 31)-1))
+#endif
+#ifndef ERTS_SINT32_MIN
+#  define ERTS_SINT32_MIN ((Sint32) ((((Uint32) 1) << 31)))
+#endif
+
 #if SIZEOF_INT == 2
 typedef unsigned int Uint16;
 typedef int          Sint16;
@@ -425,6 +417,16 @@ typedef short          Sint16;
 #error Found no appropriate type to use for 'Uint16' and 'Sint16'
 #endif
 
+#ifndef ERTS_UINT16_MAX
+#  define ERTS_UINT16_MAX (~((Uint16) 0))
+#endif
+#ifndef ERTS_SINT16_MAX
+#  define ERTS_SINT16_MAX ((Sint16) ((((Uint16) 1) << 15)-1))
+#endif
+#ifndef ERTS_SINT16_MIN
+#  define ERTS_SINT16_MIN ((Sint16) ((((Uint16) 1) << 15)))
+#endif
+
 #if CHAR_BIT == 8
 typedef unsigned char byte;
 #else