blob: 18ce563fc2b0f6aac5bdc65af07e9c7fc52645b6 [file] [log] [blame]
/*
* 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