| /* |
| * 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; |
| } |
