X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=builtin.c;h=acd8f50709abfe1c059d5316e3464f808d0c298b;hb=a99bacb6174d51571e29ec0e141a9b4db38db54d;hp=e3e82db7b7423655cbf8ae8d9d58bec098cb0a22;hpb=cf0614dc30f0285eaa215c18ccf567147bcc3a63;p=cacao.git diff --git a/builtin.c b/builtin.c index e3e82db7b..acd8f5070 100644 --- a/builtin.c +++ b/builtin.c @@ -34,13 +34,14 @@ calls instead of machine instructions, using the C calling convention. - $Id: builtin.c 612 2003-11-12 13:14:38Z twisti $ + $Id: builtin.c 957 2004-03-14 21:01:12Z twisti $ */ #include #include +#include #include "main.h" #include "global.h" #include "builtin.h" @@ -48,107 +49,20 @@ #include "loader.h" #include "tables.h" #include "asmpart.h" +#include "mm/boehm.h" #include "threads/thread.h" #include "threads/locks.h" #include "toolbox/loging.h" #include "toolbox/memory.h" +#include "nat/java_lang_Cloneable.h" +#include "nat/java_lang_VMObject.h" -#include "native-math.h" +#undef DEBUG /*define DEBUG 1*/ -builtin_descriptor builtin_desc[] = { - {(functionptr) builtin_instanceof, "instanceof"}, - {(functionptr) builtin_checkcast, "checkcast"}, - {(functionptr) asm_builtin_checkcast, "checkcast"}, - {(functionptr) builtin_arrayinstanceof, "arrayinstanceof"}, -#if defined(__I386__) - {(functionptr) asm_builtin_arrayinstanceof,"arrayinstanceof"}, -#endif - {(functionptr) builtin_checkarraycast, "checkarraycast"}, - {(functionptr) asm_builtin_checkarraycast, "checkarraycast"}, - {(functionptr) asm_builtin_aastore, "aastore"}, - {(functionptr) builtin_new, "new"}, - {(functionptr) builtin_anewarray, "anewarray"}, - {(functionptr) builtin_newarray_array, "newarray_array"}, -#if defined(__I386__) - /* have 2 parameters (needs stack manipulation) */ - {(functionptr) asm_builtin_anewarray, "anewarray"}, - {(functionptr) asm_builtin_newarray_array, "newarray_array"}, -#endif - {(functionptr) builtin_newarray_boolean, "newarray_boolean"}, - {(functionptr) builtin_newarray_char, "newarray_char"}, - {(functionptr) builtin_newarray_float, "newarray_float"}, - {(functionptr) builtin_newarray_double, "newarray_double"}, - {(functionptr) builtin_newarray_byte, "newarray_byte"}, - {(functionptr) builtin_newarray_short, "newarray_short"}, - {(functionptr) builtin_newarray_int, "newarray_int"}, - {(functionptr) builtin_newarray_long, "newarray_long"}, - {(functionptr) builtin_displaymethodstart, "displaymethodstart"}, - {(functionptr) builtin_displaymethodstop, "displaymethodstop"}, - {(functionptr) builtin_monitorenter, "monitorenter"}, - {(functionptr) asm_builtin_monitorenter, "monitorenter"}, - {(functionptr) builtin_monitorexit, "monitorexit"}, - {(functionptr) asm_builtin_monitorexit, "monitorexit"}, -#if !SUPPORT_DIVISION - {(functionptr) builtin_idiv, "idiv"}, - {(functionptr) asm_builtin_idiv, "idiv"}, - {(functionptr) builtin_irem, "irem"}, - {(functionptr) asm_builtin_irem, "irem"}, -#endif - {(functionptr) builtin_ladd, "ladd"}, - {(functionptr) builtin_lsub, "lsub"}, - {(functionptr) builtin_lmul, "lmul"}, -#if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV) - {(functionptr) builtin_ldiv, "ldiv"}, - {(functionptr) asm_builtin_ldiv, "ldiv"}, - {(functionptr) builtin_lrem, "lrem"}, - {(functionptr) asm_builtin_lrem, "lrem"}, -#endif - {(functionptr) builtin_lshl, "lshl"}, - {(functionptr) builtin_lshr, "lshr"}, - {(functionptr) builtin_lushr, "lushr"}, - {(functionptr) builtin_land, "land"}, - {(functionptr) builtin_lor, "lor"}, - {(functionptr) builtin_lxor, "lxor"}, - {(functionptr) builtin_lneg, "lneg"}, - {(functionptr) builtin_lcmp, "lcmp"}, - {(functionptr) builtin_fadd, "fadd"}, - {(functionptr) builtin_fsub, "fsub"}, - {(functionptr) builtin_fmul, "fmul"}, - {(functionptr) builtin_fdiv, "fdiv"}, - {(functionptr) builtin_frem, "frem"}, - {(functionptr) builtin_fneg, "fneg"}, - {(functionptr) builtin_fcmpl, "fcmpl"}, - {(functionptr) builtin_fcmpg, "fcmpg"}, - {(functionptr) builtin_dadd, "dadd"}, - {(functionptr) builtin_dsub, "dsub"}, - {(functionptr) builtin_dmul, "dmul"}, - {(functionptr) builtin_ddiv, "ddiv"}, - {(functionptr) builtin_drem, "drem"}, - {(functionptr) builtin_dneg, "dneg"}, - {(functionptr) builtin_dcmpl, "dcmpl"}, - {(functionptr) builtin_dcmpg, "dcmpg"}, - {(functionptr) builtin_i2l, "i2l"}, - {(functionptr) builtin_i2f, "i2f"}, - {(functionptr) builtin_i2d, "i2d"}, - {(functionptr) builtin_l2i, "l2i"}, - {(functionptr) builtin_l2f, "l2f"}, - {(functionptr) builtin_l2d, "l2d"}, - {(functionptr) builtin_f2i, "f2i"}, - {(functionptr) builtin_f2l, "f2l"}, - {(functionptr) builtin_f2d, "f2d"}, - {(functionptr) builtin_d2i, "d2i"}, - {(functionptr) builtin_d2l, "d2l"}, -#if defined(__I386__) - {(functionptr) asm_builtin_f2i, "f2i"}, - {(functionptr) asm_builtin_f2l, "f2l"}, - {(functionptr) asm_builtin_d2i, "d2i"}, - {(functionptr) asm_builtin_d2l, "d2l"}, -#endif - {(functionptr) builtin_d2f, "d2f"}, - {(functionptr) NULL, "unknown"} -}; +THREADSPECIFIC methodinfo* _threadrootmethod = NULL; +THREADSPECIFIC void *_thread_nativestackframeinfo=NULL; /***************************************************************************** TYPE CHECKS @@ -164,9 +78,11 @@ builtin_descriptor builtin_desc[] = { 0 ... otherwise *****************************************************************************/ - -s4 builtin_isanysubclass (classinfo *sub, classinfo *super) +s4 builtin_isanysubclass(classinfo *sub, classinfo *super) { + s4 res; + + /*classinfo *tmp;*/ if (super->flags & ACC_INTERFACE) return (sub->vftbl->interfacetablelength > super->index) && (sub->vftbl->interfacetable[-super->index] != NULL); @@ -181,8 +97,60 @@ s4 builtin_isanysubclass (classinfo *sub, classinfo *super) return 0; */ - return (unsigned) (sub->vftbl->baseval - super->vftbl->baseval) <= +/* + for (tmp=sub;tmp!=0;tmp=tmp->super) { + printf("->"); + utf_display(tmp->name); + } + printf("\n\n"); + + for (tmp=super;tmp!=0;tmp=tmp->super) { + printf("->"); + utf_display(tmp->name); + } + printf("\n"); + + + printf("sub->vftbl->baseval %d, super->vftbl->baseval %d\n diff %d, super->vftbl->diffval %d\n", + sub->vftbl->baseval, super->vftbl->baseval, (unsigned)(sub->vftbl->baseval - super->vftbl->baseval), + super->vftbl->diffval); */ + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_lock(); +#endif + + res = (unsigned) (sub->vftbl->baseval - super->vftbl->baseval) <= (unsigned) (super->vftbl->diffval); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_unlock(); +#endif + + return res; +} + +s4 builtin_isanysubclass_vftbl(vftbl *sub,vftbl *super) +{ + int base; + s4 res; + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_lock(); +#endif + + if ((base = super->baseval) <= 0) + /* super is an interface */ + res = (sub->interfacetablelength > -base) && + (sub->interfacetable[base] != NULL); + else + res = (unsigned) (sub->baseval - base) + <= (unsigned) (super->diffval); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_unlock(); +#endif + + return res; } @@ -196,12 +164,12 @@ s4 builtin_isanysubclass (classinfo *sub, classinfo *super) *****************************************************************************/ +/* XXX should use vftbl */ s4 builtin_instanceof(java_objectheader *obj, classinfo *class) { #ifdef DEBUG log_text ("builtin_instanceof called"); -#endif - +#endif if (!obj) return 0; return builtin_isanysubclass (obj->vftbl->class, class); } @@ -215,6 +183,7 @@ s4 builtin_instanceof(java_objectheader *obj, classinfo *class) ****************************************************************************/ +/* XXX should use vftbl */ s4 builtin_checkcast(java_objectheader *obj, classinfo *class) { #ifdef DEBUG @@ -246,21 +215,23 @@ s4 builtin_checkcast(java_objectheader *obj, classinfo *class) ******************************************************************************/ -static s4 builtin_descriptorscompatible(constant_arraydescriptor *desc, constant_arraydescriptor *target) +static s4 builtin_descriptorscompatible(arraydescriptor *desc,arraydescriptor *target) { - if (desc == target) return 1; + if (desc==target) return 1; if (desc->arraytype != target->arraytype) return 0; - - switch (target->arraytype) { - case ARRAYTYPE_OBJECT: - return builtin_isanysubclass(desc->objectclass, target->objectclass); - case ARRAYTYPE_ARRAY: - return builtin_descriptorscompatible - (desc->elementdescriptor, target->elementdescriptor); - default: return 1; + if (desc->arraytype != ARRAYTYPE_OBJECT) return 1; + + /* {both arrays are arrays of references} */ + if (desc->dimension == target->dimension) { + /* an array which contains elements of interface types is allowed to be casted to Object (JOWENN)*/ + if ( (desc->elementvftbl->baseval<0) && (target->elementvftbl->baseval==1) ) return 1; + return builtin_isanysubclass_vftbl(desc->elementvftbl,target->elementvftbl); } -} + if (desc->dimension < target->dimension) return 0; + /* {desc has higher dimension than target} */ + return builtin_isanysubclass_vftbl(pseudo_class_Arraystub_vftbl,target->elementvftbl); +} /******************** function: builtin_checkarraycast *********************** @@ -280,57 +251,21 @@ static s4 builtin_descriptorscompatible(constant_arraydescriptor *desc, constant *****************************************************************************/ -s4 builtin_checkarraycast(java_objectheader *o, constant_arraydescriptor *desc) +s4 builtin_checkarraycast(java_objectheader *o, vftbl *target) { - java_arrayheader *a = (java_arrayheader*) o; - - if (!o) return 1; - if (o->vftbl->class != class_array) { -#ifdef DEBUG - printf("#### checkarraycast failed 1\n"); -#endif - return 0; - } - - if (a->arraytype != desc->arraytype) { -#ifdef DEBUG - printf("#### checkarraycast failed 2\n"); -#endif - return 0; - } + arraydescriptor *desc; - switch (a->arraytype) { - case ARRAYTYPE_OBJECT: { - java_objectarray *oa = (java_objectarray*) o; - int result = builtin_isanysubclass(oa->elementtype, desc->objectclass); - -#ifdef DEBUG - if (!result) - printf("#### checkarraycast failed 3\n"); -#endif - return result; - } - case ARRAYTYPE_ARRAY: { - java_arrayarray *aa = (java_arrayarray*) o; - int result = builtin_descriptorscompatible - (aa->elementdescriptor, desc->elementdescriptor); + if (!o) return 1; + if ((desc = o->vftbl->arraydesc) == NULL) return 0; -#ifdef DEBUG - if (!result) - printf("#### checkarraycast failed 4\n"); -#endif - return result; - } - default: - return 1; - } + return builtin_descriptorscompatible(desc, target->arraydesc); } -s4 builtin_arrayinstanceof(java_objectheader *obj, constant_arraydescriptor *desc) +s4 builtin_arrayinstanceof(java_objectheader *obj, vftbl *target) { if (!obj) return 1; - return builtin_checkarraycast (obj, desc); + return builtin_checkarraycast(obj, target); } @@ -341,14 +276,42 @@ s4 builtin_arrayinstanceof(java_objectheader *obj, constant_arraydescriptor *des java_objectheader *builtin_throw_exception(java_objectheader *local_exceptionptr) { if (verbose) { + char logtext[MAXLOGTEXT]; sprintf(logtext, "Builtin exception thrown: "); - utf_sprint(logtext + strlen(logtext), local_exceptionptr->vftbl->class->name); - dolog(); + if (local_exceptionptr) + utf_sprint(logtext + strlen(logtext), local_exceptionptr->vftbl->class->name); + else { + sprintf(logtext+strlen(logtext),"%s","Error: "); + if (!proto_java_lang_ClassCastException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_ClassCastException==0"); + if (!proto_java_lang_NullPointerException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_NullPointerException==0"); + if (!proto_java_lang_NullPointerException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_NullPointerException==0"); + if (!proto_java_lang_ArrayIndexOutOfBoundsException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_ArrayIndexOutOfBoundsException==0"); + if (!proto_java_lang_NegativeArraySizeException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_NegativeArraySizeException==0"); + if (!proto_java_lang_OutOfMemoryError) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_OutOfMemoryError==0"); + if (!proto_java_lang_ArithmeticException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_ArithmeticException==0"); + if (!proto_java_lang_ArrayStoreException) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_ArrayStoreException==0"); + if (!proto_java_lang_ThreadDeath) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_ThreadDeath==0"); + if (!proto_java_lang_ThreadDeath) sprintf(logtext+strlen(logtext),"%s","proto_java_lang_ThreadDeath==0"); + } + log_text(logtext); } - exceptionptr = local_exceptionptr; + *exceptionptr = local_exceptionptr; return local_exceptionptr; } +void builtin_reset_exceptionptr() +{ +#if defined(USE_THREADS) && defined(NATIVE_THREADS) +#ifdef HAVE___THREAD + _exceptionptr = NULL; +#else + ((nativethread*) pthread_getspecific(tkey_exceptionptr))->_exceptionptr = 0; +#endif +#else + panic("builtin_reset_exceptionptr should not be used in this configuration"); +#endif +} + /******************* function: builtin_canstore ******************************* @@ -358,39 +321,155 @@ java_objectheader *builtin_throw_exception(java_objectheader *local_exceptionptr ******************************************************************************/ +s4 builtin_canstore (java_objectarray *a, java_objectheader *o) +{ + arraydescriptor *desc; + arraydescriptor *valuedesc; + vftbl *componentvftbl; + vftbl *valuevftbl; + int dim_m1; + int base; + + if (!o) return 1; + + /* The following is guaranteed (by verifier checks): + * + * *) a->...vftbl->arraydesc != NULL + * *) a->...vftbl->arraydesc->componentvftbl != NULL + * *) o->vftbl is not an interface vftbl + */ + + desc = a->header.objheader.vftbl->arraydesc; + componentvftbl = desc->componentvftbl; + valuevftbl = o->vftbl; + + if ((dim_m1 = desc->dimension - 1) == 0) { + s4 res; + + /* {a is a one-dimensional array} */ + /* {a is an array of references} */ + + if (valuevftbl == componentvftbl) + return 1; + + if ((base = componentvftbl->baseval) <= 0) + /* an array of interface references */ + return (valuevftbl->interfacetablelength > -base && + valuevftbl->interfacetable[base] != NULL); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_lock(); +#endif + + res = (unsigned)(valuevftbl->baseval - base) + <= (unsigned)(componentvftbl->diffval); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_unlock(); +#endif + + return res; + } + /* {a has dimension > 1} */ + /* {componentvftbl->arraydesc != NULL} */ + + /* check if o is an array */ + if ((valuedesc = valuevftbl->arraydesc) == NULL) + return 0; + /* {o is an array} */ + + return builtin_descriptorscompatible(valuedesc,componentvftbl->arraydesc); +} -s4 builtin_canstore(java_objectarray *a, java_objectheader *o) + +/* This is an optimized version where a is guaranteed to be one-dimensional */ +s4 builtin_canstore_onedim (java_objectarray *a, java_objectheader *o) { + arraydescriptor *desc; + vftbl *elementvftbl; + vftbl *valuevftbl; + int base; + s4 res; + if (!o) return 1; + + /* The following is guaranteed (by verifier checks): + * + * *) a->...vftbl->arraydesc != NULL + * *) a->...vftbl->arraydesc->elementvftbl != NULL + * *) a->...vftbl->arraydesc->dimension == 1 + * *) o->vftbl is not an interface vftbl + */ + + desc = a->header.objheader.vftbl->arraydesc; + elementvftbl = desc->elementvftbl; + valuevftbl = o->vftbl; + + /* {a is a one-dimensional array} */ - switch (a->header.arraytype) { - case ARRAYTYPE_OBJECT: - if (!builtin_checkcast(o, a->elementtype)) { - return 0; - } + if (valuevftbl == elementvftbl) return 1; - break; - case ARRAYTYPE_ARRAY: - if (!builtin_checkarraycast - (o, ((java_arrayarray*)a)->elementdescriptor)) { - return 0; - } - return 1; - break; + if ((base = elementvftbl->baseval) <= 0) + /* an array of interface references */ + return (valuevftbl->interfacetablelength > -base && + valuevftbl->interfacetable[base] != NULL); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_lock(); +#endif - default: - panic("builtin_canstore called with invalid arraytype"); - return 0; - } + res = (unsigned)(valuevftbl->baseval - base) + <= (unsigned)(elementvftbl->diffval); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_unlock(); +#endif + + return res; } +/* 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) +{ + vftbl *elementvftbl; + vftbl *valuevftbl; + s4 res; + + if (!o) return 1; + + /* The following is guaranteed (by verifier checks): + * + * *) a->...vftbl->arraydesc != NULL + * *) a->...vftbl->arraydesc->elementvftbl != NULL + * *) a->...vftbl->arraydesc->elementvftbl is not an interface vftbl + * *) a->...vftbl->arraydesc->dimension == 1 + * *) o->vftbl is not an interface vftbl + */ + + elementvftbl = a->header.objheader.vftbl->arraydesc->elementvftbl; + valuevftbl = o->vftbl; -/***************************************************************************** - ARRAY OPERATIONS -*****************************************************************************/ + /* {a is a one-dimensional array} */ + + if (valuevftbl == elementvftbl) + return 1; +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_lock(); +#endif + + res = (unsigned)(valuevftbl->baseval - elementvftbl->baseval) + <= (unsigned)(elementvftbl->diffval); + +#if defined(USE_THREADS) && defined(NATIVE_THREADS) + cast_unlock(); +#endif + + return res; +} /******************** Function: builtin_new ********************************** @@ -407,8 +486,21 @@ s4 builtin_canstore(java_objectarray *a, java_objectheader *o) java_objectheader *builtin_new(classinfo *c) { java_objectheader *o; - - class_init(c); +/*DEBUGING - NOT THREAD SAFE*/ +/* static long depth=0; + depth++; + printf("Entering builtin_new:depth(%ld)",depth);*/ + + if (!c->initialized) { + if (initverbose) { + char logtext[MAXLOGTEXT]; + sprintf(logtext, "Initialize class "); + utf_sprint(logtext + strlen(logtext), c->name); + sprintf(logtext + strlen(logtext), " (from builtin_new)"); + log_text(logtext); + } + class_init(c); + } #ifdef SIZE_FROM_CLASSINFO c->alignedsize = align_size(c->instancesize); @@ -416,223 +508,125 @@ java_objectheader *builtin_new(classinfo *c) #else o = heap_allocate(c->instancesize, true, c->finalizer); #endif - if (!o) return NULL; + if (!o) { + /*DEBUGING - NOT THREAD SAFE*/ + /*printf("Leaving builtin_new: depth(%ld): NULL",depth); + depth--;*/ + return NULL; + } memset(o, 0, c->instancesize); o->vftbl = c->vftbl; + /*DEBUGING - NOT THREAD SAFE*/ + /* printf("Leaving builtin_new: depth(%ld): object",depth); + depth--;*/ return o; } +/********************** Function: builtin_newarray ************************** + Creates an array with the given vftbl on the heap. -/******************** function: builtin_anewarray **************************** - - Creates an array of pointers to objects on the heap. - Parameters: - size ......... number of elements - elementtype .. pointer to the classinfo structure for the element type - Return value: pointer to the array or NULL if no memory is available + CAUTION: The given vftbl must be the vftbl of the *array* class, + not of the element class. + *****************************************************************************/ -static -void* __builtin_newarray(s4 base_size, - s4 size, - bool references, - int elementsize, - int arraytype, - classinfo *el) +java_arrayheader *builtin_newarray(s4 size, vftbl *arrayvftbl) { java_arrayheader *a; - + arraydescriptor *desc = arrayvftbl->arraydesc; + s4 dataoffset = desc->dataoffset; + s4 componentsize = desc->componentsize; + s4 actualsize; + + if (size<0) { + *exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/NegativeArraySizeException"))); + return NULL; + } #ifdef SIZE_FROM_CLASSINFO - s4 alignedsize = align_size(base_size + (size-1) * elementsize); - a = heap_allocate(alignedsize, references, NULL); -#else - a = heap_allocate(sizeof(java_objectarray) + (size-1) * elementsize, - references, - NULL); + actualsize = align_size(dataoffset + size * componentsize); +#else + actualsize = dataoffset + size * componentsize; #endif - if (!a) return NULL; -#ifdef SIZE_FROM_CLASSINFO - memset(a, 0, alignedsize); -#else - memset(a, 0, base_size + (size-1) * elementsize); -#endif + if (((u4)actualsize)<((u4)size)) { /* overflow */ + *exceptionptr = native_new_and_init(loader_load(utf_new_char("java/lang/OutOfMemoryError"))); + return NULL; + } + a = heap_allocate(actualsize, + (desc->arraytype == ARRAYTYPE_OBJECT), + NULL); -#if 0 - { - classinfo *c; - - switch (arraytype) { - case ARRAYTYPE_INT: - c = create_array_class(utf_new_char("[I")); - use_class_as_object(c, "int"); - break; - - case ARRAYTYPE_LONG: - c = create_array_class(utf_new_char("[J")); - use_class_as_object(c, "long"); - break; - - case ARRAYTYPE_FLOAT: - c = create_array_class(utf_new_char("[F")); - use_class_as_object(c, "float"); - break; - - case ARRAYTYPE_DOUBLE: - c = create_array_class(utf_new_char("[D")); - use_class_as_object(c, "double"); - break; - - case ARRAYTYPE_BYTE: - c = create_array_class(utf_new_char("[B")); - use_class_as_object(c, "byte"); - break; - - case ARRAYTYPE_CHAR: - c = create_array_class(utf_new_char("[C")); - use_class_as_object(c, "char"); - break; - - case ARRAYTYPE_SHORT: - c = create_array_class(utf_new_char("[S")); - use_class_as_object(c, "short"); - break; - - case ARRAYTYPE_BOOLEAN: - c = create_array_class(utf_new_char("[Z")); - use_class_as_object(c, "boolean"); - break; - - case ARRAYTYPE_OBJECT: - { - char *cname, *buf; - cname = heap_allocate(utf_strlen(el->name), false, NULL); - utf_sprint(cname, el->name); - buf = heap_allocate(strlen(cname) + 3, false, NULL); - /* printf("\n\n[L%s;\n\n", cname); */ - sprintf(buf, "[L%s;", cname); - c = create_array_class(utf_new_char(buf)); - /* MFREE(buf, char, strlen(cname) + 3); */ - /* MFREE(cname, char, utf_strlen(el->name)); */ - use_class_as_object(c, cname); - } - break; + if (!a) return NULL; + memset(a, 0, actualsize); - case ARRAYTYPE_ARRAY: - c = create_array_class(utf_new_char("[[")); - use_class_as_object(c, "java/lang/Boolean"); - break; - default: - panic("unknown array type"); - } + /*printf("builtin_newarray: Created an array of size : %d\n",size);*/ - a->objheader.vftbl = c->vftbl; - } -#else - a->objheader.vftbl = class_array->vftbl; -#endif + a->objheader.vftbl = arrayvftbl; a->size = size; #ifdef SIZE_FROM_CLASSINFO - a->alignedsize = alignedsize; + a->alignedsize = actualsize; #endif - a->arraytype = arraytype; - - return a; -} - - -java_objectarray *builtin_anewarray(s4 size, classinfo *elementtype) -{ - java_objectarray *a; - a = (java_objectarray*)__builtin_newarray(sizeof(java_objectarray), - size, - true, - sizeof(void*), - ARRAYTYPE_OBJECT, - elementtype); - if (!a) return NULL; - a->elementtype = elementtype; return a; } +/********************** Function: builtin_anewarray ************************* -/******************** function: builtin_newarray_array *********************** + Creates an array of references to the given class type on the heap. - Creates an array of pointers to arrays on the heap. - Parameters: - size ......... number of elements - elementdesc .. pointer to the array description structure for the - element arrays - Return value: pointer to the array or NULL if no memory is available + XXX This function does not do The Right Thing, because it uses a + classinfo pointer at runtime. builtin_newarray should be used + instead. + *****************************************************************************/ -java_arrayarray *builtin_newarray_array(s4 size, - constant_arraydescriptor *elementdesc) +java_objectarray *builtin_anewarray(s4 size, classinfo *component) { - java_arrayarray *a; - a = (java_arrayarray*)__builtin_newarray(sizeof(java_arrayarray), - size, - true, - sizeof(void*), - ARRAYTYPE_ARRAY, - elementdesc->objectclass); - if (!a) return NULL; - - a->elementdescriptor = elementdesc; - return a; +/* + printf("builtin_anewarray: classvftbl: %d\n",component->classvftbl); + printf("builtin_anewarray: baseval: %d\n",component->vftbl->baseval); + utf_display(component->vftbl->class->name); + printf("\nbuiltin_anewarray: linked: %d\n",component->linked); + utf_display(component->super->name);*/ + return (java_objectarray*) builtin_newarray(size, class_array_of(component)->vftbl); } -/******************** function: builtin_newarray_boolean ************************ +/******************** Function: builtin_newarray_int *********************** + + Creates an array of 32 bit Integers on the heap. - Creates an array of bytes on the heap. The array is designated as an array - of booleans (important for casts) - Return value: pointer to the array or NULL if no memory is available *****************************************************************************/ -java_booleanarray *builtin_newarray_boolean(s4 size) +java_intarray *builtin_newarray_int(s4 size) { - java_booleanarray *a; - a = (java_booleanarray*)__builtin_newarray(sizeof(java_booleanarray), - size, - false, - sizeof(u1), - ARRAYTYPE_BOOLEAN, - NULL); - return a; + return (java_intarray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_INT].arrayvftbl); } -/******************** function: builtin_newarray_char ************************ - Creates an array of characters on the heap. +/******************** Function: builtin_newarray_long *********************** + + Creates an array of 64 bit Integers on the heap. Return value: pointer to the array or NULL if no memory is available *****************************************************************************/ -java_chararray *builtin_newarray_char(s4 size) +java_longarray *builtin_newarray_long(s4 size) { - java_chararray *a; - a = (java_chararray*)__builtin_newarray(sizeof(java_chararray), - size, - false, - sizeof(u2), - ARRAYTYPE_CHAR, - NULL); - return a; + return (java_longarray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_LONG].arrayvftbl); } @@ -646,14 +640,7 @@ java_chararray *builtin_newarray_char(s4 size) java_floatarray *builtin_newarray_float(s4 size) { - java_floatarray *a; - a = (java_floatarray*)__builtin_newarray(sizeof(java_floatarray), - size, - false, - sizeof(float), - ARRAYTYPE_FLOAT, - NULL); - return a; + return (java_floatarray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_FLOAT].arrayvftbl); } @@ -667,19 +654,10 @@ java_floatarray *builtin_newarray_float(s4 size) java_doublearray *builtin_newarray_double(s4 size) { - java_doublearray *a; - a = (java_doublearray*)__builtin_newarray(sizeof(java_doublearray), - size, - false, - sizeof(double), - ARRAYTYPE_DOUBLE, - NULL); - return a; + return (java_doublearray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_DOUBLE].arrayvftbl); } - - /******************** function: builtin_newarray_byte *********************** Creates an array of 8 bit Integers on the heap. @@ -690,90 +668,62 @@ java_doublearray *builtin_newarray_double(s4 size) java_bytearray *builtin_newarray_byte(s4 size) { - java_bytearray *a; - a = (java_bytearray*)__builtin_newarray(sizeof(java_bytearray), - size, - false, - sizeof(u1), - ARRAYTYPE_BYTE, - NULL); - return a; + return (java_bytearray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_BYTE].arrayvftbl); } -/******************** function: builtin_newarray_short *********************** +/******************** function: builtin_newarray_char ************************ - Creates an array of 16 bit Integers on the heap. + Creates an array of characters on the heap. Return value: pointer to the array or NULL if no memory is available *****************************************************************************/ -java_shortarray *builtin_newarray_short(s4 size) +java_chararray *builtin_newarray_char(s4 size) { - java_shortarray *a; - a = (java_shortarray*)__builtin_newarray(sizeof(java_shortarray), - size, - false, - sizeof(s2), - ARRAYTYPE_SHORT, - NULL); - return a; + return (java_chararray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_CHAR].arrayvftbl); } -/******************** Function: builtin_newarray_int *********************** +/******************** function: builtin_newarray_short *********************** - Creates an array of 32 bit Integers on the heap. + Creates an array of 16 bit Integers on the heap. Return value: pointer to the array or NULL if no memory is available *****************************************************************************/ -java_intarray *builtin_newarray_int(s4 size) +java_shortarray *builtin_newarray_short(s4 size) { - java_intarray *a; - a = (java_intarray*)__builtin_newarray(sizeof(java_intarray), - size, - false, - sizeof(s4), - ARRAYTYPE_INT, - NULL); - if (a == NULL) { - asm_handle_builtin_exception(proto_java_lang_OutOfMemoryError); - } - - return a; + return (java_shortarray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_SHORT].arrayvftbl); } -/******************** Function: builtin_newarray_long *********************** - - Creates an array of 64 bit Integers on the heap. +/******************** function: builtin_newarray_boolean ************************ + Creates an array of bytes on the heap. The array is designated as an array + of booleans (important for casts) + Return value: pointer to the array or NULL if no memory is available *****************************************************************************/ -java_longarray *builtin_newarray_long(s4 size) +java_booleanarray *builtin_newarray_boolean(s4 size) { - java_longarray *a; - a = (java_longarray*)__builtin_newarray(sizeof(java_longarray), - size, - false, - sizeof(s8), - ARRAYTYPE_LONG, - NULL); - return a; + return (java_booleanarray*) builtin_newarray(size, primitivetype_table[ARRAYTYPE_BOOLEAN].arrayvftbl); } - -/***************** function: builtin_multianewarray *************************** +/**************** function: builtin_nmultianewarray *************************** Creates a multi-dimensional array on the heap. The dimensions are passed in - an array of Integers. The type for the array is passed as a reference to a - constant_arraydescriptor structure. + 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 Return value: pointer to the array or NULL if no memory is available @@ -781,165 +731,39 @@ java_longarray *builtin_newarray_long(s4 size) /* Helper functions */ -static java_arrayheader *multianewarray_part(java_intarray *dims, int thisdim, - constant_arraydescriptor *desc) +java_arrayheader *builtin_nmultianewarray (int n, vftbl *arrayvftbl, long *dims) { - u4 size,i; - java_arrayarray *a; - - size = dims->data[thisdim]; - - if (thisdim == (dims->header.size - 1)) { - /* last dimension reached */ - - switch (desc -> arraytype) { - case ARRAYTYPE_BOOLEAN: - return (java_arrayheader*) builtin_newarray_boolean(size); - case ARRAYTYPE_CHAR: - return (java_arrayheader*) builtin_newarray_char(size); - case ARRAYTYPE_FLOAT: - return (java_arrayheader*) builtin_newarray_float(size); - case ARRAYTYPE_DOUBLE: - return (java_arrayheader*) builtin_newarray_double(size); - case ARRAYTYPE_BYTE: - return (java_arrayheader*) builtin_newarray_byte(size); - case ARRAYTYPE_SHORT: - return (java_arrayheader*) builtin_newarray_short(size); - case ARRAYTYPE_INT: - return (java_arrayheader*) builtin_newarray_int(size); - case ARRAYTYPE_LONG: - return (java_arrayheader*) builtin_newarray_long(size); - case ARRAYTYPE_OBJECT: - return (java_arrayheader*) builtin_anewarray(size, desc->objectclass); - - case ARRAYTYPE_ARRAY: - return (java_arrayheader*) builtin_newarray_array(size, desc->elementdescriptor); - - default: panic("Invalid arraytype in multianewarray"); - } - } - - /* if the last dimension has not been reached yet */ - - if (desc->arraytype != ARRAYTYPE_ARRAY) - panic("multianewarray with too many dimensions"); + int size, i; + java_arrayheader *a; + vftbl *componentvftbl; - a = builtin_newarray_array(size, desc->elementdescriptor); + /* create this dimension */ + size = (int) dims[0]; + a = builtin_newarray(size,arrayvftbl); if (!a) return NULL; - - for (i = 0; i < size; i++) { - java_arrayheader *ea = - multianewarray_part(dims, thisdim + 1, desc->elementdescriptor); - if (!ea) return NULL; - - a->data[i] = ea; - } - - return (java_arrayheader*) a; -} - - -java_arrayheader *builtin_multianewarray(java_intarray *dims, - constant_arraydescriptor *desc) -{ - return multianewarray_part(dims, 0, desc); -} - - -static java_arrayheader *nmultianewarray_part(int n, long *dims, int thisdim, - constant_arraydescriptor *desc) -{ - int size, i; - java_arrayarray *a; - size = (int) dims[thisdim]; - - if (thisdim == (n - 1)) { - /* last dimension reached */ - - switch (desc -> arraytype) { - case ARRAYTYPE_BOOLEAN: - return (java_arrayheader*) builtin_newarray_boolean(size); - case ARRAYTYPE_CHAR: - return (java_arrayheader*) builtin_newarray_char(size); - case ARRAYTYPE_FLOAT: - return (java_arrayheader*) builtin_newarray_float(size); - case ARRAYTYPE_DOUBLE: - return (java_arrayheader*) builtin_newarray_double(size); - case ARRAYTYPE_BYTE: - return (java_arrayheader*) builtin_newarray_byte(size); - case ARRAYTYPE_SHORT: - return (java_arrayheader*) builtin_newarray_short(size); - case ARRAYTYPE_INT: - return (java_arrayheader*) builtin_newarray_int(size); - case ARRAYTYPE_LONG: - return (java_arrayheader*) builtin_newarray_long(size); - case ARRAYTYPE_OBJECT: - return (java_arrayheader*) builtin_anewarray(size, - desc->objectclass); - case ARRAYTYPE_ARRAY: - return (java_arrayheader*) builtin_newarray_array(size, - desc->elementdescriptor); - - default: panic ("Invalid arraytype in multianewarray"); - } - } + /* if this is the last dimension return */ + if (!--n) return a; - /* if the last dimension has not been reached yet */ + /* get the vftbl of the components to create */ + componentvftbl = arrayvftbl->arraydesc->componentvftbl; - if (desc->arraytype != ARRAYTYPE_ARRAY) - panic ("multianewarray with too many dimensions"); + /* The verifier guarantees this. */ + /* if (!componentvftbl) */ + /* panic ("multianewarray with too many dimensions"); */ - a = builtin_newarray_array(size, desc->elementdescriptor); - if (!a) return NULL; - + /* create the component arrays */ for (i = 0; i < size; i++) { java_arrayheader *ea = - nmultianewarray_part(n, dims, thisdim + 1, desc->elementdescriptor); + builtin_nmultianewarray(n,componentvftbl,dims+1); if (!ea) return NULL; - - a -> data[i] = ea; + ((java_objectarray*)a)->data[i] = (java_objectheader *) ea; } - - return (java_arrayheader*) a; -} - - -java_arrayheader *builtin_nmultianewarray (int size, - constant_arraydescriptor *desc, long *dims) -{ - (void) builtin_newarray_int(size); /* for compatibility with -old */ - return nmultianewarray_part (size, dims, 0, desc); -} - - - - -/************************* function: builtin_aastore ************************* - - Stores a reference to an object into an object array or into an array - array. Before any action is performed, the validity of the operation is - checked. - - Return value: 1 ... ok - 0 ... this object cannot be stored into this array - -*****************************************************************************/ -s4 builtin_aastore (java_objectarray *a, s4 index, java_objectheader *o) -{ - if (builtin_canstore(a,o)) { - a->data[index] = o; - return 1; - } - return 0; + return a; } - - - - /***************************************************************************** METHOD LOGGING @@ -948,35 +772,56 @@ s4 builtin_aastore (java_objectarray *a, s4 index, java_objectheader *o) *****************************************************************************/ - u4 methodindent = 0; -java_objectheader *builtin_trace_exception(java_objectheader *exceptionptr, - methodinfo *method, int *pos, +java_objectheader *builtin_trace_exception(java_objectheader *_exceptionptr, + methodinfo *method, + int *pos, int noindent) { - - if (!noindent) - methodindent--; + if (!noindent) { + if (methodindent) + methodindent--; + else + log_text("WARNING: unmatched methodindent--"); + } if (verbose || runverbose) { printf("Exception "); - utf_display (exceptionptr->vftbl->class->name); + if (_exceptionptr) { + utf_display_classname(_exceptionptr->vftbl->class->name); + + } else { + printf("Error: "); + if (!proto_java_lang_ClassCastException) printf("%s","proto_java_lang_ClassCastException==0"); + if (!proto_java_lang_NullPointerException) printf("%s","proto_java_lang_NullPointerException==0"); + if (!proto_java_lang_NullPointerException) printf("%s","proto_java_lang_NullPointerException==0"); + if (!proto_java_lang_ArrayIndexOutOfBoundsException) printf("%s","proto_java_lang_ArrayIndexOutOfBoundsException==0"); + if (!proto_java_lang_NegativeArraySizeException) printf("%s","proto_java_lang_NegativeArraySizeException==0"); + if (!proto_java_lang_OutOfMemoryError) printf("%s","proto_java_lang_OutOfMemoryError==0"); + if (!proto_java_lang_ArithmeticException) printf("%s","proto_java_lang_ArithmeticException==0"); + if (!proto_java_lang_ArrayStoreException) printf("%s","proto_java_lang_ArrayStoreException==0"); + if (!proto_java_lang_ThreadDeath) printf("%s","proto_java_lang_ThreadDeath==0"); + if (!proto_java_lang_ThreadDeath) printf("%s","proto_java_lang_ThreadDeath==0"); + + } printf(" thrown in "); + if (method) { - utf_display (method->class->name); + utf_display_classname(method->class->name); printf("."); - utf_display (method->name); + utf_display(method->name); if (method->flags & ACC_SYNCHRONIZED) printf("(SYNC)"); else printf("(NOSYNC)"); printf("(%p) at position %p\n", method->entrypoint, pos); - } - else + + } else printf("call_java_method\n"); fflush (stdout); } - return exceptionptr; + + return _exceptionptr; } @@ -988,20 +833,36 @@ void builtin_trace_args(s8 a0, s8 a1, s8 a2, s8 a3, s8 a4, s8 a5, methodinfo *method) { int i; + char logtext[MAXLOGTEXT]; for (i = 0; i < methodindent; i++) logtext[i] = '\t'; + sprintf(logtext + methodindent, "called: "); utf_sprint(logtext + strlen(logtext), method->class->name); sprintf(logtext + strlen(logtext), "."); utf_sprint(logtext + strlen(logtext), method->name); utf_sprint(logtext + strlen(logtext), method->descriptor); + + if ( method->flags & ACC_PUBLIC ) sprintf (logtext + strlen(logtext)," PUBLIC"); + if ( method->flags & ACC_PRIVATE ) sprintf (logtext + strlen(logtext)," PRIVATE"); + if ( method->flags & ACC_PROTECTED ) sprintf (logtext + strlen(logtext)," PROTECTED"); + if ( method->flags & ACC_STATIC ) sprintf (logtext + strlen(logtext)," STATIC"); + if ( method->flags & ACC_FINAL ) sprintf (logtext + strlen(logtext)," FINAL"); + if ( method->flags & ACC_SYNCHRONIZED ) sprintf (logtext + strlen(logtext)," SYNCHRONIZED"); + if ( method->flags & ACC_VOLATILE ) sprintf (logtext + strlen(logtext)," VOLATILE"); + if ( method->flags & ACC_TRANSIENT ) sprintf (logtext + strlen(logtext)," TRANSIENT"); + if ( method->flags & ACC_NATIVE ) sprintf (logtext + strlen(logtext)," NATIVE"); + if ( method->flags & ACC_INTERFACE ) sprintf (logtext + strlen(logtext)," INTERFACE"); + if ( method->flags & ACC_ABSTRACT ) sprintf (logtext + strlen(logtext)," ABSTRACT"); + + sprintf(logtext + strlen(logtext), "("); switch (method->paramcount) { case 0: break; -#if defined(__I386__) +#if defined(__I386__) || defined(__POWERPC__) case 1: sprintf(logtext+strlen(logtext), "%llx", a0); break; @@ -1101,9 +962,10 @@ void builtin_trace_args(s8 a0, s8 a1, s8 a2, s8 a3, s8 a4, s8 a5, #endif #endif } + sprintf(logtext + strlen(logtext), ")"); + log_text(logtext); - dolog(); methodindent++; } #endif @@ -1111,13 +973,27 @@ void builtin_trace_args(s8 a0, s8 a1, s8 a2, s8 a3, s8 a4, s8 a5, void builtin_displaymethodstart(methodinfo *method) { + char logtext[MAXLOGTEXT]; sprintf(logtext, " "); sprintf(logtext + methodindent, "called: "); utf_sprint(logtext + strlen(logtext), method->class->name); sprintf(logtext + strlen(logtext), "."); utf_sprint(logtext + strlen(logtext), method->name); utf_sprint(logtext + strlen(logtext), method->descriptor); - dolog(); + + if ( method->flags & ACC_PUBLIC ) sprintf (logtext + strlen(logtext)," PUBLIC"); + if ( method->flags & ACC_PRIVATE ) sprintf (logtext + strlen(logtext)," PRIVATE"); + if ( method->flags & ACC_PROTECTED ) sprintf (logtext + strlen(logtext)," PROTECTED"); + if ( method->flags & ACC_STATIC ) sprintf (logtext + strlen(logtext)," STATIC"); + if ( method->flags & ACC_FINAL ) sprintf (logtext + strlen(logtext)," FINAL"); + if ( method->flags & ACC_SYNCHRONIZED ) sprintf (logtext + strlen(logtext)," SYNCHRONIZED"); + if ( method->flags & ACC_VOLATILE ) sprintf (logtext + strlen(logtext)," VOLATILE"); + if ( method->flags & ACC_TRANSIENT ) sprintf (logtext + strlen(logtext)," TRANSIENT"); + if ( method->flags & ACC_NATIVE ) sprintf (logtext + strlen(logtext)," NATIVE"); + if ( method->flags & ACC_INTERFACE ) sprintf (logtext + strlen(logtext)," INTERFACE"); + if ( method->flags & ACC_ABSTRACT ) sprintf (logtext + strlen(logtext)," ABSTRACT"); + + log_text(logtext); methodindent++; } @@ -1125,9 +1001,14 @@ void builtin_displaymethodstart(methodinfo *method) void builtin_displaymethodstop(methodinfo *method, s8 l, double d, float f) { int i; + char logtext[MAXLOGTEXT]; for (i = 0; i < methodindent; i++) logtext[i] = '\t'; - methodindent--; + if (methodindent) + methodindent--; + else + log_text("WARNING: unmatched methodindent--"); + sprintf(logtext + methodindent, "finished: "); utf_sprint(logtext + strlen(logtext), method->class->name); sprintf(logtext + strlen(logtext), "."); @@ -1138,34 +1019,39 @@ void builtin_displaymethodstop(methodinfo *method, s8 l, double d, float f) case TYPE_INT: sprintf(logtext + strlen(logtext), "->%d", (s4) l); break; + case TYPE_LONG: -#if defined(__I386__) +#if defined(__I386__) || defined(__POWERPC__) sprintf(logtext + strlen(logtext), "->%lld", (s8) l); #else sprintf(logtext + strlen(logtext), "->%ld", (s8) l); #endif break; + case TYPE_ADDRESS: -#if defined(__I386__) +#if defined(__I386__) || defined(__POWERPC__) sprintf(logtext + strlen(logtext), "->%p", (u1*) ((s4) l)); #else sprintf(logtext + strlen(logtext), "->%p", (u1*) l); #endif break; + case TYPE_FLOAT: sprintf(logtext + strlen(logtext), "->%g", f); break; + case TYPE_DOUBLE: sprintf(logtext + strlen(logtext), "->%g", d); break; } - dolog(); + log_text(logtext); } void builtin_displaymethodexception(methodinfo *method) { int i; + char logtext[MAXLOGTEXT]; for (i = 0; i < methodindent; i++) logtext[i] = '\t'; sprintf(logtext + methodindent, "exception abort: "); @@ -1173,7 +1059,7 @@ void builtin_displaymethodexception(methodinfo *method) sprintf(logtext + strlen(logtext), "."); utf_sprint(logtext + strlen(logtext), method->name); utf_sprint(logtext + strlen(logtext), method->descriptor); - dolog(); + log_text(logtext); } @@ -1184,10 +1070,9 @@ void builtin_displaymethodexception(methodinfo *method) /* * Lock the mutex of an object. */ -#ifdef USE_THREADS -void -internal_lock_mutex_for_object (java_objectheader *object) +void internal_lock_mutex_for_object(java_objectheader *object) { +#if defined(USE_THREADS) && !defined(NATIVE_THREADS) mutexHashEntry *entry; int hashValue; @@ -1228,17 +1113,16 @@ internal_lock_mutex_for_object (java_objectheader *object) entry->object = object; internal_lock_mutex(&entry->mutex); -} #endif +} /* * Unlocks the mutex of an object. */ -#ifdef USE_THREADS -void -internal_unlock_mutex_for_object (java_objectheader *object) +void internal_unlock_mutex_for_object (java_objectheader *object) { +#if defined(USE_THREADS) && !defined(NATIVE_THREADS) int hashValue; mutexHashEntry *entry; @@ -1264,13 +1148,13 @@ internal_unlock_mutex_for_object (java_objectheader *object) firstFreeOverflowEntry = unlinked; } } -} #endif +} void builtin_monitorenter(java_objectheader *o) { -#ifdef USE_THREADS +#if defined(USE_THREADS) && !defined(NATIVE_THREADS) int hashValue; assert(blockInts == 0); @@ -1278,7 +1162,7 @@ void builtin_monitorenter(java_objectheader *o) ++blockInts; hashValue = MUTEX_HASH_VALUE(o); - if (mutexHashTable[hashValue].object == o + if (mutexHashTable[hashValue].object == o && mutexHashTable[hashValue].mutex.holder == currentThread) ++mutexHashTable[hashValue].mutex.count; else @@ -1293,7 +1177,7 @@ void builtin_monitorenter(java_objectheader *o) void builtin_monitorexit (java_objectheader *o) { -#ifdef USE_THREADS +#if defined(USE_THREADS) && !defined(NATIVE_THREADS) int hashValue; assert(blockInts == 0); @@ -1470,8 +1354,8 @@ s4 builtin_lcmp(s8 a, s8 b) float builtin_fadd(float a, float b) { - if (isnanf(a)) return FLT_NAN; - if (isnanf(b)) return FLT_NAN; + if (isnanf(a)) return intBitsToFloat(FLT_NAN); + if (isnanf(b)) return intBitsToFloat(FLT_NAN); if (finitef(a)) { if (finitef(b)) return a + b; @@ -1485,7 +1369,7 @@ float builtin_fadd(float a, float b) if (copysignf(1.0, a) == copysignf(1.0, b)) return a; else - return FLT_NAN; + return intBitsToFloat(FLT_NAN); } } } @@ -1499,18 +1383,18 @@ float builtin_fsub(float a, float b) float builtin_fmul(float a, float b) { - if (isnanf(a)) return FLT_NAN; - if (isnanf(b)) return FLT_NAN; + if (isnanf(a)) return intBitsToFloat(FLT_NAN); + if (isnanf(b)) return intBitsToFloat(FLT_NAN); if (finitef(a)) { - if (finitef(b)) return a*b; + if (finitef(b)) return a * b; else { - if (a == 0) return FLT_NAN; + if (a == 0) return intBitsToFloat(FLT_NAN); else return copysignf(b, copysignf(1.0, b)*a); } } else { if (finitef(b)) { - if (b == 0) return FLT_NAN; + if (b == 0) return intBitsToFloat(FLT_NAN); else return copysignf(a, copysignf(1.0, a)*b); } else { @@ -1527,12 +1411,12 @@ float builtin_fdiv(float a, float b) return a / b; else { if (a > 0) - return FLT_POSINF; + return intBitsToFloat(FLT_POSINF); else if (a < 0) - return FLT_NEGINF; + return intBitsToFloat(FLT_NEGINF); } } - return FLT_NAN; + return intBitsToFloat(FLT_NAN); } @@ -1585,17 +1469,17 @@ s4 builtin_fcmpg(float a, float b) double builtin_dadd(double a, double b) { - if (isnan(a)) return DBL_NAN; - if (isnan(b)) return DBL_NAN; + if (isnan(a)) return longBitsToDouble(DBL_NAN); + if (isnan(b)) return longBitsToDouble(DBL_NAN); if (finite(a)) { - if (finite(b)) return a+b; + if (finite(b)) return a + b; else return b; } else { if (finite(b)) return a; else { if (copysign(1.0, a)==copysign(1.0, b)) return a; - else return DBL_NAN; + else return longBitsToDouble(DBL_NAN); } } } @@ -1609,18 +1493,18 @@ double builtin_dsub(double a, double b) double builtin_dmul(double a, double b) { - if (isnan(a)) return DBL_NAN; - if (isnan(b)) return DBL_NAN; + if (isnan(a)) return longBitsToDouble(DBL_NAN); + if (isnan(b)) return longBitsToDouble(DBL_NAN); if (finite(a)) { if (finite(b)) return a * b; else { - if (a == 0) return DBL_NAN; + if (a == 0) return longBitsToDouble(DBL_NAN); else return copysign(b, copysign(1.0, b) * a); } } else { if (finite(b)) { - if (b == 0) return DBL_NAN; + if (b == 0) return longBitsToDouble(DBL_NAN); else return copysign(a, copysign(1.0, a) * b); } else { @@ -1632,17 +1516,41 @@ double builtin_dmul(double a, double b) double builtin_ddiv(double a, double b) { - if (finite(a) && finite(b)) { - if (b != 0) + if (finite(a)) { + if (finite(b)) { return a / b; - else { + + } else { + if (isnan(b)) + return longBitsToDouble(DBL_NAN); + else + return copysign(0.0, b); + } + + } else { + if (finite(b)) { if (a > 0) - return DBL_POSINF; + return longBitsToDouble(DBL_POSINF); else if (a < 0) - return DBL_NEGINF; - } + return longBitsToDouble(DBL_NEGINF); + + } else + return longBitsToDouble(DBL_NAN); } - return DBL_NAN; + +/* if (finite(a) && finite(b)) { */ +/* if (b != 0) */ +/* return a / b; */ +/* else { */ +/* if (a > 0) */ +/* return longBitsToDouble(DBL_POSINF); */ +/* else if (a < 0) */ +/* return longBitsToDouble(DBL_NEGINF); */ +/* } */ +/* } */ + + /* keep compiler happy */ + return 0; } @@ -1697,7 +1605,10 @@ s8 builtin_i2l(s4 i) #if U8_AVAILABLE return i; #else - s8 v; v.high = 0; v.low=i; return v; + s8 v; + v.high = 0; + v.low = i; + return v; #endif } @@ -1799,9 +1710,9 @@ double builtin_f2d(float a) if (finitef(a)) return (double) a; else { if (isnanf(a)) - return DBL_NAN; + return longBitsToDouble(DBL_NAN); else - return copysign(DBL_POSINF, (double) copysignf(1.0, a) ); + return copysign(longBitsToDouble(DBL_POSINF), (double) copysignf(1.0, a) ); } } @@ -1852,13 +1763,68 @@ float builtin_d2f(double a) return (float) a; else { if (isnan(a)) - return FLT_NAN; + return intBitsToFloat(FLT_NAN); else - return copysignf(FLT_POSINF, (float) copysign(1.0, a)); + return copysignf(intBitsToFloat(FLT_POSINF), (float) copysign(1.0, a)); } } +/* used to convert FLT_xxx defines into float values */ + +inline float intBitsToFloat(s4 i) +{ + imm_union imb; + + imb.i = i; + return imb.f; +} + + +/* used to convert DBL_xxx defines into double values */ + +inline float longBitsToDouble(s8 l) +{ + imm_union imb; + + imb.l = l; + return imb.d; +} + + +java_arrayheader *builtin_clone_array(void *env, java_arrayheader *o) +{ + return (java_arrayheader *) Java_java_lang_VMObject_clone(0, 0, (java_lang_Cloneable *) o); +} + +s4 builtin_dummy() +{ + panic("Internal error: builtin_dummy called (native function is missing)"); + return 0; /* for the compiler */ +} + + +inline methodinfo *builtin_asm_get_threadrootmethod() { + return *threadrootmethod; +} + + +inline void* +builtin_asm_get_stackframeinfo(){ +/*log_text("builtin_asm_get_stackframeinfo()");*/ +#if defined(USE_THREADS) && defined(NATIVE_THREADS) +#ifdef HAVE___THREAD + return &_thread_nativestackframeinfo; /*support for __thread attribute*/ +#else + return &((nativethread*) pthread_getspecific(tkey_stackframeinfo))->_stackframeinfo /*copied from exception handling, is that really */ + /*old pthread*/ +#endif +#else +#warning FIXME FOR OLD THREAD IMPL (jowenn) + return &_thread_nativestackframeinfo; /* no threading, at least no native*/ +#endif +} + /* * These are local overrides for various environment variables in Emacs. * Please do not remove this and leave it at the end of the file, where