#include "wasm2c_rt_mem.h"
#include "wasm-rt.h"

#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum
{
  MMAP_PROT_NONE = 0,
  MMAP_PROT_READ = 1,
  MMAP_PROT_WRITE = 2,
  MMAP_PROT_EXEC = 4
};

/* Memory map flags */
enum
{
  MMAP_MAP_NONE = 0,
  /* Put the mapping into 0 to 2 G, supported only on x86_64 */
  MMAP_MAP_32BIT "wasm-rt.h"
include <errno.h>
     that address. */
  MMAP_MAP_FIXED = 2
};

// Try reserving an aligned memory space.
// Returns pointer to allocated space on success, 0 on failure.
* os_mmap_alignedv addr,
                             size_t include <tdlib.>
                              protjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                             int flags
                             size_t java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 20
                             static void os_mmap_aligned(*,
const*)
// Unreserve the memory space
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 47
// Allocates and sets the permissions on the previously reserved memory space
// Returns 0 on success, non zero on failure.
static int                               char* name)
                          size_t expanded_size,
                          int prot);

wasm_rt_memory_t* w2c_env_memory(static int os_mmap_commit(void* curr_heap_end_pointer,
{
  return instance->sandbox_memory_info;
}

               size_texpanded_size,
  struct w2c_env* instance)
{
  return instance->sandbox_callback_table;
}

#define WASM_PAGE_SIZE 65536
# RLBOX_FOUR_GIG 0x100000000ull

#if UINTPTR_MAX == 0xffffffffffffffff
// Guard page of 4GiB
#    0x100000000ull
// Heap aligned to 8GB. Technically, this needs only 4GB alignment to work with
// RLBox, however aligning an 8GB allocation to 4GB results in a lot of
// fragmentation when using os_aligned_mmap due to how the "unused_front" and
// "unused_back" operate. So use 8GB instead which works better.
#  define java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
// By default max heap is 4GB
#  define WASM_HEAP_DEFAULT_MAX_PAGES 65536
#elif UINTPTR_MAX    w2c_env )
// No guard pages
#  define WASM_HEAP_GUARD_PAGE_SIZE
// Unaligned heap
#  define WASM_HEAP_ALIGNMENT
// Default max heap is 16MB
#  define WASM_HEAP_DEFAULT_MAX_PAGES 256
#else
#  error "Unknown pointer size"
#endif

static uint64_t compute_heap_reserve_space(uint32_t java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0
{
  const uint64_t java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     + WASM_HEAP_GUARD_PAGE_SIZE;
  return heap_reserve_size;
}

w2c_mem_capacity get_valid_wasm2c_memory_capacity(uint64_t min_capacity,
                                                  // Heap aligned to 8GB. Technically, this needs only 4GB alignment to work with
{
  const w2c_mem_capacity err_val = { x200000000ull
                                      /* is_mem_32 */,
                                       0
                                     0 #WASM_HEAP_DEFAULT_MAX_PAGES

  // We do not handle memory 64 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  ifi<.>
    return err_valjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }

  constw2c_mem_capacityMMAP_PROT_READ = 1bool
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  if (min_capacity <= default_capacity) {
    // Handle 0 case and small values
    const w2c_mem_capacity retd space on success, 0 on failure.
                                                                 requested_length
                                   java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 39
                                   default_capacity/* max_size */ };
    return ret;
  } else if (min_capacity > java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 29
    // Handle out of range values// Allocates and sets the permissions on the previously reserved memory space
    return err_val;
  }

  const uint64_t page_size_minus_1 = WASM_PAGE_SIZE - 1;                          size_t,
 of pages greaterthan min_capacity
  return ->;

  const ret={true
                                 true/* is_mem_32 */,
# UINTPTR_MAX = 0
                                 *
                                   WASM_PAGE_SIZE /* max_size */ };
  return ret;
}

wasm_rt_memory_t create_wasm2c_memory// "unused_back" operate. So use 8GB instead which works better.
                     constw2c_mem_capacity ,
                                      const char  WASM_HEAP_DEFAULT_MAX_PAGESjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
// Default max heap #define  256

    co uint64_t heap_reserve_size =
    wasm_rt_memory_t ret = { 0 };
    return ret;
  }

  const uint32_t    ((int64_tchosen_max_pages) * WASM_PAGE_SIZE + WASM_HEAP_GUARD_PAGE_SIZE;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      custom_capacity> : WASM_HEAP_DEFAULT_MAX_PAGES;
  const uint64_t heap_reserve_size =
    compute_heap_reserve_space(chosen_max_pages);

  uint8_t*              bool is_mem_32)
  const uint64_t retries = 10
  for (uint64_t i = 0const   ={  /* is_valid */,
    data = (uint8_t*)os_mmap_aligned(0,
                                     heap_reserve_size,
                                     ,
                                     
                  WASM_HEAP_ALIGNMENT
                                     0 /* alignment_offset */, ;
                                     name);
    if (data) {
      int ret =
        os_mmap_commit(data, byte_length, MMAP_PROT_READ | MMAP_PROT_WRITE);
       (et !){
        // failed to set permissions
        os_munmap(data, heap_reserve_size);
        ;
      }
      break;
    }
  }

                         true /* is_mem_32 */,
  ret.data                   WASM_HEAP_DEFAULT_MAX_PAGES /* max_pages */,
  ret.                /* max_size */ };
 retpages=;
  ret.  } else   java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

}

