path: root/vm/compiler/codegen/x86/Lower.cpp

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed 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.
 */


/*! \file Lower.cpp
    \brief This file implements the high-level wrapper for lowering

*/

//#include "uthash.h"
#include "libdex/DexOpcodes.h"
#include "libdex/DexFile.h"
#include <math.h>
#include <sys/mman.h>
#include "Translator.h"
#include "Lower.h"
#include "enc_wrapper.h"
#include "vm/mterp/Mterp.h"
#include "NcgHelper.h"
#include "libdex/DexCatch.h"
#include "compiler/CompilerIR.h"

//statistics for optimization
int num_removed_nullCheck;

PhysicalReg scratchRegs[4];

LowOp* ops[BUFFER_SIZE];
LowOp* op;
u2* rPC; //PC pointer to bytecode
u2 inst; //current bytecode
int offsetPC/*offset in bytecode*/, offsetNCG/*byte offset in native code*/;
int ncg_rPC;
//! map from PC in bytecode to PC in native code
int mapFromBCtoNCG[BYTECODE_SIZE_PER_METHOD]; //initially mapped to -1
char* streamStart = NULL; //start of the Pure CodeItem?, not include the global symbols
char* streamCode = NULL; //start of the Pure CodeItem?, not include the global symbols
char* streamMethodStart; //start of the method
char* stream; //current stream pointer
int lowOpTimeStamp = 0;
Method* currentMethod = NULL;
int currentExceptionBlockIdx = -1;
LowOpBlockLabel* traceLabelList = NULL;
BasicBlock* traceCurrentBB = NULL;
MIR* traceCurrentMIR = NULL;
bool scheduling_is_on = false;

int common_invokeMethodNoRange();
int common_invokeMethodRange();
int common_invokeArgsDone(ArgsDoneType, bool);

//data section of .ia32:
char globalData[128];

char strClassCastException[] = "Ljava/lang/ClassCastException;";
char strInstantiationError[] = "Ljava/lang/InstantiationError;";
char strInternalError[] = "Ljava/lang/InternalError;";
char strFilledNewArrayNotImpl[] = "filled-new-array only implemented for 'int'";
char strArithmeticException[] = "Ljava/lang/ArithmeticException;";
char strArrayIndexException[] = "Ljava/lang/ArrayIndexOutOfBoundsException;";
char strArrayStoreException[] = "Ljava/lang/ArrayStoreException;";
char strDivideByZero[] = "divide by zero";
char strNegativeArraySizeException[] = "Ljava/lang/NegativeArraySizeException;";
char strNoSuchMethodError[] = "Ljava/lang/NoSuchMethodError;";
char strNullPointerException[] = "Ljava/lang/NullPointerException;";
char strStringIndexOutOfBoundsException[] = "Ljava/lang/StringIndexOutOfBoundsException;";

int LstrClassCastExceptionPtr, LstrInstantiationErrorPtr, LstrInternalError, LstrFilledNewArrayNotImpl;
int LstrArithmeticException, LstrArrayIndexException, LstrArrayStoreException, LstrStringIndexOutOfBoundsException;
int LstrDivideByZero, LstrNegativeArraySizeException, LstrNoSuchMethodError, LstrNullPointerException;
int LdoubNeg, LvaluePosInfLong, LvalueNegInfLong, LvalueNanLong, LshiftMask, Lvalue64, L64bits, LintMax, LintMin;

