From ca560895bb9027748b7e3c7fbfaa027c252bfe47 Mon Sep 17 00:00:00 2001 From: Aleksey Demakov Date: Fri, 12 Oct 2012 23:53:03 +0400 Subject: [PATCH] Remove jit_malloc_exec() and friends from public API. --- ChangeLog | 11 +++- doc/Makefile.am | 4 -- doc/libjit.texi | 1 - include/jit/jit-util.h | 5 +- jit/jit-alloc.c | 124 ++++------------------------------------- jit/jit-apply-arm.c | 6 +- jit/jit-apply.c | 2 +- jit/jit-cache.c | 12 ++-- jit/jit-compile.c | 2 +- jit/jit-elf-read.c | 16 +++--- jit/jit-function.c | 4 +- jit/jit-internal.h | 4 ++ jit/jit-util.c | 72 ++++++++++++++++++++++++ jit/jit-vmem.c | 8 +++ 14 files changed, 126 insertions(+), 145 deletions(-) diff --git a/ChangeLog b/ChangeLog index 66691b8..8f3514c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,8 +1,13 @@ 2012-10-12 Aleksey Demakov - * jit/jit-memory.h: remove file. - * jit/jit-memory.c: rename to jit/jit-util.c. - * jit/jit-string.c: append to jit/jit-util.c. + * include/jit/jit-util.h, jit/jit-alloc.c (jit_malloc_exec) + (jit_free_exec, jit_flush_exec, jit_exec_page_size): remove functions + from public API. + * jit/jit-internal.h, jit/jit-alloc.c (_jit_malloc_exec) + (_jit_free_exec, _jit_flush_exec): make these functions internal. + + * jit/jit-util.c: new file, move here all public util functions from + jit/jit-alloc.c, jit/jit-memory.c, jit/jit-string.c. 2012-10-08 Aleksey Demakov diff --git a/doc/Makefile.am b/doc/Makefile.am index 8f3e0f0..dce4520 100644 --- a/doc/Makefile.am +++ b/doc/Makefile.am @@ -5,7 +5,6 @@ EXTRA_DIST = $(man_MANS) $(EXTRA_SCRIPTS) info_TEXINFOS = libjit.texi libjit_TEXINFOS = \ - $(srcdir)/libjitext-alloc.texi \ $(srcdir)/libjitext-apply.texi \ $(srcdir)/libjitext-block.texi \ $(srcdir)/libjitext-context.texi \ @@ -30,9 +29,6 @@ libjit_TEXINFOS = \ $(srcdir)/libjitext-plus-function.texi \ $(srcdir)/libjitext-plus-value.texi -$(srcdir)/libjitext-alloc.texi: $(top_srcdir)/jit/jit-alloc.c - $(SHELL) $(srcdir)/extract-docs.sh $< >$@ - $(srcdir)/libjitext-apply.texi: $(top_srcdir)/jit/jit-apply.c $(SHELL) $(srcdir)/extract-docs.sh $< >$@ diff --git a/doc/libjit.texi b/doc/libjit.texi index 3e2c562..7d0c970 100644 --- a/doc/libjit.texi +++ b/doc/libjit.texi @@ -1057,7 +1057,6 @@ field with a @code{pointer to procedure/function} type. The @code{libjit} library provides a number of utility routines that it itself uses internally, but which may also be useful to front ends. -@include libjitext-alloc.texi @include libjitext-util.texi @include libjitext-meta.texi @include libjitext-apply.texi diff --git a/include/jit/jit-util.h b/include/jit/jit-util.h index c2d7556..2017183 100644 --- a/include/jit/jit-util.h +++ b/include/jit/jit-util.h @@ -34,10 +34,7 @@ void *jit_malloc(unsigned int size) JIT_NOTHROW; void *jit_calloc(unsigned int num, unsigned int size) JIT_NOTHROW; void *jit_realloc(void *ptr, unsigned int size) JIT_NOTHROW; void jit_free(void *ptr) JIT_NOTHROW; -void *jit_malloc_exec(unsigned int size) JIT_NOTHROW; -void jit_free_exec(void *ptr, unsigned int size) JIT_NOTHROW; -void jit_flush_exec(void *ptr, unsigned int size) JIT_NOTHROW; -unsigned int jit_exec_page_size(void) JIT_NOTHROW; + #define jit_new(type) ((type *)jit_malloc(sizeof(type))) #define jit_cnew(type) ((type *)jit_calloc(1, sizeof(type))) diff --git a/jit/jit-alloc.c b/jit/jit-alloc.c index 45d6a2c..a96620b 100644 --- a/jit/jit-alloc.c +++ b/jit/jit-alloc.c @@ -57,91 +57,22 @@ #endif #endif - -/*@ - * @section Memory allocation - * - * The @code{libjit} library provides an interface to the traditional - * system @code{malloc} routines. All heap allocation in @code{libjit} - * goes through these functions. If you need to perform some other kind - * of memory allocation, you can replace these functions with your - * own versions. -@*/ - -/*@ - * @deftypefun {void *} jit_malloc (unsigned int @var{size}) - * Allocate @var{size} bytes of memory from the heap. - * @end deftypefun - * - * @deftypefun {type *} jit_new (@var{type}) - * Allocate @code{sizeof(@var{type})} bytes of memory from the heap and - * cast the return pointer to @code{@var{type} *}. This is a macro that - * wraps up the underlying @code{jit_malloc} function and is less - * error-prone when allocating structures. - * @end deftypefun -@*/ -void *jit_malloc(unsigned int size) -{ - return malloc(size); -} - -/*@ - * @deftypefun {void *} jit_calloc (unsigned int @var{num}, unsigned int @var{size}) - * Allocate @code{@var{num} * @var{size}} bytes of memory from the heap and clear - * them to zero. - * @end deftypefun - * - * @deftypefun {type *} jit_cnew (@var{type}) - * Allocate @code{sizeof(@var{type})} bytes of memory from the heap and - * cast the return pointer to @code{@var{type} *}. The memory is cleared - * to zero. - * @end deftypefun -@*/ -void *jit_calloc(unsigned int num, unsigned int size) -{ - return calloc(num, size); -} - /*@ - * @deftypefun {void *} jit_realloc (void *@var{ptr}, unsigned int @var{size}) - * Re-allocate the memory at @var{ptr} to be @var{size} bytes in size. - * The memory block at @var{ptr} must have been allocated by a previous - * call to @code{jit_malloc}, @code{jit_calloc}, or @code{jit_realloc}. - * @end deftypefun -@*/ -void *jit_realloc(void *ptr, unsigned int size) -{ - return realloc(ptr, size); -} - -/*@ - * @deftypefun void jit_free (void *@var{ptr}) - * Free the memory at @var{ptr}. It is safe to pass a NULL pointer. - * @end deftypefun -@*/ -void jit_free(void *ptr) -{ - if(ptr) - { - free(ptr); - } -} - -/*@ - * @deftypefun {void *} jit_malloc_exec (unsigned int @var{size}) + * @deftypefun {void *} _jit_malloc_exec (unsigned int @var{size}) * Allocate a block of memory that is read/write/executable. Such blocks * are used to store JIT'ed code, function closures, and other trampolines. - * The size should be a multiple of @code{jit_exec_page_size()}. + * The size should be a multiple of @code{jit_vmem_page_size()}. * * This will usually be identical to @code{jit_malloc}. However, * some systems may need special handling to create executable code * segments, so this function must be used instead. * * You must never mix regular and executable segment allocation. That is, - * do not use @code{jit_free} to free the result of @code{jit_malloc_exec}. + * do not use @code{jit_free} to free the result of @code{_jit_malloc_exec}. * @end deftypefun @*/ -void *jit_malloc_exec(unsigned int size) +void * +_jit_malloc_exec(unsigned int size) { #if defined(JIT_WIN32_PLATFORM) return VirtualAlloc(NULL, size, @@ -162,14 +93,15 @@ void *jit_malloc_exec(unsigned int size) } /*@ - * @deftypefun void jit_free_exec (void *@var{ptr}, unsigned int @var{size}) + * @deftypefun void _jit_free_exec (void *@var{ptr}, unsigned int @var{size}) * Free a block of memory that was previously allocated by - * @code{jit_malloc_exec}. The @var{size} must be identical to the + * @code{_jit_malloc_exec}. The @var{size} must be identical to the * original allocated size, as some systems need to know this information * to be able to free the block. * @end deftypefun @*/ -void jit_free_exec(void *ptr, unsigned int size) +void +_jit_free_exec(void *ptr, unsigned int size) { if(ptr) { @@ -184,14 +116,15 @@ void jit_free_exec(void *ptr, unsigned int size) } /*@ - * @deftypefun void jit_flush_exec (void *@var{ptr}, unsigned int @var{size}) + * @deftypefun void _jit_flush_exec (void *@var{ptr}, unsigned int @var{size}) * Flush the contents of the block at @var{ptr} from the CPU's * data and instruction caches. This must be used after the code is * written to an executable code segment, but before the code is * executed, to prepare it for execution. * @end deftypefun @*/ -void jit_flush_exec(void *ptr, unsigned int size) +void +_jit_flush_exec(void *ptr, unsigned int size) { #define ROUND_BEG_PTR(p) \ @@ -269,36 +202,3 @@ void jit_flush_exec(void *ptr, unsigned int size) #endif #endif /* __GNUC__ */ } - -/*@ - * @deftypefun {unsigned int} jit_exec_page_size (void) - * Get the page allocation size for the system. This is the preferred - * unit when making calls to @code{jit_malloc_exec}. It is not - * required that you supply a multiple of this size when allocating, - * but it can lead to better performance on some systems. - * @end deftypefun -@*/ -unsigned int jit_exec_page_size(void) -{ -#ifndef JIT_WIN32_PLATFORM - /* Get the page size using a Unix-like sequence */ - #ifdef HAVE_GETPAGESIZE - return (unsigned long)getpagesize(); - #else - #ifdef NBPG - return NBPG; - #else - #ifdef PAGE_SIZE - return PAGE_SIZE; - #else - return 4096; - #endif - #endif - #endif -#else - /* Get the page size from a Windows-specific API */ - SYSTEM_INFO sysInfo; - GetSystemInfo(&sysInfo); - return (unsigned long)(sysInfo.dwPageSize); -#endif -} diff --git a/jit/jit-apply-arm.c b/jit/jit-apply-arm.c index 0f0513d..ed9ee2b 100644 --- a/jit/jit-apply-arm.c +++ b/jit/jit-apply-arm.c @@ -91,7 +91,7 @@ void *_jit_create_redirector(unsigned char *buf, void *func, arm_mov_reg_reg(inst, ARM_PC, ARM_R12); /* Flush the cache lines that we just wrote */ - jit_flush_exec(buf, ((unsigned char *)(inst.current)) - buf); + _jit_flush_exec(buf, ((unsigned char *)(inst.current)) - buf); /* Return the aligned start of the buffer as the entry point */ return (void *)buf; @@ -118,7 +118,7 @@ void *_jit_create_indirector(unsigned char *buf, void **entry) arm_mov_reg_reg(inst, ARM_PC, ARM_WORK); /* Flush the cache lines that we just wrote */ - jit_flush_exec(buf, ((unsigned char *)(inst.current)) - buf); + _jit_flush_exec(buf, ((unsigned char *)(inst.current)) - buf); return start; } @@ -137,7 +137,7 @@ void _jit_pad_buffer(unsigned char *buf, int len) } /* Flush the cache lines that we just wrote */ - jit_flush_exec(buf, ((unsigned char *)(inst.current)) - buf); + _jit_flush_exec(buf, ((unsigned char *)(inst.current)) - buf); } #endif /* arm */ diff --git a/jit/jit-apply.c b/jit/jit-apply.c index 4d5331c..0b4ecef 100644 --- a/jit/jit-apply.c +++ b/jit/jit-apply.c @@ -906,7 +906,7 @@ jit_closure_create(jit_context_t context, jit_type_t signature, jit_closure_func closure->user_data = user_data; /* Perform a cache flush on the closure's code */ - jit_flush_exec(closure->buf, sizeof(closure->buf)); + _jit_flush_exec(closure->buf, sizeof(closure->buf)); /* Unlock the cache, as we are finished with it */ jit_mutex_unlock(&context->cache_lock); diff --git a/jit/jit-cache.c b/jit/jit-cache.c index c4b3951..62536ce 100644 --- a/jit/jit-cache.c +++ b/jit/jit-cache.c @@ -146,7 +146,7 @@ AllocCachePage(jit_cache_t cache, int factor) } /* Try to allocate a physical page */ - ptr = (unsigned char *) jit_malloc_exec((unsigned int) cache->pageSize * factor); + ptr = (unsigned char *) _jit_malloc_exec((unsigned int) cache->pageSize * factor); if(!ptr) { goto failAlloc; @@ -176,7 +176,7 @@ AllocCachePage(jit_cache_t cache, int factor) sizeof(struct jit_cache_page) * num); if(!list) { - jit_free_exec(ptr, cache->pageSize * factor); + _jit_free_exec(ptr, cache->pageSize * factor); failAlloc: cache->free_start = 0; cache->free_end = 0; @@ -380,7 +380,7 @@ _jit_cache_create(jit_context_t context) } /* determine the default cache page size */ - exec_page_size = jit_exec_page_size(); + exec_page_size = jit_vmem_page_size(); if(cache_page_size <= 0) { cache_page_size = JIT_CACHE_PAGE_SIZE; @@ -446,8 +446,8 @@ _jit_cache_destroy(jit_cache_t cache) /* Free all of the cache pages */ for(page = 0; page < cache->numPages; ++page) { - jit_free_exec(cache->pages[page].page, - cache->pageSize * cache->pages[page].factor); + _jit_free_exec(cache->pages[page].page, + cache->pageSize * cache->pages[page].factor); } if(cache->pages) { @@ -476,7 +476,7 @@ _jit_cache_extend(jit_cache_t cache, int count) if((cache->free_start == ((unsigned char *)p->page)) && (cache->free_end == (cache->free_start + cache->pageSize * p->factor))) { - jit_free_exec(p->page, cache->pageSize * p->factor); + _jit_free_exec(p->page, cache->pageSize * p->factor); --(cache->numPages); if(cache->pagesLeft >= 0) diff --git a/jit/jit-compile.c b/jit/jit-compile.c index 40860f3..151e381 100644 --- a/jit/jit-compile.c +++ b/jit/jit-compile.c @@ -523,7 +523,7 @@ cache_flush(_jit_compile_t *state) #ifndef JIT_BACKEND_INTERP /* On success perform a CPU cache flush, to make the code executable */ - jit_flush_exec(state->code_start, + _jit_flush_exec(state->code_start, (unsigned int)(state->code_end - state->code_start)); #endif diff --git a/jit/jit-elf-read.c b/jit/jit-elf-read.c index a2bca7d..7d23e46 100644 --- a/jit/jit-elf-read.c +++ b/jit/jit-elf-read.c @@ -299,7 +299,7 @@ static int map_program(jit_readelf_t readelf, int fd) int zero_fd, prot; /* Round the total memory and file sizes up to the CPU page size */ - page_size = (Elf_Off)(jit_exec_page_size()); + page_size = (Elf_Off)(jit_vmem_page_size()); end = memory_size; if((end % page_size) != 0) { @@ -416,7 +416,7 @@ failed_mmap: /* If we haven't mapped the file yet, then fall back to "malloc" */ if(!base_address) { - base_address = jit_malloc_exec(memory_size); + base_address = _jit_malloc_exec(memory_size); if(!base_address) { return 0; @@ -433,7 +433,7 @@ failed_mmap: read(fd, segment_address, (size_t)(phdr->p_filesz)) != (int)(size_t)(phdr->p_filesz)) { - jit_free_exec(base_address, memory_size); + _jit_free_exec(base_address, memory_size); return 0; } } @@ -458,19 +458,19 @@ static void *map_section(int fd, Elf_Off offset, Elf_Xword file_size, { memory_size = file_size; } - address = jit_malloc_exec(memory_size); + address = _jit_malloc_exec(memory_size); if(!address) { return 0; } if(lseek(fd, (off_t)offset, 0) != (off_t)offset) { - jit_free_exec(address, memory_size); + _jit_free_exec(address, memory_size); return 0; } if(read(fd, address, (size_t)file_size) != (int)(size_t)file_size) { - jit_free_exec(address, memory_size); + _jit_free_exec(address, memory_size); return 0; } return address; @@ -488,7 +488,7 @@ static void unmap_section(void *address, Elf_Xword file_size, } if((flags & JIT_ELF_IS_MALLOCED) != 0) { - jit_free_exec(address, (unsigned int)memory_size); + _jit_free_exec(address, (unsigned int)memory_size); } } @@ -1105,7 +1105,7 @@ void jit_readelf_close(jit_readelf_t readelf) else #endif { - jit_free_exec(readelf->map_address, readelf->map_size); + _jit_free_exec(readelf->map_address, readelf->map_size); } for(index = 0; index < readelf->ehdr.e_shnum; ++index) { diff --git a/jit/jit-function.c b/jit/jit-function.c index 6a05958..b8c5768 100644 --- a/jit/jit-function.c +++ b/jit/jit-function.c @@ -103,11 +103,11 @@ jit_function_create(jit_context_t context, jit_type_t signature) func->entry_point = _jit_create_redirector (func->redirector, (void *) context->on_demand_driver, func, jit_type_get_abi(signature)); - jit_flush_exec(func->redirector, jit_redirector_size); + _jit_flush_exec(func->redirector, jit_redirector_size); #endif #if !defined(JIT_BACKEND_INTERP) && defined(jit_indirector_size) _jit_create_indirector(func->indirector, (void**) &(func->entry_point)); - jit_flush_exec(func->indirector, jit_indirector_size); + _jit_flush_exec(func->indirector, jit_indirector_size); #endif /* Add the function to the context list */ diff --git a/jit/jit-internal.h b/jit/jit-internal.h index 1b52dd8..fe68aef 100644 --- a/jit/jit-internal.h +++ b/jit/jit-internal.h @@ -81,6 +81,10 @@ extern "C" { */ #include "jit-varint.h" +void *_jit_malloc_exec(unsigned int size); +void _jit_free_exec(void *ptr, unsigned int size); +void _jit_flush_exec(void *ptr, unsigned int size); + /* * The following is some macro magic that attempts to detect * the best alignment to use on the target platform. The final diff --git a/jit/jit-util.c b/jit/jit-util.c index 9f2ec0c..4dfab68 100644 --- a/jit/jit-util.c +++ b/jit/jit-util.c @@ -24,6 +24,9 @@ #include "jit-config.h" #include +#ifdef HAVE_STDLIB_H +# include +#endif #if defined(HAVE_STRING_H) # include #elif defined(HAVE_STRINGS_H) @@ -48,6 +51,75 @@ #undef jit_memcmp #undef jit_memchr +/*@ + * @section Memory allocation + * + * The @code{libjit} library provides an interface to the traditional + * system @code{malloc} routines. All heap allocation in @code{libjit} + * goes through these functions. If you need to perform some other kind + * of memory allocation, you can replace these functions with your + * own versions. +@*/ + +/*@ + * @deftypefun {void *} jit_malloc (unsigned int @var{size}) + * Allocate @var{size} bytes of memory from the heap. + * @end deftypefun + * + * @deftypefun {type *} jit_new (@var{type}) + * Allocate @code{sizeof(@var{type})} bytes of memory from the heap and + * cast the return pointer to @code{@var{type} *}. This is a macro that + * wraps up the underlying @code{jit_malloc} function and is less + * error-prone when allocating structures. + * @end deftypefun +@*/ +void *jit_malloc(unsigned int size) +{ + return malloc(size); +} + +/*@ + * @deftypefun {void *} jit_calloc (unsigned int @var{num}, unsigned int @var{size}) + * Allocate @code{@var{num} * @var{size}} bytes of memory from the heap and clear + * them to zero. + * @end deftypefun + * + * @deftypefun {type *} jit_cnew (@var{type}) + * Allocate @code{sizeof(@var{type})} bytes of memory from the heap and + * cast the return pointer to @code{@var{type} *}. The memory is cleared + * to zero. + * @end deftypefun +@*/ +void *jit_calloc(unsigned int num, unsigned int size) +{ + return calloc(num, size); +} + +/*@ + * @deftypefun {void *} jit_realloc (void *@var{ptr}, unsigned int @var{size}) + * Re-allocate the memory at @var{ptr} to be @var{size} bytes in size. + * The memory block at @var{ptr} must have been allocated by a previous + * call to @code{jit_malloc}, @code{jit_calloc}, or @code{jit_realloc}. + * @end deftypefun +@*/ +void *jit_realloc(void *ptr, unsigned int size) +{ + return realloc(ptr, size); +} + +/*@ + * @deftypefun void jit_free (void *@var{ptr}) + * Free the memory at @var{ptr}. It is safe to pass a NULL pointer. + * @end deftypefun +@*/ +void jit_free(void *ptr) +{ + if(ptr) + { + free(ptr); + } +} + /*@ * @section Memory set, copy, compare, etc * @cindex Memory operations diff --git a/jit/jit-vmem.c b/jit/jit-vmem.c index dfdaf6c..d5f7118 100644 --- a/jit/jit-vmem.c +++ b/jit/jit-vmem.c @@ -108,6 +108,14 @@ jit_vmem_init(void) #endif } +/*@ + * @deftypefun {unsigned int} jit_vmem_page_size (void) + * Get the page allocation size for the system. This is the preferred + * unit when making calls to @code{_jit_malloc_exec}. It is not + * required that you supply a multiple of this size when allocating, + * but it can lead to better performance on some systems. + * @end deftypefun +@*/ jit_uint jit_vmem_page_size(void) { -- 2.47.3