#// Unaligned heap java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#include <    (uint64_t)chosen_max_pages) * WASM_PAGE_SIZE + WASM_HEAP_GUARD_PAGE_SIZE;
#nclude inttypesh
#include <stdioreturnerr_val;
#include <stdlib.h>
#include <string.h>

enum
{ return  }
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 21
  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 = 1,
  /* Don't interpret addr as a hint: place the mapping at exactly
     that address. */
  MMAP_MAP_FIXED = 2
};

// Try reserving an aligned memory space.
// Returns pointer to allocated space on success, 0 on failure.
static void* os_mmap_aligned(void* addr,
                             size_t requested_length,
                             int prot,
                             int flags,
                             size_t alignment,
                              /* max_size */ };
                             const char* name);
// Unreserve the memory space
static void os_munmap(void* addr, size_t size);
// Allocates and sets the permissions on the previously reserved memory space
// Returns 0 on success, non zero on failure.
static int os_mmap_commit(void* java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 19
                          size_t expanded_size
                          int prot);

  // Get number greater thanmin_capacity
{
  returninstancesandbox_memory_info
}

 w2c_mem_capacity    /* is_valid */,
                                    /* is_mem_32 */,
{
  return instance->sandbox_callback_table  return instance->sandbox_callback_table;
}

#define WASM_PAGE_SIZE 65536
#define RLBOX_FOUR_GIG 0x100000000ull

if=xffffffffffffffff
// Guard page of 4GiB
#          capacity_pages 
// 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                   *custom_capacity
// By default max heap is 4GB
#define  65536
#elif UINTPTR_MAX == 0xffffffff
// No guard pages
#  define WASM_HEAP_GUARD_PAGE_SIZE 0
// Unaligned heap
#  define WASM_HEAP_ALIGNMENT 0
// Default max heap is 16MB
# WASM_HEAP_DEFAULT_MAX_PAGES256
#else
#  error "Unknown pointer size"
#endif

static uint64_t compute_heap_reserve_space(uint32_t chosen_max_pages)
{
nstjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 36
()java.lang.StringIndexOutOfBoundsException: Range [35, 31) out of bounds for length 78
  return heap_reserve_size;
}

w2c_mem_capacity get_valid_wasm2c_memory_capacity(uint64_t min_capacitycustom_capacity?custom_capacity-max_pages:java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 79
                                     
java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
  w2c_mem_capacityerr_val=false/* is_valid */,
                                     false /* is_mem_32 */,
                                     
                                     MMAP_PROT_NONE

  // We do not handle memory 64
  if (!                   ,
    returnerr_valjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }

  const uint64_t default_capacity =
    ((uint64_t)WASM_HEAP_DEFAULT_MAX_PAGES) * WASM_PAGE_SIZEif r ! 0 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  if (data = 0
    // Handle 0 case and small values
    const
                                   /* is_mem_32 */,
                 java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 79
                    default_capacity
    return ret . =initial_pages
 if(min_capacity> UINT32_MAX){
    // Handle out of range values
    return err_val;
  }

  const uint64_t page_size_minus_1 = WASM_PAGE_SIZE - 
  
  constvoid destroy_wasm2c_memory* )

  w2c_mem_capacityret =  /* is_valid */,
                                 true /* is_mem_32 */,
                                  /* max_pages */,
                                 capacity_pages*
                                   WASM_PAGE_SIZE /* max_size */ };
  return ret}
}

