1 /*
2  * Copyright (C) 2012 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_RUNTIME_INTERPRETER_INTERPRETER_COMMON_H_
18 #define ART_RUNTIME_INTERPRETER_INTERPRETER_COMMON_H_
19 
20 #include "interpreter.h"
21 
22 #include <math.h>
23 
24 #include "base/logging.h"
25 #include "class_linker-inl.h"
26 #include "common_throws.h"
27 #include "dex_file-inl.h"
28 #include "dex_instruction-inl.h"
29 #include "dex_instruction.h"
30 #include "entrypoints/entrypoint_utils-inl.h"
31 #include "gc/accounting/card_table-inl.h"
32 #include "handle_scope-inl.h"
33 #include "method_helper-inl.h"
34 #include "nth_caller_visitor.h"
35 #include "mirror/art_field-inl.h"
36 #include "mirror/art_method.h"
37 #include "mirror/art_method-inl.h"
38 #include "mirror/class.h"
39 #include "mirror/class-inl.h"
40 #include "mirror/object-inl.h"
41 #include "mirror/object_array-inl.h"
42 #include "mirror/string-inl.h"
43 #include "ScopedLocalRef.h"
44 #include "scoped_thread_state_change.h"
45 #include "thread.h"
46 #include "well_known_classes.h"
47 
48 using ::art::mirror::ArtField;
49 using ::art::mirror::ArtMethod;
50 using ::art::mirror::Array;
51 using ::art::mirror::BooleanArray;
52 using ::art::mirror::ByteArray;
53 using ::art::mirror::CharArray;
54 using ::art::mirror::Class;
55 using ::art::mirror::ClassLoader;
56 using ::art::mirror::IntArray;
57 using ::art::mirror::LongArray;
58 using ::art::mirror::Object;
59 using ::art::mirror::ObjectArray;
60 using ::art::mirror::ShortArray;
61 using ::art::mirror::String;
62 using ::art::mirror::Throwable;
63 
64 namespace art {
65 namespace interpreter {
66 
67 // External references to both interpreter implementations.
68 
69 template<bool do_access_check, bool transaction_active>
70 extern JValue ExecuteSwitchImpl(Thread* self, MethodHelper& mh,
71                                 const DexFile::CodeItem* code_item,
72                                 ShadowFrame& shadow_frame, JValue result_register);
73 
74 template<bool do_access_check, bool transaction_active>
75 extern JValue ExecuteGotoImpl(Thread* self, MethodHelper& mh,
76                               const DexFile::CodeItem* code_item,
77                               ShadowFrame& shadow_frame, JValue result_register);
78 
79 void ThrowNullPointerExceptionFromInterpreter(const ShadowFrame& shadow_frame)
80     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
81 
DoMonitorEnter(Thread * self,Object * ref)82 static inline void DoMonitorEnter(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
83   ref->MonitorEnter(self);
84 }
85 
DoMonitorExit(Thread * self,Object * ref)86 static inline void DoMonitorExit(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
87   ref->MonitorExit(self);
88 }
89 
90 void AbortTransaction(Thread* self, const char* fmt, ...)
91     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
92 
93 void RecordArrayElementsInTransaction(mirror::Array* array, int32_t count)
94     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
95 
96 // Invokes the given method. This is part of the invocation support and is used by DoInvoke and
97 // DoInvokeVirtualQuick functions.
98 // Returns true on success, otherwise throws an exception and returns false.
99 template<bool is_range, bool do_assignability_check>
100 bool DoCall(ArtMethod* method, Thread* self, ShadowFrame& shadow_frame,
101             const Instruction* inst, uint16_t inst_data, JValue* result);
102 
103 // Handles invoke-XXX/range instructions.
104 // Returns true on success, otherwise throws an exception and returns false.
105 template<InvokeType type, bool is_range, bool do_access_check>
DoInvoke(Thread * self,ShadowFrame & shadow_frame,const Instruction * inst,uint16_t inst_data,JValue * result)106 static inline bool DoInvoke(Thread* self, ShadowFrame& shadow_frame, const Instruction* inst,
107                             uint16_t inst_data, JValue* result) {
108   const uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
109   const uint32_t vregC = (is_range) ? inst->VRegC_3rc() : inst->VRegC_35c();
110   Object* receiver = (type == kStatic) ? nullptr : shadow_frame.GetVRegReference(vregC);
111   mirror::ArtMethod* sf_method = shadow_frame.GetMethod();
112   ArtMethod* const method = FindMethodFromCode<type, do_access_check>(
113       method_idx, &receiver, &sf_method, self);
114   // The shadow frame should already be pushed, so we don't need to update it.
115   if (UNLIKELY(method == nullptr)) {
116     CHECK(self->IsExceptionPending());
117     result->SetJ(0);
118     return false;
119   } else if (UNLIKELY(method->IsAbstract())) {
120     ThrowAbstractMethodError(method);
121     result->SetJ(0);
122     return false;
123   } else {
124     return DoCall<is_range, do_access_check>(method, self, shadow_frame, inst, inst_data, result);
125   }
126 }
127 
128 // Handles invoke-virtual-quick and invoke-virtual-quick-range instructions.
129 // Returns true on success, otherwise throws an exception and returns false.
130 template<bool is_range>
DoInvokeVirtualQuick(Thread * self,ShadowFrame & shadow_frame,const Instruction * inst,uint16_t inst_data,JValue * result)131 static inline bool DoInvokeVirtualQuick(Thread* self, ShadowFrame& shadow_frame,
132                                         const Instruction* inst, uint16_t inst_data,
133                                         JValue* result) {
134   const uint32_t vregC = (is_range) ? inst->VRegC_3rc() : inst->VRegC_35c();
135   Object* const receiver = shadow_frame.GetVRegReference(vregC);
136   if (UNLIKELY(receiver == nullptr)) {
137     // We lost the reference to the method index so we cannot get a more
138     // precised exception message.
139     ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
140     return false;
141   }
142   const uint32_t vtable_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
143   CHECK(receiver->GetClass()->ShouldHaveEmbeddedImtAndVTable());
144   ArtMethod* const method = receiver->GetClass()->GetEmbeddedVTableEntry(vtable_idx);
145   if (UNLIKELY(method == nullptr)) {
146     CHECK(self->IsExceptionPending());
147     result->SetJ(0);
148     return false;
149   } else if (UNLIKELY(method->IsAbstract())) {
150     ThrowAbstractMethodError(method);
151     result->SetJ(0);
152     return false;
153   } else {
154     // No need to check since we've been quickened.
155     return DoCall<is_range, false>(method, self, shadow_frame, inst, inst_data, result);
156   }
157 }
158 
159 // Handles iget-XXX and sget-XXX instructions.
160 // Returns true on success, otherwise throws an exception and returns false.
161 template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check>
162 bool DoFieldGet(Thread* self, ShadowFrame& shadow_frame, const Instruction* inst,
163                 uint16_t inst_data) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
164 
165 // Handles iget-quick, iget-wide-quick and iget-object-quick instructions.
166 // Returns true on success, otherwise throws an exception and returns false.
167 template<Primitive::Type field_type>
168 bool DoIGetQuick(ShadowFrame& shadow_frame, const Instruction* inst, uint16_t inst_data)
169     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
170 
171 // Handles iput-XXX and sput-XXX instructions.
172 // Returns true on success, otherwise throws an exception and returns false.
173 template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check,
174          bool transaction_active>
175 bool DoFieldPut(Thread* self, const ShadowFrame& shadow_frame, const Instruction* inst,
176                 uint16_t inst_data) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
177 
178 // Handles iput-quick, iput-wide-quick and iput-object-quick instructions.
179 // Returns true on success, otherwise throws an exception and returns false.
180 template<Primitive::Type field_type, bool transaction_active>
181 bool DoIPutQuick(const ShadowFrame& shadow_frame, const Instruction* inst, uint16_t inst_data)
182     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
183 
184 
185 // Handles string resolution for const-string and const-string-jumbo instructions. Also ensures the
186 // java.lang.String class is initialized.
ResolveString(Thread * self,MethodHelper & mh,uint32_t string_idx)187 static inline String* ResolveString(Thread* self, MethodHelper& mh, uint32_t string_idx)
188     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
189   CHECK(!kMovingMethods);
190   Class* java_lang_string_class = String::GetJavaLangString();
191   if (UNLIKELY(!java_lang_string_class->IsInitialized())) {
192     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
193     StackHandleScope<1> hs(self);
194     Handle<mirror::Class> h_class(hs.NewHandle(java_lang_string_class));
195     if (UNLIKELY(!class_linker->EnsureInitialized(h_class, true, true))) {
196       DCHECK(self->IsExceptionPending());
197       return nullptr;
198     }
199   }
200   return mh.ResolveString(string_idx);
201 }
202 
203 // Handles div-int, div-int/2addr, div-int/li16 and div-int/lit8 instructions.
204 // Returns true on success, otherwise throws a java.lang.ArithmeticException and return false.
DoIntDivide(ShadowFrame & shadow_frame,size_t result_reg,int32_t dividend,int32_t divisor)205 static inline bool DoIntDivide(ShadowFrame& shadow_frame, size_t result_reg,
206                                int32_t dividend, int32_t divisor)
207     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
208   const int32_t kMinInt = std::numeric_limits<int32_t>::min();
209   if (UNLIKELY(divisor == 0)) {
210     ThrowArithmeticExceptionDivideByZero();
211     return false;
212   }
213   if (UNLIKELY(dividend == kMinInt && divisor == -1)) {
214     shadow_frame.SetVReg(result_reg, kMinInt);
215   } else {
216     shadow_frame.SetVReg(result_reg, dividend / divisor);
217   }
218   return true;
219 }
220 
221 // Handles rem-int, rem-int/2addr, rem-int/li16 and rem-int/lit8 instructions.
222 // Returns true on success, otherwise throws a java.lang.ArithmeticException and return false.
DoIntRemainder(ShadowFrame & shadow_frame,size_t result_reg,int32_t dividend,int32_t divisor)223 static inline bool DoIntRemainder(ShadowFrame& shadow_frame, size_t result_reg,
224                                   int32_t dividend, int32_t divisor)
225     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
226   const int32_t kMinInt = std::numeric_limits<int32_t>::min();
227   if (UNLIKELY(divisor == 0)) {
228     ThrowArithmeticExceptionDivideByZero();
229     return false;
230   }
231   if (UNLIKELY(dividend == kMinInt && divisor == -1)) {
232     shadow_frame.SetVReg(result_reg, 0);
233   } else {
234     shadow_frame.SetVReg(result_reg, dividend % divisor);
235   }
236   return true;
237 }
238 
239 // Handles div-long and div-long-2addr instructions.
240 // Returns true on success, otherwise throws a java.lang.ArithmeticException and return false.
DoLongDivide(ShadowFrame & shadow_frame,size_t result_reg,int64_t dividend,int64_t divisor)241 static inline bool DoLongDivide(ShadowFrame& shadow_frame, size_t result_reg,
242                                 int64_t dividend, int64_t divisor)
243     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
244   const int64_t kMinLong = std::numeric_limits<int64_t>::min();
245   if (UNLIKELY(divisor == 0)) {
246     ThrowArithmeticExceptionDivideByZero();
247     return false;
248   }
249   if (UNLIKELY(dividend == kMinLong && divisor == -1)) {
250     shadow_frame.SetVRegLong(result_reg, kMinLong);
251   } else {
252     shadow_frame.SetVRegLong(result_reg, dividend / divisor);
253   }
254   return true;
255 }
256 
257 // Handles rem-long and rem-long-2addr instructions.
258 // Returns true on success, otherwise throws a java.lang.ArithmeticException and return false.
DoLongRemainder(ShadowFrame & shadow_frame,size_t result_reg,int64_t dividend,int64_t divisor)259 static inline bool DoLongRemainder(ShadowFrame& shadow_frame, size_t result_reg,
260                                    int64_t dividend, int64_t divisor)
261     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
262   const int64_t kMinLong = std::numeric_limits<int64_t>::min();
263   if (UNLIKELY(divisor == 0)) {
264     ThrowArithmeticExceptionDivideByZero();
265     return false;
266   }
267   if (UNLIKELY(dividend == kMinLong && divisor == -1)) {
268     shadow_frame.SetVRegLong(result_reg, 0);
269   } else {
270     shadow_frame.SetVRegLong(result_reg, dividend % divisor);
271   }
272   return true;
273 }
274 
275 // Handles filled-new-array and filled-new-array-range instructions.
276 // Returns true on success, otherwise throws an exception and returns false.
277 template <bool is_range, bool do_access_check, bool transaction_active>
278 bool DoFilledNewArray(const Instruction* inst, const ShadowFrame& shadow_frame,
279                       Thread* self, JValue* result);
280 
281 // Handles packed-switch instruction.
282 // Returns the branch offset to the next instruction to execute.
DoPackedSwitch(const Instruction * inst,const ShadowFrame & shadow_frame,uint16_t inst_data)283 static inline int32_t DoPackedSwitch(const Instruction* inst, const ShadowFrame& shadow_frame,
284                                      uint16_t inst_data)
285     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
286   DCHECK(inst->Opcode() == Instruction::PACKED_SWITCH);
287   const uint16_t* switch_data = reinterpret_cast<const uint16_t*>(inst) + inst->VRegB_31t();
288   int32_t test_val = shadow_frame.GetVReg(inst->VRegA_31t(inst_data));
289   DCHECK_EQ(switch_data[0], static_cast<uint16_t>(Instruction::kPackedSwitchSignature));
290   uint16_t size = switch_data[1];
291   DCHECK_GT(size, 0);
292   const int32_t* keys = reinterpret_cast<const int32_t*>(&switch_data[2]);
293   DCHECK(IsAligned<4>(keys));
294   int32_t first_key = keys[0];
295   const int32_t* targets = reinterpret_cast<const int32_t*>(&switch_data[4]);
296   DCHECK(IsAligned<4>(targets));
297   int32_t index = test_val - first_key;
298   if (index >= 0 && index < size) {
299     return targets[index];
300   } else {
301     // No corresponding value: move forward by 3 (size of PACKED_SWITCH).
302     return 3;
303   }
304 }
305 
306 // Handles sparse-switch instruction.
307 // Returns the branch offset to the next instruction to execute.
DoSparseSwitch(const Instruction * inst,const ShadowFrame & shadow_frame,uint16_t inst_data)308 static inline int32_t DoSparseSwitch(const Instruction* inst, const ShadowFrame& shadow_frame,
309                                      uint16_t inst_data)
310     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
311   DCHECK(inst->Opcode() == Instruction::SPARSE_SWITCH);
312   const uint16_t* switch_data = reinterpret_cast<const uint16_t*>(inst) + inst->VRegB_31t();
313   int32_t test_val = shadow_frame.GetVReg(inst->VRegA_31t(inst_data));
314   DCHECK_EQ(switch_data[0], static_cast<uint16_t>(Instruction::kSparseSwitchSignature));
315   uint16_t size = switch_data[1];
316   DCHECK_GT(size, 0);
317   const int32_t* keys = reinterpret_cast<const int32_t*>(&switch_data[2]);
318   DCHECK(IsAligned<4>(keys));
319   const int32_t* entries = keys + size;
320   DCHECK(IsAligned<4>(entries));
321   int lo = 0;
322   int hi = size - 1;
323   while (lo <= hi) {
324     int mid = (lo + hi) / 2;
325     int32_t foundVal = keys[mid];
326     if (test_val < foundVal) {
327       hi = mid - 1;
328     } else if (test_val > foundVal) {
329       lo = mid + 1;
330     } else {
331       return entries[mid];
332     }
333   }
334   // No corresponding value: move forward by 3 (size of SPARSE_SWITCH).
335   return 3;
336 }
337 
338 uint32_t FindNextInstructionFollowingException(Thread* self, ShadowFrame& shadow_frame,
339     uint32_t dex_pc, const instrumentation::Instrumentation* instrumentation)
340         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
341 
342 void UnexpectedOpcode(const Instruction* inst, MethodHelper& mh)
343   __attribute__((cold, noreturn))
344   SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
345 
TraceExecution(const ShadowFrame & shadow_frame,const Instruction * inst,const uint32_t dex_pc,MethodHelper & mh)346 static inline void TraceExecution(const ShadowFrame& shadow_frame, const Instruction* inst,
347                                   const uint32_t dex_pc, MethodHelper& mh)
348     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
349   constexpr bool kTracing = false;
350   if (kTracing) {
351 #define TRACE_LOG std::cerr
352     std::ostringstream oss;
353     oss << PrettyMethod(shadow_frame.GetMethod())
354         << StringPrintf("\n0x%x: ", dex_pc)
355         << inst->DumpString(mh.GetMethod()->GetDexFile()) << "\n";
356     for (uint32_t i = 0; i < shadow_frame.NumberOfVRegs(); ++i) {
357       uint32_t raw_value = shadow_frame.GetVReg(i);
358       Object* ref_value = shadow_frame.GetVRegReference(i);
359       oss << StringPrintf(" vreg%u=0x%08X", i, raw_value);
360       if (ref_value != NULL) {
361         if (ref_value->GetClass()->IsStringClass() &&
362             ref_value->AsString()->GetCharArray() != NULL) {
363           oss << "/java.lang.String \"" << ref_value->AsString()->ToModifiedUtf8() << "\"";
364         } else {
365           oss << "/" << PrettyTypeOf(ref_value);
366         }
367       }
368     }
369     TRACE_LOG << oss.str() << "\n";
370 #undef TRACE_LOG
371   }
372 }
373 
IsBackwardBranch(int32_t branch_offset)374 static inline bool IsBackwardBranch(int32_t branch_offset) {
375   return branch_offset <= 0;
376 }
377 
378 // Explicitly instantiate all DoInvoke functions.
379 #define EXPLICIT_DO_INVOKE_TEMPLATE_DECL(_type, _is_range, _do_check)                      \
380   template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                                     \
381   bool DoInvoke<_type, _is_range, _do_check>(Thread* self, ShadowFrame& shadow_frame,      \
382                                              const Instruction* inst, uint16_t inst_data,  \
383                                              JValue* result)
384 
385 #define EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(_type)       \
386   EXPLICIT_DO_INVOKE_TEMPLATE_DECL(_type, false, false);  \
387   EXPLICIT_DO_INVOKE_TEMPLATE_DECL(_type, false, true);   \
388   EXPLICIT_DO_INVOKE_TEMPLATE_DECL(_type, true, false);   \
389   EXPLICIT_DO_INVOKE_TEMPLATE_DECL(_type, true, true);
390 
391 EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kStatic);      // invoke-static/range.
392 EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kDirect);      // invoke-direct/range.
393 EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kVirtual);     // invoke-virtual/range.
394 EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kSuper);       // invoke-super/range.
395 EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kInterface);   // invoke-interface/range.
396 #undef EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL
397 #undef EXPLICIT_DO_INVOKE_TEMPLATE_DECL
398 
399 // Explicitly instantiate all DoInvokeVirtualQuick functions.
400 #define EXPLICIT_DO_INVOKE_VIRTUAL_QUICK_TEMPLATE_DECL(_is_range)                    \
401   template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                               \
402   bool DoInvokeVirtualQuick<_is_range>(Thread* self, ShadowFrame& shadow_frame,      \
403                                        const Instruction* inst, uint16_t inst_data,  \
404                                        JValue* result)
405 
406 EXPLICIT_DO_INVOKE_VIRTUAL_QUICK_TEMPLATE_DECL(false);  // invoke-virtual-quick.
407 EXPLICIT_DO_INVOKE_VIRTUAL_QUICK_TEMPLATE_DECL(true);   // invoke-virtual-quick-range.
408 #undef EXPLICIT_INSTANTIATION_DO_INVOKE_VIRTUAL_QUICK
409 
410 
411 }  // namespace interpreter
412 }  // namespace art
413 
414 #endif  // ART_RUNTIME_INTERPRETER_INTERPRETER_COMMON_H_
415