9b737f65b1
Patch from davefiddes. Original commit message : This fixes the following warnings: codegen_allocator.c: - implict function declaration of rand() due to missing stdlib.h codegen_backend_x86-64.c: - implict function declaration of malloc() due to missing stdlib.h - unused variables in codegen_backend_init() - invalid typecast in use of host_x86_CALL() codegen_backend_x86-64-uop.c: - Remove unused variable declarations in codegen_CALL_FUNC_RESULT(), codegen_LOAD_SEG(), codegen_OR_IMM(), codegen_XOR() and codegen_XOR_IMM() - Move debug only variable declarations under the debug conditional define in codegen_CALL_FUNC_RESULT(), codegen_LOAD_SEG(), codegen_MEM_LOAD_SINGLE(), codegen_MEM_LOAD_DOUBLE(), codegen_MEM_STORE_SINGLE(), codegen_MEM_STORE_DOUBLE() codegen_reg.c: - Change (int) typecasts to the correct (intptr_t) for small values stored in a pointer. This fixes a series of 64-bit compilation warnings. Tests: - Build with no warnings on Fedora 32 with gcc 10.1 - Boot a Win98 machine with dynamic compilation enabled
127 lines
4 KiB
C
127 lines
4 KiB
C
#if defined(__linux__) || defined(__APPLE__)
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#endif
|
|
#if defined WIN32 || defined _WIN32 || defined _WIN32
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#include "ibm.h"
|
|
#include "codegen.h"
|
|
#include "codegen_allocator.h"
|
|
|
|
typedef struct mem_block_t
|
|
{
|
|
uint32_t offset; /*Offset into mem_block_alloc*/
|
|
uint32_t next;
|
|
uint16_t code_block;
|
|
} mem_block_t;
|
|
|
|
static mem_block_t mem_blocks[MEM_BLOCK_NR];
|
|
static uint32_t mem_block_free_list;
|
|
static uint8_t *mem_block_alloc = NULL;
|
|
|
|
int codegen_allocator_usage = 0;
|
|
|
|
void codegen_allocator_init()
|
|
{
|
|
int c;
|
|
|
|
#if defined WIN32 || defined _WIN32 || defined _WIN32
|
|
mem_block_alloc = VirtualAlloc(NULL, MEM_BLOCK_NR * MEM_BLOCK_SIZE, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
|
|
#else
|
|
mem_block_alloc = mmap(0, MEM_BLOCK_NR * MEM_BLOCK_SIZE, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, 0, 0);
|
|
#endif
|
|
|
|
for (c = 0; c < MEM_BLOCK_NR; c++)
|
|
{
|
|
mem_blocks[c].offset = c * MEM_BLOCK_SIZE;
|
|
mem_blocks[c].code_block = BLOCK_INVALID;
|
|
if (c < MEM_BLOCK_NR-1)
|
|
mem_blocks[c].next = c+2;
|
|
else
|
|
mem_blocks[c].next = 0;
|
|
}
|
|
mem_block_free_list = 1;
|
|
}
|
|
|
|
mem_block_t *codegen_allocator_allocate(mem_block_t *parent, int code_block)
|
|
{
|
|
mem_block_t *block;
|
|
uint32_t block_nr;
|
|
|
|
while (!mem_block_free_list)
|
|
{
|
|
/*Pick a random memory block and free the owning code block*/
|
|
block_nr = rand() & MEM_BLOCK_MASK;
|
|
block = &mem_blocks[block_nr];
|
|
|
|
if (block->code_block && block->code_block != code_block)
|
|
codegen_delete_block(&codeblock[block->code_block]);
|
|
}
|
|
// fatal("codegen_allocator_allocate: free list empty!\n");
|
|
|
|
/*Remove from free list*/
|
|
block_nr = mem_block_free_list;
|
|
block = &mem_blocks[block_nr-1];
|
|
mem_block_free_list = block->next;
|
|
|
|
block->code_block = code_block;
|
|
if (parent)
|
|
{
|
|
/*Add to parent list*/
|
|
block->next = parent->next;
|
|
parent->next = block_nr;
|
|
}
|
|
else
|
|
block->next = 0;
|
|
|
|
codegen_allocator_usage++;
|
|
/* if (parent)
|
|
pclog("codegen_allocator_allocate with parent: %p %i %i %p\n", block, block_nr, codegen_allocator_usage, parent);
|
|
else
|
|
pclog("codegen_allocator_allocate: %p %i %i\n", block, block_nr, codegen_allocator_usage);*/
|
|
return block;
|
|
}
|
|
void codegen_allocator_free(mem_block_t *block)
|
|
{
|
|
int block_nr = (((uintptr_t)block - (uintptr_t)mem_blocks) / sizeof(mem_block_t)) + 1;
|
|
|
|
// pclog("codegen_allocator_free: %p %i %i %i\n", block, block_nr, codegen_allocator_usage, block->next);
|
|
while (1)
|
|
{
|
|
int next_block_nr = block->next;
|
|
// pclog(" free next=%i\n", next_block_nr);
|
|
codegen_allocator_usage--;
|
|
|
|
block->next = mem_block_free_list;
|
|
block->code_block = BLOCK_INVALID;
|
|
mem_block_free_list = block_nr;
|
|
block_nr = next_block_nr;
|
|
|
|
if (block_nr)
|
|
block = &mem_blocks[block_nr - 1];
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint8_t *codeblock_allocator_get_ptr(mem_block_t *block)
|
|
{
|
|
return &mem_block_alloc[block->offset];
|
|
}
|
|
|
|
void codegen_allocator_clean_blocks(struct mem_block_t *block)
|
|
{
|
|
#if defined __ARM_EABI__ || defined __aarch64__
|
|
while (1)
|
|
{
|
|
__clear_cache(&mem_block_alloc[block->offset], &mem_block_alloc[block->offset + MEM_BLOCK_SIZE]);
|
|
if (block->next)
|
|
block = &mem_blocks[block->next - 1];
|
|
else
|
|
break;
|
|
}
|
|
#endif
|
|
}
|