more statistics, less crashing

diff --git a/src/native/jni.c b/src/native/jni.c
index 8062cd0708c7d4a43d488fe929562fb5a49ee924..4ad5e43d29574911aa5e1f51fd0db76995f485e8 100644 (file)
--- a/src/native/jni.c
+++ b/src/native/jni.c
@@ -31,7 +31,7 @@
             Martin Platter
             Christian Thalinger
 
-   $Id: jni.c 2408 2005-04-28 12:38:50Z jowenn $
+   $Id: jni.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -79,7 +79,7 @@
 #include "vm/tables.h"
 #include "vm/jit/asmpart.h"
 #include "vm/jit/jit.h"
-
+#include "vm/statistics.h"
 
 /* XXX TWISTI hack: define it extern so they can be found in this file */
 extern const struct JNIInvokeInterface JNI_JavaVMTable;
@@ -105,6 +105,8 @@ static jmethodID newint = NULL;
 static jclass ihmclass = NULL;
 static jmethodID removemid = NULL;
 
+#define JWCLINITDEBUG(x)
+
 
 /********************* accessing instance-fields **********************************/
 
@@ -367,6 +369,7 @@ static jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
 
        fill_callblock(obj, methodID->parseddesc, blk, args, TYPE_ADR);
        /*      printf("parameter: obj: %p",blk[0].item); */
+       STATS(jnicallXmethodnvokation();)
        ret = asm_calljavafunction2(methodID,
                                                                argcount + 1,
                                                                (argcount + 1) * sizeof(jni_callblock),
@@ -388,6 +391,8 @@ static jint callIntegerMethod(jobject obj, jmethodID methodID, int retType, va_l
        jni_callblock *blk;
        jint ret;
 
+       STATS(jniinvokation();)
+
         /*
         log_text("JNI-Call: CallObjectMethodV");
         utf_display(methodID->name);
@@ -427,6 +432,7 @@ static jint callIntegerMethod(jobject obj, jmethodID methodID, int retType, va_l
        fill_callblock(obj, methodID->parseddesc, blk, args, retType);
 
        /*      printf("parameter: obj: %p",blk[0].item); */
+       STATS(jnicallXmethodnvokation();)
        ret = asm_calljavafunction2int(methodID,
                                                                   argcount + 1,
                                                                   (argcount + 1) * sizeof(jni_callblock),
@@ -446,6 +452,8 @@ static jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
        jni_callblock *blk;
        jlong ret;
 
+       STATS(jniinvokation();)
+
 /*     
         log_text("JNI-Call: CallObjectMethodV");
         utf_display(methodID->name);
@@ -485,6 +493,7 @@ static jlong callLongMethod(jobject obj, jmethodID methodID, va_list args)
        fill_callblock(obj, methodID->parseddesc, blk, args, TYPE_LNG);
 
        /*      printf("parameter: obj: %p",blk[0].item); */
+       STATS(jnicallXmethodnvokation();)
        ret = asm_calljavafunction2long(methodID,
                                                                        argcount + 1,
                                                                        (argcount + 1) * sizeof(jni_callblock),
@@ -504,6 +513,8 @@ static jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,int
        jni_callblock *blk;
        jdouble ret;
 
+       STATS(jniinvokation();)
+
         /*
         log_text("JNI-Call: CallObjectMethodV");
         utf_display(methodID->name);
@@ -526,6 +537,7 @@ static jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,int
        fill_callblock(obj, methodID->parseddesc, blk, args, retType);
 
        /*      printf("parameter: obj: %p",blk[0].item); */
+       STATS(jnicallXmethodnvokation();)
        ret = asm_calljavafunction2double(methodID,
                                                                          argcount + 1,
                                                                          (argcount + 1) * sizeof(jni_callblock),
@@ -548,6 +560,8 @@ static jdouble callFloatMethod(jobject obj, jmethodID methodID, va_list args,int
 static fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
 {
        s4 i;
+       STATS(jniinvokation();)
+
 /*     printf(" FieldCount: %d\n",c->fieldscount);
        utf_display(c->name); */
                for (i = 0; i < c->fieldscount; i++) {
@@ -575,7 +589,7 @@ static fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
 jint GetVersion(JNIEnv *env)
 {
        /* GNU classpath currently supports JNI 1.2 */
-
+       STATS(jniinvokation();)
        return JNI_VERSION_1_2;
 }
 
@@ -593,6 +607,7 @@ jint GetVersion(JNIEnv *env)
 jclass DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize bufLen)
 {
        jclass c;
+       STATS(jniinvokation();)
 
        c = (jclass) Java_java_lang_VMClassLoader_defineClass(env,
                                                                                                                  NULL,
@@ -618,6 +633,7 @@ jclass DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *b
 jclass FindClass(JNIEnv *env, const char *name)
 {
        classinfo *c = NULL;  
+       STATS(jniinvokation();)
   
        if (!load_class_bootstrap(utf_new_char_classname((char *) name),&c) || !link_class(c)) {
                return NULL;
@@ -639,6 +655,7 @@ jclass FindClass(JNIEnv *env, const char *name)
 jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
 {
        log_text("JNI-Call: FromReflectedMethod: IMPLEMENT ME!!!");
+       STATS(jniinvokation();)
 
        return 0;
 }
@@ -655,6 +672,7 @@ jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
 jclass GetSuperclass(JNIEnv *env, jclass sub)
 {
        classinfo *c;
+       STATS(jniinvokation();)
 
        c = ((classinfo *) sub)->super.cls;
 
@@ -675,6 +693,7 @@ jclass GetSuperclass(JNIEnv *env, jclass sub)
 
 jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
 {
+       STATS(jniinvokation();)
        return Java_java_lang_VMClass_isAssignableFrom(env,
                                                                                                   NULL,
                                                                                                   (java_lang_Class *) sup,
@@ -687,7 +706,7 @@ jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
 jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
 {
        log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!!!");
-
+       STATS(jniinvokation();)
        return NULL;
 }
 
@@ -701,6 +720,7 @@ jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isS
 jint Throw(JNIEnv *env, jthrowable obj)
 {
        *exceptionptr = (java_objectheader *) obj;
+       STATS(jniinvokation();)
 
        return JNI_OK;
 }
@@ -718,6 +738,7 @@ jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
 {
        java_lang_Throwable *o;
        java_lang_String    *s;
+       STATS(jniinvokation();)
 
        s = (java_lang_String *) javastring_new_char(msg);
 
@@ -745,6 +766,7 @@ jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
 
 jthrowable ExceptionOccurred(JNIEnv *env)
 {
+       STATS(jniinvokation();)
        return (jthrowable) *exceptionptr;
 }
 
@@ -761,6 +783,7 @@ void ExceptionDescribe(JNIEnv *env)
 {
        java_objectheader *e;
        methodinfo        *m;
+       STATS(jniinvokation();)
 
        e = *exceptionptr;
 
@@ -797,6 +820,7 @@ void ExceptionDescribe(JNIEnv *env)
 
 void ExceptionClear(JNIEnv *env)
 {
+       STATS(jniinvokation();)
        *exceptionptr = NULL;
 }
 
@@ -810,6 +834,7 @@ void ExceptionClear(JNIEnv *env)
 
 void FatalError(JNIEnv *env, const char *msg)
 {
+       STATS(jniinvokation();)
        throw_cacao_exception_exit(string_java_lang_InternalError, msg);
 }
 
@@ -819,6 +844,7 @@ void FatalError(JNIEnv *env, const char *msg)
 jint PushLocalFrame(JNIEnv* env, jint capacity)
 {
        log_text("JNI-Call: PushLocalFrame: IMPLEMENT ME!");
+       STATS(jniinvokation();)
 
        return 0;
 }
@@ -828,6 +854,7 @@ jint PushLocalFrame(JNIEnv* env, jint capacity)
 jobject PopLocalFrame(JNIEnv* env, jobject result)
 {
        log_text("JNI-Call: PopLocalFrame: IMPLEMENT ME!");
+       STATS(jniinvokation();)
 
        return NULL;
 }
@@ -842,6 +869,8 @@ jobject PopLocalFrame(JNIEnv* env, jobject result)
 void DeleteLocalRef(JNIEnv *env, jobject localRef)
 {
        log_text("JNI-Call: DeleteLocalRef: IMPLEMENT ME!");
+       STATS(jniinvokation();)
+
 }
 
 
@@ -853,6 +882,7 @@ void DeleteLocalRef(JNIEnv *env, jobject localRef)
 
 jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
 {
+       STATS(jniinvokation();)
        return (ref1 == ref2);
 }
 
@@ -866,7 +896,7 @@ jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
 jobject NewLocalRef(JNIEnv *env, jobject ref)
 {
        log_text("JNI-Call: NewLocalRef: IMPLEMENT ME!");
-
+       STATS(jniinvokation();)
        return ref;
 }
 
@@ -879,6 +909,7 @@ jobject NewLocalRef(JNIEnv *env, jobject ref)
 
 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
 {
+       STATS(jniinvokation();)
        return 0; /* return 0 on success */
 }
 
@@ -893,6 +924,7 @@ jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
 jobject AllocObject(JNIEnv *env, jclass clazz)
 {
        java_objectheader *o;
+       STATS(jniinvokation();)
 
        if ((clazz->flags & ACC_INTERFACE) || (clazz->flags & ACC_ABSTRACT)) {
                *exceptionptr =
@@ -923,6 +955,7 @@ jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
        int argcount=methodID->parseddesc->paramcount;
        int i;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 #ifdef arglimit
        if (argcount > 3) {
@@ -963,6 +996,7 @@ jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
 {
        log_text("JNI-Call: NewObjectV");
+       STATS(jniinvokation();)
 
        return NULL;
 }
@@ -979,6 +1013,7 @@ jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
 jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
 {
        log_text("JNI-Call: NewObjectA");
+       STATS(jniinvokation();)
 
        return NULL;
 }
@@ -993,6 +1028,7 @@ jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
 jclass GetObjectClass(JNIEnv *env, jobject obj)
 {
        classinfo *c;
+       STATS(jniinvokation();)
        
        if (!obj || !obj->vftbl)
                return NULL;
@@ -1011,6 +1047,8 @@ jclass GetObjectClass(JNIEnv *env, jobject obj)
 
 jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
 {
+       STATS(jniinvokation();)
+
        return Java_java_lang_VMClass_isInstance(env,
                                                                                         NULL,
                                                                                         (java_lang_Class *) clazz,
@@ -1023,6 +1061,7 @@ jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
 jfieldID FromReflectedField(JNIEnv* env, jobject field)
 {
        log_text("JNI-Call: FromReflectedField");
+       STATS(jniinvokation();)
 
        return 0;
 }
@@ -1038,6 +1077,7 @@ jfieldID FromReflectedField(JNIEnv* env, jobject field)
 jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
 {
        log_text("JNI-Call: ToReflectedMethod");
+       STATS(jniinvokation();)
 
        return NULL;
 }
@@ -1052,6 +1092,7 @@ jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean
 jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *name, const char *sig)
 {
        jmethodID m;
+       STATS(jniinvokation();)
 
        m = class_resolvemethod(clazz, 
                                                        utf_new_char((char *) name), 
@@ -1074,6 +1115,7 @@ jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jobject ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallObjectMethod");*/
 
@@ -1087,6 +1129,7 @@ jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return callObjectMethod(obj,methodID,args);
 }
 
@@ -1094,6 +1137,7 @@ jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list
 jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 {
        log_text("JNI-Call: CallObjectMethodA");
+       STATS(jniinvokation();)
 
        return NULL;
 }
@@ -1105,6 +1149,7 @@ jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jboolean ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallBooleanMethod");*/
 
@@ -1117,12 +1162,15 @@ jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
+
        return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_BOOLEAN,args);
 
 }
 
 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallBooleanMethodA");
 
        return 0;
@@ -1132,6 +1180,7 @@ jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jbyte ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallVyteMethod");*/
 
@@ -1145,6 +1194,8 @@ jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
 /*     log_text("JNI-Call: CallByteMethodV");*/
+       STATS(jniinvokation();)
+
        return callIntegerMethod(obj,methodID,PRIMITIVETYPE_BYTE,args);
 }
 
@@ -1152,6 +1203,7 @@ jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list arg
 jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
        log_text("JNI-Call: CallByteMethodA");
+       STATS(jniinvokation();)
 
        return 0;
 }
@@ -1161,6 +1213,7 @@ jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jchar ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallCharMethod");*/
 
@@ -1174,6 +1227,8 @@ jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
+
 /*     log_text("JNI-Call: CallCharMethodV");*/
        return callIntegerMethod(obj,get_virtual(obj,methodID),PRIMITIVETYPE_CHAR,args);
 }
@@ -1181,6 +1236,8 @@ jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args
 
 jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
+
        log_text("JNI-Call: CallCharMethodA");
 
        return 0;
@@ -1191,6 +1248,7 @@ jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jshort ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallShortMethod");*/
 
@@ -1204,12 +1262,14 @@ jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_SHORT, args);
 }
 
 
 jshort CallShortMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallShortMethodA");
 
        return 0;
@@ -1221,6 +1281,7 @@ jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jint ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        va_start(vaargs,methodID);
        ret = callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, vaargs);
@@ -1232,12 +1293,14 @@ jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, args);
 }
 
 
 jint CallIntMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallIntMethodA");
 
        return 0;
@@ -1249,6 +1312,7 @@ jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jlong ret;
        va_list vaargs;
+       STATS(jniinvokation();)
        
        va_start(vaargs,methodID);
        ret = callLongMethod(obj,get_virtual(obj, methodID),vaargs);
@@ -1260,12 +1324,14 @@ jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return  callLongMethod(obj,get_virtual(obj, methodID),args);
 }
 
 
 jlong CallLongMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallLongMethodA");
 
        return 0;
@@ -1278,6 +1344,7 @@ jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
        jfloat ret;
        va_list vaargs;
 
+       STATS(jniinvokation();)
 /*     log_text("JNI-Call: CallFloatMethod");*/
 
        va_start(vaargs,methodID);
@@ -1290,6 +1357,7 @@ jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallFloatMethodV");
        return callFloatMethod(obj, get_virtual(obj, methodID), args, PRIMITIVETYPE_FLOAT);
 }
@@ -1297,6 +1365,7 @@ jfloat CallFloatMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list ar
 
 jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallFloatMethodA");
 
        return 0;
@@ -1308,6 +1377,7 @@ jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jdouble ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallDoubleMethod");*/
 
@@ -1321,6 +1391,7 @@ jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 
 jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallDoubleMethodV");
        return callFloatMethod(obj, get_virtual(obj, methodID), args, PRIMITIVETYPE_DOUBLE);
 }
@@ -1328,6 +1399,7 @@ jdouble CallDoubleMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list
 
 jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallDoubleMethodA");
        return 0;
 }
@@ -1337,6 +1409,7 @@ jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *
 void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        va_list vaargs;
+       STATS(jniinvokation();)
 
        va_start(vaargs,methodID);
        (void) callIntegerMethod(obj, get_virtual(obj, methodID),TYPE_VOID, vaargs);
@@ -1347,12 +1420,14 @@ void CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {
        log_text("JNI-Call: CallVoidMethodV");
+       STATS(jniinvokation();)
        (void)callIntegerMethod(obj,get_virtual(obj,methodID),TYPE_VOID,args);
 }
 
 
 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallVoidMethodA");
 }
 
@@ -1360,6 +1435,7 @@ void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * arg
 
 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualObjectMethod");
 
        return NULL;
@@ -1368,6 +1444,7 @@ jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmet
 
 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualObjectMethodV");
 
        return NULL;
@@ -1376,6 +1453,7 @@ jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jme
 
 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualObjectMethodA");
 
        return NULL;
@@ -1387,6 +1465,7 @@ jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jm
 {
        jboolean ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
 /*     log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
 
@@ -1400,6 +1479,7 @@ jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jm
 
 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
 /*     log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
        return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BOOLEAN,args);
 }
@@ -1407,6 +1487,7 @@ jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, j
 
 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualBooleanMethodA");
 
        return 0;
@@ -1419,6 +1500,7 @@ jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodI
        jbyte ret;
        va_list vaargs;
 
+       STATS(jniinvokation();)
 /*     log_text("JNI-Call: CallNonvirutalByteMethod");*/
 
        va_start(vaargs,methodID);
@@ -1430,6 +1512,7 @@ jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodI
 
 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
        return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_BYTE,args);
 
@@ -1438,6 +1521,7 @@ jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethod
 
 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualByteMethodA");
 
        return 0;
@@ -1450,6 +1534,7 @@ jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodI
        jchar ret;
        va_list vaargs;
 
+       STATS(jniinvokation();)
 /*     log_text("JNI-Call: CallNonVirtualCharMethod");*/
 
        va_start(vaargs,methodID);
@@ -1461,6 +1546,7 @@ jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodI
 
 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
        return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_CHAR,args);
 }
@@ -1468,6 +1554,7 @@ jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethod
 
 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualCharMethodA");
 
        return 0;
@@ -1479,6 +1566,7 @@ jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmetho
 {
        jshort ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
 
@@ -1491,6 +1579,7 @@ jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmetho
 
 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
        return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_SHORT,args);
 }
@@ -1498,6 +1587,7 @@ jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmeth
 
 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualShortMethodA");
 
        return 0;
@@ -1510,6 +1600,7 @@ jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID
 
         jint ret;
         va_list vaargs;
+       STATS(jniinvokation();)
 
        /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
 
@@ -1522,6 +1613,7 @@ jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID
 
 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
         return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),PRIMITIVETYPE_INT,args);
 }
@@ -1529,6 +1621,7 @@ jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID
 
 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualIntMethodA");
 
        return 0;
@@ -1538,6 +1631,7 @@ jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID
 
 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualLongMethod");
 
        return 0;
@@ -1546,6 +1640,7 @@ jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodI
 
 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualLongMethodV");
 
        return 0;
@@ -1554,6 +1649,7 @@ jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethod
 
 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualLongMethodA");
 
        return 0;
@@ -1565,6 +1661,7 @@ jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmetho
 {
        jfloat ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
 
@@ -1579,6 +1676,7 @@ jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmetho
 
 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualFloatMethodV");
        return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,PRIMITIVETYPE_FLOAT);
 }
