| /* |
| * 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 BytecodeVisitor.cpp |
| \brief This file implements visitors of the bytecode |
| */ |
| #include "libdex/DexOpcodes.h" |
| #include "libdex/DexFile.h" |
| #include "Lower.h" |
| #include "AnalysisO1.h" |
| |
| //! Returns size of the current bytecode in u2 unit |
| |
| //! |
| int getByteCodeSize() { //uses inst, unit in u2 |
| switch (INST_INST(inst)) { |
| case OP_NOP: |
| return 1; |
| case OP_MOVE: |
| case OP_MOVE_OBJECT: |
| return 1; |
| case OP_MOVE_FROM16: |
| case OP_MOVE_OBJECT_FROM16: |
| return 2; |
| case OP_MOVE_16: |
| case OP_MOVE_OBJECT_16: |
| return 3; |
| case OP_MOVE_WIDE: |
| return 1; |
| case OP_MOVE_WIDE_FROM16: |
| return 2; |
| case OP_MOVE_WIDE_16: |
| return 3; |
| case OP_MOVE_RESULT: |
| case OP_MOVE_RESULT_OBJECT: |
| return 1; |
| case OP_MOVE_RESULT_WIDE: |
| return 1; |
| case OP_MOVE_EXCEPTION: |
| return 1; |
| case OP_RETURN_VOID: |
| case OP_RETURN_VOID_BARRIER: |
| return 1; |
| case OP_RETURN: |
| case OP_RETURN_OBJECT: |
| return 1; |
| case OP_RETURN_WIDE: |
| return 1; |
| case OP_CONST_4: |
| return 1; |
| case OP_CONST_16: |
| return 2; |
| case OP_CONST: |
| return 3; |
| case OP_CONST_HIGH16: |
| return 2; |
| case OP_CONST_WIDE_16: |
| return 2; |
| case OP_CONST_WIDE_32: |
| return 3; |
| case OP_CONST_WIDE: |
| return 5; |
| case OP_CONST_WIDE_HIGH16: |
| return 2; |
| case OP_CONST_STRING: |
| return 2; |
| case OP_CONST_STRING_JUMBO: |
| return 3; |
| case OP_CONST_CLASS: |
| return 2; |
| case OP_MONITOR_ENTER: |
| return 1; |
| case OP_MONITOR_EXIT: |
| return 1; |
| case OP_CHECK_CAST: |
| return 2; |
| case OP_INSTANCE_OF: |
| return 2; |
| case OP_ARRAY_LENGTH: |
| return 1; |
| case OP_NEW_INSTANCE: |
| return 2; |
| case OP_NEW_ARRAY: |
| return 2; |
| case OP_FILLED_NEW_ARRAY: |
| return 3; |
| case OP_FILLED_NEW_ARRAY_RANGE: |
| return 3; |
| case OP_FILL_ARRAY_DATA: |
| return 3; |
| case OP_THROW: |
| return 1; |
| case OP_THROW_VERIFICATION_ERROR: |
| return 2; |
| case OP_GOTO: |
| return 1; |
| case OP_GOTO_16: |
| return 2; |
| case OP_GOTO_32: |
| return 3; |
| case OP_PACKED_SWITCH: |
| return 3; |
| case OP_SPARSE_SWITCH: |
| return 3; |
| case OP_CMPL_FLOAT: |
| return 2; |
| case OP_CMPG_FLOAT: |
| return 2; |
| case OP_CMPL_DOUBLE: |
| return 2; |
| case OP_CMPG_DOUBLE: |
| return 2; |
| case OP_CMP_LONG: |
| return 2; |
| case OP_IF_EQ: |
| return 2; |
| case OP_IF_NE: |
| return 2; |
| case OP_IF_LT: |
| return 2; |
| case OP_IF_GE: |
| return 2; |
| case OP_IF_GT: |
| return 2; |
| case OP_IF_LE: |
| return 2; |
| case OP_IF_EQZ: |
| return 2; |
| case OP_IF_NEZ: |
| return 2; |
| case OP_IF_LTZ: |
| return 2; |
| case OP_IF_GEZ: |
| return 2; |
| case OP_IF_GTZ: |
| return 2; |
| case OP_IF_LEZ: |
| return 2; |
| case OP_AGET: |
| return 2; |
| case OP_AGET_WIDE: |
| return 2; |
| case OP_AGET_OBJECT: |
| return 2; |
| case OP_AGET_BOOLEAN: |
| return 2; |
| case OP_AGET_BYTE: |
| return 2; |
| case OP_AGET_CHAR: |
| return 2; |
| case OP_AGET_SHORT: |
| return 2; |
| case OP_APUT: |
| return 2; |
| case OP_APUT_WIDE: |
| return 2; |
| case OP_APUT_OBJECT: |
| return 2; |
| case OP_APUT_BOOLEAN: |
| return 2; |
| case OP_APUT_BYTE: |
| return 2; |
| case OP_APUT_CHAR: |
| return 2; |
| case OP_APUT_SHORT: |
| return 2; |
| case OP_IGET: |
| case OP_IGET_WIDE: |
| case OP_IGET_OBJECT: |
| case OP_IGET_VOLATILE: |
| case OP_IGET_WIDE_VOLATILE: |
| case OP_IGET_OBJECT_VOLATILE: |
| case OP_IGET_BOOLEAN: |
| case OP_IGET_BYTE: |
| case OP_IGET_CHAR: |
| case OP_IGET_SHORT: |
| case OP_IPUT: |
| case OP_IPUT_WIDE: |
| case OP_IPUT_OBJECT: |
| case OP_IPUT_VOLATILE: |
| case OP_IPUT_WIDE_VOLATILE: |
| case OP_IPUT_OBJECT_VOLATILE: |
| case OP_IPUT_BOOLEAN: |
| case OP_IPUT_BYTE: |
| case OP_IPUT_CHAR: |
| case OP_IPUT_SHORT: |
| return 2; |
| case OP_SGET: |
| case OP_SGET_WIDE: |
| case OP_SGET_OBJECT: |
| case OP_SGET_VOLATILE: |
| case OP_SGET_WIDE_VOLATILE: |
| case OP_SGET_OBJECT_VOLATILE: |
| case OP_SGET_BOOLEAN: |
| case OP_SGET_BYTE: |
| case OP_SGET_CHAR: |
| case OP_SGET_SHORT: |
| case OP_SPUT: |
| case OP_SPUT_WIDE: |
| case OP_SPUT_OBJECT: |
| case OP_SPUT_VOLATILE: |
| case OP_SPUT_WIDE_VOLATILE: |
| case OP_SPUT_OBJECT_VOLATILE: |
| case OP_SPUT_BOOLEAN: |
| case OP_SPUT_BYTE: |
| case OP_SPUT_CHAR: |
| case OP_SPUT_SHORT: |
| return 2; |
| case OP_INVOKE_VIRTUAL: |
| case OP_INVOKE_SUPER: |
| case OP_INVOKE_DIRECT: |
| case OP_INVOKE_STATIC: |
| case OP_INVOKE_INTERFACE: |
| case OP_INVOKE_VIRTUAL_RANGE: |
| case OP_INVOKE_SUPER_RANGE: |
| case OP_INVOKE_DIRECT_RANGE: |
| case OP_INVOKE_STATIC_RANGE: |
| case OP_INVOKE_INTERFACE_RANGE: |
| return 3; |
| |
| case OP_NEG_INT: |
| case OP_NOT_INT: |
| case OP_NEG_LONG: |
| case OP_NOT_LONG: |
| case OP_NEG_FLOAT: |
| case OP_NEG_DOUBLE: |
| case OP_INT_TO_LONG: |
| case OP_INT_TO_FLOAT: |
| case OP_INT_TO_DOUBLE: |
| case OP_LONG_TO_INT: |
| case OP_LONG_TO_FLOAT: |
| case OP_LONG_TO_DOUBLE: |
| case OP_FLOAT_TO_INT: |
| case OP_FLOAT_TO_LONG: |
| case OP_FLOAT_TO_DOUBLE: |
| case OP_DOUBLE_TO_INT: |
| case OP_DOUBLE_TO_LONG: |
| case OP_DOUBLE_TO_FLOAT: |
| case OP_INT_TO_BYTE: |
| case OP_INT_TO_CHAR: |
| case OP_INT_TO_SHORT: |
| return 1; |
| |
| case OP_ADD_INT: |
| case OP_SUB_INT: |
| case OP_MUL_INT: |
| case OP_DIV_INT: |
| case OP_REM_INT: |
| case OP_AND_INT: |
| case OP_OR_INT: |
| case OP_XOR_INT: |
| case OP_SHL_INT: |
| case OP_SHR_INT: |
| case OP_USHR_INT: |
| case OP_ADD_LONG: |
| case OP_SUB_LONG: |
| case OP_MUL_LONG: |
| case OP_DIV_LONG: |
| case OP_REM_LONG: |
| case OP_AND_LONG: |
| case OP_OR_LONG: |
| case OP_XOR_LONG: |
| case OP_SHL_LONG: |
| case OP_SHR_LONG: |
| case OP_USHR_LONG: |
| case OP_ADD_FLOAT: |
| case OP_SUB_FLOAT: |
| case OP_MUL_FLOAT: |
| case OP_DIV_FLOAT: |
| case OP_REM_FLOAT: |
| case OP_ADD_DOUBLE: |
| case OP_SUB_DOUBLE: |
| case OP_MUL_DOUBLE: |
| case OP_DIV_DOUBLE: |
| case OP_REM_DOUBLE: |
| return 2; |
| |
| case OP_ADD_INT_2ADDR: |
| case OP_SUB_INT_2ADDR: |
| case OP_MUL_INT_2ADDR: |
| case OP_DIV_INT_2ADDR: |
| case OP_REM_INT_2ADDR: |
| case OP_AND_INT_2ADDR: |
| case OP_OR_INT_2ADDR: |
| case OP_XOR_INT_2ADDR: |
| case OP_SHL_INT_2ADDR: |
| case OP_SHR_INT_2ADDR: |
| case OP_USHR_INT_2ADDR: |
| case OP_ADD_LONG_2ADDR: |
| case OP_SUB_LONG_2ADDR: |
| case OP_MUL_LONG_2ADDR: |
| case OP_DIV_LONG_2ADDR: |
| case OP_REM_LONG_2ADDR: |
| case OP_AND_LONG_2ADDR: |
| case OP_OR_LONG_2ADDR: |
| case OP_XOR_LONG_2ADDR: |
| case OP_SHL_LONG_2ADDR: |
| case OP_SHR_LONG_2ADDR: |
| case OP_USHR_LONG_2ADDR: |
| case OP_ADD_FLOAT_2ADDR: |
| case OP_SUB_FLOAT_2ADDR: |
| case OP_MUL_FLOAT_2ADDR: |
| case OP_DIV_FLOAT_2ADDR: |
| case OP_REM_FLOAT_2ADDR: |
| case OP_ADD_DOUBLE_2ADDR: |
| case OP_SUB_DOUBLE_2ADDR: |
| case OP_MUL_DOUBLE_2ADDR: |
| case OP_DIV_DOUBLE_2ADDR: |
| case OP_REM_DOUBLE_2ADDR: |
| return 1; |
| |
| case OP_ADD_INT_LIT16: |
| case OP_RSUB_INT: |
| case OP_MUL_INT_LIT16: |
| case OP_DIV_INT_LIT16: |
| case OP_REM_INT_LIT16: |
| case OP_AND_INT_LIT16: |
| case OP_OR_INT_LIT16: |
| case OP_XOR_INT_LIT16: |
| return 2; |
| |
| case OP_ADD_INT_LIT8: |
| case OP_RSUB_INT_LIT8: |
| case OP_MUL_INT_LIT8: |
| case OP_DIV_INT_LIT8: |
| case OP_REM_INT_LIT8: |
| case OP_AND_INT_LIT8: |
| case OP_OR_INT_LIT8: |
| case OP_XOR_INT_LIT8: |
| case OP_SHL_INT_LIT8: |
| case OP_SHR_INT_LIT8: |
| case OP_USHR_INT_LIT8: |
| return 2; |
| |
| case OP_EXECUTE_INLINE: |
| case OP_EXECUTE_INLINE_RANGE: |
| return 3; |
| #if FIXME |
| case OP_INVOKE_OBJECT_INIT_RANGE: |
| return 3; |
| #endif |
| |
| case OP_IGET_QUICK: |
| case OP_IGET_WIDE_QUICK: |
| case OP_IGET_OBJECT_QUICK: |
| case OP_IPUT_QUICK: |
| case OP_IPUT_WIDE_QUICK: |
| case OP_IPUT_OBJECT_QUICK: |
| return 2; |
| |
| case OP_INVOKE_VIRTUAL_QUICK: |
| case OP_INVOKE_VIRTUAL_QUICK_RANGE: |
| case OP_INVOKE_SUPER_QUICK: |
| case OP_INVOKE_SUPER_QUICK_RANGE: |
| return 3; |
| #ifdef SUPPORT_HLO |
| case kExtInstruction: |
| switch(inst) { |
| case OP_X_AGET_QUICK: |
| case OP_X_AGET_WIDE_QUICK: |
| case OP_X_AGET_OBJECT_QUICK: |
| case OP_X_AGET_BOOLEAN_QUICK: |
| case OP_X_AGET_BYTE_QUICK: |
| case OP_X_AGET_CHAR_QUICK: |
| case OP_X_AGET_SHORT_QUICK: |
| case OP_X_APUT_QUICK: |
| case OP_X_APUT_WIDE_QUICK: |
| case OP_X_APUT_OBJECT_QUICK: |
| case OP_X_APUT_BOOLEAN_QUICK: |
| case OP_X_APUT_BYTE_QUICK: |
| case OP_X_APUT_CHAR_QUICK: |
| case OP_X_APUT_SHORT_QUICK: |
| return 3; |
| case OP_X_DEREF_GET: |
| case OP_X_DEREF_GET_OBJECT: |
| case OP_X_DEREF_GET_WIDE: |
| case OP_X_DEREF_GET_BOOLEAN: |
| case OP_X_DEREF_GET_BYTE: |
| case OP_X_DEREF_GET_CHAR: |
| case OP_X_DEREF_GET_SHORT: |
| case OP_X_DEREF_PUT: |
| case OP_X_DEREF_PUT_WIDE: |
| case OP_X_DEREF_PUT_OBJECT: |
| case OP_X_DEREF_PUT_BOOLEAN: |
| case OP_X_DEREF_PUT_BYTE: |
| case OP_X_DEREF_PUT_CHAR: |
| case OP_X_DEREF_PUT_SHORT: |
| return 2; |
| case OP_X_ARRAY_CHECKS: |
| case OP_X_ARRAY_OBJECT_CHECKS: |
| return 3; |
| case OP_X_CHECK_BOUNDS: |
| case OP_X_CHECK_NULL: |
| case OP_X_CHECK_TYPE: |
| return 2; |
| } |
| #endif |
| } |
| return -1; |
| } |
| //! reduces refCount of a virtual register |
| |
| //! |
| void touchOneVR(u2 vA, LowOpndRegType type) { |
| int index = searchCompileTable(LowOpndRegType_virtual | type, vA); |
| if(index < 0) { |
| ALOGE("virtual reg %d type %d not found in touchOneVR", vA, type); |
| return; |
| } |
| compileTable[index].refCount--; |
| } |
| //! reduces refCount of two virtual registers |
| |
| //! |
| void touchTwoVRs(u2 vA, u2 vB, LowOpndRegType type) { |
| int index = searchCompileTable(LowOpndRegType_virtual | type, vA); |
| if(index < 0) { |
| ALOGE("virtual reg vA %d type %d not found in touchTwoVRs", vA, type); |
| return; |
| } |
| compileTable[index].refCount--; |
| index = searchCompileTable(LowOpndRegType_virtual | type, vB); |
| if(index < 0) { |
| ALOGE("virtual reg vB %d type %d not found in touchTwoVRs", vB, type); |
| return; |
| } |
| compileTable[index].refCount--; |
| } |
| int num_const_worklist; |
| //! worklist to update constVRTable later |
| int constWorklist[10]; |
| |
| int num_const_vr; //in a basic block |
| //! table to store the constant information for virtual registers |
| ConstVRInfo constVRTable[MAX_CONST_REG]; |
| //! update constVRTable for a given virtual register |
| |
| //! set "isConst" to false |
| void setVRToNonConst(int regNum, OpndSize size) { |
| int k; |
| int indexL = -1; |
| int indexH = -1; |
| for(k = 0; k < num_const_vr; k++) { |
| if(constVRTable[k].regNum == regNum) { |
| indexL = k; |
| continue; |
| } |
| if(constVRTable[k].regNum == regNum + 1 && size == OpndSize_64) { |
| indexH = k; |
| continue; |
| } |
| } |
| if(indexL >= 0) { |
| //remove this entry?? |
| constVRTable[indexL].isConst = false; |
| } |
| if(size == OpndSize_64 && indexH >= 0) { |
| constVRTable[indexH].isConst = false; |
| } |
| } |
| //! update constVRTable for a given virtual register |
| |
| //! set "isConst" to true |
| void setVRToConst(int regNum, OpndSize size, int* tmpValue) { |
| int k; |
| int indexL = -1; |
| int indexH = -1; |
| for(k = 0; k < num_const_vr; k++) { |
| if(constVRTable[k].regNum == regNum) { |
| indexL = k; |
| continue; |
| } |
| if(constVRTable[k].regNum == regNum + 1 && size == OpndSize_64) { |
| indexH = k; |
| continue; |
| } |
| } |
| if(indexL < 0) { |
| indexL = num_const_vr; |
| constVRTable[indexL].regNum = regNum; |
| num_const_vr++; |
| } |
| constVRTable[indexL].isConst = true; |
| constVRTable[indexL].value = tmpValue[0]; |
| if(size == OpndSize_64) { |
| if(indexH < 0) { |
| indexH = num_const_vr; |
| constVRTable[indexH].regNum = regNum+1; |
| num_const_vr++; |
| } |
| constVRTable[indexH].isConst = true; |
| constVRTable[indexH].value = tmpValue[1]; |
| } |
| if(num_const_vr > MAX_CONST_REG) ALOGE("constVRTable overflows"); |
| invalidateVRDueToConst(regNum, size); |
| } |
| |
| //! perform work on constWorklist |
| |
| //! |
| void updateConstInfo(BasicBlock_O1* bb) { |
| if(bb == NULL) return; |
| int k; |
| for(k = 0; k < num_const_worklist; k++) { |
| //int indexOrig = constWorklist[k]; |
| //compileTable[indexOrig].isConst = false; |
| //int A = compileTable[indexOrig].regNum; |
| //LowOpndRegType type = compileTable[indexOrig].physicalType & MASK_FOR_TYPE; |
| setVRToNonConst(constWorklist[k], OpndSize_32); |
| } |
| } |
| //! check whether the current bytecode generates a const |
| |
| //! if yes, update constVRTable; otherwise, update constWorklist |
| //! if a bytecode uses vA (const), and updates vA to non const, getConstInfo will return false and update constWorklist to make sure when lowering the bytecode, vA is treated as constant |
| bool getConstInfo(BasicBlock_O1* bb) { |
| compileTableEntry* infoArray = compileTable; |
| u2 inst_op = INST_INST(inst); |
| u2 vA = 0, vB = 0, v1, v2; |
| u2 BBBB; |
| u2 tmp_u2; |
| s4 tmp_s4; |
| u4 tmp_u4; |
| int entry, tmpValue[2], tmpValue2[2]; |
| num_const_worklist = 0; |
| |
| switch(inst_op) { |
| //for other opcode, if update the register, set isConst to false |
| case OP_MOVE: |
| case OP_MOVE_OBJECT: |
| case OP_MOVE_FROM16: |
| case OP_MOVE_OBJECT_FROM16: |
| case OP_MOVE_16: |
| case OP_MOVE_OBJECT_16: |
| if(inst_op == OP_MOVE || inst_op == OP_MOVE_OBJECT) { |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| } |
| else if(inst_op == OP_MOVE_FROM16 || inst_op == OP_MOVE_OBJECT_FROM16) { |
| vA = INST_AA(inst); |
| vB = FETCH(1); |
| } |
| else if(inst_op == OP_MOVE_16 || inst_op == OP_MOVE_OBJECT_16) { |
| vA = FETCH(1); |
| vB = FETCH(2); |
| } |
| if(isVirtualRegConstant(vB, LowOpndRegType_gp, tmpValue, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = tmpValue[0]; |
| compileTable[entry].refCount--; |
| touchOneVR(vB, LowOpndRegType_gp); |
| return true; |
| } else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| } |
| return false; |
| case OP_MOVE_WIDE: |
| case OP_MOVE_WIDE_FROM16: |
| case OP_MOVE_WIDE_16: |
| if(inst_op == OP_MOVE_WIDE) { |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| } |
| else if(inst_op == OP_MOVE_WIDE_FROM16) { |
| vA = INST_AA(inst); |
| vB = FETCH(1); |
| } |
| else if(inst_op == OP_MOVE_WIDE_16) { |
| vA = FETCH(1); |
| vB = FETCH(2); |
| } |
| if(isVirtualRegConstant(vB, LowOpndRegType_xmm, tmpValue, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_xmm, true); |
| setVRToConst(vA, OpndSize_64, tmpValue); |
| compileTable[entry].refCount--; |
| touchOneVR(vB, LowOpndRegType_xmm); |
| return true; |
| } else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| } |
| return false; |
| case OP_MOVE_RESULT: |
| case OP_MOVE_RESULT_OBJECT: |
| case OP_MOVE_EXCEPTION: |
| case OP_CONST_STRING: |
| case OP_CONST_STRING_JUMBO: |
| case OP_CONST_CLASS: |
| case OP_NEW_INSTANCE: |
| case OP_CMPL_FLOAT: |
| case OP_CMPG_FLOAT: |
| case OP_CMPL_DOUBLE: |
| case OP_CMPG_DOUBLE: |
| case OP_AGET: |
| case OP_AGET_OBJECT: |
| case OP_AGET_BOOLEAN: |
| case OP_AGET_BYTE: |
| case OP_AGET_CHAR: |
| case OP_AGET_SHORT: |
| case OP_SGET: |
| case OP_SGET_OBJECT: |
| case OP_SGET_VOLATILE: |
| case OP_SGET_OBJECT_VOLATILE: |
| case OP_SGET_BOOLEAN: |
| case OP_SGET_BYTE: |
| case OP_SGET_CHAR: |
| case OP_SGET_SHORT: |
| vA = INST_AA(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_MOVE_RESULT_WIDE: |
| case OP_AGET_WIDE: |
| case OP_SGET_WIDE: |
| case OP_SGET_WIDE_VOLATILE: |
| vA = INST_AA(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_INSTANCE_OF: |
| case OP_ARRAY_LENGTH: |
| case OP_NEW_ARRAY: |
| case OP_IGET: |
| case OP_IGET_OBJECT: |
| case OP_IGET_VOLATILE: |
| case OP_IGET_OBJECT_VOLATILE: |
| case OP_IGET_BOOLEAN: |
| case OP_IGET_BYTE: |
| case OP_IGET_CHAR: |
| case OP_IGET_SHORT: |
| case OP_IGET_QUICK: |
| case OP_IGET_OBJECT_QUICK: |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_IGET_WIDE: |
| case OP_IGET_WIDE_VOLATILE: |
| case OP_IGET_WIDE_QUICK: |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| //TODO: constant folding for float/double/long ALU |
| case OP_ADD_FLOAT: |
| case OP_SUB_FLOAT: |
| case OP_MUL_FLOAT: |
| case OP_DIV_FLOAT: |
| case OP_REM_FLOAT: |
| vA = INST_AA(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_ADD_DOUBLE: |
| case OP_SUB_DOUBLE: |
| case OP_MUL_DOUBLE: |
| case OP_DIV_DOUBLE: |
| case OP_REM_DOUBLE: |
| vA = INST_AA(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_NEG_FLOAT: |
| case OP_INT_TO_FLOAT: |
| case OP_LONG_TO_FLOAT: |
| case OP_FLOAT_TO_INT: |
| case OP_DOUBLE_TO_INT: |
| case OP_ADD_FLOAT_2ADDR: |
| case OP_SUB_FLOAT_2ADDR: |
| case OP_MUL_FLOAT_2ADDR: |
| case OP_DIV_FLOAT_2ADDR: |
| case OP_REM_FLOAT_2ADDR: |
| case OP_DOUBLE_TO_FLOAT: |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; //change constWorklist to point to vA TODO |
| num_const_worklist++; |
| return false; |
| case OP_FLOAT_TO_LONG: |
| case OP_DOUBLE_TO_LONG: |
| case OP_FLOAT_TO_DOUBLE: |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_NEG_DOUBLE: |
| case OP_INT_TO_DOUBLE: //fp stack |
| case OP_LONG_TO_DOUBLE: |
| case OP_ADD_DOUBLE_2ADDR: |
| case OP_SUB_DOUBLE_2ADDR: |
| case OP_MUL_DOUBLE_2ADDR: |
| case OP_DIV_DOUBLE_2ADDR: |
| case OP_REM_DOUBLE_2ADDR: |
| //ops on float, double |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_NEG_INT: |
| case OP_NOT_INT: |
| case OP_LONG_TO_INT: |
| case OP_INT_TO_BYTE: |
| case OP_INT_TO_CHAR: |
| case OP_INT_TO_SHORT: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| if(isVirtualRegConstant(vB, LowOpndRegType_gp, tmpValue, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| if(inst_op == OP_NEG_INT) |
| infoArray[entry].value[0] = -tmpValue[0]; |
| if(inst_op == OP_NOT_INT) |
| infoArray[entry].value[0] = ~tmpValue[0]; //CHECK |
| if(inst_op == OP_LONG_TO_INT) |
| infoArray[entry].value[0] = tmpValue[0]; |
| if(inst_op == OP_INT_TO_BYTE)// sar |
| infoArray[entry].value[0] = (tmpValue[0] << 24) >> 24; |
| if(inst_op == OP_INT_TO_CHAR) //shr |
| infoArray[entry].value[0] = ((unsigned int)(tmpValue[0] << 16)) >> 16; |
| if(inst_op == OP_INT_TO_SHORT) //sar |
| infoArray[entry].value[0] = (tmpValue[0] << 16) >> 16; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| touchOneVR(vB, LowOpndRegType_gp); |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| } |
| else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| } |
| case OP_NEG_LONG: |
| case OP_NOT_LONG: |
| case OP_INT_TO_LONG: |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; //fixed on 10/15/2009 |
| num_const_worklist++; |
| return false; |
| case OP_DIV_INT_2ADDR: |
| case OP_REM_INT_2ADDR: |
| case OP_REM_INT_LIT16: |
| case OP_DIV_INT_LIT16: |
| case OP_REM_INT_LIT8: |
| case OP_DIV_INT_LIT8: |
| case OP_DIV_INT: |
| case OP_REM_INT: |
| if(inst_op == OP_DIV_INT || inst_op == OP_DIV_INT_LIT8 || |
| inst_op == OP_REM_INT || inst_op == OP_REM_INT_LIT8) |
| vA = INST_AA(inst); |
| else |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_ADD_INT_2ADDR: |
| case OP_SUB_INT_2ADDR: |
| case OP_MUL_INT_2ADDR: |
| case OP_AND_INT_2ADDR: |
| case OP_OR_INT_2ADDR: |
| case OP_XOR_INT_2ADDR: |
| case OP_SHL_INT_2ADDR: |
| case OP_SHR_INT_2ADDR: |
| case OP_USHR_INT_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| if(isVirtualRegConstant(vA, LowOpndRegType_gp, tmpValue, false) == 3 && |
| isVirtualRegConstant(v2, LowOpndRegType_gp, tmpValue2, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| if(inst_op == OP_ADD_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] + tmpValue2[0]; |
| if(inst_op == OP_SUB_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] - tmpValue2[0]; |
| if(inst_op == OP_MUL_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] * tmpValue2[0]; |
| if(inst_op == OP_DIV_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] / tmpValue2[0]; |
| if(inst_op == OP_REM_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] % tmpValue2[0]; |
| if(inst_op == OP_AND_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] & tmpValue2[0]; |
| if(inst_op == OP_OR_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] | tmpValue2[0]; |
| if(inst_op == OP_XOR_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] ^ tmpValue2[0]; |
| if(inst_op == OP_SHL_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] << tmpValue2[0]; |
| if(inst_op == OP_SHR_INT_2ADDR) |
| infoArray[entry].value[0] = tmpValue[0] >> tmpValue2[0]; |
| if(inst_op == OP_USHR_INT_2ADDR) |
| infoArray[entry].value[0] = (unsigned int)tmpValue[0] >> tmpValue2[0]; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| touchOneVR(v2, LowOpndRegType_gp); |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| } |
| else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| } |
| case OP_ADD_INT_LIT16: |
| case OP_RSUB_INT: |
| case OP_MUL_INT_LIT16: |
| case OP_AND_INT_LIT16: |
| case OP_OR_INT_LIT16: |
| case OP_XOR_INT_LIT16: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| tmp_s4 = (s2)FETCH(1); |
| if(isVirtualRegConstant(vB, LowOpndRegType_gp, tmpValue, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| if(inst_op == OP_ADD_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] + tmp_s4; |
| if(inst_op == OP_RSUB_INT) |
| infoArray[entry].value[0] = tmp_s4 - tmpValue[0]; |
| if(inst_op == OP_MUL_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] * tmp_s4; |
| if(inst_op == OP_DIV_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] / tmp_s4; |
| if(inst_op == OP_REM_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] % tmp_s4; |
| if(inst_op == OP_AND_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] & tmp_s4; |
| if(inst_op == OP_OR_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] | tmp_s4; |
| if(inst_op == OP_XOR_INT_LIT16) |
| infoArray[entry].value[0] = tmpValue[0] ^ tmp_s4; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| touchOneVR(vB, LowOpndRegType_gp); |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| } |
| else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| } |
| case OP_ADD_INT: |
| case OP_SUB_INT: |
| case OP_MUL_INT: |
| case OP_AND_INT: |
| case OP_OR_INT: |
| case OP_XOR_INT: |
| case OP_SHL_INT: |
| case OP_SHR_INT: |
| case OP_USHR_INT: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| if(isVirtualRegConstant(v1, LowOpndRegType_gp, tmpValue, false) == 3 && |
| isVirtualRegConstant(v2, LowOpndRegType_gp, tmpValue2, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| if(inst_op == OP_ADD_INT) |
| infoArray[entry].value[0] = tmpValue[0] + tmpValue2[0]; |
| if(inst_op == OP_SUB_INT) |
| infoArray[entry].value[0] = tmpValue[0] - tmpValue2[0]; |
| if(inst_op == OP_MUL_INT) |
| infoArray[entry].value[0] = tmpValue[0] * tmpValue2[0]; |
| if(inst_op == OP_DIV_INT) |
| infoArray[entry].value[0] = tmpValue[0] / tmpValue2[0]; |
| if(inst_op == OP_REM_INT) |
| infoArray[entry].value[0] = tmpValue[0] % tmpValue2[0]; |
| if(inst_op == OP_AND_INT) |
| infoArray[entry].value[0] = tmpValue[0] & tmpValue2[0]; |
| if(inst_op == OP_OR_INT) |
| infoArray[entry].value[0] = tmpValue[0] | tmpValue2[0]; |
| if(inst_op == OP_XOR_INT) |
| infoArray[entry].value[0] = tmpValue[0] ^ tmpValue2[0]; |
| if(inst_op == OP_SHL_INT) |
| infoArray[entry].value[0] = tmpValue[0] << tmpValue2[0]; |
| if(inst_op == OP_SHR_INT) |
| infoArray[entry].value[0] = tmpValue[0] >> tmpValue2[0]; |
| if(inst_op == OP_USHR_INT) |
| infoArray[entry].value[0] = (unsigned int)tmpValue[0] >> tmpValue2[0]; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| touchOneVR(v1, LowOpndRegType_gp); |
| touchOneVR(v2, LowOpndRegType_gp); |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| } |
| else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| } |
| case OP_ADD_INT_LIT8: //INST_AA |
| case OP_RSUB_INT_LIT8: |
| case OP_MUL_INT_LIT8: |
| case OP_AND_INT_LIT8: |
| case OP_OR_INT_LIT8: |
| case OP_XOR_INT_LIT8: |
| case OP_SHL_INT_LIT8: |
| case OP_SHR_INT_LIT8: |
| case OP_USHR_INT_LIT8: |
| vA = INST_AA(inst); |
| vB = (u2)FETCH(1) & 0xff; |
| tmp_s4 = (s2)FETCH(1) >> 8; |
| if(isVirtualRegConstant(vB, LowOpndRegType_gp, tmpValue, false) == 3) { |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| if(inst_op == OP_ADD_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] + tmp_s4; |
| if(inst_op == OP_RSUB_INT_LIT8) |
| infoArray[entry].value[0] = tmp_s4 - tmpValue[0]; |
| if(inst_op == OP_MUL_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] * tmp_s4; |
| if(inst_op == OP_DIV_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] / tmp_s4; |
| if(inst_op == OP_REM_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] % tmp_s4; |
| if(inst_op == OP_AND_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] & tmp_s4; |
| if(inst_op == OP_OR_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] | tmp_s4; |
| if(inst_op == OP_XOR_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] ^ tmp_s4; |
| if(inst_op == OP_SHL_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] << tmp_s4; |
| if(inst_op == OP_SHR_INT_LIT8) |
| infoArray[entry].value[0] = tmpValue[0] >> tmp_s4; |
| if(inst_op == OP_USHR_INT_LIT8) |
| infoArray[entry].value[0] = (unsigned int)tmpValue[0] >> tmp_s4; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| touchOneVR(vB, LowOpndRegType_gp); |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| } |
| else { |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| } |
| case OP_ADD_LONG: |
| case OP_SUB_LONG: |
| case OP_AND_LONG: |
| case OP_OR_LONG: |
| case OP_XOR_LONG: |
| case OP_MUL_LONG: |
| case OP_DIV_LONG: |
| case OP_REM_LONG: |
| case OP_SHL_LONG: |
| case OP_SHR_LONG: |
| case OP_USHR_LONG: |
| //TODO bytecode is not going to update state registers |
| //constant folding |
| vA = INST_AA(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_CMP_LONG: |
| vA = INST_AA(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_ADD_LONG_2ADDR: |
| case OP_SUB_LONG_2ADDR: |
| case OP_AND_LONG_2ADDR: |
| case OP_OR_LONG_2ADDR: |
| case OP_XOR_LONG_2ADDR: |
| case OP_MUL_LONG_2ADDR: |
| case OP_DIV_LONG_2ADDR: |
| case OP_REM_LONG_2ADDR: |
| case OP_SHL_LONG_2ADDR: |
| case OP_SHR_LONG_2ADDR: |
| case OP_USHR_LONG_2ADDR: |
| vA = INST_A(inst); |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_CONST_4: |
| vA = INST_A(inst); |
| tmp_s4 = (s4) (INST_B(inst) << 28) >> 28; |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = tmp_s4; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, tmp_s4); |
| #endif |
| return true; |
| case OP_CONST_16: |
| BBBB = FETCH(1); |
| vA = INST_AA(inst); |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s2)BBBB; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| case OP_CONST: |
| vA = INST_AA(inst); |
| tmp_u4 = FETCH(1); |
| tmp_u4 |= (u4)FETCH(2) << 16; |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u4; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| case OP_CONST_HIGH16: |
| vA = INST_AA(inst); |
| tmp_u2 = FETCH(1); |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u2<<16; |
| tmpValue[0] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_32, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %d", vA, infoArray[entry].value[0]); |
| #endif |
| return true; |
| case OP_CONST_WIDE_16: |
| vA = INST_AA(inst); |
| tmp_u2 = FETCH(1); |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s2)tmp_u2; |
| tmpValue[0] = infoArray[entry].value[0]; |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA, infoArray[entry].value[0]); |
| #endif |
| |
| entry = findVirtualRegInTable(vA+1, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s2)tmp_u2>>31; |
| tmpValue[1] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_64, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA+1, infoArray[entry].value[0]); |
| #endif |
| return true; |
| case OP_CONST_WIDE_32: |
| vA = INST_AA(inst); |
| tmp_u4 = FETCH(1); |
| tmp_u4 |= (u4)FETCH(2) << 16; |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u4; |
| tmpValue[0] = infoArray[entry].value[0]; |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA, infoArray[entry].value[0]); |
| #endif |
| |
| entry = findVirtualRegInTable(vA+1, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u4>>31; |
| tmpValue[1] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_64, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA+1, infoArray[entry].value[0]); |
| #endif |
| return true; |
| case OP_CONST_WIDE: |
| vA = INST_AA(inst); |
| tmp_u4 = FETCH(1); |
| tmp_u4 |= (u8)FETCH(2) << 16; |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u4; |
| tmpValue[0] = infoArray[entry].value[0]; |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA, infoArray[entry].value[0]); |
| #endif |
| |
| tmp_u4 = (u8)FETCH(3); |
| tmp_u4 |= (u8)FETCH(4) << 16; |
| entry = findVirtualRegInTable(vA+1, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u4; |
| tmpValue[1] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_64, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA+1, infoArray[entry].value[0]); |
| #endif |
| return true; |
| case OP_CONST_WIDE_HIGH16: |
| vA = INST_AA(inst); |
| tmp_u2 = FETCH(1); |
| entry = findVirtualRegInTable(vA, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = 0; |
| tmpValue[0] = infoArray[entry].value[0]; |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA, infoArray[entry].value[0]); |
| #endif |
| |
| entry = findVirtualRegInTable(vA+1, LowOpndRegType_gp, true); |
| infoArray[entry].isConst = true; |
| infoArray[entry].value[0] = (s4)tmp_u2<<16; |
| tmpValue[1] = infoArray[entry].value[0]; |
| setVRToConst(vA, OpndSize_64, tmpValue); |
| compileTable[entry].refCount--; |
| #ifdef DEBUG_CONST |
| LOGD("getConstInfo: set VR %d to %x", vA+1, infoArray[entry].value[0]); |
| #endif |
| return true; |
| #ifdef SUPPORT_HLO |
| case OP_X_AGET_QUICK: |
| case OP_X_AGET_OBJECT_QUICK: |
| case OP_X_AGET_BOOLEAN_QUICK: |
| case OP_X_AGET_BYTE_QUICK: |
| case OP_X_AGET_CHAR_QUICK: |
| case OP_X_AGET_SHORT_QUICK: |
| vA = FETCH(1) & 0xff; |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_X_AGET_WIDE_QUICK: |
| vA = FETCH(1) & 0xff; |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| case OP_X_DEREF_GET: |
| case OP_X_DEREF_GET_OBJECT: |
| case OP_X_DEREF_GET_BOOLEAN: |
| case OP_X_DEREF_GET_BYTE: |
| case OP_X_DEREF_GET_CHAR: |
| case OP_X_DEREF_GET_SHORT: |
| vA = FETCH(1) & 0xff; |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| return false; |
| case OP_X_DEREF_GET_WIDE: |
| vA = FETCH(1) & 0xff; |
| constWorklist[num_const_worklist] = vA; |
| num_const_worklist++; |
| constWorklist[num_const_worklist] = vA+1; |
| num_const_worklist++; |
| return false; |
| #endif |
| } |
| return false; |
| } |
| |
| //! This function updates infoArray with virtual registers accessed when lowering the bytecode, and returns size of the bytecode in unit of u2 |
| |
| //! uses of virtual registers are added to infoArray first |
| int getVirtualRegInfo(VirtualRegInfo* infoArray) { |
| u2 inst_op = INST_INST(inst); |
| u2 vA = 0, vB = 0, vref, vindex; |
| u2 v1, v2, length, vD, vG, vE, vF, count; |
| u4 v1_u4, v2_u4; |
| int kk, num, num_entry; |
| s4 tmp_s4; |
| s2 tmp_s2; |
| u4 tmp_u4; |
| int codeSize = 0; |
| num_regs_per_bytecode = 0; |
| //update infoArray[xx].allocConstraints |
| for(num = 0; num < MAX_REG_PER_BYTECODE; num++) { |
| for(kk = 0; kk < 8; kk++) { |
| infoArray[num].allocConstraints[kk].physicalReg = (PhysicalReg)kk; |
| infoArray[num].allocConstraints[kk].count = 0; |
| } |
| } |
| |
| switch (inst_op) { |
| case OP_NOP: |
| codeSize = 1; |
| break; |
| case OP_MOVE: |
| case OP_MOVE_OBJECT: |
| case OP_MOVE_FROM16: |
| case OP_MOVE_OBJECT_FROM16: |
| case OP_MOVE_16: |
| case OP_MOVE_OBJECT_16: |
| if(inst_op == OP_MOVE || inst_op == OP_MOVE_OBJECT) { |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 1; |
| } |
| else if(inst_op == OP_MOVE_FROM16 || inst_op == OP_MOVE_OBJECT_FROM16) { |
| vA = INST_AA(inst); |
| vB = FETCH(1); |
| codeSize = 2; |
| } |
| else if(inst_op == OP_MOVE_16 || inst_op == OP_MOVE_OBJECT_16) { |
| vA = FETCH(1); |
| vB = FETCH(2); |
| codeSize = 3; |
| } |
| infoArray[1].regNum = vA; //dst |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_MOVE_WIDE: |
| case OP_MOVE_WIDE_FROM16: |
| case OP_MOVE_WIDE_16: |
| if(inst_op == OP_MOVE_WIDE) { |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 1; |
| } |
| else if(inst_op == OP_MOVE_WIDE_FROM16) { |
| vA = INST_AA(inst); |
| vB = FETCH(1); |
| codeSize = 2; |
| } |
| else if(inst_op == OP_MOVE_WIDE_16) { |
| vA = FETCH(1); |
| vB = FETCH(2); |
| codeSize = 3; |
| } |
| infoArray[1].regNum = vA; //dst |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[0].regNum = vB; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_MOVE_RESULT: //access memory |
| case OP_MOVE_RESULT_OBJECT: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| codeSize = 1; |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_MOVE_RESULT_WIDE: //note: 2 destinations |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| codeSize = 1; |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_MOVE_EXCEPTION: //access memory |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| codeSize = 1; |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_RETURN_VOID: |
| case OP_RETURN_VOID_BARRIER: |
| codeSize = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| num_regs_per_bytecode = 0; |
| break; |
| case OP_RETURN: |
| case OP_RETURN_OBJECT: |
| vA = INST_AA(inst); |
| codeSize = 1; |
| infoArray[0].regNum = vA; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_RETURN_WIDE: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 1; |
| codeSize = 1; |
| break; |
| case OP_CONST_4: |
| vA = INST_A(inst); |
| tmp_s4 = (s4) (INST_B(inst) << 28) >> 28; |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| codeSize = 1; |
| break; |
| case OP_CONST_16: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| codeSize = 2; |
| break; |
| case OP_CONST: |
| vA = INST_AA(inst); |
| tmp_u4 = FETCH(1); |
| tmp_u4 |= (u4)FETCH(2) << 16; |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| codeSize = 3; |
| break; |
| case OP_CONST_HIGH16: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| codeSize = 2; |
| break; |
| case OP_CONST_WIDE_16: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| codeSize = 2; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_CONST_WIDE_32: |
| vA = INST_AA(inst); |
| tmp_u4 = FETCH(1); |
| tmp_u4 |= (u4)FETCH(2) << 16; |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| codeSize = 3; |
| break; |
| case OP_CONST_WIDE: |
| vA = INST_AA(inst); |
| tmp_u4 = FETCH(1); |
| tmp_u4 |= (u8)FETCH(2) << 16; |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| tmp_u4 = (u8)FETCH(3); |
| tmp_u4 |= (u8)FETCH(4) << 16; |
| infoArray[1].regNum = vA+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| codeSize = 5; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_CONST_WIDE_HIGH16: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| codeSize = 2; |
| break; |
| case OP_CONST_STRING: |
| case OP_CONST_STRING_JUMBO: |
| case OP_CONST_CLASS: |
| vA = INST_AA(inst); |
| if(inst_op == OP_CONST_STRING || inst_op == OP_CONST_CLASS) |
| codeSize = 2; |
| else if(inst_op == OP_CONST_STRING_JUMBO) |
| codeSize = 3; |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].allocConstraints[PhysicalReg_EAX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_MONITOR_ENTER: |
| vA = INST_AA(inst); |
| codeSize = 1; |
| infoArray[0].regNum = vA; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_MONITOR_EXIT: |
| vA = INST_AA(inst); |
| codeSize = 1; |
| infoArray[0].regNum = vA; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); //eax is used as return value from c function |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_CHECK_CAST: |
| codeSize = 2; |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_ECX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 1; |
| break; |
| case OP_INSTANCE_OF: |
| codeSize = 2; |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| infoArray[0].regNum = vB; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA; //dst |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_ARRAY_LENGTH: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[0].regNum = vB; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA; //dst |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| //%edx is used in this bytecode, update currentBB->allocConstraints |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_NEW_INSTANCE: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //dst |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].allocConstraints[PhysicalReg_EAX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_ECX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 1; |
| codeSize = 2; |
| break; |
| case OP_NEW_ARRAY: |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); //length |
| infoArray[0].regNum = vB; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA; //dst |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[1].allocConstraints[PhysicalReg_EAX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 2; |
| codeSize = 2; |
| break; |
| case OP_FILLED_NEW_ARRAY: {//update return value |
| //can use up to 5 registers to fill the content of array |
| length = INST_B(inst); |
| u2 vv = FETCH(2); |
| v1 = vv & 0xf; |
| v2 = (vv >> 4) & 0xf; |
| u2 v3 = (vv >> 8) & 0xf; |
| u2 v4 = (vv >> 12) & 0xf; |
| u2 v5 = INST_A(inst); |
| if(length >= 1) { |
| infoArray[0].regNum = v1; //src |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 2) { |
| infoArray[1].regNum = v2; //src |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 3) { |
| infoArray[2].regNum = v3; //src |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 4) { |
| infoArray[3].regNum = v4; //src |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_U; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 5) { |
| infoArray[4].regNum = v5; //src |
| infoArray[4].refCount = 1; |
| infoArray[4].accessType = REGACCESS_U; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| } |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = length; |
| codeSize = 3; |
| break; |
| } |
| case OP_FILLED_NEW_ARRAY_RANGE: {//use "length" virtual registers |
| length = INST_AA(inst); |
| u4 vC = (u4)FETCH(2); |
| for(kk = 0; kk < length; kk++) { |
| infoArray[kk].regNum = vC+kk; //src |
| infoArray[kk].refCount = 1; |
| infoArray[kk].accessType = REGACCESS_U; |
| infoArray[kk].physicalType = LowOpndRegType_gp; |
| } |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = length; |
| codeSize = 3; |
| break; |
| } |
| case OP_FILL_ARRAY_DATA: //update content of array, read memory |
| vA = INST_AA(inst); //use virtual register, but has side-effect, update memory |
| infoArray[0].regNum = vA; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 1; |
| codeSize = 3; |
| break; |
| case OP_THROW: //update glue->exception |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 1; |
| codeSize = 1; |
| break; |
| case OP_THROW_VERIFICATION_ERROR: |
| num_regs_per_bytecode = 0; |
| codeSize = 2; |
| break; |
| case OP_GOTO: |
| codeSize = 1; |
| num_regs_per_bytecode = 0; |
| break; |
| case OP_GOTO_16: |
| codeSize = 2; |
| num_regs_per_bytecode = 0; |
| break; |
| case OP_GOTO_32: |
| codeSize = 3; |
| num_regs_per_bytecode = 0; |
| break; |
| case OP_PACKED_SWITCH: |
| case OP_SPARSE_SWITCH: |
| vA = INST_AA(inst); |
| codeSize = 3; |
| infoArray[0].regNum = vA; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 1; |
| break; |
| |
| case OP_CMPL_FLOAT: //move 32 bits from memory to lower part of XMM register |
| case OP_CMPG_FLOAT: |
| codeSize = 2; |
| vA = INST_AA(inst); |
| v1_u4 = FETCH(1) & 0xff; |
| v2_u4 = FETCH(1) >> 8; |
| num_regs_per_bytecode = 1; |
| infoArray[0].regNum = v1_u4; //use ss or sd CHECK |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_ss; |
| infoArray[1].regNum = v2_u4; //use |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_ss; |
| num_regs_per_bytecode = 3; |
| num_entry = 2; |
| infoArray[num_entry].regNum = vA; //define |
| infoArray[num_entry].refCount = 1; |
| infoArray[num_entry].accessType = REGACCESS_D; |
| infoArray[num_entry].physicalType = LowOpndRegType_gp; |
| break; |
| case OP_CMPL_DOUBLE: //move 64 bits from memory to lower part of XMM register |
| case OP_CMPG_DOUBLE: |
| case OP_CMP_LONG: //load v1, v1+1, v2, v2+1 to gpr |
| codeSize = 2; |
| vA = INST_AA(inst); |
| v1_u4 = FETCH(1) & 0xff; |
| v2_u4 = FETCH(1) >> 8; |
| num_regs_per_bytecode = 1; |
| if(inst_op == OP_CMP_LONG) { |
| infoArray[0].regNum = v1_u4; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v1_u4 + 1; //use |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = v2_u4; //use |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = v2_u4 + 1; //use |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_U; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 5; |
| num_entry = 4; |
| infoArray[num_entry].regNum = vA; //define |
| infoArray[num_entry].refCount = 2; |
| infoArray[num_entry].accessType = REGACCESS_D; |
| infoArray[num_entry].physicalType = LowOpndRegType_gp; |
| } |
| else { |
| infoArray[0].regNum = v1_u4; //use ss or sd CHECK |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2_u4; //use |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 3; |
| num_entry = 2; |
| infoArray[num_entry].regNum = vA; //define |
| infoArray[num_entry].refCount = 1; |
| infoArray[num_entry].accessType = REGACCESS_D; |
| infoArray[num_entry].physicalType = LowOpndRegType_gp; |
| } |
| break; |
| case OP_IF_EQ: |
| case OP_IF_NE: |
| case OP_IF_LT: |
| case OP_IF_GE: |
| case OP_IF_GT: |
| case OP_IF_LE: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| infoArray[0].regNum = vA; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vB; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| codeSize =12; |
| break; |
| case OP_IF_EQZ: |
| case OP_IF_NEZ: |
| case OP_IF_LTZ: |
| case OP_IF_GEZ: |
| case OP_IF_GTZ: |
| case OP_IF_LEZ: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = vA; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| codeSize = 2; |
| break; |
| case OP_AGET: |
| codeSize = 2; |
| case OP_AGET_WIDE: |
| codeSize = 2; |
| case OP_AGET_OBJECT: |
| codeSize = 2; |
| case OP_AGET_BOOLEAN: //movez 8 |
| codeSize = 2; |
| case OP_AGET_BYTE: //moves 8 |
| codeSize = 2; |
| case OP_AGET_CHAR: //movez 16 |
| codeSize = 2; |
| case OP_AGET_SHORT: //moves 16 |
| codeSize = 2; |
| vA = INST_AA(inst); |
| vref = FETCH(1) & 0xff; |
| vindex = FETCH(1) >> 8; |
| if(inst_op == OP_AGET_WIDE) { |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_xmm; //64, 128 not used in lowering |
| } else { |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| } |
| infoArray[0].regNum = vref; //use |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vindex; //use |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_APUT: |
| case OP_APUT_WIDE: |
| case OP_APUT_OBJECT: |
| case OP_APUT_BOOLEAN: |
| case OP_APUT_BYTE: |
| case OP_APUT_CHAR: |
| case OP_APUT_SHORT: |
| vA = INST_AA(inst); |
| vref = FETCH(1) & 0xff; |
| vindex = FETCH(1) >> 8; |
| codeSize = 2; |
| if(inst_op == OP_APUT_WIDE) { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; //64, 128 not used in lowering |
| } else { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| infoArray[1].regNum = vref; //use |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = vindex; //use |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| if(inst_op == OP_APUT_OBJECT) { |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| } |
| num_regs_per_bytecode = 3; |
| break; |
| |
| case OP_IGET: |
| case OP_IGET_WIDE: |
| case OP_IGET_OBJECT: |
| case OP_IGET_VOLATILE: |
| case OP_IGET_WIDE_VOLATILE: |
| case OP_IGET_OBJECT_VOLATILE: |
| case OP_IGET_BOOLEAN: |
| case OP_IGET_BYTE: |
| case OP_IGET_CHAR: |
| case OP_IGET_SHORT: |
| case OP_IGET_QUICK: |
| case OP_IGET_WIDE_QUICK: |
| case OP_IGET_OBJECT_QUICK: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 2; |
| if(inst_op == OP_IGET_WIDE || inst_op == OP_IGET_WIDE_QUICK) { |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_xmm; //64 |
| } else if(inst_op == OP_IGET_WIDE_VOLATILE) { |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = vA+1; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| } else { |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| } |
| infoArray[0].regNum = vB; //object instance |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| if(inst_op == OP_IGET_WIDE_VOLATILE) |
| num_regs_per_bytecode = 3; |
| else |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_IPUT: |
| case OP_IPUT_WIDE: |
| case OP_IPUT_OBJECT: |
| case OP_IPUT_VOLATILE: |
| case OP_IPUT_WIDE_VOLATILE: |
| case OP_IPUT_OBJECT_VOLATILE: |
| case OP_IPUT_BOOLEAN: |
| case OP_IPUT_BYTE: |
| case OP_IPUT_CHAR: |
| case OP_IPUT_SHORT: |
| case OP_IPUT_QUICK: |
| case OP_IPUT_WIDE_QUICK: |
| case OP_IPUT_OBJECT_QUICK: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 2; |
| if(inst_op == OP_IPUT_WIDE || inst_op == OP_IPUT_WIDE_QUICK || inst_op == OP_IPUT_WIDE_VOLATILE) { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; //64 |
| } else { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| infoArray[1].regNum = vB; //object instance |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_SGET: |
| case OP_SGET_WIDE: |
| case OP_SGET_OBJECT: |
| case OP_SGET_VOLATILE: |
| case OP_SGET_WIDE_VOLATILE: |
| case OP_SGET_OBJECT_VOLATILE: |
| case OP_SGET_BOOLEAN: |
| case OP_SGET_BYTE: |
| case OP_SGET_CHAR: |
| case OP_SGET_SHORT: |
| vA = INST_AA(inst); |
| codeSize = 2; |
| if(inst_op == OP_SGET_WIDE) { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_xmm; //64 |
| } else if(inst_op == OP_SGET_WIDE_VOLATILE) { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| } else { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_D; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| if(inst_op == OP_SGET_WIDE_VOLATILE) |
| num_regs_per_bytecode = 2; |
| else |
| num_regs_per_bytecode = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| break; |
| case OP_SPUT: |
| case OP_SPUT_WIDE: |
| case OP_SPUT_OBJECT: |
| case OP_SPUT_VOLATILE: |
| case OP_SPUT_WIDE_VOLATILE: |
| case OP_SPUT_OBJECT_VOLATILE: |
| case OP_SPUT_BOOLEAN: |
| case OP_SPUT_BYTE: |
| case OP_SPUT_CHAR: |
| case OP_SPUT_SHORT: |
| vA = INST_AA(inst); |
| codeSize = 2; |
| if(inst_op == OP_SPUT_WIDE || inst_op == OP_SPUT_WIDE_VOLATILE) { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; //64 |
| } else { |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| num_regs_per_bytecode = 1; |
| break; |
| |
| case OP_INVOKE_VIRTUAL: |
| case OP_INVOKE_SUPER: |
| case OP_INVOKE_DIRECT: |
| case OP_INVOKE_STATIC: |
| case OP_INVOKE_INTERFACE: |
| case OP_INVOKE_VIRTUAL_QUICK: |
| case OP_INVOKE_SUPER_QUICK: |
| codeSize = 3; |
| vD = FETCH(2) & 0xf; //object for virtual,direct & interface |
| count = INST_B(inst); |
| vE = (FETCH(2) >> 4) & 0xf; |
| vF = (FETCH(2) >> 8) & 0xf; |
| vG = (FETCH(2) >> 12) & 0xf; |
| vA = INST_A(inst); //5th argument |
| if(count == 0) { |
| if(inst_op == OP_INVOKE_VIRTUAL || inst_op == OP_INVOKE_DIRECT || |
| inst_op == OP_INVOKE_INTERFACE || inst_op == OP_INVOKE_VIRTUAL_QUICK || |
| inst_op == OP_INVOKE_SUPER_QUICK) { |
| infoArray[0].regNum = vD; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 1; |
| } |
| num_regs_per_bytecode = 0; |
| } |
| else num_regs_per_bytecode = count; |
| if(count >= 1) { |
| infoArray[0].regNum = vD; |
| if(inst_op == OP_INVOKE_VIRTUAL_QUICK || |
| inst_op == OP_INVOKE_SUPER_QUICK) { |
| infoArray[0].refCount = 2; |
| } else if(inst_op == OP_INVOKE_VIRTUAL || inst_op == OP_INVOKE_DIRECT || inst_op == OP_INVOKE_INTERFACE) { |
| infoArray[0].refCount = 2; |
| } else { |
| infoArray[0].refCount = 1; |
| } |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| if(count >= 2) { |
| infoArray[1].regNum = vE; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| } |
| if(count >= 3) { |
| infoArray[2].regNum = vF; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| } |
| if(count >= 4) { |
| infoArray[3].regNum = vG; |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_U; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| } |
| if(count >= 5) { |
| infoArray[4].regNum = vA; |
| infoArray[4].refCount = 1; |
| infoArray[4].accessType = REGACCESS_U; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| } |
| if(inst_op != OP_INVOKE_VIRTUAL_QUICK && inst_op != OP_INVOKE_SUPER_QUICK) |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_ECX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| break; |
| case OP_INVOKE_VIRTUAL_RANGE: |
| case OP_INVOKE_SUPER_RANGE: |
| case OP_INVOKE_DIRECT_RANGE: |
| case OP_INVOKE_STATIC_RANGE: |
| case OP_INVOKE_INTERFACE_RANGE: |
| case OP_INVOKE_VIRTUAL_QUICK_RANGE: |
| case OP_INVOKE_SUPER_QUICK_RANGE: |
| codeSize = 3; |
| vD = FETCH(2); |
| count = INST_AA(inst); |
| if(count == 0) { |
| if(inst_op == OP_INVOKE_VIRTUAL_RANGE || inst_op == OP_INVOKE_DIRECT_RANGE || |
| inst_op == OP_INVOKE_INTERFACE_RANGE || inst_op == OP_INVOKE_VIRTUAL_QUICK_RANGE || |
| inst_op == OP_INVOKE_SUPER_QUICK_RANGE) { |
| infoArray[0].regNum = vD; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| } |
| if(count > 0) { //same for count > 10 |
| for(kk = 0; kk < count; kk++) { |
| infoArray[kk].regNum = vD+kk; //src |
| if(kk == 0 && (inst_op == OP_INVOKE_VIRTUAL_QUICK_RANGE || |
| inst_op == OP_INVOKE_SUPER_QUICK_RANGE)) |
| infoArray[kk].refCount = 2; |
| else if(kk == 0 && (inst_op == OP_INVOKE_VIRTUAL_RANGE || |
| inst_op == OP_INVOKE_DIRECT_RANGE || |
| inst_op == OP_INVOKE_INTERFACE_RANGE)) |
| infoArray[kk].refCount = 2; |
| else |
| infoArray[kk].refCount = 1; |
| infoArray[kk].accessType = REGACCESS_U; |
| infoArray[kk].physicalType = LowOpndRegType_gp; |
| } |
| } |
| if(inst_op != OP_INVOKE_VIRTUAL_QUICK_RANGE && inst_op != OP_INVOKE_SUPER_QUICK_RANGE) |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_ECX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = count; |
| break; |
| case OP_NEG_INT: |
| case OP_NOT_INT: |
| case OP_NEG_FLOAT: |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| codeSize = 1; |
| break; |
| case OP_NEG_LONG: |
| case OP_NOT_LONG: |
| case OP_NEG_DOUBLE: |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_INT_TO_LONG: //hard-coded registers |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; //save from %eax |
| infoArray[1].allocConstraints[PhysicalReg_EAX].count = 1; |
| infoArray[2].regNum = vA+1; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[2].allocConstraints[PhysicalReg_EDX].count = 1; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].allocConstraints[PhysicalReg_EAX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_INT_TO_FLOAT: //32 to 32 |
| case OP_INT_TO_DOUBLE: //32 to 64 |
| case OP_LONG_TO_FLOAT: //64 to 32 |
| case OP_LONG_TO_DOUBLE: //64 to 64 |
| case OP_FLOAT_TO_DOUBLE: //32 to 64 |
| case OP_DOUBLE_TO_FLOAT: //64 to 32 |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| if(inst_op == OP_INT_TO_DOUBLE || inst_op == OP_LONG_TO_DOUBLE || inst_op == OP_FLOAT_TO_DOUBLE) |
| infoArray[1].physicalType = LowOpndRegType_fs; |
| else |
| infoArray[1].physicalType = LowOpndRegType_fs_s; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| if(inst_op == OP_INT_TO_FLOAT || inst_op == OP_INT_TO_DOUBLE || inst_op == OP_FLOAT_TO_DOUBLE) |
| infoArray[0].physicalType = LowOpndRegType_fs_s; //float |
| else |
| infoArray[0].physicalType = LowOpndRegType_fs; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_LONG_TO_INT: |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| codeSize = 1; |
| break; |
| case OP_FLOAT_TO_INT: |
| case OP_DOUBLE_TO_INT: //for reaching-def analysis |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 3; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_fs_s; //store_int_fp_stack_VR |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| if(inst_op == OP_DOUBLE_TO_INT) |
| infoArray[0].physicalType = LowOpndRegType_fs; |
| else |
| infoArray[0].physicalType = LowOpndRegType_fs_s; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_FLOAT_TO_LONG: |
| case OP_DOUBLE_TO_LONG: |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 3; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_fs; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| if(inst_op == OP_DOUBLE_TO_LONG) |
| infoArray[0].physicalType = LowOpndRegType_fs; |
| else |
| infoArray[0].physicalType = LowOpndRegType_fs_s; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_INT_TO_BYTE: |
| case OP_INT_TO_CHAR: |
| case OP_INT_TO_SHORT: |
| vA = INST_A(inst); //destination |
| vB = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| break; |
| |
| case OP_ADD_INT: |
| case OP_SUB_INT: |
| case OP_MUL_INT: |
| case OP_AND_INT: |
| case OP_OR_INT: |
| case OP_XOR_INT: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_DIV_INT: |
| case OP_REM_INT: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 2; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].allocConstraints[PhysicalReg_EAX].count = 1; //for v1 |
| if(inst_op == OP_REM_INT) |
| infoArray[2].allocConstraints[PhysicalReg_EDX].count = 1;//vA |
| else |
| infoArray[2].allocConstraints[PhysicalReg_EAX].count = 1;//vA |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_SHL_INT: |
| case OP_SHR_INT: |
| case OP_USHR_INT: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v2; // in ecx |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[1].allocConstraints[PhysicalReg_ECX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_ECX); |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_ADD_LONG: |
| case OP_SUB_LONG: |
| case OP_AND_LONG: |
| case OP_OR_LONG: |
| case OP_XOR_LONG: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_MUL_LONG: //used int |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v1+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = v2; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = v2+1; |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_U; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = vA; |
| infoArray[4].refCount = 1; |
| infoArray[4].accessType = REGACCESS_D; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = vA+1; |
| infoArray[5].refCount = 1; |
| infoArray[5].accessType = REGACCESS_D; |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 6; |
| codeSize = 2; |
| break; |
| case OP_DIV_LONG: //v1: xmm v2,vA: |
| case OP_REM_LONG: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = v2+1; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = vA; |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_D; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = vA+1; |
| infoArray[4].refCount = 1; |
| infoArray[4].accessType = REGACCESS_D; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 5; |
| codeSize = 2; |
| break; |
| case OP_SHL_LONG: //v2: 32, move_ss; v1,vA: xmm CHECK |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_ss; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 3; |
| codeSize = 2; |
| break; |
| case OP_SHR_LONG: //v2: 32, move_ss; v1,vA: xmm CHECK |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_ss; |
| infoArray[2].regNum = v1+1; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = vA; |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_D; |
| infoArray[3].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 4; |
| codeSize = 2; |
| break; |
| case OP_USHR_LONG: //v2: move_ss; v1,vA: move_sd |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; //sd |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_ss; //ss |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_xmm; //sd |
| num_regs_per_bytecode = 3; |
| codeSize = 2; |
| break; |
| case OP_ADD_FLOAT: //move_ss |
| case OP_SUB_FLOAT: |
| case OP_MUL_FLOAT: |
| case OP_DIV_FLOAT: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_ss; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_ss; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_ss; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_REM_FLOAT: //32 bit GPR, fp_stack for output |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_fs_s; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_ADD_DOUBLE: //move_sd |
| case OP_SUB_DOUBLE: |
| case OP_MUL_DOUBLE: |
| case OP_DIV_DOUBLE: |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 3; |
| break; |
| case OP_REM_DOUBLE: //64 bit XMM, fp_stack for output |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| v2 = *((u1*)rPC + 3); |
| codeSize = 2; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_D; |
| infoArray[2].physicalType = LowOpndRegType_fs; |
| infoArray[0].regNum = v1; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 3; |
| break; |
| |
| case OP_ADD_INT_2ADDR: |
| case OP_SUB_INT_2ADDR: |
| case OP_MUL_INT_2ADDR: |
| case OP_AND_INT_2ADDR: |
| case OP_OR_INT_2ADDR: |
| case OP_XOR_INT_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; //use then define |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_DIV_INT_2ADDR: |
| case OP_REM_INT_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 3; |
| infoArray[1].accessType = REGACCESS_UD; //use then define |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].allocConstraints[PhysicalReg_EAX].count = 1; //for v1 is vA |
| if(inst_op == OP_REM_INT_2ADDR) |
| infoArray[1].allocConstraints[PhysicalReg_EDX].count = 1;//vA |
| else |
| infoArray[1].allocConstraints[PhysicalReg_EAX].count = 1;//vA |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_SHL_INT_2ADDR: |
| case OP_SHR_INT_2ADDR: |
| case OP_USHR_INT_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; //use then define |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].allocConstraints[PhysicalReg_ECX].count = 1; //v2 |
| updateCurrentBBWithConstraints(PhysicalReg_ECX); |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_ADD_LONG_2ADDR: |
| case OP_SUB_LONG_2ADDR: |
| case OP_AND_LONG_2ADDR: |
| case OP_OR_LONG_2ADDR: |
| case OP_XOR_LONG_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_MUL_LONG_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| num_regs_per_bytecode = 4; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = v2+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 2; |
| infoArray[2].accessType = REGACCESS_UD; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = vA+1; |
| infoArray[3].refCount = 2; |
| infoArray[3].accessType = REGACCESS_UD; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| break; |
| case OP_DIV_LONG_2ADDR: //vA used as xmm, then updated as gps |
| case OP_REM_LONG_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| num_regs_per_bytecode = 5; |
| codeSize = 1; |
| infoArray[0].regNum = vA; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = v2; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = v2+1; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = vA; |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_D; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = vA+1; |
| infoArray[4].refCount = 1; |
| infoArray[4].accessType = REGACCESS_D; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| break; |
| case OP_SHL_LONG_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| num_regs_per_bytecode = 2; |
| codeSize = 1; |
| infoArray[0].regNum = v2; //ss |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_ss; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| break; |
| case OP_SHR_LONG_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| num_regs_per_bytecode = 3; |
| codeSize = 1; |
| infoArray[0].regNum = v2; //ss |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_ss; |
| infoArray[1].regNum = vA+1; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = vA; |
| infoArray[2].refCount = 2; |
| infoArray[2].accessType = REGACCESS_UD; |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| break; |
| case OP_USHR_LONG_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| num_regs_per_bytecode = 2; |
| codeSize = 1; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_ss; //ss CHECK |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_xmm; //sd |
| break; |
| case OP_ADD_FLOAT_2ADDR: |
| case OP_SUB_FLOAT_2ADDR: |
| case OP_MUL_FLOAT_2ADDR: |
| case OP_DIV_FLOAT_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_ss; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_ss; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_REM_FLOAT_2ADDR: //load vA as GPR, store from fs |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_gp; //CHECK |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_ADD_DOUBLE_2ADDR: |
| case OP_SUB_DOUBLE_2ADDR: |
| case OP_MUL_DOUBLE_2ADDR: |
| case OP_DIV_DOUBLE_2ADDR: |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_REM_DOUBLE_2ADDR: //load to xmm, store from fs |
| vA = INST_A(inst); |
| v2 = INST_B(inst); |
| codeSize = 1; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 2; |
| infoArray[1].accessType = REGACCESS_UD; |
| infoArray[1].physicalType = LowOpndRegType_xmm; //CHECK |
| infoArray[0].regNum = v2; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| num_regs_per_bytecode = 2; |
| break; |
| |
| case OP_ADD_INT_LIT16: |
| case OP_RSUB_INT: |
| case OP_MUL_INT_LIT16: |
| case OP_AND_INT_LIT16: |
| case OP_OR_INT_LIT16: |
| case OP_XOR_INT_LIT16: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 2; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_DIV_INT_LIT16: |
| case OP_REM_INT_LIT16: |
| vA = INST_A(inst); |
| vB = INST_B(inst); |
| codeSize = 2; |
| tmp_s4 = (s2)FETCH(1); |
| tmp_s2 = tmp_s4; |
| if(tmp_s2 == 0) { |
| num_regs_per_bytecode = 0; |
| break; |
| } |
| infoArray[1].regNum = vA; //in edx for rem, in eax |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; //in eax |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| if(inst_op == OP_DIV_INT_LIT16) { |
| int power = isPowerOfTwo(tmp_s2); |
| if(power >= 1) { /* divide by a power of 2 constant */ |
| infoArray[1].refCount = 1; |
| break; |
| } |
| } |
| if(tmp_s2 == -1) |
| infoArray[1].refCount = 2; |
| else |
| infoArray[1].refCount = 1; |
| if(inst_op == OP_REM_INT_LIT16) |
| infoArray[1].allocConstraints[PhysicalReg_EDX].count = 1; |
| else |
| infoArray[1].allocConstraints[PhysicalReg_EAX].count = 1; |
| infoArray[0].allocConstraints[PhysicalReg_EAX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| break; |
| case OP_ADD_INT_LIT8: |
| case OP_RSUB_INT_LIT8: |
| case OP_MUL_INT_LIT8: |
| case OP_AND_INT_LIT8: |
| case OP_OR_INT_LIT8: |
| case OP_XOR_INT_LIT8: |
| case OP_SHL_INT_LIT8: |
| case OP_SHR_INT_LIT8: |
| case OP_USHR_INT_LIT8: |
| codeSize = 2; |
| vA = INST_AA(inst); |
| vB = (u2)FETCH(1) & 0xff; |
| infoArray[1].regNum = vA; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| break; |
| case OP_DIV_INT_LIT8: |
| case OP_REM_INT_LIT8: |
| codeSize = 2; |
| vA = INST_AA(inst); |
| vB = (u2)FETCH(1) & 0xff; |
| tmp_s2 = (s2)FETCH(1) >> 8; |
| if(tmp_s2 == 0) { |
| num_regs_per_bytecode = 0; |
| break; |
| } |
| |
| infoArray[1].regNum = vA; |
| infoArray[1].accessType = REGACCESS_D; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[0].regNum = vB; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| num_regs_per_bytecode = 2; |
| if(inst_op == OP_DIV_INT_LIT8) { |
| int power = isPowerOfTwo(tmp_s2); |
| if(power >= 1) { /* divide by a power of 2 constant */ |
| infoArray[1].refCount = 1; |
| break; |
| } |
| } |
| |
| if(tmp_s2 == -1) |
| infoArray[1].refCount = 2; |
| else |
| infoArray[1].refCount = 1; |
| if(inst_op == OP_REM_INT_LIT8) |
| infoArray[1].allocConstraints[PhysicalReg_EDX].count = 1; |
| else |
| infoArray[1].allocConstraints[PhysicalReg_EAX].count = 1; |
| infoArray[0].allocConstraints[PhysicalReg_EAX].count = 1; |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| break; |
| case OP_EXECUTE_INLINE: //update glue->retval |
| case OP_EXECUTE_INLINE_RANGE: |
| u4 vC; |
| if(inst_op == OP_EXECUTE_INLINE) |
| num = INST_B(inst); |
| else |
| num = INST_AA(inst); |
| if(inst_op == OP_EXECUTE_INLINE) { |
| vC = FETCH(2) & 0xf; |
| vD = (FETCH(2) >> 4) & 0xf; |
| vE = (FETCH(2) >> 8) & 0xf; |
| vF = FETCH(2) >> 12; |
| } else { |
| vC = FETCH(2); |
| vD = vC + 1; |
| vE = vC + 2; |
| vF = vC + 3; |
| } |
| codeSize = 3; |
| if(num >= 1) { |
| infoArray[0].regNum = vC; |
| infoArray[0].refCount = 1; |
| infoArray[0].accessType = REGACCESS_U; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| } |
| if(num >= 2) { |
| infoArray[1].regNum = vD; |
| infoArray[1].refCount = 1; |
| infoArray[1].accessType = REGACCESS_U; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| } |
| if(num >= 3) { |
| infoArray[2].regNum = vE; |
| infoArray[2].refCount = 1; |
| infoArray[2].accessType = REGACCESS_U; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| } |
| if(num >= 4) { |
| infoArray[3].regNum = vF; |
| infoArray[3].refCount = 1; |
| infoArray[3].accessType = REGACCESS_U; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| } |
| updateCurrentBBWithConstraints(PhysicalReg_EAX); |
| updateCurrentBBWithConstraints(PhysicalReg_EDX); |
| num_regs_per_bytecode = num; |
| break; |
| #if FIXME |
| case OP_INVOKE_OBJECT_INIT_RANGE: |
| codeSize = 3; |
| num_regs_per_bytecode = 0; |
| break; |
| #endif |
| } |
| return codeSize; |
| } |
| //! Updates infoArray(TempRegInfo) with temporaries accessed by INVOKE_NO_RANGE |
| |
| //! |
| int updateInvokeNoRange(TempRegInfo* infoArray, int startInd) { |
| int j = startInd; |
| //invokeMethodNoRange |
| int count = INST_B(inst); |
| if(count == 5) { |
| infoArray[j].regNum = 22; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 4) { |
| infoArray[j].regNum = 23; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 3) { |
| infoArray[j].regNum = 24; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 2) { |
| infoArray[j].regNum = 25; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 1) { |
| infoArray[j].regNum = 26; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| return j; |
| } |
| //! Updates infoArray(TempRegInfo) with temporaries accessed by INVOKE_RANGE |
| |
| //! LOOP_COUNT is used to indicate a variable is live through a loop |
| int updateInvokeRange(TempRegInfo* infoArray, int startIndex) { |
| int j = startIndex; |
| int count = INST_AA(inst); |
| infoArray[j].regNum = 21; |
| if(count <= 10) { |
| infoArray[j].refCount = 1+count; //DU |
| } else { |
| infoArray[j].refCount = 2+3*LOOP_COUNT; |
| } |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| if(count >= 1 && count <= 10) { |
| infoArray[j].regNum = 22; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 2 && count <= 10) { |
| infoArray[j].regNum = 23; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 3 && count <= 10) { |
| infoArray[j].regNum = 24; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 4 && count <= 10) { |
| infoArray[j].regNum = 25; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 5 && count <= 10) { |
| infoArray[j].regNum = 26; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 6 && count <= 10) { |
| infoArray[j].regNum = 27; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 7 && count <= 10) { |
| infoArray[j].regNum = 28; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 8 && count <= 10) { |
| infoArray[j].regNum = 29; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count >= 9 && count <= 10) { |
| infoArray[j].regNum = 30; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count == 10) { |
| infoArray[j].regNum = 31; |
| infoArray[j].refCount = 2; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| if(count > 10) { |
| //NOTE: inside a loop, LOOP_COUNT can't be 1 |
| // if LOOP_COUNT is 1, it is likely that a logical register is freed inside the loop |
| // and the next iteration will have incorrect result |
| infoArray[j].regNum = 12; |
| infoArray[j].refCount = 1+3*LOOP_COUNT; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| infoArray[j].regNum = 13; |
| infoArray[j].refCount = 1+LOOP_COUNT; //DU |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| infoArray[j].regNum = 14; |
| //MUST be 2, otherwise, transferToState will think its state was in memory |
| infoArray[j].refCount = 2; //DU local |
| infoArray[j].physicalType = LowOpndRegType_gp; |
| j++; |
| } |
| return j; |
| } |
| |
| /* update temporaries used by RETURN bytecodes |
| a temporary is represented by <number, type of the temporary> |
| */ |
| int updateReturnCommon(TempRegInfo* infoArray) { |
| int numTmps; |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| infoArray[2].regNum = PhysicalReg_EAX; |
| infoArray[2].refCount = 5; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[3].regNum = 1; |
| #if defined(ENABLE_TRACING)//WITH_DEBUGGER is true WITH_PROFILER can be false |
| infoArray[3].refCount = 6+4; |
| #else |
| infoArray[3].refCount = 6; //DU |
| #endif |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 2; |
| infoArray[4].refCount = 4; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 5; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| infoArray[6].regNum = 10; |
| infoArray[6].refCount = 3; |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| infoArray[7].regNum = 6; |
| infoArray[7].refCount = 4; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp; |
| infoArray[8].regNum = 3; |
| infoArray[8].refCount = 3; |
| infoArray[8].physicalType = LowOpndRegType_gp; |
| infoArray[9].regNum = 7; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_gp; |
| numTmps = 12; |
| #if defined(ENABLE_TRACING) |
| infoArray[12].regNum = 4; |
| infoArray[12].refCount = 3; //DU |
| infoArray[12].physicalType = LowOpndRegType_gp; |
| infoArray[13].regNum = 3; |
| infoArray[13].refCount = 2; //DU |
| infoArray[13].physicalType = LowOpndRegType_scratch; |
| infoArray[14].regNum = 15; |
| infoArray[14].refCount = 2; //DU |
| infoArray[14].physicalType = LowOpndRegType_gp; |
| infoArray[15].regNum = 16; |
| infoArray[15].refCount = 2; //DU |
| infoArray[15].physicalType = LowOpndRegType_gp; |
| infoArray[16].regNum = PhysicalReg_EDX; |
| infoArray[16].refCount = 2; //DU |
| infoArray[16].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[17].regNum = 6; |
| infoArray[17].refCount = 2; //DU |
| infoArray[17].physicalType = LowOpndRegType_scratch; |
| numTmps = 18; |
| #endif |
| infoArray[10].regNum = 14; |
| infoArray[10].refCount = 2; //DU |
| infoArray[10].physicalType = LowOpndRegType_gp; |
| infoArray[11].regNum = 4; |
| infoArray[11].refCount = 2; //DU |
| infoArray[11].physicalType = LowOpndRegType_scratch; |
| #ifdef DEBUG_CALL_STACK |
| infoArray[numTmps].regNum = 5; |
| infoArray[numTmps].refCount = 2; |
| infoArray[numTmps].physicalType = LowOpndRegType_scratch; |
| numTmps++; |
| #endif |
| infoArray[numTmps].regNum = PhysicalReg_EBX; |
| /* used to hold chaining cell |
| updated to be returnAddr |
| then conditionally updated to zero |
| used to update inJitCodeCache |
| compare against zero to determine whether to jump to native code |
| jump to native code (%ebx) |
| */ |
| infoArray[numTmps].refCount = 3+1+1; |
| infoArray[numTmps].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| numTmps++; |
| infoArray[numTmps].regNum = 17; |
| infoArray[numTmps].refCount = 2; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_gp; |
| numTmps++; |
| infoArray[numTmps].regNum = 7; |
| infoArray[numTmps].refCount = 4; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_scratch; |
| numTmps++; |
| return numTmps; |
| } |
| |
| /* update temporaries used by predicted INVOKE_VIRTUAL & INVOKE_INTERFACE */ |
| int updateGenPrediction(TempRegInfo* infoArray, bool isInterface) { |
| infoArray[0].regNum = 40; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 41; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 32; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| |
| if(isInterface) { |
| infoArray[0].refCount = 2+2; |
| infoArray[1].refCount = 3+2-1; //for temp41, -1 for gingerbread |
| infoArray[3].regNum = 33; |
| infoArray[3].refCount = 4+1; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = PhysicalReg_EAX; |
| infoArray[4].refCount = 5; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[5].regNum = PhysicalReg_ECX; |
| infoArray[5].refCount = 1+1+2; //used in ArgsDone (twice) |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[6].regNum = 10; |
| infoArray[6].refCount = 2; |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| infoArray[7].regNum = 9; |
| infoArray[7].refCount = 2; |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| infoArray[8].regNum = 8; |
| infoArray[8].refCount = 2; |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| infoArray[9].regNum = PhysicalReg_EDX; //space holder |
| infoArray[9].refCount = 1; |
| infoArray[9].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[10].regNum = 43; |
| infoArray[10].refCount = 3; |
| infoArray[10].physicalType = LowOpndRegType_gp; |
| infoArray[11].regNum = 44; |
| infoArray[11].refCount = 3; |
| infoArray[11].physicalType = LowOpndRegType_gp; |
| infoArray[12].regNum = 45; |
| infoArray[12].refCount = 2; |
| infoArray[12].physicalType = LowOpndRegType_gp; |
| infoArray[13].regNum = 7; |
| infoArray[13].refCount = 4; |
| infoArray[13].physicalType = LowOpndRegType_scratch; |
| return 14; |
| } else { //virtual or virtual_quick |
| infoArray[0].refCount = 2+2; |
| infoArray[1].refCount = 3+2-2; //for temp41, -2 for gingerbread |
| infoArray[2].refCount++; //for temp32 gingerbread |
| infoArray[3].regNum = 33; |
| infoArray[3].refCount = 4+1; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 34; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = PhysicalReg_EAX; |
| infoArray[5].refCount = 2; |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[6].regNum = PhysicalReg_ECX; |
| infoArray[6].refCount = 1+3+2; |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[7].regNum = 10; |
| infoArray[7].refCount = 2; |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| infoArray[8].regNum = PhysicalReg_EDX; //space holder |
| infoArray[8].refCount = 1; |
| infoArray[8].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[9].regNum = 43; |
| infoArray[9].refCount = 3; |
| infoArray[9].physicalType = LowOpndRegType_gp; |
| infoArray[10].regNum = 44; |
| infoArray[10].refCount = 3; |
| infoArray[10].physicalType = LowOpndRegType_gp; |
| infoArray[11].regNum = 7; |
| infoArray[11].refCount = 4; |
| infoArray[11].physicalType = LowOpndRegType_scratch; |
| return 12; |
| } |
| } |
| |
| int updateMarkCard(TempRegInfo* infoArray, int j1/*valReg*/, |
| int j2/*tgtAddrReg*/, int j3/*scratchReg*/) { |
| infoArray[j3].regNum = 11; |
| infoArray[j3].physicalType = LowOpndRegType_gp; |
| infoArray[j3].refCount = 3; |
| infoArray[j3].is8Bit = true; |
| infoArray[j1].refCount++; |
| infoArray[j2].refCount += 2; |
| infoArray[j3+1].regNum = 6; |
| infoArray[j3+1].physicalType = LowOpndRegType_scratch; |
| infoArray[j3+1].refCount = 2; |
| return j3+2; |
| } |
| |
| int updateMarkCard_notNull(TempRegInfo* infoArray, |
| int j2/*tgtAddrReg*/, int j3/*scratchReg*/) { |
| infoArray[j3].regNum = 11; |
| infoArray[j3].physicalType = LowOpndRegType_gp; |
| infoArray[j3].refCount = 3; |
| infoArray[j3].is8Bit = true; |
| infoArray[j2].refCount += 2; |
| infoArray[j3+1].regNum = 2; |
| infoArray[j3+1].refCount = 2; //DU |
| infoArray[j3+1].physicalType = LowOpndRegType_scratch; |
| return j3+2; |
| } |
| |
| int iget_obj_inst = -1; |
| //! This function updates infoArray with temporaries accessed when lowering the bytecode |
| |
| //! returns the number of temporaries |
| int getTempRegInfo(TempRegInfo* infoArray) { //returns an array of TempRegInfo |
| int k; |
| int numTmps; |
| for(k = 0; k < MAX_TEMP_REG_PER_BYTECODE; k++) { |
| infoArray[k].linkageToVR = -1; |
| infoArray[k].versionNum = 0; |
| infoArray[k].shareWithVR = true; |
| infoArray[k].is8Bit = false; |
| } |
| u2 vA, v1, length, num, tmp; |
| u2 inst_op = INST_INST(inst); |
| s2 tmp_s2; |
| s4 tmp_s4; |
| switch(inst_op) { |
| case OP_APUT_BYTE: |
| for(k = 0; k < MAX_TEMP_REG_PER_BYTECODE; k++) |
| infoArray[k].shareWithVR = true; //false; |
| break; |
| } |
| switch (INST_INST(inst)) { |
| case OP_NOP: |
| return 0; |
| case OP_MOVE: |
| case OP_MOVE_OBJECT: |
| case OP_MOVE_FROM16: |
| case OP_MOVE_OBJECT_FROM16: |
| case OP_MOVE_16: |
| case OP_MOVE_OBJECT_16: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| return 1; |
| case OP_MOVE_WIDE: |
| case OP_MOVE_WIDE_FROM16: |
| case OP_MOVE_WIDE_16: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| return 1; |
| case OP_MOVE_RESULT: |
| case OP_MOVE_RESULT_OBJECT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| return 2; |
| case OP_MOVE_RESULT_WIDE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| return 2; |
| case OP_MOVE_EXCEPTION: |
| infoArray[0].regNum = 2; |
| infoArray[0].refCount = 3; //DUU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 3; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| return 3; |
| |
| case OP_CONST_4: |
| case OP_CONST_16: |
| case OP_CONST: |
| case OP_CONST_HIGH16: |
| case OP_CONST_WIDE_16: |
| case OP_CONST_WIDE_32: |
| case OP_CONST_WIDE: |
| case OP_CONST_WIDE_HIGH16: |
| return 0; |
| case OP_CONST_STRING: //hardcode %eax |
| case OP_CONST_STRING_JUMBO: |
| infoArray[0].regNum = 3; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| infoArray[2].regNum = 2; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 4; |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 4; |
| case OP_CONST_CLASS: |
| infoArray[0].regNum = 3; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| infoArray[2].regNum = 2; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 4; |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 4; |
| |
| case OP_MONITOR_ENTER: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 3; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| infoArray[3].regNum = 2; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 5; |
| case OP_MONITOR_EXIT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EAX; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| infoArray[3].regNum = PhysicalReg_EDX; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[4].regNum = 2; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| infoArray[5].regNum = 3; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| return 6; |
| case OP_CHECK_CAST: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 4; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 6; |
| infoArray[2].refCount = 3; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| infoArray[4].regNum = 2; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[5].regNum = PhysicalReg_EAX; |
| /* %eax has 3 live ranges |
| 1> 5 accesses: to resolve the class object |
| 2> call dvmInstanceofNonTrivial to define %eax, then use it once |
| 3> move exception object to %eax, then jump to throw_exception |
| if WITH_JIT is true, the first live range has 6 accesses |
| */ |
| infoArray[5].refCount = 6; |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[6].regNum = PhysicalReg_EDX; |
| infoArray[6].refCount = 2; //export_pc |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[7].regNum = PhysicalReg_ECX; |
| infoArray[7].refCount = 1; |
| infoArray[7].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[8].regNum = 3; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| return 9; |
| case OP_INSTANCE_OF: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 3; |
| infoArray[1].refCount = 4; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 4; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 6; |
| infoArray[3].refCount = 3; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| |
| infoArray[4].regNum = 1; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| infoArray[5].regNum = 2; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[6].regNum = PhysicalReg_EAX; |
| infoArray[6].refCount = 6; |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[7].regNum = 3; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| infoArray[8].regNum = PhysicalReg_EDX; |
| infoArray[8].refCount = 2; //export_pc for class_resolve |
| infoArray[8].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 9; |
| |
| case OP_ARRAY_LENGTH: |
| vA = INST_A(inst); |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[1].linkageToVR = vA; |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 3; |
| case OP_NEW_INSTANCE: |
| infoArray[0].regNum = PhysicalReg_EAX; |
| //6: class object |
| //3: defined by C function, used twice |
| infoArray[0].refCount = 6; //next version has 3 references |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].regNum = PhysicalReg_ECX; //before common_throw_message |
| infoArray[1].refCount = 1; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 5; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[3].is8Bit = true; |
| infoArray[4].regNum = 6; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| |
| infoArray[5].regNum = 1; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| infoArray[6].regNum = 2; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| infoArray[7].regNum = 3; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[8].regNum = PhysicalReg_EDX; //before common_throw_message |
| infoArray[8].refCount = 2; |
| infoArray[8].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[9].regNum = 4; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_scratch; |
| return 10; |
| |
| case OP_NEW_ARRAY: |
| infoArray[0].regNum = PhysicalReg_EAX; |
| //4: class object |
| //3: defined by C function, used twice |
| infoArray[0].refCount = 4; //next version has 3 references |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].regNum = PhysicalReg_EDX; //before common_throw_message |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 5; |
| infoArray[3].refCount = 3; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| |
| infoArray[4].regNum = 1; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| infoArray[5].regNum = 2; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| infoArray[6].regNum = 3; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| infoArray[7].regNum = 4; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| return 8; |
| |
| case OP_FILLED_NEW_ARRAY: |
| length = INST_B(inst); |
| infoArray[0].regNum = PhysicalReg_EAX; |
| //4: class object |
| //3: defined by C function, used twice (array object) |
| //length: access array object to update the content |
| infoArray[0].refCount = 4; //next version has 5+length references |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].regNum = PhysicalReg_EDX; //before common_throw_message |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 5; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 6; |
| infoArray[4].refCount = 8; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[4].is8Bit = true; |
| |
| if(length >= 1) { |
| infoArray[5].regNum = 7; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 2) { |
| infoArray[6].regNum = 8; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 3) { |
| infoArray[7].regNum = 9; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 4) { |
| infoArray[8].regNum = 10; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_gp; |
| } |
| if(length >= 5) { |
| infoArray[9].regNum = 11; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_gp; |
| } |
| infoArray[5+length].regNum = 1; |
| infoArray[5+length].refCount = 2; //DU |
| infoArray[5+length].physicalType = LowOpndRegType_scratch; |
| infoArray[6+length].regNum = 2; |
| infoArray[6+length].refCount = 4; //DU |
| infoArray[6+length].physicalType = LowOpndRegType_scratch; |
| infoArray[7+length].regNum = 3; |
| infoArray[7+length].refCount = 2; //DU |
| infoArray[7+length].physicalType = LowOpndRegType_scratch; |
| infoArray[8+length].regNum = 4; |
| infoArray[8+length].refCount = 5; //DU |
| infoArray[8+length].physicalType = LowOpndRegType_scratch; |
| return 9+length; |
| |
| case OP_FILLED_NEW_ARRAY_RANGE: |
| length = INST_AA(inst); |
| infoArray[0].regNum = PhysicalReg_EAX; |
| //4: class object |
| //3: defined by C function, used twice (array object) |
| //if length is 0, no access to array object |
| //else, used inside a loop |
| infoArray[0].refCount = 4; //next version: 5+(length >= 1 ? LOOP_COUNT : 0) |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].regNum = PhysicalReg_EDX; //before common_throw_message |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 5; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 6; |
| infoArray[4].refCount = 8; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[4].is8Bit = true; |
| |
| infoArray[5].regNum = 1; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| infoArray[6].regNum = 2; |
| infoArray[6].refCount = 4; //DU |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| infoArray[7].regNum = 3; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[8].regNum = 7; |
| infoArray[8].refCount = 3*(length >= 1 ? LOOP_COUNT : 0); |
| infoArray[8].physicalType = LowOpndRegType_gp; |
| infoArray[9].regNum = 8; |
| infoArray[9].refCount = 3*(length >= 1 ? LOOP_COUNT : 0); |
| infoArray[9].physicalType = LowOpndRegType_gp; |
| infoArray[10].regNum = 9; |
| infoArray[10].refCount = 2*(length >= 1 ? LOOP_COUNT : 0); |
| infoArray[10].physicalType = LowOpndRegType_gp; |
| infoArray[11].regNum = 10; |
| infoArray[11].refCount = 2*(length >= 1 ? LOOP_COUNT : 0); |
| infoArray[11].physicalType = LowOpndRegType_gp; |
| infoArray[12].regNum = 4; |
| infoArray[12].refCount = 5; //DU |
| infoArray[12].physicalType = LowOpndRegType_scratch; |
| return 13; |
| |
| case OP_FILL_ARRAY_DATA: |
| infoArray[0].regNum = PhysicalReg_EAX; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].regNum = PhysicalReg_EDX; //before common_throw_message |
| #if 0//def HARDREG_OPT |
| infoArray[1].refCount = 3; //next version has refCount of 2 |
| #else |
| infoArray[1].refCount = 5; |
| #endif |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum =1; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| infoArray[4].regNum = 2; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| return 5; |
| |
| case OP_THROW: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EDX; //before common_throw_message |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| infoArray[3].regNum = 2; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| return 4; |
| case OP_THROW_VERIFICATION_ERROR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EDX; //export_pc |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| infoArray[3].regNum = 2; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| return 4; |
| |
| case OP_GOTO: //called function common_periodicChecks4 |
| #if defined(ENABLE_TRACING) |
| tt = INST_AA(inst); |
| tmp_s2 = (s2)((s2)tt << 8) >> 8; |
| if(tmp_s2 < 0) { |
| infoArray[0].regNum = PhysicalReg_EDX; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 1; |
| } |
| #endif |
| return 0; |
| case OP_GOTO_16: |
| #if defined(ENABLE_TRACING) |
| tmp_s2 = (s2)FETCH(1); |
| if(tmp_s2 < 0) { |
| infoArray[0].regNum = PhysicalReg_EDX; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 1; |
| } |
| #endif |
| return 0; |
| case OP_GOTO_32: |
| #if defined(ENABLE_TRACING) |
| tmp_u4 = (u4)FETCH(1); |
| tmp_u4 |= (u4)FETCH(2) << 16; |
| if(((s4)tmp_u4) < 0) { |
| infoArray[0].regNum = PhysicalReg_EDX; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 1; |
| } |
| #endif |
| return 0; |
| case OP_IF_EQ: |
| case OP_IF_NE: |
| case OP_IF_LT: |
| case OP_IF_GE: |
| case OP_IF_GT: |
| case OP_IF_LE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| #if defined(ENABLE_TRACING) |
| tmp_s2 = (s2)FETCH(1); |
| if(tmp_s2 < 0) { |
| infoArray[1].regNum = PhysicalReg_EDX; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 2; |
| } |
| #endif |
| return 1; |
| case OP_IF_EQZ: //called function common_periodicChecks4 |
| case OP_IF_NEZ: |
| case OP_IF_LTZ: |
| case OP_IF_GEZ: |
| case OP_IF_GTZ: |
| case OP_IF_LEZ: |
| #if defined(ENABLE_TRACING) |
| tmp_s2 = (s2)FETCH(1); |
| if(tmp_s2 < 0) { |
| infoArray[0].regNum = PhysicalReg_EDX; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 1; |
| } |
| #endif |
| return 0; |
| case OP_PACKED_SWITCH: //jump common_backwardBranch, which calls common_periodicChecks_entry, then jump_reg %eax |
| case OP_SPARSE_SWITCH: //%edx, %eax |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EDX; |
| infoArray[1].refCount = 6; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[2].regNum = PhysicalReg_EAX; //return by dvm helper |
| infoArray[2].refCount = 2+1; //2 uses |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| infoArray[4].regNum = 2; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| return 5; |
| |
| case OP_AGET: |
| case OP_AGET_OBJECT: |
| case OP_AGET_BOOLEAN: |
| case OP_AGET_BYTE: |
| case OP_AGET_CHAR: |
| case OP_AGET_SHORT: |
| vA = INST_AA(inst); |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[3].linkageToVR = vA; |
| if(inst_op == OP_AGET_BYTE || inst_op == OP_AGET_BOOLEAN) |
| infoArray[3].is8Bit = true; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 5; |
| case OP_AGET_WIDE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_xmm; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 5; |
| |
| case OP_APUT: |
| case OP_APUT_BOOLEAN: |
| case OP_APUT_BYTE: |
| case OP_APUT_CHAR: |
| case OP_APUT_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| if(inst_op == OP_APUT_BYTE || inst_op == OP_APUT_BOOLEAN) |
| infoArray[3].is8Bit = true; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 5; |
| case OP_APUT_WIDE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_xmm; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 5; |
| case OP_APUT_OBJECT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 5+1; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; //live through function call dvmCanPut |
| infoArray[1].refCount = 3+1; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 4+1; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 6; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| |
| infoArray[6].regNum = PhysicalReg_EDX; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[7].regNum = PhysicalReg_EAX; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[8].regNum = 1; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| infoArray[0].shareWithVR = false; |
| return updateMarkCard_notNull(infoArray, |
| 0/*index for tgtAddrReg*/, 9); |
| |
| case OP_IGET: |
| case OP_IGET_OBJECT: |
| case OP_IGET_VOLATILE: |
| case OP_IGET_OBJECT_VOLATILE: |
| case OP_IGET_BOOLEAN: |
| case OP_IGET_BYTE: |
| case OP_IGET_CHAR: |
| case OP_IGET_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 3; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[4].regNum = 3; |
| infoArray[4].refCount = 3; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 7; |
| #ifdef DEBUG_IGET_OBJ |
| //add hack for a specific instance (iget_obj_inst) of IGET_OBJECT within a method |
| if(inst_op == OP_IGET_OBJECT && !strncmp(currentMethod->clazz->descriptor, "Lspec/benchmarks/_228_jack/Parse", 32) && |
| !strncmp(currentMethod->name, "buildPhase3", 11)) |
| { |
| #if 0 |
| if(iget_obj_inst == 12) { |
| LOGD("increase count for instance %d of %s %s", iget_obj_inst, currentMethod->clazz->descriptor, currentMethod->name); |
| infoArray[5].refCount = 4; //DU |
| } |
| else |
| #endif |
| infoArray[5].refCount = 3; |
| iget_obj_inst++; |
| } |
| else |
| infoArray[5].refCount = 3; |
| #else |
| infoArray[5].refCount = 3; //DU |
| #endif |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| infoArray[6].regNum = 8; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| infoArray[7].regNum = 9; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp; |
| return 8; |
| case OP_IPUT: |
| case OP_IPUT_OBJECT: |
| case OP_IPUT_VOLATILE: |
| case OP_IPUT_OBJECT_VOLATILE: |
| case OP_IPUT_BOOLEAN: |
| case OP_IPUT_BYTE: |
| case OP_IPUT_CHAR: |
| case OP_IPUT_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 3; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[4].regNum = 3; |
| infoArray[4].refCount = 3; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 7; |
| infoArray[5].refCount = 3; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| infoArray[6].regNum = 8; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| infoArray[7].regNum = 9; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp; |
| if(inst_op == OP_IPUT_OBJECT || inst_op == OP_IPUT_OBJECT_VOLATILE) { |
| infoArray[5].shareWithVR = false; |
| return updateMarkCard(infoArray, 7/*index for valReg*/, |
| 5/*index for tgtAddrReg*/, 8); |
| } |
| return 8; |
| case OP_IGET_WIDE: |
| case OP_IGET_WIDE_VOLATILE: |
| case OP_IPUT_WIDE: |
| case OP_IPUT_WIDE_VOLATILE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 3; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[4].regNum = 3; |
| infoArray[4].refCount = 3; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 7; |
| infoArray[5].refCount = 3; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| infoArray[6].regNum = 8; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| infoArray[7].regNum = 1; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_xmm; |
| |
| if(inst_op == OP_IPUT_WIDE_VOLATILE || inst_op == OP_IGET_WIDE_VOLATILE) { |
| infoArray[8].regNum = 3; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| infoArray[9].regNum = 9; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_gp; |
| return 10; |
| } |
| return 8; |
| |
| case OP_SGET: |
| case OP_SGET_OBJECT: |
| case OP_SGET_VOLATILE: |
| case OP_SGET_OBJECT_VOLATILE: |
| case OP_SGET_BOOLEAN: |
| case OP_SGET_BYTE: |
| case OP_SGET_CHAR: |
| case OP_SGET_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[2].regNum = PhysicalReg_EAX; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = 3; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 7; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = PhysicalReg_EDX; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 6; |
| case OP_SPUT: |
| case OP_SPUT_OBJECT: |
| case OP_SPUT_VOLATILE: |
| case OP_SPUT_OBJECT_VOLATILE: |
| case OP_SPUT_BOOLEAN: |
| case OP_SPUT_BYTE: |
| case OP_SPUT_CHAR: |
| case OP_SPUT_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[2].regNum = PhysicalReg_EAX; |
| infoArray[2].refCount = 2+1; //access clazz of the field |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = 3; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 7; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = PhysicalReg_EDX; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| if(inst_op == OP_SPUT_OBJECT || inst_op == OP_SPUT_OBJECT_VOLATILE) { |
| infoArray[2].shareWithVR = false; |
| infoArray[6].regNum = 12; |
| infoArray[6].refCount = 1; //1 def, 2 uses in updateMarkCard |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| return updateMarkCard(infoArray, 4/*index for valReg*/, |
| 6/*index for tgtAddrReg */, 7); |
| } |
| return 6; |
| case OP_SGET_WIDE: |
| case OP_SGET_WIDE_VOLATILE: |
| case OP_SPUT_WIDE: |
| case OP_SPUT_WIDE_VOLATILE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_scratch; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_scratch; |
| |
| infoArray[2].regNum = PhysicalReg_EAX; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = 3; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 1; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_xmm; |
| infoArray[5].regNum = PhysicalReg_EDX; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| if(inst_op == OP_SPUT_WIDE_VOLATILE || inst_op == OP_SGET_WIDE_VOLATILE) { |
| infoArray[6].regNum = 3; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| infoArray[7].regNum = 9; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp; |
| return 8; |
| } |
| return 6; |
| |
| case OP_IGET_QUICK: |
| case OP_IGET_OBJECT_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 3; |
| case OP_IPUT_QUICK: |
| case OP_IPUT_OBJECT_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| if(inst_op == OP_IPUT_OBJECT_QUICK) { |
| infoArray[0].shareWithVR = false; |
| return updateMarkCard(infoArray, 1/*index for valReg*/, |
| 0/*index for tgtAddrReg*/, 3); |
| } |
| return 3; |
| case OP_IGET_WIDE_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 3; |
| case OP_IPUT_WIDE_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 3; |
| |
| case OP_RETURN_VOID: |
| case OP_RETURN_VOID_BARRIER: |
| return updateReturnCommon(infoArray); |
| case OP_RETURN: |
| case OP_RETURN_OBJECT: |
| numTmps = updateReturnCommon(infoArray); |
| |
| infoArray[numTmps].regNum = 21; |
| infoArray[numTmps].refCount = 2; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_gp; |
| numTmps++; |
| infoArray[numTmps].regNum = 22; |
| infoArray[numTmps].refCount = 2; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_gp; |
| numTmps++; |
| return numTmps; |
| case OP_RETURN_WIDE: |
| numTmps = updateReturnCommon(infoArray); |
| |
| infoArray[numTmps].regNum = 10; |
| infoArray[numTmps].refCount = 2; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_scratch; |
| numTmps++; |
| infoArray[numTmps].regNum = 1; |
| infoArray[numTmps].refCount = 2; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_xmm; |
| numTmps++; |
| return numTmps; |
| |
| case OP_INVOKE_VIRTUAL: |
| case OP_INVOKE_VIRTUAL_RANGE: |
| #ifdef PREDICTED_CHAINING |
| numTmps = updateGenPrediction(infoArray, false /*not interface*/); |
| infoArray[numTmps].regNum = 5; |
| infoArray[numTmps].refCount = 3; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_gp; |
| numTmps++; |
| if(inst_op == OP_INVOKE_VIRTUAL) |
| k = updateInvokeNoRange(infoArray, numTmps); |
| else |
| k = updateInvokeRange(infoArray, numTmps); |
| return k; |
| #else |
| infoArray[0].regNum = 3; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 7; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 8; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 6; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 3; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = PhysicalReg_EDX; |
| infoArray[5].refCount = 2; //2 versions, first version DU is for exception, 2nd version: eip right before jumping to invokeArgsDone |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[6].regNum = PhysicalReg_ECX; //ecx is ued in invokeArgsDone |
| infoArray[6].refCount = 1+1; //used in .invokeArgsDone |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| //when WITH_JIT is true and PREDICTED_CHAINING is false |
| // temp 8 and EAX are not used; but it is okay to keep it here |
| infoArray[7].regNum = PhysicalReg_EAX; |
| infoArray[7].refCount = 4; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[8].regNum = 1; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| infoArray[9].regNum = 2; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_INVOKE_VIRTUAL) |
| k = updateInvokeNoRange(infoArray, 10); |
| else |
| k = updateInvokeRange(infoArray, 10); |
| return k; |
| #endif |
| case OP_INVOKE_SUPER: |
| case OP_INVOKE_SUPER_RANGE: |
| infoArray[0].regNum = 3; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 7; |
| infoArray[1].refCount = 3; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 8; |
| infoArray[2].refCount = 3; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 6; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 9; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| |
| infoArray[5].regNum = PhysicalReg_EDX; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[6].regNum = PhysicalReg_ECX; |
| infoArray[6].refCount = 1+1; //DU |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[7].regNum = PhysicalReg_EAX; |
| infoArray[7].refCount = 4; //DU |
| infoArray[7].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[8].regNum = 1; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| infoArray[9].regNum = 2; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_scratch; |
| infoArray[10].regNum = 3; |
| infoArray[10].refCount = 2; //DU |
| infoArray[10].physicalType = LowOpndRegType_scratch; |
| infoArray[11].regNum = 4; |
| infoArray[11].refCount = 2; //DU |
| infoArray[11].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_INVOKE_SUPER) |
| k = updateInvokeNoRange(infoArray, 12); |
| else |
| k = updateInvokeRange(infoArray, 12); |
| return k; |
| case OP_INVOKE_DIRECT: |
| case OP_INVOKE_DIRECT_RANGE: |
| infoArray[0].regNum = 3; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 5; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| |
| infoArray[2].regNum = PhysicalReg_EDX; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = PhysicalReg_ECX; |
| infoArray[3].refCount = 2; |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[4].regNum = PhysicalReg_EAX; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[5].regNum = 1; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| infoArray[6].regNum = 2; |
| infoArray[6].refCount = 2; //DU |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_INVOKE_DIRECT) |
| k = updateInvokeNoRange(infoArray, 7); |
| else |
| k = updateInvokeRange(infoArray, 7); |
| return k; |
| case OP_INVOKE_STATIC: |
| case OP_INVOKE_STATIC_RANGE: |
| infoArray[0].regNum = 3; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| |
| infoArray[1].regNum = PhysicalReg_EDX; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[2].regNum = PhysicalReg_ECX; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[4].regNum = 1; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| infoArray[5].regNum = 2; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_INVOKE_STATIC) |
| k = updateInvokeNoRange(infoArray, 6); |
| else |
| k = updateInvokeRange(infoArray, 6); |
| return k; |
| case OP_INVOKE_INTERFACE: |
| case OP_INVOKE_INTERFACE_RANGE: |
| #ifdef PREDICTED_CHAINING |
| numTmps = updateGenPrediction(infoArray, true /*interface*/); |
| infoArray[numTmps].regNum = 1; |
| infoArray[numTmps].refCount = 3; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_gp; |
| numTmps++; |
| if(inst_op == OP_INVOKE_INTERFACE) |
| k = updateInvokeNoRange(infoArray, numTmps); |
| else |
| k = updateInvokeRange(infoArray, numTmps); |
| return k; |
| #else |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 3; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 4; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 5; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[5].regNum = PhysicalReg_ECX; |
| infoArray[5].refCount = 1+1; //DU |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[6].regNum = PhysicalReg_EAX; |
| infoArray[6].refCount = 2+1; //2 uses |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[7].regNum = 1; |
| infoArray[7].refCount = 2; //DU |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| infoArray[8].regNum = 2; |
| infoArray[8].refCount = 2; //DU |
| infoArray[8].physicalType = LowOpndRegType_scratch; |
| infoArray[9].regNum = 3; |
| infoArray[9].refCount = 2; //DU |
| infoArray[9].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_INVOKE_INTERFACE) |
| k = updateInvokeNoRange(infoArray, 10); |
| else |
| k = updateInvokeRange(infoArray, 10); |
| return k; |
| #endif |
| ////////////////////////////////////////////// ALU |
| case OP_NEG_INT: |
| case OP_NOT_INT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].shareWithVR = false; |
| return 1; |
| case OP_NEG_LONG: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //define, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 4; //define, update, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| case OP_NOT_LONG: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| case OP_NEG_FLOAT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].shareWithVR = false; |
| return 1; |
| case OP_NEG_DOUBLE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //define, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //define, update, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| case OP_INT_TO_LONG: //hard-code eax & edx |
| infoArray[0].regNum = PhysicalReg_EAX; |
| infoArray[0].refCount = 2+1; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = PhysicalReg_EDX; |
| infoArray[1].refCount = 1+1; //cdq accesses edx & eax |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 2; |
| case OP_INT_TO_FLOAT: |
| case OP_INT_TO_DOUBLE: |
| case OP_LONG_TO_FLOAT: |
| case OP_LONG_TO_DOUBLE: |
| case OP_FLOAT_TO_DOUBLE: |
| case OP_DOUBLE_TO_FLOAT: |
| return 0; //fp stack |
| case OP_LONG_TO_INT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| return 1; |
| case OP_FLOAT_TO_INT: |
| case OP_DOUBLE_TO_INT: //fp stack |
| return 0; |
| case OP_FLOAT_TO_LONG: |
| case OP_DOUBLE_TO_LONG: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //define, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //define, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //define, use |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| return 3; |
| case OP_INT_TO_BYTE: |
| case OP_INT_TO_CHAR: |
| case OP_INT_TO_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //define, update, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].shareWithVR = false; |
| return 1; |
| |
| case OP_ADD_INT: |
| case OP_SUB_INT: |
| case OP_MUL_INT: |
| case OP_AND_INT: |
| case OP_OR_INT: |
| case OP_XOR_INT: |
| case OP_ADD_INT_2ADDR: |
| case OP_SUB_INT_2ADDR: |
| case OP_MUL_INT_2ADDR: |
| case OP_AND_INT_2ADDR: |
| case OP_OR_INT_2ADDR: |
| case OP_XOR_INT_2ADDR: |
| if(inst_op == OP_ADD_INT || inst_op == OP_SUB_INT || inst_op == OP_MUL_INT || |
| inst_op == OP_AND_INT || inst_op == OP_OR_INT || inst_op == OP_XOR_INT) { |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| } else { |
| vA = INST_A(inst); |
| v1 = vA; |
| } |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| if(vA != v1) |
| infoArray[0].shareWithVR = false; |
| return 1; //common_alu_int |
| |
| case OP_SHL_INT: |
| case OP_SHR_INT: |
| case OP_USHR_INT: |
| case OP_SHL_INT_2ADDR: |
| case OP_SHR_INT_2ADDR: |
| case OP_USHR_INT_2ADDR: //use %cl or %ecx? |
| if(inst_op == OP_SHL_INT || inst_op == OP_SHR_INT || inst_op == OP_USHR_INT) { |
| vA = INST_AA(inst); |
| v1 = *((u1*)rPC + 2); |
| } else { |
| vA = INST_A(inst); |
| v1 = vA; |
| } |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| if(vA != v1) |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = PhysicalReg_ECX; |
| infoArray[1].refCount = 2; //define, use |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 2;//common_shift_int |
| |
| case OP_DIV_INT: |
| case OP_REM_INT: |
| case OP_DIV_INT_2ADDR: |
| case OP_REM_INT_2ADDR: //hard-code %eax, %edx (dividend in edx:eax; quotient in eax; remainder in edx) |
| infoArray[0].regNum = 2; |
| infoArray[0].refCount = 4; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EAX; //dividend, quotient |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].shareWithVR = false; |
| infoArray[2].regNum = PhysicalReg_EDX; //export_pc, output for REM |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //define, use |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_DIV_INT || inst_op == OP_DIV_INT_2ADDR) { |
| infoArray[1].refCount = 5; |
| infoArray[2].refCount = 4; |
| } else { |
| infoArray[1].refCount = 4; |
| infoArray[2].refCount = 5; |
| } |
| return 4; |
| |
| case OP_ADD_INT_LIT16: |
| case OP_MUL_INT_LIT16: |
| case OP_AND_INT_LIT16: |
| case OP_OR_INT_LIT16: |
| case OP_XOR_INT_LIT16: |
| case OP_ADD_INT_LIT8: |
| case OP_MUL_INT_LIT8: |
| case OP_AND_INT_LIT8: |
| case OP_OR_INT_LIT8: |
| case OP_XOR_INT_LIT8: |
| case OP_SHL_INT_LIT8: |
| case OP_SHR_INT_LIT8: |
| case OP_USHR_INT_LIT8: |
| if(inst_op == OP_ADD_INT_LIT16 || inst_op == OP_MUL_INT_LIT16 || |
| inst_op == OP_AND_INT_LIT16 || inst_op == OP_OR_INT_LIT16 || inst_op == OP_XOR_INT_LIT16) { |
| vA = INST_A(inst); |
| v1 = INST_B(inst); |
| } else { |
| vA = INST_AA(inst); |
| v1 = (u2)FETCH(1) & 0xff; |
| } |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| if(vA != v1) |
| infoArray[0].shareWithVR = false; |
| return 1; |
| |
| case OP_RSUB_INT_LIT8: |
| case OP_RSUB_INT: |
| vA = INST_AA(inst); |
| v1 = (inst_op == OP_RSUB_INT) ? INST_B(inst) : ((u2)FETCH(1) & 0xff); |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| if(vA != v1) |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| if(vA != v1) |
| infoArray[1].shareWithVR = false; |
| return 2; |
| |
| case OP_DIV_INT_LIT16: |
| case OP_REM_INT_LIT16: |
| case OP_DIV_INT_LIT8: |
| case OP_REM_INT_LIT8: |
| if(inst_op == OP_DIV_INT_LIT8 || inst_op == OP_REM_INT_LIT8) { |
| tmp_s2 = (s2)FETCH(1) >> 8; |
| } |
| else { |
| tmp_s4 = (s2)FETCH(1); |
| tmp_s2 = tmp_s4; |
| } |
| if((inst_op == OP_DIV_INT_LIT8 || inst_op == OP_DIV_INT_LIT16)) { |
| int power = isPowerOfTwo(tmp_s2); |
| if(power >= 1) { /* divide by a power of 2 constant */ |
| infoArray[0].regNum = 2; |
| infoArray[0].refCount = 3; //define, use, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| if(power == 1) infoArray[1].refCount = 5; |
| else infoArray[1].refCount = 6; |
| return 2; |
| } |
| } |
| if(tmp_s2 == 0) { |
| //export_pc |
| infoArray[0].regNum = PhysicalReg_EDX; //export_pc, output for REM |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 1; |
| } |
| if(inst_op == OP_DIV_INT_LIT16 || inst_op == OP_DIV_INT_LIT8) { |
| if(tmp_s2 == -1) |
| infoArray[1].refCount = 4+1; |
| else |
| infoArray[1].refCount = 4; |
| infoArray[2].refCount = 2; //edx |
| } else { |
| if(tmp_s2 == -1) |
| infoArray[1].refCount = 3+1; |
| else |
| infoArray[1].refCount = 3; |
| infoArray[2].refCount = 3; //edx |
| } |
| infoArray[0].regNum = 2; |
| infoArray[0].refCount = 2; //define, use |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EAX; //dividend, quotient |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[1].shareWithVR = false; |
| infoArray[2].regNum = PhysicalReg_EDX; //export_pc, output for REM |
| infoArray[2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 3; |
| |
| case OP_ADD_LONG: |
| case OP_SUB_LONG: |
| case OP_AND_LONG: |
| case OP_OR_LONG: |
| case OP_XOR_LONG: |
| case OP_ADD_LONG_2ADDR: |
| case OP_SUB_LONG_2ADDR: |
| case OP_AND_LONG_2ADDR: |
| case OP_OR_LONG_2ADDR: |
| case OP_XOR_LONG_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //define, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| |
| case OP_SHL_LONG: |
| case OP_SHL_LONG_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //define, update, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[1].shareWithVR = false; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //define, use |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| return 3; |
| |
| case OP_SHR_LONG: |
| case OP_SHR_LONG_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 4; //define, update, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[1].shareWithVR = false; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //define, use |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 3; |
| infoArray[3].physicalType = LowOpndRegType_xmm; |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 3; |
| infoArray[4].physicalType = LowOpndRegType_xmm; |
| return 5; |
| |
| case OP_USHR_LONG: |
| case OP_USHR_LONG_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //define, update, use |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //define, update, use |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[1].shareWithVR = false; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //define, use |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| return 3; |
| |
| case OP_MUL_LONG: //general purpose register |
| case OP_MUL_LONG_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 6; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 2+1; //for mul_opc |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; //for mul_opc |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 5; |
| |
| case OP_DIV_LONG: |
| case OP_REM_LONG: |
| case OP_DIV_LONG_2ADDR: |
| case OP_REM_LONG_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_xmm; |
| infoArray[3].regNum = PhysicalReg_EAX; |
| infoArray[3].refCount = 2; //defined by function call |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; //next version has 2 references |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[5].regNum = 1; |
| infoArray[5].refCount = 2; |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| return 6; |
| |
| case OP_ADD_FLOAT: |
| case OP_SUB_FLOAT: |
| case OP_MUL_FLOAT: |
| case OP_ADD_FLOAT_2ADDR: |
| case OP_SUB_FLOAT_2ADDR: |
| case OP_MUL_FLOAT_2ADDR: |
| case OP_ADD_DOUBLE: //PhysicalReg_FP TODO |
| case OP_SUB_DOUBLE: |
| case OP_MUL_DOUBLE: |
| case OP_ADD_DOUBLE_2ADDR: |
| case OP_SUB_DOUBLE_2ADDR: |
| case OP_MUL_DOUBLE_2ADDR: |
| case OP_DIV_FLOAT: |
| case OP_DIV_FLOAT_2ADDR: |
| case OP_DIV_DOUBLE: |
| case OP_DIV_DOUBLE_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| //for ALU ops with 2ADDR, the temp variable can share the same physical |
| //reg as the virtual register, since the content of VR is updated by |
| //the content of the temp variable |
| if(inst_op == OP_ADD_FLOAT || inst_op == OP_SUB_FLOAT || |
| inst_op == OP_MUL_FLOAT || inst_op == OP_ADD_DOUBLE || |
| inst_op == OP_SUB_DOUBLE || inst_op == OP_MUL_DOUBLE || |
| inst_op == OP_DIV_FLOAT || inst_op == OP_DIV_DOUBLE) |
| infoArray[0].shareWithVR = false; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| case OP_REM_FLOAT: |
| case OP_REM_FLOAT_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| return 3; |
| |
| case OP_REM_DOUBLE: |
| case OP_REM_DOUBLE_2ADDR: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| return 3; |
| |
| case OP_CMPL_FLOAT: |
| case OP_CMPL_DOUBLE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 2; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 3; |
| infoArray[3].refCount = 2; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 4; //return |
| infoArray[4].refCount = 5; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| return 5; |
| |
| case OP_CMPG_FLOAT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 2; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 3; |
| infoArray[3].refCount = 5; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| return 4; |
| break; |
| case OP_CMPG_DOUBLE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_xmm; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 2; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 3; |
| infoArray[3].refCount = 5; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| return 4; |
| |
| case OP_CMP_LONG: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 3; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 6; |
| infoArray[5].refCount = 7; |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| return 6; |
| |
| case OP_EXECUTE_INLINE: |
| case OP_EXECUTE_INLINE_RANGE: |
| if(inst_op == OP_EXECUTE_INLINE) |
| num = INST_B(inst); |
| else |
| num = INST_AA(inst); |
| tmp = FETCH(1); |
| switch (tmp) { |
| case INLINE_STRING_LENGTH: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; |
| infoArray[3].physicalType = LowOpndRegType_scratch; |
| return 4; |
| case INLINE_STRING_IS_EMPTY: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 4; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 1; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_scratch; |
| return 3; |
| case INLINE_STRING_FASTINDEXOF_II: |
| #if defined(USE_GLOBAL_STRING_DEFS) |
| break; |
| #else |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 14 * LOOP_COUNT; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3 * LOOP_COUNT; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 11 * LOOP_COUNT; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 3 * LOOP_COUNT; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 9 * LOOP_COUNT; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 6; |
| infoArray[5].refCount = 4 * LOOP_COUNT; |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| infoArray[6].regNum = 7; |
| infoArray[6].refCount = 2; |
| infoArray[6].physicalType = LowOpndRegType_gp; |
| infoArray[7].regNum = 1; |
| infoArray[7].refCount = 2; |
| infoArray[7].physicalType = LowOpndRegType_scratch; |
| return 8; |
| #endif |
| case INLINE_MATH_ABS_LONG: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 7; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 3; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 6; |
| infoArray[5].refCount = 5; |
| infoArray[5].physicalType = LowOpndRegType_gp; |
| return 6; |
| case INLINE_MATH_ABS_INT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 5; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 4; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| return 3; |
| case INLINE_MATH_MAX_INT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| return 3; |
| case INLINE_MATH_ABS_FLOAT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| return 2; |
| case INLINE_MATH_ABS_DOUBLE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| return 3; |
| case INLINE_FLOAT_TO_RAW_INT_BITS: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| return 2; |
| case INLINE_INT_BITS_TO_FLOAT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| return 2; |
| case INLINE_DOUBLE_TO_RAW_LONG_BITS: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| return 3; |
| case INLINE_LONG_BITS_TO_DOUBLE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 3; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| return 3; |
| default: |
| break; |
| } |
| |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 4; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| if(num >= 1) { |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| } |
| if(num >= 2) { |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| } |
| if(num >= 3) { |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 2; |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| } |
| if(num >= 4) { |
| infoArray[4].regNum = 5; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| } |
| infoArray[num+1].regNum = 6; |
| infoArray[num+1].refCount = 2; |
| infoArray[num+1].physicalType = LowOpndRegType_gp; |
| infoArray[num+2].regNum = PhysicalReg_EAX; |
| infoArray[num+2].refCount = 2; |
| infoArray[num+2].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[num+3].regNum = PhysicalReg_EDX; |
| infoArray[num+3].refCount = 2; |
| infoArray[num+3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[num+4].regNum = 1; |
| infoArray[num+4].refCount = 4; |
| infoArray[num+4].physicalType = LowOpndRegType_scratch; |
| return num+5; |
| #if FIXME |
| case OP_INVOKE_OBJECT_INIT_RANGE: |
| return 0; |
| #endif |
| case OP_INVOKE_VIRTUAL_QUICK: |
| case OP_INVOKE_VIRTUAL_QUICK_RANGE: |
| #ifdef PREDICTED_CHAINING |
| numTmps = updateGenPrediction(infoArray, false /*not interface*/); |
| infoArray[numTmps].regNum = 1; |
| infoArray[numTmps].refCount = 3; //DU |
| infoArray[numTmps].physicalType = LowOpndRegType_gp; |
| numTmps++; |
| if(inst_op == OP_INVOKE_VIRTUAL_QUICK) |
| k = updateInvokeNoRange(infoArray, numTmps); |
| else |
| k = updateInvokeRange(infoArray, numTmps); |
| return k; |
| #else |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| |
| infoArray[3].regNum = PhysicalReg_ECX; |
| infoArray[3].refCount = 1+1; |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| if(inst_op == OP_INVOKE_VIRTUAL_QUICK_RANGE) |
| k = updateInvokeRange(infoArray, 5); |
| else |
| k = updateInvokeNoRange(infoArray, 5); |
| return k; |
| #endif |
| case OP_INVOKE_SUPER_QUICK: |
| case OP_INVOKE_SUPER_QUICK_RANGE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 4; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 5; |
| infoArray[2].refCount = 2; |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| |
| infoArray[3].regNum = PhysicalReg_ECX; |
| infoArray[3].refCount = 1+1; |
| infoArray[3].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| infoArray[4].regNum = PhysicalReg_EDX; |
| infoArray[4].refCount = 2; |
| infoArray[4].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| |
| infoArray[5].regNum = 1; |
| infoArray[5].refCount = 2; |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| infoArray[6].regNum = 2; |
| infoArray[6].refCount = 2; |
| infoArray[6].physicalType = LowOpndRegType_scratch; |
| if(inst_op == OP_INVOKE_SUPER_QUICK_RANGE) |
| k = updateInvokeRange(infoArray, 7); |
| else |
| k = updateInvokeNoRange(infoArray, 7); |
| return k; |
| #ifdef SUPPORT_HLO |
| case kExtInstruction: |
| switch(inst) { |
| case OP_X_AGET_QUICK: |
| case OP_X_AGET_OBJECT_QUICK: |
| case OP_X_AGET_BOOLEAN_QUICK: |
| case OP_X_AGET_BYTE_QUICK: |
| case OP_X_AGET_CHAR_QUICK: |
| case OP_X_AGET_SHORT_QUICK: |
| vA = FETCH(1) & 0xff; |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[3].linkageToVR = vA; |
| if(inst == OP_X_AGET_BYTE_QUICK || inst == OP_X_AGET_BOOLEAN_QUICK) |
| infoArray[3].is8Bit = true; |
| return 4; |
| case OP_X_AGET_WIDE_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_xmm; |
| return 4; |
| case OP_X_APUT_QUICK: |
| case OP_X_APUT_OBJECT_QUICK: |
| case OP_X_APUT_BOOLEAN_QUICK: |
| case OP_X_APUT_BYTE_QUICK: |
| case OP_X_APUT_CHAR_QUICK: |
| case OP_X_APUT_SHORT_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 4; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| if(inst == OP_X_APUT_BYTE_QUICK || inst == OP_X_APUT_BOOLEAN_QUICK) |
| infoArray[3].is8Bit = true; |
| return 4; |
| case OP_X_APUT_WIDE_QUICK: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 1; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_xmm; |
| return 4; |
| case OP_X_DEREF_GET: |
| case OP_X_DEREF_GET_OBJECT: |
| case OP_X_DEREF_GET_BOOLEAN: |
| case OP_X_DEREF_GET_BYTE: |
| case OP_X_DEREF_GET_CHAR: |
| case OP_X_DEREF_GET_SHORT: |
| vA = FETCH(1) & 0xff; |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[1].linkageToVR = vA; |
| if(inst == OP_X_DEREF_GET_BYTE || inst == OP_X_DEREF_GET_BOOLEAN) |
| infoArray[1].is8Bit = true; |
| return 2; |
| case OP_X_DEREF_GET_WIDE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| case OP_X_DEREF_PUT: |
| case OP_X_DEREF_PUT_OBJECT: |
| case OP_X_DEREF_PUT_BOOLEAN: |
| case OP_X_DEREF_PUT_BYTE: |
| case OP_X_DEREF_PUT_CHAR: |
| case OP_X_DEREF_PUT_SHORT: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| if(inst == OP_X_DEREF_PUT_BYTE || inst == OP_X_DEREF_PUT_BOOLEAN) |
| infoArray[1].is8Bit = true; |
| return 2; |
| case OP_X_DEREF_PUT_WIDE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 1; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_xmm; |
| return 2; |
| case OP_X_ARRAY_CHECKS: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| return 2; |
| case OP_X_CHECK_BOUNDS: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 2; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| return 2; |
| case OP_X_CHECK_NULL: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 2; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = PhysicalReg_EDX; |
| infoArray[1].refCount = 2; |
| infoArray[1].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 2; |
| case OP_X_CHECK_TYPE: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 3; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 5; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 6; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 1; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_scratch; |
| infoArray[5].regNum = PhysicalReg_EAX; |
| infoArray[5].refCount = 2; |
| infoArray[5].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 6; |
| case OP_X_ARRAY_OBJECT_CHECKS: |
| infoArray[0].regNum = 1; |
| infoArray[0].refCount = 3; //DU |
| infoArray[0].physicalType = LowOpndRegType_gp; |
| infoArray[1].regNum = 2; |
| infoArray[1].refCount = 4; //DU |
| infoArray[1].physicalType = LowOpndRegType_gp; |
| infoArray[2].regNum = 3; |
| infoArray[2].refCount = 2; //DU |
| infoArray[2].physicalType = LowOpndRegType_gp; |
| infoArray[3].regNum = 5; |
| infoArray[3].refCount = 2; //DU |
| infoArray[3].physicalType = LowOpndRegType_gp; |
| infoArray[4].regNum = 6; |
| infoArray[4].refCount = 2; //DU |
| infoArray[4].physicalType = LowOpndRegType_gp; |
| infoArray[5].regNum = 1; |
| infoArray[5].refCount = 2; //DU |
| infoArray[5].physicalType = LowOpndRegType_scratch; |
| infoArray[6].regNum = PhysicalReg_EAX; |
| infoArray[6].refCount = 2; |
| infoArray[6].physicalType = LowOpndRegType_gp | LowOpndRegType_hard; |
| return 7; |
| } |
| #endif |
| } |
| return -1; |
| } |
