Add RefData, fix STM32 tests

Signed-off-by: Mateusz Front <[email protected]>

Author: mat-hek

src/libAtomVM/nifs.c

@@ -1142,7 +1142,7 @@ static NativeHandlerResult process_console_message(Context *ctx, term msg)
 {
     // msg is not in the port's heap
     NativeHandlerResult result = NativeContinue;
-    if (UNLIKELY(memory_ensure_free_opt(ctx, 12, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+    if (UNLIKELY(memory_ensure_free_opt(ctx, 13, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
         fprintf(stderr, "Unable to allocate sufficient memory for console driver.\n");
         AVM_ABORT();
     }
@@ -1160,7 +1160,7 @@ static NativeHandlerResult process_console_message(Context *ctx, term msg)
         term pid = term_get_tuple_element(msg, 1);
         term ref = term_get_tuple_element(msg, 2);
         term req = term_get_tuple_element(msg, 3);
-        uint64_t ref_ticks = term_to_ref_ticks(ref);
+        RefData ref_data = term_to_ref_data(ref);
 
         if (is_tagged_tuple(req, PUT_CHARS_ATOM, 3)) {
             term chars = term_get_tuple_element(req, 2);
@@ -1170,7 +1170,7 @@ static NativeHandlerResult process_console_message(Context *ctx, term msg)
                 printf("%s", str);
                 free(str);
 
-                term refcopy = term_from_ref_ticks(ref_ticks, &ctx->heap);
+                term refcopy = term_from_ref_data(ref_data, &ctx->heap);
 
                 term reply = term_alloc_tuple(3, &ctx->heap);
                 term_put_tuple_element(reply, 0, IO_REPLY_ATOM);

src/libAtomVM/term.h

@@ -152,7 +152,10 @@ extern "C" {
 #define BOXED_FUN_SIZE 3
 #define FLOAT_SIZE (sizeof(float_term_t) / sizeof(term) + 1)
 #define REF_SIZE ((int) ((sizeof(uint64_t) / sizeof(term)) + 1))
-#define TERM_BOXED_PROCESS_REF_SIZE (REF_SIZE + 1)
+// FIXME: The required size is REF_SIZE + 1, but then it's equal to
+// TERM_BOXED_REFERENCE_RESOURCE_SIZE on 32bit arch, and therefore
+// the process ref is indistinguishable from resource ref there
+#define TERM_BOXED_PROCESS_REF_SIZE 5
 #define TERM_BOXED_PROCESS_REF_HEADER (((TERM_BOXED_PROCESS_REF_SIZE - 1) << 6) | TERM_BOXED_REF)
 #if TERM_BYTES == 8
 #define EXTERNAL_PID_SIZE 3
@@ -248,6 +251,14 @@ extern "C" {
 typedef struct GlobalContext GlobalContext;
 #endif
 
+typedef struct RefData RefData;
+
+struct RefData
+{
+    uint64_t ref_ticks;
+    int32_t process_id;
+};
+
 typedef struct PrinterFun PrinterFun;
 
 typedef int (*printer_function_t)(PrinterFun *fun, const char *fmt, ...) PRINTF_FORMAT_ARGS(2, 3);
@@ -1999,7 +2010,7 @@ static inline term term_make_process_reference(int32_t process_id, uint64_t ref_
     boxed_value[0] = TERM_BOXED_PROCESS_REF_HEADER;
 
 #if TERM_BYTES == 4
-    boxed_value[1] = (ref_ticks >> 4);
+    boxed_value[1] = (ref_ticks >> 32);
     boxed_value[2] = (ref_ticks & 0xFFFFFFFF);
     boxed_value[3] = process_id;
 
@@ -2027,6 +2038,23 @@ static inline uint32_t term_process_ref_to_process_id(term rt)
 #endif
 }
 
+static inline RefData term_to_ref_data(term t)
+{
+    RefData ref_data;
+    ref_data.ref_ticks = term_to_ref_ticks(t);
+    ref_data.process_id = term_is_process_reference(t) ? term_process_ref_to_process_id(t) : 0;
+    return ref_data;
+}
+
+static inline term term_from_ref_data(RefData ref_data, Heap *heap)
+{
+    if (ref_data.process_id) {
+        return term_make_process_reference(ref_data.process_id, ref_data.ref_ticks, heap);
+    } else {
+        return term_from_ref_ticks(ref_data.ref_ticks, heap);
+    }
+}
+
 /**
  * @brief Make an external pid term from node, process_id, serial and creation
  *

src/platforms/esp32/components/avm_builtins/network_driver.c

@@ -58,7 +58,7 @@
 #define TCPIP_HOSTNAME_MAX_SIZE 255
 
 #define TAG "network_driver"
-#define PORT_REPLY_SIZE (TUPLE_SIZE(2) + REF_SIZE)
+#define PORT_REPLY_SIZE (TUPLE_SIZE(2) + TERM_BOXED_PROCESS_REF_SIZE)
 
 static const char *const ap_atom = ATOM_STR("\x2", "ap");
 static const char *const ap_channel_atom = ATOM_STR("\xA", "ap_channel");
@@ -110,7 +110,7 @@ struct ClientData
     GlobalContext *global;
     uint32_t port_process_id;
     uint32_t owner_process_id;
-    uint64_t ref_ticks;
+    RefData ref_data;
 };
 
 static inline term make_atom(GlobalContext *global, AtomString atom_str)
@@ -131,7 +131,7 @@ static term tuple_from_addr(Heap *heap, uint32_t addr)
 
 static void send_term(Heap *heap, struct ClientData *data, term t)
 {
-    term ref = term_from_ref_ticks(data->ref_ticks, heap);
+    term ref = term_from_ref_data(data->ref_data, heap);
     term msg = term_alloc_tuple(2, heap);
     term_put_tuple_element(msg, 0, ref);
     term_put_tuple_element(msg, 1, t);
@@ -659,7 +659,7 @@ static void start_network(Context *ctx, term pid, term ref, term config)
     data->global = ctx->global;
     data->port_process_id = ctx->process_id;
     data->owner_process_id = term_to_local_process_id(pid);
-    data->ref_ticks = term_to_ref_ticks(ref);
+    data->ref_data = term_to_ref_data(ref);
 
     esp_err_t err;
 
@@ -890,7 +890,7 @@ static NativeHandlerResult consume_mailbox(Context *ctx)
         return NativeContinue;
     }
 
-    //TODO: port this code to standard port (and gen_message)
+    // TODO: port this code to standard port (and gen_message)
     term pid = term_get_tuple_element(msg, 0);
     term ref = term_get_tuple_element(msg, 1);
     term cmd = term_get_tuple_element(msg, 2);
@@ -922,7 +922,7 @@ static NativeHandlerResult consume_mailbox(Context *ctx)
             default: {
                 ESP_LOGE(TAG, "Unrecognized command: %x", cmd);
                 // {Ref, {error, badarg}}
-                size_t heap_size = TUPLE_SIZE(2) + REF_SIZE + TUPLE_SIZE(2);
+                size_t heap_size = TUPLE_SIZE(2) + TERM_BOXED_PROCESS_REF_SIZE + TUPLE_SIZE(2);
                 if (UNLIKELY(memory_ensure_free(ctx, heap_size) != MEMORY_GC_OK)) {
                     ESP_LOGE(TAG, "Unable to allocate heap space for error; no message sent");
                     return NativeContinue;
@@ -932,7 +932,7 @@ static NativeHandlerResult consume_mailbox(Context *ctx)
         }
     } else {
         // {Ref, {error, badarg}}
-        size_t heap_size = TUPLE_SIZE(2) + REF_SIZE + TUPLE_SIZE(2);
+        size_t heap_size = TUPLE_SIZE(2) + TERM_BOXED_PROCESS_REF_SIZE + TUPLE_SIZE(2);
         if (UNLIKELY(memory_ensure_free(ctx, heap_size) != MEMORY_GC_OK)) {
             ESP_LOGE(TAG, "Unable to allocate heap space for error; no message sent");
             return NativeContinue;