@@ -1586,6 +1684,7 @@ jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmeth
 
 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualFloatMethodA");
 
        return 0;
@@ -1597,6 +1696,7 @@ jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmet
 {
        jdouble ret;
        va_list vaargs;
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualDoubleMethod");
 
        va_start(vaargs,methodID);
@@ -1609,6 +1709,7 @@ jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmet
 
 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
 /*     log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
        return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,PRIMITIVETYPE_DOUBLE);
 }
@@ -1616,6 +1717,7 @@ jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jme
 
 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualDoubleMethodA");
 
        return 0;
@@ -1626,6 +1728,7 @@ jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jme
 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 {
         va_list vaargs;
+       STATS(jniinvokation();)
 
 /*      log_text("JNI-Call: CallNonvirtualVoidMethod");*/
 
@@ -1639,6 +1742,7 @@ void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID
 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {
 /*     log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
+       STATS(jniinvokation();)
 
         (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),TYPE_VOID,args);
 
@@ -1647,6 +1751,7 @@ void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodI
 
 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallNonvirtualVoidMethodA");
 }
 
@@ -1655,6 +1760,7 @@ void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodI
 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig) 
 {
        jfieldID f;
+       STATS(jniinvokation();)
 
 /*     log_text("========================= searching for:");
        log_text(name);
@@ -1678,6 +1784,7 @@ jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *si
 jfieldID getFieldID_critical(JNIEnv *env, jclass clazz, char *name, char *sig)
 {
     jfieldID id = GetFieldID(env, clazz, name, sig);
+       STATS(jniinvokation();)
 
     if (!id) {
        log_text("class:");
@@ -1722,107 +1829,125 @@ jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
 
 
 /*     return dbg;*/
+       STATS(jniinvokation();)
 
        return getField(obj,jobject,fieldID);
 }
 
 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jboolean,fieldID);
 }
 
 
 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
                return getField(obj,jbyte,fieldID);
 }
 
 
 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jchar,fieldID);
 }
 
 
 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jshort,fieldID);
 }
 
 
 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jint,fieldID);
 }
 
 
 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jlong,fieldID);
 }
 
 
 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jfloat,fieldID);
 }
 
 
 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
        return getField(obj,jdouble,fieldID);
 }
 
 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
 {
+       STATS(jniinvokation();)
         setField(obj,jobject,fieldID,val);
 }
 
 
 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
 {
+       STATS(jniinvokation();)
         setField(obj,jboolean,fieldID,val);
 }
 
 
 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
 {
+       STATS(jniinvokation();)
         setField(obj,jbyte,fieldID,val);
 }
 
 
 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
 {
+       STATS(jniinvokation();)
         setField(obj,jchar,fieldID,val);
 }
 
 
 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
 {
+       STATS(jniinvokation();)
         setField(obj,jshort,fieldID,val);
 }
 
 
 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
 {
+       STATS(jniinvokation();)
         setField(obj,jint,fieldID,val);
 }
 
 
 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
 {
+       STATS(jniinvokation();)
         setField(obj,jlong,fieldID,val);
 }
 
 
 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
 {
+       STATS(jniinvokation();)
         setField(obj,jfloat,fieldID,val);
 }
 
 
 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
 {
+       STATS(jniinvokation();)
         setField(obj,jdouble,fieldID,val);
 }
 
