drlvm/modules/vm/src/main/native/vmcore/shared/jni/jni_method.cpp

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/** 
 * @author Intel, Gregory Shimansky
 */  


#define LOG_DOMAIN "jni.method"
#include "cxxlog.h"

#include <assert.h>

#include "jni.h"
#include "jni_utils.h"
#include "jni_direct.h"

#include "vtable.h"
#include "Class.h"
#include "environment.h"
#include "exceptions.h"
#include "object_handles.h"
#include "open/vm_util.h"
#include "vm_threads.h"

#include "ini.h"
#include "nogc.h"
#include "open/vm_method_access.h"


static Method* lookup_method_init(Class* clss, const char* descr)
{
    String* method_name = VM_Global_State::loader_env->Init_String;
    String* method_descr =
        VM_Global_State::loader_env->string_pool.lookup(descr);

    return clss->lookup_method(method_name, method_descr);
} // lookup_method_init


static Method* lookup_method_clinit(Class* clss)
{
    return clss->lookup_method(VM_Global_State::loader_env->Clinit_String,
        VM_Global_State::loader_env->VoidVoidDescriptor_String);
} // lookup_method_clinit


jmethodID JNICALL GetMethodID(JNIEnv * jni_env,
                              jclass clazz,
                              const char *name,
                              const char *descr)
{
    TRACE2("jni", "GetMethodID called: " << name << descr);
    assert(hythread_is_suspend_enabled());
    assert(clazz);
    
    if (exn_raised()) return NULL;

    Class* clss = jclass_to_struct_Class(clazz);
    Method *method;
    if ('<' == *name) {
        if (!strcmp(name + 1, "init>")) {
            method = lookup_method_init(clss, descr);
        } else {
            ThrowNew_Quick(jni_env, "java/lang/NoSuchMethodError", name);
            return NULL;
        }
    } else {
        method = class_lookup_method_recursive(clss, name, descr);
    }

    if(!method || method->is_static()) {
        ThrowNew_Quick(jni_env, "java/lang/NoSuchMethodError", name);
        return NULL;
    }
    TRACE2("jni", "GetMethodID " << clss->get_name()->bytes
        << "." << name << " " << descr << " = " << (jmethodID)method);

    return (jmethodID)method;
} //GetMethodID



jmethodID JNICALL GetStaticMethodID(JNIEnv *jni_env,
                                    jclass clazz,
                                    const char *name,
                                    const char *descr)
{
    TRACE2("jni", "GetStaticMethodID called: " << name << descr);
    assert(hythread_is_suspend_enabled());
    Class* clss = jclass_to_struct_Class(clazz);
        
    if (exn_raised()) return NULL;

    Method *method;
    if ('<' == *name) {
        if (!strcmp(name + 1, "clinit>") && !strcmp(descr, "()V")) {
            method = lookup_method_clinit(clss);
        } else {
            ThrowNew_Quick(jni_env, "java/lang/NoSuchMethodError", name);
            return NULL;
        }
    } else {
        method = class_lookup_method_recursive(clss, name, descr);
    }

    if(!method || !method->is_static()) {
        ThrowNew_Quick(jni_env, "java/lang/NoSuchMethodError", name);
        return NULL;
    }
    TRACE2("jni", "GetStaticMethodID " << clss->get_name()->bytes
        << "." << name << " " << descr << " = " << (jmethodID)method);

    return (jmethodID)method;
} //GetStaticMethodID

static Method *object_lookup_method(jobject obj, const String* name, const String* desc) 
{
    ObjectHandle h = (ObjectHandle)obj;

    tmn_suspend_disable(); // v----------
    VTable *vtable = ((ManagedObject *)h->object)->vt();
    tmn_suspend_enable();  // ^----------

    assert(vtable);

    Method *method = class_lookup_method_recursive(vtable->clss, name, desc);
    if (method == 0) {
        LDIE(21, "Can't find method {0} {1}" << name->bytes << desc->bytes);
    }

    return method;
}


/////////////////////////////////////////////////////////////////////////////
// begin Call<Type>MethodA functions


