1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_ 18 #define ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_ 19 20 #include "base/macros.h" 21 #include "base/mutex.h" 22 #include "dex_file.h" 23 #include "dex_instruction.h" 24 #include "method_reference.h" 25 26 /* 27 * NOTE: This code is part of the quick compiler. It lives in the runtime 28 * only to allow the debugger to check whether a method has been inlined. 29 */ 30 31 namespace art { 32 33 namespace verifier { 34 class MethodVerifier; 35 } // namespace verifier 36 class ArtMethod; 37 38 enum InlineMethodOpcode : uint16_t { 39 kInlineOpNop, 40 kInlineOpReturnArg, 41 kInlineOpNonWideConst, 42 kInlineOpIGet, 43 kInlineOpIPut, 44 kInlineOpConstructor, 45 }; 46 47 struct InlineIGetIPutData { 48 // The op_variant below is DexMemAccessType but the runtime doesn't know that enumeration. 49 uint16_t op_variant : 3; 50 uint16_t method_is_static : 1; 51 uint16_t object_arg : 4; 52 uint16_t src_arg : 4; // iput only 53 uint16_t return_arg_plus1 : 4; // iput only, method argument to return + 1, 0 = return void. 54 uint16_t field_idx; 55 uint32_t is_volatile : 1; 56 uint32_t field_offset : 31; 57 }; 58 static_assert(sizeof(InlineIGetIPutData) == sizeof(uint64_t), "Invalid size of InlineIGetIPutData"); 59 60 struct InlineReturnArgData { 61 uint16_t arg; 62 uint16_t is_wide : 1; 63 uint16_t is_object : 1; 64 uint16_t reserved : 14; 65 uint32_t reserved2; 66 }; 67 static_assert(sizeof(InlineReturnArgData) == sizeof(uint64_t), 68 "Invalid size of InlineReturnArgData"); 69 70 struct InlineConstructorData { 71 // There can be up to 3 IPUTs, unused fields are marked with kNoDexIndex16. 72 uint16_t iput0_field_index; 73 uint16_t iput1_field_index; 74 uint16_t iput2_field_index; 75 uint16_t iput0_arg : 4; 76 uint16_t iput1_arg : 4; 77 uint16_t iput2_arg : 4; 78 uint16_t reserved : 4; 79 }; 80 static_assert(sizeof(InlineConstructorData) == sizeof(uint64_t), 81 "Invalid size of InlineConstructorData"); 82 83 struct InlineMethod { 84 InlineMethodOpcode opcode; 85 union { 86 uint64_t data; 87 InlineIGetIPutData ifield_data; 88 InlineReturnArgData return_data; 89 InlineConstructorData constructor_data; 90 } d; 91 }; 92 93 class InlineMethodAnalyser { 94 public: 95 /** 96 * Analyse method code to determine if the method is a candidate for inlining. 97 * If it is, record the inlining data. 98 * 99 * @return true if the method is a candidate for inlining, false otherwise. 100 */ 101 static bool AnalyseMethodCode(ArtMethod* method, InlineMethod* result) 102 REQUIRES_SHARED(Locks::mutator_lock_); 103 IsInstructionIGet(Instruction::Code opcode)104 static constexpr bool IsInstructionIGet(Instruction::Code opcode) { 105 return Instruction::IGET <= opcode && opcode <= Instruction::IGET_SHORT; 106 } 107 IsInstructionIPut(Instruction::Code opcode)108 static constexpr bool IsInstructionIPut(Instruction::Code opcode) { 109 return Instruction::IPUT <= opcode && opcode <= Instruction::IPUT_SHORT; 110 } 111 IGetVariant(Instruction::Code opcode)112 static constexpr uint16_t IGetVariant(Instruction::Code opcode) { 113 return opcode - Instruction::IGET; 114 } 115 IPutVariant(Instruction::Code opcode)116 static constexpr uint16_t IPutVariant(Instruction::Code opcode) { 117 return opcode - Instruction::IPUT; 118 } 119 120 // Determines whether the method is a synthetic accessor (method name starts with "access$"). 121 static bool IsSyntheticAccessor(MethodReference ref); 122 123 private: 124 static bool AnalyseMethodCode(const DexFile::CodeItem* code_item, 125 const MethodReference& method_ref, 126 bool is_static, 127 ArtMethod* method, 128 InlineMethod* result) 129 REQUIRES_SHARED(Locks::mutator_lock_); 130 static bool AnalyseReturnMethod(const DexFile::CodeItem* code_item, InlineMethod* result); 131 static bool AnalyseConstMethod(const DexFile::CodeItem* code_item, InlineMethod* result); 132 static bool AnalyseIGetMethod(const DexFile::CodeItem* code_item, 133 const MethodReference& method_ref, 134 bool is_static, 135 ArtMethod* method, 136 InlineMethod* result) 137 REQUIRES_SHARED(Locks::mutator_lock_); 138 static bool AnalyseIPutMethod(const DexFile::CodeItem* code_item, 139 const MethodReference& method_ref, 140 bool is_static, 141 ArtMethod* method, 142 InlineMethod* result) 143 REQUIRES_SHARED(Locks::mutator_lock_); 144 145 // Can we fast path instance field access in a verified accessor? 146 // If yes, computes field's offset and volatility and whether the method is static or not. 147 static bool ComputeSpecialAccessorInfo(ArtMethod* method, 148 uint32_t field_idx, 149 bool is_put, 150 InlineIGetIPutData* result) 151 REQUIRES_SHARED(Locks::mutator_lock_); 152 }; 153 154 } // namespace art 155 156 #endif // ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_ 157