@@ -1832,6 +1957,7 @@ void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
 jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
 {
        jmethodID m;
+       STATS(jniinvokation();)
 
        m = class_resolvemethod(clazz,
                                                        utf_new_char((char *) name),
@@ -1852,6 +1978,7 @@ jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ..
 {
        jobject ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /* log_text("JNI-Call: CallStaticObjectMethod");*/
 
@@ -1865,6 +1992,7 @@ jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ..
 
 jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        /* log_text("JNI-Call: CallStaticObjectMethodV"); */
        
        return callObjectMethod(0,methodID,args);
@@ -1873,6 +2001,7 @@ jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, v
 
 jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticObjectMethodA");
 
        return NULL;
@@ -1883,6 +2012,7 @@ jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
 {
        jboolean ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        va_start(vaargs, methodID);
        ret = (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, vaargs);
@@ -1894,12 +2024,14 @@ jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
 
 jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, args);
 }
 
 
 jboolean CallStaticBooleanMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticBooleanMethodA");
 
        return 0;
@@ -1910,6 +2042,7 @@ jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jbyte ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticByteMethod");*/
 
@@ -1923,12 +2056,14 @@ jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 
 jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return (jbyte) callIntegerMethod(0, methodID, PRIMITIVETYPE_BYTE, args);
 }
 
 
 jbyte CallStaticByteMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticByteMethodA");
 
        return 0;
@@ -1939,6 +2074,7 @@ jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jchar ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticByteMethod");*/
 
@@ -1952,12 +2088,14 @@ jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 
 jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        return (jchar) callIntegerMethod(0, methodID, PRIMITIVETYPE_CHAR, args);
 }
 
 
 jchar CallStaticCharMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticCharMethodA");
 
        return 0;
@@ -1969,6 +2107,7 @@ jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jshort ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticByteMethod");*/
 
@@ -1982,6 +2121,7 @@ jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 
 jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        /*log_text("JNI-Call: CallStaticShortMethodV");*/
        return (jshort) callIntegerMethod(0, methodID, PRIMITIVETYPE_SHORT, args);
 }
@@ -1989,6 +2129,7 @@ jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_
 
 jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticShortMethodA");
 
        return 0;
@@ -2000,6 +2141,7 @@ jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jint ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticIntMethod");*/
 
@@ -2013,6 +2155,7 @@ jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 
 jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticIntMethodV");
 
        return callIntegerMethod(0, methodID, PRIMITIVETYPE_INT, args);
@@ -2021,6 +2164,7 @@ jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list
 
 jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticIntMethodA");
 
        return 0;
@@ -2032,6 +2176,7 @@ jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jlong ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticLongMethod");*/
 
@@ -2045,6 +2190,7 @@ jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 
 jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticLongMethodV");
        
        return callLongMethod(0,methodID,args);
@@ -2053,6 +2199,7 @@ jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_li
 
 jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticLongMethodA");
 
        return 0;
@@ -2064,6 +2211,7 @@ jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jfloat ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticLongMethod");*/
 
@@ -2077,6 +2225,7 @@ jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 
 jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
 
        return callFloatMethod(0, methodID, args, PRIMITIVETYPE_FLOAT);
 
@@ -2085,6 +2234,7 @@ jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_
 
 jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticFloatMethodA");
 
        return 0;