void initConstDataSec() {
    char* tmpPtr = globalData;

    LdoubNeg = (int)tmpPtr;
    *((u4*)tmpPtr) = 0x00000000;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0x80000000;
    tmpPtr += sizeof(u4);

    LvaluePosInfLong = (int)tmpPtr;
    *((u4*)tmpPtr) = 0xFFFFFFFF;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0x7FFFFFFF;
    tmpPtr += sizeof(u4);

    LvalueNegInfLong = (int)tmpPtr;
    *((u4*)tmpPtr) = 0x00000000;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0x80000000;
    tmpPtr += sizeof(u4);

    LvalueNanLong = (int)tmpPtr;
    *((u4*)tmpPtr) = 0;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0;
    tmpPtr += sizeof(u4);

    LshiftMask = (int)tmpPtr;
    *((u4*)tmpPtr) = 0x3f;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0;
    tmpPtr += sizeof(u4);

    Lvalue64 = (int)tmpPtr;
    *((u4*)tmpPtr) = 0x40;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0;
    tmpPtr += sizeof(u4);

    L64bits = (int)tmpPtr;
    *((u4*)tmpPtr) = 0xFFFFFFFF;
    tmpPtr += sizeof(u4);
    *((u4*)tmpPtr) = 0xFFFFFFFF;
    tmpPtr += sizeof(u4);

    LintMin = (int)tmpPtr;
    *((u4*)tmpPtr) = 0x80000000;
    tmpPtr += sizeof(u4);

    LintMax = (int)tmpPtr;
    *((u4*)tmpPtr) = 0x7FFFFFFF;
    tmpPtr += sizeof(u4);

    LstrClassCastExceptionPtr = (int)strClassCastException;
    LstrInstantiationErrorPtr = (int)strInstantiationError;
    LstrInternalError = (int)strInternalError;
    LstrFilledNewArrayNotImpl = (int)strFilledNewArrayNotImpl;
    LstrArithmeticException = (int)strArithmeticException;
    LstrArrayIndexException = (int)strArrayIndexException;
    LstrArrayStoreException = (int)strArrayStoreException;
    LstrDivideByZero = (int)strDivideByZero;
    LstrNegativeArraySizeException = (int)strNegativeArraySizeException;
    LstrNoSuchMethodError = (int)strNoSuchMethodError;
    LstrNullPointerException = (int)strNullPointerException;
    LstrStringIndexOutOfBoundsException = (int)strStringIndexOutOfBoundsException;
}

//declarations of functions used in this file
int spill_reg(int reg, bool isPhysical);
int unspill_reg(int reg, bool isPhysical);

int const_string_resolve();
int sget_sput_resolve();
int new_instance_needinit();
int new_instance_abstract();
int invoke_virtual_resolve();
int invoke_direct_resolve();
int invoke_static_resolve();
int filled_new_array_notimpl();
int resolve_class2(
                   int startLR/*logical register index*/, bool isPhysical, int indexReg/*const pool index*/,
                   bool indexPhysical,
                   int thirdArg);
int resolve_method2(
                    int startLR/*logical register index*/, bool isPhysical, int indexReg/*const pool index*/,
                    bool indexPhysical,
                    int thirdArg/*VIRTUAL*/);
int resolve_inst_field2(
                        int startLR/*logical register index*/, bool isPhysical,
                        int indexReg/*const pool index*/,
                        bool indexPhysical);
int resolve_static_field2(
                          int startLR/*logical register index*/, bool isPhysical,
                          int indexReg/*const pool index*/,
                          bool indexPhysical);

int invokeMethodNoRange_1_helper();
int invokeMethodNoRange_2_helper();
int invokeMethodNoRange_3_helper();
int invokeMethodNoRange_4_helper();
int invokeMethodNoRange_5_helper();
int invokeMethodRange_helper();

int invoke_virtual_helper();
int invoke_virtual_quick_helper();
int invoke_static_helper();
int invoke_direct_helper();
int new_instance_helper();
int sget_sput_helper(int flag);
int aput_obj_helper();
int aget_helper(int flag);
int aput_helper(int flag);
int monitor_enter_helper();
int monitor_exit_helper();
int throw_helper();
int const_string_helper();
int array_length_helper();
int invoke_super_helper();
int invoke_interface_helper();
int iget_iput_helper(int flag);
int check_cast_helper(bool instance);
int new_array_helper();

int common_returnFromMethod();

/*!
\brief dump helper functions

*/
int performCGWorklist() {
    filled_new_array_notimpl();
    freeShortMap();
    const_string_resolve();
    freeShortMap();

    resolve_class2(PhysicalReg_EAX, true, PhysicalReg_EAX, true, 0);
    freeShortMap();
    resolve_method2(PhysicalReg_EAX, true, PhysicalReg_EAX, true, METHOD_VIRTUAL);
    freeShortMap();
    resolve_method2(PhysicalReg_EAX, true, PhysicalReg_EAX, true, METHOD_DIRECT);
    freeShortMap();
    resolve_method2(PhysicalReg_EAX, true, PhysicalReg_EAX, true, METHOD_STATIC);
    freeShortMap();
    resolve_inst_field2(PhysicalReg_EAX, true, PhysicalReg_EAX, true);
    freeShortMap();
    resolve_static_field2(PhysicalReg_EAX, true, PhysicalReg_EAX, true);
    freeShortMap();
    throw_exception_message(PhysicalReg_ECX, PhysicalReg_EAX, true, PhysicalReg_Null, true);
    freeShortMap();
    throw_exception(PhysicalReg_ECX, PhysicalReg_EAX, PhysicalReg_Null, true);
    freeShortMap();
    new_instance_needinit();
    freeShortMap();
    return 0;
}

