diff options
Diffstat (limited to 'compiler/dex/mir_analysis.cc')
| -rw-r--r-- | compiler/dex/mir_analysis.cc | 1433 |
1 files changed, 0 insertions, 1433 deletions
diff --git a/compiler/dex/mir_analysis.cc b/compiler/dex/mir_analysis.cc deleted file mode 100644 index 18ce563fc2..0000000000 --- a/compiler/dex/mir_analysis.cc +++ /dev/null @@ -1,1433 +0,0 @@ -/* - * Copyright (C) 2013 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 <algorithm> -#include <memory> - -#include "base/logging.h" -#include "base/scoped_arena_containers.h" -#include "dataflow_iterator-inl.h" -#include "compiler_ir.h" -#include "dex_flags.h" -#include "dex_instruction-inl.h" -#include "dex/mir_field_info.h" -#include "dex/verified_method.h" -#include "dex/quick/dex_file_method_inliner.h" -#include "dex/quick/dex_file_to_method_inliner_map.h" -#include "driver/compiler_driver.h" -#include "driver/compiler_options.h" -#include "driver/dex_compilation_unit.h" -#include "scoped_thread_state_change.h" -#include "utils.h" - -namespace art { - -enum InstructionAnalysisAttributeOps : uint8_t { - kUninterestingOp = 0, - kArithmeticOp, - kFpOp, - kSingleOp, - kDoubleOp, - kIntOp, - kLongOp, - kBranchOp, - kInvokeOp, - kArrayOp, - kHeavyweightOp, - kSimpleConstOp, - kMoveOp, - kSwitch -}; - -enum InstructionAnalysisAttributeMasks : uint16_t { - kAnNone = 1 << kUninterestingOp, - kAnMath = 1 << kArithmeticOp, - kAnFp = 1 << kFpOp, - kAnLong = 1 << kLongOp, - kAnInt = 1 << kIntOp, - kAnSingle = 1 << kSingleOp, - kAnDouble = 1 << kDoubleOp, - kAnFloatMath = 1 << kFpOp, - kAnBranch = 1 << kBranchOp, - kAnInvoke = 1 << kInvokeOp, - kAnArrayOp = 1 << kArrayOp, - kAnHeavyWeight = 1 << kHeavyweightOp, - kAnSimpleConst = 1 << kSimpleConstOp, - kAnMove = 1 << kMoveOp, - kAnSwitch = 1 << kSwitch, - kAnComputational = kAnMath | kAnArrayOp | kAnMove | kAnSimpleConst, -}; - -// Instruction characteristics used to statically identify computation-intensive methods. -static const uint16_t kAnalysisAttributes[kMirOpLast] = { - // 00 NOP - kAnNone, - - // 01 MOVE vA, vB - kAnMove, - - // 02 MOVE_FROM16 vAA, vBBBB - kAnMove, - - // 03 MOVE_16 vAAAA, vBBBB - kAnMove, - - // 04 MOVE_WIDE vA, vB - kAnMove, - - // 05 MOVE_WIDE_FROM16 vAA, vBBBB - kAnMove, - - // 06 MOVE_WIDE_16 vAAAA, vBBBB - kAnMove, - - // 07 MOVE_OBJECT vA, vB - kAnMove, - - // 08 MOVE_OBJECT_FROM16 vAA, vBBBB - kAnMove, - - // 09 MOVE_OBJECT_16 vAAAA, vBBBB - kAnMove, - - // 0A MOVE_RESULT vAA - kAnMove, - - // 0B MOVE_RESULT_WIDE vAA - kAnMove, - - // 0C MOVE_RESULT_OBJECT vAA - kAnMove, - - // 0D MOVE_EXCEPTION vAA - kAnMove, - - // 0E RETURN_VOID - kAnBranch, - - // 0F RETURN vAA - kAnBranch, - - // 10 RETURN_WIDE vAA - kAnBranch, - - // 11 RETURN_OBJECT vAA - kAnBranch, - - // 12 CONST_4 vA, #+B - kAnSimpleConst, - - // 13 CONST_16 vAA, #+BBBB - kAnSimpleConst, - - // 14 CONST vAA, #+BBBBBBBB - kAnSimpleConst, - - // 15 CONST_HIGH16 VAA, #+BBBB0000 - kAnSimpleConst, - - // 16 CONST_WIDE_16 vAA, #+BBBB - kAnSimpleConst, - - // 17 CONST_WIDE_32 vAA, #+BBBBBBBB - kAnSimpleConst, - - // 18 CONST_WIDE vAA, #+BBBBBBBBBBBBBBBB - kAnSimpleConst, - - // 19 CONST_WIDE_HIGH16 vAA, #+BBBB000000000000 - kAnSimpleConst, - - // 1A CONST_STRING vAA, string@BBBB - kAnNone, - - // 1B CONST_STRING_JUMBO vAA, string@BBBBBBBB - kAnNone, - - // 1C CONST_CLASS vAA, type@BBBB - kAnNone, - - // 1D MONITOR_ENTER vAA - kAnNone, - - // 1E MONITOR_EXIT vAA - kAnNone, - - // 1F CHK_CAST vAA, type@BBBB - kAnNone, - - // 20 INSTANCE_OF vA, vB, type@CCCC - kAnNone, - - // 21 ARRAY_LENGTH vA, vB - kAnArrayOp, - - // 22 NEW_INSTANCE vAA, type@BBBB - kAnHeavyWeight, - - // 23 NEW_ARRAY vA, vB, type@CCCC - kAnHeavyWeight, - - // 24 FILLED_NEW_ARRAY {vD, vE, vF, vG, vA} - kAnHeavyWeight, - - // 25 FILLED_NEW_ARRAY_RANGE {vCCCC .. vNNNN}, type@BBBB - kAnHeavyWeight, - - // 26 FILL_ARRAY_DATA vAA, +BBBBBBBB - kAnNone, - - // 27 THROW vAA - kAnHeavyWeight | kAnBranch, - - // 28 GOTO - kAnBranch, - - // 29 GOTO_16 - kAnBranch, - - // 2A GOTO_32 - kAnBranch, - - // 2B PACKED_SWITCH vAA, +BBBBBBBB - kAnSwitch, - - // 2C SPARSE_SWITCH vAA, +BBBBBBBB - kAnSwitch, - - // 2D CMPL_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // 2E CMPG_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // 2F CMPL_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // 30 CMPG_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // 31 CMP_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // 32 IF_EQ vA, vB, +CCCC - kAnMath | kAnBranch | kAnInt, - - // 33 IF_NE vA, vB, +CCCC - kAnMath | kAnBranch | kAnInt, - - // 34 IF_LT vA, vB, +CCCC - kAnMath | kAnBranch | kAnInt, - - // 35 IF_GE vA, vB, +CCCC - kAnMath | kAnBranch | kAnInt, - - // 36 IF_GT vA, vB, +CCCC - kAnMath | kAnBranch | kAnInt, - - // 37 IF_LE vA, vB, +CCCC - kAnMath | kAnBranch | kAnInt, - - // 38 IF_EQZ vAA, +BBBB - kAnMath | kAnBranch | kAnInt, - - // 39 IF_NEZ vAA, +BBBB - kAnMath | kAnBranch | kAnInt, - - // 3A IF_LTZ vAA, +BBBB - kAnMath | kAnBranch | kAnInt, - - // 3B IF_GEZ vAA, +BBBB - kAnMath | kAnBranch | kAnInt, - - // 3C IF_GTZ vAA, +BBBB - kAnMath | kAnBranch | kAnInt, - - // 3D IF_LEZ vAA, +BBBB - kAnMath | kAnBranch | kAnInt, - - // 3E UNUSED_3E - kAnNone, - - // 3F UNUSED_3F - kAnNone, - - // 40 UNUSED_40 - kAnNone, - - // 41 UNUSED_41 - kAnNone, - - // 42 UNUSED_42 - kAnNone, - - // 43 UNUSED_43 - kAnNone, - - // 44 AGET vAA, vBB, vCC - kAnArrayOp, - - // 45 AGET_WIDE vAA, vBB, vCC - kAnArrayOp, - - // 46 AGET_OBJECT vAA, vBB, vCC - kAnArrayOp, - - // 47 AGET_BOOLEAN vAA, vBB, vCC - kAnArrayOp, - - // 48 AGET_BYTE vAA, vBB, vCC - kAnArrayOp, - - // 49 AGET_CHAR vAA, vBB, vCC - kAnArrayOp, - - // 4A AGET_SHORT vAA, vBB, vCC - kAnArrayOp, - - // 4B APUT vAA, vBB, vCC - kAnArrayOp, - - // 4C APUT_WIDE vAA, vBB, vCC - kAnArrayOp, - - // 4D APUT_OBJECT vAA, vBB, vCC - kAnArrayOp, - - // 4E APUT_BOOLEAN vAA, vBB, vCC - kAnArrayOp, - - // 4F APUT_BYTE vAA, vBB, vCC - kAnArrayOp, - - // 50 APUT_CHAR vAA, vBB, vCC - kAnArrayOp, - - // 51 APUT_SHORT vAA, vBB, vCC - kAnArrayOp, - - // 52 IGET vA, vB, field@CCCC - kAnNone, - - // 53 IGET_WIDE vA, vB, field@CCCC - kAnNone, - - // 54 IGET_OBJECT vA, vB, field@CCCC - kAnNone, - - // 55 IGET_BOOLEAN vA, vB, field@CCCC - kAnNone, - - // 56 IGET_BYTE vA, vB, field@CCCC - kAnNone, - - // 57 IGET_CHAR vA, vB, field@CCCC - kAnNone, - - // 58 IGET_SHORT vA, vB, field@CCCC - kAnNone, - - // 59 IPUT vA, vB, field@CCCC - kAnNone, - - // 5A IPUT_WIDE vA, vB, field@CCCC - kAnNone, - - // 5B IPUT_OBJECT vA, vB, field@CCCC - kAnNone, - - // 5C IPUT_BOOLEAN vA, vB, field@CCCC - kAnNone, - - // 5D IPUT_BYTE vA, vB, field@CCCC - kAnNone, - - // 5E IPUT_CHAR vA, vB, field@CCCC - kAnNone, - - // 5F IPUT_SHORT vA, vB, field@CCCC - kAnNone, - - // 60 SGET vAA, field@BBBB - kAnNone, - - // 61 SGET_WIDE vAA, field@BBBB - kAnNone, - - // 62 SGET_OBJECT vAA, field@BBBB - kAnNone, - - // 63 SGET_BOOLEAN vAA, field@BBBB - kAnNone, - - // 64 SGET_BYTE vAA, field@BBBB - kAnNone, - - // 65 SGET_CHAR vAA, field@BBBB - kAnNone, - - // 66 SGET_SHORT vAA, field@BBBB - kAnNone, - - // 67 SPUT vAA, field@BBBB - kAnNone, - - // 68 SPUT_WIDE vAA, field@BBBB - kAnNone, - - // 69 SPUT_OBJECT vAA, field@BBBB - kAnNone, - - // 6A SPUT_BOOLEAN vAA, field@BBBB - kAnNone, - - // 6B SPUT_BYTE vAA, field@BBBB - kAnNone, - - // 6C SPUT_CHAR vAA, field@BBBB - kAnNone, - - // 6D SPUT_SHORT vAA, field@BBBB - kAnNone, - - // 6E INVOKE_VIRTUAL {vD, vE, vF, vG, vA} - kAnInvoke | kAnHeavyWeight, - - // 6F INVOKE_SUPER {vD, vE, vF, vG, vA} - kAnInvoke | kAnHeavyWeight, - - // 70 INVOKE_DIRECT {vD, vE, vF, vG, vA} - kAnInvoke | kAnHeavyWeight, - - // 71 INVOKE_STATIC {vD, vE, vF, vG, vA} - kAnInvoke | kAnHeavyWeight, - - // 72 INVOKE_INTERFACE {vD, vE, vF, vG, vA} - kAnInvoke | kAnHeavyWeight, - - // 73 RETURN_VOID_NO_BARRIER - kAnBranch, - - // 74 INVOKE_VIRTUAL_RANGE {vCCCC .. vNNNN} - kAnInvoke | kAnHeavyWeight, - - // 75 INVOKE_SUPER_RANGE {vCCCC .. vNNNN} - kAnInvoke | kAnHeavyWeight, - - // 76 INVOKE_DIRECT_RANGE {vCCCC .. vNNNN} - kAnInvoke | kAnHeavyWeight, - - // 77 INVOKE_STATIC_RANGE {vCCCC .. vNNNN} - kAnInvoke | kAnHeavyWeight, - - // 78 INVOKE_INTERFACE_RANGE {vCCCC .. vNNNN} - kAnInvoke | kAnHeavyWeight, - - // 79 UNUSED_79 - kAnNone, - - // 7A UNUSED_7A - kAnNone, - - // 7B NEG_INT vA, vB - kAnMath | kAnInt, - - // 7C NOT_INT vA, vB - kAnMath | kAnInt, - - // 7D NEG_LONG vA, vB - kAnMath | kAnLong, - - // 7E NOT_LONG vA, vB - kAnMath | kAnLong, - - // 7F NEG_FLOAT vA, vB - kAnMath | kAnFp | kAnSingle, - - // 80 NEG_DOUBLE vA, vB - kAnMath | kAnFp | kAnDouble, - - // 81 INT_TO_LONG vA, vB - kAnMath | kAnInt | kAnLong, - - // 82 INT_TO_FLOAT vA, vB - kAnMath | kAnFp | kAnInt | kAnSingle, - - // 83 INT_TO_DOUBLE vA, vB - kAnMath | kAnFp | kAnInt | kAnDouble, - - // 84 LONG_TO_INT vA, vB - kAnMath | kAnInt | kAnLong, - - // 85 LONG_TO_FLOAT vA, vB - kAnMath | kAnFp | kAnLong | kAnSingle, - - // 86 LONG_TO_DOUBLE vA, vB - kAnMath | kAnFp | kAnLong | kAnDouble, - - // 87 FLOAT_TO_INT vA, vB - kAnMath | kAnFp | kAnInt | kAnSingle, - - // 88 FLOAT_TO_LONG vA, vB - kAnMath | kAnFp | kAnLong | kAnSingle, - - // 89 FLOAT_TO_DOUBLE vA, vB - kAnMath | kAnFp | kAnSingle | kAnDouble, - - // 8A DOUBLE_TO_INT vA, vB - kAnMath | kAnFp | kAnInt | kAnDouble, - - // 8B DOUBLE_TO_LONG vA, vB - kAnMath | kAnFp | kAnLong | kAnDouble, - - // 8C DOUBLE_TO_FLOAT vA, vB - kAnMath | kAnFp | kAnSingle | kAnDouble, - - // 8D INT_TO_BYTE vA, vB - kAnMath | kAnInt, - - // 8E INT_TO_CHAR vA, vB - kAnMath | kAnInt, - - // 8F INT_TO_SHORT vA, vB - kAnMath | kAnInt, - - // 90 ADD_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 91 SUB_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 92 MUL_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 93 DIV_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 94 REM_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 95 AND_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 96 OR_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 97 XOR_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 98 SHL_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 99 SHR_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 9A USHR_INT vAA, vBB, vCC - kAnMath | kAnInt, - - // 9B ADD_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // 9C SUB_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // 9D MUL_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // 9E DIV_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // 9F REM_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A0 AND_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A1 OR_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A2 XOR_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A3 SHL_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A4 SHR_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A5 USHR_LONG vAA, vBB, vCC - kAnMath | kAnLong, - - // A6 ADD_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // A7 SUB_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // A8 MUL_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // A9 DIV_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // AA REM_FLOAT vAA, vBB, vCC - kAnMath | kAnFp | kAnSingle, - - // AB ADD_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // AC SUB_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // AD MUL_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // AE DIV_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // AF REM_DOUBLE vAA, vBB, vCC - kAnMath | kAnFp | kAnDouble, - - // B0 ADD_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B1 SUB_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B2 MUL_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B3 DIV_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B4 REM_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B5 AND_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B6 OR_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B7 XOR_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B8 SHL_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // B9 SHR_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // BA USHR_INT_2ADDR vA, vB - kAnMath | kAnInt, - - // BB ADD_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // BC SUB_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // BD MUL_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // BE DIV_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // BF REM_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C0 AND_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C1 OR_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C2 XOR_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C3 SHL_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C4 SHR_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C5 USHR_LONG_2ADDR vA, vB - kAnMath | kAnLong, - - // C6 ADD_FLOAT_2ADDR vA, vB - kAnMath | kAnFp | kAnSingle, - - // C7 SUB_FLOAT_2ADDR vA, vB - kAnMath | kAnFp | kAnSingle, - - // C8 MUL_FLOAT_2ADDR vA, vB - kAnMath | kAnFp | kAnSingle, - - // C9 DIV_FLOAT_2ADDR vA, vB - kAnMath | kAnFp | kAnSingle, - - // CA REM_FLOAT_2ADDR vA, vB - kAnMath | kAnFp | kAnSingle, - - // CB ADD_DOUBLE_2ADDR vA, vB - kAnMath | kAnFp | kAnDouble, - - // CC SUB_DOUBLE_2ADDR vA, vB - kAnMath | kAnFp | kAnDouble, - - // CD MUL_DOUBLE_2ADDR vA, vB - kAnMath | kAnFp | kAnDouble, - - // CE DIV_DOUBLE_2ADDR vA, vB - kAnMath | kAnFp | kAnDouble, - - // CF REM_DOUBLE_2ADDR vA, vB - kAnMath | kAnFp | kAnDouble, - - // D0 ADD_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D1 RSUB_INT vA, vB, #+CCCC - kAnMath | kAnInt, - - // D2 MUL_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D3 DIV_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D4 REM_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D5 AND_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D6 OR_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D7 XOR_INT_LIT16 vA, vB, #+CCCC - kAnMath | kAnInt, - - // D8 ADD_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // D9 RSUB_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // DA MUL_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // DB DIV_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // DC REM_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // DD AND_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // DE OR_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // DF XOR_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // E0 SHL_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // E1 SHR_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // E2 USHR_INT_LIT8 vAA, vBB, #+CC - kAnMath | kAnInt, - - // E3 IGET_QUICK - kAnNone, - - // E4 IGET_WIDE_QUICK - kAnNone, - - // E5 IGET_OBJECT_QUICK - kAnNone, - - // E6 IPUT_QUICK - kAnNone, - - // E7 IPUT_WIDE_QUICK - kAnNone, - - // E8 IPUT_OBJECT_QUICK - kAnNone, - - // E9 INVOKE_VIRTUAL_QUICK - kAnInvoke | kAnHeavyWeight, - - // EA INVOKE_VIRTUAL_RANGE_QUICK - kAnInvoke | kAnHeavyWeight, - - // EB IPUT_BOOLEAN_QUICK - kAnNone, - - // EC IPUT_BYTE_QUICK - kAnNone, - - // ED IPUT_CHAR_QUICK - kAnNone, - - // EE IPUT_SHORT_QUICK - kAnNone, - - // EF IGET_BOOLEAN_QUICK - kAnNone, - - // F0 IGET_BYTE_QUICK - kAnNone, - - // F1 IGET_CHAR_QUICK - kAnNone, - - // F2 IGET_SHORT_QUICK - kAnNone, - - // F3 UNUSED_F3 - kAnNone, - - // F4 UNUSED_F4 - kAnNone, - - // F5 UNUSED_F5 - kAnNone, - - // F6 UNUSED_F6 - kAnNone, - - // F7 UNUSED_F7 - kAnNone, - - // F8 UNUSED_F8 - kAnNone, - - // F9 UNUSED_F9 - kAnNone, - - // FA UNUSED_FA - kAnNone, - - // FB UNUSED_FB - kAnNone, - - // FC UNUSED_FC - kAnNone, - - // FD UNUSED_FD - kAnNone, - - // FE UNUSED_FE - kAnNone, - - // FF UNUSED_FF - kAnNone, - - // Beginning of extended MIR opcodes - // 100 MIR_PHI - kAnNone, - - // 101 MIR_COPY - kAnNone, - - // 102 MIR_FUSED_CMPL_FLOAT - kAnNone, - - // 103 MIR_FUSED_CMPG_FLOAT - kAnNone, - - // 104 MIR_FUSED_CMPL_DOUBLE - kAnNone, - - // 105 MIR_FUSED_CMPG_DOUBLE - kAnNone, - - // 106 MIR_FUSED_CMP_LONG - kAnNone, - - // 107 MIR_NOP - kAnNone, - - // 108 MIR_NULL_CHECK - kAnNone, - - // 109 MIR_RANGE_CHECK - kAnNone, - - // 10A MIR_DIV_ZERO_CHECK - kAnNone, - - // 10B MIR_CHECK - kAnNone, - - // 10C MIR_CHECKPART2 - kAnNone, - - // 10D MIR_SELECT - kAnNone, - - // 10E MirOpConstVector - kAnNone, - - // 10F MirOpMoveVector - kAnNone, - - // 110 MirOpPackedMultiply - kAnNone, - - // 111 MirOpPackedAddition - kAnNone, - - // 112 MirOpPackedSubtract - kAnNone, - - // 113 MirOpPackedShiftLeft - kAnNone, - - // 114 MirOpPackedSignedShiftRight - kAnNone, - - // 115 MirOpPackedUnsignedShiftRight - kAnNone, - - // 116 MirOpPackedAnd - kAnNone, - - // 117 MirOpPackedOr - kAnNone, - - // 118 MirOpPackedXor - kAnNone, - - // 119 MirOpPackedAddReduce - kAnNone, - - // 11A MirOpPackedReduce - kAnNone, - - // 11B MirOpPackedSet - kAnNone, - - // 11C MirOpReserveVectorRegisters - kAnNone, - - // 11D MirOpReturnVectorRegisters - kAnNone, - - // 11E MirOpMemBarrier - kAnNone, - - // 11F MirOpPackedArrayGet - kAnArrayOp, - - // 120 MirOpPackedArrayPut - kAnArrayOp, -}; - -struct MethodStats { - int dex_instructions; - int math_ops; - int fp_ops; - int array_ops; - int branch_ops; - int heavyweight_ops; - bool has_computational_loop; - bool has_switch; - float math_ratio; - float fp_ratio; - float array_ratio; - float branch_ratio; - float heavyweight_ratio; -}; - -void MIRGraph::AnalyzeBlock(BasicBlock* bb, MethodStats* stats) { - if (bb->visited || (bb->block_type != kDalvikByteCode)) { - return; - } - bool computational_block = true; - bool has_math = false; - /* - * For the purposes of this scan, we want to treat the set of basic blocks broken - * by an exception edge as a single basic block. We'll scan forward along the fallthrough - * edges until we reach an explicit branch or return. - */ - BasicBlock* ending_bb = bb; - if (ending_bb->last_mir_insn != nullptr) { - uint32_t ending_flags = kAnalysisAttributes[ending_bb->last_mir_insn->dalvikInsn.opcode]; - while ((ending_flags & kAnBranch) == 0) { - ending_bb = GetBasicBlock(ending_bb->fall_through); - ending_flags = kAnalysisAttributes[ending_bb->last_mir_insn->dalvikInsn.opcode]; - } - } - /* - * Ideally, we'd weight the operations by loop nesting level, but to do so we'd - * first need to do some expensive loop detection - and the point of this is to make - * an informed guess before investing in computation. However, we can cheaply detect - * many simple loop forms without having to do full dataflow analysis. - */ - int loop_scale_factor = 1; - // Simple for and while loops - if ((ending_bb->taken != NullBasicBlockId) && (ending_bb->fall_through == NullBasicBlockId)) { - if ((GetBasicBlock(ending_bb->taken)->taken == bb->id) || - (GetBasicBlock(ending_bb->taken)->fall_through == bb->id)) { - loop_scale_factor = 25; - } - } - // Simple do-while loop - if ((ending_bb->taken != NullBasicBlockId) && (ending_bb->taken == bb->id)) { - loop_scale_factor = 25; - } - - BasicBlock* tbb = bb; - bool done = false; - while (!done) { - tbb->visited = true; - for (MIR* mir = tbb->first_mir_insn; mir != nullptr; mir = mir->next) { - if (MIR::DecodedInstruction::IsPseudoMirOp(mir->dalvikInsn.opcode)) { - // Skip any MIR pseudo-op. - continue; - } - uint16_t flags = kAnalysisAttributes[mir->dalvikInsn.opcode]; - stats->dex_instructions += loop_scale_factor; - if ((flags & kAnBranch) == 0) { - computational_block &= ((flags & kAnComputational) != 0); - } else { - stats->branch_ops += loop_scale_factor; - } - if ((flags & kAnMath) != 0) { - stats->math_ops += loop_scale_factor; - has_math = true; - } - if ((flags & kAnFp) != 0) { - stats->fp_ops += loop_scale_factor; - } - if ((flags & kAnArrayOp) != 0) { - stats->array_ops += loop_scale_factor; - } - if ((flags & kAnHeavyWeight) != 0) { - stats->heavyweight_ops += loop_scale_factor; - } - if ((flags & kAnSwitch) != 0) { - stats->has_switch = true; - } - } - if (tbb == ending_bb) { - done = true; - } else { - tbb = GetBasicBlock(tbb->fall_through); - } - } - if (has_math && computational_block && (loop_scale_factor > 1)) { - stats->has_computational_loop = true; - } -} - -bool MIRGraph::ComputeSkipCompilation(MethodStats* stats, bool skip_default, - std::string* skip_message) { - float count = stats->dex_instructions; - stats->math_ratio = stats->math_ops / count; - stats->fp_ratio = stats->fp_ops / count; - stats->branch_ratio = stats->branch_ops / count; - stats->array_ratio = stats->array_ops / count; - stats->heavyweight_ratio = stats->heavyweight_ops / count; - - if (cu_->enable_debug & (1 << kDebugShowFilterStats)) { - LOG(INFO) << "STATS " << stats->dex_instructions << ", math:" - << stats->math_ratio << ", fp:" - << stats->fp_ratio << ", br:" - << stats->branch_ratio << ", hw:" - << stats->heavyweight_ratio << ", arr:" - << stats->array_ratio << ", hot:" - << stats->has_computational_loop << ", " - << PrettyMethod(cu_->method_idx, *cu_->dex_file); - } - - // Computation intensive? - if (stats->has_computational_loop && (stats->heavyweight_ratio < 0.04)) { - return false; - } - - // Complex, logic-intensive? - if (cu_->compiler_driver->GetCompilerOptions().IsSmallMethod(GetNumDalvikInsns()) && - stats->branch_ratio > 0.3) { - return false; - } - - // Significant floating point? - if (stats->fp_ratio > 0.05) { - return false; - } - - // Significant generic math? - if (stats->math_ratio > 0.3) { - return false; - } - - // If array-intensive, compiling is probably worthwhile. - if (stats->array_ratio > 0.1) { - return false; - } - - // Switch operations benefit greatly from compilation, so go ahead and spend the cycles. - if (stats->has_switch) { - return false; - } - - // If significant in size and high proportion of expensive operations, skip. - if (cu_->compiler_driver->GetCompilerOptions().IsSmallMethod(GetNumDalvikInsns()) && - (stats->heavyweight_ratio > 0.3)) { - *skip_message = "Is a small method with heavyweight ratio " + - std::to_string(stats->heavyweight_ratio); - return true; - } - - return skip_default; -} - - /* - * Will eventually want this to be a bit more sophisticated and happen at verification time. - */ -bool MIRGraph::SkipCompilation(std::string* skip_message) { - const CompilerOptions& compiler_options = cu_->compiler_driver->GetCompilerOptions(); - CompilerOptions::CompilerFilter compiler_filter = compiler_options.GetCompilerFilter(); - if (compiler_filter == CompilerOptions::kEverything) { - return false; - } - - // Contains a pattern we don't want to compile? - if (PuntToInterpreter()) { - *skip_message = "Punt to interpreter set"; - return true; - } - - DCHECK(compiler_options.IsCompilationEnabled()); - - // Set up compilation cutoffs based on current filter mode. - size_t small_cutoff; - size_t default_cutoff; - switch (compiler_filter) { - case CompilerOptions::kBalanced: - small_cutoff = compiler_options.GetSmallMethodThreshold(); - default_cutoff = compiler_options.GetLargeMethodThreshold(); - break; - case CompilerOptions::kSpace: - small_cutoff = compiler_options.GetTinyMethodThreshold(); - default_cutoff = compiler_options.GetSmallMethodThreshold(); - break; - case CompilerOptions::kSpeed: - case CompilerOptions::kTime: - small_cutoff = compiler_options.GetHugeMethodThreshold(); - default_cutoff = compiler_options.GetHugeMethodThreshold(); - break; - default: - LOG(FATAL) << "Unexpected compiler_filter_: " << compiler_filter; - UNREACHABLE(); - } - - // If size < cutoff, assume we'll compile - but allow removal. - bool skip_compilation = (GetNumDalvikInsns() >= default_cutoff); - if (skip_compilation) { - *skip_message = "#Insns >= default_cutoff: " + std::to_string(GetNumDalvikInsns()); - } - - /* - * Filter 1: Huge methods are likely to be machine generated, but some aren't. - * If huge, assume we won't compile, but allow futher analysis to turn it back on. - */ - if (compiler_options.IsHugeMethod(GetNumDalvikInsns())) { - skip_compilation = true; - *skip_message = "Huge method: " + std::to_string(GetNumDalvikInsns()); - // If we're got a huge number of basic blocks, don't bother with further analysis. - if (static_cast<size_t>(GetNumBlocks()) > (compiler_options.GetHugeMethodThreshold() / 2)) { - return true; - } - } else if (compiler_options.IsLargeMethod(GetNumDalvikInsns()) && - /* If it's large and contains no branches, it's likely to be machine generated initialization */ - (GetBranchCount() == 0)) { - *skip_message = "Large method with no branches"; - return true; - } else if (compiler_filter == CompilerOptions::kSpeed) { - // If not huge, compile. - return false; - } - - // Filter 2: Skip class initializers. - if (((cu_->access_flags & kAccConstructor) != 0) && ((cu_->access_flags & kAccStatic) != 0)) { - *skip_message = "Class initializer"; - return true; - } - - // Filter 3: if this method is a special pattern, go ahead and emit the canned pattern. - if (cu_->compiler_driver->GetMethodInlinerMap() != nullptr && - cu_->compiler_driver->GetMethodInlinerMap()->GetMethodInliner(cu_->dex_file) - ->IsSpecial(cu_->method_idx)) { - return false; - } - - // Filter 4: if small, just compile. - if (GetNumDalvikInsns() < small_cutoff) { - return false; - } - - // Analyze graph for: - // o floating point computation - // o basic blocks contained in loop with heavy arithmetic. - // o proportion of conditional branches. - - MethodStats stats; - memset(&stats, 0, sizeof(stats)); - - ClearAllVisitedFlags(); - AllNodesIterator iter(this); - for (BasicBlock* bb = iter.Next(); bb != nullptr; bb = iter.Next()) { - AnalyzeBlock(bb, &stats); - } - - return ComputeSkipCompilation(&stats, skip_compilation, skip_message); -} - -void MIRGraph::DoCacheFieldLoweringInfo() { - static constexpr uint32_t kFieldIndexFlagQuickened = 0x80000000; - // All IGET/IPUT/SGET/SPUT instructions take 2 code units and there must also be a RETURN. - const uint32_t max_refs = (GetNumDalvikInsns() - 1u) / 2u; - ScopedArenaAllocator allocator(&cu_->arena_stack); - auto* field_idxs = allocator.AllocArray<uint32_t>(max_refs, kArenaAllocMisc); - DexMemAccessType* field_types = allocator.AllocArray<DexMemAccessType>( - max_refs, kArenaAllocMisc); - // Find IGET/IPUT/SGET/SPUT insns, store IGET/IPUT fields at the beginning, SGET/SPUT at the end. - size_t ifield_pos = 0u; - size_t sfield_pos = max_refs; - AllNodesIterator iter(this); - for (BasicBlock* bb = iter.Next(); bb != nullptr; bb = iter.Next()) { - if (bb->block_type != kDalvikByteCode) { - continue; - } - for (MIR* mir = bb->first_mir_insn; mir != nullptr; mir = mir->next) { - // Get field index and try to find it among existing indexes. If found, it's usually among - // the last few added, so we'll start the search from ifield_pos/sfield_pos. Though this - // is a linear search, it actually performs much better than map based approach. - const bool is_iget_or_iput = IsInstructionIGetOrIPut(mir->dalvikInsn.opcode); - const bool is_iget_or_iput_quick = IsInstructionIGetQuickOrIPutQuick(mir->dalvikInsn.opcode); - if (is_iget_or_iput || is_iget_or_iput_quick) { - uint32_t field_idx; - DexMemAccessType access_type; - if (is_iget_or_iput) { - field_idx = mir->dalvikInsn.vC; - access_type = IGetOrIPutMemAccessType(mir->dalvikInsn.opcode); - } else { - DCHECK(is_iget_or_iput_quick); - // Set kFieldIndexFlagQuickened so that we don't deduplicate against non quickened field - // indexes. - field_idx = mir->offset | kFieldIndexFlagQuickened; - access_type = IGetQuickOrIPutQuickMemAccessType(mir->dalvikInsn.opcode); - } - size_t i = ifield_pos; - while (i != 0u && field_idxs[i - 1] != field_idx) { - --i; - } - if (i != 0u) { - mir->meta.ifield_lowering_info = i - 1; - DCHECK_EQ(field_types[i - 1], access_type); - } else { - mir->meta.ifield_lowering_info = ifield_pos; - field_idxs[ifield_pos] = field_idx; - field_types[ifield_pos] = access_type; - ++ifield_pos; - } - } else if (IsInstructionSGetOrSPut(mir->dalvikInsn.opcode)) { - auto field_idx = mir->dalvikInsn.vB; - size_t i = sfield_pos; - while (i != max_refs && field_idxs[i] != field_idx) { - ++i; - } - if (i != max_refs) { - mir->meta.sfield_lowering_info = max_refs - i - 1u; - DCHECK_EQ(field_types[i], SGetOrSPutMemAccessType(mir->dalvikInsn.opcode)); - } else { - mir->meta.sfield_lowering_info = max_refs - sfield_pos; - --sfield_pos; - field_idxs[sfield_pos] = field_idx; - field_types[sfield_pos] = SGetOrSPutMemAccessType(mir->dalvikInsn.opcode); - } - } - DCHECK_LE(ifield_pos, sfield_pos); - } - } - - if (ifield_pos != 0u) { - // Resolve instance field infos. - DCHECK_EQ(ifield_lowering_infos_.size(), 0u); - ifield_lowering_infos_.reserve(ifield_pos); - for (size_t pos = 0u; pos != ifield_pos; ++pos) { - const uint32_t field_idx = field_idxs[pos]; - const bool is_quickened = (field_idx & kFieldIndexFlagQuickened) != 0; - const uint32_t masked_field_idx = field_idx & ~kFieldIndexFlagQuickened; - CHECK_LT(masked_field_idx, 1u << 16); - ifield_lowering_infos_.push_back( - MirIFieldLoweringInfo(masked_field_idx, field_types[pos], is_quickened)); - } - ScopedObjectAccess soa(Thread::Current()); - MirIFieldLoweringInfo::Resolve(soa, - cu_->compiler_driver, - GetCurrentDexCompilationUnit(), - ifield_lowering_infos_.data(), - ifield_pos); - } - - if (sfield_pos != max_refs) { - // Resolve static field infos. - DCHECK_EQ(sfield_lowering_infos_.size(), 0u); - sfield_lowering_infos_.reserve(max_refs - sfield_pos); - for (size_t pos = max_refs; pos != sfield_pos;) { - --pos; - sfield_lowering_infos_.push_back(MirSFieldLoweringInfo(field_idxs[pos], field_types[pos])); - } - MirSFieldLoweringInfo::Resolve(cu_->compiler_driver, GetCurrentDexCompilationUnit(), - sfield_lowering_infos_.data(), max_refs - sfield_pos); - } -} - -void MIRGraph::DoCacheMethodLoweringInfo() { - static constexpr uint16_t invoke_types[] = { kVirtual, kSuper, kDirect, kStatic, kInterface }; - static constexpr uint32_t kMethodIdxFlagQuickened = 0x80000000; - - // Embed the map value in the entry to avoid extra padding in 64-bit builds. - struct MapEntry { - // Map key: target_method_idx, invoke_type, devirt_target. Ordered to avoid padding. - const MethodReference* devirt_target; - uint32_t target_method_idx; - uint32_t vtable_idx; - uint16_t invoke_type; - // Map value. - uint32_t lowering_info_index; - }; - - struct MapEntryComparator { - bool operator()(const MapEntry& lhs, const MapEntry& rhs) const { - if (lhs.target_method_idx != rhs.target_method_idx) { - return lhs.target_method_idx < rhs.target_method_idx; - } - if (lhs.invoke_type != rhs.invoke_type) { - return lhs.invoke_type < rhs.invoke_type; - } - if (lhs.vtable_idx != rhs.vtable_idx) { - return lhs.vtable_idx < rhs.vtable_idx; - } - if (lhs.devirt_target != rhs.devirt_target) { - if (lhs.devirt_target == nullptr) { - return true; - } - if (rhs.devirt_target == nullptr) { - return false; - } - return devirt_cmp(*lhs.devirt_target, *rhs.devirt_target); - } - return false; - } - MethodReferenceComparator devirt_cmp; - }; - - ScopedArenaAllocator allocator(&cu_->arena_stack); - - // All INVOKE instructions take 3 code units and there must also be a RETURN. - const uint32_t max_refs = (GetNumDalvikInsns() - 1u) / 3u; - - // Map invoke key (see MapEntry) to lowering info index and vice versa. - // The invoke_map and sequential entries are essentially equivalent to Boost.MultiIndex's - // multi_index_container with one ordered index and one sequential index. - ScopedArenaSet<MapEntry, MapEntryComparator> invoke_map(MapEntryComparator(), - allocator.Adapter()); - const MapEntry** sequential_entries = - allocator.AllocArray<const MapEntry*>(max_refs, kArenaAllocMisc); - - // Find INVOKE insns and their devirtualization targets. - const VerifiedMethod* verified_method = GetCurrentDexCompilationUnit()->GetVerifiedMethod(); - AllNodesIterator iter(this); - for (BasicBlock* bb = iter.Next(); bb != nullptr; bb = iter.Next()) { - if (bb->block_type != kDalvikByteCode) { - continue; - } - for (MIR* mir = bb->first_mir_insn; mir != nullptr; mir = mir->next) { - const bool is_quick_invoke = IsInstructionQuickInvoke(mir->dalvikInsn.opcode); - const bool is_invoke = IsInstructionInvoke(mir->dalvikInsn.opcode); - if (is_quick_invoke || is_invoke) { - uint32_t vtable_index = 0; - uint32_t target_method_idx = 0; - uint32_t invoke_type_idx = 0; // Default to virtual (in case of quickened). - DCHECK_EQ(invoke_types[invoke_type_idx], kVirtual); - if (is_quick_invoke) { - // We need to store the vtable index since we can't necessarily recreate it at resolve - // phase if the dequickening resolved to an interface method. - vtable_index = mir->dalvikInsn.vB; - // Fake up the method index by storing the mir offset so that we can read the dequicken - // info in resolve. - target_method_idx = mir->offset | kMethodIdxFlagQuickened; - } else { - DCHECK(is_invoke); - // Decode target method index and invoke type. - invoke_type_idx = InvokeInstructionType(mir->dalvikInsn.opcode); - target_method_idx = mir->dalvikInsn.vB; - } - // Find devirtualization target. - // TODO: The devirt map is ordered by the dex pc here. Is there a way to get INVOKEs - // ordered by dex pc as well? That would allow us to keep an iterator to devirt targets - // and increment it as needed instead of making O(log n) lookups. - const MethodReference* devirt_target = verified_method->GetDevirtTarget(mir->offset); - // Try to insert a new entry. If the insertion fails, we will have found an old one. - MapEntry entry = { - devirt_target, - target_method_idx, - vtable_index, - invoke_types[invoke_type_idx], - static_cast<uint32_t>(invoke_map.size()) - }; - auto it = invoke_map.insert(entry).first; // Iterator to either the old or the new entry. - mir->meta.method_lowering_info = it->lowering_info_index; - // If we didn't actually insert, this will just overwrite an existing value with the same. - sequential_entries[it->lowering_info_index] = &*it; - } - } - } - if (invoke_map.empty()) { - return; - } - // Prepare unique method infos, set method info indexes for their MIRs. - const size_t count = invoke_map.size(); - method_lowering_infos_.reserve(count); - for (size_t pos = 0u; pos != count; ++pos) { - const MapEntry* entry = sequential_entries[pos]; - const bool is_quick = (entry->target_method_idx & kMethodIdxFlagQuickened) != 0; - const uint32_t masked_method_idx = entry->target_method_idx & ~kMethodIdxFlagQuickened; - MirMethodLoweringInfo method_info(masked_method_idx, - static_cast<InvokeType>(entry->invoke_type), is_quick); - if (entry->devirt_target != nullptr) { - method_info.SetDevirtualizationTarget(*entry->devirt_target); - } - if (is_quick) { - method_info.SetVTableIndex(entry->vtable_idx); - } - method_lowering_infos_.push_back(method_info); - } - MirMethodLoweringInfo::Resolve(cu_->compiler_driver, GetCurrentDexCompilationUnit(), - method_lowering_infos_.data(), count); -} - -} // namespace art |