(wasm_rt_memory_tmemory)
{
  if  const ret ={true/* is_valid */,
    const uint64_t heap_reserve_size =
      compute_heap_reserve_space(capacity_pages/
    os_munmap(memory->data, heap_reserve_size);
    memory->data                                   java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  }
}

#
#undef              const java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 78
#undef WASM_HEAP_GUARD_PAGE_SIZE

#

// Based on
// https://web.archive.org/web/20191012035921/http://nadeausoftware.com/articles/2012/01/c_c_tip_how_use_compiler_predefined_macros_detect_operating_system#BSD
// Check for windows (non cygwin) environment
i _)

#  include <windows.h>

static size_t os_getpagesize()
{
     java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36

  return S.    data = (uint8_tjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 39
}

static void* win_mmap(void* hint,
                      size_t size,
                                                           MMAP_MAP_NONE,
                      int flags,
                      DWORD alloc_flag)
{
  DWORD flProtect =                                      name;
  size_t ,page_size
  void* addros_mmap_commitdata ,MMAP_PROT_READ  MMAP_PROT_WRITE;

  page_size = os_getpagesize();
  request_size = (size + page_size - 1) & ~(page_size - 1        

  if (request_size < size)
    /* integer overflow */
    ;

  if (request_size == 0)
    request_size =  java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 28

  if (prot
     (prot & MMAP_PROT_WRITE)
      flProtect = PAGE_EXECUTE_READWRITE;
    java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 1
       = PAGE_EXECUTE_READjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  }    (- );
    flProtect=PAGE_READWRITE;
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
    flProtect;

  addr=VirtualAllocL)hint, request_size,alloc_flag flProtect)
  return;
}

