/*
 *  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 Ivan Volosyuk
 */  

#include "interpreter.h"
#include "interpreter_exports.h"
#include "interpreter_imports.h"

#include "vtable.h"
#include "exceptions.h"
#include "mon_enter_exit.h"
#include "open/vm_method_access.h"
#include "interp_native.h"
#include "interp_defs.h"
#include "ini.h"



extern "C" {
    int64 invokeJNI(uint64 *args, uword n_fps, uword n_stacks, GenericFunctionPointer f);
}

typedef double (*DoubleFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef ManagedObject** (*RefFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef void* (*ObjFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef float (*FloatFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef I_32 (*IntFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef int16 (*ShortFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef I_8 (*ByteFuncPtr)(uword*,uword,word,GenericFunctionPointer);
typedef uint16 (*CharFuncPtr)(uword*,uword,word,GenericFunctionPointer);

DoubleFuncPtr invokeJNI_Double = (DoubleFuncPtr) invokeJNI;
ObjFuncPtr invokeJNI_Obj = (ObjFuncPtr) invokeJNI;
RefFuncPtr invokeJNI_Ref = (RefFuncPtr) invokeJNI;
IntFuncPtr invokeJNI_Int = (IntFuncPtr) invokeJNI;
FloatFuncPtr invokeJNI_Float = (FloatFuncPtr) invokeJNI;
ShortFuncPtr invokeJNI_Short = (ShortFuncPtr) invokeJNI;
CharFuncPtr invokeJNI_Char = (CharFuncPtr) invokeJNI;
ByteFuncPtr invokeJNI_Byte = (ByteFuncPtr) invokeJNI;

#ifdef _WIN32
#define MAX_REG_FLOATS  4
#define MAX_REG_INTS  4
#else
#define MAX_REG_FLOATS  8
#define MAX_REG_INTS  6
#endif

void
interpreter_execute_native_method(
        Method *method,
        jvalue *return_value,
        jvalue *args) {
    assert(!hythread_is_suspend_enabled());


    DEBUG_TRACE("\n<<< interpreter_invoke_native: " << method);

    GenericFunctionPointer f = interpreterGetNativeMethodAddr(method);
    if (f == 0) {
        DEBUG_TRACE("<EXCEPTION> native_invoke_virtual>>>\n");
        return;
    }
    M2N_ALLOC_MACRO;
    hythread_suspend_enable();

    int sz = method->get_num_arg_slots();

    int n_ints = 0;
#ifdef _WIN32 /* important difference in calling conventions */
#define n_fps n_ints
#else
    int n_fps = 0;
#endif
    int n_stacks = 0;
    uword *out_args = (uword*) ALLOC_FRAME(8 + sizeof(char) + (MAX_REG_FLOATS + sz + 2) * sizeof(uword));
    uword *fps = out_args + 1;
    uword *ints = fps + MAX_REG_FLOATS;
    uword *stacks = ints + MAX_REG_INTS;

    int pos = 0;
    ints[n_ints++] = (uword) get_jni_native_intf();

    jobject _this;
    if (method->is_static()) {
        _this = (jobject) method->get_class()->get_class_handle();
    } else {
        _this = args[pos++].l;
    }
    ints[n_ints++] = (uword) _this;

    const char *mtype = method->get_descriptor()->bytes + 1;
    assert(mtype != 0);

    for(; *mtype != ')'; mtype++) {
        switch(*mtype) {
            case JAVA_TYPE_CLASS:
            case JAVA_TYPE_ARRAY:
                {
                    jobject obj = args[pos++].l;
                    ObjectHandle UNUSED h = (ObjectHandle) obj;
                    if (n_ints != MAX_REG_INTS) {
                        ints[n_ints++] = (uword) obj;
                    } else {
                        stacks[n_stacks++] = (uword) obj;
                    }
                    while(*mtype == '[') mtype++;
                    if (*mtype == 'L')
                        while(*mtype != ';') mtype++;
                }
                break;

            case JAVA_TYPE_SHORT:
            case JAVA_TYPE_BYTE:
            case JAVA_TYPE_INT:
                // sign extend
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = (uword)(word) args[pos++].i;
                } else {
                    stacks[n_stacks++] = (uword)(word) args[pos++].i;
                }
                break;

            case JAVA_TYPE_BOOLEAN:
            case JAVA_TYPE_CHAR:
                // zero extend
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = (word) args[pos++].i;
                } else {
                    stacks[n_stacks++] = (word) args[pos++].i;
                }
                break;

            case JAVA_TYPE_LONG:
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = args[pos++].j;
                } else {
                    stacks[n_stacks++] = args[pos++].j;
                }
                break;

            case JAVA_TYPE_FLOAT:
                if (n_fps != MAX_REG_FLOATS) {
                    *(float*)&fps[n_fps++] = args[pos++].f;
                } else {
                    *(float*)&stacks[n_stacks++] = args[pos++].f;
                }

            case JAVA_TYPE_DOUBLE:
                if (n_fps != MAX_REG_FLOATS) {
                    fps[n_fps++] = args[pos++].j;
                } else {
                    stacks[n_stacks++] = args[pos++].j;
                }

            default:
                LDIE(53, "Unexpected java type");
        }
    }
//    assert(argId <= sz + 2);

    if (interpreter_ti_notification_mode
            & INTERPRETER_TI_METHOD_ENTRY_EVENT)
        method_entry_callback(method);

    if (method->is_synchronized()) {
        assert(hythread_is_suspend_enabled());
        jthread_monitor_enter(_this);
    }

    jvalue *resultPtr = return_value;
    Java_Type ret_type = method->get_return_java_type();

    switch(ret_type) {
        case JAVA_TYPE_VOID:
            invokeJNI(out_args, n_fps, n_stacks, f);
            hythread_suspend_disable();
            M2N_FREE_MACRO;
            break;

        case JAVA_TYPE_CLASS:
        case JAVA_TYPE_ARRAY:
        case JAVA_TYPE_STRING:
            {
                jobject obj = (jobject) invokeJNI_Obj(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                if (obj) {
                    ManagedObject *ref = obj->object;
                    M2N_FREE_MACRO;
                    ObjectHandle new_handle = oh_allocate_local_handle();
                    new_handle->object = ref;
                    resultPtr->l = new_handle;
                } else {
                    M2N_FREE_MACRO;
                    resultPtr->l = NULL;
                }
            }
            break;

        case JAVA_TYPE_BOOLEAN:
        case JAVA_TYPE_BYTE:
        case JAVA_TYPE_CHAR:
        case JAVA_TYPE_SHORT:
        case JAVA_TYPE_INT:
            resultPtr->i = invokeJNI_Int(out_args, n_fps, n_stacks, f);
            hythread_suspend_disable();
            M2N_FREE_MACRO;
            break;

        case JAVA_TYPE_FLOAT:
            resultPtr->f = invokeJNI_Float(out_args, n_fps, n_stacks, f);
            hythread_suspend_disable();
            M2N_FREE_MACRO;
            break;

        case JAVA_TYPE_LONG:
            resultPtr->j = invokeJNI(out_args, n_fps, n_stacks, f);
            hythread_suspend_disable();
            M2N_FREE_MACRO;
            break;

        case JAVA_TYPE_DOUBLE:
            resultPtr->d = invokeJNI_Double(out_args, n_fps, n_stacks, f);
            hythread_suspend_disable();
            M2N_FREE_MACRO;
            break;

        default:
            LDIE(53, "Unexpected java type");
    }

    if (exn_raised()) {
        if ((resultPtr != NULL) && (ret_type != JAVA_TYPE_VOID)) {   
            DEBUG_TRACE("<EXCEPTION> ");
            resultPtr->l = 0; //clear result
        }
    }

    if (method->is_synchronized()) {
        vm_monitor_exit_wrapper(_this->object);
    }

    if (interpreter_ti_notification_mode
            & INTERPRETER_TI_METHOD_EXIT_EVENT) {
        jvalue val;
        method_exit_callback(method,
                exn_raised(),
                resultPtr != 0 ? *resultPtr : (val.j = 0, val));
    }

    DEBUG_TRACE("interpreter_invoke_native >>>\n");
    FREE_FRAME(out_args);
}

void
interpreterInvokeStaticNative(StackFrame& prevFrame, StackFrame& frame, Method *method) {

    GenericFunctionPointer f = interpreterGetNativeMethodAddr(method);
    if (f == 0) {
        DEBUG_TRACE("<EXCEPTION> interpreter_invoke_native >>>\n");
        return;
    }

    DEBUG_TRACE("\n<<< native_invoke_static     : " << method);
    TRACE("interpreter static native: " << frame.method);

    M2N_ALLOC_MACRO;
    
    int sz = method->get_num_arg_slots();

    int n_ints = 0;
#ifdef _WIN32 /* important difference in calling conventions */
#define n_fps n_ints
#else
    int n_fps = 0;
#endif
    int n_stacks = 0;
    uword *out_args = (uword*) ALLOC_FRAME(8 + sizeof(char) + (MAX_REG_FLOATS + sz + 2) * sizeof(uword));
    uword *fps = out_args + 1;
    uword *ints = fps + MAX_REG_FLOATS;
    uword *stacks = ints + MAX_REG_INTS;

    frame.This = *(method->get_class()->get_class_handle());
    ints[n_ints++] = (uword) get_jni_native_intf();
    ints[n_ints++] = (uword) &frame.This; 
    int pos = sz - 1;
    uword arg;

    const char *mtype = method->get_descriptor()->bytes + 1;
    assert(mtype != 0);

    for(; pos >= 0; mtype++) {

        switch(*mtype) {
            case JAVA_TYPE_CLASS:
            case JAVA_TYPE_ARRAY:
                {
                    ASSERT_TAGS(prevFrame.stack.ref(pos));
                    REF& ref = prevFrame.stack.pick(pos--).ref;
                    ASSERT_OBJECT(UNCOMPRESS_INTERP(ref));
                    if (ref == 0) {
                        arg = 0;
                    } else {
#ifdef REF32
                        ObjectHandle new_handle = oh_allocate_local_handle();
                        new_handle->object = UNCOMPRESS_INTERP(ref);
                        arg = (uword) new_handle;
#else
                        arg = (uword) &ref;
#endif
                    }
                    if (n_ints != MAX_REG_INTS) {
                        ints[n_ints++] = arg;
                    } else {
                        stacks[n_stacks++] = arg;
                    }
                    while(*mtype == '[') mtype++;
                    if (*mtype == 'L')
                        while(*mtype != ';') mtype++;
                }
                break;

            case JAVA_TYPE_SHORT:
            case JAVA_TYPE_BYTE:
            case JAVA_TYPE_INT:
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                // sign extend
                arg = (uword)(word) prevFrame.stack.pick(pos--).i;
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                break;

            case JAVA_TYPE_BOOLEAN:
            case JAVA_TYPE_CHAR:
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                // zero extend
                arg = prevFrame.stack.pick(pos--).u;
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                break;

            case JAVA_TYPE_LONG:
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                ASSERT_TAGS(!prevFrame.stack.ref(pos-1));
                arg = prevFrame.stack.getLong(pos-1).u64;
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                pos -= 2;
                break;

            case JAVA_TYPE_FLOAT:
                {
                    ASSERT_TAGS(!prevFrame.stack.ref(pos));
                    // zero extend
                    float farg = prevFrame.stack.pick(pos--).f;
                    if (n_fps != MAX_REG_FLOATS) {
                        *(float*)&fps[n_fps++] = farg;
                    } else {
                        *(float*)&stacks[n_stacks++] = farg;
                    }
                }
                break;

            case JAVA_TYPE_DOUBLE:
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                ASSERT_TAGS(!prevFrame.stack.ref(pos-1));
                arg = prevFrame.stack.getLong(pos-1).u64;

                if (n_fps != MAX_REG_FLOATS) {
                    fps[n_fps++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                pos -= 2;
                break;

            default:
                LDIE(53, "Unexpected java type");
        }
    }
    assert(*mtype == ')');

    if (interpreter_ti_notification_mode
            & INTERPRETER_TI_METHOD_ENTRY_EVENT) {
        method_entry_callback(method);
    }

    if (method->is_synchronized()) {
        vm_monitor_enter_wrapper(frame.This);
    }

    hythread_suspend_enable();

    switch(method->get_return_java_type()) {
        case JAVA_TYPE_VOID:
            {
                invokeJNI(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);
            }
            break;

        case JAVA_TYPE_CLASS:
        case JAVA_TYPE_ARRAY:
        case JAVA_TYPE_STRING:
            {
                ManagedObject **ref = invokeJNI_Ref(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                if (ref != 0) {
                    ASSERT_OBJECT(*ref);
                    if (!*ref) {
                        INFO(
                        "VM WARNING: Reference with null value returned from jni function:\n"
                        "VM WARNING: Method name: "
                        << method->get_class()->get_name()->bytes
                        << "/" << method->get_name()->bytes
                        << method->get_descriptor()->bytes <<
                        "\nVM WARNING: Not allowed, return NULL (0) instead\n");
                    }
                    prevFrame.stack.pick().ref = COMPRESS_INTERP(*ref);
                } else {
                    prevFrame.stack.pick().ref = 0;
                }
                prevFrame.stack.ref() = FLAG_OBJECT;
            }
            break;

        case JAVA_TYPE_BOOLEAN:
        case JAVA_TYPE_BYTE:
            {
                I_8 res = invokeJNI_Byte(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick().i = (I_32)res;
            }
            break;

        case JAVA_TYPE_CHAR:
            {
                uint16 res = invokeJNI_Char(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick().u = (U_32) res;
            }
            break;

        case JAVA_TYPE_SHORT:
            {
                int16 res = invokeJNI_Short(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick().i = (I_32) res;
            }
            break;

        case JAVA_TYPE_INT:
            {
                Value res;
                res.i = invokeJNI_Int(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick() = res;
            }
            break;

        case JAVA_TYPE_FLOAT:
            {
                Value res;
                res.f = invokeJNI_Float(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick() = res;
            }
            break;

        case JAVA_TYPE_LONG:
            {
                Value2 res;
                res.i64 = invokeJNI(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push(2);
                prevFrame.stack.setLong(0, res);
            }
            break;

        case JAVA_TYPE_DOUBLE:
            {
                Value2 res;
                res.d = invokeJNI_Double(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push(2);
                prevFrame.stack.setLong(0, res);
            }
            break;

        default:
            LDIE(53, "Unexpected java type");
    }

    if (method->is_synchronized()) {
        vm_monitor_exit_wrapper(frame.This);
    }

    if (interpreter_ti_notification_mode
            & INTERPRETER_TI_METHOD_EXIT_EVENT)
        method_exit_callback_with_frame(method, prevFrame);

    M2N_FREE_MACRO;
    FREE_FRAME(out_args);
    DEBUG_TRACE("native_invoke_static >>>\n");
}

void
interpreterInvokeVirtualNative(StackFrame& prevFrame, StackFrame& frame, Method *method, int sz) {
    assert(method->is_native());
    assert(!method->is_static());

    TRACE("interpreter virtual native: " << frame.method);
    DEBUG_TRACE("\n<<< native_invoke_virtual: " << method);

    int n_ints = 0;
#ifdef _WIN32 /* important difference in calling conventions */
#define n_fps n_ints
#else
    int n_fps = 0;
#endif
    int n_stacks = 0;
    uword *out_args = (uword*) ALLOC_FRAME(8 + sizeof(char) + (MAX_REG_FLOATS + sz + 2) * sizeof(uword));
    uword *fps = out_args + 1;
    uword *ints = fps + MAX_REG_FLOATS;
    uword *stacks = ints + MAX_REG_INTS;

    ints[n_ints++] = (uword) get_jni_native_intf();
    ints[n_ints++] = (uword) &frame.This;
    int pos = sz - 2;

    GenericFunctionPointer f = interpreterGetNativeMethodAddr(method);
    if (f == 0) {
        DEBUG_TRACE("<EXCEPTION> native_invoke_virtual>>>\n");
        return;
    }
    M2N_ALLOC_MACRO;

    const char *mtype = method->get_descriptor()->bytes + 1;
    assert(mtype != 0);
    uword arg;

    for(; pos >= 0; mtype++) {

        switch(*mtype) {
            case JAVA_TYPE_CLASS:
            case JAVA_TYPE_ARRAY:
                {
                    ASSERT_TAGS(prevFrame.stack.ref(pos));
                    REF& ref = prevFrame.stack.pick(pos--).ref;
                    ASSERT_OBJECT(UNCOMPRESS_INTERP(ref));
                    if (ref == 0) {
                        arg = 0;
                    } else {
#ifdef REF32
                        ObjectHandle new_handle = oh_allocate_local_handle();
                        new_handle->object = UNCOMPRESS_INTERP(ref);
                        arg = (uword) new_handle;
#else
                        arg = (uword) &ref;
#endif
                    }
                    if (n_ints != MAX_REG_INTS) {
                        ints[n_ints++] = arg;
                    } else {
                        stacks[n_stacks++] = arg;
                    }
                    while(*mtype == '[') mtype++;
                    if (*mtype == 'L')
                        while(*mtype != ';') mtype++;
                }
                break;

            case JAVA_TYPE_BOOLEAN:
            case JAVA_TYPE_CHAR:
                // zero extend
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                arg = prevFrame.stack.pick(pos--).u;
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                break;

            case JAVA_TYPE_BYTE:
            case JAVA_TYPE_SHORT:
            case JAVA_TYPE_INT:
                // sign extend
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                arg = (uword)(word) prevFrame.stack.pick(pos--).i;
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                break;

            case JAVA_TYPE_LONG:
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                ASSERT_TAGS(!prevFrame.stack.ref(pos-1));
                arg = prevFrame.stack.getLong(pos-1).u64;
                if (n_ints != MAX_REG_INTS) {
                    ints[n_ints++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                pos -= 2;
                break;

            case JAVA_TYPE_FLOAT:
                {
                    ASSERT_TAGS(!prevFrame.stack.ref(pos));
                    float farg = prevFrame.stack.pick(pos--).f;
                    if (n_fps != MAX_REG_FLOATS) {
                        *(float*)&fps[n_fps++] = farg;
                    } else {
                        *(float*)&stacks[n_stacks++] = farg;
                    }
                }
                break;
            case JAVA_TYPE_DOUBLE:
                ASSERT_TAGS(!prevFrame.stack.ref(pos));
                ASSERT_TAGS(!prevFrame.stack.ref(pos-1));
                arg = prevFrame.stack.getLong(pos-1).u64;
                if (n_fps != MAX_REG_FLOATS) {
                    fps[n_fps++] = arg;
                } else {
                    stacks[n_stacks++] = arg;
                }
                pos -= 2;
                break;
            default:
                LDIE(53, "Unexpected java type");
        }
    }
    assert(*mtype == ')');

    if (interpreter_ti_notification_mode
            & INTERPRETER_TI_METHOD_ENTRY_EVENT) {
        method_entry_callback(method);
    }

    if (method->is_synchronized()) {
        vm_monitor_enter_wrapper(frame.This);
    }
    
    hythread_suspend_enable();

    switch(method->get_return_java_type()) {
        case JAVA_TYPE_VOID:
            {
                invokeJNI(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);
            }
            break;

        case JAVA_TYPE_CLASS:
        case JAVA_TYPE_ARRAY:
        case JAVA_TYPE_STRING:
            {
                ManagedObject ** ref = invokeJNI_Ref(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                if (ref != 0) {
                    ASSERT_OBJECT(*ref);

                    if (!*ref) {
                        INFO(
                        "VM WARNING: Reference with null value returned from jni function:\n"
                        "VM WARNING: Method name: "
                        << method->get_class()->get_name()->bytes
                        << "/" << method->get_name()->bytes
                        << method->get_descriptor()->bytes <<
                        "\nVM WARNING: Not allowed, return NULL (0) instead\n");
                    }
                    prevFrame.stack.pick().ref = COMPRESS_INTERP(*ref);
                } else {
                    prevFrame.stack.pick().ref = 0;
                }
                prevFrame.stack.ref() = FLAG_OBJECT;
            }
            break;

        case JAVA_TYPE_BOOLEAN:
        case JAVA_TYPE_BYTE:
            {
                I_8 res = invokeJNI_Byte(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick().i = (I_32) res;
            }
            break;

        case JAVA_TYPE_CHAR:
            {
                uint16 res = invokeJNI_Char(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick().u = (U_32) res;
            }
            break;

        case JAVA_TYPE_SHORT:
            {
                int16 res = invokeJNI_Short(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick().i = (I_32) res;
            }
            break;

        case JAVA_TYPE_INT:
            {
                Value res;
                res.i = invokeJNI_Int(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick() = res;
            }
            break;

        case JAVA_TYPE_FLOAT:
            {
                Value res;
                res.f = invokeJNI_Float(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push();
                prevFrame.stack.pick() = res;
            }
            break;

        case JAVA_TYPE_LONG:
            {
                Value2 res;
                res.i64 = invokeJNI(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push(2);
                prevFrame.stack.setLong(0, res);
            }
            break;

        case JAVA_TYPE_DOUBLE:
            {
                Value2 res;
                res.d = invokeJNI_Double(out_args, n_fps, n_stacks, f);
                hythread_suspend_disable();
                prevFrame.stack.popClearRef(sz);

                prevFrame.stack.push(2);
                prevFrame.stack.setLong(0, res);
            }
            break;

        default:
            LDIE(53, "Unexpected java type");
    }

    if (method->is_synchronized()) {
        vm_monitor_exit_wrapper(frame.This);
    }

    if (interpreter_ti_notification_mode
            & INTERPRETER_TI_METHOD_EXIT_EVENT)
        method_exit_callback_with_frame(method, prevFrame);

    M2N_FREE_MACRO;
    DEBUG_TRACE("native_invoke_virtual >>>\n");
    FREE_FRAME(out_args);
}