interpreter_common.h revision 0e7f37de5bcebb413712eddd1831f30bd0818664 
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 "nth_caller_visitor.h"
34#include "mirror/art_field-inl.h"
35#include "mirror/art_method.h"
36#include "mirror/art_method-inl.h"
37#include "mirror/class.h"
38#include "mirror/class-inl.h"
39#include "mirror/object-inl.h"
40#include "mirror/object_array-inl.h"
41#include "mirror/string-inl.h"
42#include "object_utils.h"
43#include "ScopedLocalRef.h"
44#include "scoped_thread_state_change.h"
45#include "thread.h"
46#include "well_known_classes.h"
47
48using ::art::mirror::ArtField;
49using ::art::mirror::ArtMethod;
50using ::art::mirror::Array;
51using ::art::mirror::BooleanArray;
52using ::art::mirror::ByteArray;
53using ::art::mirror::CharArray;
54using ::art::mirror::Class;
55using ::art::mirror::ClassLoader;
56using ::art::mirror::IntArray;
57using ::art::mirror::LongArray;
58using ::art::mirror::Object;
59using ::art::mirror::ObjectArray;
60using ::art::mirror::ShortArray;
61using ::art::mirror::String;
62using ::art::mirror::Throwable;
63
64namespace art {
65namespace interpreter {
66
67// External references to both interpreter implementations.
68
69template<bool do_access_check, bool transaction_active>
70extern JValue ExecuteSwitchImpl(Thread* self, MethodHelper& mh,
71                                const DexFile::CodeItem* code_item,
72                                ShadowFrame& shadow_frame, JValue result_register);
73
74template<bool do_access_check, bool transaction_active>
75extern JValue ExecuteGotoImpl(Thread* self, MethodHelper& mh,
76                              const DexFile::CodeItem* code_item,
77                              ShadowFrame& shadow_frame, JValue result_register);
78
79void ThrowNullPointerExceptionFromInterpreter(const ShadowFrame& shadow_frame)
80    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
81
82static inline void DoMonitorEnter(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
83  ref->MonitorEnter(self);
84}
85
86static inline void DoMonitorExit(Thread* self, Object* ref) NO_THREAD_SAFETY_ANALYSIS {
87  ref->MonitorExit(self);
88}
89
90void AbortTransaction(Thread* self, const char* fmt, ...)
91    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
92
93void 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.
99template<bool is_range, bool do_assignability_check>
100bool 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.
105template<InvokeType type, bool is_range, bool do_access_check>
106static 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.
130template<bool is_range>
131static 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.
161template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check>
162bool 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.
167template<Primitive::Type field_type>
168bool 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.
173template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check,
174         bool transaction_active>
175bool 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.
180template<Primitive::Type field_type, bool transaction_active>
181bool 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.
187static 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.
205static 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.
223static 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.
241static 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.
259static 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.
277template <bool is_range, bool do_access_check, bool transaction_active>
278bool 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.
283static 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.
308static 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
338uint32_t FindNextInstructionFollowingException(Thread* self, ShadowFrame& shadow_frame,
339    uint32_t dex_pc, const instrumentation::Instrumentation* instrumentation)
340        SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
341
342void UnexpectedOpcode(const Instruction* inst, MethodHelper& mh)
343  __attribute__((cold, noreturn))
344  SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
345
346static 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
374static 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
391EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kStatic);      // invoke-static/range.
392EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kDirect);      // invoke-direct/range.
393EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kVirtual);     // invoke-virtual/range.
394EXPLICIT_DO_INVOKE_ALL_TEMPLATE_DECL(kSuper);       // invoke-super/range.
395EXPLICIT_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
406EXPLICIT_DO_INVOKE_VIRTUAL_QUICK_TEMPLATE_DECL(false);  // invoke-virtual-quick.
407EXPLICIT_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