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/dex_file.h" 23 #include "dex/dex_instruction.h" 24 #include "dex/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 class CodeItemDataAccessor; 34 35 namespace verifier { 36 class MethodVerifier; 37 } // namespace verifier 38 class ArtMethod; 39 40 enum InlineMethodOpcode : uint16_t { 41 kInlineOpNop, 42 kInlineOpReturnArg, 43 kInlineOpNonWideConst, 44 kInlineOpIGet, 45 kInlineOpIPut, 46 kInlineOpConstructor, 47 }; 48 49 struct InlineIGetIPutData { 50 // The op_variant below is DexMemAccessType but the runtime doesn't know that enumeration. 51 uint16_t op_variant : 3; 52 uint16_t method_is_static : 1; 53 uint16_t object_arg : 4; 54 uint16_t src_arg : 4; // iput only 55 uint16_t return_arg_plus1 : 4; // iput only, method argument to return + 1, 0 = return void. 56 uint16_t field_idx; 57 uint32_t is_volatile : 1; 58 uint32_t field_offset : 31; 59 }; 60 static_assert(sizeof(InlineIGetIPutData) == sizeof(uint64_t), "Invalid size of InlineIGetIPutData"); 61 62 struct InlineReturnArgData { 63 uint16_t arg; 64 uint16_t is_wide : 1; 65 uint16_t is_object : 1; 66 uint16_t reserved : 14; 67 uint32_t reserved2; 68 }; 69 static_assert(sizeof(InlineReturnArgData) == sizeof(uint64_t), 70 "Invalid size of InlineReturnArgData"); 71 72 struct InlineConstructorData { 73 // There can be up to 3 IPUTs, unused fields are marked with kNoDexIndex16. 74 uint16_t iput0_field_index; 75 uint16_t iput1_field_index; 76 uint16_t iput2_field_index; 77 uint16_t iput0_arg : 4; 78 uint16_t iput1_arg : 4; 79 uint16_t iput2_arg : 4; 80 uint16_t reserved : 4; 81 }; 82 static_assert(sizeof(InlineConstructorData) == sizeof(uint64_t), 83 "Invalid size of InlineConstructorData"); 84 85 struct InlineMethod { 86 InlineMethodOpcode opcode; 87 union { 88 uint64_t data; 89 InlineIGetIPutData ifield_data; 90 InlineReturnArgData return_data; 91 InlineConstructorData constructor_data; 92 } d; 93 }; 94 95 class InlineMethodAnalyser { 96 public: 97 /** 98 * Analyse method code to determine if the method is a candidate for inlining. 99 * If it is, record the inlining data. 100 * 101 * @return true if the method is a candidate for inlining, false otherwise. 102 */ 103 static bool AnalyseMethodCode(ArtMethod* method, InlineMethod* result) 104 REQUIRES_SHARED(Locks::mutator_lock_); 105 IsInstructionIGet(Instruction::Code opcode)106 static constexpr bool IsInstructionIGet(Instruction::Code opcode) { 107 return Instruction::IGET <= opcode && opcode <= Instruction::IGET_SHORT; 108 } 109 IsInstructionIPut(Instruction::Code opcode)110 static constexpr bool IsInstructionIPut(Instruction::Code opcode) { 111 return Instruction::IPUT <= opcode && opcode <= Instruction::IPUT_SHORT; 112 } 113 IGetVariant(Instruction::Code opcode)114 static constexpr uint16_t IGetVariant(Instruction::Code opcode) { 115 return opcode - Instruction::IGET; 116 } 117 IPutVariant(Instruction::Code opcode)118 static constexpr uint16_t IPutVariant(Instruction::Code opcode) { 119 return opcode - Instruction::IPUT; 120 } 121 122 // Determines whether the method is a synthetic accessor (method name starts with "access$"). 123 static bool IsSyntheticAccessor(MethodReference ref); 124 125 private: 126 static bool AnalyseMethodCode(const CodeItemDataAccessor* code_item, 127 const MethodReference& method_ref, 128 bool is_static, 129 ArtMethod* method, 130 InlineMethod* result) 131 REQUIRES_SHARED(Locks::mutator_lock_); 132 static bool AnalyseReturnMethod(const CodeItemDataAccessor* code_item, InlineMethod* result); 133 static bool AnalyseConstMethod(const CodeItemDataAccessor* code_item, InlineMethod* result); 134 static bool AnalyseIGetMethod(const CodeItemDataAccessor* code_item, 135 const MethodReference& method_ref, 136 bool is_static, 137 ArtMethod* method, 138 InlineMethod* result) 139 REQUIRES_SHARED(Locks::mutator_lock_); 140 static bool AnalyseIPutMethod(const CodeItemDataAccessor* code_item, 141 const MethodReference& method_ref, 142 bool is_static, 143 ArtMethod* method, 144 InlineMethod* result) 145 REQUIRES_SHARED(Locks::mutator_lock_); 146 147 // Can we fast path instance field access in a verified accessor? 148 // If yes, computes field's offset and volatility and whether the method is static or not. 149 static bool ComputeSpecialAccessorInfo(ArtMethod* method, 150 uint32_t field_idx, 151 bool is_put, 152 InlineIGetIPutData* result) 153 REQUIRES_SHARED(Locks::mutator_lock_); 154 }; 155 156 } // namespace art 157 158 #endif // ART_COMPILER_DEX_INLINE_METHOD_ANALYSER_H_ 159