py/malloc: Add m_tracked_realloc.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

ports/unix/coverage.c

@@ -343,6 +343,13 @@ static mp_obj_t extra_coverage(void) {
             gc_collect();
         }
 
+        // resize one of the blocks
+        void *before = ptrs[1];
+        ptrs[1] = FLIP_POINTER(m_tracked_realloc(FLIP_POINTER(ptrs[1]), 2 * NUM_BYTES));
+        void *after = ptrs[1];
+        bool location_changed = before != after;
+        mp_printf(&mp_plat_print, "%d\n", location_changed);
+
         // check the memory blocks have the correct content
         for (size_t i = 0; i < NUM_PTRS; ++i) {
             bool correct_contents = true;

py/malloc.c

@@ -245,6 +245,15 @@ typedef struct _m_tracked_node_t {
     uint8_t data[];
 } m_tracked_node_t;
 
+// Helper to get data size of a tracked node, abstracting MICROPY_TRACKED_ALLOC_STORE_SIZE.
+static inline size_t get_tracked_node_size(m_tracked_node_t *node) {
+    #if MICROPY_TRACKED_ALLOC_STORE_SIZE
+    return node->size;
+    #else
+    return gc_nbytes(node) - sizeof(m_tracked_node_t);
+    #endif
+}
+
 #if MICROPY_DEBUG_VERBOSE
 static size_t m_tracked_count_links(size_t *nb) {
     m_tracked_node_lock();
@@ -292,18 +301,57 @@ void *m_tracked_calloc(size_t nmemb, size_t size) {
     return &node->data[0];
 }
 
+void *m_tracked_realloc(void *ptr_in, size_t n_bytes) {
+    // check for pure allocation
+    if (ptr_in == NULL) {
+        return m_tracked_calloc(1, n_bytes);
+    }
+    // check for pure free
+    if (n_bytes == 0) {
+        m_tracked_free(ptr_in);
+        return NULL;
+    }
+    m_tracked_node_t *node = (m_tracked_node_t *)((uint8_t *)ptr_in - sizeof(m_tracked_node_t));
+    #if MICROPY_MALLOC_USES_ALLOCATED_SIZE || MICROPY_DEBUG_VERBOSE
+    size_t prev_bytes;
+    prev_bytes = get_tracked_node_size(node);
+    #if MICROPY_DEBUG_VERBOSE
+    size_t nb;
+    size_t n = m_tracked_count_links(&nb);
+    DEBUG_printf("m_tracked_realloc(%p, [%p, %p], pbytes=%u, nbytes=%u, links=%u;%u)\n", node, node->prev, node->next, (int)prev_bytes, (int)n_bytes, (int)n, (int)nb);
+    #endif
+    #endif
+    node = m_realloc(node,
+        #if MICROPY_MALLOC_USES_ALLOCATED_SIZE
+        sizeof(m_tracked_node_t) + prev_bytes,
+        #endif
+        sizeof(m_tracked_node_t) + n_bytes
+        );
+    // m_realloc raises on failure (never returns NULL), so no error handling needed.
+    #if MICROPY_TRACKED_ALLOC_STORE_SIZE
+    node->size = n_bytes;
+    #endif
+    m_tracked_node_lock();
+    if (node->next != NULL) {
+        node->next->prev = node;
+    }
+    if (node->prev != NULL) {
+        node->prev->next = node;
+    } else {
+        MP_STATE_VM(m_tracked_head) = node;
+    }
+    m_tracked_node_unlock();
+    return &node->data[0];
+}
+
 void m_tracked_free(void *ptr_in) {
     if (ptr_in == NULL) {
         return;
     }
     m_tracked_node_t *node = (m_tracked_node_t *)((uint8_t *)ptr_in - sizeof(m_tracked_node_t));
     #if MICROPY_DEBUG_VERBOSE
     size_t data_bytes;
-    #if MICROPY_TRACKED_ALLOC_STORE_SIZE
-    data_bytes = node->size;
-    #else
-    data_bytes = gc_nbytes(node);
-    #endif
+    data_bytes = get_tracked_node_size(node);
     size_t nb;
     size_t n = m_tracked_count_links(&nb);
     DEBUG_printf("m_tracked_free(%p, [%p, %p], nbytes=%u, links=%u;%u)\n", node, node->prev, node->next, (int)data_bytes, (int)n, (int)nb);

py/misc.h

@@ -137,6 +137,7 @@ MP_NORETURN void m_malloc_fail(size_t num_bytes);
 // These alloc/free functions track the pointers in a linked list so the GC does not reclaim
 // them.  They can be used by code that requires traditional C malloc/free semantics.
 void *m_tracked_calloc(size_t nmemb, size_t size);
+void *m_tracked_realloc(void *ptr_in, size_t n_bytes);
 void m_tracked_free(void *ptr_in);
 #endif
 

tests/ports/unix/extra_coverage.py.exp

@@ -45,6 +45,7 @@ m_tracked_head = 0
 5 1
 6 1
 7 1
+1
 0 1
 1 1
 2 1

tests/run-tests.py

@@ -1382,6 +1382,10 @@ def main():
   run-tests.py -i async - exclude all, then include tests containing "async" anywhere
   run-tests.py -e '/big.+int' - include all, then exclude by regex
   run-tests.py -e async -i async_foo - include all, exclude async, yet still include async_foo
+
+For tests that use cpython, unix micropython and mpy-cross, the default executables
+vcan be overridden with the environment variables MICROPY_CPYTHON3, MICROPY_MICROPYTHON and
+MICROPY_MPYCROSS respectively.
 """,
     )
     cmd_parser.add_argument(