(dump_size): Renamed to dumpmemory_marker.
* src/mm/dumpmemory.h: Likewise.
(DMARKER, DRELEASE): New macros.
* src/cacaoh/dummy.c,
src/mm/cacao-gc/gc.c,
src/mm/memory.h,
src/native/native.c,
src/native/vm/gnu/java_lang_VMRuntime.c,
src/vm/builtin.c,
src/vm/jit/codegen-common.c,
src/vm/jit/intrp/codegen.c,
src/vm/jit/jit.c,
src/vm/jit/replace.c,
src/vm/jit/show.c,
src/vm/jit/trace.c,
src/vm/vm.c,
src/vmcore/class.c,
src/vmcore/loader.c: Use new macros.
return malloc(size);
}
-void dump_release(int32_t size)
+int32_t dumpmemory_marker(void)
{
+ return 0;
}
-int32_t dump_size(void)
+void dumpmemory_release(int32_t size)
{
- return 0;
}
/* src/mm/cacao-gc/gc.c - main garbage collector methods
- Copyright (C) 2006 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
#include "config.h"
+
#include <signal.h>
+#include <stdint.h>
+
#include "vm/types.h"
#include "threads/lock-common.h"
void gc_collect(s4 level)
{
rootset_t *rs;
- s4 dumpsize;
+ int32_t dumpmarker;
#if !defined(NDEBUG)
stackframeinfo_t *sfi;
stacktracebuffer *stb;
GC_MUTEX_LOCK;
/* remember start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
GCSTAT_COUNT(gcstat_collections);
RT_TIMING_TIME_DIFF(time_start , time_end , RT_TIMING_GC_TOTAL);
/* free dump memory area */
- dump_release(dumpsize);
+ DRELEASE;
/* leave the global gc lock */
GC_MUTEX_UNLOCK;
NULL iff `size` was zero
ERROR HANDLING:
- XXX This function uses `memory_checked_alloc`, which *exits* if no
- memory could be allocated.
+ XXX This function uses `memory_checked_alloc`, which *exits* if
+ no memory could be allocated.
THREADS:
- dump_alloc is thread safe. Each thread has its own dump memory area.
+ dumpmemory_get is thread safe. Each thread has its own dump
+ memory area.
This function is a fast allocator suitable for scratch memory that
can be collectively freed when the current activity (eg. compiling)
You cannot selectively free dump memory. Before you start
allocating it, you remember the current size returned by
- `dump_size`. Later, when you no longer need the memory, call
- `dump_release` with the remembered size and all dump memory
- allocated since the call to `dump_size` will be freed.
+ `dumpmemory_marker`. Later, when you no longer need the memory,
+ call `dumpmemory_release` with the remembered size and all dump
+ memory allocated since the call to `dumpmemory_marker` will be
+ freed.
*******************************************************************************/
}
-/* dump_release ****************************************************************
+/* dumpmemory_release **********************************************************
Release dump memory above the given size.
IN:
size........All dump memory above this mark will be freed. Usually
- `size` will be the return value of a `dump_size` call
- made earlier.
+ `size` will be the return value of a `dumpmemory_marker`
+ call made earlier.
ERROR HANDLING:
XXX If the given size is invalid, this function *exits* with an
*******************************************************************************/
-void dump_release(s4 size)
+void dumpmemory_release(s4 size)
{
#if defined(DISABLE_DUMP)
}
-/* dump_size *******************************************************************
+/* dumpmemory_marker ***********************************************************
- Return the current size of the dump memory area. See `dump_alloc`.
+ Returns a marker of the dump memory area. This marker is actually
+ the used size of the dump memory area.
+
+ RETURN VALUE:
+ marker of the current dump memory status
*******************************************************************************/
-s4 dump_size(void)
+int32_t dumpmemory_marker(void)
{
#if defined(DISABLE_DUMP)
/* use malloc memory for dump memory (for debugging only!) */
/* convenience macros *********************************************************/
+#define DMARKER dumpmarker = dumpmemory_marker()
+#define DRELEASE dumpmemory_release(dumpmarker)
+
#define DNEW(type) ((type *) dumpmemory_get(sizeof(type)))
#define DMNEW(type,num) ((type *) dumpmemory_get(sizeof(type) * (num)))
#define DMREALLOC(ptr,type,num1,num2) dumpmemory_realloc((ptr), sizeof(type) * (num1), \
void *dumpmemory_get(size_t size);
void *dumpmemory_realloc(void *src, int32_t len1, int32_t len2);
-int32_t dump_size(void);
-void dump_release(int32_t size);
+int32_t dumpmemory_marker(void);
+void dumpmemory_release(int32_t size);
#endif /* _DUMPMEMORY_H */
mem_realloc ... change size of a memory block (position may change)
mem_usage ..... amount of allocated memory
-
- 2. explicit allocating, automatic deallocating
-
- dump_alloc .... allocate a memory block in the dump area
- dump_realloc .. change size of a memory block (position may change)
- dump_size ..... marks the current top of dump
- dump_release .. free all memory requested after the mark
-
-
There are some useful macros:
NEW (type) ....... allocate memory for an element of type `type`
MREALLOC (ptr,type,num1,num2) .. enlarge the array to size num2
-These macros do the same except they operate on the dump area:
-
- DNEW, DMNEW, DMREALLOC (there is no DFREE)
-
-
-------------------------------------------------------------------------------
Some more macros:
/* src/native/native.c - table of native functions
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
char *utf_ptr;
u2 c;
s4 i;
- s4 dumpsize;
utf *u;
+ int32_t dumpmarker;
/* mark memory */
- dumpsize = dump_size();
+ DMARKER;
utf_ptr = descriptor->text;
namelen = strlen(name->text) + strlen("__") + strlen("0");
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
return u;
}
char *utf_endptr;
u2 c;
u4 pos;
- s4 dumpsize;
utf *u;
+ int32_t dumpmarker;
/* mark memory */
- dumpsize = dump_size();
+ DMARKER;
/* Calculate length of native function name. We multiply the
class and method name length by 6 as this is the maxium
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
return u;
}
/* src/native/vm/gnu/java_lang_VMRuntime.c
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
# include <mach/mach.h>
#endif
+#include "mm/dumpmemory.h"
#include "mm/gc-common.h"
-#include "mm/memory.h"
#include "native/jni.h"
#include "native/native.h"
utf *u;
char *buffer;
int32_t buffer_len;
- int32_t dumpsize;
java_handle_t *o;
+ int32_t dumpmarker;
if (libname == NULL) {
exceptions_throw_nullpointerexception();
buffer_len += strlen("0");
- dumpsize = dump_size();
+ DMARKER;
+
buffer = DMNEW(char, buffer_len);
/* generate library name */
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
return (java_lang_String *) o;
}
/* src/vm/builtin.c - functions for unsupported operations
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
static bool builtintable_init(void)
{
descriptor_pool *descpool;
- s4 dumpsize;
builtintable_entry *bte;
methodinfo *m;
+ int32_t dumpmarker;
/* mark start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
/* create a new descriptor pool */
if (!descriptor_pool_add(descpool, bte->descriptor, NULL)) {
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
return false;
}
bte->descriptor = utf_new_char(bte->cdescriptor);
if (!descriptor_pool_add(descpool, bte->descriptor, NULL)) {
- dump_release(dumpsize);
+ DRELEASE;
return false;
}
}
bte->descriptor = utf_new_char(bte->cdescriptor);
if (!descriptor_pool_add(descpool, bte->descriptor, NULL)) {
- dump_release(dumpsize);
+ DRELEASE;
return false;
}
}
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
return true;
}
/* src/vm/jit/codegen-common.c - architecture independent code generator stuff
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
codegendata *cd;
ptrint *d; /* pointer to data memory */
u1 *c; /* pointer to code memory */
- s4 dumpsize;
+ int32_t dumpmarker;
/* mark dump memory */
- dumpsize = dump_size();
+ DMARKER;
/* allocate required data structures */
/* release dump memory */
- dump_release(dumpsize);
+ DRELEASE;
/* return native stub code */
jitdata *jd;
codeinfo *code;
int skipparams;
- s4 dumpsize;
+ int32_t dumpmarker;
/* mark dump memory */
- dumpsize = dump_size();
+ DMARKER;
/* Create JIT data structure. */
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
}
{
jitdata *jd;
codeinfo *code;
- s4 dumpsize;
methoddesc *md;
methoddesc *nmd;
int skipparams;
+ int32_t dumpmarker;
/* mark dump memory */
- dumpsize = dump_size();
+ DMARKER;
/* Create JIT data structure. */
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
/* return native stub code */
/* src/vm/jit/intrp/codegen.c - code generator for Interpreter
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
Inst *s;
Inst *d;
codegendata *cd;
- s4 dumpsize;
s4 stackframesize;
+ int32_t dumpmarker;
s = CNEW(Inst, COMPILERSTUB_SIZE);
/* mark start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
cd = DNEW(codegendata);
cd->mcodeptr = (u1 *) s;
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
return (u1 *) s;
}
jitdata *jd;
codegendata *cd;
registerdata *rd;
- s4 dumpsize;
methoddesc *md;
+ int32_t dumpmarker;
/* mark dump memory */
- dumpsize = dump_size();
+ DMARKER;
/* allocate memory */
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
return entrypoint;
}
/* src/vm/jit/jit.c - calls the code generation functions
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
{
u1 *r;
jitdata *jd;
- s4 dumpsize;
+ int32_t dumpmarker;
STATISTICS(count_jit_calls++);
/* mark start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
/* create jitdata structure */
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
#if defined(ENABLE_STATISTICS)
/* measure time */
u1 *r;
jitdata *jd;
u1 optlevel;
- s4 dumpsize;
+ int32_t dumpmarker;
/* check for max. optimization level */
/* mark start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
/* create jitdata structure */
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
#if defined(ENABLE_STATISTICS)
/* measure time */
/* src/vm/jit/replace.c - on-stack replacement of methods
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
stackframeinfo_t *sfi;
sourcestate_t *ss;
sourceframe_t *frame;
- s4 dumpsize;
codeinfo *origcode;
rplpoint *origrp;
#if defined(ENABLE_THREADS) && defined(ENABLE_GC_CACAO)
threadobject *thread;
#endif
+ int32_t dumpmarker;
origcode = es->code;
origrp = rp;
/* mark start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
/* get the stackframeinfo for the current thread */
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
}
/* src/vm/jit/show.c - showing the intermediate representation
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
int res;
char *method_name;
s4 len;
- s4 dumpsize;
+ int32_t dumpmarker;
/* compose full name of method */
utf_bytes(m->descriptor) +
1;
- dumpsize = dump_size(); /* allocate memory */
+ DMARKER;
method_name = DMNEW(char, len);
/* release memory */
- dump_release(dumpsize);
-
+ DRELEASE;
}
#define STATE_IS_INITIAL() ((FILTERVERBOSECALLCTR[0] == 0) && (FILTERVERBOSECALLCTR[1] == 0))
/* src/vm/jit/trace.c - Functions for tracing from java code.
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
imm_union arg;
char *logtext;
s4 logtextlen;
- s4 dumpsize;
s4 i;
s4 pos;
+ int32_t dumpmarker;
#if defined(ENABLE_DEBUG_FILTER)
if (!show_filters_test_verbosecall_enter(m))
/* allocate memory */
- dumpsize = dump_size();
+ DMARKER;
logtext = DMNEW(char, logtextlen);
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
TRACEJAVACALLINDENT++;
methoddesc *md;
char *logtext;
s4 logtextlen;
- s4 dumpsize;
s4 i;
s4 pos;
imm_union val;
+ int32_t dumpmarker;
#if defined(ENABLE_DEBUG_FILTER)
if (!show_filters_test_verbosecall_exit(m))
/* allocate memory */
- dumpsize = dump_size();
+ DMARKER;
logtext = DMNEW(char, logtextlen);
/* release memory */
- dump_release(dumpsize);
-
+ DRELEASE;
}
{
char *logtext;
s4 logtextlen;
- s4 dumpsize;
codeinfo *code;
+ int32_t dumpmarker;
/* calculate message length */
/* allocate memory */
- dumpsize = dump_size();
+ DMARKER;
logtext = DMNEW(char, logtextlen);
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
}
java_lang_String *s;
char *logtext;
s4 logtextlen;
- s4 dumpsize;
+ int32_t dumpmarker;
t = (java_lang_Throwable *) xptr;
/* allocate memory */
- dumpsize = dump_size();
+ DMARKER;
logtext = DMNEW(char, logtextlen);
/* release memory */
- dump_release(dumpsize);
+ DRELEASE;
}
/* src/vm/vm.c - VM startup and shutdown functions
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
This file is part of CACAO.
type vm_call_method##name##_valist(methodinfo *m, java_handle_t *o, \
va_list ap) \
{ \
- int32_t dumpsize; \
uint64_t *array; \
type value; \
+ int32_t dumpmarker; \
\
if (m->code == NULL) \
if (!jit_compile(m)) \
return 0; \
\
THREAD_NATIVEWORLD_EXIT; \
+ DMARKER; \
\
- dumpsize = dump_size(); \
array = argument_vmarray_from_valist(m, o, ap); \
value = vm_call##name##_array(m, array); \
- dump_release(dumpsize); \
\
+ DRELEASE; \
THREAD_NATIVEWORLD_ENTER; \
\
return value; \
type vm_call_method##name##_jvalue(methodinfo *m, java_handle_t *o, \
const jvalue *args) \
{ \
- int32_t dumpsize; \
uint64_t *array; \
type value; \
+ int32_t dumpmarker; \
\
if (m->code == NULL) \
if (!jit_compile(m)) \
return 0; \
\
THREAD_NATIVEWORLD_EXIT; \
+ DMARKER; \
\
- dumpsize = dump_size(); \
array = argument_vmarray_from_jvalue(m, o, args); \
value = vm_call##name##_array(m, array); \
- dump_release(dumpsize); \
\
+ DRELEASE; \
THREAD_NATIVEWORLD_ENTER; \
\
return value; \
java_handle_t *vm_call_method_objectarray(methodinfo *m, java_handle_t *o,
java_handle_objectarray_t *params)
{
- int32_t dumpsize;
uint64_t *array;
java_handle_t *xptr;
java_handle_t *ro;
imm_union value;
+ int32_t dumpmarker;
/* compile methods which are not yet compiled */
/* mark start of dump memory area */
- dumpsize = dump_size();
+ DMARKER;
/* Fill the argument array from a object-array. */
if (array == NULL) {
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
/* enter the nativeworld again */
/* release dump area */
- dump_release(dumpsize);
+ DRELEASE;
/* enter the nativeworld again */
/* src/vmcore/class.c - class related functions
- Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zu Foerderung der freien virtuellen Machine CACAO
+
This file is part of CACAO.
char *namebuf;
utf *u;
classinfo *c;
- s4 dumpsize;
+ int32_t dumpmarker;
cl = component->classloader;
- dumpsize = dump_size();
+ DMARKER;
/* Assemble the array class name */
namelen = component->name->blength;
c = get_array_class(u, cl, cl, link);
- dump_release(dumpsize);
+ DRELEASE;
return c;
}
{
s4 namelen;
char *namebuf;
- s4 dumpsize;
classinfo *c;
+ int32_t dumpmarker;
- dumpsize = dump_size();
+ DMARKER;
if (dim < 1) {
log_text("Invalid array dimension requested");
element->classloader,
link);
- dump_release(dumpsize);
+ DRELEASE;
return c;
}
{
s4 namelen;
char *namebuf;
- s4 dumpsize;
constant_classref *cr;
+ int32_t dumpmarker;
assert(ref);
assert(dim >= 1 && dim <= 255);
- dumpsize = dump_size();
+ DMARKER;
/* Assemble the array class name */
namelen = ref->name->blength;
cr = class_get_classref(ref->referer,utf_new(namebuf, namelen));
- dump_release(dumpsize);
+ DRELEASE;
return cr;
}
classinfo *load_class_from_classbuffer(classbuffer *cb)
{
classinfo *c;
- int32_t dumpsize;
bool result;
+ int32_t dumpmarker;
/* Get the classbuffer's class. */
/* Mark start of dump memory area. */
- dumpsize = dump_size();
+ DMARKER;
/* Class is currently loading. */
/* Release dump area. */
- dump_release(dumpsize);
+ DRELEASE;
/* An error occurred. */