int aput_object_count;
int common_periodicChecks_entry();
int common_periodicChecks4();
/*!
\brief for debugging purpose, dump the sequence of native code for each bytecode

*/
int ncgMethodFake(Method* method) {
    //to measure code size expansion, no need to patch up labels
    methodDataWorklist = NULL;
    globalShortWorklist = NULL;
    globalNCGWorklist = NULL;
    streamMethodStart = stream;

    //initialize mapFromBCtoNCG
    memset(&mapFromBCtoNCG[0], -1, BYTECODE_SIZE_PER_METHOD * sizeof(mapFromBCtoNCG[0]));
    unsigned int i;
    u2* rStart = (u2*)malloc(5*sizeof(u2));
    if(rStart == NULL) {
        ALOGE("Memory allocation failed");
        return -1;
    }
    rPC = rStart;
    method->insns = rStart;
    for(i = 0; i < 5; i++) *rPC++ = 0;
    for(i = 0; i < 256; i++) {
        rPC = rStart;
        //modify the opcode
        char* tmp = (char*)rStart;
        *tmp++ = i;
        *tmp = i;
        inst = FETCH(0);
        char* tmpStart = stream;
        lowerByteCode(method); //use inst, rPC, method, modify rPC
        int size_in_u2 = rPC - rStart;
        if(stream - tmpStart  > 0)
            ALOGI("LOWER bytecode %x size in u2: %d ncg size in byte: %d", i, size_in_u2, stream - tmpStart);
    }
    exit(0);
}

bool existATryBlock(Method* method, int startPC, int endPC) {
    const DexCode* pCode = dvmGetMethodCode(method);
    u4 triesSize = pCode->triesSize;
    const DexTry* pTries = dexGetTries(pCode);
    unsigned int i;
    for (i = 0; i < triesSize; i++) {
        const DexTry* pTry = &pTries[i];
        u4 start = pTry->startAddr; //offsetPC
        u4 end = start + pTry->insnCount;
        //if [start, end] overlaps with [startPC, endPC] returns true
        if((int)end < startPC || (int)start > endPC) { //no overlap
        } else {
            return true;
        }
    }
    return false;
}

int mm_bytecode_size = 0;
int mm_ncg_size = 0;
int mm_relocation_size = 0;
int mm_map_size = 0;
void resetCodeSize() {
    mm_bytecode_size = 0;
    mm_ncg_size = 0;
    mm_relocation_size = 0;
    mm_map_size = 0;
}

bool bytecodeIsRemoved(const Method* method, u4 bytecodeOffset) {
    if(gDvm.executionMode == kExecutionModeNcgO0) return false;
    u4 ncgOff = mapFromBCtoNCG[bytecodeOffset];
    int k = bytecodeOffset+1;
    u2 insnsSize = dvmGetMethodInsnsSize(method);
    while(k < insnsSize) {
        if(mapFromBCtoNCG[k] < 0) {
            k++;
            continue;
        }
        if(mapFromBCtoNCG[k] == (int)ncgOff) return true;
        return false;
    }
    return false;
}

int invoke_super_nsm();
void init_common(const char* curFileName, DvmDex *pDvmDex, bool forNCG); //forward declaration
void initGlobalMethods(); //forward declaration

//called once when compiler thread starts up
void initJIT(const char* curFileName, DvmDex *pDvmDex) {
    init_common(curFileName, pDvmDex, false);
}

void init_common(const char* curFileName, DvmDex *pDvmDex, bool forNCG) {
    if(!gDvm.constInit) {
        globalMapNum = 0;
        globalMap = NULL;
        initConstDataSec();
        gDvm.constInit = true;
    }

    //for initJIT: stream is already set
    if(!gDvm.commonInit) {
        initGlobalMethods();
        gDvm.commonInit = true;
    }
}

