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 "debugger.h"
22 #include "mirror/array-inl.h"
23 #include "unstarted_runtime.h"
24 #include "verifier/method_verifier.h"
25 
26 namespace art {
27 namespace interpreter {
28 
ThrowNullPointerExceptionFromInterpreter()29 void ThrowNullPointerExceptionFromInterpreter() {
30   ThrowNullPointerExceptionFromDexPC();
31 }
32 
33 template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check>
DoFieldGet(Thread * self,ShadowFrame & shadow_frame,const Instruction * inst,uint16_t inst_data)34 bool DoFieldGet(Thread* self, ShadowFrame& shadow_frame, const Instruction* inst,
35                 uint16_t inst_data) {
36   const bool is_static = (find_type == StaticObjectRead) || (find_type == StaticPrimitiveRead);
37   const uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
38   ArtField* f = FindFieldFromCode<find_type, do_access_check>(field_idx, shadow_frame.GetMethod(), self,
39                                                               Primitive::ComponentSize(field_type));
40   if (UNLIKELY(f == nullptr)) {
41     CHECK(self->IsExceptionPending());
42     return false;
43   }
44   Object* obj;
45   if (is_static) {
46     obj = f->GetDeclaringClass();
47   } else {
48     obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
49     if (UNLIKELY(obj == nullptr)) {
50       ThrowNullPointerExceptionForFieldAccess(f, true);
51       return false;
52     }
53   }
54   f->GetDeclaringClass()->AssertInitializedOrInitializingInThread(self);
55   // Report this field access to instrumentation if needed.
56   instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
57   if (UNLIKELY(instrumentation->HasFieldReadListeners())) {
58     Object* this_object = f->IsStatic() ? nullptr : obj;
59     instrumentation->FieldReadEvent(self, this_object, shadow_frame.GetMethod(),
60                                     shadow_frame.GetDexPC(), f);
61   }
62   uint32_t vregA = is_static ? inst->VRegA_21c(inst_data) : inst->VRegA_22c(inst_data);
63   switch (field_type) {
64     case Primitive::kPrimBoolean:
65       shadow_frame.SetVReg(vregA, f->GetBoolean(obj));
66       break;
67     case Primitive::kPrimByte:
68       shadow_frame.SetVReg(vregA, f->GetByte(obj));
69       break;
70     case Primitive::kPrimChar:
71       shadow_frame.SetVReg(vregA, f->GetChar(obj));
72       break;
73     case Primitive::kPrimShort:
74       shadow_frame.SetVReg(vregA, f->GetShort(obj));
75       break;
76     case Primitive::kPrimInt:
77       shadow_frame.SetVReg(vregA, f->GetInt(obj));
78       break;
79     case Primitive::kPrimLong:
80       shadow_frame.SetVRegLong(vregA, f->GetLong(obj));
81       break;
82     case Primitive::kPrimNot:
83       shadow_frame.SetVRegReference(vregA, f->GetObject(obj));
84       break;
85     default:
86       LOG(FATAL) << "Unreachable: " << field_type;
87       UNREACHABLE();
88   }
89   return true;
90 }
91 
92 // Explicitly instantiate all DoFieldGet functions.
93 #define EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL(_find_type, _field_type, _do_check) \
94   template bool DoFieldGet<_find_type, _field_type, _do_check>(Thread* self, \
95                                                                ShadowFrame& shadow_frame, \
96                                                                const Instruction* inst, \
97                                                                uint16_t inst_data)
98 
99 #define EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(_find_type, _field_type)  \
100     EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL(_find_type, _field_type, false);  \
101     EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL(_find_type, _field_type, true);
102 
103 // iget-XXX
EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead,Primitive::kPrimBoolean)104 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimBoolean)
105 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimByte)
106 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimChar)
107 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimShort)
108 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimInt)
109 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstancePrimitiveRead, Primitive::kPrimLong)
110 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(InstanceObjectRead, Primitive::kPrimNot)
111 
112 // sget-XXX
113 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimBoolean)
114 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimByte)
115 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimChar)
116 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimShort)
117 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimInt)
118 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticPrimitiveRead, Primitive::kPrimLong)
119 EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL(StaticObjectRead, Primitive::kPrimNot)
120 
121 #undef EXPLICIT_DO_FIELD_GET_ALL_TEMPLATE_DECL
122 #undef EXPLICIT_DO_FIELD_GET_TEMPLATE_DECL
123 
124 // Handles iget-quick, iget-wide-quick and iget-object-quick instructions.
125 // Returns true on success, otherwise throws an exception and returns false.
126 template<Primitive::Type field_type>
127 bool DoIGetQuick(ShadowFrame& shadow_frame, const Instruction* inst, uint16_t inst_data) {
128   Object* obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
129   if (UNLIKELY(obj == nullptr)) {
130     // We lost the reference to the field index so we cannot get a more
131     // precised exception message.
132     ThrowNullPointerExceptionFromDexPC();
133     return false;
134   }
135   MemberOffset field_offset(inst->VRegC_22c());
136   // Report this field access to instrumentation if needed. Since we only have the offset of
137   // the field from the base of the object, we need to look for it first.
138   instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
139   if (UNLIKELY(instrumentation->HasFieldReadListeners())) {
140     ArtField* f = ArtField::FindInstanceFieldWithOffset(obj->GetClass(),
141                                                         field_offset.Uint32Value());
142     DCHECK(f != nullptr);
143     DCHECK(!f->IsStatic());
144     instrumentation->FieldReadEvent(Thread::Current(), obj, shadow_frame.GetMethod(),
145                                     shadow_frame.GetDexPC(), f);
146   }
147   // Note: iget-x-quick instructions are only for non-volatile fields.
148   const uint32_t vregA = inst->VRegA_22c(inst_data);
149   switch (field_type) {
150     case Primitive::kPrimInt:
151       shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetField32(field_offset)));
152       break;
153     case Primitive::kPrimBoolean:
154       shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldBoolean(field_offset)));
155       break;
156     case Primitive::kPrimByte:
157       shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldByte(field_offset)));
158       break;
159     case Primitive::kPrimChar:
160       shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldChar(field_offset)));
161       break;
162     case Primitive::kPrimShort:
163       shadow_frame.SetVReg(vregA, static_cast<int32_t>(obj->GetFieldShort(field_offset)));
164       break;
165     case Primitive::kPrimLong:
166       shadow_frame.SetVRegLong(vregA, static_cast<int64_t>(obj->GetField64(field_offset)));
167       break;
168     case Primitive::kPrimNot:
169       shadow_frame.SetVRegReference(vregA, obj->GetFieldObject<mirror::Object>(field_offset));
170       break;
171     default:
172       LOG(FATAL) << "Unreachable: " << field_type;
173       UNREACHABLE();
174   }
175   return true;
176 }
177 
178 // Explicitly instantiate all DoIGetQuick functions.
179 #define EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(_field_type) \
180   template bool DoIGetQuick<_field_type>(ShadowFrame& shadow_frame, const Instruction* inst, \
181                                          uint16_t inst_data)
182 
183 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimInt);      // iget-quick.
184 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimBoolean);  // iget-boolean-quick.
185 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimByte);     // iget-byte-quick.
186 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimChar);     // iget-char-quick.
187 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimShort);    // iget-short-quick.
188 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimLong);     // iget-wide-quick.
189 EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL(Primitive::kPrimNot);      // iget-object-quick.
190 #undef EXPLICIT_DO_IGET_QUICK_TEMPLATE_DECL
191 
192 template<Primitive::Type field_type>
GetFieldValue(const ShadowFrame & shadow_frame,uint32_t vreg)193 static JValue GetFieldValue(const ShadowFrame& shadow_frame, uint32_t vreg)
194     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
195   JValue field_value;
196   switch (field_type) {
197     case Primitive::kPrimBoolean:
198       field_value.SetZ(static_cast<uint8_t>(shadow_frame.GetVReg(vreg)));
199       break;
200     case Primitive::kPrimByte:
201       field_value.SetB(static_cast<int8_t>(shadow_frame.GetVReg(vreg)));
202       break;
203     case Primitive::kPrimChar:
204       field_value.SetC(static_cast<uint16_t>(shadow_frame.GetVReg(vreg)));
205       break;
206     case Primitive::kPrimShort:
207       field_value.SetS(static_cast<int16_t>(shadow_frame.GetVReg(vreg)));
208       break;
209     case Primitive::kPrimInt:
210       field_value.SetI(shadow_frame.GetVReg(vreg));
211       break;
212     case Primitive::kPrimLong:
213       field_value.SetJ(shadow_frame.GetVRegLong(vreg));
214       break;
215     case Primitive::kPrimNot:
216       field_value.SetL(shadow_frame.GetVRegReference(vreg));
217       break;
218     default:
219       LOG(FATAL) << "Unreachable: " << field_type;
220       UNREACHABLE();
221   }
222   return field_value;
223 }
224 
225 template<FindFieldType find_type, Primitive::Type field_type, bool do_access_check,
226          bool transaction_active>
DoFieldPut(Thread * self,const ShadowFrame & shadow_frame,const Instruction * inst,uint16_t inst_data)227 bool DoFieldPut(Thread* self, const ShadowFrame& shadow_frame, const Instruction* inst,
228                 uint16_t inst_data) {
229   bool do_assignability_check = do_access_check;
230   bool is_static = (find_type == StaticObjectWrite) || (find_type == StaticPrimitiveWrite);
231   uint32_t field_idx = is_static ? inst->VRegB_21c() : inst->VRegC_22c();
232   ArtField* f = FindFieldFromCode<find_type, do_access_check>(field_idx, shadow_frame.GetMethod(), self,
233                                                               Primitive::ComponentSize(field_type));
234   if (UNLIKELY(f == nullptr)) {
235     CHECK(self->IsExceptionPending());
236     return false;
237   }
238   Object* obj;
239   if (is_static) {
240     obj = f->GetDeclaringClass();
241   } else {
242     obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
243     if (UNLIKELY(obj == nullptr)) {
244       ThrowNullPointerExceptionForFieldAccess(f, false);
245       return false;
246     }
247   }
248   f->GetDeclaringClass()->AssertInitializedOrInitializingInThread(self);
249   uint32_t vregA = is_static ? inst->VRegA_21c(inst_data) : inst->VRegA_22c(inst_data);
250   // Report this field access to instrumentation if needed. Since we only have the offset of
251   // the field from the base of the object, we need to look for it first.
252   instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
253   if (UNLIKELY(instrumentation->HasFieldWriteListeners())) {
254     JValue field_value = GetFieldValue<field_type>(shadow_frame, vregA);
255     Object* this_object = f->IsStatic() ? nullptr : obj;
256     instrumentation->FieldWriteEvent(self, this_object, shadow_frame.GetMethod(),
257                                      shadow_frame.GetDexPC(), f, field_value);
258   }
259   switch (field_type) {
260     case Primitive::kPrimBoolean:
261       f->SetBoolean<transaction_active>(obj, shadow_frame.GetVReg(vregA));
262       break;
263     case Primitive::kPrimByte:
264       f->SetByte<transaction_active>(obj, shadow_frame.GetVReg(vregA));
265       break;
266     case Primitive::kPrimChar:
267       f->SetChar<transaction_active>(obj, shadow_frame.GetVReg(vregA));
268       break;
269     case Primitive::kPrimShort:
270       f->SetShort<transaction_active>(obj, shadow_frame.GetVReg(vregA));
271       break;
272     case Primitive::kPrimInt:
273       f->SetInt<transaction_active>(obj, shadow_frame.GetVReg(vregA));
274       break;
275     case Primitive::kPrimLong:
276       f->SetLong<transaction_active>(obj, shadow_frame.GetVRegLong(vregA));
277       break;
278     case Primitive::kPrimNot: {
279       Object* reg = shadow_frame.GetVRegReference(vregA);
280       if (do_assignability_check && reg != nullptr) {
281         // FieldHelper::GetType can resolve classes, use a handle wrapper which will restore the
282         // object in the destructor.
283         Class* field_class;
284         {
285           StackHandleScope<2> hs(self);
286           HandleWrapper<mirror::Object> h_reg(hs.NewHandleWrapper(&reg));
287           HandleWrapper<mirror::Object> h_obj(hs.NewHandleWrapper(&obj));
288           field_class = f->GetType<true>();
289         }
290         if (!reg->VerifierInstanceOf(field_class)) {
291           // This should never happen.
292           std::string temp1, temp2, temp3;
293           self->ThrowNewExceptionF("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
EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite,Primitive::kPrimBoolean)323 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimBoolean)
324 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimByte)
325 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimChar)
326 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimShort)
327 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimInt)
328 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstancePrimitiveWrite, Primitive::kPrimLong)
329 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(InstanceObjectWrite, Primitive::kPrimNot)
330 
331 // sput-XXX
332 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimBoolean)
333 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimByte)
334 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimChar)
335 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimShort)
336 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimInt)
337 EXPLICIT_DO_FIELD_PUT_ALL_TEMPLATE_DECL(StaticPrimitiveWrite, Primitive::kPrimLong)
338 EXPLICIT_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 
343 template<Primitive::Type field_type, bool transaction_active>
344 bool 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();
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 
406 EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimInt)      // iput-quick.
EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimBoolean)407 EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimBoolean)  // iput-boolean-quick.
408 EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimByte)     // iput-byte-quick.
409 EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimChar)     // iput-char-quick.
410 EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimShort)    // iput-short-quick.
411 EXPLICIT_DO_IPUT_QUICK_ALL_TEMPLATE_DECL(Primitive::kPrimLong)     // iput-wide-quick.
412 EXPLICIT_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 uint32_t FindNextInstructionFollowingException(
417     Thread* self, ShadowFrame& shadow_frame, uint32_t dex_pc,
418     const instrumentation::Instrumentation* instrumentation) {
419   self->VerifyStack();
420   StackHandleScope<2> hs(self);
421   Handle<mirror::Throwable> exception(hs.NewHandle(self->GetException()));
422   if (instrumentation->HasExceptionCaughtListeners()
423       && self->IsExceptionThrownByCurrentMethod(exception.Get())) {
424     instrumentation->ExceptionCaughtEvent(self, exception.Get());
425   }
426   bool clear_exception = false;
427   uint32_t found_dex_pc = shadow_frame.GetMethod()->FindCatchBlock(
428       hs.NewHandle(exception->GetClass()), dex_pc, &clear_exception);
429   if (found_dex_pc == DexFile::kDexNoIndex) {
430     // Exception is not caught by the current method. We will unwind to the
431     // caller. Notify any instrumentation listener.
432     instrumentation->MethodUnwindEvent(self, shadow_frame.GetThisObject(),
433                                        shadow_frame.GetMethod(), dex_pc);
434   } else {
435     // Exception is caught in the current method. We will jump to the found_dex_pc.
436     if (clear_exception) {
437       self->ClearException();
438     }
439   }
440   return found_dex_pc;
441 }
442 
UnexpectedOpcode(const Instruction * inst,const ShadowFrame & shadow_frame)443 void UnexpectedOpcode(const Instruction* inst, const ShadowFrame& shadow_frame) {
444   LOG(FATAL) << "Unexpected instruction: "
445              << inst->DumpString(shadow_frame.GetMethod()->GetDexFile());
446   UNREACHABLE();
447 }
448 
449 // Assign register 'src_reg' from shadow_frame to register 'dest_reg' into new_shadow_frame.
AssignRegister(ShadowFrame * new_shadow_frame,const ShadowFrame & shadow_frame,size_t dest_reg,size_t src_reg)450 static inline void AssignRegister(ShadowFrame* new_shadow_frame, const ShadowFrame& shadow_frame,
451                                   size_t dest_reg, size_t src_reg)
452     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
453   // If both register locations contains the same value, the register probably holds a reference.
454   // Uint required, so that sign extension does not make this wrong on 64b systems
455   uint32_t src_value = shadow_frame.GetVReg(src_reg);
456   mirror::Object* o = shadow_frame.GetVRegReference<kVerifyNone>(src_reg);
457   if (src_value == reinterpret_cast<uintptr_t>(o)) {
458     new_shadow_frame->SetVRegReference(dest_reg, o);
459   } else {
460     new_shadow_frame->SetVReg(dest_reg, src_value);
461   }
462 }
463 
AbortTransactionF(Thread * self,const char * fmt,...)464 void AbortTransactionF(Thread* self, const char* fmt, ...) {
465   va_list args;
466   va_start(args, fmt);
467   AbortTransactionV(self, fmt, args);
468   va_end(args);
469 }
470 
AbortTransactionV(Thread * self,const char * fmt,va_list args)471 void AbortTransactionV(Thread* self, const char* fmt, va_list args) {
472   CHECK(Runtime::Current()->IsActiveTransaction());
473   // Constructs abort message.
474   std::string abort_msg;
475   StringAppendV(&abort_msg, fmt, args);
476   // Throws an exception so we can abort the transaction and rollback every change.
477   Runtime::Current()->AbortTransactionAndThrowAbortError(self, abort_msg);
478 }
479 
480 template<bool is_range, bool do_assignability_check>
DoCall(ArtMethod * called_method,Thread * self,ShadowFrame & shadow_frame,const Instruction * inst,uint16_t inst_data,JValue * result)481 bool DoCall(ArtMethod* called_method, Thread* self, ShadowFrame& shadow_frame,
482             const Instruction* inst, uint16_t inst_data, JValue* result) {
483   bool string_init = false;
484   // Replace calls to String.<init> with equivalent StringFactory call.
485   if (called_method->GetDeclaringClass()->IsStringClass() && called_method->IsConstructor()) {
486     ScopedObjectAccessUnchecked soa(self);
487     jmethodID mid = soa.EncodeMethod(called_method);
488     called_method = soa.DecodeMethod(WellKnownClasses::StringInitToStringFactoryMethodID(mid));
489     string_init = true;
490   }
491 
492   // Compute method information.
493   const DexFile::CodeItem* code_item = called_method->GetCodeItem();
494   const uint16_t num_ins = (is_range) ? inst->VRegA_3rc(inst_data) : inst->VRegA_35c(inst_data);
495   uint16_t num_regs;
496   if (LIKELY(code_item != nullptr)) {
497     num_regs = code_item->registers_size_;
498     DCHECK_EQ(string_init ? num_ins - 1 : num_ins, code_item->ins_size_);
499   } else {
500     DCHECK(called_method->IsNative() || called_method->IsProxyMethod());
501     num_regs = num_ins;
502     if (string_init) {
503       // The new StringFactory call is static and has one fewer argument.
504       num_regs--;
505     }
506   }
507 
508   // Allocate shadow frame on the stack.
509   const char* old_cause = self->StartAssertNoThreadSuspension("DoCall");
510   void* memory = alloca(ShadowFrame::ComputeSize(num_regs));
511   ShadowFrame* new_shadow_frame(ShadowFrame::Create(num_regs, &shadow_frame, called_method, 0,
512                                                     memory));
513 
514   // Initialize new shadow frame.
515   size_t first_dest_reg = num_regs - num_ins;
516   if (do_assignability_check) {
517     // Slow path.
518     // We might need to do class loading, which incurs a thread state change to kNative. So
519     // register the shadow frame as under construction and allow suspension again.
520     ScopedStackedShadowFramePusher pusher(
521         self, new_shadow_frame, StackedShadowFrameType::kShadowFrameUnderConstruction);
522     self->EndAssertNoThreadSuspension(old_cause);
523 
524     // We need to do runtime check on reference assignment. We need to load the shorty
525     // to get the exact type of each reference argument.
526     const DexFile::TypeList* params = new_shadow_frame->GetMethod()->GetParameterTypeList();
527     uint32_t shorty_len = 0;
528     const char* shorty = new_shadow_frame->GetMethod()->GetShorty(&shorty_len);
529 
530     // TODO: find a cleaner way to separate non-range and range information without duplicating
531     //       code.
532     uint32_t arg[5];  // only used in invoke-XXX.
533     uint32_t vregC;   // only used in invoke-XXX-range.
534     if (is_range) {
535       vregC = inst->VRegC_3rc();
536     } else {
537       inst->GetVarArgs(arg, inst_data);
538     }
539 
540     // Handle receiver apart since it's not part of the shorty.
541     size_t dest_reg = first_dest_reg;
542     size_t arg_offset = 0;
543     if (!new_shadow_frame->GetMethod()->IsStatic()) {
544       size_t receiver_reg = is_range ? vregC : arg[0];
545       new_shadow_frame->SetVRegReference(dest_reg, shadow_frame.GetVRegReference(receiver_reg));
546       ++dest_reg;
547       ++arg_offset;
548     } else if (string_init) {
549       // Skip the referrer for the new static StringFactory call.
550       ++dest_reg;
551       ++arg_offset;
552     }
553     for (uint32_t shorty_pos = 0; dest_reg < num_regs; ++shorty_pos, ++dest_reg, ++arg_offset) {
554       DCHECK_LT(shorty_pos + 1, shorty_len);
555       const size_t src_reg = (is_range) ? vregC + arg_offset : arg[arg_offset];
556       switch (shorty[shorty_pos + 1]) {
557         case 'L': {
558           Object* o = shadow_frame.GetVRegReference(src_reg);
559           if (do_assignability_check && o != nullptr) {
560             Class* arg_type =
561                 new_shadow_frame->GetMethod()->GetClassFromTypeIndex(
562                     params->GetTypeItem(shorty_pos).type_idx_, true);
563             if (arg_type == nullptr) {
564               CHECK(self->IsExceptionPending());
565               return false;
566             }
567             if (!o->VerifierInstanceOf(arg_type)) {
568               // This should never happen.
569               std::string temp1, temp2;
570               self->ThrowNewExceptionF("Ljava/lang/VirtualMachineError;",
571                                        "Invoking %s with bad arg %d, type '%s' not instance of '%s'",
572                                        new_shadow_frame->GetMethod()->GetName(), shorty_pos,
573                                        o->GetClass()->GetDescriptor(&temp1),
574                                        arg_type->GetDescriptor(&temp2));
575               return false;
576             }
577           }
578           new_shadow_frame->SetVRegReference(dest_reg, o);
579           break;
580         }
581         case 'J': case 'D': {
582           uint64_t wide_value = (static_cast<uint64_t>(shadow_frame.GetVReg(src_reg + 1)) << 32) |
583                                 static_cast<uint32_t>(shadow_frame.GetVReg(src_reg));
584           new_shadow_frame->SetVRegLong(dest_reg, wide_value);
585           ++dest_reg;
586           ++arg_offset;
587           break;
588         }
589         default:
590           new_shadow_frame->SetVReg(dest_reg, shadow_frame.GetVReg(src_reg));
591           break;
592       }
593     }
594   } else {
595     // Fast path: no extra checks.
596     if (is_range) {
597       uint16_t first_src_reg = inst->VRegC_3rc();
598       if (string_init) {
599         // Skip the referrer for the new static StringFactory call.
600         ++first_src_reg;
601         ++first_dest_reg;
602       }
603       for (size_t src_reg = first_src_reg, dest_reg = first_dest_reg; dest_reg < num_regs;
604           ++dest_reg, ++src_reg) {
605         AssignRegister(new_shadow_frame, shadow_frame, dest_reg, src_reg);
606       }
607     } else {
608       DCHECK_LE(num_ins, 5U);
609       uint16_t regList = inst->Fetch16(2);
610       uint16_t count = num_ins;
611       size_t arg_index = 0;
612       if (count == 5) {
613         AssignRegister(new_shadow_frame, shadow_frame, first_dest_reg + 4U,
614                        (inst_data >> 8) & 0x0f);
615         --count;
616       }
617       if (string_init) {
618         // Skip the referrer for the new static StringFactory call.
619         regList >>= 4;
620         ++first_dest_reg;
621         --count;
622       }
623       for (; arg_index < count; ++arg_index, regList >>= 4) {
624         AssignRegister(new_shadow_frame, shadow_frame, first_dest_reg + arg_index, regList & 0x0f);
625       }
626     }
627     self->EndAssertNoThreadSuspension(old_cause);
628   }
629 
630   // Do the call now.
631   if (LIKELY(Runtime::Current()->IsStarted())) {
632     if (kIsDebugBuild && new_shadow_frame->GetMethod()->GetEntryPointFromInterpreter() == nullptr) {
633       LOG(FATAL) << "Attempt to invoke non-executable method: "
634           << PrettyMethod(new_shadow_frame->GetMethod());
635       UNREACHABLE();
636     }
637     if (kIsDebugBuild && Runtime::Current()->GetInstrumentation()->IsForcedInterpretOnly() &&
638         !new_shadow_frame->GetMethod()->IsNative() &&
639         !new_shadow_frame->GetMethod()->IsProxyMethod() &&
640         new_shadow_frame->GetMethod()->GetEntryPointFromInterpreter()
641             == artInterpreterToCompiledCodeBridge) {
642       LOG(FATAL) << "Attempt to call compiled code when -Xint: "
643           << PrettyMethod(new_shadow_frame->GetMethod());
644       UNREACHABLE();
645     }
646     // Force the use of interpreter when it is required by the debugger.
647     EntryPointFromInterpreter* entry;
648     if (UNLIKELY(Dbg::IsForcedInterpreterNeededForCalling(self, new_shadow_frame->GetMethod()))) {
649       entry = &art::artInterpreterToInterpreterBridge;
650     } else {
651       entry = new_shadow_frame->GetMethod()->GetEntryPointFromInterpreter();
652     }
653     entry(self, code_item, new_shadow_frame, result);
654   } else {
655     UnstartedRuntime::Invoke(self, code_item, new_shadow_frame, result, first_dest_reg);
656   }
657 
658   if (string_init && !self->IsExceptionPending()) {
659     // Set the new string result of the StringFactory.
660     uint32_t vregC = (is_range) ? inst->VRegC_3rc() : inst->VRegC_35c();
661     shadow_frame.SetVRegReference(vregC, result->GetL());
662     // Overwrite all potential copies of the original result of the new-instance of string with the
663     // new result of the StringFactory. Use the verifier to find this set of registers.
664     ArtMethod* method = shadow_frame.GetMethod();
665     MethodReference method_ref = method->ToMethodReference();
666     SafeMap<uint32_t, std::set<uint32_t>> string_init_map;
667     SafeMap<uint32_t, std::set<uint32_t>>* string_init_map_ptr;
668     MethodRefToStringInitRegMap& method_to_string_init_map = Runtime::Current()->GetStringInitMap();
669     auto it = method_to_string_init_map.find(method_ref);
670     if (it == method_to_string_init_map.end()) {
671       string_init_map = std::move(verifier::MethodVerifier::FindStringInitMap(method));
672       method_to_string_init_map.Overwrite(method_ref, string_init_map);
673       string_init_map_ptr = &string_init_map;
674     } else {
675       string_init_map_ptr = &it->second;
676     }
677     if (string_init_map_ptr->size() != 0) {
678       uint32_t dex_pc = shadow_frame.GetDexPC();
679       auto map_it = string_init_map_ptr->find(dex_pc);
680       if (map_it != string_init_map_ptr->end()) {
681         const std::set<uint32_t>& reg_set = map_it->second;
682         for (auto set_it = reg_set.begin(); set_it != reg_set.end(); ++set_it) {
683           shadow_frame.SetVRegReference(*set_it, result->GetL());
684         }
685       }
686     }
687   }
688 
689   return !self->IsExceptionPending();
690 }
691 
692 template <bool is_range, bool do_access_check, bool transaction_active>
DoFilledNewArray(const Instruction * inst,const ShadowFrame & shadow_frame,Thread * self,JValue * result)693 bool DoFilledNewArray(const Instruction* inst, const ShadowFrame& shadow_frame,
694                       Thread* self, JValue* result) {
695   DCHECK(inst->Opcode() == Instruction::FILLED_NEW_ARRAY ||
696          inst->Opcode() == Instruction::FILLED_NEW_ARRAY_RANGE);
697   const int32_t length = is_range ? inst->VRegA_3rc() : inst->VRegA_35c();
698   if (!is_range) {
699     // Checks FILLED_NEW_ARRAY's length does not exceed 5 arguments.
700     CHECK_LE(length, 5);
701   }
702   if (UNLIKELY(length < 0)) {
703     ThrowNegativeArraySizeException(length);
704     return false;
705   }
706   uint16_t type_idx = is_range ? inst->VRegB_3rc() : inst->VRegB_35c();
707   Class* array_class = ResolveVerifyAndClinit(type_idx, shadow_frame.GetMethod(),
708                                               self, false, do_access_check);
709   if (UNLIKELY(array_class == nullptr)) {
710     DCHECK(self->IsExceptionPending());
711     return false;
712   }
713   CHECK(array_class->IsArrayClass());
714   Class* component_class = array_class->GetComponentType();
715   const bool is_primitive_int_component = component_class->IsPrimitiveInt();
716   if (UNLIKELY(component_class->IsPrimitive() && !is_primitive_int_component)) {
717     if (component_class->IsPrimitiveLong() || component_class->IsPrimitiveDouble()) {
718       ThrowRuntimeException("Bad filled array request for type %s",
719                             PrettyDescriptor(component_class).c_str());
720     } else {
721       self->ThrowNewExceptionF("Ljava/lang/InternalError;",
722                                "Found type %s; filled-new-array not implemented for anything but 'int'",
723                                PrettyDescriptor(component_class).c_str());
724     }
725     return false;
726   }
727   Object* new_array = Array::Alloc<true>(self, array_class, length,
728                                          array_class->GetComponentSizeShift(),
729                                          Runtime::Current()->GetHeap()->GetCurrentAllocator());
730   if (UNLIKELY(new_array == nullptr)) {
731     self->AssertPendingOOMException();
732     return false;
733   }
734   uint32_t arg[5];  // only used in filled-new-array.
735   uint32_t vregC;   // only used in filled-new-array-range.
736   if (is_range) {
737     vregC = inst->VRegC_3rc();
738   } else {
739     inst->GetVarArgs(arg);
740   }
741   for (int32_t i = 0; i < length; ++i) {
742     size_t src_reg = is_range ? vregC + i : arg[i];
743     if (is_primitive_int_component) {
744       new_array->AsIntArray()->SetWithoutChecks<transaction_active>(
745           i, shadow_frame.GetVReg(src_reg));
746     } else {
747       new_array->AsObjectArray<Object>()->SetWithoutChecks<transaction_active>(
748           i, shadow_frame.GetVRegReference(src_reg));
749     }
750   }
751 
752   result->SetL(new_array);
753   return true;
754 }
755 
756 // TODO fix thread analysis: should be SHARED_LOCKS_REQUIRED(Locks::mutator_lock_).
757 template<typename T>
RecordArrayElementsInTransactionImpl(mirror::PrimitiveArray<T> * array,int32_t count)758 static void RecordArrayElementsInTransactionImpl(mirror::PrimitiveArray<T>* array, int32_t count)
759     NO_THREAD_SAFETY_ANALYSIS {
760   Runtime* runtime = Runtime::Current();
761   for (int32_t i = 0; i < count; ++i) {
762     runtime->RecordWriteArray(array, i, array->GetWithoutChecks(i));
763   }
764 }
765 
RecordArrayElementsInTransaction(mirror::Array * array,int32_t count)766 void RecordArrayElementsInTransaction(mirror::Array* array, int32_t count)
767     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
768   DCHECK(Runtime::Current()->IsActiveTransaction());
769   DCHECK(array != nullptr);
770   DCHECK_LE(count, array->GetLength());
771   Primitive::Type primitive_component_type = array->GetClass()->GetComponentType()->GetPrimitiveType();
772   switch (primitive_component_type) {
773     case Primitive::kPrimBoolean:
774       RecordArrayElementsInTransactionImpl(array->AsBooleanArray(), count);
775       break;
776     case Primitive::kPrimByte:
777       RecordArrayElementsInTransactionImpl(array->AsByteArray(), count);
778       break;
779     case Primitive::kPrimChar:
780       RecordArrayElementsInTransactionImpl(array->AsCharArray(), count);
781       break;
782     case Primitive::kPrimShort:
783       RecordArrayElementsInTransactionImpl(array->AsShortArray(), count);
784       break;
785     case Primitive::kPrimInt:
786       RecordArrayElementsInTransactionImpl(array->AsIntArray(), count);
787       break;
788     case Primitive::kPrimFloat:
789       RecordArrayElementsInTransactionImpl(array->AsFloatArray(), count);
790       break;
791     case Primitive::kPrimLong:
792       RecordArrayElementsInTransactionImpl(array->AsLongArray(), count);
793       break;
794     case Primitive::kPrimDouble:
795       RecordArrayElementsInTransactionImpl(array->AsDoubleArray(), count);
796       break;
797     default:
798       LOG(FATAL) << "Unsupported primitive type " << primitive_component_type
799                  << " in fill-array-data";
800       break;
801   }
802 }
803 
804 // Explicit DoCall template function declarations.
805 #define EXPLICIT_DO_CALL_TEMPLATE_DECL(_is_range, _do_assignability_check)                      \
806   template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                                          \
807   bool DoCall<_is_range, _do_assignability_check>(ArtMethod* method, Thread* self,              \
808                                                   ShadowFrame& shadow_frame,                    \
809                                                   const Instruction* inst, uint16_t inst_data,  \
810                                                   JValue* result)
811 EXPLICIT_DO_CALL_TEMPLATE_DECL(false, false);
812 EXPLICIT_DO_CALL_TEMPLATE_DECL(false, true);
813 EXPLICIT_DO_CALL_TEMPLATE_DECL(true, false);
814 EXPLICIT_DO_CALL_TEMPLATE_DECL(true, true);
815 #undef EXPLICIT_DO_CALL_TEMPLATE_DECL
816 
817 // Explicit DoFilledNewArray template function declarations.
818 #define EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(_is_range_, _check, _transaction_active)       \
819   template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                                            \
820   bool DoFilledNewArray<_is_range_, _check, _transaction_active>(const Instruction* inst,         \
821                                                                  const ShadowFrame& shadow_frame, \
822                                                                  Thread* self, JValue* result)
823 #define EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL(_transaction_active)       \
824   EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(false, false, _transaction_active);  \
825   EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(false, true, _transaction_active);   \
826   EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(true, false, _transaction_active);   \
827   EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL(true, true, _transaction_active)
828 EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL(false);
829 EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL(true);
830 #undef EXPLICIT_DO_FILLED_NEW_ARRAY_ALL_TEMPLATE_DECL
831 #undef EXPLICIT_DO_FILLED_NEW_ARRAY_TEMPLATE_DECL
832 
833 }  // namespace interpreter
834 }  // namespace art
835