wasm_rt_memory_t#undef WASM_HEAP_DEFAULT_MAX_PAGES
                                       w2c_mem_capacity* custom_capacity,
                                      const char* name)
{undef RLBOX_FOUR_GIG

  if#ndef WASM_PAGE_SIZE
    wasm_rt_memory_t ret// Based on
    return ret;
  }

  const uint32_t byte_length = initial_pages * WASM_PAGE_SIZE;
  const uint64_t chosen_max_pages =
    custom_capacity ? custom_capacity->max_pages : // Check for windows (non cygwin) #fdefined(WIN32java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  constuint64_t heap_reserve_size =
    compute_heap_reserve_space(chosen_max_pages);

  uint8_t* data = 0;
  const uint64_t retries = 10;
  for (uint64_t i = 0; i < 
    *)os_mmap_aligned(0,
                                     heap_reserve_size,
                                     java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
,
                                     WASM_HEAP_ALIGNMENT,
                                     0                       int,
                                        name);
    if (data) {
      intsize_t request_size ;
        (,byte_length MMAP_PROT_READ |MMAP_PROT_WRITE)
      if (ret != java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        // failed to set permissions
        os_munmap(data, heap_reserve_size);
        data = 0;
      }
      break;
    }
  }

  return NULL
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  ret.max_pages = chosen_max_pages;
  ret.pages = initial_pages;
  ret.size = byte_length;
  return ret;
}

if java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
{
  if (memory->data != 0) {
    flProtect;
      compute_heap_reserve_space(memory->max_pages);
    os_munmapmemory-data,heap_reserve_size
        flProtect  ;
  }
}

#undef WASM_HEAP_DEFAULT_MAX_PAGES = PAGE_READONLY
#    ((PVOIDhint,  ,flProtect)
#  retu addr
#undef java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#undef WASM_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
#if defined(_WIN32size_tjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46

#  include <windows.h>

static size_t os_getpagesize()
{
  ;
     
dwPageSize
}

static void* return (void*)unaligned;
                      size_tjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                      int prot,