void initGlobalMethods() {
    dump_x86_inst = false; /* DEBUG */
    // generate native code for function ncgGetEIP
    insertLabel("ncgGetEIP", false);
    move_mem_to_reg(OpndSize_32, 0, PhysicalReg_ESP, true, PhysicalReg_EDX, true);
    x86_return();

    //generate code for common labels
    //jumps within a helper function is treated as short labels
    globalShortMap = NULL;
    common_periodicChecks_entry();
    freeShortMap();
    common_periodicChecks4();
    freeShortMap();
    //common_invokeMethodNoRange();
    //common_invokeMethodRange();

    if(dump_x86_inst) ALOGI("ArgsDone_Normal start");
    common_invokeArgsDone(ArgsDone_Normal, false);
    freeShortMap();
    if(dump_x86_inst) ALOGI("ArgsDone_Native start");
    common_invokeArgsDone(ArgsDone_Native, false);
    freeShortMap();
    if(dump_x86_inst) ALOGI("ArgsDone_Full start");
    common_invokeArgsDone(ArgsDone_Full, true/*isJitFull*/);
    if(dump_x86_inst) ALOGI("ArgsDone_Full end");
    freeShortMap();

    common_backwardBranch();
    freeShortMap();
    common_exceptionThrown();
    freeShortMap();
    common_errNullObject();
    freeShortMap();
    common_errArrayIndex();
    freeShortMap();
    common_errArrayStore();
    freeShortMap();
    common_errNegArraySize();
    freeShortMap();
    common_errNoSuchMethod();
    freeShortMap();
    common_errDivideByZero();
    freeShortMap();
    common_gotoBail();
    freeShortMap();
    common_gotoBail_0();
    freeShortMap();
    invoke_super_nsm();
    freeShortMap();

    performCGWorklist(); //generate code for helper functions
    performLabelWorklist(); //it is likely that the common labels will jump to other common labels

    dump_x86_inst = false;
}

ExecutionMode origMode;
//when to update streamMethodStart
bool lowerByteCodeJit(const Method* method, const u2* codePtr, MIR* mir) {
    rPC = (u2*)codePtr;
    inst = FETCH(0);
    traceCurrentMIR = mir;
    int retCode = lowerByteCode(method);
    traceCurrentMIR = NULL;
    freeShortMap();
    if(retCode >= 0) return false; //handled
    return true; //not handled
}

void startOfBasicBlock(BasicBlock* bb) {
    traceCurrentBB = bb;
    if(gDvm.executionMode == kExecutionModeNcgO0) {
        isScratchPhysical = true;
    } else {
        isScratchPhysical = false;
    }
}

void startOfTrace(const Method* method, LowOpBlockLabel* labelList, int exceptionBlockId,
                  CompilationUnit *cUnit) {
    origMode = gDvm.executionMode;
    gDvm.executionMode = kExecutionModeNcgO1;
    if(gDvm.executionMode == kExecutionModeNcgO0) {
        isScratchPhysical = true;
    } else {
        isScratchPhysical = false;
    }
    currentMethod = (Method*)method;
    currentExceptionBlockIdx = exceptionBlockId;
    methodDataWorklist = NULL;
    globalShortWorklist = NULL;
    globalNCGWorklist = NULL;

    streamMethodStart = stream;
    //initialize mapFromBCtoNCG
    memset(&mapFromBCtoNCG[0], -1, BYTECODE_SIZE_PER_METHOD * sizeof(mapFromBCtoNCG[0]));
    traceLabelList = labelList;
    if(gDvm.executionMode == kExecutionModeNcgO1)
        startOfTraceO1(method, labelList, exceptionBlockId, cUnit);
}

void endOfTrace(bool freeOnly) {
    if(freeOnly) {
        freeLabelWorklist();
        freeNCGWorklist();
        freeDataWorklist();
        freeChainingWorklist();
    }
    else {
        performLabelWorklist();
        performNCGWorklist(); //handle forward jump (GOTO, IF)
        performDataWorklist(); //handle SWITCH & FILL_ARRAY_DATA
        performChainingWorklist();
    }
    if(gDvm.executionMode == kExecutionModeNcgO1) {
        endOfTraceO1();
    }
    gDvm.executionMode = origMode;
}