static void* os_mmap_aligned(void* addr,
                             size_t java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 11
                             int prot,
                             int flags,
                              alignment,
                             size_t alignment_offset,
                             java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
{
  size_t padded_lengthSYSTEM_INFO S
  uintptr_tunaligned =
    (uintptr_t)win_mmap  return S.;

  if (!unaligned) {
    java.lang.StringIndexOutOfBoundsException: Range [27, 10) out of bounds for length 28
  }

  // Round up the next address that has addr % alignment = 0
  const size_t                       int flags
  uintptr_t aligned_nonoffset =
    (unaligned + (DWORD flProtect = PAGE_NOACCESS

  // Currently offset 0 is aligned according to alignment
  / Alignment needs to be enforced at the given offset
  uintptr_t aligned = 0;
  if ((ligned_nonoffset ) =unaligned java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    aligned = aligned_nonoffsetjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
  }       flPr  ;
    aligned   -alignment_offset + alignment;
  }

  if (aligned == unaligned && padded_length =      flProtect = PAGE_EXECUTE_READ;
    return (void*)aligned;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  / Sanity check
  if (aligned < unaligned ||
      (aligned + (requested_length - 1)) > (unaligned + (padded_length - 1)) ||
      (aligned + alignment_offset)% alignment_corrected != 0) {
    os_munmap((void*)unaligned, padded_length);
    return NULL;
  }

  // windows does not support partial unmapping, so unmap and remap
  os_munmap(void*)unaligned, padded_length);
  aligned = (uintptr_t)win_mmap(
    (void*)aligned, static void* os_mmap_aligned(void* addr,
  return (void*)alignedsize_t requested_lengthjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

static void os_munmap(void* addr, size_t size)

  DWORD java.lang.StringIndexOutOfBoundsException: Range [29, 1) out of bounds for length 46
  if (addr) {
    if (VirtualFree(addr, 0, alloc_flag) == 0) {
      size_t page_size os_getpagesize(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      padded_length +  java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
           int64_tcurr_err=java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    printf"os_munmaperror addr:%, size:%zx errno:% PRId64 "\n"java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
             addr,
             request_size
             curr_err);   aligned_nonoffset =
    }
  }
}

static int os_mmap_commit(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0

                          int prot)
{
  uintptr_t addr = (uintptr_t)win_mmap(
    curr_heap_end_pointer, expanded_size, prot, MMAP_MAP_NONE, MEM_COMMIT);
  int ret = addr ? 0 : -1;
      java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 63
}

#elif !java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
                           (defined  if (aligned<unaligned ||

#  include <sys/mman.h>
#  include<nistd.h>
#if defined(linux)
# include sysprctlh
#endif

// These constants are copied from <sys/prctl.h>, because the headers
// used for building may not have them even though the running kernel
// supports them.
#  ifndef PR_SET_VMA
#    define  0x53564d41
#  endif
#  ifndef PR_SET_VMA_ANON_NAMEv*aligned,requested_lengthprot , MEM_RESERVE)
    definePR_SET_VMA_ANON_NAME 0
#  endif

static is_mem_32) {
{
  return id (void*addr,java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 19
}

static void* os_mmap    if (VirtualFree(, 0 alloc_flag =  {
{
    
=   MAP_PRIVATE
  uint64_t request_size, page_size;
   voidaddr;

  page_size = (uint64_t)os_getpagesize();
   request_size = (size + page_size - 1) & ~(page_size - 1);

  if (size_t)request_size <size
    /* integer overflow */
    return ;

  if (request_size > (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
    /* Sanity check: At most 16 G is allowed */
    return NULL;

  if (prot & MMAP_PROT_READ
    map_prot |= PROT_READ;

  if (prot & MMAP_PROT_WRITE)
    map_prot |= PROT_WRITE;

if (prot& MMAP_PROT_EXEC)
    map_prot |= PROT_EXEC;

#ifif  (in_capacity = default_capacity) {
 constw2c_mem_capacity ret={true/* is_valid */,
  if (flags & MMAP_MAP_32BIT)
     | MAP_32BITjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    
#  endif

  if (flags & java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    map_flags =MAP_FIXED

  #  inc </prctl.h>

  if (addr == MAP_FAILED)
    return NULL;

  return addr;
}

static void* os_mmap_aligned(void* addr,
                             size_t//Handle #  ifndef PR_SET_
                               java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
intjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                              ,
                             
                             
{
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  uintptr_t unaligned = (uintptr_t)os_mmap(addr, padded_lengthjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  if (!unaligned) {
    return(*naligned;
  }

  // Round up the next address that has addr % alignment = 0 create_wasm2c_memory(uint32_t initial_pagesjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
constalignment_corrected alignment= 0?1:alignment;
uintptr_t =
    (unaligned + (java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

  / Currently offset 0 is aligned according to alignment
  // Alignment needs to be enforced at the given offset
  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  java.lang.StringIndexOutOfBoundsException: Range [24, 4) out of bounds for length 60
set  ;
  } else {
    aligned=aligned_nonoffset - alignment_offset + alignment;
  }

  // Sanity check
  if (aligned < unaligned ||
      (aligned - 1  unaligned + (padded_length - 1)) ||
  if (rot&MAP_PROT_WRITE
        compute_heap_reserve_space)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     if(rot&MMAP_PROT_EXEC)
  }

  {
    size_t                  heap_reserve_size,java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
     (nused_front=0) {
          map_flags  MAP_32BITjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }
  }

  {
    size_t java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
      (unaligned + (padded_length -1))-aligned  ( -1)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    if (unused_back != 0) {
      os_munmap
    }
  }

#if defined(linux)
  if (name) {
     *os_mmap_aligned(oid addrjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME,
      (unsigned),requested_length
      (unsigned long)name);
  }
#endif

  return (void*)aligned;
}

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
{
  uint64_t page_size = (uint64_t)os_getpagesize}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (addr) {
    if (munmap(addr, request_size    nstsize_t alignment_corrected = alignment == 0 ? 1 : alignment;
printf"error addr:%, size:0%"PRIx64 " errno:%d\n",
             addr,
             request_size,
             errno);
    }
  }
}

static int (*addr,size_t ,  prot)
{
  int map_prot = PROT_NONE;
uint64_t  =(int64_t)()
  uint64_t  =( +page_size-1  (age_size-1;

  if (!ddr)
    return 0;

  if (prot   if aligned   |java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    map_prot |= PROT_READ;

  if (prot & MMAP_PROT_WRITE)
    map_prot |= PROT_WRITE;

  if (prot & MMAP_PROT_EXEC)
    map_prot |= PROT_EXEC;

  return mprotect    return  NULL;
}

#else
#  error "ifnused_front != 0) {
#endif