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
 
             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/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;
 
 /* 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;
 
 static jclass ihmclass = NULL;
 static jmethodID removemid = NULL;
 

+#define JWCLINITDEBUG(x)
+

 
 /********************* accessing instance-fields **********************************/
 
 
 /********************* 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); */
 
        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),
        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;
 
        jni_callblock *blk;
        jint ret;
 

+       STATS(jniinvokation();)
+

         /*
         log_text("JNI-Call: CallObjectMethodV");
         utf_display(methodID->name);
         /*
         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); */
        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),
        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;
 
        jni_callblock *blk;
        jlong ret;
 

+       STATS(jniinvokation();)
+

 /*     
         log_text("JNI-Call: CallObjectMethodV");
         utf_display(methodID->name);
 /*     
         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); */
        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),
        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;
 
        jni_callblock *blk;
        jdouble ret;
 

+       STATS(jniinvokation();)
+

         /*
         log_text("JNI-Call: CallObjectMethodV");
         utf_display(methodID->name);
         /*
         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); */
        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),
        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;
 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++) {
 /*     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 */
 jint GetVersion(JNIEnv *env)
 {
        /* GNU classpath currently supports JNI 1.2 */

-
+       STATS(jniinvokation();)

        return JNI_VERSION_1_2;
 }
 
        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;
 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,
 
        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;  
 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;
   
        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!!!");
 jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
 {
        log_text("JNI-Call: FromReflectedMethod: IMPLEMENT ME!!!");

+       STATS(jniinvokation();)

 
        return 0;
 }
 
        return 0;
 }