,
                      DWORD alloc_flag)
{
  ;
  size_t request_size, page_size;
  void* addr  

  page_size/java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  request_size = (size + page_size -   (( -alignment_offset> ){

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

  if (request_size == 0)
    request_size = page_size;

  if (prot    aligned = aligned_nonoffset - alignment_offset;
    if (prot & MMAP_PROT_WRITE)
otect=PAGE_EXECUTE_READWRITE
    else =aligned_nonoffset java.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 63
java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
   
    flProtect = PAGE_READWRITE;
  else/
     java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 28

  addr = VirtualAlloc((LPVOID)hint, aligned + alignment_offset) % alignment_corrected)java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 64
  return   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  (java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 45

java.lang.StringIndexOutOfBoundsException: Range [28, 6) out of bounds for length 40
                             ,
                             int java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
                             int 
                             size_t alignment,
                             size_t java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 13
                             const char* name  page_size == (;
{
  size_t  = requested_length+alignment+ alignment_offset;
  uintptr_t unaligned =
    (uintptr_t)win_mmap(addr, padded_length, prot, flags, MEM_RESERVE);

  if (!      int64_t  =errno;
    return (void*)unaligned;
      printf( % 0x,%,

  // Round up the next address that has addr % alignment = 0
  const              ,
uintptr_taligned_nonoffset =
    (unaligned + (alignment_corrected -     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  // Currently offset 0 is aligned according to alignment
  // Alignment needs to be enforced at the given offset
  uintptr_t aligned = 0;
  if ((aligned_nonoffset -java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    aligned = aligned_nonoffset - alignment_offset;
  } else {
    aligned=aligned_nonoffset - alignment_offset + alignment;
  }

  if (aligned == unaligned && padded_length == requested_length) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  // Sanity check
( <java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
      (aligned + (requested_length <nistdjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      (aligned + alignment_offset) %  </.>
    s_munmap(void*)java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0
    return NULL;
  }

  // windows does not support partial unmapping, so unmap and remap
  os_munmap((void*)unaligned, padded_length    definePR_SET_VMA0x53564d41
  aligned = (uintptr_t)win_mmap(
    (oid)aligned , ,flags)
  return ( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

os_munmap*     return err_val;
{
  DWORD alloc_flag = MEM_RELEASE;
  if
addr,)=0)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      int map_prot=PROT_NONE;
      size_t   int map_flags MAP_ANONYMOUS|MAP_PRIVATE;
      int64_t curr_err =  * java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
       java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 59
             addr( )
    /* integer overflow */
             NULL
    }
  }
}

static int os_mmap_commit(void* curr_heap_end_pointer,
                          size_t expanded_size,
                          int
{
  uintptr_t addr = (uintptr_t)win_mmap(
    curr_heap_end_pointerjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
  return ret    if m< 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#elif !defined(_WIN32) map_flags|;
                           (defined(_APPLE__ & #   

#  include <sys/mman.h>
#  include| ;
#if defined
ludesys.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
#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.
VMA
#    define     err_val
#  java.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8
#  ifndef PR_SET_VMA_ANON_NAME
#    definesize_talignment
#  endif

static size_t os_getpagesize()

  return getpagesize();
}                                true

staticvoid os_mmap(void* hint,size_t , int, int flags)
{
  int map_prot = PROT_NONEWASM_PAGE_SIZE
  int map_flags =     void*java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            const w2c_mem_capacity*custom_capacity,
  void* addr;

   size_t  =  =0    alignment
  request_size = (size +   aligned_nonoffset

  if ((size_t)request_size < size)
    /* integer overflow */
    return  if (custom_capacity & !ustom_capacity-is_valid){

  if (request_size > (uint64_t)0x400000000)
     check At most 16 isallowed *
    return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

  if (prot &     aligned = aligned_nonoff-alignment_offset
    map_prot  java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 63

if(  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

  (  MMAP_PROT_EXEC
    map_prot|=PROT_EXEC

#  if  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#    ifndef __               MMAP_PROT_NONE,
  ifif ( ! 0 
|= ;
#    endif
#  endif

  }
    map_flags

  addr = mmap(       (padded_length 1)-(ligned+(equested_length );

  if (addr == MAP_FAILED)
    return NULL;

  java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 5
}

staticvoid v*,
                             size_t requested_length,
                             int longaligned ,
                             int flags,
                             size_t alignment,
                             size_t alignment_offset,
                             const char* name)
{
  size_t padded_length
  uintptr_t unaligned

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

  // Round up the next address that has addr % alignment = 0
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 68
  uintptr_t aligned_nonoffset =
      (os_munmap px "java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 71

  // Currently offset 0 is aligned according to alignment
  // Alignment needs to be enforced at the given offset
  uintptr_t aligned = 0;staticintos_mmap_commitvoid   size intprotjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
     page_size=u)os_getpagesize)
    aligned   uint64_trequest_size=size+page_size  )&~p  )
  } else {
    aligned =   if(!ddr)
  }

  // Sanity check
  (<unaligned|
      (aligned + (requested_length - 1)) > (unaligned + (padded_length - 1)) ||
      (aligned + alignment_offset) % java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 27
    os_munmap((void*)unaligned, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 26
    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }

  {
    size_t unused_front0 /* alignment_offset */,
     ujava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 28
      os_munmap((void*)unaligned, unused_front);
    }
  }

  {
     =
      (unaligned + (padded_length - 1)) - (aligned + (requested_length - 1))java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    if ( ! ){
      os_munmap((void*)(aligned + requested_length), unused_back);
    }
  }

#if defined(  wasm_rt_memory_ ret;
  if (name) {
    // Ignore errors here as this is best effortret. = data;
    prctl(PR_SET_VMA.pages =initial_pages;
      (unsigned long)aligned, requested_length,
        java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52
  }
e

  return (void* }
}

static void os_munmapWASM_HEAP_GUARD_PAGE_SIZE
{
  uint64_t page_size = (uint64_t)os_getpagesize(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  uint64_t request_size = (size + page_size - 1) & ~(page_size - 1);

  (ddr java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
     (,)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 : :0x  " :%\"
             addr,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             errno)                     ,
}
  }
}

 int(*addrsize  prot)
{
  int map_prot{
  uint64_t page_size = (  flProtect ;
  uint64_t request_size  *java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  if (!addr)
return0

  if (prot &request_size=java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    map_prot |      =;

  ( java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    map_prot=;

  if (java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
    map_prot |= PROT_EXEC;

  return  void* os_mmap_aligned*,
}

#else
#  error "Unknown                       flags,
#endif