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.h"
18 
19 #include <limits>
20 
21 #include "common_throws.h"
22 #include "interpreter_common.h"
23 #include "mirror/string-inl.h"
24 #include "scoped_thread_state_change.h"
25 #include "ScopedLocalRef.h"
26 #include "stack.h"
27 #include "unstarted_runtime.h"
28 #include "mterp/mterp.h"
29 #include "jit/jit.h"
30 #include "jit/jit_code_cache.h"
31 
32 namespace art {
33 namespace interpreter {
34 
InterpreterJni(Thread * self,ArtMethod * method,const StringPiece & shorty,Object * receiver,uint32_t * args,JValue * result)35 static void InterpreterJni(Thread* self, ArtMethod* method, const StringPiece& shorty,
36                            Object* receiver, uint32_t* args, JValue* result)
37     SHARED_REQUIRES(Locks::mutator_lock_) {
38   // TODO: The following enters JNI code using a typedef-ed function rather than the JNI compiler,
39   //       it should be removed and JNI compiled stubs used instead.
40   ScopedObjectAccessUnchecked soa(self);
41   if (method->IsStatic()) {
42     if (shorty == "L") {
43       typedef jobject (fntype)(JNIEnv*, jclass);
44       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
45       ScopedLocalRef<jclass> klass(soa.Env(),
46                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
47       jobject jresult;
48       {
49         ScopedThreadStateChange tsc(self, kNative);
50         jresult = fn(soa.Env(), klass.get());
51       }
52       result->SetL(soa.Decode<Object*>(jresult));
53     } else if (shorty == "V") {
54       typedef void (fntype)(JNIEnv*, jclass);
55       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
56       ScopedLocalRef<jclass> klass(soa.Env(),
57                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
58       ScopedThreadStateChange tsc(self, kNative);
59       fn(soa.Env(), klass.get());
60     } else if (shorty == "Z") {
61       typedef jboolean (fntype)(JNIEnv*, jclass);
62       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
63       ScopedLocalRef<jclass> klass(soa.Env(),
64                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
65       ScopedThreadStateChange tsc(self, kNative);
66       result->SetZ(fn(soa.Env(), klass.get()));
67     } else if (shorty == "BI") {
68       typedef jbyte (fntype)(JNIEnv*, jclass, jint);
69       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
70       ScopedLocalRef<jclass> klass(soa.Env(),
71                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
72       ScopedThreadStateChange tsc(self, kNative);
73       result->SetB(fn(soa.Env(), klass.get(), args[0]));
74     } else if (shorty == "II") {
75       typedef jint (fntype)(JNIEnv*, jclass, jint);
76       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
77       ScopedLocalRef<jclass> klass(soa.Env(),
78                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
79       ScopedThreadStateChange tsc(self, kNative);
80       result->SetI(fn(soa.Env(), klass.get(), args[0]));
81     } else if (shorty == "LL") {
82       typedef jobject (fntype)(JNIEnv*, jclass, jobject);
83       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
84       ScopedLocalRef<jclass> klass(soa.Env(),
85                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
86       ScopedLocalRef<jobject> arg0(soa.Env(),
87                                    soa.AddLocalReference<jobject>(
88                                        reinterpret_cast<Object*>(args[0])));
89       jobject jresult;
90       {
91         ScopedThreadStateChange tsc(self, kNative);
92         jresult = fn(soa.Env(), klass.get(), arg0.get());
93       }
94       result->SetL(soa.Decode<Object*>(jresult));
95     } else if (shorty == "IIZ") {
96       typedef jint (fntype)(JNIEnv*, jclass, jint, jboolean);
97       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
98       ScopedLocalRef<jclass> klass(soa.Env(),
99                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
100       ScopedThreadStateChange tsc(self, kNative);
101       result->SetI(fn(soa.Env(), klass.get(), args[0], args[1]));
102     } else if (shorty == "ILI") {
103       typedef jint (fntype)(JNIEnv*, jclass, jobject, jint);
104       fntype* const fn = reinterpret_cast<fntype*>(const_cast<void*>(
105           method->GetEntryPointFromJni()));
106       ScopedLocalRef<jclass> klass(soa.Env(),
107                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
108       ScopedLocalRef<jobject> arg0(soa.Env(),
109                                    soa.AddLocalReference<jobject>(
110                                        reinterpret_cast<Object*>(args[0])));
111       ScopedThreadStateChange tsc(self, kNative);
112       result->SetI(fn(soa.Env(), klass.get(), arg0.get(), args[1]));
113     } else if (shorty == "SIZ") {
114       typedef jshort (fntype)(JNIEnv*, jclass, jint, jboolean);
115       fntype* const fn =
116           reinterpret_cast<fntype*>(const_cast<void*>(method->GetEntryPointFromJni()));
117       ScopedLocalRef<jclass> klass(soa.Env(),
118                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
119       ScopedThreadStateChange tsc(self, kNative);
120       result->SetS(fn(soa.Env(), klass.get(), args[0], args[1]));
121     } else if (shorty == "VIZ") {
122       typedef void (fntype)(JNIEnv*, jclass, jint, jboolean);
123       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
124       ScopedLocalRef<jclass> klass(soa.Env(),
125                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
126       ScopedThreadStateChange tsc(self, kNative);
127       fn(soa.Env(), klass.get(), args[0], args[1]);
128     } else if (shorty == "ZLL") {
129       typedef jboolean (fntype)(JNIEnv*, jclass, jobject, jobject);
130       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
131       ScopedLocalRef<jclass> klass(soa.Env(),
132                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
133       ScopedLocalRef<jobject> arg0(soa.Env(),
134                                    soa.AddLocalReference<jobject>(
135                                        reinterpret_cast<Object*>(args[0])));
136       ScopedLocalRef<jobject> arg1(soa.Env(),
137                                    soa.AddLocalReference<jobject>(
138                                        reinterpret_cast<Object*>(args[1])));
139       ScopedThreadStateChange tsc(self, kNative);
140       result->SetZ(fn(soa.Env(), klass.get(), arg0.get(), arg1.get()));
141     } else if (shorty == "ZILL") {
142       typedef jboolean (fntype)(JNIEnv*, jclass, jint, jobject, jobject);
143       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
144       ScopedLocalRef<jclass> klass(soa.Env(),
145                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
146       ScopedLocalRef<jobject> arg1(soa.Env(),
147                                    soa.AddLocalReference<jobject>(
148                                        reinterpret_cast<Object*>(args[1])));
149       ScopedLocalRef<jobject> arg2(soa.Env(),
150                                    soa.AddLocalReference<jobject>(
151                                        reinterpret_cast<Object*>(args[2])));
152       ScopedThreadStateChange tsc(self, kNative);
153       result->SetZ(fn(soa.Env(), klass.get(), args[0], arg1.get(), arg2.get()));
154     } else if (shorty == "VILII") {
155       typedef void (fntype)(JNIEnv*, jclass, jint, jobject, jint, jint);
156       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
157       ScopedLocalRef<jclass> klass(soa.Env(),
158                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
159       ScopedLocalRef<jobject> arg1(soa.Env(),
160                                    soa.AddLocalReference<jobject>(
161                                        reinterpret_cast<Object*>(args[1])));
162       ScopedThreadStateChange tsc(self, kNative);
163       fn(soa.Env(), klass.get(), args[0], arg1.get(), args[2], args[3]);
164     } else if (shorty == "VLILII") {
165       typedef void (fntype)(JNIEnv*, jclass, jobject, jint, jobject, jint, jint);
166       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
167       ScopedLocalRef<jclass> klass(soa.Env(),
168                                    soa.AddLocalReference<jclass>(method->GetDeclaringClass()));
169       ScopedLocalRef<jobject> arg0(soa.Env(),
170                                    soa.AddLocalReference<jobject>(
171                                        reinterpret_cast<Object*>(args[0])));
172       ScopedLocalRef<jobject> arg2(soa.Env(),
173                                    soa.AddLocalReference<jobject>(
174                                        reinterpret_cast<Object*>(args[2])));
175       ScopedThreadStateChange tsc(self, kNative);
176       fn(soa.Env(), klass.get(), arg0.get(), args[1], arg2.get(), args[3], args[4]);
177     } else {
178       LOG(FATAL) << "Do something with static native method: " << PrettyMethod(method)
179           << " shorty: " << shorty;
180     }
181   } else {
182     if (shorty == "L") {
183       typedef jobject (fntype)(JNIEnv*, jobject);
184       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
185       ScopedLocalRef<jobject> rcvr(soa.Env(),
186                                    soa.AddLocalReference<jobject>(receiver));
187       jobject jresult;
188       {
189         ScopedThreadStateChange tsc(self, kNative);
190         jresult = fn(soa.Env(), rcvr.get());
191       }
192       result->SetL(soa.Decode<Object*>(jresult));
193     } else if (shorty == "V") {
194       typedef void (fntype)(JNIEnv*, jobject);
195       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
196       ScopedLocalRef<jobject> rcvr(soa.Env(),
197                                    soa.AddLocalReference<jobject>(receiver));
198       ScopedThreadStateChange tsc(self, kNative);
199       fn(soa.Env(), rcvr.get());
200     } else if (shorty == "LL") {
201       typedef jobject (fntype)(JNIEnv*, jobject, jobject);
202       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
203       ScopedLocalRef<jobject> rcvr(soa.Env(),
204                                    soa.AddLocalReference<jobject>(receiver));
205       ScopedLocalRef<jobject> arg0(soa.Env(),
206                                    soa.AddLocalReference<jobject>(
207                                        reinterpret_cast<Object*>(args[0])));
208       jobject jresult;
209       {
210         ScopedThreadStateChange tsc(self, kNative);
211         jresult = fn(soa.Env(), rcvr.get(), arg0.get());
212       }
213       result->SetL(soa.Decode<Object*>(jresult));
214       ScopedThreadStateChange tsc(self, kNative);
215     } else if (shorty == "III") {
216       typedef jint (fntype)(JNIEnv*, jobject, jint, jint);
217       fntype* const fn = reinterpret_cast<fntype*>(method->GetEntryPointFromJni());
218       ScopedLocalRef<jobject> rcvr(soa.Env(),
219                                    soa.AddLocalReference<jobject>(receiver));
220       ScopedThreadStateChange tsc(self, kNative);
221       result->SetI(fn(soa.Env(), rcvr.get(), args[0], args[1]));
222     } else {
223       LOG(FATAL) << "Do something with native method: " << PrettyMethod(method)
224           << " shorty: " << shorty;
225     }
226   }
227 }
228 
229 enum InterpreterImplKind {
230   kSwitchImplKind,        // Switch-based interpreter implementation.
231   kComputedGotoImplKind,  // Computed-goto-based interpreter implementation.
232   kMterpImplKind          // Assembly interpreter
233 };
operator <<(std::ostream & os,const InterpreterImplKind & rhs)234 static std::ostream& operator<<(std::ostream& os, const InterpreterImplKind& rhs) {
235   os << ((rhs == kSwitchImplKind)
236               ? "Switch-based interpreter"
237               : (rhs == kComputedGotoImplKind)
238                   ? "Computed-goto-based interpreter"
239                   : "Asm interpreter");
240   return os;
241 }
242 
243 static constexpr InterpreterImplKind kInterpreterImplKind = kMterpImplKind;
244 
245 #if defined(__clang__)
246 // Clang 3.4 fails to build the goto interpreter implementation.
247 template<bool do_access_check, bool transaction_active>
ExecuteGotoImpl(Thread *,const DexFile::CodeItem *,ShadowFrame &,JValue)248 JValue ExecuteGotoImpl(Thread*, const DexFile::CodeItem*, ShadowFrame&, JValue) {
249   LOG(FATAL) << "UNREACHABLE";
250   UNREACHABLE();
251 }
252 // Explicit definitions of ExecuteGotoImpl.
253 template<> SHARED_REQUIRES(Locks::mutator_lock_)
254 JValue ExecuteGotoImpl<true, false>(Thread* self, const DexFile::CodeItem* code_item,
255                                     ShadowFrame& shadow_frame, JValue result_register);
256 template<> SHARED_REQUIRES(Locks::mutator_lock_)
257 JValue ExecuteGotoImpl<false, false>(Thread* self, const DexFile::CodeItem* code_item,
258                                      ShadowFrame& shadow_frame, JValue result_register);
259 template<> SHARED_REQUIRES(Locks::mutator_lock_)
260 JValue ExecuteGotoImpl<true, true>(Thread* self,  const DexFile::CodeItem* code_item,
261                                    ShadowFrame& shadow_frame, JValue result_register);
262 template<> SHARED_REQUIRES(Locks::mutator_lock_)
263 JValue ExecuteGotoImpl<false, true>(Thread* self, const DexFile::CodeItem* code_item,
264                                     ShadowFrame& shadow_frame, JValue result_register);
265 #endif
266 
Execute(Thread * self,const DexFile::CodeItem * code_item,ShadowFrame & shadow_frame,JValue result_register,bool stay_in_interpreter=false)267 static inline JValue Execute(
268     Thread* self,
269     const DexFile::CodeItem* code_item,
270     ShadowFrame& shadow_frame,
271     JValue result_register,
272     bool stay_in_interpreter = false) SHARED_REQUIRES(Locks::mutator_lock_) {
273   DCHECK(!shadow_frame.GetMethod()->IsAbstract());
274   DCHECK(!shadow_frame.GetMethod()->IsNative());
275   if (LIKELY(shadow_frame.GetDexPC() == 0)) {  // Entering the method, but not via deoptimization.
276     if (kIsDebugBuild) {
277       self->AssertNoPendingException();
278     }
279     instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
280     ArtMethod *method = shadow_frame.GetMethod();
281 
282     if (UNLIKELY(instrumentation->HasMethodEntryListeners())) {
283       instrumentation->MethodEnterEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
284                                         method, 0);
285     }
286 
287     if (!stay_in_interpreter) {
288       jit::Jit* jit = Runtime::Current()->GetJit();
289       if (jit != nullptr) {
290         jit->MethodEntered(self, shadow_frame.GetMethod());
291         if (jit->CanInvokeCompiledCode(method)) {
292           JValue result;
293 
294           // Pop the shadow frame before calling into compiled code.
295           self->PopShadowFrame();
296           ArtInterpreterToCompiledCodeBridge(self, nullptr, code_item, &shadow_frame, &result);
297           // Push the shadow frame back as the caller will expect it.
298           self->PushShadowFrame(&shadow_frame);
299 
300           return result;
301         }
302       }
303     }
304   }
305 
306   shadow_frame.GetMethod()->GetDeclaringClass()->AssertInitializedOrInitializingInThread(self);
307 
308   // Lock counting is a special version of accessibility checks, and for simplicity and
309   // reduction of template parameters, we gate it behind access-checks mode.
310   ArtMethod* method = shadow_frame.GetMethod();
311   DCHECK(!method->SkipAccessChecks() || !method->MustCountLocks());
312 
313   bool transaction_active = Runtime::Current()->IsActiveTransaction();
314   if (LIKELY(method->SkipAccessChecks())) {
315     // Enter the "without access check" interpreter.
316     if (kInterpreterImplKind == kMterpImplKind) {
317       if (transaction_active) {
318         // No Mterp variant - just use the switch interpreter.
319         return ExecuteSwitchImpl<false, true>(self, code_item, shadow_frame, result_register,
320                                               false);
321       } else if (UNLIKELY(!Runtime::Current()->IsStarted())) {
322         return ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame, result_register,
323                                                false);
324       } else {
325         while (true) {
326           // Mterp does not support all instrumentation/debugging.
327           if (MterpShouldSwitchInterpreters()) {
328             return ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame, result_register,
329                                                    false);
330           }
331           bool returned = ExecuteMterpImpl(self, code_item, &shadow_frame, &result_register);
332           if (returned) {
333             return result_register;
334           } else {
335             // Mterp didn't like that instruction.  Single-step it with the reference interpreter.
336             result_register = ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame,
337                                                                result_register, true);
338             if (shadow_frame.GetDexPC() == DexFile::kDexNoIndex) {
339               // Single-stepped a return or an exception not handled locally.  Return to caller.
340               return result_register;
341             }
342           }
343         }
344       }
345     } else if (kInterpreterImplKind == kSwitchImplKind) {
346       if (transaction_active) {
347         return ExecuteSwitchImpl<false, true>(self, code_item, shadow_frame, result_register,
348                                               false);
349       } else {
350         return ExecuteSwitchImpl<false, false>(self, code_item, shadow_frame, result_register,
351                                                false);
352       }
353     } else {
354       DCHECK_EQ(kInterpreterImplKind, kComputedGotoImplKind);
355       if (transaction_active) {
356         return ExecuteGotoImpl<false, true>(self, code_item, shadow_frame, result_register);
357       } else {
358         return ExecuteGotoImpl<false, false>(self, code_item, shadow_frame, result_register);
359       }
360     }
361   } else {
362     // Enter the "with access check" interpreter.
363     if (kInterpreterImplKind == kMterpImplKind) {
364       // No access check variants for Mterp.  Just use the switch version.
365       if (transaction_active) {
366         return ExecuteSwitchImpl<true, true>(self, code_item, shadow_frame, result_register,
367                                              false);
368       } else {
369         return ExecuteSwitchImpl<true, false>(self, code_item, shadow_frame, result_register,
370                                               false);
371       }
372     } else if (kInterpreterImplKind == kSwitchImplKind) {
373       if (transaction_active) {
374         return ExecuteSwitchImpl<true, true>(self, code_item, shadow_frame, result_register,
375                                              false);
376       } else {
377         return ExecuteSwitchImpl<true, false>(self, code_item, shadow_frame, result_register,
378                                               false);
379       }
380     } else {
381       DCHECK_EQ(kInterpreterImplKind, kComputedGotoImplKind);
382       if (transaction_active) {
383         return ExecuteGotoImpl<true, true>(self, code_item, shadow_frame, result_register);
384       } else {
385         return ExecuteGotoImpl<true, false>(self, code_item, shadow_frame, result_register);
386       }
387     }
388   }
389 }
390 
EnterInterpreterFromInvoke(Thread * self,ArtMethod * method,Object * receiver,uint32_t * args,JValue * result,bool stay_in_interpreter)391 void EnterInterpreterFromInvoke(Thread* self, ArtMethod* method, Object* receiver,
392                                 uint32_t* args, JValue* result,
393                                 bool stay_in_interpreter) {
394   DCHECK_EQ(self, Thread::Current());
395   bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks();
396   if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) {
397     ThrowStackOverflowError(self);
398     return;
399   }
400 
401   const char* old_cause = self->StartAssertNoThreadSuspension("EnterInterpreterFromInvoke");
402   const DexFile::CodeItem* code_item = method->GetCodeItem();
403   uint16_t num_regs;
404   uint16_t num_ins;
405   if (code_item != nullptr) {
406     num_regs =  code_item->registers_size_;
407     num_ins = code_item->ins_size_;
408   } else if (!method->IsInvokable()) {
409     self->EndAssertNoThreadSuspension(old_cause);
410     method->ThrowInvocationTimeError();
411     return;
412   } else {
413     DCHECK(method->IsNative());
414     num_regs = num_ins = ArtMethod::NumArgRegisters(method->GetShorty());
415     if (!method->IsStatic()) {
416       num_regs++;
417       num_ins++;
418     }
419   }
420   // Set up shadow frame with matching number of reference slots to vregs.
421   ShadowFrame* last_shadow_frame = self->GetManagedStack()->GetTopShadowFrame();
422   ShadowFrameAllocaUniquePtr shadow_frame_unique_ptr =
423       CREATE_SHADOW_FRAME(num_regs, last_shadow_frame, method, /* dex pc */ 0);
424   ShadowFrame* shadow_frame = shadow_frame_unique_ptr.get();
425   self->PushShadowFrame(shadow_frame);
426 
427   size_t cur_reg = num_regs - num_ins;
428   if (!method->IsStatic()) {
429     CHECK(receiver != nullptr);
430     shadow_frame->SetVRegReference(cur_reg, receiver);
431     ++cur_reg;
432   }
433   uint32_t shorty_len = 0;
434   const char* shorty = method->GetShorty(&shorty_len);
435   for (size_t shorty_pos = 0, arg_pos = 0; cur_reg < num_regs; ++shorty_pos, ++arg_pos, cur_reg++) {
436     DCHECK_LT(shorty_pos + 1, shorty_len);
437     switch (shorty[shorty_pos + 1]) {
438       case 'L': {
439         Object* o = reinterpret_cast<StackReference<Object>*>(&args[arg_pos])->AsMirrorPtr();
440         shadow_frame->SetVRegReference(cur_reg, o);
441         break;
442       }
443       case 'J': case 'D': {
444         uint64_t wide_value = (static_cast<uint64_t>(args[arg_pos + 1]) << 32) | args[arg_pos];
445         shadow_frame->SetVRegLong(cur_reg, wide_value);
446         cur_reg++;
447         arg_pos++;
448         break;
449       }
450       default:
451         shadow_frame->SetVReg(cur_reg, args[arg_pos]);
452         break;
453     }
454   }
455   self->EndAssertNoThreadSuspension(old_cause);
456   // Do this after populating the shadow frame in case EnsureInitialized causes a GC.
457   if (method->IsStatic() && UNLIKELY(!method->GetDeclaringClass()->IsInitialized())) {
458     ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
459     StackHandleScope<1> hs(self);
460     Handle<mirror::Class> h_class(hs.NewHandle(method->GetDeclaringClass()));
461     if (UNLIKELY(!class_linker->EnsureInitialized(self, h_class, true, true))) {
462       CHECK(self->IsExceptionPending());
463       self->PopShadowFrame();
464       return;
465     }
466   }
467   if (LIKELY(!method->IsNative())) {
468     JValue r = Execute(self, code_item, *shadow_frame, JValue(), stay_in_interpreter);
469     if (result != nullptr) {
470       *result = r;
471     }
472   } else {
473     // We don't expect to be asked to interpret native code (which is entered via a JNI compiler
474     // generated stub) except during testing and image writing.
475     // Update args to be the args in the shadow frame since the input ones could hold stale
476     // references pointers due to moving GC.
477     args = shadow_frame->GetVRegArgs(method->IsStatic() ? 0 : 1);
478     if (!Runtime::Current()->IsStarted()) {
479       UnstartedRuntime::Jni(self, method, receiver, args, result);
480     } else {
481       InterpreterJni(self, method, shorty, receiver, args, result);
482     }
483   }
484   self->PopShadowFrame();
485 }
486 
IsStringInit(const Instruction * instr,ArtMethod * caller)487 static bool IsStringInit(const Instruction* instr, ArtMethod* caller)
488     SHARED_REQUIRES(Locks::mutator_lock_) {
489   if (instr->Opcode() == Instruction::INVOKE_DIRECT ||
490       instr->Opcode() == Instruction::INVOKE_DIRECT_RANGE) {
491     // Instead of calling ResolveMethod() which has suspend point and can trigger
492     // GC, look up the callee method symbolically.
493     uint16_t callee_method_idx = (instr->Opcode() == Instruction::INVOKE_DIRECT_RANGE) ?
494         instr->VRegB_3rc() : instr->VRegB_35c();
495     const DexFile* dex_file = caller->GetDexFile();
496     const DexFile::MethodId& method_id = dex_file->GetMethodId(callee_method_idx);
497     const char* class_name = dex_file->StringByTypeIdx(method_id.class_idx_);
498     const char* method_name = dex_file->GetMethodName(method_id);
499     // Compare method's class name and method name against string init.
500     // It's ok since it's not allowed to create your own java/lang/String.
501     // TODO: verify that assumption.
502     if ((strcmp(class_name, "Ljava/lang/String;") == 0) &&
503         (strcmp(method_name, "<init>") == 0)) {
504       return true;
505     }
506   }
507   return false;
508 }
509 
GetReceiverRegisterForStringInit(const Instruction * instr)510 static int16_t GetReceiverRegisterForStringInit(const Instruction* instr) {
511   DCHECK(instr->Opcode() == Instruction::INVOKE_DIRECT_RANGE ||
512          instr->Opcode() == Instruction::INVOKE_DIRECT);
513   return (instr->Opcode() == Instruction::INVOKE_DIRECT_RANGE) ?
514       instr->VRegC_3rc() : instr->VRegC_35c();
515 }
516 
EnterInterpreterFromDeoptimize(Thread * self,ShadowFrame * shadow_frame,bool from_code,JValue * ret_val)517 void EnterInterpreterFromDeoptimize(Thread* self,
518                                     ShadowFrame* shadow_frame,
519                                     bool from_code,
520                                     JValue* ret_val)
521     SHARED_REQUIRES(Locks::mutator_lock_) {
522   JValue value;
523   // Set value to last known result in case the shadow frame chain is empty.
524   value.SetJ(ret_val->GetJ());
525   // Are we executing the first shadow frame?
526   bool first = true;
527   while (shadow_frame != nullptr) {
528     // We do not want to recover lock state for lock counting when deoptimizing. Currently,
529     // the compiler should not have compiled a method that failed structured-locking checks.
530     DCHECK(!shadow_frame->GetMethod()->MustCountLocks());
531 
532     self->SetTopOfShadowStack(shadow_frame);
533     const DexFile::CodeItem* code_item = shadow_frame->GetMethod()->GetCodeItem();
534     const uint32_t dex_pc = shadow_frame->GetDexPC();
535     uint32_t new_dex_pc = dex_pc;
536     if (UNLIKELY(self->IsExceptionPending())) {
537       // If we deoptimize from the QuickExceptionHandler, we already reported the exception to
538       // the instrumentation. To prevent from reporting it a second time, we simply pass a
539       // null Instrumentation*.
540       const instrumentation::Instrumentation* const instrumentation =
541           first ? nullptr : Runtime::Current()->GetInstrumentation();
542       uint32_t found_dex_pc = FindNextInstructionFollowingException(self, *shadow_frame, dex_pc,
543                                                                     instrumentation);
544       new_dex_pc = found_dex_pc;  // the dex pc of a matching catch handler
545                                   // or DexFile::kDexNoIndex if there is none.
546     } else if (!from_code) {
547       // For the debugger and full deoptimization stack, we must go past the invoke
548       // instruction, as it already executed.
549       // TODO: should be tested more once b/17586779 is fixed.
550       const Instruction* instr = Instruction::At(&code_item->insns_[dex_pc]);
551       if (instr->IsInvoke()) {
552         if (IsStringInit(instr, shadow_frame->GetMethod())) {
553           uint16_t this_obj_vreg = GetReceiverRegisterForStringInit(instr);
554           // Move the StringFactory.newStringFromChars() result into the register representing
555           // "this object" when invoking the string constructor in the original dex instruction.
556           // Also move the result into all aliases.
557           DCHECK(value.GetL()->IsString());
558           SetStringInitValueToAllAliases(shadow_frame, this_obj_vreg, value);
559           // Calling string constructor in the original dex code doesn't generate a result value.
560           value.SetJ(0);
561         }
562         new_dex_pc = dex_pc + instr->SizeInCodeUnits();
563       } else if (instr->Opcode() == Instruction::NEW_INSTANCE) {
564         // It's possible to deoptimize at a NEW_INSTANCE dex instruciton that's for a
565         // java string, which is turned into a call into StringFactory.newEmptyString();
566         // Move the StringFactory.newEmptyString() result into the destination register.
567         DCHECK(value.GetL()->IsString());
568         shadow_frame->SetVRegReference(instr->VRegA_21c(), value.GetL());
569         // new-instance doesn't generate a result value.
570         value.SetJ(0);
571         // Skip the dex instruction since we essentially come back from an invocation.
572         new_dex_pc = dex_pc + instr->SizeInCodeUnits();
573         if (kIsDebugBuild) {
574           ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
575           // This is a suspend point. But it's ok since value has been set into shadow_frame.
576           mirror::Class* klass = class_linker->ResolveType(
577               instr->VRegB_21c(), shadow_frame->GetMethod());
578           DCHECK(klass->IsStringClass());
579         }
580       } else {
581         CHECK(false) << "Unexpected instruction opcode " << instr->Opcode()
582                      << " at dex_pc " << dex_pc
583                      << " of method: " << PrettyMethod(shadow_frame->GetMethod(), false);
584       }
585     } else {
586       // Nothing to do, the dex_pc is the one at which the code requested
587       // the deoptimization.
588     }
589     if (new_dex_pc != DexFile::kDexNoIndex) {
590       shadow_frame->SetDexPC(new_dex_pc);
591       value = Execute(self, code_item, *shadow_frame, value);
592     }
593     ShadowFrame* old_frame = shadow_frame;
594     shadow_frame = shadow_frame->GetLink();
595     ShadowFrame::DeleteDeoptimizedFrame(old_frame);
596     // Following deoptimizations of shadow frames must pass the invoke instruction.
597     from_code = false;
598     first = false;
599   }
600   ret_val->SetJ(value.GetJ());
601 }
602 
EnterInterpreterFromEntryPoint(Thread * self,const DexFile::CodeItem * code_item,ShadowFrame * shadow_frame)603 JValue EnterInterpreterFromEntryPoint(Thread* self, const DexFile::CodeItem* code_item,
604                                       ShadowFrame* shadow_frame) {
605   DCHECK_EQ(self, Thread::Current());
606   bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks();
607   if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) {
608     ThrowStackOverflowError(self);
609     return JValue();
610   }
611 
612   jit::Jit* jit = Runtime::Current()->GetJit();
613   if (jit != nullptr) {
614     jit->NotifyCompiledCodeToInterpreterTransition(self, shadow_frame->GetMethod());
615   }
616   return Execute(self, code_item, *shadow_frame, JValue());
617 }
618 
ArtInterpreterToInterpreterBridge(Thread * self,const DexFile::CodeItem * code_item,ShadowFrame * shadow_frame,JValue * result)619 void ArtInterpreterToInterpreterBridge(Thread* self, const DexFile::CodeItem* code_item,
620                                        ShadowFrame* shadow_frame, JValue* result) {
621   bool implicit_check = !Runtime::Current()->ExplicitStackOverflowChecks();
622   if (UNLIKELY(__builtin_frame_address(0) < self->GetStackEndForInterpreter(implicit_check))) {
623     ThrowStackOverflowError(self);
624     return;
625   }
626 
627   self->PushShadowFrame(shadow_frame);
628   ArtMethod* method = shadow_frame->GetMethod();
629   // Ensure static methods are initialized.
630   const bool is_static = method->IsStatic();
631   if (is_static) {
632     mirror::Class* declaring_class = method->GetDeclaringClass();
633     if (UNLIKELY(!declaring_class->IsInitialized())) {
634       StackHandleScope<1> hs(self);
635       HandleWrapper<Class> h_declaring_class(hs.NewHandleWrapper(&declaring_class));
636       if (UNLIKELY(!Runtime::Current()->GetClassLinker()->EnsureInitialized(
637           self, h_declaring_class, true, true))) {
638         DCHECK(self->IsExceptionPending());
639         self->PopShadowFrame();
640         return;
641       }
642       CHECK(h_declaring_class->IsInitializing());
643     }
644   }
645 
646   if (LIKELY(!shadow_frame->GetMethod()->IsNative())) {
647     result->SetJ(Execute(self, code_item, *shadow_frame, JValue()).GetJ());
648   } else {
649     // We don't expect to be asked to interpret native code (which is entered via a JNI compiler
650     // generated stub) except during testing and image writing.
651     CHECK(!Runtime::Current()->IsStarted());
652     Object* receiver = is_static ? nullptr : shadow_frame->GetVRegReference(0);
653     uint32_t* args = shadow_frame->GetVRegArgs(is_static ? 0 : 1);
654     UnstartedRuntime::Jni(self, shadow_frame->GetMethod(), receiver, args, result);
655   }
656 
657   self->PopShadowFrame();
658 }
659 
CheckInterpreterAsmConstants()660 void CheckInterpreterAsmConstants() {
661   CheckMterpAsmConstants();
662 }
663 
InitInterpreterTls(Thread * self)664 void InitInterpreterTls(Thread* self) {
665   InitMterpTls(self);
666 }
667 
668 }  // namespace interpreter
669 }  // namespace art
670