/* src/vm/builtin.c - functions for unsupported operations
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ 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
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Reinhard Grafl
- Andreas Krall
- Mark Probst
-
- Changes: Christian Thalinger
- Edwin Steiner
-
Contains C functions for JavaVM Instructions that cannot be
translated to machine language directly. Consequently, the
generated machine code for these instructions contains function
calls instead of machine instructions, using the C calling
convention.
- $Id: builtin.c 4879 2006-05-05 17:34:49Z edwin $
-
*/
#include "config.h"
#include <assert.h>
-#include <math.h>
+#include <errno.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/time.h>
#include "vm/types.h"
#include "md-abi.h"
#include "fdlibm/fdlibm.h"
+#if defined(__CYGWIN__) && defined(Bias)
+# undef Bias
+#endif
-#include "mm/boehm.h"
+#include "mm/gc-common.h"
#include "mm/memory.h"
-#include "native/native.h"
-#include "native/include/java_lang_Cloneable.h"
-#include "native/include/java_lang_Object.h" /* required by VMObject */
-#include "native/include/java_lang_VMObject.h"
-
-#if defined(USE_THREADS)
-# if defined(NATIVE_THREADS)
-# include "threads/native/threads.h"
-# else
-# include "threads/green/threads.h"
-# include "threads/green/locks.h"
-# endif
-#endif
+
+#include "native/jni.h"
+#include "native/llni.h"
+
+#include "threads/lock-common.h"
+#include "threads/threads-common.h"
#include "toolbox/logging.h"
#include "toolbox/util.h"
+
+#include "vm/array.h"
#include "vm/builtin.h"
-#include "vm/class.h"
+#include "vm/cycles-stats.h"
#include "vm/exceptions.h"
#include "vm/global.h"
#include "vm/initialize.h"
-#include "vm/loader.h"
-#include "vm/options.h"
+#include "vm/primitive.h"
#include "vm/stringlocal.h"
+
#include "vm/jit/asmpart.h"
-#include "vm/jit/patcher.h"
-#include "vm/rt-timing.h"
-#include "vm/cycles-stats.h"
+#include "vm/jit/trace.h"
+#include "vmcore/class.h"
+#include "vmcore/linker.h"
+#include "vmcore/loader.h"
+#include "vmcore/options.h"
+#include "vmcore/rt-timing.h"
+
+#if defined(ENABLE_VMLOG)
+#include <vmlog_cacao.h>
+#endif
+
+#if defined(ENABLE_DEBUG_FILTER)
+# include "vm/jit/show.h"
+#endif
/* include builtin tables *****************************************************/
#include "vm/builtintable.inc"
-CYCLES_STATS_DECLARE(builtin_monitorenter,100,2)
-CYCLES_STATS_DECLARE(builtin_monitorexit ,100,2)
CYCLES_STATS_DECLARE(builtin_new ,100,5)
CYCLES_STATS_DECLARE(builtin_overhead , 80,1)
static bool builtintable_init(void)
{
- descriptor_pool *descpool;
- s4 dumpsize;
- utf *descriptor;
- s4 entries_internal;
- s4 entries_automatic;
- s4 i;
+ descriptor_pool *descpool;
+ s4 dumpsize;
+ builtintable_entry *bte;
+ methodinfo *m;
/* mark start of dump memory area */
if (!descriptor_pool_add_class(descpool, utf_java_lang_Class))
return false;
- /* calculate table entries statically */
-
- entries_internal =
- sizeof(builtintable_internal) / sizeof(builtintable_entry);
-
- entries_automatic =
- sizeof(builtintable_automatic) / sizeof(builtintable_entry)
- - 1; /* last filler entry (comment see builtintable.inc) */
-
/* first add all descriptors to the pool */
- for (i = 0; i < entries_internal; i++) {
- /* create a utf8 string from descriptor */
-
- descriptor = utf_new_char(builtintable_internal[i].descriptor);
+ for (bte = builtintable_internal; bte->fp != NULL; bte++) {
+ bte->name = utf_new_char(bte->cname);
+ bte->descriptor = utf_new_char(bte->cdescriptor);
- if (!descriptor_pool_add(descpool, descriptor, NULL)) {
+ if (!descriptor_pool_add(descpool, bte->descriptor, NULL)) {
/* release dump area */
dump_release(dumpsize);
}
}
- for (i = 0; i < entries_automatic; i++) {
- /* create a utf8 string from descriptor */
+ for (bte = builtintable_automatic; bte->fp != NULL; bte++) {
+ bte->descriptor = utf_new_char(bte->cdescriptor);
- descriptor = utf_new_char(builtintable_automatic[i].descriptor);
+ if (!descriptor_pool_add(descpool, bte->descriptor, NULL)) {
+ dump_release(dumpsize);
+ return false;
+ }
+ }
- if (!descriptor_pool_add(descpool, descriptor, NULL)) {
- /* release dump area */
+ for (bte = builtintable_function; bte->fp != NULL; bte++) {
+ bte->classname = utf_new_char(bte->cclassname);
+ bte->name = utf_new_char(bte->cname);
+ bte->descriptor = utf_new_char(bte->cdescriptor);
+ if (!descriptor_pool_add(descpool, bte->descriptor, NULL)) {
dump_release(dumpsize);
-
return false;
}
}
descriptor_pool_alloc_parsed_descriptors(descpool);
- /* now parse all descriptors */
+ /* Now parse all descriptors. NOTE: builtin-functions are treated
+ like static methods (no `this' pointer). */
- for (i = 0; i < entries_internal; i++) {
- /* create a utf8 string from descriptor */
+ for (bte = builtintable_internal; bte->fp != NULL; bte++) {
+ bte->md =
+ descriptor_pool_parse_method_descriptor(descpool,
+ bte->descriptor,
+ ACC_STATIC | ACC_METHOD_BUILTIN,
+ NULL);
- descriptor = utf_new_char(builtintable_internal[i].descriptor);
+ /* generate a builtin stub if we need one */
- /* parse the descriptor, builtin is always static (no `this' pointer) */
-
- builtintable_internal[i].md =
- descriptor_pool_parse_method_descriptor(descpool, descriptor,
- ACC_STATIC, NULL);
+ if (bte->flags & BUILTINTABLE_FLAG_STUB) {
+ m = method_new_builtin(bte);
+ codegen_generate_stub_builtin(m, bte);
+ }
}
- for (i = 0; i < entries_automatic; i++) {
- /* create a utf8 string from descriptor */
+ for (bte = builtintable_automatic; bte->fp != NULL; bte++) {
+ bte->md =
+ descriptor_pool_parse_method_descriptor(descpool,
+ bte->descriptor,
+ ACC_STATIC | ACC_METHOD_BUILTIN,
+ NULL);
+
+ /* no stubs should be needed for this table */
+
+ assert(!bte->flags & BUILTINTABLE_FLAG_STUB);
+ }
- descriptor = utf_new_char(builtintable_automatic[i].descriptor);
+ for (bte = builtintable_function; bte->fp != NULL; bte++) {
+ bte->md =
+ descriptor_pool_parse_method_descriptor(descpool,
+ bte->descriptor,
+ ACC_STATIC | ACC_METHOD_BUILTIN,
+ NULL);
- /* parse the descriptor, builtin is always static (no `this' pointer) */
+ /* generate a builtin stub if we need one */
- builtintable_automatic[i].md =
- descriptor_pool_parse_method_descriptor(descpool, descriptor,
- ACC_STATIC, NULL);
+ if (bte->flags & BUILTINTABLE_FLAG_STUB) {
+ m = method_new_builtin(bte);
+ codegen_generate_stub_builtin(m, bte);
+ }
}
/* release dump area */
/* builtin_init ****************************************************************
- XXX
+ Initialize the global table of builtin functions.
*******************************************************************************/
builtintable_entry *builtintable_get_internal(functionptr fp)
{
- s4 i;
+ builtintable_entry *bte;
- for (i = 0; builtintable_internal[i].fp != NULL; i++) {
- if (builtintable_internal[i].fp == fp)
- return &builtintable_internal[i];
+ for (bte = builtintable_internal; bte->fp != NULL; bte++) {
+ if (bte->fp == fp)
+ return bte;
}
return NULL;
if (middle->opcode < opcode) {
first = middle + 1;
entries -= half + 1;
- } else
+ }
+ else
entries = half;
}
}
-/*****************************************************************************
- TYPE CHECKS
-*****************************************************************************/
-
+/* builtintable_replace_function ***********************************************
+ XXX
-/*************** internal function: builtin_isanysubclass *********************
+*******************************************************************************/
- Checks a subclass relation between two classes. Implemented interfaces
- are interpreted as super classes.
- Return value: 1 ... sub is subclass of super
- 0 ... otherwise
-
-*****************************************************************************/
-s4 builtin_isanysubclass(classinfo *sub, classinfo *super)
+#if defined(ENABLE_JIT)
+bool builtintable_replace_function(void *iptr_)
{
- s4 res;
- castinfo classvalues;
+ constant_FMIref *mr;
+ builtintable_entry *bte;
+ instruction *iptr;
- if (sub == super)
- return 1;
+ iptr = (instruction *) iptr_; /* twisti will kill me ;) */
- if (super->flags & ACC_INTERFACE) {
- res = (sub->vftbl->interfacetablelength > super->index) &&
- (sub->vftbl->interfacetable[-super->index] != NULL);
+ /* get name and descriptor of the function */
- } else {
- ASM_GETCLASSVALUES_ATOMIC(super->vftbl, sub->vftbl, &classvalues);
+ switch (iptr->opc) {
+ case ICMD_INVOKESTATIC:
+ /* The instruction MUST be resolved, otherwise we run into
+ lazy loading troubles. Anyway, we should/can only replace
+ very VM-close functions. */
+
+ if (INSTRUCTION_IS_UNRESOLVED(iptr))
+ return false;
- res = (u4) (classvalues.sub_baseval - classvalues.super_baseval) <=
- (u4) classvalues.super_diffval;
+ mr = iptr->sx.s23.s3.fmiref;
+ break;
+
+ default:
+ return false;
}
- return res;
-}
+ /* search the function table */
+ for (bte = builtintable_function; bte->fp != NULL; bte++) {
+ if ((METHODREF_CLASSNAME(mr) == bte->classname) &&
+ (mr->name == bte->name) &&
+ (mr->descriptor == bte->descriptor)) {
-s4 builtin_isanysubclass_vftbl(vftbl_t *sub, vftbl_t *super)
-{
- s4 res;
- s4 base;
- castinfo classvalues;
+ /* set the values in the instruction */
- if (sub == super)
- return 1;
+ iptr->opc = bte->opcode;
+ iptr->sx.s23.s3.bte = bte;
- ASM_GETCLASSVALUES_ATOMIC(super, sub, &classvalues);
+ if (bte->flags & BUILTINTABLE_FLAG_EXCEPTION)
+ iptr->flags.bits |= INS_FLAG_CHECK;
+ else
+ iptr->flags.bits &= ~INS_FLAG_CHECK;
- if ((base = classvalues.super_baseval) <= 0) {
- /* super is an interface */
- res = (sub->interfacetablelength > -base) &&
- (sub->interfacetable[base] != NULL);
- } else {
- res = (u4) (classvalues.sub_baseval - classvalues.super_baseval)
- <= (u4) classvalues.super_diffval;
+ return true;
+ }
}
- return res;
+ return false;
}
+#endif /* defined(ENABLE_JIT) */
-/****************** function: builtin_instanceof *****************************
+/*****************************************************************************
+ TYPE CHECKS
+*****************************************************************************/
+
+/* builtin_instanceof **********************************************************
- Checks if an object is an instance of some given class (or subclass of
- that class). If class is an interface, checks if the interface is
- implemented.
- Return value: 1 ... obj is an instance of class or implements the interface
- 0 ... otherwise or if obj == NULL
+ Checks if an object is an instance of some given class (or subclass
+ of that class). If class is an interface, checks if the interface
+ is implemented.
+
+ Return value: 1 ... o is an instance of class or implements the interface
+ 0 ... otherwise or if o == NULL
-*****************************************************************************/
+*******************************************************************************/
-s4 builtin_instanceof(java_objectheader *obj, classinfo *class)
+s4 builtin_instanceof(java_handle_t *o, classinfo *class)
{
- if (!obj)
+ classinfo *c;
+
+ if (o == NULL)
return 0;
- return builtin_isanysubclass(obj->vftbl->class, class);
+ LLNI_class_get(o, c);
+
+ return class_isanysubclass(c, class);
}
-/**************** function: builtin_checkcast *******************************
+/* builtin_checkcast ***********************************************************
- The same as builtin_instanceof except that 1 is returned when
- obj == NULL
+ The same as builtin_instanceof except that 1 is returned when o ==
+ NULL.
-****************************************************************************/
+*******************************************************************************/
-s4 builtin_checkcast(java_objectheader *obj, classinfo *class)
+s4 builtin_checkcast(java_handle_t *o, classinfo *class)
{
- if (obj == NULL)
+ classinfo *c;
+
+ if (o == NULL)
return 1;
- if (builtin_isanysubclass(obj->vftbl->class, class))
+ LLNI_class_get(o, c);
+
+ if (class_isanysubclass(c, class))
return 1;
return 0;
(target->elementvftbl->baseval == 1))
return 1;
- return builtin_isanysubclass_vftbl(desc->elementvftbl,
- target->elementvftbl);
+ return class_isanysubclass(desc->elementvftbl->class,
+ target->elementvftbl->class);
}
if (desc->dimension < target->dimension)
/* {desc has higher dimension than target} */
- return builtin_isanysubclass_vftbl(pseudo_class_Arraystub->vftbl,
- target->elementvftbl);
+ return class_isanysubclass(pseudo_class_Arraystub,
+ target->elementvftbl->class);
}
*******************************************************************************/
-s4 builtin_arraycheckcast(java_objectheader *o, classinfo *targetclass)
+s4 builtin_arraycheckcast(java_handle_t *o, classinfo *targetclass)
{
arraydescriptor *desc;
- if (!o)
+ if (o == NULL)
return 1;
- if ((desc = o->vftbl->arraydesc) == NULL)
+ desc = LLNI_vftbl_direct(o)->arraydesc;
+
+ if (desc == NULL)
return 0;
return builtin_descriptorscompatible(desc, targetclass->vftbl->arraydesc);
}
-s4 builtin_arrayinstanceof(java_objectheader *o, classinfo *targetclass)
+s4 builtin_arrayinstanceof(java_handle_t *o, classinfo *targetclass)
{
- if (!o)
+ if (o == NULL)
return 0;
return builtin_arraycheckcast(o, targetclass);
*******************************************************************************/
-void *builtin_throw_exception(java_objectheader *xptr)
+void *builtin_throw_exception(java_object_t *xptr)
{
#if !defined(NDEBUG)
- java_lang_Throwable *t;
- char *logtext;
- s4 logtextlen;
- s4 dumpsize;
-
- if (opt_verbose) {
- t = (java_lang_Throwable *) xptr;
-
- /* calculate message length */
-
- logtextlen = strlen("Builtin exception thrown: ") + strlen("0");
-
- if (t) {
- logtextlen +=
- utf_get_number_of_u2s(xptr->vftbl->class->name) +
- strlen(": ") +
- javastring_strlen(t->detailMessage);
-
- } else
- logtextlen += strlen("(nil)");
+ /* print exception trace */
- /* allocate memory */
-
- dumpsize = dump_size();
-
- logtext = DMNEW(char, logtextlen);
-
- strcpy(logtext, "Builtin exception thrown: ");
-
- if (t) {
- utf_sprint_convert_to_latin1_classname(logtext + strlen(logtext),
- xptr->vftbl->class->name);
-
- if (t->detailMessage) {
- char *buf;
-
- buf = javastring_tochar((java_objectheader *) t->detailMessage);
- strcat(logtext, ": ");
- strcat(logtext, buf);
- MFREE(buf, char, strlen(buf));
- }
-
- } else {
- strcat(logtext, "(nil)");
- }
-
- log_text(logtext);
-
- /* release memory */
-
- dump_release(dumpsize);
- }
+ if (opt_TraceExceptions)
+ trace_exception_builtin(xptr);
#endif /* !defined(NDEBUG) */
/* actually set the exception */
- *exceptionptr = xptr;
+ exceptions_set_exception(xptr);
/* Return a NULL pointer. This is required for vm_call_method to
check for an exception. This is for convenience. */
Checks, if an object can be stored in an array.
Return value: 1 ... possible
- 0 ... otherwise
+ 0 ... otherwise (throws an ArrayStoreException)
*******************************************************************************/
-s4 builtin_canstore(java_objectarray *oa, java_objectheader *o)
+s4 builtin_canstore(java_handle_objectarray_t *oa, java_handle_t *o)
+{
+ int result;
+
+ LLNI_CRITICAL_START;
+
+ result = builtin_fast_canstore(LLNI_DIRECT(oa), LLNI_UNWRAP(o));
+
+ LLNI_CRITICAL_END;
+
+ /* if not possible, throw an exception */
+
+ if (result == 0)
+ exceptions_throw_arraystoreexception();
+
+ return result;
+}
+
+
+s4 builtin_fast_canstore(java_objectarray_t *oa, java_object_t *o)
{
arraydescriptor *desc;
arraydescriptor *valuedesc;
vftbl_t *componentvftbl;
vftbl_t *valuevftbl;
- s4 base;
- castinfo classvalues;
+ int32_t baseval;
+ uint32_t diffval;
+ int result;
- if (!o)
+ if (o == NULL)
return 1;
/* The following is guaranteed (by verifier checks):
desc = oa->header.objheader.vftbl->arraydesc;
componentvftbl = desc->componentvftbl;
valuevftbl = o->vftbl;
+ valuedesc = valuevftbl->arraydesc;
if ((desc->dimension - 1) == 0) {
- s4 res;
-
/* {oa is a one-dimensional array} */
/* {oa is an array of references} */
if (valuevftbl == componentvftbl)
return 1;
- ASM_GETCLASSVALUES_ATOMIC(componentvftbl, valuevftbl, &classvalues);
+ LOCK_MONITOR_ENTER(linker_classrenumber_lock);
- if ((base = classvalues.super_baseval) <= 0)
+ baseval = componentvftbl->baseval;
+
+ if (baseval <= 0) {
/* an array of interface references */
- return (valuevftbl->interfacetablelength > -base &&
- valuevftbl->interfacetable[base] != NULL);
-
- res = ((unsigned) (classvalues.sub_baseval - classvalues.super_baseval)
- <= (unsigned) classvalues.super_diffval);
- return res;
- }
+ result = ((valuevftbl->interfacetablelength > -baseval) &&
+ (valuevftbl->interfacetable[baseval] != NULL));
+ }
+ else {
+ diffval = valuevftbl->baseval - componentvftbl->baseval;
+ result = diffval <= (uint32_t) componentvftbl->diffval;
+ }
- /* {oa has dimension > 1} */
- /* {componentvftbl->arraydesc != NULL} */
+ LOCK_MONITOR_EXIT(linker_classrenumber_lock);
+ }
+ else if (valuedesc == NULL) {
+ /* {oa has dimension > 1} */
+ /* {componentvftbl->arraydesc != NULL} */
- /* check if o is an array */
+ /* check if o is an array */
- if ((valuedesc = valuevftbl->arraydesc) == NULL)
return 0;
+ }
+ else {
+ /* {o is an array} */
+
+ result = builtin_descriptorscompatible(valuedesc, componentvftbl->arraydesc);
+ }
- /* {o is an array} */
+ /* return result */
- return builtin_descriptorscompatible(valuedesc, componentvftbl->arraydesc);
+ return result;
}
/* This is an optimized version where a is guaranteed to be one-dimensional */
-s4 builtin_canstore_onedim (java_objectarray *a, java_objectheader *o)
+s4 builtin_canstore_onedim (java_objectarray_t *a, java_object_t *o)
{
arraydescriptor *desc;
- vftbl_t *elementvftbl;
- vftbl_t *valuevftbl;
- s4 res;
- int base;
- castinfo classvalues;
+ vftbl_t *elementvftbl;
+ vftbl_t *valuevftbl;
+ int32_t baseval;
+ uint32_t diffval;
+ int result;
- if (!o) return 1;
+ if (o == NULL)
+ return 1;
/* The following is guaranteed (by verifier checks):
*
if (valuevftbl == elementvftbl)
return 1;
- ASM_GETCLASSVALUES_ATOMIC(elementvftbl, valuevftbl, &classvalues);
+ LOCK_MONITOR_ENTER(linker_classrenumber_lock);
- if ((base = classvalues.super_baseval) <= 0)
+ baseval = elementvftbl->baseval;
+
+ if (baseval <= 0) {
/* an array of interface references */
- return (valuevftbl->interfacetablelength > -base &&
- valuevftbl->interfacetable[base] != NULL);
+ result = ((valuevftbl->interfacetablelength > -baseval) &&
+ (valuevftbl->interfacetable[baseval] != NULL));
+ }
+ else {
+ diffval = valuevftbl->baseval - elementvftbl->baseval;
+ result = diffval <= (uint32_t) elementvftbl->diffval;
+ }
- res = (unsigned) (classvalues.sub_baseval - classvalues.super_baseval)
- <= (unsigned) classvalues.super_diffval;
+ LOCK_MONITOR_EXIT(linker_classrenumber_lock);
- return res;
+ return result;
}
/* This is an optimized version where a is guaranteed to be a
* one-dimensional array of a class type */
-s4 builtin_canstore_onedim_class(java_objectarray *a, java_objectheader *o)
+s4 builtin_canstore_onedim_class(java_objectarray_t *a, java_object_t *o)
{
- vftbl_t *elementvftbl;
- vftbl_t *valuevftbl;
- s4 res;
- castinfo classvalues;
+ vftbl_t *elementvftbl;
+ vftbl_t *valuevftbl;
+ uint32_t diffval;
+ int result;
- if (!o) return 1;
+ if (o == NULL)
+ return 1;
/* The following is guaranteed (by verifier checks):
*
if (valuevftbl == elementvftbl)
return 1;
- ASM_GETCLASSVALUES_ATOMIC(elementvftbl, valuevftbl, &classvalues);
+ LOCK_MONITOR_ENTER(linker_classrenumber_lock);
- res = (unsigned) (classvalues.sub_baseval - classvalues.super_baseval)
- <= (unsigned) classvalues.super_diffval;
+ diffval = valuevftbl->baseval - elementvftbl->baseval;
+ result = diffval <= (uint32_t) elementvftbl->diffval;
- return res;
+ LOCK_MONITOR_EXIT(linker_classrenumber_lock);
+
+ return result;
}
Return value: pointer to the object or NULL if no memory is
available
-
+
*******************************************************************************/
-java_objectheader *builtin_new(classinfo *c)
+java_handle_t *builtin_new(classinfo *c)
{
- java_objectheader *o;
+ java_object_t *o;
#if defined(ENABLE_RT_TIMING)
struct timespec time_start, time_end;
#endif
/* check if we can instantiate this class */
if (c->flags & ACC_ABSTRACT) {
- *exceptionptr =
- new_exception_utfmessage(string_java_lang_InstantiationError,
- c->name);
+ exceptions_throw_instantiationerror(c);
return NULL;
}
return NULL;
}
- o = heap_allocate(c->instancesize, c->flags & ACC_CLASS_HAS_POINTERS,
- c->finalizer);
+ o = heap_alloc(c->instancesize, c->flags & ACC_CLASS_HAS_POINTERS,
+ c->finalizer, true);
if (!o)
return NULL;
o->vftbl = c->vftbl;
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
- initObjectLock(o);
+#if defined(ENABLE_THREADS)
+ lock_init_object_lock(o);
+#endif
+
+ CYCLES_STATS_GET(cycles_end);
+ RT_TIMING_GET_TIME(time_end);
+
+ CYCLES_STATS_COUNT(builtin_new,cycles_end - cycles_start);
+ RT_TIMING_TIME_DIFF(time_start, time_end, RT_TIMING_NEW_OBJECT);
+
+ return o;
+}
+
+
+/* builtin_fast_new ************************************************************
+
+ Creates a new instance of class c on the heap.
+
+ Return value: pointer to the object or NULL if no fast return
+ is possible for any reason.
+
+*******************************************************************************/
+
+java_object_t *builtin_fast_new(classinfo *c)
+{
+ java_object_t *o;
+#if defined(ENABLE_RT_TIMING)
+ struct timespec time_start, time_end;
+#endif
+#if defined(ENABLE_CYCLES_STATS)
+ u8 cycles_start, cycles_end;
+#endif
+
+ RT_TIMING_GET_TIME(time_start);
+ CYCLES_STATS_GET(cycles_start);
+
+ /* is the class loaded */
+
+ assert(c->state & CLASS_LOADED);
+
+ /* check if we can instantiate this class */
+
+ if (c->flags & ACC_ABSTRACT)
+ return NULL;
+
+ /* is the class linked */
+
+ if (!(c->state & CLASS_LINKED))
+ return NULL;
+
+ if (!(c->state & CLASS_INITIALIZED))
+ return NULL;
+
+ o = heap_alloc(c->instancesize, c->flags & ACC_CLASS_HAS_POINTERS,
+ c->finalizer, false);
+
+ if (!o)
+ return NULL;
+
+ o->vftbl = c->vftbl;
+
+#if defined(ENABLE_THREADS)
+ lock_init_object_lock(o);
#endif
CYCLES_STATS_GET(cycles_end);
*******************************************************************************/
-java_arrayheader *builtin_newarray(s4 size, classinfo *arrayclass)
+java_handle_t *builtin_newarray(s4 size, classinfo *arrayclass)
{
- arraydescriptor *desc;
- s4 dataoffset;
- s4 componentsize;
- s4 actualsize;
- java_arrayheader *a;
+ arraydescriptor *desc;
+ s4 dataoffset;
+ s4 componentsize;
+ s4 actualsize;
+ java_array_t *a;
#if defined(ENABLE_RT_TIMING)
struct timespec time_start, time_end;
#endif
actualsize = dataoffset + size * componentsize;
- if (((u4) actualsize) < ((u4) size)) { /* overflow */
- *exceptionptr = new_exception(string_java_lang_OutOfMemoryError);
+ /* check for overflow */
+
+ if (((u4) actualsize) < ((u4) size)) {
+ exceptions_throw_outofmemoryerror();
return NULL;
}
- a = heap_allocate(actualsize, (desc->arraytype == ARRAYTYPE_OBJECT), NULL);
+ a = heap_alloc(actualsize, (desc->arraytype == ARRAYTYPE_OBJECT), NULL, true);
- if (!a)
+ if (a == NULL)
return NULL;
a->objheader.vftbl = arrayclass->vftbl;
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
- initObjectLock(&a->objheader);
+#if defined(ENABLE_THREADS)
+ lock_init_object_lock(&a->objheader);
#endif
- a->size = size;
+ LLNI_array_size(a) = size;
RT_TIMING_GET_TIME(time_end);
RT_TIMING_TIME_DIFF(time_start, time_end, RT_TIMING_NEW_ARRAY);
*******************************************************************************/
-java_objectarray *builtin_anewarray(s4 size, classinfo *componentclass)
+java_handle_objectarray_t *builtin_anewarray(s4 size, classinfo *componentclass)
{
classinfo *arrayclass;
if (!arrayclass)
return NULL;
- return (java_objectarray *) builtin_newarray(size, arrayclass);
+ return (java_handle_objectarray_t *) builtin_newarray(size, arrayclass);
}
*******************************************************************************/
-java_booleanarray *builtin_newarray_boolean(s4 size)
+java_handle_booleanarray_t *builtin_newarray_boolean(s4 size)
{
- return (java_booleanarray *)
+ return (java_handle_booleanarray_t *)
builtin_newarray(size,
primitivetype_table[ARRAYTYPE_BOOLEAN].arrayclass);
}
*******************************************************************************/
-java_bytearray *builtin_newarray_byte(s4 size)
+java_handle_bytearray_t *builtin_newarray_byte(s4 size)
{
- return (java_bytearray *)
+ return (java_handle_bytearray_t *)
builtin_newarray(size, primitivetype_table[ARRAYTYPE_BYTE].arrayclass);
}
*******************************************************************************/
-java_chararray *builtin_newarray_char(s4 size)
+java_handle_chararray_t *builtin_newarray_char(s4 size)
{
- return (java_chararray *)
+ return (java_handle_chararray_t *)
builtin_newarray(size, primitivetype_table[ARRAYTYPE_CHAR].arrayclass);
}
*******************************************************************************/
-java_shortarray *builtin_newarray_short(s4 size)
+java_handle_shortarray_t *builtin_newarray_short(s4 size)
{
- return (java_shortarray *)
+ return (java_handle_shortarray_t *)
builtin_newarray(size, primitivetype_table[ARRAYTYPE_SHORT].arrayclass);
}
*******************************************************************************/
-java_intarray *builtin_newarray_int(s4 size)
+java_handle_intarray_t *builtin_newarray_int(s4 size)
{
- return (java_intarray *)
+ return (java_handle_intarray_t *)
builtin_newarray(size, primitivetype_table[ARRAYTYPE_INT].arrayclass);
}
*******************************************************************************/
-java_longarray *builtin_newarray_long(s4 size)
+java_handle_longarray_t *builtin_newarray_long(s4 size)
{
- return (java_longarray *)
+ return (java_handle_longarray_t *)
builtin_newarray(size, primitivetype_table[ARRAYTYPE_LONG].arrayclass);
}
*******************************************************************************/
-java_floatarray *builtin_newarray_float(s4 size)
+java_handle_floatarray_t *builtin_newarray_float(s4 size)
{
- return (java_floatarray *)
+ return (java_handle_floatarray_t *)
builtin_newarray(size, primitivetype_table[ARRAYTYPE_FLOAT].arrayclass);
}
*******************************************************************************/
-java_doublearray *builtin_newarray_double(s4 size)
+java_handle_doublearray_t *builtin_newarray_double(s4 size)
{
- return (java_doublearray *)
+ return (java_handle_doublearray_t *)
builtin_newarray(size,
primitivetype_table[ARRAYTYPE_DOUBLE].arrayclass);
}
passed in an array of longs.
Arguments:
- n............number of dimensions to create
- arrayvftbl...vftbl of the array class
- dims.........array containing the size of each dimension to create
+ n.............number of dimensions to create
+ arrayclass....the array class
+ dims..........array containing the size of each dimension to create
Return value: pointer to the array or NULL if no memory is
available
******************************************************************************/
-static java_arrayheader *builtin_multianewarray_intern(int n,
- classinfo *arrayclass,
- long *dims)
+static java_handle_t *builtin_multianewarray_intern(int n,
+ classinfo *arrayclass,
+ long *dims)
{
- s4 size;
- java_arrayheader *a;
- classinfo *componentclass;
- s4 i;
+ s4 size;
+ java_handle_t *a;
+ classinfo *componentclass;
+ s4 i;
/* create this dimension */
size = (s4) dims[0];
- a = builtin_newarray(size, arrayclass);
+ a = builtin_newarray(size, arrayclass);
if (!a)
return NULL;
/* create the component arrays */
for (i = 0; i < size; i++) {
- java_arrayheader *ea =
+ java_handle_t *ea =
#if defined(__MIPS__) && (SIZEOF_VOID_P == 4)
/* we save an s4 to a s8 slot, 8-byte aligned */
if (!ea)
return NULL;
-
- ((java_objectarray *) a)->data[i] = (java_objectheader *) ea;
+
+ LLNI_objectarray_element_set((java_handle_objectarray_t *) a, i, ea);
}
return a;
******************************************************************************/
-java_arrayheader *builtin_multianewarray(int n, classinfo *arrayclass,
- long *dims)
+java_handle_objectarray_t *builtin_multianewarray(int n, classinfo *arrayclass,
+ long *dims)
{
s4 i;
s4 size;
/* now call the real function */
- return builtin_multianewarray_intern(n, arrayclass, dims);
+ return (java_handle_objectarray_t *)
+ builtin_multianewarray_intern(n, arrayclass, dims);
}
*****************************************************************************/
-#if !defined(NDEBUG)
-static s4 methodindent = 0;
-static u4 callcount = 0;
+/* builtin_print_argument ******************************************************
-java_objectheader *builtin_trace_exception(java_objectheader *xptr,
- methodinfo *m,
- void *pos,
- s4 indent)
-{
- char *logtext;
- s4 logtextlen;
- s4 dumpsize;
- codeinfo *code;
+ Prints arguments and return values for the call trace.
- if (opt_verbosecall && indent)
- methodindent--;
-
- /* calculate message length */
+*******************************************************************************/
- if (xptr) {
- logtextlen =
- strlen("Exception ") +
- utf_get_number_of_u2s(xptr->vftbl->class->name);
+#if !defined(NDEBUG)
+static char *builtin_print_argument(char *logtext, s4 *logtextlen,
+ typedesc *paramtype, s8 value)
+{
+ imm_union imu;
+ java_object_t *o;
+ classinfo *c;
+ utf *u;
+ u4 len;
- } else {
- logtextlen = strlen("Some Throwable");
- }
+ switch (paramtype->type) {
+ case TYPE_INT:
+ imu.i = (s4) value;
+ sprintf(logtext + strlen(logtext), "%d (0x%08x)", imu.i, imu.i);
+ break;
- logtextlen += strlen(" thrown in ");
+ case TYPE_LNG:
+ imu.l = value;
+#if SIZEOF_VOID_P == 4
+ sprintf(logtext + strlen(logtext), "%lld (0x%016llx)", imu.l, imu.l);
+#else
+ sprintf(logtext + strlen(logtext), "%ld (0x%016lx)", imu.l, imu.l);
+#endif
+ break;
- if (m) {
- logtextlen +=
- utf_get_number_of_u2s(m->class->name) +
- strlen(".") +
- utf_get_number_of_u2s(m->name) +
- utf_get_number_of_u2s(m->descriptor) +
- strlen("(NOSYNC,NATIVE");
+ case TYPE_FLT:
+#if defined(__S390__)
+ imu.l = value;
+ /* The below won't work on S390 */
+#else
+ imu.i = (s4) value;
+#endif
+ sprintf(logtext + strlen(logtext), "%g (0x%08x)", imu.f, imu.i);
+ break;
-#if SIZEOF_VOID_P == 8
- logtextlen +=
- strlen(")(0x123456789abcdef0) at position 0x123456789abcdef0 (");
+ case TYPE_DBL:
+ imu.l = value;
+#if SIZEOF_VOID_P == 4
+ sprintf(logtext + strlen(logtext), "%g (0x%016llx)", imu.d, imu.l);
#else
- logtextlen += strlen(")(0x12345678) at position 0x12345678 (");
+ sprintf(logtext + strlen(logtext), "%g (0x%016lx)", imu.d, imu.l);
#endif
+ break;
- if (m->class->sourcefile == NULL)
- logtextlen += strlen("<NO CLASSFILE INFORMATION>");
- else
- logtextlen += utf_get_number_of_u2s(m->class->sourcefile);
+ case TYPE_ADR:
+#if SIZEOF_VOID_P == 4
+ sprintf(logtext + strlen(logtext), "0x%08x", (ptrint) value);
+#else
+ sprintf(logtext + strlen(logtext), "0x%016lx", (ptrint) value);
+#endif
- logtextlen += strlen(":65536)");
+ /* cast to java.lang.Object */
- } else
- logtextlen += strlen("call_java_method");
+ o = (java_object_t *) (ptrint) value;
- logtextlen += strlen("0");
+ /* check return argument for java.lang.Class or java.lang.String */
- /* allocate memory */
+ if (o != NULL) {
+ if (o->vftbl->class == class_java_lang_String) {
+ /* get java.lang.String object and the length of the
+ string */
- dumpsize = dump_size();
+ u = javastring_toutf(o, false);
- logtext = DMNEW(char, logtextlen);
+ len = strlen(" (String = \"") + utf_bytes(u) + strlen("\")");
- if (xptr) {
- strcpy(logtext, "Exception ");
- utf_strcat_convert_to_latin1_classname(logtext, xptr->vftbl->class->name);
+ /* realloc memory for string length */
- } else {
- strcpy(logtext, "Some Throwable");
- }
+ logtext = DMREALLOC(logtext, char, *logtextlen, *logtextlen + len);
+ *logtextlen += len;
- strcat(logtext, " thrown in ");
+ /* convert to utf8 string and strcat it to the logtext */
- if (m) {
- utf_strcat_convert_to_latin1_classname(logtext, m->class->name);
- strcat(logtext, ".");
- utf_strcat_convert_to_latin1(logtext, m->name);
- utf_strcat_convert_to_latin1(logtext, m->descriptor);
+ strcat(logtext, " (String = \"");
+ utf_cat(logtext, u);
+ strcat(logtext, "\")");
+ }
+ else {
+ if (o->vftbl->class == class_java_lang_Class) {
+ /* if the object returned is a java.lang.Class
+ cast it to classinfo structure and get the name
+ of the class */
- if (m->flags & ACC_SYNCHRONIZED)
- strcat(logtext, "(SYNC");
- else
- strcat(logtext, "(NOSYNC");
+ c = (classinfo *) o;
- if (m->flags & ACC_NATIVE) {
- strcat(logtext, ",NATIVE");
+ u = c->name;
+ }
+ else {
+ /* if the object returned is not a java.lang.String or
+ a java.lang.Class just print the name of the class */
- code = m->code;
+ u = o->vftbl->class->name;
+ }
-#if SIZEOF_VOID_P == 8
- sprintf(logtext + strlen(logtext),
- ")(0x%016lx) at position 0x%016lx",
- (ptrint) code->entrypoint, (ptrint) pos);
-#else
- sprintf(logtext + strlen(logtext),
- ")(0x%08x) at position 0x%08x",
- (ptrint) code->entrypoint, (ptrint) pos);
-#endif
+ len = strlen(" (Class = \"") + utf_bytes(u) + strlen("\")");
- } else {
+ /* realloc memory for string length */
- /* XXX preliminary: This should get the actual codeinfo */
- /* in which the exception happened. */
- code = m->code;
-
-#if SIZEOF_VOID_P == 8
- sprintf(logtext + strlen(logtext),
- ")(0x%016lx) at position 0x%016lx (",
- (ptrint) code->entrypoint, (ptrint) pos);
-#else
- sprintf(logtext + strlen(logtext),
- ")(0x%08x) at position 0x%08x (",
- (ptrint) code->entrypoint, (ptrint) pos);
-#endif
+ logtext = DMREALLOC(logtext, char, *logtextlen, *logtextlen + len);
+ *logtextlen += len;
- if (m->class->sourcefile == NULL)
- strcat(logtext, "<NO CLASSFILE INFORMATION>");
- else
- utf_strcat_convert_to_latin1(logtext, m->class->sourcefile);
+ /* strcat to the logtext */
- sprintf(logtext + strlen(logtext), ":%d)", 0);
+ strcat(logtext, " (Class = \"");
+ utf_cat_classname(logtext, u);
+ strcat(logtext, "\")");
+ }
}
+ }
- } else
- strcat(logtext, "call_java_method");
-
- log_text(logtext);
-
- /* release memory */
-
- dump_release(dumpsize);
-
- return xptr;
+ return logtext;
}
#endif /* !defined(NDEBUG) */
+/* builtin_verbosecall_enter ***************************************************
-/* builtin_trace_args **********************************************************
-
- XXX
+ Print method call with arguments for -verbose:call.
*******************************************************************************/
#if !defined(NDEBUG)
#ifdef TRACE_ARGS_NUM
-void builtin_trace_args(s8 a0, s8 a1,
-#if TRACE_ARGS_NUM >= 4
- s8 a2, s8 a3,
-#endif /* TRACE_ARGS_NUM >= 4 */
-#if TRACE_ARGS_NUM >= 6
- s8 a4, s8 a5,
-#endif /* TRACE_ARGS_NUM >= 6 */
-#if TRACE_ARGS_NUM == 8
- s8 a6, s8 a7,
-#endif /* TRACE_ARGS_NUM == 8 */
- methodinfo *m)
+void builtin_verbosecall_enter(s8 a0, s8 a1,
+# if TRACE_ARGS_NUM >= 4
+ s8 a2, s8 a3,
+# endif
+# if TRACE_ARGS_NUM >= 6
+ s8 a4, s8 a5,
+# endif
+# if TRACE_ARGS_NUM == 8
+ s8 a6, s8 a7,
+# endif
+ methodinfo *m)
{
methoddesc *md;
char *logtext;
s4 dumpsize;
s4 i;
s4 pos;
+ int methodindent;
+ int callcount;
+
+#if defined(ENABLE_DEBUG_FILTER)
+ if (! show_filters_test_verbosecall_enter(m)) return;
+#endif
+
+#if defined(ENABLE_VMLOG)
+ vmlog_cacao_enter_method(m);
+ return;
+#endif
md = m->parseddesc;
+ methodindent = TRACEJAVACALLINDENT;
+
/* calculate message length */
logtextlen =
strlen("-2147483647-") + /* INT_MAX should be sufficient */
methodindent +
strlen("called: ") +
- utf_get_number_of_u2s(m->class->name) +
+ utf_bytes(m->class->name) +
strlen(".") +
- utf_get_number_of_u2s(m->name) +
- utf_get_number_of_u2s(m->descriptor) +
- strlen(" SYNCHRONIZED") + strlen("(") + strlen(")");
+ utf_bytes(m->name) +
+ utf_bytes(m->descriptor);
+
+ /* Actually it's not possible to have all flags printed, but:
+ safety first! */
+
+ logtextlen +=
+ strlen(" PUBLIC") +
+ strlen(" PRIVATE") +
+ strlen(" PROTECTED") +
+ strlen(" STATIC") +
+ strlen(" FINAL") +
+ strlen(" SYNCHRONIZED") +
+ strlen(" VOLATILE") +
+ strlen(" TRANSIENT") +
+ strlen(" NATIVE") +
+ strlen(" INTERFACE") +
+ strlen(" ABSTRACT");
/* add maximal argument length */
- logtextlen += strlen("0x123456789abcdef0, 0x123456789abcdef0, 0x123456789abcdef0, 0x123456789abcdef0, 0x123456789abcdef0, 0x123456789abcdef0, 0x123456789abcdef0, 0x123456789abcdef0, ...(255)");
+ logtextlen +=
+ strlen("(") +
+ strlen("-9223372036854775808 (0x123456789abcdef0), ") * TRACE_ARGS_NUM +
+ strlen("...(255)") +
+ strlen(")");
/* allocate memory */
logtext = DMNEW(char, logtextlen);
- callcount++;
+ callcount = ++TRACEJAVACALLCOUNT;
sprintf(logtext, "%10d ", callcount);
sprintf(logtext + strlen(logtext), "-%d-", methodindent);
strcpy(logtext + pos, "called: ");
- utf_strcat_convert_to_latin1_classname(logtext, m->class->name);
+ utf_cat_classname(logtext, m->class->name);
strcat(logtext, ".");
- utf_strcat_convert_to_latin1(logtext, m->name);
- utf_strcat_convert_to_latin1(logtext, m->descriptor);
+ utf_cat(logtext, m->name);
+ utf_cat(logtext, m->descriptor);
if (m->flags & ACC_PUBLIC) strcat(logtext, " PUBLIC");
if (m->flags & ACC_PRIVATE) strcat(logtext, " PRIVATE");
strcat(logtext, "(");
- /* xxxprintf ?Bug? an PowerPc Linux (rlwinm.inso) */
- /* Only Arguments in integer Registers are passed correctly here */
- /* long longs spilled on Stack have an wrong offset of +4 */
- /* So preliminary Bugfix: Only pass 3 params at once to sprintf */
- /* for SIZEOG_VOID_P == 4 && TRACE_ARGS_NUM == 8 */
- switch (md->paramcount) {
- case 0:
- break;
-
-#if SIZEOF_VOID_P == 4
- case 1:
- sprintf(logtext + strlen(logtext),
- "0x%llx",
- a0);
- break;
-
- case 2:
- sprintf(logtext + strlen(logtext),
- "0x%llx, 0x%llx",
- a0, a1);
- break;
-
-#if TRACE_ARGS_NUM >= 4
- case 3:
- sprintf(logtext + strlen(logtext),
- "0x%llx, 0x%llx, 0x%llx",
- a0, a1, a2);
- break;
-
- case 4:
- sprintf(logtext + strlen(logtext), "0x%llx, 0x%llx, 0x%llx"
- , a0, a1, a2);
- sprintf(logtext + strlen(logtext), ", 0x%llx", a3);
-
- break;
-#endif /* TRACE_ARGS_NUM >= 4 */
-
-#if TRACE_ARGS_NUM >= 6
- case 5:
- sprintf(logtext + strlen(logtext), "0x%llx, 0x%llx, 0x%llx"
- , a0, a1, a2);
- sprintf(logtext + strlen(logtext), ", 0x%llx, 0x%llx", a3, a4);
- break;
-
-
- case 6:
- sprintf(logtext + strlen(logtext), "0x%llx, 0x%llx, 0x%llx"
- , a0, a1, a2);
- sprintf(logtext + strlen(logtext), ", 0x%llx, 0x%llx, 0x%llx"
- , a3, a4, a5);
- break;
-#endif /* TRACE_ARGS_NUM >= 6 */
-
-#if TRACE_ARGS_NUM == 8
- case 7:
- sprintf(logtext + strlen(logtext), "0x%llx, 0x%llx, 0x%llx"
- , a0, a1, a2);
- sprintf(logtext + strlen(logtext), ", 0x%llx, 0x%llx, 0x%llx"
- , a3, a4, a5);
- sprintf(logtext + strlen(logtext), ", 0x%llx", a6);
- break;
-
- case 8:
- sprintf(logtext + strlen(logtext), "0x%llx, 0x%llx, 0x%llx"
- , a0, a1, a2);
- sprintf(logtext + strlen(logtext), ", 0x%llx, 0x%llx, 0x%llx"
- , a3, a4, a5);
- sprintf(logtext + strlen(logtext), ", 0x%llx, 0x%llx", a6, a7);
- break;
-#endif /* TRACE_ARGS_NUM == 8 */
-
- default:
-#if TRACE_ARGS_NUM == 2
- sprintf(logtext + strlen(logtext), "0x%llx, 0x%llx, ...(%d)", a0, a1, md->paramcount - 2);
-
-#elif TRACE_ARGS_NUM == 4
- sprintf(logtext + strlen(logtext),
- "0x%llx, 0x%llx, 0x%llx, 0x%llx, ...(%d)",
- a0, a1, a2, a3, md->paramcount - 4);
-
-#elif TRACE_ARGS_NUM == 6
- sprintf(logtext + strlen(logtext),
- "0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx, 0x%llx, ...(%d)",
- a0, a1, a2, a3, a4, a5, md->paramcount - 6);
-
-#elif TRACE_ARGS_NUM == 8
- sprintf(logtext + strlen(logtext),"0x%llx, 0x%llx, 0x%llx,"
- , a0, a1, a2);
- sprintf(logtext + strlen(logtext)," 0x%llx, 0x%llx, 0x%llx,"
- , a3, a4, a5);
- sprintf(logtext + strlen(logtext)," 0x%llx, 0x%llx, ...(%d)"
- , a6, a7, md->paramcount - 8);
-#endif
- break;
-
-#else /* SIZEOF_VOID_P == 4 */
-
- case 1:
- sprintf(logtext + strlen(logtext),
- "0x%lx",
- a0);
- break;
-
- case 2:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx",
- a0, a1);
- break;
-
- case 3:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx", a0, a1, a2);
- break;
-
- case 4:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx",
- a0, a1, a2, a3);
- break;
-
-#if TRACE_ARGS_NUM >= 6
- case 5:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx",
- a0, a1, a2, a3, a4);
- break;
-
- case 6:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx",
- a0, a1, a2, a3, a4, a5);
- break;
-#endif /* TRACE_ARGS_NUM >= 6 */
-
-#if TRACE_ARGS_NUM == 8
- case 7:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx",
- a0, a1, a2, a3, a4, a5, a6);
- break;
-
- case 8:
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx",
- a0, a1, a2, a3, a4, a5, a6, a7);
- break;
-#endif /* TRACE_ARGS_NUM == 8 */
-
- default:
-#if TRACE_ARGS_NUM == 4
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, ...(%d)",
- a0, a1, a2, a3, md->paramcount - 4);
-
-#elif TRACE_ARGS_NUM == 6
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, ...(%d)",
- a0, a1, a2, a3, a4, a5, md->paramcount - 6);
-
-#elif TRACE_ARGS_NUM == 8
- sprintf(logtext + strlen(logtext),
- "0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, 0x%lx, ...(%d)",
- a0, a1, a2, a3, a4, a5, a6, a7, md->paramcount - 8);
-#endif
- break;
-#endif /* SIZEOF_VOID_P == 4 */
- }
-
- strcat(logtext, ")");
-
- log_text(logtext);
-
- /* release memory */
-
- dump_release(dumpsize);
-
- methodindent++;
-}
-#endif
-#endif /* !defined(NDEBUG) */
-
-
-/* builtin_displaymethodstop ***************************************************
-
- XXX
-
-*******************************************************************************/
-
-#if !defined(NDEBUG)
-void builtin_displaymethodstop(methodinfo *m, s8 l, double d, float f)
-{
- methoddesc *md;
- char *logtext;
- s4 logtextlen;
- s4 dumpsize;
- s4 i;
- s4 pos;
- java_objectheader *o;
- java_lang_String *s;
- classinfo *c;
- s4 len;
- utf *u;
- imm_union imu;
-
- md = m->parseddesc;
-
- /* calculate message length */
-
- logtextlen =
- strlen("4294967295 ") +
- strlen("-2147483647-") + /* INT_MAX should be sufficient */
- methodindent +
- strlen("finished: ") +
- utf_get_number_of_u2s(m->class->name) +
- strlen(".") +
- utf_get_number_of_u2s(m->name) +
- utf_get_number_of_u2s(m->descriptor) +
- strlen(" SYNCHRONIZED") + strlen("(") + strlen(")");
-
- /* add maximal argument length */
-
- logtextlen += strlen("->0.4872328470301428 (0x0123456789abcdef)");
-
- /* allocate memory */
-
- dumpsize = dump_size();
-
- logtext = DMNEW(char, logtextlen);
-
- /* outdent the log message */
-
- if (methodindent)
- methodindent--;
- else
- log_text("WARNING: unmatched methodindent--");
-
- /* generate the message */
-
- sprintf(logtext, " ");
- sprintf(logtext + strlen(logtext), "-%d-", methodindent);
-
- pos = strlen(logtext);
-
- for (i = 0; i < methodindent; i++)
- logtext[pos++] = '\t';
-
- strcpy(logtext + pos, "finished: ");
- utf_strcat_convert_to_latin1_classname(logtext, m->class->name);
- strcat(logtext, ".");
- utf_strcat_convert_to_latin1(logtext, m->name);
- utf_strcat_convert_to_latin1(logtext, m->descriptor);
-
- switch (md->returntype.type) {
- case TYPE_INT:
- sprintf(logtext + strlen(logtext), "->%d (0x%08x)", (s4) l, (s4) l);
- break;
-
- case TYPE_LNG:
-#if SIZEOF_VOID_P == 4
- sprintf(logtext + strlen(logtext), "->%lld (0x%016llx)", (s8) l, l);
-#else
- sprintf(logtext + strlen(logtext), "->%ld (0x%016lx)", (s8) l, l);
-#endif
- break;
-
- case TYPE_ADR:
- sprintf(logtext + strlen(logtext), "->%p", (void *) (ptrint) l);
-
- /* check return argument for java.lang.Class or java.lang.String */
-
- o = (java_objectheader *) (ptrint) l;
-
- if (o != NULL) {
- if (o->vftbl->class == class_java_lang_String) {
- /* get java.lang.String object and the length of the
- string */
-
- s= (java_lang_String *) (ptrint) l;
-
- len = strlen(", String = \"") + javastring_strlen(s) +
- strlen("\"");
-
- /* realloc memory for string length */
-
- DMREALLOC(logtext, char, logtextlen, logtextlen + len);
-
- /* convert to utf8 string and strcat it to the logtext */
+ if (md->paramcount >= 1) {
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[0], a0);
+ }
- u = javastring_toutf(s, false);
+ if (md->paramcount >= 2) {
+ strcat(logtext, ", ");
- strcat(logtext, ", String = \"");
- utf_strcat_convert_to_latin1(logtext, u);
- strcat(logtext, "\"");
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[1], a1);
+ }
- } else {
- if (o->vftbl->class == class_java_lang_Class) {
- /* if the object returned is a java.lang.Class
- cast it to classinfo structure and get the name
- of the class */
+#if TRACE_ARGS_NUM >= 4
+ if (md->paramcount >= 3) {
+ strcat(logtext, ", ");
- c = (classinfo *) (ptrint) l;
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[2], a2);
+ }
- u = c->name;
+ if (md->paramcount >= 4) {
+ strcat(logtext, ", ");
- } else {
- /* if the object returned is not a java.lang.String or
- a java.lang.Class just print the name of the class */
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[3], a3);
+ }
+#endif
- u = o->vftbl->class->name;
- }
+#if TRACE_ARGS_NUM >= 6
+ if (md->paramcount >= 5) {
+ strcat(logtext, ", ");
- len = strlen(", Class = \"") + utf_get_number_of_u2s(u) + strlen("\"");
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[4], a4);
+ }
- /* realloc memory for string length */
+ if (md->paramcount >= 6) {
+ strcat(logtext, ", ");
- DMREALLOC(logtext, char, logtextlen, logtextlen + len);
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[5], a5);
+ }
+#endif
- /* strcat to the logtext */
+#if TRACE_ARGS_NUM == 8
+ if (md->paramcount >= 7) {
+ strcat(logtext, ", ");
- strcat(logtext, ", Class = \"");
- utf_strcat_convert_to_latin1(logtext, u);
- strcat(logtext, "\"");
- }
- }
- break;
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[6], a6);
+ }
- case TYPE_FLT:
- imu.f = f;
- sprintf(logtext + strlen(logtext), "->%.8f (0x%08x)", f, imu.i);
- break;
+ if (md->paramcount >= 8) {
+ strcat(logtext, ", ");
- case TYPE_DBL:
- imu.d = d;
-#if SIZEOF_VOID_P == 4
- sprintf(logtext + strlen(logtext), "->%.16g (0x%016llx)", d, imu.l);
-#else
- sprintf(logtext + strlen(logtext), "->%.16g (0x%016lx)", d, imu.l);
+ logtext = builtin_print_argument(logtext, &logtextlen,
+ &md->paramtypes[7], a7);
+ }
#endif
- break;
+
+ if (md->paramcount > 8) {
+ sprintf(logtext + strlen(logtext), ", ...(%d)",
+ md->paramcount - TRACE_ARGS_NUM);
}
+ strcat(logtext, ")");
+
log_text(logtext);
/* release memory */
dump_release(dumpsize);
-}
-#endif /* !defined(NDEBUG) */
-
-/****************************************************************************
- SYNCHRONIZATION FUNCTIONS
-*****************************************************************************/
-
-#if defined(USE_THREADS) && !defined(NATIVE_THREADS)
-/*
- * Lock the mutex of an object.
- */
-void internal_lock_mutex_for_object(java_objectheader *object)
-{
- mutexHashEntry *entry;
- int hashValue;
+ TRACEJAVACALLINDENT++;
- assert(object != 0);
+}
+#endif
+#endif /* !defined(NDEBUG) */
- hashValue = MUTEX_HASH_VALUE(object);
- entry = &mutexHashTable[hashValue];
- if (entry->object != 0) {
- if (entry->mutex.count == 0 && entry->conditionCount == 0) {
- entry->object = 0;
- entry->mutex.holder = 0;
- entry->mutex.count = 0;
- entry->mutex.muxWaiters = 0;
+/* builtin_verbosecall_exit ****************************************************
- } else {
- while (entry->next != 0 && entry->object != object)
- entry = entry->next;
+ Print method exit for -verbose:call.
- if (entry->object != object) {
- entry->next = firstFreeOverflowEntry;
- firstFreeOverflowEntry = firstFreeOverflowEntry->next;
+*******************************************************************************/
- entry = entry->next;
- entry->object = 0;
- entry->next = 0;
- assert(entry->conditionCount == 0);
- }
- }
+#if !defined(NDEBUG)
+void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m)
+{
+ methoddesc *md;
+ char *logtext;
+ s4 logtextlen;
+ s4 dumpsize;
+ s4 i;
+ s4 pos;
+ imm_union val;
+ int methodindent;
- } else {
- entry->mutex.holder = 0;
- entry->mutex.count = 0;
- entry->mutex.muxWaiters = 0;
- }
+#if defined(ENABLE_DEBUG_FILTER)
+ if (! show_filters_test_verbosecall_exit(m)) return;
+#endif
- if (entry->object == 0)
- entry->object = object;
-
- internal_lock_mutex(&entry->mutex);
-}
+#if defined(ENABLE_VMLOG)
+ vmlog_cacao_leave_method(m);
+ return;
#endif
+ md = m->parseddesc;
-#if defined(USE_THREADS) && !defined(NATIVE_THREADS)
-/*
- * Unlocks the mutex of an object.
- */
-void internal_unlock_mutex_for_object (java_objectheader *object)
-{
- int hashValue;
- mutexHashEntry *entry;
+ /* outdent the log message */
- hashValue = MUTEX_HASH_VALUE(object);
- entry = &mutexHashTable[hashValue];
+ if (TRACEJAVACALLINDENT)
+ TRACEJAVACALLINDENT--;
+ else
+ log_text("WARNING: unmatched methodindent--");
- if (entry->object == object) {
- internal_unlock_mutex(&entry->mutex);
+ methodindent = TRACEJAVACALLINDENT;
- } else {
- while (entry->next != 0 && entry->next->object != object)
- entry = entry->next;
+ /* calculate message length */
- assert(entry->next != 0);
+ logtextlen =
+ strlen("4294967295 ") +
+ strlen("-2147483647-") + /* INT_MAX should be sufficient */
+ methodindent +
+ strlen("finished: ") +
+ utf_bytes(m->class->name) +
+ strlen(".") +
+ utf_bytes(m->name) +
+ utf_bytes(m->descriptor) +
+ strlen(" SYNCHRONIZED") + strlen("(") + strlen(")");
- internal_unlock_mutex(&entry->next->mutex);
+ /* add maximal argument length */
- if (entry->next->mutex.count == 0 && entry->conditionCount == 0) {
- mutexHashEntry *unlinked = entry->next;
+ logtextlen += strlen("->0.4872328470301428 (0x0123456789abcdef)");
- entry->next = unlinked->next;
- unlinked->next = firstFreeOverflowEntry;
- firstFreeOverflowEntry = unlinked;
- }
- }
-}
-#endif
+ /* allocate memory */
-#if defined(ENABLE_CYCLES_STATS)
-void builtin_print_cycles_stats(FILE *file)
-{
- fprintf(file,"builtin cylce count statistics:\n");
+ dumpsize = dump_size();
- CYCLES_STATS_PRINT_OVERHEAD(builtin_overhead,file);
- CYCLES_STATS_PRINT(builtin_monitorenter,file);
- CYCLES_STATS_PRINT(builtin_monitorexit ,file);
- CYCLES_STATS_PRINT(builtin_new ,file);
+ logtext = DMNEW(char, logtextlen);
- fprintf(file,"\n");
-}
-#endif /* defined(ENABLE_CYCLES_STATS) */
+ /* generate the message */
-#if defined(USE_THREADS)
-void builtin_monitorenter(java_objectheader *o)
-{
-#if defined(ENABLE_CYCLES_STATS)
- u8 cycles_start, cycles_overhead, cycles_end;
-#endif
+ sprintf(logtext, " ");
+ sprintf(logtext + strlen(logtext), "-%d-", methodindent);
-#if !defined(NATIVE_THREADS)
- int hashValue;
+ pos = strlen(logtext);
- ++blockInts;
+ for (i = 0; i < methodindent; i++)
+ logtext[pos++] = '\t';
- hashValue = MUTEX_HASH_VALUE(o);
- if (mutexHashTable[hashValue].object == o
- && mutexHashTable[hashValue].mutex.holder == currentThread)
- ++mutexHashTable[hashValue].mutex.count;
- else
- internal_lock_mutex_for_object(o);
+ strcpy(logtext + pos, "finished: ");
+ utf_cat_classname(logtext, m->class->name);
+ strcat(logtext, ".");
+ utf_cat(logtext, m->name);
+ utf_cat(logtext, m->descriptor);
+
+ if (!IS_VOID_TYPE(md->returntype.type)) {
+ strcat(logtext, "->");
+
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ val.l = l;
+ break;
+
+ case TYPE_FLT:
+ val.f = f;
+ break;
+
+ case TYPE_DBL:
+ val.d = d;
+ break;
+ }
- --blockInts;
-#else /* defined(NATIVE_THREADS) */
- CYCLES_STATS_GET(cycles_start);
- CYCLES_STATS_GET(cycles_overhead);
+ logtext =
+ builtin_print_argument(logtext, &logtextlen, &md->returntype, val.l);
+ }
- monitorEnter((threadobject *) THREADOBJECT, o);
+ log_text(logtext);
- CYCLES_STATS_GET(cycles_end);
- CYCLES_STATS_COUNT(builtin_monitorenter, cycles_end - cycles_overhead);
- CYCLES_STATS_COUNT(builtin_overhead , cycles_overhead - cycles_start);
-#endif /* defined(NATIVE_THREADS) */
-}
-#endif
+ /* release memory */
+ dump_release(dumpsize);
-#if defined(USE_THREADS)
-/*
- * Locks the class object - needed for static synchronized methods.
- */
-void builtin_staticmonitorenter(classinfo *c)
-{
- builtin_monitorenter(&c->object.header);
}
-#endif
+#endif /* !defined(NDEBUG) */
-#if defined(USE_THREADS)
-void builtin_monitorexit(java_objectheader *o)
-{
#if defined(ENABLE_CYCLES_STATS)
- u8 cycles_start, cycles_end;
-#endif
-
-#if !defined(NATIVE_THREADS)
- int hashValue;
-
- ++blockInts;
-
- hashValue = MUTEX_HASH_VALUE(o);
- if (mutexHashTable[hashValue].object == o) {
- if (mutexHashTable[hashValue].mutex.count == 1
- && mutexHashTable[hashValue].mutex.muxWaiters != 0)
- internal_unlock_mutex_for_object(o);
- else
- --mutexHashTable[hashValue].mutex.count;
-
- } else
- internal_unlock_mutex_for_object(o);
-
- --blockInts;
-#else /* defined(NATIVE_THREADS) */
- CYCLES_STATS_GET(cycles_start);
+void builtin_print_cycles_stats(FILE *file)
+{
+ fprintf(file,"builtin cylce count statistics:\n");
- monitorExit((threadobject *) THREADOBJECT, o);
+ CYCLES_STATS_PRINT_OVERHEAD(builtin_overhead,file);
+ CYCLES_STATS_PRINT(builtin_new ,file);
- CYCLES_STATS_GET(cycles_end);
- CYCLES_STATS_COUNT(builtin_monitorexit, cycles_end - cycles_start);
-#endif /* defined(NATIVE_THREADS) */
+ fprintf(file,"\n");
}
-#endif
+#endif /* defined(ENABLE_CYCLES_STATS) */
/*****************************************************************************
******************************************************************************/
-#if !SUPPORT_DIVISION
+#if !SUPPORT_DIVISION || defined(DISABLE_GC)
s4 builtin_idiv(s4 a, s4 b)
{
s4 c;
return c;
}
-#endif /* !SUPPORT_DIVISION */
+#endif /* !SUPPORT_DIVISION || defined(DISABLE_GC) */
/* functions for long arithmetics **********************************************
#endif /* !(SUPPORT_LONG && SUPPORT_LONG_MUL) */
-#if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV)
+#if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV) || defined (DISABLE_GC)
s8 builtin_ldiv(s8 a, s8 b)
{
s8 c;
#endif /* !SUPPORT_FLOAT */
-#if !SUPPORT_FLOAT || defined(ENABLE_INTRP)
+#if !SUPPORT_FLOAT || !SUPPORT_FLOAT_CMP || defined(ENABLE_INTRP)
s4 builtin_fcmpl(float a, float b)
{
- if (isnanf(a)) return -1;
- if (isnanf(b)) return -1;
+ if (isnanf(a))
+ return -1;
+
+ if (isnanf(b))
+ return -1;
+
if (!finitef(a) || !finitef(b)) {
a = finitef(a) ? 0 : copysignf(1.0, a);
b = finitef(b) ? 0 : copysignf(1.0, b);
}
- if (a > b) return 1;
- if (a == b) return 0;
+
+ if (a > b)
+ return 1;
+
+ if (a == b)
+ return 0;
+
return -1;
}
if (a == b) return 0;
return -1;
}
-#endif /* !SUPPORT_FLOAT || defined(ENABLE_INTRP) */
+#endif /* !SUPPORT_FLOAT || !SUPPORT_FLOAT_CMP || defined(ENABLE_INTRP) */
float builtin_frem(float a, float b)
#endif /* !SUPPORT_DOUBLE */
-#if !SUPPORT_DOUBLE || defined(ENABLE_INTRP)
+#if !SUPPORT_DOUBLE || !SUPPORT_DOUBLE_CMP || defined(ENABLE_INTRP)
s4 builtin_dcmpl(double a, double b)
{
- if (isnan(a)) return -1;
- if (isnan(b)) return -1;
+ if (isnan(a))
+ return -1;
+
+ if (isnan(b))
+ return -1;
+
if (!finite(a) || !finite(b)) {
a = finite(a) ? 0 : copysign(1.0, a);
b = finite(b) ? 0 : copysign(1.0, b);
}
- if (a > b) return 1;
- if (a == b) return 0;
+
+ if (a > b)
+ return 1;
+
+ if (a == b)
+ return 0;
+
return -1;
}
s4 builtin_dcmpg(double a, double b)
{
- if (isnan(a)) return 1;
- if (isnan(b)) return 1;
+ if (isnan(a))
+ return 1;
+
+ if (isnan(b))
+ return 1;
+
if (!finite(a) || !finite(b)) {
a = finite(a) ? 0 : copysign(1.0, a);
b = finite(b) ? 0 : copysign(1.0, b);
}
- if (a > b) return 1;
- if (a == b) return 0;
+
+ if (a > b)
+ return 1;
+
+ if (a == b)
+ return 0;
+
return -1;
}
-#endif /* !SUPPORT_DOUBLE || defined(ENABLE_INTRP) */
+#endif /* !SUPPORT_DOUBLE || !SUPPORT_DOUBLE_CMP || defined(ENABLE_INTRP) */
double builtin_drem(double a, double b)
#endif /* !(SUPPORT_LONG && SUPPORT_DOUBLE && SUPPORT_L2D) */
-#if !(SUPPORT_FLOAT && SUPPORT_F2I) || defined(ENABLE_INTRP)
+#if !(SUPPORT_FLOAT && SUPPORT_F2I) || defined(ENABLE_INTRP) || defined(DISABLE_GC)
s4 builtin_f2i(float a)
{
s4 i;
return 2147483647;
return (-2147483648); */
}
-#endif /* !(SUPPORT_FLOAT && SUPPORT_F2I) || defined(ENABLE_INTRP) */
+#endif /* !(SUPPORT_FLOAT && SUPPORT_F2I) || defined(ENABLE_INTRP) || defined(DISABLE_GC) */
-#if !(SUPPORT_FLOAT && SUPPORT_LONG && SUPPORT_F2L)
+#if !(SUPPORT_FLOAT && SUPPORT_LONG && SUPPORT_F2L) || defined(DISABLE_GC)
s8 builtin_f2l(float a)
{
s8 l;
#endif /* !(SUPPORT_FLOAT && SUPPORT_LONG && SUPPORT_F2L) */
-#if !(SUPPORT_DOUBLE && SUPPORT_D2I) || defined(ENABLE_INTRP)
+#if !(SUPPORT_DOUBLE && SUPPORT_D2I) || defined(ENABLE_INTRP) || defined(DISABLE_GC)
s4 builtin_d2i(double a)
{
double d;
return 2147483647;
return (-2147483647-1);
}
-#endif /* !(SUPPORT_DOUBLE && SUPPORT_D2I) || defined(ENABLE_INTRP) */
+#endif /* !(SUPPORT_DOUBLE && SUPPORT_D2I) || defined(ENABLE_INTRP) || defined(DISABLE_GC) */
-#if !(SUPPORT_DOUBLE && SUPPORT_LONG && SUPPORT_D2L)
+#if !(SUPPORT_DOUBLE && SUPPORT_LONG && SUPPORT_D2L) || defined(DISABLE_GC)
s8 builtin_d2l(double a)
{
double d;
#endif /* !(SUPPORT_FLOAT && SUPPORT_DOUBLE) */
-/* builtin_clone_array *********************************************************
+/* builtin_arraycopy ***********************************************************
+
+ Builtin for java.lang.System.arraycopy.
+
+*******************************************************************************/
+
+void builtin_arraycopy(java_handle_t *src, s4 srcStart,
+ java_handle_t *dest, s4 destStart, s4 len)
+{
+ arraydescriptor *sdesc;
+ arraydescriptor *ddesc;
+ s4 i;
+
+ if ((src == NULL) || (dest == NULL)) {
+ exceptions_throw_nullpointerexception();
+ return;
+ }
+
+ sdesc = LLNI_vftbl_direct(src)->arraydesc;
+ ddesc = LLNI_vftbl_direct(dest)->arraydesc;
+
+ if (!sdesc || !ddesc || (sdesc->arraytype != ddesc->arraytype)) {
+ exceptions_throw_arraystoreexception();
+ return;
+ }
+
+ /* we try to throw exception with the same message as SUN does */
+
+ if ((len < 0) || (srcStart < 0) || (destStart < 0) ||
+ (srcStart + len < 0) || (srcStart + len > LLNI_array_size(src)) ||
+ (destStart + len < 0) || (destStart + len > LLNI_array_size(dest))) {
+ exceptions_throw_arrayindexoutofboundsexception();
+ return;
+ }
+
+ if (sdesc->componentvftbl == ddesc->componentvftbl) {
+ /* We copy primitive values or references of exactly the same type */
+
+ s4 dataoffset = sdesc->dataoffset;
+ s4 componentsize = sdesc->componentsize;
+
+ memmove(((u1 *) dest) + dataoffset + componentsize * destStart,
+ ((u1 *) src) + dataoffset + componentsize * srcStart,
+ (size_t) len * componentsize);
+ }
+ else {
+ /* We copy references of different type */
+
+ java_handle_objectarray_t *oas = (java_handle_objectarray_t *) src;
+ java_handle_objectarray_t *oad = (java_handle_objectarray_t *) dest;
+
+ if (destStart <= srcStart) {
+ for (i = 0; i < len; i++) {
+ java_handle_t *o;
+
+ LLNI_objectarray_element_get(oas, srcStart + i, o);
+
+ if (!builtin_canstore(oad, o))
+ return;
+
+ LLNI_objectarray_element_set(oad, destStart + i, o);
+ }
+ }
+ else {
+ /* XXX this does not completely obey the specification!
+ If an exception is thrown only the elements above the
+ current index have been copied. The specification
+ requires that only the elements *below* the current
+ index have been copied before the throw. */
+
+ for (i = len - 1; i >= 0; i--) {
+ java_handle_t *o;
+
+ LLNI_objectarray_element_get(oas, srcStart + i, o);
+
+ if (!builtin_canstore(oad, o))
+ return;
+
+ LLNI_objectarray_element_set(oad, destStart + i, o);
+ }
+ }
+ }
+}
+
- Wrapper function for cloning arrays.
+/* builtin_nanotime ************************************************************
+
+ Return the current time in nanoseconds.
*******************************************************************************/
-java_arrayheader *builtin_clone_array(void *env, java_arrayheader *o)
+s8 builtin_nanotime(void)
{
- java_arrayheader *ah;
- java_lang_Cloneable *c;
+ struct timeval tv;
+ s8 usecs;
+
+ if (gettimeofday(&tv, NULL) == -1)
+ vm_abort("gettimeofday failed: %s", strerror(errno));
+
+ usecs = (s8) tv.tv_sec * (1000 * 1000) + (s8) tv.tv_usec;
+
+ return usecs * 1000;
+}
+
- c = (java_lang_Cloneable *) o;
+/* builtin_currenttimemillis ***************************************************
- ah = (java_arrayheader *) Java_java_lang_VMObject_clone(0, 0, c);
+ Return the current time in milliseconds.
- return ah;
+*******************************************************************************/
+
+s8 builtin_currenttimemillis(void)
+{
+ s8 msecs;
+
+ msecs = builtin_nanotime() / 1000 / 1000;
+
+ return msecs;
}
-/* builtin_asm_get_exceptionptrptr *********************************************
+/* builtin_clone ***************************************************************
- this is a wrapper for calls from asmpart
+ Function for cloning objects or arrays.
*******************************************************************************/
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-java_objectheader **builtin_asm_get_exceptionptrptr(void)
+java_handle_t *builtin_clone(void *env, java_handle_t *o)
{
- return builtin_get_exceptionptrptr();
+ arraydescriptor *ad;
+ java_handle_t *ah;
+ u4 size;
+ classinfo *c;
+ java_handle_t *co; /* cloned object header */
+
+ /* get the array descriptor */
+
+ ad = LLNI_vftbl_direct(o)->arraydesc;
+
+ /* we are cloning an array */
+
+ if (ad != NULL) {
+ ah = (java_handle_t *) o;
+
+ size = ad->dataoffset + ad->componentsize * LLNI_array_size(ah);
+
+ co = heap_alloc(size, (ad->arraytype == ARRAYTYPE_OBJECT), NULL, true);
+
+ if (co == NULL)
+ return NULL;
+
+ MCOPY(co, o, u1, size);
+
+#if defined(ENABLE_GC_CACAO)
+ heap_init_objectheader(co, size);
+#endif
+
+#if defined(ENABLE_THREADS)
+ lock_init_object_lock(co);
+#endif
+
+ return co;
+ }
+
+ /* we are cloning a non-array */
+
+ if (!builtin_instanceof(o, class_java_lang_Cloneable)) {
+ exceptions_throw_clonenotsupportedexception();
+ return NULL;
+ }
+
+ /* get the class of the object */
+
+ LLNI_class_get(o, c);
+
+ /* create new object */
+
+ co = builtin_new(c);
+
+ if (co == NULL)
+ return NULL;
+
+ MCOPY(co, o, u1, c->instancesize);
+
+#if defined(ENABLE_GC_CACAO)
+ heap_init_objectheader(co, c->instancesize);
+#endif
+
+#if defined(ENABLE_THREADS)
+ lock_init_object_lock(co);
+#endif
+
+ return co;
}
+
+#if defined(ENABLE_VMLOG)
+#define NDEBUG
+#include <vmlog_cacao.c>
#endif