@@ -655,6 +672,7 @@ jmethodID FromReflectedMethod(JNIEnv* env, jobject method)
 jclass GetSuperclass(JNIEnv *env, jclass sub)
 {
        classinfo *c;
 jclass GetSuperclass(JNIEnv *env, jclass sub)
 {
        classinfo *c;

+       STATS(jniinvokation();)

 
        c = ((classinfo *) sub)->super.cls;
 
 
        c = ((classinfo *) sub)->super.cls;
 


@@ -675,6 +693,7 @@ jclass GetSuperclass(JNIEnv *env, jclass sub)
 
 jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
 {
 
 jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
 {

+       STATS(jniinvokation();)

        return Java_java_lang_VMClass_isAssignableFrom(env,
                                                                                                   NULL,
                                                                                                   (java_lang_Class *) sup,
        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!!!");
 jobject ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
 {
        log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!!!");

-
+       STATS(jniinvokation();)

        return NULL;
 }
 
        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;
 jint Throw(JNIEnv *env, jthrowable obj)
 {
        *exceptionptr = (java_objectheader *) obj;

+       STATS(jniinvokation();)

 
        return JNI_OK;
 }
 
        return JNI_OK;
 }


@@ -718,6 +738,7 @@ jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
 {
        java_lang_Throwable *o;
        java_lang_String    *s;
 {
        java_lang_Throwable *o;
        java_lang_String    *s;

+       STATS(jniinvokation();)

 
        s = (java_lang_String *) javastring_new_char(msg);
 
 
        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)
 {
 
 jthrowable ExceptionOccurred(JNIEnv *env)
 {

+       STATS(jniinvokation();)

        return (jthrowable) *exceptionptr;
 }
 
        return (jthrowable) *exceptionptr;
 }
 


@@ -761,6 +783,7 @@ void ExceptionDescribe(JNIEnv *env)
 {
        java_objectheader *e;
        methodinfo        *m;
 {
        java_objectheader *e;
        methodinfo        *m;

+       STATS(jniinvokation();)

 
        e = *exceptionptr;
 
 
        e = *exceptionptr;
 


@@ -797,6 +820,7 @@ void ExceptionDescribe(JNIEnv *env)
 
 void ExceptionClear(JNIEnv *env)
 {
 
 void ExceptionClear(JNIEnv *env)
 {

+       STATS(jniinvokation();)

        *exceptionptr = NULL;
 }
 
        *exceptionptr = NULL;
 }
 


@@ -810,6 +834,7 @@ void ExceptionClear(JNIEnv *env)
 
 void FatalError(JNIEnv *env, const char *msg)
 {
 
 void FatalError(JNIEnv *env, const char *msg)
 {

+       STATS(jniinvokation();)

        throw_cacao_exception_exit(string_java_lang_InternalError, msg);
 }
 
        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!");
 jint PushLocalFrame(JNIEnv* env, jint capacity)
 {
        log_text("JNI-Call: PushLocalFrame: IMPLEMENT ME!");

+       STATS(jniinvokation();)

 
        return 0;
 }
 
        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!");
 jobject PopLocalFrame(JNIEnv* env, jobject result)
 {
        log_text("JNI-Call: PopLocalFrame: IMPLEMENT ME!");

+       STATS(jniinvokation();)

 
        return NULL;
 }
 
        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!");
 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)
 {
 
 jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
 {

+       STATS(jniinvokation();)

        return (ref1 == ref2);
 }
 
        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!");
 jobject NewLocalRef(JNIEnv *env, jobject ref)
 {
        log_text("JNI-Call: NewLocalRef: IMPLEMENT ME!");

-
+       STATS(jniinvokation();)

        return ref;
 }
 
        return ref;
 }
 


@@ -879,6 +909,7 @@ jobject NewLocalRef(JNIEnv *env, jobject ref)
 
 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
 {
 
 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
 {

+       STATS(jniinvokation();)

        return 0; /* return 0 on success */
 }
 
        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;
 jobject AllocObject(JNIEnv *env, jclass clazz)
 {
        java_objectheader *o;

+       STATS(jniinvokation();)

 
        if ((clazz->flags & ACC_INTERFACE) || (clazz->flags & ACC_ABSTRACT)) {
                *exceptionptr =
 
        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;
        int argcount=methodID->parseddesc->paramcount;
        int i;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 #ifdef arglimit
        if (argcount > 3) {
 
 #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");
 jobject NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
 {
        log_text("JNI-Call: NewObjectV");

+       STATS(jniinvokation();)

 
        return NULL;
 }
 
        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");
 jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
 {
        log_text("JNI-Call: NewObjectA");

+       STATS(jniinvokation();)

 
        return NULL;
 }
 
        return NULL;
 }


@@ -993,6 +1028,7 @@ jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
 jclass GetObjectClass(JNIEnv *env, jobject obj)
 {
        classinfo *c;
 jclass GetObjectClass(JNIEnv *env, jobject obj)
 {
        classinfo *c;

+       STATS(jniinvokation();)

        
        if (!obj || !obj->vftbl)
                return NULL;
        
        if (!obj || !obj->vftbl)
                return NULL;


@@ -1011,6 +1047,8 @@ jclass GetObjectClass(JNIEnv *env, jobject obj)
 
 jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
 {
 
 jboolean IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
 {

+       STATS(jniinvokation();)
+

        return Java_java_lang_VMClass_isInstance(env,
                                                                                         NULL,
                                                                                         (java_lang_Class *) clazz,
        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");
 jfieldID FromReflectedField(JNIEnv* env, jobject field)
 {
        log_text("JNI-Call: FromReflectedField");

+       STATS(jniinvokation();)

 
        return 0;
 }
 
        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");
 jobject ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
 {
        log_text("JNI-Call: ToReflectedMethod");

+       STATS(jniinvokation();)

 
        return NULL;
 }
 
        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;
 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), 
 
        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;
 {
        jobject ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallObjectMethod");*/
 
 
 /*     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)
 {
 
 jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 {

+       STATS(jniinvokation();)

        return callObjectMethod(obj,methodID,args);
 }
 
        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");
 jobject CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 {
        log_text("JNI-Call: CallObjectMethodA");

+       STATS(jniinvokation();)

 
        return NULL;
 }
 
        return NULL;
 }


@@ -1105,6 +1149,7 @@ jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jboolean ret;
        va_list vaargs;
 {
        jboolean ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallBooleanMethod");*/
 
 
 /*     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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallBooleanMethodA");
 
        return 0;


@@ -1132,6 +1180,7 @@ jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jbyte ret;
        va_list vaargs;
 {
        jbyte ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallVyteMethod");*/
 
 
 /*     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");*/
 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);
 }
 
        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");
 jbyte CallByteMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {
        log_text("JNI-Call: CallByteMethodA");

+       STATS(jniinvokation();)

 
        return 0;
 }
 
        return 0;
 }


@@ -1161,6 +1213,7 @@ jchar CallCharMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jchar ret;
        va_list vaargs;
 {
        jchar ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallCharMethod");*/
 
 
 /*     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)
 {
 
 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);
 }
 /*     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)
 {
 
 jchar CallCharMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)
+

        log_text("JNI-Call: CallCharMethodA");
 
        return 0;
        log_text("JNI-Call: CallCharMethodA");
 
        return 0;


@@ -1191,6 +1248,7 @@ jshort CallShortMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jshort ret;
        va_list vaargs;
 {
        jshort ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallShortMethod");*/
 
 
 /*     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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallShortMethodA");
 
        return 0;


@@ -1221,6 +1281,7 @@ jint CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jint ret;
        va_list vaargs;
 {
        jint ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        va_start(vaargs,methodID);
        ret = callIntegerMethod(obj, get_virtual(obj, methodID),PRIMITIVETYPE_INT, vaargs);
 
        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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallIntMethodA");
 
        return 0;


@@ -1249,6 +1312,7 @@ jlong CallLongMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jlong ret;
        va_list vaargs;
 {
        jlong ret;
        va_list vaargs;

+       STATS(jniinvokation();)

        
        va_start(vaargs,methodID);
        ret = callLongMethod(obj,get_virtual(obj, methodID),vaargs);
        
        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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallLongMethodA");
 
        return 0;


@@ -1278,6 +1344,7 @@ jfloat CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
        jfloat ret;
        va_list vaargs;
 
        jfloat ret;
        va_list vaargs;
 

+       STATS(jniinvokation();)

 /*     log_text("JNI-Call: CallFloatMethod");*/
 
        va_start(vaargs,methodID);
 /*     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)
 {
 
 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);
 }
        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)
 {
 
 jfloat CallFloatMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallFloatMethodA");
 
        return 0;
        log_text("JNI-Call: CallFloatMethodA");
 
        return 0;


@@ -1308,6 +1377,7 @@ jdouble CallDoubleMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
 {
        jdouble ret;
        va_list vaargs;
 {
        jdouble ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallDoubleMethod");*/
 
 
 /*     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)
 {
 
 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);
 }
        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)
 {
 
 jdouble CallDoubleMethodA(JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallDoubleMethodA");
        return 0;
 }
        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;
 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);
 
        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");
 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)
 {
        (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");
 }
 
        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, ...)
 {
 
 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualObjectMethod");
 
        return NULL;
        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)
 {
 
 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualObjectMethodV");
 
        return NULL;
        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)
 {
 
 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualObjectMethodA");
 
        return NULL;
        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;
 {
        jboolean ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
 /*     log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
 
 
 /*     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)
 {
 
 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);
 }
 /*     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)
 {
 
 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualBooleanMethodA");
 
        return 0;
        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;
 
        jbyte ret;
        va_list vaargs;
 

+       STATS(jniinvokation();)

 /*     log_text("JNI-Call: CallNonvirutalByteMethod");*/
 
        va_start(vaargs,methodID);
 /*     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)
 {
 
 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);
 
        /*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)
 {
 
 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualByteMethodA");
 
        return 0;
        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;
 
        jchar ret;
        va_list vaargs;
 

+       STATS(jniinvokation();)

 /*     log_text("JNI-Call: CallNonVirtualCharMethod");*/
 
        va_start(vaargs,methodID);
 /*     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)
 {
 
 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);
 }
        /*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)
 {
 
 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualCharMethodA");
 
        return 0;
        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;
 {
        jshort ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
 
 
        /*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)
 {
 
 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);
 }
        /*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)
 {
 
 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualShortMethodA");
 
        return 0;
        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;
 
         jint ret;
         va_list vaargs;

+       STATS(jniinvokation();)

 
        /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
 
 
        /*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)
 {
 
 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);
 }
        /*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)
 {
 
 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualIntMethodA");
 
        return 0;
        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, ...)
 {
 
 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualLongMethod");
 
        return 0;
        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)
 {
 
 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualLongMethodV");
 
        return 0;
        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)
 {
 
 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualLongMethodA");
 
        return 0;
        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;
 {
        jfloat ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
 
 
        /*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)
 {
 
 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);
 }
        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)
 {
 
 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualFloatMethodA");
 
        return 0;
        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;
 {
        jdouble ret;
        va_list vaargs;

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualDoubleMethod");
 
        va_start(vaargs,methodID);
        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)
 {
 
 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);
 }
 /*     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)
 {
 
 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualDoubleMethodA");
 
        return 0;
        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;
 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 {
         va_list vaargs;

+       STATS(jniinvokation();)

 
 /*      log_text("JNI-Call: CallNonvirtualVoidMethod");*/
 
 
 /*      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");*/
 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);
 
 
         (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)
 {
 
 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallNonvirtualVoidMethodA");
 }
 
        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;
 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig) 
 {
        jfieldID f;

+       STATS(jniinvokation();)

 
 /*     log_text("========================= searching for:");
        log_text(name);
 
 /*     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);
 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:");
 
     if (!id) {
        log_text("class:");


@@ -1722,107 +1829,125 @@ jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
 
 
 /*     return dbg;*/
 
 
 /*     return dbg;*/

+       STATS(jniinvokation();)

 
        return getField(obj,jobject,fieldID);
 }
 
 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
 {
 
        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)
 {
        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)
 {
                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)
 {
        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)
 {
        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)
 {
        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)
 {
        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)
 {
        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)
 {
        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)
 {
         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)
 {
         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)
 {
         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)
 {
         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)
 {
         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)
 {
         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)
 {
         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)
 {
         setField(obj,jfloat,fieldID,val);
 }
 
 
 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
 {

+       STATS(jniinvokation();)

         setField(obj,jdouble,fieldID,val);
 }
 
         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;
 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),
 
        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;
 {
        jobject ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /* log_text("JNI-Call: CallStaticObjectMethod");*/
 
 
        /* 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)
 {
 
 jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {

+       STATS(jniinvokation();)

        /* log_text("JNI-Call: CallStaticObjectMethodV"); */
        
        return callObjectMethod(0,methodID,args);
        /* 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)
 {
 
 jobject CallStaticObjectMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticObjectMethodA");
 
        return NULL;
        log_text("JNI-Call: CallStaticObjectMethodA");
 
        return NULL;


@@ -1883,6 +2012,7 @@ jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID,
 {
        jboolean ret;
        va_list vaargs;
 {
        jboolean ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        va_start(vaargs, methodID);
        ret = (jboolean) callIntegerMethod(0, methodID, PRIMITIVETYPE_BOOLEAN, vaargs);
 
        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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallStaticBooleanMethodA");
 
        return 0;


@@ -1910,6 +2042,7 @@ jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jbyte ret;
        va_list vaargs;
 {
        jbyte ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticByteMethod");*/
 
 
        /*      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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallStaticByteMethodA");
 
        return 0;


@@ -1939,6 +2074,7 @@ jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jchar ret;
        va_list vaargs;
 {
        jchar ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticByteMethod");*/
 
 
        /*      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)
 {
 
 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)
 {
        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;
        log_text("JNI-Call: CallStaticCharMethodA");
 
        return 0;


@@ -1969,6 +2107,7 @@ jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jshort ret;
        va_list vaargs;
 {
        jshort ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticByteMethod");*/
 
 
        /*      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)
 {
 
 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);
 }
        /*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)
 {
 
 jshort CallStaticShortMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticShortMethodA");
 
        return 0;
        log_text("JNI-Call: CallStaticShortMethodA");
 
        return 0;


@@ -2000,6 +2141,7 @@ jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jint ret;
        va_list vaargs;
 {
        jint ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticIntMethod");*/
 
 
        /*      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)
 {
 
 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);
        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)
 {
 
 jint CallStaticIntMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticIntMethodA");
 
        return 0;
        log_text("JNI-Call: CallStaticIntMethodA");
 
        return 0;


@@ -2032,6 +2176,7 @@ jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jlong ret;
        va_list vaargs;
 {
        jlong ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticLongMethod");*/
 
 
        /*      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)
 {
 
 jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticLongMethodV");
        
        return callLongMethod(0,methodID,args);
        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)
 {
 
 jlong CallStaticLongMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticLongMethodA");
 
        return 0;
        log_text("JNI-Call: CallStaticLongMethodA");
 
        return 0;


@@ -2064,6 +2211,7 @@ jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 {
        jfloat ret;
        va_list vaargs;
 {
        jfloat ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticLongMethod");*/
 
 
        /*      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)
 {
 
 jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 {

+       STATS(jniinvokation();)

 
        return callFloatMethod(0, methodID, args, PRIMITIVETYPE_FLOAT);
 
 
        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)
 {
 
 jfloat CallStaticFloatMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticFloatMethodA");
 
        return 0;
        log_text("JNI-Call: CallStaticFloatMethodA");
 
        return 0;


@@ -2096,6 +2246,7 @@ jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ..
 {
        jdouble ret;
        va_list vaargs;
 {
        jdouble ret;
        va_list vaargs;

+       STATS(jniinvokation();)

 
        /*      log_text("JNI-Call: CallStaticDoubleMethod");*/
 
 
        /*      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)
 {
 
 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);
        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)
 {
 
 jdouble CallStaticDoubleMethodA(JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticDoubleMethodA");
 
        return 0;
        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;
 void CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...)
 {
        va_list vaargs;

+       STATS(jniinvokation();)

 
        va_start(vaargs, methodID);
        (void) callIntegerMethod(0, methodID, TYPE_VOID, vaargs);
 
        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");
 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)
 {
        (void)callIntegerMethod(0, methodID, TYPE_VOID, args);
 }
 
 
 void CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: CallStaticVoidMethodA");
 }
 
        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;
 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),
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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)
 {
 
 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;
 
        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;
        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);
        
        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;
        java_chararray *a;
        u4 i;
        u2 *stringbuffer;

+       STATS(jniinvokation();)

        
        if (!s) return NULL;
 
        
        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);
 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
 {      
        jchar *jc=javastring_tou2(str);

+       STATS(jniinvokation();)

 
        if (jc) {
                if (isCopy) *isCopy=JNI_TRUE;
 
        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)
 {
 
 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);
 }
        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)
 {
 
 jstring NewStringUTF(JNIEnv *env, const char *bytes)
 {

+       STATS(jniinvokation();)

     return (jstring) javastring_new(utf_new_char(bytes));
 }
 
     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;
 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); 
 }
 
     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;
 const char* GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy)
 {
     utf *u;

+       STATS(jniinvokation();)

 
     u = javastring_toutf((java_lang_String *) string, false);
 
 
     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)
 {
 
 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*/
        /*
     /*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)
 {
 
 jsize GetArrayLength(JNIEnv *env, jarray array)
 {

+       STATS(jniinvokation();)
+

     return array->size;
 }
 
     return array->size;
 }
 


@@ -2512,6 +2719,7 @@ jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobj
 {
        java_objectarray *oa;
        s4 i;
 {
        java_objectarray *oa;
        s4 i;

+       STATS(jniinvokation();)

 
        if (length < 0) {
                *exceptionptr = new_negativearraysizeexception();
 
        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;
 jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index)
 {
     jobject j = NULL;

+       STATS(jniinvokation();)

 
     if (index < array->header.size)    
                j = array->data[index];
 
     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)
 {
 
 void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val)
 {

+       STATS(jniinvokation();)

     if (index >= array->header.size)
                *exceptionptr = new_exception(string_java_lang_ArrayIndexOutOfBoundsException);
 
     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;
 jbooleanArray NewBooleanArray(JNIEnv *env, jsize len)
 {
        java_booleanarray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jbyteArray NewByteArray(JNIEnv *env, jsize len)
 {
        java_bytearray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jcharArray NewCharArray(JNIEnv *env, jsize len)
 {
        java_chararray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jshortArray NewShortArray(JNIEnv *env, jsize len)
 {
        java_shortarray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jintArray NewIntArray(JNIEnv *env, jsize len)
 {
        java_intarray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jlongArray NewLongArray(JNIEnv *env, jsize len)
 {
        java_longarray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jfloatArray NewFloatArray(JNIEnv *env, jsize len)
 {
        java_floatarray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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;
 jdoubleArray NewDoubleArray(JNIEnv *env, jsize len)
 {
        java_doublearray *j;

+       STATS(jniinvokation();)

 
     if (len < 0) {
                *exceptionptr = new_exception(string_java_lang_NegativeArraySizeException);
 
     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)
 {
 
 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

     if (isCopy) *isCopy = JNI_FALSE;
     return array->data;
 }
     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)
 {
 
 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
 {

+       STATS(jniinvokation();)

     /* empty */
 }
 
 
 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
 {
     /* empty */
 }
 
 
 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
 {

+       STATS(jniinvokation();)

     /* empty */
 }
 
     /* empty */
 }
 


@@ -2759,36 +2987,42 @@ void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint
 
 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
 {
 
 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
 {

+       STATS(jniinvokation();)

     /* empty */
 }
 
 
 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
 {
     /* empty */
 }
 
 
 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
 {

+       STATS(jniinvokation();)

     /* empty */
 }
 
 
 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
 {
     /* empty */
 }
 
 
 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
 {

+       STATS(jniinvokation();)

     /* empty */
 }
 
 
 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
 {
     /* empty */
 }
 
 
 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
 {

+       STATS(jniinvokation();)

     /* empty */
 }
 
 
 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
 {
     /* 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)
 {
     /* 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 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);
 
     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)
 {
 
 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
 {

+       STATS(jniinvokation();)

     log_text("JNI-Call: RegisterNatives");
     return 0;
 }
     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)
 {
 
 jint UnregisterNatives (JNIEnv* env, jclass clazz)
 {

+       STATS(jniinvokation();)

     log_text("JNI-Call: UnregisterNatives");
     return 0;
 }
     log_text("JNI-Call: UnregisterNatives");
     return 0;
 }


@@ -2976,6 +3227,7 @@ jint UnregisterNatives (JNIEnv* env, jclass clazz)
 
 jint MonitorEnter(JNIEnv *env, jobject obj)
 {
 
 jint MonitorEnter(JNIEnv *env, jobject obj)
 {

+       STATS(jniinvokation();)

        if (!obj) {
                *exceptionptr = new_nullpointerexception();
                return JNI_ERR;
        if (!obj) {
                *exceptionptr = new_nullpointerexception();
                return JNI_ERR;


@@ -3001,6 +3253,7 @@ jint MonitorEnter(JNIEnv *env, jobject obj)
 
 jint MonitorExit(JNIEnv *env, jobject obj)
 {
 
 jint MonitorExit(JNIEnv *env, jobject obj)
 {

+       STATS(jniinvokation();)

        if (!obj) {
                *exceptionptr = new_nullpointerexception();
                return JNI_ERR;
        if (!obj) {
                *exceptionptr = new_nullpointerexception();
                return JNI_ERR;


@@ -3026,6 +3279,7 @@ jint MonitorExit(JNIEnv *env, jobject obj)
 
 jint GetJavaVM(JNIEnv *env, JavaVM **vm)
 {
 
 jint GetJavaVM(JNIEnv *env, JavaVM **vm)
 {

+       STATS(jniinvokation();)

     *vm = &ptr_jvm;
 
        return 0;
     *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)
 {
 
 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)
 {
        log_text("JNI-Call: GetStringRegion");
 }
 
 
 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: GetStringUTFRegion");
 }
 
        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)
 {
 
 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

        java_objectheader *s = (java_objectheader*) array;
        arraydescriptor *desc = s->vftbl->arraydesc;
 
        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)
 {
 
 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: ReleasePrimitiveArrayCritical");
 
        /* empty */
        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)
 {
 
 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: GetStringCritical");
 
        return GetStringChars(env,string,isCopy);
        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)
 {
 
 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: ReleaseStringCritical");
 
        ReleaseStringChars(env,string,cstring);
        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)
 {
 
 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: NewWeakGlobalRef");
 
        return obj;
        log_text("JNI-Call: NewWeakGlobalRef");
 
        return obj;


@@ -3093,6 +3354,7 @@ jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
 
 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
 {
 
 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
 {

+       STATS(jniinvokation();)

        log_text("JNI-Call: DeleteWeakGlobalRef");
 
        /* empty */
        log_text("JNI-Call: DeleteWeakGlobalRef");
 
        /* empty */


@@ -3106,6 +3368,7 @@ jobject NewGlobalRef(JNIEnv* env, jobject lobj)
        jobject refcount;
        jint val;
        jobject newval;
        jobject refcount;
        jint val;
        jobject newval;

+       STATS(jniinvokation();)

 
        MonitorEnter(env, *global_ref_table);
        
 
        MonitorEnter(env, *global_ref_table);
        


@@ -3131,6 +3394,7 @@ void DeleteGlobalRef(JNIEnv* env, jobject gref)
 {
        jobject refcount;
        jint val;
 {
        jobject refcount;
        jint val;

+       STATS(jniinvokation();)

 
        MonitorEnter(env, *global_ref_table);
        refcount = CallObjectMethod(env, *global_ref_table, getmid, gref);
 
        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)
 {
 
 jboolean ExceptionCheck(JNIEnv *env)
 {

+       STATS(jniinvokation();)

        return *exceptionptr ? JNI_TRUE : JNI_FALSE;
 }
 
        return *exceptionptr ? JNI_TRUE : JNI_FALSE;
 }
 


@@ -3185,6 +3450,7 @@ jboolean ExceptionCheck(JNIEnv *env)
 
 jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
 {
 
 jobject NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
 {

+       STATS(jniinvokation();)

        log_text("NewDirectByteBuffer: IMPLEMENT ME!");
 
        return NULL;
        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)
 {
 
 void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
 {

+       STATS(jniinvokation();)

        log_text("GetDirectBufferAddress: IMPLEMENT ME!");
 
        return NULL;
        log_text("GetDirectBufferAddress: IMPLEMENT ME!");
 
        return NULL;


@@ -3215,6 +3482,7 @@ void *GetDirectBufferAddress(JNIEnv *env, jobject buf)
 
 jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
 {
 
 jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
 {

+       STATS(jniinvokation();)

        log_text("GetDirectBufferCapacity: IMPLEMENT ME!");
 
        return 0;
        log_text("GetDirectBufferCapacity: IMPLEMENT ME!");
 
        return 0;


@@ -3223,6 +3491,7 @@ jlong GetDirectBufferCapacity(JNIEnv* env, jobject buf)
 
 jint DestroyJavaVM(JavaVM *vm)
 {
 
 jint DestroyJavaVM(JavaVM *vm)
 {

+       STATS(jniinvokation();)

        log_text("DestroyJavaVM called");
 
        return 0;
        log_text("DestroyJavaVM called");
 
        return 0;


@@ -3231,15 +3500,15 @@ jint DestroyJavaVM(JavaVM *vm)
 
 jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
 {
 
 jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
 {

+       STATS(jniinvokation();)

        log_text("AttachCurrentThread called");
        log_text("AttachCurrentThread called");

-#if 0
+

 #if !defined(HAVE___THREAD)
 #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
 #else
        #error "No idea how to implement that. Perhaps Stefan knows"
 #endif

-#endif
+

        *env = &ptr_env;
        return 0;
 }
        *env = &ptr_env;
        return 0;
 }


@@ -3247,6 +3516,7 @@ jint AttachCurrentThread(JavaVM *vm, void **env, void *thr_args)
 
 jint DetachCurrentThread(JavaVM *vm)
 {
 
 jint DetachCurrentThread(JavaVM *vm)
 {

+       STATS(jniinvokation();)

        log_text("DetachCurrentThread called");
 
        return 0;
        log_text("DetachCurrentThread called");
 
        return 0;


@@ -3255,6 +3525,7 @@ jint DetachCurrentThread(JavaVM *vm)
 
 jint GetEnv(JavaVM *vm, void **env, jint version)
 {
 
 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;
        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)
 {
 
 jint AttachCurrentThreadAsDaemon(JavaVM *vm, void **par1, void *par2)
 {

+       STATS(jniinvokation();)

        log_text("AttachCurrentThreadAsDaemon called");
 
        return 0;
        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
 
    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*/
 
        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*/
                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*/
 
        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*/
                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*/
 
        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*/
                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*/
 
        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*/
                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*/
 
        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*/
                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*/
 
        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*/
                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*/
 
        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*/
                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*/
 
        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*/
                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
 
    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);
 
        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;
 
        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 */
        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);
                /* 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
 
             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"
 
 #include "vm/stringlocal.h"
 #include "vm/jit/asmpart.h"
 

+#undef JWDEBUG

 
 /* private functions **********************************************************/
 
 
 /* private functions **********************************************************/
 


@@ -91,6 +92,9 @@ bool initialize_class(classinfo *c)
                return true;
        }
 
                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;
 
        /* this initalizing run begins NOW */
        c->initializing = true;
 


@@ -102,6 +106,10 @@ bool initialize_class(classinfo *c)
        if (r)
                c->initialized = true;
 
        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;
 
        /* 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);
                        }
                                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;
                }
                        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) {
 
        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 ");
                        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).   
 
    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"
 
 #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 *********************************/
 
 
 /* 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;
 void codegen_insertmethod(functionptr startpc, functionptr endpc)
 {
        methodtree_element *mte;


@@ -675,6 +663,13 @@ functionptr codegen_findmethod(functionptr pc)
 #endif
 #endif
                {
 #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,
                        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
 
    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);
 
        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
        }
 
 #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
 
 
    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):");
                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);}
                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 {
 #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");
                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;       
                                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--;
                }
        }
        ent--;


@@ -207,6 +215,14 @@ void  cacao_stacktrace_fillInStackTrace(void **target,CacaoStackTraceCollector c
        buffer.full=0;
 #ifdef JWDEBUG
        log_text("entering cacao_stacktrace_fillInStacktrace");
        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()))));
 #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;
                                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) {
                                        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__)
                                                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;
                                        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
 #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++) {
         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);
                 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;
                 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;
 }
 
         *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
 
             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                         */
        .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              */
        .quad   0                         /* line number table  start             */
        .quad   0                         /* line number table  size              */

+        .long   0

        .long   0                         /* fltsave                              */
        .long   0                         /* intsave                              */
        .long   0                         /* isleaf                               */
        .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
 
    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/jit/x86_64/types.h"
 #include "vm/jit/x86_64/asmoffsets.h"
 #include "vm/jit/helper.h"

+#include "vm/statistics.h"

 
 /* register descripton - array ************************************************/
 
 
 /* register descripton - array ************************************************/
 


@@ -89,7 +90,11 @@ static int nregdescfloat[] = {
 #include "vm/jit/lsra.inc"
 #endif
 
 #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)
 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.                                                 */
 
        /* 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 */
                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);
                }
 
                                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++)
                /* 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 */
 
 /* 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)
 #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);
        }
 
                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);
                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);
 
        /* 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);
 
        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*/
 
 #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 */
 
 #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);
 
 
        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);
                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);
 
                        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      */
 
        /* 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:
 
 
    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"
 
 
 #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:
 /* patcher_get_putstatic *******************************************************
 
    Machine code:


@@ -87,7 +120,7 @@ bool patcher_get_putstatic(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -98,40 +131,11 @@ bool patcher_get_putstatic(u1 *sp)
                *dontfillinexceptionstacktrace=false;
                return false;
        }
                *dontfillinexceptionstacktrace=false;
                return false;
        }

-

        /* check if the field's class is initialized */
 
        *dontfillinexceptionstacktrace=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 */
 
 
        /* patch back original code */
 


@@ -157,7 +161,10 @@ bool patcher_get_putstatic(u1 *sp)
 
        /* leave the monitor on the patching position */
 
 
        /* leave the monitor on the patching position */
 

+       *dontfillinexceptionstacktrace=true;

        builtin_monitorexit(o);
        builtin_monitorexit(o);

+       *dontfillinexceptionstacktrace=false;
+

 #endif
 
        return true;
 #endif
 
        return true;


@@ -204,7 +211,7 @@ bool patcher_get_putfield(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -244,7 +251,6 @@ bool patcher_get_putfield(u1 *sp)
                        *((u4 *) (ra + 3)) = (u4) (fi->offset);
        }
 
                        *((u4 *) (ra + 3)) = (u4) (fi->offset);
        }
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #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);
        /* leave the monitor on the patching position */
 
        builtin_monitorexit(o);

+

 #endif
 #endif

+       *dontfillinexceptionstacktrace=false;

 
        return true;
 }
 
        return true;
 }


@@ -331,7 +339,6 @@ bool patcher_putfieldconst(u1 *sp)
                *((u4 *) (ra + 3)) = (u4) (fi->offset);
        }
 
                *((u4 *) (ra + 3)) = (u4) (fi->offset);
        }
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -342,6 +349,7 @@ bool patcher_putfieldconst(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

+       *dontfillinexceptionstacktrace=false;

 
        return true;
 }
 
        return true;
 }


@@ -365,13 +373,14 @@ bool patcher_builtin_new(u1 *sp)
        u8                 mcode;
        constant_classref *cr;
        classinfo         *c;
        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));
        /* 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 */
 
 
        /* calculate and set the new return address */
 


@@ -389,7 +398,7 @@ bool patcher_builtin_new(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -398,9 +407,14 @@ bool patcher_builtin_new(u1 *sp)
 
        if (!(c = helper_resolve_classinfo(cr))) {
                *dontfillinexceptionstacktrace=false;
 
        if (!(c = helper_resolve_classinfo(cr))) {
                *dontfillinexceptionstacktrace=false;

+               /*should here be an monitorexit too ?*/

                return false;
        }
 
                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;
        /* 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;
 
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_new;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #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 */
        o->vftbl = (vftbl_t *) 1;
 
        /* leave the monitor on the patching position */

-
+       *dontfillinexceptionstacktrace=true;

        builtin_monitorexit(o);
        builtin_monitorexit(o);

+       *dontfillinexceptionstacktrace=false;
+

 #endif
 
        return true;
 #endif
 
        return true;


@@ -476,7 +491,7 @@ bool patcher_builtin_newarray(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -505,7 +520,6 @@ bool patcher_builtin_newarray(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_newarray;
 
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_newarray;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #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);
        /* leave the monitor on the patching position */
 
        builtin_monitorexit(o);

+

 #endif
 #endif

+       *dontfillinexceptionstacktrace=false;

 
        return true;
 }
 
        return true;
 }


@@ -565,7 +581,7 @@ bool patcher_builtin_multianewarray(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -594,7 +610,6 @@ bool patcher_builtin_multianewarray(u1 *sp)
 
        *((ptrint *) (ra + 10 + 10 + 3 + 2)) = (ptrint) BUILTIN_multianewarray;
 
 
        *((ptrint *) (ra + 10 + 10 + 3 + 2)) = (ptrint) BUILTIN_multianewarray;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -605,6 +620,7 @@ bool patcher_builtin_multianewarray(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

+       *dontfillinexceptionstacktrace=false;

 
        return true;
 }
 
        return true;
 }


@@ -652,7 +668,7 @@ bool patcher_builtin_checkarraycast(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -681,7 +697,6 @@ bool patcher_builtin_checkarraycast(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_checkarraycast;
 
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_checkarraycast;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -692,7 +707,7 @@ bool patcher_builtin_checkarraycast(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -768,7 +783,6 @@ bool patcher_builtin_arrayinstanceof(u1 *sp)
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_arrayinstanceof;
 
 
        *((ptrint *) (ra + 10 + 2)) = (ptrint) BUILTIN_arrayinstanceof;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -779,7 +793,7 @@ bool patcher_builtin_arrayinstanceof(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -821,7 +835,7 @@ bool patcher_invokestatic_special(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -845,7 +859,6 @@ bool patcher_invokestatic_special(u1 *sp)
 
        *((ptrint *) (ra + 2)) = (ptrint) m->stubroutine;
 
 
        *((ptrint *) (ra + 2)) = (ptrint) m->stubroutine;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -856,7 +869,7 @@ bool patcher_invokestatic_special(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -898,7 +911,7 @@ bool patcher_invokevirtual(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                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);
 
        *((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 */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -935,7 +947,7 @@ bool patcher_invokevirtual(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -977,7 +989,7 @@ bool patcher_invokeinterface(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=true;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -1008,7 +1020,6 @@ bool patcher_invokeinterface(u1 *sp)
        *((s4 *) (ra + 3 + 7 + 3)) =
                (s4) (sizeof(methodptr) * (m - m->class->methods));
 
        *((s4 *) (ra + 3 + 7 + 3)) =
                (s4) (sizeof(methodptr) * (m - m->class->methods));
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -1019,7 +1030,7 @@ bool patcher_invokeinterface(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -1061,7 +1072,7 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -1086,7 +1097,6 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 
        *((s4 *) (ra + 2)) = (s4) c->flags;
 
 
        *((s4 *) (ra + 2)) = (s4) c->flags;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -1097,7 +1107,7 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -1139,7 +1149,7 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -1168,7 +1178,6 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
                (s4) (OFFSET(vftbl_t, interfacetable[0]) -
                          c->index * sizeof(methodptr*));
 
                (s4) (OFFSET(vftbl_t, interfacetable[0]) -
                          c->index * sizeof(methodptr*));
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -1179,7 +1188,7 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -1221,7 +1230,7 @@ bool patcher_checkcast_class(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                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;
 
        *((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 */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -1258,7 +1266,7 @@ bool patcher_checkcast_class(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -1300,7 +1308,7 @@ bool patcher_instanceof_class(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
                return true;
        }
 #endif


@@ -1325,7 +1333,6 @@ bool patcher_instanceof_class(u1 *sp)
 
        *((ptrint *) (ra + 2)) = (ptrint) c->vftbl;
 
 
        *((ptrint *) (ra + 2)) = (ptrint) c->vftbl;
 

-       *dontfillinexceptionstacktrace=false;

 
 #if defined(USE_THREADS)
        /* this position has been patched */
 
 #if defined(USE_THREADS)
        /* this position has been patched */


@@ -1336,7 +1343,7 @@ bool patcher_instanceof_class(u1 *sp)
 
        builtin_monitorexit(o);
 #endif
 
        builtin_monitorexit(o);
 #endif

-
+       *dontfillinexceptionstacktrace=false;

        return true;
 }
 
        return true;
 }
 


@@ -1379,41 +1386,14 @@ bool patcher_clinit(u1 *sp)
 
        if (o->vftbl) {
                builtin_monitorexit(o);
 
        if (o->vftbl) {
                builtin_monitorexit(o);

-
+               *dontfillinexceptionstacktrace=false;

                return true;
        }
 #endif
 
        /* check if the class is initialized */
                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 */
 
 
        /* 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 */
        o->vftbl = (vftbl_t *) 1;
 
        /* leave the monitor on the patching position */

-
+       *dontfillinexceptionstacktrace=true;

        builtin_monitorexit(o);
        builtin_monitorexit(o);

+       *dontfillinexceptionstacktrace=false;
+

 #endif
 
        return true;
 #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
 
 
    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;
 
 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};
 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;
 
 
 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
 /* 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);
         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
 
 
    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 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 */
 
  
 #endif /* _STATISTICS_H */