static void call_method_no_ref_result(JNIEnv * jni_env,
                                      jobject obj,
                                      jmethodID methodID,
                                      jvalue *args,
                                      jvalue *result,
                                      int non_virtual)
{
    assert(hythread_is_suspend_enabled());
    Method *method = (Method *)methodID;

    if ( !non_virtual && !method_is_private(method) ) {
        // lookup the underlying "real" (e.g. abstract) method
        method = object_lookup_method(obj, method->get_name(), method->get_descriptor());
    }

    // Check method is not abstract
    // Alternative solution is to restore exception stubs in 
    // class_parse_methods() in Class_File_Loader.cpp, 
    // and to add similar functionality to interpreter
    if (method->is_abstract()) {
        ThrowNew_Quick (jni_env, "java/lang/AbstractMethodError", 
                "attempt to invoke abstract method");
        return;
    }

    if (!ensure_initialised(jni_env, method->get_class()))
        return;

    unsigned num_args = method->get_num_args();
    jvalue *all_args = (jvalue*) STD_ALLOCA(num_args * sizeof(jvalue));

    all_args[0].l = obj;
    memcpy(all_args + 1, args, (num_args - 1) * sizeof(jvalue));

    tmn_suspend_disable(); // v----------
    vm_execute_java_method_array((jmethodID)method, result, all_args);
    tmn_suspend_enable();  // ^----------
} //call_method_no_ref_result



void JNICALL CallVoidMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallVoidMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    CallVoidMethodV(jni_env, obj, methodID, args);
} //CallVoidMethod



void JNICALL CallVoidMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallVoidMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    CallVoidMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
} //CallVoidMethodV



void JNICALL CallVoidMethodA(JNIEnv * jni_env,
                             jobject obj,
                             jmethodID methodID,
                             jvalue *args)
{
    TRACE2("jni", "CallVoidMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue UNREF result;
    
    if (exn_raised()) return;

    String *name = ((Method*)methodID)->get_name();
    bool non_virtual = name == VM_Global_State::loader_env->Init_String;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, non_virtual);
} //CallVoidMethodA



jobject JNICALL CallObjectMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallObjectMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallObjectMethodV(jni_env, obj, methodID, args);
} //CallObjectMethod



jobject JNICALL CallObjectMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallObjectMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jobject result = CallObjectMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallObjectMethodV



jobject JNICALL CallObjectMethodA(JNIEnv * jni_env,
                                  jobject obj,
                                  jmethodID methodID,
                                  jvalue *args)
{
    TRACE2("jni", "CallObjectMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return NULL;

    jvalue result;
    Method *method = (Method *)methodID; // resolve to actual vtable entry below

    if (! method_is_private(method)) {
        // lookup the underlying "real" (e.g. abstract) method
        method = object_lookup_method(obj, method->get_name(), method->get_descriptor());
    }

    // Check method is not abstract
    // Alternative solution is to restore exception stubs in 
    // class_parse_methods() in Class_File_Loader.cpp, 
    // and to add similar functionality to interpreter
    if (method->is_abstract()) {
        ThrowNew_Quick (jni_env, "java/lang/AbstractMethodError", 
                "attempt to invoke abstract method");
        return NULL;
    }

    if (!ensure_initialised(jni_env, method->get_class()))
        return NULL;

    unsigned num_args = method->get_num_args();
    jvalue *all_args = (jvalue*) STD_ALLOCA(num_args * sizeof(jvalue));

    all_args[0].l = obj;
    memcpy(all_args + 1, args, (num_args - 1) * sizeof(jvalue));

    tmn_suspend_disable(); // v----------
    vm_execute_java_method_array((jmethodID)method, &result, all_args);
    tmn_suspend_enable();  // ^----------

    return result.l;
} //CallObjectMethodA



jboolean JNICALL CallBooleanMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallBooleanMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallBooleanMethodV(jni_env, obj, methodID, args);
} //CallBooleanMethod



jboolean JNICALL CallBooleanMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallBooleanMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jboolean result = CallBooleanMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallBooleanMethodV



jboolean JNICALL CallBooleanMethodA(JNIEnv * jni_env,
                                    jobject obj,
                                    jmethodID methodID,
                                    jvalue *args)
{
    TRACE2("jni", "CallBooleanMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
        
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.z;
} //CallBooleanMethodA



jbyte JNICALL CallByteMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallByteMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallByteMethodV(jni_env, obj, methodID, args);
} //CallByteMethod



jbyte JNICALL CallByteMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallByteMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jbyte result = CallByteMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallByteMethodV



