interpreter_common.cc revision 7642cfc90fc9c3ebfd8e3b5041915705c93b5cf0 
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#include "interpreter_common.h"
18
19#include <cmath>
20
21#include "mirror/array-inl.h"
22
23namespace art {
24namespace interpreter {
25
26void ThrowNullPointerExceptionFromInterpreter(const ShadowFrame& shadow_frame) {
27  ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
28}
29
30template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check>
31bool DoFieldGet(Thread* self, ShadowFrame& shadow_frame, const Instruction* inst,
32                uint16_t inst_data) {
33  const bool is_static = (find_type == StaticObjectRead) || (find_type == StaticPrimitiveRead);
34  const uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
35  ArtField* f = FindFieldFromCode<find_type, do_access_check>(field_idx, shadow_frame.GetMethod(), self,
36                                                              Primitive::ComponentSize(field_type));
37  if (UNLIKELY(f == nullptr)) {
38    CHECK(self->IsExceptionPending());
39    return false;
40  }
41  Object* obj;
42  if (is_static) {
43    obj = f->GetDeclaringClass();
44  } else {
45    obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
46    if (UNLIKELY(obj == nullptr)) {
47      ThrowNullPointerExceptionForFieldAccess(shadow_frame.GetCurrentLocationForThrow(), f, true);
48      return false;
49    }
50  }
51  f->GetDeclaringClass()->AssertInitializedOrInitializingInThread(self);
52  // Report this field access to instrumentation if needed.
53  instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
54  if (UNLIKELY(instrumentation->HasFieldReadListeners())) {
55    Object* this_object = f->IsStatic() ? nullptr : obj;
56    instrumentation->FieldReadEvent(self, this_object, shadow_frame.GetMethod(),
57                                    shadow_frame.GetDexPC(), f);
58  }
59  uint32_t vregA = is_static ? inst->VRegA_21c(inst_data) : inst->VRegA_22c(inst_data);
60  switch (field_type) {
61    case Primitive::kPrimBoolean:
62      shadow_frame.SetVReg(vregA, f->GetBoolean(obj));
63      break;
64    case Primitive::kPrimByte:
65      shadow_frame.SetVReg(vregA, f->GetByte(obj));
66      break;
67    case Primitive::kPrimChar:
68      shadow_frame.SetVReg(vregA, f->GetChar(obj));
69      break;
70    case Primitive::kPrimShort:
71      shadow_frame.SetVReg(vregA, f->GetShort(obj));
72      break;
73    case Primitive::kPrimInt:
74      shadow_frame.SetVReg(vregA, f->GetInt(obj));
75      break;
76    case Primitive::kPrimLong:
77      shadow_frame.SetVRegLong(vregA, f->GetLong(obj));
78      break;
79    case Primitive::kPrimNot:
80      shadow_frame.SetVRegReference(vregA, f->GetObject(obj));
81      break;
82    default:
83      LOG(FATAL) << "Unreachable: " << field_type;
84      UNREACHABLE();
85  }
86  return true;
87}
88
89// Explicitly instantiate all DoFieldGet functions.
90#define EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL(_find_type, _field_type, _do_check) \
91  template bool DoFieldGet<_find_type, _field_type, _do_check>(Thread* self, \
92                                                               ShadowFrame& shadow_frame, \
93                                                               const Instruction* inst, \
94                                                               uint16_t inst_data)
95
96#define EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(_find_type, _field_type)  \
97    EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL(_find_type, _field_type, false);  \
98    EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL(_find_type, _field_type, true);
99
100// iget-XXX
101EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimBoolean)
102EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimByte)
103EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimChar)
104EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimShort)
105EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimInt)
106EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimLong)
107EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstanceObjectRead, Primitive::kPrimNot)
108
109// sget-XXX
110EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimBoolean)
111EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimByte)
112EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimChar)
113EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimShort)
114EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimInt)
115EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimLong)
116EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticObjectRead, Primitive::kPrimNot)
117
118#undef EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL
119#undef EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL
120
121// Handles iget-quick, iget-wide-quick and iget-object-quick instructions.
122// Returns true on success, otherwise throws an exception and returns false.
123template<Primitive::Type field_type>
124bool DoIGetQuick(ShadowFrame& shadow_frame, const Instruction* inst, uint16_t inst_data) {
125  Object* obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
126  if (UNLIKELY(obj == nullptr)) {
127    // We lost the reference to the field index so we cannot get a more
128    // precised exception message.
129    ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
130    return false;
131  }
132  MemberOffset field_offset(inst->VRegC_22c());
133  // Report this field access to instrumentation if needed. Since we only have the offset of
134  // the field from the base of the object, we need to look for it first.
135  instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
136  if (UNLIKELY(instrumentation->HasFieldReadListeners())) {
137    ArtField* f = ArtField::FindInstanceFieldWithOffset(obj->GetClass(),
138                                                        field_offset.Uint32Value());
139    DCHECK(f != nullptr);
140    DCHECK(!f->IsStatic());
141    instrumentation->FieldReadEvent(Thread::Current(), obj, shadow_frame.GetMethod(),
142                                    shadow_frame.GetDexPC(), f);
143  }
144  // Note: iget-x-quick instructions are only for non-volatile fields.
145  const uint32_t vregA = inst->VRegA_22c(inst_data);
146  switch (field_type) {
147    case Primitive::kPrimInt:
148      shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetField32(field_offset)));
149      break;
150    case Primitive::kPrimBoolean:
151      shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldBoolean(field_offset)));
152      break;
153    case Primitive::kPrimByte:
154      shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldByte(field_offset)));
155      break;
156    case Primitive::kPrimChar:
157      shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldChar(field_offset)));
158      break;
159    case Primitive::kPrimShort:
160      shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldShort(field_offset)));
161      break;
162    case Primitive::kPrimLong:
163      shadow_frame.SetVRegLong(vregA, static_cast<int64_t>(obj->GetField64(field_offset)));
164      break;
165    case Primitive::kPrimNot:
166      shadow_frame.SetVRegReference(vregA, obj->GetFieldObject<mirror::Object>(field_offset));
167      break;
168    default:
169      LOG(FATAL) << "Unreachable: " << field_type;
170      UNREACHABLE();
171  }
172  return true;
173}
174
175// Explicitly instantiate all DoIGetQuick functions.
176#define EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(_field_type) \
177  template bool DoIGetQuick<_field_type>(ShadowFrame& shadow_frame, const Instruction* inst, \
178                                         uint16_t inst_data)
179
180EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimInt);      // iget-quick.
181EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimBoolean);  // iget-boolean-quick.
182EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimByte);     // iget-byte-quick.
183EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimChar);     // iget-char-quick.
184EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimShort);    // iget-short-quick.
185EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimLong);     // iget-wide-quick.
186EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimNot);      // iget-object-quick.
187#undef EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL
188
189template<Primitive::Type field_type>
190static JValue GetFieldValue(const ShadowFrame& shadow_frame, uint32_t vreg)
191    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
192  JValue field_value;
193  switch (field_type) {
194    case Primitive::kPrimBoolean:
195      field_value.SetZ(static_cast<uint8_t>(shadow_frame.GetVReg(vreg)));
196      break;
197    case Primitive::kPrimByte:
198      field_value.SetB(static_cast<int8_t>(shadow_frame.GetVReg(vreg)));
199      break;
200    case Primitive::kPrimChar:
201      field_value.SetC(static_cast<uint16_t>(shadow_frame.GetVReg(vreg)));
202      break;
203    case Primitive::kPrimShort:
204      field_value.SetS(static_cast<int16_t>(shadow_frame.GetVReg(vreg)));
205      break;
206    case Primitive::kPrimInt:
207      field_value.SetI(shadow_frame.GetVReg(vreg));
208      break;
209    case Primitive::kPrimLong:
210      field_value.SetJ(shadow_frame.GetVRegLong(vreg));
211      break;
212    case Primitive::kPrimNot:
213      field_value.SetL(shadow_frame.GetVRegReference(vreg));
214      break;
215    default:
216      LOG(FATAL) << "Unreachable: " << field_type;
217      UNREACHABLE();
218  }
219  return field_value;
220}
221
222template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check,
223         bool transaction_active>
224bool DoFieldPut(Thread* self, const ShadowFrame& shadow_frame, const Instruction* inst,
225                uint16_t inst_data) {
226  bool do_assignability_check = do_access_check;
227  bool is_static = (find_type == StaticObjectWrite) || (find_type == StaticPrimitiveWrite);
228  uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
229  ArtField* f = FindFieldFromCode<find_type, do_access_check>(field_idx, shadow_frame.GetMethod(), self,
230                                                              Primitive::ComponentSize(field_type));
231  if (UNLIKELY(f == nullptr)) {
232    CHECK(self->IsExceptionPending());
233    return false;
234  }
235  Object* obj;
236  if (is_static) {
237    obj = f->GetDeclaringClass();
238  } else {
239    obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
240    if (UNLIKELY(obj == nullptr)) {
241      ThrowNullPointerExceptionForFieldAccess(shadow_frame.GetCurrentLocationForThrow(),
242                                              f, false);
243      return false;
244    }
245  }
246  f->GetDeclaringClass()->AssertInitializedOrInitializingInThread(self);
247  uint32_t vregA = is_static ? inst->VRegA_21c(inst_data) : inst->VRegA_22c(inst_data);
248  // Report this field access to instrumentation if needed. Since we only have the offset of
249  // the field from the base of the object, we need to look for it first.
250  instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
251  if (UNLIKELY(instrumentation->HasFieldWriteListeners())) {
252    JValue field_value = GetFieldValue<field_type>(shadow_frame, vregA);
253    Object* this_object = f->IsStatic() ? nullptr : obj;
254    instrumentation->FieldWriteEvent(self, this_object, shadow_frame.GetMethod(),
255                                     shadow_frame.GetDexPC(), f, field_value);
256  }
257  switch (field_type) {
258    case Primitive::kPrimBoolean:
259      f->SetBoolean<transaction_active>(obj, shadow_frame.GetVReg(vregA));
260      break;
261    case Primitive::kPrimByte:
262      f->SetByte<transaction_active>(obj, shadow_frame.GetVReg(vregA));
263      break;
264    case Primitive::kPrimChar:
265      f->SetChar<transaction_active>(obj, shadow_frame.GetVReg(vregA));
266      break;
267    case Primitive::kPrimShort:
268      f->SetShort<transaction_active>(obj, shadow_frame.GetVReg(vregA));
269      break;
270    case Primitive::kPrimInt:
271      f->SetInt<transaction_active>(obj, shadow_frame.GetVReg(vregA));
272      break;
273    case Primitive::kPrimLong:
274      f->SetLong<transaction_active>(obj, shadow_frame.GetVRegLong(vregA));
275      break;
276    case Primitive::kPrimNot: {
277      Object* reg = shadow_frame.GetVRegReference(vregA);
278      if (do_assignability_check && reg != nullptr) {
279        // FieldHelper::GetType can resolve classes, use a handle wrapper which will restore the
280        // object in the destructor.
281        Class* field_class;
282        {
283          StackHandleScope<3> hs(self);
284          HandleWrapper<mirror::ArtField> h_f(hs.NewHandleWrapper(&f));
285          HandleWrapper<mirror::Object> h_reg(hs.NewHandleWrapper(&reg));
286          HandleWrapper<mirror::Object> h_obj(hs.NewHandleWrapper(&obj));
287          field_class = h_f->GetType(true);
288        }
289        if (!reg->VerifierInstanceOf(field_class)) {
290          // This should never happen.
291          std::string temp1, temp2, temp3;
292          self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(),
293                                   "Ljava/lang/VirtualMachineError;",
294                                   "Put '%s' that is not instance of field '%s' in '%s'",
295                                   reg->GetClass()->GetDescriptor(&temp1),
296                                   field_class->GetDescriptor(&temp2),
297                                   f->GetDeclaringClass()->GetDescriptor(&temp3));
298          return false;
299        }
300      }
301      f->SetObj<transaction_active>(obj, reg);
302      break;
303    }
304    default:
305      LOG(FATAL) << "Unreachable: " << field_type;
306      UNREACHABLE();
307  }
308  return true;
309}
310
311// Explicitly instantiate all DoFieldPut functions.
312#define EXPLICIT_DO_FIELD_PUT_TEMPLATE_DECL(_find_type, _field_type, _do_check, _transaction_active) \
313  template bool DoFieldPut<_find_type, _field_type, _do_check, _transaction_active>(Thread* self, \
314      const ShadowFrame& shadow_frame, const Instruction* inst, uint16_t inst_data)
315
316#define EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(_find_type, _field_type)  \
317    EXPLICIT_DO_FIELD_PUT_TEMPLATE_DECL(_find_type, _field_type, false, false);  \
318    EXPLICIT_DO_FIELD_PUT_TEMPLATE_DECL(_find_type, _field_type, true, false);  \
319    EXPLICIT_DO_FIELD_PUT_TEMPLATE_DECL(_find_type, _field_type, false, true);  \
320    EXPLICIT_DO_FIELD_PUT_TEMPLATE_DECL(_find_type, _field_type, true, true);
321
322// iput-XXX
323EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimBoolean)
324EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimByte)
325EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimChar)
326EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimShort)
327EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimInt)
328EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimLong)
329EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstanceObjectWrite, Primitive::kPrimNot)
330
331// sput-XXX
332EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimBoolean)
333EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimByte)
334EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimChar)
335EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimShort)
336EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimInt)
337EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimLong)
338EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticObjectWrite, Primitive::kPrimNot)
339
340#undef EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL
341#undef EXPLICIT_DO_FIELD_PUT_TEMPLATE_DECL
342
343template<Primitive::Type field_type, bool transaction_active>
344bool DoIPutQuick(const ShadowFrame& shadow_frame, const Instruction* inst, uint16_t inst_data) {
345  Object* obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
346  if (UNLIKELY(obj == nullptr)) {
347    // We lost the reference to the field index so we cannot get a more
348    // precised exception message.
349    ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
350    return false;
351  }
352  MemberOffset field_offset(inst->VRegC_22c());
353  const uint32_t vregA = inst->VRegA_22c(inst_data);
354  // Report this field modification to instrumentation if needed. Since we only have the offset of
355  // the field from the base of the object, we need to look for it first.
356  instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
357  if (UNLIKELY(instrumentation->HasFieldWriteListeners())) {
358    ArtField* f = ArtField::FindInstanceFieldWithOffset(obj->GetClass(),
359                                                        field_offset.Uint32Value());
360    DCHECK(f != nullptr);
361    DCHECK(!f->IsStatic());
362    JValue field_value = GetFieldValue<field_type>(shadow_frame, vregA);
363    instrumentation->FieldWriteEvent(Thread::Current(), obj, shadow_frame.GetMethod(),
364                                     shadow_frame.GetDexPC(), f, field_value);
365  }
366  // Note: iput-x-quick instructions are only for non-volatile fields.
367  switch (field_type) {
368    case Primitive::kPrimBoolean:
369      obj->SetFieldBoolean<transaction_active>(field_offset, shadow_frame.GetVReg(vregA));
370      break;
371    case Primitive::kPrimByte:
372      obj->SetFieldByte<transaction_active>(field_offset, shadow_frame.GetVReg(vregA));
373      break;
374    case Primitive::kPrimChar:
375      obj->SetFieldChar<transaction_active>(field_offset, shadow_frame.GetVReg(vregA));
376      break;
377    case Primitive::kPrimShort:
378      obj->SetFieldShort<transaction_active>(field_offset, shadow_frame.GetVReg(vregA));
379      break;
380    case Primitive::kPrimInt:
381      obj->SetField32<transaction_active>(field_offset, shadow_frame.GetVReg(vregA));
382      break;
383    case Primitive::kPrimLong:
384      obj->SetField64<transaction_active>(field_offset, shadow_frame.GetVRegLong(vregA));
385      break;
386    case Primitive::kPrimNot:
387      obj->SetFieldObject<transaction_active>(field_offset, shadow_frame.GetVRegReference(vregA));
388      break;
389    default:
390      LOG(FATAL) << "Unreachable: " << field_type;
391      UNREACHABLE();
392  }
393  return true;
394}
395
396// Explicitly instantiate all DoIPutQuick functions.
397#define EXPLICIT_DO_IPUT_QUICK_TEMPLATE_DECL(_field_type, _transaction_active) \
398  template bool DoIPutQuick<_field_type, _transaction_active>(const ShadowFrame& shadow_frame, \
399                                                              const Instruction* inst, \
400                                                              uint16_t inst_data)
401
402#define EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(_field_type)   \
403  EXPLICIT_DO_IPUT_QUICK_TEMPLATE_DECL(_field_type, false);     \
404  EXPLICIT_DO_IPUT_QUICK_TEMPLATE_DECL(_field_type, true);
405
406EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimInt)      // iput-quick.
407EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimBoolean)  // iput-boolean-quick.
408EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimByte)     // iput-byte-quick.
409EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimChar)     // iput-char-quick.
410EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimShort)    // iput-short-quick.
411EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimLong)     // iput-wide-quick.
412EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimNot)      // iput-object-quick.
413#undef EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL
414#undef EXPLICIT_DO_IPUT_QUICK_TEMPLATE_DECL
415
416/**
417 * Finds the location where this exception will be caught. We search until we reach either the top
418 * frame or a native frame, in which cases this exception is considered uncaught.
419 */
420class CatchLocationFinder : public StackVisitor {
421 public:
422  explicit CatchLocationFinder(Thread* self, Handle<mirror::Throwable>* exception)
423      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
424    : StackVisitor(self, nullptr), self_(self), handle_scope_(self), exception_(exception),
425      catch_method_(handle_scope_.NewHandle<mirror::ArtMethod>(nullptr)),
426      catch_dex_pc_(DexFile::kDexNoIndex), clear_exception_(false) {
427  }
428
429  bool VisitFrame() OVERRIDE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
430    mirror::ArtMethod* method = GetMethod();
431    if (method == nullptr) {
432      return true;
433    }
434    if (method->IsRuntimeMethod()) {
435      // Ignore callee save method.
436      DCHECK(method->IsCalleeSaveMethod());
437      return true;
438    }
439    if (method->IsNative()) {
440      return false;  // End stack walk.
441    }
442    DCHECK(!method->IsNative());
443    uint32_t dex_pc = GetDexPc();
444    if (dex_pc != DexFile::kDexNoIndex) {
445      uint32_t found_dex_pc;
446      {
447        StackHandleScope<3> hs(self_);
448        Handle<mirror::Class> exception_class(hs.NewHandle((*exception_)->GetClass()));
449        Handle<mirror::ArtMethod> h_method(hs.NewHandle(method));
450        found_dex_pc = mirror::ArtMethod::FindCatchBlock(h_method, exception_class, dex_pc,
451                                                         &clear_exception_);
452      }
453      if (found_dex_pc != DexFile::kDexNoIndex) {
454        catch_method_.Assign(method);
455        catch_dex_pc_ = found_dex_pc;
456        return false;  // End stack walk.
457      }
458    }
459    return true;  // Continue stack walk.
460  }
461
462  ArtMethod* GetCatchMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
463    return catch_method_.Get();
464  }
465
466  uint32_t GetCatchDexPc() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
467    return catch_dex_pc_;
468  }
469
470  bool NeedClearException() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
471    return clear_exception_;
472  }
473
474 private:
475  Thread* const self_;
476  StackHandleScope<1> handle_scope_;
477  Handle<mirror::Throwable>* exception_;
478  MutableHandle<mirror::ArtMethod> catch_method_;
479  uint32_t catch_dex_pc_;
480  bool clear_exception_;
481
482
483  DISALLOW_COPY_AND_ASSIGN(CatchLocationFinder);
484};
485
486uint32_t FindNextInstructionFollowingException(Thread* self,
487                                               ShadowFrame& shadow_frame,
488                                               uint32_t dex_pc,
489                                               const instrumentation::Instrumentation* instrumentation) {
490  self->VerifyStack();
491  ThrowLocation throw_location;
492  StackHandleScope<3> hs(self);
493  Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException(&throw_location)));
494  if (instrumentation->HasExceptionCaughtListeners()
495      && self->IsExceptionThrownByCurrentMethod(exception.Get())) {
496    CatchLocationFinder clf(self, &exception);
497    clf.WalkStack(false);
498    instrumentation->ExceptionCaughtEvent(self, throw_location, clf.GetCatchMethod(),
499                                          clf.GetCatchDexPc(), exception.Get());
500  }
501  bool clear_exception = false;
502  uint32_t found_dex_pc;
503  {
504    Handle<mirror::Class> exception_class(hs.NewHandle(exception->GetClass()));
505    Handle<mirror::ArtMethod> h_method(hs.NewHandle(shadow_frame.GetMethod()));
506    found_dex_pc = mirror::ArtMethod::FindCatchBlock(h_method, exception_class, dex_pc,
507                                                     &clear_exception);
508  }
509  if (found_dex_pc == DexFile::kDexNoIndex) {
510    // Exception is not caught by the current method. We will unwind to the
511    // caller. Notify any instrumentation listener.
512    instrumentation->MethodUnwindEvent(self, shadow_frame.GetThisObject(),
513                                       shadow_frame.GetMethod(), dex_pc);
514  } else {
515    // Exception is caught in the current method. We will jump to the found_dex_pc.
516    if (clear_exception) {
517      self->ClearException();
518    }
519  }
520  return found_dex_pc;
521}
522
523void UnexpectedOpcode(const Instruction* inst, const ShadowFrame& shadow_frame) {
524  LOG(FATAL) << "Unexpected instruction: "
525             << inst->DumpString(shadow_frame.GetMethod()->GetDexFile());
526  UNREACHABLE();
527}
528
529static void UnstartedRuntimeInvoke(Thread* self, const DexFile::CodeItem* code_item,
530                                   ShadowFrame* shadow_frame, JValue* result, size_t arg_offset)
531    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
532
533// Assign register 'src_reg' from shadow_frame to register 'dest_reg' into new_shadow_frame.
534static inline void AssignRegister(ShadowFrame* new_shadow_frame, const ShadowFrame& shadow_frame,
535                                  size_t dest_reg, size_t src_reg)
536    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
537  // If both register locations contains the same value, the register probably holds a reference.
538  // Uint required, so that sign extension does not make this wrong on 64b systems
539  uint32_t src_value = shadow_frame.GetVReg(src_reg);
540  mirror::Object* o = shadow_frame.GetVRegReference<kVerifyNone>(src_reg);
541  if (src_value == reinterpret_cast<uintptr_t>(o)) {
542    new_shadow_frame->SetVRegReference(dest_reg, o);
543  } else {
544    new_shadow_frame->SetVReg(dest_reg, src_value);
545  }
546}
547
548void AbortTransaction(Thread* self, const char* fmt, ...) {
549  CHECK(Runtime::Current()->IsActiveTransaction());
550  // Constructs abort message.
551  va_list args;
552  va_start(args, fmt);
553  std::string abort_msg;
554  StringAppendV(&abort_msg, fmt, args);
555  // Throws an exception so we can abort the transaction and rollback every change.
556  Runtime::Current()->AbortTransactionAndThrowInternalError(self, abort_msg);
557  va_end(args);
558}
559
560template<bool is_range, bool do_assignability_check>
561bool DoCall(ArtMethod* called_method, Thread* self, ShadowFrame& shadow_frame,
562            const Instruction* inst, uint16_t inst_data, JValue* result) {
563  // Compute method information.
564  const DexFile::CodeItem* code_item = called_method->GetCodeItem();
565  const uint16_t num_ins = (is_range) ? inst->VRegA_3rc(inst_data) : inst->VRegA_35c(inst_data);
566  uint16_t num_regs;
567  if (LIKELY(code_item != NULL)) {
568    num_regs = code_item->registers_size_;
569    DCHECK_EQ(num_ins, code_item->ins_size_);
570  } else {
571    DCHECK(called_method->IsNative() || called_method->IsProxyMethod());
572    num_regs = num_ins;
573  }
574
575  // Allocate shadow frame on the stack.
576  const char* old_cause = self->StartAssertNoThreadSuspension("DoCall");
577  void* memory = alloca(ShadowFrame::ComputeSize(num_regs));
578  ShadowFrame* new_shadow_frame(ShadowFrame::Create(num_regs, &shadow_frame, called_method, 0,
579                                                    memory));
580
581  // Initialize new shadow frame.
582  const size_t first_dest_reg = num_regs - num_ins;
583  if (do_assignability_check) {
584    // Slow path.
585    // We might need to do class loading, which incurs a thread state change to kNative. So
586    // register the shadow frame as under construction and allow suspension again.
587    self->SetShadowFrameUnderConstruction(new_shadow_frame);
588    self->EndAssertNoThreadSuspension(old_cause);
589
590    // We need to do runtime check on reference assignment. We need to load the shorty
591    // to get the exact type of each reference argument.
592    const DexFile::TypeList* params = new_shadow_frame->GetMethod()->GetParameterTypeList();
593    uint32_t shorty_len = 0;
594    const char* shorty = new_shadow_frame->GetMethod()->GetShorty(&shorty_len);
595
596    // TODO: find a cleaner way to separate non-range and range information without duplicating
597    //       code.
598    uint32_t arg[5];  // only used in invoke-XXX.
599    uint32_t vregC;   // only used in invoke-XXX-range.
600    if (is_range) {
601      vregC = inst->VRegC_3rc();
602    } else {
603      inst->GetVarArgs(arg, inst_data);
604    }
605
606    // Handle receiver apart since it's not part of the shorty.
607    size_t dest_reg = first_dest_reg;
608    size_t arg_offset = 0;
609    if (!new_shadow_frame->GetMethod()->IsStatic()) {
610      size_t receiver_reg = is_range ? vregC : arg[0];
611      new_shadow_frame->SetVRegReference(dest_reg, shadow_frame.GetVRegReference(receiver_reg));
612      ++dest_reg;
613      ++arg_offset;
614    }
615    for (uint32_t shorty_pos = 0; dest_reg < num_regs; ++shorty_pos, ++dest_reg, ++arg_offset) {
616      DCHECK_LT(shorty_pos + 1, shorty_len);
617      const size_t src_reg = (is_range) ? vregC + arg_offset : arg[arg_offset];
618      switch (shorty[shorty_pos + 1]) {
619        case 'L': {
620          Object* o = shadow_frame.GetVRegReference(src_reg);
621          if (do_assignability_check && o != NULL) {
622            Class* arg_type =
623                new_shadow_frame->GetMethod()->GetClassFromTypeIndex(
624                    params->GetTypeItem(shorty_pos).type_idx_, true);
625            if (arg_type == NULL) {
626              CHECK(self->IsExceptionPending());
627              return false;
628            }
629            if (!o->VerifierInstanceOf(arg_type)) {
630              // This should never happen.
631              std::string temp1, temp2;
632              self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(),
633                                       "Ljava/lang/VirtualMachineError;",
634                                       "Invoking %s with bad arg %d, type '%s' not instance of '%s'",
635                                       new_shadow_frame->GetMethod()->GetName(), shorty_pos,
636                                       o->GetClass()->GetDescriptor(&temp1),
637                                       arg_type->GetDescriptor(&temp2));
638              return false;
639            }
640          }
641          new_shadow_frame->SetVRegReference(dest_reg, o);
642          break;
643        }
644        case 'J': case 'D': {
645          uint64_t wide_value = (static_cast<uint64_t>(shadow_frame.GetVReg(src_reg + 1)) << 32) |
646                                static_cast<uint32_t>(shadow_frame.GetVReg(src_reg));
647          new_shadow_frame->SetVRegLong(dest_reg, wide_value);
648          ++dest_reg;
649          ++arg_offset;
650          break;
651        }
652        default:
653          new_shadow_frame->SetVReg(dest_reg, shadow_frame.GetVReg(src_reg));
654          break;
655      }
656    }
657    // We're done with the construction.
658    self->ClearShadowFrameUnderConstruction();
659  } else {
660    // Fast path: no extra checks.
661    if (is_range) {
662      const uint16_t first_src_reg = inst->VRegC_3rc();
663      for (size_t src_reg = first_src_reg, dest_reg = first_dest_reg; dest_reg < num_regs;
664          ++dest_reg, ++src_reg) {
665        AssignRegister(new_shadow_frame, shadow_frame, dest_reg, src_reg);
666      }
667    } else {
668      DCHECK_LE(num_ins, 5U);
669      uint16_t regList = inst->Fetch16(2);
670      uint16_t count = num_ins;
671      if (count == 5) {
672        AssignRegister(new_shadow_frame, shadow_frame, first_dest_reg + 4U,
673                       (inst_data >> 8) & 0x0f);
674        --count;
675       }
676      for (size_t arg_index = 0; arg_index < count; ++arg_index, regList >>= 4) {
677        AssignRegister(new_shadow_frame, shadow_frame, first_dest_reg + arg_index, regList & 0x0f);
678      }
679    }
680    self->EndAssertNoThreadSuspension(old_cause);
681  }
682
683  // Do the call now.
684  if (LIKELY(Runtime::Current()->IsStarted())) {
685    if (kIsDebugBuild && new_shadow_frame->GetMethod()->GetEntryPointFromInterpreter() == nullptr) {
686      LOG(FATAL) << "Attempt to invoke non-executable method: "
687          << PrettyMethod(new_shadow_frame->GetMethod());
688      UNREACHABLE();
689    }
690    if (kIsDebugBuild && Runtime::Current()->GetInstrumentation()->IsForcedInterpretOnly() &&
691        !new_shadow_frame->GetMethod()->IsNative() &&
692        !new_shadow_frame->GetMethod()->IsProxyMethod() &&
693        new_shadow_frame->GetMethod()->GetEntryPointFromInterpreter()
694            == artInterpreterToCompiledCodeBridge) {
695      LOG(FATAL) << "Attempt to call compiled code when -Xint: "
696          << PrettyMethod(new_shadow_frame->GetMethod());
697      UNREACHABLE();
698    }
699    (new_shadow_frame->GetMethod()->GetEntryPointFromInterpreter())(self, code_item,
700                                                                    new_shadow_frame, result);
701  } else {
702    UnstartedRuntimeInvoke(self, code_item, new_shadow_frame, result, first_dest_reg);
703  }
704  return !self->IsExceptionPending();
705}
706
707template <bool is_range, bool do_access_check, bool transaction_active>
708bool DoFilledNewArray(const Instruction* inst, const ShadowFrame& shadow_frame,
709                      Thread* self, JValue* result) {
710  DCHECK(inst->Opcode() == Instruction::FILLED_NEW_ARRAY ||
711         inst->Opcode() == Instruction::FILLED_NEW_ARRAY_RANGE);
712  const int32_t length = is_range ? inst->VRegA_3rc() : inst->VRegA_35c();
713  if (!is_range) {
714    // Checks FILLED_NEW_ARRAY's length does not exceed 5 arguments.
715    CHECK_LE(length, 5);
716  }
717  if (UNLIKELY(length < 0)) {
718    ThrowNegativeArraySizeException(length);
719    return false;
720  }
721  uint16_t type_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
722  Class* arrayClass = ResolveVerifyAndClinit(type_idx, shadow_frame.GetMethod(),
723                                             self, false, do_access_check);
724  if (UNLIKELY(arrayClass == NULL)) {
725    DCHECK(self->IsExceptionPending());
726    return false;
727  }
728  CHECK(arrayClass->IsArrayClass());
729  Class* componentClass = arrayClass->GetComponentType();
730  if (UNLIKELY(componentClass->IsPrimitive() && !componentClass->IsPrimitiveInt())) {
731    if (componentClass->IsPrimitiveLong() || componentClass->IsPrimitiveDouble()) {
732      ThrowRuntimeException("Bad filled array request for type %s",
733                            PrettyDescriptor(componentClass).c_str());
734    } else {
735      self->ThrowNewExceptionF(shadow_frame.GetCurrentLocationForThrow(),
736                               "Ljava/lang/InternalError;",
737                               "Found type %s; filled-new-array not implemented for anything but 'int'",
738                               PrettyDescriptor(componentClass).c_str());
739    }
740    return false;
741  }
742  Object* newArray = Array::Alloc<true>(self, arrayClass, length,
743                                        arrayClass->GetComponentSizeShift(),
744                                        Runtime::Current()->GetHeap()->GetCurrentAllocator());
745  if (UNLIKELY(newArray == NULL)) {
746    DCHECK(self->IsExceptionPending());
747    return false;
748  }
749  uint32_t arg[5];  // only used in filled-new-array.
750  uint32_t vregC;   // only used in filled-new-array-range.
751  if (is_range) {
752    vregC = inst->VRegC_3rc();
753  } else {
754    inst->GetVarArgs(arg);
755  }
756  const bool is_primitive_int_component = componentClass->IsPrimitiveInt();
757  for (int32_t i = 0; i < length; ++i) {
758    size_t src_reg = is_range ? vregC + i : arg[i];
759    if (is_primitive_int_component) {
760      newArray->AsIntArray()->SetWithoutChecks<transaction_active>(i, shadow_frame.GetVReg(src_reg));
761    } else {
762      newArray->AsObjectArray<Object>()->SetWithoutChecks<transaction_active>(i, shadow_frame.GetVRegReference(src_reg));
763    }
764  }
765
766  result->SetL(newArray);
767  return true;
768}
769
770// TODO fix thread analysis: should be SHARED_LOCKS_REQUIRED(Locks::mutator_lock_).
771template<typename T>
772static void RecordArrayElementsInTransactionImpl(mirror::PrimitiveArray<T>* array, int32_t count)
773    NO_THREAD_SAFETY_ANALYSIS {
774  Runtime* runtime = Runtime::Current();
775  for (int32_t i = 0; i < count; ++i) {
776    runtime->RecordWriteArray(array, i, array->GetWithoutChecks(i));
777  }
778}
779
780void RecordArrayElementsInTransaction(mirror::Array* array, int32_t count)
781    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
782  DCHECK(Runtime::Current()->IsActiveTransaction());
783  DCHECK(array != nullptr);
784  DCHECK_LE(count, array->GetLength());
785  Primitive::Type primitive_component_type = array->GetClass()->GetComponentType()->GetPrimitiveType();
786  switch (primitive_component_type) {
787    case Primitive::kPrimBoolean:
788      RecordArrayElementsInTransactionImpl(array->AsBooleanArray(), count);
789      break;
790    case Primitive::kPrimByte:
791      RecordArrayElementsInTransactionImpl(array->AsByteArray(), count);
792      break;
793    case Primitive::kPrimChar:
794      RecordArrayElementsInTransactionImpl(array->AsCharArray(), count);
795      break;
796    case Primitive::kPrimShort:
797      RecordArrayElementsInTransactionImpl(array->AsShortArray(), count);
798      break;
799    case Primitive::kPrimInt:
800    case Primitive::kPrimFloat:
801      RecordArrayElementsInTransactionImpl(array->AsIntArray(), count);
802      break;
803    case Primitive::kPrimLong:
804    case Primitive::kPrimDouble:
805      RecordArrayElementsInTransactionImpl(array->AsLongArray(), count);
806      break;
807    default:
808      LOG(FATAL) << "Unsupported primitive type " << primitive_component_type
809                 << " in fill-array-data";
810      break;
811  }
812}
813
814// Helper function to deal with class loading in an unstarted runtime.
815static void UnstartedRuntimeFindClass(Thread* self, Handle<mirror::String> className,
816                                      Handle<mirror::ClassLoader> class_loader, JValue* result,
817                                      const std::string& method_name, bool initialize_class,
818                                      bool abort_if_not_found)
819    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
820  CHECK(className.Get() != nullptr);
821  std::string descriptor(DotToDescriptor(className->ToModifiedUtf8().c_str()));
822  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
823
824  Class* found = class_linker->FindClass(self, descriptor.c_str(), class_loader);
825  if (found == nullptr && abort_if_not_found) {
826    if (!self->IsExceptionPending()) {
827      AbortTransaction(self, "%s failed in un-started runtime for class: %s",
828                       method_name.c_str(), PrettyDescriptor(descriptor.c_str()).c_str());
829    }
830    return;
831  }
832  if (found != nullptr && initialize_class) {
833    StackHandleScope<1> hs(self);
834    Handle<mirror::Class> h_class(hs.NewHandle(found));
835    if (!class_linker->EnsureInitialized(self, h_class, true, true)) {
836      CHECK(self->IsExceptionPending());
837      return;
838    }
839  }
840  result->SetL(found);
841}
842
843// Common helper for class-loading cutouts in an unstarted runtime. We call Runtime methods that
844// rely on Java code to wrap errors in the correct exception class (i.e., NoClassDefFoundError into
845// ClassNotFoundException), so need to do the same. The only exception is if the exception is
846// actually InternalError. This must not be wrapped, as it signals an initialization abort.
847static void CheckExceptionGenerateClassNotFound(Thread* self)
848    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
849  if (self->IsExceptionPending()) {
850    // If it is not an InternalError, wrap it.
851    std::string type(PrettyTypeOf(self->GetException(nullptr)));
852    if (type != "java.lang.InternalError") {
853      self->ThrowNewWrappedException(self->GetCurrentLocationForThrow(),
854                                     "Ljava/lang/ClassNotFoundException;",
855                                     "ClassNotFoundException");
856    }
857  }
858}
859
860static void UnstartedRuntimeInvoke(Thread* self,  const DexFile::CodeItem* code_item,
861                                   ShadowFrame* shadow_frame,
862                                   JValue* result, size_t arg_offset) {
863  // In a runtime that's not started we intercept certain methods to avoid complicated dependency
864  // problems in core libraries.
865  std::string name(PrettyMethod(shadow_frame->GetMethod()));
866  if (name == "java.lang.Class java.lang.Class.forName(java.lang.String)") {
867    mirror::String* class_name = shadow_frame->GetVRegReference(arg_offset)->AsString();
868    StackHandleScope<1> hs(self);
869    Handle<mirror::String> h_class_name(hs.NewHandle(class_name));
870    UnstartedRuntimeFindClass(self, h_class_name, NullHandle<mirror::ClassLoader>(), result, name,
871                              true, false);
872    CheckExceptionGenerateClassNotFound(self);
873  } else if (name == "java.lang.Class java.lang.Class.forName(java.lang.String, boolean, java.lang.ClassLoader)") {
874    mirror::String* class_name = shadow_frame->GetVRegReference(arg_offset)->AsString();
875    bool initialize_class = shadow_frame->GetVReg(arg_offset + 1) != 0;
876    mirror::ClassLoader* class_loader =
877        down_cast<mirror::ClassLoader*>(shadow_frame->GetVRegReference(arg_offset + 2));
878    StackHandleScope<2> hs(self);
879    Handle<mirror::String> h_class_name(hs.NewHandle(class_name));
880    Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(class_loader));
881    UnstartedRuntimeFindClass(self, h_class_name, h_class_loader, result, name, initialize_class,
882                              false);
883    CheckExceptionGenerateClassNotFound(self);
884  } else if (name == "java.lang.Class java.lang.Class.classForName(java.lang.String, boolean, java.lang.ClassLoader)") {
885    mirror::String* class_name = shadow_frame->GetVRegReference(arg_offset)->AsString();
886    bool initialize_class = shadow_frame->GetVReg(arg_offset + 1) != 0;
887    mirror::ClassLoader* class_loader =
888        down_cast<mirror::ClassLoader*>(shadow_frame->GetVRegReference(arg_offset + 2));
889    StackHandleScope<2> hs(self);
890    Handle<mirror::String> h_class_name(hs.NewHandle(class_name));
891    Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(class_loader));
892    UnstartedRuntimeFindClass(self, h_class_name, h_class_loader, result, name, initialize_class,
893                              false);
894    CheckExceptionGenerateClassNotFound(self);
895  } else if (name == "java.lang.Class java.lang.VMClassLoader.findLoadedClass(java.lang.ClassLoader, java.lang.String)") {
896    mirror::String* class_name = shadow_frame->GetVRegReference(arg_offset + 1)->AsString();
897    mirror::ClassLoader* class_loader =
898        down_cast<mirror::ClassLoader*>(shadow_frame->GetVRegReference(arg_offset));
899    StackHandleScope<2> hs(self);
900    Handle<mirror::String> h_class_name(hs.NewHandle(class_name));
901    Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(class_loader));
902    UnstartedRuntimeFindClass(self, h_class_name, h_class_loader, result, name, false, false);
903    // This might have an error pending. But semantics are to just return null.
904    if (self->IsExceptionPending()) {
905      // If it is an InternalError, keep it. See CheckExceptionGenerateClassNotFound.
906      std::string type(PrettyTypeOf(self->GetException(nullptr)));
907      if (type != "java.lang.InternalError") {
908        self->ClearException();
909      }
910    }
911  } else if (name == "java.lang.Class java.lang.Void.lookupType()") {
912    result->SetL(Runtime::Current()->GetClassLinker()->FindPrimitiveClass('V'));
913  } else if (name == "java.lang.Object java.lang.Class.newInstance()") {
914    StackHandleScope<2> hs(self);
915    Class* klass = shadow_frame->GetVRegReference(arg_offset)->AsClass();
916    Handle<Class> h_klass(hs.NewHandle(klass));
917    // There are two situations in which we'll abort this run.
918    //  1) If the class isn't yet initialized and initialization fails.
919    //  2) If we can't find the default constructor. We'll postpone the exception to runtime.
920    // Note that 2) could likely be handled here, but for safety abort the transaction.
921    bool ok = false;
922    if (Runtime::Current()->GetClassLinker()->EnsureInitialized(self, h_klass, true, true)) {
923      ArtMethod* c = h_klass->FindDeclaredDirectMethod("<init>", "()V");
924      if (c != nullptr) {
925        Handle<Object> obj(hs.NewHandle(klass->AllocObject(self)));
926        CHECK(obj.Get() != nullptr);  // We don't expect OOM at compile-time.
927        EnterInterpreterFromInvoke(self, c, obj.Get(), nullptr, nullptr);
928        result->SetL(obj.Get());
929        ok = true;
930      } else {
931        self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(), "Ljava/lang/InternalError;",
932                                 "Could not find default constructor for '%s'",
933                                 PrettyClass(h_klass.Get()).c_str());
934      }
935    }
936    if (!ok) {
937      std::string error_msg = StringPrintf("Failed in Class.newInstance for '%s' with %s",
938                                           PrettyClass(h_klass.Get()).c_str(),
939                                           PrettyTypeOf(self->GetException(nullptr)).c_str());
940      self->ThrowNewWrappedException(self->GetCurrentLocationForThrow(),
941                                     "Ljava/lang/InternalError;",
942                                     error_msg.c_str());
943    }
944  } else if (name == "java.lang.reflect.Field java.lang.Class.getDeclaredField(java.lang.String)") {
945    // Special managed code cut-out to allow field lookup in a un-started runtime that'd fail
946    // going the reflective Dex way.
947    Class* klass = shadow_frame->GetVRegReference(arg_offset)->AsClass();
948    String* name2 = shadow_frame->GetVRegReference(arg_offset + 1)->AsString();
949    ArtField* found = NULL;
950    ObjectArray<ArtField>* fields = klass->GetIFields();
951    for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
952      ArtField* f = fields->Get(i);
953      if (name2->Equals(f->GetName())) {
954        found = f;
955      }
956    }
957    if (found == NULL) {
958      fields = klass->GetSFields();
959      for (int32_t i = 0; i < fields->GetLength() && found == NULL; ++i) {
960        ArtField* f = fields->Get(i);
961        if (name2->Equals(f->GetName())) {
962          found = f;
963        }
964      }
965    }
966    CHECK(found != NULL)
967      << "Failed to find field in Class.getDeclaredField in un-started runtime. name="
968      << name2->ToModifiedUtf8() << " class=" << PrettyDescriptor(klass);
969    // TODO: getDeclaredField calls GetType once the field is found to ensure a
970    //       NoClassDefFoundError is thrown if the field's type cannot be resolved.
971    Class* jlr_Field = self->DecodeJObject(WellKnownClasses::java_lang_reflect_Field)->AsClass();
972    StackHandleScope<1> hs(self);
973    Handle<Object> field(hs.NewHandle(jlr_Field->AllocNonMovableObject(self)));
974    CHECK(field.Get() != NULL);
975    ArtMethod* c = jlr_Field->FindDeclaredDirectMethod("<init>", "(Ljava/lang/reflect/ArtField;)V");
976    uint32_t args[1];
977    args[0] = StackReference<mirror::Object>::FromMirrorPtr(found).AsVRegValue();
978    EnterInterpreterFromInvoke(self, c, field.Get(), args, NULL);
979    result->SetL(field.Get());
980  } else if (name == "int java.lang.Object.hashCode()") {
981    Object* obj = shadow_frame->GetVRegReference(arg_offset);
982    result->SetI(obj->IdentityHashCode());
983  } else if (name == "java.lang.String java.lang.reflect.ArtMethod.getMethodName(java.lang.reflect.ArtMethod)") {
984    mirror::ArtMethod* method = shadow_frame->GetVRegReference(arg_offset)->AsArtMethod();
985    result->SetL(method->GetNameAsString(self));
986  } else if (name == "void java.lang.System.arraycopy(java.lang.Object, int, java.lang.Object, int, int)" ||
987             name == "void java.lang.System.arraycopy(char[], int, char[], int, int)") {
988    // Special case array copying without initializing System.
989    Class* ctype = shadow_frame->GetVRegReference(arg_offset)->GetClass()->GetComponentType();
990    jint srcPos = shadow_frame->GetVReg(arg_offset + 1);
991    jint dstPos = shadow_frame->GetVReg(arg_offset + 3);
992    jint length = shadow_frame->GetVReg(arg_offset + 4);
993    if (!ctype->IsPrimitive()) {
994      ObjectArray<Object>* src = shadow_frame->GetVRegReference(arg_offset)->AsObjectArray<Object>();
995      ObjectArray<Object>* dst = shadow_frame->GetVRegReference(arg_offset + 2)->AsObjectArray<Object>();
996      for (jint i = 0; i < length; ++i) {
997        dst->Set(dstPos + i, src->Get(srcPos + i));
998      }
999    } else if (ctype->IsPrimitiveChar()) {
1000      CharArray* src = shadow_frame->GetVRegReference(arg_offset)->AsCharArray();
1001      CharArray* dst = shadow_frame->GetVRegReference(arg_offset + 2)->AsCharArray();
1002      for (jint i = 0; i < length; ++i) {
1003        dst->Set(dstPos + i, src->Get(srcPos + i));
1004      }
1005    } else if (ctype->IsPrimitiveInt()) {
1006      IntArray* src = shadow_frame->GetVRegReference(arg_offset)->AsIntArray();
1007      IntArray* dst = shadow_frame->GetVRegReference(arg_offset + 2)->AsIntArray();
1008      for (jint i = 0; i < length; ++i) {
1009        dst->Set(dstPos + i, src->Get(srcPos + i));
1010      }
1011    } else {
1012      self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(), "Ljava/lang/InternalError;",
1013                               "Unimplemented System.arraycopy for type '%s'",
1014                               PrettyDescriptor(ctype).c_str());
1015    }
1016  } else if (name == "long java.lang.Double.doubleToRawLongBits(double)") {
1017    double in = shadow_frame->GetVRegDouble(arg_offset);
1018    result->SetJ(bit_cast<int64_t>(in));
1019  } else if (name == "double java.lang.Math.ceil(double)") {
1020    double in = shadow_frame->GetVRegDouble(arg_offset);
1021    double out;
1022    // Special cases:
1023    // 1) NaN, infinity, +0, -0 -> out := in. All are guaranteed by cmath.
1024    // -1 < in < 0 -> out := -0.
1025    if (-1.0 < in && in < 0) {
1026      out = -0.0;
1027    } else {
1028      out = ceil(in);
1029    }
1030    result->SetD(out);
1031  } else if (name == "java.lang.Object java.lang.ThreadLocal.get()") {
1032    std::string caller(PrettyMethod(shadow_frame->GetLink()->GetMethod()));
1033    bool ok = false;
1034    if (caller == "java.lang.String java.lang.IntegralToString.convertInt(java.lang.AbstractStringBuilder, int)") {
1035      // Allocate non-threadlocal buffer.
1036      result->SetL(mirror::CharArray::Alloc(self, 11));
1037      ok = true;
1038    } else if (caller == "java.lang.RealToString java.lang.RealToString.getInstance()") {
1039      // Note: RealToString is implemented and used in a different fashion than IntegralToString.
1040      // Conversion is done over an actual object of RealToString (the conversion method is an
1041      // instance method). This means it is not as clear whether it is correct to return a new
1042      // object each time. The caller needs to be inspected by hand to see whether it (incorrectly)
1043      // stores the object for later use.
1044      // See also b/19548084 for a possible rewrite and bringing it in line with IntegralToString.
1045      if (shadow_frame->GetLink()->GetLink() != nullptr) {
1046        std::string caller2(PrettyMethod(shadow_frame->GetLink()->GetLink()->GetMethod()));
1047        if (caller2 == "java.lang.String java.lang.Double.toString(double)") {
1048          // Allocate new object.
1049          mirror::Class* real_to_string_class =
1050              shadow_frame->GetLink()->GetMethod()->GetDeclaringClass();
1051          mirror::Object* real_to_string_obj = real_to_string_class->AllocObject(self);
1052          if (real_to_string_obj != nullptr) {
1053            mirror::ArtMethod* init_method =
1054                real_to_string_class->FindDirectMethod("<init>", "()V");
1055            if (init_method == nullptr) {
1056              real_to_string_class->DumpClass(LOG(FATAL), mirror::Class::kDumpClassFullDetail);
1057            }
1058            JValue invoke_result;
1059            // One arg, this.
1060            uint32_t args = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(real_to_string_obj));
1061            init_method->Invoke(self, &args, 4, &invoke_result, init_method->GetShorty());
1062            if (!self->IsExceptionPending()) {
1063              result->SetL(real_to_string_obj);
1064              ok = true;
1065            }
1066          }
1067
1068          if (!ok) {
1069            // We'll abort, so clear exception.
1070            self->ClearException();
1071          }
1072        }
1073      }
1074    }
1075
1076    if (!ok) {
1077      self->ThrowNewException(self->GetCurrentLocationForThrow(), "Ljava/lang/InternalError;",
1078                              "Unimplemented ThreadLocal.get");
1079    }
1080  } else {
1081    // Not special, continue with regular interpreter execution.
1082    artInterpreterToInterpreterBridge(self, code_item, shadow_frame, result);
1083  }
1084}
1085
1086// Explicit DoCall template function declarations.
1087#define EXPLICIT_DO_CALL_TEMPLATE_DECL(_is_range, _do_assignability_check)                      \
1088  template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                                          \
1089  bool DoCall<_is_range, _do_assignability_check>(ArtMethod* method, Thread* self,              \
1090                                                  ShadowFrame& shadow_frame,                    \
1091                                                  const Instruction* inst, uint16_t inst_data,  \
1092                                                  JValue* result)
1093EXPLICIT_DO_CALL_TEMPLATE_DECL(false, false);
1094EXPLICIT_DO_CALL_TEMPLATE_DECL(false, true);
1095EXPLICIT_DO_CALL_TEMPLATE_DECL(true, false);
1096EXPLICIT_DO_CALL_TEMPLATE_DECL(true, true);
1097#undef EXPLICIT_DO_CALL_TEMPLATE_DECL
1098
1099// Explicit DoFilledNewArray template function declarations.
1100#define EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(_is_range_, _check, _transaction_active)       \
1101  template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                                            \
1102  bool DoFilledNewArray<_is_range_, _check, _transaction_active>(const Instruction* inst,         \
1103                                                                 const ShadowFrame& shadow_frame, \
1104                                                                 Thread* self, JValue* result)
1105#define EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL(_transaction_active)       \
1106  EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(false, false, _transaction_active);  \
1107  EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(false, true, _transaction_active);   \
1108  EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(true, false, _transaction_active);   \
1109  EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(true, true, _transaction_active)
1110EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL(false);
1111EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL(true);
1112#undef EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL
1113#undef EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL
1114
1115}  // namespace interpreter
1116}  // namespace art
1117