///////////////////////////////////////////////////////////////////
//!
//! each bytecode is translated to a sequence of machine codes
int lowerByteCode(const Method* method) { //inputs: rPC & inst & stream & streamMethodStart
    /* offsetPC is used in O1 code generator, where it is defined as the sequence number
       use a local version to avoid overwriting */
    int offsetPC = rPC - (u2*)method->insns;

    if(dump_x86_inst)
        ALOGI("LOWER bytecode %x at offsetPC %x offsetNCG %x @%p",
              INST_INST(inst), offsetPC, stream - streamMethodStart, stream);

    //update mapFromBCtoNCG
    offsetNCG = stream - streamMethodStart;
    if(offsetPC >= BYTECODE_SIZE_PER_METHOD) ALOGE("offsetPC %d exceeds BYTECODE_SIZE_PER_METHOD", offsetPC);
    mapFromBCtoNCG[offsetPC] = offsetNCG;
#if defined(ENABLE_TRACING) && defined(TRACING_OPTION2)
    insertMapWorklist(offsetPC, mapFromBCtoNCG[offsetPC], 1);
#endif
    //return number of LowOps generated
    switch (INST_INST(inst)) {
    case OP_NOP:
        return op_nop();
    case OP_MOVE:
    case OP_MOVE_OBJECT:
        return op_move();
    case OP_MOVE_FROM16:
    case OP_MOVE_OBJECT_FROM16:
        return op_move_from16();
    case OP_MOVE_16:
    case OP_MOVE_OBJECT_16:
        return op_move_16();
    case OP_MOVE_WIDE:
        return op_move_wide();
    case OP_MOVE_WIDE_FROM16:
        return op_move_wide_from16();
    case OP_MOVE_WIDE_16:
        return op_move_wide_16();
    case OP_MOVE_RESULT:
    case OP_MOVE_RESULT_OBJECT:
        return op_move_result();
    case OP_MOVE_RESULT_WIDE:
        return op_move_result_wide();
    case OP_MOVE_EXCEPTION:
        return op_move_exception();
    case OP_RETURN_VOID:
    case OP_RETURN_VOID_BARRIER:
        return op_return_void();
    case OP_RETURN:
    case OP_RETURN_OBJECT:
        return op_return();
    case OP_RETURN_WIDE:
        return op_return_wide();
    case OP_CONST_4:
        return op_const_4();
    case OP_CONST_16:
        return op_const_16();
    case OP_CONST:
        return op_const();
    case OP_CONST_HIGH16:
        return op_const_high16();
    case OP_CONST_WIDE_16:
        return op_const_wide_16();
    case OP_CONST_WIDE_32:
        return op_const_wide_32();
    case OP_CONST_WIDE:
        return op_const_wide();
    case OP_CONST_WIDE_HIGH16:
        return op_const_wide_high16();
    case OP_CONST_STRING:
        return op_const_string();
    case OP_CONST_STRING_JUMBO:
        return op_const_string_jumbo();
    case OP_CONST_CLASS:
        return op_const_class();
    case OP_MONITOR_ENTER:
        return op_monitor_enter();
    case OP_MONITOR_EXIT:
        return op_monitor_exit();
    case OP_CHECK_CAST:
        return op_check_cast();
    case OP_INSTANCE_OF:
        return op_instance_of();
    case OP_ARRAY_LENGTH:
        return op_array_length();
    case OP_NEW_INSTANCE:
        return op_new_instance();
    case OP_NEW_ARRAY:
        return op_new_array();
    case OP_FILLED_NEW_ARRAY:
        return op_filled_new_array();
    case OP_FILLED_NEW_ARRAY_RANGE:
        return op_filled_new_array_range();
    case OP_FILL_ARRAY_DATA:
        return op_fill_array_data();
    case OP_THROW:
        return op_throw();
    case OP_THROW_VERIFICATION_ERROR:
        return op_throw_verification_error();
    case OP_GOTO:
        return op_goto();
    case OP_GOTO_16:
        return op_goto_16();
    case OP_GOTO_32:
        return op_goto_32();
    case OP_PACKED_SWITCH:
        return op_packed_switch();
    case OP_SPARSE_SWITCH:
        return op_sparse_switch();
    case OP_CMPL_FLOAT:
        return op_cmpl_float();
    case OP_CMPG_FLOAT:
        return op_cmpg_float();
    case OP_CMPL_DOUBLE:
        return op_cmpl_double();
    case OP_CMPG_DOUBLE:
        return op_cmpg_double();
    case OP_CMP_LONG:
        return op_cmp_long();
    case OP_IF_EQ:
        return op_if_eq();
    case OP_IF_NE:
        return op_if_ne();
    case OP_IF_LT:
        return op_if_lt();
    case OP_IF_GE:
        return op_if_ge();
    case OP_IF_GT:
        return op_if_gt();
    case OP_IF_LE:
        return op_if_le();
    case OP_IF_EQZ:
        return op_if_eqz();
    case OP_IF_NEZ:
        return op_if_nez();
    case OP_IF_LTZ:
        return op_if_ltz();
    case OP_IF_GEZ:
        return op_if_gez();
    case OP_IF_GTZ:
        return op_if_gtz();
    case OP_IF_LEZ:
        return op_if_lez();
    case OP_AGET:
        return op_aget();
    case OP_AGET_WIDE:
        return op_aget_wide();
    case OP_AGET_OBJECT:
        return op_aget_object();
    case OP_AGET_BOOLEAN:
        return op_aget_boolean();
    case OP_AGET_BYTE:
        return op_aget_byte();
    case OP_AGET_CHAR:
        return op_aget_char();
    case OP_AGET_SHORT:
        return op_aget_short();
    case OP_APUT:
        return op_aput();
    case OP_APUT_WIDE:
        return op_aput_wide();
    case OP_APUT_OBJECT:
        return op_aput_object();
    case OP_APUT_BOOLEAN:
        return op_aput_boolean();
    case OP_APUT_BYTE:
        return op_aput_byte();
    case OP_APUT_CHAR:
        return op_aput_char();
    case OP_APUT_SHORT:
        return op_aput_short();
    case OP_IGET:
    case OP_IGET_VOLATILE:
        return op_iget();
    case OP_IGET_WIDE:
        return op_iget_wide(false); // isVolatile==false
    case OP_IGET_WIDE_VOLATILE:
        return op_iget_wide(true);  // isVolatile==true
    case OP_IGET_OBJECT:
    case OP_IGET_OBJECT_VOLATILE:
        return op_iget_object();
    case OP_IGET_BOOLEAN:
        return op_iget_boolean();
    case OP_IGET_BYTE:
        return op_iget_byte();
    case OP_IGET_CHAR:
        return op_iget_char();
    case OP_IGET_SHORT:
        return op_iget_short();
    case OP_IPUT:
    case OP_IPUT_VOLATILE:
        return op_iput();
    case OP_IPUT_WIDE:
        return op_iput_wide(false); // isVolatile==false
    case OP_IPUT_WIDE_VOLATILE:
        return op_iput_wide(true);  // isVolatile==true
    case OP_IPUT_OBJECT:
    case OP_IPUT_OBJECT_VOLATILE:
        return op_iput_object();
    case OP_IPUT_BOOLEAN:
        return op_iput_boolean();
    case OP_IPUT_BYTE:
        return op_iput_byte();
    case OP_IPUT_CHAR:
        return op_iput_char();
    case OP_IPUT_SHORT:
        return op_iput_short();
    case OP_SGET:
    case OP_SGET_VOLATILE:
        return op_sget();
    case OP_SGET_WIDE:
        return op_sget_wide(false); // isVolatile==false
    case OP_SGET_WIDE_VOLATILE:
        return op_sget_wide(true);  // isVolatile==true
    case OP_SGET_OBJECT:
    case OP_SGET_OBJECT_VOLATILE:
        return op_sget_object();
    case OP_SGET_BOOLEAN:
        return op_sget_boolean();
    case OP_SGET_BYTE:
        return op_sget_byte();
    case OP_SGET_CHAR:
        return op_sget_char();
    case OP_SGET_SHORT:
        return op_sget_short();
    case OP_SPUT:
    case OP_SPUT_VOLATILE:
        return op_sput(false);
    case OP_SPUT_WIDE:
        return op_sput_wide(false); // isVolatile==false
    case OP_SPUT_WIDE_VOLATILE:
        return op_sput_wide(true);  // isVolatile==true
    case OP_SPUT_OBJECT:
    case OP_SPUT_OBJECT_VOLATILE:
        return op_sput_object();
    case OP_SPUT_BOOLEAN:
        return op_sput_boolean();
    case OP_SPUT_BYTE:
        return op_sput_byte();
    case OP_SPUT_CHAR:
        return op_sput_char();
    case OP_SPUT_SHORT:
        return op_sput_short();
    case OP_INVOKE_VIRTUAL:
        return op_invoke_virtual();
    case OP_INVOKE_SUPER:
        return op_invoke_super();
    case OP_INVOKE_DIRECT:
        return op_invoke_direct();
    case OP_INVOKE_STATIC:
        return op_invoke_static();
    case OP_INVOKE_INTERFACE:
        return op_invoke_interface();
    case OP_INVOKE_VIRTUAL_RANGE:
        return op_invoke_virtual_range();
    case OP_INVOKE_SUPER_RANGE:
        return op_invoke_super_range();
    case OP_INVOKE_DIRECT_RANGE:
        return op_invoke_direct_range();
    case OP_INVOKE_STATIC_RANGE:
        return op_invoke_static_range();
    case OP_INVOKE_INTERFACE_RANGE:
        return op_invoke_interface_range();
    case OP_NEG_INT:
        return op_neg_int();
    case OP_NOT_INT:
        return op_not_int();
    case OP_NEG_LONG:
        return op_neg_long();
    case OP_NOT_LONG:
        return op_not_long();
    case OP_NEG_FLOAT:
        return op_neg_float();
    case OP_NEG_DOUBLE:
        return op_neg_double();
    case OP_INT_TO_LONG:
        return op_int_to_long();
    case OP_INT_TO_FLOAT:
        return op_int_to_float();
    case OP_INT_TO_DOUBLE:
        return op_int_to_double();
    case OP_LONG_TO_INT:
        return op_long_to_int();
    case OP_LONG_TO_FLOAT:
        return op_long_to_float();
    case OP_LONG_TO_DOUBLE:
        return op_long_to_double();
    case OP_FLOAT_TO_INT:
        return op_float_to_int();
    case OP_FLOAT_TO_LONG:
        return op_float_to_long();
    case OP_FLOAT_TO_DOUBLE:
        return op_float_to_double();
    case OP_DOUBLE_TO_INT:
        return op_double_to_int();
    case OP_DOUBLE_TO_LONG:
        return op_double_to_long();
    case OP_DOUBLE_TO_FLOAT:
        return op_double_to_float();
    case OP_INT_TO_BYTE:
        return op_int_to_byte();
    case OP_INT_TO_CHAR:
        return op_int_to_char();
    case OP_INT_TO_SHORT:
        return op_int_to_short();
    case OP_ADD_INT:
        return op_add_int();
    case OP_SUB_INT:
        return op_sub_int();
    case OP_MUL_INT:
        return op_mul_int();
    case OP_DIV_INT:
        return op_div_int();
    case OP_REM_INT:
        return op_rem_int();
    case OP_AND_INT:
        return op_and_int();
    case OP_OR_INT:
        return op_or_int();
    case OP_XOR_INT:
        return op_xor_int();
    case OP_SHL_INT:
        return op_shl_int();
    case OP_SHR_INT:
        return op_shr_int();
    case OP_USHR_INT:
        return op_ushr_int();
    case OP_ADD_LONG:
        return op_add_long();
    case OP_SUB_LONG:
        return op_sub_long();
    case OP_MUL_LONG:
        return op_mul_long();
    case OP_DIV_LONG:
        return op_div_long();
    case OP_REM_LONG:
        return op_rem_long();
    case OP_AND_LONG:
        return op_and_long();
    case OP_OR_LONG:
        return op_or_long();
    case OP_XOR_LONG:
        return op_xor_long();
    case OP_SHL_LONG:
        return op_shl_long();
    case OP_SHR_LONG:
        return op_shr_long();
    case OP_USHR_LONG:
        return op_ushr_long();
    case OP_ADD_FLOAT:
        return op_add_float();
    case OP_SUB_FLOAT:
        return op_sub_float();
    case OP_MUL_FLOAT:
        return op_mul_float();
    case OP_DIV_FLOAT:
        return op_div_float();
    case OP_REM_FLOAT:
        return op_rem_float();
    case OP_ADD_DOUBLE:
        return op_add_double();
    case OP_SUB_DOUBLE:
        return op_sub_double();
    case OP_MUL_DOUBLE:
        return op_mul_double();
    case OP_DIV_DOUBLE:
        return op_div_double();
    case OP_REM_DOUBLE:
        return op_rem_double();
    case OP_ADD_INT_2ADDR:
        return op_add_int_2addr();
    case OP_SUB_INT_2ADDR:
        return op_sub_int_2addr();
    case OP_MUL_INT_2ADDR:
        return op_mul_int_2addr();
    case OP_DIV_INT_2ADDR:
        return op_div_int_2addr();
    case OP_REM_INT_2ADDR:
        return op_rem_int_2addr();
    case OP_AND_INT_2ADDR:
        return op_and_int_2addr();
    case OP_OR_INT_2ADDR:
        return op_or_int_2addr();
    case OP_XOR_INT_2ADDR:
        return op_xor_int_2addr();
    case OP_SHL_INT_2ADDR:
        return op_shl_int_2addr();
    case OP_SHR_INT_2ADDR:
        return op_shr_int_2addr();
    case OP_USHR_INT_2ADDR:
        return op_ushr_int_2addr();
    case OP_ADD_LONG_2ADDR:
        return op_add_long_2addr();
    case OP_SUB_LONG_2ADDR:
        return op_sub_long_2addr();
    case OP_MUL_LONG_2ADDR:
        return op_mul_long_2addr();
    case OP_DIV_LONG_2ADDR:
        return op_div_long_2addr();
    case OP_REM_LONG_2ADDR:
        return op_rem_long_2addr();
    case OP_AND_LONG_2ADDR:
        return op_and_long_2addr();
    case OP_OR_LONG_2ADDR:
        return op_or_long_2addr();
    case OP_XOR_LONG_2ADDR:
        return op_xor_long_2addr();
    case OP_SHL_LONG_2ADDR:
        return op_shl_long_2addr();
    case OP_SHR_LONG_2ADDR:
        return op_shr_long_2addr();
    case OP_USHR_LONG_2ADDR:
        return op_ushr_long_2addr();
    case OP_ADD_FLOAT_2ADDR:
        return op_add_float_2addr();
    case OP_SUB_FLOAT_2ADDR:
        return op_sub_float_2addr();
    case OP_MUL_FLOAT_2ADDR:
        return op_mul_float_2addr();
    case OP_DIV_FLOAT_2ADDR:
        return op_div_float_2addr();
    case OP_REM_FLOAT_2ADDR:
        return op_rem_float_2addr();
    case OP_ADD_DOUBLE_2ADDR:
        return op_add_double_2addr();
    case OP_SUB_DOUBLE_2ADDR:
        return op_sub_double_2addr();
    case OP_MUL_DOUBLE_2ADDR:
        return op_mul_double_2addr();
    case OP_DIV_DOUBLE_2ADDR:
        return op_div_double_2addr();
    case OP_REM_DOUBLE_2ADDR:
        return op_rem_double_2addr();
    case OP_ADD_INT_LIT16:
        return op_add_int_lit16();
    case OP_RSUB_INT:
        return op_rsub_int();
    case OP_MUL_INT_LIT16:
        return op_mul_int_lit16();
    case OP_DIV_INT_LIT16:
        return op_div_int_lit16();
    case OP_REM_INT_LIT16:
        return op_rem_int_lit16();
    case OP_AND_INT_LIT16:
        return op_and_int_lit16();
    case OP_OR_INT_LIT16:
        return op_or_int_lit16();
    case OP_XOR_INT_LIT16:
        return op_xor_int_lit16();
    case OP_ADD_INT_LIT8:
        return op_add_int_lit8();
    case OP_RSUB_INT_LIT8:
        return op_rsub_int_lit8();
    case OP_MUL_INT_LIT8:
        return op_mul_int_lit8();
    case OP_DIV_INT_LIT8:
        return op_div_int_lit8();
    case OP_REM_INT_LIT8:
        return op_rem_int_lit8();
    case OP_AND_INT_LIT8:
        return op_and_int_lit8();
    case OP_OR_INT_LIT8:
        return op_or_int_lit8();
    case OP_XOR_INT_LIT8:
        return op_xor_int_lit8();
    case OP_SHL_INT_LIT8:
        return op_shl_int_lit8();
    case OP_SHR_INT_LIT8:
        return op_shr_int_lit8();
    case OP_USHR_INT_LIT8:
        return op_ushr_int_lit8();
    case OP_EXECUTE_INLINE:
        return op_execute_inline(false);
    case OP_EXECUTE_INLINE_RANGE:
        return op_execute_inline(true);
    case OP_BREAKPOINT:
        ALOGE("found bytecode OP_BREAKPOINT");
        dvmAbort();
    case OP_INVOKE_OBJECT_INIT_RANGE:
        return op_invoke_object_init_range();
    case OP_IGET_QUICK:
        return op_iget_quick();
    case OP_IGET_WIDE_QUICK:
        return op_iget_wide_quick();
    case OP_IGET_OBJECT_QUICK:
        return op_iget_object_quick();
    case OP_IPUT_QUICK:
        return op_iput_quick();
    case OP_IPUT_WIDE_QUICK:
        return op_iput_wide_quick();
    case OP_IPUT_OBJECT_QUICK:
        return op_iput_object_quick();
    case OP_INVOKE_VIRTUAL_QUICK:
        return op_invoke_virtual_quick();
    case OP_INVOKE_VIRTUAL_QUICK_RANGE:
        return op_invoke_virtual_quick_range();
    case OP_INVOKE_SUPER_QUICK:
        return op_invoke_super_quick();
    case OP_INVOKE_SUPER_QUICK_RANGE:
        return op_invoke_super_quick_range();
    }

    ALOGE("No JIT support for bytecode %x at offsetPC %x",
          INST_INST(inst), offsetPC);
    return -1;
}
int op_nop() {
    rPC++;
    return 0;
}