zephyr: alloc: Map native_sim heap to the C library

When building the firmware for native_sim, debugging allocations with
host machine tools like Valgrind is constrained due to Zephyr's
internal minimal libc tracking the heap manually via static pools. By bypassing
Zephyr's memory interception on native_sim using nsi_host_malloc,
dynamically tracked memory can surface appropriately to Valgrind memory
checkers without causing a libc heap pool panic.

Signed-off-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>

Author: lrgirdwo

zephyr/lib/alloc.c

@@ -153,6 +153,7 @@ extern char _end[], _heap_sentry[];
 
 static struct k_heap sof_heap;
 
+#if !defined(CONFIG_BOARD_NATIVE_SIM)
 /**
  * Checks whether pointer is from a given heap memory.
  * @param heap Pointer to a heap.
@@ -171,6 +172,7 @@ static bool is_heap_pointer(const struct k_heap *heap, void *ptr)
 	return ((POINTER_TO_UINT(ptr) >= heap_start) &&
 		(POINTER_TO_UINT(ptr) < heap_end));
 }
+#endif
 
 #if CONFIG_SOF_USERSPACE_USE_SHARED_HEAP
 static struct k_heap shared_buffer_heap;
@@ -382,6 +384,7 @@ struct k_heap *sof_sys_heap_get(void)
 	return &sof_heap;
 }
 
+#if !defined(CONFIG_BOARD_NATIVE_SIM)
 static void *heap_alloc_aligned(struct k_heap *h, size_t min_align, size_t bytes)
 {
 	k_spinlock_key_t key;
@@ -451,7 +454,106 @@ static void heap_free(struct k_heap *h, void *mem)
 
 	k_spin_unlock(&h->lock, key);
 }
+#endif
+
 
+#if defined(CONFIG_BOARD_NATIVE_SIM)
+#include <nsi_host_trampolines.h>
+#include <string.h>
+
+void *rmalloc_align(uint32_t flags, size_t bytes, uint32_t alignment)
+{
+	void *ptr;
+	void *raw;
+
+	if (alignment < sizeof(void *))
+		alignment = sizeof(void *);
+
+	raw = nsi_host_malloc(bytes + alignment + sizeof(void *));
+	if (!raw)
+		return NULL;
+
+	ptr = (void *)(((uintptr_t)raw + sizeof(void *) + alignment - 1) & ~(alignment - 1));
+	((void **)ptr)[-1] = raw;
+
+	return ptr;
+}
+EXPORT_SYMBOL(rmalloc_align);
+
+void *rmalloc(uint32_t flags, size_t bytes)
+{
+	return rmalloc_align(flags, bytes, 0);
+}
+EXPORT_SYMBOL(rmalloc);
+
+void *rbrealloc_align(void *ptr, uint32_t flags, size_t bytes,
+		      size_t old_bytes, uint32_t alignment)
+{
+	void *new_ptr;
+
+	if (!ptr)
+		return rmalloc_align(flags, bytes, alignment);
+
+	if (!bytes) {
+		void *raw = ((void **)ptr)[-1];
+
+		nsi_host_free(raw);
+		return NULL;
+	}
+
+	new_ptr = rmalloc_align(flags, bytes, alignment);
+	if (!new_ptr)
+		return NULL;
+
+	if (!(flags & SOF_MEM_FLAG_NO_COPY))
+		memcpy_s(new_ptr, bytes, ptr, MIN(bytes, old_bytes));
+
+	void *raw_old = ((void **)ptr)[-1];
+
+	nsi_host_free(raw_old);
+
+	return new_ptr;
+}
+
+void *rzalloc(uint32_t flags, size_t bytes)
+{
+	void *ptr = rmalloc_align(flags, bytes, 0);
+
+	if (ptr)
+		memset(ptr, 0, bytes);
+	return ptr;
+}
+EXPORT_SYMBOL(rzalloc);
+
+void *rballoc_align(uint32_t flags, size_t bytes, uint32_t align)
+{
+	return rmalloc_align(flags, bytes, align);
+}
+EXPORT_SYMBOL(rballoc_align);
+
+void rfree(void *ptr)
+{
+	if (!ptr)
+		return;
+
+	void *raw = ((void **)ptr)[-1];
+
+	nsi_host_free(raw);
+}
+EXPORT_SYMBOL(rfree);
+
+void *sof_heap_alloc(struct k_heap *heap, uint32_t flags, size_t bytes,
+		     size_t alignment)
+{
+	return rmalloc_align(flags, bytes, alignment);
+}
+
+void sof_heap_free(struct k_heap *heap, void *addr)
+{
+	rfree(addr);
+}
+
+#else
 
 void *rmalloc_align(uint32_t flags, size_t bytes, uint32_t alignment)
 {
@@ -642,6 +744,8 @@ void sof_heap_free(struct k_heap *heap, void *addr)
 		rfree(addr);
 }
 
+#endif /* CONFIG_BOARD_NATIVE_SIM */
+
 static int heap_init(void)
 {
 	sys_heap_init(&sof_heap.heap, heapmem, HEAPMEM_SIZE - SHARED_BUFFER_HEAP_MEM_SIZE);