jbyte JNICALL CallByteMethodA(JNIEnv * jni_env,
                              jobject obj,
                              jmethodID methodID,
                              jvalue *args)
{
    TRACE2("jni", "CallByteMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.b;
} //CallByteMethodA




jchar JNICALL CallCharMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallCharMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallCharMethodV(jni_env, obj, methodID, args);
} //CallCharMethod



jchar JNICALL CallCharMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallCharMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jchar result = CallCharMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallCharMethodV



jchar JNICALL CallCharMethodA(JNIEnv * jni_env,
                              jobject obj,
                              jmethodID methodID,
                              jvalue *args)
{
    TRACE2("jni", "CallCharMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.c;
} //CallCharMethodA




jshort JNICALL CallShortMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallShortMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallShortMethodV(jni_env, obj, methodID, args);
} //CallShortMethod



jshort JNICALL CallShortMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallShortMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jshort result = CallShortMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallShortMethodV



jshort JNICALL CallShortMethodA(JNIEnv * jni_env,
                                jobject obj,
                                jmethodID methodID,
                                jvalue *args)
{
    TRACE2("jni", "CallShortMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.s;
} //CallShortMethodA




jint JNICALL CallIntMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallIntMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallIntMethodV(jni_env, obj, methodID, args);
} //CallIntMethod



jint JNICALL CallIntMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallIntMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jint result = CallIntMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallIntMethodV



jint JNICALL CallIntMethodA(JNIEnv * jni_env,
                              jobject obj,
                              jmethodID methodID,
                              jvalue *args)
{
    TRACE2("jni", "CallIntMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.i;
} //CallIntMethodA




jlong JNICALL CallLongMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallLongMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallLongMethodV(jni_env, obj, methodID, args);
} //CallLongMethod



jlong JNICALL CallLongMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallLongMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jlong result = CallLongMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallLongMethodV



jlong JNICALL CallLongMethodA(JNIEnv * jni_env,
                              jobject obj,
                              jmethodID methodID,
                              jvalue *args)
{
    TRACE2("jni", "CallLongMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.j;
} //CallLongMethodA




jfloat JNICALL CallFloatMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallFloatMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallFloatMethodV(jni_env, obj, methodID, args);
} //CallFloatMethod



jfloat JNICALL CallFloatMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallFloatMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jfloat result = CallFloatMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallFloatMethodV



