[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (l
From: |
Aleksey Demakov |
Subject: |
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, cache-refactoring, updated. ca560895bb9027748b7e3c7fbfaa027c252bfe47 |
Date: |
Fri, 12 Oct 2012 19:54:28 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "DotGNU Portable.NET Just In Time compiler (libjit)".
The branch, cache-refactoring has been updated
via ca560895bb9027748b7e3c7fbfaa027c252bfe47 (commit)
from 708d469c76e680b80b9caa6a1f5bb54242bf16a9 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/libjit.git/commit/?id=ca560895bb9027748b7e3c7fbfaa027c252bfe47
commit ca560895bb9027748b7e3c7fbfaa027c252bfe47
Author: Aleksey Demakov <address@hidden>
Date: Fri Oct 12 23:53:03 2012 +0400
Remove jit_malloc_exec() and friends from public API.
diff --git a/ChangeLog b/ChangeLog
index 66691b8..8f3514c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,8 +1,13 @@
2012-10-12 Aleksey Demakov <address@hidden>
- * 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 <address@hidden>
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.
address@hidden 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.
address@hidden/
-
-/*@
- * @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 @address@hidden *}. This is a macro that
- * wraps up the underlying @code{jit_malloc} function and is less
- * error-prone when allocating structures.
- * @end deftypefun
address@hidden/
-void *jit_malloc(unsigned int size)
-{
- return malloc(size);
-}
-
-/*@
- * @deftypefun {void *} jit_calloc (unsigned int @var{num}, unsigned int
@var{size})
- * Allocate @address@hidden * @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 @address@hidden *}. The memory is cleared
- * to zero.
- * @end deftypefun
address@hidden/
-void *jit_calloc(unsigned int num, unsigned int size)
-{
- return calloc(num, size);
-}
-
/*@
- * @deftypefun {void *} jit_realloc (void address@hidden, 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
address@hidden/
-void *jit_realloc(void *ptr, unsigned int size)
-{
- return realloc(ptr, size);
-}
-
-/*@
- * @deftypefun void jit_free (void address@hidden)
- * Free the memory at @var{ptr}. It is safe to pass a NULL pointer.
- * @end deftypefun
address@hidden/
-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 address@hidden, unsigned int
@var{size})
+ * @deftypefun void _jit_free_exec (void address@hidden, 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 address@hidden, unsigned int
@var{size})
+ * @deftypefun void _jit_flush_exec (void address@hidden, 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
address@hidden/
-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 <stdio.h>
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
#if defined(HAVE_STRING_H)
# include <string.h>
#elif defined(HAVE_STRINGS_H)
@@ -49,6 +52,75 @@
#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.
address@hidden/
+
+/*@
+ * @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 @address@hidden *}. This is a macro that
+ * wraps up the underlying @code{jit_malloc} function and is less
+ * error-prone when allocating structures.
+ * @end deftypefun
address@hidden/
+void *jit_malloc(unsigned int size)
+{
+ return malloc(size);
+}
+
+/*@
+ * @deftypefun {void *} jit_calloc (unsigned int @var{num}, unsigned int
@var{size})
+ * Allocate @address@hidden * @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 @address@hidden *}. The memory is cleared
+ * to zero.
+ * @end deftypefun
address@hidden/
+void *jit_calloc(unsigned int num, unsigned int size)
+{
+ return calloc(num, size);
+}
+
+/*@
+ * @deftypefun {void *} jit_realloc (void address@hidden, 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
address@hidden/
+void *jit_realloc(void *ptr, unsigned int size)
+{
+ return realloc(ptr, size);
+}
+
+/*@
+ * @deftypefun void jit_free (void address@hidden)
+ * Free the memory at @var{ptr}. It is safe to pass a NULL pointer.
+ * @end deftypefun
address@hidden/
+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
address@hidden/
jit_uint
jit_vmem_page_size(void)
{
-----------------------------------------------------------------------
Summary of changes:
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(-)
hooks/post-receive
--
DotGNU Portable.NET Just In Time compiler (libjit)
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, cache-refactoring, updated. ca560895bb9027748b7e3c7fbfaa027c252bfe47,
Aleksey Demakov <=