@@ -2096,6 +2246,7 @@ jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ..
 {
        jdouble ret;
        va_list vaargs;
+       STATS(jniinvokation();)
 
        /*      log_text("JNI-Call: CallStaticDoubleMethod");*/
 
@@ -2109,6 +2260,7 @@ jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ..
 
 jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticDoubleMethodV");
 
        return callFloatMethod(0, methodID, args, PRIMITIVETYPE_DOUBLE);
@@ -2117,6 +2269,7 @@ jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, v
 
 jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticDoubleMethodA");
 
        return 0;
@@ -2126,6 +2279,7 @@ jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, j
 void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
 {
        va_list vaargs;
+       STATS(jniinvokation();)
 
        va_start(vaargs, methodID);
        (void) callIntegerMethod(0, methodID, TYPE_VOID, vaargs);
@@ -2136,12 +2290,14 @@ void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
 void CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
 {
        log_text("JNI-Call: CallStaticVoidMethodV");
+       STATS(jniinvokation();)
        (void)callIntegerMethod(0, methodID, TYPE_VOID, args);
 }
 
 
 void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: CallStaticVoidMethodA");
 }
 
@@ -2160,6 +2316,7 @@ void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue *
 jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig)
 {
        jfieldID f;
+       STATS(jniinvokation();)
 
        f = jclass_findfield(clazz,
                                                 utf_new_char((char *) name),
@@ -2181,6 +2338,8 @@ jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const cha
 
 jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticObjectField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return NULL;
 
@@ -2190,6 +2349,9 @@ jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticBooleanField: calling initialize_class %s\n",clazz->name->text);)
+
        if (!initialize_class(clazz))
                return false;
 
@@ -2199,6 +2361,9 @@ jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticByteField: calling initialize_class %s\n",clazz->name->text);)
+
        if (!initialize_class(clazz))
                return 0;
 
@@ -2208,6 +2373,9 @@ jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticCharField: calling initialize_class %s\n",clazz->name->text);)
+
        if (!initialize_class(clazz))
                return 0;
 
@@ -2217,6 +2385,8 @@ jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticShorttField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return 0;
 
@@ -2226,6 +2396,8 @@ jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticIntField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return 0;
 
@@ -2235,6 +2407,8 @@ jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticLongField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return 0;
 
@@ -2244,6 +2418,8 @@ jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticFloatField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return 0.0;
 
@@ -2253,6 +2429,8 @@ jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("GetStaticDoubleField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return 0.0;
 
@@ -2269,6 +2447,8 @@ jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID)
 
 void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticObjectField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2278,6 +2458,8 @@ void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject v
 
 void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticBooleanField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2287,6 +2469,8 @@ void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean
 
 void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticByteField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2296,6 +2480,8 @@ void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value
 
 void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticCharField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2305,6 +2491,8 @@ void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value
 
 void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticShortField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2314,6 +2502,8 @@ void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort val
 
 void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticIntField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2323,6 +2513,8 @@ void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
 
 void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticLongField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2332,6 +2524,8 @@ void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value
 
 void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticFloatField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2341,6 +2535,8 @@ void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat val
 
 void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
 {
+       STATS(jniinvokation();)
+       JWCLINITDEBUG(printf("SetStaticDoubleField: calling initialize_class %s\n",clazz->name->text);)
        if (!initialize_class(clazz))
                return;
 
@@ -2360,6 +2556,7 @@ jstring NewString(JNIEnv *env, const jchar *buf, jsize len)
        java_lang_String *s;
        java_chararray   *a;
        u4                i;
+       STATS(jniinvokation();)
        
        s = (java_lang_String *) builtin_new(class_java_lang_String);
        a = builtin_newarray_char(len);
@@ -2399,6 +2596,7 @@ u2 *javastring_tou2 (jstring so)
        java_chararray *a;
        u4 i;
        u2 *stringbuffer;
+       STATS(jniinvokation();)
        
        if (!s) return NULL;
 
@@ -2422,6 +2620,7 @@ u2 *javastring_tou2 (jstring so)
 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
 {      
        jchar *jc=javastring_tou2(str);
+       STATS(jniinvokation();)
 
        if (jc) {
                if (isCopy) *isCopy=JNI_TRUE;
@@ -2435,6 +2634,7 @@ const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
 
 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
 {
+       STATS(jniinvokation();)
        if (chars==emptyStringJ) return;
        MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count+1);
 }
@@ -2448,6 +2648,7 @@ void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
 
 jstring NewStringUTF(JNIEnv *env, const char *bytes)
 {
+       STATS(jniinvokation();)
     return (jstring) javastring_new(utf_new_char(bytes));
 }
 
@@ -2457,6 +2658,7 @@ jstring NewStringUTF(JNIEnv *env, const char *bytes)
 jsize GetStringUTFLength (JNIEnv *env, jstring string)
 {   
     java_lang_String *s = (java_lang_String*) string;
+       STATS(jniinvokation();)
 
     return (jsize) u2_utflength(s->value->data, s->count); 
 }
@@ -2467,6 +2669,7 @@ jsize GetStringUTFLength (JNIEnv *env, jstring string)
 const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
 {
     utf *u;
+       STATS(jniinvokation();)
 
     u = javastring_toutf((java_lang_String *) string, false);
 
@@ -2485,6 +2688,8 @@ const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
 
 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
 {
+       STATS(jniinvokation();)
+
     /*we don't release utf chars right now, perhaps that should be done later. Since there is always one reference
        the garbage collector will never get them*/
        /*
@@ -2497,6 +2702,8 @@ void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
 
 jsize GetArrayLength(JNIEnv *env, jarray array)
 {
+       STATS(jniinvokation();)
+
     return array->size;
 }
 
@@ -2512,6 +2719,7 @@ jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobj
 {
        java_objectarray *oa;
        s4 i;
+       STATS(jniinvokation();)
 
        if (length < 0) {
                *exceptionptr = new_negativearraysizeexception();
@@ -2535,6 +2743,7 @@ jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobj
 jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
 {
     jobject j = NULL;
+       STATS(jniinvokation();)
 
     if (index < array->header.size)    
                j = array->data[index];
@@ -2547,6 +2756,7 @@ jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
 
 void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
 {
+       STATS(jniinvokation();)
     if (index >= array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2565,6 +2775,7 @@ void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject
 jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
 {
        java_booleanarray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2580,6 +2791,7 @@ jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
 jbyteArray NewByteArray(JNIEnv *env, jsize len)
 {
        java_bytearray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2595,6 +2807,7 @@ jbyteArray NewByteArray(JNIEnv *env, jsize len)
 jcharArray NewCharArray(JNIEnv *env, jsize len)
 {
        java_chararray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2610,6 +2823,7 @@ jcharArray NewCharArray(JNIEnv *env, jsize len)
 jshortArray NewShortArray(JNIEnv *env, jsize len)
 {
        java_shortarray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2625,6 +2839,7 @@ jshortArray NewShortArray(JNIEnv *env, jsize len)
 jintArray NewIntArray(JNIEnv *env, jsize len)
 {
        java_intarray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2640,6 +2855,7 @@ jintArray NewIntArray(JNIEnv *env, jsize len)
 jlongArray NewLongArray(JNIEnv *env, jsize len)
 {
        java_longarray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2655,6 +2871,7 @@ jlongArray NewLongArray(JNIEnv *env, jsize len)
 jfloatArray NewFloatArray(JNIEnv *env, jsize len)
 {
        java_floatarray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2670,6 +2887,7 @@ jfloatArray NewFloatArray(JNIEnv *env, jsize len)
 jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
 {
        java_doublearray *j;
+       STATS(jniinvokation();)
 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
@@ -2684,6 +2902,7 @@ jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
 
 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2691,6 +2910,7 @@ jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *
 
 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2698,6 +2918,7 @@ jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
 
 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2705,6 +2926,7 @@ jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
 
 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2712,6 +2934,7 @@ jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy
 
 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2719,6 +2942,7 @@ jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
 
 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2726,6 +2950,7 @@ jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
 
 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2733,6 +2958,7 @@ jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy
 
 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
@@ -2741,12 +2967,14 @@ jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isC
 
 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
 
 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
@@ -2759,36 +2987,42 @@ void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint
 
 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
 
 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
 
 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
 
 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
 
 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
 {
+       STATS(jniinvokation();)
     /* empty */
 }
 
 
 void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2799,6 +3033,7 @@ void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize
 
 void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size) 
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2809,6 +3044,7 @@ void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, j
 
 void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2819,6 +3055,7 @@ void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, j
 
 void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2829,6 +3066,7 @@ void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len,
 
 void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2839,6 +3077,7 @@ void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jin
 
 void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2849,6 +3088,7 @@ void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, j
 
 void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2859,6 +3099,7 @@ void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len,
 
 void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start+len>array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2869,6 +3110,7 @@ void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize le
 
 void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2879,6 +3121,7 @@ void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize
 
 void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2889,6 +3132,7 @@ void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize len, j
 
 void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2900,6 +3144,7 @@ void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize len, j
 
 void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2910,6 +3155,7 @@ void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize len,
 
 void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2921,6 +3167,7 @@ void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize len, jin
 
 void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2932,6 +3179,7 @@ void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, j
 
 void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2943,6 +3191,7 @@ void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize len,
 
 void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
 {
+       STATS(jniinvokation();)
     if (start < 0 || len < 0 || start + len > array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
@@ -2953,6 +3202,7 @@ void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize le
 
 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
 {
+       STATS(jniinvokation();)
     log_text("JNI-Call: RegisterNatives");
     return 0;
 }
@@ -2960,6 +3210,7 @@ jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods,
 
 jint UnregisterNatives (JNIEnv* env, jclass clazz)
 {
+       STATS(jniinvokation();)
     log_text("JNI-Call: UnregisterNatives");
     return 0;
 }
@@ -2976,6 +3227,7 @@ jint UnregisterNatives (JNIEnv* env, jclass clazz)
 
 jint MonitorEnter(JNIEnv *env, jobject obj)
 {
+       STATS(jniinvokation();)
        if (!obj) {
                *exceptionptr = new_nullpointerexception();
                return JNI_ERR;
@@ -3001,6 +3253,7 @@ jint MonitorEnter(JNIEnv *env, jobject obj)
 
 jint MonitorExit(JNIEnv *env, jobject obj)
 {
+       STATS(jniinvokation();)
        if (!obj) {
                *exceptionptr = new_nullpointerexception();
                return JNI_ERR;
@@ -3026,6 +3279,7 @@ jint MonitorExit(JNIEnv *env, jobject obj)
 
 jint GetJavaVM(JNIEnv *env, JavaVM **vm)
 {
+       STATS(jniinvokation();)
     *vm = &ptr_jvm;
 
        return 0;
@@ -3034,12 +3288,14 @@ jint GetJavaVM(JNIEnv *env, JavaVM **vm)
 
 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: GetStringRegion");
 }
 
 
 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: GetStringUTFRegion");
 }
 
@@ -3048,6 +3304,7 @@ void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char
 
 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
        java_objectheader *s = (java_objectheader*) array;
        arraydescriptor *desc = s->vftbl->arraydesc;
 
@@ -3059,6 +3316,7 @@ void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
 
 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: ReleasePrimitiveArrayCritical");
 
        /* empty */
@@ -3068,6 +3326,7 @@ void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jin
 
 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: GetStringCritical");
 
        return GetStringChars(env,string,isCopy);
@@ -3077,6 +3336,7 @@ const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
 
 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: ReleaseStringCritical");
 
        ReleaseStringChars(env,string,cstring);
@@ -3085,6 +3345,7 @@ void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
 
 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: NewWeakGlobalRef");
 
        return obj;
@@ -3093,6 +3354,7 @@ jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
 
 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
 {
+       STATS(jniinvokation();)
        log_text("JNI-Call: DeleteWeakGlobalRef");
 
        /* empty */
@@ -3106,6 +3368,7 @@ jobject NewGlobalRef(JNIEnv* env, jobject lobj)
        jobject refcount;
        jint val;
        jobject newval;
+       STATS(jniinvokation();)
 
        MonitorEnter(env, *global_ref_table);
        
@@ -3131,6 +3394,7 @@ void DeleteGlobalRef(JNIEnv* env, jobject gref)
 {
        jobject refcount;
        jint val;
+       STATS(jniinvokation();)
 
        MonitorEnter(env, *global_ref_table);
        refcount = CallObjectMethod(env, *global_ref_table, getmid, gref);
@@ -3170,6 +3434,7 @@ void DeleteGlobalRef(JNIEnv* env, jobject gref)
 
 jboolean ExceptionCheck(JNIEnv *env)
 {
+       STATS(jniinvokation();)
        return *exceptionptr ? JNI_TRUE : JNI_FALSE;
 }
 
@@ -3185,6 +3450,7 @@ jboolean ExceptionCheck(JNIEnv *env)
 
 jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
 {
+       STATS(jniinvokation();)
        log_text("NewDirectByteBuffer: IMPLEMENT ME!");
 
        return NULL;
@@ -3200,6 +3466,7 @@ jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
 
 void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
 {
+       STATS(jniinvokation();)
        log_text("GetDirectBufferAddress: IMPLEMENT ME!");
 
        return NULL;
@@ -3215,6 +3482,7 @@ void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
 
 jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
 {
+       STATS(jniinvokation();)
        log_text("GetDirectBufferCapacity: IMPLEMENT ME!");
 
        return 0;
@@ -3223,6 +3491,7 @@ jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
 
 jint DestroyJavaVM(JavaVM *vm)
 {
+       STATS(jniinvokation();)
        log_text("DestroyJavaVM called");
 
        return 0;
@@ -3231,15 +3500,15 @@ jint DestroyJavaVM(JavaVM *vm)
 
 jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
 {
+       STATS(jniinvokation();)
        log_text("AttachCurrentThread called");
-#if 0
+
 #if !defined(HAVE___THREAD)
-       log_text("implement really attaching here (threadobj)");
-       cacao_thread_attach();
+/*     cacao_thread_attach();*/
 #else
        #error "No idea how to implement that. Perhaps Stefan knows"
 #endif
-#endif
+
        *env = &ptr_env;
        return 0;
 }
@@ -3247,6 +3516,7 @@ jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
 
 jint DetachCurrentThread(JavaVM *vm)
 {
+       STATS(jniinvokation();)
        log_text("DetachCurrentThread called");
 
        return 0;
@@ -3255,6 +3525,7 @@ jint DetachCurrentThread(JavaVM *vm)
 
 jint GetEnv(JavaVM *vm, void **env, jint version)
 {
+       STATS(jniinvokation();)
        if ((version != JNI_VERSION_1_1) && (version != JNI_VERSION_1_2) &&
                (version != JNI_VERSION_1_4)) {
                *env = NULL;
@@ -3277,6 +3548,7 @@ jint GetEnv(JavaVM *vm, void **env, jint version)
 
 jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
 {
+       STATS(jniinvokation();)
        log_text("AttachCurrentThreadAsDaemon called");
 
        return 0;

diff --git a/src/native/vm/Field.c b/src/native/vm/Field.c
index 04b7f8ca790458e3ffee3e2d8698cdcc4d465088..ea5097d2e66c0a3f317eb48f6c9ff091e85d0ec1 100644 (file)
--- a/src/native/vm/Field.c
+++ b/src/native/vm/Field.c
@@ -29,7 +29,7 @@
    Changes: Joseph Wenninger
             Christian Thalinger
 
-   $Id: Field.c 2201 2005-04-03 21:48:11Z twisti $
+   $Id: Field.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -295,6 +295,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_reflect_Field_getBoolean(JNIEnv *env, java_l
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -360,6 +361,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_reflect_Field_getByte(JNIEnv *env, java_lang
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -425,6 +427,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_reflect_Field_getChar(JNIEnv *env, java_lang
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -490,6 +493,7 @@ JNIEXPORT double JNICALL Java_java_lang_reflect_Field_getDouble(JNIEnv *env , ja
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -564,6 +568,7 @@ JNIEXPORT float JNICALL Java_java_lang_reflect_Field_getFloat(JNIEnv *env, java_
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -636,6 +641,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_reflect_Field_getInt(JNIEnv *env , java_lang
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -707,6 +713,7 @@ JNIEXPORT s8 JNICALL Java_java_lang_reflect_Field_getLong(JNIEnv *env, java_lang
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/
@@ -780,6 +787,7 @@ JNIEXPORT s4 JNICALL Java_java_lang_reflect_Field_getShort(JNIEnv *env, java_lan
 
        if (fid->flags & ACC_STATIC) {
                /* initialize class if needed*/
+               fprintf("calling initialize_class %s\n",((classinfo*) this->declaringClass)->name->text);
                initialize_class((classinfo *) this->declaringClass);
                if (*exceptionptr) return 0;
                /*return value*/

diff --git a/src/native/vm/VMClass.c b/src/native/vm/VMClass.c
index 15a7a1cbc03f5372e56fcd3412430b452a793248..655366937e31b7a52256bd5656d049f2d3b46a81 100644 (file)
--- a/src/native/vm/VMClass.c
+++ b/src/native/vm/VMClass.c
@@ -29,7 +29,7 @@
    Changes: Joseph Wenninger
             Christian Thalinger
 
-   $Id: VMClass.c 2209 2005-04-04 09:41:17Z twisti $
+   $Id: VMClass.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -582,6 +582,8 @@ JNIEXPORT java_lang_String* JNICALL Java_java_lang_VMClass_getName(JNIEnv *env,
        classinfo *c = (classinfo *) that;
        java_lang_String *s = (java_lang_String *) javastring_new(c->name);
 
+       /*log_text("Java_java_lang_VMClass_getName");*/
+
        if (!s)
                return NULL;
 
@@ -791,10 +793,12 @@ JNIEXPORT void JNICALL Java_java_lang_VMClass_initialize(JNIEnv *env, jclass cla
        ci = (classinfo *) c;
 
        /* initialize class */
-       if (!ci->initialized)
+       if (!ci->initialized) {
+               /*printf("Java_java_land_VMClass_initialize calling initialize_class %s\n",ci->name->text);*/
                /* No need to check return value, because class_init already sets the */
                /* exception pointer. */
                (void) initialize_class(ci);
+       }
 }
 
 

diff --git a/src/vm/initialize.c b/src/vm/initialize.c
index f1d88c691219cb9626fbc192a0b641f8e35c72a8..e3493ebd3682df73ef74a4f5eb37a0598cf736f1 100644 (file)
--- a/src/vm/initialize.c
+++ b/src/vm/initialize.c
@@ -30,7 +30,7 @@
             Andreas Krall
             Christian Thalinger
 
-   $Id: initialize.c 2213 2005-04-04 13:05:15Z edwin $
+   $Id: initialize.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -48,6 +48,7 @@
 #include "vm/stringlocal.h"
 #include "vm/jit/asmpart.h"
 
+#undef JWDEBUG
 
 /* private functions **********************************************************/
 
@@ -91,6 +92,9 @@ bool initialize_class(classinfo *c)
                return true;
        }
 
+#ifdef JWDEBUG
+       printf("preparing to call initialize_class_intern for %s\n",c->name->text);
+#endif
        /* this initalizing run begins NOW */
        c->initializing = true;
 
@@ -102,6 +106,10 @@ bool initialize_class(classinfo *c)
        if (r)
                c->initialized = true;
 
+#ifdef JWDEBUG
+       printf("finished to call initialize_class_intern for %s\n",c->name->text);
+#endif
+
        /* this initalizing run is done */
        c->initializing = false;
 
@@ -153,7 +161,9 @@ static bool initialize_class_intern(classinfo *c)
                                utf_strcat_classname(logtext, c->name);
                                log_text(logtext);
                        }
-
+#ifdef JWDEBUG
+                       printf("preparing to call initialize_class for super  %s\n",c->super.cls->name->text);
+#endif
                        if (!initialize_class(c->super.cls))
                                return false;
                }
@@ -163,6 +173,9 @@ static bool initialize_class_intern(classinfo *c)
 
        for (i = 0; i < c->interfacescount; i++) {
                if (!c->interfaces[i].cls->initialized) {
+#ifdef JWDEBUG
+                       printf("preparing to call initialize_class for interface  %s\n",c->interfaces[i].cls->name->text);
+#endif
                        if (initverbose) {
                                char logtext[MAXLOGTEXT];
                                strcpy(logtext, "Initialize interface class ");

diff --git a/src/vm/jit/codegen.inc b/src/vm/jit/codegen.inc
index 41d8526bb585b2a598b165d64d4f855ec66103df..860487b6360560fe20dd64825074db2ebe48a49c 100644 (file)
--- a/src/vm/jit/codegen.inc
+++ b/src/vm/jit/codegen.inc
@@ -47,7 +47,7 @@
    memory. All functions writing values into the data area return the offset
    relative the begin of the code area (start of procedure).   
 
-   $Id: codegen.inc 2406 2005-04-28 12:19:06Z jowenn $
+   $Id: codegen.inc 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -78,6 +78,11 @@
 #include "vm/statistics.h"
 #include "vm/jit/codegen.inc.h"
 
+#undef JWDEBUG_X86
+
+#ifdef JWDEBUG_X86
+#include <execinfo.h>
+#endif
 
 /* in this tree we store all method addresses *********************************/
 
@@ -600,23 +605,6 @@ static int methodtree_comparator(const void *pc, const void *element, void *para
 }
 
 
-#if 0
-void *codegen_findmethod1(void *pc)
-{
-       void * retVal=findmethod(pc);
-       methodinfo **ma=(methodinfo**)retVal;
-       methodinfo *m=ma[-1];
-       if (m)
-               if (m->name)
-                       utf_display(m->name);
-               else 
-                       log_text("No Name");
-       else log_text("No methodinfo");
-       return retVal;
-}
-#endif
-
-
 void codegen_insertmethod(functionptr startpc, functionptr endpc)
 {
        methodtree_element *mte;
@@ -675,6 +663,13 @@ functionptr codegen_findmethod(functionptr pc)
 #endif
 #endif
                {
+#ifdef JWDEBUG_X86
+                       {
+                               void *bt[5];
+                               fprintf(stderr,"backtrace:");
+                               backtrace_symbols_fd(bt,5,2);
+                       }
+#endif
                        char msg[63];
                        sprintf(msg,"cannot find function (%p)",pc);
                        throw_cacao_exception_exit(string_java_lang_InternalError,

diff --git a/src/vm/jit/jit.c b/src/vm/jit/jit.c
index 5a49df1497dad913f8c5440d983f94c1eb48e87a..fca20aa0972591c54af3854431b6d1dcb0bf51ee 100644 (file)
--- a/src/vm/jit/jit.c
+++ b/src/vm/jit/jit.c
@@ -30,7 +30,7 @@
    Changes: Edwin Steiner
             Christian Thalinger
 
-   $Id: jit.c 2406 2005-04-28 12:19:06Z jowenn $
+   $Id: jit.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -1494,7 +1494,7 @@ static functionptr jit_compile_intern(methodinfo *m, codegendata *cd,
 
        if (compileverbose) {
                log_message_method("Compiling done: ", m);
-               printf("%p - %p\n",(void *) ((long) m->mcode + cd->dseglen),(void *) ((long) m->mcode + m->mcodelength));
+               printf("method dataseg:%p, range:%p %p\n",m->mcode,(void *) ((long) m->mcode + cd->dseglen),(void *) ((long) m->mcode + m->mcodelength));
        }
 
 #ifdef LSRA

diff --git a/src/vm/jit/stacktrace.c b/src/vm/jit/stacktrace.c
index 2fbe9893c65205c8e5de3fa73aa21b99f2a25ec4..514e48d60f3dcd938eaf1e26502b4252191e4715 100644 (file)
--- a/src/vm/jit/stacktrace.c
+++ b/src/vm/jit/stacktrace.c
@@ -26,7 +26,7 @@
 
    Authors: Joseph Wenninger
 
-   $Id: stacktrace.c 2406 2005-04-28 12:19:06Z jowenn $
+   $Id: stacktrace.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -87,11 +87,14 @@ static void addEntry(stackTraceBuffer* buffer,methodinfo*method ,LineNumber line
                buffer->full = buffer->full + 1;
 #ifdef JWDEBUG
                log_text("addEntry (stacktrace):");
+               printf("method %p\n",method);
+               if (method) printf("method->name %p\n",method->name);
                if (method) utf_display(method->name); else printf("Native");
                if (method) {printf("\n");utf_display(method->class->name);}
-               printf("\nLine:%ld\n",line);
+               printf("\nnext buffer item %d\nLine:%ld\n",buffer->full,line);
 #endif
        } else {
+               log_text("stacktrace buffer full, resizing");
                stacktraceelement *newBuffer=(stacktraceelement*)
                        malloc((buffer->size+BLOCK_SIZEINCREMENT)*sizeof(stacktraceelement));
                if (newBuffer==0) panic("OOM during stacktrace creation");
@@ -140,7 +143,12 @@ static int fillInStackTrace_methodRecursive(stackTraceBuffer *buffer,methodinfo
                                ent--;
                                addEntry(buffer,method,ent->lineNr);
                                return 1;       
-                       } else panic("trace point before method");
+                       } else {
+#ifdef JWDEBUG
+                               printf("trace point: %p\n",adress);
+#endif
+                               panic("trace point before method");
+                       }
                }
        }
        ent--;
@@ -207,6 +215,14 @@ void  cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c
        buffer.full=0;
 #ifdef JWDEBUG
        log_text("entering cacao_stacktrace_fillInStacktrace");
+       {
+               int i=0;
+               struct native_stackframeinfo *tmpinfo;
+               for (tmpinfo=(*(((void**)(builtin_asm_get_stackframeinfo()))));tmpinfo;tmpinfo=tmpinfo->oldThreadspecificHeadValue)
+                       i++;
+               printf("native function depth:%d\n",i);
+               
+       }
 #endif
        {
                struct native_stackframeinfo *info=(*(((void**)(builtin_asm_get_stackframeinfo()))));
@@ -229,10 +245,19 @@ void  cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c
                                if (currentMethod==0) { /*some builtin native */
                                        currentMethod=info->method;
                                        returnAdress=(functionptr)info->returnToFromNative;
-                                       /*log_text("native");*/
+#ifdef JWDEBUG
+                                       log_text("native");
+                                       printf("return to %p\n",returnAdress);
+#endif
                                        if (currentMethod) {
-                                               /*utf_display(currentMethod->class->name);
-                                               utf_display(currentMethod->name);*/
+#ifdef JWDEBUG
+                                               log_text("real native (not an internal helper)\n");
+                                               printf("returnaddress %p, methodpointer %p, stackframe begin %p\n",info->returnToFromNative,info->method, info->beginOfJavaStackframe);
+#if 0
+                                               utf_display(currentMethod->class->name);
+                                               utf_display(currentMethod->name);
+#endif
+#endif
                                                addEntry(&buffer,currentMethod,0);
                                        }
 #if defined(__ALPHA__)
@@ -255,7 +280,9 @@ void  cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c
                                        info=info->oldThreadspecificHeadValue;
                                } else { /*method created by jit*/
                                        u4 frameSize;
-                                       /*log_text("JIT");*/
+#ifdef JWDEBUG
+                                       log_text("JIT");
+#endif
 #if defined (__ALPHA__)
                                        if (currentMethod->isleafmethod) {
 #ifdef JWDEBUG
@@ -359,13 +386,30 @@ void classContextCollector(void **target, stackTraceBuffer *buffer) {
         tmpArray = builtin_anewarray(targetSize, class_java_lang_Class);
 
         for(i = 0, current = start; i < targetSize; i++, current++) {
-                if (current->method==0) { i--; continue;}
-               /*printf("adding item to class context array:%s\n",current->method->class->name->text);
-               printf("method for class: :%s\n",current->method->name->text);*/
+                if (current->method==0) { i--; /*printf("Skipping\n");*/ continue;}
+#ifdef JWDEBUG
+               {
+                       printf("after current->method check\n");
+                       if (current->method->class==0) printf("Error method defining class i null\n");
+                       else printf("method defining class is not null :)\n");
+                       printf("adding item to class context array:%s\n",current->method->class->name->text);
+                       printf("method for class: :%s\n",current->method->name->text);
+               }
+#endif
                 use_class_as_object(current->method->class);
+#ifdef JWDEBUG
+               {
+                       printf("use_class_as_object_finished\n");
+               }
+#endif
                 tmpArray->data[i] = (java_objectheader *) current->method->class;
+#ifdef JWDEBUG
+               printf("array item has been set\n");
+#endif
         }
-
+#ifdef JWDEBUG
+       printf("leaving classContextCollector");
+#endif
         *target=tmpArray;
 }
 

diff --git a/src/vm/jit/x86_64/asmpart.S b/src/vm/jit/x86_64/asmpart.S
index 1695ebae4a10b6b9a063a3973408e835a92aa016..88e056d27b4126af9ca121ef91ecdea77b03757b 100644 (file)
--- a/src/vm/jit/x86_64/asmpart.S
+++ b/src/vm/jit/x86_64/asmpart.S
@@ -28,7 +28,7 @@
             Reinhard Grafl
             Christian Thalinger
 
-   $Id: asmpart.S 2414 2005-04-29 18:55:09Z twisti $
+   $Id: asmpart.S 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -246,8 +246,10 @@ call_name2:
        .quad   calljava_xhandler2        /* end pc                               */
        .quad   asm_calljavafunction2     /* start pc                             */
        .long   1                         /* extable size                         */
+       .long   0
        .quad   0                         /* line number table  start             */
        .quad   0                         /* line number table  size              */
+        .long   0
        .long   0                         /* fltsave                              */
        .long   0                         /* intsave                              */
        .long   0                         /* isleaf                               */

diff --git a/src/vm/jit/x86_64/codegen.c b/src/vm/jit/x86_64/codegen.c
index 8480c8bdcff43cfd0cce062cacf56ac367b09117..4887c9cbb0db6bb3cbe3ed27bc8e697737b0ab7e 100644 (file)
--- a/src/vm/jit/x86_64/codegen.c
+++ b/src/vm/jit/x86_64/codegen.c
@@ -27,7 +27,7 @@
    Authors: Andreas Krall
             Christian Thalinger
 
-   $Id: codegen.c 2422 2005-04-30 13:29:34Z twisti $
+   $Id: codegen.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -54,6 +54,7 @@
 #include "vm/jit/x86_64/types.h"
 #include "vm/jit/x86_64/asmoffsets.h"
 #include "vm/jit/helper.h"
+#include "vm/statistics.h"
 
 /* register descripton - array ************************************************/
 
@@ -89,7 +90,11 @@ static int nregdescfloat[] = {
 #include "vm/jit/lsra.inc"
 #endif
 
-
+#if 0
+#define JWNATIVEDEBUG(x) true
+#else
+#define JWNATIVEDEBUG(x) x
+#endif
 void codegen_dummy_func() { log_text("codegen_dummy_func"); }
 
 #if defined(USE_THREADS) && defined(NATIVE_THREADS)
@@ -442,7 +447,7 @@ void codegen(methodinfo *m, codegendata *cd, registerdata *rd)
        /* Copy argument registers to stack and call trace function with pointer  */
        /* to arguments on stack.                                                 */
 
-       if (runverbose) {
+       if (runverbose || opt_stat) {
                M_LSUB_IMM((INT_ARG_CNT + FLT_ARG_CNT + INT_TMP_CNT + FLT_TMP_CNT + 1 + 1) * 8, REG_SP);
 
                /* save integer argument registers */
@@ -465,29 +470,35 @@ void codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_DST(rd->tmpfltregs[p], REG_SP, (1 + INT_ARG_CNT + FLT_ARG_CNT + INT_TMP_CNT + p) * 8);
                }
 
-               /* show integer hex code for float arguments */
+               if (runverbose) {
+                       /* show integer hex code for float arguments */
 
-               for (p = 0, l = 0; p < m->paramcount && p < INT_ARG_CNT; p++) {
-                       t = m->paramtypes[p];
+                       for (p = 0, l = 0; p < m->paramcount && p < INT_ARG_CNT; p++) {
+                               t = m->paramtypes[p];
 
-                       /* if the paramtype is a float, we have to right shift all        */
-                       /* following integer registers                                    */
+                               /* if the paramtype is a float, we have to right shift all        */
+                               /* following integer registers                                    */
+       
+                               if (IS_FLT_DBL_TYPE(t)) {
+                                       for (s1 = INT_ARG_CNT - 2; s1 >= p; s1--) {
+                                               x86_64_mov_reg_reg(cd, rd->argintregs[s1], rd->argintregs[s1 + 1]);
+                                       }
 
-                       if (IS_FLT_DBL_TYPE(t)) {
-                               for (s1 = INT_ARG_CNT - 2; s1 >= p; s1--) {
-                                       x86_64_mov_reg_reg(cd, rd->argintregs[s1], rd->argintregs[s1 + 1]);
+                                       x86_64_movd_freg_reg(cd, rd->argfltregs[l], rd->argintregs[p]);
+                                       l++;
                                }
-
-                               x86_64_movd_freg_reg(cd, rd->argfltregs[l], rd->argintregs[p]);
-                               l++;
                        }
-               }
-
-               x86_64_mov_imm_reg(cd, (ptrint) m, REG_ITMP2);
-               x86_64_mov_reg_membase(cd, REG_ITMP2, REG_SP, 0 * 8);
-               x86_64_mov_imm_reg(cd, (ptrint) builtin_trace_args, REG_ITMP1);
-               x86_64_call_reg(cd, REG_ITMP1);
 
+                       x86_64_mov_imm_reg(cd, (ptrint) m, REG_ITMP2);
+                       x86_64_mov_reg_membase(cd, REG_ITMP2, REG_SP, 0 * 8);
+                       x86_64_mov_imm_reg(cd, (ptrint) builtin_trace_args, REG_ITMP1);
+                       x86_64_call_reg(cd, REG_ITMP1);
+               }
+               STATS({
+                       x86_64_mov_imm_reg(cd,(u8)compiledinvokation,REG_ITMP1);
+                       x86_64_call_reg(cd,REG_ITMP1);
+               })
+               
                /* restore integer argument registers */
 
                for (p = 0; p < INT_ARG_CNT; p++)
@@ -4388,7 +4399,7 @@ void removecompilerstub(u1 *stub)
 /* static java_objectheader **(*callgetexceptionptrptr)() = builtin_get_exceptionptrptr; */
 /* #endif */
 
-#define NATIVESTUBSIZE    800           /* keep this size high enough!        */
+#define NATIVESTUBSIZE    1024           /* keep this size high enough!        */
 #define NATIVESTUB_DATA_SIZE (7*8)
 
 u1 *createnativestub(functionptr f, methodinfo *m)
@@ -4472,7 +4483,7 @@ u1 *createnativestub(functionptr f, methodinfo *m)
                codegen_addpatchref(cd, cd->mcodeptr, PATCHER_clinit, m->class);
        }
 
-       if (runverbose) {
+       if (JWNATIVEDEBUG(runverbose)) {
                s4 l, s1;
 
                x86_64_alu_imm_reg(cd, X86_64_SUB, (INT_ARG_CNT + FLT_ARG_CNT + 1) * 8, REG_SP);
@@ -4551,7 +4562,8 @@ u1 *createnativestub(functionptr f, methodinfo *m)
 
        /* CREATE DYNAMIC STACK INFO -- BEGIN   offsets:15,16,17,18*/
        x86_64_mov_imm_membase(cd, 0, REG_SP, 18*8);
-       x86_64_mov_imm_membase(cd, (u8)m, REG_SP, 17*8);
+       x86_64_mov_imm_membase(cd, (ptrint)m, REG_SP, 17*8);
+       /*x86_64_mov_imm_membase(cd, 0, REG_SP, 17*8);*/
 
        x86_64_mov_imm_reg(cd, (u8) builtin_asm_get_stackframeinfo,REG_ITMP1);
        x86_64_call_reg(cd,REG_ITMP1);
@@ -4578,6 +4590,10 @@ u1 *createnativestub(functionptr f, methodinfo *m)
 #endif
        /* CREATE DYNAMIC STACK INFO -- END*/
 
+       STATS({
+               x86_64_mov_imm_reg(cd,(u8)nativeinvokation,REG_ITMP1);
+               x86_64_call_reg(cd,REG_ITMP1);
+       })
 
 #if !defined(STATIC_CLASSPATH)
        /* call method to resolve native function if needed */
@@ -4740,7 +4756,7 @@ u1 *createnativestub(functionptr f, methodinfo *m)
 
        x86_64_alu_imm_reg(cd, X86_64_ADD, 4 * 8, REG_SP);
 
-       if (runverbose) {
+       if (JWNATIVEDEBUG(runverbose)) {
                x86_64_alu_imm_reg(cd, X86_64_SUB, 3 * 8, REG_SP);    /* keep stack 16-byte aligned */
 
                x86_64_mov_reg_membase(cd, REG_RESULT, REG_SP, 0 * 8);
@@ -4856,13 +4872,13 @@ u1 *createnativestub(functionptr f, methodinfo *m)
                        x86_64_mov_imm_reg(cd, (ptrint) asm_wrapper_patcher, REG_ITMP3);
                        x86_64_jmp_reg(cd, REG_ITMP3);
 
-                       codegen_insertmethod((functionptr) (ptrint) cs,
-                                                                (functionptr) (ptrint) cd->mcodeptr);
-                       /*printf("codegen_insertmethod (nativestub) %p - %p\n",cs,cd->mcodeptr);*/
+                       codegen_insertmethod((functionptr) cs, (functionptr) cd->mcodeptr);
+                       /*printf("codegen_insertmethod (nativestub) %s.%s:   %p  %p\n",
+                                                               m->class->name->text,m->name->text,cs,cd->mcodeptr);*/
                }
        }
 
-       /*printf("(nativestub) %s: %p - %p\n",m->name->text,cs,cd->mcodeptr);*/
+       /*printf("(nativestub) %s.%s:  %p  %p\n",m->class->name->text,m->name->text,cs,cd->mcodeptr);*/
 
        /* Check if the stub size is big enough to hold the whole stub generated. */
        /* If not, this can lead into unpredictable crashes, because of heap      */

diff --git a/src/vm/jit/x86_64/patcher.c b/src/vm/jit/x86_64/patcher.c
index e116f0fe587ff3cfeb6ee1c7b8b2acee91498415..689640f48a1eda9ecf2db4b08d6dab0584d1899c 100644 (file)
--- a/src/vm/jit/x86_64/patcher.c
+++ b/src/vm/jit/x86_64/patcher.c
@@ -28,7 +28,7 @@
 
    Changes:
 
-   $Id: patcher.c 2421 2005-04-30 13:28:35Z twisti $
+   $Id: patcher.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -43,6 +43,39 @@
 #include "vm/exceptions.h"
 
 
+helper_initialize_class(void* beginOfJavaStack,classinfo *c,u1 *ra) {
+       if (!c->initialized) {
+               bool init;
+               {
+                       /*struct native_stackframeinfo {
+                               void *oldThreadspecificHeadValue;
+                               void **addressOfThreadspecificHead;
+                               methodinfo *method;
+                               void *beginOfJavaStackframe; only used if != 0
+                               void *returnToFromNative;
+                       }*/
+                       /* more or less the same as the above sfi setup is done in the assembler code by the prepare/remove functions*/
+                       native_stackframeinfo sfi;
+                       sfi.returnToFromNative=ra;
+                       sfi.beginOfJavaStackframe=beginOfJavaStack;
+                       sfi.method=0; /*internal*/
+                       sfi.addressOfThreadspecificHead=builtin_asm_get_stackframeinfo();
+                       sfi.oldThreadspecificHeadValue=*(sfi.addressOfThreadspecificHead);
+                       *(sfi.addressOfThreadspecificHead)=&sfi;
+
+                       /*printf("calling static initializer (helper_initialize_class), returnaddress=%p for class %s\n",ra,c->name->text);*/
+
+                       init=initialize_class(c);
+
+                       *(sfi.addressOfThreadspecificHead)=sfi.oldThreadspecificHeadValue;
+               }
+               return init;
+       }
+       return true;
+}
+
+
+
 /* patcher_get_putstatic *******************************************************
 
    Machine code:
@@ -87,7 +120,7 @@ bool patcher_get_putstatic(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -98,40 +131,11 @@ bool patcher_get_putstatic(u1 *sp)
                *dontfillinexceptionstacktrace=false;
                return false;
        }
-
        /* check if the field's class is initialized */
 
        *dontfillinexceptionstacktrace=false;
-       if (!fi->class->initialized) {
-               bool init;
-               {
-                       /*struct native_stackframeinfo {
-                               void *oldThreadspecificHeadValue;
-                               void **addressOfThreadspecificHead;
-                               methodinfo *method;
-                               void *beginOfJavaStackframe; only used if != 0
-                               void *returnToFromNative;
-                       }*/
-                       /* more or less the same as the above sfi setup is done in the assembler code by the prepare/remove functions*/
-                       native_stackframeinfo sfi;
-                       sfi.returnToFromNative=(void*)ra;
-                       sfi.beginOfJavaStackframe=beginJavaStack;
-                       sfi.method=0; /*internal*/
-                       sfi.addressOfThreadspecificHead=builtin_asm_get_stackframeinfo();
-                       sfi.oldThreadspecificHeadValue=*(sfi.addressOfThreadspecificHead);
-                       *(sfi.addressOfThreadspecificHead)=&sfi;
-
-                       init=initialize_class(fi->class);
-
-                       *(sfi.addressOfThreadspecificHead)=sfi.oldThreadspecificHeadValue;
-               }
-               if (!init)
-               {
-                       return false;
-               }
-       }
+       if (!helper_initialize_class(beginJavaStack,fi->class,ra)) return false;
 
-       *dontfillinexceptionstacktrace=false;
 
        /* patch back original code */
 
@@ -157,7 +161,10 @@ bool patcher_get_putstatic(u1 *sp)
 
        /* leave the monitor on the patching position */
 
+       *dontfillinexceptionstacktrace=true;
        builtin_monitorexit(o);
+       *dontfillinexceptionstacktrace=false;
+
 #endif
 
        return true;
@@ -204,7 +211,7 @@ bool patcher_get_putfield(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -244,7 +251,6 @@ bool patcher_get_putfield(u1 *sp)
                        *((u4 *) (ra + 3)) = (u4) (fi->offset);
        }
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -254,7 +260,9 @@ bool patcher_get_putfield(u1 *sp)
        /* leave the monitor on the patching position */
 
        builtin_monitorexit(o);
+
 #endif
+       *dontfillinexceptionstacktrace=false;
 
        return true;
 }
@@ -331,7 +339,6 @@ bool patcher_putfieldconst(u1 *sp)
                *((u4 *) (ra + 3)) = (u4) (fi->offset);
        }
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -342,6 +349,7 @@ bool patcher_putfieldconst(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
+       *dontfillinexceptionstacktrace=false;
 
        return true;
 }
@@ -365,13 +373,14 @@ bool patcher_builtin_new(u1 *sp)
        u8                 mcode;
        constant_classref *cr;
        classinfo         *c;
-
+       void              *beginJavaStack;
        /* get stuff from the stack */
 
        ra    = (u1 *)                *((ptrint *) (sp + 3 * 8));
        o     = (java_objectheader *) *((ptrint *) (sp + 2 * 8));
        mcode =                       *((u8 *)     (sp + 1 * 8));
        cr    = (constant_classref *) *((ptrint *) (sp + 0 * 8));
+       beginJavaStack =              (void*) (sp+3*8);
 
        /* calculate and set the new return address */
 
@@ -389,7 +398,7 @@ bool patcher_builtin_new(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -398,9 +407,14 @@ bool patcher_builtin_new(u1 *sp)
 
        if (!(c = helper_resolve_classinfo(cr))) {
                *dontfillinexceptionstacktrace=false;
+               /*should here be an monitorexit too ?*/
                return false;
        }
 
+       *dontfillinexceptionstacktrace=false;
+       /*printf("ra:%p\n",ra);*/
+       if (!helper_initialize_class(beginJavaStack,c,ra+5)) return false;
+
        /* patch back original code */
 
        *((u8 *) (ra + 10)) = mcode;
@@ -418,7 +432,6 @@ bool patcher_builtin_new(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_new;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -426,8 +439,10 @@ bool patcher_builtin_new(u1 *sp)
        o->vftbl = (vftbl_t *) 1;
 
        /* leave the monitor on the patching position */
-
+       *dontfillinexceptionstacktrace=true;
        builtin_monitorexit(o);
+       *dontfillinexceptionstacktrace=false;
+
 #endif
 
        return true;
@@ -476,7 +491,7 @@ bool patcher_builtin_newarray(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -505,7 +520,6 @@ bool patcher_builtin_newarray(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_newarray;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -515,7 +529,9 @@ bool patcher_builtin_newarray(u1 *sp)
        /* leave the monitor on the patching position */
 
        builtin_monitorexit(o);
+
 #endif
+       *dontfillinexceptionstacktrace=false;
 
        return true;
 }
@@ -565,7 +581,7 @@ bool patcher_builtin_multianewarray(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -594,7 +610,6 @@ bool patcher_builtin_multianewarray(u1 *sp)
 
        *((ptrint *) (ra + 10 + 10 + 3 + 2)) = (ptrint) BUILTIN_multianewarray;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -605,6 +620,7 @@ bool patcher_builtin_multianewarray(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
+       *dontfillinexceptionstacktrace=false;
 
        return true;
 }
@@ -652,7 +668,7 @@ bool patcher_builtin_checkarraycast(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -681,7 +697,6 @@ bool patcher_builtin_checkarraycast(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_checkarraycast;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -692,7 +707,7 @@ bool patcher_builtin_checkarraycast(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -768,7 +783,6 @@ bool patcher_builtin_arrayinstanceof(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_arrayinstanceof;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -779,7 +793,7 @@ bool patcher_builtin_arrayinstanceof(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -821,7 +835,7 @@ bool patcher_invokestatic_special(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -845,7 +859,6 @@ bool patcher_invokestatic_special(u1 *sp)
 
        *((ptrint *) (ra + 2)) = (ptrint) m->stubroutine;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -856,7 +869,7 @@ bool patcher_invokestatic_special(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -898,7 +911,7 @@ bool patcher_invokevirtual(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -924,7 +937,6 @@ bool patcher_invokevirtual(u1 *sp)
        *((s4 *) (ra + 3 + 3)) = (s4) (OFFSET(vftbl_t, table[0]) +
                                                                   sizeof(methodptr) * m->vftblindex);
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -935,7 +947,7 @@ bool patcher_invokevirtual(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -977,7 +989,7 @@ bool patcher_invokeinterface(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=true;
                return true;
        }
 #endif
@@ -1008,7 +1020,6 @@ bool patcher_invokeinterface(u1 *sp)
        *((s4 *) (ra + 3 + 7 + 3)) =
                (s4) (sizeof(methodptr) * (m - m->class->methods));
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -1019,7 +1030,7 @@ bool patcher_invokeinterface(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -1061,7 +1072,7 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -1086,7 +1097,6 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 
        *((s4 *) (ra + 2)) = (s4) c->flags;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -1097,7 +1107,7 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -1139,7 +1149,7 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -1168,7 +1178,6 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
                (s4) (OFFSET(vftbl_t, interfacetable[0]) -
                          c->index * sizeof(methodptr*));
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -1179,7 +1188,7 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -1221,7 +1230,7 @@ bool patcher_checkcast_class(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -1247,7 +1256,6 @@ bool patcher_checkcast_class(u1 *sp)
        *((ptrint *) (ra + 2)) = (ptrint) c->vftbl;
        *((ptrint *) (ra + 10 + 7 + 7 + 3 + 2)) = (ptrint) c->vftbl;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -1258,7 +1266,7 @@ bool patcher_checkcast_class(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -1300,7 +1308,7 @@ bool patcher_instanceof_class(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
@@ -1325,7 +1333,6 @@ bool patcher_instanceof_class(u1 *sp)
 
        *((ptrint *) (ra + 2)) = (ptrint) c->vftbl;
 
-       *dontfillinexceptionstacktrace=false;
 
 #if defined(USE_THREADS)
        /* this position has been patched */
@@ -1336,7 +1343,7 @@ bool patcher_instanceof_class(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
-
+       *dontfillinexceptionstacktrace=false;
        return true;
 }
 
@@ -1379,41 +1386,14 @@ bool patcher_clinit(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
-
+               *dontfillinexceptionstacktrace=false;
                return true;
        }
 #endif
 
        /* check if the class is initialized */
-
-       if (!c->initialized) {
-               bool init;
-               {
-                       /*struct native_stackframeinfo {
-                               void *oldThreadspecificHeadValue;
-                               void **addressOfThreadspecificHead;
-                               methodinfo *method;
-                               void *beginOfJavaStackframe; only used if != 0
-                               void *returnToFromNative;
-                       }*/
-                       /* more or less the same as the above sfi setup is done in the assembler code by the prepare/remove functions*/
-                       native_stackframeinfo sfi;
-                       sfi.returnToFromNative=(void*)ra;
-                       sfi.beginOfJavaStackframe=beginJavaStack;
-                       sfi.method=0; /*internal*/
-                       sfi.addressOfThreadspecificHead=builtin_asm_get_stackframeinfo();
-                       sfi.oldThreadspecificHeadValue=*(sfi.addressOfThreadspecificHead);
-                       *(sfi.addressOfThreadspecificHead)=&sfi;
-
-                       init=initialize_class(c);
-
-                       *(sfi.addressOfThreadspecificHead)=sfi.oldThreadspecificHeadValue;
-               }
-               if (!init)
-               {
-                       return false;
-               }
-       }
+       *dontfillinexceptionstacktrace=false;
+       if (!helper_initialize_class(beginJavaStack,c,ra)) return false;
 
        /* patch back original code */
 
@@ -1425,8 +1405,10 @@ bool patcher_clinit(u1 *sp)
        o->vftbl = (vftbl_t *) 1;
 
        /* leave the monitor on the patching position */
-
+       *dontfillinexceptionstacktrace=true;
        builtin_monitorexit(o);
+       *dontfillinexceptionstacktrace=false;
+
 #endif
 
        return true;

diff --git a/src/vm/statistics.c b/src/vm/statistics.c
index b7ef1183d2cdcb65292422566c083c8cfd212f0d..670ba533fe6428331ece1c36216721d2c5c536f8 100644 (file)
--- a/src/vm/statistics.c
+++ b/src/vm/statistics.c
@@ -26,7 +26,7 @@
 
    Authors: Christian Thalinger
 
-   $Id: statistics.c 2211 2005-04-04 10:39:36Z christian $
+   $Id: statistics.c 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -144,6 +144,11 @@ int count_in_uniqueInterface_not_inlined = 0;
 int count_in_maxDepth = 0;
 int count_in_maxMethods = 0;
 
+u8 count_native_function_calls=0;
+u8 count_compiled_function_calls=0;
+u8 count_jni_callXmethod_calls=0;
+u8 count_jni_calls=0;
+
 u2 count_in_not   [512];
 /***
 int count_no_in[12] = {0,0,0,0, 0,0,0,0, 0,0,0,0};
@@ -198,6 +203,49 @@ s4 count_schedule_max_leaders = 0;
 s4 count_schedule_critical_path = 0;
 
 
+
+/* nativeinvokation ***********************************************************
+
+   increments the native invokation count by one
+       
+*******************************************************************************/
+void nativeinvokation() {
+       /*do locking here */
+       count_native_function_calls++;
+}
+
+/* compiledinvokation *********************************************************
+
+   increments the compiled invokation count by one
+       
+*******************************************************************************/
+void compiledinvokation() {
+       /* do locking here*/
+       count_compiled_function_calls++;
+}
+
+
+/* jnicallXmethodinvokation ***************************************************
+
+   increments the jni CallXMethod invokation count by one
+       
+*******************************************************************************/
+void jnicallXmethodnvokation() {
+       /*do locking here */
+       count_jni_callXmethod_calls++;
+}
+
+/* jniinvokation *************************************************************
+
+   increments the jni overall  invokation count by one
+       
+*******************************************************************************/
+void jniinvokation() {
+       /*do locking here */
+       count_jni_calls++;
+}
+
+
 /* getcputime *********************************** ******************************
 
    Returns the used CPU time in microseconds
@@ -618,6 +666,18 @@ void print_stats()
         log_text(logtext);
         sprintf(logtext, "Length of critical path:      %7d\n", count_schedule_critical_path);
         log_text(logtext);
+
+
+       /* call statistics */
+       log_text("Function call statistics:");
+       sprintf(logtext,"Number of native function invokations:           %ld", count_native_function_calls);
+       log_text(logtext);
+       sprintf(logtext,"Number of compiled function invokations:         %ld", count_compiled_function_calls);
+       log_text(logtext);
+       sprintf(logtext,"Number of jni->CallXMethod function invokations: %ld", count_jni_callXmethod_calls);
+       log_text(logtext);
+       sprintf(logtext,"Overall number of jni invokations:               %ld", count_jni_calls);
+       log_text(logtext);
 }
 
 

diff --git a/src/vm/statistics.h b/src/vm/statistics.h
index 5b02620fb0f51961bc3507b3c13bfa0a96a2e45e..2575fb822c2e9691940056e3ea0d7e69e53ca40d 100644 (file)
--- a/src/vm/statistics.h
+++ b/src/vm/statistics.h
@@ -26,7 +26,7 @@
 
    Authors: Christian Thalinger
 
-   $Id: statistics.h 2211 2005-04-04 10:39:36Z christian $
+   $Id: statistics.h 2424 2005-04-30 13:45:06Z jowenn $
 
 */
 
@@ -183,6 +183,25 @@ void print_times();
 void print_stats();
 
 void mem_usagelog(bool givewarnings);
+
+
+void nativeinvokation();
+void compiledinvokation();
+void jnicallXmethodnvokation();
+void jniinvokation();
+
+
+#if defined(STATISTICS)
+#define STATS(x) \
+       { \
+               if (opt_stat) \
+                       x \
+       }
+#else
+#define STATS(x)
+#endif
+
+
  
 #endif /* _STATISTICS_H */