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