scripting/wamr_nx/nx_platform.cpp

/*
 * Copyright 2026 Rive
 */

// The half of WAMR's platform layer that the Nintendo SDK does not cover.
// nnSdk exports no mmap family, so mapping goes through nn::os virtual
// address memory: AllocateAddressRegion reserves, AllocateMemoryPages commits,
// SetMemoryPermission is mprotect.

#include "platform_api_vmcore.h"

#include <nn/nn_Result.h>
#include <nn/os.h>
#include <nn/os/os_MemoryHeapCommon.h>
#include <nn/os/os_MemoryPermission.h>
#include <nn/os/os_VirtualAddressMemoryApi.h>

#include <malloc.h>
#include <string.h>

// Virtual address memory is opt-in per application. Without it the mapping
// calls all fail, so fall back to aligned allocations from the app heap:
// software bounds checks mean nothing here needs real page permissions.
static bool s_virtualAddressMemory = false;

static size_t roundUpToPage(size_t size)
{
  const size_t page = nn::os::MemoryPageSize;
  return (size + page - 1) & ~(page - 1);
}

static nn::os::MemoryPermission toPermission(int prot)
{
  if (prot & MMAP_PROT_WRITE)
  {
    return nn::os::MemoryPermission_ReadWrite;
  }
  if (prot & MMAP_PROT_READ)
  {
    return nn::os::MemoryPermission_ReadOnly;
  }
  return nn::os::MemoryPermission_None;
}

extern "C"
{

  int bh_platform_init()
  {
    s_virtualAddressMemory = nn::os::IsVirtualAddressMemoryEnabled();
    fprintf(
        stderr,
        "nx wamr: virtual address memory %s\n",
        s_virtualAddressMemory ? "enabled" : "disabled (heap fallback)");
    return 0;
  }

  void bh_platform_destroy() {}

  int os_printf(const char* format, ...)
  {
    va_list ap;
    va_start(ap, format);
    int ret = vprintf(format, ap);
    va_end(ap);
    return ret;
  }

  int os_vprintf(const char* format, va_list ap) { return vprintf(format, ap); }

  int os_getpagesize(void) { return (int)nn::os::MemoryPageSize; }

  // WAMR's shared posix thread code calls the libc spelling directly.
  int getpagesize(void) { return (int)nn::os::MemoryPageSize; }

  void* os_mmap(
      void* hint,
      size_t size,
      int prot,
      int flags,
      os_file_handle file)
  {
    (void)hint;
    (void)flags;
    (void)file;

    size_t requestSize = roundUpToPage(size);
    if (requestSize < size)
    {
      return NULL;
    }

    if (!s_virtualAddressMemory)
    {
      void* p = memalign(nn::os::MemoryPageSize, requestSize);
      if (p != NULL)
      {
        // mmap semantics: callers, wasm linear memory above all,
        // depend on fresh pages reading zero.
        memset(p, 0, requestSize);
      }
      if (p == NULL)
      {
        fprintf(
            stderr,
            "nx wamr: memalign failed for %zu bytes\n",
            requestSize);
      }
      return p;
    }

    uintptr_t address = 0;
    if (nn::os::AllocateAddressRegion(&address, requestSize).IsFailure())
    {
      fprintf(
          stderr,
          "nx wamr: AllocateAddressRegion failed for %zu bytes\n",
          requestSize);
      return NULL;
    }
    // Committing the whole reservation is right because software bounds
    // checks make WAMR reserve only what it maps.
    if (nn::os::AllocateMemoryPages(address, requestSize).IsFailure())
    {
      fprintf(
          stderr,
          "nx wamr: AllocateMemoryPages failed for %zu bytes\n",
          requestSize);
      static_cast<void>(nn::os::FreeAddressRegion(address));
      return NULL;
    }
    nn::os::SetMemoryPermission(address, requestSize, toPermission(prot));
    return (void*)address;
  }

  void os_munmap(void* addr, size_t size)
  {
    if (addr == NULL)
    {
      return;
    }
    if (!s_virtualAddressMemory)
    {
      free(addr);
      return;
    }

    uintptr_t address = (uintptr_t)addr;
    size_t requestSize = roundUpToPage(size);
    // Permissions must come back before the pages can be released.
    nn::os::SetMemoryPermission(
        address,
        requestSize,
        nn::os::MemoryPermission_ReadWrite);
    static_cast<void>(nn::os::FreeMemoryPages(address, requestSize));
    static_cast<void>(nn::os::FreeAddressRegion(address));
  }

  int os_mprotect(void* addr, size_t size, int prot)
  {
    if (addr == NULL || !s_virtualAddressMemory)
    {
      return 0;
    }
    nn::os::SetMemoryPermission(
        (uintptr_t)addr,
        roundUpToPage(size),
        toPermission(prot));
    return 0;
  }

  // No executable mapping exists on this platform, so nothing ever needs the
  // instruction stream made coherent.
  void os_dcache_flush(void) {}

  void os_icache_flush(void* start, size_t len)
  {
    (void)start;
    (void)len;
  }
}