| /* |
| * Copyright (C) 2011 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. |
| */ |
| |
| #include "object_utils.h" |
| |
| #include "../compiler_internals.h" |
| #include "local_optimizations.h" |
| #include "codegen_util.h" |
| #include "ralloc_util.h" |
| |
| namespace art { |
| |
| // TODO: unify bad_loc |
| const RegLocation bad_loc = {kLocDalvikFrame, 0, 0, 0, 0, 0, 0, 0, 0, |
| INVALID_REG, INVALID_REG, INVALID_SREG, |
| INVALID_SREG}; |
| |
| /* Mark register usage state and return long retloc */ |
| RegLocation GetReturnWide(CompilationUnit* cu, bool is_double) |
| { |
| RegLocation gpr_res = LocCReturnWide(); |
| RegLocation fpr_res = LocCReturnDouble(); |
| RegLocation res = is_double ? fpr_res : gpr_res; |
| Clobber(cu, res.low_reg); |
| Clobber(cu, res.high_reg); |
| LockTemp(cu, res.low_reg); |
| LockTemp(cu, res.high_reg); |
| MarkPair(cu, res.low_reg, res.high_reg); |
| return res; |
| } |
| |
| RegLocation GetReturn(CompilationUnit* cu, bool is_float) |
| { |
| RegLocation gpr_res = LocCReturn(); |
| RegLocation fpr_res = LocCReturnFloat(); |
| RegLocation res = is_float ? fpr_res : gpr_res; |
| Clobber(cu, res.low_reg); |
| if (cu->instruction_set == kMips) { |
| MarkInUse(cu, res.low_reg); |
| } else { |
| LockTemp(cu, res.low_reg); |
| } |
| return res; |
| } |
| |
| /* |
| * Target-independent code generation. Use only high-level |
| * load/store utilities here, or target-dependent genXX() handlers |
| * when necessary. |
| */ |
| static bool CompileDalvikInstruction(CompilationUnit* cu, MIR* mir, BasicBlock* bb, |
| LIR* label_list) |
| { |
| bool res = false; // Assume success |
| RegLocation rl_src[3]; |
| RegLocation rl_dest = bad_loc; |
| RegLocation rl_result = bad_loc; |
| Instruction::Code opcode = mir->dalvikInsn.opcode; |
| int opt_flags = mir->optimization_flags; |
| uint32_t vB = mir->dalvikInsn.vB; |
| uint32_t vC = mir->dalvikInsn.vC; |
| |
| /* Prep Src and Dest locations */ |
| int next_sreg = 0; |
| int next_loc = 0; |
| int attrs = oat_data_flow_attributes[opcode]; |
| rl_src[0] = rl_src[1] = rl_src[2] = bad_loc; |
| if (attrs & DF_UA) { |
| if (attrs & DF_A_WIDE) { |
| rl_src[next_loc++] = GetSrcWide(cu, mir, next_sreg); |
| next_sreg+= 2; |
| } else { |
| rl_src[next_loc++] = GetSrc(cu, mir, next_sreg); |
| next_sreg++; |
| } |
| } |
| if (attrs & DF_UB) { |
| if (attrs & DF_B_WIDE) { |
| rl_src[next_loc++] = GetSrcWide(cu, mir, next_sreg); |
| next_sreg+= 2; |
| } else { |
| rl_src[next_loc++] = GetSrc(cu, mir, next_sreg); |
| next_sreg++; |
| } |
| } |
| if (attrs & DF_UC) { |
| if (attrs & DF_C_WIDE) { |
| rl_src[next_loc++] = GetSrcWide(cu, mir, next_sreg); |
| } else { |
| rl_src[next_loc++] = GetSrc(cu, mir, next_sreg); |
| } |
| } |
| if (attrs & DF_DA) { |
| if (attrs & DF_A_WIDE) { |
| rl_dest = GetDestWide(cu, mir); |
| } else { |
| rl_dest = GetDest(cu, mir); |
| } |
| } |
| switch (opcode) { |
| case Instruction::NOP: |
| break; |
| |
| case Instruction::MOVE_EXCEPTION: |
| GenMoveException(cu, rl_dest); |
| break; |
| case Instruction::RETURN_VOID: |
| if (!(cu->attrs & METHOD_IS_LEAF)) { |
| GenSuspendTest(cu, opt_flags); |
| } |
| break; |
| |
| case Instruction::RETURN: |
| case Instruction::RETURN_OBJECT: |
| if (!(cu->attrs & METHOD_IS_LEAF)) { |
| GenSuspendTest(cu, opt_flags); |
| } |
| StoreValue(cu, GetReturn(cu, cu->shorty[0] == 'F'), rl_src[0]); |
| break; |
| |
| case Instruction::RETURN_WIDE: |
| if (!(cu->attrs & METHOD_IS_LEAF)) { |
| GenSuspendTest(cu, opt_flags); |
| } |
| StoreValueWide(cu, GetReturnWide(cu, |
| cu->shorty[0] == 'D'), rl_src[0]); |
| break; |
| |
| case Instruction::MOVE_RESULT_WIDE: |
| if (opt_flags & MIR_INLINED) |
| break; // Nop - combined w/ previous invoke |
| StoreValueWide(cu, rl_dest, GetReturnWide(cu, rl_dest.fp)); |
| break; |
| |
| case Instruction::MOVE_RESULT: |
| case Instruction::MOVE_RESULT_OBJECT: |
| if (opt_flags & MIR_INLINED) |
| break; // Nop - combined w/ previous invoke |
| StoreValue(cu, rl_dest, GetReturn(cu, rl_dest.fp)); |
| break; |
| |
| case Instruction::MOVE: |
| case Instruction::MOVE_OBJECT: |
| case Instruction::MOVE_16: |
| case Instruction::MOVE_OBJECT_16: |
| case Instruction::MOVE_FROM16: |
| case Instruction::MOVE_OBJECT_FROM16: |
| StoreValue(cu, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::MOVE_WIDE: |
| case Instruction::MOVE_WIDE_16: |
| case Instruction::MOVE_WIDE_FROM16: |
| StoreValueWide(cu, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::CONST: |
| case Instruction::CONST_4: |
| case Instruction::CONST_16: |
| rl_result = EvalLoc(cu, rl_dest, kAnyReg, true); |
| LoadConstantNoClobber(cu, rl_result.low_reg, vB); |
| StoreValue(cu, rl_dest, rl_result); |
| break; |
| |
| case Instruction::CONST_HIGH16: |
| rl_result = EvalLoc(cu, rl_dest, kAnyReg, true); |
| LoadConstantNoClobber(cu, rl_result.low_reg, vB << 16); |
| StoreValue(cu, rl_dest, rl_result); |
| break; |
| |
| case Instruction::CONST_WIDE_16: |
| case Instruction::CONST_WIDE_32: |
| rl_result = EvalLoc(cu, rl_dest, kAnyReg, true); |
| LoadConstantValueWide(cu, rl_result.low_reg, rl_result.high_reg, vB, |
| (vB & 0x80000000) ? -1 : 0); |
| StoreValueWide(cu, rl_dest, rl_result); |
| break; |
| |
| case Instruction::CONST_WIDE: |
| rl_result = EvalLoc(cu, rl_dest, kAnyReg, true); |
| LoadConstantValueWide(cu, rl_result.low_reg, rl_result.high_reg, |
| mir->dalvikInsn.vB_wide & 0xffffffff, |
| (mir->dalvikInsn.vB_wide >> 32) & 0xffffffff); |
| StoreValueWide(cu, rl_dest, rl_result); |
| break; |
| |
| case Instruction::CONST_WIDE_HIGH16: |
| rl_result = EvalLoc(cu, rl_dest, kAnyReg, true); |
| LoadConstantValueWide(cu, rl_result.low_reg, rl_result.high_reg, |
| 0, vB << 16); |
| StoreValueWide(cu, rl_dest, rl_result); |
| break; |
| |
| case Instruction::MONITOR_ENTER: |
| GenMonitorEnter(cu, opt_flags, rl_src[0]); |
| break; |
| |
| case Instruction::MONITOR_EXIT: |
| GenMonitorExit(cu, opt_flags, rl_src[0]); |
| break; |
| |
| case Instruction::CHECK_CAST: |
| GenCheckCast(cu, vB, rl_src[0]); |
| break; |
| |
| case Instruction::INSTANCE_OF: |
| GenInstanceof(cu, vC, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::NEW_INSTANCE: |
| GenNewInstance(cu, vB, rl_dest); |
| break; |
| |
| case Instruction::THROW: |
| GenThrow(cu, rl_src[0]); |
| break; |
| |
| case Instruction::ARRAY_LENGTH: |
| int len_offset; |
| len_offset = Array::LengthOffset().Int32Value(); |
| rl_src[0] = LoadValue(cu, rl_src[0], kCoreReg); |
| GenNullCheck(cu, rl_src[0].s_reg_low, rl_src[0].low_reg, opt_flags); |
| rl_result = EvalLoc(cu, rl_dest, kCoreReg, true); |
| LoadWordDisp(cu, rl_src[0].low_reg, len_offset, rl_result.low_reg); |
| StoreValue(cu, rl_dest, rl_result); |
| break; |
| |
| case Instruction::CONST_STRING: |
| case Instruction::CONST_STRING_JUMBO: |
| GenConstString(cu, vB, rl_dest); |
| break; |
| |
| case Instruction::CONST_CLASS: |
| GenConstClass(cu, vB, rl_dest); |
| break; |
| |
| case Instruction::FILL_ARRAY_DATA: |
| GenFillArrayData(cu, vB, rl_src[0]); |
| break; |
| |
| case Instruction::FILLED_NEW_ARRAY: |
| GenFilledNewArray(cu, NewMemCallInfo(cu, bb, mir, kStatic, |
| false /* not range */)); |
| break; |
| |
| case Instruction::FILLED_NEW_ARRAY_RANGE: |
| GenFilledNewArray(cu, NewMemCallInfo(cu, bb, mir, kStatic, |
| true /* range */)); |
| break; |
| |
| case Instruction::NEW_ARRAY: |
| GenNewArray(cu, vC, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::GOTO: |
| case Instruction::GOTO_16: |
| case Instruction::GOTO_32: |
| if (bb->taken->start_offset <= mir->offset) { |
| GenSuspendTestAndBranch(cu, opt_flags, &label_list[bb->taken->id]); |
| } else { |
| OpUnconditionalBranch(cu, &label_list[bb->taken->id]); |
| } |
| break; |
| |
| case Instruction::PACKED_SWITCH: |
| GenPackedSwitch(cu, vB, rl_src[0]); |
| break; |
| |
| case Instruction::SPARSE_SWITCH: |
| GenSparseSwitch(cu, vB, rl_src[0]); |
| break; |
| |
| case Instruction::CMPL_FLOAT: |
| case Instruction::CMPG_FLOAT: |
| case Instruction::CMPL_DOUBLE: |
| case Instruction::CMPG_DOUBLE: |
| res = GenCmpFP(cu, opcode, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::CMP_LONG: |
| GenCmpLong(cu, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::IF_EQ: |
| case Instruction::IF_NE: |
| case Instruction::IF_LT: |
| case Instruction::IF_GE: |
| case Instruction::IF_GT: |
| case Instruction::IF_LE: { |
| LIR* taken = &label_list[bb->taken->id]; |
| LIR* fall_through = &label_list[bb->fall_through->id]; |
| bool backward_branch; |
| backward_branch = (bb->taken->start_offset <= mir->offset); |
| if (backward_branch) { |
| GenSuspendTest(cu, opt_flags); |
| } |
| GenCompareAndBranch(cu, opcode, rl_src[0], rl_src[1], taken, |
| fall_through); |
| break; |
| } |
| |
| case Instruction::IF_EQZ: |
| case Instruction::IF_NEZ: |
| case Instruction::IF_LTZ: |
| case Instruction::IF_GEZ: |
| case Instruction::IF_GTZ: |
| case Instruction::IF_LEZ: { |
| LIR* taken = &label_list[bb->taken->id]; |
| LIR* fall_through = &label_list[bb->fall_through->id]; |
| bool backward_branch; |
| backward_branch = (bb->taken->start_offset <= mir->offset); |
| if (backward_branch) { |
| GenSuspendTest(cu, opt_flags); |
| } |
| GenCompareZeroAndBranch(cu, opcode, rl_src[0], taken, fall_through); |
| break; |
| } |
| |
| case Instruction::AGET_WIDE: |
| GenArrayGet(cu, opt_flags, kLong, rl_src[0], rl_src[1], rl_dest, 3); |
| break; |
| case Instruction::AGET: |
| case Instruction::AGET_OBJECT: |
| GenArrayGet(cu, opt_flags, kWord, rl_src[0], rl_src[1], rl_dest, 2); |
| break; |
| case Instruction::AGET_BOOLEAN: |
| GenArrayGet(cu, opt_flags, kUnsignedByte, rl_src[0], rl_src[1], rl_dest, 0); |
| break; |
| case Instruction::AGET_BYTE: |
| GenArrayGet(cu, opt_flags, kSignedByte, rl_src[0], rl_src[1], rl_dest, 0); |
| break; |
| case Instruction::AGET_CHAR: |
| GenArrayGet(cu, opt_flags, kUnsignedHalf, rl_src[0], rl_src[1], rl_dest, 1); |
| break; |
| case Instruction::AGET_SHORT: |
| GenArrayGet(cu, opt_flags, kSignedHalf, rl_src[0], rl_src[1], rl_dest, 1); |
| break; |
| case Instruction::APUT_WIDE: |
| GenArrayPut(cu, opt_flags, kLong, rl_src[1], rl_src[2], rl_src[0], 3); |
| break; |
| case Instruction::APUT: |
| GenArrayPut(cu, opt_flags, kWord, rl_src[1], rl_src[2], rl_src[0], 2); |
| break; |
| case Instruction::APUT_OBJECT: |
| GenArrayObjPut(cu, opt_flags, rl_src[1], rl_src[2], rl_src[0], 2); |
| break; |
| case Instruction::APUT_SHORT: |
| case Instruction::APUT_CHAR: |
| GenArrayPut(cu, opt_flags, kUnsignedHalf, rl_src[1], rl_src[2], rl_src[0], 1); |
| break; |
| case Instruction::APUT_BYTE: |
| case Instruction::APUT_BOOLEAN: |
| GenArrayPut(cu, opt_flags, kUnsignedByte, rl_src[1], rl_src[2], |
| rl_src[0], 0); |
| break; |
| |
| case Instruction::IGET_OBJECT: |
| //case Instruction::IGET_OBJECT_VOLATILE: |
| GenIGet(cu, vC, opt_flags, kWord, rl_dest, rl_src[0], false, true); |
| break; |
| |
| case Instruction::IGET_WIDE: |
| //case Instruction::IGET_WIDE_VOLATILE: |
| GenIGet(cu, vC, opt_flags, kLong, rl_dest, rl_src[0], true, false); |
| break; |
| |
| case Instruction::IGET: |
| //case Instruction::IGET_VOLATILE: |
| GenIGet(cu, vC, opt_flags, kWord, rl_dest, rl_src[0], false, false); |
| break; |
| |
| case Instruction::IGET_CHAR: |
| GenIGet(cu, vC, opt_flags, kUnsignedHalf, rl_dest, rl_src[0], false, false); |
| break; |
| |
| case Instruction::IGET_SHORT: |
| GenIGet(cu, vC, opt_flags, kSignedHalf, rl_dest, rl_src[0], false, false); |
| break; |
| |
| case Instruction::IGET_BOOLEAN: |
| case Instruction::IGET_BYTE: |
| GenIGet(cu, vC, opt_flags, kUnsignedByte, rl_dest, rl_src[0], false, false); |
| break; |
| |
| case Instruction::IPUT_WIDE: |
| //case Instruction::IPUT_WIDE_VOLATILE: |
| GenIPut(cu, vC, opt_flags, kLong, rl_src[0], rl_src[1], true, false); |
| break; |
| |
| case Instruction::IPUT_OBJECT: |
| //case Instruction::IPUT_OBJECT_VOLATILE: |
| GenIPut(cu, vC, opt_flags, kWord, rl_src[0], rl_src[1], false, true); |
| break; |
| |
| case Instruction::IPUT: |
| //case Instruction::IPUT_VOLATILE: |
| GenIPut(cu, vC, opt_flags, kWord, rl_src[0], rl_src[1], false, false); |
| break; |
| |
| case Instruction::IPUT_BOOLEAN: |
| case Instruction::IPUT_BYTE: |
| GenIPut(cu, vC, opt_flags, kUnsignedByte, rl_src[0], rl_src[1], false, false); |
| break; |
| |
| case Instruction::IPUT_CHAR: |
| GenIPut(cu, vC, opt_flags, kUnsignedHalf, rl_src[0], rl_src[1], false, false); |
| break; |
| |
| case Instruction::IPUT_SHORT: |
| GenIPut(cu, vC, opt_flags, kSignedHalf, rl_src[0], rl_src[1], false, false); |
| break; |
| |
| case Instruction::SGET_OBJECT: |
| GenSget(cu, vB, rl_dest, false, true); |
| break; |
| case Instruction::SGET: |
| case Instruction::SGET_BOOLEAN: |
| case Instruction::SGET_BYTE: |
| case Instruction::SGET_CHAR: |
| case Instruction::SGET_SHORT: |
| GenSget(cu, vB, rl_dest, false, false); |
| break; |
| |
| case Instruction::SGET_WIDE: |
| GenSget(cu, vB, rl_dest, true, false); |
| break; |
| |
| case Instruction::SPUT_OBJECT: |
| GenSput(cu, vB, rl_src[0], false, true); |
| break; |
| |
| case Instruction::SPUT: |
| case Instruction::SPUT_BOOLEAN: |
| case Instruction::SPUT_BYTE: |
| case Instruction::SPUT_CHAR: |
| case Instruction::SPUT_SHORT: |
| GenSput(cu, vB, rl_src[0], false, false); |
| break; |
| |
| case Instruction::SPUT_WIDE: |
| GenSput(cu, vB, rl_src[0], true, false); |
| break; |
| |
| case Instruction::INVOKE_STATIC_RANGE: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kStatic, true)); |
| break; |
| case Instruction::INVOKE_STATIC: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kStatic, false)); |
| break; |
| |
| case Instruction::INVOKE_DIRECT: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kDirect, false)); |
| break; |
| case Instruction::INVOKE_DIRECT_RANGE: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kDirect, true)); |
| break; |
| |
| case Instruction::INVOKE_VIRTUAL: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kVirtual, false)); |
| break; |
| case Instruction::INVOKE_VIRTUAL_RANGE: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kVirtual, true)); |
| break; |
| |
| case Instruction::INVOKE_SUPER: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kSuper, false)); |
| break; |
| case Instruction::INVOKE_SUPER_RANGE: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kSuper, true)); |
| break; |
| |
| case Instruction::INVOKE_INTERFACE: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kInterface, false)); |
| break; |
| case Instruction::INVOKE_INTERFACE_RANGE: |
| GenInvoke(cu, NewMemCallInfo(cu, bb, mir, kInterface, true)); |
| break; |
| |
| case Instruction::NEG_INT: |
| case Instruction::NOT_INT: |
| res = GenArithOpInt(cu, opcode, rl_dest, rl_src[0], rl_src[0]); |
| break; |
| |
| case Instruction::NEG_LONG: |
| case Instruction::NOT_LONG: |
| res = GenArithOpLong(cu, opcode, rl_dest, rl_src[0], rl_src[0]); |
| break; |
| |
| case Instruction::NEG_FLOAT: |
| res = GenArithOpFloat(cu, opcode, rl_dest, rl_src[0], rl_src[0]); |
| break; |
| |
| case Instruction::NEG_DOUBLE: |
| res = GenArithOpDouble(cu, opcode, rl_dest, rl_src[0], rl_src[0]); |
| break; |
| |
| case Instruction::INT_TO_LONG: |
| GenIntToLong(cu, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::LONG_TO_INT: |
| rl_src[0] = UpdateLocWide(cu, rl_src[0]); |
| rl_src[0] = WideToNarrow(cu, rl_src[0]); |
| StoreValue(cu, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::INT_TO_BYTE: |
| case Instruction::INT_TO_SHORT: |
| case Instruction::INT_TO_CHAR: |
| GenIntNarrowing(cu, opcode, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::INT_TO_FLOAT: |
| case Instruction::INT_TO_DOUBLE: |
| case Instruction::LONG_TO_FLOAT: |
| case Instruction::LONG_TO_DOUBLE: |
| case Instruction::FLOAT_TO_INT: |
| case Instruction::FLOAT_TO_LONG: |
| case Instruction::FLOAT_TO_DOUBLE: |
| case Instruction::DOUBLE_TO_INT: |
| case Instruction::DOUBLE_TO_LONG: |
| case Instruction::DOUBLE_TO_FLOAT: |
| GenConversion(cu, opcode, rl_dest, rl_src[0]); |
| break; |
| |
| case Instruction::ADD_INT: |
| case Instruction::SUB_INT: |
| case Instruction::MUL_INT: |
| case Instruction::DIV_INT: |
| case Instruction::REM_INT: |
| case Instruction::AND_INT: |
| case Instruction::OR_INT: |
| case Instruction::XOR_INT: |
| case Instruction::SHL_INT: |
| case Instruction::SHR_INT: |
| case Instruction::USHR_INT: |
| case Instruction::ADD_INT_2ADDR: |
| case Instruction::SUB_INT_2ADDR: |
| case Instruction::MUL_INT_2ADDR: |
| case Instruction::DIV_INT_2ADDR: |
| case Instruction::REM_INT_2ADDR: |
| case Instruction::AND_INT_2ADDR: |
| case Instruction::OR_INT_2ADDR: |
| case Instruction::XOR_INT_2ADDR: |
| case Instruction::SHL_INT_2ADDR: |
| case Instruction::SHR_INT_2ADDR: |
| case Instruction::USHR_INT_2ADDR: |
| GenArithOpInt(cu, opcode, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::ADD_LONG: |
| case Instruction::SUB_LONG: |
| case Instruction::MUL_LONG: |
| case Instruction::DIV_LONG: |
| case Instruction::REM_LONG: |
| case Instruction::AND_LONG: |
| case Instruction::OR_LONG: |
| case Instruction::XOR_LONG: |
| case Instruction::ADD_LONG_2ADDR: |
| case Instruction::SUB_LONG_2ADDR: |
| case Instruction::MUL_LONG_2ADDR: |
| case Instruction::DIV_LONG_2ADDR: |
| case Instruction::REM_LONG_2ADDR: |
| case Instruction::AND_LONG_2ADDR: |
| case Instruction::OR_LONG_2ADDR: |
| case Instruction::XOR_LONG_2ADDR: |
| GenArithOpLong(cu, opcode, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::SHL_LONG: |
| case Instruction::SHR_LONG: |
| case Instruction::USHR_LONG: |
| case Instruction::SHL_LONG_2ADDR: |
| case Instruction::SHR_LONG_2ADDR: |
| case Instruction::USHR_LONG_2ADDR: |
| GenShiftOpLong(cu, opcode, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::ADD_FLOAT: |
| case Instruction::SUB_FLOAT: |
| case Instruction::MUL_FLOAT: |
| case Instruction::DIV_FLOAT: |
| case Instruction::REM_FLOAT: |
| case Instruction::ADD_FLOAT_2ADDR: |
| case Instruction::SUB_FLOAT_2ADDR: |
| case Instruction::MUL_FLOAT_2ADDR: |
| case Instruction::DIV_FLOAT_2ADDR: |
| case Instruction::REM_FLOAT_2ADDR: |
| GenArithOpFloat(cu, opcode, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::ADD_DOUBLE: |
| case Instruction::SUB_DOUBLE: |
| case Instruction::MUL_DOUBLE: |
| case Instruction::DIV_DOUBLE: |
| case Instruction::REM_DOUBLE: |
| case Instruction::ADD_DOUBLE_2ADDR: |
| case Instruction::SUB_DOUBLE_2ADDR: |
| case Instruction::MUL_DOUBLE_2ADDR: |
| case Instruction::DIV_DOUBLE_2ADDR: |
| case Instruction::REM_DOUBLE_2ADDR: |
| GenArithOpDouble(cu, opcode, rl_dest, rl_src[0], rl_src[1]); |
| break; |
| |
| case Instruction::RSUB_INT: |
| case Instruction::ADD_INT_LIT16: |
| case Instruction::MUL_INT_LIT16: |
| case Instruction::DIV_INT_LIT16: |
| case Instruction::REM_INT_LIT16: |
| case Instruction::AND_INT_LIT16: |
| case Instruction::OR_INT_LIT16: |
| case Instruction::XOR_INT_LIT16: |
| case Instruction::ADD_INT_LIT8: |
| case Instruction::RSUB_INT_LIT8: |
| case Instruction::MUL_INT_LIT8: |
| case Instruction::DIV_INT_LIT8: |
| case Instruction::REM_INT_LIT8: |
| case Instruction::AND_INT_LIT8: |
| case Instruction::OR_INT_LIT8: |
| case Instruction::XOR_INT_LIT8: |
| case Instruction::SHL_INT_LIT8: |
| case Instruction::SHR_INT_LIT8: |
| case Instruction::USHR_INT_LIT8: |
| GenArithOpIntLit(cu, opcode, rl_dest, rl_src[0], vC); |
| break; |
| |
| default: |
| res = true; |
| } |
| return res; |
| } |
| |
| /* Extended MIR instructions like PHI */ |
| static void HandleExtendedMethodMIR(CompilationUnit* cu, BasicBlock* bb, MIR* mir) |
| { |
| int op_offset = mir->dalvikInsn.opcode - kMirOpFirst; |
| char* msg = NULL; |
| if (cu->verbose) { |
| msg = static_cast<char*>(NewMem(cu, strlen(extended_mir_op_names[op_offset]) + 1, |
| false, kAllocDebugInfo)); |
| strcpy(msg, extended_mir_op_names[op_offset]); |
| } |
| LIR* op = NewLIR1(cu, kPseudoExtended, reinterpret_cast<uintptr_t>(msg)); |
| |
| switch (static_cast<ExtendedMIROpcode>(mir->dalvikInsn.opcode)) { |
| case kMirOpPhi: { |
| char* ssa_string = NULL; |
| if (cu->verbose) { |
| ssa_string = GetSSAString(cu, mir->ssa_rep); |
| } |
| op->flags.is_nop = true; |
| NewLIR1(cu, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssa_string)); |
| break; |
| } |
| case kMirOpCopy: { |
| RegLocation rl_src = GetSrc(cu, mir, 0); |
| RegLocation rl_dest = GetDest(cu, mir); |
| StoreValue(cu, rl_dest, rl_src); |
| break; |
| } |
| case kMirOpFusedCmplFloat: |
| GenFusedFPCmpBranch(cu, bb, mir, false /*gt bias*/, false /*double*/); |
| break; |
| case kMirOpFusedCmpgFloat: |
| GenFusedFPCmpBranch(cu, bb, mir, true /*gt bias*/, false /*double*/); |
| break; |
| case kMirOpFusedCmplDouble: |
| GenFusedFPCmpBranch(cu, bb, mir, false /*gt bias*/, true /*double*/); |
| break; |
| case kMirOpFusedCmpgDouble: |
| GenFusedFPCmpBranch(cu, bb, mir, true /*gt bias*/, true /*double*/); |
| break; |
| case kMirOpFusedCmpLong: |
| GenFusedLongCmpBranch(cu, bb, mir); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /* Handle the content in each basic block */ |
| static bool MethodBlockCodeGen(CompilationUnit* cu, BasicBlock* bb) |
| { |
| if (bb->block_type == kDead) return false; |
| cu->current_dalvik_offset = bb->start_offset; |
| MIR* mir; |
| LIR* label_list = cu->block_label_list; |
| int block_id = bb->id; |
| |
| cu->cur_block = bb; |
| label_list[block_id].operands[0] = bb->start_offset; |
| |
| /* Insert the block label */ |
| label_list[block_id].opcode = kPseudoNormalBlockLabel; |
| AppendLIR(cu, &label_list[block_id]); |
| |
| LIR* head_lir = NULL; |
| |
| /* If this is a catch block, export the start address */ |
| if (bb->catch_entry) { |
| head_lir = NewLIR0(cu, kPseudoExportedPC); |
| } |
| |
| /* Free temp registers and reset redundant store tracking */ |
| ResetRegPool(cu); |
| ResetDefTracking(cu); |
| |
| ClobberAllRegs(cu); |
| |
| |
| if (bb->block_type == kEntryBlock) { |
| int start_vreg = cu->num_dalvik_registers - cu->num_ins; |
| GenEntrySequence(cu, &cu->reg_location[start_vreg], |
| cu->reg_location[cu->method_sreg]); |
| } else if (bb->block_type == kExitBlock) { |
| GenExitSequence(cu); |
| } |
| |
| for (mir = bb->first_mir_insn; mir != NULL; mir = mir->next) { |
| ResetRegPool(cu); |
| if (cu->disable_opt & (1 << kTrackLiveTemps)) { |
| ClobberAllRegs(cu); |
| } |
| |
| if (cu->disable_opt & (1 << kSuppressLoads)) { |
| ResetDefTracking(cu); |
| } |
| |
| #ifndef NDEBUG |
| /* Reset temp tracking sanity check */ |
| cu->live_sreg = INVALID_SREG; |
| #endif |
| |
| cu->current_dalvik_offset = mir->offset; |
| int opcode = mir->dalvikInsn.opcode; |
| LIR* boundary_lir; |
| |
| /* Mark the beginning of a Dalvik instruction for line tracking */ |
| char* inst_str = cu->verbose ? |
| GetDalvikDisassembly(cu, mir->dalvikInsn, "") : NULL; |
| boundary_lir = MarkBoundary(cu, mir->offset, inst_str); |
| /* Remember the first LIR for this block */ |
| if (head_lir == NULL) { |
| head_lir = boundary_lir; |
| /* Set the first boundary_lir as a scheduling barrier */ |
| head_lir->def_mask = ENCODE_ALL; |
| } |
| |
| /* Don't generate the SSA annotation unless verbose mode is on */ |
| if (cu->verbose && mir->ssa_rep) { |
| char* ssa_string = GetSSAString(cu, mir->ssa_rep); |
| NewLIR1(cu, kPseudoSSARep, reinterpret_cast<uintptr_t>(ssa_string)); |
| } |
| |
| if (opcode == kMirOpCheck) { |
| // Combine check and work halves of throwing instruction. |
| MIR* work_half = mir->meta.throw_insn; |
| mir->dalvikInsn.opcode = work_half->dalvikInsn.opcode; |
| opcode = work_half->dalvikInsn.opcode; |
| SSARepresentation* ssa_rep = work_half->ssa_rep; |
| work_half->ssa_rep = mir->ssa_rep; |
| mir->ssa_rep = ssa_rep; |
| work_half->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpNop); |
| } |
| |
| if (opcode >= kMirOpFirst) { |
| HandleExtendedMethodMIR(cu, bb, mir); |
| continue; |
| } |
| |
| bool not_handled = CompileDalvikInstruction(cu, mir, bb, label_list); |
| if (not_handled) { |
| LOG(FATAL) << StringPrintf("%#06x: Opcode %#x (%s)", |
| mir->offset, opcode, |
| Instruction::Name(mir->dalvikInsn.opcode)); |
| } |
| } |
| |
| if (head_lir) { |
| /* |
| * Eliminate redundant loads/stores and delay stores into later |
| * slots |
| */ |
| ApplyLocalOptimizations(cu, head_lir, cu->last_lir_insn); |
| |
| /* |
| * Generate an unconditional branch to the fallthrough block. |
| */ |
| if (bb->fall_through) { |
| OpUnconditionalBranch(cu, &label_list[bb->fall_through->id]); |
| } |
| } |
| return false; |
| } |
| |
| void SpecialMIR2LIR(CompilationUnit* cu, SpecialCaseHandler special_case) |
| { |
| /* Find the first DalvikByteCode block */ |
| int num_reachable_blocks = cu->num_reachable_blocks; |
| const GrowableList *block_list = &cu->block_list; |
| BasicBlock*bb = NULL; |
| for (int idx = 0; idx < num_reachable_blocks; idx++) { |
| int dfs_index = cu->dfs_order.elem_list[idx]; |
| bb = reinterpret_cast<BasicBlock*>(GrowableListGetElement(block_list, dfs_index)); |
| if (bb->block_type == kDalvikByteCode) { |
| break; |
| } |
| } |
| if (bb == NULL) { |
| return; |
| } |
| DCHECK_EQ(bb->start_offset, 0); |
| DCHECK(bb->first_mir_insn != NULL); |
| |
| /* Get the first instruction */ |
| MIR* mir = bb->first_mir_insn; |
| |
| /* Free temp registers and reset redundant store tracking */ |
| ResetRegPool(cu); |
| ResetDefTracking(cu); |
| ClobberAllRegs(cu); |
| |
| GenSpecialCase(cu, bb, mir, special_case); |
| } |
| |
| void MethodMIR2LIR(CompilationUnit* cu) |
| { |
| /* Used to hold the labels of each block */ |
| cu->block_label_list = |
| static_cast<LIR*>(NewMem(cu, sizeof(LIR) * cu->num_blocks, true, kAllocLIR)); |
| |
| DataFlowAnalysisDispatcher(cu, MethodBlockCodeGen, |
| kPreOrderDFSTraversal, false /* Iterative */); |
| |
| HandleSuspendLaunchPads(cu); |
| |
| HandleThrowLaunchPads(cu); |
| |
| HandleIntrinsicLaunchPads(cu); |
| |
| if (!(cu->disable_opt & (1 << kSafeOptimizations))) { |
| RemoveRedundantBranches(cu); |
| } |
| } |
| |
| } // namespace art |
