412 lines
12 KiB
C
412 lines
12 KiB
C
/*
|
|
* Stack-less Just-In-Time compiler
|
|
*
|
|
* Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are
|
|
* permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
* conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
|
* provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
* SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
|
|
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
|
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
This file contains a simple executable memory allocator
|
|
|
|
It is assumed, that executable code blocks are usually medium (or sometimes
|
|
large) memory blocks, and the allocator is not too frequently called (less
|
|
optimized than other allocators). Thus, using it as a generic allocator is
|
|
not suggested.
|
|
|
|
How does it work:
|
|
Memory is allocated in continuous memory areas called chunks by alloc_chunk()
|
|
Chunk format:
|
|
[ block ][ block ] ... [ block ][ block terminator ]
|
|
|
|
All blocks and the block terminator is started with block_header. The block
|
|
header contains the size of the previous and the next block. These sizes
|
|
can also contain special values.
|
|
Block size:
|
|
0 - The block is a free_block, with a different size member.
|
|
1 - The block is a block terminator.
|
|
n - The block is used at the moment, and the value contains its size.
|
|
Previous block size:
|
|
0 - This is the first block of the memory chunk.
|
|
n - The size of the previous block.
|
|
|
|
Using these size values we can go forward or backward on the block chain.
|
|
The unused blocks are stored in a chain list pointed by free_blocks. This
|
|
list is useful if we need to find a suitable memory area when the allocator
|
|
is called.
|
|
|
|
When a block is freed, the new free block is connected to its adjacent free
|
|
blocks if possible.
|
|
|
|
[ free block ][ used block ][ free block ]
|
|
and "used block" is freed, the three blocks are connected together:
|
|
[ one big free block ]
|
|
*/
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
/* System (OS) functions */
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
/* 64 KByte. */
|
|
#define CHUNK_SIZE (sljit_uw)0x10000u
|
|
|
|
/*
|
|
alloc_chunk / free_chunk :
|
|
* allocate executable system memory chunks
|
|
* the size is always divisible by CHUNK_SIZE
|
|
SLJIT_ALLOCATOR_LOCK / SLJIT_ALLOCATOR_UNLOCK :
|
|
* provided as part of sljitUtils
|
|
* only the allocator requires this lock, sljit is fully thread safe
|
|
as it only uses local variables
|
|
*/
|
|
|
|
#ifdef _WIN32
|
|
#define SLJIT_UPDATE_WX_FLAGS(from, to, enable_exec)
|
|
|
|
static SLJIT_INLINE void* alloc_chunk(sljit_uw size)
|
|
{
|
|
return VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
|
|
}
|
|
|
|
static SLJIT_INLINE void free_chunk(void *chunk, sljit_uw size)
|
|
{
|
|
SLJIT_UNUSED_ARG(size);
|
|
VirtualFree(chunk, 0, MEM_RELEASE);
|
|
}
|
|
|
|
#else /* POSIX */
|
|
|
|
#if defined(__APPLE__) && defined(MAP_JIT)
|
|
/*
|
|
On macOS systems, returns MAP_JIT if it is defined _and_ we're running on a
|
|
version where it's OK to have more than one JIT block or where MAP_JIT is
|
|
required.
|
|
On non-macOS systems, returns MAP_JIT if it is defined.
|
|
*/
|
|
#include <TargetConditionals.h>
|
|
#if TARGET_OS_OSX
|
|
#if defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86
|
|
#ifdef MAP_ANON
|
|
#include <sys/utsname.h>
|
|
#include <stdlib.h>
|
|
|
|
#define SLJIT_MAP_JIT (get_map_jit_flag())
|
|
|
|
static SLJIT_INLINE int get_map_jit_flag()
|
|
{
|
|
size_t page_size;
|
|
void *ptr;
|
|
struct utsname name;
|
|
static int map_jit_flag = -1;
|
|
|
|
if (map_jit_flag < 0) {
|
|
map_jit_flag = 0;
|
|
uname(&name);
|
|
|
|
/* Kernel version for 10.14.0 (Mojave) or later */
|
|
if (atoi(name.release) >= 18) {
|
|
page_size = get_page_alignment() + 1;
|
|
/* Only use MAP_JIT if a hardened runtime is used */
|
|
ptr = mmap(NULL, page_size, PROT_WRITE | PROT_EXEC,
|
|
MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
|
|
if (ptr != MAP_FAILED)
|
|
munmap(ptr, page_size);
|
|
else
|
|
map_jit_flag = MAP_JIT;
|
|
}
|
|
}
|
|
return map_jit_flag;
|
|
}
|
|
#endif /* MAP_ANON */
|
|
#else /* !SLJIT_CONFIG_X86 */
|
|
#if !(defined SLJIT_CONFIG_ARM && SLJIT_CONFIG_ARM)
|
|
#error "Unsupported architecture"
|
|
#endif /* SLJIT_CONFIG_ARM */
|
|
#include <AvailabilityMacros.h>
|
|
#include <pthread.h>
|
|
|
|
#define SLJIT_MAP_JIT (MAP_JIT)
|
|
#define SLJIT_UPDATE_WX_FLAGS(from, to, enable_exec) \
|
|
apple_update_wx_flags(enable_exec)
|
|
|
|
static SLJIT_INLINE void apple_update_wx_flags(sljit_s32 enable_exec)
|
|
{
|
|
#if MAC_OS_X_VERSION_MIN_REQUIRED >= 110000
|
|
pthread_jit_write_protect_np(enable_exec);
|
|
#else
|
|
#error "Must target Big Sur or newer"
|
|
#endif /* BigSur */
|
|
}
|
|
#endif /* SLJIT_CONFIG_X86 */
|
|
#else /* !TARGET_OS_OSX */
|
|
#define SLJIT_MAP_JIT (MAP_JIT)
|
|
#endif /* TARGET_OS_OSX */
|
|
#endif /* __APPLE__ && MAP_JIT */
|
|
#ifndef SLJIT_UPDATE_WX_FLAGS
|
|
#define SLJIT_UPDATE_WX_FLAGS(from, to, enable_exec)
|
|
#endif /* !SLJIT_UPDATE_WX_FLAGS */
|
|
#ifndef SLJIT_MAP_JIT
|
|
#define SLJIT_MAP_JIT (0)
|
|
#endif /* !SLJIT_MAP_JIT */
|
|
|
|
static SLJIT_INLINE void* alloc_chunk(sljit_uw size)
|
|
{
|
|
void *retval;
|
|
int prot = PROT_READ | PROT_WRITE | PROT_EXEC;
|
|
int flags = MAP_PRIVATE;
|
|
int fd = -1;
|
|
|
|
#ifdef PROT_MAX
|
|
prot |= PROT_MAX(prot);
|
|
#endif
|
|
|
|
#ifdef MAP_ANON
|
|
flags |= MAP_ANON | SLJIT_MAP_JIT;
|
|
#else /* !MAP_ANON */
|
|
if (SLJIT_UNLIKELY((dev_zero < 0) && open_dev_zero()))
|
|
return NULL;
|
|
|
|
fd = dev_zero;
|
|
#endif /* MAP_ANON */
|
|
|
|
retval = mmap(NULL, size, prot, flags, fd, 0);
|
|
if (retval == MAP_FAILED)
|
|
return NULL;
|
|
|
|
#ifdef __FreeBSD__
|
|
/* HardenedBSD's mmap lies, so check permissions again */
|
|
if (mprotect(retval, size, PROT_READ | PROT_WRITE | PROT_EXEC) < 0) {
|
|
munmap(retval, size);
|
|
return NULL;
|
|
}
|
|
#endif /* FreeBSD */
|
|
|
|
SLJIT_UPDATE_WX_FLAGS(retval, (uint8_t *)retval + size, 0);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static SLJIT_INLINE void free_chunk(void *chunk, sljit_uw size)
|
|
{
|
|
munmap(chunk, size);
|
|
}
|
|
|
|
#endif /* windows */
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
/* Common functions */
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
#define CHUNK_MASK (~(CHUNK_SIZE - 1))
|
|
|
|
struct block_header {
|
|
sljit_uw size;
|
|
sljit_uw prev_size;
|
|
};
|
|
|
|
struct free_block {
|
|
struct block_header header;
|
|
struct free_block *next;
|
|
struct free_block *prev;
|
|
sljit_uw size;
|
|
};
|
|
|
|
#define AS_BLOCK_HEADER(base, offset) \
|
|
((struct block_header*)(((sljit_u8*)base) + offset))
|
|
#define AS_FREE_BLOCK(base, offset) \
|
|
((struct free_block*)(((sljit_u8*)base) + offset))
|
|
#define MEM_START(base) ((void*)(((sljit_u8*)base) + sizeof(struct block_header)))
|
|
#define ALIGN_SIZE(size) (((size) + sizeof(struct block_header) + 7u) & ~(sljit_uw)7)
|
|
|
|
static struct free_block* free_blocks;
|
|
static sljit_uw allocated_size;
|
|
static sljit_uw total_size;
|
|
|
|
static SLJIT_INLINE void sljit_insert_free_block(struct free_block *free_block, sljit_uw size)
|
|
{
|
|
free_block->header.size = 0;
|
|
free_block->size = size;
|
|
|
|
free_block->next = free_blocks;
|
|
free_block->prev = NULL;
|
|
if (free_blocks)
|
|
free_blocks->prev = free_block;
|
|
free_blocks = free_block;
|
|
}
|
|
|
|
static SLJIT_INLINE void sljit_remove_free_block(struct free_block *free_block)
|
|
{
|
|
if (free_block->next)
|
|
free_block->next->prev = free_block->prev;
|
|
|
|
if (free_block->prev)
|
|
free_block->prev->next = free_block->next;
|
|
else {
|
|
SLJIT_ASSERT(free_blocks == free_block);
|
|
free_blocks = free_block->next;
|
|
}
|
|
}
|
|
|
|
SLJIT_API_FUNC_ATTRIBUTE void* sljit_malloc_exec(sljit_uw size)
|
|
{
|
|
struct block_header *header;
|
|
struct block_header *next_header;
|
|
struct free_block *free_block;
|
|
sljit_uw chunk_size;
|
|
|
|
SLJIT_ALLOCATOR_LOCK();
|
|
if (size < (64 - sizeof(struct block_header)))
|
|
size = (64 - sizeof(struct block_header));
|
|
size = ALIGN_SIZE(size);
|
|
|
|
free_block = free_blocks;
|
|
while (free_block) {
|
|
if (free_block->size >= size) {
|
|
chunk_size = free_block->size;
|
|
SLJIT_UPDATE_WX_FLAGS(NULL, NULL, 0);
|
|
if (chunk_size > size + 64) {
|
|
/* We just cut a block from the end of the free block. */
|
|
chunk_size -= size;
|
|
free_block->size = chunk_size;
|
|
header = AS_BLOCK_HEADER(free_block, chunk_size);
|
|
header->prev_size = chunk_size;
|
|
AS_BLOCK_HEADER(header, size)->prev_size = size;
|
|
}
|
|
else {
|
|
sljit_remove_free_block(free_block);
|
|
header = (struct block_header*)free_block;
|
|
size = chunk_size;
|
|
}
|
|
allocated_size += size;
|
|
header->size = size;
|
|
SLJIT_ALLOCATOR_UNLOCK();
|
|
return MEM_START(header);
|
|
}
|
|
free_block = free_block->next;
|
|
}
|
|
|
|
chunk_size = (size + sizeof(struct block_header) + CHUNK_SIZE - 1) & CHUNK_MASK;
|
|
header = (struct block_header*)alloc_chunk(chunk_size);
|
|
if (!header) {
|
|
SLJIT_ALLOCATOR_UNLOCK();
|
|
return NULL;
|
|
}
|
|
|
|
chunk_size -= sizeof(struct block_header);
|
|
total_size += chunk_size;
|
|
|
|
header->prev_size = 0;
|
|
if (chunk_size > size + 64) {
|
|
/* Cut the allocated space into a free and a used block. */
|
|
allocated_size += size;
|
|
header->size = size;
|
|
chunk_size -= size;
|
|
|
|
free_block = AS_FREE_BLOCK(header, size);
|
|
free_block->header.prev_size = size;
|
|
sljit_insert_free_block(free_block, chunk_size);
|
|
next_header = AS_BLOCK_HEADER(free_block, chunk_size);
|
|
}
|
|
else {
|
|
/* All space belongs to this allocation. */
|
|
allocated_size += chunk_size;
|
|
header->size = chunk_size;
|
|
next_header = AS_BLOCK_HEADER(header, chunk_size);
|
|
}
|
|
next_header->size = 1;
|
|
next_header->prev_size = chunk_size;
|
|
SLJIT_ALLOCATOR_UNLOCK();
|
|
return MEM_START(header);
|
|
}
|
|
|
|
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_exec(void* ptr)
|
|
{
|
|
struct block_header *header;
|
|
struct free_block* free_block;
|
|
|
|
SLJIT_ALLOCATOR_LOCK();
|
|
header = AS_BLOCK_HEADER(ptr, -(sljit_sw)sizeof(struct block_header));
|
|
allocated_size -= header->size;
|
|
|
|
/* Connecting free blocks together if possible. */
|
|
SLJIT_UPDATE_WX_FLAGS(NULL, NULL, 0);
|
|
|
|
/* If header->prev_size == 0, free_block will equal to header.
|
|
In this case, free_block->header.size will be > 0. */
|
|
free_block = AS_FREE_BLOCK(header, -(sljit_sw)header->prev_size);
|
|
if (SLJIT_UNLIKELY(!free_block->header.size)) {
|
|
free_block->size += header->size;
|
|
header = AS_BLOCK_HEADER(free_block, free_block->size);
|
|
header->prev_size = free_block->size;
|
|
}
|
|
else {
|
|
free_block = (struct free_block*)header;
|
|
sljit_insert_free_block(free_block, header->size);
|
|
}
|
|
|
|
header = AS_BLOCK_HEADER(free_block, free_block->size);
|
|
if (SLJIT_UNLIKELY(!header->size)) {
|
|
free_block->size += ((struct free_block*)header)->size;
|
|
sljit_remove_free_block((struct free_block*)header);
|
|
header = AS_BLOCK_HEADER(free_block, free_block->size);
|
|
header->prev_size = free_block->size;
|
|
}
|
|
|
|
/* The whole chunk is free. */
|
|
if (SLJIT_UNLIKELY(!free_block->header.prev_size && header->size == 1)) {
|
|
/* If this block is freed, we still have (allocated_size / 2) free space. */
|
|
if (total_size - free_block->size > (allocated_size * 3 / 2)) {
|
|
total_size -= free_block->size;
|
|
sljit_remove_free_block(free_block);
|
|
free_chunk(free_block, free_block->size + sizeof(struct block_header));
|
|
}
|
|
}
|
|
|
|
SLJIT_UPDATE_WX_FLAGS(NULL, NULL, 1);
|
|
SLJIT_ALLOCATOR_UNLOCK();
|
|
}
|
|
|
|
SLJIT_API_FUNC_ATTRIBUTE void sljit_free_unused_memory_exec(void)
|
|
{
|
|
struct free_block* free_block;
|
|
struct free_block* next_free_block;
|
|
|
|
SLJIT_ALLOCATOR_LOCK();
|
|
SLJIT_UPDATE_WX_FLAGS(NULL, NULL, 0);
|
|
|
|
free_block = free_blocks;
|
|
while (free_block) {
|
|
next_free_block = free_block->next;
|
|
if (!free_block->header.prev_size &&
|
|
AS_BLOCK_HEADER(free_block, free_block->size)->size == 1) {
|
|
total_size -= free_block->size;
|
|
sljit_remove_free_block(free_block);
|
|
free_chunk(free_block, free_block->size + sizeof(struct block_header));
|
|
}
|
|
free_block = next_free_block;
|
|
}
|
|
|
|
SLJIT_ASSERT((total_size && free_blocks) || (!total_size && !free_blocks));
|
|
SLJIT_UPDATE_WX_FLAGS(NULL, NULL, 1);
|
|
SLJIT_ALLOCATOR_UNLOCK();
|
|
}
|