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 #include "inline_method_analyser.h"
18 #include "dex_instruction.h"
19 #include "dex_instruction-inl.h"
20 #include "mirror/art_field.h"
21 #include "mirror/art_field-inl.h"
22 #include "mirror/art_method.h"
23 #include "mirror/art_method-inl.h"
24 #include "mirror/class.h"
25 #include "mirror/class-inl.h"
26 #include "mirror/dex_cache.h"
27 #include "mirror/dex_cache-inl.h"
28 #include "verifier/method_verifier.h"
29 #include "verifier/method_verifier-inl.h"
30
31 /*
32 * NOTE: This code is part of the quick compiler. It lives in the runtime
33 * only to allow the debugger to check whether a method has been inlined.
34 */
35
36 namespace art {
37
38 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET),
39 check_iget_type);
40 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_WIDE),
41 check_iget_wide_type);
42 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_OBJECT),
43 check_iget_object_type);
44 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_BOOLEAN),
45 check_iget_boolean_type);
46 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_BYTE),
47 check_iget_byte_type);
48 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_CHAR),
49 check_iget_char_type);
50 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_SHORT),
51 check_iget_short_type);
52
53 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT),
54 check_iput_type);
55 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_WIDE),
56 check_iput_wide_type);
57 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_OBJECT),
58 check_iput_object_type);
59 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_BOOLEAN),
60 check_iput_boolean_type);
61 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_BYTE),
62 check_iput_byte_type);
63 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_CHAR),
64 check_iput_char_type);
65 COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_SHORT),
66 check_iput_short_type);
67
68 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET) ==
69 InlineMethodAnalyser::IPutVariant(Instruction::IPUT), check_iget_iput_variant);
70 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_WIDE) ==
71 InlineMethodAnalyser::IPutVariant(Instruction::IPUT_WIDE), check_iget_iput_wide_variant);
72 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_OBJECT) ==
73 InlineMethodAnalyser::IPutVariant(Instruction::IPUT_OBJECT), check_iget_iput_object_variant);
74 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_BOOLEAN) ==
75 InlineMethodAnalyser::IPutVariant(Instruction::IPUT_BOOLEAN), check_iget_iput_boolean_variant);
76 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_BYTE) ==
77 InlineMethodAnalyser::IPutVariant(Instruction::IPUT_BYTE), check_iget_iput_byte_variant);
78 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_CHAR) ==
79 InlineMethodAnalyser::IPutVariant(Instruction::IPUT_CHAR), check_iget_iput_char_variant);
80 COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_SHORT) ==
81 InlineMethodAnalyser::IPutVariant(Instruction::IPUT_SHORT), check_iget_iput_short_variant);
82
83 // This is used by compiler and debugger. We look into the dex cache for resolved methods and
84 // fields. However, in the context of the debugger, not all methods and fields are resolved. Since
85 // we need to be able to detect possibly inlined method, we pass a null inline method to indicate
86 // we don't want to take unresolved methods and fields into account during analysis.
AnalyseMethodCode(verifier::MethodVerifier * verifier,InlineMethod * method)87 bool InlineMethodAnalyser::AnalyseMethodCode(verifier::MethodVerifier* verifier,
88 InlineMethod* method) {
89 DCHECK(verifier != nullptr);
90 DCHECK_EQ(Runtime::Current()->IsCompiler(), method != nullptr);
91 DCHECK_EQ(verifier->CanLoadClasses(), method != nullptr);
92 // We currently support only plain return or 2-instruction methods.
93
94 const DexFile::CodeItem* code_item = verifier->CodeItem();
95 DCHECK_NE(code_item->insns_size_in_code_units_, 0u);
96 const Instruction* instruction = Instruction::At(code_item->insns_);
97 Instruction::Code opcode = instruction->Opcode();
98
99 switch (opcode) {
100 case Instruction::RETURN_VOID:
101 if (method != nullptr) {
102 method->opcode = kInlineOpNop;
103 method->flags = kInlineSpecial;
104 method->d.data = 0u;
105 }
106 return true;
107 case Instruction::RETURN:
108 case Instruction::RETURN_OBJECT:
109 case Instruction::RETURN_WIDE:
110 return AnalyseReturnMethod(code_item, method);
111 case Instruction::CONST:
112 case Instruction::CONST_4:
113 case Instruction::CONST_16:
114 case Instruction::CONST_HIGH16:
115 // TODO: Support wide constants (RETURN_WIDE).
116 return AnalyseConstMethod(code_item, method);
117 case Instruction::IGET:
118 case Instruction::IGET_OBJECT:
119 case Instruction::IGET_BOOLEAN:
120 case Instruction::IGET_BYTE:
121 case Instruction::IGET_CHAR:
122 case Instruction::IGET_SHORT:
123 case Instruction::IGET_WIDE:
124 return AnalyseIGetMethod(verifier, method);
125 case Instruction::IPUT:
126 case Instruction::IPUT_OBJECT:
127 case Instruction::IPUT_BOOLEAN:
128 case Instruction::IPUT_BYTE:
129 case Instruction::IPUT_CHAR:
130 case Instruction::IPUT_SHORT:
131 case Instruction::IPUT_WIDE:
132 return AnalyseIPutMethod(verifier, method);
133 default:
134 return false;
135 }
136 }
137
IsSyntheticAccessor(MethodReference ref)138 bool InlineMethodAnalyser::IsSyntheticAccessor(MethodReference ref) {
139 const DexFile::MethodId& method_id = ref.dex_file->GetMethodId(ref.dex_method_index);
140 const char* method_name = ref.dex_file->GetMethodName(method_id);
141 return strncmp(method_name, "access$", strlen("access$")) == 0;
142 }
143
AnalyseReturnMethod(const DexFile::CodeItem * code_item,InlineMethod * result)144 bool InlineMethodAnalyser::AnalyseReturnMethod(const DexFile::CodeItem* code_item,
145 InlineMethod* result) {
146 const Instruction* return_instruction = Instruction::At(code_item->insns_);
147 Instruction::Code return_opcode = return_instruction->Opcode();
148 uint32_t reg = return_instruction->VRegA_11x();
149 uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_;
150 DCHECK_GE(reg, arg_start);
151 DCHECK_LT((return_opcode == Instruction::RETURN_WIDE) ? reg + 1 : reg,
152 code_item->registers_size_);
153
154 if (result != nullptr) {
155 result->opcode = kInlineOpReturnArg;
156 result->flags = kInlineSpecial;
157 InlineReturnArgData* data = &result->d.return_data;
158 data->arg = reg - arg_start;
159 data->is_wide = (return_opcode == Instruction::RETURN_WIDE) ? 1u : 0u;
160 data->is_object = (return_opcode == Instruction::RETURN_OBJECT) ? 1u : 0u;
161 data->reserved = 0u;
162 data->reserved2 = 0u;
163 }
164 return true;
165 }
166
AnalyseConstMethod(const DexFile::CodeItem * code_item,InlineMethod * result)167 bool InlineMethodAnalyser::AnalyseConstMethod(const DexFile::CodeItem* code_item,
168 InlineMethod* result) {
169 const Instruction* instruction = Instruction::At(code_item->insns_);
170 const Instruction* return_instruction = instruction->Next();
171 Instruction::Code return_opcode = return_instruction->Opcode();
172 if (return_opcode != Instruction::RETURN &&
173 return_opcode != Instruction::RETURN_OBJECT) {
174 return false;
175 }
176
177 int32_t return_reg = return_instruction->VRegA_11x();
178 DCHECK_LT(return_reg, code_item->registers_size_);
179
180 int32_t const_value = instruction->VRegB();
181 if (instruction->Opcode() == Instruction::CONST_HIGH16) {
182 const_value <<= 16;
183 }
184 DCHECK_LT(instruction->VRegA(), code_item->registers_size_);
185 if (instruction->VRegA() != return_reg) {
186 return false; // Not returning the value set by const?
187 }
188 if (return_opcode == Instruction::RETURN_OBJECT && const_value != 0) {
189 return false; // Returning non-null reference constant?
190 }
191 if (result != nullptr) {
192 result->opcode = kInlineOpNonWideConst;
193 result->flags = kInlineSpecial;
194 result->d.data = static_cast<uint64_t>(const_value);
195 }
196 return true;
197 }
198
AnalyseIGetMethod(verifier::MethodVerifier * verifier,InlineMethod * result)199 bool InlineMethodAnalyser::AnalyseIGetMethod(verifier::MethodVerifier* verifier,
200 InlineMethod* result) {
201 const DexFile::CodeItem* code_item = verifier->CodeItem();
202 const Instruction* instruction = Instruction::At(code_item->insns_);
203 Instruction::Code opcode = instruction->Opcode();
204 DCHECK(IsInstructionIGet(opcode));
205
206 const Instruction* return_instruction = instruction->Next();
207 Instruction::Code return_opcode = return_instruction->Opcode();
208 if (!(return_opcode == Instruction::RETURN_WIDE && opcode == Instruction::IGET_WIDE) &&
209 !(return_opcode == Instruction::RETURN_OBJECT && opcode == Instruction::IGET_OBJECT) &&
210 !(return_opcode == Instruction::RETURN && opcode != Instruction::IGET_WIDE &&
211 opcode != Instruction::IGET_OBJECT)) {
212 return false;
213 }
214
215 uint32_t return_reg = return_instruction->VRegA_11x();
216 DCHECK_LT(return_opcode == Instruction::RETURN_WIDE ? return_reg + 1 : return_reg,
217 code_item->registers_size_);
218
219 uint32_t dst_reg = instruction->VRegA_22c();
220 uint32_t object_reg = instruction->VRegB_22c();
221 uint32_t field_idx = instruction->VRegC_22c();
222 uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_;
223 DCHECK_GE(object_reg, arg_start);
224 DCHECK_LT(object_reg, code_item->registers_size_);
225 uint32_t object_arg = object_reg - arg_start;
226
227 DCHECK_LT(opcode == Instruction::IGET_WIDE ? dst_reg + 1 : dst_reg, code_item->registers_size_);
228 if (dst_reg != return_reg) {
229 return false; // Not returning the value retrieved by IGET?
230 }
231
232 if ((verifier->GetAccessFlags() & kAccStatic) != 0u || object_arg != 0u) {
233 // TODO: Implement inlining of IGET on non-"this" registers (needs correct stack trace for NPE).
234 // Allow synthetic accessors. We don't care about losing their stack frame in NPE.
235 if (!IsSyntheticAccessor(verifier->GetMethodReference())) {
236 return false;
237 }
238 }
239
240 // InlineIGetIPutData::object_arg is only 4 bits wide.
241 static constexpr uint16_t kMaxObjectArg = 15u;
242 if (object_arg > kMaxObjectArg) {
243 return false;
244 }
245
246 if (result != nullptr) {
247 InlineIGetIPutData* data = &result->d.ifield_data;
248 if (!ComputeSpecialAccessorInfo(field_idx, false, verifier, data)) {
249 return false;
250 }
251 result->opcode = kInlineOpIGet;
252 result->flags = kInlineSpecial;
253 data->op_variant = IGetVariant(opcode);
254 data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0u ? 1u : 0u;
255 data->object_arg = object_arg; // Allow IGET on any register, not just "this".
256 data->src_arg = 0u;
257 data->return_arg_plus1 = 0u;
258 }
259 return true;
260 }
261
AnalyseIPutMethod(verifier::MethodVerifier * verifier,InlineMethod * result)262 bool InlineMethodAnalyser::AnalyseIPutMethod(verifier::MethodVerifier* verifier,
263 InlineMethod* result) {
264 const DexFile::CodeItem* code_item = verifier->CodeItem();
265 const Instruction* instruction = Instruction::At(code_item->insns_);
266 Instruction::Code opcode = instruction->Opcode();
267 DCHECK(IsInstructionIPut(opcode));
268
269 const Instruction* return_instruction = instruction->Next();
270 Instruction::Code return_opcode = return_instruction->Opcode();
271 uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_;
272 uint16_t return_arg_plus1 = 0u;
273 if (return_opcode != Instruction::RETURN_VOID) {
274 if (return_opcode != Instruction::RETURN &&
275 return_opcode != Instruction::RETURN_OBJECT &&
276 return_opcode != Instruction::RETURN_WIDE) {
277 return false;
278 }
279 // Returning an argument.
280 uint32_t return_reg = return_instruction->VRegA_11x();
281 DCHECK_GE(return_reg, arg_start);
282 DCHECK_LT(return_opcode == Instruction::RETURN_WIDE ? return_reg + 1u : return_reg,
283 code_item->registers_size_);
284 return_arg_plus1 = return_reg - arg_start + 1u;
285 }
286
287 uint32_t src_reg = instruction->VRegA_22c();
288 uint32_t object_reg = instruction->VRegB_22c();
289 uint32_t field_idx = instruction->VRegC_22c();
290 DCHECK_GE(object_reg, arg_start);
291 DCHECK_LT(object_reg, code_item->registers_size_);
292 DCHECK_GE(src_reg, arg_start);
293 DCHECK_LT(opcode == Instruction::IPUT_WIDE ? src_reg + 1 : src_reg, code_item->registers_size_);
294 uint32_t object_arg = object_reg - arg_start;
295 uint32_t src_arg = src_reg - arg_start;
296
297 if ((verifier->GetAccessFlags() & kAccStatic) != 0u || object_arg != 0u) {
298 // TODO: Implement inlining of IPUT on non-"this" registers (needs correct stack trace for NPE).
299 // Allow synthetic accessors. We don't care about losing their stack frame in NPE.
300 if (!IsSyntheticAccessor(verifier->GetMethodReference())) {
301 return false;
302 }
303 }
304
305 // InlineIGetIPutData::object_arg/src_arg/return_arg_plus1 are each only 4 bits wide.
306 static constexpr uint16_t kMaxObjectArg = 15u;
307 static constexpr uint16_t kMaxSrcArg = 15u;
308 static constexpr uint16_t kMaxReturnArgPlus1 = 15u;
309 if (object_arg > kMaxObjectArg || src_arg > kMaxSrcArg || return_arg_plus1 > kMaxReturnArgPlus1) {
310 return false;
311 }
312
313 if (result != nullptr) {
314 InlineIGetIPutData* data = &result->d.ifield_data;
315 if (!ComputeSpecialAccessorInfo(field_idx, true, verifier, data)) {
316 return false;
317 }
318 result->opcode = kInlineOpIPut;
319 result->flags = kInlineSpecial;
320 data->op_variant = IPutVariant(opcode);
321 data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0u ? 1u : 0u;
322 data->object_arg = object_arg; // Allow IPUT on any register, not just "this".
323 data->src_arg = src_arg;
324 data->return_arg_plus1 = return_arg_plus1;
325 }
326 return true;
327 }
328
ComputeSpecialAccessorInfo(uint32_t field_idx,bool is_put,verifier::MethodVerifier * verifier,InlineIGetIPutData * result)329 bool InlineMethodAnalyser::ComputeSpecialAccessorInfo(uint32_t field_idx, bool is_put,
330 verifier::MethodVerifier* verifier,
331 InlineIGetIPutData* result) {
332 mirror::DexCache* dex_cache = verifier->GetDexCache();
333 uint32_t method_idx = verifier->GetMethodReference().dex_method_index;
334 mirror::ArtMethod* method = dex_cache->GetResolvedMethod(method_idx);
335 mirror::ArtField* field = dex_cache->GetResolvedField(field_idx);
336 if (method == nullptr || field == nullptr || field->IsStatic()) {
337 return false;
338 }
339 mirror::Class* method_class = method->GetDeclaringClass();
340 mirror::Class* field_class = field->GetDeclaringClass();
341 if (!method_class->CanAccessResolvedField(field_class, field, dex_cache, field_idx) ||
342 (is_put && field->IsFinal() && method_class != field_class)) {
343 return false;
344 }
345 DCHECK_GE(field->GetOffset().Int32Value(), 0);
346 result->field_idx = field_idx;
347 result->field_offset = field->GetOffset().Int32Value();
348 result->is_volatile = field->IsVolatile();
349 return true;
350 }
351
352 } // namespace art
353