jfloat JNICALL CallFloatMethodA(JNIEnv * jni_env,
                                jobject obj,
                                jmethodID methodID,
                                jvalue *args)
{
    TRACE2("jni", "CallFloatMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.f;
} //CallFloatMethodA




jdouble JNICALL CallDoubleMethod(JNIEnv * jni_env, jobject obj, jmethodID methodID, ...)
{
    TRACE2("jni", "CallDoubleMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallDoubleMethodV(jni_env, obj, methodID, args);
} //CallDoubleMethod



jdouble JNICALL CallDoubleMethodV(JNIEnv * jni_env, jobject obj, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallDoubleMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jdouble result = CallDoubleMethodA(jni_env, obj, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallDoubleMethodV



jdouble JNICALL CallDoubleMethodA(JNIEnv * jni_env,
                                  jobject obj,
                                  jmethodID methodID,
                                  jvalue *args)
{
    TRACE2("jni", "CallDoubleMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, FALSE);
    return result.d;
} //CallDoubleMethodA




// end Call<Type>MethodA functions
/////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////
// begin CallNonvirtual<Type>MethodA functions


void JNICALL CallNonvirtualVoidMethod(JNIEnv * jni_env,
                                       jobject obj,
                                       jclass clazz,
                                       jmethodID methodID,
                                       ...)
{
    TRACE2("jni", "CallNonvirtualVoidMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    CallNonvirtualVoidMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualVoidMethod



void JNICALL CallNonvirtualVoidMethodV(JNIEnv * jni_env,
                                       jobject obj,
                                       jclass clazz,
                                       jmethodID methodID,
                                       va_list args)
{
    TRACE2("jni", "CallNonvirtualVoidMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    CallNonvirtualVoidMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
} //CallNonvirtualVoidMethodV



void JNICALL CallNonvirtualVoidMethodA(JNIEnv * jni_env,
                                       jobject obj,
                                       jclass UNREF clazz,
                                       jmethodID methodID,
                                       jvalue *args)
{
    TRACE2("jni", "CallNonvirtualVoidMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return;

    call_method_no_ref_result(jni_env, obj, methodID, args, 0, TRUE);
} //CallNonvirtualVoidMethodA



jobject JNICALL CallNonvirtualObjectMethod(JNIEnv * jni_env,
                                           jobject obj,
                                           jclass clazz,
                                           jmethodID methodID,
                                           ...)
{
    TRACE2("jni", "CallNonvirtualObjectMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualObjectMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualObjectMethod



jobject JNICALL CallNonvirtualObjectMethodV(JNIEnv * jni_env,
                                            jobject obj,
                                            jclass clazz,
                                            jmethodID methodID,
                                            va_list args)
{
    TRACE2("jni", "CallNonvirtualObjectMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jobject result = CallNonvirtualObjectMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualObjectMethodV



jobject JNICALL CallNonvirtualObjectMethodA(JNIEnv * jni_env,
                                            jobject obj,
                                            jclass UNREF clazz,
                                            jmethodID methodID,
                                            jvalue *args)
{
    TRACE2("jni", "CallNonvirtualObjectMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return NULL;

    jvalue result;
    Method *method = (Method *)methodID;
    if (!ensure_initialised(jni_env, method->get_class()))
        return NULL;
    unsigned num_args = method->get_num_args();
    jvalue *all_args = (jvalue*) STD_ALLOCA(num_args * sizeof(jvalue));


    all_args[0].l = obj;
    memcpy(all_args + 1, args, (num_args - 1) * sizeof(jvalue));
    tmn_suspend_disable();
    vm_execute_java_method_array(methodID, &result, all_args);
    tmn_suspend_enable();
 
    return result.l;
} //CallNonvirtualObjectMethodA



jboolean JNICALL CallNonvirtualBooleanMethod(JNIEnv * jni_env,
                                             jobject obj,
                                             jclass clazz,
                                             jmethodID methodID,
                                             ...)
{
    TRACE2("jni", "CallNonvirtualBooleanMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualBooleanMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualBooleanMethod



jboolean JNICALL CallNonvirtualBooleanMethodV(JNIEnv * jni_env,
                                              jobject obj,
                                              jclass clazz,
                                              jmethodID methodID,
                                              va_list args)
{
    TRACE2("jni", "CallNonvirtualBooleanMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jboolean result = CallNonvirtualBooleanMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualBooleanMethodV



jboolean JNICALL CallNonvirtualBooleanMethodA(JNIEnv * jni_env,
                                              jobject obj,
                                              jclass UNREF clazz,
                                              jmethodID methodID,
                                              jvalue *args)
{
    TRACE2("jni", "CallNonvirtualBooleanMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.z;
} //CallNonvirtualBooleanMethodA



jbyte JNICALL CallNonvirtualByteMethod(JNIEnv * jni_env,
                                       jobject obj,
                                       jclass clazz,
                                       jmethodID methodID,
                                       ...)
{
    TRACE2("jni", "CallNonvirtualByteMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualByteMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualByteMethod



jbyte JNICALL CallNonvirtualByteMethodV(JNIEnv * jni_env,
                                        jobject obj,
                                        jclass clazz,
                                        jmethodID methodID,
                                        va_list args)
{
    TRACE2("jni", "CallNonvirtualByteMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jbyte result = CallNonvirtualByteMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualByteMethodV



jbyte JNICALL CallNonvirtualByteMethodA(JNIEnv * jni_env,
                                        jobject obj,
                                        jclass UNREF clazz,
                                        jmethodID methodID,
                                        jvalue *args)
{
    TRACE2("jni", "CallNonvirtualByteMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.b;
} //CallNonvirtualByteMethodA



jchar JNICALL CallNonvirtualCharMethod(JNIEnv * jni_env,
                                       jobject obj,
                                       jclass clazz,
                                       jmethodID methodID,
                                       ...)
{
    TRACE2("jni", "CallNonvirtualCharMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualCharMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualCharMethod



jchar JNICALL CallNonvirtualCharMethodV(JNIEnv * jni_env,
                                        jobject obj,
                                        jclass clazz,
                                        jmethodID methodID,
                                        va_list args)
{
    TRACE2("jni", "CallNonvirtualCharMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jchar result = CallNonvirtualCharMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualCharMethodV



jchar JNICALL CallNonvirtualCharMethodA(JNIEnv * jni_env,
                                        jobject obj,
                                        jclass UNREF clazz,
                                        jmethodID methodID,
                                        jvalue *args)
{
    TRACE2("jni", "CallNonvirtualCharMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.c;
} //CallNonvirtualCharMethodA



jshort JNICALL CallNonvirtualShortMethod(JNIEnv * jni_env,
                                         jobject obj,
                                         jclass clazz,
                                         jmethodID methodID,
                                         ...)
{
    TRACE2("jni", "CallNonvirtualShortMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualShortMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualShortMethod



jshort JNICALL CallNonvirtualShortMethodV(JNIEnv * jni_env,
                                          jobject obj,
                                          jclass clazz,
                                          jmethodID methodID,
                                          va_list args)
{
    TRACE2("jni", "CallNonvirtualShortMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jshort result = CallNonvirtualShortMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualShortMethodV



jshort JNICALL CallNonvirtualShortMethodA(JNIEnv * jni_env,
                                          jobject obj,
                                          jclass UNREF clazz,
                                          jmethodID methodID,
                                          jvalue *args)
{
    TRACE2("jni", "CallNonvirtualShortMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.s;
} //CallNonvirtualShortMethodA



jint JNICALL CallNonvirtualIntMethod(JNIEnv * jni_env,
                                     jobject obj,
                                     jclass clazz,
                                     jmethodID methodID,
                                     ...)
{
    TRACE2("jni", "CallNonvirtualIntMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualIntMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualIntMethod



jint JNICALL CallNonvirtualIntMethodV(JNIEnv * jni_env,
                                      jobject obj,
                                      jclass clazz,
                                      jmethodID methodID,
                                      va_list args)
{
    TRACE2("jni", "CallNonvirtualIntMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jint result = CallNonvirtualIntMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualIntMethodV



jint JNICALL CallNonvirtualIntMethodA(JNIEnv * jni_env,
                                      jobject obj,
                                      jclass UNREF clazz,
                                      jmethodID methodID,
                                      jvalue *args)
{
    TRACE2("jni", "CallNonvirtualIntMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result,  TRUE);
    return result.i;
} //CallNonvirtualIntMethodA



jlong JNICALL CallNonvirtualLongMethod(JNIEnv * jni_env,
                                       jobject obj,
                                       jclass clazz,
                                       jmethodID methodID,
                                       ...)
{
    TRACE2("jni", "CallNonvirtualLongMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualLongMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualLongMethod



jlong JNICALL CallNonvirtualLongMethodV(JNIEnv * jni_env,
                                        jobject obj,
                                        jclass clazz,
                                        jmethodID methodID,
                                        va_list args)
{
    TRACE2("jni", "CallNonvirtualLongMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jlong result = CallNonvirtualLongMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualLongMethodV



jlong JNICALL CallNonvirtualLongMethodA(JNIEnv * jni_env,
                                        jobject obj,
                                        jclass UNREF clazz,
                                        jmethodID methodID,
                                        jvalue *args)
{
    TRACE2("jni", "CallNonvirtualLongMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.j;
} //CallNonvirtualLongMethodA



jfloat JNICALL CallNonvirtualFloatMethod(JNIEnv * jni_env,
                                         jobject obj,
                                         jclass clazz,
                                         jmethodID methodID,
                                         ...)
{
    TRACE2("jni", "CallNonvirtualFloatMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualFloatMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualFloatMethod



jfloat JNICALL CallNonvirtualFloatMethodV(JNIEnv * jni_env,
                                          jobject obj,
                                          jclass clazz,
                                          jmethodID methodID,
                                          va_list args)
{
    TRACE2("jni", "CallNonvirtualFloatMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jfloat result = CallNonvirtualFloatMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualFloatMethodV



jfloat JNICALL CallNonvirtualFloatMethodA(JNIEnv * jni_env,
                                          jobject obj,
                                          jclass UNREF clazz,
                                          jmethodID methodID,
                                          jvalue *args)
{
    TRACE2("jni", "CallNonvirtualFloatMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.f;
} //CallNonvirtualFloatMethodA



jdouble JNICALL CallNonvirtualDoubleMethod(JNIEnv * jni_env,
                                           jobject obj,
                                           jclass clazz,
                                           jmethodID methodID,
                                           ...)
{
    TRACE2("jni", "CallNonvirtualDoubleMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallNonvirtualDoubleMethodV(jni_env, obj, clazz, methodID, args);
} //CallNonvirtualDoubleMethod



jdouble JNICALL CallNonvirtualDoubleMethodV(JNIEnv * jni_env,
                                            jobject obj,
                                            jclass clazz,
                                            jmethodID methodID,
                                            va_list args)
{
    TRACE2("jni", "CallNonvirtualDoubleMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jdouble result = CallNonvirtualDoubleMethodA(jni_env, obj, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallNonvirtualDoubleMethodV



jdouble JNICALL CallNonvirtualDoubleMethodA(JNIEnv * jni_env,
                                            jobject obj,
                                            jclass UNREF clazz,
                                            jmethodID methodID,
                                            jvalue *args)
{
    TRACE2("jni", "CallNonvirtualDoubleMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_method_no_ref_result(jni_env, obj, methodID, args, &result, TRUE);
    return result.d;
} //CallNonvirtualDoubleMethodA



// end CallNonvirtual<Type>MethodA functions
/////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////
// begin CallStatic<Type>MethodA functions


static void call_static_method_no_ref_result(JNIEnv * jni_env,
                                             jclass UNREF clazz,
                                             jmethodID methodID,
                                             jvalue *args,
                                             jvalue *result)
{
    assert(hythread_is_suspend_enabled());
    Method *method = (Method *)methodID;
    if (!ensure_initialised(jni_env, method->get_class()))
        return;
    tmn_suspend_disable();
    vm_execute_java_method_array(methodID, result, args);
    tmn_suspend_enable();
} //call_static_method_no_ref_result



jobject JNICALL CallStaticObjectMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticObjectMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticObjectMethodV(jni_env, clazz, methodID, args);
} //CallStaticObjectMethod



jobject JNICALL CallStaticObjectMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticObjectMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jobject result = CallStaticObjectMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticObjectMethodV



jobject JNICALL CallStaticObjectMethodA(JNIEnv * jni_env,
                                        jclass UNREF clazz,
                                        jmethodID methodID,
                                        jvalue *args)
{
    TRACE2("jni", "CallStaticObjectMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return NULL;

    jvalue result;
    Method *method = (Method *)methodID;
    if (!ensure_initialised(jni_env, method->get_class()))
        return NULL;
    unsigned num_args = method->get_num_args();
    jvalue *all_args = (jvalue*) STD_ALLOCA(num_args * sizeof(jvalue));

    memcpy(all_args, args, num_args * sizeof(jvalue));
    tmn_suspend_disable();
    vm_execute_java_method_array(methodID, &result, all_args);
    tmn_suspend_enable();
 
    return result.l;
} //CallStaticObjectMethodA



jboolean JNICALL CallStaticBooleanMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticBooleanMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticBooleanMethodV(jni_env, clazz, methodID, args);
} //CallStaticBooleanMethod



jboolean JNICALL CallStaticBooleanMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticBooleanMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jboolean result = CallStaticBooleanMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticBooleanMethodV



jboolean JNICALL CallStaticBooleanMethodA(JNIEnv * jni_env,
                                          jclass clazz,
                                          jmethodID methodID,
                                          jvalue *args)
{
    TRACE2("jni", "CallStaticBooleanMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.z;
} //CallStaticBooleanMethodA



jbyte JNICALL CallStaticByteMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticByteMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticByteMethodV(jni_env, clazz, methodID, args);
} //CallStaticByteMethod



jbyte JNICALL CallStaticByteMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticByteMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jbyte result = CallStaticByteMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticByteMethodV



jbyte JNICALL CallStaticByteMethodA(JNIEnv * jni_env,
                                    jclass clazz,
                                    jmethodID methodID,
                                    jvalue *args)
{
    TRACE2("jni", "CallStaticByteMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.b;
} //CallStaticByteMethodA



jchar JNICALL CallStaticCharMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticCharMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticCharMethodV(jni_env, clazz, methodID, args);
} //CallStaticCharMethod



jchar JNICALL CallStaticCharMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticCharMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jchar result = CallStaticCharMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticCharMethodV



jchar JNICALL CallStaticCharMethodA(JNIEnv * jni_env,
                                    jclass clazz,
                                    jmethodID methodID,
                                    jvalue *args)
{
    TRACE2("jni", "CallStaticCharMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.c;
} //CallStaticCharMethodA



jshort JNICALL CallStaticShortMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticShortMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticShortMethodV(jni_env, clazz, methodID, args);
} //CallStaticShortMethod



jshort JNICALL CallStaticShortMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticShortMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jshort result = CallStaticShortMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticShortMethodV



jshort JNICALL CallStaticShortMethodA(JNIEnv * jni_env,
                                      jclass clazz,
                                      jmethodID methodID,
                                      jvalue *args)
{
    TRACE2("jni", "CallStaticShortMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.s;
} //CallStaticShortMethodA



jint JNICALL CallStaticIntMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticIntMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticIntMethodV(jni_env, clazz, methodID, args);
} //CallStaticIntMethod



jint JNICALL CallStaticIntMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticIntMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jint result = CallStaticIntMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticIntMethodV



jint JNICALL CallStaticIntMethodA(JNIEnv * jni_env,
                                  jclass clazz,
                                  jmethodID methodID,
                                  jvalue *args)
{
    TRACE2("jni", "CallStaticIntMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.i;
} //CallStaticIntMethodA



jlong JNICALL CallStaticLongMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticLongMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticLongMethodV(jni_env, clazz, methodID, args);
} //CallStaticLongMethod



jlong JNICALL CallStaticLongMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticLongMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jlong result = CallStaticLongMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticLongMethodV



jlong JNICALL CallStaticLongMethodA(JNIEnv * jni_env,
                                    jclass clazz,
                                    jmethodID methodID,
                                    jvalue *args)
{
    TRACE2("jni", "CallStaticLongMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.j;
} //CallStaticLongMethodA



jfloat JNICALL CallStaticFloatMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticFloatMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticFloatMethodV(jni_env, clazz, methodID, args);
} //CallStaticFloatMethod



jfloat JNICALL CallStaticFloatMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticFloatMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jfloat result = CallStaticFloatMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticFloatMethodV



jfloat JNICALL CallStaticFloatMethodA(JNIEnv * jni_env,
                                      jclass clazz,
                                      jmethodID methodID,
                                      jvalue *args)
{
    TRACE2("jni", "CallStaticFloatMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.f;
} //CallStaticFloatMethodA



jdouble JNICALL CallStaticDoubleMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticDoubleMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    return CallStaticDoubleMethodV(jni_env, clazz, methodID, args);
} //CallStaticDoubleMethod



jdouble JNICALL CallStaticDoubleMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticDoubleMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    jdouble result = CallStaticDoubleMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
    return result;
} //CallStaticDoubleMethodV



jdouble JNICALL CallStaticDoubleMethodA(JNIEnv * jni_env,
                                        jclass clazz,
                                        jmethodID methodID,
                                        jvalue *args)
{
    TRACE2("jni", "CallStaticDoubleMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return 0;

    jvalue result;
    call_static_method_no_ref_result(jni_env, clazz, methodID, args, &result);
    return result.d;
} //CallStaticDoubleMethodA



void JNICALL CallStaticVoidMethod(JNIEnv * jni_env, jclass clazz, jmethodID methodID, ...)
{
    TRACE2("jni", "CallStaticVoidMethod called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    va_list args;
    va_start(args, methodID);
    CallStaticVoidMethodV(jni_env, clazz, methodID, args);
} //CallStaticVoidMethod



void JNICALL CallStaticVoidMethodV(JNIEnv * jni_env, jclass clazz, jmethodID methodID, va_list args)
{
    TRACE2("jni", "CallStaticVoidMethodV called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    jvalue *jvalue_args = get_jvalue_arg_array((Method *)methodID, args);
    CallStaticVoidMethodA(jni_env, clazz, methodID, jvalue_args);
    STD_FREE(jvalue_args);
} //CallStaticVoidMethodV



void JNICALL CallStaticVoidMethodA(JNIEnv * jni_env,
                                   jclass clazz,
                                   jmethodID methodID,
                                   jvalue *args)
{
    TRACE2("jni", "CallStaticVoidMethodA called, id = " << methodID);
    assert(hythread_is_suspend_enabled());
    
    if (exn_raised()) return;

    call_static_method_no_ref_result(jni_env, clazz, methodID, args, 0);
} //CallStaticVoidMethodA



// end CallStatic<Type>MethodA functions
/////////////////////////////////////////////////////////////////////////////